logistics_core 20.8.1

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

@@ -0,0 +1,133 @@
+module Logistics
+  module Core
+    class OfferRequestsController < ApplicationController
+      protect_from_forgery with: :null_session
+      before_action :set_offer_request, only: [:update]
+      def index
+        offer_request = OfferRequest.new
+        result = offer_request.get_bill_of_loading_by_status_and_user(params[:status], session[:user_id])
+        data = ActiveModelSerializers::SerializableResource.new(result).as_json
+        response = Mks::Common::MethodResponse.new(true, nil, data, nil, nil)
+        render json: response
+      end
+
+      def get_request_by_status
+        offer_request = OfferRequest.new
+        result = offer_request.get_bill_of_loading_by_status(params[:status])
+        data = ActiveModelSerializers::SerializableResource.new(result).as_json
+        response = Mks::Common::MethodResponse.new(true, nil, data, nil, nil)
+        render json: response
+      end
+
+      def get_requests_with_additional_service
+        offer_request = OfferRequest.new
+        result = offer_request.get_request_with_additional_service
+        data = ActiveModelSerializers::SerializableResource.new(result).as_json
+        response = Mks::Common::MethodResponse.new(true, nil, data, nil, nil)
+        render json: response
+      end
+
+      def get_request_by_security_status
+        offer_request = OfferRequest.new
+        result = offer_request.get_requests_by_security_status(params[:security_status])
+        data = ActiveModelSerializers::SerializableResource.new(result).as_json
+        response = Mks::Common::MethodResponse.new(true, nil, data, nil, nil)
+        render json: response
+      end
+
+      def new
+      
+      end
+
+      def create
+        offer_request = OfferRequest.new(offer_request_params)
+        if offer_request.valid?
+          offer_request.status = 'draft'
+          offer_request.user_id = session[:user_id]
+          offer_request.request_no = ReferenceNumber.ref_num
+          offer_request.save
+          response = Mks::Common::MethodResponse.new(true, 'Request capture successfully!', nil, nil, nil)
+        else
+          errors = Mks::Common::Util.error_messages offer_request, 'Offer Request'
+          response = Mks::Common::MethodResponse.new(false, nil, nil, errors, nil)
+        end
+        render json: response
+      end
+
+      def update
+        if @offer_request.update(offer_request_params)
+          response = Mks::Common::MethodResponse.new(true, 'Request updated successfully !', nil, nil, nil)
+        else
+          errors = Mks::Common::Util.error_messages @offer_request, 'Offer Request'
+          response = Mks::Common::MethodResponse.new(false, nil, nil, errors, nil)
+        end
+        render json: response
+      end
+
+      def change_status
+        status = params[:status]
+        offer_request = OfferRequest.find(params[:offer_request_id])
+        offer_request.status = status
+        if offer_request.save
+          response = Mks::Common::MethodResponse.new(true, "Status changed to #{status}!", nil, nil, nil)
+        else
+          response = Mks::Common::MethodResponse.new(false, "Status change failure!", nil, nil, nil)
+        end
+        render json: response
+      end
+
+      def change_sent_status
+        offer_request = OfferRequest.find(params[:offer_request_id])
+        offer_request.is_sent = true
+        offer_request.sent_date = Date.today
+        offer_request.save
+        response = Mks::Common::MethodResponse.new(true, 'Status changed to sent !',nil,nil,nil)
+        render json: response
+      end
+
+      def set_security_status
+        offer_request = OfferRequest.find(params[:offer_request_id])
+        offer_request.security_status = params[:security_status]
+        offer_request.save
+        response = Mks::Common::MethodResponse.new(true, "Security status changed to #{params[:security_status]} !",nil,nil,nil)
+        render json: response
+      end
+
+      def update_storage_detail
+        offer_request = OfferRequest.find(params[:offer_request_id])
+        offer_request.arrival_date = params[:arrival_date]
+        offer_request.days_until_loaded = params[:days_until_loaded]
+        offer_request.warehouse_id = params[:warehouse_id]
+        offer_request.save
+        @response = Mks::Common::MethodResponse.new(true, 'Storage data captured successfully !',nil, nil, nil)
+        render json: @response
+      end
+
+      def update_demurage_detail
+        offer_request = OfferRequest.find(params[:offer_request_id])
+        offer_request.carrier_id = params[:carrier_id]
+        offer_request.agent_id = params[:agent_id]
+        offer_request.arrival_date = params[:arrival_date]
+        offer_request.days_before_returning_container = params[:days_before_returning_container]
+        offer_request.save
+        @response = Mks::Common::MethodResponse.new(true, 'Demurage data captured successfully !',nil, nil, nil)
+        render json: @response
+      end
+
+      private
+
+      def set_offer_request
+        @offer_request = OfferRequest.find(params[:id])
+      end
+
+      def offer_request_params
+        params.require('offer_request').permit(:client_id, :transaction_type_id, :operation_type_id, :freight_forwarding,
+                                               :customs_clearing, :transport, :security_status,
+                                               :request_no, :communication_channel_id, :source_detail, :point_of_recipient,
+                                               :date_of_recipient,:general_remark, :rate_level, :no_of_items, :no_of_convoy,
+                                               :is_bulk,:contract_id,:remark)
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,67 @@
+module Logistics
+  module Core
+    class OperationDocumentsController < ApplicationController
+      before_action :set_operation_document, only: [:update, :destroy]
+
+      def index
+        operation_documents = OperationDocument.where(:operation_id => params[:id])
+        data = ApplicationRecord.as_json(operation_documents)
+        response = Mks::Common::MethodResponse.new(true, nil, data, nil, nil)
+        render json: response
+      end
+
+      def create
+        @operation_document = OperationDocument.new(operation_document_params)
+        if @operation_document.save
+          response = Mks::Common::MethodResponse.new(true, 'Operation document saved successfully!', @operation_document, nil, nil)
+        else
+          errors = Mks::Common::Util.error_messages @operation_document, 'Operation document'
+          response = Mks::Common::MethodResponse.new(false, nil, nil, errors, nil)
+        end
+        render json: response
+      end
+
+      def update
+        if @operation_document.update(operation_document_params)
+          response = Mks::Common::MethodResponse.new(true, "Operation document updated successfully!", @operation_document, nil, nil)
+        else
+          errors = Mks::Common::Util.error_messages @operation_document, "Operation document"
+          response = Mks::Common::MethodResponse.new(false, nil, nil, errors, nil)
+        end
+        render json: response
+      end
+
+      def accept
+        document = OperationDocument.find(params[:id])
+        document.is_accepted = true
+        document.user_id = params[:user_id]
+        document.date_accepted = DateTime.now.to_date
+        document.save
+        response = Mks::Common::MethodResponse.new(true, "Operation document accepted!", document, nil, nil)
+        render json: response
+      end
+
+      def download
+        document = OperationDocument.find(params[:id])
+        render json: Base64.encode64(document.file.read)
+      end
+
+      def destroy
+        @operation_document.destroy
+        response = Mks::Common::MethodResponse.new(true, "Operation document deleted!", nil, nil, nil)
+        render json: response
+      end
+
+      private
+
+      def set_operation_document
+        @operation_document = OperationDocument.find(params[:id])
+      end
+
+      def operation_document_params
+        params.require(:operation_document).permit(:operation_id, :document, :applicant, :original, :copy, :certified,
+                                                   :source, :is_mandatory, :is_accepted, :file, :user_id, :date_accepted)
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,102 @@
+module Logistics
+  module Core
+    class OperationsController < ApplicationController
+      # include ControllerCommon
+      before_action :set_service, only: %i[assign]
+
+      def index
+        operations = Operation.includes(:declarant, :declaration_type, :transport_mode,
+                                        :customs_office, :customs_office_unit, :country_of_origin,
+                                        :acquisition_mode, :payment_term, :delivery_term,
+                                        :container_arrangement, :customs_transport_tariff,
+                                        :esl_transport_tariff, :warehouse, :owner, :offer_request).order('id DESC')
+        data = ApplicationRecord.as_json(operations)
+        response = { success: true, data: data }
+        render json: response
+      end
+
+      def create
+        service = OperationService.new
+        result, @operation = service.save(model_params)
+        if result
+          response = Mks::Common::MethodResponse.new(true, 'Operation saved successfully!', @operation, nil, nil)
+        else
+          errors = Mks::Common::Util.error_messages @operation, 'Operation'
+          response = Mks::Common::MethodResponse.new(false, nil, nil, errors, nil)
+        end
+        render json: response
+      end
+
+      def update
+        operation = Operation.find(params[:id])
+        update_attributes(operation, model_params)
+        if operation.save
+          response = Mks::Common::MethodResponse.new(true, 'Operation updated successfully!', nil, nil, nil)
+        else
+          response = Mks::Common::MethodResponse.new(false, nil, nil, ['Operation update failed!'], nil)
+        end
+        render json: response
+      end
+
+      def fresh
+        operations = Operation.fresh
+        data = ApplicationRecord.as_json(operations)
+        response = Mks::Common::MethodResponse.new(true, nil, data, nil, nil)
+        render json: response
+      end
+
+      def filter_fresh_by_client
+        operations = Operation.joins(:offer_request).fresh.where('logistics_core_offer_requests.client_id = ?', params[:id])
+        data = ApplicationRecord.as_json(operations)
+        response = Mks::Common::MethodResponse.new(true, nil, data, nil, nil)
+        render json: response
+      end
+
+      def assigned
+        operations = Operation.where.not(owner_id: nil)
+        data = ApplicationRecord.as_json(operations)
+        response = Mks::Common::MethodResponse.new(true, nil, data, nil, nil)
+        render json: response
+      end
+
+      def unassigned
+        operations = Operation.where(owner_id: nil)
+        data = ApplicationRecord.as_json(operations)
+        response = Mks::Common::MethodResponse.new(true, nil, data, nil, nil)
+        render json: response
+      end
+
+      def assign
+        response = @service.assign_owner(assign_params[:payload])
+        render json: response
+      end
+
+      private
+
+      def update_attributes(op, params)
+        params.each do |k, v|
+          op[k] = v
+        end
+        op
+      end
+
+      def set_service
+        @service = OperationService.new
+      end
+
+      def assign_params
+        params.permit(payload: [:owner_id, op_ids: []])
+      end
+
+      def model_params
+        params.require(:operation).permit(:operation_number, :contract_number, :is_new_customer, :status, :load_level,
+                                          :offer_request_id, :declarant_id, :declaration_type_id, :transport_mode_id,
+                                          :customs_office_id, :customs_office_unit_id, :country_of_origin_id, :t_number,
+                                          :acquisition_mode_id, :payment_term_id, :delivery_term_id, :tin_number,
+                                          :container_arrangement_id, :customs_transport_tariff_id,  :transfer_tin_no,
+                                          :warehouse_id, :trade_license_number, :esl_transport_tariff_id, :is_transfer,
+                                          :investment_license_number, :transfer_name, :transport_modality)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+require_dependency 'application_controller'
+
+module Logistics
+  module Core
+    class OutOfGaugeBbRatesController < ApplicationController
+      protect_from_forgery with: :null_session
+      before_action :set_out_of_gauge_bb_rate, only: [:update]
+
+      # GET /out_of_gauge_bb_rates
+      # GET /out_of_gauge_bb_rates.json
+      def index
+        out_of_gauge_bb_rates = OutOfGaugeBbRate.fetch_all
+        response = Mks::Common::MethodResponse.new(true, nil, out_of_gauge_bb_rates, nil, nil)
+        render json: response
+      end
+
+      def search_route
+        route_id = params[:route][:id]
+        route = Route.find(route_id)
+        response = Mks::Common::MethodResponse.new(true, nil, route.margin, nil, nil)
+        render json: response
+      end
+
+      # POST /out_of_gauge_bb_rates
+      # POST /out_of_gauge_bb_rates.json
+      def create
+        out_of_gauge_bb_rate = OutOfGaugeBbRate.new(out_of_gauge_bb_rate_params)
+        margin = out_of_gauge_bb_rate_params[:margin]
+        rate = out_of_gauge_bb_rate_params[:rate]
+        new_rate = rate + (rate * margin/100)
+        out_of_gauge_bb_rate.rate = new_rate
+
+        if out_of_gauge_bb_rate.save
+          response = Mks::Common::MethodResponse.new(true, "Break Bulk Out of Gauge rate information saved successfully!", out_of_gauge_bb_rate, nil, nil)
+        else
+          errors = Mks::Common::Util.error_messages out_of_gauge_bb_rate,"Break Bulk Out of Gauge Rate"
+          response = Mks::Common::MethodResponse.new(false, nil, nil, errors, nil)
+        end
+        render json: response
+      end
+
+      # PATCH/PUT /out_of_gauge_bb_rates/1
+      # PATCH/PUT /out_of_gauge_bb_rates/1.json
+      def update
+        out_of_gauge_bb_rate = OutOfGaugeBbRate.find(params[:id])
+        margin = out_of_gauge_bb_rate_params[:margin]
+        if margin > out_of_gauge_bb_rate.margin
+          rate = out_of_gauge_bb_rate_params[:rate]
+          margin = margin - out_of_gauge_bb_rate.margin
+          new_rate = rate + (rate * margin/100)
+          params[:out_of_gauge_bb_rate][:rate] = new_rate
+        end
+
+        if out_of_gauge_bb_rate.update(out_of_gauge_bb_rate_params)
+          response = Mks::Common::MethodResponse.new(true, "Break Bulk Out of Gauge rate information updated successfully!", out_of_gauge_bb_rate, nil, nil)
+        else
+          errors = Mks::Common::Util.error_messages out_of_gauge_bb_rate,"Break Bulk Out of Gauge Rate"
+          response = Mks::Common::MethodResponse.new(false, nil, nil, errors, nil)
+        end
+        render json: response
+      end
+
+      private
+
+      def set_out_of_gauge_bb_rate
+        @out_of_gauge_bb_rate = OutOfGaugeBbRate.find(params[:id])
+      end
+
+      def out_of_gauge_bb_rate_params
+        params.require(:out_of_gauge_bb_rate).permit(:route_id, :break_bulk_unit_id, :length_from, :length_to, :width_from, :width_to, :height_from, :height_to, :weight_from, :weight_to, :rate, :margin, :effective_date, :valid_until)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+require_dependency 'application_controller'
+
+module Logistics
+  module Core
+    class OutOfGaugeCntRatesController < ApplicationController
+      protect_from_forgery with: :null_session
+      before_action :set_out_of_gauge_cnt_rate, only: [:update]
+
+      # GET /out_of_gauge_cnt_rates
+      # GET /out_of_gauge_cnt_rates.json
+      def index
+        out_of_gauge_cnt_rates = OutOfGaugeCntRate.fetch_all
+        response = Mks::Common::MethodResponse.new(true, nil, out_of_gauge_cnt_rates, nil, nil)
+        render json: response
+      end
+
+      def search_route
+        route_id = params[:route][:id]
+        route = Route.find(route_id)
+        response = Mks::Common::MethodResponse.new(true, nil, route.margin, nil, nil)
+        render json: response
+      end
+
+      # POST /out_of_gauge_cnt_rates
+      # POST /out_of_gauge_cnt_rates.json
+      def create
+        out_of_gauge_cnt_rate = OutOfGaugeCntRate.new(out_of_gauge_cnt_rate_params)
+        margin = out_of_gauge_cnt_rate_params[:margin]
+        rate = out_of_gauge_cnt_rate_params[:rate]
+        new_rate = rate + (rate * margin/100)
+        out_of_gauge_cnt_rate.rate = new_rate
+
+
+        if out_of_gauge_cnt_rate.save
+          response = Mks::Common::MethodResponse.new(true, "Containerized Out of Gauge rate information saved successfully!", out_of_gauge_cnt_rate, nil, nil)
+        else
+          errors = Mks::Common::Util.error_messages out_of_gauge_cnt_rate,"Containerized Out of Gauge Rate"
+          response = Mks::Common::MethodResponse.new(false, nil, nil, errors, nil)
+        end
+        render json: response
+      end
+
+      # PATCH/PUT /out_of_gauge_cnt_rates/1
+      # PATCH/PUT /out_of_gauge_cnt_rates/1.json
+      def update
+        out_of_gauge_cnt_rate = OutOfGaugeCntRate.find(params[:id])
+        margin = out_of_gauge_cnt_rate_params[:margin]
+        if margin > out_of_gauge_cnt_rate.margin
+          rate = out_of_gauge_cnt_rate_params[:rate]
+          margin = margin - out_of_gauge_cnt_rate.margin
+          new_rate = rate + (rate * margin/100)
+          params[:out_of_gauge_cnt_rate][:rate] = new_rate
+        end
+
+        if out_of_gauge_cnt_rate.update(out_of_gauge_cnt_rate_params)
+          response = Mks::Common::MethodResponse.new(true, "Containerized Out of Gauge rate information updated successfully!", out_of_gauge_cnt_rate, nil, nil)
+        else
+          errors = Mks::Common::Util.error_messages out_of_gauge_cnt_rate,"Containerized Out of Gauge Rate"
+          response = Mks::Common::MethodResponse.new(false, nil, nil, errors, nil)
+        end
+        render json: response
+      end
+
+      private
+
+      def set_out_of_gauge_cnt_rate
+        @out_of_gauge_cnt_rate = OutOfGaugeCntRate.find(params[:id])
+      end
+
+      def out_of_gauge_cnt_rate_params
+        params.require(:out_of_gauge_cnt_rate).permit(:route_id, :container_size_id, :length_from, :length_to, :width_from, :width_to, :height_from, :height_to, :weight_from, :weight_to, :rate, :margin, :effective_date, :valid_until)
+      end
+    end
+  end
+end