logistics_core 20.8.1

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

@@ -0,0 +1,44 @@
+module Logistics
+  module Core
+    class ServiceDeliveryUnitServicesController < ApplicationController
+
+      # POST /service_delivery_unit_services
+      # POST /service_delivery_unit_services.json
+      def create
+        sdu_services = params[:service_delivery_unit_services]
+        if sdu_services.count > 0
+          sdu = Logistics::Core::ServiceDeliveryUnit.find sdu_services[0][:service_delivery_unit_id]
+        end
+        sdu_services.each do |sdu_service|
+          Logistics::Core::ServiceDeliveryUnitChargeableService.create('service_delivery_unit_id' => sdu_service[:service_delivery_unit_id],
+                                                 'chargeable_service_id' => sdu_service[:chargeable_service_id],
+                                                 'is_mandatory' => sdu_service[:is_mandatory] )
+        end
+        response = {:success => true, :message => 'Service delivery unit service(s) recorded successfully'}
+        render json: response
+      end
+
+      def update
+        sdu_service = Logistics::Core::ServiceDeliveryUnitChargeableService.find(params[:id])
+        sdu_service.is_mandatory = params[:edited_row][:is_mandatory]
+        sdu_service.save
+        response = Mks::Common::MethodResponse.new(true, 'Service updated successfully !', nil, nil, nil)
+        render json: response
+      end
+
+      def delete
+        sdu_service = ServiceDeliveryUnitServiceService.new
+        sdu_service.delete_services(params[:id])
+        response = Mks::Common::MethodResponse.new(true, 'Service deleted successfully !', nil, nil, nil)
+        render json: response
+      end
+
+      private
+
+        # Never trust parameters from the scary internet, only allow the white list through.
+        def service_delivery_unit_service_params
+          params.permit(:service_delivery_unit_services => [:service_delivery_unit_id, :chargeable_service_id, :is_mandatory])
+        end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,92 @@
+require_dependency 'application_controller'
+
+module Logistics
+  module Core
+    class ServiceDeliveryUnitsController < ApplicationController
+      before_action :set_service_delivery_unit, only: [:update]
+      def index
+        @sdus = ServiceDeliveryUnit.all
+        service_delivery_units_array = []
+        @sdus.each { |sdu|
+          service_delivery_units_array.push({:id => sdu.id, :code => sdu.code, :name => sdu.name, :address => sdu.address,
+                                             :currency_id => sdu.currency_id, :currency_name => sdu.currency.name,
+                                             :service_delivery_unit_type_id => sdu.service_delivery_unit_type_id,
+                                             :type_name => sdu.service_delivery_unit_type.name })
+        }
+        @response = {:success => true, :message => '', :data => service_delivery_units_array}
+        render json: @response
+      end
+
+      def create
+        @service_delivery_unit = ServiceDeliveryUnit.new(model_params)
+        if @service_delivery_unit.valid?
+          @service_delivery_unit.save
+          @response = {:success => true, :message => 'Service delivery unit saved successfully!', :data => @service_delivery_unit}
+          render json: @response
+        else
+          errors = Mks::Common::Util.error_messages(@service_delivery_unit, 'Service delivery unit')
+          response = Mks::Common::MethodResponse.new(false,nil,nil,errors,nil)
+          render json: response
+        end
+      end
+
+      # PATCH/PUT /service_delivery_units/1
+      # PATCH/PUT /service_delivery_units/1.json
+      def update
+
+        if @service_delivery_unit.update_attributes(model_params)
+          @service_delivery_unit.save
+          @response = {:success => true, :message => 'Service delivery unit updated successfully!', :data => @service_delivery_unit}
+          render json: @response
+        else
+          errors = Mks::Common::Util.error_messages(@service_delivery_unit, 'Service delivery unit')
+          response = Mks::Common::MethodResponse.new(false,nil,nil,errors,nil)
+          render json: response
+        end
+      end
+
+      def get_chargeable_service_name(cs_id)
+        cs = ChargeableService.find(cs_id)
+        return cs.name
+      end
+
+      def chargeable_services
+        cs_array = []
+        service_delivery_unit_id = params[:id]
+        chargeable_services = ServiceDeliveryUnitChargeableService.where('service_delivery_unit_id' =>service_delivery_unit_id)
+        chargeable_services.each { |cs|
+          cs_array.push({:id =>cs.chargeable_service_id, :name => get_chargeable_service_name(cs.chargeable_service_id),
+                         :is_mandatory => cs.is_mandatory, sdu_cs_id: cs.id})
+        }
+        @response = {:success => true, :message => '', :data => cs_array}
+        render json: @response
+      end
+
+      def unassigned_services
+        sdu = ServiceDeliveryUnit.find(params[:id])
+        ids = sdu.chargeable_services.map(&:id)
+        unassigned_services = ChargeableService.where.not(id: ids)
+        response = Mks::Common::MethodResponse.new(true, nil, unassigned_services, nil, nil)
+        render json: response
+      end
+
+      def get_sdus_with_specific_services
+        offer_request_id = params[:offer_request_id]
+        type = params[:type]
+        sdus = ServiceDeliveryUnit.get_sdus_with_specific_services(offer_request_id, type)
+        response = Mks::Common::MethodResponse.new(true, nil, sdus, nil, nil)
+        render json: response
+      end
+
+      private
+
+      def set_service_delivery_unit
+        @service_delivery_unit = ServiceDeliveryUnit.find(params[:id])
+      end
+      # Never trust parameters from the scary internet, only allow the white list through.
+      def model_params
+        params.require(:service_delivery_unit).permit(:code, :name, :address, :currency_id, :service_delivery_unit_type_id)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+module Logistics
+  module Core
+    class ServiceIncrementsController < ApplicationController
+      before_action :set_service_increment, only: [:update]
+
+      # GET /service_increments
+      # GET /service_increments.json
+      def index
+        @service_increments = Logistics::Core::ServiceIncrement.all
+        @response = {:success => true, :message => '', :data => @service_increments}
+        render  json: @response
+      end
+
+      # POST /service_increments
+      # POST /service_increments.json
+      def create
+        @service_increment = Logistics::Core::ServiceIncrement.new(service_increment_params)
+
+        #respond_to do |format|
+        #format.json do
+        if @service_increment.valid?
+          @service_increment.save
+          @response = Mks::Common::MethodResponse.new(true, 'Increment recorded successfully', nil, nil, nil)
+          render json: @response
+        else
+          errors = Mks::Common::Util.error_messages(@service_increment, 'Increment')
+          response = Mks::Common::MethodResponse.new(false,nil,nil,errors,nil)
+          render json: response
+        end
+        #end
+        #end
+      end
+
+      # PATCH/PUT /service_increments/1
+      # PATCH/PUT /service_increments/1.json
+      def update
+        @service_increment.update_attributes(service_increment_params)
+        if @service_increment.save
+          @response = Mks::Common::MethodResponse.new(true,'Increment updated successfully',nil,nil,nil)
+          render json: @response
+        else
+          errors = Mks::Common::Util.error_messages(@service_increment, 'Increment')
+          response = Mks::Common::MethodResponse.new(false,nil,nil,errors,nil)
+          render json: response
+        end
+      end
+
+      def increments
+        service_increment_id = params[:id]
+        service_increment = Logistics::Core::ServiceIncrement.find(service_increment_id)
+        @response = {:success => true, :message => '', :data => service_increment.additions}
+        render json: @response
+      end
+
+      def unassigned_increments
+        service_increment_id = params[:id]
+        assigned_increment_ids = []
+        assigned_increment_ids.push(params[:id])
+        assigned_increments = Logistics::Core::Addendum.where('service_increment_id' => service_increment_id)
+        if assigned_increments.count > 0
+          assigned_increments.each { |ai|
+            assigned_increment_ids.push(ai.addition_id)
+          }
+        end
+        unassigned_increments = Logistics::Core::ServiceIncrement.where.not(id: assigned_increment_ids)
+        @response ={:success =>true, :message => '', :data => unassigned_increments}
+        render json: @response
+      end
+
+      private
+        # Use callbacks to share common setup or constraints between actions.
+        def set_service_increment
+          @service_increment = Logistics::Core::ServiceIncrement.find(params[:id])
+        end
+
+        # Never trust parameters from the scary internet, only allow the white list through.
+        def service_increment_params
+          params.require(:service_increment).permit(:code, :name, :has_increment)
+        end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+module Logistics
+  module Core
+    class ServiceRatesController < ApplicationController
+      before_action :set_service_rate, only: [:update]
+
+      # GET /service_rates
+      # GET /service_rates.json
+      def index
+        service_rate_array = []
+        @service_rates = ServiceRate.all#includes('chargeable_service').order("chargeable_services.order")
+        @service_rates.each { |service_rate|
+          service_rate_array.push({:id => service_rate.id,
+                                  :chargeable_service_name => service_rate.chargeable_service_unit_of_charge.chargeable_service.name,
+                                  :effective_date => service_rate.effective_date,:low => service_rate.low,
+                                  :medium => service_rate.medium, :high => service_rate.high,
+                                  :margin => service_rate.margin,
+                                  :container_size_id => service_rate.container_size_id,
+                                  :container_size_name => service_rate.container_size.name,
+                                  :transaction_type_id => service_rate.transaction_type_id,
+                                  :transaction_type_name => service_rate.transaction_type.name,
+                                  :service_delivery_unit_id => service_rate.chargeable_service_unit_of_charge.service_delivery_unit_id,
+                                  :service_delivery_unit_name => service_rate.chargeable_service_unit_of_charge.service_delivery_unit.name,
+                                  })
+        }
+        @response = {:success => true, :message => '', :data => service_rate_array}
+        render json: @response
+      end
+
+      # POST /service_rates
+      # POST /service_rates.json
+      def create
+        ServiceRate.generate_rate_for_containerized_chargeable_service(params[:effective_date])
+        @response = {:success => true, :message => 'Rate table generated successfully', :data => []}
+        render json: @response
+      end
+
+      # PATCH/PUT /service_rates/1
+      # PATCH/PUT /service_rates/1.json
+      def update
+        service_rates = params[:updated_service_rates]
+        service_rates.each { |service_rate|
+          old_service_rate = ServiceRate.find(service_rate['id'])
+          old_service_rate.low = service_rate['low']
+          old_service_rate.medium = service_rate['medium']
+          old_service_rate.high = service_rate['high']
+          old_service_rate.margin = service_rate['margin']
+          old_service_rate.effective_date = service_rate['effective_date']
+          old_service_rate.save
+        }
+        @response = {:success => true, :message => 'Rate table updated successfully', :data => service_rates}
+        render json: @response
+      end
+
+      private
+        # Use callbacks to share common setup or constraints between actions.
+        def set_service_rate
+          @service_rate = ServiceRate.find(params[:id])
+        end
+
+        # Never trust parameters from the scary internet, only allow the white list through.
+        def service_rate_params
+          params.require(:service_rate).permit(:container_size_id, :transaction_type_id, :service_delivery_unit_id, :chargeable_service_id, :unit_price)
+        end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+module Logistics
+  module Core
+    class SpecialIncrementContainerRatesController < ApplicationController
+      before_action :set_container_increment, only: [:update]
+      def index
+        container_increments = SpecialIncrementContainerRate.all
+        container_increments_array = []
+        container_increments.each { |ci|
+          container_increments_array.push({:id => ci.id, :container_type_id => ci.container_type_id, :container_type_name => ci.container_type.name,
+                                          :rate => ci.rate, :effective_date => ci.effective_date})
+        }
+        response = Mks::Common::MethodResponse.new(true,nil,container_increments_array,nil,nil)
+        render json: response
+      end
+
+      def create
+        errors = []
+        container_increment = SpecialIncrementContainerRate.new(container_increment_params)
+        if container_increment.valid?
+          container_increment.save
+          response = Mks::Common::MethodResponse.new(true, 'Container increment successfully created',nil,nil,nil)
+        else
+          errors << Mks::Common::Util.error_messages(container_increment, 'ContainerIncrement')
+          response = Mks::Common::MethodResponse.new(false,nil,nil,errors,nil)
+        end
+        render json: response
+      end
+
+      def update
+        @container_increment.update_attributes(container_increment_params)
+        if @container_increment.save
+          response = Mks::Common::MethodResponse.new(true, 'Container increment updated successfully !',nil,nil,nil)
+          render json: response
+        else
+          errors = Mks::Common::Util.error_messages @container_increment, 'ContainerIncrement'
+          @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_container_increment
+        @container_increment = SpecialIncrementContainerRate.find(params[:id])
+      end
+
+      # Never trust parameters from the scary internet, only allow the white list through.
+      def container_increment_params
+        params.require(:container_increment).permit(:id, :container_type_id, :rate, :effective_date)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+module Logistics
+  module Core
+    class SpecialIncrementContentRatesController < ApplicationController
+      before_action :set_content_increment, only: [:update]
+      def index
+        content_increments = SpecialIncrementContentRate.all
+        content_increments_array = []
+        content_increments.each { |ci|
+          content_increments_array.push({:id => ci.id, :content_type_id => ci.content_type_id, :content_type_name => ci.content_type.name,
+                                           :rate => ci.rate, :effective_date => ci.effective_date})
+        }
+        response = Mks::Common::MethodResponse.new(true,nil,content_increments_array,nil,nil)
+        render json: response
+      end
+
+      def create
+        errors = []
+        content_increment = SpecialIncrementContentRate.new(content_increment_params)
+        if content_increment.valid?
+          content_increment.save
+          response = Mks::Common::MethodResponse.new(true, 'Content increment successfully created',nil,nil,nil)
+        else
+          errors = Mks::Common::Util.error_messages(content_increment, 'ContentIncrement')
+          response = Mks::Common::MethodResponse.new(false,nil,nil,errors,nil)
+        end
+        render json: response
+      end
+
+      def update
+        @content_increment.update_attributes(content_increment_params)
+        if @content_increment.save
+          response = Mks::Common::MethodResponse.new(true, 'Content increment updated successfully !',nil,nil,nil)
+          render json: response
+        else
+          errors = Mks::Common::Util.error_messages(@content_increment, 'ContentIncrement')
+          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_content_increment
+        @content_increment = SpecialIncrementContentRate.find(params[:id])
+      end
+
+      # Never trust parameters from the scary internet, only allow the white list through.
+      def content_increment_params
+        params.require(:content_increment).permit(:id, :content_type_id, :rate, :effective_date)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require_dependency "application_controller"
+
+module Logistics
+  module Core
+    class StandardRemarksController < ApplicationController
+      before_action :set_standard_remark, only: [:update]
+      def index
+        standard_remarks = StandardRemark.all
+        render json: Mks::Common::MethodResponse.new(true, nil, standard_remarks, nil, nil)
+      end
+
+      def create
+        standard_remark = StandardRemark.new(standard_remark_params)
+        if standard_remark.save
+          res = Mks::Common::MethodResponse.new(true, 'Remark added successfully !', nil, nil, nil)
+        else
+          errors = Mks::Common::Util.error_messages('Standard Remark', standard_remark)
+          res = Mks::Common::MethodResponse.new(false, nil, nil, errors, nil)
+        end
+        render json: res
+      end
+
+      def update
+        if @standard_remark.update(standard_remark_params)
+          res = Mks::Common::MethodResponse.new(true, 'Remark updated successfully !', nil, nil, nil)
+        else
+          errors = Mks::Common::Util.error_messages(@standard_remark, 'Standard Remark')
+          res = Mks::Common::MethodResponse.new(false, nil, nil, errors, nil)
+        end
+        render json: res
+      end
+
+      private
+      def standard_remark_params
+        params.require(:standard_remark).permit(:id, :code, :description)
+      end
+
+      def set_standard_remark
+        @standard_remark = StandardRemark.find(params[:id])
+      end
+    end
+  end
+end