logistics_core 20.8.1

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

@@ -0,0 +1,9 @@
+require_dependency "application_controller"
+
+module Logistics
+  module Core
+    class CargoTypesController < ApplicationController
+      include LookupCommon
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module Logistics
+  module Core
+    class CarrierAgentsController < ApplicationController
+
+      def index
+        @carrierAgents = CarrierAgent.all
+        carrier_agent_array = []
+        @carrierAgents.each { |ca|
+          carrier_agent_array.push({ :id => ca.id, :name => ca.carrier.name+' '+ca.agent.name})
+        }
+        @response = Mks::Common::MethodResponse.new(true, nil, carrier_agent_array, nil, nil)
+        render json: @response
+      end
+
+      def create
+        carriers = params[:carrier_agents]
+        if carriers.count > 0
+          carrier = Carrier.find carriers[0][:carrier_id]
+        end
+        carriers.each do |c|
+          agent = Agent.find c[:agent_id]
+          carrier.agents << agent
+        end
+
+        carrier.save
+        response = Mks::Common::MethodResponse.new(true, 'Agent(s) associated successfully !')
+        render json: response
+      end
+
+      def carrier_agent_params
+        params.permit(:carrier_agents => [:carrier_id, :agent_id])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+module Logistics
+  module Core
+    class CarrierTypesController < ApplicationController
+      before_action :set_carrier_type, only: [:update]
+
+      def index
+        @carrier_types = CarrierType.all
+        carrier_type_array =[]
+        @carrier_types.each { |ct|
+          carrier_type_array.push({:id => ct.id, :code => ct.code, :name => ct.name, :description => ct.description })
+        }
+        @response = Mks::Common::MethodResponse.new(true, nil, carrier_type_array, nil, nil)
+        render json: @response
+      end
+
+      def create
+        @carrier_type = CarrierType.new(carrier_type_params)
+        if @carrier_type.valid?
+          @carrier_type.save
+          @response = Mks::Common::MethodResponse.new(true, 'Carrier type saved successfully !',nil,nil,nil);
+          render json: @response
+        else
+          errors = Mks::Common::Util.error_messages @carrier_type, 'CarrierType'
+          @response = Mks::Common::MethodResponse.new(false, nil, nil, errors, nil)
+          render json: @response
+        end
+      end
+
+      def update
+        if @carrier_type.update_attributes(carrier_type_params)
+          @carrier_type.save
+          @response = Mks::Common::MethodResponse.new(true, 'Carrier type updated successfully !', nil, nil, nil)
+          render json: @response
+        else
+          errors = Mks::Common::Util.error_messages @carrier_type, 'CarrierType'
+          @response = Mks::Common::MethodResponse.new(false, nil, nil, errors, nil)
+          render json: @response
+        end
+      end
+
+      private
+      # Use callbacks to share common setup or constraints between actions.
+      def set_carrier_type
+        @carrier_type = CarrierType.find(params[:id])
+      end
+
+      # Never trust parameters from the scary internet, only allow the white list through.
+      def carrier_type_params
+        params.require(:carrier_type).permit(:code, :name, :description)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+module Logistics
+  module Core
+    class CarriersController < ApplicationController
+      before_action :set_carrier, only: [:update]
+
+      def index
+        @carrier = Carrier.all
+        carrier_array =[]
+        @carrier.each { |c|
+          carrier_array.push({:id => c.id, :name => c.name, :email => c.email, :contact_telephone => c.contact_telephone,
+                              :carrier_type_id => c.carrier_type_id, :carrier_type_name => c.carrier_type.name})
+        }
+        @response = Mks::Common::MethodResponse.new(true, nil, carrier_array, nil, nil)
+        render json: @response
+      end
+
+      def create
+        @carrier = Carrier.new(carrier_params)
+        if @carrier.valid?
+          @carrier.save
+          @response = Mks::Common::MethodResponse.new(true, 'Carrier saved successfully !',nil,nil,nil);
+          render json: @response
+        else
+          errors = Mks::Common::Util.error_messages @carrier, 'Carrier'
+          @response = Mks::Common::MethodResponse.new(false, nil, nil, errors, nil)
+          render json: @response
+        end
+      end
+
+      def update
+        if @carrier.update_attributes(carrier_params)
+          @carrier.save
+          @response = Mks::Common::MethodResponse.new(true, 'Carrier updated successfully !', nil, nil, nil)
+          render json: @response
+        else
+          errors = Mks::Common::Util.error_messages @carrier, 'Carrier'
+          @response = Mks::Common::MethodResponse.new(false, nil, nil, errors, nil)
+          render json: @response
+        end
+      end
+
+      def engaged_agents
+        carrier_id = params[:carrier_id]
+        engaged_agents_id = CarrierAgent.select(:agent_id).where('carrier_id' =>carrier_id)
+        agents = Agent.where(id: engaged_agents_id)
+        @response = Mks::Common::MethodResponse.new(true, nil, agents, nil, nil)
+        render json: @response
+      end
+
+      def unengaged_agents
+        carrier_id = params[:carrier_id]
+        engaged_agents = CarrierAgent.select(:agent_id).where('carrier_id' => carrier_id)
+        unengaged_agents = Agent.where.not(id: engaged_agents)
+        @response = Mks::Common::MethodResponse.new(true, nil, unengaged_agents, nil, nil)
+        render json: @response
+      end
+
+      private
+      # Use callbacks to share common setup or constraints between actions.
+      def set_carrier
+        @carrier = Carrier.find(params[:id])
+      end
+
+      # Never trust parameters from the scary internet, only allow the white list through.
+      def carrier_params
+        params.require(:carrier).permit(:name, :email, :contact_telephone, :carrier_type_id)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+module Logistics
+  module Core
+    class ChargeableServiceIncrementsController < ApplicationController
+
+      # GET /chargeable_service_increments
+      # GET /chargeable_service_increments.json
+      def index
+        @chargeable_service_increments = ChargeableServiceIncrement.all
+        @response = {:success => true, :message => '', :data => @chargeable_service_increments}
+        render json: @response
+      end
+
+
+      # POST /chargeable_service_increments
+      # POST /chargeable_service_increments.json
+      def create
+        uoc_list = params[:increments]
+        cs_uoc = nil
+        if uoc_list.count > 0
+          cs_uoc = ChargeableServiceUnitOfCharge.find(uoc_list[0][:chargeable_service_unit_of_charge_id])
+        end
+
+        uoc_list.each do |uoc|
+          increment = ServiceIncrement.find(uoc[:service_increment_id])
+          cs_uoc.service_increments << increment
+        end
+        begin
+          cs_uoc.save
+          response = {:success => true, :message => 'Service Increment successfully'}
+        rescue => e
+          response = {:success => false, :message => e.message}
+        end
+        render json: response
+      end
+
+
+      private
+
+        # Never trust parameters from the scary internet, only allow the white list through.
+        def chargeable_service_increment_params
+          params.permit(:increments => [:chargeable_service_unit_of_charge_id, :service_increment_id])
+        end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,103 @@
+module Logistics
+  module Core
+    class ChargeableServiceUnitOfChargesController < ApplicationController
+      # GET /chargeable_service_unit_of_charges
+      # GET /chargeable_service_unit_of_charges.json
+      def index
+        @chargeable_service_unit_of_charges = ChargeableServiceUnitOfCharge.all
+        chargeable_service_units_array = []
+        @chargeable_service_unit_of_charges.each { |csuoc|
+          unit_of_charge_name = nil
+          unit_of_charge_id = nil
+          if csuoc.unit_of_charge_id != nil
+            unit_of_charge_id = csuoc.unit_of_charge_id
+            unit_of_charge_name = csuoc.unit_of_charge.name
+          end
+          chargeable_service_units_array.push({:id => csuoc.id, :service_delivery_unit_id => csuoc.service_delivery_unit_id,
+                                              :service_delivery_unit_name => csuoc.service_delivery_unit.name,
+                                              :chargeable_service_id => csuoc.chargeable_service_id,
+                                              :chargeable_service_name => csuoc.chargeable_service.name,
+                                              :unit_of_charge_id => unit_of_charge_id,
+                                              :unit_of_charge_name => unit_of_charge_name,
+                                              :has_increment => csuoc.has_increment,
+                                              :has_container_special_increment => csuoc.has_container_special_increment,
+                                              :has_content_special_increment => csuoc.has_content_special_increment})
+        }
+        response = Mks::Common::MethodResponse.new(true,nil,chargeable_service_units_array,nil,nil)
+        render json: response
+      end
+
+      # POST /chargeable_service_unit_of_charges
+      # POST /chargeable_service_unit_of_charges.json
+      def create
+        ChargeableServiceUnitOfCharge.generate_chargeable_service_units
+        response = Mks::Common::MethodResponse.new(true, 'Chargeable services and unit of charges associated successfully!',nil,nil,nil)
+        render json: response
+      end
+
+      def update_changes
+        if not params[:updated_unit_of_charges].nil?
+          updated_unit_of_charges = params[:updated_unit_of_charges]
+
+          updated_unit_of_charges.each { |unit_of_charge|
+            if unit_of_charge['unit_of_charge_id'].nil?
+              old_cs_uoc = ChargeableServiceUnitOfCharge.find(unit_of_charge['id'])
+              old_cs_uoc.has_increment = unit_of_charge['has_increment']
+              old_cs_uoc.has_container_special_increment = unit_of_charge['has_container_special_increment']
+              old_cs_uoc.has_content_special_increment = unit_of_charge['has_content_special_increment']
+              old_cs_uoc.save
+            else
+              old_cs_uoc = ChargeableServiceUnitOfCharge.find(unit_of_charge['id'])
+              old_cs_uoc.unit_of_charge_id = unit_of_charge['unit_of_charge_id']
+              old_cs_uoc.has_increment = unit_of_charge['has_increment']
+              old_cs_uoc.has_container_special_increment = unit_of_charge['has_container_special_increment']
+              old_cs_uoc.has_content_special_increment = unit_of_charge['has_content_special_increment']
+              old_cs_uoc.save
+            end
+          }
+        end
+        response = Mks::Common::MethodResponse.new(true, 'Chargeable services unit of charges updated successfully!')
+        render json: response
+      end
+
+      def increments
+        @cs_service_unit_of_charge = ChargeableServiceUnitOfCharge.find(params[:id])
+        service_increments = @cs_service_unit_of_charge.service_increments
+        response = Mks::Common::MethodResponse.new(true,nil,service_increments,nil,nil)
+        render json: response
+      end
+
+      def unassigned_increments
+        assigned_increments = ChargeableServiceIncrement.select('service_increment_id').where('chargeable_service_unit_of_charge_id'=>params[:id])
+        unassigned_increments = ServiceIncrement.where.not(id: assigned_increments)
+        response = Mks::Common::MethodResponse.new(true,nil,unassigned_increments,nil,nil)
+        render json: response
+      end
+
+      def get_sdus_by_cs_code
+        sdus = ChargeableServiceUnitOfCharge.get_sdus_with_specific_unit_of_charge(params[:code])
+        res = Mks::Common::MethodResponse.new(true, nil, sdus, nil, nil)
+        render json: res
+      end
+
+      def get_cs_by_sdu_and_code
+        cs = ChargeableServiceUnitOfCharge.get_chargeable_services_with_specific_sdu_and_uoc(params[:sdu_id], params[:code])
+        res = Mks::Common::MethodResponse.new(true, nil, cs, nil, nil)
+        render json: cs
+      end
+
+      def get_cs_by_sdu
+        result = ChargeableServiceUnitOfCharge.where(service_delivery_unit_id: params[:sdu_id])
+        data = ActiveModelSerializers::SerializableResource.new(result).as_json
+        response = Mks::Common::MethodResponse.new(true, nil, data, nil, nil)
+        render json: response
+      end
+
+      private
+
+        def chargeable_service_unit_of_charge_params
+          params.require(:chargeable_service_unit_of_charge).permit(:service_delivery_unit_id, :chargeable_service_id, :unit_of_charge_id, :has_increment, :has_container_special_increment, :has_content_special_increment)
+        end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+module Logistics
+  module Core
+    class ChargeableServicesController < ApplicationController
+      before_action :set_chargeable_service, only: [:update]
+
+      # GET /chargeable_services
+      # GET /chargeable_services.json
+      def index
+        @chargeable_services = ChargeableService.order(:order)
+        chargeable_service_array = []
+        @chargeable_services.each{ |chargeable_service|
+          transport_service_name = nil
+          if chargeable_service.transport_service_type_id != nil
+            transport_service_type = chargeable_service.transport_service_type.name
+          end
+          chargeable_service_array.push({:id => chargeable_service.id, :name => chargeable_service.name,
+                                        :code => chargeable_service.code,
+                                        :order => chargeable_service.order,
+                                        :chargeable_service_type_name => chargeable_service.chargeable_service_type.name,
+                                        :chargeable_service_type_id => chargeable_service.chargeable_service_type_id,
+                                        :transport_service_type_id => chargeable_service.transport_service_type_id,
+                                        :transport_service_type => transport_service_type})
+        }
+        @response = {:success => true, :message => '', :data => chargeable_service_array}
+        render json: @response
+      end
+
+      # POST /chargeable_services
+      # POST /chargeable_services.json
+      def create
+        @chargeable_service = ChargeableService.new(chargeable_service_params)
+
+        #respond_to do |format|
+          #format.json do
+            if @chargeable_service.valid?
+              @chargeable_service.save
+              @response = Mks::Common::MethodResponse.new(true, 'Chargeable service saved successfully!',nil, nil, nil )
+              render json: @response
+            else
+              errors = Mks::Common::Util.error_messages @chargeable_service, 'Chargeable service'
+              @response = Mks::Common::MethodResponse.new(false, nil, nil, errors, nil)
+              render json: @response
+            end
+          #end
+        #end
+      end
+
+      # PATCH/PUT /chargeable_services/1
+      # PATCH/PUT /chargeable_services/1.json
+      def update
+        @chargeable_service.update_attributes(chargeable_service_params)
+        if @chargeable_service.save
+          @response = Mks::Common::MethodResponse.new(true, 'Chargeable service updated successfully!', nil, nil, nil)
+          render json: @response
+        else
+          errors = Mks::Common::Util.error_messages @chargeable_service, 'Chargeable service'
+          @response = Mks::Common::MethodResponse.new(false, nil, nil, errors, nil)
+          render json: @response
+        end
+      end
+
+      private
+        # Use callbacks to share common setup or constraints between actions.
+        def set_chargeable_service
+          @chargeable_service = ChargeableService.find(params[:id])
+        end
+
+        # Never trust parameters from the scary internet, only allow the white list through.
+        def chargeable_service_params
+          params.require(:chargeable_service).permit(:code, :name, :order, :transport_service_type_id,
+                                                     :chargeable_service_type_id)
+        end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,7 @@
+class ClientContractsController < ApplicationController
+  def get_contract_per_client
+    result = Mks::ClientContract.get_contract_per_client(params[:client_id])
+    @response = Mks::Common::MethodResponse.new(true, nil, result, nil, nil)
+    render json: @response
+  end
+end

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

@@ -0,0 +1,27 @@
+require_dependency 'application_controller'
+
+module Logistics
+  module Core
+    class ClientsController < ApplicationController
+
+      include ControllerCommon
+      include LookupList
+
+      def index
+        clients = Client.includes(:client_category, :country).order(:name)
+        data = ApplicationRecord.as_json(clients)
+        response = Mks::Common::MethodResponse.new(true, nil, data, nil)
+        render json: response
+      end
+
+
+      private
+
+      def model_params
+        params.require(:client).permit(:name, :postal_code, :city, :country_id, :telephone, :fax, :email, :license, :tin,
+                                       :client_category_id, :code)
+      end
+
+    end
+  end
+end