erp_work_effort 4.0.0 → 4.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ad5d23963efb2e5067ac139ef8d7886811a058d1
-  data.tar.gz: 0d51e61b9b9b83fe5d6080a4a543cffa27bc9c8f
+  metadata.gz: b58acc4d8a198a71e9c42ac9daa6b9d977aa5fef
+  data.tar.gz: f7b3fb86a17d31ac9b3dde1e428140c5e2ec1449
 SHA512:
-  metadata.gz: 7f7a8b18fa29c8584836be2c62a412575163c2ea82acb3d9c8d5106a507efbe704c32ae7b46968949fbbcd765fc7235ab3f5e08ac41fb8a759655cda9a1ad0e3
-  data.tar.gz: d775e88305f33b49f9e54e0520638cf70b6bc408606f89acb994449f0204c55e6eaaf8260c3df506540434270c1bf2e6069e5e0dbc542a54f39fd52958d769f6
+  metadata.gz: c132f84cd49fa0c36acd5b11731e542007f7f9dc2bee440a685d91753b35210cd7a78a7d23fd8b7cccb8695d91d27bd126805465accbfa0e751bb7d8bae9c9b9
+  data.tar.gz: b9789ee3069d3201144cce1a6419ad7ec2c287475d22fa8f0f7cc8b105c156ede8b98022f40692a2534ba10c254456f9414ac3dba3bdc896652e46f6bed27ba6

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

@@ -0,0 +1,25 @@
+module Api
+  module V1
+    class ProjectsController < BaseController
+
+      def index
+        # check if we are scoping by current user
+        if params[:scope_by_user].present? and params[:scope_by_user].to_bool
+          party = current_user.party
+          projects = Project.scope_by_party(party,
+                                            {role_types: RoleType.find_child_role_types(party.party_roles.collect { |party_role| party_role.role_type })})
+        else
+          # scope by dba organization
+          projects = Project.scope_by_dba_organization(current_user.party.dba_organization)
+        end
+
+        if params[:query]
+          projects = projects.where(projects.arel_table[:description].matches("%#{params[:query]}%"))
+        end
+
+        render :json => {success: true, projects: projects.all.map { |project| project.to_data_hash }}
+      end
+
+    end # ProjectsController
+  end # V1
+end # Api

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

