public ValidationIssues Validate()
{
var issues = new ValidationIssues()
//.AddIf("Title", movie.Title.Length == 0, "Title is required")
//.AddRule(new NotEmptyRule("Title", movie.Title, "Title is required"))
//.AddIf("Title", () => movie.Title.Length > 20, "Title must be more than 20 characters")
.AddRule(new MaxLengtRule("Title", movie.Title, 20, "Title must be more than 20 characters"))
.AddRule(new MovieExistRule(movie));
return(issues);
}
public void CheckCollision(string sourceName, string lookupName, IList <string> keys, IList <string> altKeys, ValidationIssues issues)
{
foreach (String testId in altKeys)
{
if (keys.Contains(testId))
{
string message = string.Format("The {2} has a duplicate {0} key with a value of {1}.", lookupName, testId, sourceName);
ValidationIssues.Add(ValidationIssue.Code.NonUniqueKeyCode, message);
}
}
}
public void Using_validation_issues()
{
var value = "Tahir";
var issues = new ValidationIssues()
.AddIf("Title", value.Length == 0, "Title is required")
.AddIf("Title", value.StartsWith("S"), "Title should start with T")
.AddIf("Title", () => value.Length > 3, "Title must be more than 3 characters");
Assert.True(issues.HasIssues);
}
private void LoadRow(string sheetName, Dictionary <string, string> values)
{
ValidationIssues issues = generalDet.ValidationIssues;
if (sheetName == "DET_Surveys")
{
CrossSectionSurveyDTO newDto = new CrossSectionSurveyDTO(values);
newDto.Validate();
issues.Merge(newDto.ValidationIssues);
bool success = generalDet.Surveys.Add(newDto);
if (!success)
{
issues.Add(ValidationIssue.Code.NonUniqueKeyCode, string.Format("The survey with code {0} is not unique.", newDto.LookupKey));
}
}
else if (sheetName == "DET_Elevations")
{
CrossSectionElevationDTO newDto = new CrossSectionElevationDTO(values);
newDto.Validate();
issues.Merge(newDto.ValidationIssues);
bool success = generalDet.Elevations.Add(newDto);
if (!success)
{
issues.Add(ValidationIssue.Code.NonUniqueKeyCode, string.Format("The elevation with code {0} is not unique.", newDto.LookupKey));
}
}
else if (sheetName == "LIST_Instruments")
{
InstrumentDTO newDto = new InstrumentDTO(values);
newDto.Validate();
issues.Merge(newDto.ValidationIssues);
bool success = generalDet.Instruments.Add(newDto);
if (!success)
{
issues.Add(ValidationIssue.Code.NonUniqueKeyCode, string.Format("The instrument with code {0} is not unique.", newDto.LookupKey));
}
}
else if (sheetName == "LIST_Sites")
{
SiteDTO newDto = new SiteDTO(values);
newDto.Validate();
issues.Merge(newDto.ValidationIssues);
bool success = generalDet.Sites.Add(newDto);
if (!success)
{
issues.Add(ValidationIssue.Code.NonUniqueKeyCode, string.Format("The site with code {0} is not unique.", newDto.LookupKey));
}
}
}
private void DeploymentDateOrder(DateTime?startDate, DateTime?endDate)
{
DateTime now = DateTime.Now;
if (startDate >= endDate)
{
string message = string.Format("The deployment window {0} {1} ends before it starts.", startDate, endDate);
ValidationIssues.Add(ValidationIssue.Code.TemporalConsistencyCode, message);
}
if (startDate >= now || endDate >= now)
{
string message = string.Format("The deployment window {0} {1} must be in the past.", startDate, endDate);
ValidationIssues.Add(ValidationIssue.Code.TemporalConsistencyCode, message);
}
}
public static void ReadFile(string fName)
{
Console.WriteLine("reading workbook named [{0}]", fName);
PreyAvailabilityDET det = new PreyAvailabilityDET();
ExcelPreyAvailabilityDET excel = new ExcelPreyAvailabilityDET(det);
excel.Load(fName);
ValidationIssues issues = det.ValidationIssues;
if (issues.Count > 0)
{
foreach (ValidationIssue issue in issues)
{
Console.WriteLine(issue.IssueMessage);
}
return;
}
Console.WriteLine("Custom property Name: {0}, Value: {1}", "oncorID", det.Id);
Console.WriteLine("Custom property Name: {0}, Value: {1}", "oncorOwner", det.Owner);
int count = 1;
foreach (var dto in det.PreySurveys.Values)
{
Console.WriteLine("PreySurvey Row: {0}, Value: {1}", count++, dto);
}
count = 1;
foreach (var dto in det.Prey.Values)
{
Console.WriteLine("Prey Row: {0}, Value: {1}", count++, dto);
}
count = 1;
foreach (var dto in det.Sites.Values)
{
Console.WriteLine("Site Row: {0}, Value: {1}", count++, dto);
}
count = 1;
foreach (var dto in det.Species.Values)
{
Console.WriteLine("Species Row: {0}, Value: {1}", count++, dto);
}
Console.WriteLine("Closing workbook named [{0}]", fName);
}
public static void ReadFile(string fName)
{
Console.WriteLine("reading workbook named [{0}]", fName);
CrossSectionDET det = new CrossSectionDET();
ExcelCrossSectionDET excel = new ExcelCrossSectionDET(det);
excel.Load(fName);
ValidationIssues issues = det.ValidationIssues;
if (issues.Count > 0)
{
foreach (ValidationIssue issue in issues)
{
Console.WriteLine(issue.IssueMessage);
}
return;
}
Console.WriteLine("Custom property Name: {0}, Value: {1}", "oncorID", det.Id);
Console.WriteLine("Custom property Name: {0}, Value: {1}", "oncorOwner", det.Owner);
int count = 1;
foreach (var dto in det.Surveys.Values)
{
Console.WriteLine("Survey Row: {0}, Value: {1}", count++, dto);
}
count = 1;
foreach (var dto in det.Elevations.Values)
{
Console.WriteLine("Elevation Row: {0}, Value: {1}", count++, dto);
}
count = 1;
foreach (var dto in det.Instruments.Values)
{
Console.WriteLine("Instruments Row: {0}, Value: {1}", count++, dto);
}
count = 1;
foreach (var dto in det.Sites.Values)
{
Console.WriteLine("Site Row: {0}, Value: {1}", count++, dto);
}
Console.WriteLine("Closing workbook named [{0}]", fName);
}
public static void ReadFile(string fName)
{
Console.WriteLine("reading workbook named [{0}]", fName);
WaterQualityDET det = new WaterQualityDET();
ExcelWaterQualityDET excel = new ExcelWaterQualityDET(det);
excel.Load(fName);
ValidationIssues issues = det.ValidationIssues;
if (issues.Count > 0)
{
foreach (ValidationIssue issue in issues)
{
Console.WriteLine(issue.IssueMessage);
}
//return;
}
Console.WriteLine("Custom property Name: {0}, Value: {1}", "oncorID", det.Id);
Console.WriteLine("Custom property Name: {0}, Value: {1}", "oncorOwner", det.Owner);
int count = 1;
foreach (var dto in det.Deployments.Values)
{
Console.WriteLine("Deployment Row: {0}, Value: {1}", count++, dto);
}
count = 1;
foreach (var dto in det.Measurements.Values)
{
Console.WriteLine("Measurement Row: {0}, Value: {1}", count++, dto);
}
count = 1;
foreach (var dto in det.Sites.Values)
{
Console.WriteLine("Site Row: {0}, Value: {1}", count++, dto);
}
count = 1;
foreach (var dto in det.Instruments.Values)
{
Console.WriteLine("Sensor Row: {0}, Value: {1}", count++, dto);
}
Console.WriteLine("Closing workbook named [{0}]", fName);
}
public BaseDTO()
{
ValidationIssues = new ValidationIssues();
}
public CrossSectionDET()
{
InitializeCollections();
ValidationIssues = new ValidationIssues();
}
public SedimentAccretionDET()
{
InitializeCollections();
ValidationIssues = new ValidationIssues();
}
private void LoadRow(string sheetName, Dictionary <string, string> values)
{
ValidationIssues issues = generalDet.ValidationIssues;
if (sheetName == "DET_Survey")
{
VegSurveyDTO newDto = new VegSurveyDTO(values);
newDto.Validate();
issues.Merge(newDto.ValidationIssues);
bool success = generalDet.Surveys.Add(newDto);
if (!success)
{
issues.Add(ValidationIssue.Code.NonUniqueKeyCode, string.Format("The survey with code {0} is not unique.", newDto.LookupKey));
}
}
else if (sheetName == "DET_Tree")
{
VegTreeDTO newDto = new VegTreeDTO(values);
newDto.Validate();
issues.Merge(newDto.ValidationIssues);
bool success = generalDet.Trees.Add(newDto);
if (!success)
{
issues.Add(ValidationIssue.Code.NonUniqueKeyCode, string.Format("The measurment with code {0} is not unique.", newDto.LookupKey));
}
}
else if (sheetName == "DET_Herb")
{
VegHerbDTO newDto = new VegHerbDTO(values);
newDto.Validate();
issues.Merge(newDto.ValidationIssues);
bool success = generalDet.Herbs.Add(newDto);
if (!success)
{
issues.Add(ValidationIssue.Code.NonUniqueKeyCode, string.Format("The measurment with code {0} is not unique.", newDto.LookupKey));
}
}
else if (sheetName == "DET_Shrub")
{
VegShrubDTO newDto = new VegShrubDTO(values);
newDto.Validate();
issues.Merge(newDto.ValidationIssues);
bool success = generalDet.Shrubs.Add(newDto);
if (!success)
{
issues.Add(ValidationIssue.Code.NonUniqueKeyCode, string.Format("The measurment with code {0} is not unique.", newDto.LookupKey));
}
}
else if (sheetName == "DET_Elevation")
{
VegElevationDTO newDto = new VegElevationDTO(values);
newDto.Validate();
issues.Merge(newDto.ValidationIssues);
bool success = generalDet.Elevations.Add(newDto);
if (!success)
{
issues.Add(ValidationIssue.Code.NonUniqueKeyCode, string.Format("The elevation with code {0} is not unique.", newDto.LookupKey));
}
}
else if (sheetName == "LIST_Sites")
{
SiteDTO newDto = new SiteDTO(values);
newDto.Validate();
issues.Merge(newDto.ValidationIssues);
bool success = generalDet.Sites.Add(newDto);
if (!success)
{
issues.Add(ValidationIssue.Code.NonUniqueKeyCode, string.Format("The site with code {0} is not unique.", newDto.LookupKey));
}
}
else if (sheetName == "LIST_PlotTypes")
{
PlotTypeDTO newDto = new PlotTypeDTO(values);
newDto.Validate();
issues.Merge(newDto.ValidationIssues);
bool success = generalDet.PlotTypes.Add(newDto);
if (!success)
{
issues.Add(ValidationIssue.Code.NonUniqueKeyCode, string.Format("The plottype with code {0} is not unique.", newDto.LookupKey));
}
}
else if (sheetName == "LIST_NonLiving")
{
SpeciesDTO newDto = new SpeciesDTO(values);
newDto.Validate();
issues.Merge(newDto.ValidationIssues);
bool success = generalDet.NonLiving.Add(newDto);
if (!success)
{
issues.Add(ValidationIssue.Code.NonUniqueKeyCode, string.Format("The nonliving with code {0} is not unique.", newDto.LookupKey));
}
}
else if (sheetName == "LIST_TreeSpecies")
{
SpeciesDTO newDto = new SpeciesDTO(values);
newDto.Validate();
issues.Merge(newDto.ValidationIssues);
bool success = generalDet.TreeSpecies.Add(newDto);
if (!success)
{
issues.Add(ValidationIssue.Code.NonUniqueKeyCode, string.Format("The taxa with code {0} is not unique.", newDto.LookupKey));
}
}
else if (sheetName == "LIST_HerbSpecies")
{
SpeciesDTO newDto = new SpeciesDTO(values);
newDto.Validate();
issues.Merge(newDto.ValidationIssues);
bool success = generalDet.HerbSpecies.Add(newDto);
if (!success)
{
issues.Add(ValidationIssue.Code.NonUniqueKeyCode, string.Format("The taxa with code {0} is not unique.", newDto.LookupKey));
}
}
else if (sheetName == "LIST_ShrubSpecies")
{
SpeciesDTO newDto = new SpeciesDTO(values);
newDto.Validate();
issues.Merge(newDto.ValidationIssues);
bool success = generalDet.ShrubSpecies.Add(newDto);
if (!success)
{
issues.Add(ValidationIssue.Code.NonUniqueKeyCode, string.Format("The taxa with code {0} is not unique.", newDto.LookupKey));
}
}
}
public static void ReadFile(string fName)
{
Console.WriteLine("reading workbook named [{0}]", fName);
FishDET det = new FishDET();
ExcelFishDET excel = new ExcelFishDET(det);
excel.Load(fName);
ValidationIssues issues = det.ValidationIssues;
if (issues.Count > 0)
{
foreach (ValidationIssue issue in issues)
{
Console.WriteLine(issue.IssueMessage);
}
return;
}
Console.WriteLine("Custom property Name: {0}, Value: {1}", "oncorID", det.Id);
Console.WriteLine("Custom property Name: {0}, Value: {1}", "oncorOwner", det.Owner);
int count = 1;
foreach (var dto in det.CatchEfforts.Values)
{
Console.WriteLine("CatchEfforts Row: {0}, Value: {1}", count++, dto);
}
count = 1;
foreach (var dto in det.NetHaulEvents.Values)
{
Console.WriteLine("NetHaulEvents Row: {0}, Value: {1}", count++, dto);
}
count = 1;
foreach (var dto in det.FishCounts.Values)
{
Console.WriteLine("FishCounts Row: {0}, Value: {1}", count++, dto);
}
count = 1;
foreach (var dto in det.CatchMetrics.Values)
{
Console.WriteLine("CatchMetrics Row: {0}, Value: {1}", count++, dto);
}
count = 1;
foreach (var dto in det.Fish.Values)
{
Console.WriteLine("Fish Row: {0}, Value: {1}", count++, dto);
}
count = 1;
foreach (var dto in det.IdTags.Values)
{
Console.WriteLine("IdTags Row: {0}, Value: {1}", count++, dto);
}
count = 1;
foreach (var dto in det.Genetics.Values)
{
Console.WriteLine("Genetics Row: {0}, Value: {1}", count++, dto);
}
count = 1;
foreach (var dto in det.Diet.Values)
{
Console.WriteLine("Diet Row: {0}, Value: {1}", count++, dto);
}
count = 1;
foreach (var dto in det.FishSpecies.Values)
{
Console.WriteLine("FishSpecies Row: {0}, Value: {1}", count++, dto);
}
count = 1;
foreach (var dto in det.MacroSpecies.Values)
{
Console.WriteLine("MacroSpecies Row: {0}, Value: {1}", count++, dto);
}
count = 1;
foreach (var dto in det.Sites.Values)
{
Console.WriteLine("Site Row: {0}, Value: {1}", count++, dto);
}
count = 1;
foreach (var dto in det.Nets.Values)
{
Console.WriteLine("Net Row: {0}, Value: {1}", count++, dto);
}
Console.WriteLine("Closing workbook named [{0}]", fName);
}
public WaterQualityDET()
{
InitializeCollections();
ValidationIssues = new ValidationIssues();
}
public void CheckReferentialIntegrity(string sourceName, string lookupName, string testId, IList <string> keys, ValidationIssues issues)
{
if (!keys.Contains(testId))
{
string message = string.Format("The {2} has an invalid {0} key with a value of {1}.", lookupName, testId, sourceName);
ValidationIssues.Add(ValidationIssue.Code.InvalidForeignKeyCode, message);
}
}
public override UpdateStatus Update(FilestoreFile tempFileUpload, SampleEventMap map)
{
if (tempFileUpload != null)
{
FilestoreFile oldFile = this.Get(map);
if (oldFile != null)
{
if (this.CanModify(map))
{
FishDET curdet = new FishDET();
ExcelFishDET curexcel = new ExcelFishDET(curdet);
curexcel.Load(tempFileUpload);
ValidationIssues curIssues = curdet.ValidationIssues;
if (curIssues.Count < 1)
{
FishDET olddet = new FishDET();
ExcelFishDET excel = new ExcelFishDET(olddet);
excel.Load(oldFile);
ValidationIssues issues = olddet.ValidationIssues;
if (issues.Count < 1) //should be this is the old file
{
UpdateStatus status = null;
if (olddet.CatchEfforts.Count < 1) //old file has no data - bare det
{
if (curdet.CatchEfforts.Count < 1) //nothing to do really, new file has no data either
{
olddet = null;
excel = null;
oldFile.Dispose();
curdet = null;
curexcel = null;
FileStoreManager.Instance.GetProvider().Delete(tempFileUpload);
status = new UpdateStatus(UpdateIssue.AllOk);
status.Add(new IssueNotice("NoDataInEither", "nothing to do"));
return(status);
}
SampleEventMapItem item = map.Get(KnownDetType.Fish);
if (item != null)
{
olddet = null; //release old reference
excel = null; //release old reference
//ok, no data in old file, but data in new file -- we have work to do -- handle first-time data insertion
ICatchEffortProvider depl = FishManager.Instance.GetCatchEffortProvider(this.Context);
ICatchHaulProvider meas = FishManager.Instance.GetCatchHaulProvider(this.Context);
IFishProvider fi = FishManager.Instance.GetFishProvider(this.Context);
if (depl != null && meas != null && fi != null)
{
if (depl.CanCreate())
{
List <EntityBundle> bundles = this.GetBundles(map, KnownDetType.Fish);
if (bundles != null && bundles.Count >= 3)
{
EntityBundle mac = null;
if (bundles.Count > 3)
{
mac = bundles[3];
}
status = this.InitialLoad(map.SampleEventId, bundles[0], bundles[1], bundles[2], mac, curdet, depl, meas, fi, item.IsPrivate);
if (status != null && status.Issue == UpdateIssue.AllOk) //success, so we overwrite the file
{
curdet = null;
curexcel = null;
olddet = null;
excel = null;
IFileStoreProvider ip = FileStoreManager.Instance.GetProvider();
if (ip.Replace(tempFileUpload, oldFile)) //overwrite the existing file with the new one
{
tempFileUpload.Dispose();
oldFile.Dispose();
//ip.Delete(tempFileUpload); //may still be references so delete can fail
return(status); //we're done here
}
else
{
status = new UpdateStatus(UpdateIssue.DataIssue);
status.Add(new IssueNotice("File", "Failed to replace file"));
}
}
}
else
{
status = new UpdateStatus(UpdateIssue.DataIssue);
status.Add(new IssueNotice("Bundles", "Failed to get bundles"));
}
}
else
{
status = new UpdateStatus(UpdateIssue.Security);
status.Add(new IssueNotice("Permissions", "create denied"));
}
}
else
{
status = new UpdateStatus(UpdateIssue.SystemIssue);
status.Add(new IssueNotice("Failure", "Failed to get provider"));
}
}
else
{
status = new UpdateStatus(UpdateIssue.NoExistingFile);
status.Add(new IssueNotice("NoMapEntry", "Failed to find map reference"));
}
return(status);
}
else //crap -- this is an update where existing file already had data
{
ICatchEffortProvider depl = FishManager.Instance.GetCatchEffortProvider(this.Context);
ICatchHaulProvider meas = FishManager.Instance.GetCatchHaulProvider(this.Context);
IFishProvider fi = FishManager.Instance.GetFishProvider(this.Context);
if (depl != null && meas != null && fi != null)
{
if (depl.CanCreate())
{
SampleEventMapItem item = map.Get(KnownDetType.Fish);
List <EntityBundle> bundles = this.GetBundles(map, KnownDetType.Fish);
if (item != null && bundles != null && bundles.Count >= 3)
{
EntityBundle mac = null;
if (bundles.Count > 3)
{
mac = bundles[3];
}
status = this.DeltaLoad(map.SampleEventId, bundles[0], bundles[1], bundles[2], mac, curdet, olddet, depl, meas, fi, map);
if (status != null && status.Issue == UpdateIssue.AllOk) //success, so we overwrite the file
{
curdet = null;
curexcel = null;
olddet = null;
excel = null;
//NOTE -- making new file the permanent file and removing old file, then updating map for new file
IFileStoreProvider ip = FileStoreManager.Instance.GetProvider();
if (ip.Replace(tempFileUpload, oldFile)) //overwrite the existing file with the new one
{
tempFileUpload.Dispose();
oldFile.Dispose();
//ip.Delete(tempFileUpload); //may still be references so delete can fail
return(status); //we're done here
}
else
{
status = new UpdateStatus(UpdateIssue.DataIssue);
status.Add(new IssueNotice("File", "Failed to replace file"));
}
}
}
else
{
status = new UpdateStatus(UpdateIssue.DataIssue);
status.Add(new IssueNotice("Bundles", "Failed to get bundles"));
}
}
else
{
status = new UpdateStatus(UpdateIssue.Security);
status.Add(new IssueNotice("Permissions", "create denied"));
}
}
else
{
status = new UpdateStatus(UpdateIssue.SystemIssue);
status.Add(new IssueNotice("Failure", "Failed to get provider"));
}
return(status);
}
}
else
{
UpdateStatus stat = new UpdateStatus(UpdateIssue.NoExistingFile);
foreach (ValidationIssue cur in issues)
{
stat.Add(new IssueNotice(cur.IssueCode.ToString(), cur.IssueMessage));
}
return(stat);
}
}
else
{
UpdateStatus stat = new UpdateStatus(UpdateIssue.FileValidationIssues);
foreach (ValidationIssue cur in curIssues)
{
stat.Add(new IssueNotice(cur.IssueCode.ToString(), cur.IssueMessage));
}
return(stat);
}
}
else
{
UpdateStatus status = new UpdateStatus(UpdateIssue.Security);
status.Add(new IssueNotice("Permissions", "create denied"));
return(status);
}
}
return(new UpdateStatus(UpdateIssue.NoExistingFile));
}
return(new UpdateStatus(UpdateIssue.NoFilePosted));
}
public static void ReadFile(string fName)
{
Console.WriteLine("reading workbook named [{0}]", fName);
VegDET det = new VegDET();
ExcelVegDET excel = new ExcelVegDET(det);
excel.Load(fName);
ValidationIssues issues = det.ValidationIssues;
if (issues.Count > 0)
{
foreach (ValidationIssue issue in issues)
{
Console.WriteLine(issue.IssueMessage);
}
//return;
}
Console.WriteLine("Custom property Name: {0}, Value: {1}", "oncorID", det.Id);
Console.WriteLine("Custom property Name: {0}, Value: {1}", "oncorOwner", det.Owner);
int count = 1;
foreach (var dto in det.Sites.Values)
{
Console.WriteLine("Site Row: {0}, Value: {1}", count++, dto);
}
count = 1;
foreach (var dto in det.Elevations.Values)
{
Console.WriteLine("Elevations Row: {0}, Value: {1}", count++, dto);
}
count = 1;
foreach (var dto in det.Herbs.Values)
{
Console.WriteLine("Herbs Row: {0}, Value: {1}", count++, dto);
}
count = 1;
foreach (var dto in det.HerbSpecies.Values)
{
Console.WriteLine("HerbSpecies Row: {0}, Value: {1}", count++, dto);
}
count = 1;
foreach (var dto in det.NonLiving.Values)
{
Console.WriteLine("NonLiving Row: {0}, Value: {1}", count++, dto);
}
count = 1;
foreach (var dto in det.PlotTypes.Values)
{
Console.WriteLine("PlotTypes Row: {0}, Value: {1}", count++, dto);
}
count = 1;
foreach (var dto in det.Shrubs.Values)
{
Console.WriteLine("Shrubs Row: {0}, Value: {1}", count++, dto);
}
count = 1;
foreach (var dto in det.ShrubSpecies.Values)
{
Console.WriteLine("Shrubs Row: {0}, Value: {1}", count++, dto);
}
count = 1;
foreach (var dto in det.Surveys.Values)
{
Console.WriteLine("Surveys Row: {0}, Value: {1}", count++, dto);
}
count = 1;
foreach (var dto in det.Trees.Values)
{
Console.WriteLine("Trees Row: {0}, Value: {1}", count++, dto);
}
count = 1;
foreach (var dto in det.TreeSpecies.Values)
{
Console.WriteLine("TreeSpecies Row: {0}, Value: {1}", count++, dto);
}
Console.WriteLine("Closing workbook named [{0}]", fName);
}
public FishDET()
{
InitializeCollections();
ValidationIssues = new ValidationIssues();
}
public PreyAvailabilityDET()
{
InitializeCollections();
ValidationIssues = new ValidationIssues();
}
private void LoadRow(string sheetName, Dictionary <string, string> values)
{
ValidationIssues issues = generalDet.ValidationIssues;
if (sheetName == "DET_CatchEffort")
{
CatchEffortDTO newDto = new CatchEffortDTO(values);
newDto.Validate();
issues.Merge(newDto.ValidationIssues);
bool success = generalDet.CatchEfforts.Add(newDto);
if (!success)
{
issues.Add(ValidationIssue.Code.NonUniqueKeyCode, string.Format("The catch effort with code {0} is not unique.", newDto.LookupKey));
}
}
else if (sheetName == "DET_NetHaulEvent")
{
NetHaulEventDTO newDto = new NetHaulEventDTO(values);
newDto.Validate();
issues.Merge(newDto.ValidationIssues);
bool success = generalDet.NetHaulEvents.Add(newDto);
if (!success)
{
issues.Add(ValidationIssue.Code.NonUniqueKeyCode, string.Format("The net haul event with code {0} is not unique.", newDto.LookupKey));
}
}
else if (sheetName == "DET_FishCount")
{
FishCountDTO newDto = new FishCountDTO(values);
newDto.Validate();
issues.Merge(newDto.ValidationIssues);
bool success = generalDet.FishCounts.Add(newDto);
if (!success)
{
issues.Add(ValidationIssue.Code.NonUniqueKeyCode, string.Format("The fish count with code {0} is not unique.", newDto.LookupKey));
}
}
else if (sheetName == "DET_CatchMetric")
{
CatchMetricDTO newDto = new CatchMetricDTO(values);
newDto.Validate();
issues.Merge(newDto.ValidationIssues);
bool success = generalDet.CatchMetrics.Add(newDto);
if (!success)
{
issues.Add(ValidationIssue.Code.NonUniqueKeyCode, string.Format("The catch metric with code {0} is not unique.", newDto.LookupKey));
}
}
else if (sheetName == "DET_Fish")
{
FishDTO newDto = new FishDTO(values);
newDto.Validate();
issues.Merge(newDto.ValidationIssues);
bool success = generalDet.Fish.Add(newDto);
if (!success)
{
issues.Add(ValidationIssue.Code.NonUniqueKeyCode, string.Format("The fish with code {0} is not unique.", newDto.LookupKey));
}
}
else if (sheetName == "DET_IdTags")
{
IdTagDTO newDto = new IdTagDTO(values);
newDto.Validate();
issues.Merge(newDto.ValidationIssues);
bool success = generalDet.IdTags.Add(newDto);
if (!success)
{
issues.Add(ValidationIssue.Code.NonUniqueKeyCode, string.Format("The ID tag with code {0} is not unique.", newDto.LookupKey));
}
}
else if (sheetName == "DET_Genetics")
{
GeneticDTO newDto = new GeneticDTO(values);
newDto.Validate();
issues.Merge(newDto.ValidationIssues);
bool success = generalDet.Genetics.Add(newDto);
if (!success)
{
issues.Add(ValidationIssue.Code.NonUniqueKeyCode, string.Format("The genetic with code {0} is not unique.", newDto.LookupKey));
}
}
else if (sheetName == "DET_Diet")
{
DietDTO newDto = new DietDTO(values);
newDto.Validate();
issues.Merge(newDto.ValidationIssues);
bool success = generalDet.Diet.Add(newDto);
if (!success)
{
issues.Add(ValidationIssue.Code.NonUniqueKeyCode, string.Format("The diet with code {0} is not unique.", newDto.LookupKey));
}
}
else if (sheetName == "LIST_FishSpecies")
{
FishSpeciesDTO newDto = new FishSpeciesDTO(values);
newDto.Validate();
issues.Merge(newDto.ValidationIssues);
bool success = generalDet.FishSpecies.Add(newDto);
if (!success)
{
issues.Add(ValidationIssue.Code.NonUniqueKeyCode, string.Format("The fish-species with code {0} is not unique.", newDto.LookupKey));
}
}
else if (sheetName == "LIST_MacroSpecies")
{
MacroSpeciesDTO newDto = new MacroSpeciesDTO(values);
newDto.Validate();
issues.Merge(newDto.ValidationIssues);
bool success = generalDet.MacroSpecies.Add(newDto);
if (!success)
{
issues.Add(ValidationIssue.Code.NonUniqueKeyCode, string.Format("The macro-species with code {0} is not unique.", newDto.LookupKey));
}
}
else if (sheetName == "LIST_Sites")
{
SiteDTO newDto = new SiteDTO(values);
newDto.Validate();
issues.Merge(newDto.ValidationIssues);
bool success = generalDet.Sites.Add(newDto);
if (!success)
{
issues.Add(ValidationIssue.Code.NonUniqueKeyCode, string.Format("The site with code {0} is not unique.", newDto.LookupKey));
}
}
else if (sheetName == "LIST_Nets")
{
NetDTO newDto = new NetDTO(values);
newDto.Validate();
issues.Merge(newDto.ValidationIssues);
bool success = generalDet.Nets.Add(newDto);
if (!success)
{
issues.Add(ValidationIssue.Code.NonUniqueKeyCode, string.Format("The net with code {0} is not unique.", newDto.LookupKey));
}
}
}
private void ValidateDto(BaseDTO dto, ValidationIssues issues)
{
dto.Validate();
issues.Merge(dto.ValidationIssues);
}
