fluke/devops-service/db/mongo/connectors/project.rb

module Connectors
  class Project < Base
    include Helpers::InsertCommand,
      Helpers::ShowCommand,
#      Helpers::ListCommand,
      Helpers::DeleteCommand
#      Helpers::UpdateCommand


    def initialize(db)
      super(db)
    end

    def collection_name
      'projects'
    end

    def is_project_exists?(project)
      self.project(project.id)
      return true
    rescue RecordNotFound => e
      return false
    end

    def projects_all
      list
    end

    def projects ids=nil, type=nil, fields=[], archived=false
      query = {}
      query['_id'] = {'$in' => ids} if ids
      query['type'] = 'multi' if type == :multi
      if archived
        query["archived"] = true
      else
        query["archived"] = {"$exists" => false}
      end
      list(query, fields: fields)
    end

    # names - array of project names
    def project_names_with_envs(names=nil)
      # db.projects.aggregate({$unwind:"$deploy_envs"}, {$project:{"deploy_envs.identifier":1}}, {$group:{_id:"$_id", envs: {$addToSet: "$deploy_envs.identifier"}}})
      q = []
      unless names.nil?
        q.push({
          '$match' => {
            '_id' => {
              '$in' => names
            }
          }
        })
      end
      q.push({
        '$unwind' => '$deploy_envs'
      })
      q.push({
        '$project' => {
          'deploy_envs.identifier' => 1
        }
      })
      q.push({
        '$group' => {
          '_id' => '$_id',
          'envs' => {
            '$addToSet' => '$deploy_envs.identifier'
          }
        }
      })
      res = @collection.aggregate(q)
      r = {}
      res.each do |ar|
        r[ar['_id']] = ar['envs']
      end
      return r
    end

    def projects_by_image(image)
      list('deploy_envs.image' => image)
    end

    def projects_by_user(user)
      list('deploy_envs.users' => user)
    end

    def archive_project id
      @collection.update({"_id" => id}, {"$set" => {"archived" => true}})
    end

    def unarchive_project id
      @collection.update({"_id" => id}, {"$unset" => {"archived" => ""}})
    end

    def check_project_auth(project_id, env, user_id)
      project = show(project_id)
      raise InvalidPrivileges.new("User '#{user_id}' unauthorized to work with project '#{project_id}'") unless project.check_authorization(user_id, env)
      project
    end

    def projects_and_deploy_envs_by_field field, value
      q = {}
      q[field] = value
      # {find all projects with deploy_envs with field=value}, {return deploy_envs with field=value}
      list( {'deploy_envs' => {'$elemMatch' => q}}, {:fields => {'deploy_envs' => {'$elemMatch' => q}}} )
    end

    def set_project_deploy_env_field(project_id, env, field_value_hash)
      set = {}
      field_value_hash.each do |field, value|
        set["deploy_envs.$.#{field}"] = value
      end
      @collection.update({"_id" => project_id, "deploy_envs.identifier" => env}, {"$set" => set})
    end

    def set_project_env_run_list(project_id, env, run_list)
      Helpers::RunList.new(run_list).validate!
      set_project_deploy_env_field(project_id, env, {"run_list" => run_list})
    end

    def set_project_run_list(project_id, env, run_list)
      Helpers::RunList.new(run_list).validate!
      @collection.update({"_id" => project_id}, {"$set" => {run_list: run_list}})
    end

    def add_deploy_env_to_project id, env
      @collection.update({"_id" => id}, {'$push' => {deploy_envs: env.to_hash} })
    end

    def remove_deploy_env_from_project id, env
      @collection.update({"_id" => id}, {'$pull' => {deploy_envs: {identifier: env}} })
    end

    def project_update_field id, field, value
      obj = {}
      obj[field] = value
      @collection.update({"_id" => id}, {'$set' => obj })
    end

    def project_update id, params
      #raise InvalidRecord.new("You can not change project name for '#{id}'.") if params["name"]
      keys = %w(run_list description)
      params.delete_if{|k,v| !keys.include?(k)}
      @collection.update({"_id" => id}, {'$set' => params })
    end

    private

    def list(query={}, query_options={})
      @collection.find(query, query_options).to_a.map {|bson| model_from_bson(bson)}
    end

    def model_from_bson(bson)
      Devops::Model::Project.build_from_bson(bson)
    end
  end

end