logistics_core 20.8.1

data/app/models/logistics/core/increment_rate.rb

@@ -0,0 +1,8 @@
+module Logistics
+  module Core
+    class IncrementRate < ApplicationRecord
+      belongs_to :service_increment
+      validates :percent, :effective_date, presence: true
+    end
+  end
+end

data/app/models/logistics/core/inter_city_route.rb

@@ -0,0 +1,13 @@
+module Logistics
+  module Core
+    class InterCityRoute < Route
+      validates :from_id, :to_id, presence: true, allow_blank: false
+      validates :from_id, uniqueness: {scope: [:from_id, :to_id]}
+      validate :check_from_id_and_to_id
+
+      def check_from_id_and_to_id
+        errors.add(:from_id, "can't be the same as to.") if from_id == to_id
+      end
+    end
+  end
+end

data/app/models/logistics/core/item_rate.rb

@@ -0,0 +1,33 @@
+module Logistics
+  module Core
+    class ItemRate < ApplicationRecord
+      belongs_to :chargeable_service_unit_of_charge
+      belongs_to :transaction_type
+
+      def self.get_chargeable_services(service_delivery_unit_id)
+        unit_of_charge_id = UnitOfCharge.select(:id).where('code' => 'ITEM')
+        csuocs = ChargeableServiceUnitOfCharge.where('service_delivery_unit_id' => service_delivery_unit_id, 'unit_of_charge_id' => unit_of_charge_id)
+        return csuocs
+      end
+
+      def self.generate_rate_for_item_services(effective_date)
+        transaction_types = TransactionType.all
+        service_delivery_units = ServiceDeliveryUnit.all
+        service_delivery_units.each { |sdu|
+          transaction_types.each { |transaction_type|
+            chargeable_services = get_chargeable_services(sdu.id)
+            chargeable_services.each { |chargeable_service|
+              item_rate = ItemRate.where('transaction_type_id' => transaction_type.id,
+                                         'chargeable_service_unit_of_charge_id' => chargeable_service.id)
+              if item_rate.count == 0
+                ItemRate.create('transaction_type_id' => transaction_type.id, 'chargeable_service_unit_of_charge_id' =>
+                    chargeable_service.id, 'minimum_quantity' => 0, 'rate' => 0,
+                                'margin' => 0, 'effective_date' => effective_date)
+              end
+            }
+          }
+        }
+      end
+    end
+  end
+end

data/app/models/logistics/core/kilogram_minimum_rate.rb

@@ -0,0 +1,8 @@
+module Logistics::Core
+  class KilogramMinimumRate < ApplicationRecord
+    belongs_to :chargeable_service_unit_of_charge
+    belongs_to :transaction_type
+
+    delegate(:name, to: :transaction_type, prefix: true)
+  end
+end

data/app/models/logistics/core/kilogram_rate.rb

@@ -0,0 +1,33 @@
+module Logistics
+  module Core
+    class KilogramRate < ApplicationRecord
+      belongs_to :transaction_type
+      belongs_to :chargeable_service_unit_of_charge
+
+      def self.get_chargeable_services(service_delivery_unit_id)
+        unit_of_charge_id = UnitOfCharge.select(:id).where('code' => 'KG')
+        csuocs = ChargeableServiceUnitOfCharge.where('service_delivery_unit_id' => service_delivery_unit_id, 'unit_of_charge_id' => unit_of_charge_id )
+        return csuocs
+      end
+
+      def self.generate_rate_for_kilogram_services(effective_date)
+        transaction_types = TransactionType.all
+        service_delivery_units = ServiceDeliveryUnit.all
+        service_delivery_units.each { |sdu|
+          transaction_types.each { |transaction_type|
+            chargeable_services = get_chargeable_services(sdu.id)
+            chargeable_services.each { |chargeable_service|
+              kilogram_rate = KilogramRate.where('transaction_type_id' =>transaction_type.id,
+                                                 'chargeable_service_unit_of_charge_id' => chargeable_service.id)
+              if kilogram_rate.count == 0
+                KilogramRate.create('transaction_type_id' => transaction_type.id,'chargeable_service_unit_of_charge_id' =>
+                  chargeable_service.id, 'low' => 0, 'medium' => 0,'high' => 0,
+                                    'margin' => 0,'effective_date' => effective_date)
+              end
+            }
+          }
+        }
+      end
+    end
+  end
+end

data/app/models/logistics/core/lookup.rb

@@ -0,0 +1,8 @@
+module Logistics
+  module Core
+    class Lookup < ApplicationRecord
+      validates :code, presence: true, uniqueness: { scope: [:code, :type] }
+      validates :name, :type, presence: true, uniqueness: { scope: [:name, :type] }
+    end
+  end
+end

