FFS-2490 Wrap Argyle Data Fetch API's

app/app/models/response_objects/employment.rb

@@ -7,7 +7,6 @@
   employer_phone_number
   employer_address
 ]
-
 module ResponseObjects
   Employment = Struct.new(*EMPLOYMENT_FIELDS, keyword_init: true) do
     def self.from_pinwheel(response_body)
@@ -21,5 +20,14 @@ def self.from_pinwheel(response_body)
         employer_address: response_body.dig("employer_address", "raw")
       )
     end
+    def self.from_argyle(identity_response_body)
+      new(
+        account_id: identity_response_body["account"],
+        employer_name: identity_response_body["employer"],
+        start_date: identity_response_body["hire_date"],
+        termination_date: identity_response_body["termination_date"],
+        status: ResponseObjects::FormatMethods::Argyle.format_employment_status(identity_response_body["employment_status"]),
+      )
+    end
   end
 end

app/app/models/response_objects/format_methods/argyle.rb

@@ -0,0 +1,32 @@
+module ResponseObjects::FormatMethods::Argyle
+  def self.format_employment_status(employment_status)
+    return unless employment_status
+
+    case employment_status
+    when "active"
+      "employed"
+    when "inactive"
+      "furloughed"
+    else
+      employment_status
+    end
+  end
+
+  def self.format_date(date)
+    return unless date
+
+    DateTime.parse(date).strftime("%Y-%m-%d")
+  end
+
+  def self.format_currency(amount)
+    return unless amount
+    amount.to_f
+  end
+
+  def self.hours_by_earning_category(gross_pay_list)
+    gross_pay_list
+       .filter { |e| e["hours"].present? }
+       .group_by { |e| e["type"] }
+       .transform_values { |earnings| earnings.sum { |e| e["hours"].to_f } }
+  end
+end

app/app/models/response_objects/format_methods/pinwheel.rb

@@ -0,0 +1,28 @@
+module ResponseObjects::FormatMethods::Pinwheel
+  def self.hours(earnings)
+    base_hours = earnings
+      .filter { |e| e["category"] != "overtime" }
+      .map { |e| e["hours"] }
+      .compact
+      .max
+    return unless base_hours
+
+    # Add overtime hours to the base hours, because they tend to be additional
+    # work beyond the other entries. (As opposed to category="premium", which
+    # often duplicates other earnings' hours.)
+    #
+    # See FFS-1773.
+    overtime_hours = earnings
+      .filter { |e| e["category"] == "overtime" }
+      .sum { |e| e["hours"] || 0.0 }
+
+    base_hours + overtime_hours
+  end
+
+  def self.hours_by_earning_category(earnings)
+    earnings
+      .filter { |e| e["hours"] && e["hours"] > 0 }
+      .group_by { |e| e["category"] }
+      .transform_values { |earnings| earnings.sum { |e| e["hours"] } }
+  end
+end

app/app/models/response_objects/identity.rb

@@ -11,5 +11,11 @@ def self.from_pinwheel(response_body)
         full_name: response_body["full_name"],
       )
     end
+    def self.from_argyle(identity_response_body)
+      new(
+        account_id: identity_response_body["account"],
+        full_name: identity_response_body["full_name"],
+      )
+    end
   end
 end

app/app/models/response_objects/income.rb

@@ -15,5 +15,13 @@ def self.from_pinwheel(response_body)
         compensation_unit: response_body["compensation_unit"],
       )
     end
+    def self.from_argyle(identities_response_body)
+      new(
+        account_id: identities_response_body["account"],
+        pay_frequency: identities_response_body["base_pay"]["period"],
+        compensation_amount: ResponseObjects::FormatMethods::Argyle.format_currency(identities_response_body["base_pay"]["amount"]),
+        compensation_unit: identities_response_body["base_pay"]["currency"],
+      )
+    end
   end
 end

app/app/models/response_objects/paystub.rb

@@ -22,8 +22,8 @@ def self.from_pinwheel(response_body)
         pay_period_start: response_body["pay_period_start"],
         pay_period_end: response_body["pay_period_end"],
         pay_date: response_body["pay_date"],
