erp_base_erp_svcs 4.0.0 → 4.2.0

data/app/controllers/api/v1/role_types_controller.rb

@@ -0,0 +1,146 @@
+module Api
+  module V1
+    class RoleTypesController < BaseController
+
+      def index
+        if params[:party_id]
+          party = Party.find(params[:party_id])
+
+          render :json => {success: true, role_types: party.role_types.collect{|role_type| role_type.to_data_hash}}
+
+        elsif params[:parent]
+          parent = nil
+          # create parent if it doesn't exist
+          # if the parent param is a comma seperated string then
+          # the parent is nested from left to right
+          params[:parent].split(',').each do |parent_iid|
+            if parent
+              parent = RoleType.find_or_create(parent_iid, parent_iid.humanize, parent)
+            else
+              parent = RoleType.find_or_create(parent_iid, parent_iid.humanize)
+            end
+          end
+
+          respond_to do |format|
+            format.tree do
+              render :json => {success: true, role_types: parent.children_to_tree_hash}
+            end
+            format.json do
+              render :json => {success: true, role_types: RoleType.to_all_representation(parent)}
+            end
+          end
+
+          # if ids are passed look up on the Role Types with the ids passed
+        elsif params[:ids]
+          ids = params[:ids].split(',').compact
+
+          role_types = []
+
+          ids.each do |id|
+            # check if id is a integer if so fine by id
+            if id.is_integer?
+              role_type = RoleType.find(id)
+            else
+              role_type = RoleType.iid(id)
+            end
+
+            if role_type
+              respond_to do |format|
+                format.tree do
+                  data = role_type.to_hash({
+                                             only: [:id, :parent_id, :internal_identifier],
+                                             leaf: role_type.leaf?,
+                                             text: role_type.to_label,
+                                             children: []
+                  })
+
+                  parent = nil
+                  role_types.each do |role_type_hash|
+                    if role_type_hash[:id] == data[:parent_id]
+                      parent = role_type_hash
+                    end
+                  end
+
+                  if parent
+                    parent[:children].push(data)
+                  else
+                    role_types.push(data)
+                  end
+                end
+                format.json do
+                  role_types.push(role_type.to_hash(only: [:id, :description, :internal_identifier]))
+                end
+              end
+            end
+
+          end
+
+          render :json => {success: true, role_types: role_types}
+
+          # get all role types
+        else
+          respond_to do |format|
+            format.tree do
+              nodes = [].tap do |nodes|
+                RoleType.roots.each do |root|
+                  nodes.push(root.to_tree_hash)
+                end
+              end
+
+              render :json => {success: true, role_types: nodes}
+            end
+            format.json do
+              render :json => {success: true, role_types: RoleType.to_all_representation}
+            end
+          end
+
+        end
+      end
+
+      def show
+        id = params[:id]
+
+        # check if id is a integer if so fine by id
+        if id.is_integer?
+          role_type = RoleType.find(id)
+        else
+          role_type = RoleType.iid(id)
+        end
+
+        respond_to do |format|
+          format.tree do
+            render :json => {success: true, role_type: role_type.to_tree_hash}
+          end
+          format.json do
+            render :json => {success: true, role_type: role_type.to_hash(only: [:id, :description, :internal_identifier])}
+          end
+        end
+      end
+
+      def create
+        description = params[:description].strip
+
+        begin
+          ActiveRecord::Base.transaction do
+            role_type = RoleType.create!(description: description, internal_identifier: description.to_iid)
+
+            if params[:parent] != 'No Parent'
+              parent = RoleType.iid(params[:parent])
+              role_type.move_to_child_of(parent)
+            elsif params[:default_parent]
+              parent = RoleType.iid(params[:default_parent])
+              role_type.move_to_child_of(parent)
+            end
+
+            render :json => {success: true, role_type: role_type.to_hash(only: [:id, :description, :internal_identifier])}
+          end
+        rescue ActiveRecord::RecordInvalid => invalid
+          Rails.logger.error invalid.record.errors.full_messages
+
+          render :json => {:success => false, :message => invalid.record.errors.full_messages.join('</br>')}
+        end
+      end
+
+    end # RoleTypesController
+  end # V1
+end # Api

data/app/controllers/api/v1/status_applications_controller.rb

