blue_state_digital 0.6.0

data/lib/blue_state_digital/constituent.rb

@@ -0,0 +1,178 @@
+module BlueStateDigital
+  class Constituent < ApiDataModel
+    FIELDS = [:id, :firstname, :lastname, :is_banned, :create_dt, :ext_id, :birth_dt, :gender,
+                  :emails, :addresses, :phones, :groups, :is_new]
+    attr_accessor *FIELDS
+    attr_accessor :group_ids
+
+    def initialize(attrs = {})
+      super(attrs)
+      self.group_ids = []
+    end
+
+    def save
+      xml = connection.perform_request '/cons/set_constituent_data', {}, "POST", self.to_xml
+      doc = Nokogiri::XML(xml)
+      record =  doc.xpath('//cons').first
+      if record
+        self.id = record[:id]
+        self.is_new = record[:is_new]
+      else
+        raise "Set constituent data failed with message: #{xml}"
+      end
+      self
+    end
+
+    def is_new?
+      is_new == "1"
+    end
+
+    def to_xml
+      builder = Builder::XmlMarkup.new
+      builder.instruct! :xml, version: '1.0', encoding: 'utf-8'
+      builder.api do |api|
+        cons_attrs = {}
+        cons_attrs[:id] = self.id unless self.id.blank?
+        unless self.ext_id.blank?
+          cons_attrs[:ext_id] =  self.ext_id.id    unless self.ext_id.id.blank?
+          cons_attrs[:ext_type] = self.ext_id.type unless self.ext_id.type.blank?
+        end
+
+        api.cons(cons_attrs) do |cons|
+          cons.firstname(self.firstname) unless self.firstname.blank?
+          cons.lastname(self.lastname)   unless self.lastname.blank?
+          cons.is_banned(self.is_banned) unless self.is_banned.blank?
+          cons.create_dt(self.create_dt) unless self.create_dt.blank?
+          cons.birth_dt(self.birth_dt) unless self.birth_dt.blank?
+          cons.gender(self.gender) unless self.gender.blank?
+
+          unless self.emails.blank?
+            self.emails.each {|email| build_constituent_email(email, cons) }
+          end
+          unless self.addresses.blank?
+            self.addresses.each {|address| build_constituent_address(address, cons) }
+          end
+          unless self.phones.blank?
+            self.phones.each {|phone| build_constituent_phone(phone, cons) }
+          end
+          unless self.groups.blank?
+            self.groups.each {|group| build_constituent_group(group, cons) }
+          end
+        end
+      end
+    end
+
+    private
+
+
+    def build_constituent_group(group, cons)
+      cons.cons_group({ id: group })
+    end
+
+    def build_constituent_email(email, cons)
+      cons.cons_email do |cons_email|
+        email.to_hash.each do |key, value|
+          cons_email.__send__(key, value) unless value.blank?
+        end
+      end
+    end
+
+    def build_constituent_phone(phone, cons)
+      cons.cons_phone do |cons_phone|
+        phone.to_hash.each do |key, value|
+          cons_phone.__send__(key, value) unless value.blank?
+        end
+      end
+    end
+
+    def build_constituent_address(address, cons)
+      cons.cons_addr do |cons_addr|
+        address.to_hash.each do |key, value|
+         cons_addr.__send__(key, value) unless value.blank?
+        end
+      end
+    end
+  end
+
+  class Constituents < CollectionResource
+    def get_constituents_by_email email, bundles= [ 'cons_group' ]
+      get_constituents "email=#{email}", bundles
+    end
+
+    def get_constituents_by_id(cons_ids, bundles = ['cons_group'])
+      cons_ids_concat = cons_ids.is_a?(Array) ? cons_ids.join(',') : cons_ids.to_s
+
+      from_response(connection.perform_request('/cons/get_constituents_by_id', {:cons_ids => cons_ids_concat, :bundles=> bundles.join(',')}, "GET"))
+    end
+
+    def get_constituents(filter, bundles = [ 'cons_group' ])
+      result = connection.wait_for_deferred_result( connection.perform_request('/cons/get_constituents', {:filter => filter, :bundles=> bundles.join(',')}, "GET") )
+
+      from_response(result)
+    end
+
+    def delete_constituents_by_id(cons_ids)
+      cons_ids_concat = cons_ids.is_a?(Array) ? cons_ids.join(',') : cons_ids.to_s
+      connection.perform_request('/cons/delete_constituents_by_id', {:cons_ids => cons_ids_concat}, "POST")
+    end
+
+    def from_response(string)
+      parsed_result = Crack::XML.parse(string)
+      if parsed_result["api"].present?
+        result = []
+        if parsed_result["api"]["cons"].is_a?(Array)
+          parsed_result["api"]["cons"].each do |cons_group|
+            result << from_hash(cons_group)
+          end
+        else
+          result << from_hash(parsed_result["api"]["cons"])
+        end
+        return result
+      else
+        nil
+      end
+    end
+
+    def from_hash(hash)
+      attrs  = {}
+      Constituent::FIELDS.each do | field |
+        attrs[field] = hash[field.to_s] if hash[field.to_s].present?
+      end
+      cons = Constituent.new(attrs)
+      cons.connection = connection
+      if hash['cons_group'].present?
+        if hash['cons_group'].is_a?(Array)
+          cons.group_ids = hash['cons_group'].collect{|g| g["id"]}
+        else
+          cons.group_ids << hash['cons_group']["id"]
+        end
+      end
+
+      if hash['cons_addr'].present?
+        if hash['cons_addr'].is_a?(Array)
+          cons.addresses = hash['cons_addr'].collect {|addr_hash| BlueStateDigital::Address.new addr_hash}
+        else
+          cons.addresses = [BlueStateDigital::Address.new(hash['cons_addr'])]
+        end
+      end
+
+      if hash['cons_email'].present?
+        if hash['cons_email'].is_a?(Array)
+          cons.emails = hash['cons_email'].collect {|email_hash| BlueStateDigital::Email.new email_hash}
+        else
+          cons.emails = [BlueStateDigital::Email.new(hash['cons_email'])]
+        end
+      end
+
+      if hash['cons_phone'].present?
+        if hash['cons_phone'].is_a?(Array)
+          cons.phones = hash['cons_phone'].collect {|phone_hash| BlueStateDigital::Phone.new phone_hash}
+        else
+          cons.phones = [BlueStateDigital::Phone.new(hash['cons_phone'])]
+        end
+      end
+
+      cons
+    end
+  end
+end

