/// <summary>
/// Map data
/// </summary>
/// <param name="dbContext"></param>
/// <param name="oldObject"></param>
/// <param name="equipment"></param>
/// <param name="systemId"></param>
/// <param name="maxEquipmentIndex"></param>
private static void CopyToInstance(DbAppContext dbContext, Equip oldObject, ref Equipment equipment, string systemId, ref int maxEquipmentIndex)
{
try
{
if (oldObject.Equip_Id <= 0)
{
return;
}
equipment = new Equipment {
Id = ++maxEquipmentIndex
};
// there is a problem with 1 equipment record
// Per BC Bid - the correct Owner Id should be: 8786195
if (oldObject.Equip_Id == 19165)
{
oldObject.Owner_Popt_Id = 8786195;
}
// ***********************************************
// set the equipment status
// ***********************************************
string tempArchive = oldObject.Archive_Cd;
string tempStatus = oldObject.Status_Cd.Trim();
if (tempArchive == "Y")
{
// archived!
equipment.ArchiveCode = "Y";
equipment.ArchiveDate = DateTime.UtcNow;
equipment.ArchiveReason = "Imported from BC Bid";
equipment.Status = "Archived";
string tempArchiveReason = ImportUtility.CleanString(oldObject.Archive_Reason);
if (!string.IsNullOrEmpty(tempArchiveReason))
{
equipment.ArchiveReason = ImportUtility.GetUppercaseFirst(tempArchiveReason);
}
}
else
{
equipment.ArchiveCode = "N";
equipment.ArchiveDate = null;
equipment.ArchiveReason = null;
equipment.Status = tempStatus == "A" ? "Approved" : "Unapproved";
equipment.StatusComment = string.Format("Imported from BC Bid ({0})", tempStatus);
}
// ***********************************************
// set equipment attributes
// ***********************************************
string tempLicense = ImportUtility.CleanString(oldObject.Licence).ToUpper();
if (!string.IsNullOrEmpty(tempLicense))
{
equipment.LicencePlate = tempLicense;
}
equipment.ApprovedDate = ImportUtility.CleanDateTime(oldObject.Approved_Dt);
DateTime?tempReceivedDate = ImportUtility.CleanDateTime(oldObject.Received_Dt);
if (tempReceivedDate != null)
{
equipment.ReceivedDate = (DateTime)tempReceivedDate;
}
else
{
if (equipment.ArchiveCode == "N" && equipment.Status == "Approved")
{
throw new DataException(string.Format("Received Date cannot be null (EquipmentIndex: {0}", maxEquipmentIndex));
}
}
// equipment code
string tempEquipmentCode = ImportUtility.CleanString(oldObject.Equip_Cd).ToUpper();
if (!string.IsNullOrEmpty(tempEquipmentCode))
{
equipment.EquipmentCode = tempEquipmentCode;
}
else
{
if (equipment.ArchiveCode == "N" && equipment.Status == "Approved")
{
throw new DataException(string.Format("Equipment Code cannot be null (EquipmentIndex: {0}", maxEquipmentIndex));
}
}
// pay rate
float?tempPayRate = ImportUtility.GetFloatValue(oldObject.Pay_Rate);
if (tempPayRate != null)
{
equipment.PayRate = tempPayRate;
}
// ***********************************************
// make, model, year, etc.
// ***********************************************
string tempMake = ImportUtility.CleanString(oldObject.Make);
if (!string.IsNullOrEmpty(tempMake))
{
tempMake = ImportUtility.GetCapitalCase(tempMake);
equipment.Make = tempMake;
}
// model
string tempModel = ImportUtility.CleanString(oldObject.Model).ToUpper();
if (!string.IsNullOrEmpty(tempModel))
{
equipment.Model = tempModel;
}
// year
string tempYear = ImportUtility.CleanString(oldObject.Year);
if (!string.IsNullOrEmpty(tempYear))
{
equipment.Year = tempYear;
}
// size
string tempSize = ImportUtility.CleanString(oldObject.Size);
if (!string.IsNullOrEmpty(tempSize))
{
tempSize = ImportUtility.GetCapitalCase(tempSize);
equipment.Size = tempSize;
}
// serial number
string tempSerialNumber = ImportUtility.CleanString(oldObject.Serial_Num).ToUpper();
if (!string.IsNullOrEmpty(tempSerialNumber))
{
equipment.SerialNumber = tempSerialNumber;
}
// operator
string tempOperator = ImportUtility.CleanString(oldObject.Operator);
if (!string.IsNullOrEmpty(tempOperator))
{
equipment.Operator = tempOperator ?? null;
}
// ***********************************************
// add comment into the notes field
// ***********************************************
string tempComment = ImportUtility.CleanString(oldObject.Comment);
if (!string.IsNullOrEmpty(tempComment))
{
tempComment = ImportUtility.GetUppercaseFirst(tempComment);
Note note = new Note
{
Text = tempComment,
IsNoLongerRelevant = false
};
if (equipment.Notes == null)
{
equipment.Notes = new List <Note>();
}
equipment.Notes.Add(note);
}
// ***********************************************
// add equipment to the correct area
// ***********************************************
if (oldObject.Area_Id != null)
{
LocalArea area = dbContext.LocalAreas.AsNoTracking()
.FirstOrDefault(x => x.LocalAreaNumber == oldObject.Area_Id);
if (area != null)
{
int tempAreaId = area.Id;
equipment.LocalAreaId = tempAreaId;
}
}
if (equipment.LocalAreaId == null && equipment.ArchiveCode == "N" && equipment.Status == "Approved")
{
throw new DataException(string.Format("Local Area cannot be null (EquipmentIndex: {0}", maxEquipmentIndex));
}
// ***********************************************
// set the equipment type
// ***********************************************
if (oldObject.Equip_Type_Id != null)
{
// get the new id for the "District" Equipment Type
string tempEquipmentTypeId = oldObject.Equip_Type_Id.ToString();
ImportMap equipMap = dbContext.ImportMaps.AsNoTracking()
.FirstOrDefault(x => x.OldTable == ImportDistrictEquipmentType.OldTable &&
x.OldKey == tempEquipmentTypeId &&
x.NewTable == ImportDistrictEquipmentType.NewTable);
if (equipMap != null)
{
DistrictEquipmentType distEquipType = dbContext.DistrictEquipmentTypes.FirstOrDefault(x => x.Id == equipMap.NewKey);
if (distEquipType != null)
{
int tempEquipmentId = distEquipType.Id;
equipment.DistrictEquipmentTypeId = tempEquipmentId;
}
// is this a dump truck?
if (!string.IsNullOrEmpty(oldObject.Reg_Dump_Trk) && oldObject.Reg_Dump_Trk == "Y")
{
// update the equipment type record -> IsDumpTruck = True
EquipmentType equipType = dbContext.EquipmentTypes.FirstOrDefault(x => x.Id == distEquipType.EquipmentTypeId);
if (equipType != null)
{
equipType.IsDumpTruck = true;
dbContext.EquipmentTypes.Update(equipType);
}
}
}
}
if (equipment.DistrictEquipmentTypeId == null && equipment.ArchiveCode == "N" && equipment.Status == "Approved")
{
throw new DataException(string.Format("Equipment Type cannot be null (EquipmentIndex: {0}", maxEquipmentIndex));
}
// ***********************************************
// set the equipment owner
// ***********************************************
ImportMap ownerMap = dbContext.ImportMaps.AsNoTracking()
.FirstOrDefault(x => x.OldTable == ImportOwner.OldTable &&
x.OldKey == oldObject.Owner_Popt_Id.ToString());
if (ownerMap != null)
{
Models.Owner owner = dbContext.Owners.FirstOrDefault(x => x.Id == ownerMap.NewKey);
if (owner != null)
{
int tempOwnerId = owner.Id;
equipment.OwnerId = tempOwnerId;
// set address fields on the owner record
if (string.IsNullOrEmpty(owner.Address1))
{
string tempAddress1 = ImportUtility.CleanString(oldObject.Addr1);
tempAddress1 = ImportUtility.GetCapitalCase(tempAddress1);
string tempAddress2 = ImportUtility.CleanString(oldObject.Addr2);
tempAddress2 = ImportUtility.GetCapitalCase(tempAddress2);
string tempCity = ImportUtility.CleanString(oldObject.City);
tempCity = ImportUtility.GetCapitalCase(tempCity);
owner.Address1 = tempAddress1;
owner.Address2 = tempAddress2;
owner.City = tempCity;
owner.PostalCode = ImportUtility.CleanString(oldObject.Postal).ToUpper();
owner.Province = "BC";
dbContext.Owners.Update(owner);
}
}
}
if (equipment.OwnerId == null && equipment.ArchiveCode != "Y")
{
throw new DataException(string.Format("Owner cannot be null (EquipmentIndex: {0}", maxEquipmentIndex));
}
// ***********************************************
// set seniority and hours
// ***********************************************
float?tempSeniority = ImportUtility.GetFloatValue(oldObject.Seniority);
equipment.Seniority = tempSeniority ?? 0.0F;
float?tempYearsOfService = ImportUtility.GetFloatValue(oldObject.Num_Years);
equipment.YearsOfService = tempYearsOfService ?? 0.0F;
int?tempBlockNumber = ImportUtility.GetIntValue(oldObject.Block_Num);
equipment.BlockNumber = tempBlockNumber ?? null;
float?tempServiceHoursLastYear = ImportUtility.GetFloatValue(oldObject.YTD1);
equipment.ServiceHoursLastYear = tempServiceHoursLastYear ?? 0.0F;
float?tempServiceHoursTwoYearsAgo = ImportUtility.GetFloatValue(oldObject.YTD2);
equipment.ServiceHoursTwoYearsAgo = tempServiceHoursTwoYearsAgo ?? 0.0F;
float?tempServiceHoursThreeYearsAgo = ImportUtility.GetFloatValue(oldObject.YTD3);
equipment.ServiceHoursThreeYearsAgo = tempServiceHoursThreeYearsAgo ?? 0.0F;
// ***********************************************
// set last verified date (default to March 31, 2018)
// ***********************************************
equipment.LastVerifiedDate = DateTime.Parse("2018-03-31 0:00:01");
// ***********************************************
// create equipment
// ***********************************************
equipment.AppCreateUserid = systemId;
equipment.AppCreateTimestamp = DateTime.UtcNow;
equipment.AppLastUpdateUserid = systemId;
equipment.AppLastUpdateTimestamp = DateTime.UtcNow;
dbContext.Equipments.Add(equipment);
}
catch (Exception ex)
{
Debug.WriteLine("***Error*** - Equipment Code: " + equipment.EquipmentCode);
Debug.WriteLine("***Error*** - Master Equipment Index: " + maxEquipmentIndex);
Debug.WriteLine(ex.Message);
throw;
}
}
/// <summary>
/// Map data
/// </summary>
/// <param name="performContext"></param>
/// <param name="dbContext"></param>
/// <param name="oldObject"></param>
/// <param name="instance"></param>
/// <param name="systemId"></param>
private static void CopyToInstance(PerformContext performContext, DbAppContext dbContext, Equip oldObject, ref Equipment instance, string systemId)
{
if (oldObject.Equip_Id <= 0)
{
return;
}
//Add the user specified in oldObject.Modified_By and oldObject.Created_By if not there in the database
User modifiedBy = ImportUtility.AddUserFromString(dbContext, oldObject.Modified_By, systemId);
User createdBy = ImportUtility.AddUserFromString(dbContext, oldObject.Created_By, systemId);
if (instance == null)
{
instance = new Equipment
{
Id = oldObject.Equip_Id,
ArchiveCode = oldObject.Archive_Cd == null
? ""
: new string(oldObject.Archive_Cd.Take(50).ToArray()),
ArchiveReason = oldObject.Archive_Reason == null
? ""
: new string(oldObject.Archive_Reason.Take(2048).ToArray()),
LicencePlate = oldObject.Licence == null ? "" : new string(oldObject.Licence.Take(20).ToArray())
};
if (oldObject.Approved_Dt != null)
{
instance.ApprovedDate = DateTime.ParseExact(oldObject.Approved_Dt.Trim().Substring(0, 10), "yyyy-MM-dd", System.Globalization.CultureInfo.InvariantCulture);
}
if (oldObject.Received_Dt != null)
{
instance.ReceivedDate = DateTime.ParseExact(oldObject.Received_Dt.Trim().Substring(0, 10), "yyyy-MM-dd", System.Globalization.CultureInfo.InvariantCulture);
}
if (oldObject.Comment != null)
{
instance.Notes = new List <Note>();
Note note = new Note
{
Text = new string(oldObject.Comment.Take(2048).ToArray()),
IsNoLongerRelevant = true
};
instance.Notes.Add(note);
}
if (oldObject.Area_Id != null)
{
LocalArea area = dbContext.LocalAreas.FirstOrDefault(x => x.Id == oldObject.Area_Id);
if (area != null)
{
instance.LocalArea = area;
}
}
if (oldObject.Equip_Type_Id != null)
{
//Equipment_TYPE_ID is copied to the table of HET_DISTRICT_DISTRICT_TYPE as key
DistrictEquipmentType equipType = dbContext.DistrictEquipmentTypes.FirstOrDefault(x => x.Id == oldObject.Equip_Type_Id);
if (equipType != null)
{
instance.DistrictEquipmentType = equipType;
instance.DistrictEquipmentTypeId = oldObject.Equip_Type_Id;
}
}
instance.EquipmentCode = oldObject.Equip_Cd == null ? "" : new string(oldObject.Equip_Cd.Take(25).ToArray());
instance.Model = oldObject.Model == null ? "" : new string(oldObject.Model.Take(50).ToArray());
instance.Make = oldObject.Make == null ? "" : new string(oldObject.Make.Take(50).ToArray());
instance.Year = oldObject.Year == null ? "" : new string(oldObject.Year.Take(15).ToArray());
instance.Operator = oldObject.Operator == null ? "" : new string(oldObject.Operator.Take(255).ToArray());
instance.SerialNumber = oldObject.Serial_Num == null ? "" : new string(oldObject.Serial_Num.Take(100).ToArray());
instance.Status = oldObject.Status_Cd == null ? "" : new string(oldObject.Status_Cd.Take(50).ToArray());
if (oldObject.Pay_Rate != null)
{
try
{
instance.PayRate = float.Parse(oldObject.Pay_Rate.Trim());
}
catch
{
instance.PayRate = (float)0.0;
}
}
if (instance.Seniority != null)
{
try
{
instance.Seniority = float.Parse(oldObject.Seniority.Trim());
}
catch
{
instance.Seniority = (float)0.0;
}
}
// find the owner which is referenced in the equipment of the xml file entry Through ImportMaps because owner_ID is not prop_ID
ImportMap map = dbContext.ImportMaps.FirstOrDefault(x => x.OldTable == ImportOwner.OldTable && x.OldKey == oldObject.Owner_Popt_Id.ToString());
if (map != null)
{
Models.Owner owner = dbContext.Owners.FirstOrDefault(x => x.Id == map.NewKey);
if (owner != null)
{
instance.Owner = owner;
Contact con = dbContext.Contacts.FirstOrDefault(x => x.Id == owner.PrimaryContactId);
// update owner contact address
if (con != null)
{
try
{
con.Address1 = oldObject.Addr1;
con.Address2 = oldObject.Addr2;
con.City = oldObject.City;
con.PostalCode = oldObject.Postal;
con.Province = "BC";
dbContext.Contacts.Update(con);
}
catch (Exception e)
{
performContext.WriteLine("Error mapping data " + e.Message);
}
}
}
}
if (oldObject.Seniority != null)
{
try
{
instance.Seniority = float.Parse(oldObject.Seniority.Trim());
}
catch
{
instance.Seniority = (float)0.0;
}
}
if (oldObject.Num_Years != null)
{
try
{
instance.YearsOfService = float.Parse(oldObject.Num_Years.Trim());
}
catch
{
instance.YearsOfService = (float)0.0;
}
}
if (oldObject.Block_Num != null)
{
try
{
instance.BlockNumber = decimal.ToInt32(Decimal.Parse(oldObject.Block_Num, System.Globalization.NumberStyles.Float));
}
catch
{
// do nothing
}
}
if (oldObject.Size != null)
{
try
{
instance.Size = oldObject.Size;
}
catch
{
// do nothing
}
}
if (oldObject.YTD1 != null && oldObject.YTD2 != null && oldObject.YTD3 != null)
{
try
{
instance.ServiceHoursLastYear = (float)Decimal.Parse(oldObject.YTD1, System.Globalization.NumberStyles.Any);
}
catch
{
instance.ServiceHoursLastYear = (float)0.0;
}
try
{
instance.ServiceHoursTwoYearsAgo = (float)Decimal.Parse(oldObject.YTD2, System.Globalization.NumberStyles.Any);
instance.ServiceHoursThreeYearsAgo = (float)Decimal.Parse(oldObject.YTD3, System.Globalization.NumberStyles.Any);
}
catch
{
instance.ServiceHoursTwoYearsAgo = (float)0.0;
instance.ServiceHoursThreeYearsAgo = (float)0.0;
}
}
instance.CreateTimestamp = DateTime.UtcNow;
instance.CreateUserid = createdBy.SmUserId;
dbContext.Equipments.Add(instance);
}
else
{
instance = dbContext.Equipments.First(x => x.Id == oldObject.Equip_Id);
instance.LastUpdateUserid = modifiedBy.SmUserId;
try
{
instance.LastUpdateUserid = modifiedBy.SmUserId;
instance.LastUpdateTimestamp = DateTime.ParseExact(oldObject.Modified_Dt.Trim().Substring(0, 10), "yyyy-MM-dd", System.Globalization.CultureInfo.InvariantCulture);
}
catch (Exception e)
{
performContext.WriteLine("Error mapping data " + e.Message);
}
dbContext.Equipments.Update(instance);
}
}
