public async Task <TimeAndAttendancePunchIn> IsPunchOpen(long?employeeId, DateTime asOfDate)
{
//bool retVal = false;
try
{
Udc taskStatusQuery = await base.GetUdc2("TA_STATUS", TypeOfTAStatus.Open.ToString().ToUpper());
TimeAndAttendancePunchIn TAPunch = await(from e in _dbContext.TimeAndAttendancePunchIn
where e.EmployeeId == employeeId &&
e.PunchinDate >= asOfDate &&
e.PunchoutDate <= asOfDate &&
e.TaskStatusXrefId == taskStatusQuery.XrefId
select e
).FirstOrDefaultAsync <TimeAndAttendancePunchIn>();
//retVal = list.Any(e => e.EmployeeId == employeeId);
return(TAPunch);
}
catch (Exception ex)
{
throw new Exception(GetMyMethodName(), ex);
}
}
public override async Task <ProjectManagementTaskView> MapToView(ProjectManagementTask inputObject)
{
Mapper mapper = new Mapper();
ProjectManagementTaskView outObject = mapper.Map <ProjectManagementTaskView>(inputObject);
ProjectManagementProject project = await _unitOfWork.projectManagementProjectRepository.GetEntityById(inputObject.ProjectId);
ProjectManagementMilestone milestone = await _unitOfWork.projectManagementMilestoneRepository.GetEntityById(1);
Udc udc = await _unitOfWork.udcRepository.GetEntityById(21);
ProjectManagementWorkOrder workOrder = await _unitOfWork.projectManagementWorkOrderRepository.GetEntityById(7);
ChartOfAccount account = await _unitOfWork.chartOfAccountRepository.GetEntityById(4);
FluentProjectManagementWorkOrderToEmployee WorkToEmployee = new FluentProjectManagementWorkOrderToEmployee(_unitOfWork);
IList <ProjectManagementWorkOrderToEmployeeView> views = await WorkToEmployee.Query().GetViewsByWorkOrderId(workOrder.WorkOrderId);
outObject.ProjectName = project.ProjectName;
outObject.Status = udc.Value;
outObject.Instructions = workOrder.Instructions;
outObject.Account = account.Account;
outObject.WorkOrderToEmployeeViews = views;
return(outObject);
}
public async Task TestAddUpdatDelete()
{
AddressBook customerAddressBook = null;
AddressBook employeeAddressBook = null;
CustomerClaimModule CustomerClaimMod = new CustomerClaimModule();
Udc udc = await CustomerClaimMod.Udc.Query().GetEntityById(39);
Customer customer = await CustomerClaimMod.Customer.Query().GetEntityById(2);
if (customer != null)
{
customerAddressBook = await CustomerClaimMod.AddressBook.Query().GetEntityById(customer.AddressId);
}
Employee employee = await CustomerClaimMod.Employee.Query().GetEntityById(3);
if (employee != null)
{
employeeAddressBook = await CustomerClaimMod.AddressBook.Query().GetEntityById(employee.AddressId);
}
Udc groupUdc = await CustomerClaimMod.Udc.Query().GetEntityById(37);
CustomerClaimView view = new CustomerClaimView()
{
ClassificationXrefId = udc.XrefId,
Classification = udc.Value,
CustomerId = customer.CustomerId,
CustomerName = customerAddressBook?.Name,
Configuration = "Javascript Dashboard",
Note = "larger images",
EmployeeId = employee?.EmployeeId ?? 0,
EmployeeName = employeeAddressBook?.Name,
GroupIdXrefId = groupUdc.XrefId,
GroupId = groupUdc.Value,
CreatedDate = DateTime.Parse("11/16/2019")
};
NextNumber nnNextNumber = await CustomerClaimMod.CustomerClaim.Query().GetNextNumber();
view.CustomerClaimNumber = nnNextNumber.NextNumberValue;
CustomerClaim customerClaim = await CustomerClaimMod.CustomerClaim.Query().MapToEntity(view);
CustomerClaimMod.CustomerClaim.AddCustomerClaim(customerClaim).Apply();
CustomerClaim newCustomerClaim = await CustomerClaimMod.CustomerClaim.Query().GetEntityByNumber(view.CustomerClaimNumber);
Assert.NotNull(newCustomerClaim);
newCustomerClaim.Note = "larger image update";
CustomerClaimMod.CustomerClaim.UpdateCustomerClaim(newCustomerClaim).Apply();
CustomerClaimView updateView = await CustomerClaimMod.CustomerClaim.Query().GetViewById(newCustomerClaim.ClaimId);
Assert.Same(updateView.Note, "large image update");
CustomerClaimMod.CustomerClaim.DeleteCustomerClaim(newCustomerClaim).Apply();
CustomerClaim lookupCustomerClaim = await CustomerClaimMod.CustomerClaim.Query().GetEntityById(view.ClaimId);
Assert.Null(lookupCustomerClaim);
}
public async Task TestAddUpdatDelete()
{
UdcModule UdcMod = new UdcModule();
UdcView view = new UdcView()
{
ProductCode = "Test",
KeyCode = "TestCode",
Value = "TestValue"
};
NextNumber nnNextNumber = await UdcMod.Udc.Query().GetNextNumber();
view.UdcNumber = nnNextNumber.NextNumberValue;
Udc udc = await UdcMod.Udc.Query().MapToEntity(view);
UdcMod.Udc.AddUdc(udc).Apply();
Udc newUdc = await UdcMod.Udc.Query().GetEntityByNumber(view.UdcNumber);
Assert.NotNull(newUdc);
newUdc.KeyCode = "KeyCodeTest";
UdcMod.Udc.UpdateUdc(newUdc).Apply();
UdcView updateView = await UdcMod.Udc.Query().GetViewById(newUdc.XrefId);
Assert.Same(updateView.KeyCode, "KeyCodeTest");
UdcMod.Udc.DeleteUdc(newUdc).Apply();
Udc lookupUdc = await UdcMod.Udc.Query().GetEntityById(view.XrefId);
Assert.Null(lookupUdc);
}
public async Task <bool> CreateIncome(GeneralLedgerView glView)
{
try
{
//ChartOfAccts coa = await unitOfWork.generalLedgerRepository.GetChartofAccount("1000", "1200", "300", "");
ChartOfAccount coa = await ChartOfAccounts.Query().GetEntity("1000", "1200", "300", "");
//Udc udcLedgerType = await unitOfWork.generalLedgerRepository.GetUdc("GENERALLEDGERTYPE", "AA");
Udc udcLedgerType = await UDC.Query().GetUdc("GENERALLEDGERTYPE", "AA");
Udc udcDocType = await UDC.Query().GetUdc("DOCTYPE", "PV");
//Udc udcDocType = await unitOfWork.generalLedgerRepository.GetUdc("DOCTYPE","PV");
//AddressBook addressBook = await unitOfWork.addressBookRepository.GetAddressBookByAddressId(addressId);
AddressBook addressBook = await AddressBook.Query().GetEntityById(glView.AddressId);
glView.DocType = udcDocType.KeyCode;
glView.AccountId = coa.AccountId;
glView.LedgerType = udcLedgerType.KeyCode;
glView.CreatedDate = DateTime.Now;
glView.AddressId = addressBook.AddressId;
glView.FiscalPeriod = glView.GLDate.Month;
glView.FiscalYear = glView.GLDate.Year;
glView.DebitAmount = glView.Amount;
glView.CreditAmount = 0;
GeneralLedgerView glLookup = null;
if (String.IsNullOrEmpty(glView.CheckNumber) == false)
{
glLookup = await GeneralLedger.Query().GetLedgerViewByExpression(
e => e.AccountId == glView.AccountId &&
e.AddressId == glView.AddressId &&
e.Amount == glView.Amount &&
e.CheckNumber == glView.CheckNumber &&
e.DocType == glView.DocType &&
e.Gldate == glView.GLDate
);
}
if (glLookup == null)
{
//create income
GeneralLedger.CreateGeneralLedgerByView(glView).Apply();
GeneralLedger.UpdateAccountBalances(glView);
GeneralLedgerView glViewLookup = await GeneralLedger.Query().GetViewByDocNumber(glView.DocNumber, glView.DocType);
return(glViewLookup != null);
}
else
{
glView.DocNumber = glLookup.DocNumber;
}
return(true);
}
catch (Exception ex) { throw new Exception("CreateCash", ex); }
}
public override async Task <SalesOrderDetailView> MapToView(SalesOrderDetail inputObject)
{
SalesOrderDetailView outObject = mapper.Map <SalesOrderDetailView>(inputObject);
Udc carrierUdc = null;
Carrier carrier = await _unitOfWork.carrierRepository.GetEntityById(2);
if (carrier != null)
{
carrierUdc = await _unitOfWork.udcRepository.GetEntityById(carrier.CarrierTypeXrefId);
}
Task <SalesOrder> salesOrderTask = _unitOfWork.salesOrderRepository.GetEntityById(inputObject.SalesOrderId);
Task <ItemMaster> itemMasterTask = _unitOfWork.itemMasterRepository.GetEntityById(inputObject.ItemId);
Task <ChartOfAccount> accountTask = _unitOfWork.chartOfAccountRepository.GetEntityById(inputObject.AccountId);
Task <PurchaseOrder> purchaseOrderTask = _unitOfWork.purchaseOrderRepository.GetEntityById(inputObject.CarrierId ?? 0);
Task <PurchaseOrderDetail> purchaseOrderDetailTask = _unitOfWork.purchaseOrderDetailRepository.GetEntityById(inputObject.PurchaseOrderDetailId);
Task.WaitAll(salesOrderTask, itemMasterTask, accountTask, purchaseOrderTask, purchaseOrderDetailTask);
outObject.ItemDescription2 = itemMasterTask.Result.Description2;
outObject.Account = accountTask.Result.Account;
outObject.BusUnit = accountTask.Result.BusUnit;
outObject.CarrierName = carrierUdc.Value;
outObject.CompanyCode = accountTask.Result.CompanyCode;
outObject.CarrierName = carrierUdc.Value;
outObject.PurchaseOrderId = purchaseOrderTask.Result?.PurchaseOrderId;
outObject.PurchaseOrderDetailId = purchaseOrderDetailTask.Result?.PurchaseOrderDetailId;
await Task.Yield();
return(outObject);
}
public async Task TestAddUpdatDelete()
{
ServiceInformationModule ServiceInformationMod = new ServiceInformationModule();
LocationAddressView locationAddressView = await ServiceInformationMod.LocationAddress.Query().GetViewById(3);
CustomerView customerView = await ServiceInformationMod.Customer.Query().GetViewById(3);
AddressBook addressBook = await ServiceInformationMod.AddressBook.Query().GetEntityById(customerView.AddressId);
ContractView contractView = await ServiceInformationMod.Contract.Query().GetViewById(1);
Udc udc = await ServiceInformationMod.Udc.Query().GetEntityById(2);
ServiceInformationView view = new ServiceInformationView()
{
ServiceDescription = " truck oil change",
Price = 80.76M,
AddOns = "none",
ServiceTypeXrefId = udc.XrefId,
ServiceType = udc.Value,
CreatedDate = DateTime.Parse("12/25/2019"),
LocationId = locationAddressView.LocationAddressId,
CustomerId = customerView.CustomerId,
ContractId = contractView.ContractId,
vwCustomer = customerView,
vwContract = contractView,
vwLocationAddress = locationAddressView,
SquareFeetOfStructure = 100,
LocationDescription = "Eiensten brothers on orchard",
LocationGps = "",
Comments = "",
Status = true
};
NextNumber nnNextNumber = await ServiceInformationMod.ServiceInformation.Query().GetNextNumber();
view.ServiceInformationNumber = nnNextNumber.NextNumberValue;
ServiceInformation serviceInformation = await ServiceInformationMod.ServiceInformation.Query().MapToEntity(view);
ServiceInformationMod.ServiceInformation.AddServiceInformation(serviceInformation).Apply();
ServiceInformation newServiceInformation = await ServiceInformationMod.ServiceInformation.Query().GetEntityByNumber(view.ServiceInformationNumber);
Assert.NotNull(newServiceInformation);
newServiceInformation.ServiceDescription = "ServiceInformation Test Update";
ServiceInformationMod.ServiceInformation.UpdateServiceInformation(newServiceInformation).Apply();
ServiceInformationView updateView = await ServiceInformationMod.ServiceInformation.Query().GetViewById(newServiceInformation.ServiceId);
Assert.Same(updateView.ServiceDescription, "ServiceInformation Test Update");
ServiceInformationMod.ServiceInformation.DeleteServiceInformation(newServiceInformation).Apply();
ServiceInformation lookupServiceInformation = await ServiceInformationMod.ServiceInformation.Query().GetEntityById(view.ServiceId);
Assert.Null(lookupServiceInformation);
}
public async Task TestTaskToProjectRollup()
{
ProjectManagementModule pmMod = new ProjectManagementModule();
ProjectManagementProject project = await pmMod.Project.Query().GetEntityById(1);
ProjectManagementMilestone milestone = await pmMod.Milestone.Query().GetEntityById(1);
Udc udc = await pmMod.Udc.Query().GetEntityById(21);
ChartOfAccount account = await pmMod.ChartOfAccount.Query().GetEntityById(4);
ProjectManagementTaskView view = new ProjectManagementTaskView()
{
Wbs = "1.3",
TaskName = "test rollup",
Description = "task to project rollup",
EstimatedStartDate = DateTime.Parse("12/1/2019"),
EstimatedHours = 1,
EstimatedEndDate = DateTime.Parse("12/31/2019"),
ActualStartDate = DateTime.Parse("12/23/2019"),
ActualHours = 1,
ActualEndDate = DateTime.Parse("12/23/2020"),
Cost = 31,
MileStoneId = milestone.MilestoneId,
MilestoneName = milestone.MilestoneName,
StatusXrefId = udc.XrefId,
EstimatedCost = 29,
ActualDays = 1,
EstimatedDays = 1,
ProjectId = project.ProjectId,
AccountId = account.AccountId,
Account = account.Account,
ProjectName = project.ProjectName,
};
NextNumber nnNextNumber = await pmMod.ProjectManagementTask.Query().GetNextNumber();
view.TaskNumber = nnNextNumber.NextNumberValue;
ProjectManagementTask projectManagementTask = await pmMod.ProjectManagementTask.Query().MapToEntity(view);
pmMod.ProjectManagementTask.AddProjectManagementTask(projectManagementTask).Apply();
RollupTaskToProjectView rollup = await pmMod.Project.Query().GetTaskToProjectRollupViewById(milestone.MilestoneId);
ProjectManagementTask newProjectManagementTask = await pmMod.ProjectManagementTask.Query().GetEntityByNumber(view.TaskNumber);
if (rollup.Cost < 3000)
{
Assert.True(false);
}
pmMod.ProjectManagementTask.DeleteProjectManagementTask(newProjectManagementTask).Apply();
}
public async Task <IActionResult> DeleteUdc([FromBody] UdcView view)
{
UdcModule invMod = new UdcModule();
Udc udc = await invMod.Udc.Query().MapToEntity(view);
invMod.Udc.DeleteUdc(udc).Apply();
return(Ok(view));
}
public async Task <BudgetActualsView> GetBudgetActualsView(BudgetRangeView budgetRangeView)
{
Udc udcActuals = await _unitOfWork.udcRepository.GetUdc("GENERALLEDGERTYPE", "AA");
Udc udcHours = await _unitOfWork.udcRepository.GetUdc("GENERALLEDGERTYPE", "HA");
BudgetActualsView budgetActualsView = await _unitOfWork.budgetRepository.GetActualsView(budgetRangeView, udcActuals.KeyCode, udcHours.KeyCode);
return(budgetActualsView);
}
public async Task TestAddUpdatDeleteAssets()
{
AssetModule assetsMod = new AssetModule();
Udc equipmentStatus = await assetsMod.Asset.Query().GetUdc("ASSETS_STATUS", "InUse");
AssetView view = new AssetView()
{
AssetCode = "12345",
TagCode = "Amplifier",
ClassCode = "SOUND",
Description = "PA SYSTEM",
Manufacturer = "LIGHTSPEED",
Model = "CAT 855",
SerialNumber = "12X34X56",
AcquiredDate = DateTime.Parse("5/11/2019"),
OriginalCost = 855.57M,
ReplacementCost = 855.57M,
Depreciation = 0,
Location = "Build 1",
SubLocation = "Room 1",
Quantity = 1,
EquipmentStatusXrefId = equipmentStatus.XrefId,
GenericLocationLevel1 = "",
GenericLocationLevel2 = "",
GenericLocationLevel3 = ""
};
NextNumber nnAssets = await assetsMod.Asset.Query().GetAssetNextNumber();
view.AssetNumber = nnAssets.NextNumberValue;
Asset Asset = await assetsMod.Asset.Query().MapToEntity(view);
assetsMod.Asset.AddAsset(Asset).Apply();
Asset newAssets = await assetsMod.Asset.Query().GetAssetByNumber(view.AssetNumber);
Assert.NotNull(newAssets);
newAssets.Description = "Testing Assets update";
assetsMod.Asset.UpdateAsset(newAssets).Apply();
AssetView updateView = await assetsMod.Asset.Query().GetViewById(newAssets.AssetId);
Assert.Same(updateView.Description, "Testing Assets update");
assetsMod.Asset.DeleteAsset(newAssets).Apply();
Asset lookupAssets = await assetsMod.Asset.Query().GetEntityById(view.AssetId);
Assert.Null(lookupAssets);
}
public async Task <Udc> GetUdc2(string productCode, string keyCode)
{
try
{
ListensoftwaredbContext _dbListensoftwaredbContext = (ListensoftwaredbContext)_dbContext;
Udc udc = await(from e in _dbListensoftwaredbContext.Udc
where e.ProductCode == productCode &&
e.KeyCode == keyCode
select e).FirstOrDefaultAsync <Udc>();
return(udc);
}
catch (Exception ex) { throw new Exception(GetMyMethodName(), ex); }
}
public override async Task <LocationAddressView> MapToView(LocationAddress inputObject)
{
LocationAddressView outObject = mapper.Map <LocationAddressView>(inputObject);
Task <AddressBook> addressBookTask = _unitOfWork.addressBookRepository.GetEntityById(inputObject.AddressId);
Task <Udc> udcTask = _unitOfWork.udcRepository.GetEntityById(inputObject.TypeXrefId);
AddressBook addressBook = await addressBookTask;
Udc udc = await udcTask;
outObject.Name = addressBook.Name;
outObject.Type = udc.Value;
return(outObject);
}
public async Task <bool> CreateCashPayment(GeneralLedgerView glCashView)
{
try
{
ChartOfAccount coaCash = await ChartOfAccounts.Query().GetEntity("1000", "1200", "101", "");
Udc udcLedgerType = await UDC.Query().GetUdc("GENERALLEDGERTYPE", "AA");
Udc udcDocType = await UDC.Query().GetUdc("DOCTYPE", "PV");
AddressBook addressBook = await AddressBook.Query().GetEntityById(glCashView.AddressId);
glCashView.AccountId = coaCash.AccountId;
glCashView.DebitAmount = 0;
glCashView.CreditAmount = glCashView.Amount;
glCashView.FiscalPeriod = glCashView.GLDate.Month;
glCashView.FiscalYear = glCashView.GLDate.Year;
glCashView.DocType = udcDocType.KeyCode;
glCashView.LedgerType = udcLedgerType.KeyCode;
glCashView.CreatedDate = DateTime.Now;
glCashView.AddressId = addressBook.AddressId;
GeneralLedgerView glLookup = null;
if (glCashView.CheckNumber != null)
{
glLookup = await GeneralLedger.Query().GetLedgerViewByExpression(
e => e.AccountId == glCashView.AccountId &&
e.AddressId == glCashView.AddressId &&
e.Amount == glCashView.Amount &&
e.CheckNumber == glCashView.CheckNumber &&
e.DocType == glCashView.DocType &&
e.Gldate == glCashView.GLDate
);
}
if (glLookup == null)
{
GeneralLedger.CreateGeneralLedgerByView(glCashView).Apply();
GeneralLedger.UpdateAccountBalances(glCashView);
}
else
{
glCashView.DocNumber = glLookup.DocNumber;
}
return(true);
}
catch (Exception ex) { throw new Exception("CreateCashPayment", ex); }
}
public async Task <IActionResult> UpdateUdc([FromBody] UdcView view)
{
UdcModule invMod = new UdcModule();
Udc udc = await invMod.Udc.Query().MapToEntity(view);
invMod.Udc.UpdateUdc(udc).Apply();
UdcView retView = await invMod.Udc.Query().GetViewById(udc.XrefId);
return(Ok(retView));
}
public async Task TestAddUpdatDelete()
{
SupervisorModule SupervisorMod = new SupervisorModule();
AddressBook addressBook = await SupervisorMod.AddressBook.Query().GetEntityById(1);
Udc udcTitle = await SupervisorMod.Udc.Query().GetEntityById(25);
Supervisor parentSupervisor = await SupervisorMod.Supervisor.Query().GetEntityById(2);
AddressBook parentAddressBook = await SupervisorMod.AddressBook.Query().GetEntityById(parentSupervisor?.AddressId);
Udc parentUdcTitle = await SupervisorMod.Udc.Query().GetEntityById(parentSupervisor?.JobTitleXrefId);
SupervisorView view = new SupervisorView()
{
AddressId = addressBook.AddressId,
SupervisorName = addressBook.Name,
SupervisorCode = "6785",
JobTitleXrefId = udcTitle.XrefId,
JobTitle = udcTitle.Value,
ParentSupervisorId = parentSupervisor?.SupervisorId,
ParentSupervisorName = parentAddressBook?.Name,
ParentSupervisorAddressId = parentAddressBook?.AddressId,
ParentSupervisorTitle = parentUdcTitle?.Value,
ParentSupervisorCode = parentSupervisor?.SupervisorCode
};
NextNumber nnNextNumber = await SupervisorMod.Supervisor.Query().GetNextNumber();
view.SupervisorNumber = nnNextNumber.NextNumberValue;
Supervisor supervisor = await SupervisorMod.Supervisor.Query().MapToEntity(view);
SupervisorMod.Supervisor.AddSupervisor(supervisor).Apply();
Supervisor newSupervisor = await SupervisorMod.Supervisor.Query().GetEntityByNumber(view.SupervisorNumber);
Assert.NotNull(newSupervisor);
newSupervisor.SupervisorCode = "6785U";
SupervisorMod.Supervisor.UpdateSupervisor(newSupervisor).Apply();
SupervisorView updateView = await SupervisorMod.Supervisor.Query().GetViewById(newSupervisor.SupervisorId);
Assert.Same(updateView.SupervisorCode, "6785U");
SupervisorMod.Supervisor.DeleteSupervisor(newSupervisor).Apply();
Supervisor lookupSupervisor = await SupervisorMod.Supervisor.Query().GetEntityById(updateView.SupervisorId);
Assert.Null(lookupSupervisor);
}
public async Task TestAddUpdatDelete()
{
AddressBook addressBook = null;
ContractModule ContractMod = new ContractModule();
Customer customer = await ContractMod.Customer.Query().GetEntityById(2);
Udc udc = await ContractMod.Udc.Query().GetEntityById(64);
if (customer != null)
{
addressBook = await ContractMod.AddressBook.Query().GetEntityById(customer.AddressId);
}
ContractView view = new ContractView()
{
CustomerId = customer.CustomerId,
CustomerName = addressBook.Name,
ServiceTypeXrefId = udc.XrefId,
ServiceType = udc.Value,
StartDate = DateTime.Parse("11/13/2019"),
EndDate = DateTime.Parse("11/13/2019"),
Cost = 250.1M,
RemainingBalance = 111.11M,
Title = "Bob Test"
};
NextNumber nnNextNumber = await ContractMod.Contract.Query().GetNextNumber();
view.ContractNumber = nnNextNumber.NextNumberValue;
Contract contract = await ContractMod.Contract.Query().MapToEntity(view);
ContractMod.Contract.AddContract(contract).Apply();
Contract newContract = await ContractMod.Contract.Query().GetEntityByNumber(view.ContractNumber);
Assert.NotNull(newContract);
newContract.Title = "Bob Test Update";
ContractMod.Contract.UpdateContract(newContract).Apply();
ContractView updateView = await ContractMod.Contract.Query().GetViewById(newContract.ContractId);
Assert.Same(updateView.Title, "Bob Test Update");
ContractMod.Contract.DeleteContract(newContract).Apply();
Contract lookupContract = await ContractMod.Contract.Query().GetEntityById(view.ContractId);
Assert.Null(lookupContract);
}
/// <inheritdoc />
public void WriteXml(XmlWriter writer)
{
writer.WriteAttributeString("cla", String.Format("{0:X2}", Cla));
writer.WriteAttributeString("ins", String.Format("{0:X2}", Ins));
writer.WriteAttributeString("p1", String.Format("{0:X2}", P1));
writer.WriteAttributeString("p2", String.Format("{0:X2}", P2));
if (HasLc)
{
writer.WriteString(Udc.ToHexa());
}
if (HasLe)
{
writer.WriteAttributeString("le", String.Format("{0:X2}", Le));
}
}
public async Task <IActionResult> AddUdc([FromBody] UdcView view)
{
UdcModule invMod = new UdcModule();
NextNumber nnUdc = await invMod.Udc.Query().GetNextNumber();
view.UdcNumber = nnUdc.NextNumberValue;
Udc udc = await invMod.Udc.Query().MapToEntity(view);
invMod.Udc.AddUdc(udc).Apply();
UdcView newView = await invMod.Udc.Query().GetViewByNumber(view.UdcNumber);
return(Ok(newView));
}
public async Task <IList <TimeAndAttendancePunchIn> > GetOpenEntitiesByEmployeeId(long?employeeId)
{
Udc taskStatusQuery = await base.GetUdc2("TA_STATUS", TypeOfTAStatus.Open.ToString().ToUpper());
IList <TimeAndAttendancePunchIn> list = await(from e in _dbContext.TimeAndAttendancePunchIn
where e.EmployeeId == employeeId &&
e.PunchoutDate == null &&
e.TaskStatusXrefId == taskStatusQuery.XrefId
select e
).ToListAsync <TimeAndAttendancePunchIn>();
return(list);
}
public async Task TestAddUpdatDelete()
{
LocationAddressModule LocationAddressMod = new LocationAddressModule();
AddressBook addressBook = await LocationAddressMod.AddressBook.Query().GetEntityById(1);
Udc udc = await LocationAddressMod.Udc.Query().GetEntityById(60);
LocationAddressView view = new LocationAddressView()
{
AddressLine1 = "123 abc",
City = "Boise",
Zipcode = "83709",
TypeXrefId = udc.XrefId,
Type = udc.Value,
AddressId = addressBook.AddressId,
Name = addressBook.Name,
State = "ID",
Country = "USA"
};
NextNumber nnNextNumber = await LocationAddressMod.LocationAddress.Query().GetNextNumber();
view.LocationAddressNumber = nnNextNumber.NextNumberValue;
LocationAddress locationAddress = await LocationAddressMod.LocationAddress.Query().MapToEntity(view);
LocationAddressMod.LocationAddress.AddLocationAddress(locationAddress).Apply();
LocationAddress newLocationAddress = await LocationAddressMod.LocationAddress.Query().GetEntityByNumber(view.LocationAddressNumber);
Assert.NotNull(newLocationAddress);
newLocationAddress.Type = "Residence Update";
LocationAddressMod.LocationAddress.UpdateLocationAddress(newLocationAddress).Apply();
LocationAddressView updateView = await LocationAddressMod.LocationAddress.Query().GetViewById(newLocationAddress.LocationAddressId);
Assert.Same(updateView.Type, "Residence Update");
LocationAddressMod.LocationAddress.DeleteLocationAddress(newLocationAddress).Apply();
LocationAddress lookupLocationAddress = await LocationAddressMod.LocationAddress.Query().GetEntityById(view.LocationAddressId);
Assert.Null(lookupLocationAddress);
}
public async Task TestAddUpdatDelete()
{
CarrierModule CarrierMod = new CarrierModule();
Udc udcCarrier = await CarrierMod.Udc.Query().GetEntityById(41);
AddressBook addressBook = await CarrierMod.AddressBook.Query().GetEntityById(18);
CarrierView view = new CarrierView()
{
AddressId = addressBook.AddressId,
CarrierTypeXrefId = udcCarrier.XrefId,
CarrierType = udcCarrier.Value,
CarrierName = addressBook.Name
};
NextNumber nnNextNumber = await CarrierMod.Carrier.Query().GetNextNumber();
view.CarrierNumber = nnNextNumber.NextNumberValue;
Carrier carrier = await CarrierMod.Carrier.Query().MapToEntity(view);
CarrierMod.Carrier.AddCarrier(carrier).Apply();
Carrier newCarrier = await CarrierMod.Carrier.Query().GetEntityByNumber(view.CarrierNumber);
Assert.NotNull(newCarrier);
newCarrier.AddressId = 19;
CarrierMod.Carrier.UpdateCarrier(newCarrier).Apply();
CarrierView updateView = await CarrierMod.Carrier.Query().GetViewById(newCarrier.CarrierId);
if (updateView.AddressId == 19)
{
Assert.True(true);
}
CarrierMod.Carrier.DeleteCarrier(newCarrier).Apply();
Carrier lookupCarrier = await CarrierMod.Carrier.Query().GetEntityById(updateView.CarrierId ?? 0);
Assert.Null(lookupCarrier);
}
public async Task <CreateProcessStatus> UpdatePunchin(TimeAndAttendancePunchIn taPunchin, int mealDeduction, int manualElapsedHours = 0, int manualElapsedMinutes = 0)
{
try
{
//long timePunchinId = 0;
long? employeeId = taPunchin.EmployeeId;
string punchinDateTime = taPunchin.PunchinDateTime;
int minutesDuration = 0;
TimeAndAttendanceTimeView currentTime = null;
//Case 1 : Manual entry of punchout time based on minutes duration
if (manualElapsedHours != 0 || manualElapsedMinutes != 0)
{
minutesDuration = manualElapsedHours * 60 + manualElapsedMinutes - mealDeduction;
currentTime = await GetTimeByMinuteDuration(punchinDateTime, minutesDuration);
}
//Case 2 : User presses punchout
else
{
currentTime = await GetUTCAdjustedTime();
minutesDuration = await GetDuration(punchinDateTime, currentTime.PunchDateTime, mealDeduction);
}
taPunchin.PunchoutDate = currentTime.PunchDate;
taPunchin.PunchoutDateTime = currentTime.PunchDateTime;
taPunchin.DurationInMinutes = minutesDuration;
taPunchin.MealDurationInMinutes = mealDeduction;
Udc status = await base.GetUdc2("TA_STATUS", TypeOfTAStatus.Closed.ToString().ToUpper());
taPunchin.TaskStatusXrefId = status.XrefId;
taPunchin.TaskStatus = status.KeyCode;
UpdateObject(taPunchin);
return(CreateProcessStatus.Update);
}
catch (Exception ex)
{
throw new Exception(GetMyMethodName(), ex);
}
}
public async Task <TimeAndAttendancePunchIn> GetPunchOpen(long?employeeId)
{
try
{
Udc taskStatusQuery = await base.GetUdc2("TA_STATUS", TypeOfTAStatus.Open.ToString().ToUpper());
TimeAndAttendancePunchIn item = await(from e in _dbContext.TimeAndAttendancePunchIn
where e.EmployeeId == employeeId &&
e.PunchoutDate == null &&
e.TaskStatusXrefId == taskStatusQuery.XrefId
select e
).FirstOrDefaultAsync <TimeAndAttendancePunchIn>();
return(item);
}
catch (Exception ex)
{
throw new Exception(GetMyMethodName(), ex);
}
}
public async Task<IActionResult> AddSalesOrder([FromBody]SalesOrderView view)
{
SalesOrderModule salesOrderMod = new SalesOrderModule();
List<SalesOrderDetailView> detailViews = view.SalesOrderDetailViews.ToList<SalesOrderDetailView>();
Udc orderType = await salesOrderMod.SalesOrder.Query().GetUdc("ORDER_TYPE", SalesOrderEnum.CASH_SALES.ToString());
Udc paymentTerms = await salesOrderMod.SalesOrder.Query().GetUdc("PAYMENTTERMS", PaymentTermsEnum.Net_2_10_30.ToString());
NextNumber nnSalesOrder = await salesOrderMod.SalesOrder.Query().GetNextNumber();
view.OrderNumber = nnSalesOrder.NextNumberValue.ToString();
SalesOrder salesOrder = await salesOrderMod.SalesOrder.Query().MapToEntity(view);
salesOrderMod.SalesOrder.AddSalesOrder(salesOrder).Apply();
SalesOrder newSalesOrder = await salesOrderMod.SalesOrder.Query().GetEntityByNumber(view.OrderNumber);
detailViews.ForEach(m => m.SalesOrderId = newSalesOrder.SalesOrderId);
List<SalesOrderDetail> salesOrderDetails = (await salesOrderMod.SalesOrderDetail.Query().MapToEntity(detailViews)).ToList<SalesOrderDetail>();
salesOrderMod.SalesOrderDetail.AddSalesOrderDetails(salesOrderDetails).Apply();
newSalesOrder = salesOrderMod.SalesOrder.Query().SumAmounts(newSalesOrder,salesOrderDetails);
salesOrderMod.SalesOrder.UpdateSalesOrder(newSalesOrder).Apply();
SalesOrderView newSalesOrderView = await salesOrderMod.SalesOrder.Query().MapToView(newSalesOrder);
List<SalesOrderDetailView> listDetailViews = (await salesOrderMod.SalesOrderDetail.Query().GetDetailViewsBySalesOrderId(newSalesOrder.SalesOrderId)).ToList<SalesOrderDetailView>();
newSalesOrderView.SalesOrderDetailViews = listDetailViews;
return Ok(newSalesOrderView);
}
public async Task <AccountReceivable> MapEntityFromPurchaseOrder(PurchaseOrder purchaseOrder, Udc udcAccountReceivableType, ChartOfAccount coaAccountReceivable)
{
return(new AccountReceivable()
{
PurchaseOrderId = purchaseOrder.PurchaseOrderId,
PaymentTerms = purchaseOrder.PaymentTerms,
CustomerId = purchaseOrder.CustomerId ?? 0,
DocNumber = (await GetDocNumber()).NextNumberValue,
Remark = purchaseOrder.Remark,
Gldate = purchaseOrder.Gldate,
CustomerPurchaseOrder = purchaseOrder.Ponumber,
Description = purchaseOrder.Description,
DiscountDueDate = purchaseOrder.DiscountDueDate,
Tax = purchaseOrder.Tax,
Amount = purchaseOrder.Amount,
DebitAmount = purchaseOrder.Amount,
DiscountPercent = purchaseOrder.DiscountPercent,
DiscountAmount = purchaseOrder.DiscountAmount,
AcctRecDocType = udcAccountReceivableType.Value,
AcctRecDocTypeXrefId = udcAccountReceivableType.XrefId,
AccountReceivableNumber = (await GetNextNumber()).NextNumberValue,
CreateDate = DateTime.Now,
AccountId = coaAccountReceivable.AccountId
});
}
async Task TestCreateAccountReceivableFromPO()
{
AddressBook addressBook = null;
AddressBook buyerAddressBook = null;
PurchaseOrderModule PurchaseOrderMod = new PurchaseOrderModule();
ChartOfAccount account = await PurchaseOrderMod.ChartOfAccount.Query().GetEntityById(17);
Supplier supplier = await PurchaseOrderMod.Supplier.Query().GetEntityById(3);
if (supplier != null)
{
addressBook = await PurchaseOrderMod.AddressBook.Query().GetEntityById(supplier.AddressId);
}
Contract contract = await PurchaseOrderMod.Contract.Query().GetEntityById(1);
Poquote poquote = await PurchaseOrderMod.POQuote.Query().GetEntityById(2);
Buyer buyer = await PurchaseOrderMod.Buyer.Query().GetEntityById(1);
if (buyer != null)
{
buyerAddressBook = await PurchaseOrderMod.AddressBook.Query().GetEntityById(buyer.AddressId);
}
TaxRatesByCode taxRatesByCode = await PurchaseOrderMod.TaxRatesByCode.Query().GetEntityById(1);
PurchaseOrderView view = new PurchaseOrderView()
{
DocType = "STD",
PaymentTerms = "Net 30",
Amount = 286.11M,
AmountPaid = 0,
Remark = "PO Remark",
Gldate = DateTime.Parse("11/29/2019"),
AccountId = account.AccountId,
Location = account.Location,
BusUnit = account.BusUnit,
Subsidiary = account.Subsidiary,
SubSub = account.SubSub,
Account = account.Account,
AccountDescription = account.Description,
SupplierId = supplier.SupplierId,
CustomerId = contract?.CustomerId,
SupplierName = addressBook.Name,
ContractId = contract?.ContractId,
PoquoteId = poquote?.PoquoteId,
QuoteAmount = poquote?.QuoteAmount,
Description = "PO Description",
Ponumber = "PO-123",
TakenBy = "David Nishimoto",
ShippedToName = " shipped name",
ShippedToAddress1 = "shipped to address1",
ShippedToAddress2 = "shipped to address2",
ShippedToCity = "shipped city",
ShippedToState = "ID",
ShippedToZipcode = "83709",
BuyerId = buyer.BuyerId,
BuyerName = buyerAddressBook?.Name,
RequestedDate = DateTime.Parse("11/29/2019"),
PromisedDeliveredDate = DateTime.Parse("11/29/2019"),
Tax = 0M,
TransactionDate = DateTime.Parse("11/29/2019"),
TaxCode1 = taxRatesByCode.TaxCode,
TaxCode2 = "",
TaxRate = taxRatesByCode.TaxRate ?? 0,
PurchaseOrderNumber = (await PurchaseOrderMod.PurchaseOrder.Query().GetNextNumber()).NextNumberValue
};
PurchaseOrder purchaseOrder = await PurchaseOrderMod.PurchaseOrder.Query().MapToEntity(view);
PurchaseOrderMod.PurchaseOrder.AddPurchaseOrder(purchaseOrder).Apply();
Udc udcAccountReceivableType = await PurchaseOrderMod.Udc.Query().GetEntityById(66);
ChartOfAccount coaAccountReceivable = await PurchaseOrderMod.ChartOfAccount.Query().GetEntityById(4);
AccountReceivable accountReceivable = await PurchaseOrderMod.AccountReceivable.Query().MapEntityFromPurchaseOrder(purchaseOrder, udcAccountReceivableType, coaAccountReceivable);
PurchaseOrderMod.AccountReceivable.AddAccountReceivable(accountReceivable).Apply();
}
public async Task TestAddUpdatDelete()
{
ProjectManagementTaskModule ProjectManagementTaskMod = new ProjectManagementTaskModule();
ProjectManagementMilestone milestone = await ProjectManagementTaskMod.Milestone.Query().GetEntityById(1);
Udc udc = await ProjectManagementTaskMod.Udc.Query().GetEntityById(21);
ProjectManagementProject project = await ProjectManagementTaskMod.Project.Query().GetEntityById(1);
ProjectManagementWorkOrder workOrder = await ProjectManagementTaskMod.WorkOrder.Query().GetEntityById(7);
ChartOfAccount account = await ProjectManagementTaskMod.ChartOfAccount.Query().GetEntityById(4);
IList <ProjectManagementWorkOrderToEmployeeView> views = await ProjectManagementTaskMod.WorkToEmployee.Query().GetViewsByWorkOrderId(workOrder.WorkOrderId);
ProjectManagementTaskView view = new ProjectManagementTaskView()
{
Wbs = "1.3",
TaskName = "refactor code",
Description = "refactor code to solid principles",
EstimatedStartDate = DateTime.Parse("12/1/2019"),
EstimatedHours = 100,
EstimatedEndDate = DateTime.Parse("12/31/2019"),
ActualStartDate = DateTime.Parse("12/1/2019"),
ActualHours = 101,
ActualEndDate = DateTime.Parse("12/20/2020"),
Cost = 3100,
MileStoneId = milestone.MilestoneId,
MilestoneName = milestone.MilestoneName,
StatusXrefId = udc.XrefId,
EstimatedCost = 2900,
ActualDays = 101 / 8,
EstimatedDays = 100 / 8,
ProjectId = project.ProjectId,
WorkOrderId = workOrder.WorkOrderId,
Instructions = workOrder.Instructions,
AccountId = account.AccountId,
Account = account.Account,
ProjectName = project.ProjectName,
WorkOrderToEmployeeViews = views
};
NextNumber nnNextNumber = await ProjectManagementTaskMod.ProjectManagementTask.Query().GetNextNumber();
view.TaskNumber = nnNextNumber.NextNumberValue;
ProjectManagementTask projectManagementTask = await ProjectManagementTaskMod.ProjectManagementTask.Query().MapToEntity(view);
ProjectManagementTaskMod.ProjectManagementTask.AddProjectManagementTask(projectManagementTask).Apply();
ProjectManagementTask newProjectManagementTask = await ProjectManagementTaskMod.ProjectManagementTask.Query().GetEntityByNumber(view.TaskNumber);
Assert.NotNull(newProjectManagementTask);
newProjectManagementTask.Description = "ProjectManagementTask Test Update";
ProjectManagementTaskMod.ProjectManagementTask.UpdateProjectManagementTask(newProjectManagementTask).Apply();
ProjectManagementTaskView updateView = await ProjectManagementTaskMod.ProjectManagementTask.Query().GetViewById(newProjectManagementTask.TaskId);
Assert.Same(updateView.Description, "ProjectManagementTask Test Update");
ProjectManagementTaskMod.ProjectManagementTask.DeleteProjectManagementTask(newProjectManagementTask).Apply();
ProjectManagementTask lookupProjectManagementTask = await ProjectManagementTaskMod.ProjectManagementTask.Query().GetEntityById(view.TaskId);
Assert.Null(lookupProjectManagementTask);
}
public async Task TestAddUpdatDelete()
{
AccountReceivableDetailModule AccountReceivableDetailMod = new AccountReceivableDetailModule();
Invoice invoice = await AccountReceivableDetailMod.Invoice.Query().GetEntityById(18);
Customer customer = await AccountReceivableDetailMod.Customer.Query().GetEntityById(9);
AddressBook addressBookCustomer = await AccountReceivableDetailMod.AddressBook.Query().GetEntityById(customer?.AddressId);
PurchaseOrder purchaseOrder = await AccountReceivableDetailMod.PurchaseOrder.Query().GetEntityById(20);
Udc udc = await AccountReceivableDetailMod.Udc.Query().GetEntityById(66);
ChartOfAccount chartOfAccount = await AccountReceivableDetailMod.ChartOfAccount.Query().GetEntityById(3);
AccountReceivableView acctRecView = new AccountReceivableView()
{
DiscountDueDate = DateTime.Parse("2/8/2020"),
Gldate = DateTime.Parse("7/16/2018"),
InvoiceId = invoice.InvoiceId,
CreateDate = DateTime.Parse("7/16/2018"),
DocNumber = (await AccountReceivableDetailMod.AccountReceivable.Query().GetDocNumber()).NextNumberValue,
Remark = "VNW Fixed Asset project",
PaymentTerms = "Net 30",
CustomerId = customer?.CustomerId ?? 0,
PurchaseOrderId = purchaseOrder?.PurchaseOrderId ?? 0,
Description = "Fixed Asset Project",
AcctRecDocTypeXrefId = udc.XrefId,
AccountId = chartOfAccount.AccountId,
Amount = 1500M,
DebitAmount = 189.6300M,
CreditAmount = 1500,
OpenAmount = 1335.37M,
DiscountPercent = 0,
DiscountAmount = 0,
AcctRecDocType = "INV",
InterestPaid = 0,
LateFee = 25.0000M,
AccountReceivableNumber = (await AccountReceivableDetailMod.AccountReceivable.Query().GetNextNumber()).NextNumberValue,
CustomerPurchaseOrder = "PO-321",
Tax = 0,
InvoiceDocument = invoice.InvoiceDocument,
CustomerName = addressBookCustomer?.Name,
DocType = udc.KeyCode
};
AccountReceivable newAccountReceivable = await AccountReceivableDetailMod.AccountReceivable.Query().MapToEntity(acctRecView);
AccountReceivableDetailMod.AccountReceivable.AddAccountReceivable(newAccountReceivable).Apply();
AccountReceivable lookupAccountReceivable = await AccountReceivableDetailMod.AccountReceivable.Query().GetEntityByNumber(newAccountReceivable.AccountReceivableNumber);
InvoiceDetail invoiceDetail = await AccountReceivableDetailMod.InvoiceDetail.Query().GetEntityById(6);
PurchaseOrderDetail purchaseOrderDetail = await AccountReceivableDetailMod.PurchaseOrderDetail.Query().GetEntityById(33);
ItemMaster itemMaster = await AccountReceivableDetailMod.ItemMaster.Query().GetEntityById(4);
AccountReceivableDetailView acctRecDetailView = new AccountReceivableDetailView()
{
InvoiceId = invoice.InvoiceId,
InvoiceDetailId = invoiceDetail.InvoiceDetailId,
AccountReceivableId = lookupAccountReceivable.AccountReceivableId,
UnitPrice = invoiceDetail.UnitPrice,
Quantity = invoiceDetail.Quantity,
UnitOfMeasure = invoiceDetail.UnitOfMeasure,
Amount = invoiceDetail.Amount,
AmountReceived = 189.6300M,
PurchaseOrderDetailId = purchaseOrderDetail.PurchaseOrderDetailId,
ItemId = itemMaster.ItemId,
AccountReceivableDetailNumber = (await AccountReceivableDetailMod.AccountReceivableDetail.Query().GetNextNumber()).NextNumberValue,
PurchaseOrderId = purchaseOrder.PurchaseOrderId,
CustomerId = customer.CustomerId,
QuantityDelivered = invoiceDetail.Quantity,
Comment = "possible write off",
TypeOfPayment = "Partial"
};
AccountReceivableDetail accountReceivableDetail = await AccountReceivableDetailMod.AccountReceivableDetail.Query().MapToEntity(acctRecDetailView);
AccountReceivableDetailMod.AccountReceivableDetail.AddAccountReceivableDetail(accountReceivableDetail).Apply();
AccountReceivableDetail newAccountReceivableDetail = await AccountReceivableDetailMod.AccountReceivableDetail.Query().GetEntityByNumber(acctRecDetailView.AccountReceivableDetailNumber);
Assert.NotNull(newAccountReceivableDetail);
newAccountReceivableDetail.Comment = "AccountReceivableDetail Test Update";
AccountReceivableDetailMod.AccountReceivableDetail.UpdateAccountReceivableDetail(newAccountReceivableDetail).Apply();
AccountReceivableDetailView updateView = await AccountReceivableDetailMod.AccountReceivableDetail.Query().GetViewById(newAccountReceivableDetail.AccountReceivableDetailId);
Assert.Same(updateView.Comment, "AccountReceivableDetail Test Update");
AccountReceivableDetailMod.AccountReceivableDetail.DeleteAccountReceivableDetail(newAccountReceivableDetail).Apply();
AccountReceivableDetail lookupAccountReceivableDetail = await AccountReceivableDetailMod.AccountReceivableDetail.Query().GetEntityById(acctRecDetailView.AccountReceivableDetailId);
Assert.Null(lookupAccountReceivableDetail);
AccountReceivableDetailMod.AccountReceivable.DeleteAccountReceivable(lookupAccountReceivable).Apply();
AccountReceivable lookupAccountReceivable2 = await AccountReceivableDetailMod.AccountReceivable.Query().GetEntityByNumber(newAccountReceivable.AccountReceivableNumber);
Assert.Null(lookupAccountReceivable2);
}
public IFluentUdc DeleteUdc(Udc deleteObject)
{
unitOfWork.udcRepository.DeleteObject(deleteObject);
this.processStatus = CreateProcessStatus.Delete;
return(this as IFluentUdc);
}
