jasper print speed refactor working

app/controllers/employers_controller.rb

@@ -72,7 +72,7 @@ class EmployersController < ApplicationController
   def import
     word_doc = params[:employer][:import_from_word]
     if word_doc.present? && word_doc.is_a?(ActionDispatch::Http::UploadedFile)
-      @employer = WordDocProcessor.new(word_doc.tempfile).call
+      @employer = BenefitsWordDocService::WordDocProcessor.new(word_doc.tempfile).call
       @employer.save
       redirect_to employer_path(@employer.slug), notice: 'Employer Imported'
     else

app/controllers/id_card/print_controller.rb

@@ -70,7 +70,7 @@ module IdCard
                 slug = params[:id]
                 @employer = Employer.find_by(slug: slug)
             end
-            cards_pdf = IdCardPrinterService::EmployerCardsGenerator.new(@employer, "PrintCard").call
+            cards_pdf = IdCardPrinterService::CardsGenerator.new(@employer.employer_member_keys, "PrintCard").call
 
             send_data cards_pdf.to_pdf,
                 filename: "#{@employer.name.parameterize(separator: "_")}_print_cards_#{Date.today}.pdf",

app/jobs/process_id_card_data_job.rb

@@ -0,0 +1,90 @@
+class ProcessIdCardDataJob < ApplicationJob
+  queue_as :default
+
+  def perform(member_key, field_exception_ids, has_divisions = false)
+    member = Member.find_by(pb_entity_key: member_key)
+
+    effect_date = determine_eff_date(member)
+    if effect_date
+      member_card = @base_card.dup
+        member_attributes = {
+            full_name: member.id_card_display_name,
+            full_name_last_name_first: member.name,
+            primary_mb_member_key: member.pb_entity_key,
+            family_id: member.family_id,
+            plan_id: member.id_card_plan_id,
+            medical_eff_date: effect_date.strftime("%m/%d/%Y")
+        }
+
+        dependent_attributes = get_dependent_fields(member)
+        if dependent_attributes.present?
+            member_attributes.merge!(dependent_attributes)
+        end
+
+        if has_divisions
+            member_attributes.merge!({employer_name: member.division})
+        end
+
+        if field_exception_ids.present?
+            exceptions_attributes = {}
+            field_exceptions = IdCard::FieldException.where(id: field_exception_ids)
+            member_exception_values = member.id_card_field_exception_values
+            field_exceptions.each do |fe|
+                if member_exception_values[fe.field_type] == fe.field_value
+                    fe.field_exception_items.each do |fei|
+                        if fei.field_value.present?
+                            exceptions_attributes[fei.field_name] = fei.field_value
+                        elsif fei.provider_section_id.present?
+                            provider_attributes = IdCard::ProviderSection.find(fei.provider_section_id).attributes.with_indifferent_access.slice(
+                                :provider_line_1, :provider_line_2, :provider_line_3, :provider_line_4, :provider_line_5, :provider_line_6,
+                                :provider_line_7, :provider_line_8, :provider_line_9, :provider_line_10, :provider_line_11, :provider_line_12,
+                                :claim_to_1, :claim_to_2, :claim_to_3, :claim_to_4, :claim_to_5, :claim_to_6,
+                                :claim_to_7, :claim_to_8, :claim_to_9, :claim_to_10, :claim_to_11, :claim_to_12
+                            )
+                            exceptions_attributes.merge!(provider_attributes)
+                        elsif fei.network_logo_id.present?
+                            exceptions_attributes.merge!(network_logo_id: fei.network_logo_id)
+                            exceptions_attributes.merge!(network_logo_filename: fei.network_logo.filename)
+                        end
+                    end
+                end
+            end
+            member_attributes.merge!(exceptions_attributes)
+        end
+
+        member_card = IdCard::PrintData.find_by(pl_plan_key: member.pl_plan_key, plan_id: member.id_card_plan_id, primary_mb_member_key: nil).dup
+        member_card.assign_attributes(member_attributes)
+        member_card.save
+    end
+
+    true
+
+    # BatchProcess.increment_counter(:completed_jobs, batch_process_id)
+    
+  end
+
+  private
+
+  def determine_eff_date(member)
+      participation = Vhcs::PbProductParticipation.joins('INNER JOIN "PBCoveredEntities" ON "PBProductParticipation"."PBProductParticipationKey" = "PBCoveredEntities"."PBProductParticipationKey"').where('"PBCoveredEntities"."PBEntityKey" = ?', member.pb_entity_key).last
+      in_effect = participation.in_effect
+      out_of_effect = participation.out_of_effect
+
+      if in_effect <= (Date.today + 90.days) && (out_of_effect - 1.day) > Date.today && out_of_effect > in_effect
+          in_effect
+      else
+          false
+      end
+  end
+
+  def get_dependent_fields(member)
+      dependent_attributes = {}
+      dependents = Vhcs::VwmbMember.where(pl_plan_key: member.pl_plan_key, family_id: member.family_id).where.not(pb_entity_key: member.pb_entity_key)
+      dependents.each do |dep|
+          dependent_name = dep.first_name + ' ' + dep.last_name
+          dependent_attributes["dependent_#{dep.sequence_number - 1}".to_sym] = dependent_name
+      end
+      dependent_attributes
+  end
+
+end