data/app/models/logistics/core/offer_request.rb

@@ -0,0 +1,114 @@
+module Logistics
+  module Core
+    class OfferRequest < ApplicationRecord
+      validates :communication_channel_id, :no_of_convoy,:no_of_items, presence: true
+      belongs_to :user, class_name: 'Mks::Auth::User'
+      belongs_to :communication_channel
+      belongs_to :agent, optional: true
+      belongs_to :carrier, optional: true
+      belongs_to :contract, optional: true
+      has_many :review_notes, as: :correspondence
+      belongs_to :warehouse, optional: true
+      belongs_to :transaction_type
+      belongs_to :client
+      belongs_to :operation_type
+
+      delegate(:name, to: :transaction_type, prefix: true, allow_nil: true)
+      delegate( :contract_number, to: :contract, prefix: false, allow_nil: true )
+      delegate(:name, to: :client, prefix: true, allow_nil: true)
+      delegate(:name, to: :communication_channel, prefix: true, allow_nil: true)
+      delegate(:name, to: :operation_type, prefix: true, allow_nil: true)
+
+      def to_json
+        JSON.parse(
+            Jbuilder.encode do |json|
+              json.id self.id
+              json.request_no self.request_no
+              json.transaction_type_id self.transaction_type.id
+              json.transaction_type_name self.transaction_type.name
+              json.status self.status
+              json.client_id self.client.id
+              json.client self.client.name
+              json.communication_channel_id self.communication_channel_id
+              json.communication_channel_name self.communication_channel.name
+              json.source_detail self.source_detail
+              json.point_of_recipient self.point_of_recipient
+              json.date_of_recipient self.date_of_recipient
+              json.general_remark self.general_remark
+              json.freight_forwarding self.freight_forwarding
+              json.customs_clearing self.customs_clearing
+              json.transport self.transport
+              json.rate_level self.rate_level
+              json.security_status self.security_status
+              json.operation_type_id self.operation_type.id
+              json.operation_type_name self.operation_type.name
+              json.no_of_items self.no_of_items
+              json.no_of_convoy self.no_of_convoy
+              json.is_bulk self.is_bulk
+            end
+        )
+      end
+
+      def get_bill_of_loading_by_status_and_user(status, user_id)
+        bill_of_loadings = OfferRequest.where(status: status, user_id:  user_id).order(:id)
+        return bill_of_loadings
+      end
+
+      def get_bill_of_loading_by_status(status)
+        bill_of_loadings = OfferRequest.where(status: status).order('id DESC')
+        return bill_of_loadings
+      end
+
+      def change_to_hash(items)
+        data = []
+        items.each { |item|
+          data.push item.to_json
+        }
+        return data
+      end
+
+      def get_request_with_additional_service
+        offer_requests = OfferRequest.where.not(additional_service_status: nil).order(:id)
+        return offer_requests
+      end
+
+      def get_requests_by_security_status(security_status)
+        offer_requests = OfferRequest.where(security_status: security_status)
+        return offer_requests
+      end
+
+      def self.fetch_all(bill_of_loading_ids, user, filtering_criteria)
+        result = []
+        @bill_of_loadings = nil
+        if filtering_criteria != 'none'
+          if filtering_criteria == 'request'
+            @bill_of_loadings = OfferRequest.where('(user_id =:user_id and status = :status_one)',{user_id:user.id,status_one:'draft'} )
+          else
+            @bill_of_loadings = OfferRequest.where('(user_id =:user_id and status = :status_one)',{user_id:user.id,status_one:filtering_criteria} )
+          end
+        else
+          @bill_of_loadings = OfferRequest.where.not(id: bill_of_loading_ids).where(user_id: user.id)
+        end
+        @bill_of_loadings.each do |bill_of_loading|
+          result.push({:id => bill_of_loading.id, :bill_of_loading_number => bill_of_loading.bill_of_loading_number,
+                       :transaction_type_id => bill_of_loading.transaction_type_id, :transaction_type_name => bill_of_loading.transaction_type_name,
+                       :operation_type_id => bill_of_loading.operation_type_id, :operation_type_name => bill_of_loading.operation_type_name,
+                       :user_id => bill_of_loading.user.id, :status => bill_of_loading.status, :entry_status => bill_of_loading.entry_status,
+                       :client_id => bill_of_loading.client_id, :client => bill_of_loading.client_name,
+                       :communication_channel_id => bill_of_loading.communication_channel_id,
+                       :communication_channel_name => bill_of_loading.communication_channel_name,
+                       :source_detail => bill_of_loading.source_detail, :point_of_recipient => bill_of_loading.point_of_recipient,
+                       :date_of_recipient => bill_of_loading.date_of_recipient, :general_remark => bill_of_loading.general_remark,
+                       :freight_forwarding => bill_of_loading.freight_forwarding, :customs_clearing => bill_of_loading.customs_clearing,
+                       :transport => bill_of_loading.transport, :rate_level => bill_of_loading.rate_level,
+                       :route_id => bill_of_loading.route_id, :route_name => bill_of_loading.route_name,
+                       :positioning_route_id => bill_of_loading.positioning_route_id, :positioning_route_name => bill_of_loading.positioning_route_name,
+                       :return_fee_route_id => bill_of_loading.return_fee_route_id, :return_fee_route_name => bill_of_loading.return_fee_route_name,
+                       :review_count =>bill_of_loading.review_count, :no_of_items => bill_of_loading.no_of_items,
+                       :no_of_convoy => bill_of_loading.no_of_convoy})
+        end
+        return result
+      end
+    end
+  end
+end

