logistics_core 20.8.1

data/app/controllers/logistics/core/document_type_categories_controller.rb

@@ -0,0 +1,11 @@
+module Logistics
+  module Core
+    class DocumentTypeCategoriesController < ApplicationController
+      def index
+        document_type_categories = DocumentTypeCategory.all
+        response = Mks::Common::MethodResponse.new(true, nil, document_type_categories, nil, nil)
+        render json: response
+      end
+    end
+  end
+end

data/app/controllers/logistics/core/document_type_origins_controller.rb

@@ -0,0 +1,11 @@
+module Logistics
+  module Core
+    class DocumentTypeOriginsController < ApplicationController
+      def index
+        document_type_origins = DocumentTypeOrigin.all
+        response = Mks::Common::MethodResponse.new(true, nil, document_type_origins, nil, nil)
+        render json: response
+      end
+    end
+  end
+end

data/app/controllers/logistics/core/document_types_controller.rb

@@ -0,0 +1,60 @@
+module Logistics
+  module Core
+    class DocumentTypesController < ApplicationController
+      before_action :set_document_type, only: [:update]
+
+      # GET /document_types
+      # GET /document_types.json
+      def index
+        document_types = DocumentType.includes(:document_type_category, :document_type_origin)
+        data = ApplicationRecord.as_json(document_types)
+        response = Mks::Common::MethodResponse.new(true, nil, data, nil, nil)
+        render json: response
+      end
+
+      def lookup
+        document_types = DocumentType.all.to_lookup
+        response = Mks::Common::MethodResponse.new(true, nil, document_types, nil, nil)
+        render json: response
+      end
+
+      # POST /document_types
+      # POST /document_types.json
+      def create
+        @document_type = DocumentType.new(document_type_params)
+
+        if @document_type.save
+          response = Mks::Common::MethodResponse.new(true, "Document Type information saved successfully!", @document_type, nil, nil)
+        else
+          errors = Mks::Common::Util.error_messages @document_type, "Document Type"
+          response = Mks::Common::MethodResponse.new(false, nil, nil, errors, nil)
+        end
+        render json: response
+      end
+
+      # PATCH/PUT /document_types/1
+      # PATCH/PUT /document_types/1.json
+      def update
+        @document_type = DocumentType.find(params[:id])
+
+        if @document_type.update(document_type_params)
+          response = Mks::Common::MethodResponse.new(true, "Document Type information updated successfully!", @document_type, nil, nil)
+        else
+          errors = Mks::Common::Util.error_messages @document_type, "Document Type"
+          response = Mks::Common::MethodResponse.new(false, nil, nil, errors, nil)
+        end
+        render json: response
+      end
+
+      private
+
+      def set_document_type
+        @document_type = DocumentType.find(params[:id])
+      end
+
+      def document_type_params
+        params.require(:document_type).permit(:code, :name, :description, :document_type_category_id, :document_type_origin_id)
+      end
+    end
+  end
+end

data/app/controllers/logistics/core/entry_points_controller.rb

@@ -0,0 +1,7 @@
+module Logistics
+  module Core
+    class EntryPointsController < ApplicationController
+      include LookupCommon
+    end
+  end
+end

data/app/controllers/logistics/core/esl_transport_tariff_rates_controller.rb

