public async Task <IAdminObject> DeserializeToAdminObjectAsync(String metaData)
{
if (metaData == null)
{
throw new ArgumentException(nameof(metaData));
}
try
{
return(await Task.Run(() =>
{
IAdminObject adminObject = JsonConvert.DeserializeObject <IAdminObject>(
value: metaData,
settings: new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.Objects,
ObjectCreationHandling = ObjectCreationHandling.Replace
}
);
return adminObject;
}));
}
catch (Exception ex)
{
throw new AdminMigrationUtilityException(Constant.ErrorMessages.AdminObjectDeSerializationError, ex);
}
}
private async Task ValidateColumnsAsync(IAdminObject migrationObject, IParser parser, List <ImportJobError> violations)
{
if (migrationObject != null && parser != null)
{
var missingColumns = new List <String>();
var requiredColumns = (await migrationObject.GetColumnsAsync()).Select(x => x.ColumnName).ToList();
var loadFileColumns = parser.ParseColumns();
foreach (var requiredColumn in requiredColumns)
{
if (!loadFileColumns.Contains(requiredColumn))
{
missingColumns.Add(requiredColumn);
}
}
if (missingColumns.Any())
{
var formattedMissingColumnList = String.Join(Constant.CommaSeparator, missingColumns);
violations.Add(new ImportJobError()
{
Message = String.Format(Constant.ErrorMessages.MissingColumnsError, formattedMissingColumnList), LineNumber = null, Type = Constant.ImportUtilityJob.ErrorType.FileLevel
});
}
}
}
public static string MoveToItemImageFolder(IAdminObject item, string origionalFilePath)
{
string filePath = new FileInfo(item.ObjectId).Directory.FullName + Settings.VehicleImageFolder + "\\";
if (!Directory.Exists(filePath))
Directory.CreateDirectory(filePath);
string[] allImages = Directory.GetFiles(filePath);
int fileNumber = 0;
foreach (string image in allImages)
{
int num;
FileInfo file = new FileInfo(image);
int.TryParse(file.Name.Replace(file.Extension, ""), out num);
if (num > fileNumber)
fileNumber = num;
}
fileNumber++;
filePath = filePath + fileNumber + new FileInfo(origionalFilePath).Extension;
File.Copy(origionalFilePath, filePath);
return filePath;
}
public void LoadPanel(IAdminObject item)
{
_item = item;
ThumbNailWrapPanel.Children.Clear();
if (item == null)
{
LoadDefaultImage();
return;
}
_images = item.GetMultiValue(PropertyId);
if (_images == null || _images.Count == 0)
{
LoadDefaultImage();
return;
}
try
{
LoadVehicleImageLarge(_images[imageLoadIndex][Settings.MultiValueValueIndex]);
LoadVehicleThumbNails();
}
catch {}
imageTimer.Start();
}
public void LoadPanel(IAdminObject item)
{
_vehicle = item as VehicleAdminObject;
if (_vehicle == null)
return;
VehicleListView.LoadPanel(_vehicle);
}
private String GenerateMetaDataForAdminObject(IAdminObject adminObject)
{
var serializedJson = JsonConvert.SerializeObject(adminObject, Formatting.None, new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.Objects,
TypeNameAssemblyFormat = System.Runtime.Serialization.Formatters.FormatterAssemblyStyle.Simple
});
return(serializedJson);
}
public virtual void LoadPanel(IAdminObject item)
{
if (item == null)
{
Content = String.Empty;
}
else
{
Content = item.GetValue(PropertyId);
}
}
private void NodesTreeView_AfterSelect(object sender, TreeViewEventArgs treeViewArgs)
{
IAdminObject adminObject = treeViewArgs.Node.Tag as IAdminObject;
if (null == adminObject)
{
MessageBox.Show("Admin node was incorrectly initialized");
}
else
{
viewPanel.Controls.Clear();
adminObject.Show(viewPanel);
}
}
public void LoadPanel(IAdminObject item)
{
_item = item;
if (item == null)
{
Text = String.Empty;
}
else
{
Text = item.GetValue(PropertyId);
if (Text == string.Empty || Text == "")
this.MinWidth = UISettings.ADMINTEXTBOX_MINSIZE_WHEN_NO_TEXT;
}
}
public void LoadPanel(IAdminObject item)
{
_item = item;
//if (item == null || item.GetValue(PropertyId) == null)
//{
// SelectedDate = DateTime.Today;
//}
//else
//{
string date = item.GetValue(PropertyId);
if (!string.IsNullOrEmpty(date))
SelectedDate = DateTime.Parse(date);
//}
}
public void LoadAllChildren(Panel panel, IAdminObject item)
{
foreach (var child in panel.Children)
{
IPropertyPanel propPanel = child as IPropertyPanel;
if (propPanel != null)
{
propPanel.LoadPanel(item);
}
Panel isPanel = child as Panel;
if (isPanel != null)
LoadAllChildren(isPanel, item);
}
}
public void UpdateAllViews()
{
foreach (TreeNode treeNode in nodesTreeView.Nodes)
{
IAdminObject adminObject = ( IAdminObject )treeNode.Tag;
try
{
adminObject.Show(viewPanel);
}
catch (Exception e)
{
MessageBox.Show(string.Format("There was an exception updating: {0}\n\n{1}", adminObject.GetNodeText(), e.ToString()));
}
}
}
public void LoadPanel(IAdminObject item)
{
loadingPanel = true;
this.Items.Clear();
_item = item;
VehicleAdminObject vehicle = item as VehicleAdminObject;
if (vehicle == null)
return;
foreach (VehicleTask task in vehicle.VehicleTasks)
{
this.Items.Add(task);
}
loadingPanel = false;
}
private async Task <IAdminObject> GetMigrationObject(String objectType, List <ImportJobError> violations)
{
IAdminObject migrationObject = null;
try
{
migrationObject = await Utility.GetImportObjectSelectionAsync(objectType);
}
catch (Exception ex)
{
var error = new ImportJobError()
{
Message = ex.Message, Type = Constant.ImportUtilityJob.ErrorType.JobLevel, Details = ex.ToString(), LineNumber = null
};
violations.Add(error);
}
return(migrationObject);
}
private async Task ValidateFileDoesNotContainExtraColumnsAsync(IAdminObject migrationObject, IParser parser, String migrationObjectType, List <ImportJobError> violations)
{
if (migrationObject != null && parser != null)
{
var requiredColumns = (await migrationObject.GetColumnsAsync()).Select(x => x.ColumnName).ToList();
var loadFileColumns = parser.ParseColumns();
var extraColumns = loadFileColumns.Except(requiredColumns);
if (extraColumns.Any())
{
var formattedExtraColumnList = String.Join(Constant.CommaSeparator, extraColumns);
violations.Add(new ImportJobError()
{
Message = String.Format(Constant.ErrorMessages.ExtraColumnsError, migrationObjectType, formattedExtraColumnList), LineNumber = null, Type = Constant.ImportUtilityJob.ErrorType.FileLevel
});
}
}
}
public async Task WriteColumnHeadersToExportFileAsync(FileInfo tempFileInfo, String objectTypeEnum)
{
try
{
using (StreamWriter streamWriter = tempFileInfo.AppendText()) //creates file if it does not already exists
{
IAdminObject migrationObject = await Utility.GetImportObjectSelectionAsync(objectTypeEnum);
String[] headers = (await migrationObject.GetColumnsAsync()).Select(x => x.ColumnName).ToArray();
String csvFormattedColumns = await Utility.FormatCsvLineAsync(headers);
//write header
await streamWriter.WriteLineAsync(csvFormattedColumns);
}
}
catch (Exception ex)
{
throw new AdminMigrationUtilityException(Constant.ErrorMessages.WritingColumnHeadersToExportFileError, ex);
}
}
public async Task <Int32> InsertExportWorkerResultTableUserRecordsIntoExportFileInBatchesAsync(ExportManagerQueueRecord exportManagerQueueRecord, FileInfo tempFileInfo)
{
try
{
Int32 actualNumberOfExports = 0;
//query for records in the results table in batches
List <ExportWorkerResultsTableRecord> exportWorkerResultsTableRecords = await QueryBatchFromExportResultsTableAsync(exportManagerQueueRecord);
do
{
foreach (ExportWorkerResultsTableRecord currentExportWorkerResultsTableRecord in exportWorkerResultsTableRecords)
{
IAdminObject migrationObject = await SerializationHelper.DeserializeToAdminObjectAsync(currentExportWorkerResultsTableRecord.MetaData);
using (StreamWriter streamWriter = tempFileInfo.AppendText()) //creates file if it does not already exists
{
String[] orderedCells = (await migrationObject.ExportAsync()).ToArray();
String csvFormatedCells = await Utility.FormatCsvLineAsync(orderedCells);
await streamWriter.WriteLineAsync(csvFormatedCells);
actualNumberOfExports++;
}
}
//delete processed records from export results table
await DeleteProcessedRecordsFromExportResultsTableAsync(exportManagerQueueRecord, exportWorkerResultsTableRecords);
//query for records in the results table in batches
exportWorkerResultsTableRecords = await QueryBatchFromExportResultsTableAsync(exportManagerQueueRecord);
} while (exportWorkerResultsTableRecords.Count > 0);
return(actualNumberOfExports);
}
catch (Exception ex)
{
throw new AdminMigrationUtilityException(Constant.ErrorMessages.WritingResultRecordsToExportFileError, ex);
}
}
public async Task <String> SerializeAdminObjectAsync(IAdminObject adminObject)
{
try
{
return(await Task.Run(() =>
{
String userMetadata = JsonConvert.SerializeObject(
value: adminObject,
formatting: Formatting.None,
settings: new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.Objects,
TypeNameAssemblyFormat = System.Runtime.Serialization.Formatters.FormatterAssemblyStyle.Simple
}
);
return userMetadata;
}));
}
catch (Exception ex)
{
throw new AdminMigrationUtilityException(Constant.ErrorMessages.AdminObjectSerializationError, ex);
}
}
public void LoadPanel(IAdminObject item)
{
_vehicle = item as VehicleAdminObject;
ClearFormState();
LoadAllChildren(PurchaseInfoGrid, item);
addtionalContentControl.ListChanged += addtionalContentControl_ListChanged;
string foundVendor = _vehicle.GetValue(PropertyId.Vendor);
WellKnownVendors vehicleVendor = WellKnownVendors.Adesa;
bool foundVehicleVendor = false;
if (!string.IsNullOrEmpty(foundVendor))
{
foundVehicleVendor = true;
vehicleVendor = (WellKnownVendors)Enum.Parse(typeof(WellKnownVendors), foundVendor, true);
}
int foundIndex = -1;
cmbVendor.Items.Add("");
foreach (WellKnownVendors vendor in (WellKnownVendors[])Enum.GetValues(typeof(WellKnownVendors)))
{
cmbVendor.Items.Add(vendor.ToString());
if (foundVehicleVendor && vendor == vehicleVendor)
{
foundIndex = cmbVendor.Items.Count - 1;
}
}
if (foundIndex != -1)
{
cmbVendor.SelectedIndex = foundIndex;
}
CalculateTasksCost();
}
public async Task ProcessRecordsAsync(IHelper helper, IDBContext eddsDbContext, IRsapiRepositoryGroup repositoryGroup, ISqlQueryHelper sqlQueryHelper, ImportWorkerQueueRecord record, List <ImportJobError> errors)
{
var currentRecordErrors = new List <ImportJobError>();
IAdminObject migrationObject = null;
try
{
migrationObject = await _serializationHelper.DeserializeToAdminObjectAsync(record.MetaData);
}
catch (Exception ex)
{
var serializationError = new ImportJobError()
{
Message = Constant.ErrorMessages.GeneralDeSerializationError, Details = ex.ToString(), Type = Constant.ImportUtilityJob.ErrorType.DataLevel, LineNumber = record.ImportRowID
};
currentRecordErrors.Add(serializationError);
}
if (migrationObject != null && !currentRecordErrors.Any())
{
var violations = new List <String>();
violations.AddRange(await migrationObject.ValidateAsync(_apiOptions, repositoryGroup, _artifactQueryHelper, eddsDbContext, sqlQueryHelper));
if (record.JobType == Constant.ImportUtilityJob.JobType.VALIDATE_SUBMIT && !violations.Any())
{
violations.AddRange(await migrationObject.ImportAsync(_apiOptions, repositoryGroup, _artifactQueryHelper, helper, eddsDbContext, sqlQueryHelper));
}
currentRecordErrors.AddRange(
violations.Select(x => new ImportJobError()
{
Message = x, Type = Constant.ImportUtilityJob.ErrorType.DataLevel, LineNumber = record.ImportRowID
})
);
}
errors.AddRange(currentRecordErrors);
}
/*
public VehicleInfoWindow(VehicleAdminObject vehicle): this(vehicle, VehicleInfoWindowTabs.Default)
{
}
*/
public void LoadPanel(IAdminObject item)
{
foreach (IPropertyPanel propertyPanel in propertyPanels)
{
propertyPanel.LoadPanel(item);
}
}
public void LoadPanel(IAdminObject item)
{
if (item == null)
{
PropertyLabel.Content = String.Empty;
}
else
{
PropertyLabel.Content = PropertyId;
}
PropertyValueTextBox.LoadPanel(item);
}
public void LoadPanel(IAdminObject item)
{
_vehicle = null;
TxtCustomerId.Text = "";
_vehicle = item as VehicleAdminObject;
ClearFormState();
LoadAllChildren(SaleInfoGrid, item);
LoadAllChildren(WarrantyGrid, item);
LoadAllChildren(TradeInGrid, item);
addtionalContentControl.ListChanged += addtionalContentControl_ListChanged;
LoadComboBoxes();
if (!CacheManager.ActiveUser.Permissions.Contains(UserAdminObject.PermissionTypes.UpdateSaleTaxPercentage))
{
txtSalesTaxPercentage.Visibility = Visibility.Hidden;
}
if (string.IsNullOrEmpty(txtSalesTaxPercentage.Text))
{
txtSalesTaxPercentage.Text = Settings.HST.ToString(CultureInfo.InvariantCulture);
}
}
public void LoadPanel(IAdminObject item)
{
CustomerInfoControl.LoadPanel(item);
ApplyActiveUserPermissions();
}
public void LoadPanel(IAdminObject item)
{
var customer = item as CustomerAdminObject;
if (customer == null)
{
return;
}
_customer = customer;
LoadAllChildren(ContactCardGrid, item);
addtionalContentControl.ListChanged += addtionalContentControl_ListChanged;
Dictionary<VehicleCacheSearchKey, string> searchParam = new Dictionary<VehicleCacheSearchKey, string>();
searchParam.Add(VehicleCacheSearchKey.CustomerId, item.GetValue(PropertyId.Id));
VehicleCache cache = new VehicleCache(Settings.VehiclePath, searchParam);
LstCustomerVehicles.SetContent(cache);
}
public void LoadPanel(IAdminObject item)
{
files.Clear();
FileList.Items.Clear();
_item = item;
List<string[]> items = _item.GetMultiValue(PropertyId);
if (items == null)
{
return;
}
foreach (string[] file in items)
{
files.Add(file);
FileList.Items.Add(file[Settings.MultiValueValueIndex]);
}
}
public void LoadPanel(IAdminObject item)
{
throw new NotImplementedException();
}
public override bool Equals(IAdminObject item)
{
CustomerAdminObject customer = item as CustomerAdminObject;
if (customer == null)
return false;
//Tasks, Images, Basic Info
if (_vehicleIds.Select(vehicleId => customer.VehicleIds.Any(otherImg => otherImg[0] == vehicleId[0])).Any(subListFound => !subListFound))
{
return false;
}
// AdditionalFiles
List<string[]> customerFiles = customer.AssociatedFiles.ToList();
foreach (string[] file in _associatedFiles)
{
bool found = false;
foreach (string[] otherCustomerFile in customerFiles)
{
if (otherCustomerFile[Settings.MultiValueValueIndex] == file[Settings.MultiValueValueIndex])
{
found = true;
customerFiles.Remove(otherCustomerFile);
break;
}
}
if (!found)
{
return false;
}
}
if (customerFiles.Count > 0)
{
return false;
}
foreach (var info in _basicInfo)
{
if (!customer.BasicInfo.ContainsKey(info.Key))
return false;
if (!customer.BasicInfo[info.Key].Equals(info.Value))
return false;
}
return true;
}
public override bool Equals(IAdminObject item)
{
VehicleAdminObject vehicle = item as VehicleAdminObject;
if (vehicle == null)
return false;
//Tasks, Images, Basic Info
/* foreach (var vehicleTask in VehicleTasks)
{
bool found = false;
for (int i = 0; i < vehicle.VehicleTasks.Count; i++)
{
if (vehicleTask.Equals(vehicle.VehicleTasks[i]))
{
found = true;
vehicle.VehicleTasks.RemoveAt(i);
break;
}
}
if (!found)
{
return false;
}
}*/
if (VehicleTasks.Any(vehicleTask => !vehicle.VehicleTasks.Contains(vehicleTask)))
{
return false;
}
// images
bool same = ListsAreEqual(_images, vehicle.Images.ToList());
if (!same)
{
return false;
}
// PurchaseAssociatedFiles
same = ListsAreEqual(_purchaseAssociatedFiles, vehicle.PurchaseAssociatedFiles.ToList());
if (!same)
{
return false;
}
// SaleAssociatedFiles
same = ListsAreEqual(_saleAssociatedFiles, vehicle.SaleAssociatedFiles.ToList());
if (!same)
{
return false;
}
// basic info
foreach (var info in _basicInfo)
{
if (!vehicle.BasicInfo.ContainsKey(info.Key))
return false;
if (!vehicle.BasicInfo[info.Key].Equals(info.Value))
return false;
}
return true;
#region PreLinq
// VehicleAdminObject vehicle = item as VehicleAdminObject;
//if (vehicle == null)
// return false;
////Tasks, Images, Basic Info
//foreach (var vehicleTask in VehicleTasks)
//{
// if (!vehicle.VehicleTasks.Contains(vehicleTask))
// return false;
//}
//foreach (var image in _images)
//{
// bool subListFound = false;
// foreach (var otherImg in vehicle.Images)
// {
// if (otherImg[0] == image[0])
// {
// subListFound = true;
// break;
// }
// }
// if (subListFound)
// {
// continue;
// }
// return false;
//}
//foreach (var info in _basicInfo)
//{
// if (!vehicle.BasicInfo.ContainsKey(info.Key))
// return false;
// if (!vehicle.BasicInfo[info.Key].Equals(info.Value))
// return false;
//}
//return true;
#endregion
}
public void LoadPanel(IAdminObject item)
{
_item = item;
}
public void LoadPanel(IAdminObject item)
{
_item = item;
LoadBasicIds(item);
LoadAllChildren(BasicVehicleInfo, item);
}
private void LoadBasicIds(IAdminObject item)
{
for (int i = 0; i < basicIds.Count(); i++) // PropertyId propertyId in basicIds)
{
PropertyId propertyId = basicIds[i];
AdminLabelTextbox labelItem = new AdminLabelTextbox();
labelItem.PropertyId = propertyId;
labelItem.SetMinGapSize = UISettings.ADMINLABELTEXTBOX_GAPSIZE;
RowDefinition rowDefinition = new RowDefinition();
rowDefinition.Height = GridLength.Auto;
BasicIdsGrid.RowDefinitions.Add(rowDefinition);
Grid.SetRow(labelItem, i);
bool alreadyExists = BasicIdsGrid.Children.Cast<AdminLabelTextbox>().Any(textbox => textbox.PropertyId == propertyId);
if (!alreadyExists)
BasicIdsGrid.Children.Add(labelItem);
}
}
private async Task <Int32> PopulateWorkerQueueAsync(ImportManagerQueueRecord managerQueueRecord, IParser parser, IAdminObject migrationObject, List <ImportJobError> violations)
{
var loadFileColumns = parser.ParseColumns();
var workerQueue = new Dictionary <long, String>();
Int32 lineNumber = LongToInt(parser.LineNumber);
var timeOfInsert = DateTime.UtcNow;
try
{
while (parser.Read())
{
try
{
var adminObjectDictionary = new Dictionary <String, String>();
foreach (var column in loadFileColumns)
{
var value = parser[column] == null ? String.Empty : parser[column].ToString();
adminObjectDictionary.Add(column, value);
}
await migrationObject.MapObjectColumnsAsync(adminObjectDictionary);
var serializedJson = await _serializationHelper.SerializeAdminObjectAsync(migrationObject);
workerQueue.Add(lineNumber, serializedJson);
}
catch (Exception ex)
{
violations.Add(new ImportJobError()
{
Message = String.Format(Constant.ErrorMessages.ImportQueueManagerLineNumberError, lineNumber, ex.Message), LineNumber = lineNumber >= Int32.MaxValue ? null : (Int32?)lineNumber, Type = Constant.ImportUtilityJob.ErrorType.DataLevel, Details = ex.ToString()
});
}
if ((workerQueue.Count % Constant.BatchSizes.ImportManagerIntoWorkerQueue) == 0)
{
await WriteQueueRecordsAsync(managerQueueRecord, workerQueue, violations, timeOfInsert);
workerQueue.Clear();
}
//The parser returns the current line from the Read above and advances the cursor to the next line. We want our logs should report the current line number of data values so linenumber should be updated last.
//parser.LineNumber is -1 when the parser get to the end of the file and we don't want to report that value
if (parser.LineNumber != -1)
{
lineNumber = LongToInt(parser.LineNumber);
}
}
if (workerQueue.Any())
{
await WriteQueueRecordsAsync(managerQueueRecord, workerQueue, violations, timeOfInsert);
}
return((lineNumber - 1) < 0 ? 0 : lineNumber - 1); //minus 1 because the header row should not be counted
}
catch (Exception ex)
{
// This is thrown instead of being recorded in the violation list because parser errors indicate load file issues, the user should updated the file before attempting the job again
throw new AdminMigrationUtilityException(String.Format(Constant.ErrorMessages.UnableToParseLineNumberError, lineNumber), ex);
}
}
