cloudfactory 0.0.13

data/lib/cf/input_format.rb

@@ -0,0 +1,134 @@
+module CF
+  class InputFormat
+    include Client
+
+    # name for the input_format, e.g. :name => "image_url"
+    attr_accessor :name
+    
+    # required boolean either true or false , e.g. :required => "true" & if false then you don't need to mention
+    attr_accessor :required
+    
+    # valid_type format of the source for the input_format, e.g. :valid_type => "url"
+    attr_accessor :valid_type
+    
+    # ID of an input_format 
+    attr_accessor :id
+    
+    # ID of Line with which input_format is associated
+    attr_accessor :line_title, :errors
+    
+    # ==Initializes a new input_format
+    # * Syntax for creating new input_format: <b>InputFormat.new(</b> Hash <b>)</b>
+    # ===Usage Example:
+    #   line = CF::Line.create("Digitize", "Survey")
+    #
+    #   attrs = {:line => line,
+    #     :name => "image_url",
+    #     :required => true,
+    #     :valid_type => "url"} 
+    #   
+    #   input_format = CF::InputFormat.new(attrs) 
+    #   line.input_formats input_format
+    def initialize(options={})
+      @station            = options[:station]
+      @line               = options[:line]
+      @name              = options[:name]
+      @required           = options[:required]
+      @valid_type  = options[:valid_type]
+      if !@station.nil? or !@line.nil?
+        line_title = @station.nil? ? @line.title : @station.line_title
+        resp = self.class.post("/lines/#{CF.account_name}/#{@line.title.downcase}/input_formats.json", :input_format => {:name => @name, :required => @required, :valid_type => @valid_type})
+        if resp.code != 200
+          self.errors = resp.error.message
+        end
+        @line_title = line_title
+        if !@station.nil? && @station.except.nil? && @station.extra.nil?
+          @station.input_formats = self
+        else
+          @line.input_formats = self
+        end
+      end
+    end
+    
+    # ==Returns all the input headers of a specific line
+    #   line = CF::Line.new("Digitize Card","Survey")
+    #
+    #   attrs_1 = {:line => line,
+    #     :name => "image_url",
+    #     :required => true, 
+    #     :valid_type => "url"
+    #   }
+    #   attrs_2 = {:line => line,
+    #     :name => "text_url", 
+    #     :required => true, 
+    #     :valid_type => "url"
+    #   }
+    #   
+    #   input_format_1 = CF::InputFormat.new(attrs_1)
+    #   line.input_formats input_format_1
+    #   input_format_2 = CF::InputFormat.new(attrs_2)
+    #   line.input_formats input_format_2
+    # 
+    #   input_formats_of_line = CF::InputFormat.all(line)
+    # returns an array of input headers associated with line
+    def self.all(line)
+      get("/lines/#{CF.account_name}/#{line.title.downcase}/input_formats.json")
+    end
+    
+    # ==Returns a particular input header of a specific line
+    # ===Usage example
+    #   line = CF::Line.new("Digitize Card","Survey")
+    #   attrs = {:line => line,
+    #     :name => "image_url_type",
+    #     :required => true, 
+    #     :valid_type => "url"
+    #   }
+    #      
+    #   input_format = CF::InputFormat.new(attrs)
+    #   line.input_formats input_format
+    #   input_format = line.input_formats[0]
+    #   
+    #   got_input_format = input_format.get
+    def get
+      self.class.get("/lines/#{line_id}/input_formats/#{id}.json")
+    end
+    
+    # ==Updates input header
+    # ===Usage example
+    #   line = CF::Line.new("Digitize Card","Survey")
+    #   attrs = {:line => line,
+    #     :name => "image_url_type", 
+    #     :required => true, 
+    #     :valid_type => "url"
+    #   }
+    #   
+    #   input_format = CF::InputFormat.new(attrs)
+    #   line.input_formats input_format
+    #   input_format = line.input_formats[0]
+    #
+    #   updated_input_format = input_format.update({:name => "jackpot", :field_type => "lottery"})
+    def update(options={})
+      @name              = options[:name]
+      @required           = options[:required]
+      @valid_type  = options[:valid_type]
+      self.class.put("/lines/#{line_id}/input_formats/#{id}.json", :input_format => {:name => @name, :required => @required, :valid_type => @valid_type})
+    end
+    
+    #   line = CF::Line.new("Digitize Card","Survey")
+    #   attrs = {:line => line,
+    #     :name => "image_url_type", 
+    #     :required => true, 
+    #     :valid_type => "url"
+    #   }
+    #   
+    #   input_format = CF::InputFormat.new(attrs)
+    #   line.input_formats input_format
+    #
+    #   input_format = line.input_formats[0]
+    #   input_format.delete
+    # deletes input header
+    def delete
+      self.class.delete("/lines/#{line_id}/input_formats/#{id}.json")
+    end
+  end
+end