data/app/models/logistics/core/operation.rb

@@ -0,0 +1,45 @@
+module Logistics
+  module Core
+    class Operation < ApplicationRecord
+      belongs_to :offer_request
+      belongs_to :declarant, optional: true
+      belongs_to :declaration_type, optional: true
+      belongs_to :transport_mode, optional: true
+      belongs_to :customs_office, optional: true
+      belongs_to :customs_office_unit, optional: true
+      belongs_to :country_of_origin, :class_name => 'Logistics::Core::Country', optional: true
+      belongs_to :acquisition_mode, optional: true
+      belongs_to :payment_term, optional: true
+      belongs_to :delivery_term, optional: true
+      belongs_to :container_arrangement, optional: true
+      belongs_to :customs_transport_tariff, optional: true
+      belongs_to :esl_transport_tariff, optional: true
+      belongs_to :warehouse, optional: true
+      belongs_to :owner, class_name: 'Mks::Auth::User', optional: true
+
+      has_many :operation_documents
+
+      validates :operation_number, presence: true
+
+      delegate(:full_name, to: :declarant, prefix: true, allow_nil: true)
+      delegate(:name, to: :declaration_type, prefix: true, allow_nil: true)
+      delegate(:name, to: :transport_mode, prefix: true, allow_nil: true)
+      delegate(:name, to: :customs_office, prefix: true, allow_nil: true)
+      delegate(:name, to: :customs_office_unit, prefix: true, allow_nil: true)
+      delegate(:name, to: :country_of_origin, prefix: true, allow_nil: true)
+      delegate(:name, to: :acquisition_mode, prefix: true, allow_nil: true)
+      delegate(:name, to: :payment_term, prefix: true, allow_nil: true)
+      delegate(:name, to: :delivery_term, prefix: true, allow_nil: true)
+      delegate(:name, to: :container_arrangement, prefix: true, allow_nil: true)
+      delegate(:name, to: :warehouse, prefix: true, allow_nil: true)
+      delegate(:client, to: :offer_request, prefix: false, allow_nil: true)
+      delegate(:request_no, to: :offer_request, prefix: false, allow_nil: true)
+
+      scope :fresh, -> { where(:tasks_generated => false) }
+
+      def self.build(options = {})
+        Operation.new(options)
+      end
+    end
+  end
+end

data/app/models/logistics/core/operation_document.rb

@@ -0,0 +1,19 @@
+module Logistics
+  module Core
+    class OperationDocument < ApplicationRecord
+      mount_base64_uploader :file, DocumentUploader
+      belongs_to :operation
+      belongs_to :user, class_name: 'Mks::Auth::User', optional: true
+
+      scope :accepted, -> { where(:accepted => true) }
+      scope :remaining, -> { where(:accepted => false) }
+
+      validates :document, :original, :copy, :certified, :operation, presence: true
+
+      def user_name
+        self.user&.first_name.to_s + ' ' + self.user&.last_name.to_s
+      end
+
+    end
+  end
+end

data/app/models/logistics/core/operation_summary.rb

@@ -0,0 +1,8 @@
+module Logistics
+  module Core
+    class OperationSummary < ApplicationRecord
+      belongs_to :operation
+      validates :operation, presence: true, uniqueness: true
+    end
+  end
+end

data/app/models/logistics/core/operation_type.rb

@@ -0,0 +1,6 @@
+module Logistics
+  module Core
+    class OperationType < Lookup
+    end
+  end
+end

data/app/models/logistics/core/out_of_gauge_bb_rate.rb

