cats_core 1.5.16 → 1.5.18

data/app/services/cats/core/dispatch_service.rb

@@ -4,33 +4,33 @@ module Cats
       def search(user, status, authorized: false)
         details = user.details
 
-        unless details['stores'] || details['warehouse'] || details['hub']
-          raise(StandardError, 'User does not have associated location.')
+        unless details["stores"] || details["warehouse"] || details["hub"]
+          raise(StandardError, "User does not have associated location.")
         end
 
         # Get user's hub
-        hub = if details['stores']
-                Store.find(details['stores'][0]).warehouse.parent
-              elsif details['warehouse']
-                Location.find(details['warehouse']).parent
-              else
-                Location.find(details['hub'])
-              end
+        hub = if details["stores"]
+          Store.find(details["stores"][0]).warehouse.parent
+        elsif details["warehouse"]
+          Location.find(details["warehouse"]).parent
+        else
+          Location.find(details["hub"])
+        end
 
         if authorized
           return Dispatch.joins(:dispatch_plan_item)
-                         .includes({ dispatch_plan_item: :destination }, :transporter, :prepared_by, :unit)
-                         .where(
-                           dispatch_plan_item: { destination: hub, status: DispatchPlanItem::AUTHORIZED },
-                           dispatch_status: status
-                         )
+              .includes({dispatch_plan_item: :destination}, :transporter, :prepared_by, :unit)
+              .where(
+                dispatch_plan_item: {destination: hub, status: DispatchPlanItem::AUTHORIZED},
+                dispatch_status: status
+              )
         end
         Dispatch.joins(:dispatch_plan_item)
-                .includes({ dispatch_plan_item: :destination }, :transporter, :prepared_by, :unit)
-                .where(
-                  dispatch_plan_item: { destination: hub },
-                  dispatch_status: status
-                )
+          .includes({dispatch_plan_item: :destination}, :transporter, :prepared_by, :unit)
+          .where(
+            dispatch_plan_item: {destination: hub},
+            dispatch_status: status
+          )
       end
 
       def start(dispatch)
@@ -41,23 +41,23 @@ module Cats
 
       def start_with_pin(dispatch_id, pin)
         dispatch = Dispatch.includes(
-          { dispatch_plan_item: :destination },
+          {dispatch_plan_item: :destination},
           :transporter,
           :prepared_by,
           :unit
         ).find(dispatch_id)
-        raise(StandardError, 'Dispatch is already started.') if dispatch.dispatch_status == Dispatch::STARTED
+        raise(StandardError, "Dispatch is already started.") if dispatch.dispatch_status == Dispatch::STARTED
 
-        raise(StandardError, 'No pin has been generated for dispatch.') if dispatch.auth_details.nil?
+        raise(StandardError, "No pin has been generated for dispatch.") if dispatch.auth_details.nil?
 
-        raise(StandardError, 'Incorrect pin.') unless pin == dispatch.auth_details['pin']
+        raise(StandardError, "Incorrect pin.") unless pin == dispatch.auth_details["pin"]
 
-        raise(StandardError, 'Pin is not active.') unless dispatch.auth_details['active']
+        raise(StandardError, "Pin is not active.") unless dispatch.auth_details["active"]
 
-        if DateTime.now > dispatch.auth_details['expires_at']
+        if DateTime.now > dispatch.auth_details["expires_at"]
           dispatch.auth_details[:active] = false
           dispatch.save!
-          raise(StandardError, 'Pin has expired.')
+          raise(StandardError, "Pin has expired.")
         end
         dispatch.start
         send_notification(dispatch)
@@ -67,17 +67,17 @@ module Cats
       end
 
       def send_notification(dispatch)
-        notification_rule = NotificationRule.find_by(code: 'dispatch')
-        raise(StandardError, 'Notification rule not found for dispatch notification.') unless notification_rule
+        notification_rule = NotificationRule.find_by(code: "dispatch")
+        raise(StandardError, "Notification rule not found for dispatch notification.") unless notification_rule
 
-        users = User.joins(:roles).where(cats_core_roles: { name: notification_rule.roles })
+        users = User.joins(:roles).where(cats_core_roles: {name: notification_rule.roles})
         location_id = dispatch.dispatch_plan_item.destination_id
         hub = Location.find(location_id)
         recipients = users.map do |user|
           details = user.details
 
-          if (details.key?('warehouse') && hub.child_ids.include?(details['warehouse'])) ||
-             (details.key?('hub') && details['hub'] == location_id)
+          if (details.key?("warehouse") && hub.child_ids.include?(details["warehouse"])) ||
+              (details.key?("hub") && details["hub"] == location_id)
             user
           end
         end.compact