data/lib/cf/line.rb

@@ -0,0 +1,231 @@
+module CF
+  class Line
+    require 'httparty'
+    include Client
+
+    # Title of the Line
+    attr_accessor :title
+
+    # Category Name is required for the category which is categorized according to ID, e.g. "4dc8ad6572f8be0600000001"
+    attr_accessor :department_name
+
+    # Public is a boolean attribute which when set to true becomes public & vice-versa
+    #
+    # Public attribute is optional
+    attr_accessor :public
+
+    # Description attribute describes about the line
+    #
+    # Description attribute is optional
+    attr_accessor :description
+
+    # id attribute is for the line_id & is required to be stored for making Api calls
+    attr_accessor :id
+
+    # stations contained within line object
+    attr_accessor :stations
+
+    # input_formats contained within line object
+    attr_accessor :input_formats
+    attr_accessor :errors
+    #attr_accessor :input_format_instance
+    #attr_accessor :station_instance
+
+    # ==Initializes a new line
+    # ==Usage of line.new("line_name")
+    #
+    #     line = Line.new("Digit", "Survey")
+    def initialize(title, department_name, options={})
+      @input_formats =[]
+      @stations =[]
+      @title = title
+      @department_name = department_name
+      @public = options[:public]
+      @description = options[:description]
+      resp = self.class.post("/lines/#{CF.account_name}.json", {:line => {:title => title, :department_name => department_name, :public => @public, :description => @description}})
+      if resp.code != 200
+        self.errors = resp.error.message
+      end
+    end
+
+    # ==Usage of line.stations << station
+    #   line = CF::Line.new("line name")
+    #   station = CF::Station.new({:type => "Work"})
+    #   line.stations station
+    #
+    # * returns
+    # line.stations as an array of stations
+    def stations stations = nil
+      if stations
+        type = stations.type
+        @station_input_formats = stations.station_input_formats
+        if type == "Improve" && self.stations.size < 1
+          raise ImproveStationNotAllowed.new("You cannot add Improve Station as a first station of a line")
+        else
+          request_general = 
+          {
+            :body => 
+            {
+              :api_key => CF.api_key,
+              :station => {:type => type, :input_formats => @station_input_formats}
+            }
+          }
+          if type == "Tournament"
+            @jury_worker = stations.jury_worker
+            @auto_judge = stations.auto_judge
+            request_tournament = 
+            {
+              :body => 
+              {
+                :api_key => CF.api_key,
+                :station => {:type => type, :jury_worker => @jury_worker, :auto_judge => @auto_judge, :input_formats => @station_input_formats}
+              }
+            }
+            resp = HTTParty.post("#{CF.api_url}#{CF.api_version}/lines/#{CF.account_name}/#{self.title.downcase}/stations.json",request_tournament)
+          else
+            resp = HTTParty.post("#{CF.api_url}#{CF.api_version}/lines/#{CF.account_name}/#{self.title.downcase}/stations.json",request_general)
+          end
+          station = CF::Station.new()
+          resp.to_hash.each_pair do |k,v|
+            station.send("#{k}=",v) if station.respond_to?(k)
+          end
+          station.line = self
+          station.line_title = self.title
+          if resp.response.code != "200"
+            station.errors = resp.parsed_response['error']['message']
+          end
+          @stations << station
+        end
+      else
+        @stations
+      end
+    end
+
+    def << stations #:nodoc:
+      type = stations.type
+      @stations << stations
+      resp = CF::Station.post("/lines/#{self.id}/stations.json", :station => {:type => type})
+    end
+
+
+    def stations=(stations) # :nodoc:
+      @stations << stations
+      #resp = CF::Station.post("/lines/#{id}/stations.json", :station => {:type => stations.type})
+      #@station_id = resp._id
+    end
+
+    # ==Initializes a new line
+    # ==Usage of line.create("line_name") do |block|
+    # ===creating Line within block using variable
+    #   Line.create("line_name") do |line|
+    #     CF::InputFormat.new({:line => line, :label => "image_url", :field_type => "text_data", :value => "http://s3.amazon.com/bizcardarmy/medium/1.jpg", :required => true, :validation_format => "url"})
+    #     CF::Station.new({:line => line, :type => "Work"})
+    #   end
+    #
+    # ===OR creating without variable
+    #   CF::Line.create("line_name") do
+    #     CF::InputFormat.new({:line => self, :label => "image_url", :field_type => "text_data", :value => "http://s3.amazon.com/bizcardarmy/medium/1.jpg", :required => true, :validation_format => "url"})
+    #     CF::Station.new({:line => self, :type => "Work"})
+    #   end
+    def self.create(title, department_name, options={}, &block)
+      line = Line.new(title,department_name,options={})
+      @public = options[:public]
+      @description = options[:description]
+      if block.arity >= 1
+        block.call(line)
+      else
+        line.instance_eval &block
+      end
+      line
+    end
+
+    # ==Usage of line.input_formats(input_format)
+    #   line = Line.new("line name", "Survey")
+    #
+    #   input_format = CF::InputFormat.new({:label => "image_url", :field_type => "text_data", :value => "http://s3.amazon.com/bizcardarmy/medium/1.jpg", :required => true, :validation_format => "url"})
+    #   line.input_formats input_format
+    # * returns
+    # line.input_formats as an array of input_formats
+    def input_formats input_formats_value = nil
+      if input_formats_value
+        name = input_formats_value.name
+        required = input_formats_value.required
+        valid_type = input_formats_value.valid_type
+        resp = CF::InputFormat.post("/lines/#{CF.account_name}/#{self.title.downcase}/input_formats.json", :input_format => {:name => name, :required => required, :valid_type => valid_type})
+        input_format = CF::InputFormat.new()
+        resp.each_pair do |k,v|
+          input_format.send("#{k}=",v) if input_format.respond_to?(k)
+        end
+        if resp.code != 200
+          input_format.errors = resp.error.message
+        end
+        @input_formats << input_format
+      else
+        @input_formats
+      end
+    end
+    def input_formats=(input_formats_value) # :nodoc:
+      @input_formats << input_formats_value
+    end
+
+    # ==Returns the content of a line by making an Api call
+    # ===Syntax for get_line method is
+    #   CF::Line.info(line)
+    def self.info(line)
+      if line.class == CF::Line
+        resp = get("/lines/#{CF.account_name}/#{line.title.downcase}.json")
+      else
+        resp = get("/lines/#{CF.account_name}/#{line.downcase}.json")
+      end
+    end
+
+    # ==Finds a line
+    # ===Syntax for find method is
+    #   CF::Line.find(line.id)
+    def self.find(line_id)
+      get("/lines/#{line_id}.json")
+    end
+    # ==Returns all the lines of an account
+    # ===Syntax for all method is
+    #   CF::Line.all
+    def self.all
+      get("/lines/#{CF.account_name}.json")
+    end
+    
+    def get_stations
+      CF::Station.get("/lines/#{ACCOUNT_NAME}/#{self.title.downcase}/stations.json")
+    end
+    # ==Return all the lines whose public value is set true
+    # ===Syntax for public_lines method is
+    #   CF::Line.public_lines
+    def self.public_lines
+      get("/public_lines.json")
+    end
+
+    # ==Updates a line
+    # ===Syntax for update method is
+    #   line = CF::Line.new("Digitize Card", "Survey")
+    #   line.update({:title => "New Title"})
+    # * This changes the title of the "line" object from "Digitize Card" to "New Title"
+    def update(options={})
+      old_title = self.title
+      @title = options[:title]
+      @department_name = options[:department_name]
+      @public = options[:public]
+      @description = options[:description]
+      self.class.put("/lines/#{CF.account_name}/#{old_title.downcase}.json", :line => {:title => @title, :department_name => @department_name, :public => @public, :description => @description})
+    end
+
+    # ==Deletes a line
+    # ===Syantax for delete method
+    #   line = CF::Line.new("Digitize Card", "Survey")
+    #   line.delete
+    def destroy
+      self.class.delete("/lines/#{CF.account_name}/#{self.title.downcase}.json")
+    end
+    
+    def self.destroy(title)
+      delete("/lines/#{CF.account_name}/#{title.downcase}.json")
+    end
+  end
+end

