public virtual IActionResult RentalRequestsIdNotesGet([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))));
}
HetRentalRequest request = _context.HetRentalRequest.AsNoTracking()
.Include(x => x.HetNote)
.First(x => x.RentalRequestId == id);
List <HetNote> notes = new List <HetNote>();
foreach (HetNote note in request.HetNote)
{
if (note.IsNoLongerRelevant == false)
{
notes.Add(note);
}
}
return(new ObjectResult(new HetsResponse(notes)));
}
/// <summary>
/// Convert to Rental Request Lite Model
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public static RentalRequestLite ToLiteModel(HetRentalRequest request)
{
RentalRequestLite requestLite = new RentalRequestLite();
if (request != null)
{
if (request.DistrictEquipmentType != null)
{
requestLite.EquipmentTypeName = request.DistrictEquipmentType.EquipmentType.Name;
requestLite.DistrictEquipmentName = request.DistrictEquipmentType.DistrictEquipmentName;
}
requestLite.Id = request.RentalRequestId;
requestLite.LocalArea = request.LocalArea;
if (request.Project != null)
{
requestLite.PrimaryContact = request.Project.PrimaryContact;
requestLite.ProjectName = request.Project.Name;
requestLite.ProjectId = request.Project.ProjectId;
}
requestLite.Status = request.RentalRequestStatusType.Description;
requestLite.EquipmentCount = request.EquipmentCount;
requestLite.ExpectedEndDate = request.ExpectedEndDate;
requestLite.ExpectedStartDate = request.ExpectedStartDate;
}
return(requestLite);
}
public virtual IActionResult RentalRequestsIdAttachmentsGet([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))));
}
HetRentalRequest equipment = _context.HetRentalRequest.AsNoTracking()
.Include(x => x.HetDigitalFile)
.First(a => a.RentalRequestId == id);
// extract the attachments and update properties for UI
List <HetDigitalFile> attachments = new List <HetDigitalFile>();
foreach (HetDigitalFile attachment in equipment.HetDigitalFile)
{
if (attachment != null)
{
attachment.FileSize = attachment.FileContents.Length;
attachment.LastUpdateTimestamp = attachment.AppLastUpdateTimestamp;
attachment.LastUpdateUserid = attachment.AppLastUpdateUserid;
attachments.Add(attachment);
}
}
return(new ObjectResult(new HetsResponse(attachments)));
}
/// <summary>
/// Check how many Yes' we currently have from Owners
/// </summary>
/// <returns></returns>
public static int CalculateYesCount(HetRentalRequest rentalRequest)
{
int temp = 0;
if (rentalRequest.HetRentalRequestRotationList != null)
{
foreach (HetRentalRequestRotationList equipment in rentalRequest.HetRentalRequestRotationList)
{
if (equipment.OfferResponse != null &&
equipment.OfferResponse.Equals("Yes", StringComparison.InvariantCultureIgnoreCase))
{
temp++;
}
if (equipment.IsForceHire != null &&
equipment.IsForceHire == true)
{
temp++;
}
}
}
// set the current Yes / Forced Hire Count
return(temp);
}
/// <summary>
/// Get the number of blocks for this type of equipment
/// </summary>
/// <param name="item"></param>
/// <param name="context"></param>
/// <param name="configuration"></param>
/// <returns></returns>
private static int GetNumberOfBlocks(HetRentalRequest item, DbAppContext context, IConfiguration configuration)
{
int numberOfBlocks = -1;
try
{
SeniorityScoringRules scoringRules = new SeniorityScoringRules(configuration);
// get record
HetDistrictEquipmentType equipment = context.HetDistrictEquipmentType.AsNoTracking()
.Include(x => x.EquipmentType)
.FirstOrDefault(x => x.DistrictEquipmentTypeId == item.DistrictEquipmentTypeId);
if (equipment == null)
{
return(0);
}
numberOfBlocks = equipment.EquipmentType.IsDumpTruck ?
scoringRules.GetTotalBlocks("DumpTruck") : scoringRules.GetTotalBlocks();
}
catch
{
// do nothing
}
return(numberOfBlocks);
}
private static HetRentalRequest DropHiredEquipment(HetRentalRequest rentalRequest, DbAppContext context)
{
// check if any items have "Active" contracts - and drop them from the list
// * ensure we ignore "blank" rental agreements (i.e. rental request is null)
int?statusIdRentalAgreement = StatusHelper.GetStatusId(HetRentalAgreement.StatusActive, "rentalAgreementStatus", context);
if (statusIdRentalAgreement == null)
{
throw new ArgumentException("Status Id cannot be null");
}
int listSize = rentalRequest.HetRentalRequestRotationList.Count;
for (int i = listSize - 1; i >= 0; i--)
{
bool agreementExists = context.HetRentalAgreement.AsNoTracking()
.Any(x => x.EquipmentId == rentalRequest.HetRentalRequestRotationList.ElementAt(i).EquipmentId&&
x.RentalRequestId != null &&
x.RentalAgreementStatusTypeId == statusIdRentalAgreement);
if (agreementExists)
{
rentalRequest.HetRentalRequestRotationList.Remove(rentalRequest.HetRentalRequestRotationList.ElementAt(i));
}
}
return(rentalRequest);
}
/// <summary>
/// Set the Status of the Rental Request Rotation List
/// </summary>
/// <param name="rentalRequest"></param>
/// <param name="context"></param>
public static string RentalRequestStatus(HetRentalRequest rentalRequest, DbAppContext context)
{
string tempStatus = "New";
// validate input parameters
if (rentalRequest?.LocalAreaId != null && rentalRequest.DistrictEquipmentTypeId != null)
{
int?statusIdInProgress = StatusHelper.GetStatusId(HetRentalRequest.StatusInProgress, "rentalRequestStatus", context);
if (statusIdInProgress == null)
{
return(null);
}
// check if there is an existing "In Progress" Rental Request
List <HetRentalRequest> requests = context.HetRentalRequest
.Where(x => x.DistrictEquipmentType.DistrictEquipmentTypeId == rentalRequest.DistrictEquipmentTypeId &&
x.LocalArea.LocalAreaId == rentalRequest.LocalAreaId &&
x.RentalRequestStatusTypeId == statusIdInProgress)
.ToList();
tempStatus = requests.Count == 0 ? "In Progress" : "New";
}
return(tempStatus);
}
public virtual IActionResult RentalRequestsIdNotePost([FromRoute] int id, [FromBody] HetNote item)
{
bool exists = _context.HetRentalRequest.Any(a => a.RentalRequestId == id);
// not found
if (!exists || item == null)
{
return(new NotFoundObjectResult(new HetsResponse("HETS-01", ErrorViewModel.GetDescription("HETS-01", _configuration))));
}
// add or update note
if (item.NoteId > 0)
{
// get note
HetNote note = _context.HetNote.FirstOrDefault(a => a.NoteId == item.NoteId);
// not found
if (note == null)
{
return(new NotFoundObjectResult(new HetsResponse("HETS-01", ErrorViewModel.GetDescription("HETS-01", _configuration))));
}
note.ConcurrencyControlNumber = item.ConcurrencyControlNumber;
note.Text = item.Text;
note.IsNoLongerRelevant = item.IsNoLongerRelevant;
}
else // add note
{
HetNote note = new HetNote
{
RentalRequestId = id,
Text = item.Text,
IsNoLongerRelevant = item.IsNoLongerRelevant
};
_context.HetNote.Add(note);
}
_context.SaveChanges();
// return updated note records
HetRentalRequest request = _context.HetRentalRequest.AsNoTracking()
.Include(x => x.HetNote)
.First(x => x.RentalRequestId == id);
List <HetNote> notes = new List <HetNote>();
foreach (HetNote note in request.HetNote)
{
if (note.IsNoLongerRelevant == false)
{
notes.Add(note);
}
}
return(new ObjectResult(new HetsResponse(notes)));
}
public virtual IActionResult RentalRequestIdAttachmentsPost([FromRoute] int id, [FromForm] IList <IFormFile> files)
{
// validate the id
bool exists = _context.HetRentalRequest.Any(a => a.RentalRequestId == id);
if (!exists)
{
return(new StatusCodeResult(404));
}
HetRentalRequest rentalRequest = _context.HetRentalRequest
.Include(x => x.HetDigitalFile)
.First(a => a.RentalRequestId == id);
foreach (IFormFile file in files)
{
if (file.Length > 0)
{
HetDigitalFile attachment = new HetDigitalFile();
// strip out extra info in the file name
if (!string.IsNullOrEmpty(file.FileName))
{
attachment.FileName = Path.GetFileName(file.FileName);
}
// allocate storage for the file and create a memory stream
attachment.FileContents = new byte[file.Length];
using (MemoryStream fileStream = new MemoryStream(attachment.FileContents))
{
file.CopyTo(fileStream);
}
attachment.Type = GetType(attachment.FileName);
// set the mime type id
int?mimeTypeId = StatusHelper.GetMimeTypeId(attachment.Type, _context);
if (mimeTypeId == null)
{
throw new DataException("Mime Type Id cannot be null");
}
attachment.MimeTypeId = (int)mimeTypeId;
rentalRequest.HetDigitalFile.Add(attachment);
}
}
_context.SaveChanges();
return(new ObjectResult(rentalRequest.HetDigitalFile));
}
public static List <History> GetHistoryRecords(int id, int?offset, int?limit, DbAppContext context)
{
HetRentalRequest request = context.HetRentalRequest.AsNoTracking()
.Include(x => x.HetHistory)
.First(a => a.RentalRequestId == id);
List <HetHistory> data = request.HetHistory
.OrderByDescending(y => y.AppLastUpdateTimestamp)
.ToList();
if (offset == null)
{
offset = 0;
}
if (limit == null)
{
limit = data.Count - offset;
}
List <History> result = new List <History>();
for (int i = (int)offset; i < data.Count && i < offset + limit; i++)
{
History temp = new History();
if (data[i] != null)
{
temp.HistoryText = data[i].HistoryText;
temp.Id = data[i].HistoryId;
temp.LastUpdateTimestamp = data[i].AppLastUpdateTimestamp;
temp.LastUpdateUserid = data[i].AppLastUpdateUserid;
temp.AffectedEntityId = data[i].RentalRequestId;
}
result.Add(temp);
}
return(result);
}
/// <summary>
/// Get rental request record
/// </summary>
/// <param name="id"></param>
/// <param name="context"></param>
public static HetRentalRequest GetRecord(int id, DbAppContext context)
{
HetRentalRequest request = context.HetRentalRequest.AsNoTracking()
.Include(x => x.RentalRequestStatusType)
.Include(x => x.LocalArea.ServiceArea.District.Region)
.Include(x => x.Project)
.ThenInclude(c => c.PrimaryContact)
.Include(x => x.Project)
.ThenInclude(c => c.ProjectStatusType)
.Include(x => x.HetRentalRequestAttachment)
.Include(x => x.DistrictEquipmentType)
.Include(x => x.HetRentalRequestRotationList)
.ThenInclude(y => y.Equipment)
.ThenInclude(z => z.EquipmentStatusType)
.FirstOrDefault(a => a.RentalRequestId == id);
if (request != null)
{
request.Status = request.RentalRequestStatusType.RentalRequestStatusTypeCode;
// calculate the Yes Count based on the RentalRequestList
request.YesCount = CalculateYesCount(request);
// calculate YTD hours for the equipment records
if (request.HetRentalRequestRotationList != null)
{
foreach (HetRentalRequestRotationList rotationList in request.HetRentalRequestRotationList)
{
if (rotationList.Equipment != null)
{
rotationList.Equipment.HoursYtd = EquipmentHelper.GetYtdServiceHours(rotationList.Equipment.EquipmentId, context);
}
}
}
}
return(request);
}
public virtual IActionResult DistrictEquipmentTypesIdDeletePost([FromRoute] int id)
{
bool exists = _context.HetDistrictEquipmentType.Any(a => a.DistrictEquipmentTypeId == id);
// not found
if (!exists)
{
return(new NotFoundObjectResult(new HetsResponse("HETS-01", ErrorViewModel.GetDescription("HETS-01", _configuration))));
}
HetDistrictEquipmentType item = _context.HetDistrictEquipmentType.First(a => a.DistrictEquipmentTypeId == id);
// HETS-978 - Give a clear error message when deleting equipment type fails
int?archiveStatus = StatusHelper.GetStatusId(HetEquipment.StatusArchived, "equipmentStatus", _context);
if (archiveStatus == null)
{
return(new NotFoundObjectResult(new HetsResponse("HETS-23", ErrorViewModel.GetDescription("HETS-23", _configuration))));
}
int?pendingStatus = StatusHelper.GetStatusId(HetEquipment.StatusPending, "equipmentStatus", _context);
if (pendingStatus == null)
{
return(new NotFoundObjectResult(new HetsResponse("HETS-23", ErrorViewModel.GetDescription("HETS-23", _configuration))));
}
HetEquipment equipment = _context.HetEquipment.AsNoTracking()
.FirstOrDefault(x => x.DistrictEquipmentTypeId == item.DistrictEquipmentTypeId &&
x.EquipmentStatusTypeId != archiveStatus);
if (equipment != null)
{
return(new BadRequestObjectResult(new HetsResponse("HETS-37", ErrorViewModel.GetDescription("HETS-37", _configuration))));
}
bool softDelete = false;
// check for foreign key relationships - equipment
equipment = _context.HetEquipment.AsNoTracking()
.FirstOrDefault(x => x.DistrictEquipmentTypeId == item.DistrictEquipmentTypeId);
if (equipment != null)
{
softDelete = true;
}
// check for foreign key relationships - local area rotation lists
HetLocalAreaRotationList rotationList = _context.HetLocalAreaRotationList.AsNoTracking()
.FirstOrDefault(x => x.DistrictEquipmentTypeId == item.DistrictEquipmentTypeId);
if (rotationList != null)
{
softDelete = true;
}
// check for foreign key relationships - rental requests
HetRentalRequest request = _context.HetRentalRequest.AsNoTracking()
.FirstOrDefault(x => x.DistrictEquipmentTypeId == item.DistrictEquipmentTypeId);
if (request != null)
{
softDelete = true;
}
// delete the record
if (!softDelete)
{
_context.HetDistrictEquipmentType.Remove(item);
}
else
{
// else "SOFT" delete record
item.Deleted = true;
}
_context.SaveChanges();
return(new ObjectResult(new HetsResponse(item)));
}
/// <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;
}
}
public static void MergeDistrictEquipmentTypes(PerformContext context, string seniorityScoringRules,
string connectionString)
{
// open a connection to the database
DbAppContext dbContext = new DbAppContext(connectionString);
// get equipment status
int?equipmentStatusId = StatusHelper.GetStatusId(HetEquipment.StatusApproved, "equipmentStatus", dbContext);
if (equipmentStatusId == null)
{
throw new ArgumentException("Status Code not found");
}
// **************************************************
// Phase 1: Identify Master District Equipment Types
// **************************************************
context.WriteLine("Phase 1: Identify Master District Equipment Types");
IProgressBar progress = context.WriteProgressBar();
progress.SetValue(0);
// get records
List <MergeRecord> masterList = dbContext.HetDistrictEquipmentType.AsNoTracking()
.Where(x => x.ServiceAreaId != null &&
x.Deleted == false)
.Select(x => new MergeRecord
{
DistrictEquipmentTypeId = x.DistrictEquipmentTypeId,
DistrictEquipmentName = x.DistrictEquipmentName,
EquipmentPrefix = GetPrefix(x.DistrictEquipmentName),
DistrictId = x.DistrictId,
EquipmentTypeId = x.EquipmentTypeId
})
.Distinct()
.ToList();
// sort the list accordingly
masterList = masterList
.OrderBy(x => x.DistrictId)
.ThenBy(x => x.EquipmentTypeId)
.ThenBy(x => x.EquipmentPrefix).ToList();
int increment = 0;
int? currentDistrict = -1;
int? masterDistrictEquipmentTypeId = -1;
int? currentEquipmentType = -1;
string currentPrefix = "";
foreach (MergeRecord detRecord in masterList)
{
bool newMerge;
if (detRecord.DistrictId != currentDistrict ||
detRecord.EquipmentTypeId != currentEquipmentType ||
detRecord.EquipmentPrefix != currentPrefix)
{
newMerge = true;
currentDistrict = detRecord.DistrictId;
currentEquipmentType = detRecord.EquipmentTypeId;
currentPrefix = detRecord.EquipmentPrefix;
masterDistrictEquipmentTypeId = detRecord.DistrictEquipmentTypeId;
detRecord.Master = true;
detRecord.MasterDistrictEquipmentTypeId = masterDistrictEquipmentTypeId;
}
else
{
newMerge = false;
detRecord.Master = false;
detRecord.MasterDistrictEquipmentTypeId = masterDistrictEquipmentTypeId;
}
// kickoff the merge for this district, equipment type and prefix
if (newMerge)
{
int district = currentDistrict ?? -1;
int type = currentEquipmentType ?? -1;
string prefix = currentPrefix;
string masterName = "";
List <MergeRecord> types = masterList
.Where(x => x.DistrictId == district &&
x.EquipmentTypeId == type &&
x.EquipmentPrefix == prefix).ToList();
// create master name and update master record
foreach (MergeRecord equipmentType in types)
{
string temp = equipmentType.DistrictEquipmentName.Replace(currentPrefix, "").Trim();
int start = temp.IndexOf("-", StringComparison.Ordinal);
if (start > -1)
{
start++;
}
int length = temp.Length - start < 0 ? 0 : temp.Length - start;
temp = temp.Substring(start, length).Trim();
masterName = masterName.Length > 0 ?
$"{masterName} | {temp}" :
temp;
}
masterName = $"{currentPrefix} - {masterName}";
types.ElementAt(0).DistrictEquipmentName = masterName;
}
// update status bar
increment++;
progress.SetValue(Convert.ToInt32((decimal)(masterList.Count - (masterList.Count - increment)) / masterList.Count * 100));
}
// done!
progress.SetValue(100);
// **************************************************
// Phase 2: Update Master District Equipment Types
// **************************************************
context.WriteLine("Phase 2: Update Master District Equipment Types");
progress = context.WriteProgressBar();
progress.SetValue(0);
List <MergeRecord> masterRecords = masterList.Where(x => x.Master).ToList();
increment = 0;
foreach (MergeRecord detRecord in masterRecords)
{
// get det record & update name
HetDistrictEquipmentType det = dbContext.HetDistrictEquipmentType
.First(x => x.DistrictEquipmentTypeId == detRecord.DistrictEquipmentTypeId);
det.DistrictEquipmentName = detRecord.DistrictEquipmentName;
det.ServiceAreaId = null;
// save changes to district equipment types and associated equipment records
dbContext.SaveChangesForImport();
// update status bar
increment++;
progress.SetValue(Convert.ToInt32((decimal)(masterRecords.Count - (masterRecords.Count - increment)) / masterRecords.Count * 100));
}
// done!
progress.SetValue(100);
// **************************************************
// Phase 3: Update Non-Master District Equipment Types
// **************************************************
context.WriteLine("Phase 3: Update Non-Master District Equipment Types");
progress = context.WriteProgressBar();
progress.SetValue(0);
List <MergeRecord> mergeRecords = masterList.Where(x => !x.Master).ToList();
increment = 0;
foreach (MergeRecord detRecord in mergeRecords)
{
int originalDistrictEquipmentTypeId = detRecord.DistrictEquipmentTypeId;
int?newDistrictEquipmentTypeId = detRecord.MasterDistrictEquipmentTypeId;
// get equipment & update
IEnumerable <HetEquipment> equipmentRecords = dbContext.HetEquipment
.Where(x => x.DistrictEquipmentTypeId == originalDistrictEquipmentTypeId);
foreach (HetEquipment equipment in equipmentRecords)
{
equipment.DistrictEquipmentTypeId = newDistrictEquipmentTypeId;
}
// save changes to associated equipment records
dbContext.SaveChangesForImport();
// get det record
HetDistrictEquipmentType det = dbContext.HetDistrictEquipmentType
.First(x => x.DistrictEquipmentTypeId == originalDistrictEquipmentTypeId);
// delete old det record
HetRentalRequest request = dbContext.HetRentalRequest.AsNoTracking()
.FirstOrDefault(x => x.DistrictEquipmentTypeId == originalDistrictEquipmentTypeId);
HetLocalAreaRotationList rotationList = dbContext.HetLocalAreaRotationList.AsNoTracking()
.FirstOrDefault(x => x.DistrictEquipmentTypeId == originalDistrictEquipmentTypeId);
if (request != null || rotationList != null)
{
det.Deleted = true;
}
else
{
dbContext.HetDistrictEquipmentType.Remove(det);
}
// save changes to district equipment types and associated equipment records
dbContext.SaveChangesForImport();
// update status bar
increment++;
progress.SetValue(Convert.ToInt32((decimal)(mergeRecords.Count - (mergeRecords.Count - increment)) / mergeRecords.Count * 100));
}
// done!
progress.SetValue(100);
// **************************************************
// Phase 4: Update seniority and block assignments
// **************************************************
context.WriteLine("Phase 4: Update seniority and block assignments");
progress = context.WriteProgressBar();
progress.SetValue(0);
increment = 0;
foreach (MergeRecord detRecord in masterRecords)
{
// update the seniority and block assignments for the master record
List <HetLocalArea> localAreas = dbContext.HetEquipment.AsNoTracking()
.Include(x => x.LocalArea)
.Where(x => x.EquipmentStatusTypeId == equipmentStatusId &&
x.DistrictEquipmentTypeId == detRecord.DistrictEquipmentTypeId)
.Select(x => x.LocalArea)
.Distinct()
.ToList();
foreach (HetLocalArea localArea in localAreas)
{
EquipmentHelper.RecalculateSeniority(localArea.LocalAreaId,
detRecord.DistrictEquipmentTypeId, dbContext, seniorityScoringRules);
}
// save changes to equipment records
dbContext.SaveChangesForImport();
// update status bar
increment++;
progress.SetValue(Convert.ToInt32((decimal)(masterRecords.Count - (masterRecords.Count - increment)) / masterRecords.Count * 100));
}
// done!
progress.SetValue(100);
// **************************************************
// Phase 5: Cleanup "empty" District Equipment Types
// **************************************************
context.WriteLine("Phase 5: Cleanup empty District Equipment Types");
progress = context.WriteProgressBar();
progress.SetValue(0);
// get records
List <HetDistrictEquipmentType> districtEquipmentTypes = dbContext.HetDistrictEquipmentType.AsNoTracking()
.Include(x => x.HetEquipment)
.Where(x => x.Deleted == false)
.Distinct()
.ToList();
increment = 0;
foreach (HetDistrictEquipmentType districtEquipmentType in districtEquipmentTypes)
{
int districtEquipmentTypeId = districtEquipmentType.DistrictEquipmentTypeId;
// does this det have any equipment records?
if (districtEquipmentType.HetEquipment.Count < 1)
{
// get det record
HetDistrictEquipmentType det = dbContext.HetDistrictEquipmentType
.First(x => x.DistrictEquipmentTypeId == districtEquipmentTypeId);
// delete old det record
HetRentalRequest request = dbContext.HetRentalRequest.AsNoTracking()
.FirstOrDefault(x => x.DistrictEquipmentTypeId == districtEquipmentTypeId);
HetLocalAreaRotationList rotationList = dbContext.HetLocalAreaRotationList.AsNoTracking()
.FirstOrDefault(x => x.DistrictEquipmentTypeId == districtEquipmentTypeId);
if (request != null || rotationList != null)
{
det.Deleted = true;
}
else
{
dbContext.HetDistrictEquipmentType.Remove(det);
}
// save changes to district equipment types and associated equipment records
dbContext.SaveChangesForImport();
}
// update status bar
increment++;
progress.SetValue(Convert.ToInt32((decimal)(districtEquipmentTypes.Count - (districtEquipmentTypes.Count - increment)) / districtEquipmentTypes.Count * 100));
}
// done!
progress.SetValue(100);
}
/// <summary>
/// Update the Local Area Rotation List
/// </summary>
/// <param name="request"></param>
/// <param name="numberOfBlocks"></param>
/// <param name="context"></param>
public static void UpdateRotationList(HetRentalRequest request, int numberOfBlocks, DbAppContext context)
{
// first get the localAreaRotationList.askNextBlock"N" for the given local area
bool exists = context.HetLocalAreaRotationList.Any(a => a.LocalArea.LocalAreaId == request.LocalArea.LocalAreaId);
HetLocalAreaRotationList localAreaRotationList;
if (exists)
{
localAreaRotationList = context.HetLocalAreaRotationList
.Include(x => x.LocalArea)
.Include(x => x.AskNextBlock1)
.Include(x => x.AskNextBlock2)
.Include(x => x.AskNextBlockOpen)
.FirstOrDefault(x => x.LocalArea.LocalAreaId == request.LocalArea.LocalAreaId &&
x.DistrictEquipmentTypeId == request.DistrictEquipmentTypeId);
}
else
{
localAreaRotationList = new HetLocalAreaRotationList
{
LocalAreaId = request.LocalAreaId,
DistrictEquipmentTypeId = request.DistrictEquipmentTypeId
};
}
// determine what the next id is
int?nextId = null;
if (localAreaRotationList != null && localAreaRotationList.LocalAreaRotationListId > 0)
{
if (localAreaRotationList.AskNextBlock1Id != null)
{
nextId = localAreaRotationList.AskNextBlock1Id;
}
else if (localAreaRotationList.AskNextBlock2Id != null)
{
nextId = localAreaRotationList.AskNextBlock2Id;
}
else
{
nextId = localAreaRotationList.AskNextBlockOpenId;
}
}
// populate:
// 1. the "next on the list" table for the Local Area (HET_LOCAL_AREA_ROTATION_LIST)
// 2. the first on the list id for the Rental Request (HET_RENTAL_REQUEST.FIRST_ON_ROTATION_LIST_ID)
if (request.HetRentalRequestRotationList.Count > 0)
{
request.HetRentalRequestRotationList = request.HetRentalRequestRotationList
.OrderBy(x => x.RotationListSortOrder).ToList();
request.FirstOnRotationListId = request.HetRentalRequestRotationList.ElementAt(0).Equipment.EquipmentId;
// find our next record
int nextRecordToAskIndex = 0;
bool foundCurrentRecord = false;
if (nextId != null)
{
for (int i = 0; i < request.HetRentalRequestRotationList.Count; i++)
{
bool forcedHire;
bool asked;
if (foundCurrentRecord &&
request.HetRentalRequestRotationList.ElementAt(i).IsForceHire != null &&
request.HetRentalRequestRotationList.ElementAt(i).IsForceHire == false)
{
forcedHire = false;
}
else if (foundCurrentRecord && request.HetRentalRequestRotationList.ElementAt(i).IsForceHire == null)
{
forcedHire = false;
}
else
{
forcedHire = true;
}
if (foundCurrentRecord &&
request.HetRentalRequestRotationList.ElementAt(i).OfferResponse != null &&
!request.HetRentalRequestRotationList.ElementAt(i).OfferResponse.Equals("Yes", StringComparison.InvariantCultureIgnoreCase) &&
!request.HetRentalRequestRotationList.ElementAt(i).OfferResponse.Equals("No", StringComparison.InvariantCultureIgnoreCase))
{
asked = false;
}
else if (foundCurrentRecord && request.HetRentalRequestRotationList.ElementAt(i).OfferResponse == null)
{
asked = false;
}
else
{
asked = true;
}
if (foundCurrentRecord && !forcedHire && !asked)
{
// we've found our next record - exit and update the lists
nextRecordToAskIndex = i;
break;
}
if (!foundCurrentRecord &&
request.HetRentalRequestRotationList.ElementAt(i).EquipmentId == nextId)
{
foundCurrentRecord = true;
}
}
}
if (request.HetRentalRequestRotationList.ElementAt(nextRecordToAskIndex).Equipment.BlockNumber == 1 &&
request.HetRentalRequestRotationList.ElementAt(nextRecordToAskIndex).Equipment.BlockNumber <= numberOfBlocks &&
localAreaRotationList != null)
{
localAreaRotationList.AskNextBlock1Id = request.HetRentalRequestRotationList.ElementAt(nextRecordToAskIndex).Equipment.EquipmentId;
localAreaRotationList.AskNextBlock1Seniority = request.HetRentalRequestRotationList.ElementAt(nextRecordToAskIndex).Equipment.Seniority;
localAreaRotationList.AskNextBlock2Id = null;
localAreaRotationList.AskNextBlock2Seniority = null;
localAreaRotationList.AskNextBlockOpen = null;
localAreaRotationList.AskNextBlockOpenId = null;
}
else if (request.HetRentalRequestRotationList.ElementAt(nextRecordToAskIndex).Equipment.BlockNumber == 2 &&
request.HetRentalRequestRotationList.ElementAt(nextRecordToAskIndex).Equipment.BlockNumber <= numberOfBlocks &&
localAreaRotationList != null)
{
localAreaRotationList.AskNextBlock2Id = request.HetRentalRequestRotationList.ElementAt(nextRecordToAskIndex).Equipment.EquipmentId;
localAreaRotationList.AskNextBlock2Seniority = request.HetRentalRequestRotationList.ElementAt(nextRecordToAskIndex).Equipment.Seniority;
localAreaRotationList.AskNextBlock1Id = null;
localAreaRotationList.AskNextBlock1Seniority = null;
localAreaRotationList.AskNextBlockOpen = null;
localAreaRotationList.AskNextBlockOpenId = null;
}
else if (localAreaRotationList != null)
{
localAreaRotationList.AskNextBlockOpenId = request.HetRentalRequestRotationList.ElementAt(nextRecordToAskIndex).Equipment.EquipmentId;
localAreaRotationList.AskNextBlock1Id = null;
localAreaRotationList.AskNextBlock1Seniority = null;
localAreaRotationList.AskNextBlock2Id = null;
localAreaRotationList.AskNextBlock2Seniority = null;
}
// save the list - Done!
if (!exists)
{
context.HetLocalAreaRotationList.Add(localAreaRotationList);
}
}
}
/// <summary>
/// New Rotation List
/// * Find Record Number 1
/// * Then update the Local Area Rotation List
///
/// Business rules
/// * is this the first request of the new fiscal year -> Yes: start from #1
/// * get the "next equipment to be asked" from "LOCAL_AREA_ROTATION_LIST"
/// -> if this is Block 1 -> temporarily becomes #1 on the list
/// -> if not block 1 -> #1 i block 1 temporarily becomes #1 on the list
/// * check all records before temporary #1
/// -> if a record was Force Hired -> make them #1
/// </summary>
/// <param name="rentalRequest"></param>
/// <param name="numberOfBlocks"></param>
/// <param name="context"></param>
public static HetRentalRequest SetupNewRotationList(HetRentalRequest rentalRequest, int numberOfBlocks, DbAppContext context)
{
// nothing to do!
if (rentalRequest.HetRentalRequestRotationList.Count <= 0)
{
return(rentalRequest);
}
// sort our new rotation list
rentalRequest.HetRentalRequestRotationList = rentalRequest.HetRentalRequestRotationList
.OrderBy(x => x.RotationListSortOrder)
.ToList();
// check if we have a localAreaRotationList.askNextBlock"N" for the given local area
bool localAreaRotationListExists = context.HetLocalAreaRotationList
.Any(a => a.LocalArea.LocalAreaId == rentalRequest.LocalAreaId);
HetLocalAreaRotationList newAreaRotationList;
if (localAreaRotationListExists)
{
newAreaRotationList = context.HetLocalAreaRotationList
.First(a => a.LocalArea.LocalAreaId == rentalRequest.LocalAreaId);
}
else
{
// setup our new "local area rotation list"
newAreaRotationList = new HetLocalAreaRotationList
{
LocalAreaId = rentalRequest.LocalAreaId,
DistrictEquipmentTypeId = rentalRequest.DistrictEquipmentTypeId
};
}
// determine current fiscal year - check for existing rotation lists this year
DateTime fiscalStart;
if (DateTime.UtcNow.Month == 1 || DateTime.UtcNow.Month == 2 || DateTime.UtcNow.Month == 3)
{
fiscalStart = new DateTime(DateTime.UtcNow.AddYears(-1).Year, 4, 1);
}
else
{
fiscalStart = new DateTime(DateTime.UtcNow.Year, 4, 1);
}
// get the last rotation list created this fiscal year
bool previousRequestExists = context.HetRentalRequest
.Any(x => x.DistrictEquipmentType.DistrictEquipmentTypeId == rentalRequest.DistrictEquipmentTypeId &&
x.LocalArea.LocalAreaId == rentalRequest.LocalAreaId &&
x.AppCreateTimestamp >= fiscalStart);
// *****************************************************************
// if we don't have a request
// ** remove hired equipment
// ** pick block 1 / record 1 & we're done
// *****************************************************************
if (!previousRequestExists)
{
// remove hired equipment from the list
rentalRequest = DropHiredEquipment(rentalRequest, context);
rentalRequest.FirstOnRotationListId = rentalRequest.HetRentalRequestRotationList.ElementAt(0).EquipmentId;
int block = numberOfBlocks;
if (rentalRequest.HetRentalRequestRotationList.ElementAt(0).BlockNumber != null)
{
int?equipmentBlockNumber = rentalRequest.HetRentalRequestRotationList.ElementAt(0).BlockNumber;
if (equipmentBlockNumber != null)
{
block = (int)equipmentBlockNumber;
}
}
// update local area rotation list
newAreaRotationList = UpdateNextRecordToAsk(block,
rentalRequest.HetRentalRequestRotationList.ElementAt(0).EquipmentId,
rentalRequest.HetRentalRequestRotationList.ElementAt(0).SeniorityFloat,
newAreaRotationList);
// save rotation list
if (localAreaRotationListExists)
{
context.HetLocalAreaRotationList.Update(newAreaRotationList);
}
else
{
context.HetLocalAreaRotationList.Add(newAreaRotationList);
}
return(rentalRequest); //done!
}
// *****************************************************************
// use the previous rotation list to determine where we were
// ** we pick the record after the last "asked" (Yes/No)
// ** if all records in that block were "asked" - then we need to
// move on to the next block
// ** also need to check if the equipment is currently hired
// *****************************************************************
int[] nextRecordToAskIndex = new int[numberOfBlocks];
int[] nextRecordToAskId = new int[numberOfBlocks];
int[] nextRecordToAskBlock = new int[numberOfBlocks];
float[] nextRecordToAskSeniority = new float[numberOfBlocks];
int startBlock = -1;
for (int b = 0; b < numberOfBlocks; b++)
{
nextRecordToAskIndex[b] = -1;
nextRecordToAskId[b] = -1;
nextRecordToAskBlock[b] = -1;
// get the last asked equipment id for this "block"
HetEquipment lastEquipment = LastAskedByBlock(b, rentalRequest.DistrictEquipmentTypeId, rentalRequest.LocalAreaId,
fiscalStart, context);
// nothing found for this block - start at 0
if (lastEquipment == null && rentalRequest.HetRentalRequestRotationList.Count > 0)
{
for (int j = 0; j < rentalRequest.HetRentalRequestRotationList.Count; j++)
{
if (rentalRequest.HetRentalRequestRotationList.ElementAt(j).BlockNumber != (b + 1))
{
continue; // move to next record
}
if (!IsEquipmentHired(rentalRequest.HetRentalRequestRotationList.ElementAt(j).EquipmentId, context))
{
int temp = rentalRequest.HetRentalRequestRotationList.ElementAt(j).EquipmentId ?? -1;
if (temp > -1)
{
nextRecordToAskId[b] = temp;
nextRecordToAskBlock[b] = b;
break;
}
}
}
}
// find the next record - and ensure it's not currently hired
bool foundLast = false;
for (int j = 0; j < rentalRequest.HetRentalRequestRotationList.Count; j++)
{
// make sure we're working in the right block
if (rentalRequest.HetRentalRequestRotationList.ElementAt(j).Equipment.BlockNumber != (b + 1))
{
continue; // move to next record
}
if (foundLast)
{
if (!IsEquipmentHired(rentalRequest.HetRentalRequestRotationList.ElementAt(j).EquipmentId, context))
{
int temp = rentalRequest.HetRentalRequestRotationList.ElementAt(j).EquipmentId ?? -1;
if (temp > -1)
{
nextRecordToAskId[b] = temp;
nextRecordToAskBlock[b] = b;
break;
}
}
}
foundLast = rentalRequest.HetRentalRequestRotationList.ElementAt(j).EquipmentId == lastEquipment?.EquipmentId;
}
}
// *****************************************************************
// 2. Remove all hired equipment from the new list
// *****************************************************************
rentalRequest = DropHiredEquipment(rentalRequest, context);
// locate our "start" records in the updated list
for (int b = 0; b < numberOfBlocks; b++)
{
if (nextRecordToAskId[b] > 0)
{
for (int j = 0; j < rentalRequest.HetRentalRequestRotationList.Count; j++)
{
// make sure we're working in the right block
if (rentalRequest.HetRentalRequestRotationList.ElementAt(j).Equipment.BlockNumber != (b + 1))
{
continue; // move to next record
}
if (rentalRequest.HetRentalRequestRotationList.ElementAt(j).EquipmentId == nextRecordToAskId[b])
{
nextRecordToAskIndex[b] = j;
if (startBlock == -1)
{
startBlock = b;
}
break;
}
}
}
}
// check we have equipment still after removing everything
if (rentalRequest.HetRentalRequestRotationList.Count <= 0)
{
throw new ArgumentException("HETS-35"); // no more records available
}
// *****************************************************************
// 3. Default the index to the first record if nothing is selected
// *****************************************************************
for (int b = 0; b < numberOfBlocks; b++)
{
if (nextRecordToAskIndex[b] < 0)
{
if (rentalRequest.HetRentalRequestRotationList.ElementAt(0) != null)
{
nextRecordToAskIndex[b] = 0;
nextRecordToAskId[b] = rentalRequest.HetRentalRequestRotationList.ElementAt(0).Equipment.EquipmentId;
if (rentalRequest.HetRentalRequestRotationList.ElementAt(0).Equipment.Seniority == null)
{
nextRecordToAskSeniority[b] = 0.0F;
}
else
{
float?equipmentSeniority = rentalRequest.HetRentalRequestRotationList.ElementAt(0).Equipment.Seniority;
if (equipmentSeniority != null)
{
nextRecordToAskSeniority[b] = (float)equipmentSeniority;
}
}
if (startBlock == -1)
{
startBlock = b;
}
break; // done
}
}
}
// *****************************************************************
// 4. Update the local area rotation list
// *****************************************************************
rentalRequest.FirstOnRotationListId = nextRecordToAskId[startBlock];
// update local area rotation list
newAreaRotationList = UpdateNextRecordToAsk(nextRecordToAskBlock[startBlock],
nextRecordToAskId[startBlock],
nextRecordToAskSeniority[startBlock],
newAreaRotationList);
// *****************************************************************
// 5. Reset the rotation list sort order
// ** starting @ nextRecordToAskIndex
// *****************************************************************
int masterSortOrder = 0;
// process the start block first
for (int i = nextRecordToAskIndex[startBlock]; i < rentalRequest.HetRentalRequestRotationList.Count; i++)
{
if (rentalRequest.HetRentalRequestRotationList.ElementAt(i).BlockNumber != startBlock)
{
break; // done with the start block / start index to end of block
}
masterSortOrder++;
rentalRequest.HetRentalRequestRotationList.ElementAt(i).RotationListSortOrder = masterSortOrder;
}
// finish the "first set" of records in the start block (before the index)
for (int i = 0; i < nextRecordToAskIndex[startBlock]; i++)
{
if (rentalRequest.HetRentalRequestRotationList.ElementAt(i).BlockNumber != startBlock)
{
continue; // move to the next record
}
masterSortOrder++;
rentalRequest.HetRentalRequestRotationList.ElementAt(i).RotationListSortOrder = masterSortOrder;
}
// process other blocks
for (int b = 0; b < numberOfBlocks; b++)
{
if (b + 1 == startBlock)
{
continue; // already processed
}
for (int i = nextRecordToAskIndex[b]; i < rentalRequest.HetRentalRequestRotationList.Count; i++)
{
if (i < 0 || rentalRequest.HetRentalRequestRotationList.ElementAt(i).BlockNumber != b + 1)
{
continue; // move to the next record
}
masterSortOrder++;
rentalRequest.HetRentalRequestRotationList.ElementAt(i).RotationListSortOrder = masterSortOrder;
}
// finish the "first set" of records in the block (before the index)
for (int i = 0; i < nextRecordToAskIndex[b]; i++)
{
if (rentalRequest.HetRentalRequestRotationList.ElementAt(i).BlockNumber != b + 1)
{
continue; // move to the next record
}
masterSortOrder++;
rentalRequest.HetRentalRequestRotationList.ElementAt(i).RotationListSortOrder = masterSortOrder;
}
}
// add the new list
if (!localAreaRotationListExists)
{
context.HetLocalAreaRotationList.Add(newAreaRotationList);
}
return(rentalRequest);
}
/// <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 RentalRequestsViewOnlyPost([FromBody] HetRentalRequest item)
{
return(CreateRentalRequest(item, true));
}
private IActionResult CreateRentalRequest(HetRentalRequest item, bool noProject = false)
{
// not found
if (item == null)
{
return(new BadRequestObjectResult(new HetsResponse("HETS-04", ErrorViewModel.GetDescription("HETS-04", _configuration))));
}
// check if we have an existing rental request for the same
// local area and equipment type - if so - throw an error
// Per discussion with the business (19 Jan 2018):
// * Don't create a record as New if another Request exists
// * Simply give the user an error and not allow the new request
//
// Note: leaving the "New" code in place in case this changes in the future
int?statusIdInProgress = StatusHelper.GetStatusId(HetRentalRequest.StatusInProgress, "rentalRequestStatus", _context);
if (statusIdInProgress == null)
{
return(new NotFoundObjectResult(new HetsResponse("HETS-23", ErrorViewModel.GetDescription("HETS-23", _configuration))));
}
List <HetRentalRequest> requests = _context.HetRentalRequest
.Where(x => x.DistrictEquipmentTypeId == item.DistrictEquipmentType.DistrictEquipmentTypeId &&
x.LocalAreaId == item.LocalArea.LocalAreaId &&
x.RentalRequestStatusTypeId == statusIdInProgress)
.ToList();
// in Progress Rental Request already exists
if (requests.Count > 0)
{
int quantity = requests[0].EquipmentCount;
int hiredCount = 0;
foreach (HetRentalRequestRotationList equipment in requests[0].HetRentalRequestRotationList)
{
if (equipment.OfferResponse != null &&
equipment.OfferResponse.Equals("Yes", StringComparison.InvariantCultureIgnoreCase))
{
hiredCount++;
}
if (equipment.IsForceHire != null &&
equipment.IsForceHire == true)
{
hiredCount++;
}
}
// ...Currently {0} of {1} requested equipment have been hired....
string message = string.Format(ErrorViewModel.GetDescription("HETS-28", _configuration), hiredCount, quantity);
return(new BadRequestObjectResult(new HetsResponse("HETS-28", message)));
}
// create new rental request
HetRentalRequest rentalRequest = new HetRentalRequest
{
LocalAreaId = item.LocalArea.LocalAreaId,
DistrictEquipmentTypeId = item.DistrictEquipmentType.DistrictEquipmentTypeId,
RentalRequestStatusTypeId = (int)statusIdInProgress,
EquipmentCount = item.EquipmentCount,
ExpectedEndDate = item.ExpectedEndDate,
ExpectedStartDate = item.ExpectedStartDate,
ExpectedHours = item.ExpectedHours
};
// is this a "project-less" request? - can't be hired from
if (!noProject)
{
rentalRequest.ProjectId = item.Project.ProjectId;
}
// build new list
try
{
rentalRequest = RentalRequestHelper.CreateRotationList(rentalRequest, _context, _configuration);
}
catch (Exception e)
{
// check if this a "no available equipment exception"
if (e.Message == "HETS-42")
{
return(new NotFoundObjectResult(new HetsResponse("HETS-42", ErrorViewModel.GetDescription("HETS-42", _configuration))));
}
Console.WriteLine(e);
throw;
}
// check if we have an existing "In Progress" request
// for the same Local Area and Equipment Type
string tempStatus = RentalRequestHelper.RentalRequestStatus(rentalRequest, _context);
statusIdInProgress = StatusHelper.GetStatusId(tempStatus, "rentalRequestStatus", _context);
if (statusIdInProgress == null)
{
return(new NotFoundObjectResult(new HetsResponse("HETS-23", ErrorViewModel.GetDescription("HETS-23", _configuration))));
}
rentalRequest.RentalRequestStatusTypeId = (int)statusIdInProgress;
if (item.HetRentalRequestAttachment != null &&
item.HetRentalRequestAttachment.Count > 0)
{
HetRentalRequestAttachment attachment = new HetRentalRequestAttachment
{
Attachment = item.HetRentalRequestAttachment.ElementAt(0).Attachment
};
rentalRequest.HetRentalRequestAttachment.Add(attachment);
}
// save the changes
_context.HetRentalRequest.Add(rentalRequest);
_context.SaveChanges();
int id = rentalRequest.RentalRequestId;
// retrieve updated rental request to return to ui
return(new ObjectResult(new HetsResponse(RentalRequestHelper.GetRecord(id, _context))));
}
public virtual IActionResult RentalRequestsIdCancelGet([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 record
HetRentalRequest rentalRequest = _context.HetRentalRequest.AsNoTracking()
.Include(x => x.HetRentalRequestRotationList)
.ThenInclude(y => y.RentalAgreement)
.Include(x => x.HetRentalRequestRotationList)
.ThenInclude(y => y.Equipment)
.Include(x => x.HetRentalRequestAttachment)
.Include(x => x.HetHistory)
.Include(x => x.RentalRequestStatusType)
.Include(x => x.HetNote)
.First(a => a.RentalRequestId == id);
if (rentalRequest.HetRentalRequestRotationList != null &&
rentalRequest.HetRentalRequestRotationList.Count > 0)
{
bool agreementExists = false;
foreach (HetRentalRequestRotationList listItem in rentalRequest.HetRentalRequestRotationList)
{
if (listItem.RentalAgreement != null && listItem.RentalAgreement.RentalAgreementId != 0)
{
agreementExists = true;
break; // agreement found
}
}
// cannot cancel - rental agreements exist
if (agreementExists)
{
return(new BadRequestObjectResult(new HetsResponse("HETS-09", ErrorViewModel.GetDescription("HETS-09", _configuration))));
}
}
if (rentalRequest.RentalRequestStatusType.RentalRequestStatusTypeCode
.Equals(HetRentalRequest.StatusComplete, StringComparison.InvariantCulture))
{
// cannot cancel - rental request is complete
return(new BadRequestObjectResult(new HetsResponse("HETS-10", ErrorViewModel.GetDescription("HETS-10", _configuration))));
}
// remove (delete) rental request rotation list
if (rentalRequest.HetRentalRequestRotationList != null)
{
foreach (HetRentalRequestRotationList rotationList in rentalRequest.HetRentalRequestRotationList)
{
_context.HetRentalRequestRotationList.Remove(rotationList);
}
}
// remove (delete) rental request attachments
if (rentalRequest.HetRentalRequestAttachment != null)
{
foreach (HetRentalRequestAttachment attachment in rentalRequest.HetRentalRequestAttachment)
{
_context.HetRentalRequestAttachment.Remove(attachment);
}
}
// remove (delete) rental request attachments
if (rentalRequest.HetDigitalFile != null)
{
foreach (HetDigitalFile attachment in rentalRequest.HetDigitalFile)
{
_context.HetDigitalFile.Remove(attachment);
}
}
// remove (delete) rental request notes
if (rentalRequest.HetNote != null)
{
foreach (HetNote note in rentalRequest.HetNote)
{
_context.HetNote.Remove(note);
}
}
// remove (delete) rental request history
if (rentalRequest.HetHistory != null)
{
foreach (HetHistory history in rentalRequest.HetHistory)
{
_context.HetHistory.Remove(history);
}
}
// remove (delete) request
_context.HetRentalRequest.Remove(rentalRequest);
// save the changes
_context.SaveChanges();
return(new ObjectResult(new HetsResponse(rentalRequest)));
}
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))));
}
public virtual IActionResult RentalRequestsIdPut([FromRoute] int id, [FromBody] HetRentalRequest item)
{
if (item == null || id != item.RentalRequestId)
{
// not found
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))));
}
// get record
HetRentalRequest rentalRequest = _context.HetRentalRequest
.Include(x => x.LocalArea.ServiceArea.District.Region)
.Include(x => x.Project)
.ThenInclude(c => c.PrimaryContact)
.Include(x => x.HetRentalRequestAttachment)
.Include(x => x.DistrictEquipmentType)
.Include(x => x.HetRentalRequestRotationList)
.ThenInclude(y => y.Equipment)
.First(a => a.RentalRequestId == id);
// need to check if we are going over the "count" and close this request
int hiredCount = 0;
foreach (HetRentalRequestRotationList equipment in rentalRequest.HetRentalRequestRotationList)
{
if (equipment.OfferResponse != null &&
equipment.OfferResponse.Equals("Yes", StringComparison.InvariantCultureIgnoreCase))
{
hiredCount++;
}
if (equipment.IsForceHire != null &&
equipment.IsForceHire == true)
{
hiredCount++;
}
}
// has the count changed - and is now less than the already "hired" equipment
if (item.EquipmentCount != rentalRequest.EquipmentCount &&
hiredCount > item.EquipmentCount)
{
//"HETS-07": "Rental Request count cannot be less than equipment already hired"
return(new BadRequestObjectResult(new HetsResponse("HETS-07", ErrorViewModel.GetDescription("HETS-07", _configuration))));
}
// if the number of hired records is now "over the count" - then close
if (hiredCount >= item.EquipmentCount)
{
int?statusIdComplete = StatusHelper.GetStatusId(HetRentalRequest.StatusComplete, "rentalRequestStatus", _context);
if (statusIdComplete == null)
{
return(new BadRequestObjectResult(new HetsResponse("HETS-23", ErrorViewModel.GetDescription("HETS-23", _configuration))));
}
item.RentalRequestStatusTypeId = (int)statusIdComplete;
item.Status = "Complete";
item.FirstOnRotationList = null;
}
int?statusId = StatusHelper.GetStatusId(item.Status, "rentalRequestStatus", _context);
if (statusId == null)
{
return(new BadRequestObjectResult(new HetsResponse("HETS-23", ErrorViewModel.GetDescription("HETS-23", _configuration))));
}
// update rental request
rentalRequest.ConcurrencyControlNumber = item.ConcurrencyControlNumber;
rentalRequest.RentalRequestStatusTypeId = (int)statusId;
rentalRequest.EquipmentCount = item.EquipmentCount;
rentalRequest.ExpectedEndDate = item.ExpectedEndDate;
rentalRequest.ExpectedStartDate = item.ExpectedStartDate;
rentalRequest.ExpectedHours = item.ExpectedHours;
rentalRequest.HetDigitalFile = item.HetDigitalFile;
rentalRequest.FirstOnRotationList = item.FirstOnRotationList;
// do we have any attachments (only a single string is ever stored)
if (item.HetRentalRequestAttachment != null &&
item.HetRentalRequestAttachment.Count > 0)
{
if (rentalRequest.HetRentalRequestAttachment == null)
{
rentalRequest.HetRentalRequestAttachment = new List <HetRentalRequestAttachment>();
}
HetRentalRequestAttachment attachment = new HetRentalRequestAttachment
{
Attachment = item.HetRentalRequestAttachment.ElementAt(0).Attachment
};
if (rentalRequest.HetRentalRequestAttachment.Count > 0)
{
rentalRequest.HetRentalRequestAttachment.ElementAt(0).Attachment = attachment.Attachment;
}
else
{
rentalRequest.HetRentalRequestAttachment.Add(attachment);
}
}
// save the changes
_context.SaveChanges();
// retrieve updated rental request to return to ui
return(new ObjectResult(new HetsResponse(RentalRequestHelper.GetRecord(id, _context))));
}
/// <summary>
/// Get rental request record
/// </summary>
/// <param name="id"></param>
/// <param name="scoringRules"></param>
/// <param name="context"></param>
public static HetRentalRequest GetRecordWithRotationList(int id, SeniorityScoringRules scoringRules, DbAppContext context)
{
HetRentalRequest request = context.HetRentalRequest.AsNoTracking()
.Include(x => x.DistrictEquipmentType)
.ThenInclude(y => y.EquipmentType)
.Include(x => x.FirstOnRotationList)
.Include(x => x.HetRentalRequestAttachment)
.Include(x => x.HetRentalRequestRotationList)
.ThenInclude(y => y.Equipment)
.ThenInclude(r => r.HetEquipmentAttachment)
.Include(x => x.HetRentalRequestRotationList)
.ThenInclude(y => y.Equipment)
.ThenInclude(r => r.LocalArea)
.Include(x => x.HetRentalRequestRotationList)
.ThenInclude(y => y.Equipment)
.ThenInclude(r => r.DistrictEquipmentType)
.Include(x => x.HetRentalRequestRotationList)
.ThenInclude(y => y.Equipment)
.ThenInclude(e => e.Owner)
.ThenInclude(c => c.PrimaryContact)
.FirstOrDefault(a => a.RentalRequestId == id);
if (request != null)
{
// re-sort list using: LocalArea / District Equipment Type and SenioritySortOrder (desc)
request.HetRentalRequestRotationList = request.HetRentalRequestRotationList
.OrderBy(e => e.RotationListSortOrder)
.ToList();
// calculate the Yes Count based on the RentalRequestList
request.YesCount = CalculateYesCount(request);
// calculate YTD hours for the equipment records
if (request.HetRentalRequestRotationList != null)
{
foreach (HetRentalRequestRotationList rotationList in request.HetRentalRequestRotationList)
{
if (rotationList.Equipment != null)
{
int numberOfBlocks = 0;
// get number of blocks for this equipment type
if (rotationList.Equipment.DistrictEquipmentType != null)
{
numberOfBlocks = rotationList.Equipment.DistrictEquipmentType.EquipmentType.IsDumpTruck
? scoringRules.GetTotalBlocks("DumpTruck") + 1
: scoringRules.GetTotalBlocks() + 1;
}
// get equipment seniority
float seniority = 0F;
if (rotationList.Equipment.Seniority != null)
{
seniority = (float)rotationList.Equipment.Seniority;
}
// get equipment block number
int blockNumber = 0;
if (rotationList.Equipment.BlockNumber != null)
{
blockNumber = (int)rotationList.Equipment.BlockNumber;
//HETS-968 - Rotation list -Wrong Block number for Open block
if (blockNumber == numberOfBlocks)
{
blockNumber = 3;
rotationList.Equipment.BlockNumber = blockNumber;
}
}
rotationList.Equipment.HoursYtd = EquipmentHelper.GetYtdServiceHours(rotationList.Equipment.EquipmentId, context);
rotationList.Equipment.SeniorityString = EquipmentHelper.FormatSeniorityString(seniority, blockNumber, numberOfBlocks);
}
}
}
}
return(request);
}