data/app/services/cats/core/notification_service.rb

@@ -3,14 +3,14 @@ module Cats
     class NotificationService
       NOTIFICATION_RULES = {
         dispatch_plan: {
-          application: 'CATS-WH',
-          notification: 'DispatchPlanNotification',
+          application: "CATS-WH",
+          notification: "DispatchPlanNotification",
           params: [:way_bill],
           recipients: [:warehouse_manager]
         },
         receipt_plan: {
-          application: 'CATS-WH',
-          notification: 'ReceiptPlanNotification',
+          application: "CATS-WH",
+          notification: "ReceiptPlanNotification",
           params: [:receipt_plan],
           recipients: [:store_keeper]
         }
@@ -34,7 +34,7 @@ module Cats
         roles = rule[:recipients]
 
         users = Cats::Core::User.joins(:application_module)
-                                .where(application_module: { prefix: app_code }).with_all_roles(*roles)
+          .where(application_module: {prefix: app_code}).with_all_roles(*roles)
         notifier.deliver(users)
       end
     end

data/app/services/cats/core/round_plan_service.rb

@@ -3,9 +3,9 @@ module Cats
     class RoundPlanService
       def generate_round_needs(plan_id)
         round_plan = Cats::Core::RoundPlan.find(plan_id)
-        raise(StandardError, 'Plan has no rations.') if round_plan.round_rations.count.zero?
+        raise(StandardError, "Plan has no rations.") if round_plan.round_rations.count.zero?
 
-        raise(StandardError, 'Plan has no plan items.') if round_plan.round_plan_items.count.zero?
+        raise(StandardError, "Plan has no plan items.") if round_plan.round_plan_items.count.zero?
 
         clear_needs(round_plan.id)
 
@@ -13,15 +13,15 @@ module Cats
         rations = round_plan.round_rations
         plan = round_plan.plan
         no_of_days = plan.total_days / plan.rounds
-        mt = UnitOfMeasure.find_by(abbreviation: 'mt')
+        mt = UnitOfMeasure.find_by(abbreviation: "mt")
         round_plan.beneficiary_round_plan_items.each do |plan_item|
           round_rations = rations.select { |r| r.beneficiary_category_id == plan_item.beneficiary_category_id }
           round_rations.each do |ration|
             quantity = (no_of_days / ration.no_of_days * ration.quantity) * plan_item.beneficiaries *
-                       round_plan.rounds.count
+              round_plan.rounds.count
             quantity = quantity.truncate(2)
             unit = ration.unit
-            if ration.unit.abbreviation.downcase != 'pc'
+            if ration.unit.abbreviation.downcase != "pc"
               quantity = UnitConversion.convert(unit, mt, quantity).truncate(2)
               unit = mt
             end
@@ -42,7 +42,7 @@ module Cats
       def clear_needs(plan_id)
         Cats::Core::RoundPlanItemDetail
           .joins(beneficiary_round_plan_item: :round_plan_item)
-          .where(cats_core_beneficiary_round_plan_items: { cats_core_round_plan_items: { round_plan_id: plan_id } })
+          .where(cats_core_beneficiary_round_plan_items: {cats_core_round_plan_items: {round_plan_id: plan_id}})
           .delete_all
       end
 
@@ -54,7 +54,7 @@ module Cats
           status: Cats::Core::Plan::DRAFT,
           rounds: rounds
         )
