private static HetEquipment LastAskedByBlock(int block, int?districtEquipmentTypeId,
int?localAreaId, DateTime fiscalStart, DbAppContext context)
{
if (districtEquipmentTypeId == null || localAreaId == null)
{
return(null);
}
block++;
// if this is not block 1 - check that we have "asked" anyone in the previous list
HetRentalRequestRotationList rotationList = context.HetRentalRequestRotationList.AsNoTracking()
.Include(x => x.RentalRequest)
.Include(x => x.Equipment)
.Where(x => x.RentalRequest.DistrictEquipmentTypeId == districtEquipmentTypeId &&
x.RentalRequest.LocalAreaId == localAreaId &&
x.RentalRequest.AppCreateTimestamp >= fiscalStart &&
x.Equipment.BlockNumber == block &&
x.WasAsked == true &&
x.IsForceHire != true)
.OrderByDescending(x => x.RentalRequestId)
.ThenByDescending(x => x.RotationListSortOrder)
.FirstOrDefault();
// return the equipment record that was last asked for this block
return(rotationList?.Equipment);
}
/// <summary>
/// Create Last Called
/// </summary>
/// <param name="performContext"></param>
/// <param name="dbContext"></param>
/// <param name="systemId"></param>
public static void ProcessLastCalled(PerformContext performContext, DbAppContext dbContext, string systemId)
{
try
{
performContext.WriteLine("*** Recreating Last Called ***");
Debug.WriteLine("Recreating Last Called");
int ii = 0;
string _oldTableProgress = "LastCalled_Progress";
string _newTable = "LastCalled";
// check if the last called 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("*** Recreating Last Called is complete from the former process ***");
return;
}
// ************************************************************
// get all last called records
// ************************************************************
List <HetLocalAreaRotationList> rotationList = dbContext.HetLocalAreaRotationList.AsNoTracking()
.Distinct()
.ToList();
// ************************************************************************
// iterate the data and create rotation requests
// ************************************************************************
Debug.WriteLine("Recreating Last Called - Rotation List Record Count: " + rotationList.Count);
// get status
int?statusIdComplete = StatusHelper.GetStatusId(HetRentalRequest.StatusComplete, "rentalRequestStatus", dbContext);
if (statusIdComplete == null)
{
throw new DataException("Status Id cannot be null");
}
foreach (HetLocalAreaRotationList listItem in rotationList)
{
HetRentalRequest request = new HetRentalRequest
{
LocalAreaId = listItem.LocalAreaId,
DistrictEquipmentTypeId = listItem.DistrictEquipmentTypeId,
RentalRequestStatusTypeId = (int)statusIdComplete,
ExpectedStartDate = DateTime.Now,
ExpectedEndDate = DateTime.Now,
EquipmentCount = 1,
ExpectedHours = 0,
AppCreateUserid = systemId,
AppCreateTimestamp = DateTime.UtcNow,
AppLastUpdateUserid = systemId,
AppLastUpdateTimestamp = DateTime.UtcNow
};
dbContext.HetRentalRequest.Add(request);
// save change to database
if (ii++ % 100 == 0)
{
Debug.WriteLine("Recreating Last Called - Index: " + ii);
ImportUtility.AddImportMapForProgress(dbContext, _oldTableProgress, ii.ToString(), BcBidImport.SigId, _newTable);
dbContext.SaveChangesForImport();
}
}
// save remaining requests
dbContext.SaveChangesForImport();
// ************************************************************************
// iterate the data and create "last called" records
// ************************************************************************
foreach (HetLocalAreaRotationList listItem in rotationList)
{
// get request
HetRentalRequest request = dbContext.HetRentalRequest.AsNoTracking()
.FirstOrDefault(x => x.LocalAreaId == listItem.LocalAreaId &&
x.DistrictEquipmentTypeId == listItem.DistrictEquipmentTypeId);
if (request == null)
{
throw new DataException("Rental request cannot be null");
}
// block 1
if (listItem.AskNextBlock1Id != null)
{
// create last call record
HetRentalRequestRotationList rotation = new HetRentalRequestRotationList
{
RentalRequestId = request.RentalRequestId,
EquipmentId = listItem.AskNextBlock1Id,
BlockNumber = 1,
RotationListSortOrder = 1,
AskedDateTime = DateTime.Now,
WasAsked = true,
OfferResponse = "Yes",
OfferResponseDatetime = DateTime.Now,
IsForceHire = false,
Note = "CONVERSION",
AppCreateUserid = systemId,
AppCreateTimestamp = DateTime.UtcNow,
AppLastUpdateUserid = systemId,
AppLastUpdateTimestamp = DateTime.UtcNow
};
dbContext.HetRentalRequestRotationList.Add(rotation);
}
// block 2
if (listItem.AskNextBlock2Id != null)
{
// create last call record
HetRentalRequestRotationList rotation = new HetRentalRequestRotationList
{
RentalRequestId = request.RentalRequestId,
EquipmentId = listItem.AskNextBlock2Id,
BlockNumber = 2,
RotationListSortOrder = 2,
AskedDateTime = DateTime.Now,
WasAsked = true,
OfferResponse = "Yes",
OfferResponseDatetime = DateTime.Now,
IsForceHire = false,
Note = "CONVERSION",
AppCreateUserid = systemId,
AppCreateTimestamp = DateTime.UtcNow,
AppLastUpdateUserid = systemId,
AppLastUpdateTimestamp = DateTime.UtcNow
};
dbContext.HetRentalRequestRotationList.Add(rotation);
}
// open block
if (listItem.AskNextBlockOpenId != null)
{
// get equipment record
HetEquipment equipment = dbContext.HetEquipment.AsNoTracking()
.FirstOrDefault(x => x.EquipmentId == listItem.AskNextBlockOpenId);
if (equipment == null)
{
throw new DataException("Equipment cannot be null");
}
// create last call record
HetRentalRequestRotationList rotation = new HetRentalRequestRotationList
{
RentalRequestId = request.RentalRequestId,
EquipmentId = listItem.AskNextBlockOpenId,
BlockNumber = equipment.BlockNumber,
RotationListSortOrder = 3,
AskedDateTime = DateTime.Now,
WasAsked = true,
OfferResponse = "Yes",
OfferResponseDatetime = DateTime.Now,
IsForceHire = false,
Note = "CONVERSION",
AppCreateUserid = systemId,
AppCreateTimestamp = DateTime.UtcNow,
AppLastUpdateUserid = systemId,
AppLastUpdateTimestamp = DateTime.UtcNow
};
dbContext.HetRentalRequestRotationList.Add(rotation);
}
// save change to database
if (ii++ % 100 == 0)
{
Debug.WriteLine("Recreating Last Called - Index: " + ii);
ImportUtility.AddImportMapForProgress(dbContext, _oldTableProgress, ii.ToString(), BcBidImport.SigId, _newTable);
dbContext.SaveChangesForImport();
}
}
// save remaining requests
dbContext.SaveChangesForImport();
// ************************************************************
// save final set of updates
// ************************************************************
try
{
performContext.WriteLine("*** Recreating Last Called is Done ***");
Debug.WriteLine("Recreating Last Called 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="rotationList"></param>
/// <param name="context"></param>
/// <returns></returns>
public static SeniorityViewModel ToSeniorityViewModel(HetEquipment model, SeniorityScoringRules scoringRules,
HetRentalRequestRotationList rotationList, DbAppContext context)
{
SeniorityViewModel seniorityViewModel = new SeniorityViewModel();
if (model == null)
{
return(seniorityViewModel);
}
int numberOfBlocks = 0;
// get number of blocks for this equipment type
if (model.DistrictEquipmentType != null)
{
numberOfBlocks = model.DistrictEquipmentType.EquipmentType.IsDumpTruck
? scoringRules.GetTotalBlocks("DumpTruck") + 1
: scoringRules.GetTotalBlocks() + 1;
}
// 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;
}
// *************************************************************
// check if this record/owner was called last
// *************************************************************
bool callLast = rotationList != null && rotationList.EquipmentId == model.EquipmentId;
seniorityViewModel.LastCalled = callLast ? "Y" : " ";
// *************************************************************
// map data to view model
// *************************************************************
seniorityViewModel.Id = model.EquipmentId;
if (model.DistrictEquipmentType != null)
{
seniorityViewModel.EquipmentType = model.DistrictEquipmentType.DistrictEquipmentName;
}
if (model.Owner != null)
{
seniorityViewModel.OwnerName = model.Owner.OrganizationName;
seniorityViewModel.OwnerId = model.OwnerId;
}
// replacing Open with 3 (HETS-968 Rotation list -Wrong Block number for Open block)
seniorityViewModel.Block = blockNumber == numberOfBlocks ? "3" : blockNumber.ToString();
// format the seniority value
seniorityViewModel.Seniority = $"{model.Seniority:0.###}";
// format year / make / model / size
seniorityViewModel.YearMakeModelSize = $"{model.Year}/{model.Make}/{model.Model}/{model.Size}";
seniorityViewModel.EquipmentCode = model.EquipmentCode;
seniorityViewModel.YearsRegistered = model.YearsOfService.ToString();
// Determine if this equipment is currently hired
seniorityViewModel.IsHired = EquipmentHelper.IsHired(model.EquipmentId, context) ? "Y" : "N";
// calculate and format the ytd hours
float tempHours = EquipmentHelper.GetYtdServiceHours(model.EquipmentId, context);
seniorityViewModel.YtdHours = string.Format("{0:0.###}", tempHours);
// format the hours
seniorityViewModel.HoursYearMinus1 = string.Format("{0:0.###}", model.ServiceHoursLastYear);
seniorityViewModel.HoursYearMinus2 = string.Format("{0:0.###}", model.ServiceHoursTwoYearsAgo);
seniorityViewModel.HoursYearMinus3 = string.Format("{0:0.###}", model.ServiceHoursThreeYearsAgo);
// add the correct sorting order (numeric)
seniorityViewModel.SenioritySortOrder = EquipmentHelper.CalculateSenioritySortOrder(blockNumber, numberInBlock);
return(seniorityViewModel);
}
/// <summary>
/// Create Rental Request Rotation List
/// </summary>
/// <param name="request"></param>
/// <param name="context"></param>
/// <param name="configuration"></param>
public static HetRentalRequest CreateRotationList(HetRentalRequest request, DbAppContext context, IConfiguration configuration)
{
request.HetRentalRequestRotationList = new List <HetRentalRequestRotationList>();
// validate input parameters
if (request.LocalAreaId == null || request.DistrictEquipmentTypeId == null)
{
return(request);
}
int currentSortOrder = 1;
// get the number of blocks for this piece of equipment
int numberOfBlocks = GetNumberOfBlocks(request, context, configuration);
numberOfBlocks = numberOfBlocks + 1;
int?statusId = StatusHelper.GetStatusId(HetEquipment.StatusApproved, "equipmentStatus", context);
if (statusId == null)
{
throw new ArgumentException("Status Id cannot be null");
}
// get the equipment based on the current seniority list for the area
// (and sort the results based on block then
// numberInBlock -> ensures consistency with the UI)
for (int currentBlock = 1; currentBlock <= numberOfBlocks; currentBlock++)
{
// start by getting the current set of equipment for the given equipment type
List <HetEquipment> blockEquipment = context.HetEquipment.AsNoTracking()
.Where(x => x.DistrictEquipmentTypeId == request.DistrictEquipmentTypeId &&
x.BlockNumber == currentBlock &&
x.LocalAreaId == request.LocalAreaId &&
x.EquipmentStatusTypeId == statusId)
.OrderBy(x => x.NumberInBlock)
.ToList();
int listSize = blockEquipment.Count;
// sets the rotation list sort order
int currentPosition = 0;
for (int i = 0; i < listSize; i++)
{
HetRentalRequestRotationList rentalRequestRotationList = new HetRentalRequestRotationList
{
Equipment = blockEquipment[i],
EquipmentId = blockEquipment[i].EquipmentId,
SeniorityFloat = blockEquipment[i].Seniority,
BlockNumber = blockEquipment[i].BlockNumber,
AppCreateTimestamp = DateTime.UtcNow,
RotationListSortOrder = currentSortOrder
};
request.HetRentalRequestRotationList.Add(rentalRequestRotationList);
currentPosition++;
currentSortOrder++;
if (currentPosition >= listSize)
{
currentPosition = 0;
}
}
}
// update the local area rotation list - find record #1
request = SetupNewRotationList(request, numberOfBlocks, context);
// remove equipment records
foreach (HetRentalRequestRotationList rotationList in request.HetRentalRequestRotationList)
{
rotationList.Equipment = null;
}
// Done!
return(request);
}
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))));
}