-        hours: PinwheelMethods.hours(response_body["earnings"]),
-        hours_by_earning_category: PinwheelMethods.hours_by_earning_category(response_body["earnings"]),
+        hours: ResponseObjects::FormatMethods::Pinwheel.hours(response_body["earnings"]),
+        hours_by_earning_category: ResponseObjects::FormatMethods::Pinwheel.hours_by_earning_category(response_body["earnings"]),
         deductions: response_body["deductions"].map do |deduction|
           OpenStruct.new(
             category: deduction["category"],
@@ -33,36 +33,28 @@ def self.from_pinwheel(response_body)
       )
     end
 
-    alias_attribute :start, :pay_period_start
-    alias_attribute :end, :pay_period_end
-  end
-
-  module PinwheelMethods
-    def self.hours(earnings)
-      base_hours = earnings
-        .filter { |e| e["category"] != "overtime" }
-        .map { |e| e["hours"] }
-        .compact
-        .max
-      return unless base_hours
 
-      # Add overtime hours to the base hours, because they tend to be additional
-      # work beyond the other entries. (As opposed to category="premium", which
-      # often duplicates other earnings' hours.)
-      #
-      # See FFS-1773.
-      overtime_hours = earnings
-        .filter { |e| e["category"] == "overtime" }
-        .sum { |e| e["hours"] || 0.0 }
-
-      base_hours + overtime_hours
+    def self.from_argyle(response_body)
+      new(
+        account_id: response_body["account"],
+        gross_pay_amount: ResponseObjects::FormatMethods::Argyle.format_currency(response_body["gross_pay"]),
+        net_pay_amount: ResponseObjects::FormatMethods::Argyle.format_currency(response_body["net_pay"]),
+        gross_pay_ytd: ResponseObjects::FormatMethods::Argyle.format_currency(response_body["gross_pay_ytd"]),
+        pay_period_start: ResponseObjects::FormatMethods::Argyle.format_date(response_body["paystub_period"]["start_date"]),
+        pay_period_end: ResponseObjects::FormatMethods::Argyle.format_date(response_body["paystub_period"]["end_date"]),
+        pay_date: ResponseObjects::FormatMethods::Argyle.format_date(response_body["paystub_date"]),
+        hours: response_body["hours"],
+        hours_by_earning_category: ResponseObjects::FormatMethods::Argyle.hours_by_earning_category(response_body["gross_pay_list"]),
+        deductions: response_body["deduction_list"].map do |deduction|
+          OpenStruct.new(
+            category: deduction["name"],
+            amount: ResponseObjects::FormatMethods::Argyle.format_currency(deduction["amount"]),
+          )
+        end,
+      )
     end
 
-    def self.hours_by_earning_category(earnings)
-      earnings
-        .filter { |e| e["hours"] && e["hours"] > 0 }
-        .group_by { |e| e["category"] }
-        .transform_values { |earnings| earnings.sum { |e| e["hours"] } }
-    end
+    alias_attribute :start, :pay_period_start
+    alias_attribute :end, :pay_period_end
   end
 end

app/app/services/argyle_service.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require "faraday"
+require "fileutils"
+require "json"
 
 class ArgyleService
   ENVIRONMENTS = {
@@ -11,7 +13,12 @@ class ArgyleService
     }
   }
 
-  USERS_ENDPOINT = "https://api-sandbox.argyle.com/v2/users"
+  ITEMS_ENDPOINT = "items"
+  PAYSTUBS_ENDPOINT = "paystubs"
+  IDENTITIES_ENDPOINT = "identities"
+  USERS_ENDPOINT = "users"
+  ACCOUNTS_ENDPOINT = "accounts"
+  EMPLOYMENTS_ENDPOINT = "employments"
 
   def initialize(environment, api_key_id = nil, api_key_secret = nil)
     @api_key_id = api_key_id || ENVIRONMENTS.fetch(environment.to_sym)[:api_key_id]
@@ -38,12 +45,108 @@ def initialize(environment, api_key_id = nil, api_key_secret = nil)
     end
   end
 
