public virtual IActionResult RentalRequestsIdRotationListIdGet([FromRoute] int id)
{
bool exists = _context.HetRentalRequest.Any(a => a.RentalRequestId == id);
// not found
if (!exists)
{
return(new NotFoundObjectResult(new HetsResponse("HETS-01", ErrorViewModel.GetDescription("HETS-01", _configuration))));
}
// get the scoring rules
SeniorityScoringRules scoringRules = new SeniorityScoringRules(_configuration);
return(new ObjectResult(new HetsResponse(RentalRequestHelper.GetRecordWithRotationList(id, scoringRules, _context))));
}
/// <summary>
/// Get the number of blocks for the equipment type
/// </summary>
/// <param name="item"></param>
/// <param name="configuration"></param>
public static int GetNumberOfBlocks(HetEquipment item, IConfiguration configuration)
{
int numberOfBlocks = -1;
try
{
SeniorityScoringRules scoringRules = new SeniorityScoringRules(configuration);
numberOfBlocks = item.DistrictEquipmentType.EquipmentType.IsDumpTruck ?
scoringRules.GetTotalBlocks("DumpTruck") + 1 : scoringRules.GetTotalBlocks() + 1;
}
catch
{
// do nothing
}
return(numberOfBlocks);
}
/// <summary>
/// Get the number of blocks for this type of equipment
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
private int GetNumberOfBlocks(RentalRequest item)
{
int numberOfBlocks = -1;
try
{
SeniorityScoringRules scoringRules = new SeniorityScoringRules(_configuration);
numberOfBlocks = item.DistrictEquipmentType.EquipmentType.IsDumpTruck ?
scoringRules.GetTotalBlocks("DumpTruck") : scoringRules.GetTotalBlocks();
}
catch
{
// do nothing
}
return(numberOfBlocks);
}
/// <summary>
/// Convert to Equipment Lite Model
/// </summary>
/// <param name="equipment"></param>
/// <param name="scoringRules"></param>
/// <param name="agreementStatusId"></param>
/// <param name="context"></param>
/// <returns></returns>
public static EquipmentLite ToLiteModel(HetEquipment equipment, SeniorityScoringRules scoringRules,
int agreementStatusId, DbAppContext context)
{
EquipmentLite equipmentLite = new EquipmentLite();
if (equipment != null)
{
// HETS - 709 [BVT - Adjust the search for Equipment search screen]
/*
* int numberOfBlocks = 0;
*
* // get number of blocks for this equipment type
* if (equipment.DistrictEquipmentType != null)
* {
* numberOfBlocks = equipment.DistrictEquipmentType.EquipmentType.IsDumpTruck
* ? scoringRules.GetTotalBlocks("DumpTruck") + 1
* : scoringRules.GetTotalBlocks() + 1;
* }
*
* // get equipment seniority
* float seniority = 0F;
* if (equipment.Seniority != null)
* {
* seniority = (float)equipment.Seniority;
* }
*
* // get equipment block number
* int blockNumber = 0;
* if (equipment.BlockNumber != null)
* {
* blockNumber = (int)equipment.BlockNumber;
* }
*
* // get equipment block number
* int numberInBlock = 0;
* if (equipment.NumberInBlock != null)
* {
* numberInBlock = (int)equipment.NumberInBlock;
* }
*/
// map data to light model
equipmentLite.Id = equipment.EquipmentId;
if (equipment.DistrictEquipmentType != null)
{
equipmentLite.EquipmentType = equipment.DistrictEquipmentType.DistrictEquipmentName;
}
if (equipment.Owner != null)
{
equipmentLite.OwnerName = equipment.Owner.OrganizationName;
equipmentLite.OwnerId = equipment.OwnerId;
}
// HETS - 709 [BVT - Adjust the search for Equipment search screen]
//equipmentLite.SeniorityString = FormatSeniorityString(seniority, blockNumber, numberOfBlocks);
equipmentLite.SeniorityString = "0";
// HETS - 709 [BVT - Adjust the search for Equipment search screen]
//equipmentLite.IsHired = CheckIsHired(equipment.HetRentalAgreement.ToList());
equipmentLite.IsHired = false;
// HETS - 709 [BVT - Adjust the search for Equipment search screen]
//equipmentLite.SenioritySortOrder = CalculateSenioritySortOrder(blockNumber, numberInBlock);
equipmentLite.SenioritySortOrder = 0;
equipmentLite.Make = equipment.Make;
equipmentLite.Model = equipment.Model;
equipmentLite.Size = equipment.Size;
equipmentLite.Year = equipment.Year;
equipmentLite.EquipmentCode = equipment.EquipmentCode;
equipmentLite.EquipmentPrefix = Regex.Match(equipment.EquipmentCode, @"^[^\d-]+").Value;
string temp = "";
if (!string.IsNullOrEmpty(equipmentLite.EquipmentPrefix))
{
temp = equipment.EquipmentCode.Replace(equipmentLite.EquipmentPrefix, "");
}
temp = temp.Replace("-", "");
equipmentLite.EquipmentNumber = !string.IsNullOrEmpty(temp) ?
int.Parse(Regex.Match(temp, @"\d+").Value) :
0;
equipmentLite.AttachmentCount = CalculateAttachmentCount(equipment.HetEquipmentAttachment.ToList());
equipmentLite.LastVerifiedDate = equipment.LastVerifiedDate;
equipmentLite.Status = equipment.EquipmentStatusType.EquipmentStatusTypeCode;
equipmentLite.LocalArea = equipment.LocalArea.Name;
// get project
HetRentalAgreement agreement = context.HetRentalAgreement
.AsNoTracking()
.Include(x => x.Project)
.Include(x => x.Equipment)
.FirstOrDefault(x => x.RentalAgreementStatusTypeId == agreementStatusId &&
x.EquipmentId == equipmentLite.Id);
if (agreement?.Project != null)
{
equipmentLite.ProjectId = agreement.Project.ProjectId;
equipmentLite.ProjectName = agreement.Project.Name;
}
}
return(equipmentLite);
}
/// <summary>
/// Recalculate the block assignment for each piece of equipment
/// </summary>
/// <param name="performContext"></param>
/// <param name="seniorityScoringRules"></param>
/// <param name="dbContext"></param>
/// <param name="systemId"></param>
public static void ProcessBlocks(PerformContext performContext, string seniorityScoringRules, DbAppContext dbContext, string systemId)
{
try
{
performContext.WriteLine("*** Recalculating Equipment Block Assignment ***");
Debug.WriteLine("Recalculating Equipment Block Assignment");
int ii = 0;
string _oldTableProgress = "BlockAssignment_Progress";
string _newTable = "BlockAssignment";
// check if the block assignment has already been completed
int startPoint = ImportUtility.CheckInterMapForStartPoint(dbContext, _oldTableProgress, BcBidImport.SigId, _newTable);
if (startPoint == BcBidImport.SigId) // this means the assignment job is complete
{
performContext.WriteLine("*** Recalculating Equipment Block Assignment is complete from the former process ***");
return;
}
// ************************************************************
// cleanup old block assignment status records
// ************************************************************
List <ImportMap> importMapList = dbContext.ImportMaps
.Where(x => x.OldTable == _oldTableProgress &&
x.NewTable == _newTable)
.ToList();
foreach (ImportMap importMap in importMapList)
{
dbContext.ImportMaps.Remove(importMap);
}
dbContext.SaveChanges();
// ************************************************************
// get processing rules
// ************************************************************
SeniorityScoringRules scoringRules = new SeniorityScoringRules(seniorityScoringRules);
// ************************************************************
// get all local areas
// (using active equipment to minimize the results)
// ************************************************************
List <LocalArea> localAreas = dbContext.Equipments
.Include(x => x.LocalArea)
.Where(x => x.Status == Equipment.StatusApproved &&
x.ArchiveCode == "N")
.Select(x => x.LocalArea)
.Distinct()
.ToList();
// ************************************************************
// get all district equipment types
// (using active equipment to minimize the results)
// ************************************************************
List <DistrictEquipmentType> equipmentTypes = dbContext.Equipments
.Include(x => x.DistrictEquipmentType)
.Where(x => x.Status == Equipment.StatusApproved &&
x.ArchiveCode == "N")
.Select(x => x.DistrictEquipmentType)
.Distinct()
.ToList();
// ************************************************************************
// iterate the data and update the assugnment blocks
// (seniority is already calculated)
// ************************************************************************
Debug.WriteLine("Recalculating Equipment Block Assignment - Local Area Record Count: " + localAreas.Count);
foreach (LocalArea localArea in localAreas)
{
foreach (DistrictEquipmentType districtEquipmentType in equipmentTypes)
{
// get the associated equipment type
EquipmentType equipmentTypeRecord = dbContext.EquipmentTypes.FirstOrDefault(x => x.Id == districtEquipmentType.EquipmentTypeId);
if (equipmentTypeRecord == null)
{
throw new DataException(string.Format("Invalid District Equipment Type. No associated Equipment Type record (District Equipment Id: {0})", districtEquipmentType.Id));
}
// get rules
int blockSize = equipmentTypeRecord.IsDumpTruck ? scoringRules.GetBlockSize("DumpTruck") : scoringRules.GetBlockSize();
int totalBlocks = equipmentTypeRecord.IsDumpTruck ? scoringRules.GetTotalBlocks("DumpTruck") : scoringRules.GetTotalBlocks();
// assign blocks
SeniorityListExtensions.AssignBlocks(dbContext, localArea.Id, districtEquipmentType.Id, blockSize, totalBlocks, false);
// save change to database periodically to avoid frequent writing to the database
if (ii++ % 1000 == 0)
{
try
{
Debug.WriteLine("Recalculating Equipment Block Assignment - Index: " + ii);
ImportUtility.AddImportMapForProgress(dbContext, _oldTableProgress, ii.ToString(), BcBidImport.SigId, _newTable);
dbContext.SaveChangesForImport();
}
catch (Exception e)
{
performContext.WriteLine("Error saving data " + e.Message);
}
}
}
}
// ************************************************************
// save final set of updates
// ************************************************************
try
{
performContext.WriteLine("*** Recalculating Equipment Block Assignment is Done ***");
Debug.WriteLine("Recalculating Equipment Block Assignment is Done");
ImportUtility.AddImportMapForProgress(dbContext, _oldTableProgress, BcBidImport.SigId.ToString(), BcBidImport.SigId, _newTable);
dbContext.SaveChangesForImport();
}
catch (Exception e)
{
string temp = string.Format("Error saving data (Record: {0}): {1}", ii, e.Message);
performContext.WriteLine(temp);
throw new DataException(temp);
}
}
catch (Exception e)
{
performContext.WriteLine("*** ERROR ***");
performContext.WriteLine(e.ToString());
throw;
}
}
/// <summary>
/// Seniority List view model
/// </summary>
/// <param name="model"></param>
/// <param name="scoringRules"></param>
/// <param name="context"></param>
/// <returns></returns>
public static SeniorityViewModel ToSeniorityViewModel(this Equipment model, SeniorityScoringRules scoringRules, DbAppContext context)
{
var dto = new SeniorityViewModel();
if (model != null)
{
int numberOfBlocks = 0;
// get number of blocks for this equiment type
if (model.DistrictEquipmentType != null)
{
numberOfBlocks = model.DistrictEquipmentType.EquipmentType.IsDumpTruck
? scoringRules.GetTotalBlocks("DumpTruck") + 1
: scoringRules.GetTotalBlocks() + 1;
}
// get equipment seniority
float seniority = 0F;
if (model.Seniority != null)
{
seniority = (float)model.Seniority;
}
// get equipment block number
int blockNumber = 0;
if (model.BlockNumber != null)
{
blockNumber = (int)model.BlockNumber;
}
// get equipment block number
int numberInBlock = 0;
if (model.NumberInBlock != null)
{
numberInBlock = (int)model.NumberInBlock;
}
// *************************************************************
// Map data to view model
// *************************************************************
dto.Id = model.Id;
if (model.DistrictEquipmentType != null)
{
dto.EquipmentType = model.DistrictEquipmentType.DistrictEquipmentName;
}
if (model.Owner != null)
{
dto.OwnerName = model.Owner.OrganizationName;
dto.OwnerId = model.OwnerId;
}
dto.SeniorityString = dto.FormatSeniorityString(seniority, blockNumber, numberOfBlocks);
// format the seniority value
dto.Seniority = string.Format("{0:0.###}", model.Seniority);
dto.Make = model.Make;
dto.Model = model.Model;
dto.Size = model.Size;
dto.EquipmentCode = model.EquipmentCode;
dto.YearsRegistered = model.YearsOfService.ToString();
// calculate and format the ytd hours
float tempHours = model.GetYtdServiceHours(context);
dto.YtdHours = string.Format("{0:0.###}", tempHours);
// format the hours
dto.HoursYearMinus1 = string.Format("{0:0.###}", model.ServiceHoursLastYear);
dto.HoursYearMinus2 = string.Format("{0:0.###}", model.ServiceHoursTwoYearsAgo);
dto.HoursYearMinus3 = string.Format("{0:0.###}", model.ServiceHoursThreeYearsAgo);
// get last called value
dto.SenioritySortOrder = dto.CalculateSenioritySortOrder(blockNumber, numberInBlock);
}
return(dto);
}
/// <summary>
/// Equipment view model
/// </summary>
/// <param name="model"></param>
/// <param name="scoringRules"></param>
/// <returns></returns>
public static EquipmentViewModel ToViewModel(this Equipment model, SeniorityScoringRules scoringRules)
{
var dto = new EquipmentViewModel();
if (model != null)
{
int numberOfBlocks = 0;
// get number of blocks for this equiment type
if (model.DistrictEquipmentType != null)
{
numberOfBlocks = model.DistrictEquipmentType.EquipmentType.IsDumpTruck
? scoringRules.GetTotalBlocks("DumpTruck") + 1
: scoringRules.GetTotalBlocks() + 1;
}
// get equipment seniority
float seniority = 0F;
if (model.Seniority != null)
{
seniority = (float)model.Seniority;
}
// get equipment block number
int blockNumber = 0;
if (model.BlockNumber != null)
{
blockNumber = (int)model.BlockNumber;
}
// get equipment block number
int numberInBlock = 0;
if (model.NumberInBlock != null)
{
numberInBlock = (int)model.NumberInBlock;
}
// *************************************************************
// Map data to ciew model
// *************************************************************
dto.Id = model.Id;
if (model.DistrictEquipmentType != null)
{
dto.EquipmentType = model.DistrictEquipmentType.DistrictEquipmentName;
}
if (model.Owner != null)
{
dto.OwnerName = model.Owner.OrganizationName;
dto.OwnerId = model.OwnerId;
}
dto.SeniorityString = dto.FormatSeniorityString(seniority, blockNumber, numberOfBlocks);
dto.IsHired = dto.CheckIsHired(model.RentalAgreements);
dto.Make = model.Make;
dto.Model = model.Model;
dto.Size = model.Size;
dto.EquipmentCode = model.EquipmentCode;
dto.AttachmentCount = dto.CalculateAttachmentCount(model.EquipmentAttachments);
dto.LastVerifiedDate = model.LastVerifiedDate;
dto.SenioritySortOrder = dto.CalculateSenioritySortOrder(blockNumber, numberInBlock);
}
return(dto);
}
public virtual IActionResult RentalRequestIdRotationListIdPut([FromRoute] int id, [FromBody] HetRentalRequestRotationList item)
{
// not found
if (item == null)
{
return(new NotFoundObjectResult(new HetsResponse("HETS-01", ErrorViewModel.GetDescription("HETS-01", _configuration))));
}
bool exists = _context.HetRentalRequest.Any(a => a.RentalRequestId == id);
// not found
if (!exists)
{
return(new NotFoundObjectResult(new HetsResponse("HETS-01", ErrorViewModel.GetDescription("HETS-01", _configuration))));
}
int?statusId = StatusHelper.GetStatusId(HetRentalRequest.StatusInProgress, "rentalRequestStatus", _context);
if (statusId == null)
{
return(new NotFoundObjectResult(new HetsResponse("HETS-23", ErrorViewModel.GetDescription("HETS-23", _configuration))));
}
// check if we have the rental request that is In Progress
exists = _context.HetRentalRequest
.Any(a => a.RentalRequestId == id &&
a.RentalRequestStatusTypeId == statusId);
// rental request must be "in progress"
if (!exists)
{
return(new BadRequestObjectResult(new HetsResponse("HETS-06", ErrorViewModel.GetDescription("HETS-06", _configuration))));
}
// get rental request record
HetRentalRequest request = _context.HetRentalRequest
.Include(x => x.Project)
.ThenInclude(x => x.District)
.Include(x => x.LocalArea)
.Include(x => x.HetRentalRequestRotationList)
.ThenInclude(x => x.Equipment)
.First(a => a.RentalRequestId == id);
// get rotation list record
HetRentalRequestRotationList requestRotationList = _context.HetRentalRequestRotationList
.FirstOrDefault(a => a.RentalRequestRotationListId == item.RentalRequestRotationListId);
// not found
if (requestRotationList == null)
{
return(new NotFoundObjectResult(new HetsResponse("HETS-01", ErrorViewModel.GetDescription("HETS-01", _configuration))));
}
// update rotation list record
int tempEquipmentId = item.Equipment.EquipmentId;
requestRotationList.ConcurrencyControlNumber = item.ConcurrencyControlNumber;
requestRotationList.EquipmentId = tempEquipmentId;
requestRotationList.IsForceHire = item.IsForceHire;
requestRotationList.AskedDateTime = DateTime.UtcNow;
requestRotationList.Note = item.Note;
requestRotationList.OfferRefusalReason = item.OfferRefusalReason;
requestRotationList.OfferResponse = item.OfferResponse;
requestRotationList.OfferResponseDatetime = item.OfferResponseDatetime;
requestRotationList.WasAsked = item.WasAsked;
requestRotationList.OfferResponseNote = item.OfferResponseNote;
// do we need to create or modify a Rental Agreement?
if (item.IsForceHire == true ||
item.OfferResponse.Equals("Yes", StringComparison.InvariantCultureIgnoreCase))
{
// get rental agreement record
HetRentalAgreement rentalAgreement = _context.HetRentalAgreement
.FirstOrDefault(a => a.RentalAgreementId == item.RentalAgreementId);
// create rental agreement if it doesn't exist
if (rentalAgreement == null)
{
// generate the rental agreement number
string agreementNumber = RentalAgreementHelper.GetRentalAgreementNumber(item.Equipment, _context);
// get user info - agreement city
User user = UserAccountHelper.GetUser(_context, _httpContext);
string agreementCity = user.AgreementCity;
int?rateTypeId = StatusHelper.GetRatePeriodId(HetRatePeriodType.PeriodHourly, _context);
if (rateTypeId == null)
{
return(new NotFoundObjectResult(new HetsResponse("HETS-24", ErrorViewModel.GetDescription("HETS-24", _configuration))));
}
rentalAgreement = new HetRentalAgreement
{
ProjectId = request.ProjectId,
DistrictId = request.Project.District.DistrictId,
EquipmentId = tempEquipmentId,
Number = agreementNumber,
RatePeriodTypeId = (int)rateTypeId,
AgreementCity = agreementCity
};
// add overtime rates
List <HetProvincialRateType> overtime = _context.HetProvincialRateType.AsNoTracking()
.Where(x => x.Overtime)
.ToList();
// agreement overtime records (default overtime flag)
foreach (HetProvincialRateType rate in overtime)
{
// add the rate
HetRentalAgreementRate newAgreementRate = new HetRentalAgreementRate
{
Comment = rate.Description,
ComponentName = rate.RateType,
Overtime = true,
Active = rate.Active,
IsIncludedInTotal = rate.IsIncludedInTotal,
Rate = rate.Rate
};
if (rentalAgreement.HetRentalAgreementRate == null)
{
rentalAgreement.HetRentalAgreementRate = new List <HetRentalAgreementRate>();
}
rentalAgreement.HetRentalAgreementRate.Add(newAgreementRate);
}
_context.HetRentalAgreement.Add(rentalAgreement);
}
int?statusIdAgreement = StatusHelper.GetStatusId(HetRentalAgreement.StatusActive, "rentalAgreementStatus", _context);
if (statusIdAgreement == null)
{
return(new NotFoundObjectResult(new HetsResponse("HETS-23", ErrorViewModel.GetDescription("HETS-23", _configuration))));
}
// update rental agreement
rentalAgreement.RentalAgreementStatusTypeId = (int)statusIdAgreement;
rentalAgreement.DatedOn = DateTime.UtcNow;
rentalAgreement.EstimateHours = request.ExpectedHours;
rentalAgreement.EstimateStartWork = request.ExpectedStartDate;
rentalAgreement.RentalRequestId = request.RentalRequestId;
rentalAgreement.RentalRequestRotationListId = requestRotationList.RentalRequestRotationListId;
// have to save the agreement
_context.SaveChanges();
// relate the new rental agreement to the original rotation list record
int tempRentalAgreementId = rentalAgreement.RentalAgreementId;
requestRotationList.RentalAgreementId = tempRentalAgreementId;
requestRotationList.RentalAgreement = rentalAgreement;
}
// can we "Complete" this rental request (if the Yes or Forced Hires = Request.EquipmentCount)
int countOfYeses = 0;
int equipmentRequestCount = request.EquipmentCount;
foreach (HetRentalRequestRotationList rotationList in request.HetRentalRequestRotationList)
{
if (rotationList.OfferResponse != null &&
rotationList.OfferResponse.Equals("Yes", StringComparison.InvariantCultureIgnoreCase))
{
countOfYeses = countOfYeses + 1;
}
else if (rotationList.IsForceHire != null &&
rotationList.IsForceHire == true)
{
countOfYeses = countOfYeses + 1;
}
}
if (countOfYeses >= equipmentRequestCount)
{
int?statusIdComplete = StatusHelper.GetStatusId(HetRentalRequest.StatusComplete, "rentalRequestStatus", _context);
if (statusIdComplete == null)
{
return(new NotFoundObjectResult(new HetsResponse("HETS-23", ErrorViewModel.GetDescription("HETS-23", _configuration))));
}
request.RentalRequestStatusTypeId = (int)statusIdComplete;
request.Status = "Complete";
request.FirstOnRotationList = null;
}
// 1. get the number of blocks for this equipment type
// 2. set which rotation list record is currently "active"
int numberOfBlocks = EquipmentHelper.GetNumberOfBlocks(item.Equipment, _configuration);
RentalRequestHelper.UpdateRotationList(request, numberOfBlocks, _context);
// save the changes
_context.SaveChanges();
// get the scoring rules
SeniorityScoringRules scoringRules = new SeniorityScoringRules(_configuration);
return(new ObjectResult(new HetsResponse(RentalRequestHelper.GetRecordWithRotationList(id, scoringRules, _context))));
}