@@ -0,0 +1,40 @@
+module Api
+  module V1
+    class StatusApplicationsController < BaseController
+
+      def index
+        statuses = if params[:record_id].present? && params[:record_type].present?
+
+                     # if the record acts as BizTxnEvent we need to use BizTxnEvent
+                     record = params[:record_type].constantize.find(params[:record_id])
+                     if record.respond_to?(:root_txn)
+                       record_type = 'BizTxnEvent'
+                       record_id = record.root_txn.id
+                     else
+                       record_type = params[:record_type]
+                       record_id = params[:record_id]
+                     end
+
+                     StatusApplication.where('status_application_record_id = ? and status_application_record_type = ?',
+                                             record_id,
+                                             record_type)
+                         .includes(:tracked_status_type).order('created_at desc').collect do |status|
+                       status.to_data_hash
+                     end
+
+                   else
+                     StatusApplication.all.collect { |status| status.to_data_hash }
+                   end
+
+        render :json => {:success => true, :status_applications => statuses}
+      end
+
+      def show
+        status_application = StatusApplication.find(params[:id])
+
+        render :json => {:success => true, :status_application => status_application.to_data_hash}
+      end
+
+    end # StatusApplicationsController
+  end # V1
+end # Api

data/app/controllers/api/v1/tracked_status_types_controller.rb

@@ -0,0 +1,146 @@
+module Api
+  module V1
+    class TrackedStatusTypesController < BaseController
+
+      def index
+        # look up parent by internal identifier
+        if params[:parent].present?
+          parent = nil
+          # create parent if it doesn't exist
+          # if the parent param is a comma separated string then
+          # the parent is nested from left to right
+          params[:parent].split(',').each do |parent_iid|
+            if parent
+              parent = TrackedStatusType.find_or_create(parent_iid, parent_iid.humanize, parent)
+            else
+              parent = TrackedStatusType.find_or_create(parent_iid, parent_iid.humanize)
+            end
+          end
+
+          respond_to do |format|
+            format.tree do
+              render :json => {success: true, tracked_status_types: parent.children_to_tree_hash}
+            end
+            format.json do
+              render :json => {success: true, tracked_status_types: parent.children.all.collect{|item| item.to_data_hash}}
+            end
+          end
+
+          # if parent id is passed find parent and get its children
+        elsif params[:parent_id].present?
+          parent = TrackedStatusType.find(params[:parent_id])
+
+          respond_to do |format|
+            format.tree do
+              render :json => {success: true, tracked_status_types: parent.children_to_tree_hash}
+            end
+            format.json do
+              render :json => {success: true, tracked_status_types: parent.children.all.collect{|item| item.to_data_hash}}
+            end
+          end
+          # if ids are passed look up on the Tracked Status Types with the ids passed
+        elsif params[:ids].present?
+          ids = params[:ids].split(',').compact
+
+          tracked_status_types = []
+
+          ids.each do |id|
+            # check if id is a integer if so fine by id
+            if id.is_integer?
+              tracked_status_type = TrackedStatusType.find(id)
+            else
+              tracked_status_type = TrackedStatusType.iid(id)
+            end
+
+            respond_to do |format|
+              format.tree do
+                data = tracked_status_type.to_hash({
+                                             only: [:id, :parent_id, :internal_identifier],
+                                             leaf: tracked_status_type.leaf?,
+                                             text: tracked_status_type.to_label,
+                                             children: []
+                                         })
+
+                parent = nil
+                tracked_status_types.each do |tracked_status_type_hash|
+                  if tracked_status_type_hash[:id] == data[:parent_id]
+                    parent = tracked_status_type_hash
+                  end
+                end
+
+                if parent
+                  parent[:children].push(data)
+                else
+                  tracked_status_types.push(data)
+                end
+              end
+              format.json do
+                tracked_status_types.push(tracked_status_type.to_data_hash)
+              end
+            end
+
+          end
+
+          render :json => {success: true, tracked_status_types: role_types}
+
+          # get all role types
+        else
+          respond_to do |format|
+            format.tree do
+              nodes = [].tap do |nodes|
+                TrackedStatusType.roots.each do |root|
+                  nodes.push(root.to_tree_hash)
+                end
+              end
+
+              render :json => {success: true, tracked_status_types: nodes}
+            end
+            format.json do
+              render :json => {success: true, tracked_status_types: TrackedStatusType.where('parent_id is null').all.collect{|item| item.to_data_hash}}
+            end
+          end
+
+        end
+      end
+
+      def show
+        id = params[:id]
+
+        # check if id is a integer if so fine by id
+        if id.is_integer?
+          tracked_status_type = TrackedStatusType.find(id)
+        else
+          tracked_status_type = TrackedStatusType.iid(id)
+        end
+
+        respond_to do |format|
+          format.tree do
+            render :json => {success: true, tracked_status_type: tracked_status_type.to_tree_hash}
+          end
+          format.json do
+            render :json => {success: true, tracked_status_type: tracked_status_type.to_data_hash}
+          end
+        end
+      end
+
+      def create
+        description = params[:description].strip
+
+        ActiveRecord::Base.transaction do
+          tracked_status_type = TrackedStatusType.create(description: description, internal_identifier: description.to_iid)
+
+          if params[:parent] != 'No Parent'
+            parent = TrackedStatusType.iid(params[:parent])
+            tracked_status_type.move_to_child_of(parent)
+          elsif params[:default_parent]
+            parent = TrackedStatusType.iid(params[:default_parent])
+            tracked_status_type.move_to_child_of(parent)
+          end
+
+          render :json => {success: true, tracked_status_type: tracked_status_type.to_data_hash}
+        end
+      end
+
+    end # TrackedStatusTypesController
+  end # V1
+end # Api