data/lib/cf/robot_worker.rb

@@ -0,0 +1,31 @@
+module CF
+  class RobotWorker
+    require 'httparty'
+    include Client
+
+    # type of the station, e.g. station = Station.new(line, {:type => "Work"})
+    attr_accessor :settings, :type, :errors, :station, :number, :reward
+
+    def initialize(options={})
+      @type = options[:type].nil? ? nil : options[:type].camelize
+      @settings = options[:settings]
+      station = options[:station]
+      
+      if station
+        request = options[:settings].merge(:type => @type)
+        resp = self.class.post("/lines/#{CF.account_name}/#{station.line_title.downcase}/stations/#{station.index}/workers.json", :worker => request)
+        if resp.code != 200
+          self.errors = resp.error.message
+        end
+        self.number = resp.number
+        self.reward = resp.reward
+        self.station = station
+        station.worker = self
+      end
+    end
+    
+    def self.create(options)
+      RobotWorker.new(options)
+    end
+  end
+end

data/lib/cf/run.rb

@@ -0,0 +1,158 @@
+module CF
+  class Run
+    require 'httparty'
+    include Client
+
+    # title of the "run" object
+    attr_accessor :title
+
+    # file attributes to upload
+    attr_accessor :file, :input
+
+    # line attribute with which run is associated
+    attr_accessor :line
+
+    attr_accessor :id, :errors
+
+    # ==Initializes a new Run
+    # ==Usage Example:
+    #
+    #   line = CF::Line.create("Digitize Card","Digitization") do |l|
+    #     CF::InputHeader.new({:label => "Company", :field_type => "text_data", :value => "Google", :required => true, :validation_format => "general"})
+    #     CF::InputHeader.new({:label => "Website", :field_type => "text_data", :value => "www.google.com", :required => true, :validation_format => "url"})
+    #     CF::Station.create({:line => l, :type => "work") do |s|
+    #       CF::HumanWorker.new({:station => s, :number => 1, :reward => 20)
+    #       CF::StandardInstruction.create(:station => s, :title => "Enter text from a business card image", :description => "Describe"}) do |i|
+    #         CF::FormField.new({:instruction => i, :label => "First Name", :field_type => "SA", :required => "true"})
+    #         CF::FormField.new({:instruction => i, :label => "Middle Name", :field_type => "SA"})
+    #         CF::FormField.new({:instruction => i, :label => "Last Name", :field_type => "SA", :required => "true"})
+    #       end
+    #     end
+    #   end
+    #
+    #   run = CF::Run.new(line, "run name", File.expand_path("../../fixtures/input_data/test.csv", __FILE__))
+    def initialize(line, title, input)
+      @line = line
+      @title = title
+      if File.exist?(input.to_s)
+        @file = input
+        @param_data = File.new(input, 'rb')
+        @param_for_input = :file
+        resp = self.class.post("/lines/#{CF.account_name}/#{@line.title.downcase}/runs.json", {:data => {:run => {:title => @title}}, @param_for_input => @param_data})
+        if resp.code != 200
+          self.errors = resp.error.message
+        end
+      else
+        @input = input
+        @param_data = input
+        @param_for_input = :inputs
+        options = 
+        {
+          :body => 
+          {
+            :api_key => CF.api_key,
+            :data =>{:run => { :title => @title }, :inputs => @param_data}
+          }
+        }
+        run =  HTTParty.post("#{CF.api_url}#{CF.api_version}/lines/#{CF.account_name}/#{@line.title.downcase}/runs.json",options)
+        if run.code != 200
+          self.errors = run.parsed_response['error']['message']
+        end
+      end
+    end
+
+    # ==Creates a new Run
+    # ==Usage Example:
+    #
+    #   line = CF::Line.create("Digitize Card","Digitization") do |l|
+    #     CF::InputHeader.new({:line => l, :label => "Company", :field_type => "text_data", :value => "Google", :required => true, :validation_format => "general"})
+    #     CF::InputHeader.new({:line => l, :label => "Website", :field_type => "text_data", :value => "www.google.com", :required => true, :validation_format => "url"})
+    #     CF::Station.create({:line => l, :type => "work") do |s|
+    #       CF::HumanWorker.new({:station => s, :number => 1, :reward => 20)
+    #       CF::StandardInstruction.create(:station => s, :title => "Enter text from a business card image", :description => "Describe"}) do |i|
+    #         CF::FormField.new({:instruction => i, :label => "First Name", :field_type => "SA", :required => "true"})
+    #         CF::FormField.new({:instruction => i, :label => "Middle Name", :field_type => "SA"})
+    #         CF::FormField.new({:instruction => i, :label => "Last Name", :field_type => "SA", :required => "true"})
+    #       end
+    #     end
+    #   end
+    #
+    #   run = CF::Run.create(line, "run name", File.expand_path("../../fixtures/input_data/test.csv", __FILE__))
+    def self.create(line, title, file)
+      Run.new(line, title, file)
+    end
+
+    def get # :nodoc:
+      self.class.get("/lines/#{@line.id}/runs/#{@id}.json")
+    end
+
+    def self.get_final_output(run_id)
+      resp = get("/runs/#{run_id}/final_outputs.json")
+
+      @final_output =[]
+      resp.each do |r|
+        result = FinalOutput.new()
+        r.to_hash.each_pair do |k,v|
+          result.send("#{k}=",v) if result.respond_to?(k)
+        end
+        @final_output << result
+      end
+      return @final_output
+    end
+
+    def final_output
+      resp = self.class.get("/runs/#{CF.account_name}/#{self.title.downcase}/output.json")
+      @final_output =[]
+      resp['output'].each do |r|
+        result = FinalOutput.new()
+        r.to_hash.each_pair do |k,v|
+          result.send("#{k}=",v) if result.respond_to?(k)
+        end
+        if result.final_output == nil
+          result.final_output = resp.output
+        end
+        @final_output << result
+      end
+      return @final_output
+    end
+
+    def self.final_output(title)
+      resp = get("/runs/#{CF.account_name}/#{title.downcase}/output.json")
+      @final_output =[]
+      resp['output'].each do |r|
+        result = FinalOutput.new()
+        r.to_hash.each_pair do |k,v|
+          result.send("#{k}=",v) if result.respond_to?(k)
+        end
+        if result.final_output == nil
+          result.final_output = resp.output
+        end
+        @final_output << result
+      end
+      return @final_output
+    end
+    
+    def self.output(options={})
+      station_no = options[:station]
+      title = options[:title]
+      resp = get("/runs/#{CF.account_name}/#{title.downcase}/output/#{station_no}.json")
+      return resp['output'].first.to_hash
+    end
+    
+    def output(options={})
+      station_no = options[:station]
+      resp = self.class.get("/runs/#{CF.account_name}/#{self.title.downcase}/output/#{station_no}.json")
+      return resp['output'].first.to_hash
+    end
+    
+    def self.find(title)
+      resp = get("/runs/#{CF.account_name}/#{title.downcase}.json")
+      if resp.code != 200
+        resp.error = resp.error.message
+        resp.merge!(:errors => "#{resp.error}")
+        resp.delete(:error)
+      end
+      return resp
+    end
+  end
+end