/// <summary>
/// This is recording where the last import was stopped for specific table
/// Use BCBidImport.todayDate as newTable entry
/// Please note that NewTable enrty of the Import_Map table is aleats today's dat: BCBidImport.todayDate for identifying purpose. This means the restarting point inly carew
/// what has done for today, not in the past.
/// </summary>
/// <param name="dbContext"></param>
/// <param name="oldTable"></param> This is lile "Owner_Progress" for th eimport progress entry (row) of Import_Map table
/// <param name="oldKey"></param> This is where stopped last time in string If this is "388888", then complete
/// <param name="newKey"></param> This is always a constant; for identification of progress entry of the table only. This is extraneous.
static public void AddImportMap_For_Progress(DbAppContext dbContext, string oldTable, string oldKey, int newKey)
{
List <Models.ImportMap> importMapList = dbContext.ImportMaps
.Where(x => x.OldTable == oldTable && x.NewKey == newKey)
.ToList();
if (importMapList.Count == 0)
{
ImportUtility.AddImportMap(dbContext, oldTable, oldKey, BCBidImport.todayDate, newKey);
}
else
{
//Sometimes there are multiple progress entries exists for the same xml file import.
// In that case, the extra one should be deleted and the correct one should be updated.
int maxProgressCount = importMapList.Max(t => int.Parse(t.OldKey));
foreach (ImportMap importMap in importMapList)
{
if (importMap.OldKey == maxProgressCount.ToString())
{
importMap.NewTable = BCBidImport.todayDate;
importMap.OldKey = Math.Max(int.Parse(oldKey), maxProgressCount).ToString();
importMap.LastUpdateTimestamp = DateTime.Now;
dbContext.ImportMaps.Update(importMap);
}
else
{
dbContext.ImportMaps.Remove(importMap);
}
}
}
}
/// <summary>
/// Map data
/// </summary>
/// <param name="dbContext"></param>
/// <param name="oldObject"></param>
/// <param name="instance"></param>
/// <param name="systemId"></param>
private static void CopyToInstance(DbAppContext dbContext, EquipType oldObject, ref EquipmentType instance, string systemId)
{
if (oldObject.Equip_Type_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 EquipmentType
{
Id = oldObject.Equip_Type_Id,
IsDumpTruck = false
};
try
{
instance.ExtendHours = float.Parse(oldObject.Extend_Hours.Trim());
instance.MaximumHours = float.Parse(oldObject.Max_Hours.Trim());
instance.MaxHoursSub = float.Parse(oldObject.Max_Hours_Sub.Trim());
}
catch
{
// do nothing
}
try
{
instance.Name = oldObject.Equip_Type_Cd.Trim();
}
catch
{
// do nothing
}
instance.CreateTimestamp = DateTime.UtcNow;
instance.CreateUserid = createdBy.SmUserId;
dbContext.EquipmentTypes.Add(instance);
}
else
{
instance = dbContext.EquipmentTypes.First(x => x.Id == oldObject.Equip_Type_Id);
instance.LastUpdateUserid = modifiedBy.SmUserId;
try
{
instance.LastUpdateTimestamp = DateTime.ParseExact(oldObject.Modified_Dt.Trim().Substring(0, 10), "yyyy-MM-dd", System.Globalization.CultureInfo.InvariantCulture);
}
catch
{
// do nothing
}
dbContext.EquipmentTypes.Update(instance);
}
}
/// <summary>
/// Import Local Areas
/// </summary>
/// <param name="performContext"></param>
/// <param name="dbContext"></param>
/// <param name="fileLocation"></param>
/// <param name="systemId"></param>
public static void Import(PerformContext performContext, DbAppContext dbContext, string fileLocation, string systemId)
{
// check the start point. If startPoint == sigId then it is already completed
int startPoint = ImportUtility.CheckInterMapForStartPoint(dbContext, OldTableProgress, BcBidImport.SigId, NewTable);
if (startPoint == BcBidImport.SigId) // this means the import job it has done today is complete for all the records in the xml file.
{
performContext.WriteLine("*** Importing " + XmlFileName + " is complete from the former process ***");
return;
}
try
{
string rootAttr = "ArrayOf" + OldTable;
// create Processer progress indicator
performContext.WriteLine("Processing " + OldTable);
IProgressBar progress = performContext.WriteProgressBar();
progress.SetValue(0);
// create serializer and serialize xml file
XmlSerializer ser = new XmlSerializer(typeof(Area[]), new XmlRootAttribute(rootAttr));
MemoryStream memoryStream = ImportUtility.MemoryStreamGenerator(XmlFileName, OldTable, fileLocation, rootAttr);
Area[] legacyItems = (Area[])ser.Deserialize(memoryStream);
int ii = startPoint;
// skip the portion already processed
if (startPoint > 0)
{
legacyItems = legacyItems.Skip(ii).ToArray();
}
Debug.WriteLine("Importing LocalArea Data. Total Records: " + legacyItems.Length);
foreach (Area item in legacyItems.WithProgress(progress))
{
// see if we have this one already
ImportMap importMap = dbContext.ImportMaps.FirstOrDefault(x => x.OldTable == OldTable && x.OldKey == item.Area_Id.ToString());
// new entry
if (importMap == null && item.Area_Id > 0)
{
LocalArea localArea = null;
CopyToInstance(dbContext, item, ref localArea, systemId);
ImportUtility.AddImportMap(dbContext, OldTable, item.Area_Id.ToString(), NewTable, localArea.Id);
}
}
performContext.WriteLine("*** Importing " + XmlFileName + " is Done ***");
ImportUtility.AddImportMapForProgress(dbContext, OldTableProgress, BcBidImport.SigId.ToString(), BcBidImport.SigId, NewTable);
dbContext.SaveChangesForImport();
}
catch (Exception e)
{
performContext.WriteLine("*** ERROR ***");
performContext.WriteLine(e.ToString());
throw;
}
}
/// <summary>
/// Insert District_Equipment_Type or not according to the rule laid out by HETS-365
/// </summary>
/// <param name="dbContext"></param>
/// <param name="oldObject"></param>
/// <param name="instance"></param>
/// <param name="equipRentalRateNo"></param>
/// <param name="description"></param>
/// <param name="serviceAreaName"></param>
/// <param name="addImportMaps"></param>
private static void AddingDistrictEquipmentTypeInstance(DbAppContext dbContext, EquipType oldObject,
DistrictEquipmentType instance, float equipRentalRateNo, string description, string serviceAreaName, bool addImportMaps)
{
// add the instance (according to the rule of HETS-365)
List <DistrictEquipmentType> disEquipTypelist = dbContext.DistrictEquipmentTypes
.Where(x => x.DistrictId == instance.DistrictId)
.Where(x => x.DistrictEquipmentName.Substring(0, Math.Max(0, x.DistrictEquipmentName.IndexOf(Delim, StringComparison.Ordinal)))
.IndexOf(instance.DistrictEquipmentName, StringComparison.Ordinal) >= 0)
.Include(x => x.EquipmentType)
.ToList();
// HETS-365 Step 1
if (disEquipTypelist.Count == 0)
{
instance.DistrictEquipmentName += Delim + description;
dbContext.DistrictEquipmentTypes.Add(instance);
if (addImportMaps)
{
ImportUtility.AddImportMap(dbContext, OldTable, oldObject.Equip_Type_Id.ToString(), NewTable, instance.Id);
}
}
else // HETS-365 Step 2
{
List <DistrictEquipmentType> list1 = disEquipTypelist
.FindAll(x => Math.Abs((x.EquipmentType.BlueBookSection ?? 0.1) - equipRentalRateNo) <= ErrowAllowed);
// HETS-365 Step 2.1
if (list1.Count > 0 && addImportMaps)
{
ImportUtility.AddImportMap(dbContext, OldTable, oldObject.Equip_Type_Id.ToString(),
NewTable, list1.OrderBy(x => x.Id).FirstOrDefault().Id);
}
// check if XML.Description matches any of the HETS.Descriptions
List <DistrictEquipmentType> list2 = disEquipTypelist
.FindAll(x => x.DistrictEquipmentName.Substring(x.DistrictEquipmentName.IndexOf(Delim, StringComparison.Ordinal) + Delim.Length)
.IndexOf(description, StringComparison.Ordinal) >= 0);
// HETS-365 Step 2.1
if (list2.Count > 0 && addImportMaps)
{
ImportUtility.AddImportMap(dbContext, OldTable, oldObject.Equip_Type_Id.ToString(),
NewTable, list2.OrderBy(x => x.Id).FirstOrDefault().Id);
}
// HETS-365 Step 3
if (list1.Count == 0 && list2.Count == 0)
{
instance.DistrictEquipmentName += Delim0 + serviceAreaName + Delim + description;
dbContext.DistrictEquipmentTypes.Add(instance);
if (addImportMaps)
{
ImportUtility.AddImportMap(dbContext, OldTable, oldObject.Equip_Type_Id.ToString(), NewTable, instance.Id);
}
}
}
}
/// <summary>
/// Map data
/// </summary>
/// <param name="dbContext"></param>
/// <param name="oldObject"></param>
/// <param name="equipType"></param>
/// <param name="systemId"></param>
/// <param name="maxEquipTypeIndex"></param>
private static void CopyToInstance(DbAppContext dbContext, EquipType oldObject,
ref EquipmentType equipType, string systemId, ref int maxEquipTypeIndex)
{
try
{
if (oldObject.Equip_Type_Id <= 0)
{
return;
}
if (equipType != null)
{
return;
}
// get the equipment type
string tempEquipTypeCode = ImportUtility.CleanString(oldObject.Equip_Type_Cd).ToUpper();
// check if we have this type already
bool exists = dbContext.EquipmentTypes.Any(x => x.Name == tempEquipTypeCode);
if (exists)
{
return;
}
// add new equipment type
equipType = new EquipmentType
{
Id = ++maxEquipTypeIndex,
IsDumpTruck = false,
ExtendHours = ImportUtility.GetFloatValue(oldObject.Extend_Hours),
MaximumHours = ImportUtility.GetFloatValue(oldObject.Max_Hours),
MaxHoursSub = ImportUtility.GetFloatValue(oldObject.Max_Hours_Sub),
BlueBookRateNumber = ImportUtility.GetFloatValue(oldObject.Equip_Rental_Rate_No),
BlueBookSection = ImportUtility.GetFloatValue(oldObject.Equip_Rental_Rate_Page)
};
if (!string.IsNullOrEmpty(tempEquipTypeCode))
{
equipType.Name = tempEquipTypeCode;
}
equipType.AppCreateUserid = systemId;
equipType.AppCreateTimestamp = DateTime.UtcNow;
equipType.AppLastUpdateUserid = systemId;
equipType.AppLastUpdateTimestamp = DateTime.UtcNow;
dbContext.EquipmentTypes.Add(equipType);
}
catch (Exception ex)
{
Debug.WriteLine("***Error*** - Master Equipment Type Index: " + maxEquipTypeIndex);
Debug.WriteLine(ex.Message);
throw;
}
}
/// <summary>
/// Import existing Cities
/// </summary>
/// <param name="performContext"></param>
/// <param name="dbContext"></param>
/// <param name="fileLocation"></param>
/// <param name="systemId"></param>
private static void ImportCities(PerformContext performContext, DbAppContext dbContext, string fileLocation, string systemId)
{
// check the start point. If startPoint == sigId then it is already completed
int startPoint = ImportUtility.CheckInterMapForStartPoint(dbContext, OldTableProgress, BcBidImport.SigId, NewTable);
if (startPoint == BcBidImport.SigId) // this means the import job it has done today is complete for all the records in the xml file.
{
performContext.WriteLine("*** Importing " + XmlFileName + " is complete from the former process ***");
return;
}
int maxCityIndex = 0;
if (dbContext.Cities.Any())
{
maxCityIndex = dbContext.Cities.Max(x => x.Id);
}
try
{
string rootAttr = "ArrayOf" + OldTable;
performContext.WriteLine("Processing " + OldTable);
IProgressBar progress = performContext.WriteProgressBar();
progress.SetValue(0);
// create serializer and serialize xml file
XmlSerializer ser = new XmlSerializer(typeof(HetsCity[]), new XmlRootAttribute(rootAttr));
MemoryStream memoryStream = ImportUtility.MemoryStreamGenerator(XmlFileName, OldTable, fileLocation, rootAttr);
HetsCity[] legacyItems = (HetsCity[])ser.Deserialize(memoryStream);
foreach (HetsCity item in legacyItems.WithProgress(progress))
{
// see if we have this one already
ImportMap importMap = dbContext.ImportMaps.FirstOrDefault(x => x.OldTable == OldTable && x.OldKey == item.City_Id.ToString());
// new entry
if (importMap == null)
{
City city = null;
CopyToInstance(dbContext, item, ref city, systemId, ref maxCityIndex);
ImportUtility.AddImportMap(dbContext, OldTable, item.City_Id.ToString(), NewTable, city.Id);
}
}
performContext.WriteLine("*** Importing " + XmlFileName + " is Done ***");
ImportUtility.AddImportMapForProgress(dbContext, OldTableProgress, BcBidImport.SigId.ToString(), BcBidImport.SigId, NewTable);
dbContext.SaveChangesForImport();
}
catch (Exception e)
{
performContext.WriteLine("*** ERROR ***");
performContext.WriteLine(e.ToString());
throw;
}
}
static private void CopyToInstance(PerformContext performContext, DbAppContext dbContext, HETSAPI.Import.EquipType oldObject, ref Models.EquipmentType instance, string systemId)
{
bool isNew = false;
if (oldObject.Equip_Type_Id <= 0)
{
return;
}
//Add the user specified in oldObject.Modified_By and oldObject.Created_By if not there in the database
Models.User modifiedBy = ImportUtility.AddUserFromString(dbContext, oldObject.Modified_By, systemId);
Models.User createdBy = ImportUtility.AddUserFromString(dbContext, oldObject.Created_By, systemId);
if (instance == null)
{
isNew = true;
instance = new Models.EquipmentType();
instance.Id = oldObject.Equip_Type_Id;
instance.IsDumpTruck = false; // Where this is coming from? !!!!!!
try
{
instance.ExtendHours = float.Parse(oldObject.Extend_Hours.Trim());
instance.MaximumHours = float.Parse(oldObject.Max_Hours.Trim());
instance.MaxHoursSub = float.Parse(oldObject.Max_Hours_Sub.Trim());
}
catch
{
}
try
{
instance.Name = oldObject.Equip_Type_Cd.Trim();
}
catch
{
}
instance.CreateTimestamp = DateTime.UtcNow;
instance.CreateUserid = createdBy.SmUserId;
dbContext.EquipmentTypes.Add(instance);
}
else
{
instance = dbContext.EquipmentTypes
.First(x => x.Id == oldObject.Equip_Type_Id);
instance.LastUpdateUserid = modifiedBy.SmUserId;
try
{
instance.LastUpdateTimestamp = DateTime.ParseExact(oldObject.Modified_Dt.Trim().Substring(0, 10), "yyyy-MM-dd", System.Globalization.CultureInfo.InvariantCulture);
}
catch
{
}
dbContext.EquipmentTypes.Update(instance);
}
}
/// <summary>
/// Copy Block item of LocalAreaRotationList item
/// </summary>
/// <param name="dbContext"></param>
/// <param name="oldObject"></param>
/// <param name="instance"></param>
/// <param name="systemId"></param>
private static void CopyToInstance(DbAppContext dbContext, Block oldObject, ref LocalAreaRotationList instance, string systemId)
{
if (oldObject.Area_Id <= 0)
{
return;
}
// add the user specified in oldObject.Modified_By and oldObject.Created_By if not there in the database
User createdBy = ImportUtility.AddUserFromString(dbContext, oldObject.Created_By, systemId);
int equipmentTypeId = oldObject.Equip_Type_Id ?? 0;
int blockNum = Convert.ToInt32(float.Parse(oldObject.Block_Num == null ? "0.0" : oldObject.Block_Num));
if (instance == null)
{
instance = new LocalAreaRotationList();
DistrictEquipmentType disEquipType = dbContext.DistrictEquipmentTypes.FirstOrDefault(x => x.Id == equipmentTypeId);
if (disEquipType != null)
{
instance.DistrictEquipmentType = disEquipType;
instance.DistrictEquipmentTypeId = disEquipType.Id;
}
// extract AskNextBlock*Id which is the secondary key of Equip.Id
int equipId = oldObject.Last_Hired_Equip_Id ?? 0;
if (dbContext.Equipments.Any(x => x.Id == equipId))
{
switch (blockNum)
{
case 1:
instance.AskNextBlockOpenId = equipId;
break;
case 2:
instance.AskNextBlock1Id = equipId;
break;
case 3:
instance.AskNextBlock2Id = equipId;
break;
}
}
instance.CreateUserid = createdBy.SmUserId;
if (oldObject.Created_Dt != null)
{
instance.CreateTimestamp = DateTime.ParseExact(oldObject.Created_Dt.Trim().Substring(0, 10), "yyyy-MM-dd", System.Globalization.CultureInfo.InvariantCulture);
}
dbContext.LocalAreaRotationLists.Add(instance);
}
}
/// <summary>
/// This is recording where the last import was stopped for specific table
/// Use BCBidImport.todayDate as newTable entry
/// Please note that NewTable enrty of the Import_Map table is aleats today's dat: BCBidImport.todayDate for identifying purpose. This means the restarting point inly carew
/// what has done for today, not in the past.
/// </summary>
/// <param name="dbContext"></param>
/// <param name="oldTable"></param> This is lile "Owner_Progress" for th eimport progress entry (row) of Import_Map table
/// <param name="oldKey"></param> This is where stopped last time in string If this is "300000", then complete
/// <param name="newKey"></param> This is always a constant; for identification of progress entry of the table only. This is extraneous.
static public void AddImportMap_For_Progress(DbAppContext dbContext, string oldTable, string oldKey, int newKey)
{
Models.ImportMap importMap = dbContext.ImportMaps.FirstOrDefault(x => x.OldTable == oldTable && x.NewKey == newKey);
if (importMap == null)
{
ImportUtility.AddImportMap(dbContext, oldTable, oldKey, BCBidImport.todayDate, newKey);
}
else
{
importMap.OldKey = oldKey;
importMap.LastUpdateTimestamp = DateTime.Now;
dbContext.ImportMaps.Update(importMap);
}
}
public static void Obfuscate(PerformContext performContext, DbAppContext dbContext, string sourceLocation, string destinationLocation, string systemId)
{
int startPoint = ImportUtility.CheckInterMapForStartPoint(dbContext, "Obfuscate_" + OldTableProgress, BcBidImport.SigId, NewTable);
if (startPoint == BcBidImport.SigId) // this means the import job it has done today is complete for all the records in the xml file.
{
performContext.WriteLine("*** Obfuscating " + XmlFileName + " is complete from the former process ***");
return;
}
try
{
string rootAttr = "ArrayOf" + OldTable;
// create Processer progress indicator
performContext.WriteLine("Processing " + OldTable);
IProgressBar progress = performContext.WriteProgressBar();
progress.SetValue(0);
// create serializer and serialize xml file
XmlSerializer ser = new XmlSerializer(typeof(Block[]), new XmlRootAttribute(rootAttr));
MemoryStream memoryStream = ImportUtility.MemoryStreamGenerator(XmlFileName, OldTable, sourceLocation, rootAttr);
Block[] legacyItems = (Block[])ser.Deserialize(memoryStream);
performContext.WriteLine("Obfuscating Block data");
progress.SetValue(0);
foreach (Block item in legacyItems.WithProgress(progress))
{
item.Created_By = systemId;
item.Closed_Comments = ImportUtility.ScrambleString(item.Closed_Comments);
}
performContext.WriteLine("Writing " + XmlFileName + " to " + destinationLocation);
// write out the array
FileStream fs = ImportUtility.GetObfuscationDestination(XmlFileName, destinationLocation);
ser.Serialize(fs, legacyItems);
fs.Close();
// no excel for Block.
}
catch (Exception e)
{
performContext.WriteLine("*** ERROR ***");
performContext.WriteLine(e.ToString());
}
}
/// <summary>
/// Copy xml item to instance (table entries)
/// </summary>
/// <param name="dbContext"></param>
/// <param name="oldObject"></param>
/// <param name="instance"></param>
/// <param name="systemId"></param>
private static void CopyToInstance(DbAppContext dbContext, EquipType oldObject, ref DistrictEquipmentType instance, string systemId)
{
if (oldObject.Equip_Type_Id <= 0)
{
return;
}
// add the user specified in oldObject.Modified_By and oldObject.Created_By if not there in the database
ImportUtility.AddUserFromString(dbContext, oldObject.Modified_By, systemId);
User createdBy = ImportUtility.AddUserFromString(dbContext, oldObject.Created_By, systemId);
if (instance == null)
{
instance = new DistrictEquipmentType {
Id = oldObject.Equip_Type_Id
};
try
{
instance.DistrictEquipmentName = oldObject.Equip_Type_Cd.Length >= 10 ?
oldObject.Equip_Type_Cd.Substring(0, 10) :
oldObject.Equip_Type_Cd
+ "-" + (oldObject.Equip_Type_Desc.Length >= 210 ?
oldObject.Equip_Type_Desc.Substring(0, 210) :
oldObject.Equip_Type_Desc);
}
catch
{
// do nothing
}
ServiceArea serviceArea = dbContext.ServiceAreas.FirstOrDefault(x => x.MinistryServiceAreaID == oldObject.Service_Area_Id);
if (serviceArea != null)
{
int districtId = serviceArea.DistrictId ?? 0;
District dis = dbContext.Districts.FirstOrDefault(x => x.RegionId == districtId);
instance.DistrictId = districtId;
instance.District = dis;
}
instance.CreateTimestamp = DateTime.UtcNow;
instance.CreateUserid = createdBy.SmUserId;
dbContext.DistrictEquipmentTypes.Add(instance);
}
}
/// <summary>
/// Insert District_Equipment_Type or not according to the rule laid out by HETS-365
/// </summary>
/// <param name="dbContext"></param>
/// <param name="oldObject"></param>
/// <param name="instance"></param>
/// <param name="equip_Rental_rate_No"></param>
/// <param name="description"></param>
/// <param name="serviceAreaName"></param>
/// <param name="updateImportMaps"></param>
static private void AddingDistrictEquipmentTypeInstance(DbAppContext dbContext, HETSAPI.Import.EquipType oldObject,
Models.DistrictEquipmentType instance, float equip_Rental_rate_No, string description, string serviceAreaName, bool addImportMaps)
{
// Add the instance according to the rule of HETS-365
var disEquipTypelist = dbContext.DistrictEquipmentTypes
.Where(x => x.DistrictId == instance.DistrictId)
.Where(x => x.DistrictEquipmentName.Substring(0, Math.Max(0, x.DistrictEquipmentName.IndexOf(delim))).IndexOf(instance.DistrictEquipmentName) >= 0)
.Include(x => x.EquipmentType)
.ToList();
if (disEquipTypelist.Count == 0) //HETS-365 Step 1.
{
instance.DistrictEquipmentName += delim + description;
dbContext.DistrictEquipmentTypes.Add(instance);
if (addImportMaps)
{
ImportUtility.AddImportMap(dbContext, oldTable, oldObject.Equip_Type_Id.ToString(), newTable, instance.Id);
}
}
else //HETS-365 Step 2.
{
var list1 = disEquipTypelist
.FindAll(x => Math.Abs((x.EquipmentType.BlueBookSection ?? 0.1) - equip_Rental_rate_No) <= errowAllowed);
// .OrderBy(x => x.Id);
if (list1.Count > 0 && addImportMaps) //HETS-365 Step 2.1
{
ImportUtility.AddImportMap(dbContext, oldTable, oldObject.Equip_Type_Id.ToString(), newTable, list1.OrderBy(x => x.Id).FirstOrDefault().Id);
}
//Check if XML.Description matches any of the HETS.Descriptions
var list2 = disEquipTypelist.FindAll(x => x.DistrictEquipmentName.Substring(x.DistrictEquipmentName.IndexOf(delim) + delim.Length).IndexOf(description) > 0);
if (list2.Count > 0 && addImportMaps) //HETS-365 Step 2.1
{
ImportUtility.AddImportMap(dbContext, oldTable, oldObject.Equip_Type_Id.ToString(), newTable, list2.OrderBy(x => x.Id).FirstOrDefault().Id);
}
if (list1.Count == 0 && list2.Count == 0) //HETS-365 Step 3
{
instance.DistrictEquipmentName += delim0 + serviceAreaName + delim + description;
dbContext.DistrictEquipmentTypes.Add(instance);
if (addImportMaps)
{
ImportUtility.AddImportMap(dbContext, oldTable, oldObject.Equip_Type_Id.ToString(), newTable, instance.Id);
}
}
}
}
/// <summary>
/// Copy xml item to instance (table entries)
/// </summary>
/// <param name="performContext"></param>
/// <param name="dbContext"></param>
/// <param name="oldObject"></param>
/// <param name="instance"></param>
/// <param name="systemId"></param>
static private void CopyToInstance(PerformContext performContext, DbAppContext dbContext, HETSAPI.Import.EquipType oldObject, ref Models.DistrictEquipmentType instance, string systemId)
{
bool isNew = false;
if (oldObject.Equip_Type_Id <= 0)
{
return;
}
//Add the user specified in oldObject.Modified_By and oldObject.Created_By if not there in the database
Models.User modifiedBy = ImportUtility.AddUserFromString(dbContext, oldObject.Modified_By, systemId);
Models.User createdBy = ImportUtility.AddUserFromString(dbContext, oldObject.Created_By, systemId);
if (instance == null)
{
isNew = true;
instance = new Models.DistrictEquipmentType();
instance.Id = oldObject.Equip_Type_Id;
try //Combining <Equip_Type_Cd> and < Equip_Type_Desc> together
{
instance.DistrictEquipmentName = oldObject.Equip_Type_Cd.Length >= 10 ? oldObject.Equip_Type_Cd.Substring(0, 10) : oldObject.Equip_Type_Cd
+ "-" + (oldObject.Equip_Type_Desc.Length >= 210 ? oldObject.Equip_Type_Desc.Substring(0, 210) : oldObject.Equip_Type_Desc);
// instance.DistrictEquipmentName = oldObject.ToDelimString(" | ");
}
catch
{
}
ServiceArea serviceArea = dbContext.ServiceAreas.FirstOrDefault(x => x.MinistryServiceAreaID == oldObject.Service_Area_Id);
if (serviceArea != null)
{
int districtId = serviceArea.DistrictId ?? 0;
District dis = dbContext.Districts.FirstOrDefault(x => x.RegionId == districtId);
instance.DistrictId = districtId;
instance.District = dis;
}
// instance.EquipmentType =
instance.CreateTimestamp = DateTime.UtcNow;
instance.CreateUserid = createdBy.SmUserId;
dbContext.DistrictEquipmentTypes.Add(instance);
}
}
static private void CopyToInstance(PerformContext performContext, DbAppContext dbContext, HETSAPI.Import.EquipAttach oldObject, ref Models.EquipmentAttachment instance,
List <Models.Equipment> equips, 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
// Models.User modifiedBy = ImportUtility.AddUserFromString(dbContext, "", systemId, true);
Models.User createdBy = ImportUtility.AddUserFromString(dbContext, oldObject.Created_By, systemId);
if (instance == null)
{
instance = new Models.EquipmentAttachment();
int equipId = oldObject.Equip_Id ?? -1;
Models.Equipment equipment = equips.FirstOrDefault(x => x.Id == equipId);
if (equipment != null)
{
instance.Equipment = equipment;
instance.EquipmentId = equipment.Id;
}
instance.Description = oldObject.Attach_Desc == null ? "" : oldObject.Attach_Desc;
instance.TypeName = (oldObject.Attach_Seq_Num ?? -1).ToString();
if (oldObject.Created_Dt != null && oldObject.Created_Dt.Trim().Length >= 10)
{
instance.CreateTimestamp =
DateTime.ParseExact(oldObject.Created_Dt.Trim().Substring(0, 10), "yyyy-MM-dd", System.Globalization.CultureInfo.InvariantCulture);
}
instance.CreateUserid = createdBy.SmUserId;
dbContext.EquipmentAttachments.Add(instance);
}
else
{
instance = dbContext.EquipmentAttachments
.First(x => x.EquipmentId == oldObject.Equip_Id && x.TypeName == (oldObject.Attach_Seq_Num ?? -2).ToString());
instance.LastUpdateUserid = systemId; // modifiedBy.SmUserId;
instance.LastUpdateTimestamp = DateTime.UtcNow;
dbContext.EquipmentAttachments.Update(instance);
}
}
/// <summary>
/// Get the list of mapped records.
/// </summary>
/// <param name="dbContext"></param>
/// <param name="fileLocation"></param>
/// <returns></returns>
public static List <ImportMapRecord> GetImportMap(DbAppContext dbContext, string fileLocation)
{
List <ImportMapRecord> result = new List <ImportMapRecord>();
string rootAttr = "ArrayOf" + OldTable;
XmlSerializer ser = new XmlSerializer(typeof(UserHets[]), new XmlRootAttribute(rootAttr));
ser.UnknownAttribute += ImportUtility.UnknownAttribute;
ser.UnknownElement += ImportUtility.UnknownElement;
MemoryStream memoryStream = ImportUtility.MemoryStreamGenerator(XmlFileName, OldTable, fileLocation, rootAttr);
XmlReader reader = new XmlTextReader(memoryStream);
if (ser.CanDeserialize(reader))
{
UserHets[] legacyItems = (UserHets[])ser.Deserialize(reader);
List <string> usernames = new List <string>();
foreach (UserHets item in legacyItems)
{
string username = NormalizeUserCode(item.User_Cd);
if (!usernames.Contains(username))
{
usernames.Add(username);
}
}
usernames.Sort();
int currentUser = 0;
foreach (string username in usernames)
{
ImportMapRecord importMapRecord = new ImportMapRecord
{
TableName = NewTable,
MappedColumn = "User_cd",
OriginalValue = username,
NewValue = "User" + currentUser
};
currentUser++;
result.Add(importMapRecord);
}
}
return(result);
}
/// <summary>
/// Copy from legacy to new record For the table of HET_City
/// </summary>
/// <param name="dbContext"></param>
/// <param name="oldObject"></param>
/// <param name="city"></param>
/// <param name="systemId"></param>
/// <param name="maxCityIndex"></param>
private static void CopyToInstance(DbAppContext dbContext, HetsCity oldObject, ref City city, string systemId, ref int maxCityIndex)
{
try
{
if (city != null)
{
return;
}
city = new City {
Id = ++maxCityIndex
};
// ***********************************************
// set the city name
// ***********************************************
string tempName = ImportUtility.CleanString(oldObject.Name);
if (string.IsNullOrEmpty(tempName))
{
return;
}
tempName = ImportUtility.GetCapitalCase(tempName);
city.Name = tempName;
// ***********************************************
// create city
// ***********************************************
city.AppCreateUserid = systemId;
city.AppCreateTimestamp = DateTime.UtcNow;
city.AppLastUpdateUserid = systemId;
city.AppLastUpdateTimestamp = DateTime.UtcNow;
dbContext.Cities.Add(city);
}
catch (Exception ex)
{
Debug.WriteLine("***Error*** - City Id: " + oldObject.City_Id);
Debug.WriteLine("***Error*** - Service Area Id: " + oldObject.Service_Area_Id);
Debug.WriteLine(ex.Message);
throw;
}
}
/// <summary>
/// Map data
/// </summary>
/// <param name="dbContext"></param>
/// <param name="oldObject"></param>
/// <param name="localArea"></param>
/// <param name="systemId"></param>
private static void CopyToInstance(DbAppContext dbContext, Area oldObject, ref LocalArea localArea, string systemId)
{
try
{
if (oldObject.Area_Id <= 0)
{
return;
}
localArea = new LocalArea
{
Id = oldObject.Area_Id,
LocalAreaNumber = oldObject.Area_Id,
Name = ImportUtility.GetCapitalCase(oldObject.Area_Desc.Trim())
};
// map to the correct service area
ServiceArea serviceArea = dbContext.ServiceAreas.AsNoTracking()
.FirstOrDefault(x => x.MinistryServiceAreaID == oldObject.Service_Area_Id);
if (serviceArea == null)
{
// not mapped correctly
return;
}
localArea.ServiceAreaId = serviceArea.Id;
localArea.AppCreateUserid = systemId;
localArea.AppCreateTimestamp = DateTime.UtcNow;
localArea.AppLastUpdateUserid = systemId;
localArea.AppLastUpdateTimestamp = DateTime.UtcNow;
dbContext.LocalAreas.Add(localArea);
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public static void Obfuscate(PerformContext performContext, DbAppContext dbContext, string sourceLocation, string destinationLocation, string systemId)
{
int startPoint = ImportUtility.CheckInterMapForStartPoint(dbContext, "Obfuscate_" + OldTableProgress, BcBidImport.SigId, NewTable);
if (startPoint == BcBidImport.SigId) // this means the import job it has done today is complete for all the records in the xml file.
{
performContext.WriteLine("*** Obfuscating " + XmlFileName + " is complete from the former process ***");
return;
}
try
{
string rootAttr = "ArrayOf" + OldTable;
// create Processer progress indicator
performContext.WriteLine("Processing " + OldTable);
// create serializer and serialize xml file
XmlSerializer ser = new XmlSerializer(typeof(EquipType[]), new XmlRootAttribute(rootAttr));
MemoryStream memoryStream = ImportUtility.MemoryStreamGenerator(XmlFileName, OldTable, sourceLocation, rootAttr);
EquipType[] legacyItems = (EquipType[])ser.Deserialize(memoryStream);
// no fields to mask for equipment type - straight copy
performContext.WriteLine("Writing " + XmlFileName + " to " + destinationLocation);
// write out the array.
FileStream fs = ImportUtility.GetObfuscationDestination(XmlFileName, destinationLocation);
ser.Serialize(fs, legacyItems);
fs.Close();
// no excel for DumpTruck.
}
catch (Exception e)
{
performContext.WriteLine("*** ERROR ***");
performContext.WriteLine(e.ToString());
}
}
/// <summary>
/// Copy xml item to instance (table entries)
/// </summary>
/// <param name="performContext"></param>
/// <param name="dbContext"></param>
/// <param name="oldObject"></param>
/// <param name="instance"></param>
/// <param name="systemId"></param>
static private void CopyToInstance(PerformContext performContext, DbAppContext dbContext, HETSAPI.Import.Rotation_Doc oldObject, ref Models.Note instance,
List <Models.Equipment> equips, List <Models.Project> projs, string systemId)
{
bool isNew = false;
//Add the user specified in oldObject.Modified_By and oldObject.Created_By if not there in the database
Models.User modifiedBy = ImportUtility.AddUserFromString(dbContext, "", systemId);
Models.User createdBy = ImportUtility.AddUserFromString(dbContext, oldObject.Created_By, systemId);
if (instance == null)
{
isNew = true;
instance = new Models.Note();
Models.Project proj = projs.FirstOrDefault(x => x.Id == oldObject.Project_Id);
Models.Equipment equip = equips.FirstOrDefault(x => x.Id == oldObject.Equip_Id);
if (equip != null)
{
if (equip.Notes == null)
{
equip.Notes = new List <Note>();
}
Models.Note note = new Note();
note.Text = new string(oldObject.Reason.Take(2048).ToArray());
note.IsNoLongerRelevant = true;
if (proj != null)
{ // The current model does not allow Project Id to be added to thge Note. while Note model should have Project ID
// note. = oldObject.Project_Id;
}
equip.Notes.Add(note);
dbContext.Equipments.Update(equip);
}
}
}
public static void Obfuscate(PerformContext performContext, DbAppContext dbContext, string sourceLocation, string destinationLocation, string systemId)
{
try
{
string rootAttr = "ArrayOf" + OldTable;
// create Processer progress indicator
performContext.WriteLine("Processing " + OldTable);
IProgressBar progress = performContext.WriteProgressBar();
progress.SetValue(0);
// create serializer and serialize xml file
XmlSerializer ser = new XmlSerializer(typeof(ServiceArea[]), new XmlRootAttribute(rootAttr));
ser.UnknownAttribute += ImportUtility.UnknownAttribute;
ser.UnknownElement += ImportUtility.UnknownElement;
MemoryStream memoryStream = ImportUtility.MemoryStreamGenerator(XmlFileName, OldTable, sourceLocation, rootAttr);
ServiceArea[] legacyItems = (ServiceArea[])ser.Deserialize(memoryStream);
foreach (ServiceArea item in legacyItems.WithProgress(progress))
{
item.Created_By = systemId;
}
performContext.WriteLine("Writing " + XmlFileName + " to " + destinationLocation);
// write out the array.
FileStream fs = ImportUtility.GetObfuscationDestination(XmlFileName, destinationLocation);
ser.Serialize(fs, legacyItems);
fs.Close();
}
catch (Exception e)
{
performContext.WriteLine("*** ERROR ***");
performContext.WriteLine(e.ToString());
}
}
static public void Import(PerformContext performContext, DbAppContext dbContext, string fileLocation, string systemId)
{
// Check the start point. If startPoint == sigId then it is already completed
int startPoint = ImportUtility.CheckInterMapForStartPoint(dbContext, oldTable_Progress, BCBidImport.sigId);
if (startPoint == BCBidImport.sigId) // This means the import job it has done today is complete for all the records in the xml file.
{
performContext.WriteLine("*** Importing " + xmlFileName + " is complete from the former process ***");
return;
}
try
{
string rootAttr = "ArrayOf" + oldTable;
//Create Processer progress indicator
performContext.WriteLine("Processing " + oldTable);
var progress = performContext.WriteProgressBar();
progress.SetValue(0);
// create serializer and serialize xml file
XmlSerializer ser = new XmlSerializer(typeof(User_HETS[]), new XmlRootAttribute(rootAttr));
MemoryStream memoryStream = ImportUtility.memoryStreamGenerator(xmlFileName, oldTable, fileLocation, rootAttr);
HETSAPI.Import.User_HETS[] legacyItems = (HETSAPI.Import.User_HETS[])ser.Deserialize(memoryStream);
int ii = startPoint;
if (startPoint > 0) // Skip the portion already processed
{
legacyItems = legacyItems.Skip(ii).ToArray();
}
foreach (var item in legacyItems.WithProgress(progress))
{
// see if we have this one already.
ImportMap importMap = dbContext.ImportMaps.FirstOrDefault(x => x.OldTable == oldTable && x.OldKey == item.Popt_Id.ToString());
Models.User instance = dbContext.Users.FirstOrDefault(x => item.User_Cd.ToUpper().IndexOf(x.SmUserId.ToUpper()) >= 0);
if (instance == null)
{
CopyToInstance(performContext, dbContext, item, ref instance, systemId);
if (importMap == null && instance != null) // new entry
{
ImportUtility.AddImportMap(dbContext, oldTable, item.Popt_Id.ToString(), newTable, instance.Id);
}
ImportUtility.AddImportMap_For_Progress(dbContext, oldTable_Progress, (++ii).ToString(), BCBidImport.sigId);
int iResult = dbContext.SaveChangesForImport();
}
//else // update
//{
// instance = dbContext.Users.FirstOrDefault(x => x.Id == importMap.NewKey);
// if (instance == null) // record was deleted
// {
// CopyToInstance(performContext, dbContext, item, ref instance, systemId);
// // update the import map.
// importMap.NewKey = instance.Id;
// dbContext.ImportMaps.Update(importMap);
// }
// else // ordinary update.
// {
// CopyToInstance(performContext, dbContext, item, ref instance, systemId);
// // touch the import map.
// importMap.LastUpdateTimestamp = DateTime.UtcNow;
// dbContext.ImportMaps.Update(importMap);
// }
//}
}
}
catch (Exception e)
{
performContext.WriteLine("*** ERROR ***");
performContext.WriteLine(e.ToString());
}
try
{
performContext.WriteLine("*** Importing " + xmlFileName + " is Done ***");
ImportUtility.AddImportMap_For_Progress(dbContext, oldTable_Progress, BCBidImport.sigId.ToString(), BCBidImport.sigId);
int iResult = dbContext.SaveChangesForImport();
}
catch (Exception e)
{
string iStr = e.ToString();
}
}
/// <summary>
/// Import Equipment Types
/// </summary>
/// <param name="performContext"></param>
/// <param name="dbContext"></param>
/// <param name="fileLocation"></param>
/// <param name="systemId"></param>
public static void Import(PerformContext performContext, DbAppContext dbContext, string fileLocation, string systemId)
{
// check the start point. If startPoint == sigId then it is already completed
int startPoint = ImportUtility.CheckInterMapForStartPoint(dbContext, OldTableProgress, BcBidImport.SigId, NewTable);
if (startPoint == BcBidImport.SigId) // this means the import job it has done today is complete for all the records in the xml file.
{
performContext.WriteLine("*** Importing " + XmlFileName + " is complete from the former process ***");
return;
}
int maxEquipTypeIndex = 0;
if (dbContext.EquipmentTypes.Any())
{
maxEquipTypeIndex = dbContext.EquipmentTypes.Max(x => x.Id);
}
try
{
string rootAttr = "ArrayOf" + OldTable;
// create Processer progress indicator
performContext.WriteLine("Processing " + OldTable);
IProgressBar progress = performContext.WriteProgressBar();
progress.SetValue(0);
// create serializer and serialize xml file
XmlSerializer ser = new XmlSerializer(typeof(EquipType[]), new XmlRootAttribute(rootAttr));
MemoryStream memoryStream = ImportUtility.MemoryStreamGenerator(XmlFileName, OldTable, fileLocation, rootAttr);
EquipType[] legacyItems = (EquipType[])ser.Deserialize(memoryStream);
int ii = startPoint;
// skip the portion already processed
if (startPoint > 0)
{
legacyItems = legacyItems.Skip(ii).ToArray();
}
Debug.WriteLine("Importing EquipmentType Data. Total Records: " + legacyItems.Length);
foreach (EquipType item in legacyItems.WithProgress(progress))
{
// see if we have this one already
ImportMap importMap = dbContext.ImportMaps.FirstOrDefault(x => x.OldTable == OldTable && x.OldKey == item.Equip_Type_Id.ToString());
// new entry (only import new records of Equipment Type)
if (importMap == null && item.Equip_Type_Id > 0)
{
EquipmentType equipType = null;
CopyToInstance(dbContext, item, ref equipType, systemId, ref maxEquipTypeIndex);
if (equipType != null)
{
ImportUtility.AddImportMap(dbContext, OldTable, item.Equip_Type_Id.ToString(), NewTable, equipType.Id);
}
}
// save change to database periodically to avoid frequent writing to the database
if (ii++ % 500 == 0)
{
try
{
ImportUtility.AddImportMapForProgress(dbContext, OldTableProgress, ii.ToString(), BcBidImport.SigId, NewTable);
dbContext.SaveChangesForImport();
}
catch (Exception e)
{
performContext.WriteLine("Error saving data " + e.Message);
}
}
}
try
{
performContext.WriteLine("*** Importing " + XmlFileName + " is Done ***");
ImportUtility.AddImportMapForProgress(dbContext, OldTableProgress, BcBidImport.SigId.ToString(), BcBidImport.SigId, NewTable);
dbContext.SaveChangesForImport();
}
catch (Exception e)
{
string temp = string.Format("Error saving data (EquipmentTypeIndex: {0}): {1}", maxEquipTypeIndex, e.Message);
performContext.WriteLine(temp);
throw new DataException(temp);
}
}
catch (Exception e)
{
performContext.WriteLine("*** ERROR ***");
performContext.WriteLine(e.ToString());
throw;
}
}
/// <summary>
/// Copy user instance
/// </summary>
/// <param name="dbContext"></param>
/// <param name="oldObject"></param>
/// <param name="user"></param>
/// <param name="systemId"></param>
static private void CopyToInstance(PerformContext performContext, DbAppContext dbContext, HETSAPI.Import.User_HETS oldObject, ref Models.User user, string systemId)
{
bool isNew = false;
string smUserId;
int service_Area_Id;
int startPos = oldObject.User_Cd.IndexOf(@"\") + 1;
try
{
service_Area_Id = oldObject.Service_Area_Id;
smUserId = oldObject.User_Cd.Substring(startPos).Trim();
}
catch
{
return;
}
//Add the user specified in oldObject.Modified_By and oldObject.Created_By if not there in the database
Models.User modifiedBy = ImportUtility.AddUserFromString(dbContext, oldObject.Modified_By, systemId);
Models.User createdBy = ImportUtility.AddUserFromString(dbContext, oldObject.Created_By, systemId);
if (createdBy.SmUserId == smUserId)
{
user = createdBy;
return;
}
if (modifiedBy.SmUserId == smUserId)
{
user = modifiedBy;
return;
}
Models.UserRole userRole = new UserRole();
string authority;
try
{
authority = oldObject.Authority.Trim();
}
catch
{
authority = ""; // Regular User
}
int roleId = ImportUtility.GetRoleIdFromAuthority(authority);
Models.User user1 = dbContext.Users.FirstOrDefault(x => x.SmUserId == smUserId);
ServiceArea serArea = dbContext.ServiceAreas
.Include(x => x.District)
.FirstOrDefault(x => x.MinistryServiceAreaID == service_Area_Id);
if (user1 == null)
{
isNew = true;
if (user == null)
{
user = new User();
}
try
{
user.SmUserId = smUserId;
user.District = serArea.District;
user.DistrictId = serArea.DistrictId;
}
catch
{
}
user.CreateTimestamp = DateTime.UtcNow;
user.CreateUserid = createdBy.SmUserId;
// The followings are the data mapping
// user.Email = oldObject.
// user.GivenName
// user.Surname
//Add user Role - Role Id is limited to 1, or 2
if (roleId > 2)
{
roleId = 1;
}
userRole.Role = dbContext.Roles.First(x => x.Id == roleId);
userRole.CreateTimestamp = DateTime.UtcNow;
userRole.ExpiryDate = DateTime.UtcNow.AddMonths(12);
userRole.CreateUserid = createdBy.SmUserId;
userRole.EffectiveDate = DateTime.UtcNow.AddDays(-1);
user.UserRoles = new List <UserRole>();
user.UserRoles.Add(userRole);
dbContext.Users.Add(user);
}
else
{
user = dbContext.Users
.Include(x => x.UserRoles)
.Include(x => x.GroupMemberships)
.First(x => x.SmUserId == smUserId);
// if the user does not have the user role, add the user role
if (user.UserRoles == null)
{
user.UserRoles = new List <UserRole>();
}
// If the role does not exist for the user, add the user role for the user
if (user.UserRoles.FirstOrDefault(x => x.RoleId == roleId) == null)
{
userRole.Role = dbContext.Roles.First(x => x.Id == roleId);
userRole.CreateTimestamp = DateTime.UtcNow;
userRole.ExpiryDate = DateTime.UtcNow.AddMonths(12);
userRole.CreateUserid = createdBy.SmUserId;
userRole.EffectiveDate = DateTime.UtcNow.AddDays(-1);
user.UserRoles.Add(userRole);
}
user.LastUpdateUserid = createdBy.SmUserId;
user.CreateTimestamp = DateTime.UtcNow;
user.Active = true;
dbContext.Users.Update(user);
}
}
/// <summary>
/// Import Users
/// </summary>
/// <param name="performContext"></param>
/// <param name="dbContext"></param>
/// <param name="fileLocation"></param>
/// <param name="systemId"></param>
public static void Import(PerformContext performContext, DbAppContext dbContext, string fileLocation, string systemId)
{
// check the start point. If startPoint == sigId then it is already completed
int startPoint = ImportUtility.CheckInterMapForStartPoint(dbContext, OldTableProgress, BcBidImport.SigId, NewTable);
if (startPoint == BcBidImport.SigId) // this means the import job it has done today is complete for all the records in the xml file.
{
performContext.WriteLine("*** Importing " + XmlFileName + " is complete from the former process ***");
return;
}
// manage the id value for new user records
int maxUserIndex = 0;
if (dbContext.Users.Any())
{
maxUserIndex = dbContext.Users.Max(x => x.Id);
}
try
{
string rootAttr = "ArrayOf" + OldTable;
// create Processer progress indicator
performContext.WriteLine("Processing " + OldTable);
IProgressBar progress = performContext.WriteProgressBar();
progress.SetValue(0);
// create serializer and serialize xml file
XmlSerializer ser = new XmlSerializer(typeof(UserHets[]), new XmlRootAttribute(rootAttr));
MemoryStream memoryStream = ImportUtility.MemoryStreamGenerator(XmlFileName, OldTable, fileLocation, rootAttr);
UserHets[] legacyItems = (UserHets[])ser.Deserialize(memoryStream);
int ii = startPoint;
// skip the portion already processed
if (startPoint > 0)
{
legacyItems = legacyItems.Skip(ii).ToArray();
}
// create an array of names using the created by and modified by values in the data
performContext.WriteLine("Extracting first and last names");
progress.SetValue(0);
Dictionary <string, string> firstNames = new Dictionary <string, string>();
Dictionary <string, string> lastNames = new Dictionary <string, string>();
foreach (UserHets item in legacyItems.WithProgress(progress))
{
string name = item.Created_By;
GetNameParts(name, ref firstNames, ref lastNames);
name = item.Modified_By;
GetNameParts(name, ref firstNames, ref lastNames);
}
// import the data
performContext.WriteLine("Importing User Data");
progress.SetValue(0);
foreach (UserHets item in legacyItems.WithProgress(progress))
{
// see if we have this one already
ImportMap importMap = dbContext.ImportMaps.FirstOrDefault(x => x.OldTable == OldTable && x.OldKey == item.Popt_Id.ToString());
// new entry
if (importMap == null && item.Popt_Id != null)
{
string username = NormalizeUserCode(item.User_Cd);
string firstName = GetNamePart(username, firstNames);
string lastName = GetNamePart(username, lastNames);
username = username.ToLower();
User instance = dbContext.Users.FirstOrDefault(x => x.SmUserId == username);
// if the user exists - move to the next record
if (instance != null)
{
continue;
}
CopyToInstance(dbContext, item, ref instance, systemId, username, firstName, lastName, ref maxUserIndex);
if (instance != null)
{
ImportUtility.AddImportMap(dbContext, OldTable, item.Popt_Id, NewTable, instance.Id);
}
}
}
try
{
performContext.WriteLine("*** Importing " + XmlFileName + " is Done ***");
ImportUtility.AddImportMapForProgress(dbContext, OldTableProgress, BcBidImport.SigId.ToString(), BcBidImport.SigId, NewTable);
dbContext.SaveChangesForImport();
}
catch (Exception e)
{
string temp = string.Format("Error saving data (UserIndex: {0}): {1}", maxUserIndex, e.Message);
performContext.WriteLine(temp);
throw new DataException(temp);
}
}
catch (Exception e)
{
performContext.WriteLine("*** ERROR ***");
performContext.WriteLine(e.ToString());
throw;
}
}
public static void Obfuscate(PerformContext performContext, DbAppContext dbContext, string sourceLocation, string destinationLocation, string systemId)
{
int startPoint = ImportUtility.CheckInterMapForStartPoint(dbContext, "Obfuscate_" + OldTableProgress, BcBidImport.SigId, NewTable);
if (startPoint == BcBidImport.SigId) // this means the import job it has done today is complete for all the records in the xml file.
{
performContext.WriteLine("*** Obfuscating " + XmlFileName + " is complete from the former process ***");
return;
}
try
{
string rootAttr = "ArrayOf" + OldTable;
// create Processer progress indicator
performContext.WriteLine("Processing " + OldTable);
IProgressBar progress = performContext.WriteProgressBar();
progress.SetValue(0);
// create serializer and serialize xml file
XmlSerializer ser = new XmlSerializer(typeof(Project[]), new XmlRootAttribute(rootAttr));
MemoryStream memoryStream = ImportUtility.MemoryStreamGenerator(XmlFileName, OldTable, sourceLocation, rootAttr);
Project[] legacyItems = (Project[])ser.Deserialize(memoryStream);
performContext.WriteLine("Obfuscating Project data");
progress.SetValue(0);
List <ImportMapRecord> importMapRecords = new List <ImportMapRecord>();
foreach (Project item in legacyItems.WithProgress(progress))
{
item.Created_By = systemId;
Random random = new Random();
string newProjectNum = random.Next(10000).ToString();
ImportMapRecord importMapRecordOrganization = new ImportMapRecord
{
TableName = NewTable,
MappedColumn = "Project_Num",
OriginalValue = item.Project_Num,
NewValue = newProjectNum
};
importMapRecords.Add(importMapRecordOrganization);
item.Project_Num = newProjectNum;
item.Job_Desc1 = ImportUtility.ScrambleString(item.Job_Desc1);
item.Job_Desc2 = ImportUtility.ScrambleString(item.Job_Desc2);
}
performContext.WriteLine("Writing " + XmlFileName + " to " + destinationLocation);
// write out the array.
FileStream fs = ImportUtility.GetObfuscationDestination(XmlFileName, destinationLocation);
ser.Serialize(fs, legacyItems);
fs.Close();
// write out the spreadsheet of import records.
ImportUtility.WriteImportRecordsToExcel(destinationLocation, importMapRecords, OldTable);
}
catch (Exception e)
{
performContext.WriteLine("*** ERROR ***");
performContext.WriteLine(e.ToString());
}
}
/// <summary>
/// Import Districts
/// </summary>
/// <param name="performContext"></param>
/// <param name="dbContext"></param>
/// <param name="fileLocation"></param>
/// <param name="systemId"></param>
static public void Import(PerformContext performContext, DbAppContext dbContext, string fileLocation, string systemId)
{
string completed = DateTime.Now.ToString("d") + "-" + "Completed";
ImportMap importMap = dbContext.ImportMaps.FirstOrDefault(x => x.OldTable == oldTable && x.OldKey == completed && x.NewKey == sigId);
if (importMap != null)
{
performContext.WriteLine("*** Importing " + xmlFileName + " is complete from the former process ***");
return;
}
try
{
string rootAttr = "ArrayOf" + oldTable;
performContext.WriteLine("Processing " + oldTable);
var progress = performContext.WriteProgressBar();
progress.SetValue(0);
// create serializer and serialize xml file
XmlSerializer ser = new XmlSerializer(typeof(HETS_District[]), new XmlRootAttribute(rootAttr));
MemoryStream memoryStream = ImportUtility.memoryStreamGenerator(xmlFileName, oldTable, fileLocation, rootAttr);
HETSAPI.Import.HETS_District[] legacyItems = (HETSAPI.Import.HETS_District[])ser.Deserialize(memoryStream);
foreach (var item in legacyItems.WithProgress(progress))
{
// see if we have this one already.
importMap = dbContext.ImportMaps.FirstOrDefault(x => x.OldTable == oldTable && x.OldKey == item.District_Id.ToString());
if (importMap == null) // new entry
{
Models.District dis = null;
CopyToInstance(performContext, dbContext, item, ref dis, systemId);
ImportUtility.AddImportMap(dbContext, oldTable, item.District_Id.ToString(), newTable, dis.Id);
}
else // update
{
Models.District dis = dbContext.Districts.FirstOrDefault(x => x.Id == importMap.NewKey);
if (dis == null) // record was deleted
{
CopyToInstance(performContext, dbContext, item, ref dis, systemId);
// update the import map.
importMap.NewKey = dis.Id;
dbContext.ImportMaps.Update(importMap);
dbContext.SaveChangesForImport();
}
else // ordinary update.
{
CopyToInstance(performContext, dbContext, item, ref dis, systemId);
// touch the import map.
importMap.LastUpdateTimestamp = DateTime.UtcNow;
dbContext.ImportMaps.Update(importMap);
dbContext.SaveChangesForImport();
}
}
}
performContext.WriteLine("*** Done ***");
ImportUtility.AddImportMap(dbContext, oldTable, completed, newTable, sigId);
}
catch (Exception e)
{
performContext.WriteLine("*** ERROR ***");
performContext.WriteLine(e.ToString());
}
}
/// <summary>
/// Import Local Areas
/// </summary>
/// <param name="performContext"></param>
/// <param name="dbContext"></param>
/// <param name="fileLocation"></param>
/// <param name="systemId"></param>
public static void Import(PerformContext performContext, DbAppContext dbContext, string fileLocation, string systemId)
{
// check the start point. If startPoint == sigId then it is already completed
int startPoint = ImportUtility.CheckInterMapForStartPoint(dbContext, OldTableProgress, BCBidImport.SigId);
if (startPoint == BCBidImport.SigId) // this means the import job it has done today is complete for all the records in the xml file.
{
performContext.WriteLine("*** Importing " + XmlFileName + " is complete from the former process ***");
return;
}
try
{
string rootAttr = "ArrayOf" + OldTable;
// create Processer progress indicator
performContext.WriteLine("Processing " + OldTable);
IProgressBar progress = performContext.WriteProgressBar();
progress.SetValue(0);
// create serializer and serialize xml file
XmlSerializer ser = new XmlSerializer(typeof(ImportModels.Area[]), new XmlRootAttribute(rootAttr));
MemoryStream memoryStream = ImportUtility.MemoryStreamGenerator(XmlFileName, OldTable, fileLocation, rootAttr);
ImportModels.Area[] legacyItems = (ImportModels.Area[])ser.Deserialize(memoryStream);
int ii = startPoint;
// skip the portion already processed
if (startPoint > 0)
{
legacyItems = legacyItems.Skip(ii).ToArray();
}
foreach (Area item in legacyItems.WithProgress(progress))
{
LocalArea localArea = null;
// see if we have this one already
ImportMap importMap = dbContext.ImportMaps.FirstOrDefault(x => x.OldTable == OldTable && x.OldKey == item.Area_Id.ToString());
if (dbContext.LocalAreas.Count(x => String.Equals(x.Name, item.Area_Desc.Trim(), StringComparison.CurrentCultureIgnoreCase)) > 0)
{
localArea = dbContext.LocalAreas.FirstOrDefault(x => x.Name.ToUpper() == item.Area_Desc.Trim().ToUpper());
}
// new entry
if (importMap == null || dbContext.LocalAreas.Count(x => String.Equals(x.Name, item.Area_Desc.Trim(), StringComparison.CurrentCultureIgnoreCase)) == 0)
{
if (item.Area_Id > 0)
{
CopyToInstance(dbContext, item, ref localArea, systemId);
ImportUtility.AddImportMap(dbContext, OldTable, item.Area_Id.ToString(), NewTable, localArea.Id);
}
}
else // update
{
localArea = dbContext.LocalAreas.FirstOrDefault(x => x.Id == importMap.NewKey);
// record was deleted
if (localArea == null)
{
CopyToInstance(dbContext, item, ref localArea, systemId);
// update the import map
importMap.NewKey = localArea.Id;
dbContext.ImportMaps.Update(importMap);
}
else // ordinary update
{
CopyToInstance(dbContext, item, ref localArea, systemId);
// touch the import map
importMap.LastUpdateTimestamp = DateTime.UtcNow;
dbContext.ImportMaps.Update(importMap);
}
}
// save change to database periodically to avoid frequent writing to the database
if (++ii % 250 == 0)
{
try
{
ImportUtility.AddImportMapForProgress(dbContext, OldTableProgress, ii.ToString(), BCBidImport.SigId);
dbContext.SaveChangesForImport();
}
catch (Exception e)
{
performContext.WriteLine("Error saving data " + e.Message);
}
}
}
try
{
performContext.WriteLine("*** Importing " + XmlFileName + " is Done ***");
ImportUtility.AddImportMapForProgress(dbContext, OldTableProgress, BCBidImport.SigId.ToString(), BCBidImport.SigId);
dbContext.SaveChangesForImport();
}
catch (Exception e)
{
performContext.WriteLine("Error saving data " + e.Message);
}
}
catch (Exception e)
{
performContext.WriteLine("*** ERROR ***");
performContext.WriteLine(e.ToString());
}
}
/// <summary>
/// Import Rotaion List
/// </summary>
/// <param name="performContext"></param>
/// <param name="dbContext"></param>
/// <param name="fileLocation"></param>
/// <param name="systemId"></param>
public static void Import(PerformContext performContext, DbAppContext dbContext, string fileLocation, string systemId)
{
// check the start point. If startPoint == sigId then it is already completed
int startPoint = ImportUtility.CheckInterMapForStartPoint(dbContext, OldTableProgress, BCBidImport.SigId);
if (startPoint == BCBidImport.SigId) // this means the import job it has done today is complete for all the records in the xml file.
{
performContext.WriteLine("*** Importing " + XmlFileName + " is complete from the former process ***");
return;
}
try
{
string rootAttr = "ArrayOf" + OldTable;
//Create Processer progress indicator
performContext.WriteLine("Processing " + OldTable);
IProgressBar progress = performContext.WriteProgressBar();
progress.SetValue(0);
// create serializer and serialize xml file
XmlSerializer ser = new XmlSerializer(typeof(Block[]), new XmlRootAttribute(rootAttr));
MemoryStream memoryStream = ImportUtility.MemoryStreamGenerator(XmlFileName, OldTable, fileLocation, rootAttr);
Block[] legacyItems = (Block[])ser.Deserialize(memoryStream);
int ii = startPoint;
// skip the portion already processed
if (startPoint > 0)
{
legacyItems = legacyItems.Skip(ii).ToArray();
}
foreach (Block item in legacyItems.WithProgress(progress))
{
int areaId = item.Area_Id ?? 0;
int equipmentTypeId = item.Equip_Type_Id ?? 0;
int blockNum = Convert.ToInt32(float.Parse(item.Block_Num ?? "0.0"));
// this is for conversion record hope this is unique
string oldUniqueId = ((areaId * 10000 + equipmentTypeId) * 100 + blockNum).ToString();
// see if we have this one already
ImportMap importMap = dbContext.ImportMaps.FirstOrDefault(x => x.OldTable == OldTable && x.OldKey == oldUniqueId);
// new entry
if (importMap == null)
{
if (areaId > 0)
{
LocalAreaRotationList instance = null;
CopyToInstance(dbContext, item, ref instance, systemId);
ImportUtility.AddImportMap(dbContext, OldTable, oldUniqueId, NewTable, instance.Id);
}
}
else // update
{
LocalAreaRotationList instance = dbContext.LocalAreaRotationLists.FirstOrDefault(x => x.Id == importMap.NewKey);
// record was deleted
if (instance == null)
{
CopyToInstance(dbContext, item, ref instance, systemId);
// update the import map
importMap.NewKey = instance.Id;
dbContext.ImportMaps.Update(importMap);
}
else // ordinary update
{
CopyToInstance(dbContext, item, ref instance, systemId);
// touch the import map
importMap.LastUpdateTimestamp = DateTime.UtcNow;
dbContext.ImportMaps.Update(importMap);
}
}
// save change to database periodically to avoid frequent writing to the database
if (++ii % 500 == 0)
{
try
{
ImportUtility.AddImportMapForProgress(dbContext, OldTableProgress, ii.ToString(), BCBidImport.SigId);
dbContext.SaveChangesForImport();
}
catch (Exception e)
{
performContext.WriteLine("Error saving data " + e.Message);
}
}
}
try
{
performContext.WriteLine("*** Importing " + XmlFileName + " is Done ***");
ImportUtility.AddImportMapForProgress(dbContext, OldTableProgress, BCBidImport.SigId.ToString(), BCBidImport.SigId);
dbContext.SaveChangesForImport();
}
catch (Exception e)
{
performContext.WriteLine("Error saving data " + e.Message);
}
}
catch (Exception e)
{
performContext.WriteLine("*** ERROR ***");
performContext.WriteLine(e.ToString());
}
}
/// <summary>
/// Import Regions
/// </summary>
/// <param name="performContext"></param>
/// <param name="dbContext"></param>
/// <param name="fileLocation"></param>
/// <param name="systemId"></param>
public static void Import(PerformContext performContext, DbAppContext dbContext, string fileLocation, string systemId)
{
// check the start point. If startPoint == sigId then it is already completed
string completed = DateTime.Now.ToString("d") + "-" + "Completed";
ImportMap importMap = dbContext.ImportMaps.FirstOrDefault(x => x.OldTable == OldTable && x.OldKey == completed && x.NewKey == SigId);
if (importMap != null)
{
performContext.WriteLine("*** Importing " + XmlFileName + " is complete from the former process ***");
return;
}
try
{
string rootAttr = "ArrayOf" + OldTable;
performContext.WriteLine("Processing " + OldTable);
IProgressBar progress = performContext.WriteProgressBar();
progress.SetValue(0);
// create serializer and serialize xml file
XmlSerializer ser = new XmlSerializer(typeof(HetsRegion[]), new XmlRootAttribute(rootAttr));
MemoryStream memoryStream = ImportUtility.MemoryStreamGenerator(XmlFileName, OldTable, fileLocation, rootAttr);
HetsRegion[] legacyItems = (HetsRegion[])ser.Deserialize(memoryStream);
foreach (var item in legacyItems.WithProgress(progress))
{
// see if we have this one already
Region reg = null;
importMap = dbContext.ImportMaps.FirstOrDefault(x => x.OldTable == OldTable && x.OldKey == item.Region_Id.ToString());
if (dbContext.LocalAreas.Count(x => String.Equals(x.Name, item.Name.Trim(), StringComparison.CurrentCultureIgnoreCase)) > 0)
{
reg = dbContext.Regions.FirstOrDefault(x => String.Equals(x.Name, item.Name.Trim(), StringComparison.CurrentCultureIgnoreCase));
}
// new entry
if (importMap == null && reg == null)
{
CopyToInstance(performContext, dbContext, item, ref reg, systemId);
ImportUtility.AddImportMap(dbContext, OldTable, item.Region_Id.ToString(), NewTable, reg.Id);
}
else // update
{
// record was deleted
if (reg == null)
{
CopyToInstance(performContext, dbContext, item, ref reg, systemId);
// update the import map
importMap.NewKey = reg.Id;
dbContext.ImportMaps.Update(importMap);
dbContext.SaveChangesForImport();
}
else // ordinary update.
{
CopyToInstance(performContext, dbContext, item, ref reg, systemId);
// touch the import map
if (importMap != null)
{
importMap.LastUpdateTimestamp = DateTime.UtcNow;
dbContext.ImportMaps.Update(importMap);
}
dbContext.SaveChangesForImport();
}
}
}
performContext.WriteLine("*** Importing " + XmlFileName + " is Done ***");
ImportUtility.AddImportMap(dbContext, OldTable, completed, NewTable, SigId);
}
catch (Exception e)
{
performContext.WriteLine("*** ERROR ***");
performContext.WriteLine(e.ToString());
}
}
/// <summary>
/// Map data
/// </summary>
/// <param name="dbContext"></param>
/// <param name="oldObject"></param>
/// <param name="project"></param>
/// <param name="systemId"></param>
/// <param name="maxProjectIndex"></param>
private static void CopyToInstance(DbAppContext dbContext, Project oldObject, ref Models.Project project,
string systemId, ref int maxProjectIndex)
{
try
{
if (project != null)
{
return;
}
project = new Models.Project {
Id = ++maxProjectIndex
};
// ***********************************************
// set project properties
// ***********************************************
string tempProjectNumber = ImportUtility.CleanString(oldObject.Project_Num).ToUpper();
if (!string.IsNullOrEmpty(tempProjectNumber))
{
project.ProvincialProjectNumber = tempProjectNumber;
}
// project name
string tempName = ImportUtility.CleanString(oldObject.Job_Desc1).ToUpper();
if (!string.IsNullOrEmpty(tempName))
{
tempName = ImportUtility.GetCapitalCase(tempName);
project.Name = tempName;
}
// project information
string tempInformation = ImportUtility.CleanString(oldObject.Job_Desc2);
if (!string.IsNullOrEmpty(tempInformation))
{
tempInformation = ImportUtility.GetUppercaseFirst(tempInformation);
project.Information = tempInformation;
}
// ***********************************************
// set service area for the project
// ***********************************************
ServiceArea serviceArea = dbContext.ServiceAreas.AsNoTracking()
.Include(x => x.District)
.FirstOrDefault(x => x.MinistryServiceAreaID == oldObject.Service_Area_Id);
if (serviceArea == null)
{
throw new DataException(string.Format("Service Area cannot be null (ProjectIndex: {0}", maxProjectIndex));
}
int tempDistrictId = serviceArea.District.Id;
project.DistrictId = tempDistrictId;
// ***********************************************
// default the project to Active
// ***********************************************
project.Status = "Active";
// ***********************************************
// create project
// ***********************************************
project.AppCreateUserid = systemId;
project.AppCreateTimestamp = DateTime.UtcNow;
project.AppLastUpdateUserid = systemId;
project.AppLastUpdateTimestamp = DateTime.UtcNow;
dbContext.Projects.Add(project);
}
catch (Exception ex)
{
Debug.WriteLine("***Error*** - Project Name: " + oldObject.Job_Desc1);
Debug.WriteLine("***Error*** - Master project Index: " + maxProjectIndex);
Debug.WriteLine(ex.Message);
throw;
}
}
