orbit4-5/app/controllers/admin/import_controller.rb

# encoding: utf-8
require "net/http"
require "uri"
require 'json'
require 'yaml'

class Admin::ImportController < OrbitAdminController
  layout "structure"
  before_filter :get_user
  
  @@import_stats = {}
  @@thread = nil
  def check_url
    params['url'] = params['url']+"/" if params['url'].last!="/"
    uri = URI.parse(params['url'])

    begin
      @host = uri.host
      http = Net::HTTP.new(uri.host, uri.port)
      request = Net::HTTP::Get.new(uri.request_uri)
      response = http.request(request)
      data = response.body
      data = JSON.parse(data)
      msg = data['status']
    rescue
      msg = "Failed to connect to RSS2 (#{uri.to_s})"
    end

    render :json=>{"status"=>msg}
  end

  def module_categories
    module_app = ModuleApp.find_by(:key=>params['module'])
    uri = URI.parse(params['url'])
    http = Net::HTTP.new(uri.host, uri.port)
    request = Net::HTTP::Get.new(uri.request_uri)
    response = http.request(request)
    data = response.body
    categories = JSON.parse(data)

    I18n.locale = :zh_tw
    categories.each do |id, category|
      old_cate = module_app.categories.where(:title => category["zh_tw"]).first
      if old_cate.nil?
        cat = Category.new
        cat.title_translations = category
        cat.save!
        module_app.categories << cat
        categories[id]['id'] = cat.id.to_s
      else
        categories[id]['id'] = old_cate.id.to_s
      end
    end
    render :json=>categories
  end

  def module_data_list
    uri = URI.parse(params['url'])
    http = Net::HTTP.new(uri.host, uri.port)
    request = Net::HTTP::Get.new(uri.request_uri)
    response = http.request(request)
    data = response.body
    data = JSON.parse(data)
    render :json=>data
  end

  def module_data
    uri = URI.parse(params['url'])
    @host = uri.host
    http = Net::HTTP.new(uri.host, uri.port)
    request = Net::HTTP::Get.new(uri.request_uri)
    response = http.request(request)
    data = response.body
    data = JSON.parse(data)
    case params['module']
    when 'archive'
      import_archive(data)
    when 'announcement'
      import_announcement(data)
    end
    render :json=>['status'=>'ok']
  end

  def import_archive(file)
    archive_file = ArchiveFile.where(:rss2_sn=>file['Sn']).first
    if archive_file.nil?
      archive_file = ArchiveFile.new
      archive_file.rss2_sn = file['Sn']
    else
      archive_file.archive_file_multiples.destroy_all
    end

    archive_file.title_translations = file['title']
    archive_file.sort_number = file['sort_number']
    archive_file.category = Category.find(params["category"])
    archive_file.create_user_id = current_user.id
    archive_file.update_user_id = current_user.id
    archive_file.save

    if(file['url'])
      archive = ArchiveFileMultiple.new({
        :file_title_translations=>file['title'], 
        :choose_lang => @site_valid_locales,
        :remote_file_url => file['url'],
        :sort_number=>file['sort_number']
        })
      archive.save
      archive_file.archive_file_multiples << archive
    end

    if(file['url2'])
      archive = ArchiveFileMultiple.new({
        :file_title_translations=>file['title'], 
        :choose_lang => @site_valid_locales,
        :remote_file_url => file['url2'],
        :sort_number=>file['sort_number']
        })
      archive.save
      archive_file.archive_file_multiples << archive
    end
  end

  def import_announcement(news)
    bulletin = Bulletin.where(:rss2_sn=>news['Sn']).first
    if bulletin.nil?
      bulletin = Bulletin.new
      bulletin.rss2_sn = news['Sn']
    else
      bulletin.bulletin_links.destroy_all
      bulletin.bulletin_files.destroy_all
    end
    bulletin.update_user = current_user
    bulletin.title_translations = news['Title']
    bulletin.subtitle_translations = news['Summary']

    @site_valid_locales.each do |locale|
      locale = locale.to_s
      if news['Content'][locale]=="" and news['Summary'][locale]!=""
        news['Content'][locale] = news['Summary'][locale]
        news['Summary'][locale] = " "
      end

      temp = news['Content'][locale]

      urls = Nokogiri::HTML(temp).css("img").map do |link|

      if URI.parse(link.attr("src")).host == @host
        link.attr("src")
      end
      end
        urls.each do |url|
          next if url.nil?
          a = Asset.new
          a.remote_data_url = url
          a.title_translations = {"en" => a.data.filename, "zh_tw" => a.data.filename}
          if(a.save! rescue false)
            temp.gsub!(CGI::escapeHTML(url), "#")
          else
            @user.assets << a
            temp.gsub!(CGI::escapeHTML(url), a.data.to_s)
          end
        end
        news['Content'][locale] = temp
    end

    bulletin.text_translations = news['Content']
    bulletin.category = Category.find(params["category"])
    bulletin.view_count = news["Visits"].blank? ? 0 : news["Visits"]
    bulletin.postdate = news["PostDate"]
    bulletin.deadline = news['Deadline']
    bulletin.remote_image_url = news["Pic"] if news["Pic"]

    if news["URL"] && news['URL'] != ""
      bl = BulletinLink.new
      bl.url = news["URL"] 
      bl.title_translations = {"en" => "Link", "zh_tw" => "Link"}
      if (bl.save! rescue false)
        bulletin.bulletin_links << bl
      end
    end
    news['files'].each do |f|
      bf = BulletinFile.new
      if f['url'].split('title=').size == 1
        f['url'] = f['url']+"檔案下載" 
      end

      f['title'] = "檔案下載" if f['title'].blank?

      bf.remote_file_url = f['url']
      bf.title_translations = {"en" => f['title'], "zh_tw" => f['title']}
      bf.save!

      # Rename uploaded file
      file_ext = File.extname(f['url'].split('&')[0])
      file = File.new("tmp/uploads/#{bf.title}#{file_ext}","w+b")
      file.write(bf.file.read)
      bf.file.cache!(file)

      if (bf.save! rescue false)
        bulletin.bulletin_files << bf
      end

      File.delete(file)
    end
    
    bulletin.save!
  end

  def rss2_pages
    delete_import_file
    uri = URI.parse(params['url'])
    # @@thread = Thread.new do
      http = Net::HTTP.new(uri.host, uri.port)
      request = Net::HTTP::Get.new(uri.request_uri)
      response = http.request(request)
      data = response.body
      data = JSON.parse(data)
      pages = data["pages"]
      @@import_stats["total_pages"] = data["total_pages"].to_i
      @@import_stats["current_status"] = 0
      @@import_stats["success"] = true
      write_to_file
      pages.each do |page|
        @@import_stats["current_page"] = page["page_id"]
        @@import_stats["current_page_name"] = page["title"]["zh_tw"]
        write_to_file
        if Page.where(:rss2_id => page["page_id"]).count == 0
          page_id = page["page_id"]
          number = 0
          while page_present?page_id
            page_id = page_id + "_" + (number + 1).to_s
          end
          p = Page.new(:page_id => page_id, :parent_page_id => Page.root.id, :page_type => "page", :url => "/#{page_id}", :module => "page_content", :enabled_for => ["en", "zh_tw"], :menu_enabled_for => ["en", "zh_tw"], :enabled_for_sitemap => ["en","zh_tw"], :name_translations => {"en"=>page["title"]["en"], "zh_tw" => page["title"]["zh_tw"]},:rss2_id => page["page_id"])
          p.save
          en = smart_downloader(page["content"]["en"],data["site_url"])
          zh_tw = smart_downloader(page["content"]["zh_tw"],data["site_url"])
          page_context = PageContext.new(:content_translations => {"en" => en,"zh_tw" => zh_tw}, :version => 1, :update_user_id => current_user.id, :page_id => p.id)
          page_context.save
        else
          p = Page.find_by(:rss2_id => page["page_id"])
          page_id = p.page_id
        end
         @@import_stats["current_status"] = @@import_stats["current_status"] + 1
         write_to_file
        if !page["childpages"].blank?
          childpages = page["childpages"]
          childpages.each_with_index do |childpage,i|
            @@import_stats["current_page"] = childpage["page_id"]
            @@import_stats["current_page_name"] = page["title"]["zh_tw"]
            write_to_file
            if Page.where(:rss2_id => childpage["page_id"]).count == 0
              p_id = page_id + "_" + i.to_s
              case childpage["type"]
              when "page"
                cp = Page.new(:page_id => p_id, :parent_page_id => p.id, :page_type => "page", :url => "/#{p.page_id}/#{p_id}", :module => "page_content", "enabled_for" => ["en", "zh_tw"], :menu_enabled_for => ["en", "zh_tw"], :enabled_for_sitemap => ["en","zh_tw"], :name_translations => {"en"=>childpage["title"]["en"], "zh_tw" => childpage["title"]["zh_tw"]},:rss2_id => childpage["page_id"])
                cp.save
                en = smart_downloader(childpage["content"]["en"],data["site_url"])
                zh_tw = smart_downloader(childpage["content"]["zh_tw"],data["site_url"])
                 page_context = PageContext.new(:content_translations => {"en" => en,"zh_tw" => zh_tw}, :version => 1, :update_user_id => current_user.id, :page_id => cp.id)
                page_context.save
              when "exturl"
                cp = Page.new(:page_id => p_id, :parent_page_id => p.id, :page_type => "link", "url" => "/#{p.page_id}/#{p_id}", :enabled_for => ["en", "zh_tw"], :menu_enabled_for => ["en", "zh_tw"], :enabled_for_sitemap => ["en","zh_tw"], :name_translations => {"en"=>childpage["title"]["en"], "zh_tw" => childpage["title"]["zh_tw"]}, :external_url_translations => {"en" => childpage["url"], "zh_tw" => childpage["url"]},:rss2_id => childpage["page_id"])
                cp.save
              when "file"
                asset = Asset.new
                asset.remote_data_url = childpage["filename"]
                asset.title_translations = {"en" => childpage["file_title"], "zh_tw" =>childpage["file_title"]}
                asset.save!
                @user.assets << asset
                @user.save
                external_url = asset.data.url
                cp = Page.new(:page_id => p_id, :parent_page_id => p.id, :page_type => "link", "url" => "/#{p.page_id}/#{p_id}", :enabled_for => ["en", "zh_tw"], :menu_enabled_for => ["en", "zh_tw"], :enabled_for_sitemap => ["en","zh_tw"], :name_translations => {"en"=>childpage["title"]["en"], "zh_tw" => childpage["title"]["zh_tw"]}, :external_url_translations => {"en" => external_url, "zh_tw" => external_url},:rss2_id => childpage["page_id"])
                cp.save
              end
            end
             @@import_stats["current_status"] = @@import_stats["current_status"] + 1
             write_to_file
          end
        end
      end

    # end
    #  @@thread.join
    # @@thread.abort_on_exception = true
    render :json => {"success"=>true}.to_json
  end

  def get_import_status
    settings = get_settings_from_import_file
      render :json => settings.to_json
  end

  def rss2_members
    uri = URI.parse(params['url'])
    # @@thread = Thread.new do
      http = Net::HTTP.new(uri.host, uri.port)
      request = Net::HTTP::Get.new(uri.request_uri)
      response = http.request(request)
      data = response.body
      data = JSON.parse(data)
      @@import_stats["total_members"] = data["users"].count
      @@import_stats["current_status"] = 0
      @@import_stats["success"] = true
      write_to_file

      rss2_roles = data["attributes"]
      rss2_roles.each do |key,rss2_role|
        role = Role.find_by(key: rss2_role["name"]["en"]) rescue nil
        if role.nil?
          role = Role.new(key: rss2_role["name"]["en"], title_translations: {"en"=>rss2_role["name"]["en"],"zh_tw"=>rss2_role["name"]["zh-tw"]})
          role.save
        end
        next if rss2_role["classes"].blank?
        rss2_role["classes"].each do |class_name, rss2_class_list|
          if class_name.include? "class1"
            rss2_class_list['data'].each do  |rss2_option|
              status_key = rss2_option["name"]["en"].split(' ').join('_').underscore rescue nil
              status = RoleStatus.find_by(key: status_key, role_id: role.id) rescue nil
              if status.nil?
                status = role.role_statuses.build(key: status_key, title_translations: {"en"=>rss2_option["name"]["en"],"zh_tw"=>rss2_option["name"]["zh-tw"]})
              end
              status.save
            end
          else
            key = rss2_class_list["name"]["en"].gsub("/"," ").split(' ').join('_').underscore
            field = AttributeField.find_by(key: key, :role=>role) rescue nil
            if field.nil?
              field = AttributeField.new(key: key, title_translations: {"en"=>rss2_class_list["name"]["en"],"zh_tw"=>rss2_class_list["name"]["zh-tw"]})
              field["markup"] = "select"
              field.typeB["option_list"] = {}
              field.option_list = {}
              role.attribute_fields << field
              field.save
              field = AttributeField.find_by(key: key, :role=>role)
            end

            index = 0
            rss2_class_list['data'].each do  |rss2_option|
              option =  {"en"=>rss2_option["name"]["en"],"zh_tw"=>rss2_option["name"]["zh-tw"]}
              field.typeB["option_list"]["#{index}"] = option
              field.option_list["#{index}"] = option
              index = index+1
            end
            field.save
          end

        end
      end

      members = data["users"]
      data_to_send = []
      members.each do |member|
        @@import_stats["current_member"] = member["user_id"]
        @@import_stats["current_member_name"] = member["primary_email"]
        write_to_file

        new_member = MemberProfile.find_by(rss2_id: member["rss2_id"]) rescue nil
        if new_member.nil?
          new_member = MemberProfile.new(email: member["primary_email"], rss2_id: member["rss2_id"], sid: member["sid"], office_tel: member["phone_office"],)
          new_member.autobiography_translations = {"en"=>member["bio"]["en"],"zh_tw"=>member["bio"]["zh-tw"]}
          new_member.address_translations = {"en"=>member["address_office"]["en"],"zh_tw"=>member["address_office"]["zh-tw"]}
          new_member.first_name_translations = {"en"=>member["name"]["en"],"zh_tw"=>member["name"]["zh-tw"]}
          if member["gender"] == "M"
            new_member.sex = "male"
          elsif member["gender"] == "F"
            new_member.sex = "female"
          elsif member["gender"].nil?
            new_member.sex = "unknown"  
          end
          if member["profile_pic"].present?
            image_url = member["profile_pic"]
            new_member.remote_avatar_url = image_url
          end
          info = MemberInfo.find_by(key: "basic_info") rescue nil
          if info.nil?
            info = MemberInfo.new(key: "basic_info", title_translations: {"en"=>"Basic Info","zh_tw"=>"Basic Info"})
            info.save
          end


          if member.include?("website")
            member_profile_field = info.member_profile_fields.find_by(key: "website") rescue nil
            if member_profile_field.nil?
              field = info.member_profile_fields.build(key: "website",markup: "text_field",title_translations:{"en"=>"website","zh_tw"=>"網站"})
              field.save
              value = field.member_profile_field_values.build
              value.member_profile_id = new_member.id
              value.value = {"en"=>member["website"],"zh_tw"=>member["website"]}
              value.save
            elsif (member_profile_field.present? && member_profile_field.member_profile_field_values.blank?)
              value = member_profile_field.member_profile_field_values.build
              value.member_profile_id = new_member.id
              value.value = {"en"=>member["website"],"zh_tw"=>member["website"]}
              value.save
            end
          end

          if member.include?("address_home")
            member_profile_field = info.member_profile_fields.find_by(key: "address_home") rescue nil
            if member_profile_field.nil?
              field = info.member_profile_fields.build(key: "address_home",markup: "text_area",title_translations:{"en"=>"Home Address","zh_tw"=>"家庭住址"})
              field.save
              value = field.member_profile_field_values.build
              value.member_profile_id = new_member.id
              value.value = {"en"=>member["address_home"]["en"],"zh_tw"=>member["address_home"]["zh-tw"]}
              value.save
            elsif (member_profile_field.present? && member_profile_field.member_profile_field_values.blank?)
              value = member_profile_field.member_profile_field_values.build
              value.member_profile_id = new_member.id
              value.value = {"en"=>member["address_home"]["en"],"zh_tw"=>member["address_home"]["zh-tw"]}
              value.save
            end
          end

          if member.include?("fax")
            member_profile_field = info.member_profile_fields.find_by(key: "fax") rescue nil
            if member_profile_field.nil?
              field = info.member_profile_fields.build(key: "fax",markup: "text_field",title_translations:{"en"=>"Fax","zh_tw"=>"傳真"})
              field.save
              value = field.member_profile_field_values.build
              value.member_profile_id = new_member.id
              value.value = {"en"=>member["fax"],"zh_tw"=>member["fax"]}
              value.save
            elsif (member_profile_field.present? && member_profile_field.member_profile_field_values.blank?)
              value = member_profile_field.member_profile_field_values.build
              value.member_profile_id = new_member.id
              value.value = {"en"=>member["fax"],"zh_tw"=>member["fax"]}
              value.save
            end
          end

          if member.include?("experience")
            member_profile_field = info.member_profile_fields.find_by(key: "experience") rescue nil
            if member_profile_field.nil?
              field = info.member_profile_fields.build(key: "experience",markup: "text_area",title_translations:{"en"=>"Experience","zh_tw"=>"經驗"})
              field.save
              value = field.member_profile_field_values.build
              value.member_profile_id = new_member.id
              value.value = {"en"=>member["experience"]["en"],"zh_tw"=>member["experience"]["zh-tw"]}
              value.save
            elsif (member_profile_field.present? && member_profile_field.member_profile_field_values.blank?)
              value = member_profile_field.member_profile_field_values.build
              value.member_profile_id = new_member.id
              value.value = {"en"=>member["experience"]["en"],"zh_tw"=>member["experience"]["zh-tw"]}
              value.save
            end
          end

          if member.include?("mobile")
            member_profile_field = info.member_profile_fields.find_by(key: "mobile") rescue nil
            if member_profile_field.nil?
              field = info.member_profile_fields.build(key: "mobile",markup: "text_field",title_translations:{"en"=>"Mobile Phone Number","zh_tw"=>"手機號碼"})
              field.save
              value = field.member_profile_field_values.build
              value.member_profile_id = new_member.id
              value.value = {"en"=>member["mobile"],"zh_tw"=>member["mobile"]}
              value.save
            elsif (member_profile_field.present? && member_profile_field.member_profile_field_values.blank?)
              value = member_profile_field.member_profile_field_values.build
              value.member_profile_id = new_member.id
              value.value = {"en"=>member["mobile"],"zh_tw"=>member["mobile"]}
              value.save
            end
          end
          
        rss2_roles = member["attributes"]
          rss2_roles.each do |rss2_role|
            role = Role.find_by(key: rss2_role["name"]["en"]) rescue nil
            if role.nil?
              role = Role.new(key: rss2_role["name"]["en"], title_translations: {"en"=>rss2_role["name"]["en"],"zh_tw"=>rss2_role["name"]["zh-tw"]})
              role.save
            end
            role.member_profiles << new_member
            new_member.position = rss2_role["order"] if !rss2_role["order"].blank?

            rss2_role["fields"].each do |rss2_field|
              key = rss2_field["name"]["en"].gsub("/"," ").split(' ').join('_').underscore rescue nil
              rss2_field["type"] = rss2_field["type"].eql?("text") ? "text_field" : rss2_field["type"]
              if key != "category"
                # Role attribute
                field = AttributeField.find_by(key: key, :role=>role) rescue nil

                if field.nil?
                  field = AttributeField.new(key: key, title_translations: {"en"=>rss2_field["name"]["en"],"zh_tw"=>rss2_field["name"]["zh-tw"]})
                  field["markup"] = rss2_field["type"]
                  role.attribute_fields << field
                  field.save
                end

                case rss2_field["type"]
                when "text_field"
                  field_value = rss2_field["value"].is_a?(Hash) ? {"en"=>rss2_field["value"]["en"],"zh_tw"=>rss2_field["value"]["zh-tw"]} :  {"en"=>rss2_field["value"],"zh_tw"=>rss2_field["value"]} rescue nil
                  value = new_member.attribute_values.build(key: field.key, attribute_field_id: field.id, value: field_value)
                  value.save
                when "select"
                  if !rss2_field["value"]["en"].nil?
                    option =  {"en"=>rss2_field["value"]["en"],"zh_tw"=>rss2_field["value"]["zh-tw"]}

                    index = 0
                    if field.typeB["option_list"].nil? or !field.typeB["option_list"].has_value? option
                      field.typeB["option_list"] = {} if field.typeB["option_list"].nil?
                      index =  field.typeB["option_list"].count
                      field.typeB["option_list"]["#{index}"] = option
                      field.save
                    else
                      index = field.typeB["option_list"].key(option)
                    end
                    
                    value = new_member.attribute_values.build(key: key, attribute_field_id: field.id, value: index)
                    value.save
                  end
                end
              else
                # Role status
                status_key = rss2_field["value"]["en"].split(' ').join('_').underscore rescue nil
                status = RoleStatus.find_by(key: status_key, role_id: role.id) rescue nil
                if status.nil?
                  status = role.role_statuses.build(key: status_key, title_translations: {"en"=>rss2_field["value"]["en"],"zh_tw"=>rss2_field["value"]["zh-tw"]})
                end
                status.member_profiles << new_member
                status.save
              end
            end
          end

          new_member.save
          @@import_stats["current_status"] = @@import_stats["current_status"] + 1
          write_to_file
          if member["user_id"].present?
            user = User.new
            user.user_name = member["user_id"]
            if member["group_id"] == 40
              w = Workgroup.find_by(key: "admin") rescue nil
              user.workgroup = w
            end
            user.member_profile = new_member
            user.approved = true
            user.save(:validate => false)
          end
        end
        data_to_send << {"name" => new_member.name, "rss2_id" => new_member.rss2_id, "id" => new_member.id.to_s}
      end

    render :json => {"success" => true, "members" => data_to_send}.to_json
  end

  def rss2_galleries
    delete_import_file
    uri = URI.parse(params['url'])

    http = Net::HTTP.new(uri.host, uri.port)
    request = Net::HTTP::Get.new(uri.request_uri)
    response = http.request(request)
    data = response.body
    data = JSON.parse(data)
    albums = data["albums"]
    current_locale = I18n.locale
    I18n.locale = :en
    category = Category.where(:title => "RSS2 Gallery").first
    I18n.locale = current_locale
    if category.nil?
      module_app = ModuleApp.find_by_key("gallery")
      category = Category.new
      category.title_translations = {"en" => "RSS2 Gallery", "zh_tw" => "RSS2畫廊"}
      category.save
      module_app.categories << category
    end
    @data_to_send = []
    albums.each do |album|
      if Album.where(:rss2_id => album["albumid"]).count == 0
        newalbum = Album.new(:name_translations => {"en" => album["name"]["en"], "zh_tw" => album["name"]["zh_tw"]}, :description_translations => {"en" => album["description"]["en"], "zh_tw" => album["description"]["zh_tw"]},"rss2_id" => album["albumid"])
        newalbum.category_id = category.id
        newalbum.save  
      else
        newalbum = Album.where(:rss2_id => album["albumid"]).first
      end
      images = album["images"]        
      images.each do |image|
        @data_to_send << {"album_id" => newalbum.id.to_s,"album_name" => newalbum.name_translations["zh_tw"], "url" => image["image"], "description" => {"en" => image["description"]["en"], "zh_tw" => image["description"]["zh_tw"]},"photoid" => image["photoid"]}
       end
     end
    render :json => {"images" => @data_to_send}.to_json
  end

  def rss2_album_image
    album = Album.find(params[:album_id])
    if AlbumImage.where(:rss2_id => params["photoid"]).count == 0
        img = album.album_images.new
        img.description_translations = params["description"]
        img.rss2_id = params["photoid"]
        img.remote_file_url = params["url"]
        img.save
    end
    render :json => {"success" => true}.to_json
  end

  def rss2_links
    delete_import_file
    uri = URI.parse(params['url'])
    # @@thread = Thread.new do
      http = Net::HTTP.new(uri.host, uri.port)
      request = Net::HTTP::Get.new(uri.request_uri)
      response = http.request(request)
      data = response.body
      data = JSON.parse(data)
      @@import_stats["total_links"] = data["total_links"].to_i
      @@import_stats["current_import"] = "categories"
      @@import_stats["current_status"] = 0
      @@import_stats["success"] = true
      write_to_file
      categories = data["categories"]
      current_locale = I18n.locale
      I18n.locale = :zh_tw
      module_app =  ModuleApp.find_by_key("web_resource")
      categories.each do |category|
        cat = Category.where(:title => category[1]["zh_tw"], :module_app_id => module_app.id).first
        if cat.nil?
          cat = Category.new
          cat.title_translations = {"en" => category[1]["en"], "zh_tw" => category[1]["zh_tw"]}
          cat.save
          module_app.categories << cat
        end
      end
      @@import_stats["current_import"] = "links"
      write_to_file
      links = data["links"]
      links.each do |link|
        l = WebLink.where(:rss2_id => link["link_id"]).first
        if l.nil?
          @@import_stats["current_link_id"] = link["link_id"]
          @@import_stats["current_link_name"] = link["title"]["zh_tw"]
          write_to_file
          weblink = WebLink.new(:title_translations => {"en" => link["title"]["en"], "zh_tw" => link["title"]["zh_tw"]}, :context_translations => {:en => link["description"]["en"], :zh_tw => link["description"]["zh_tw"]}, :url_translations => {"en" => link["url"], "zh_tw" => link["url"]}, :rss2_id => link["link_id"])
          category = Category.where(:title => link["category_name"], :module_app_id => module_app).first
          weblink.category_id = category.id
          weblink.save
        end
        @@import_stats["current_status"] = @@import_stats["current_status"] + 1
        write_to_file
      end
      I18n.locale = current_locale
    # end
    #  @@thread.join
    #  @@thread.abort_on_exception = true
    render :json => {"success" => true}.to_json
  end

  def import_plugin
    id  = params["rss2_id"]
    url = params["url"]
    case params["plugin"]
    when "patents"
      import_patents(id,url)
    when "books"
      import_books(id,url)
    when "projects"
      import_projects(id,url)
    when "researches"
      import_research(id,url)
    when "honors"
      import_honors(id,url)
    when "diplomas"
      import_diplomas(id,url)
    when "experiences"
      import_experiences(id,url)
    when "journalpapers"
      import_journals(id,url)
    when "conferencespapers"
       import_conferences(id,url)
    end
  end

  def import_books(id,url)
      original_language = I18n.locale
      I18n.locale = "zh_tw"
      uri = URI.parse("#{url}?module=plugin&id=#{id}&plugin=book")
      http = Net::HTTP.new(uri.host, uri.port)
      request = Net::HTTP::Get.new(uri.request_uri)
      response = http.request(request)
      data = response.body
      data = JSON.parse(data)
      books = data["books"]
      member = MemberProfile.where(:rss2_id => id).first
      books.each do |book|
        author_types = book["author_type"]
        book_types = book["book_types"]
        old_book = Book.where(:rss2_id => book["rss2_id"]).first
        if old_book.nil?
          new_book = Book.new(
            :book_title_translations => {
              "en" => book["book_title"]["en"], 
              "zh_tw" => book["book_title"]["zh-tw"]}, 
            :extracted_chapters_translations => {
              "en" => book["extracted_chapters"]["en"], 
              "zh_tw" => book["extracted_chapters"]["zh-tw"]}, 
            :publisher_translations => {
              "en" => book["publishers"]["en"], 
              "zh_tw" => book["publishers"]["zh-tw"]}, 
            :editor_translations => {
              "en" => book["editor"]["en"], 
              "zh_tw" => book["editor"]["zh-tw"]}, 
            :year => book["year"], 
            :language => book["language"].sub("-","_"), 
            :pages => book["number_of_pages"], 
            :isbn => book["issn"], 
            :publication_date => book["publication_date"], 
            :url => book["reference_url"], 
            :note => book["note"], 
            :rss2_id  => book["rss2_id"])
          new_book.member_profile = member
          
          if !book["file"].blank?
            book_file = new_book.book_files.new
            book_file.remote_member_book_file_url = book["file"]["file"]
            book_file.title_translations = {"en" => book["file"]["name"], "zh_tw" =>  book["file"]["name"]}
            book_file.save
          end

          author_types.each do |author|
            bat = BookAuthorType.where(:title => author).first
            if bat.nil?
              bat = BookAuthorType.new(:title_translations => {"en" => author, "zh_tw" => author})
              bat.save
            end
            new_book.book_author_types << bat 
          end
          book_types.each do |type|
            bt = BookType.where(:title => type["zh-tw"]).first
            if bt.nil?
               bt = BookType.new(:title_translations => {"en" => type["en"], "zh_tw" => type["zh-tw"]})
               bt.save
            end
            new_book.book_type = bt
          end
         new_book.save
        end
      end
      I18n.locale = original_language
      render :json => {"succes" => true}.to_json
  end

   def import_projects(id,url)
      original_language = I18n.locale
      I18n.locale = "zh_tw"
      uri = URI.parse("#{url}?module=plugin&id=#{id}&plugin=project")
      http = Net::HTTP.new(uri.host, uri.port)
      request = Net::HTTP::Get.new(uri.request_uri)
      response = http.request(request)
      data = response.body
      data = JSON.parse(data)
      projects = data["projects"]
      member = MemberProfile.where(:rss2_id => id).first
      projects.each do |project|
        old_project = Project.where(:rss2_id => project["rss2_id"]).first
        if old_project.nil?
          new_project = Project.new(
            :project_title_translations => {
              "en" => project["project_title"]["en"], 
              "zh_tw" => project["project_title"]["zh-tw"]},
            :job_title_translations => {
              "en" => project["job_title"]["en"],
              "zh_tw" => project["job_title"]["zh-tw"]}, 
            :participator_translations => {
              "en" => project["participant"]["en"],
              "zh_tw" => project["participant"]["zh-tw"]}, 
            :unit_translations => {
              "en" => project["unit"]["en"],
              "zh_tw" => project["unit"]["zh-tw"]},
            :year => project["year"], 
            :language => project["language"].sub("-","_"), 
            :period_start_date => (Date.strptime(project["start_date"].sub('-00','-01'), '%Y-%m') rescue nil), 
            :period_end_date => (Date.strptime(project["end_date"].sub('-00','-01'), '%Y-%m') rescue nil), 
            :url => project["reference_url"], 
            :note_translations => {
              "en" => project["note"]["en"],
              "zh_tw" => project["note"]["zh-tw"]}, 
            :rss2_id => project["rss2_id"])
          pc = ProjectType.where(:title => project["project_categories"]["zh-tw"]).first
          if pc.nil?
            pc = ProjectType.new(:title_translations => {"en" => project["project_categories"]["en"], "zh_tw" => project["project_categories"]["zh-tw"]})
            pc.save
          end
          
          if !project["file"].blank?
            project_file = new_project.project_files.new
            project_file.remote_file_url = project["file"]["file"]
            project_file.title_translations = {"en" => project["file"]["name"], "zh_tw" =>  project["file"]["name"]}
            project_file.save
          end

          new_project.project_type = pc
          new_project.member_profile = member
          new_project.save
        end
      end
      I18n.locale = original_language
      render :json => {"succes" => true}.to_json
    end

    def import_patents(id,url)
      original_language = I18n.locale
      I18n.locale = "zh_tw"
      uri = URI.parse("#{url}?module=plugin&id=#{id}&plugin=patent")
      http = Net::HTTP.new(uri.host, uri.port)
      request = Net::HTTP::Get.new(uri.request_uri)
      response = http.request(request)
      data = response.body
      data = JSON.parse(data)
      patents = data["patents"]
      member = MemberProfile.where(:rss2_id => id).first
      patents.each do |patent|
        old_patent = Patent.where(:rss2_id => patent["rss2_id"]).first
        if old_patent.nil?
          new_patent = Patent.new(
            :patent_title_translations => {
              "en" => patent["patent_title"]["en"], 
              "zh_tw" => patent["patent_title"]["zh-tw"]}, 
            :authors_translations  => {
              "en" => patent["patent_author"]["en"], 
              "zh_tw" => patent["patent_author"]["zh-tw"]},
            :patent_country_translations  => {
              "en" => patent["patent_country"]["en"], 
              "zh_tw" => patent["patent_country"]["zh-tw"]}, 
            :year => patent["year"], 
            :language => patent["language"].gsub('-','_'), 
            :patent_no => patent["patent_number"], 
            :publish_date => Date.strptime(patent["date_of_publication"], '%Y-%m'), 
            :rss2_id => patent["rss2_id"])
          patent_categories = patent["patent_categories"]
          patent_categories.each do |pc|
            pt = PatentType.where(:title => pc["zh-tw"]).first
            if pt.nil?
              pt = PatentType.new(:title_translations => {"en" => pc["en"], "zh_tw" => pc["zh-tw"]})
              pt.save
            end
            new_patent.patent_types << pt
          end
      
          new_patent.member_profile = member
          new_patent.save
        end
      end
      I18n.locale = original_language
      render :json => {"succes" => true}.to_json
    end

     def import_research(id,url)
      original_language = I18n.locale
      I18n.locale = "zh_tw"
      uri = URI.parse("#{url}?module=plugin&id=#{id}&plugin=research")
      http = Net::HTTP.new(uri.host, uri.port)
      request = Net::HTTP::Get.new(uri.request_uri)
      response = http.request(request)
      data = response.body
      data = JSON.parse(data)
      researches = data["researches"]
      member = MemberProfile.where(:rss2_id => id).first
      researches.each do |research|
        old_research = Research.where(:rss2_id => research["rss2_id"]).first
        if old_research.nil?
          new_research = Research.new(
            :research_title_translations => {
              "en" => research["title"]["en"],
              "zh_tw" => research["title"]["zh-tw"]},
            :language => research["language"].gsub('-','_'), 
            :publish_date => research["date_of_publication"], 
            :rss2_id => research["rss2_id"])
          
          if research["file"]
            research_file = new_research.research_files.new
            research_file.remote_file_url = research["file"]["file"]
            research_file.title_translations = {"en" => research["file"]["name"], "zh_tw" =>  research["file"]["name"]}
            research_file.save
          end

          new_research.member_profile = member
          new_research.save
        end
      end
      I18n.locale = original_language
      render :json => {"succes" => true}.to_json
    end

    def import_diplomas(id,url)
      original_language = I18n.locale
      I18n.locale = "zh_tw"
      uri = URI.parse("#{url}?module=plugin&id=#{id}&plugin=diploma")
      http = Net::HTTP.new(uri.host, uri.port)
      request = Net::HTTP::Get.new(uri.request_uri)
      response = http.request(request)
      data = response.body
      data = JSON.parse(data)
      diplomas = data["diplomas"]
      member = MemberProfile.where(:rss2_id => id).first
      diplomas.each do |diploma|
        old_diploma = Diploma.where(:rss2_id => diploma["rss2_id"]).first
        if old_diploma.nil?
          new_diploma = Diploma.new(
            :school_name_translations => {
              "en" => diploma["school_name"]["en"], 
              "zh_tw" => diploma["school_name"]["zh-tw"]},
            :country_translations => {
              "en" => diploma["country"]["en"], 
              "zh_tw" => diploma["country"]["zh-tw"]}, 
            :department_translations => {
              "en" => diploma["department"]["en"], 
              "zh_tw" => diploma["department"]["zh-tw"]}, 
            :degree_translations => {
              "en" => diploma["degree"]["en"], 
              "zh_tw" => diploma["degree"]["zh-tw"]}, 
            :language => diploma["language"].gsub('-','_'), 
            :start_date => Date.strptime(diploma["start_date"], '%Y-%m'), 
            :end_date => Date.strptime(diploma["end_date"], '%Y-%m'), 
            :rss2_id => diploma["rss2_id"])
          new_diploma.member_profile = member
          new_diploma.save
        end
      end
      I18n.locale = original_language
      render :json => {"succes" => true}.to_json
    end

    def import_experiences(id,url)
      original_language = I18n.locale
      I18n.locale = "zh_tw"
      uri = URI.parse("#{url}?module=plugin&id=#{id}&plugin=experience")
      http = Net::HTTP.new(uri.host, uri.port)
      request = Net::HTTP::Get.new(uri.request_uri)
      response = http.request(request)
      data = response.body
      data = JSON.parse(data)
      experiences = data["experiences"]
      member = MemberProfile.where(:rss2_id => id).first
      experiences.each do |experience|
        old_experience = Experience.where(:rss2_id => experience["rss2_id"]).first
        if old_experience.nil?
          new_experience = Experience.new(
            :organizationt_title_translations => {
              "en" => experience["organization_title"]["en"], 
              "zh_tw" => experience["organization_title"]["zh-tw"]}, 
            :department_translations => {
              "en" => experience["department"]["en"], 
              "zh_tw" => experience["department"]["zh-tw"]}, 
            :job_title_translations => {
              "en" => experience["job_title"]["en"], 
              "zh_tw" => experience["job_title"]["zh-tw"]}, 
            :language => experience["language"].gsub('-','_'), 
            :start_date => (Date.strptime(experience["start_date"].sub('-00','-01'), '%Y-%m') rescue nil), 
            :end_date => (Date.strptime(experience["end_date"].sub('-00','-01'), '%Y-%m') rescue nil), 
            :rss2_id => experience["rss2_id"])

          new_experience.member_profile = member
          new_experience.save
        end
      end
      I18n.locale = original_language
      render :json => {"succes" => true}.to_json
    end

     def import_honors(id,url)
      original_language = I18n.locale
      I18n.locale = "zh_tw"
      uri = URI.parse("#{url}?module=plugin&id=#{id}&plugin=honor")
      http = Net::HTTP.new(uri.host, uri.port)
      request = Net::HTTP::Get.new(uri.request_uri)
      response = http.request(request)
      data = response.body
      data = JSON.parse(data)
      honors = data["honors"]
      member = MemberProfile.where(:rss2_id => id).first
      honors.each do |honor|
        old_honor = Honor.where(:rss2_id => honor["rss2_id"]).first
        if old_honor.nil?
          new_honor = Honor.new(
            :year => (honor["year"].to_i<1900 ? (honor["year"].to_i+1911).to_s : honor["year"]), 
            :award_name_translations => {
              "en" => honor["award_name"]["en"], 
              "zh_tw" => honor["award_name"]["zh-tw"]}, 
            :awarding_unit_translations => {
              "en" => honor["award_unit"]["en"], 
              "zh_tw" => honor["award_unit"]["zh-tw"]}, 
            :language => honor["language"].gsub('-','_'), 
            :rss2_id => honor["rss2_id"])
          pc = HonorType.where(:title => honor["honor_categories"]["zh-tw"]).first
          if pc.nil?
            pc = HonorType.new(:title_translations => {"en" => honor["honor_categories"]["en"], "zh_tw" => honor["honor_categories"]["zh-tw"]})
            pc.save
          end
          new_honor.honor_type = pc
          new_honor.member_profile = member
          new_honor.save
        end
      end
      I18n.locale = original_language
      render :json => {"success" => true}.to_json
    end

  def import_journals(id,url)
    original_language = I18n.locale
    I18n.locale = "zh_tw"
    uri = URI.parse("#{url}?module=plugin&id=#{id}&plugin=journal")
    http = Net::HTTP.new(uri.host, uri.port)
    request = Net::HTTP::Get.new(uri.request_uri)
    response = http.request(request)
    data = response.body
    data = JSON.parse(data)
    journals = data["jorunal_papers"]
    member = MemberProfile.where(:rss2_id => id).first

    journals.each do |rss2_journal|
      data = {:rss2_id => rss2_journal["rss_id"],
              :year => rss2_journal["year"],
              :language => rss2_journal["language"].gsub('-','_'),
              :vol_no => rss2_journal["volume_number"],
              :issue_no => rss2_journal["issue_number"],
              :form_to_start => rss2_journal["from_to"][0],
              :form_to_end => rss2_journal["from_to"][1],
              :total_pages => rss2_journal["total_pages"],
              :isbn => rss2_journal["issn"],
              :publication_date => (Date.parse(rss2_journal["date_of_publication"].sub('-00','-01')) rescue nil),
              :url => rss2_journal["reference_url"],
              :note => rss2_journal["note"],

              :journal_title_translations => {
                "en" => rss2_journal["journal_title"]["en"], 
                "zh_tw" => rss2_journal["journal_title"]["zh-tw"]},

              :paper_title_translations => {
                "en" => rss2_journal["paper_title"]["en"], 
                "zh_tw" => rss2_journal["paper_title"]["zh-tw"]}
              }

      journal = JournalPaper.where(:rss2_id => rss2_journal["rss_id"]).first
      journal = JournalPaper.new() if journal.nil?

      journal.update_attributes(data)

      journal.journal_levels = []
      rss2_journal["level_type"].each do |level|
        paper_level = JournalLevel.where(:title=>level).first
        if paper_level.nil?
          paper_level = JournalLevel.new(:title_translations => {"en" => level, "zh_tw" => level})
          paper_level.save
        end
        journal.journal_levels<<paper_level
      end

      journal.journal_paper_author_types = []
      rss2_journal["author_type"].each do |type|
        author_type = JournalPaperAuthorType.where(:title=>type).first
        if author_type.nil?
          author_type = JournalPaperAuthorType.new(:title_translations => {"en" => type, "zh_tw" => type})
          author_type.save
        end
        journal.journal_paper_author_types<<author_type
      end

      journal.journal_paper_files.destroy_all

      if !rss2_journal["file"].blank?
        paper_file = journal.journal_paper_files.new
        paper_file.remote_journal_file_url = rss2_journal["file"]["file"]
        paper_file.title_translations = {"en" => rss2_journal["file"]["name"], "zh_tw" =>  rss2_journal["file"]["name"]}
        paper_file.save rescue nil
      end

      journal.member_profile = member
      journal.save
    end

    I18n.locale = original_language
    render :json => {"success" => true}.to_json
  end

  def import_conferences(id,url)
    original_language = I18n.locale
    I18n.locale = "zh_tw"
    uri = URI.parse("#{url}?module=plugin&id=#{id}&plugin=conference")
    http = Net::HTTP.new(uri.host, uri.port)
    request = Net::HTTP::Get.new(uri.request_uri)
    response = http.request(request)
    data = response.body
    data = JSON.parse(data)
    conferences = data["conference_papers"]
    member = MemberProfile.where(:rss2_id => id).first

    conferences.each do |rss2_conference|
      data = {:rss2_id => rss2_conference["rss_id"],
              :year => rss2_conference["year"],
              :language => rss2_conference["language"].gsub('-','_'),
              :isi_number => rss2_conference["isi_number"],
              :period_start_date => (Date.parse(rss2_conference["start_date"].sub('-00','-01')) rescue nil),
              :period_end_date => (Date.parse(rss2_conference["end_date"].sub('-00','-01')) rescue nil),
              :url => rss2_conference["reference_url"],
              :isbn => rss2_conference["issn"],
              :note => rss2_conference["note"],

              :conference_title_translations => {
                "en" => rss2_conference["conference_title"]["en"], 
                "zh_tw" => rss2_conference["conference_title"]["zh-tw"]},

              :paper_title_translations => {
                "en" => rss2_conference["paper_title"]["en"], 
                "zh_tw" => rss2_conference["paper_title"]["zh-tw"]},
              
              :location_translations => {
                "en" => rss2_conference["location"]["en"], 
                "zh_tw" => rss2_conference["location"]["zh-tw"]},

              :authors_translations => {
                "en" => rss2_conference["authors"], 
                "zh_tw" => rss2_conference["authors"]},

              :sponsor_translations => {
                "en" => rss2_conference["sponsor"]["en"], 
                "zh_tw" => rss2_conference["sponsor"]["zh-tw"]}

              }

      conference = WritingConference.where(:rss2_id => rss2_conference["rss_id"]).first
      conference = WritingConference.new() if conference.nil?

      conference.update_attributes(data)

      conference.conference_paper_types = []
      rss2_conference["paper_type"].each do |type|
        paper_type = ConferencePaperType.where(:title=>type).first
        if paper_type.nil?
          paper_type = ConferencePaperType.new(:title_translations => {"en" => type, "zh_tw" => type})
          paper_type.save
        end
        conference.conference_paper_types<<paper_type
      end

      conference.conference_paper_levels = []
      rss2_conference["paper_level"].each do |level|
        paper_level = ConferencePaperLevel.where(:title=>level).first
        if paper_level.nil?
          paper_level = ConferencePaperLevel.new(:title_translations => {"en" => level, "zh_tw" => level})
          paper_level.save
        end
        conference.conference_paper_levels<<paper_level
      end

      conference.conference_author_types = []
      rss2_conference["author_type"].each do |type|
        author_type = ConferenceAuthorType.where(:title=>type).first
        if author_type.nil?
          author_type = ConferenceAuthorType.new(:title_translations => {"en" => type, "zh_tw" => type})
          author_type.save
        end
        conference.conference_author_types<<author_type
      end

      conference.writing_conference_files.destroy_all
      if !rss2_conference["file"].blank?
        paper_file = conference.writing_conference_files.new
        paper_file.remote_file_url = rss2_conference["file"]["file"]
        paper_file.title_translations = {"en" => rss2_conference["file"]["name"], "zh_tw" =>  rss2_conference["file"]["name"]}
        paper_file.save rescue nil
      end

      conference.member_profile = member
      conference.save
    end

    I18n.locale = original_language
    render :json => {"succes" => true}.to_json
  end

  private 

  def page_present?(page)
    Page.where(:page_id => page).count > 0
  end

  def smart_downloader(data,url)
     @data = data
     excluded_extensions = ["php","/"]
     @links = URI.extract(@data)
     @links.each do |link|
      if link.include?url
        temp = link.gsub(url,"")
        extension = temp.split(".").last rescue nil
        if extension.nil? || excluded_extensions.include?(extension)
          @data = @data.sub(link,"#")
        else
          a = Asset.new
          a.remote_data_url = link
          a.title_translations = {"en" => a.data.filename, "zh_tw" => a.data.filename}
          if (a.save! rescue false)
            @user.assets << a
            @user.save
            @data = @data.sub(link, a.data.url)
          end
        end
      end
     end
     @data
  end

  def write_to_file
     File.open("#{Rails.root.to_s}/public/import_status.yml", "w") do |file|
        file.write @@import_stats.to_yaml
    end
  end

  def delete_import_file
    @@import_stats = {}
    f = File.join(Rails.root,"public","import_status")
    if File.exists?f
      File.delete(f)
    end
  end

  def get_settings_from_import_file
    YAML::load_file "#{Rails.root.to_s}/public/import_status.yml"
  end

  def get_user
    @user = User.find(current_user.id)
  end
end