data/lib/blue_state_digital/constituent_group.rb

@@ -0,0 +1,151 @@
+module BlueStateDigital
+  class ConstituentGroup < ApiDataModel
+    FIELDS = [:id, :name, :slug, :description, :group_type, :create_dt]
+    attr_accessor *FIELDS
+
+    def to_xml
+      builder = Builder::XmlMarkup.new
+      builder.instruct! :xml, version: '1.0', encoding: 'utf-8'
+      builder.api do |api|
+        api.cons_group do |cons_group|
+          cons_group.name(@name) unless @name.nil?
+          cons_group.slug(@slug) unless @slug.nil?
+          cons_group.description(@description) unless @description.nil?
+          cons_group.group_type(@group_type) unless @group_type.nil?
+          cons_group.create_dt(@create_dt) unless @create_dt.nil?
+        end
+      end
+    end
+  end
+
+  class ConstituentGroups < CollectionResource
+    CONSTITUENTS_BATCH_SIZE = 100
+
+    def add_cons_ids_to_group(cons_group_id, cons_ids, options = {wait_for_result: true})
+      add_or_remove_cons_ids_from_group(:add, cons_group_id, cons_ids, options)
+    end
+
+    def remove_cons_ids_from_group(cons_group_id, cons_ids, options = {wait_for_result: true})
+      add_or_remove_cons_ids_from_group(:remove, cons_group_id, cons_ids, options)
+    end
+
+    def create(attrs = {})
+      cons_group = ConstituentGroup.new(attrs)
+
+      xml = connection.perform_request '/cons_group/add_constituent_groups', {}, "POST", cons_group.to_xml
+      doc = Nokogiri::XML(xml)
+      group = doc.xpath('//cons_group')
+
+      cons_group.id = group.first[:id]
+      cons_group
+    end
+
+    def find_or_create(attr = {})
+      group = get_constituent_group_by_slug(attr[:slug])
+      if group
+        return group
+      else
+        return create(attr)
+      end
+    end
+
+    def list_constituent_groups
+      from_response(connection.perform_request '/cons_group/list_constituent_groups', {}, "GET")
+    end
+
+    def get_constituent_group(id)
+      from_response(connection.perform_request '/cons_group/get_constituent_group', {cons_group_id: id}, "GET")
+    end
+
+    def find_by_id(id)
+      get_constituent_group(id)
+    end
+
+    def delete_constituent_groups(group_ids)
+      group_ids_concat = group_ids.is_a?(Array) ? group_ids.join(',') : group_ids.to_s
+      connection.wait_for_deferred_result( connection.perform_request( '/cons_group/delete_constituent_groups', {cons_group_ids: group_ids_concat}, "POST")  )
+    end
+
+    def get_constituent_group_by_name( name )
+      name = name.slice(0..254)
+      from_response( connection.perform_request '/cons_group/get_constituent_group_by_name', {name: name}, "GET" )
+    end
+
+    def get_constituent_group_by_slug( slug )
+      slug = slug.slice(0..31)
+      from_response( connection.perform_request '/cons_group/get_constituent_group_by_slug', {slug: slug}, "GET" )
+    end
+
+    def rename_group(id, new_name)
+      connection.perform_request '/cons_group/rename_group', {cons_group_id: id, new_name: new_name}, "POST"
+    end
+
+    # Warning: this is an expensive, potentially dangerous operation! You should almost always use rename group instead.
+    def replace_constituent_group!(old_group_id, new_group_attrs)
+      # first, check to see if this group exists.
+      group = get_constituent_group(old_group_id)
+      raise "Group being renamed does not exist!" if group.nil?
+
+      cons_ids  = get_cons_ids_for_group(old_group_id)
+      delete_constituent_groups(old_group_id)
+
+      new_group = find_or_create(new_group_attrs)
+      add_cons_ids_to_group(new_group.id, cons_ids)
+
+      new_group
+    end
+
+    def get_cons_ids_for_group(cons_group_id)
+      response = connection.wait_for_deferred_result( connection.perform_request '/cons_group/get_cons_ids_for_group', {cons_group_id: cons_group_id}, "GET" )
+      response.split("\n")
+    end
+
+
+    private
+
+    def from_response(string)
+      parsed_result = Crack::XML.parse(string)
+      if parsed_result["api"].present?
+        if parsed_result["api"]["cons_group"].is_a?(Array)
+          results = []
+          parsed_result["api"]["cons_group"].each do |cons_group|
+            results << from_hash(cons_group)
+          end
+          return results
+        else
+          return from_hash(parsed_result["api"]["cons_group"])
+        end
+      else
+        nil
+      end
+    end
+
+    def from_hash(hash)
+      attrs  = {}
+      ConstituentGroup::FIELDS.each do | field |
+        attrs[field] = hash[field.to_s] if hash[field.to_s].present?
+      end
+      ConstituentGroup.new(attrs)
+    end
+
+    def add_or_remove_cons_ids_from_group(operation, cons_group_id, cons_ids, options)
+      method = case operation
+                when :add
+                  'add_cons_ids_to_group'
+                when :remove
+                  'remove_cons_ids_from_group'
+              end
+      cons_ids = cons_ids.is_a?(Array) ? cons_ids : [cons_ids]
+
+      cons_ids.in_groups_of(CONSTITUENTS_BATCH_SIZE, false) do |batched_cons_ids|
+        cons_ids_concat = batched_cons_ids.join(',')
+        post_params = { cons_group_id: cons_group_id, cons_ids: cons_ids_concat }
+        if options[:wait_for_result]
+          connection.wait_for_deferred_result( connection.perform_request "/cons_group/#{method}", post_params, "POST" )
+        else
+          connection.perform_request "/cons_group/#{method}", post_params, "POST"
+        end
+      end
+    end
+  end
+end