data/app/controllers/api/v1/unit_of_measurements_controller.rb

@@ -0,0 +1,16 @@
+module Api
+  module V1
+    class UnitOfMeasurementsController < BaseController
+
+      def index
+        render json: {
+                   unit_of_measurements:
+                       UnitOfMeasurement.scope_by_dba_organization(current_user.party.dba_organization).collect do |uom|
+                         uom.to_data_hash
+                       end
+               }
+      end
+
+    end # UnitOfMeasurementsController
+  end # V1
+end # Api

data/app/models/category.rb

@@ -1,13 +1,125 @@
+# unless table_exists?(:categories)
+#   create_table :categories do |t|
+#     t.string :description
+#     t.string :external_identifier
+#     t.datetime :from_date
+#     t.datetime :to_date
+#     t.string :internal_identifier
+#
+#     # polymorphic assns
+#     t.integer :category_record_id
+#     t.string :category_record_type
+#
+#     # nested set cols
+#     t.integer :parent_id
+#     t.integer :lft
+#     t.integer :rgt
+#
+#     t.timestamps
+#   end
+#   add_index :categories, [:category_record_id, :category_record_type], :name => "category_polymorphic"
+#   add_index :categories, :internal_identifier, :name => 'categories_internal_identifier_idx'
+#   add_index :categories, :parent_id, :name => 'categories_parent_id_idx'
+#   add_index :categories, :lft, :name => 'categories_lft_idx'
+#   add_index :categories, :rgt, :name => 'categories_rgt_idx'
+# end
+
+
 class Category < ActiveRecord::Base
   acts_as_nested_set
+  has_party_roles
+
+  include ErpTechSvcs::Utils::DefaultNestedSetMethods
+  acts_as_erp_type
 
   attr_protected :created_at, :updated_at
 
+  validates :internal_identifier, uniqueness: {allow_nil: false}
+
   belongs_to :category_record, :polymorphic => true
   has_many :category_classifications, :dependent => :destroy
-  
-  def self.iid( internal_identifier_string )
-    where("internal_identifier = ?",internal_identifier_string.to_s).first
+
+  class << self
+    # Filter records
+    #
+    # @param filters [Hash] a hash of filters to be applied,
+    # @param statement [ActiveRecord::Relation] the query being built
+    # @return [ActiveRecord::Relation] the query being built
+    def apply_filters(filters, statement=nil)
+      unless statement
+        statement = self
+      end
+
+      # filter by parent
+      if filters[:parent]
+        if filters[:parent].is_integer?
+          statement = statement.where(categories: {parent_id: filters[:parent]})
+        else
+          statement = statement.where(categories: {parent_id: Category.iid(filters[:parent])})
+        end
+      end
+
+      # filter by query which will filter on description
+      if filters[:query]
+        statement = statement.where('description like ?', "%#{filters[:query].strip}%")
+      end
+
+      statement
+    end
+
+    # scope by dba organization
+    #
+    # @param dba_organization [Party] dba organization to scope by
+    #
+    # @return [ActiveRecord::Relation]
+    def scope_by_dba_organization(dba_organization)
+      scope_by_party(dba_organization, {role_types: 'dba_org'})
+    end
+
+    alias scope_by_dba scope_by_dba_organization
+
+    # scope by party
+    #
+    # @param party [Integer | Party | Array] either a id of Party record, a Party record, an array of Party records
+    # or an array of Party ids
+    # @param options [Hash] options to apply to this scope
+    # @option options [String | Array] :role_types BizTxnAcctPtyRtype internal identifiers to include in the scope,
+    # comma separated or an Array
+    #
+    # @return [ActiveRecord::Relation]
+    def scope_by_party(party, options={})
+      statement = joins(:entity_party_roles)
+                      .where(entity_party_roles: {party_id: party}).uniq
+
+      if options[:role_types]
+        role_types = options[:role_types]
+        unless role_types.is_a? Array
+          role_types = role_types.split(',')
+        end
+
+        statement = statement.joins(entity_party_roles: :role_type)
+                        .where(role_types: {internal_identifier: role_types})
+      end
+
+      statement
+    end
+
+    def iid(internal_identifier)
+      where("internal_identifier = ?", internal_identifier).first
+    end
+  end
+
+  def to_data_hash
+    to_hash(
+        only: [
+            :id,
+            :description,
+            :internal_identifier,
+            :created_at,
+            :updated_at
+        ],
+        leaf: leaf?
+    )
   end
-  
+
 end