@@ -0,0 +1,52 @@
+module Logistics
+  module Core
+    class EslTransportTariffRatesController < ApplicationController
+      before_action :set_esl_transport_tariff_rate, only: [:update]
+
+      def index
+        esl_transport_tariff_rates = EslTransportTariffRate.all
+        data = ActiveModelSerializers::SerializableResource.new(esl_transport_tariff_rates).as_json
+        response = Mks::Common::MethodResponse.new(true, nil, data, nil, nil)
+        render json: response
+      end
+
+      def filter_by_tariff
+        esl_transport_tariff_rates = EslTransportTariffRate.where(:esl_transport_tariff_id => params[:id])
+        data = ActiveModelSerializers::SerializableResource.new(esl_transport_tariff_rates).as_json
+        response = Mks::Common::MethodResponse.new(true, nil, data, nil, nil)
+        render json: response
+      end
+
+      def create
+        @esl_transport_tariff_rate = EslTransportTariffRate.new(esl_transport_tariff_rate_params)
+        if @esl_transport_tariff_rate.save
+          response = Mks::Common::MethodResponse.new(true, 'ESL transport tariff rate saved successfully!', @esl_transport_tariff_rate, nil, nil)
+        else
+          errors = Mks::Common::Util.error_messages @esl_transport_tariff_rate, 'ESL transport tariff rate'
+          response = Mks::Common::MethodResponse.new(false, nil, nil, errors, nil)
+        end
+        render json: response
+      end
+
+      def update
+        if @esl_transport_tariff_rate.update(esl_transport_tariff_rate_params)
+          response = Mks::Common::MethodResponse.new(true, "ESL transport tariff rate updated successfully!", @esl_transport_tariff_rate, nil, nil)
+        else
+          errors = Mks::Common::Util.error_messages @esl_transport_tariff_rate, "ESL transport tariff rate"
+          response = Mks::Common::MethodResponse.new(false, nil, nil, errors, nil)
+        end
+        render json: response
+      end
+
+      private
+
+      def set_esl_transport_tariff_rate
+        @esl_transport_tariff_rate = EslTransportTariffRate.find(params[:id])
+      end
+
+      def esl_transport_tariff_rate_params
+        params.require(:esl_transport_tariff_rate).permit(:esl_transport_tariff_id, :qt_from, :qt_to, :rate)
+      end
+    end
+  end
+end

data/app/controllers/logistics/core/esl_transport_tariffs_controller.rb

@@ -0,0 +1,45 @@
+module Logistics
+  module Core
+    class EslTransportTariffsController < ApplicationController
+      before_action :set_esl_transport_tariff, only: [:update]
+
+      def index
+        esl_transport_tariffs = EslTransportTariff.includes(:route)
+        data = ApplicationRecord.as_json(esl_transport_tariffs)
+        response = Mks::Common::MethodResponse.new(true, nil, data, nil, nil)
+        render json: response
+      end
+
+      def create
+        @esl_transport_tariff = EslTransportTariff.new(esl_transport_tariff_params)
+        if @esl_transport_tariff.save
+          response = Mks::Common::MethodResponse.new(true, 'ESL transport tariff saved successfully!', @esl_transport_tariff, nil, nil)
+        else
+          errors = Mks::Common::Util.error_messages @esl_transport_tariff, 'ESL transport tariff'
+          response = Mks::Common::MethodResponse.new(false, nil, nil, errors, nil)
+        end
+        render json: response
+      end
+
+      def update
+        if @esl_transport_tariff.update(esl_transport_tariff_params)
+          response = Mks::Common::MethodResponse.new(true, "ESL transport tariff updated successfully!", @esl_transport_tariff, nil, nil)
+        else
+          errors = Mks::Common::Util.error_messages @esl_transport_tariff, "ESL transport tariff"
+          response = Mks::Common::MethodResponse.new(false, nil, nil, errors, nil)
+        end
+        render json: response
+      end
+
+      private
+
+      def set_esl_transport_tariff
+        @esl_transport_tariff = EslTransportTariff.find(params[:id])
+      end
+
+      def esl_transport_tariff_params
+        params.require(:esl_transport_tariff).permit(:route_id, :storage_point)
+      end
+    end
+  end
+end

data/app/controllers/logistics/core/freight_ton_storage_rates_controller.rb