data/lib/blue_state_digital/contribution.rb

@@ -0,0 +1,73 @@
+module BlueStateDigital
+  class Contribution < ApiDataModel
+    #TODO are we sure we want to raise an exception on save?
+    class ContributionExternalIdMissingException < StandardError
+      def initialize
+        super("Missing GUID for ID")
+      end
+    end
+    class ContributionSaveFailureException < StandardError
+      def initialize(msg)
+        super
+      end  
+    end
+    class ContributionSaveValidationException < StandardError
+      def initialize(validation_errors)
+        error_messages = validation_errors.map do |id,msgs|
+          "Error for Contribution(ID: #{id}): #{msgs.join(', ')}. " 
+        end
+        super(error_messages.join(', '))
+      end
+    end
+
+    FIELDS = [
+      :external_id,
+      :prefix,:firstname,:middlename,:lastname,:suffix,
+      :transaction_dt,:transaction_amt,:cc_type_cd,:gateway_transaction_id,
+      :contribution_page_id,:stg_contribution_recurring_id,:contribution_page_slug,
+      :outreach_page_id,:source,:opt_compliance,
+      :addr1,:addr2,:city,:state_cd,:zip,:country,
+      :phone,:email,
+      :employer,:occupation,
+      :custom_fields
+    ]
+    attr_accessor *FIELDS
+
+    def as_json(options={})
+      fields_to_exclude = []
+      fields_to_exclude << :contribution_page_id if contribution_page_id.nil?
+      fields_to_exclude << :contribution_page_slug if contribution_page_slug.nil?
+      super(options.merge({except: fields_to_exclude}))
+    end
+
+    def save
+      begin
+        if connection
+          response = connection.perform_request( 
+            '/contribution/add_external_contribution',
+            {accept: 'application/json'},
+            'POST',
+            [self].to_json
+          )
+          begin
+            response = JSON.parse(response)  
+          rescue
+            raise ContributionSaveFailureException.new(response)
+          end
+          if(response['summary']['missing_ids']>0)
+            raise ContributionExternalIdMissingException.new
+          elsif(response['summary']['failures']>0)
+            raise ContributionSaveValidationException.new(response['errors'])
+          end 
+        else
+          raise NoConnectionException.new
+        end
+        #TODO shouldn't we be returning true or false and set the errors as in ActiveModel?
+        true
+      rescue => e
+        raise e
+      end
+    end
+  end
+
+end

