module MergingQueue::QueuedTask::ClassMethods

Public Instance Methods

accumulate_changes(search_result) click to toggle source
# File lib/merging-queue/queued_task.rb, line 46
def accumulate_changes(search_result)
  act_targets    = []
  act_target_ids = []
  act_objects    = []
  act_object_ids = []

  _actor = search_result.first.actor

  search_result.each do |result|
    result.update_attributes(:state => 'pending')

    act_object = result.act_object
    act_target = result.act_target

    if act_object != nil && !act_object_ids.include?(act_object.id)
      act_objects    << act_object
      act_object_ids << act_object.id

    end

    if act_target != nil && !act_target_ids.include?(act_target.id)
      act_targets    << act_target
      act_target_ids << act_target.id

    end

  end

  {:actor => _actor, :act_objects => act_objects, :act_object_ids => act_object_ids,
   :act_targets => act_targets, :act_target_ids => act_target_ids}
end
poll_for_changes() { |verb, accumulate_changes(changes_for_actor)| ... } click to toggle source
# File lib/merging-queue/queued_task.rb, line 18
def poll_for_changes()
  #if block_given?

  ::QueuedTask.where('state = ? AND publish_on <= ?', 'initial', Time.now).distinct(:actor_id).each do |actor_id|

    ::QueuedTask.where('state = ? AND actor_id = ? AND publish_on <= ?', 'initial', actor_id, Time.now).select(:verb).uniq.each do |verb|

      changes_for_actor =  ::QueuedTask.where(:actor_id => actor_id, :state => 'initial', :verb => verb['verb'].to_s)

      begin
        yield  verb, accumulate_changes(changes_for_actor)

        changes_for_actor.destroy_all

      rescue ActiveRecord::RecordNotFound
      end


    end


  end
end
publish(verb, cur_publish_on, data) click to toggle source

Publishes an queued_task using an queued_task name and data

@param [ String ] verb The verb of the queued_task @param [ Hash ] data The data to initialize the queued_task with.

@return [MergingQueue::QueuedTask2] An QueuedTask instance with data

# File lib/merging-queue/queued_task.rb, line 102
def publish(verb, cur_publish_on, data)
  new.publish({:verb => verb, :publish_on => cur_publish_on}.merge(data))
end
queued_task(name, &block) click to toggle source

Defines a new QueuedTask2 type and registers a definition

@param [ String ] name The name of the queued_task

@example Define a new queued_task

queued_task(:enquiry) do
  actor :user, :cache => [:full_name]
  act_object :enquiry, :cache => [:subject]
  act_target :listing, :cache => [:title]
end

@return [Definition] Returns the registered definition

# File lib/merging-queue/queued_task.rb, line 90
def queued_task(name, &block)
  definition = MergingQueue::DefinitionDSL.new(name)
  definition.instance_eval(&block)
  MergingQueue::Definition.register(definition)
end