app/models/employer.rb

@@ -46,6 +46,13 @@ class Employer < ApplicationRecord
     false
   end
 
+  def employer_member_keys
+    {
+      pl_plan_key: self.pl_plan_key,
+      member_keys: self.members.pluck(:pb_entity_key)
+    }
+  end
+
   def name_to_logo_filename(extension)
     self.employer_trim_name(self.name).titleize.gsub(/[^a-zA-Z]/, '').concat('Logo').concat(extension.downcase)
   end

app/models/id_card/setup.rb

@@ -36,6 +36,10 @@ module IdCard
             plan
         end
 
+        def has_field_exceptions?
+            self.field_exceptions.present?
+        end
+
         def self.permitted_params(params)
             params.require(:id_card_setup).permit(
                 :print_name,

app/models/member.rb

@@ -2,5 +2,16 @@ class Member < ApplicationRecord
   belongs_to :id_card_plan, class_name: 'IdCard::Plan', optional: true
   belongs_to :employer
 
+  def id_card_field_exception_values
+    address = Vhcs::PbEntityAddress.find_by(pb_entity_key: self.pb_entity_key)
+    {
+      zipcode: address.zip,
+      state: address.state,
+      family_id: self.family_id
+    }
+  end
+
+
+
 
 end

app/models/vhcs/pb_entity_address.rb

@@ -0,0 +1,47 @@
+module Vhcs
+  class PbEntityAddress < VhcsRecord
+
+    self.table_name = 'PBEntityAddress'
+
+    alias_attribute :pb_entity_address_key, :PBEntityAddressKey
+    alias_attribute :pb_entity_key, :PBEntityKey
+    alias_attribute :address_type_id, :AddressTypeID
+    alias_attribute :street_line_1, :StreetLine1
+    alias_attribute :street_line_2, :StreetLine2
+    alias_attribute :city, :City
+    alias_attribute :state, :State
+    alias_attribute :zip, :Zip
+    alias_attribute :country_code, :CountryCode
+    alias_attribute :county, :County
+    alias_attribute :override_pb_entity_address_key, :OverridePBEntityAddressKey
+    alias_attribute :when_last_changed, :WhenLastChanged
+    alias_attribute :who_last_changed, :WhoLastChanged
+    alias_attribute :full_address_to_use, :FullAddressToUse
+    alias_attribute :country_sub_div, :CountrySubDiv
+    alias_attribute :full_address, :FullAddress
+
+    def attributes
+      rails_like = {
+          pb_entity_address_key: self.pb_entity_address_key,
+          pb_entity_key: self.pb_entity_key,
+          address_type_id: self.address_type_id,
+          street_line_1: self.street_line_1,
+          street_line_2: self.street_line_2,
+          city: self.city,
+          state: self.state,
+          zip: self.zip,
+          country_code: self.country_code,
+          county: self.county,
+          override_pb_entity_address_key: self.override_pb_entity_address_key,
+          when_last_changed: self.when_last_changed,
+          who_last_changed: self.who_last_changed,
+          full_address_to_use: self.full_address_to_use,
+          country_sub_div: self.country_sub_div,
+          full_address: self.full_address,
+      }
+      super.merge(rails_like)
+    end
+
+
+  end
+end

app/services/id_card_printer_service/card_data_formatter.rb

@@ -0,0 +1,180 @@
+module IdCardPrinterService
+    class CardDataFormatter
+
+        def initialize(employers_member_keys)
+            # @employer = employer
+            @employers_member_keys = employers_member_keys
+
+            # @employer = Employer.includes(id_card_setup: [:provider_section, :rx_section]).find_by(pl_plan_key: pl_plan_key)
+            # @card_setup = @employer.id_card_setup
+        end
+
+        def call
+            # blank_card = IdCard::PrintData.new()
+            # @employer_cards = []
+            print_card_futures = []
+            @employers_member_keys.each do |emk|
+                pl_plan_key = emk[:pl_plan_key]
+                @member_keys = emk[:member_keys]
+                @employer = Employer.includes(id_card_setup: [:provider_section, :rx_section]).find_by(pl_plan_key: pl_plan_key)
+                @card_setup = @employer.id_card_setup
+
+                base_card = initialize_employer_base_card()
+                create_plan_base_cards(base_card)
+                
+                employer_card_futures = create_member_cards_async()
+
+                print_card_futures << employer_card_futures
+            end 
+
+
+            print_card_futures.flatten.map(&:value)
+
+        end
+
+        private
+
+        def initialize_employer_base_card
+
+            employer_attributes = {
+                pl_plan_key: @employer.pl_plan_key,
+                group_number: @employer.group_number,
+                rx_group: @card_setup.rx_group_number,
+                network_provider: @card_setup.network_provider,
+                network_logo_id: @card_setup.network_logo_id,
+                network_logo_filename: @card_setup.network_logo.filename,
+                employer_logo_filename: @card_setup.employer_logo.filename
+            }
+            unless @card_setup.has_divisions
+                employer_attributes.merge!({employer_name: @card_setup.print_name})
+            end
+
+            rx_attributes = @card_setup.rx_section.attributes.with_indifferent_access.slice(
+                :customer_service, 
+                :web_url
+            )
+
+            provider_attributes = @card_setup.provider_section.attributes.with_indifferent_access.slice(
+                :provider_line_1, :provider_line_2, :provider_line_3, :provider_line_4, :provider_line_5, :provider_line_6,
+                :provider_line_7, :provider_line_8, :provider_line_9, :provider_line_10, :provider_line_11, :provider_line_12,
+                :claim_to_1, :claim_to_2, :claim_to_3, :claim_to_4, :claim_to_5, :claim_to_6,
+                :claim_to_7, :claim_to_8, :claim_to_9, :claim_to_10, :claim_to_11, :claim_to_12
+            )
+
+            selected_attributes = employer_attributes.merge(rx_attributes).merge(provider_attributes)
+            # blank_card.assign_attributes(selected_attributes)
+            IdCard::PrintData.new(selected_attributes)
+        end
+
+        def create_plan_base_cards(common_fields_card)
+            needed_plans_ids = @employer.members.where(pb_entity_key: @member_keys).distinct.pluck(:id_card_plan_id)
+            needed_plans = @card_setup.plans.where(id: needed_plans_ids)
+            needed_plans.each do |plan|
+                selected_attributes = { plan_id: plan.id }
+                plan.plan_benefits.each do |bene|
+                    selected_attributes["benefit_desc_#{bene.sequence}".to_sym] = bene.benefit_desc
+                    selected_attributes["benefit_#{bene.sequence}".to_sym] = bene.benefit
+                end
+
+                plan_base_card = common_fields_card.dup
+                plan_base_card.assign_attributes(selected_attributes)
+                plan_base_card.save
+            end
+        end
+
+        def create_member_cards_async
+            field_exceptions = @card_setup.field_exceptions.pluck(:id)
+            mmember_card_futures = @member_keys.map do |member_key|
+                Concurrent::Future.execute do
+                    ActiveRecord::Base.connection_pool.with_connection do
+                        ProcessIdCardDataJob.perform_now(member_key, field_exceptions, @card_setup.has_divisions)
+                    end
+                end
+            end
+            
+            mmember_card_futures
+
+            # batch_process = BatchProcess.create!(total_jobs: @member_keys.count)
+            # @member_keys.each do |member_key|
+            #     ProcessIdCardDataJob.perform_later(member_key, @card_setup.has_divisions, batch_process.id)
+            # end
+
+            # @batch_id = batch_process.id
+            # @members.each do |me|
+            #     effect_date = determine_eff_date(me)
+            #     if effect_date
+            #         member_card = @base_card.dup
+            #         member_attributes = {
+            #             full_name: me.id_card_display_name,
+            #             full_name_last_name_first: me.name,
+            #             primary_mb_member_key: me.pb_entity_key,
+            #             family_id: me.family_id,
+            #             plan_id: me.id_card_plan_id,
+            #             medical_eff_date: effect_date.strftime("%m/%d/%Y")
+            #         }
+
+            #         if @card_setup.has_divisions
+            #             member_attributes.merge!({employer_name: me.division})
+            #         end
+
+            #         dependent_attributes = get_dependent_fields(me)
+            #         if dependent_attributes.present?
+            #             selected_attributes = member_attributes.merge(dependent_attributes)
+            #         else
+            #             selected_attributes = member_attributes
+            #         end
+
+            #         member_card.assign_attributes(selected_attributes)
+            #         @employer_cards.push(member_card)
+            #     end
+            # end
+        end
+
+        # def set_network_fields
+        #     selected_attributes = @employer.card_provider.attributes.with_indifferent_access.slice(
+        #         :provider_line_1, :provider_line_2, :provider_line_3, :provider_line_4, :provider_line_5, :provider_line_6,
+        #         :provider_line_7, :provider_line_8, :provider_line_9, :provider_line_10, :provider_line_11, :provider_line_12,
+        #         :claim_to_1, :claim_to_2, :claim_to_3, :claim_to_4, :claim_to_5, :claim_to_6,
+        #         :claim_to_7, :claim_to_8, :claim_to_9, :claim_to_10, :claim_to_11, :claim_to_12
+        #     )
+        #     @employer_cards.all do |card|
+        #         card.assign_attributes(selected_attributes)
+        #     end
+        # end
+
+        # def set_rx_fields
+        #     # fairos_information = Vhcs::HlrxCrosRef.where(pl_plan_key: 52).first
+        #     selected_attributes = @employer.card_rx.attributes.with_indifferent_access.slice(
+        #         :customer_service, 
+        #         :web_url
+        #     )
+        #     @employer_cards.all do |card|
+        #         card.assign_attributes(selected_attributes)
+        #     end
+        # end
+
+        def determine_eff_date(member)
+
+            participation = Vhcs::PbProductParticipation.joins('INNER JOIN "PBCoveredEntities" ON "PBProductParticipation"."PBProductParticipationKey" = "PBCoveredEntities"."PBProductParticipationKey"').where('"PBCoveredEntities"."PBEntityKey" = ?', member.pb_entity_key).last
+            in_effect = participation.in_effect
+            out_of_effect = participation.out_of_effect
+
+            if in_effect <= (Date.today + 90.days) && (out_of_effect - 1.day) > Date.today && out_of_effect > in_effect
+                in_effect
+            else
+                false
+            end
+
+        end
+
+        def get_dependent_fields(member)
+            dependent_attributes = {}
+            dependents = @group_dependents.where(family_id: member.family_id).where.not(pb_entity_key: member.pb_entity_key)
+            dependents.each do |dep|
+                dependent_name = dep.first_name + ' ' + dep.last_name
+                dependent_attributes["dependent_#{dep.sequence_number - 1}".to_sym] = dependent_name
+            end
+            dependent_attributes
+        end
+    end
+end

app/services/id_card_printer_service/cards_generator.rb

@@ -0,0 +1,68 @@
+module IdCardPrinterService
+    class CardsGenerator
+
+        def initialize(employers_member_keys, layout, zip=false)
+            @employers_member_keys = Array.wrap(employers_member_keys)
+            @layout = layout
+            @zip = zip
+        end
+
+        def call
+            pl_plan_keys = @employers_member_keys.map { |emk| emk[:pl_plan_key] }
+            IdCard::PrintData.where(pl_plan_key: pl_plan_keys).destroy_all
+            IdCardPrinterService::CardDataFormatter.new(@employers_member_keys).call
+
+            IdCard::PrintData.where(pl_plan_key: pl_plan_keys, primary_mb_member_key: nil).destroy_all
+
+            pdf_array = []
+            batches = break_into_batches(pl_plan_keys)
+            batches.each do |card_template, batch_pl_plan_keys|
+                jasper_batch_id = "#{batch_pl_plan_keys.join('_')}-#{Time.current.utc.to_i}"
+                batch = IdCard::PrintData.where(pl_plan_key: batch_pl_plan_keys)
+                batch.update!(jasper_batch_id: jasper_batch_id)
+                batch_pdf = IdCardPrinterService::PdfBatchProcessor.new(card_template, jasper_batch_id, @layout).call
+                pdf_array << batch_pdf
+            end
+            # @employers_member_keys.each do |emk|
+            #     employer_jasper_batches = IdCard::PrintData.where(pl_plan_key: emk[:pl_plan_key]).pluck(:network_logo_id).uniq
+            #     employer_jasper_batches.each do |batch_network_logo|
+            #         jasper_batch_id = "#{emk[:pl_plan_key]}-#{Time.current.utc.to_i}"
+            #         batch = IdCard::PrintData.where(pl_plan_key: emk[:pl_plan_key], network_logo_id: batch_network_logo)
+            #         # batch = employer_card_data.where(network_logo_id: batch_network_logo)
+            #         batch.update!(jasper_batch_id: jasper_batch_id)
+            #         batch_pdf = IdCardPrinterService::PdfBatchProcessor.new(emk[:pl_plan_key], batch_network_logo, jasper_batch_id, @layout).call
+            #         pdf_array << batch_pdf
+            #     end
+            #  end
+
+
+
+            group_pdfs = combine_pdfs(pdf_array)
+            group_pdfs
+
+        end
+
+        private
+
+        def break_into_batches(pl_plan_keys)
+            batches_by_card_template = IdCard::Setup.where(pl_plan_key: pl_plan_keys).group_by(&:card_template)
+                .transform_values { |setups| setups.map(&:pl_plan_key) }
+                .compact_blank
+        end
+
+        def combine_pdfs(pdf_array)
+            if @zip
+                group_cards_pdf = Zip::OutputStream.write_buffer do |zio|
+                    pdf_array.each do |file|
+                        zio.put_next_entry(file[:name])
+                        zio.write(file[:data])
+                    end
+                end
+            else
+                group_cards_pdf = CombinePDF.new
+                pdf_array.each { |pdf| group_cards_pdf << pdf }
+            end
+            group_cards_pdf
+        end
+    end
+end

app/services/id_card_printer_service/employer_cards_generator.rb

@@ -3,13 +3,36 @@ module IdCardPrinterService
 
         def initialize(employer, layout, zip=false)
             @employer = employer
+            @member_keys = @employer.members.pluck(:pb_entity_key)
             @layout = layout
             @zip = zip
         end
 
         def call
             IdCard::PrintData.where(pl_plan_key: @employer.pl_plan_key).destroy_all
-            IdCardPrinterService::EmployerDataFormatter.new(@employer).call
+            IdCardPrinterService::EmployerDataFormatter.new(@employer.pl_plan_key, @member_keys).call
+
+
+            # card_futures.each(&:value)
+
+            # max_retries = 60
+            # retries = 0
+            # finished = false
+
+            # batch_process = BatchProcess.find(batch_id)
+            # until finished || retries > max_retries
+            #     # Solid Queue stores finished jobs here if preserve_finished_jobs = true
+            #     if batch_process.completed_jobs < batch_process.total_jobs
+            #         sleep 0.5
+            #         retries += 1
+            #     else
+            #         batch_process.destroy!
+            #         finished = true
+            #     end
+            # end
+
+            IdCard::PrintData.where(pl_plan_key: @employer.pl_plan_key, primary_mb_member_key: nil).destroy_all
+
 
             pdf_array = IdCardPrinterService::PdfProcessor.new(@employer, @layout, @zip).call
 

app/services/id_card_printer_service/employer_data_formatter.rb

@@ -1,37 +1,35 @@
 module IdCardPrinterService
     class EmployerDataFormatter
 
-        def initialize(employer, member_keys = nil)
-            @employer = employer
+        def initialize(pl_plan_key, member_keys)
+            # @employer = employer
+            @member_keys = member_keys
+
+            @employer = Employer.includes(id_card_setup: [:provider_section, :rx_section]).find_by(pl_plan_key: pl_plan_key)
             @card_setup = @employer.id_card_setup
 
-            if member_keys
-                @members = @employer.members.where(pb_entity_key: member_keys).order(:name)
-            else
-                @members = @employer.members.order(:name)
-            end
+            @batch_id
         end
 
         def call
-            @base_card = IdCard::PrintData.new()
-            @employer_cards = []
+            # blank_card = IdCard::PrintData.new()
+            # @employer_cards = []
 
-            set_common_fields
-            set_member_fields
+            base_card = initialize_employer_base_card()
+            create_plan_base_cards(base_card)
             
+            card_futures = create_member_cards_async()
 
-            set_plan_fields
-
-            @employer_cards.each(&:save!)
+            card_futures
 
         end
 
         private
 
-        def set_common_fields
+        def initialize_employer_base_card
 
             employer_attributes = {
-                pl_plan_key: @card_setup.pl_plan_key,
+                pl_plan_key: @employer.pl_plan_key,
                 group_number: @employer.group_number,
                 rx_group: @card_setup.rx_group_number,
                 network_provider: @card_setup.network_provider
@@ -53,52 +51,70 @@ module IdCardPrinterService
             )
 
             selected_attributes = employer_attributes.merge(rx_attributes).merge(provider_attributes)
-            @base_card.assign_attributes(selected_attributes)
+            # blank_card.assign_attributes(selected_attributes)
+            IdCard::PrintData.new(selected_attributes)
         end
 
-        def set_plan_fields
-            @card_setup.plans.each do |plan|
-                selected_attributes = {}
+        def create_plan_base_cards(common_fields_card)
+            needed_plans_ids = @employer.members.where(pb_entity_key: @member_keys).distinct.pluck(:id_card_plan_id)
+            needed_plans = @card_setup.plans.where(id: needed_plans_ids)
+            needed_plans.each do |plan|
+                selected_attributes = { plan_id: plan.id }
                 plan.plan_benefits.each do |bene|
                     selected_attributes["benefit_desc_#{bene.sequence}".to_sym] = bene.benefit_desc
                     selected_attributes["benefit_#{bene.sequence}".to_sym] = bene.benefit
                 end
-                @employer_cards.find_all { |card| card.plan_id == plan.id.to_s }.each do |card|
-                    card.assign_attributes(selected_attributes)
-                end
+
+                plan_base_card = common_fields_card.dup
+                plan_base_card.assign_attributes(selected_attributes)
+                plan_base_card.save
             end
         end
 
-        def set_member_fields
-            @group_dependents = Vhcs::VwmbMember.where(pl_plan_key: @employer.pl_plan_key)
-            @members.each do |me|
-                effect_date = determine_eff_date(me)
-                if effect_date
-                    member_card = @base_card.dup
-                    member_attributes = {
-                        full_name: me.id_card_display_name,
-                        full_name_last_name_first: me.name,
-                        primary_mb_member_key: me.pb_entity_key,
-                        family_id: me.family_id,
-                        plan_id: me.id_card_plan_id,
-                        medical_eff_date: effect_date.strftime("%m/%d/%Y")
-                    }
+        def create_member_cards_async
 
-                    if @card_setup.has_divisions
-                        member_attributes.merge!({employer_name: me.division})
+            mmember_card_futures = @member_keys.map do |member_key|
+                Concurrent::Future.execute do
+                    ActiveRecord::Base.connection_pool.with_connection do
+                        ProcessIdCardDataJob.perform_now(member_key, @card_setup.has_divisions)
                     end
-
-                    dependent_attributes = get_dependent_fields(me)
-                    if dependent_attributes.present?
-                        selected_attributes = member_attributes.merge(dependent_attributes)
-                    else
-                        selected_attributes = member_attributes
-                    end
-
-                    member_card.assign_attributes(selected_attributes)
-                    @employer_cards.push(member_card)
                 end
             end
+            mmember_card_futures
+            # batch_process = BatchProcess.create!(total_jobs: @member_keys.count)
+            # @member_keys.each do |member_key|
+            #     ProcessIdCardDataJob.perform_later(member_key, @card_setup.has_divisions, batch_process.id)
+            # end
+
+            # @batch_id = batch_process.id
+            # @members.each do |me|
+            #     effect_date = determine_eff_date(me)
+            #     if effect_date
+            #         member_card = @base_card.dup
+            #         member_attributes = {
+            #             full_name: me.id_card_display_name,
+            #             full_name_last_name_first: me.name,
+            #             primary_mb_member_key: me.pb_entity_key,
+            #             family_id: me.family_id,
+            #             plan_id: me.id_card_plan_id,
+            #             medical_eff_date: effect_date.strftime("%m/%d/%Y")
+            #         }
+
+            #         if @card_setup.has_divisions
+            #             member_attributes.merge!({employer_name: me.division})
+            #         end
+
+            #         dependent_attributes = get_dependent_fields(me)
+            #         if dependent_attributes.present?
+            #             selected_attributes = member_attributes.merge(dependent_attributes)
+            #         else
+            #             selected_attributes = member_attributes
+            #         end
+
+            #         member_card.assign_attributes(selected_attributes)
+            #         @employer_cards.push(member_card)
+            #     end
+            # end
         end
 
         # def set_network_fields

app/services/id_card_printer_service/jasper_batch_url_generator.rb

@@ -0,0 +1,40 @@
+module IdCardPrinterService
+    class JasperBatchUrlGenerator
+
+        def initialize(card_template, jasper_batch_id, layout)
+            @card_template = card_template
+            @jasper_batch_id = jasper_batch_id
+            @layout = layout
+        end
+
+        def call
+            URI::HTTP.build(url_components)
+        end
+
+        private
+
+        # def determine_network_logo
+        #     # if @network_logos.length > 1
+        #     #     member_geographic_info = Vhcs::PbEntityAddress.joins("INNER JOIN vwMBMember ON PBEntityAddress.PBEntityKey = vwMBMember.PBEntityKey AND PBEntityAddress.AddressTypeID = 1137").where("vwMBMember.FamilyID = ?", @family_id).first
+        #     #     @network_logos.where.not(default: true).each do |pnl|
+        #     #         if member_geographic_info[pnl.exception_type] == pnl.exception_value
+        #     #             return pnl.net_logo
+        #     #         end
+        #     #     end
+        #     # end
+        #     # @network_logos.find_by(default: true).net_logo
+        #     IdCard::NetworkLogo.find(@network_logo_id).filename
+        # end
+# http://localhost:8080/trunk/PdfServlet?reportConn=BrittonConnect&id=&reportName=FairosRxSampleIDCard-Half&family_id=Classic%202K&employer_logo=BryanPestControl.jpeg&network_logo=CignaLogo.png&reportDir=secure/Documents&SUBREPORT_DIR=/&ImageDir=secure/Documents&netToken=3a4a8b03f4dfb0e6e3fc82dd369f70ef&FileType=PDF
+# http://localhost:8080/trunk/PdfServlet?reportConn=BrittonConnect&id=&reportName=FairosRxSampleIDCard-Half&family_id=Classic%202K&employer_logo=BryanPestControl.jpeg&network_logo=CignaLogo.png&reportDir=secure/Documents&SUBREPORT_DIR=/&ImageDir=secure/Documents&netToken=3a4a8b03f4dfb0e6e3fc82dd369f70ef&FileType=PDF
+        def url_components
+            {
+                host: '10.41.1.115',
+                port: 8080,
+                path: '/trunk/IdCardsServlet',
+                query: "reportConn=BrittonConnect&cardTemplate=#{@card_template}Batch&printType=Batch#{@layout}&jasper_batch_id=#{@jasper_batch_id}&FileType=PDF"
+            }
+        end
+        
+    end
+end

app/services/id_card_printer_service/pdf_batch_processor.rb

@@ -0,0 +1,36 @@
+module IdCardPrinterService
+    class PdfBatchProcessor
+
+        def initialize(card_template, jasper_batch_id, layout)
+            @card_template = card_template
+            @jasper_batch_id = jasper_batch_id
+            @layout = layout
+        end
+
+        def call
+            # if @zip
+            #     group_cards_pdf_array = []
+            # else
+            #     group_cards_pdf = CombinePDF.new
+            # end
+            url = IdCardPrinterService::JasperBatchUrlGenerator.new(@card_template, @jasper_batch_id, @layout).call
+            puts url
+            batch_pdf = IdCardPrinterService::JasperPdfGenerator.new(url).call
+
+
+            # if @zip
+            #     group_cards_pdf = Zip::OutputStream.write_buffer do |zio|
+            #         group_cards_pdf_array.each do |file|
+            #             zio.put_next_entry(file[:name])
+            #             zio.write(file[:data])
+            #         end
+            #     end
+            # # else
+            # #     todays_date = DateTime.current.strftime('%Y%m%d%H%M%S')
+            # #     group_cards_pdf.save("tmp/#{@employer.name}_print_cards_#{todays_date}.pdf")
+            # end
+
+            batch_pdf
+        end
+    end
+end

app/services/id_card_printer_service/pdf_processor.rb

@@ -3,7 +3,6 @@ module IdCardPrinterService
 
         def initialize(employer, layout, zip = false)
             @employer = employer
-            @card_setup = @employer.id_card_setup
             @layout = layout
             @zip = zip
         end

app/services/id_card_printer_service/sample_cards_generator.rb

@@ -6,7 +6,7 @@ module IdCardPrinterService
         end
 
         def call
-            IdCard::PrintData.where(employer_name: @employer.name).destroy_all
+            IdCard::PrintData.where(employer_name: @employer.id_card_setup.print_name).destroy_all
             IdCardPrinterService::SampleDataFormatter.new(@employer).call
 
             IdCardPrinterService::SamplePdfProcessor.new(@employer).call

app/services/id_card_printer_service/sample_data_formatter.rb

@@ -23,7 +23,7 @@ module IdCardPrinterService
 
         def set_employer_fields
             selected_attributes = {
-                employer_name: @employer.name,
+                employer_name: @card_setup.print_name,
                 group_number: @employer.group_number.present? ? @employer.group_number : "999999",
                 medical_eff_date: @employer.effective_date
             }

app/services/id_card_printer_service/sample_pdf_processor.rb

@@ -8,7 +8,7 @@ module IdCardPrinterService
 
         def call
             group_cards_pdf = CombinePDF.new
-            IdCard::PrintData.where(employer_name: @employer.name).each do |card|
+            IdCard::PrintData.where(employer_name: @card_setup.print_name).each do |card|
                 url = IdCardPrinterService::SampleJasperUrlGenerator.new(@employer, card.sample_key, card.sample_plan_title).call
                 puts url
                 card_pdf = IdCardPrinterService::JasperPdfGenerator.new(url).call

app/services/id_card_queue_service/get_queued_cards.rb

@@ -10,7 +10,21 @@ module IdCardQueueService
         end
 
         def call
-            CallStoredProc.new('BrittonGetQueuedIdCardMemberKeysTPA', { PLPlanKeys: @employer_pl_plan_keys }).call.to_ary
+            raw_employers_member_keys = CallStoredProc.new('BrittonGetQueuedIdCardMemberKeysTPA', { PLPlanKeys: @employer_pl_plan_keys }).call.to_ary
+
+            format_employers_member_keys(raw_employers_member_keys)
+        end
+
+        private
+
+        def format_employers_member_keys(raw_employers_member_keys)
+            key_map = { "PlanKey" => :pl_plan_key, "MemberKeys" => :member_keys }
+
+            raw_employers_member_keys.map do |hash|
+                hash["PlanKey"] = hash["PlanKey"].to_s
+                hash["MemberKeys"] = hash["MemberKeys"].split(", ").map(&:to_i)
+                hash.transform_keys(key_map)
+            end
         end
         
     end