trustieforge/app/controllers/sync_forges_controller.rb

class SyncForgesController < ApplicationController
  # before_filter :check_token
  # before_filter :check_ids

  def index
    Rails.logger.info("###############______params_____########{params}")

    model_name = params[:type].to_s.constantize
    targets = model_name.where(id: params[:ids])
    targets_params = []
    case params[:type].to_s
    when "Project"
      targets = targets.includes(:versions,:repository,:project_score, :owner, issues: [journals: :details], members: [:user, :member_roles])
      targets_params = get_projects(targets, params) if targets.present?
    when "Issue"
      targets = targets.includes(:author, journals: :details)
      targets_params = get_issue_issues(targets, nil) if targets.present?
    when "Journal"
      targets = targets.includes(:user, :details)
      targets_params = get_journal_issues(targets) if targets.present?
    when "Member"
      targets = targets.includes(:member_roles)
      targets_params = get_member_targets(targets,nil) if targets.present?
    else
      targets = targets.includes(:user)
      targets_params = get_common_targets(targets,nil) if targets.present?
    end

    Rails.logger.info("###############______targets_params_____########{targets_params}")
    respond_to do | format|
      format.json {
        render json: { targets_params: targets_params }
      }
    end

  end

  private 

  # def check_token
  #   unless params[:token] && params[:token] == "#{Redmine::Configuration['sync_token']}"
  #     respond_to do |format|
  #       format.json {
  #         render json: { message: "token错误" }
  #       }
  #     end
  #   end
  # end

  def get_projects(targets, params)
    new_project_id = params[:new_project_id]
    target_params = []
    project = targets.first
    project_json = project.as_json(:except=>[:user_id, :id, :created_on, :updated_on, :name, :is_public, :identifier]).values[0].delete_if {|k,v| v.blank?}
    issues = project.issues
    members = project.members.where("user_id != ?", project.user_id)
    versions = project.versions
    watchers = project.watchers
    praises = project.praise_tread
    user_login = project.owner.try(:login)
    issues_params = get_issue_issues(issues, new_project_id) if issues.present?
    member_params = get_member_targets(members, new_project_id) if members.present?
    versions_params = get_common_targets(versions, new_project_id) if versions.present?
    watcher_params = get_common_targets(watchers, new_project_id) if watchers.present?
    praise_treads = get_common_targets(praises, new_project_id) if praises.present?
    target_params.push({
      target_params: project_json,
      issues_params: issues_params || nil,
      member_params: member_params || nil,
      versions_params: versions_params || nil,
      watcher_params: watcher_params || nil,
      praise_treads: praise_treads || nil,
      user_login: user_login
    }.delete_if {|k,v| v.blank?})
    return target_params
  end

  def get_issue_issues(targets, new_project_id)
    target_params = []
    targets.find_each do |re|
      user_logins = User.select([:id, :login]).where(id: [re.author_id, re.assigned_to_id]).pluck(:login)
      author_login = user_logins[0]
      assign_login = user_logins[1]
      re_json = re.as_json(:except=>[:author_id, :id, :assigned_to_id, :lock_version]).values[0].delete_if {|k,v| v.blank?}
      re_json.merge!({
        issue_type: "Issue"
      })
      if new_project_id.present?
        re_json.merge!(project_id: new_project_id)
      end

      journal_details = re.journals 
      journal_details_params = get_journal_issues(journal_details) if journal_details.present?

      target_params.push({
        target_params: re_json,
        journals: journal_details_params || nil,
        user_login: author_login,
        assign_login: assign_login
      }.delete_if {|k,v| v.blank?})
    end
    return target_params
  end

  def get_journal_issues(targets)
    target_params = []
    targets.find_each do |re|
      re_json = re.as_json(:except=>[:user_id, :id]).values[0].delete_if {|k,v| v.blank?}
      re_detail_json = re.details.as_json(:except => [:id, :journal_id]).map{|k| k["journal_detail"].delete_if {|k,v| v.blank?}} if re.details.present?
      user_login = re.user.try(:login)
      new_re_json = {
        target_params: re_json,
        journal_details: re_detail_json || nil,
        user_login: user_login
      }
      target_params.push(new_re_json.delete_if {|k,v| v.blank?})
    end
    return target_params
  end

  def get_member_targets(targets,new_project_id)
    target_params = []
    targets.find_each do |re|
      re_json = re.as_json(:except=>[:user_id, :id]).values[0].delete_if {|k,v| v.blank?}
      if new_project_id.present?
        re_json.merge!(project_id: new_project_id)
      end
      user_login = re.user.try(:login)
      member_roles_json = re.member_roles.as_json(:except => [:id, :member_id]).map{|k| k["member_role"].delete_if {|k,v| v.blank?}} if re.member_roles.present?
      
      new_re_json = {
        target_params: re_json,
        member_roles: member_roles_json || nil,
        user_login: user_login
      }
      target_params.push(new_re_json.delete_if {|k,v| v.blank?})
    end
    return target_params
  end

  def get_common_targets(targets, new_project_id)
    target_params = []
    targets.find_each do |re|
      re_json = re.as_json(:except=>[:user_id]).values[0].delete_if {|k,v| v.blank?}
      if new_project_id.present?
        if re.try(:project_id).present?
          re_json.merge!(project_id: new_project_id)
        elsif re.try("watchable_id").present?
          re_json.merge!(watchable_id: new_project_id)
        elsif re.try("praise_tread_object_id").present?
          re_json.merge!(praise_tread_object_id: new_project_id)
        end
      end
      
      user_login = re.user.try(:login)
      new_re_json = {
        target_params: re_json,
        user_login: user_login
      }
      target_params.push(new_re_json.delete_if {|k,v| v.blank?})
    end
    return target_params
  end

  # def check_ids
  #   unless params[:ids].present?
  #     respond_to do |format|
  #       format.json {
  #         render json: { message: "缺少ID参数" }
  #       }
  #     end
  #   end
  # end

end