@@ -0,0 +1,313 @@
+module Api
+  module V1
+    class TimeEntriesController < BaseController
+
+      def create
+        begin
+          ActiveRecord::Base.connection.transaction do
+            party = current_user.party
+
+            time_entry = TimeEntry.new(
+              manual_entry: true
+            )
+
+            if params[:from_datetime]
+              time_entry.from_datetime = params[:from_datetime].to_time
+            end
+
+            if params[:thru_datetime]
+              time_entry.from_datetime = params[:thru_datetime].to_time
+            end
+
+            if params[:comment]
+              time_entry.comment = params[:comment].strip
+            end
+
+            if params[:regular_hours_in_seconds]
+              time_entry.regular_hours_in_seconds = params[:regular_hours_in_seconds].to_i
+            end
+
+            if params[:overtime_hours_in_seconds]
+              time_entry.overtime_hours_in_seconds = params[:regular_hours_in_seconds].to_i
+            end
+
+            if params[:work_effort_id]
+              time_entry.work_effort = params[:work_effort_id]
+            end
+
+            # if a timesheet id is passed assoicate to that timesheet if not associate to
+            # the current user's timesheet
+            if params[:timesheet_id]
+              time_entry.timesheet_id = params[:timesheet_id]
+            else
+              time_sheet = party.timesheets.current!(current_user.party, RoleType.iid('work_resource'))
+              time_entry.timesheet_id = time_sheet.id
+            end
+
+            render json: {
+              success: true,
+              time_entry: time_entry.to_data_hash,
+            }
+
+          end
+        rescue ActiveRecord::RecordInvalid => invalid
+          Rails.logger.error invalid.record.errors
+
+          render :json => {:success => false, :message => invalid.record.errors}
+        rescue StandardError => ex
+          Rails.logger.error ex.message
+          Rails.logger.error ex.backtrace.join("\n")
+
+          ExceptionNotifier.notify_exception(ex) if defined? ExceptionNotifier
+
+          render json: {success: false, message: 'Error creating Time Entry'}
+        end
+      end
+
+      def update
+        begin
+          ActiveRecord::Base.connection.transaction do
+
+            time_entry = TimeEntry.find(params[:id])
+
+            if params[:from_datetime]
+              time_entry.from_datetime = params[:from_datetime].to_time
+            end
+
+            if params[:thru_datetime]
+              time_entry.from_datetime = params[:thru_datetime].to_time
+            end
+
+            if params[:comment]
+              time_entry.comment = params[:comment].strip
+            end
+
+            if params[:regular_hours_in_seconds]
+              time_entry.regular_hours_in_seconds = params[:regular_hours_in_seconds].to_i
+            end
+
+            if params[:overtime_hours_in_seconds]
+              time_entry.overtime_hours_in_seconds = params[:regular_hours_in_seconds].to_i
+            end
+
+            # update to manual entry
+            time_entry.manual_entry = true
+
+            render json: {
+              success: time_entry.save!,
+              time_entry: time_entry.to_data_hash,
+            }
+
+          end
+        rescue ActiveRecord::RecordInvalid => invalid
+          Rails.logger.error invalid.record.errors
+
+          render :json => {:success => false, :message => invalid.record.errors}
+        rescue StandardError => ex
+          Rails.logger.error ex.message
+          Rails.logger.error ex.backtrace.join("\n")
+
+          ExceptionNotifier.notify_exception(ex) if defined? ExceptionNotifier
+
+          render json: {success: false, message: 'Error updating Time Entry'}
+        end
+      end
+
+      def show
+        time_entry = TimeEntry.find(params[:id])
+
+        render :json => {success: true, time_entry: time_entry.to_data_hash}
+      end
+
+      # start TimeEntry by setting the from_datetime but not the thru_datetime
+      # if there is already an open time_entry do not let another one be started
+      # It is assumed that a TimeEntry is always logged against a work effort so
+      # a WorkEffort id should be passed.
+      #
+      def start
+        begin
+          ActiveRecord::Base.connection.transaction do
+
+            party = current_user.party
+            work_effort = WorkEffort.find(params[:work_effort_id])
+
+            # check for an open TimeEntry
+            open_time_entry = party.open_time_entry
+
+            # if there is an open TimeEntry stop it and start a new one
+            if open_time_entry
+              open_time_entry.thru_datetime = Time.now
+
+              open_time_entry.calculate_regular_hours_in_seconds!
+            end
+
+            time_entry = TimeEntry.create(
+              from_datetime: params[:start_at].to_time
+            )
+
+            time_entry.work_effort = work_effort
+
+            # associate to a timesheet
+            time_sheet = party.timesheets.current!(RoleType.iid('work_resource'))
+            time_sheet.time_entries << time_entry
+
+            # update task statuses
+            time_entry.update_task_status('task_status_in_progress')
+            time_entry.update_task_assignment_status('task_resource_status_in_progress')
+
+            render json: {
+              success: true,
+              time_entry: time_entry.to_data_hash,
+            }
+          end
+        rescue ActiveRecord::RecordInvalid => invalid
+          Rails.logger.error invalid.record.errors
+
+          render :json => {:success => false, :message => invalid.record.errors}
+        rescue StandardError => ex
+          Rails.logger.error ex.message
+          Rails.logger.error ex.backtrace.join("\n")
+
+          ExceptionNotifier.notify_exception(ex) if defined? ExceptionNotifier
+
+          render json: {success: false, message: 'Error starting Time Entry'}
+        end
+      end
+
+      # stop TimeEntry by setting the thru_datetime and calculating the hours in seconds
+      # it returns the TimeEntry record as well as formatted totals for the day and week
+      #
+      def stop
+        begin
+          ActiveRecord::Base.connection.transaction do
+            party = current_user.party
+            work_effort = WorkEffort.find(params[:work_effort_id])
+            time_entry = TimeEntry.find(params[:id])
+
+            time_entry.thru_datetime = params[:end_at].to_time
+            time_entry.comment = params[:comment].present? ? params[:comment].strip : nil
+
+            time_entry.calculate_regular_hours_in_seconds!
+
+            time_entry.update_task_assignment_status('task_resource_status_hold')
+
+            result = {
+              success: true,
+              time_entry: time_entry.to_data_hash,
+            }
+
+            time_helper = ErpBaseErpSvcs::Helpers::Time::Client.new(params[:client_utc_offset])
+
+            result[:day_total_formatted] = TimeEntry.total_formatted(work_effort: work_effort,
+                                                                     party: party,
+                                                                     start: time_helper.beginning_of_day,
+                                                                     end: time_helper.end_of_day
+                                                                     )
+            result[:week_total_formatted] = TimeEntry.total_formatted(work_effort: work_effort,
+                                                                      party: party,
+                                                                      start: time_helper.beginning_of_week,
+                                                                      end: time_helper.end_of_week
+                                                                      )
+
+            render json: result
+          end
+        rescue ActiveRecord::RecordInvalid => invalid
+          Rails.logger.error invalid.record.errors
+
+          render :json => {:success => false, :message => invalid.record.errors}
+        rescue StandardError => ex
+          Rails.logger.error ex.message
+          Rails.logger.error ex.backtrace.join("\n")
+
+          ExceptionNotifier.notify_exception(ex) if defined? ExceptionNotifier
+
+          render json: {success: false, message: 'Error stopping Time Entry'}
+        end
+      end
+
+      # if a work effort id is passed get the last open time_entry for that work_effort
+      # for the current user if there are no open time entries then return only the totals
+      #
+      def open
+        if params[:work_effort_id]
+          work_effort = WorkEffort.find(params[:work_effort_id])
+          party = current_user.party
+
+          open_time_entry = work_effort.time_entries.scope_by_party(current_user.party).open_entries.first
+          time_helper = ErpBaseErpSvcs::Helpers::Time::Client.new(params[:client_utc_offset])
+
+          render :json => {success: true,
+                           time_entry: open_time_entry.nil? ? nil : open_time_entry.to_data_hash,
+                           day_total_formatted: TimeEntry.total_formatted(work_effort: work_effort,
+                                                                          party: party,
+                                                                          start: time_helper.beginning_of_day,
+                                                                          end: time_helper.end_of_day),
+                           week_total_formatted: TimeEntry.total_formatted(work_effort: work_effort,
+                                                                           party: party,
+                                                                           start: time_helper.beginning_of_week,
+                                                                           end: time_helper.end_of_week)
+                           }
+        else
+          render :json => {success: true, time_entries: TimeEntry.open_entries.collect { |time_entry| time_entry.to_data_hash }}
+        end
+      end
+
+      # returns totals for time entries.  If a work effort id is passed it will get totals for the
+      # passed work effort.  If no work effort id is passed it will get totals for the current user
+      # passed on their timesheet
+      #
+      def totals
+        result = {
+          success: true,
+          day_total_seconds: 0,
+          week_total_seconds: 0,
+          day_total_formatted: '00:00:00',
+          week_total_formatted: '00:00:00',
+          total_formatted: '00:00:00'
+        }
+
+        work_effort = nil
+        party = nil
+        time_helper = ErpBaseErpSvcs::Helpers::Time::Client.new(params[:client_utc_offset])
+
+        if params[:work_effort_id]
+          work_effort = WorkEffort.find(params[:work_effort_id])
+        end
+
+        if params[:party_id]
+          party = Party.find(params[:party_id])
+        end
+
+        result[:day_total_seconds] = TimeEntry.total_seconds(work_effort: work_effort,
+                                                             party: party,
+                                                             start: time_helper.beginning_of_day,
+                                                             end: time_helper.end_of_day
+                                                             )
+        result[:week_total_seconds] = TimeEntry.total_seconds(work_effort: work_effort,
+                                                              party: party,
+                                                              start: time_helper.beginning_of_week,
+                                                              end: time_helper.end_of_week
+                                                              )
+        result[:total_seconds] = TimeEntry.total_seconds(work_effort: work_effort,
+                                                         party: party
+                                                         )
+        result[:day_total_formatted] = TimeEntry.total_formatted(work_effort: work_effort,
+                                                                 party: party,
+                                                                 start: time_helper.beginning_of_day,
+                                                                 end: time_helper.end_of_day
+                                                                 )
+        result[:week_total_formatted] = TimeEntry.total_formatted(work_effort: work_effort,
+                                                                  party: party,
+                                                                  start: time_helper.beginning_of_week,
+                                                                  end: time_helper.end_of_week
+                                                                  )
+        result[:total_formatted] = TimeEntry.total_formatted(work_effort: work_effort,
+                                                             party: party
+                                                             )
+
+        render json: result
+      end
+
+    end # TimeEntriesController
+  end # V1
+end # Api

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

