public void AddVariables(List<VariablesModel> itemList, string entityConnectionString, string instanceIdentifier, out List<VariablesModel> listOfIncorrectRecords, out List<VariablesModel> listOfCorrectRecords, out List<VariablesModel> listOfDuplicateRecords, out List<VariablesModel> listOfEditedRecords)
{
listOfIncorrectRecords = new List<VariablesModel>();
listOfCorrectRecords = new List<VariablesModel>();
listOfDuplicateRecords = new List<VariablesModel>();
listOfEditedRecords = new List<VariablesModel>();
//var errorModel = new ErrorModel();
var context = new ODM_1_1_1EFModel.ODM_1_1_1Entities(entityConnectionString);
var objContext = ((IObjectContextAdapter)context).ObjectContext;
//read CV in to list for fster searching
var variableCV = context.VariableNameCVs.ToList();
var speciationCV = context.SpeciationCVs.ToList();
var units = context.Units.Distinct().ToDictionary(p => p.UnitsName.Trim(), p => p.UnitsID);
var sampleMediumCV = context.SampleMediumCVs.ToList();
var valueTypeCV = context.ValueTypeCVs.ToList();
var dataTypeCV = context.DataTypeCVs.ToList();
var generalCategoryCV = context.GeneralCategoryCVs.ToList();
//get all variables
var variablesInDatabase = context.Variables.Select(p => p.VariableCode.ToLower()).ToList();
var maxCount = itemList.Count;
var count = 0;
BusinessObjectsUtils.UpdateCachedprocessStatusMessage(instanceIdentifier, CacheName, String.Format(Ressources.IMPORT_STATUS_PROCESSING, count, maxCount));
foreach (var item in itemList)
{
try
{
BusinessObjectsUtils.UpdateCachedprocessStatusMessage(instanceIdentifier, CacheName, String.Format(Ressources.IMPORT_STATUS_PROCESSING, count, maxCount));
count++;
//var model = Mapper.Map<VariablesModel, Variable>(item);
var model = new Variable();
//set deafults
model.Speciation = "Not Applicable";
model.SampleMedium = "Unknown";
model.ValueType = "Unknown";
model.IsRegular = false;
model.TimeSupport = 0;
model.TimeUnitsID = 103;
model.DataType = "Unknown";
model.GeneralCategory = "Unknown";
model.NoDataValue = -9999;
var listOfErrors = new List<ErrorModel>();
var listOfUpdates = new List<UpdateFieldsModel>();
//need to look up Id's for VariableName, Speciation, VariableUnitsName, SampleMedium, ValueType, DataType, GeneralCategory, TimeUnitsName
//User has no concept of ID's
bool isRejected = false;
//VariableCode
if (!string.IsNullOrWhiteSpace(item.VariableCode))
{
if (RepositoryUtils.containsNotOnlyAllowedCaracters(item.VariableCode))
{
var err = new ErrorModel("AddVariables", string.Format(Ressources.IMPORT_VALUE_INVALIDCHARACTERS, "VariableCode")); listOfErrors.Add(err); isRejected = true;
}
else
{
model.VariableCode = item.VariableCode;
}
}
else
{
var err = new ErrorModel("AddVariables", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "VariableCode")); listOfErrors.Add(err); isRejected = true;
}
//VariableName
if (!string.IsNullOrWhiteSpace(item.VariableName))
{
var variableName = variableCV
.Where(a => a.Term.ToString().ToLower() == item.VariableName.ToLower()).SingleOrDefault();
if (variableName == null)
{
var err = new ErrorModel("AddVariables", string.Format(Ressources.IMPORT_VALUE_NOT_IN_CV, item.VariableName, "variableName"));
listOfErrors.Add(err);
isRejected = true;
}
else
{
model.VariableName = variableName.Term;
}
}
else
{
var err = new ErrorModel("AddVariables", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "VariableName")); listOfErrors.Add(err); isRejected = true;
}
//Speciation
if (!string.IsNullOrWhiteSpace(item.Speciation))
{
var speciation = speciationCV
.Where(a => a.Term.ToString().ToLower() == item.Speciation.ToLower()).SingleOrDefault();
if (speciation == null)
{
var err = new ErrorModel("AddVariables", string.Format(Ressources.IMPORT_VALUE_NOT_IN_CV, item.Speciation, "Speciation"));
listOfErrors.Add(err);
isRejected = true;
}
else
{
model.Speciation = item.Speciation;
}
}
else
{
var err = new ErrorModel("AddVariables", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "Speciation")); listOfErrors.Add(err); isRejected = true;
}
//VariableUnitsName
if (!string.IsNullOrWhiteSpace(item.VariableUnitsName))
{
if (RepositoryUtils.containsSpecialCharacters(item.VariableUnitsName))
{
var err = new ErrorModel("AddVariables", string.Format(Ressources.IMPORT_VALUE_INVALIDCHARACTERS, "VariableUnitsName")); listOfErrors.Add(err); isRejected = true;
}
else
{
int result;
bool canConvert = UniversalTypeConverter.TryConvertTo<int>(item.VariableUnitsName, out result);
if (canConvert)//user used id
{
if (result != 0)
{
model.VariableUnitsID = result;
item.VariableUnitsID = result.ToString();
}
else
{
var err = new ErrorModel("AddVariables", string.Format(Ressources.IMPORT_VALUE_INVALIDVALUE, "VariableUnitsName")); listOfErrors.Add(err); isRejected = true;
}
}
else
{
var variableUnitsID = units
.Where(a => a.Key.ToLower() == item.VariableUnitsName.ToLower())
.Select(a => a.Value)
.SingleOrDefault();
if (variableUnitsID != 0)
{
model.VariableUnitsID = variableUnitsID;
item.VariableUnitsID = variableUnitsID.ToString();
}
else
{
var err = new ErrorModel("AddVariables", string.Format(Ressources.IMPORT_VALUE_INVALIDVALUE, "VariableUnitsName")); listOfErrors.Add(err); isRejected = true;
}
}
}
}
else
{
var err = new ErrorModel("AddVariables", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "VariableUnitsName")); listOfErrors.Add(err); isRejected = true;
}
//SampleMedium
if (!string.IsNullOrWhiteSpace(item.SampleMedium))
{
var sampleMedium = sampleMediumCV
.Where(a => a.Term.ToString().ToLower() == item.SampleMedium.ToLower()).FirstOrDefault();
if (sampleMedium == null)
{
var err = new ErrorModel("AddVariables", string.Format(Ressources.IMPORT_VALUE_NOT_IN_CV, item.SampleMedium, "SampleMedium"));
listOfErrors.Add(err);
isRejected = true;
}
else
{
model.SampleMedium = sampleMedium.Term;
}
}
else
{
var err = new ErrorModel("AddVariables", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "SampleMedium")); listOfErrors.Add(err); isRejected = true;
}
//ValueType
if (!string.IsNullOrWhiteSpace(item.ValueType))
{
var valueType = valueTypeCV
.Where(a => a.Term.ToString().ToLower() == item.ValueType.ToLower()).FirstOrDefault();
if (valueType == null)
{
var err = new ErrorModel("AddVariables", string.Format(Ressources.IMPORT_VALUE_NOT_IN_CV, item.ValueType, "ValueType"));
listOfErrors.Add(err);
isRejected = true;
}
else
{
model.ValueType = valueType.Term;
}
}
else
{
var err = new ErrorModel("AddVariables", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "ValueType")); listOfErrors.Add(err); isRejected = true;
}
//IsRegular
if (!string.IsNullOrWhiteSpace(item.IsRegular))
{
bool result;
bool canConvert = UniversalTypeConverter.TryConvertTo<bool>(item.IsRegular, out result);
if (!canConvert)
{
var err = new ErrorModel("AddVariables", string.Format(Ressources.IMPORT_VALUE_NOT_IN_CV, item.IsRegular, "IsRegular"));
listOfErrors.Add(err);
isRejected = true;
}
else
{
model.IsRegular = result;
}
}
else
{
var err = new ErrorModel("AddVariables", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "IsRegular")); listOfErrors.Add(err); isRejected = true;
}
//TimeSupport
if (!string.IsNullOrWhiteSpace(item.TimeSupport))
{
double result;
bool canConvert = UniversalTypeConverter.TryConvertTo<double>(item.TimeSupport, out result);
if (!canConvert)
{
var err = new ErrorModel("AddVariables", string.Format(Ressources.IMPORT_VALUE_NOT_IN_CV, item.TimeSupport, "TimeSupport"));
listOfErrors.Add(err);
isRejected = true;
}
else
{
model.TimeSupport = result;
}
}
else
{
var err = new ErrorModel("AddVariables", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "TimeSupport")); listOfErrors.Add(err); isRejected = true;
}
//TimeUnitsID
if (!string.IsNullOrWhiteSpace(item.TimeUnitsName))
{
if (RepositoryUtils.containsSpecialCharacters(item.TimeUnitsName))
{
var err = new ErrorModel("AddVariables", string.Format(Ressources.IMPORT_VALUE_INVALIDCHARACTERS, "TimeUnitsName")); listOfErrors.Add(err); isRejected = true;
}
else
{
int result;
bool canConvert = UniversalTypeConverter.TryConvertTo<int>(item.TimeUnitsName, out result);
if (canConvert)//user used id
{
if (result != 0)
{
model.TimeUnitsID = result;
item.TimeUnitsID = result.ToString();
}
else
{
var err = new ErrorModel("AddVariables", string.Format(Ressources.IMPORT_VALUE_INVALIDVALUE, "TimeUnitsName")); listOfErrors.Add(err); isRejected = true;
}
}
else
{
var timeUnitsID = units
.Where(a => a.Key.ToLower() == item.TimeUnitsName.ToLower())
.Select(a => a.Value)
.SingleOrDefault();
if (timeUnitsID != 0)
{
model.TimeUnitsID = timeUnitsID;
item.TimeUnitsID = timeUnitsID.ToString();
}
else
{
var err = new ErrorModel("AddVariables", string.Format(Ressources.IMPORT_VALUE_INVALIDVALUE, "TimeUnitsName")); listOfErrors.Add(err); isRejected = true;
}
}
}
}
else
{
var err = new ErrorModel("AddVariables", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "TimeUnitsName")); listOfErrors.Add(err); isRejected = true;
}
//DataType
if (!string.IsNullOrWhiteSpace(item.DataType))
{
var dataType = dataTypeCV
.Where(a => a.Term.ToString().ToLower() == item.DataType.ToLower()).FirstOrDefault();
if (dataType == null)
{
var err = new ErrorModel("AddVariables", string.Format(Ressources.IMPORT_VALUE_NOT_IN_CV, item.DataType, "DataType"));
listOfErrors.Add(err);
isRejected = true;
}
else
{
model.DataType = dataType.Term;
}
}
else
{
var err = new ErrorModel("AddVariables", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "DataType")); listOfErrors.Add(err); isRejected = true;
}
//GeneralCategory
if (!string.IsNullOrWhiteSpace(item.GeneralCategory))
{
var generalCategory = generalCategoryCV
.Where(a => a.Term.ToString().ToLower() == item.GeneralCategory.ToLower()).FirstOrDefault();
if (generalCategory == null)
{
var err = new ErrorModel("AddVariables", string.Format(Ressources.IMPORT_VALUE_NOT_IN_CV, item.GeneralCategory, "GeneralCategory"));
listOfErrors.Add(err);
isRejected = true;
}
else
{
model.GeneralCategory = generalCategory.Term;
}
}
else
{
var err = new ErrorModel("AddVariables", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "GeneralCategory")); listOfErrors.Add(err); isRejected = true;
}
//NoDataValue
if (!string.IsNullOrWhiteSpace(item.NoDataValue))
{
double result;
bool canConvert = UniversalTypeConverter.TryConvertTo<double>(item.NoDataValue, out result);
if (!canConvert)
{
var err = new ErrorModel("AddVariables", string.Format(Ressources.IMPORT_FAILED_NOVALIDDATA, "NoDataValue"));
listOfErrors.Add(err);
isRejected = true;
}
else
{
model.NoDataValue = result;
}
}
else
{
var err = new ErrorModel("AddVariables", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "NoDataValue")); listOfErrors.Add(err); isRejected = true;
}
if (isRejected)
{
var sb = new StringBuilder();
foreach (var er in listOfErrors)
{
sb.Append(er.ErrorMessage + ";");
}
item.Errors = sb.ToString();
listOfIncorrectRecords.Add(item);
continue;
}
//lookup duplicates
//var objectSet = objContext.CreateObjectSet<ODM_1_1_1EFModel.Variable>().EntitySet;//.EntitySet;
//check if item with this variablecode exists in the database
var doesExist = variablesInDatabase.Find(p => p == item.VariableCode.ToLower());
if (doesExist == null)
{
var existInUpload = listOfCorrectRecords.Exists(a => a.VariableCode == item.VariableCode);
if (!existInUpload)
{
//context.Sites.Add(model);
//context.SaveChanges();
listOfCorrectRecords.Add(item);
}
else
{
var err = new ErrorModel("AddVariables", string.Format(Ressources.IMPORT_VALUE_ISDUPLICATE, "VariableCode")); listOfErrors.Add(err); isRejected = true;
listOfIncorrectRecords.Add(item);
item.Errors += err.ErrorMessage + ";";
}
}
else
{
var existingItem = context.Variables.Where(a => a.VariableCode == item.VariableCode).FirstOrDefault();
//if (existingItem.VariableCode != model.VariableCode) { listOfUpdates.Add(new UpdateFieldsModel("Variables", "VariableCode", existingItem.VariableCode.ToString(), item.VariableCode.ToString())); }
if (model.VariableName != null && existingItem.VariableName != model.VariableName) { listOfUpdates.Add(new UpdateFieldsModel("Variables", "VariableName", existingItem.VariableName.ToString(), item.VariableName.ToString())); }
if (model.Speciation != model.Speciation) { listOfUpdates.Add(new UpdateFieldsModel("Variables", "Speciation", existingItem.Speciation.ToString(), item.Speciation.ToString())); }
if (model.VariableUnitsID != model.VariableUnitsID) { listOfUpdates.Add(new UpdateFieldsModel("Variables", "VariableUnitsID", existingItem.Unit1.UnitsName.ToString(), item.VariableUnitsName.ToString())); }
if (model.SampleMedium != model.SampleMedium) { listOfUpdates.Add(new UpdateFieldsModel("Variables", "SampleMedium", existingItem.SampleMedium.ToString(), item.SampleMedium.ToString())); }
if (model.ValueType != model.ValueType) { listOfUpdates.Add(new UpdateFieldsModel("Variables", "ValueType", existingItem.ValueType.ToString(), item.ValueType.ToString())); }
if (model.IsRegular != model.IsRegular) { listOfUpdates.Add(new UpdateFieldsModel("Variables", "IsRegular", existingItem.IsRegular.ToString(), item.IsRegular.ToString())); }
if (model.TimeSupport != model.TimeSupport) { listOfUpdates.Add(new UpdateFieldsModel("Variables", "TimeSupport", existingItem.TimeSupport.ToString(), item.TimeSupport.ToString())); }
if (model.TimeUnitsID != model.TimeUnitsID) { listOfUpdates.Add(new UpdateFieldsModel("Variables", "TimeUnitsID", existingItem.Unit1.UnitsName, item.TimeUnitsName.ToString())); }
if (model.DataType != model.DataType) { listOfUpdates.Add(new UpdateFieldsModel("Variables", "DataType", existingItem.DataType.ToString(), item.DataType.ToString())); }
if (model.GeneralCategory != model.GeneralCategory) { listOfUpdates.Add(new UpdateFieldsModel("Variables", "GeneralCategory", existingItem.GeneralCategory.ToString(), item.GeneralCategory.ToString())); }
if (model.NoDataValue != model.NoDataValue) { listOfUpdates.Add(new UpdateFieldsModel("Variables", "NoDataValue", existingItem.NoDataValue.ToString(), item.NoDataValue.ToString())); }
if (listOfUpdates.Count() > 0)
{
listOfEditedRecords.Add(item);
var sb = new StringBuilder();
foreach (var u in listOfUpdates)
{
sb.Append(string.Format(Ressources.IMPORT_VALUE_UPDATED, u.ColumnName, u.CurrentValue, u.UpdatedValue + ";"));
}
item.Errors = sb.ToString();
continue;
}
else
{
listOfDuplicateRecords.Add(item);
}
}
}
catch (Exception ex)
{
listOfIncorrectRecords.Add(item);
}
}
return;
}
public void AddCategories(List<CategoriesModel> itemList, string entityConnectionString, string instanceIdentifier, out List<CategoriesModel> listOfIncorrectRecords, out List<CategoriesModel> listOfCorrectRecords, out List<CategoriesModel> listOfDuplicateRecords, out List<CategoriesModel> listOfEditedRecords)
{
listOfIncorrectRecords = new List<CategoriesModel>();
listOfCorrectRecords = new List<CategoriesModel>();
listOfDuplicateRecords = new List<CategoriesModel>();
listOfEditedRecords = new List<CategoriesModel>();
var context = new ODM_1_1_1EFModel.ODM_1_1_1Entities(entityConnectionString);
//var objContext = ((IObjectContextAdapter)context).ObjectContext;
var variables = context.Variables.ToDictionary(p => p.VariableCode, p => p.VariableID);
var maxCount = itemList.Count;
var count = 0;
BusinessObjectsUtils.UpdateCachedprocessStatusMessage(instanceIdentifier, CacheName, String.Format(Ressources.IMPORT_STATUS_PROCESSING, count, maxCount));
foreach (var item in itemList)
{
try
{
//Updating status
BusinessObjectsUtils.UpdateCachedprocessStatusMessage(instanceIdentifier, "default", Ressources.IMPORT_STATUS_EXTRACTNG);
var model = new Category();
var listOfErrors = new List<ErrorModel>();
bool isRejected = false;
//Categories
if (!string.IsNullOrWhiteSpace(item.VariableCode))
{
if (RepositoryUtils.containsNotOnlyAllowedCaracters(item.VariableCode))
{
var err = new ErrorModel("AddVariables", string.Format(Ressources.IMPORT_VALUE_INVALIDCHARACTERS, "VariableCode")); listOfErrors.Add(err); isRejected = true;
}
else
{
if (variables.ContainsKey(item.VariableCode))
{
var variableId = variables[item.VariableCode];
//update model
model.VariableID = variableId;
item.VariableID = variableId.ToString();
}
else
{
var err = new ErrorModel("AddVariables", string.Format(Ressources.IMPORT_VALUE_NOT_IN_DATABASE, item.VariableCode, "Sites")); listOfErrors.Add(err); isRejected = true;
//continue;
}
}
}
else
{
var err = new ErrorModel("AddCategories", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "VariableCode")); listOfErrors.Add(err); isRejected = true;
}
//DataValue
if (!string.IsNullOrWhiteSpace(item.DataValue))
{
double result;
bool canConvert = UniversalTypeConverter.TryConvertTo<double>(item.DataValue, out result);
if (!canConvert)
{
var err = new ErrorModel("AddCategories", string.Format(Ressources.IMPORT_VALUE_INVALIDVALUE, "DataValue")); listOfErrors.Add(err); isRejected = true;
}
else
{
model.DataValue = result;
}
}
else
{
var err = new ErrorModel("AddCategories", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "DataValue")); listOfErrors.Add(err); isRejected = true;
}
//CategoryDescription
if (!string.IsNullOrWhiteSpace(item.CategoryDescription))
{
if (RepositoryUtils.containsSpecialCharacters(item.CategoryDescription))
{
var err = new ErrorModel("AddCategories", string.Format(Ressources.IMPORT_VALUE_INVALIDCHARACTERS, "CategoryDescription")); listOfErrors.Add(err); isRejected = true;
}
else
{
model.CategoryDescription = item.CategoryDescription;
}
}
else
{
var err = new ErrorModel("AddCategories", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "CategoryDescription")); listOfErrors.Add(err); isRejected = true;
}
//var variablesID = variables
// .Where(a => a.Key == item.VariableCode)
// .Select(a => a.Value)
// .SingleOrDefault();
//if (variablesID == 0)
//{
// var err = new ErrorModel("AddCategories", string.Format(Ressources.IMPORT_VALUE_NOT_IN_CV, item.VariableCode, "Variables")); listOfErrors.Add(err); isRejected = true;
//}
//else
//{
// model.VariableID = variablesID;
//}
if (isRejected)
{
var sb = new StringBuilder();
foreach (var er in listOfErrors)
{
sb.Append(er.ErrorMessage + ";");
}
item.Errors = sb.ToString();
listOfIncorrectRecords.Add(item);
continue;
}
//lookup duplicates
var existingItem = context.Categories.Where(a => a.VariableID == model.VariableID &&
a.DataValue == model.DataValue &&
a.CategoryDescription == model.CategoryDescription
).FirstOrDefault();
if (existingItem == null)
{
context.Categories.Add(model);
//context.SaveChanges();
listOfCorrectRecords.Add(item);
}
else
{
//no editing possible no unique field in upload
listOfDuplicateRecords.Add(item);
}
}
catch (Exception ex)
{
listOfIncorrectRecords.Add(item);
}
}
return;
}
public void AddSites(List<SiteModel> itemList, string entityConnectionString, string instanceIdentifier, out List<SiteModel> listOfIncorrectRecords, out List<SiteModel> listOfCorrectRecords, out List<SiteModel> listOfDuplicateRecords, out List<SiteModel> listOfEditedRecords)
{
listOfIncorrectRecords = new List<SiteModel>();
listOfCorrectRecords = new List<SiteModel>();
listOfDuplicateRecords = new List<SiteModel>();
listOfEditedRecords = new List<SiteModel>();
var context = new ODM_1_1_1EFModel.ODM_1_1_1Entities(entityConnectionString);
//var objContext = ((IObjectContextAdapter)context).ObjectContext;
var LatLongDatum = context.SpatialReferences.ToDictionary(p => p.SRSName.Trim(), p => p.SpatialReferenceID);
var LatLongDatumSRSID = context.SpatialReferences.Where(p => p.SRSID != null).ToDictionary(p => p.SRSID, p => p.SpatialReferenceID);
var VerticalDatumCV = context.VerticalDatumCVs.ToList();
var SiteTypeCV = context.SiteTypeCVs.ToList();
//get all sites
var sitesInDatabase = context.Sites.Select(p => p.SiteCode.ToLower()).ToList();
var maxCount = itemList.Count;
var count = 0;
BusinessObjectsUtils.UpdateCachedprocessStatusMessage(instanceIdentifier, CacheName, String.Format(Ressources.IMPORT_STATUS_PROCESSING, count, maxCount));
foreach (var item in itemList)
{
//var item = new ODM_1_1_1EFModel.Site();
try
{
BusinessObjectsUtils.UpdateCachedprocessStatusMessage(instanceIdentifier, CacheName, String.Format(Ressources.IMPORT_STATUS_PROCESSING, count, maxCount));
count++;
//var model = Mapper.Map<SiteModel, Site>(item);
var model = new Site();
bool isRejected = false;
var listOfErrors = new List<ErrorModel>();
var listOfUpdates = new List<UpdateFieldsModel>();
//SiteCode
if (!string.IsNullOrWhiteSpace(item.SiteCode))
{
if (RepositoryUtils.containsNotOnlyAllowedCaracters(item.SiteCode))
{
var err = new ErrorModel("AddSites", string.Format(Ressources.IMPORT_VALUE_INVALIDCHARACTERS, "SiteCode")); listOfErrors.Add(err); isRejected = true;
}
else
{
model.SiteCode = item.SiteCode;
}
}
else
{
var err = new ErrorModel("AddSites", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "SiteCode")); listOfErrors.Add(err); isRejected = true;
}
//SiteName
if (!string.IsNullOrWhiteSpace(item.SiteName))
{
if (RepositoryUtils.containsSpecialCharacters(item.SiteName))
{
var err = new ErrorModel("AddSites", string.Format(Ressources.IMPORT_VALUE_INVALIDCHARACTERS, "SiteName")); listOfErrors.Add(err); isRejected = true;
}
else
{
model.SiteName = item.SiteName;
}
}
else
{
var err = new ErrorModel("AddSites", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "SiteName")); listOfErrors.Add(err); isRejected = true;
}
//Latitude
if (!string.IsNullOrWhiteSpace(item.Latitude))
{
double result;
bool canConvert = UniversalTypeConverter.TryConvertTo<double>(item.Latitude, out result);
if (!canConvert)
{
var err = new ErrorModel("AddSites", string.Format(Ressources.IMPORT_VALUE_INVALIDVALUE, "Latitude")); listOfErrors.Add(err); isRejected = true;
}
else
{
if (result >= -90 && result <= 90) model.Latitude = result;
else
{
var err = new ErrorModel("AddSites", string.Format(Ressources.IMPORT_VALUE_INVALIDRANGE, "Latitude", "-90 to +90")); listOfErrors.Add(err); isRejected = true;
}
}
}
else
{
var err = new ErrorModel("AddSites", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "Latitude")); listOfErrors.Add(err); isRejected = true;
}
//Longitude
if (!string.IsNullOrWhiteSpace(item.Longitude))
{
double result;
bool canConvert = UniversalTypeConverter.TryConvertTo<double>(item.Longitude, out result);
if (!canConvert)
{
var err = new ErrorModel("AddSites", string.Format(Ressources.IMPORT_VALUE_INVALIDVALUE, "Longitude")); listOfErrors.Add(err); isRejected = true;
}
else
{
if (result >= -180 && result <= 180) model.Longitude = result;
else
{
var err = new ErrorModel("AddSites", string.Format(Ressources.IMPORT_VALUE_INVALIDRANGE, "Longitude", "-180 to +180")); listOfErrors.Add(err); isRejected = true;
}
}
}
else
{
var err = new ErrorModel("AddSites", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "Longitude")); listOfErrors.Add(err); isRejected = true;
}
//#####################
//LatLongDatumID
if (!string.IsNullOrWhiteSpace(item.LatLongDatumSRSName))
{
if (RepositoryUtils.containsSpecialCharacters(item.LatLongDatumSRSName))
{
var err = new ErrorModel("AddSites", string.Format(Ressources.IMPORT_VALUE_INVALIDCHARACTERS, "LatLongDatumSRSName")); listOfErrors.Add(err); isRejected = true;
}
else
{
if (item.LatLongDatumSRSName.ToLower() == "unknown")
{
var unknownID = context.SpatialReferences.Where(p => p.SRSName.ToLower() == "unknown").Select(p => p.SpatialReferenceID).FirstOrDefault();
model.LatLongDatumID = unknownID;
item.LatLongDatumID = unknownID.ToString();// write back to viewmodel to not have to convert again when values are committed to DB
}
else
{
int result;
bool canConvert = UniversalTypeConverter.TryConvertTo<int>(item.LatLongDatumSRSName, out result);
if (canConvert)//user used SSRID
{
var LatLongDatumID = LatLongDatumSRSID
.Where(a => a.Key == result)
.Select(a => a.Value)
.SingleOrDefault();
if (LatLongDatumID != 0)
{
model.LatLongDatumID = LatLongDatumID;
item.LatLongDatumID = LatLongDatumID.ToString();// write back to viewmodel to not have to convert again when values are committed to DB
item.LatLongDatumSRSName = LatLongDatum.Where(a => a.Value == LatLongDatumID).Select(a => a.Key).FirstOrDefault();
}
else
{
var err = new ErrorModel("AddSites", string.Format(Ressources.IMPORT_VALUE_INVALIDVALUE, "LatLongDatumSRSName")); listOfErrors.Add(err); isRejected = true;
}
}
else
{
var LatLongDatumID = LatLongDatum
.Where(a => a.Key.ToLower() == item.LatLongDatumSRSName.ToLower())
.Select(a => a.Value)
.SingleOrDefault();
if (LatLongDatumID != 0)
{
model.LatLongDatumID = LatLongDatumID;
item.LatLongDatumID = LatLongDatumID.ToString();// write back to viewmodel to not have to convert again when values are comitted to DB
item.LatLongDatumSRSName = LatLongDatum.Where(a => a.Value == LatLongDatumID).Select(a => a.Key).FirstOrDefault();
}
else
{
var err = new ErrorModel("AddSites", string.Format(Ressources.IMPORT_VALUE_INVALIDVALUE, "LatLongDatumSRSName")); listOfErrors.Add(err); isRejected = true;
}
}
}
}
}
else
{
var err = new ErrorModel("AddSites", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "LatLongDatumSRSName")); listOfErrors.Add(err); isRejected = true;
}
//#####################
//Elevation_m
if (!string.IsNullOrWhiteSpace(item.Elevation_m))
{
double result;
bool canConvert = UniversalTypeConverter.TryConvertTo<double>(item.Elevation_m, out result);
if (!canConvert)
{
var err = new ErrorModel("AddSites", string.Format(Ressources.IMPORT_VALUE_INVALIDVALUE, "Elevation_m")); listOfErrors.Add(err); isRejected = true;
}
else
{
// if (result >= -180 && result <= 180)
model.Elevation_m = result;
// else
// {
// var err = new ErrorModel("AddSites", string.Format(Ressources.IMPORT_VALUE_INVALIDRANGE, "Longitude", "-180 to +180")); listOfErrors.Add(err); isRejected = true;
// }
}
}
else
{
model.Elevation_m = null;
}
//VerticalDatum
if (!string.IsNullOrWhiteSpace(item.VerticalDatum))
{
if (RepositoryUtils.containsInvalidCharacters(item.VerticalDatum))
{
var err = new ErrorModel("AddSites", string.Format(Ressources.IMPORT_VALUE_INVALIDCHARACTERS, "VerticalDatum")); listOfErrors.Add(err); isRejected = true;
}
else
{
var verticalDatum = VerticalDatumCV
.Where(a => a.Term.ToString().ToLower() == item.VerticalDatum.ToLower()).FirstOrDefault();
if (verticalDatum == null)
{
var err = new ErrorModel("AddSites", string.Format(Ressources.IMPORT_VALUE_NOT_IN_CV, item.VerticalDatum, "VerticalDatum"));
listOfErrors.Add(err); isRejected = true;
}
else
{
model.VerticalDatum = verticalDatum.Term;
item.VerticalDatum = verticalDatum.Term;
}
}
}
else
{
model.VerticalDatum = null;
item.VerticalDatum = null;
}
//LocalX
if (!string.IsNullOrWhiteSpace(item.LocalX))
{
double result;
bool canConvert = UniversalTypeConverter.TryConvertTo<double>(item.LocalX, out result);
if (!canConvert)
{
var err = new ErrorModel("AddSites", string.Format(Ressources.IMPORT_VALUE_INVALIDVALUE, "LocalX")); listOfErrors.Add(err); isRejected = true;
}
else
{
model.LocalX = result;
}
}
else
{
model.LocalX = null;
}
//LocalY
if (!string.IsNullOrWhiteSpace(item.LocalY))
{
double result;
bool canConvert = UniversalTypeConverter.TryConvertTo<double>(item.LocalY, out result);
if (!canConvert)
{
var err = new ErrorModel("AddSites", string.Format(Ressources.IMPORT_VALUE_INVALIDVALUE, "LocalY")); listOfErrors.Add(err); isRejected = true;
}
else
{
model.LocalY = result;
}
}
else
{
model.LocalY = null;
}
//LocalProjectionID
if (!string.IsNullOrWhiteSpace(item.LocalProjectionSRSName))
{
if (RepositoryUtils.containsSpecialCharacters(item.LocalProjectionSRSName))
{
var err = new ErrorModel("AddSites", string.Format(Ressources.IMPORT_VALUE_INVALIDCHARACTERS, "LocalProjectionSRSName")); listOfErrors.Add(err); isRejected = true;
}
else
{
if (item.LatLongDatumSRSName.ToLower() == "unknown")
{
var unknownID = context.SpatialReferences.Where(p => p.SRSName.ToLower() == "unknown").Select(p => p.SpatialReferenceID).FirstOrDefault();
model.LatLongDatumID = unknownID;
item.LatLongDatumID = unknownID.ToString();// write back to viewmodel to not have to convert again when values are committed to DB
}
else
{
int result;
bool canConvert = UniversalTypeConverter.TryConvertTo<int>(item.LocalProjectionSRSName, out result);
if (canConvert)//user used SSRID
{
var localDatumID = LatLongDatumSRSID
.Where(a => a.Key == result)
.Select(a => a.Value)
.SingleOrDefault();
if (localDatumID != 0)
{
model.LocalProjectionID = localDatumID;
item.LocalProjectionID = localDatumID.ToString();// write back to viewmodel to not have to convert again when values are comitted to DB
item.LocalProjectionSRSName = LatLongDatum.Where(a => a.Value == localDatumID).Select(a => a.Key).FirstOrDefault();
}
else
{
var err = new ErrorModel("AddSites", string.Format(Ressources.IMPORT_VALUE_INVALIDVALUE, "LocalProjectionSRSName")); listOfErrors.Add(err); isRejected = true;
}
}
else
{
var localDatumID = LatLongDatum
.Where(a => a.Key.ToLower() == item.LocalProjectionSRSName.ToLower())
.Select(a => a.Value)
.SingleOrDefault();
if (localDatumID != 0)
{
model.LocalProjectionID = localDatumID;
item.LocalProjectionID = localDatumID.ToString();// write back to viewmodel to not have to convert again when values are comitted to DB
item.LocalProjectionSRSName = LatLongDatum.Where(a => a.Value == localDatumID).Select(a => a.Key).FirstOrDefault();
}
else
{
var err = new ErrorModel("AddSites", string.Format(Ressources.IMPORT_VALUE_INVALIDVALUE, "LocalProjectionSRSName")); listOfErrors.Add(err); isRejected = true;
}
}
}
}
}
else
{
model.LocalProjectionID = null;
}
//PosAccuracy_m
if (!string.IsNullOrWhiteSpace(item.PosAccuracy_m))
{
double result;
bool canConvert = UniversalTypeConverter.TryConvertTo<double>(item.PosAccuracy_m, out result);
if (!canConvert)
{
var err = new ErrorModel("AddSites", string.Format(Ressources.IMPORT_VALUE_INVALIDVALUE, "PosAccuracy_m")); listOfErrors.Add(err); isRejected = true;
}
else
{
// if (result >= -180 && result <= 180)
model.PosAccuracy_m = result;
// else
// {
// var err = new ErrorModel("AddSites", string.Format(Ressources.IMPORT_VALUE_INVALIDRANGE, "Longitude", "-180 to +180")); listOfErrors.Add(err); isRejected = true;
// }
}
}
else
{
model.PosAccuracy_m = null;
}
//State
if (!string.IsNullOrWhiteSpace(item.State))
{
if (RepositoryUtils.containsSpecialCharacters(item.State))
{
var err = new ErrorModel("AddSites", string.Format(Ressources.IMPORT_VALUE_INVALIDCHARACTERS, "State")); listOfErrors.Add(err); isRejected = true;
}
else
{
model.State = item.State;
}
}
else
{
model.State = null;
item.State = null;
}
//County
if (!string.IsNullOrWhiteSpace(item.County))
{
if (RepositoryUtils.containsSpecialCharacters(item.County))
{
var err = new ErrorModel("AddSites", string.Format(Ressources.IMPORT_VALUE_INVALIDCHARACTERS, "County")); listOfErrors.Add(err); isRejected = true;
}
else
{
model.County = item.County;
}
}
else
{
model.County = null;
item.County = null;
}
//Comments
if (!string.IsNullOrWhiteSpace(item.Comments))
{
if (RepositoryUtils.containsSpecialCharacters(item.Comments))
{
var err = new ErrorModel("AddSites", string.Format(Ressources.IMPORT_VALUE_INVALIDCHARACTERS, "Comments")); listOfErrors.Add(err); isRejected = true;
}
else
{
model.Comments = item.Comments;
}
}
else
{
model.Comments = null;
item.Comments = null;
}
//SiteType
if (!string.IsNullOrWhiteSpace(item.SiteType))
{
//var siteType = SiteTypeCV
// .Exists(a => a.Term.ToString().ToLower() == item.SiteType.ToLower());
var siteType = SiteTypeCV
.Where(a => a.Term.ToString().ToLower() == item.SiteType.ToLower()).FirstOrDefault();
if (siteType == null)
{
var err = new ErrorModel("AddSites", string.Format(Ressources.IMPORT_VALUE_NOT_IN_CV, item.SiteType, "SiteType"));
listOfErrors.Add(err);
isRejected = true;
}
else
{
//using this insures correct spelling
model.SiteType = siteType.Term;
item.SiteType = siteType.Term;
}
}
else
{
var err = new ErrorModel("AddSites", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "SiteType")); listOfErrors.Add(err); isRejected = true;
}
//general rules check If one of these fields are included, then so should the rest: LocalX, LocalY, LocalSRSName
if (model.LocalX != null || model.LocalY != null || model.LocalProjectionID != null)
{
if (!(model.LocalX != null && model.LocalY != null && model.LocalProjectionID != null))
{
var err = new ErrorModel("AddSites", string.Format(Ressources.IMPORT_VALUE_LOCALVALUE_NOT_COMPLETE)); listOfErrors.Add(err); isRejected = true;
}
}
if (model.Elevation_m != null )
{
if (model.VerticalDatum == null)
{
var err = new ErrorModel("AddSites", string.Format(Ressources.IMPORT_VALUE_ELEVATION_VERTICALDATUM)); listOfErrors.Add(err); isRejected = true;
}
}
if (isRejected)
{
var sb = new StringBuilder();
foreach (var er in listOfErrors)
{
sb.Append(er.ErrorMessage + ";");
}
item.Errors = sb.ToString();
listOfIncorrectRecords.Add(item);
continue;
}
//check for duplicates first in database then in upload if a duplicate site is found the record will be rejected.
//check in list
var doesExist = sitesInDatabase.Find(p =>p == item.SiteCode.ToLower());
//var j = context.Sites.Find(s.SiteCode);
if (doesExist == null)
{
var existInUpload = listOfCorrectRecords.Exists(a => a.SiteCode.ToLower() == item.SiteCode.ToLower());
if (!existInUpload)
{
//context.Sites.Add(model);
//context.SaveChanges();
listOfCorrectRecords.Add(item);
}
else
{
var err = new ErrorModel("AddSites", string.Format(Ressources.IMPORT_VALUE_ISDUPLICATE,"SiteCode")); listOfErrors.Add(err); isRejected = true;
listOfIncorrectRecords.Add(item);
item.Errors += err.ErrorMessage + ";";
}
}
else
{
// var editedFields = new List<string>();
//retrieve all DatabaseRepository from db
var existingItem = context.Sites.Where(a => a.SiteCode.ToLower() == item.SiteCode.ToLower()).FirstOrDefault();
//if (existingItem.SiteCode != model.SiteCode) { listOfUpdates.Add(new UpdateFieldsModel("Sites", "SiteCode", existingItem.SiteCode.ToString(), item.SiteCode.ToString())); }
if (model.Latitude != null && existingItem.Latitude != model.Latitude) { listOfUpdates.Add(new UpdateFieldsModel("Sites", "Latitude", existingItem.Latitude.ToString(), item.Latitude.ToString())); }
if (model.Longitude != null && existingItem.Longitude != model.Longitude) { listOfUpdates.Add(new UpdateFieldsModel("Sites", "Longitude", existingItem.Longitude.ToString(), item.Longitude.ToString())); }
if (model.LatLongDatumID != null && existingItem.LatLongDatumID != model.LatLongDatumID) { listOfUpdates.Add(new UpdateFieldsModel("Sites", "LatLongDatumSRSName", existingItem.SpatialReference.SRSName.ToString(), item.LatLongDatumSRSName.ToString())); }
if (model.Elevation_m != null && existingItem.Elevation_m != model.Elevation_m) { listOfUpdates.Add(new UpdateFieldsModel("Sites", "Elevation_m", existingItem.Elevation_m.ToString(), item.Elevation_m.ToString())); }
if (model.VerticalDatum != null && existingItem.VerticalDatum != model.VerticalDatum) { listOfUpdates.Add(new UpdateFieldsModel("Sites", "VerticalDatum", existingItem.VerticalDatum != null ? existingItem.VerticalDatum.ToString() : String.Empty, item.VerticalDatum.ToString())); }
if (model.LocalX != null && existingItem.LocalX != model.LocalX) { listOfUpdates.Add(new UpdateFieldsModel("Sites", "LocalX", existingItem.LocalX.ToString(), item.LocalX.ToString())); }
if (model.LocalY != null && existingItem.LocalY != model.LocalY) { listOfUpdates.Add(new UpdateFieldsModel("Sites", "LocalY", existingItem.LocalY.ToString(), item.LocalY.ToString())); }
if (model.LocalProjectionID != null && existingItem.LocalProjectionID != model.LocalProjectionID) { listOfUpdates.Add(new UpdateFieldsModel("Sites", "LocalProjectionSRSName", existingItem.SpatialReference1 != null ? existingItem.SpatialReference1.ToString() : String.Empty, item.LocalProjectionSRSName.ToString())); }
if (model.PosAccuracy_m != null && existingItem.PosAccuracy_m != model.PosAccuracy_m) { listOfUpdates.Add(new UpdateFieldsModel("Sites", "PosAccuracy_m", existingItem.PosAccuracy_m.ToString(), item.PosAccuracy_m.ToString())); }
if (model.State != null && existingItem.State != model.State) { listOfUpdates.Add(new UpdateFieldsModel("Sites", "State", existingItem.State, item.State)); }
if (model.County != null && existingItem.County != model.County) { listOfUpdates.Add(new UpdateFieldsModel("Sites", "County", existingItem.County, item.County)); }
if (model.Comments != null && existingItem.Comments != model.Comments) { listOfUpdates.Add(new UpdateFieldsModel("Sites", "Comments", existingItem.Comments, item.Comments)); }
if (model.SiteType != null && existingItem.SiteType != model.SiteType) { listOfUpdates.Add(new UpdateFieldsModel("Sites", "SiteType", existingItem.SiteType, item.SiteType)); }
if (listOfUpdates.Count() > 0)
{
listOfEditedRecords.Add(item);
var sb = new StringBuilder();
foreach (var u in listOfUpdates)
{
sb.Append(string.Format(Ressources.IMPORT_VALUE_UPDATED, u.ColumnName, u.CurrentValue, u.UpdatedValue + ";"));
}
item.Errors = sb.ToString();
continue;
}
else
{
listOfDuplicateRecords.Add(item);
}
//var modifiedEntries = this.ObjectStateManager.GetObjectStateEntries(EntityState.Modified);
}
////check if entry with this key exists
//object value;
//var key = Utils.GetEntityKey(objectSet, d);
//if (!objContext.TryGetObjectByKey(key, out value))
//{
// try
// {
// var objContext = ((IObjectContextAdapter)context).ObjectContext;
//objContext.Connection.Open();
//objContext.ExecuteStoreCommand("SET IDENTITY_INSERT [dbo].[Sites] ON");
//objContext.AddObject(objectSet.Name, d);
//objContext.SaveChanges();
// objContext.Connection.Close();
//}
//catch (Exception ex)
//{
// throw;
//}
//}
//else
//{
//context.MyEntities.Attach(myEntity);
// listOfDuplicateRecords.Add(s);
//}
}
//Datum not in CV
catch (KeyNotFoundException ex)
{
listOfIncorrectRecords.Add(item);
}
catch (Exception ex)
{
listOfIncorrectRecords.Add(item);
}
}
return;
}
public void AddSources(List<SourcesModel> itemList, string entityConnectionString, string instanceIdentifier, out List<SourcesModel> listOfIncorrectRecords, out List<SourcesModel> listOfCorrectRecords, out List<SourcesModel> listOfDuplicateRecords, out List<SourcesModel> listOfEditedRecords)
{
listOfIncorrectRecords = new List<SourcesModel>();
listOfCorrectRecords = new List<SourcesModel>();
listOfDuplicateRecords = new List<SourcesModel>();
listOfEditedRecords = new List<SourcesModel>();
var context = new ODM_1_1_1EFModel.ODM_1_1_1Entities(entityConnectionString);
// var objContext = ((IObjectContextAdapter)context).ObjectContext;
//read CV in to list for fster searching
var topicCategoryCV = context.TopicCategoryCVs.ToList();
var maxCount = itemList.Count;
var count = 0;
BusinessObjectsUtils.UpdateCachedprocessStatusMessage(instanceIdentifier, CacheName, String.Format(Ressources.IMPORT_STATUS_PROCESSING, count, maxCount));
foreach (var item in itemList)
{
try
{
BusinessObjectsUtils.UpdateCachedprocessStatusMessage(instanceIdentifier, CacheName, String.Format(Ressources.IMPORT_STATUS_PROCESSING, count, maxCount));
count++;
var listOfErrors = new List<ErrorModel>();
var listOfUpdates = new List<UpdateFieldsModel>();
bool isRejected = false;
var source = new Source();
//set default values
string unk = "Unknown";
source.ContactName = unk;
source.Phone = unk;
source.Email = unk;
source.Phone = unk;
source.Address = unk;
source.City = unk;
source.State = unk;
source.ZipCode = unk;
source.Citation = unk;
source.MetadataID = 0;
var isometadata = new ISOMetadata();
isometadata.TopicCategory = unk;
isometadata.Title = unk;
isometadata.Abstract = unk;
isometadata.ProfileVersion = unk;
isometadata.MetadataLink = null;
//SourceCode
if (!string.IsNullOrWhiteSpace(item.SourceCode))
{
if (RepositoryUtils.containsNotOnlyAllowedCaracters(item.SourceCode))
{
var err = new ErrorModel("AddSource", string.Format(Ressources.IMPORT_VALUE_INVALIDCHARACTERS, "SourceCode")); listOfErrors.Add(err); isRejected = true;
}
else
{
source.SourceCode = item.SourceCode;
}
}
else
{
var err = new ErrorModel("AddSource", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "SourceCode")); listOfErrors.Add(err); isRejected = true;
}
//Organization
if (!string.IsNullOrWhiteSpace(item.Organization))
{
if (RepositoryUtils.containsSpecialCharacters(item.Organization))
{
var err = new ErrorModel("AddSources", string.Format(Ressources.IMPORT_VALUE_INVALIDCHARACTERS, "Organization")); listOfErrors.Add(err); isRejected = true;
}
else
{
source.Organization = item.Organization;
}
}
else
{
var err = new ErrorModel("AddSources", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "Organization")); listOfErrors.Add(err); isRejected = true;
}
//SourceDescription
if (!string.IsNullOrWhiteSpace(item.SourceDescription))
{
if (RepositoryUtils.containsSpecialCharacters(item.SourceDescription))
{
var err = new ErrorModel("AddSources", string.Format(Ressources.IMPORT_VALUE_INVALIDCHARACTERS, "SourceDescription")); listOfErrors.Add(err); isRejected = true;
}
else
{
source.SourceDescription = item.SourceDescription;
}
}
else
{
var err = new ErrorModel("AddSources", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "SourceDescription")); listOfErrors.Add(err); isRejected = true;
}
//SourceLink
if (!string.IsNullOrWhiteSpace(item.SourceLink))
{
if (RepositoryUtils.containsSpecialCharacters(item.SourceLink))
{
var err = new ErrorModel("AddSources", string.Format(Ressources.IMPORT_VALUE_INVALIDCHARACTERS, "SourceLink")); listOfErrors.Add(err); isRejected = true;
}
else
{
source.SourceLink = item.SourceLink;
}
}
//ContactName
if (!string.IsNullOrWhiteSpace(item.ContactName))
{
if (RepositoryUtils.containsSpecialCharacters(item.ContactName))
{
var err = new ErrorModel("AddSources", string.Format(Ressources.IMPORT_VALUE_INVALIDCHARACTERS, "ContactName")); listOfErrors.Add(err); isRejected = true;
}
else
{
source.ContactName = item.ContactName;
}
}
else
{
var err = new ErrorModel("AddSources", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "ContactName")); listOfErrors.Add(err); isRejected = true;
}
//Phone
if (!string.IsNullOrWhiteSpace(item.Phone))
{
if (RepositoryUtils.containsSpecialCharacters(item.Phone))
{
var err = new ErrorModel("AddSources", string.Format(Ressources.IMPORT_VALUE_INVALIDCHARACTERS, "Phone")); listOfErrors.Add(err); isRejected = true;
}
else
{
source.Phone = item.Phone;
}
}
else
{
var err = new ErrorModel("AddSources", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "Phone")); listOfErrors.Add(err); isRejected = true;
}
//Email
if (!string.IsNullOrWhiteSpace(item.Email))
{
if (RepositoryUtils.containsSpecialCharacters(item.Email))
{
var err = new ErrorModel("AddSources", string.Format(Ressources.IMPORT_VALUE_INVALIDCHARACTERS, "Email")); listOfErrors.Add(err); isRejected = true;
}
else
{
source.Email = item.Email;
}
}
else
{
var err = new ErrorModel("AddSources", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "Email")); listOfErrors.Add(err); isRejected = true;
}
//Address
if (!string.IsNullOrWhiteSpace(item.Address))
{
if (RepositoryUtils.containsSpecialCharacters(item.Address))
{
var err = new ErrorModel("AddSources", string.Format(Ressources.IMPORT_VALUE_INVALIDCHARACTERS, "Address")); listOfErrors.Add(err); isRejected = true;
}
else
{
source.Address = item.Address;
}
}
else
{
var err = new ErrorModel("AddSources", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "Address")); listOfErrors.Add(err); isRejected = true;
}
//City
if (!string.IsNullOrWhiteSpace(item.City))
{
if (RepositoryUtils.containsSpecialCharacters(item.City))
{
var err = new ErrorModel("AddSources", string.Format(Ressources.IMPORT_VALUE_INVALIDCHARACTERS, "City")); listOfErrors.Add(err); isRejected = true;
}
else
{
source.City = item.City;
}
}
else
{
var err = new ErrorModel("AddSources", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "City")); listOfErrors.Add(err); isRejected = true;
}
//State
if (!string.IsNullOrWhiteSpace(item.State))
{
if (RepositoryUtils.containsSpecialCharacters(item.State))
{
var err = new ErrorModel("AddSources", string.Format(Ressources.IMPORT_VALUE_INVALIDCHARACTERS, "State")); listOfErrors.Add(err); isRejected = true;
}
else
{
source.State = item.State;
}
}
else
{
var err = new ErrorModel("AddSources", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "State")); listOfErrors.Add(err); isRejected = true;
}
//ZipCode
if (!string.IsNullOrWhiteSpace(item.ZipCode))
{
if (RepositoryUtils.containsSpecialCharacters(item.ZipCode))
{
var err = new ErrorModel("AddSources", string.Format(Ressources.IMPORT_VALUE_INVALIDCHARACTERS, "ZipCode")); listOfErrors.Add(err); isRejected = true;
}
else
{
source.ZipCode = item.ZipCode;
}
}
else
{
var err = new ErrorModel("AddSources", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "ZipCode")); listOfErrors.Add(err); isRejected = true;
}
//Citation
if (!string.IsNullOrWhiteSpace(item.Citation))
{
if (RepositoryUtils.containsSpecialCharacters(item.Citation))
{
var err = new ErrorModel("AddSources", string.Format(Ressources.IMPORT_VALUE_INVALIDCHARACTERS, "Citation")); listOfErrors.Add(err); isRejected = true;
}
else
{
source.Citation = item.Citation;
}
}
else
{
var err = new ErrorModel("AddSources", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "Citation")); listOfErrors.Add(err); isRejected = true;
}
//TopicCategory
if (!string.IsNullOrWhiteSpace(item.TopicCategory))
{
var topicCategory = topicCategoryCV
.Exists(a => a.Term.ToString() == item.TopicCategory);
if (!topicCategory)
{
var err = new ErrorModel("AddSources", string.Format(Ressources.IMPORT_VALUE_NOT_IN_CV, item.TopicCategory, "TopicCategory"));
listOfErrors.Add(err);
isRejected = true;
}
else
{
isometadata.TopicCategory = item.TopicCategory;
}
}
else
{
var err = new ErrorModel("AddSources", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "TopicCategory")); listOfErrors.Add(err); isRejected = true;
}
//Title
if (!string.IsNullOrWhiteSpace(item.Title))
{
if (RepositoryUtils.containsSpecialCharacters(item.Title))
{
var err = new ErrorModel("AddSources", string.Format(Ressources.IMPORT_VALUE_INVALIDCHARACTERS, "Title")); listOfErrors.Add(err); isRejected = true;
}
else
{
isometadata.Title = item.Title;
}
}
else
{
var err = new ErrorModel("AddSources", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "Title")); listOfErrors.Add(err); isRejected = true;
}
//Abstract
if (!string.IsNullOrWhiteSpace(item.Abstract))
{
if (RepositoryUtils.containsSpecialCharacters(item.Abstract))
{
var err = new ErrorModel("AddSources", string.Format(Ressources.IMPORT_VALUE_INVALIDCHARACTERS, "Abstract")); listOfErrors.Add(err); isRejected = true;
}
else
{
isometadata.Abstract = item.Abstract;
}
}
else
{
var err = new ErrorModel("AddSources", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "Abstract")); listOfErrors.Add(err); isRejected = true;
}
//ProfileVersion
if (!string.IsNullOrWhiteSpace(item.ProfileVersion))
{
if (RepositoryUtils.containsSpecialCharacters(item.ProfileVersion))
{
var err = new ErrorModel("AddSources", string.Format(Ressources.IMPORT_VALUE_INVALIDCHARACTERS, "ProfileVersion")); listOfErrors.Add(err); isRejected = true;
}
else
{
isometadata.ProfileVersion = item.ProfileVersion;
}
}
else
{
var err = new ErrorModel("AddSources", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "ProfileVersion")); listOfErrors.Add(err); isRejected = true;
}
//MetadataLink
if (!string.IsNullOrWhiteSpace(item.MetadataLink))
{
if (RepositoryUtils.containsSpecialCharacters(item.MetadataLink))
{
var err = new ErrorModel("AddSources", string.Format(Ressources.IMPORT_VALUE_INVALIDCHARACTERS, "MetadataLink")); listOfErrors.Add(err); isRejected = true;
}
else
{
isometadata.MetadataLink = item.MetadataLink;
}
}
if (isRejected)
{
var sb = new StringBuilder();
foreach (var er in listOfErrors)
{
sb.Append(er.ErrorMessage + ";");
}
item.Errors = sb.ToString();
listOfIncorrectRecords.Add(item);
continue;
}
//Source contains info about metadata
//need to be added first so I can get the ID
var existingIsometadataItem = context.ISOMetadatas
.Where(a =>
a.TopicCategory == item.TopicCategory &&
a.Title == item.Title &&
a.Abstract == item.Abstract &&
a.ProfileVersion == item.ProfileVersion &&
a.MetadataLink == item.MetadataLink)
.FirstOrDefault();
if (existingIsometadataItem == null)
{
context.ISOMetadatas.Add(isometadata);
//context.SaveChanges();
}
else
{
//set source metatdata id to id of existing item
source.MetadataID = existingIsometadataItem.MetadataID;
}
//var metadataId = context.ISOMetadatas
// .Where(a => a.MetadataLink == item.MetadataLink)
// .Select(a => a.MetadataID)
// .FirstOrDefault();
//var existingSourcesItem = context.Sources
// .Where(a =>
// a.SourceDescription == item.SourceDescription &&
// a.SourceLink == item.SourceLink &&
// a.ContactName == item.ContactName &&
// a.Phone == item.Phone &&
// a.Email == item.Email &&
// a.Address == item.Address &&
// a.City == item.City &&
// a.State == item.State &&
// a.ZipCode == item.ZipCode &&
// a.Citation == item.Citation &&
// a.ISOMetadata.TopicCategory == item.TopicCategory &&
// a.ISOMetadata.Title == item.Title &&
// a.ISOMetadata.Abstract == item.Abstract &&
// a.ISOMetadata.ProfileVersion == item.ProfileVersion &&
// a.ISOMetadata.MetadataLink == item.MetadataLink
// ).FirstOrDefault();
var existingSourcesItem = context.Sources
.Where(a => a.SourceCode == source.SourceCode).FirstOrDefault();
if (existingSourcesItem == null)
{
var existInUpload = listOfCorrectRecords.Exists(a => a.SourceCode == item.SourceCode);
if (!existInUpload)
{
//update model
source.MetadataID = isometadata.MetadataID;
context.Sources.Add(source);
//context.SaveChanges();
listOfCorrectRecords.Add(item);
}
else
{
var err = new ErrorModel("AddSources", string.Format(Ressources.IMPORT_VALUE_ISDUPLICATE, "SourceCode")); listOfErrors.Add(err); isRejected = true;
listOfIncorrectRecords.Add(item);
item.Errors += err.ErrorMessage + ";";
}
}
else
{
if (existingSourcesItem.SourceCode != source.SourceCode) { listOfUpdates.Add(new UpdateFieldsModel("Sources", "SourcesCode", existingSourcesItem.SourceCode.ToString(), item.SourceCode.ToString())); }
if (source.Organization != null && existingSourcesItem.Organization != source.Organization) { listOfUpdates.Add(new UpdateFieldsModel("Sources", "Organization", existingSourcesItem.Organization.ToString(), item.Organization.ToString())); }
if (source.SourceDescription != null && existingSourcesItem.SourceDescription != source.SourceDescription) { listOfUpdates.Add(new UpdateFieldsModel("Sources", "SourceDescription", existingSourcesItem.SourceDescription.ToString(), item.SourceDescription.ToString())); }
if (source.SourceLink != null && existingSourcesItem.SourceLink != source.SourceLink) { listOfUpdates.Add(new UpdateFieldsModel("Sources", "SourceLink", existingSourcesItem.SourceLink.ToString(), item.SourceLink.ToString())); }
if (source.ContactName != null && existingSourcesItem.ContactName != source.ContactName) { listOfUpdates.Add(new UpdateFieldsModel("Sources", "ContactName", existingSourcesItem.ContactName.ToString(), item.ContactName.ToString())); }
if (source.Phone != null && existingSourcesItem.Phone != source.Phone) { listOfUpdates.Add(new UpdateFieldsModel("Sources", "Phone", existingSourcesItem.Phone.ToString(), item.Phone.ToString())); }
if (source.Email != null && existingSourcesItem.Email != source.Email) { listOfUpdates.Add(new UpdateFieldsModel("Sources", "Email", existingSourcesItem.Email.ToString(), item.Email.ToString())); }
if (source.Address != null && existingSourcesItem.Address != source.Address) { listOfUpdates.Add(new UpdateFieldsModel("Sources", "Address", existingSourcesItem.Address.ToString(), item.Address.ToString())); }
if (source.City != null && existingSourcesItem.City != source.City) { listOfUpdates.Add(new UpdateFieldsModel("Sources", "City", existingSourcesItem.City.ToString(), item.City.ToString())); }
if (source.State != null && existingSourcesItem.State != source.State) { listOfUpdates.Add(new UpdateFieldsModel("Sources", "State", existingSourcesItem.State.ToString(), item.State.ToString())); }
if (source.ZipCode != null && existingSourcesItem.ZipCode != source.ZipCode) { listOfUpdates.Add(new UpdateFieldsModel("Sources", "ZipCode", existingSourcesItem.ZipCode.ToString(), item.ZipCode.ToString())); }
if (source.Citation != null && existingSourcesItem.Citation != source.Citation) { listOfUpdates.Add(new UpdateFieldsModel("Sources", "Citation", existingSourcesItem.Citation.ToString(), item.Citation.ToString())); }
if (isometadata.TopicCategory != null && existingSourcesItem.ISOMetadata.TopicCategory != isometadata.TopicCategory) { listOfUpdates.Add(new UpdateFieldsModel("Sources", "TopicCategory", existingSourcesItem.ISOMetadata.TopicCategory.ToString(), item.TopicCategory.ToString())); }
if (isometadata.Title != null && existingSourcesItem.ISOMetadata.Title != isometadata.Title) { listOfUpdates.Add(new UpdateFieldsModel("Sources", "Title", existingSourcesItem.ISOMetadata.Title.ToString(), item.Title.ToString())); }
if (isometadata.Abstract != null && existingSourcesItem.ISOMetadata.Abstract != isometadata.Abstract) { listOfUpdates.Add(new UpdateFieldsModel("Sources", "Abstract", existingSourcesItem.ISOMetadata.Abstract.ToString(), item.Abstract.ToString())); }
if (isometadata.ProfileVersion != null && existingSourcesItem.ISOMetadata.ProfileVersion != isometadata.ProfileVersion) { listOfUpdates.Add(new UpdateFieldsModel("Sources", "ProfileVersion", existingSourcesItem.ISOMetadata.ProfileVersion.ToString(), item.ProfileVersion.ToString())); }
if (isometadata.MetadataLink != null && existingSourcesItem.ISOMetadata.MetadataLink != isometadata.MetadataLink) { listOfUpdates.Add(new UpdateFieldsModel("Sources", "MetadataLink", existingSourcesItem.ISOMetadata.MetadataLink.ToString(), item.MetadataLink.ToString())); }
if (listOfUpdates.Count() > 0)
{
listOfEditedRecords.Add(item);
var sb = new StringBuilder();
foreach (var u in listOfUpdates)
{
sb.Append(string.Format(Ressources.IMPORT_VALUE_UPDATED, u.ColumnName, u.CurrentValue, u.UpdatedValue + ";"));
}
item.Errors = sb.ToString();
continue;
}
else
{
listOfDuplicateRecords.Add(item);
}
}
}
catch (Exception ex)
{
listOfIncorrectRecords.Add(item);
}
}
return;
}
public void AddSamples(List<SampleModel> itemList, string entityConnectionString, string instanceIdentifier, out List<SampleModel> listOfIncorrectRecords, out List<SampleModel> listOfCorrectRecords, out List<SampleModel> listOfDuplicateRecords, out List<SampleModel> listOfEditedRecords)
{
listOfIncorrectRecords = new List<SampleModel>();
listOfCorrectRecords = new List<SampleModel>();
listOfDuplicateRecords = new List<SampleModel>();
listOfEditedRecords = new List<SampleModel>();
var context = new ODM_1_1_1EFModel.ODM_1_1_1Entities(entityConnectionString);
//prefetch Units for quick lookup
//var labMethods = context.LabMethods.ToList();
var sampleTypeCV = context.SampleTypeCVs.ToList();
var labMethods = context.LabMethods.ToDictionary(p => p.LabMethodName, p => p.LabMethodID);
var maxCount = itemList.Count;
var count = 0;
BusinessObjectsUtils.UpdateCachedprocessStatusMessage(instanceIdentifier, CacheName, String.Format(Ressources.IMPORT_STATUS_PROCESSING, count, maxCount));
foreach (var item in itemList)
{
try
{
BusinessObjectsUtils.UpdateCachedprocessStatusMessage(instanceIdentifier, CacheName, String.Format(Ressources.IMPORT_STATUS_PROCESSING, count, maxCount));
count++;
var listOfErrors = new List<ErrorModel>();
var listOfUpdates = new List<UpdateFieldsModel>();
bool isRejected = false;
var model = new Sample();
//set default values
string unk = "Unknown";
model.SampleType = unk;
model.LabMethodID = 0;
//SampleType
if (!string.IsNullOrWhiteSpace(item.SampleType))
{
var sampleType = sampleTypeCV
.Exists(a => a.Term.ToString() == item.SampleType);
if (!sampleType)
{
var err = new ErrorModel("AddSamples", string.Format(Ressources.IMPORT_VALUE_NOT_IN_CV, item.SampleType, "SampleType"));
listOfErrors.Add(err);
isRejected = true;
}
else
{
model.SampleType = item.SampleType;
}
}
else
{
var err = new ErrorModel("AddSamples", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "SampleType")); listOfErrors.Add(err); isRejected = true;
}
//LabSampleCode
if (!string.IsNullOrWhiteSpace(item.LabSampleCode))
{
if (RepositoryUtils.containsSpecialCharacters(item.LabSampleCode))
{
var err = new ErrorModel("AddSamples", string.Format(Ressources.IMPORT_VALUE_INVALIDCHARACTERS, "LabSampleCode")); listOfErrors.Add(err); isRejected = true;
}
else
{
model.LabSampleCode = item.LabSampleCode;
}
}
else
{
var err = new ErrorModel("AddSamples", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "LabSampleCode")); listOfErrors.Add(err); isRejected = true;
}
//LabMethodID
if (!string.IsNullOrWhiteSpace(item.LabMethodName))
{
if (RepositoryUtils.containsSpecialCharacters(item.LabMethodName))
{
var err = new ErrorModel("AddSamples", string.Format(Ressources.IMPORT_VALUE_INVALIDCHARACTERS, "LabMethodName")); listOfErrors.Add(err); isRejected = true;
}
else
{
if (labMethods.ContainsKey(item.LabMethodName))
{
var labMethodId = labMethods[item.LabMethodName];
//update model
model.LabMethodID = labMethodId;
item.LabMethodID = labMethodId.ToString();
}
else
{
var err = new ErrorModel("AddSamples", string.Format(Ressources.IMPORT_VALUE_NOT_IN_DATABASE, item.LabMethodName, "LabMethodName")); listOfErrors.Add(err); isRejected = true;
}
}
}
else
{
var err = new ErrorModel("AddSamples", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "LabMethodName")); listOfErrors.Add(err); isRejected = true;
}
if (isRejected)
{
var sb = new StringBuilder();
foreach (var er in listOfErrors)
{
sb.Append(er.ErrorMessage + ";");
}
item.Errors = sb.ToString();
listOfIncorrectRecords.Add(item);
continue;
}
//need to look up Id's for LabMethodId
//User has no concept of ID's
//lookup LabmethodId
//if (item.LabMethodName != null)
//{
// if (labMethods.ContainsKey(item.LabMethodName))
// {
// var labMethodsId = labMethods[item.LabMethodName];
// //update model
// model.LabMethodID = labMethodsId;
// }
// else
// {
// //if CSV has LabMethidId specified convert and process
// int labMethodId;
// bool res = int.TryParse(item.LabMethodName, out labMethodId);
// if (res)
// {
// //update model
// model.LabMethodID = labMethodId;
// }
// else
// {
// listOfIncorrectRecords.Add(item);
// continue;
// }
// }
//}
//else
//{
// listOfIncorrectRecords.Add(item);
// continue;
//}
//lookup duplicates
//var existingItem = context.Samples.Where(a => a.SampleType == model.SampleType &&
// a.LabSampleCode == model.LabSampleCode &&
// a.LabMethodID == a.LabMethodID
// ).FirstOrDefault();
var existingItem = context.Samples.Where(a => a.LabSampleCode == model.LabSampleCode).FirstOrDefault();
if (existingItem == null)
{
var existInUpload = listOfCorrectRecords.Exists(a => a.LabSampleCode == item.LabSampleCode);
if (!existInUpload)
{
//context.Sites.Add(model);
//context.SaveChanges();
listOfCorrectRecords.Add(item);
}
else
{
var err = new ErrorModel("AddSample", string.Format(Ressources.IMPORT_VALUE_ISDUPLICATE, "LabSampleCode")); listOfErrors.Add(err); isRejected = true;
listOfIncorrectRecords.Add(item);
item.Errors += err.ErrorMessage + ";";
}
}
else
{
//if (existingItem.LabSampleCode != model.LabSampleCode) { listOfUpdates.Add(new UpdateFieldsModel("Sample", "LabSampleCode", existingItem.LabSampleCode.ToString(), item.LabSampleCode.ToString())); }
if (model.SampleType != null && existingItem.SampleType != model.SampleType) { listOfUpdates.Add(new UpdateFieldsModel("Sample", "SampleType", existingItem.SampleType.ToString(), item.SampleType.ToString())); }
if (model.LabMethodID != null && existingItem.LabMethodID != model.LabMethodID) { listOfUpdates.Add(new UpdateFieldsModel("Sample", "LabMethodID", existingItem.LabMethodID.ToString(), item.LabMethodID.ToString())); }
if (listOfUpdates.Count() > 0)
{
listOfEditedRecords.Add(item);
var sb = new StringBuilder();
foreach (var u in listOfUpdates)
{
sb.Append(string.Format(Ressources.IMPORT_VALUE_UPDATED, u.ColumnName, u.CurrentValue, u.UpdatedValue + ";"));
}
item.Errors = sb.ToString();
continue;
}
else
{
listOfDuplicateRecords.Add(item);
}
}
}
catch (Exception ex)
{
listOfIncorrectRecords.Add(item);
}
}
return;
}
public void AddDataValues(List<DataValuesModel> itemList, string entityConnectionString, string instanceIdentifier, out List<DataValuesModel> listOfIncorrectRecords, out List<DataValuesModel> listOfCorrectRecords, out List<DataValuesModel> listOfDuplicateRecords, out List<DataValuesModel> listOfEditedRecords)
{
listOfIncorrectRecords = new List<DataValuesModel>();
listOfCorrectRecords = new List<DataValuesModel>();
listOfDuplicateRecords = new List<DataValuesModel>();
listOfEditedRecords = new List<DataValuesModel>();
//debug
var timeTocomplete = new TimeSpan();
var timeToRetrieveVars = new TimeSpan();
var timeToFindDatavalues = new TimeSpan();
var timeExistInUpload = new TimeSpan();
var timeToFindDuplicates = new TimeSpan();
int maxAllowedDuplicates = int.Parse(System.Configuration.ConfigurationManager.AppSettings["maxAllowedDuplicates"]);
var recordsToInsert = new List<DataValue>();
var startTime = DateTime.Now;
var context = new ODM_1_1_1EFModel.ODM_1_1_1Entities(entityConnectionString);
//context.Database.CommandTimeout = 10000;
//var objContext = ((IObjectContextAdapter)context).ObjectContext;
//get data to lookup values
var sitesIds = context.Sites.ToDictionary(p => p.SiteCode, p => p.SiteID);
var variablesIds = context.Variables.ToDictionary(p => p.VariableCode, p => p.VariableID);
var offsetTypeIds = context.OffsetTypes.ToDictionary(p => p.OffsetTypeCode, p => p.OffsetTypeID);
var censorCodeCV = context.CensorCodeCVs.ToList();
var qualifierIds = context.Qualifiers.ToDictionary(p => p.QualifierCode, p => p.QualifierID);
var methodIds = context.Methods.ToDictionary(p => p.MethodCode, p => p.MethodID);
var sourceIds = context.Sources.ToDictionary(p => p.SourceCode, p => p.SourceID);
var sampleIds = context.Samples.ToDictionary(p => p.LabSampleCode, p => p.SampleID);
//var derivedFromIds = context.DerivedFroms.Select(p => p.DerivedFromID);
var qualityControlLevelIds = context.QualityControlLevels.ToDictionary(p => p.QualityControlLevelCode, p => p.QualityControlLevelID);
//get unique sitecodes to speed up search
var uniqueSitecodes = itemList.GroupBy(g => g.SiteCode).Select(grp => new { SiteCode = grp.Key }).ToList();
var maxCount = itemList.Count;
var count = 0;
var a_end = DateTime.Now;
timeToRetrieveVars = a_end - startTime;
Debug.WriteLine("timeToRetrieveVars:" + timeToRetrieveVars);
try
{
foreach (var site in uniqueSitecodes)
{
int currentSiteId = 0;
if (sitesIds.ContainsKey(site.SiteCode))
{
currentSiteId = sitesIds[site.SiteCode];
//update model
}
var a_start = DateTime.Now;
//var datavaluesWithSiteIDInDatabase = context.DataValues.Select(p => p).Where(f.Equals(currentSiteId)).ToList();
List<DataValue> datavaluesWithSiteIDInDatabase = (from d in context.DataValues.AsNoTracking()
where d.SiteID == currentSiteId
select d).ToList();
HashSet <DateTime> setDatetime = new HashSet<DateTime>(from d in context.DataValues.AsNoTracking()
where d.SiteID == currentSiteId
select d.DateTimeUTC);
HashSet<double> setDataValue = new HashSet<double>(from d in context.DataValues.AsNoTracking()
where d.SiteID == currentSiteId
select d.DataValue1);
HashSet<int> setVariableId = new HashSet<int>(from d in context.DataValues.AsNoTracking()
where d.SiteID == currentSiteId
select d.VariableID);
HashSet<int> setMethodId = new HashSet<int>(from d in context.DataValues.AsNoTracking()
where d.SiteID == currentSiteId
select d.MethodID);
a_end = DateTime.Now;
HashSet<DataValue> allValues = new HashSet<DataValue>((from d in context.DataValues.AsNoTracking()
where d.SiteID == currentSiteId
select d).ToList());
//List<HashSet<string>> lines = new List<HashSet<string>>(); //Hashset is very fast in searching duplicates
//datavaluesWithSiteIDInDatabase.ForEach(a=>
// a.DataValue1.ToString() +
// a.ValueAccuracy.ToString() +
// a.LocalDateTime.Ticks.ToString() +
// a.UTCOffset.ToString() +
// a.DateTimeUTC.Ticks.ToString() +
// a.SiteID.ToString() +
// a.VariableID.ToString() +
// a.OffsetValue.ToString() +
// a.OffsetTypeID.ToString() +
// a.CensorCode.ToString() +
// a.QualifierID.ToString()+
// a.MethodID.ToString() +
// a.SourceID.ToString() +
// a.SampleID.ToString() +
// a.DerivedFromID.ToString() +
// a.QualityControlLevelID.ToString()
// )
var span = a_end - a_start;
timeToFindDatavalues.Add(span);
Debug.WriteLine("timeToRetrieve " + site.SiteCode + ": " + span);
BusinessObjectsUtils.UpdateCachedprocessStatusMessage(instanceIdentifier, CacheName, String.Format(Ressources.IMPORT_STATUS_PROCESSING, count, maxCount, listOfCorrectRecords.Count(), listOfIncorrectRecords.Count(), listOfDuplicateRecords.Count()));
#region loop through series
var filteredList = (from i in itemList
where i.SiteCode == site.SiteCode
select i);
//var distinctList = filteredList.Distinct().ToList();
//var duplicateList = from x in filteredList
// group x by x into grouped
// where grouped.Count() == 1
// select grouped.Key;
foreach (var item in filteredList)
{
try
{
BusinessObjectsUtils.UpdateCachedprocessStatusMessage(instanceIdentifier, CacheName, String.Format(Ressources.IMPORT_STATUS_PROCESSING, count, maxCount, listOfCorrectRecords.Count(), listOfIncorrectRecords.Count(), listOfDuplicateRecords.Count()));
count++;
#region data matching
bool isRejected = false;
var model = new DataValue();
var listOfErrors = new List<ErrorModel>();
//set default values
string unk = "Unknown";
model.ValueAccuracy = null;
model.OffsetValue = null;
model.OffsetTypeID = null;
model.CensorCode = "nc";
model.QualifierID = null;
model.MethodID = 0;
model.SampleID = null;
model.DerivedFromID = null;
model.QualityControlLevelID = -9999;
//DataValue
if (!string.IsNullOrWhiteSpace(item.DataValue))
{
double result;
bool canConvert = UniversalTypeConverter.TryConvertTo<double>(item.DataValue, out result);
//NaN can be converted properly ino a double sql field is a float and will not accept this so we need to test separately for NaN and reject
if (!canConvert || Double.IsNaN(result))
{
var err = new ErrorModel("AddDataValues", string.Format(Ressources.IMPORT_VALUE_INVALIDVALUE, "DataValue")); listOfErrors.Add(err); isRejected = true;
}
else
{
model.DataValue1 = result;
}
}
else
{
var err = new ErrorModel("AddDataValues", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "DataValue")); listOfErrors.Add(err); isRejected = true;
}
//ValueAccuracy
if (!string.IsNullOrWhiteSpace(item.ValueAccuracy))
{
double result;
bool canConvert = UniversalTypeConverter.TryConvertTo<double>(item.ValueAccuracy, out result);
if (!canConvert)
{
var err = new ErrorModel("AddDataValues", string.Format(Ressources.IMPORT_VALUE_INVALIDVALUE, "ValueAccuracy")); listOfErrors.Add(err); isRejected = true;
}
else
{
model.ValueAccuracy = result;
}
}
//LocalDateTime
if (!string.IsNullOrWhiteSpace(item.LocalDateTime))
{
DateTime result;
bool canConvert = UniversalTypeConverter.TryConvertTo<DateTime>(item.LocalDateTime, out result);
if (!canConvert)
{
var err = new ErrorModel("AddDataValues", string.Format(Ressources.IMPORT_VALUE_INVALIDVALUE, "LocalDateTime")); listOfErrors.Add(err); isRejected = true;
}
else
{
model.LocalDateTime = result;
}
}
else
{
var err = new ErrorModel("AddDataValues", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "LocalDateTime")); listOfErrors.Add(err); isRejected = true;
}
//UTCOffset
if (!string.IsNullOrWhiteSpace(item.UTCOffset))
{
double result;
bool canConvert = UniversalTypeConverter.TryConvertTo<double>(item.UTCOffset, out result);
if (!canConvert)
{
var err = new ErrorModel("AddDataValues", string.Format(Ressources.IMPORT_VALUE_INVALIDVALUE, "UTCOffset")); listOfErrors.Add(err); isRejected = true;
}
else
{
model.UTCOffset = result;
}
}
else
{
var err = new ErrorModel("AddDataValues", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "UTCOffset")); listOfErrors.Add(err); isRejected = true;
}
//DateTimeUTC
if (!string.IsNullOrWhiteSpace(item.DateTimeUTC))
{
DateTime result;
bool canConvert = UniversalTypeConverter.TryConvertTo<DateTime>(item.DateTimeUTC, out result);
if (!canConvert)
{
var err = new ErrorModel("AddDataValues", string.Format(Ressources.IMPORT_VALUE_INVALIDVALUE, "DateTimeUTC")); listOfErrors.Add(err); isRejected = true;
}
else
{
model.DateTimeUTC = result;
}
}
else
{
var err = new ErrorModel("AddDataValues", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "DateTimeUTC")); listOfErrors.Add(err); isRejected = true;
}
//SiteCode
if (!string.IsNullOrWhiteSpace(item.SiteCode))
{
if (RepositoryUtils.containsSpecialCharacters(item.SiteCode))
{
var err = new ErrorModel("AddDataValues", string.Format(Ressources.IMPORT_VALUE_INVALIDCHARACTERS, "SiteCode")); listOfErrors.Add(err); isRejected = true;
}
else
{
if (sitesIds.ContainsKey(item.SiteCode))
{
var siteId = sitesIds[item.SiteCode];
//update model
model.SiteID = siteId;
item.SiteID = siteId.ToString();
}
else
{
var err = new ErrorModel("AddDataValues", string.Format(Ressources.IMPORT_VALUE_NOT_IN_DATABASE, item.SiteCode, "SiteCode")); listOfErrors.Add(err); isRejected = true;
//continue;
}
}
}
else
{
var err = new ErrorModel("AddDataValues", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "SiteCode")); listOfErrors.Add(err); isRejected = true;
}
//VariableID
//VariableCode
if (!string.IsNullOrWhiteSpace(item.VariableCode))
{
if (RepositoryUtils.containsSpecialCharacters(item.VariableCode))
{
var err = new ErrorModel("AddDataValues", string.Format(Ressources.IMPORT_VALUE_INVALIDCHARACTERS, "VariableCode")); listOfErrors.Add(err); isRejected = true;
}
else
{
if (variablesIds.ContainsKey(item.VariableCode))
{
var variableId = variablesIds[item.VariableCode];
//update model
model.VariableID = variableId;
item.VariableID = variableId.ToString();
}
else
{
var err = new ErrorModel("AddDataValues", string.Format(Ressources.IMPORT_VALUE_NOT_IN_DATABASE, item.VariableCode, "VariableCode")); listOfErrors.Add(err); isRejected = true;
//continue;
}
}
}
else
{
var err = new ErrorModel("AddVariables", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "VariableCode")); listOfErrors.Add(err); isRejected = true;
}
//OffsetValue
if (!string.IsNullOrWhiteSpace(item.OffsetValue))
{
double result;
bool canConvert = UniversalTypeConverter.TryConvertTo<double>(item.OffsetValue, out result);
if (!canConvert)
{
var err = new ErrorModel("AddDataValues", string.Format(Ressources.IMPORT_VALUE_INVALIDVALUE, "OffsetValue")); listOfErrors.Add(err); isRejected = true;
}
else
{
model.OffsetValue = result;
}
}
//OffsetTypeID
if (!string.IsNullOrWhiteSpace(item.OffsetTypeCode))
{
if (RepositoryUtils.containsSpecialCharacters(item.OffsetTypeCode))
{
var err = new ErrorModel("AddDataValues", string.Format(Ressources.IMPORT_VALUE_INVALIDVALUE, "OffsetTypeCode")); listOfErrors.Add(err); isRejected = true;
}
else
{
if (offsetTypeIds.ContainsKey(item.OffsetTypeCode))
{
var offsetTypeId = offsetTypeIds[item.OffsetTypeCode];
//update model
model.OffsetTypeID = offsetTypeId;
item.OffsetTypeID = offsetTypeId.ToString();
}
else
{
var err = new ErrorModel("AddDataValues", string.Format(Ressources.IMPORT_VALUE_NOT_IN_DATABASE, item.OffsetTypeID, "OffsetType")); listOfErrors.Add(err); isRejected = true;
}
}
}
//CensorCode
if (!string.IsNullOrWhiteSpace(item.CensorCode))
{
if (RepositoryUtils.containsSpecialCharacters(item.CensorCode))
{
var err = new ErrorModel("AddDataValues", string.Format(Ressources.IMPORT_VALUE_INVALIDCHARACTERS, "CensorCode")); listOfErrors.Add(err); isRejected = true;
}
else
{
var censorCode = censorCodeCV
.Where(a => a.Term.ToLower() == item.CensorCode.ToLower()).FirstOrDefault();
if (censorCode != null)
{
model.CensorCode = item.CensorCode;
item.CensorCode = censorCode.Term;
}
else
{
var err = new ErrorModel("AddDataValues", string.Format(Ressources.IMPORT_VALUE_NOT_IN_CV, item.CensorCode, "CensorCode")); listOfErrors.Add(err); isRejected = true;
}
}
}
else
{
var err = new ErrorModel("AddDataValues", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "CensorCode")); listOfErrors.Add(err); isRejected = true;
}
//QualifierID
if (!string.IsNullOrWhiteSpace(item.QualifierCode))
{
if (RepositoryUtils.containsSpecialCharacters(item.QualifierCode))
{
var err = new ErrorModel("AddDataValues", string.Format(Ressources.IMPORT_VALUE_INVALIDVALUE, "QualifierCode")); listOfErrors.Add(err); isRejected = true;
}
else
{
if (qualifierIds.ContainsKey(item.QualifierCode))
{
var qualifierId = qualifierIds[item.QualifierCode];
//update model
model.QualifierID = qualifierId;
item.QualifierID = qualifierId.ToString();
}
else
{
var err = new ErrorModel("AddDataValues", string.Format(Ressources.IMPORT_VALUE_NOT_IN_DATABASE, item.QualifierID, "QualifierCode")); listOfErrors.Add(err); isRejected = true;
}
}
}
//MethodID
if (!string.IsNullOrWhiteSpace(item.MethodCode))
{
if (RepositoryUtils.containsSpecialCharacters(item.MethodCode))
{
var err = new ErrorModel("AddDataValues", string.Format(Ressources.IMPORT_VALUE_INVALIDVALUE, "MethodCode")); listOfErrors.Add(err); isRejected = true;
}
else
{
if (methodIds.ContainsKey(item.MethodCode))
{
var methodId = methodIds[item.MethodCode];
//update model
model.MethodID = methodId;
item.MethodID = methodId.ToString();
}
else
{
var err = new ErrorModel("AddDataValues", string.Format(Ressources.IMPORT_VALUE_NOT_IN_DATABASE, item.MethodID, "MethodCode")); listOfErrors.Add(err); isRejected = true;
}
}
}
else
{
var err = new ErrorModel("AddDataValues", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "MethodCode")); listOfErrors.Add(err); isRejected = true;
}
//SourceID
if (!string.IsNullOrWhiteSpace(item.SourceCode))
{
if (RepositoryUtils.containsSpecialCharacters(item.SourceCode))
{
var err = new ErrorModel("AddDataValues", string.Format(Ressources.IMPORT_VALUE_INVALIDVALUE, "SourceCode")); listOfErrors.Add(err); isRejected = true;
}
else
{
if (sourceIds.ContainsKey(item.SourceCode))
{
var sourceId = sourceIds[item.SourceCode];
//update model
model.SourceID = sourceId;
item.SourceID = sourceId.ToString();
}
else
{
var err = new ErrorModel("AddDataValues", string.Format(Ressources.IMPORT_VALUE_NOT_IN_DATABASE, item.SourceID, "SourceCode")); listOfErrors.Add(err); isRejected = true;
}
}
}
else
{
var err = new ErrorModel("AddDataValues", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "SourceCode")); listOfErrors.Add(err); isRejected = true;
}
//SampleID- labsamplecode is unique identifier
if (!string.IsNullOrWhiteSpace(item.LabSampleCode))
{
if (RepositoryUtils.containsSpecialCharacters(item.LabSampleCode))
{
var err = new ErrorModel("AddDataValues", string.Format(Ressources.IMPORT_VALUE_INVALIDVALUE, "LabSampleCode")); listOfErrors.Add(err); isRejected = true;
}
else
{
if (sampleIds.ContainsKey(item.LabSampleCode))
{
var sampleId = sampleIds[item.LabSampleCode];
//update model
model.SampleID = sampleId;
item.SampleID = sampleId.ToString();
}
else
{
var err = new ErrorModel("AddDataValues", string.Format(Ressources.IMPORT_VALUE_NOT_IN_DATABASE, item.SampleID, "LabSampleCode")); listOfErrors.Add(err); isRejected = true;
}
}
}
//DerivedFromID
if (!string.IsNullOrWhiteSpace(item.DerivedFromID))
{
int result;
bool canConvert = UniversalTypeConverter.TryConvertTo<int>(item.DerivedFromID, out result);
if (!canConvert)
{
var err = new ErrorModel("AddDataValues", string.Format(Ressources.IMPORT_VALUE_INVALIDVALUE, "DerivedFromID")); listOfErrors.Add(err); isRejected = true;
}
else
{
model.DerivedFromID = result;
}
}
//QualityControlLevelID
if (!string.IsNullOrWhiteSpace(item.QualityControlLevelCode))
{
if (qualityControlLevelIds.ContainsKey(item.QualityControlLevelCode))
{
var qualityControlLevelId = qualityControlLevelIds[item.QualityControlLevelCode];
//update model
model.QualityControlLevelID = qualityControlLevelId;
item.QualityControlLevelID = qualityControlLevelId.ToString();
}
else
{
var err = new ErrorModel("AddDataValues", string.Format(Ressources.IMPORT_VALUE_NOT_IN_CV, item.QualityControlLevelCode, "QualityControlLevelCode")); listOfErrors.Add(err); isRejected = true;
}
}
else
{
var err = new ErrorModel("AddDataValues", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "QualityControlLevelCode")); listOfErrors.Add(err); isRejected = true;
}
//lookup siteid
//if (variables.ContainsKey(item.VariableCode))
//{
// var variableId = variables[item.VariableCode];
// update model
// model.VariableID = variableId;
//}
//else
//{
// var err = new ErrorModel("AddDataValues", string.Format(Ressources.IMPORT_VALUE_NOT_IN_CV, item.VariableCode, "AddDataValues")); listOfErrors.Add(err); isRejected = true;
//}
//if (model.OffsetTypeID != null)
//{
// var offsetTyperID = OffsetTypeIds
// .Exists(a => a == model.OffsetTypeID);
// var err = new ErrorModel("AddDataValues", string.Format(Ressources.IMPORT_VALUE_NOT_IN_DATABASE, item.OffsetTypeID.ToString(), "OffsetTypes:")); listOfErrors.Add(err); isRejected = true;
//}
//if (model.CensorCode != "nc")
//{
// var censorCode = censorCodeCV
// .Exists(a => a.Term == item.CensorCode);
// if (!censorCode) { var err = new ErrorModel("AddDataValues", string.Format(Ressources.IMPORT_VALUE_NOT_IN_CV, item.OffsetTypeID, "AddDataValues")); listOfErrors.Add(err); isRejected = true; };
//}
//if (model.QualifierID != null)
//{
// var censorCode = censorCodeCV
// .Exists(a => a.Term == item.CensorCode);
// if (!censorCode) { var err = new ErrorModel("AddDataValues", string.Format(Ressources.IMPORT_VALUE_NOT_IN_DATABASE, item.QualifierID, "Qualifiers")); listOfErrors.Add(err); isRejected = true; };
//}
//if (model.MethodID != null)
//{
// var methodId = methodIds
// .Exists(a => a.MethodID == model.MethodID);
// if (!methodId) { var err = new ErrorModel("AddDataValues", string.Format(Ressources.IMPORT_VALUE_NOT_IN_DATABASE, item.MethodID, "Methods")); listOfErrors.Add(err); isRejected = true; };
//}
//if (model.SourceID != null)
//{
// var sourceId = sourceIds
// .Exists(a => a.SourceID == model.SourceID);
// if (!sourceId) { var err = new ErrorModel("AddDataValues", string.Format(Ressources.IMPORT_VALUE_NOT_IN_DATABASE, item.SourceID, "Sources")); listOfErrors.Add(err); isRejected = true; };
//}
//if (model.SampleID != null)
//{
// var sampleId = sampleIds
// .Exists(a => a.SampleID == model.SampleID);
// if (!sampleId) { var err = new ErrorModel("AddDataValues", string.Format(Ressources.IMPORT_VALUE_NOT_IN_DATABASE, item.SampleID, "Samples")); listOfErrors.Add(err); isRejected = true; };
//}
//if (qualityControlLevelIds.ContainsKey(item.QualityControlLevelCode))
//{
// var qualityControlLevelId = qualityControlLevelIds[item.QualityControlLevelCode];
// update model
// model.QualityControlLevelID = qualityControlLevelId;
//}
//else
//{
// var err = new ErrorModel("AddDataValues", string.Format(Ressources.IMPORT_VALUE_NOT_IN_CV, item.VariableCode, "AddDataValues")); listOfErrors.Add(err); isRejected = true;
//}
// var dataType = dataTypeCV
// .Exists(a => a.Term.ToString() == item.DataType);
#endregion data
if (isRejected)
{
var sb = new StringBuilder();
foreach (var er in listOfErrors)
{
sb.Append(er.ErrorMessage + ";");
}
item.Errors = sb.ToString();
listOfIncorrectRecords.Add(item);
continue;
}
//else
//{
// int variableId;
// bool res = int.TryParse(item.VariableID, out variableId);
// if (res)
// {
// //update model
// model.VariableID = variableId;
// }
// else
// {
// listOfIncorrectRecords.Add(item);
// continue;
// }
//}
//Validate foreign keys
//var methodId = context.Methods
// .Where(a => a.MethodID == model.MethodID)
// .Select(a => a);
//lookup duplicates
//check if item with this sitecode exists in the database
//check in list
//var siteidInList = datavaluesWithSiteIDInDatabase.ToList().Find(p => p.SiteID.ToString() == item.SiteID);
a_start = DateTime.Now;
bool doesExist = false;
//pretest with date and datavalue if
var possibleInSet = setDatetime.Contains(model.DateTimeUTC) && setDataValue.Contains(model.DataValue1) && setVariableId.Contains(model.VariableID) && setMethodId.Contains(model.MethodID);
//var possibleInSet2 = foo.Contains(model);
//allValues.Add(model);
if (possibleInSet)
{
doesExist = allValues.Where(a =>
a.DataValue1.Equals(model.DataValue1) &&
a.ValueAccuracy.Equals(model.ValueAccuracy) &&
a.LocalDateTime.Equals(model.LocalDateTime) &&
a.UTCOffset.Equals(model.UTCOffset) &&
a.DateTimeUTC.Ticks.Equals(model.DateTimeUTC.Ticks) &&
a.SiteID.Equals(model.SiteID) &&
a.VariableID.Equals(model.VariableID) &&
a.OffsetValue.Equals(model.OffsetValue) &&
a.OffsetTypeID.Equals(model.OffsetTypeID) &&
a.CensorCode.Equals(model.CensorCode) &&
a.QualifierID.Equals(model.QualifierID) &&
a.MethodID.Equals(model.MethodID) &&
a.SourceID.Equals(model.SourceID) &&
a.SampleID.Equals(model.SampleID) &&
a.DerivedFromID.Equals(model.DerivedFromID) &&
a.QualityControlLevelID.Equals(model.QualityControlLevelID)
).FirstOrDefault() != null;
a_end = DateTime.Now;
span = a_end - a_start;
timeToFindDuplicates = timeToFindDuplicates.Add(span);
//Debug.WriteLine("timeToFindDuplicates: " + span);
}
if (!doesExist)
{
if (count % 100 == 0) Debug.WriteLine(count);
listOfCorrectRecords.Add(item);
}
else
{
//no editing possible no unique field in upload
if (listOfDuplicateRecords.Count() > maxAllowedDuplicates )
{
throw new System.OperationCanceledException("The upload was cancelled due to a large number of duplicates (" + maxAllowedDuplicates + ") in upload. Please review data.");
}
listOfDuplicateRecords.Add(item);
}
}
catch (OperationCanceledException ex)
{
throw;
}
catch (Exception ex)
{
listOfIncorrectRecords.Add(item);
}
}
#endregion
}
}
catch (OperationCanceledException ex)
{
throw;
}
catch (Exception ex)
{
throw;
}
//context.SaveChanges();
//Pass in cnx, tablename, and list of imports
//RepositoryUtils.BulkInsert(context.Database.Connection.ConnectionString, "Datavalues", recordsToInsert);
//RepositoryUtils.UpdateSeriesCatalog(context.Database.Connection.ConnectionString);
Debug.WriteLine("timeToRetrieveVars:" + timeToRetrieveVars);
Debug.WriteLine("timeToFindDatavalues: " + timeToFindDatavalues);
Debug.WriteLine("timeToFindDuplicates: " + timeToFindDuplicates);
Debug.WriteLine("timeExistInUpload: " + timeExistInUpload);
timeTocomplete = DateTime.Now - startTime;
Debug.WriteLine("timeTocomplete: " + timeTocomplete);
//BusinessObjectsUtils.UpdateCachedprocessStatusMessage(instanceIdentifier, CacheName, String.Format(Ressources.IMPORT_STATUS_PROCESSING_DONE, count, maxCount));
return;
}
public void AddQualityControlLevel(List<QualityControlLevelModel> itemList, string entityConnectionString, string instanceIdentifier, out List<QualityControlLevelModel> listOfIncorrectRecords, out List<QualityControlLevelModel> listOfCorrectRecords, out List<QualityControlLevelModel> listOfDuplicateRecords, out List<QualityControlLevelModel> listOfEditedRecords)
{
listOfIncorrectRecords = new List<QualityControlLevelModel>();
listOfCorrectRecords = new List<QualityControlLevelModel>();
listOfDuplicateRecords = new List<QualityControlLevelModel>();
listOfEditedRecords = new List<QualityControlLevelModel>();
var context = new ODM_1_1_1EFModel.ODM_1_1_1Entities(entityConnectionString);
var maxCount = itemList.Count;
var count = 0;
BusinessObjectsUtils.UpdateCachedprocessStatusMessage(instanceIdentifier, CacheName, String.Format(Ressources.IMPORT_STATUS_PROCESSING, count, maxCount));
foreach (var item in itemList)
{
try
{
BusinessObjectsUtils.UpdateCachedprocessStatusMessage(instanceIdentifier, CacheName, String.Format(Ressources.IMPORT_STATUS_PROCESSING, count, maxCount));
count++;
var model = new QualityControlLevel();
var listOfErrors = new List<ErrorModel>();
var listOfUpdates = new List<UpdateFieldsModel>();
bool isRejected = false;
count++;
//QualityControlLevelCode
if (!string.IsNullOrWhiteSpace(item.QualityControlLevelCode))
{
if (RepositoryUtils.containsSpecialCharacters(item.QualityControlLevelCode))
{
var err = new ErrorModel("AddQualityControlLevel", string.Format(Ressources.IMPORT_VALUE_INVALIDCHARACTERS, "QualityControlLevelCode")); listOfErrors.Add(err); isRejected = true;
}
else
{
model.QualityControlLevelCode = item.QualityControlLevelCode;
}
}
else
{
var err = new ErrorModel("AddQualityControlLevel", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "QualityControlLevelCode")); listOfErrors.Add(err); isRejected = true;
}
//Definition
if (!string.IsNullOrWhiteSpace(item.Definition))
{
if (RepositoryUtils.containsSpecialCharacters(item.Definition))
{
var err = new ErrorModel("AddQualityControlLevel", string.Format(Ressources.IMPORT_VALUE_INVALIDCHARACTERS, "Definition")); listOfErrors.Add(err); isRejected = true;
}
else
{
model.Definition = item.Definition;
}
}
else
{
var err = new ErrorModel("AddQualityControlLevel", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "Definition")); listOfErrors.Add(err); isRejected = true;
}
//Explanation
if (!string.IsNullOrWhiteSpace(item.Explanation))
{
if (RepositoryUtils.containsSpecialCharacters(item.Explanation))
{
var err = new ErrorModel("AddQualityControlLevel", string.Format(Ressources.IMPORT_VALUE_INVALIDCHARACTERS, "Explanation")); listOfErrors.Add(err); isRejected = true;
}
else
{
model.Explanation = item.Explanation;
}
}
else
{
var err = new ErrorModel("AddQualityControlLevel", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "Explanation")); listOfErrors.Add(err); isRejected = true;
}
if (isRejected)
{
var sb = new StringBuilder();
foreach (var er in listOfErrors)
{
sb.Append(er.ErrorMessage + ";");
}
item.Errors = sb.ToString();
listOfIncorrectRecords.Add(item);
continue;
}
//lookup duplicates
var existingItem = context.QualityControlLevels.Where(a => a.QualityControlLevelCode == model.QualityControlLevelCode
//&& a.Definition == model.Definition &&
//a.Explanation == model.Explanation
).FirstOrDefault();
if (existingItem == null)
{
var existInUpload = listOfCorrectRecords.Exists(a => a.QualityControlLevelCode == item.QualityControlLevelCode);
if (!existInUpload)
{
context.QualityControlLevels.Add(model);
//context.SaveChanges();
listOfCorrectRecords.Add(item);
}
else
{
var err = new ErrorModel("AddQualityControlLevel", string.Format(Ressources.IMPORT_VALUE_ISDUPLICATE, "QualityControlLevelCode")); listOfErrors.Add(err); isRejected = true;
listOfIncorrectRecords.Add(item);
item.Errors += err.ErrorMessage + ";";
}
}
else
{
//if (existingItem.QualityControlLevelCode != model.QualityControlLevelCode) { listOfUpdates.Add(new UpdateFieldsModel("QualityControlLevels", "QualityControlLevelCode", existingItem.QualityControlLevelCode.ToString(), item.QualityControlLevelCode.ToString())); }
if (model.Definition != null && existingItem.Definition != model.Definition) { listOfUpdates.Add(new UpdateFieldsModel("QualityControlLevels", "Definition", existingItem.Definition.ToString(), item.Definition.ToString())); }
if (model.Explanation != null && existingItem.Explanation != model.Explanation) { listOfUpdates.Add(new UpdateFieldsModel("QualityControlLevels", "Explanation", existingItem.Explanation.ToString(), item.Explanation.ToString())); }
if (listOfUpdates.Count() > 0)
{
listOfEditedRecords.Add(item);
var sb = new StringBuilder();
foreach (var u in listOfUpdates)
{
sb.Append(string.Format(Ressources.IMPORT_VALUE_UPDATED, u.ColumnName, u.CurrentValue, u.UpdatedValue + ";"));
}
item.Errors = sb.ToString();
continue;
}
else
{
listOfDuplicateRecords.Add(item);
}
}
}
catch (Exception ex)
{
listOfIncorrectRecords.Add(item);
}
}
return;
}
public void AddOffsetTypes(List<OffsetTypesModel> itemList, string entityConnectionString, string instanceIdentifier, out List<OffsetTypesModel> listOfIncorrectRecords, out List<OffsetTypesModel> listOfCorrectRecords, out List<OffsetTypesModel> listOfDuplicateRecords, out List<OffsetTypesModel> listOfEditedRecords)
{
listOfIncorrectRecords = new List<OffsetTypesModel>();
listOfCorrectRecords = new List<OffsetTypesModel>();
listOfDuplicateRecords = new List<OffsetTypesModel>();
listOfEditedRecords = new List<OffsetTypesModel>();
var context = new ODM_1_1_1EFModel.ODM_1_1_1Entities(entityConnectionString);
//prefetch Units for quick lookup
var units = context.Units.ToDictionary(p => p.UnitsName.Trim(), p => p.UnitsID);
var maxCount = itemList.Count;
var count = 0;
BusinessObjectsUtils.UpdateCachedprocessStatusMessage(instanceIdentifier, CacheName, String.Format(Ressources.IMPORT_STATUS_PROCESSING, count, maxCount));
foreach (var item in itemList)
{
try
{
BusinessObjectsUtils.UpdateCachedprocessStatusMessage(instanceIdentifier, CacheName, String.Format(Ressources.IMPORT_STATUS_PROCESSING, count, maxCount));
count++;
var listOfErrors = new List<ErrorModel>();
var listOfUpdates = new List<UpdateFieldsModel>();
bool isRejected = false;
var model = new OffsetType();
//OffsetUnitsID
if (!string.IsNullOrWhiteSpace(item.OffsetUnitsName))
{
if (RepositoryUtils.containsSpecialCharacters(item.OffsetUnitsName))
{
var err = new ErrorModel("AddOffsetTypes", string.Format(Ressources.IMPORT_VALUE_INVALIDCHARACTERS, "OffsetUnitsName")); listOfErrors.Add(err); isRejected = true;
}
else
{
int result;
bool canConvert = UniversalTypeConverter.TryConvertTo<int>(item.OffsetUnitsName, out result);
if (canConvert)//user used id
{
if (result != 0) model.OffsetUnitsID = result;
else
{
var err = new ErrorModel("AddOffsetTypes", string.Format(Ressources.IMPORT_VALUE_INVALIDVALUE, "OffsetUnitsName")); listOfErrors.Add(err); isRejected = true;
}
}
else
{
var unitsID = units
.Where(a => a.Key == item.OffsetUnitsName)
.Select(a => a.Value)
.SingleOrDefault();
if (unitsID != 0)
{
model.OffsetUnitsID = unitsID;
item.OffsetUnitsID = unitsID.ToString();
}
else
{
var err = new ErrorModel("AddOffsetTypes", string.Format(Ressources.IMPORT_VALUE_INVALIDVALUE, "OffsetUnitsName")); listOfErrors.Add(err); isRejected = true;
}
}
}
}
else
{
var err = new ErrorModel("AddOffsetTypes", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "OffsetUnitsName")); listOfErrors.Add(err); isRejected = true;
}
//OffsetDescription
if (!string.IsNullOrWhiteSpace(item.OffsetDescription))
{
if (RepositoryUtils.containsSpecialCharacters(item.OffsetDescription))
{
var err = new ErrorModel("AddOffsetTypes", string.Format(Ressources.IMPORT_VALUE_INVALIDCHARACTERS, "OffsetDescription")); listOfErrors.Add(err); isRejected = true;
}
else
{
model.OffsetDescription = item.OffsetDescription;
}
}
else
{
model.OffsetDescription = null;
}
if (isRejected)
{
var sb = new StringBuilder();
foreach (var er in listOfErrors)
{
sb.Append(er.ErrorMessage + ";");
}
item.Errors = sb.ToString();
listOfIncorrectRecords.Add(item);
continue;
}
//OffsetTypeCode
if (!string.IsNullOrWhiteSpace(item.OffsetTypeCode))
{
if (RepositoryUtils.containsNotOnlyAllowedCaracters(item.OffsetTypeCode))
{
var err = new ErrorModel("AddOffsetType", string.Format(Ressources.IMPORT_VALUE_INVALIDCHARACTERS, "OffsetTypeCode")); listOfErrors.Add(err); isRejected = true;
}
else
{
model.OffsetTypeCode = item.OffsetTypeCode;
}
}
else
{
var err = new ErrorModel("AddOffsetType", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "OffsetTypeCode")); listOfErrors.Add(err); isRejected = true;
}
//lookup duplicates
//check if item with this variablecode exists in the database
var existingItem = context.OffsetTypes.Where(a => a.OffsetTypeCode == item.OffsetTypeCode).FirstOrDefault();
if (existingItem == null)
{
var existInUpload = listOfCorrectRecords.Exists(a => a.OffsetTypeCode == item.OffsetTypeCode);
if (!existInUpload)
{
//context.Sites.Add(model);
//context.SaveChanges();
listOfCorrectRecords.Add(item);
}
else
{
var err = new ErrorModel("AddOffsetType", string.Format(Ressources.IMPORT_VALUE_ISDUPLICATE, "OffsetTypeCode")); listOfErrors.Add(err); isRejected = true;
listOfIncorrectRecords.Add(item);
item.Errors += err.ErrorMessage + ";";
}
}
else
{
//if (existingItem.OffsetTypeCode != model.OffsetTypeCode) { listOfUpdates.Add(new UpdateFieldsModel("OffsetType", "OffsetTypeCode", existingItem.OffsetTypeCode.ToString(), item.OffsetTypeCode.ToString())); }
if (model.OffsetDescription != null && existingItem.OffsetDescription != model.OffsetTypeCode) { listOfUpdates.Add(new UpdateFieldsModel("OffsetType", "OffsetDescription", existingItem.OffsetDescription.ToString(), item.OffsetDescription.ToString())); }
if (model.OffsetUnitsID != null && existingItem.OffsetUnitsID != model.OffsetUnitsID) { listOfUpdates.Add(new UpdateFieldsModel("OffsetType", "OffsetUnitsID", existingItem.OffsetUnitsID.ToString(), item.OffsetUnitsName.ToString())); }
if (listOfUpdates.Count() > 0)
{
listOfEditedRecords.Add(item);
var sb = new StringBuilder();
foreach (var u in listOfUpdates)
{
sb.Append(string.Format(Ressources.IMPORT_VALUE_UPDATED, u.ColumnName, u.CurrentValue, u.UpdatedValue + ";"));
}
item.Errors = sb.ToString();
continue;
}
else
{
listOfDuplicateRecords.Add(item);
}
}
}
catch (Exception ex)
{
listOfIncorrectRecords.Add(item);
}
}
return;
}
public void AddLabMethods(List<LabMethodModel> itemList, string entityConnectionString, string instanceIdentifier, out List<LabMethodModel> listOfIncorrectRecords, out List<LabMethodModel> listOfCorrectRecords, out List<LabMethodModel> listOfDuplicateRecords, out List<LabMethodModel> listOfEditedRecords)
{
listOfIncorrectRecords = new List<LabMethodModel>();
listOfCorrectRecords = new List<LabMethodModel>();
listOfDuplicateRecords = new List<LabMethodModel>();
listOfEditedRecords = new List<LabMethodModel>();
var context = new ODM_1_1_1EFModel.ODM_1_1_1Entities(entityConnectionString);
//prefetch Units for quick lookup
var offsetUnits = context.Units.ToDictionary(p => p.UnitsName.Trim(), p => p.UnitsID);
var maxCount = itemList.Count;
var count = 0;
BusinessObjectsUtils.UpdateCachedprocessStatusMessage(instanceIdentifier, CacheName, String.Format(Ressources.IMPORT_STATUS_PROCESSING, count, maxCount));
foreach (var item in itemList)
{
try
{
BusinessObjectsUtils.UpdateCachedprocessStatusMessage(instanceIdentifier, CacheName, String.Format(Ressources.IMPORT_STATUS_PROCESSING, count, maxCount));
count++;
var model = new LabMethod();
var listOfErrors = new List<ErrorModel>();
var listOfUpdates = new List<UpdateFieldsModel>();
bool isRejected = false;
//set default values
string unk = "Unknown";
model.LabName = unk;
model.LabOrganization = unk;
model.LabMethodName = unk;
model.LabMethodDescription = unk;
////LabMethodCode
//if (!string.IsNullOrWhiteSpace(item.LabMethodCode))
//{
// if (RepositoryUtils.containsNotOnlyAllowedCaracters(item.LabMethodCode))
// {
// var err = new ErrorModel("AddLabMethod", string.Format(Ressources.IMPORT_VALUE_INVALIDCHARACTERS, "LabMethodCode")); listOfErrors.Add(err); isRejected = true;
// }
// else
// {
// model.LabMethodCode = item.LabMethodCode;
// }
//}
//else
//{
// var err = new ErrorModel("AddLabMethod", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "LabMethodCode")); listOfErrors.Add(err); isRejected = true;
//}
//LabName
if (!string.IsNullOrWhiteSpace(item.LabName))
{
if (RepositoryUtils.containsSpecialCharacters(item.LabName))
{
var err = new ErrorModel("AddLabMethods", string.Format(Ressources.IMPORT_VALUE_INVALIDCHARACTERS, "LabName")); listOfErrors.Add(err); isRejected = true;
}
else
{
model.LabName = item.LabName;
}
}
else
{
item.LabName = model.LabName;
}
//LabOrganization
if (!string.IsNullOrWhiteSpace(item.LabOrganization))
{
if (RepositoryUtils.containsSpecialCharacters(item.LabOrganization))
{
var err = new ErrorModel("AddLabMethods", string.Format(Ressources.IMPORT_VALUE_INVALIDCHARACTERS, "LabOrganization")); listOfErrors.Add(err); isRejected = true;
}
else
{
model.LabOrganization = item.LabOrganization;
}
}
else
{
item.LabOrganization = model.LabOrganization;
}
//LabMethodName
if (!string.IsNullOrWhiteSpace(item.LabMethodName))
{
if (RepositoryUtils.containsSpecialCharacters(item.LabMethodName))
{
var err = new ErrorModel("AddLabMethods", string.Format(Ressources.IMPORT_VALUE_INVALIDCHARACTERS, "LabMethodName")); listOfErrors.Add(err); isRejected = true;
}
else
{
model.LabMethodName = item.LabMethodName;
}
}
else
{
item.LabMethodName = model.LabMethodName;
}
//LabMethodDescription
if (!string.IsNullOrWhiteSpace(item.LabMethodDescription))
{
if (RepositoryUtils.containsSpecialCharacters(item.LabMethodDescription))
{
var err = new ErrorModel("AddLabMethods", string.Format(Ressources.IMPORT_VALUE_INVALIDCHARACTERS, "LabMethodDescription")); listOfErrors.Add(err); isRejected = true;
}
else
{
model.LabMethodDescription = item.LabMethodDescription;
}
}
else
{
item.LabMethodDescription = model.LabMethodDescription;
}
//LabMethodLink
if (!string.IsNullOrWhiteSpace(item.LabMethodLink))
{
if (RepositoryUtils.containsSpecialCharacters(item.LabMethodLink))
{
var err = new ErrorModel("AddLabMethods", string.Format(Ressources.IMPORT_VALUE_INVALIDCHARACTERS, "LabMethodLink")); listOfErrors.Add(err); isRejected = true;
}
else
{
model.LabMethodLink = item.LabMethodLink;
}
}
if (isRejected)
{
var sb = new StringBuilder();
foreach (var er in listOfErrors)
{
sb.Append(er.ErrorMessage + ";");
}
item.Errors = sb.ToString();
listOfIncorrectRecords.Add(item);
continue;
}
//lookup duplicates
var existingItem = context.LabMethods
.Where(
a => a.LabMethodName == model.LabMethodName)
.FirstOrDefault();
if (existingItem == null)
{
var existInUpload = listOfCorrectRecords.Exists(a => a.LabMethodName == item.LabMethodName);
if (!existInUpload)
{
//context.Sites.Add(model);
//context.SaveChanges();
listOfCorrectRecords.Add(item);
}
else
{
var err = new ErrorModel("AddLabMethods", string.Format(Ressources.IMPORT_VALUE_ISDUPLICATE, "LabMethodName")); listOfErrors.Add(err); isRejected = true;
listOfIncorrectRecords.Add(item);
item.Errors += err.ErrorMessage + ";";
}
}
else
{
if (existingItem.LabMethodName != model.LabMethodName) { listOfUpdates.Add(new UpdateFieldsModel("LabMethod", "LabMethodName", existingItem.LabMethodName.ToString(), item.LabMethodName.ToString())); }
if (model.LabName != null && existingItem.LabName != model.LabName) { listOfUpdates.Add(new UpdateFieldsModel("LabMethod", "LabName", existingItem.LabName.ToString(), item.LabName.ToString())); }
if (model.LabOrganization != null && existingItem.LabOrganization != model.LabOrganization) { listOfUpdates.Add(new UpdateFieldsModel("LabMethod", "LabOrganization", existingItem.LabOrganization.ToString(), item.LabOrganization.ToString())); }
//if (model.LabMethodName != null && existingItem.LabMethodName != model.LabMethodName) { listOfUpdates.Add(new UpdateFieldsModel("LabMethod", "LabMethodName", existingItem.LabMethodCode.ToString(), item.LabMethodName.ToString())); }
if (model.LabMethodDescription != null && existingItem.LabMethodDescription != model.LabMethodDescription) { listOfUpdates.Add(new UpdateFieldsModel("LabMethod", "LabMethodDescription", existingItem.LabMethodDescription.ToString(), item.LabMethodDescription.ToString())); }
if (model.LabMethodLink != null && existingItem.LabMethodLink != model.LabMethodLink) { listOfUpdates.Add(new UpdateFieldsModel("LabMethod", "LabMethodLink", existingItem.LabMethodLink.ToString(), item.LabMethodLink.ToString())); }
if (listOfUpdates.Count() > 0)
{
listOfEditedRecords.Add(item);
var sb = new StringBuilder();
foreach (var u in listOfUpdates)
{
sb.Append(string.Format(Ressources.IMPORT_VALUE_UPDATED, u.ColumnName, u.CurrentValue, u.UpdatedValue + ";"));
}
item.Errors = sb.ToString();
continue;
}
else
{
listOfDuplicateRecords.Add(item);
}
}
}
catch (Exception ex)
{
listOfIncorrectRecords.Add(item);
}
}
return;
}
public void AddGroups(List<GroupsModel> itemList, string entityConnectionString, string instanceIdentifier, out List<GroupsModel> listOfIncorrectRecords, out List<GroupsModel> listOfCorrectRecords, out List<GroupsModel> listOfDuplicateRecords, out List<GroupsModel> listOfEditedRecords)
{
listOfIncorrectRecords = new List<GroupsModel>();
listOfCorrectRecords = new List<GroupsModel>();
listOfDuplicateRecords = new List<GroupsModel>();
listOfEditedRecords = new List<GroupsModel>();
var context = new ODM_1_1_1EFModel.ODM_1_1_1Entities(entityConnectionString);
var groupDescriptions = context.GroupDescriptions.ToList();
var maxCount = itemList.Count;
var count = 0;
BusinessObjectsUtils.UpdateCachedprocessStatusMessage(instanceIdentifier, CacheName, String.Format(Ressources.IMPORT_STATUS_PROCESSING, count, maxCount));
foreach (var item in itemList)
{
try
{
BusinessObjectsUtils.UpdateCachedprocessStatusMessage(instanceIdentifier, CacheName, String.Format(Ressources.IMPORT_STATUS_PROCESSING, count, maxCount));
count++;
var model = new Group();
var listOfErrors = new List<ErrorModel>();
bool isRejected = false;
//GroupID
if (!string.IsNullOrWhiteSpace(item.GroupID))
{
int result;
bool canConvert = UniversalTypeConverter.TryConvertTo<int>(item.GroupID, out result);
if (canConvert)//user used id
{
var groupId = groupDescriptions
.Exists(a => a.GroupID == result);
if (!groupId)
{
var err = new ErrorModel("AddGroups", string.Format(Ressources.IMPORT_VALUE_NOT_IN_DATABASE, item.GroupID, "Groups"));
listOfErrors.Add(err);
isRejected = true;
}
else
{
model.GroupID = result;
}
}
else
{
var err = new ErrorModel("AddGroups", string.Format(Ressources.IMPORT_VALUE_INVALIDVALUE, "GroupID")); listOfErrors.Add(err); isRejected = true;
}
}
else
{
var err = new ErrorModel("AddGroups", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "GroupID")); listOfErrors.Add(err); isRejected = true;
}
//ValuerID
if (!string.IsNullOrWhiteSpace(item.ValueID))
{
int result;
bool canConvert = UniversalTypeConverter.TryConvertTo<int>(item.ValueID, out result);
if (canConvert)//user used id
{
var valueID = context.DataValues
.Where(a => a.ValueID == result).FirstOrDefault() ;
if (valueID != null)
{
model.ValueID = result;
}
else
{
var err = new ErrorModel("AddGroups", string.Format(Ressources.IMPORT_VALUE_NOT_IN_DATABASE, item.ValueID, "ValueID"));
listOfErrors.Add(err);
isRejected = true;
}
}
else
{
var err = new ErrorModel("AddGroups", string.Format(Ressources.IMPORT_VALUE_INVALIDVALUE, "ValueID")); listOfErrors.Add(err); isRejected = true;
}
}
else
{
var err = new ErrorModel("AddGroups", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "ValueID")); listOfErrors.Add(err); isRejected = true;
}
if (isRejected)
{
var sb = new StringBuilder();
foreach (var er in listOfErrors)
{
sb.Append(er.ErrorMessage + ";");
}
item.Errors = sb.ToString();
listOfIncorrectRecords.Add(item);
continue;
}
//lookup duplicates
var existingItem = context.Groups.Where(a => a.GroupID == model.GroupID &&
a.ValueID == model.ValueID
).FirstOrDefault();
if (existingItem == null)
{
context.Groups.Add(model);
//context.SaveChanges();
listOfCorrectRecords.Add(item);
}
else
{
//no editing possible no unique field in upload
listOfDuplicateRecords.Add(item);
}
}
catch (Exception ex)
{
listOfIncorrectRecords.Add(item);
}
}
return;
}
public void AddGroupDescriptions(List<GroupDescriptionModel> itemList, string entityConnectionString, string instanceIdentifier, out List<GroupDescriptionModel> listOfIncorrectRecords, out List<GroupDescriptionModel> listOfCorrectRecords, out List<GroupDescriptionModel> listOfDuplicateRecords, out List<GroupDescriptionModel> listOfEditedRecords)
{
listOfIncorrectRecords = new List<GroupDescriptionModel>();
listOfCorrectRecords = new List<GroupDescriptionModel>();
listOfDuplicateRecords = new List<GroupDescriptionModel>();
listOfEditedRecords = new List<GroupDescriptionModel>();
var context = new ODM_1_1_1EFModel.ODM_1_1_1Entities(entityConnectionString);
var maxCount = itemList.Count;
var count = 0;
BusinessObjectsUtils.UpdateCachedprocessStatusMessage(instanceIdentifier, CacheName, String.Format(Ressources.IMPORT_STATUS_PROCESSING, count, maxCount));
foreach (var item in itemList)
{
try
{
BusinessObjectsUtils.UpdateCachedprocessStatusMessage(instanceIdentifier, CacheName, String.Format(Ressources.IMPORT_STATUS_PROCESSING, count, maxCount));
count++;
var model = new GroupDescription();
var listOfErrors = new List<ErrorModel>();
bool isRejected = false;
//GroupDescription
if (!string.IsNullOrWhiteSpace(item.GroupDescription))
{
if (RepositoryUtils.containsSpecialCharacters(item.GroupDescription))
{
var err = new ErrorModel("AddGroupDescriptions", string.Format(Ressources.IMPORT_VALUE_INVALIDCHARACTERS, "GroupDescription")); listOfErrors.Add(err); isRejected = true;
}
else
{
model.GroupDescription1 = item.GroupDescription;
}
}
else
{
var err = new ErrorModel("AddGroupDescriptions", string.Format(Ressources.IMPORT_VALUE_CANNOTBEEMPTY, "GroupDescription")); listOfErrors.Add(err); isRejected = true;
}
if (isRejected)
{
var sb = new StringBuilder();
foreach (var er in listOfErrors)
{
sb.Append(er.ErrorMessage + ";");
}
item.Errors = sb.ToString();
listOfIncorrectRecords.Add(item);
continue;
}
//lookup duplicates
var existingItem = context.GroupDescriptions.Where(a => a.GroupDescription1 == model.GroupDescription1
).FirstOrDefault();
if (existingItem == null)
{
context.GroupDescriptions.Add(model);
//context.SaveChanges();
listOfCorrectRecords.Add(item);
}
else
{
//no editing possible no unique field in upload
listOfDuplicateRecords.Add(item);
}
}
catch (Exception ex)
{
listOfIncorrectRecords.Add(item);
}
}
return;
}