@@ -0,0 +1,45 @@
+module Logistics
+  module Core
+    class FreightTonStorageRatesController < ApplicationController
+      def index
+        rate_period_id = params[:rate_period_id]
+        @freight_ton_storage_rates = FreightTonStorageRate.where('warehouse_rate_period_id' => rate_period_id)
+        freight_ton_storage_rate_array =[]
+        @freight_ton_storage_rates.each { |fsr|
+          freight_ton_storage_rate_array.push({:id => fsr.id,
+                                                :transaction_name => fsr.transaction_type.name,
+                                                :content_type_name => fsr.content_type.name,
+                                                :rate => fsr.rate, :effective_date => fsr.effective_date
+                                               })
+        }
+        @response = Mks::Common::MethodResponse.new(true, nil, freight_ton_storage_rate_array, nil, nil)
+        render json: @response
+      end
+
+      def create
+        FreightTonStorageRate.generate_storage_rate params[:rate_period_id], params[:effective_date]
+        response = Mks::Common::MethodResponse.new(true, 'Freight ton storage rate matrix generated successfully !', nil, nil, nil)
+        render json: response
+      end
+
+      def update
+        freight_ton_storage_rates = params[:freight_ton_storage_rates]
+        freight_ton_storage_rates.each { |fsr|
+          old_freight_ton_storage_rate = FreightTonStorageRate.find(fsr['id'])
+          old_freight_ton_storage_rate.rate = fsr['rate']
+          old_freight_ton_storage_rate.effective_date = fsr['effective_date']
+          old_freight_ton_storage_rate.save
+        }
+        @response = Mks::Common::MethodResponse.new(true, 'Freight ton storage rate(s) updated successfully !', nil, nil, nil)
+        render json: @response
+      end
+
+      private
+
+      # Never trust parameters from the scary internet, only allow the white list through.
+      def freight_ton_storage_rate_params
+        params.require(:freight_ton_storage_rate).permit(:warehouse_rate_period_id, :rate, :effective_date, :transaction_type_id)
+      end
+    end
+  end
+end

data/app/controllers/logistics/core/increment_rates_controller.rb

@@ -0,0 +1,66 @@
+module Logistics
+  module Core
+    class IncrementRatesController < ApplicationController
+      before_action :set_increment_rate, only: [:update]
+
+      # GET /increment_rates
+      # GET /increment_rates.json
+      def index
+        service_increment_id = params[:service_increment_id]
+        service_increment = ServiceIncrement.find(service_increment_id)
+        @increment_rates = service_increment.increment_rates
+        @response = {:success => true, :message => '', :data => @increment_rates}
+        render json: @response
+      end
+
+
+      # POST /increment_rates
+      # POST /increment_rates.json
+      def create
+        @increment_rate = IncrementRate.new(increment_rate_params)
+        if @increment_rate.valid?
+          service_increment_id = params[:service_increment_id]
+          service_increment = ServiceIncrement.find(service_increment_id)
+          service_increment.increment_rates << @increment_rate
+          @response = Mks::Common::MethodResponse.new(true, 'Increment rate recorded successfully', nil, nil, nil)
+          render json: @response
+        else
+          errors = Mks::Common::Util.error_messages @increment_rate, 'IncrementRate'
+          @response = Mks::Common::MethodResponse.new(false, nil, nil, errors, nil)
+          render json: @response
+        end
+      end
+
+      # PATCH/PUT /increment_rates/1
+      # PATCH/PUT /increment_rates/1.json
+      def update
+        if @increment_rate.update_attributes(increment_rate_params)
+          @increment_rate.save
+          @response = Mks::Common::MethodResponse.new(true,'Increment rate updated successfully',nil, nil, nil)
+          render json: @response
+        else
+          errors = Mks::Common::Util.error_messages @increment_rate, 'IncrementRate'
+          @response = Mks::Common::MethodResponse.new(false, nil, nil, errors, nil)
+          render json: @response
+        end
+      end
+
+      def get_all
+        @increment_rates = IncrementRate.all
+        @response = {:success => true, :message => '', :data =>@increment_rates}
+        render json: @response
+      end
+
+      private
+        # Use callbacks to share common setup or constraints between actions.
+        def set_increment_rate
+          @increment_rate = IncrementRate.find(params[:id])
+        end
+
+        # Never trust parameters from the scary internet, only allow the white list through.
+        def increment_rate_params
+          params.require(:increment_rate).permit(:percent, :effective_date, :service_increment_id)
+        end
+    end
+  end
+end

data/app/controllers/logistics/core/item_rates_controller.rb