-        rations = Cats::Core::Ration.joins(:beneficiary_category).where(beneficiary_category: { plan_id: plan_id })
+        rations = Cats::Core::Ration.joins(:beneficiary_category).where(beneficiary_category: {plan_id: plan_id})
         round_rations = rations.map do |ration|
           {
             beneficiary_category_id: ration.beneficiary_category_id,
@@ -111,27 +111,27 @@ module Cats
       # round plan item becomes empty, then it too should be deleted.
       #
       def remove_items(plan_id, ids)
-        raise(StandardError, 'No beneficiary plan items specified.') if ids.count.zero?
+        raise(StandardError, "No beneficiary plan items specified.") if ids.count.zero?
 
         begin
           plan = Cats::Core::RoundPlan.find(plan_id)
         rescue ActiveRecord::RecordNotFound
-          raise(StandardError, 'Round plan not found.') unless plan
+          raise(StandardError, "Round plan not found.") unless plan
         end
 
         plans = Cats::Core::RoundPlan.includes(:beneficiary_round_plan_items)
-                                     .where(beneficiary_round_plan_items: { id: ids })
-        raise(StandardError, 'Round plan items should be from the same plan.') if plans.count > 1
+          .where(beneficiary_round_plan_items: {id: ids})
+        raise(StandardError, "Round plan items should be from the same plan.") if plans.count > 1
 
         unless plans.count.positive? && plan.id == plans[0].id
-          raise(StandardError, 'Round plan items are not from the given round plan.')
+          raise(StandardError, "Round plan items are not from the given round plan.")
         end
 
         to_delete = Cats::Core::BeneficiaryRoundPlanItem.where(id: ids)
         keys = to_delete.map(&:round_plan_item_id).uniq
 
         item_counts = Cats::Core::BeneficiaryRoundPlanItem.where(round_plan_item_id: keys)
-                                                          .group(:round_plan_item_id).count
+          .group(:round_plan_item_id).count
 
         delete_hash = {}
         keys.each { |k| delete_hash[k] = [] }
@@ -151,16 +151,16 @@ module Cats
 
       def approve(plan_id)
         plan = RoundPlan.find(plan_id)
-        if plan.plan.program.code == 'PSNP'
+        if plan.plan.program.code == "PSNP"
           rounds = plan.rounds.count
-          item_ids = plan.beneficiary_round_plan_items.pluck('beneficiary_plan_item_id').flatten
+          item_ids = plan.beneficiary_round_plan_items.pluck("beneficiary_plan_item_id").flatten
           plan_items = BeneficiaryPlanItem.includes(plan_item: :fdp).where(id: item_ids)
           invalid = plan_items.select { |pi| pi.rounds - (pi.rounds_served || 0) < rounds }.map do |pi|
             pi.plan_item.fdp.name
           end
 
           if invalid.count.positive?
-            msg = invalid.join(', ')
+            msg = invalid.join(", ")
             error = "The FDPs [#{msg}] exceeded their allowed number of rounds."
             raise(StandardError, error)
           end
@@ -169,7 +169,7 @@ module Cats
             rounds_served = plan_item.rounds_served || 0
             res << "(#{plan_item.id}, #{rounds + rounds_served})"
           end
-          values = items.join(',')
+          values = items.join(",")
           sql = <<-SQL
             UPDATE cats_core_beneficiary_plan_items AS bpi
             SET
@@ -192,11 +192,11 @@ module Cats
       end
 
       def send_approval_notification(round_plan)
-        notification_rule = NotificationRule.find_by(code: 'round_plan_approval')
-        error = 'Notification rule not found for round plan approval notification.'
+        notification_rule = NotificationRule.find_by(code: "round_plan_approval")
+        error = "Notification rule not found for round plan approval notification."
         raise(StandardError, error) unless notification_rule
 
-        users = User.joins(:roles).where(cats_core_roles: { name: notification_rule.roles })
+        users = User.joins(:roles).where(cats_core_roles: {name: notification_rule.roles})
         return if users.empty?
 
         notification = RoundPlanNotification.with(round_plan: round_plan)
@@ -204,14 +204,14 @@ module Cats
       end
 
       def send_approved_notification(round_plan)
-        notification_rule = NotificationRule.find_by(code: 'round_plan_approved')
-        error = 'Notification rule not found for round plan approved notification.'
+        notification_rule = NotificationRule.find_by(code: "round_plan_approved")
+        error = "Notification rule not found for round plan approved notification."
         raise(StandardError, error) unless notification_rule
 
         users = User.joins(roles: :application_module).where(
           cats_core_roles: {
             name: notification_rule.roles,
-            cats_core_application_modules: { prefix: 'CATS-TMS' }
+            cats_core_application_modules: {prefix: "CATS-TMS"}
           }
         )
         return if users.empty?

data/app/services/cats/core/space_service.rb

@@ -1,9 +1,9 @@
 module Cats
   module Core
     class SpaceService
-      HUB = 'Hub'.freeze
-      WAREHOUSE = 'Warehouse'.freeze
-      STORE = 'Store'.freeze
+      HUB = "Hub".freeze
+      WAREHOUSE = "Warehouse".freeze
+      STORE = "Store".freeze
 
       def available_space(id, level)
         case level
@@ -12,17 +12,17 @@ module Cats
           warehouses = hub.children
           warehouse_ids = warehouses.map(&:id)
           stores = Cats::Core::Store.joins(:warehouse)
-                                    .where(
-                                      cats_core_locations: {
-                                        location_type: Cats::Core::Location::WAREHOUSE,
-                                        id: warehouse_ids
-                                      }
-                                    ).group_by(&:warehouse_id)
+            .where(
+              cats_core_locations: {
+                location_type: Cats::Core::Location::WAREHOUSE,
+                id: warehouse_ids
+              }
+            ).group_by(&:warehouse_id)
           wh_details = []
           stores.each do |key, value|
             total_space = value.inject(0) { |sum, val| sum + val.available_space }
             details = value.map do |val|
-              { store_id: val.id, code: val.code, name: val.name, total_space: val.available_space }
+              {store_id: val.id, code: val.code, name: val.name, total_space: val.available_space}
             end
             warehouse = warehouses.find(key)
             wh_details << {
@@ -45,7 +45,7 @@ module Cats
           warehouse = Cats::Core::Location.find(id)
           stores = Cats::Core::Store.where(warehouse_id: id)
           details = stores.map do |store|
-            { store_id: store.id, code: store.code, name: store.name, total_space: store.available_space }
+            {store_id: store.id, code: store.code, name: store.name, total_space: store.available_space}
           end
           total_space = stores.inject(0) { |sum, val| sum + val.available_space }
           space = {

data/app/services/cats/core/stack_service.rb

@@ -5,20 +5,20 @@ module Cats
         details = user.details
 
         key_available = details.keys.any? { |key| %w[stores warehouse hub].include?(key) }
-        raise(StandardError, 'User does not have associated location.') unless key_available
+        raise(StandardError, "User does not have associated location.") unless key_available
 
-        hub = if details['hub']
-                Location.find(details['hub'])
-              elsif details['warehouse']
-                Location.find(details['warehouse']).parent
-              else
-                Store.find(details['stores'][0]).warehouse.parent
-              end
+        hub = if details["hub"]
+          Location.find(details["hub"])
+        elsif details["warehouse"]
+          Location.find(details["warehouse"]).parent
+        else
+          Store.find(details["stores"][0]).warehouse.parent
+        end
 
         allocation_items =
           DispatchPlanItem
-          .joins(:dispatch_plan)
-          .where(destination: hub, dispatch_plan: { status: DispatchPlan::APPROVED })
+            .joins(:dispatch_plan)
+            .where(destination: hub, dispatch_plan: {status: DispatchPlan::APPROVED})
 
         allocation_items.map do |item|
           {

data/app/services/cats/core/token_auth_service.rb

@@ -1,15 +1,15 @@
 module Cats
   module Core
     class TokenAuthService
-      AUTH_SECRET = '592fac227e8ee4ff985e376d554604f36c974b4f4605eb8d7ebe4dd1cf8fd8aa8e0cb85df1b48a8ec60cac7bb4117d854'\
-                    '5c359123e14f6784dcd88e6e6a1ea8c'.freeze
+      AUTH_SECRET = "592fac227e8ee4ff985e376d554604f36c974b4f4605eb8d7ebe4dd1cf8fd8aa8e0cb85df1b48a8ec60cac7bb4117d854" \
+                    "5c359123e14f6784dcd88e6e6a1ea8c".freeze
 
       def self.issue(payload)
-        JWT.encode(payload, auth_secret, 'HS256')
+        JWT.encode(payload, auth_secret, "HS256")
       end
 
       def self.decode(token)
-        JWT.decode(token, auth_secret, true, algorithm: 'HS256').first
+        JWT.decode(token, auth_secret, true, algorithm: "HS256").first
       end
 
       def self.auth_secret

data/app/services/cats/core/user_service.rb

@@ -0,0 +1,19 @@
+module Cats
+  module Core
+    class UserService
+      def change_password(email, old_password, new_password, password_confirmation)
+        raise(StandardError, "Password and confirmation do not match.") unless new_password == password_confirmation
+
+        user = User.find_by(email:)
+        raise(StandardError, "User with email '#{email}' could not be found.") unless user
+
+        raise(StandardError, "Old password for user '#{email}' is not correct.") unless user.authenticate(old_password)
+
+        user.password = new_password
+        user.password_confirmation = password_confirmation
+        user.save!
+        user
+      end
+    end
+  end
+end

data/app/utils/cats/core/util.rb

@@ -7,7 +7,7 @@ module Cats
 
       def self.generate_pin(obj)
         pin = SecureRandom.hex(10)
-        obj.auth_details = { pin: pin, active: true, expires_at: DateTime.now + 24.hour }
+        obj.auth_details = {pin: pin, active: true, expires_at: DateTime.now + 24.hour}
         obj.save!
       end
     end