@@ -0,0 +1,9 @@
+module Api
+  module V1
+    class TransportationRoutesController < BaseController
+
+      # TODO implement CRUD operations
+
+    end # TransportationRoutesController
+  end # V1
+end # Api

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

@@ -0,0 +1,102 @@
+module Api
+  module V1
+    class WorkEffortAssociationsController < BaseController
+
+      def index
+        work_effort_associations = WorkEffortAssociation
+
+        if params[:project_id]
+          work_effort_associations = work_effort_associations.joins('inner join work_efforts on work_efforts.id = work_effort_associations.work_effort_id_to')
+                                         .where('work_efforts.project_id = ?', params[:project_id])
+        else
+          # scope by dba organization
+          work_effort_associations = work_effort_associations.joins('inner join work_efforts on work_efforts.id = work_effort_associations.work_effort_id_to')
+                                         .joins("inner join entity_party_roles on entity_party_roles.entity_record_type = 'WorkEffort' and entity_party_roles.entity_record_id = work_efforts.id")
+                                         .where('entity_party_roles.party_id = ? and entity_party_roles.role_type_id = ?', current_user.party.dba_organization.id, RoleType.iid('dba_org').id)
+        end
+
+        render :json => {success: true, work_effort_associations: work_effort_associations.all.map { |work_effort| work_effort.to_data_hash }}
+      end
+
+      def show
+        render :json => {success: true, work_effort_association: WorkEffortAssociation.find(params[:id]).to_data_hash}
+      end
+
+      def create
+        begin
+          ActiveRecord::Base.connection.transaction do
+
+            work_effort_association = WorkEffortAssociation.new
+            work_effort_association.work_effort_id_from = params[:work_effort_id_from]
+            work_effort_association.work_effort_id_to = params[:work_effort_id_to]
+            work_effort_association.work_effort_association_type = WorkEffortAssociationType.where('external_identifier = ?', params['work_effort_association_type.external_identifier'].to_s).first
+
+            work_effort_association.save!
+
+            render :json => {success: true, work_effort_association: work_effort_association.to_data_hash}
+
+          end
+        rescue ActiveRecord::RecordInvalid => invalid
+          Rails.logger.error invalid.record.errors
+
+          render :json => {:success => false, :message => invalid.record.errors}
+        rescue StandardError => ex
+          Rails.logger.error ex.message
+          Rails.logger.error ex.backtrace.join("\n")
+
+          ExceptionNotifier.notify_exception(ex) if defined? ExceptionNotifier
+
+          render json: {success: false, message: 'Error creating Work Effort Association'}
+        end
+      end
+
+      def update
+        begin
+          ActiveRecord::Base.connection.transaction do
+
+            work_effort_association = WorkEffortAssociation.find(params[:id])
+            work_effort_association.work_effort_id_from = params[:work_effort_id_from]
+            work_effort_association.work_effort_id_to = params[:work_effort_id_to]
+            work_effort_association.work_effort_association_type = WorkEffortAssociationType.where('external_identifier = ?', params[:work_effort_association_type_external_id].to_s).first
+
+            work_effort_association.save!
+
+            render :json => {success: true, work_effort_association: work_effort_association.to_data_hash}
+
+          end
+        rescue ActiveRecord::RecordInvalid => invalid
+          Rails.logger.error invalid.record.errors
+
+          render :json => {:success => false, :message => invalid.record.errors}
+        rescue StandardError => ex
+          Rails.logger.error ex.message
+          Rails.logger.error ex.backtrace.join("\n")
+
+          ExceptionNotifier.notify_exception(ex) if defined? ExceptionNotifier
+
+          render json: {success: false, message: 'Error updating Work Effort Association'}
+        end
+      end
+
+      def destroy
+        work_effort_association = WorkEffortAssociation.find(params[:id])
+
+        begin
+          ActiveRecord::Base.connection.transaction do
+
+            render json: {success: work_effort_association.destroy}
+
+          end
+        rescue StandardError => ex
+          Rails.logger.error ex.message
+          Rails.logger.error ex.backtrace.join("\n")
+
+          ExceptionNotifier.notify_exception(ex) if defined? ExceptionNotifier
+
+          render json: {success: false, message: 'Error destroying Work Effort Association'}
+        end
+      end
+
+    end # WorkEffortAssociationsController
+  end # V1
+end # Api