@@ -0,0 +1,47 @@
+module Logistics
+  module Core
+    class ItemRatesController < ApplicationController
+
+      def index
+        @items_rate = ItemRate.all
+        items_rate_array =[]
+        @items_rate.each { |ir|
+          items_rate_array.push({:id => ir.id, :service_delivery_unit_name => ir.chargeable_service_unit_of_charge.service_delivery_unit.name,
+                                :transaction_type_name => ir.transaction_type.name,
+                                :chargeable_service_name => ir.chargeable_service_unit_of_charge.chargeable_service.name,
+                                :minimum_quantity => ir.minimum_quantity, :rate => ir.rate, :margin => ir.margin})
+        }
+        @response = Mks::Common::MethodResponse.new(true,nil,items_rate_array,nil,nil);
+        render json: @response
+      end
+
+      def create
+        effective_date = params[:effective_date]
+        ItemRate.generate_rate_for_item_services(effective_date)
+        @response = Mks::Common::MethodResponse.new(true, 'Rate generated successfully !', nil, nil, nil)
+        render json: @response
+      end
+
+      def update
+        service_rates = params[:updated_service_rates]
+        service_rates.each { |service_rate|
+          old_service_rate = ItemRate.find(service_rate['id'])
+          old_service_rate.minimum_quantity = service_rate['minimum_quantity']
+          old_service_rate.rate = service_rate['rate']
+          old_service_rate.margin = service_rate['margin']
+          old_service_rate.effective_date = service_rate['effective_date']
+          old_service_rate.save
+        }
+        @response = Mks::Common::MethodResponse.new(true, 'Rate updated successfully !', nil,nil,nil)
+        render json: @response
+      end
+
+      private
+
+      # Never trust parameters from the scary internet, only allow the white list through.
+      def item_rate_params
+        params.require(:item_rate).permit(:chargeable_service_unit_of_charge_id, :effective_date, :minimum_quantity, :rate)
+      end
+    end
+  end
+end

data/app/controllers/logistics/core/kilogram_minimum_rates_controller.rb

@@ -0,0 +1,53 @@
+module Logistics
+  module Core
+    class KilogramMinimumRatesController < ApplicationController
+      before_action :set_kilogram_minimum_rate, only: [:update]
+
+      def index
+        kilogram_minimum_rates = KilogramMinimumRate.all
+        data = ActiveModelSerializers::SerializableResource.new(kilogram_minimum_rates).as_json
+        render json: data
+
+      end
+
+      def create
+        kilogram_minimum_rate = KilogramMinimumRate.new(kilogram_minimum_rate_params)
+        cs_uoc = ChargeableServiceUnitOfCharge.where(service_delivery_unit_id: params[:kilogram_minimum_rate][:service_delivery_unit_id],
+                                                     chargeable_service_id: params[:kilogram_minimum_rate][:chargeable_service_id])
+        kilogram_minimum_rate.chargeable_service_unit_of_charge_id = cs_uoc[0].id unless cs_uoc.empty?
+        if kilogram_minimum_rate.valid?
+          kilogram_minimum_rate.save
+          res = Mks::Common::MethodResponse.new(true, 'Minimum rate set successfully !', nil, nil, nil)
+        else
+          errors = Mks::Common::Util.error_messages(kilogram_minimum_rate, 'Kilogram Minimum Rate')
+          res = Mks::Common::MethodResponse.new(false, nil, nil, errors, nil)
+        end
+        render json: res
+      end
+
+      def update
+        cs_uoc = ChargeableServiceUnitOfCharge.where(service_delivery_unit_id: params[:kilogram_minimum_rate][:service_delivery_unit_id],
+                                                     chargeable_service_id: params[:kilogram_minimum_rate][:chargeable_service_id])
+        @kilogram_minimum_rate.chargeable_service_unit_of_charge_id = cs_uoc[0].id unless cs_uoc.empty?
+        if @kilogram_minimum_rate.update(kilogram_minimum_rate_params)
+          res = Mks::Common::MethodResponse.new(true, 'Minimum rate updated successfully !', nil, nil)
+        else
+          errors = Mks::Common::Util.error_messages(@kilogram_minimum_rate, 'Kilogram Minimum Rate')
+          res = Mks::Common::MethodResponse.new(false, nil, nil, errors, nil)
+        end
+        render json: res
+      end
+
+
+      private
+
+      def kilogram_minimum_rate_params
+        params.require('kilogram_minimum_rate').permit(:transaction_type_id, :minimum_price)
+      end
+
+      def set_kilogram_minimum_rate
+        @kilogram_minimum_rate = KilogramMinimumRate.find(params[:id])
+      end
+    end
+  end
+end

