public virtual DateTime?GetMinEffectiveDate(PMLaborCostRate row) { if (row == null) { return(null); } if (!AllParametersEntered(row)) { return(null); } DateTime?result = null; EPEmployee employee = PXSelect <EPEmployee, Where <EPEmployee.bAccountID, Equal <Required <EPEmployee.bAccountID> > > > .Select(this, row.EmployeeID); if (employee != null) { PMTimeActivity firstUnreleased = PXSelect <PMTimeActivity, Where <PMTimeActivity.ownerID, Equal <Required <PMTimeActivity.ownerID> >, And <PMTimeActivity.released, NotEqual <True> > >, OrderBy <Asc <PMTimeActivity.date> > > .SelectWindowed(this, 0, 1, employee.OwnerID); if (firstUnreleased != null) { if (firstUnreleased.Date < result) { result = firstUnreleased.Date; } } } return(result); }
///NO CRM Mode public static int?GetContractLaborClassID(PXGraph graph, int?contractID, PMTimeActivity activity) { EPContractRate matrix = PXSelectJoin < EPContractRate, InnerJoin <EPEmployee, On <EPContractRate.employeeID, Equal <EPEmployee.bAccountID> > >, Where <EPContractRate.contractID, Equal <Required <EPContractRate.contractID> >, And <EPContractRate.earningType, Equal <Required <CRPMTimeActivity.earningTypeID> >, And <EPEmployee.userID, Equal <Required <CRPMTimeActivity.ownerID> > > > > > .Select(graph, contractID, activity.EarningTypeID, activity.OwnerID); if (matrix == null) { matrix = PXSelect < EPContractRate, Where <EPContractRate.contractID, Equal <Required <EPContractRate.contractID> >, And <EPContractRate.earningType, Equal <Required <CRPMTimeActivity.earningTypeID> >, And <EPContractRate.employeeID, IsNull> > > > .Select(graph, contractID, activity.EarningTypeID); } if (matrix != null) { return(matrix.LabourItemID); } else { return(null); } }
public virtual int?GetLaborClass(PMTimeActivity activity, EPEmployee employee, CRCase refCase) { if (employee == null) { throw new ArgumentNullException("employee", Messages.EmptyEmployeeID); } int?laborClassID = null; if (refCase != null) { CRCaseClass caseClass = (CRCaseClass)PXSelectorAttribute.Select <CRCase.caseClassID>(graph.Caches[typeof(CRCase)], refCase); if (caseClass.PerItemBilling == BillingTypeListAttribute.PerActivity) { laborClassID = CRCaseClassLaborMatrix.GetLaborClassID(graph, caseClass.CaseClassID, activity.EarningTypeID); } } if (laborClassID == null && activity.ProjectID != null && employee.BAccountID != null) { laborClassID = EPContractRate.GetProjectLaborClassID(graph, (int)activity.ProjectID, (int)employee.BAccountID, activity.EarningTypeID); } if (laborClassID == null) { laborClassID = EPEmployeeClassLaborMatrix.GetLaborClassID(graph, employee.BAccountID, activity.EarningTypeID); } if (laborClassID == null) { laborClassID = employee.LabourItemID; } return(laborClassID); }
private void UpdateSODetServiceRow( ServiceOrderEntry graphServiceOrder, FSSODetService fsSODetServiceRow, PMTimeActivity pmTimeActivity, FSxPMTimeActivity fsxPMTimeActivity) { //TODO SD-7788 //************************************************************** // Update all FSSODetService fields but key fields ************* //************************************************************** if (fsSODetServiceRow.LineType != ID.LineType_ServiceTemplate.SERVICE) { graphServiceOrder.ServiceOrderDetServices.SetValueExt <FSSODetService.lineType>(fsSODetServiceRow, ID.LineType_ServiceTemplate.SERVICE); } if (fsSODetServiceRow.InventoryID != fsxPMTimeActivity.ServiceID) { graphServiceOrder.ServiceOrderDetServices.SetValueExt <FSSODetService.inventoryID>(fsSODetServiceRow, fsxPMTimeActivity.ServiceID); } if (fsSODetServiceRow.ProjectID != pmTimeActivity.ProjectID) { graphServiceOrder.ServiceOrderDetServices.SetValueExt <FSSODetService.projectID>(fsSODetServiceRow, pmTimeActivity.ProjectID); } if (fsSODetServiceRow.ProjectTaskID != pmTimeActivity.ProjectTaskID) { graphServiceOrder.ServiceOrderDetServices.SetValueExt <FSSODetService.projectTaskID>(fsSODetServiceRow, pmTimeActivity.ProjectTaskID); } if (fsSODetServiceRow.CostCodeID != pmTimeActivity.CostCodeID) { graphServiceOrder.ServiceOrderDetServices.SetValueExt <FSSODetService.costCodeID>(fsSODetServiceRow, pmTimeActivity.CostCodeID); } }
protected virtual void PMTimeActivity_ProjectTaskID_FieldVerifying(PXCache sender, PXFieldVerifyingEventArgs e) { PMTimeActivity row = (PMTimeActivity)e.Row; if (row == null) { return; } if (e.NewValue != null && e.NewValue is int) { PMTask task = PXSelect <PMTask> .Search <PMTask.taskID>(sender.Graph, e.NewValue); if (task != null) { if (task.IsCompleted == true) { var ex = new PXSetPropertyException(PM.Messages.ProjectTaskIsCompleted); ex.ErrorValue = task.TaskCD; throw ex; } if (task.IsCancelled == true) { var ex = new PXSetPropertyException(PM.Messages.ProjectTaskIsCanceled); ex.ErrorValue = task.TaskCD; throw ex; } } } }
public virtual decimal?CalculateEmployeeCost(PMTimeActivity activity, int?employeeID, DateTime date) { decimal?cost; Rate employeeRate = GetEmployeeRate(activity.ProjectID, activity.ProjectTaskID, employeeID, date); if (employeeRate.Type == RateTypesAttribute.SalaryWithExemption && activity.TimeCardCD != null) { //Overtime is not applicable. Rate is prorated based on actual hours worked on the given week EPTimeCard timecard = PXSelect <EPTimeCard, Where <EPTimeCard.timeCardCD, Equal <Required <PMTimeActivity.timeCardCD> > > > .Select(graph, activity.TimeCardCD); if (timecard.TotalSpentCalc <= employeeRate.RegularHours * 60m) { cost = employeeRate.RateByType / employeeRate.RegularHours; } else { cost = employeeRate.RateByType / (timecard.TotalSpentCalc / 60m); } } else { cost = employeeRate.HourlyRate * GetOvertimeMultiplier(activity.EarningTypeID, (int)employeeID, date); } return(cost); }
public virtual void UpdateServiceOrderDetail(PXCache cache, CRActivity crActivityRow, PXDBOperation operation) { FSServiceOrder fsServiceOrderRow = GetServiceOrderRecord(cache.Graph, crActivityRow); if (fsServiceOrderRow != null) { PMTimeActivity pmTimeActivityRow = PXSelect <PMTimeActivity, Where < PMTimeActivity.refNoteID, Equal <Required <PMTimeActivity.refNoteID> > > > .Select(Base, crActivityRow.NoteID); if (pmTimeActivityRow == null) { return; } FSxPMTimeActivity fsxPMTimeActivityRow = PXCache <PMTimeActivity> .GetExtension <FSxPMTimeActivity>(pmTimeActivityRow); ServiceOrderEntry graphServiceOrder = PXGraph.CreateInstance <ServiceOrderEntry>(); //Load existing ServiceOrder graphServiceOrder.ServiceOrderRecords.Current = graphServiceOrder.ServiceOrderRecords .Search <FSServiceOrder.refNbr>(fsServiceOrderRow.RefNbr, fsServiceOrderRow.SrvOrdType); //Update ServiceOrder detail InsertUpdateDeleteSODet(graphServiceOrder, pmTimeActivityRow, fsxPMTimeActivityRow, operation); if (graphServiceOrder.IsDirty) { graphServiceOrder.Save.Press(); } } }
protected void EPEarningType_RowDeleting(PXCache sender, PXRowDeletingEventArgs e) { EPEarningType row = (EPEarningType)e.Row; if (row == null) { return; } EPSetup setup = PXSelect < EPSetup , Where <EPSetup.regularHoursType, Equal <Required <EPEarningType.typeCD> > , Or <EPSetup.holidaysType, Equal <Required <EPEarningType.typeCD> > , Or <EPSetup.vacationsType, Equal <Required <EPEarningType.typeCD> > > > > > .Select(this, row.TypeCD, row.TypeCD, row.TypeCD); if (setup != null) { throw new PXException(Messages.CannotDeleteInUse); } CRCaseClassLaborMatrix caseClassLabor = PXSelect <CRCaseClassLaborMatrix, Where <CRCaseClassLaborMatrix.earningType, Equal <Required <EPEarningType.typeCD> > > > .Select(this, row.TypeCD); if (caseClassLabor != null) { throw new PXException(Messages.CannotDeleteInUse); } EPContractRate contractRate = PXSelect <EPContractRate, Where <EPContractRate.earningType, Equal <Required <EPEarningType.typeCD> > > > .Select(this, row.TypeCD); if (contractRate != null) { throw new PXException(Messages.CannotDeleteInUse); } EPEmployeeClassLaborMatrix employeeLabor = PXSelect <EPEmployeeClassLaborMatrix, Where <EPEmployeeClassLaborMatrix.earningType, Equal <Required <EPEarningType.typeCD> > > > .Select(this, row.TypeCD); if (employeeLabor != null) { throw new PXException(Messages.CannotDeleteInUse); } PMTimeActivity activity = PXSelect <PMTimeActivity, Where <PMTimeActivity.earningTypeID, Equal <Required <EPEarningType.typeCD> > > > .Select(this, row.TypeCD); if (activity != null) { throw new PXException(Messages.CannotDeleteInUse); } PMTran pmTran = PXSelect <PMTran, Where <PMTran.earningType, Equal <Required <EPEarningType.typeCD> > > > .Select(this, row.TypeCD); if (pmTran != null) { throw new PXException(Messages.CannotDeleteInUse); } }
public static void UpdateReportedInTimeZoneIDIfNeeded(PXCache cache, PMTimeActivity row, DateTime?oldValue, DateTime?newValue) { if (oldValue != newValue) { string timeZoneID = newValue != null?LocaleInfo.GetTimeZone()?.Id : null; cache.SetValueExt <PMTimeActivity.reportedInTimeZoneID>(row, timeZoneID); } }
protected virtual void _(Events.FieldUpdated <CRActivity, CRActivity.uistatus> e) { PMTimeActivity timeActivity = (PMTimeActivity)TimeActivity.SelectSingle(); if (timeActivity != null) { Caches[typeof(PMTimeActivity)].MarkUpdated(timeActivity); //For Persisting event handler to sync Status. } }
public static void PMTimeActivity_RowSelected_Handler(PXCache cache, PMTimeActivity pmTimeActivityRow) { FSxPMTimeActivity fsxPMTimeActivityRow = cache.GetExtension <FSxPMTimeActivity>(pmTimeActivityRow); PXUIFieldAttribute.SetEnabled <FSxPMTimeActivity.appointmentID>(cache, pmTimeActivityRow, false); PXUIFieldAttribute.SetEnabled <FSxPMTimeActivity.appointmentCustomerID>(cache, pmTimeActivityRow, false); PXUIFieldAttribute.SetEnabled <FSxPMTimeActivity.sOID>(cache, pmTimeActivityRow, false); PXUIFieldAttribute.SetEnabled <FSxPMTimeActivity.appEmpID>(cache, pmTimeActivityRow, false); PXUIFieldAttribute.SetEnabled <FSxPMTimeActivity.serviceID>(cache, pmTimeActivityRow, false); }
public virtual int?GetLaborClass(PMTimeActivity activity) { CRCase refCase = PXSelectJoin <CRCase, InnerJoin <CRActivityLink, On <CRActivityLink.refNoteID, Equal <CRCase.noteID> > >, Where <CRActivityLink.noteID, Equal <Required <PMTimeActivity.refNoteID> > > > .Select(graph, activity.RefNoteID); EPEmployee employee = PXSelect <EPEmployee> .Search <EPEmployee.userID>(graph, activity.OwnerID); return(GetLaborClass(activity, employee, refCase)); }
public static string GetCalendarID(PXGraph graph, PMTimeActivity act) { var projectCalendar = act.ProjectID. With(_ => (CT.Contract)PXSelect <CT.Contract, Where <CT.Contract.contractID, Equal <Required <CT.Contract.contractID> > > > . Select(graph, _.Value)). With(_ => _.CalendarID); if (projectCalendar != null) { return(projectCalendar); } var projectTaskCalendar = act.ProjectTaskID. With(_ => (PXResult <Location, PM.PMTask>)PXSelectJoin <Location, InnerJoin <PM.PMTask, On <PM.PMTask.customerID, Equal <Location.bAccountID>, And <PM.PMTask.locationID, Equal <Location.locationID> > > >, Where <PM.PMTask.taskID, Equal <Required <PM.PMTask.taskID> > > > . Select(graph, _.Value)). With(_ => ((Location)_).CCalendarID); if (projectTaskCalendar != null) { return(projectTaskCalendar); } var caseLocationCalendar = act.RefNoteID. With(_ => (PXResult <Location, CRCase>)PXSelectJoin <Location, InnerJoin <CRCase, On <CRCase.customerID, Equal <Location.bAccountID>, And <CRCase.locationID, Equal <Location.locationID> > >, InnerJoin <CRActivityLink, On <CRActivityLink.refNoteID, Equal <CRCase.noteID> > > >, Where <CRActivityLink.noteID, Equal <Required <PMTimeActivity.refNoteID> > > > . Select(graph, _.Value)). With(_ => ((Location)_).CCalendarID); if (caseLocationCalendar != null) { return(caseLocationCalendar); } var employeeCalendar = act.OwnerID. With(_ => (EPEmployee)PXSelect <EPEmployee, Where <EPEmployee.userID, Equal <Required <EPEmployee.userID> > > > . Select(graph, _.Value)). With(_ => _.CalendarID); if (employeeCalendar != null) { return(employeeCalendar); } return(null); }
public virtual LaborCost CalculateEmployeeCost(string timeCardCD, string earningTypeID, int?laborItemID, int?projectID, int?projectTaskID, bool?certifiedJob, string unionID, int?employeeID, DateTime date) { decimal?cost; decimal overtimeMult = 1; Rate employeeRate = GetEmployeeRate(laborItemID, projectID, projectTaskID, certifiedJob, unionID, employeeID, date); if (employeeRate == null) { return(null); } if (employeeRate.Type == RateTypesAttribute.SalaryWithExemption && timeCardCD != null) { //Overtime is not applicable. Rate is prorated based on actual hours worked on the given week EPTimeCard timecard = PXSelect <EPTimeCard, Where <EPTimeCard.timeCardCD, Equal <Required <PMTimeActivity.timeCardCD> > > > .Select(graph, timeCardCD); if (timecard.TotalSpentCalc == null) { var select = new PXSelectGroupBy <PMTimeActivity, Where <PMTimeActivity.timeCardCD, Equal <Required <PMTimeActivity.timeCardCD> > >, Aggregate <Sum <PMTimeActivity.timeSpent> > >(graph); PMTimeActivity total = select.Select(timeCardCD); timecard.TotalSpentCalc = total.TimeSpent; } if (timecard.TotalSpentCalc <= employeeRate.RegularHours * 60m) { cost = employeeRate.RateByType / employeeRate.RegularHours; } else { cost = employeeRate.RateByType / (timecard.TotalSpentCalc / 60m); } } else { overtimeMult = GetOvertimeMultiplier(earningTypeID, employeeRate); cost = employeeRate.HourlyRate * overtimeMult; } return(new LaborCost(cost, overtimeMult)); }
private void UpdateSubject(PXCache cache, PMTimeActivity pmTimeActivityRow, CRActivity crActivityRow) { FSxPMTimeActivity fsxPMTimeActivityRow = cache.GetExtension <FSxPMTimeActivity>(pmTimeActivityRow); //Clean the Subject if (crActivityRow.Subject != null) { int positionPipe = crActivityRow.Subject.IndexOf("|"); if (positionPipe != -1) { crActivityRow.Subject = crActivityRow.Subject.Substring(positionPipe + 1).Trim(); if (crActivityRow.Subject == string.Empty) { crActivityRow.Subject = null; } } } if (fsxPMTimeActivityRow.ServiceID != null) { InventoryItem inventoryItemRow = PXSelect <InventoryItem, Where < InventoryItem.inventoryID, Equal <Required <InventoryItem.inventoryID> > > > .Select(Base, fsxPMTimeActivityRow.ServiceID); if (inventoryItemRow != null) { if (inventoryItemRow.ItemType == INItemTypes.ServiceItem) { if (string.IsNullOrWhiteSpace(crActivityRow.Subject)) { crActivityRow.Subject = string.Empty; } crActivityRow.Subject = TX.ModuleName.SERVICE_DESCRIPTOR + inventoryItemRow.Descr + " | " + crActivityRow.Subject; } } } }
public static int?GetContractLaborClassID(PXGraph graph, PMTimeActivity activity) { EPContractRate matrix = PXSelectJoin < EPContractRate, InnerJoin <CRCase, On <CRCase.contractID, Equal <EPContractRate.contractID> >, InnerJoin <CRActivityLink, On <CRActivityLink.refNoteID, Equal <CRCase.noteID> >, InnerJoin <EPEmployee, On <EPContractRate.employeeID, Equal <EPEmployee.bAccountID> > > > >, Where <CRActivityLink.noteID, Equal <Required <PMTimeActivity.refNoteID> >, And <EPContractRate.earningType, Equal <Required <PMTimeActivity.earningTypeID> >, And <EPEmployee.userID, Equal <Required <PMTimeActivity.ownerID> > > > > > .Select(graph, new object[] { activity.RefNoteID, activity.EarningTypeID, activity.OwnerID }); if (matrix == null) { matrix = PXSelectJoin < EPContractRate, InnerJoin <CRCase, On <CRCase.contractID, Equal <EPContractRate.contractID> >, InnerJoin <CRActivityLink, On <CRActivityLink.refNoteID, Equal <CRCase.noteID> > > >, Where <CRActivityLink.noteID, Equal <Required <PMTimeActivity.refNoteID> >, And <EPContractRate.earningType, Equal <Required <PMTimeActivity.earningTypeID> >, And <EPContractRate.employeeID, IsNull> > > > .Select(graph, new object[] { activity.RefNoteID, activity.EarningTypeID }); } if (matrix != null) { return(matrix.LabourItemID); } else { return(null); } }
private void InsertUpdateDeleteSODet( ServiceOrderEntry graphServiceOrder, PMTimeActivity pmTimeActivityRow, FSxPMTimeActivity fsxPMTimeActivityRow, PXDBOperation operation) { FSSODetService fsSODetServiceRow; graphServiceOrder.ServiceOrderDetServices.Current = graphServiceOrder.ServiceOrderDetServices .Search <FSSODet.sourceNoteID>(pmTimeActivityRow.NoteID); if (graphServiceOrder.ServiceOrderDetServices.Current != null) { if (operation == PXDBOperation.Delete || fsxPMTimeActivityRow.ServiceID == null) { graphServiceOrder.ServiceOrderDetServices.Delete(graphServiceOrder.ServiceOrderDetServices.Current); return; } } else { //This line does not require appointment if (fsxPMTimeActivityRow.ServiceID == null) { return; } //Insert a new SODet line fsSODetServiceRow = new FSSODetService(); //Assign the PMTimeActivity reference to the new FSSODet line fsSODetServiceRow.SourceNoteID = pmTimeActivityRow.NoteID; graphServiceOrder.ServiceOrderDetServices.Current = graphServiceOrder.ServiceOrderDetServices.Insert(fsSODetServiceRow); } //Update the SODet line UpdateSODetServiceRow(graphServiceOrder, graphServiceOrder.ServiceOrderDetServices.Current, pmTimeActivityRow, fsxPMTimeActivityRow); }
protected virtual void PMTask_RowDeleting(PXCache sender, PXRowDeletingEventArgs e) { PMTask row = e.Row as PMTask; if (row == null) { return; } if (row.IsActive == true && row.IsCancelled == false) { throw new PXException(Messages.OnlyPlannedCanbeDeleted); } //validate that all child records can be deleted: PMTran tran = PXSelect <PMTran, Where <PMTran.projectID, Equal <Required <PMTask.projectID> >, And <PMTran.taskID, Equal <Required <PMTask.taskID> > > > > .SelectWindowed(this, 0, 1, row.ProjectID, row.TaskID); if (tran != null) { throw new PXException(Messages.HasTranData); } PMTimeActivity activity = PXSelect <PMTimeActivity, Where <PMTimeActivity.projectID, Equal <Required <PMTask.projectID> >, And <PMTimeActivity.projectTaskID, Equal <Required <PMTask.taskID> > > > > .SelectWindowed(this, 0, 1, row.ProjectID, row.TaskID); if (activity != null) { throw new PXException(Messages.HasActivityData); } EP.EPTimeCardItem timeCardItem = PXSelect <EP.EPTimeCardItem, Where <EP.EPTimeCardItem.projectID, Equal <Required <PMTask.projectID> >, And <EP.EPTimeCardItem.taskID, Equal <Required <PMTask.taskID> > > > > .SelectWindowed(this, 0, 1, row.ProjectID, row.TaskID); if (timeCardItem != null) { throw new PXException(Messages.HasTimeCardItemData); } }
protected virtual void PMTimeActivity_ProjectID_FieldVerifying(PXCache sender, PXFieldVerifyingEventArgs e) { PMTimeActivity row = (PMTimeActivity)e.Row; if (row == null) { return; } if (e.NewValue != null && e.NewValue is int) { PMProject proj = PXSelect <PMProject> .Search <PMProject.contractID>(sender.Graph, e.NewValue); if (proj != null) { if (proj.IsCompleted == true) { var ex = new PXSetPropertyException(PM.Messages.ProjectIsCompleted); ex.ErrorValue = proj.ContractCD; throw ex; } if (proj.IsCancelled == true) { var ex = new PXSetPropertyException(PM.Messages.ProjectIsCanceled); ex.ErrorValue = proj.ContractCD;; throw ex; } if (proj.Status == CT.Contract.status.Expired) { var ex = new PXSetPropertyException(PM.Messages.ProjectIsSuspended); ex.ErrorValue = proj.ContractCD;; throw ex; } } } }
public static DateTime?GetNextActivityStartDate <Activity>(PXGraph graph, PXResultset <Activity> res, PMTimeActivity row, int?fromWeekId, int?tillWeekId, PXCache tempDataCache, Type tempDataField) where Activity : PMTimeActivity, new() { DateTime?date; if (fromWeekId != null || tillWeekId != null) { date = PXWeekSelector2Attribute.GetWeekStartDate(graph, (int)(fromWeekId ?? tillWeekId)); } else { date = graph.Accessinfo.BusinessDate.GetValueOrDefault(DateTime.Now).Date; } EPEmployee employee = PXSelect <EPEmployee, Where <EPEmployee.userID, Equal <Required <EPEmployee.userID> > > > .Select(graph, row.OwnerID); EPEmployeeClass employeeClass = PXSelect <EPEmployeeClass, Where <EPEmployeeClass.vendorClassID, Equal <Required <EPEmployee.vendorClassID> > > > .Select(graph, employee != null?employee.VendorClassID : null); var calendarId = CRActivityMaint.GetCalendarID(graph, row); if (employeeClass != null && EPEmployeeClass.defaultDateInActivity.LastDay == employeeClass.DefaultDateInActivity) { DateTime?val = tempDataCache.GetValue(tempDataCache.Current, tempDataField.Name) as DateTime?; if (val != null) { int week = PXWeekSelector2Attribute.GetWeekID(graph, (DateTime)val); if ((fromWeekId == null || week >= fromWeekId) && (tillWeekId == null || tillWeekId >= week)) { date = val; } } } else { DateTime weekDate = (DateTime)date; DateTime?newDate = null; date = res != null && res.Count > 0 ? res.Max(_ => ((Activity)_).Date) : null ?? date; for (int curentWeek = PXWeekSelector2Attribute.GetWeekID(graph, weekDate); tillWeekId == null || curentWeek <= tillWeekId; curentWeek = PXWeekSelector2Attribute.GetWeekID(graph, weekDate)) { PXWeekSelector2Attribute.WeekInfo week1 = PXWeekSelector2Attribute.GetWeekInfo(graph, PXWeekSelector2Attribute.GetWeekID(graph, weekDate)); foreach (KeyValuePair <DayOfWeek, PXWeekSelector2Attribute.DayInfo> pair in week1.Days.OrderBy(_ => _.Value.Date)) { if (pair.Value.Date >= date && (CalendarHelper.IsWorkDay(graph, calendarId, (DateTime)pair.Value.Date) || string.IsNullOrEmpty(calendarId) && pair.Key != DayOfWeek.Saturday && pair.Key != DayOfWeek.Sunday)) { newDate = (DateTime)pair.Value.Date; break; } weekDate = weekDate.AddDays(1D); } if (newDate != null) { date = ((DateTime)newDate).Date; break; } } } if (!string.IsNullOrEmpty(calendarId) && date != null) { DateTime startDate; DateTime endDate; CalendarHelper.CalculateStartEndTime(graph, calendarId, (DateTime)date, out startDate, out endDate); date = startDate; } return(date); }
public static TimeSpan CalculateOvertime(PXGraph graph, PMTimeActivity act, DateTime start, DateTime end) { var calendarId = GetCalendarID(graph, act); return(calendarId == null ? new TimeSpan() : CalendarHelper.CalculateOvertime(graph, start, end, calendarId)); }
public static void PMTimeActivity_RowPersisting_Handler(PXCache cache, PXGraph graph, PMTimeActivity pmTimeActivityRow, PXRowPersistingEventArgs e) { FSxPMTimeActivity fsxPMTimeActivityRow = PXCache <PMTimeActivity> .GetExtension <FSxPMTimeActivity>(pmTimeActivityRow); if (e.Operation == PXDBOperation.Delete && graph.Accessinfo.ScreenID != SharedFunctions.SetScreenIDToDotFormat(ID.ScreenID.APPOINTMENT)) { if (fsxPMTimeActivityRow.AppointmentID != null && fsxPMTimeActivityRow.LogLineNbr != null) { PXUpdate < Set <FSAppointmentLog.trackTime, False>, FSAppointmentLog, Where < FSAppointmentLog.docID, Equal <Required <FSAppointmentLog.docID> >, And <FSAppointmentLog.lineNbr, Equal <Required <FSAppointmentLog.lineNbr> > > > > .Update(graph, fsxPMTimeActivityRow.AppointmentID, fsxPMTimeActivityRow.LogLineNbr); } } if ((e.Operation == PXDBOperation.Insert || e.Operation == PXDBOperation.Update) && !IsAccessedFromAppointment(graph.Accessinfo.ScreenID)) { if (fsxPMTimeActivityRow.AppointmentID != null && fsxPMTimeActivityRow.LogLineNbr != null && ( (int?)cache.GetValueOriginal <EPActivityApprove.timeSpent>(pmTimeActivityRow) != pmTimeActivityRow.TimeSpent || (int?)cache.GetValueOriginal <EPActivityApprove.timeBillable>(pmTimeActivityRow) != pmTimeActivityRow.TimeBillable || (bool?)cache.GetValueOriginal <EPActivityApprove.isBillable>(pmTimeActivityRow) != pmTimeActivityRow.IsBillable)) { AppointmentEntry graphAppointmentEntry = PXGraph.CreateInstance <AppointmentEntry>(); FSAppointment fsAppointmentRow = PXSelect <FSAppointment, Where < FSAppointment.appointmentID, Equal <Required <FSAppointment.appointmentID> > > > .Select(graph, fsxPMTimeActivityRow.AppointmentID); FSAppointmentLog fsAppointmentLogRow = PXSelect <FSAppointmentLog, Where < FSAppointmentLog.docID, Equal <Required <FSAppointmentLog.docID> >, And <FSAppointmentLog.lineNbr, Equal <Required <FSAppointmentLog.lineNbr> > > > > .Select(graph, fsxPMTimeActivityRow.AppointmentID, fsxPMTimeActivityRow.LogLineNbr); fsAppointmentRow = graphAppointmentEntry.AppointmentRecords.Current = graphAppointmentEntry.AppointmentRecords.Search <FSAppointment.appointmentID> (fsAppointmentRow.AppointmentID, fsAppointmentRow.SrvOrdType); graphAppointmentEntry.SkipTimeCardUpdate = true; fsAppointmentLogRow.TimeDuration = pmTimeActivityRow.TimeSpent; fsAppointmentLogRow.EarningType = pmTimeActivityRow.EarningTypeID; FSSrvOrdType fsSrvOrdTypeRow = graphAppointmentEntry.ServiceOrderTypeSelected.Current; if (fsSrvOrdTypeRow != null && fsSrvOrdTypeRow.PostTo == ID.SrvOrdType_PostTo.PROJECTS && fsSrvOrdTypeRow.BillingType == ID.SrvOrdType_BillingType.COST_AS_COST && fsSrvOrdTypeRow.CreateTimeActivitiesFromAppointment == true) { fsAppointmentLogRow.IsBillable = pmTimeActivityRow.IsBillable; fsAppointmentLogRow.BillableTimeDuration = pmTimeActivityRow.TimeBillable; } fsAppointmentLogRow = graphAppointmentEntry.LogRecords.Update(fsAppointmentLogRow); graphAppointmentEntry.Save.Press(); } } }
///NO CRM Mode public static PMTran CreateContractUsage(RegisterEntry graph, int?contractID, PMTimeActivity timeActivity, int billableMinutes) { if (timeActivity.ApprovalStatus == ActivityStatusListAttribute.Canceled) { return(null); } if (timeActivity.IsBillable != true) { return(null); } Contract contract = PXSelect <Contract, Where <Contract.contractID, Equal <Required <Contract.contractID> > > > .Select(graph, contractID); if (contract == null) { return(null); //activity has no contract and will be billed through Project using the cost-transaction. Contract-Usage is not created in this case. } int?laborItemID = GetContractLaborClassID(graph, contractID, timeActivity);; if (laborItemID == null) { EPEmployee employeeSettings = PXSelect <EPEmployee, Where <EPEmployee.userID, Equal <Required <EPEmployee.userID> > > > .Select(graph, timeActivity.OwnerID); if (employeeSettings != null) { laborItemID = EPEmployeeClassLaborMatrix.GetLaborClassID(graph, employeeSettings.BAccountID, timeActivity.EarningTypeID) ?? employeeSettings.LabourItemID; } } InventoryItem laborItem = PXSelect <InventoryItem, Where <InventoryItem.inventoryID, Equal <Required <InventoryItem.inventoryID> > > > .Select(graph, laborItemID); if (laborItem == null) { throw new PXException(PX.Objects.CR.Messages.LaborNotConfigured); } //save the sign of the value and do the rounding against absolute value. //reuse sign later when setting value to resulting transaction. int sign = billableMinutes < 0 ? -1 : 1; billableMinutes = Math.Abs(billableMinutes); if (billableMinutes > 0) { PMTran newLabourTran = new PMTran(); newLabourTran.ProjectID = contractID; newLabourTran.InventoryID = laborItem.InventoryID; newLabourTran.AccountGroupID = contract.ContractAccountGroup; newLabourTran.OrigRefID = timeActivity.NoteID; newLabourTran.BAccountID = contract.CustomerID; newLabourTran.LocationID = contract.LocationID; newLabourTran.Description = timeActivity.Summary; newLabourTran.StartDate = timeActivity.Date; newLabourTran.EndDate = timeActivity.Date; newLabourTran.Date = timeActivity.Date; newLabourTran.UOM = laborItem.SalesUnit; newLabourTran.Qty = sign * Convert.ToDecimal(TimeSpan.FromMinutes(billableMinutes).TotalHours); newLabourTran.BillableQty = newLabourTran.Qty; newLabourTran.Released = true; newLabourTran.Allocated = true; newLabourTran.IsQtyOnly = true; newLabourTran.BillingID = contract.BillingID; return(graph.Transactions.Insert(newLabourTran)); } else { return(null); } }
public static void PMTimeActivity_RowPersisting_Handler(PXCache cache, PXGraph graph, PMTimeActivity pmTimeActivityRow, PXRowPersistingEventArgs e) { FSxPMTimeActivity fsxPMTimeActivityRow = PXCache <PMTimeActivity> .GetExtension <FSxPMTimeActivity>(pmTimeActivityRow); if (e.Operation == PXDBOperation.Delete && graph.Accessinfo.ScreenID != SharedFunctions.SetScreenIDToDotFormat(ID.ScreenID.APPOINTMENT)) { if (fsxPMTimeActivityRow.AppointmentID != null && fsxPMTimeActivityRow.AppEmpID != null) { PXUpdate <Set <FSAppointmentEmployee.trackTime, False>, FSAppointmentEmployee, Where < FSAppointmentEmployee.appointmentID, Equal <Required <FSAppointmentEmployee.appointmentID> >, And <FSAppointmentEmployee.lineNbr, Equal <Required <FSAppointmentEmployee.lineNbr> > > > > .Update(graph, fsxPMTimeActivityRow.AppointmentID, fsxPMTimeActivityRow.AppEmpID); } } if ((e.Operation == PXDBOperation.Insert || e.Operation == PXDBOperation.Update) && graph.Accessinfo.ScreenID != SharedFunctions.SetScreenIDToDotFormat(ID.ScreenID.APPOINTMENT)) { if (fsxPMTimeActivityRow.AppointmentID != null && fsxPMTimeActivityRow.AppEmpID != null && fsxPMTimeActivityRow.ServiceID != null && (int?)cache.GetValueOriginal <EPActivityApprove.timeSpent>(pmTimeActivityRow) != pmTimeActivityRow.TimeSpent) { AppointmentEntry graphAppointmentEntry = PXGraph.CreateInstance <AppointmentEntry>(); FSAppointment fsAppointmentRow = PXSelect <FSAppointment, Where <FSAppointment.appointmentID, Equal <Required <FSAppointment.appointmentID> > > > .Select(graph, fsxPMTimeActivityRow.AppointmentID); FSAppointmentEmployee fsAppointmentEmployeeRow = PXSelect <FSAppointmentEmployee, Where < FSAppointmentEmployee.appointmentID, Equal <Required <FSAppointmentEmployee.appointmentID> >, And <FSAppointmentEmployee.lineNbr, Equal <Required <FSAppointmentEmployee.lineNbr> > > > > .Select(graph, fsxPMTimeActivityRow.AppointmentID, fsxPMTimeActivityRow.AppEmpID); fsAppointmentRow = graphAppointmentEntry.AppointmentRecords.Current = graphAppointmentEntry.AppointmentRecords.Search <FSAppointment.appointmentID> (fsAppointmentRow.AppointmentID, fsAppointmentRow.SrvOrdType); graphAppointmentEntry.SkipTimeCardUpdate = true; fsAppointmentEmployeeRow.ActualDuration = pmTimeActivityRow.TimeSpent; AppointmentDateTimeHelper.UpdateStaffActualDateTimeEndFromActualDuration(fsAppointmentEmployeeRow); fsAppointmentEmployeeRow.EarningType = pmTimeActivityRow.EarningTypeID; fsAppointmentEmployeeRow = graphAppointmentEntry.AppointmentEmployees.Update(fsAppointmentEmployeeRow); graphAppointmentEntry.Save.Press(); } } }