data/lib/blue_state_digital/dataset.rb

@@ -0,0 +1,139 @@
+module BlueStateDigital
+  class Dataset < ApiDataModel
+
+    extend ActiveModel::Naming
+    include ActiveModel::Validations
+
+    UPLOAD_ENDPOINT = '/cons/upload_dataset'
+    DELETE_ENDPOINT = '/cons/delete_dataset'
+
+    FIELDS = [
+      :dataset_id,
+      :map_type,
+      :slug,
+      :rows
+    ]
+    attr_accessor *FIELDS
+    attr_reader   :data,:data_header,:errors
+
+    validates_presence_of :map_type, :slug
+    validate :data_must_have_header
+
+    def initialize(args={})
+      super
+      @data = []
+      @data_header = nil
+      @errors = ActiveModel::Errors.new(self)
+    end
+    def data
+      @data
+    end
+    def add_data_row(row)
+      @data.push row
+    end
+    def add_data_header(header_row)
+      @data_header = header_row
+    end
+    def save
+      #errors.add(:data, "cannot be blank") if @data.blank?
+      if valid?
+        if connection
+          response = connection.perform_request_raw(
+            UPLOAD_ENDPOINT,
+            {api_ver: 2, slug: slug, map_type: map_type, content_type: 'text/csv', accept: 'application/json'},
+            "PUT",
+            csv_payload
+          )
+          if(response.status == 202)
+            true
+          else
+            errors.add(:web_service,"#{response.body}")
+            false
+          end
+        else
+          errors.add(:connection,"is missing")
+          false
+        end
+      else
+        false
+      end
+    end
+
+
+    def delete
+      if dataset_id.nil?
+        errors.add(:dataset_id,"is missing")
+        return false
+      end
+      if connection
+          response = connection.perform_request_raw(
+            DELETE_ENDPOINT,
+            {api_ver: 2},
+            "POST",
+            {dataset_id: dataset_id}.to_json
+          )
+          if(response.status==200)
+            true
+          else
+            errors.add(:web_service,"#{response.body}")
+            false
+          end
+        else
+          errors.add(:connection,"is missing")
+          false
+        end
+    end
+
+    def read_attribute_for_validation(attr)
+      send(attr)
+    end
+    def self.human_attribute_name(attr, options = {})
+      attr
+    end
+    def self.lookup_ancestors
+      [self]
+    end
+
+    private
+
+    def csv_payload
+      csv_string = CSV.generate do |csv|
+        csv << (@data_header||[])
+        @data.each do |row|
+          csv << row
+        end
+      end
+    end
+
+    def data_must_have_header
+      errors.add(:data_header, "is missing") if !@data.blank? && @data_header.nil?
+    end
+  end
+
+  class Datasets < CollectionResource
+
+    FETCH_ENDPOINT = '/cons/list_datasets'
+
+    def get_datasets
+      if connection
+        response = connection.perform_request FETCH_ENDPOINT, { api_ver: 2 }, "GET"
+
+        # TODO: Should check response's status code
+        begin
+          parsed_response = JSON.parse(response)
+
+          data = parsed_response['data']
+          if(data)
+            data.map {|dataset| Dataset.new(dataset) }
+          else
+            nil
+          end
+        rescue Exception => e
+          raise FetchFailureException.new(e)
+        end
+      else
+        raise NoConnectionException.new
+      end
+    end
+  end
+end