data/app/controllers/logistics/core/kilogram_rates_controller.rb

@@ -0,0 +1,71 @@
+module Logistics
+  module Core
+    class KilogramRatesController < ApplicationController
+      before_action :set_kilogram_rate, only: [:update]
+
+      def index
+        @kilogram_rates = KilogramRate.all
+        kilogram_rates_array =[]
+        @kilogram_rates.each do |kg|
+          cs_id = kg.chargeable_service_unit_of_charge&.chargeable_service_id
+          cs_name = kg.chargeable_service_unit_of_charge&.chargeable_service&.name
+          sdu_id = kg.chargeable_service_unit_of_charge&.service_delivery_unit_id
+          sdu_name = kg.chargeable_service_unit_of_charge&.service_delivery_unit&.name
+          transaction_name = kg.transaction_type&.name
+          kilogram_rates_array.push({id: kg.id, high: kg.high, low: kg.low, medium: kg.medium, effective_date: kg.effective_date,
+                                      from: kg.from, to: kg.to, margin: kg.margin, chargeable_service_id: cs_id,
+                                      chargeable_service_name: cs_name, service_delivery_unit_id: sdu_id,
+                                      service_delivery_unit_name: sdu_name, transaction_type_id: kg.transaction_type_id,
+                                      transaction_type_name: transaction_name
+                                   })
+        end
+        @response = {:success => true, :message => '', :data => kilogram_rates_array}
+        render json: @response
+      end
+
+      # POST /air_weigh_bills
+      # POST /air_weigh_bills.json
+      def create
+        cs_uoc = ChargeableServiceUnitOfCharge.where(service_delivery_unit_id: params[:kilogram_rate][:service_delivery_unit_id],
+                                                     chargeable_service_id: params[:kilogram_rate][:chargeable_service_id])
+        @kilogram_rate = KilogramRate.new(kilogram_rate_params)
+        @kilogram_rate.chargeable_service_unit_of_charge_id = cs_uoc[0].id unless cs_uoc.empty?
+        if @kilogram_rate.valid?
+          @kilogram_rate.save
+          @response = Mks::Common::MethodResponse.new(true, 'Kilogram rate saved successfully !',nil,nil,nil);
+          render json: @response
+        else
+          @response = {:success => false, :message => 'Error saving kilogram rate', :data => []}
+          render json: @response
+        end
+      end
+
+      # PATCH/PUT /air_weigh_bills/1
+      # PATCH/PUT /air_weigh_bills/1.json
+      def update
+        cs_uoc = ChargeableServiceUnitOfCharge.where(service_delivery_unit_id: params[:kilogram_rate][:service_delivery_unit_id],
+                                                     chargeable_service_id: params[:kilogram_rate][:chargeable_service_id])
+        @kilogram_rate.chargeable_service_unit_of_charge_id = cs_uoc[0].id unless cs_uoc.empty?
+        if @kilogram_rate.update_attributes(kilogram_rate_params)
+          @kilogram_rate.save
+          @response = {:success => true, :message => 'Kilogram rate updated successfully', :data => []}
+          render json: @response
+        else
+          @response = {:success => false, :message => 'Error updating kilogram rate', :data => []}
+          render json: @response
+        end
+      end
+
+      private
+      # Use callbacks to share common setup or constraints between actions.
+      def set_kilogram_rate
+        @kilogram_rate = KilogramRate.find(params[:id])
+      end
+
+      # Never trust parameters from the scary internet, only allow the white list through.
+      def kilogram_rate_params
+        params.require(:kilogram_rate).permit(:from, :to, :low, :medium, :high, :margin, :transaction_type_id)
+      end
+    end
+  end
+end