+  def fetch_paystubs(**params)
+    json = fetch_paystubs_api(**params)
+    json["results"].map { |paystub_json| ResponseObjects::Paystub.from_argyle(paystub_json) }
+  end
+
+  def fetch_employments(**params)
+    # Note: we actually fetch Argyle's identity API instead of employment for the correct data
+    json = fetch_identities_api(**params)
+    json["results"].map { |identity_json| ResponseObjects::Employment.from_argyle(identity_json) }
+  end
+
+  def fetch_incomes(**params)
+    # Note: we actually fetch Argyle's identity API instead of employment for the correct data
+    json = fetch_identities_api(**params)
+    json["results"].map { |identity_json| ResponseObjects::Income.from_argyle(identity_json) }
+  end
+
+  # https://docs.argyle.com/api-reference/identities#retrieve
+  def fetch_identities(**params)
+    # todo: paginate
+    json = fetch_identities_api(**params)
+    json["results"].map { |identity_json| ResponseObjects::Identity.from_argyle(identity_json) }
+  end
+
   # Fetch all Argyle items
+  # https://docs.argyle.com/api-reference/items#list
   def items(query = nil)
-    @http.get("items", { q: query }).body
+    @http.get(ITEMS_ENDPOINT, { q: query }).body
+  end
+
+  # https://docs.argyle.com/api-reference/users#retrieve
+  def fetch_user_api(user:)
+    @http.get(build_url("#{USERS_ENDPOINT}/#{user}")).body
+  end
+
+  # https://docs.argyle.com/api-reference/identities#list
+  def fetch_identities_api(**params)
+    # todo: paginate
+    @http.get(IDENTITIES_ENDPOINT, params).body
+  end
+
+  # https://docs.argyle.com/api-reference/accounts#list
+  def fetch_accounts_api(**params)
+    # TODO: paginate
+    # json["data"].map { |paystub_json| ResponseObjects::Paystub.from_pinwheel(paystub_json) }
+    @http.get(ACCOUNTS_ENDPOINT, params).body
+  end
+
+  # https://docs.argyle.com/api-reference/paystubs#list
+  def fetch_paystubs_api(**params)
+    # TODO: paginate
+    @http.get(PAYSTUBS_ENDPOINT, params).body
   end
 
   def create_user
-    @http.post("users").body
+    @http.post(USERS_ENDPOINT).body
+  end
+
+  # https://docs.argyle.com/api-reference/employments#list
+  def fetch_employments_api(**params)
+    # json["data"].map { |paystub_json| ResponseObjects::Paystub.from_pinwheel(paystub_json) }
+    @http.get(EMPLOYMENTS_ENDPOINT, params).body
+  end
+
+  # TODO: refactor this into common function between argyle_service/pinwheel_service
+  def build_url(endpoint)
+    @http.build_url(endpoint).to_s
+  end
+
+  def store_mock_response(responsePayload:, folderName: "other", fileName:)
+    FileUtils.mkdir_p "spec/support/fixtures/argyle/#{folderName}"
+
+    File.open("spec/support/fixtures/argyle/#{folderName}/#{fileName}.json", "wb") do
+      |f| f.puts(JSON.pretty_generate(responsePayload))
+    end
+  end
+
+  # Only for use in sandbox environment for test mocking
+  def fetch__and_store_mock_data_for_user(argyle_user_id:, folderName:)
+    store_mock_response(
+      folderName: folderName,
+      fileName: "request_user",
+      responsePayload: fetch_user_api(user: argyle_user_id))
+
+    store_mock_response(
+      folderName: folderName,
+      fileName: "request_identity",
+      responsePayload: fetch_identities_api(user: argyle_user_id))
+
+    store_mock_response(
+      folderName: folderName,
+      fileName: "request_employment",
+      responsePayload: fetch_employment_api(user: argyle_user_id))
+
+    store_mock_response(
+      folderName: folderName,
+      fileName: "request_accounts",
+      responsePayload: fetch_accounts_api(user: argyle_user_id))
+
+    store_mock_response(
+      folderName: folderName,
+      fileName: "request_paystubs",
+      responsePayload: fetch_paystubs_api(user: argyle_user_id))
   end
 end