@@ -0,0 +1,139 @@
+module Logistics
+  module Core
+    class OutOfGaugeBbRate < ApplicationRecord
+      belongs_to :break_bulk_unit
+      belongs_to :route
+
+      validates :length_from, :length_to, :height_from, :height_to, :width_from, :width_to,
+                :weight_from, :weight_to, :rate, :route_id, :margin, presence: true, allow_blank: false
+      validates :break_bulk_unit, uniqueness: {scope: [:length_from, :width_from, :height_from, :weight_from,
+                                                          :length_to, :width_to, :height_to, :weight_to, :route_id]}
+
+      validate :length_from_is_greater_than_length_to
+      validate :width_from_is_greater_than_width_to
+      validate :height_from_is_greater_than_height_to
+      validate :weight_from_is_greater_than_weight_to
+      validate :effective_date_is_greater_than_valid_until
+
+      def break_bulk_unit_name
+        if self.break_bulk_unit_id
+          break_bulk_unit = BreakBulkUnit.find self.break_bulk_unit_id
+          break_bulk_unit.name
+        else
+          nil
+        end
+      end
+
+      def route_name
+        if self.route_id
+          route = Route.find self.route_id
+          route.route_name
+        else
+          nil
+        end
+      end
+
+      def length
+        if self.length_from && self.length_to
+          self.length_from.to_s + ' - ' + self.length_to.to_s
+        else
+          nil
+        end
+      end
+
+      def width
+        if self.width_from && self.width_to
+          self.width_from.to_s + ' - ' + self.width_to.to_s
+        else
+          nil
+        end
+      end
+
+      def height
+        if self.height_from && self.height_to
+          self.height_from.to_s + ' - ' + self.height_to.to_s
+        else
+          nil
+        end
+      end
+
+      def weight
+        if self.weight_from && self.weight_to
+          self.weight_from.to_s + ' - ' + self.weight_to.to_s
+        else
+          nil
+        end
+      end
+
+      def self.fetch_all
+        result = []
+        OutOfGaugeBbRate.all.each do |out_of_gauge_bb_rate|
+          result.push({id: out_of_gauge_bb_rate.id,
+                       break_bulk_unit_id: out_of_gauge_bb_rate.break_bulk_unit_id,
+                       break_bulk_unit_name: out_of_gauge_bb_rate.break_bulk_unit_name,
+                       length: out_of_gauge_bb_rate.length,
+                       length_from: out_of_gauge_bb_rate.length_from,
+                       length_to: out_of_gauge_bb_rate.length_to,
+                       height: out_of_gauge_bb_rate.height,
+                       height_from: out_of_gauge_bb_rate.height_from,
+                       height_to: out_of_gauge_bb_rate.height_to,
+                       width: out_of_gauge_bb_rate.width,
+                       width_from: out_of_gauge_bb_rate.width_from,
+                       width_to: out_of_gauge_bb_rate.width_to,
+                       weight: out_of_gauge_bb_rate.weight,
+                       weight_from: out_of_gauge_bb_rate.weight_from,
+                       weight_to: out_of_gauge_bb_rate.weight_to,
+                       rate: out_of_gauge_bb_rate.rate,
+                       route_id: out_of_gauge_bb_rate.route_id,
+                       route_name: out_of_gauge_bb_rate.route_name,
+                       margin: out_of_gauge_bb_rate.margin,
+                       effective_date: out_of_gauge_bb_rate.effective_date,
+                       valid_until: out_of_gauge_bb_rate.valid_until })
+        end
+        return result
+      end
+
+      private
+
+      def length_from_is_greater_than_length_to
+        return if length_from.blank? || length_to.blank?
+
+        if length_to < length_from
+          errors.add(:length_from, "cannot be greater than length to")
+        end
+      end
+
+      def width_from_is_greater_than_width_to
+        return if width_from.blank? || width_to.blank?
+
+        if width_to < width_from
+          errors.add(:width_from, "cannot be greater than width to")
+        end
+      end
+
+      def height_from_is_greater_than_height_to
+        return if height_from.blank? || height_to.blank?
+
+        if height_to < height_from
+          errors.add(:height_from, "cannot be greater than height to")
+        end
+      end
+
+      def weight_from_is_greater_than_weight_to
+        return if weight_from.blank? || weight_to.blank?
+
+        if weight_to < weight_from
+          errors.add(:weight_from, "cannot be greater than weight to")
+        end
+      end
+
+      def effective_date_is_greater_than_valid_until
+        return if effective_date.blank? || effective_date.blank?
+
+        if valid_until <= effective_date
+          errors.add(:effective_date, "cannot be greater or equal to validity date")
+        end
+      end
+    end
+  end
+end