private IEnumerable <ValidationResult> Validate(ValidationContext validationContext, ActionDBTypeEnum actionDBType)
{
string retStr = "";
Enums enums = new Enums(LanguageRequest);
SearchTagAndTerms searchTagAndTerms = validationContext.ObjectInstance as SearchTagAndTerms;
searchTagAndTerms.HasErrors = false;
retStr = enums.EnumTypeOK(typeof(SearchTagEnum), (int?)searchTagAndTerms.SearchTag);
if (!string.IsNullOrWhiteSpace(retStr))
{
searchTagAndTerms.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "SearchTag"), new[] { "SearchTag" }));
}
if (!string.IsNullOrWhiteSpace(searchTagAndTerms.SearchTagText) && searchTagAndTerms.SearchTagText.Length > 100)
{
searchTagAndTerms.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "SearchTagText", "100"), new[] { "SearchTagText" }));
}
//CSSPError: Type not implemented [SearchTermList] of type [List`1]
//SearchTermList has no StringLength Attribute
retStr = ""; // added to stop compiling CSSPError
if (retStr != "") // will never be true
{
searchTagAndTerms.HasErrors = true;
yield return(new ValidationResult("AAA", new[] { "AAA" }));
}
}
private IEnumerable <ValidationResult> Validate(ValidationContext validationContext, ActionDBTypeEnum actionDBType)
{
string retStr = "";
Enums enums = new Enums(LanguageRequest);
FilePurposeAndText filePurposeAndText = validationContext.ObjectInstance as FilePurposeAndText;
filePurposeAndText.HasErrors = false;
retStr = enums.EnumTypeOK(typeof(FilePurposeEnum), (int?)filePurposeAndText.FilePurpose);
if (!string.IsNullOrWhiteSpace(retStr))
{
filePurposeAndText.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "FilePurpose"), new[] { "FilePurpose" }));
}
if (!string.IsNullOrWhiteSpace(filePurposeAndText.FilePurposeText) && filePurposeAndText.FilePurposeText.Length > 100)
{
filePurposeAndText.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "FilePurposeText", "100"), new[] { "FilePurposeText" }));
}
retStr = ""; // added to stop compiling CSSPError
if (retStr != "") // will never be true
{
filePurposeAndText.HasErrors = true;
yield return(new ValidationResult("AAA", new[] { "AAA" }));
}
}
private IEnumerable <ValidationResult> Validate(ValidationContext validationContext, ActionDBTypeEnum actionDBType)
{
string retStr = "";
Enums enums = new Enums(LanguageRequest);
BoxModelCalNumb boxModelCalNumb = validationContext.ObjectInstance as BoxModelCalNumb;
boxModelCalNumb.HasErrors = false;
retStr = enums.EnumTypeOK(typeof(BoxModelResultTypeEnum), (int?)boxModelCalNumb.BoxModelResultType);
if (!string.IsNullOrWhiteSpace(retStr))
{
boxModelCalNumb.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "BoxModelResultType"), new[] { "BoxModelResultType" }));
}
if (boxModelCalNumb.CalLength_m < 0)
{
boxModelCalNumb.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MinValueIs_, "CalLength_m", "0"), new[] { "CalLength_m" }));
}
if (boxModelCalNumb.CalRadius_m < 0)
{
boxModelCalNumb.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MinValueIs_, "CalRadius_m", "0"), new[] { "CalRadius_m" }));
}
if (boxModelCalNumb.CalSurface_m2 < 0)
{
boxModelCalNumb.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MinValueIs_, "CalSurface_m2", "0"), new[] { "CalSurface_m2" }));
}
if (boxModelCalNumb.CalVolume_m3 < 0)
{
boxModelCalNumb.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MinValueIs_, "CalVolume_m3", "0"), new[] { "CalVolume_m3" }));
}
if (boxModelCalNumb.CalWidth_m < 0)
{
boxModelCalNumb.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MinValueIs_, "CalWidth_m", "0"), new[] { "CalWidth_m" }));
}
if (!string.IsNullOrWhiteSpace(boxModelCalNumb.BoxModelResultTypeText) && boxModelCalNumb.BoxModelResultTypeText.Length > 100)
{
boxModelCalNumb.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "BoxModelResultTypeText", "100"), new[] { "BoxModelResultTypeText" }));
}
retStr = ""; // added to stop compiling CSSPError
if (retStr != "") // will never be true
{
boxModelCalNumb.HasErrors = true;
yield return(new ValidationResult("AAA", new[] { "AAA" }));
}
}
private IEnumerable <ValidationResult> Validate(ValidationContext validationContext, ActionDBTypeEnum actionDBType)
{
string retStr = "";
Enums enums = new Enums(LanguageRequest);
PolSourceObsInfoChild polSourceObsInfoChild = validationContext.ObjectInstance as PolSourceObsInfoChild;
polSourceObsInfoChild.HasErrors = false;
retStr = enums.EnumTypeOK(typeof(PolSourceObsInfoEnum), (int?)polSourceObsInfoChild.PolSourceObsInfo);
if (!string.IsNullOrWhiteSpace(retStr))
{
polSourceObsInfoChild.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "PolSourceObsInfo"), new[] { "PolSourceObsInfo" }));
}
retStr = enums.EnumTypeOK(typeof(PolSourceObsInfoEnum), (int?)polSourceObsInfoChild.PolSourceObsInfoChildStart);
if (!string.IsNullOrWhiteSpace(retStr))
{
polSourceObsInfoChild.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "PolSourceObsInfoChildStart"), new[] { "PolSourceObsInfoChildStart" }));
}
if (!string.IsNullOrWhiteSpace(polSourceObsInfoChild.PolSourceObsInfoText) && polSourceObsInfoChild.PolSourceObsInfoText.Length > 100)
{
polSourceObsInfoChild.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "PolSourceObsInfoText", "100"), new[] { "PolSourceObsInfoText" }));
}
if (!string.IsNullOrWhiteSpace(polSourceObsInfoChild.PolSourceObsInfoChildStartText) && polSourceObsInfoChild.PolSourceObsInfoChildStartText.Length > 100)
{
polSourceObsInfoChild.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "PolSourceObsInfoChildStartText", "100"), new[] { "PolSourceObsInfoChildStartText" }));
}
retStr = ""; // added to stop compiling CSSPError
if (retStr != "") // will never be true
{
polSourceObsInfoChild.HasErrors = true;
yield return(new ValidationResult("AAA", new[] { "AAA" }));
}
}
/// <summary>
/// Validate function for all DataPathOfTideService commands
/// </summary>
/// <param name="validationContext">System.ComponentModel.DataAnnotations.ValidationContext (Describes the context in which a validation check is performed.)</param>
/// <param name="actionDBType">[ActionDBTypeEnum] (CSSPEnums.ActionDBTypeEnum.html) action type to validate</param>
/// <returns>IEnumerable of ValidationResult (Where ValidationResult is a container for the results of a validation request.)</returns>
private IEnumerable <ValidationResult> Validate(ValidationContext validationContext, ActionDBTypeEnum actionDBType)
{
string retStr = "";
Enums enums = new Enums(LanguageRequest);
DataPathOfTide dataPathOfTide = validationContext.ObjectInstance as DataPathOfTide;
dataPathOfTide.HasErrors = false;
if (string.IsNullOrWhiteSpace(dataPathOfTide.Text))
{
dataPathOfTide.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "Text"), new[] { "Text" }));
}
if (!string.IsNullOrWhiteSpace(dataPathOfTide.Text) && (dataPathOfTide.Text.Length < 1 || dataPathOfTide.Text.Length > 200))
{
dataPathOfTide.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._LengthShouldBeBetween_And_, "Text", "1", "200"), new[] { "Text" }));
}
if (dataPathOfTide.WebTideDataSet != null)
{
retStr = enums.EnumTypeOK(typeof(WebTideDataSetEnum), (int?)dataPathOfTide.WebTideDataSet);
if (dataPathOfTide.WebTideDataSet == null || !string.IsNullOrWhiteSpace(retStr))
{
dataPathOfTide.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "WebTideDataSet"), new[] { "WebTideDataSet" }));
}
}
if (!string.IsNullOrWhiteSpace(dataPathOfTide.WebTideDataSetText) && dataPathOfTide.WebTideDataSetText.Length > 100)
{
dataPathOfTide.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "WebTideDataSetText", "100"), new[] { "WebTideDataSetText" }));
}
retStr = ""; // added to stop compiling CSSPError
if (retStr != "") // will never be true
{
dataPathOfTide.HasErrors = true;
yield return(new ValidationResult("AAA", new[] { "AAA" }));
}
}
/// <summary>
/// Validate function for all TVItemInfrastructureTypeTVItemLinkService commands
/// </summary>
/// <param name="validationContext">System.ComponentModel.DataAnnotations.ValidationContext (Describes the context in which a validation check is performed.)</param>
/// <param name="actionDBType">[ActionDBTypeEnum] (CSSPEnums.ActionDBTypeEnum.html) action type to validate</param>
/// <returns>IEnumerable of ValidationResult (Where ValidationResult is a container for the results of a validation request.)</returns>
private IEnumerable <ValidationResult> Validate(ValidationContext validationContext, ActionDBTypeEnum actionDBType)
{
string retStr = "";
Enums enums = new Enums(LanguageRequest);
TVItemInfrastructureTypeTVItemLink tvItemInfrastructureTypeTVItemLink = validationContext.ObjectInstance as TVItemInfrastructureTypeTVItemLink;
tvItemInfrastructureTypeTVItemLink.HasErrors = false;
retStr = enums.EnumTypeOK(typeof(InfrastructureTypeEnum), (int?)tvItemInfrastructureTypeTVItemLink.InfrastructureType);
if (!string.IsNullOrWhiteSpace(retStr))
{
tvItemInfrastructureTypeTVItemLink.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "InfrastructureType"), new[] { "InfrastructureType" }));
}
//SeeOtherMunicipalityTVItemID has no Range Attribute
if (!string.IsNullOrWhiteSpace(tvItemInfrastructureTypeTVItemLink.InfrastructureTypeText) && tvItemInfrastructureTypeTVItemLink.InfrastructureTypeText.Length > 100)
{
tvItemInfrastructureTypeTVItemLink.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "InfrastructureTypeText", "100"), new[] { "InfrastructureTypeText" }));
}
//CSSPError: Type not implemented [TVItem] of type [TVItem]
//CSSPError: Type not implemented [TVItem] of type [TVItem]
//CSSPError: Type not implemented [TVItemLinkList] of type [List`1]
//CSSPError: Type not implemented [TVItemLinkList] of type [TVItemLink]
//CSSPError: Type not implemented [FlowTo] of type [TVItemInfrastructureTypeTVItemLink]
//CSSPError: Type not implemented [FlowTo] of type [TVItemInfrastructureTypeTVItemLink]
retStr = ""; // added to stop compiling CSSPError
if (retStr != "") // will never be true
{
tvItemInfrastructureTypeTVItemLink.HasErrors = true;
yield return(new ValidationResult("AAA", new[] { "AAA" }));
}
}
/// <summary>
/// Validate function for all MapObjService commands
/// </summary>
/// <param name="validationContext">System.ComponentModel.DataAnnotations.ValidationContext (Describes the context in which a validation check is performed.)</param>
/// <param name="actionDBType">[ActionDBTypeEnum] (CSSPEnums.ActionDBTypeEnum.html) action type to validate</param>
/// <returns>IEnumerable of ValidationResult (Where ValidationResult is a container for the results of a validation request.)</returns>
private IEnumerable <ValidationResult> Validate(ValidationContext validationContext, ActionDBTypeEnum actionDBType)
{
string retStr = "";
Enums enums = new Enums(LanguageRequest);
MapObj mapObj = validationContext.ObjectInstance as MapObj;
mapObj.HasErrors = false;
if (mapObj.MapInfoID < 1)
{
mapObj.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MinValueIs_, "MapInfoID", "1"), new[] { "MapInfoID" }));
}
retStr = enums.EnumTypeOK(typeof(MapInfoDrawTypeEnum), (int?)mapObj.MapInfoDrawType);
if (!string.IsNullOrWhiteSpace(retStr))
{
mapObj.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "MapInfoDrawType"), new[] { "MapInfoDrawType" }));
}
if (!string.IsNullOrWhiteSpace(mapObj.MapInfoDrawTypeText) && mapObj.MapInfoDrawTypeText.Length > 100)
{
mapObj.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "MapInfoDrawTypeText", "100"), new[] { "MapInfoDrawTypeText" }));
}
//CSSPError: Type not implemented [CoordList] of type [List`1]
//CSSPError: Type not implemented [CoordList] of type [Coord]
retStr = ""; // added to stop compiling CSSPError
if (retStr != "") // will never be true
{
mapObj.HasErrors = true;
yield return(new ValidationResult("AAA", new[] { "AAA" }));
}
}
private IEnumerable <ValidationResult> Validate(ValidationContext validationContext, ActionDBTypeEnum actionDBType)
{
string retStr = "";
Enums enums = new Enums(LanguageRequest);
TVTextLanguage tvTextLanguage = validationContext.ObjectInstance as TVTextLanguage;
tvTextLanguage.HasErrors = false;
if (string.IsNullOrWhiteSpace(tvTextLanguage.TVText))
{
tvTextLanguage.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "TVText"), new[] { "TVText" }));
}
//TVText has no StringLength Attribute
retStr = enums.EnumTypeOK(typeof(LanguageEnum), (int?)tvTextLanguage.Language);
if (!string.IsNullOrWhiteSpace(retStr))
{
tvTextLanguage.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "Language"), new[] { "Language" }));
}
if (!string.IsNullOrWhiteSpace(tvTextLanguage.LanguageText) && tvTextLanguage.LanguageText.Length > 100)
{
tvTextLanguage.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "LanguageText", "100"), new[] { "LanguageText" }));
}
retStr = ""; // added to stop compiling CSSPError
if (retStr != "") // will never be true
{
tvTextLanguage.HasErrors = true;
yield return(new ValidationResult("AAA", new[] { "AAA" }));
}
}
/// <summary>
/// Validate function for all MWQMRunService commands
/// </summary>
/// <param name="validationContext">System.ComponentModel.DataAnnotations.ValidationContext (Describes the context in which a validation check is performed.)</param>
/// <param name="actionDBType">[ActionDBTypeEnum] (CSSPEnums.ActionDBTypeEnum.html) action type to validate</param>
/// <returns>IEnumerable of ValidationResult (Where ValidationResult is a container for the results of a validation request.)</returns>
private IEnumerable <ValidationResult> Validate(ValidationContext validationContext, ActionDBTypeEnum actionDBType)
{
string retStr = "";
Enums enums = new Enums(LanguageRequest);
MWQMRun mwqmRun = validationContext.ObjectInstance as MWQMRun;
mwqmRun.HasErrors = false;
if (actionDBType == ActionDBTypeEnum.Update || actionDBType == ActionDBTypeEnum.Delete)
{
if (mwqmRun.MWQMRunID == 0)
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "MWQMRunID"), new[] { "MWQMRunID" }));
}
if (!(from c in db.MWQMRuns select c).Where(c => c.MWQMRunID == mwqmRun.MWQMRunID).Any())
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "MWQMRun", "MWQMRunID", mwqmRun.MWQMRunID.ToString()), new[] { "MWQMRunID" }));
}
}
TVItem TVItemSubsectorTVItemID = (from c in db.TVItems where c.TVItemID == mwqmRun.SubsectorTVItemID select c).FirstOrDefault();
if (TVItemSubsectorTVItemID == null)
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "SubsectorTVItemID", mwqmRun.SubsectorTVItemID.ToString()), new[] { "SubsectorTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.Subsector,
};
if (!AllowableTVTypes.Contains(TVItemSubsectorTVItemID.TVType))
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "SubsectorTVItemID", "Subsector"), new[] { "SubsectorTVItemID" }));
}
}
TVItem TVItemMWQMRunTVItemID = (from c in db.TVItems where c.TVItemID == mwqmRun.MWQMRunTVItemID select c).FirstOrDefault();
if (TVItemMWQMRunTVItemID == null)
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "MWQMRunTVItemID", mwqmRun.MWQMRunTVItemID.ToString()), new[] { "MWQMRunTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.MWQMRun,
};
if (!AllowableTVTypes.Contains(TVItemMWQMRunTVItemID.TVType))
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "MWQMRunTVItemID", "MWQMRun"), new[] { "MWQMRunTVItemID" }));
}
}
retStr = enums.EnumTypeOK(typeof(SampleTypeEnum), (int?)mwqmRun.RunSampleType);
if (!string.IsNullOrWhiteSpace(retStr))
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "RunSampleType"), new[] { "RunSampleType" }));
}
if (mwqmRun.DateTime_Local.Year == 1)
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "DateTime_Local"), new[] { "DateTime_Local" }));
}
else
{
if (mwqmRun.DateTime_Local.Year < 1980)
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "DateTime_Local", "1980"), new[] { "DateTime_Local" }));
}
}
if (mwqmRun.RunNumber < 1 || mwqmRun.RunNumber > 1000)
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "RunNumber", "1", "1000"), new[] { "RunNumber" }));
}
if (mwqmRun.StartDateTime_Local != null && ((DateTime)mwqmRun.StartDateTime_Local).Year < 1980)
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "StartDateTime_Local", "1980"), new[] { "StartDateTime_Local" }));
}
if (mwqmRun.EndDateTime_Local != null && ((DateTime)mwqmRun.EndDateTime_Local).Year < 1980)
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "EndDateTime_Local", "1980"), new[] { "EndDateTime_Local" }));
}
if (mwqmRun.StartDateTime_Local > mwqmRun.EndDateTime_Local)
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._DateIsBiggerThan_, "EndDateTime_Local", "MWQMRunStartDateTime_Local"), new[] { "EndDateTime_Local" }));
}
if (mwqmRun.LabReceivedDateTime_Local != null && ((DateTime)mwqmRun.LabReceivedDateTime_Local).Year < 1980)
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "LabReceivedDateTime_Local", "1980"), new[] { "LabReceivedDateTime_Local" }));
}
if (mwqmRun.TemperatureControl1_C != null)
{
if (mwqmRun.TemperatureControl1_C < -10 || mwqmRun.TemperatureControl1_C > 40)
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "TemperatureControl1_C", "-10", "40"), new[] { "TemperatureControl1_C" }));
}
}
if (mwqmRun.TemperatureControl2_C != null)
{
if (mwqmRun.TemperatureControl2_C < -10 || mwqmRun.TemperatureControl2_C > 40)
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "TemperatureControl2_C", "-10", "40"), new[] { "TemperatureControl2_C" }));
}
}
if (mwqmRun.SeaStateAtStart_BeaufortScale != null)
{
retStr = enums.EnumTypeOK(typeof(BeaufortScaleEnum), (int?)mwqmRun.SeaStateAtStart_BeaufortScale);
if (mwqmRun.SeaStateAtStart_BeaufortScale == null || !string.IsNullOrWhiteSpace(retStr))
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "SeaStateAtStart_BeaufortScale"), new[] { "SeaStateAtStart_BeaufortScale" }));
}
}
if (mwqmRun.SeaStateAtEnd_BeaufortScale != null)
{
retStr = enums.EnumTypeOK(typeof(BeaufortScaleEnum), (int?)mwqmRun.SeaStateAtEnd_BeaufortScale);
if (mwqmRun.SeaStateAtEnd_BeaufortScale == null || !string.IsNullOrWhiteSpace(retStr))
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "SeaStateAtEnd_BeaufortScale"), new[] { "SeaStateAtEnd_BeaufortScale" }));
}
}
if (mwqmRun.WaterLevelAtBrook_m != null)
{
if (mwqmRun.WaterLevelAtBrook_m < 0 || mwqmRun.WaterLevelAtBrook_m > 100)
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "WaterLevelAtBrook_m", "0", "100"), new[] { "WaterLevelAtBrook_m" }));
}
}
if (mwqmRun.WaveHightAtStart_m != null)
{
if (mwqmRun.WaveHightAtStart_m < 0 || mwqmRun.WaveHightAtStart_m > 100)
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "WaveHightAtStart_m", "0", "100"), new[] { "WaveHightAtStart_m" }));
}
}
if (mwqmRun.WaveHightAtEnd_m != null)
{
if (mwqmRun.WaveHightAtEnd_m < 0 || mwqmRun.WaveHightAtEnd_m > 100)
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "WaveHightAtEnd_m", "0", "100"), new[] { "WaveHightAtEnd_m" }));
}
}
if (!string.IsNullOrWhiteSpace(mwqmRun.SampleCrewInitials) && mwqmRun.SampleCrewInitials.Length > 20)
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "SampleCrewInitials", "20"), new[] { "SampleCrewInitials" }));
}
if (mwqmRun.AnalyzeMethod != null)
{
retStr = enums.EnumTypeOK(typeof(AnalyzeMethodEnum), (int?)mwqmRun.AnalyzeMethod);
if (mwqmRun.AnalyzeMethod == null || !string.IsNullOrWhiteSpace(retStr))
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "AnalyzeMethod"), new[] { "AnalyzeMethod" }));
}
}
if (mwqmRun.SampleMatrix != null)
{
retStr = enums.EnumTypeOK(typeof(SampleMatrixEnum), (int?)mwqmRun.SampleMatrix);
if (mwqmRun.SampleMatrix == null || !string.IsNullOrWhiteSpace(retStr))
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "SampleMatrix"), new[] { "SampleMatrix" }));
}
}
if (mwqmRun.Laboratory != null)
{
retStr = enums.EnumTypeOK(typeof(LaboratoryEnum), (int?)mwqmRun.Laboratory);
if (mwqmRun.Laboratory == null || !string.IsNullOrWhiteSpace(retStr))
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "Laboratory"), new[] { "Laboratory" }));
}
}
if (mwqmRun.SampleStatus != null)
{
retStr = enums.EnumTypeOK(typeof(SampleStatusEnum), (int?)mwqmRun.SampleStatus);
if (mwqmRun.SampleStatus == null || !string.IsNullOrWhiteSpace(retStr))
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "SampleStatus"), new[] { "SampleStatus" }));
}
}
if (mwqmRun.LabSampleApprovalContactTVItemID != null)
{
TVItem TVItemLabSampleApprovalContactTVItemID = (from c in db.TVItems where c.TVItemID == mwqmRun.LabSampleApprovalContactTVItemID select c).FirstOrDefault();
if (TVItemLabSampleApprovalContactTVItemID == null)
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "LabSampleApprovalContactTVItemID", (mwqmRun.LabSampleApprovalContactTVItemID == null ? "" : mwqmRun.LabSampleApprovalContactTVItemID.ToString())), new[] { "LabSampleApprovalContactTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.Contact,
};
if (!AllowableTVTypes.Contains(TVItemLabSampleApprovalContactTVItemID.TVType))
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "LabSampleApprovalContactTVItemID", "Contact"), new[] { "LabSampleApprovalContactTVItemID" }));
}
}
}
if (mwqmRun.LabAnalyzeBath1IncubationStartDateTime_Local != null && ((DateTime)mwqmRun.LabAnalyzeBath1IncubationStartDateTime_Local).Year < 1980)
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "LabAnalyzeBath1IncubationStartDateTime_Local", "1980"), new[] { "LabAnalyzeBath1IncubationStartDateTime_Local" }));
}
if (mwqmRun.LabAnalyzeBath2IncubationStartDateTime_Local != null && ((DateTime)mwqmRun.LabAnalyzeBath2IncubationStartDateTime_Local).Year < 1980)
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "LabAnalyzeBath2IncubationStartDateTime_Local", "1980"), new[] { "LabAnalyzeBath2IncubationStartDateTime_Local" }));
}
if (mwqmRun.LabAnalyzeBath3IncubationStartDateTime_Local != null && ((DateTime)mwqmRun.LabAnalyzeBath3IncubationStartDateTime_Local).Year < 1980)
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "LabAnalyzeBath3IncubationStartDateTime_Local", "1980"), new[] { "LabAnalyzeBath3IncubationStartDateTime_Local" }));
}
if (mwqmRun.LabRunSampleApprovalDateTime_Local != null && ((DateTime)mwqmRun.LabRunSampleApprovalDateTime_Local).Year < 1980)
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "LabRunSampleApprovalDateTime_Local", "1980"), new[] { "LabRunSampleApprovalDateTime_Local" }));
}
if (mwqmRun.Tide_Start != null)
{
retStr = enums.EnumTypeOK(typeof(TideTextEnum), (int?)mwqmRun.Tide_Start);
if (mwqmRun.Tide_Start == null || !string.IsNullOrWhiteSpace(retStr))
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "Tide_Start"), new[] { "Tide_Start" }));
}
}
if (mwqmRun.Tide_End != null)
{
retStr = enums.EnumTypeOK(typeof(TideTextEnum), (int?)mwqmRun.Tide_End);
if (mwqmRun.Tide_End == null || !string.IsNullOrWhiteSpace(retStr))
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "Tide_End"), new[] { "Tide_End" }));
}
}
if (mwqmRun.RainDay0_mm != null)
{
if (mwqmRun.RainDay0_mm < 0 || mwqmRun.RainDay0_mm > 300)
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "RainDay0_mm", "0", "300"), new[] { "RainDay0_mm" }));
}
}
if (mwqmRun.RainDay1_mm != null)
{
if (mwqmRun.RainDay1_mm < 0 || mwqmRun.RainDay1_mm > 300)
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "RainDay1_mm", "0", "300"), new[] { "RainDay1_mm" }));
}
}
if (mwqmRun.RainDay2_mm != null)
{
if (mwqmRun.RainDay2_mm < 0 || mwqmRun.RainDay2_mm > 300)
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "RainDay2_mm", "0", "300"), new[] { "RainDay2_mm" }));
}
}
if (mwqmRun.RainDay3_mm != null)
{
if (mwqmRun.RainDay3_mm < 0 || mwqmRun.RainDay3_mm > 300)
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "RainDay3_mm", "0", "300"), new[] { "RainDay3_mm" }));
}
}
if (mwqmRun.RainDay4_mm != null)
{
if (mwqmRun.RainDay4_mm < 0 || mwqmRun.RainDay4_mm > 300)
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "RainDay4_mm", "0", "300"), new[] { "RainDay4_mm" }));
}
}
if (mwqmRun.RainDay5_mm != null)
{
if (mwqmRun.RainDay5_mm < 0 || mwqmRun.RainDay5_mm > 300)
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "RainDay5_mm", "0", "300"), new[] { "RainDay5_mm" }));
}
}
if (mwqmRun.RainDay6_mm != null)
{
if (mwqmRun.RainDay6_mm < 0 || mwqmRun.RainDay6_mm > 300)
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "RainDay6_mm", "0", "300"), new[] { "RainDay6_mm" }));
}
}
if (mwqmRun.RainDay7_mm != null)
{
if (mwqmRun.RainDay7_mm < 0 || mwqmRun.RainDay7_mm > 300)
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "RainDay7_mm", "0", "300"), new[] { "RainDay7_mm" }));
}
}
if (mwqmRun.RainDay8_mm != null)
{
if (mwqmRun.RainDay8_mm < 0 || mwqmRun.RainDay8_mm > 300)
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "RainDay8_mm", "0", "300"), new[] { "RainDay8_mm" }));
}
}
if (mwqmRun.RainDay9_mm != null)
{
if (mwqmRun.RainDay9_mm < 0 || mwqmRun.RainDay9_mm > 300)
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "RainDay9_mm", "0", "300"), new[] { "RainDay9_mm" }));
}
}
if (mwqmRun.RainDay10_mm != null)
{
if (mwqmRun.RainDay10_mm < 0 || mwqmRun.RainDay10_mm > 300)
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "RainDay10_mm", "0", "300"), new[] { "RainDay10_mm" }));
}
}
if (mwqmRun.LastUpdateDate_UTC.Year == 1)
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "LastUpdateDate_UTC"), new[] { "LastUpdateDate_UTC" }));
}
else
{
if (mwqmRun.LastUpdateDate_UTC.Year < 1980)
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "LastUpdateDate_UTC", "1980"), new[] { "LastUpdateDate_UTC" }));
}
}
TVItem TVItemLastUpdateContactTVItemID = (from c in db.TVItems where c.TVItemID == mwqmRun.LastUpdateContactTVItemID select c).FirstOrDefault();
if (TVItemLastUpdateContactTVItemID == null)
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "LastUpdateContactTVItemID", mwqmRun.LastUpdateContactTVItemID.ToString()), new[] { "LastUpdateContactTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.Contact,
};
if (!AllowableTVTypes.Contains(TVItemLastUpdateContactTVItemID.TVType))
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "LastUpdateContactTVItemID", "Contact"), new[] { "LastUpdateContactTVItemID" }));
}
}
retStr = ""; // added to stop compiling CSSPError
if (retStr != "") // will never be true
{
mwqmRun.HasErrors = true;
yield return(new ValidationResult("AAA", new[] { "AAA" }));
}
}
private IEnumerable <ValidationResult> Validate(ValidationContext validationContext, ActionDBTypeEnum actionDBType)
{
string retStr = "";
Enums enums = new Enums(LanguageRequest);
SamplingPlan samplingPlan = validationContext.ObjectInstance as SamplingPlan;
samplingPlan.HasErrors = false;
if (actionDBType == ActionDBTypeEnum.Update || actionDBType == ActionDBTypeEnum.Delete)
{
if (samplingPlan.SamplingPlanID == 0)
{
samplingPlan.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "SamplingPlanID"), new[] { "SamplingPlanID" }));
}
if (!(from c in db.SamplingPlans select c).Where(c => c.SamplingPlanID == samplingPlan.SamplingPlanID).Any())
{
samplingPlan.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "SamplingPlan", "SamplingPlanID", samplingPlan.SamplingPlanID.ToString()), new[] { "SamplingPlanID" }));
}
}
if (string.IsNullOrWhiteSpace(samplingPlan.SamplingPlanName))
{
samplingPlan.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "SamplingPlanName"), new[] { "SamplingPlanName" }));
}
if (!string.IsNullOrWhiteSpace(samplingPlan.SamplingPlanName) && samplingPlan.SamplingPlanName.Length > 200)
{
samplingPlan.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "SamplingPlanName", "200"), new[] { "SamplingPlanName" }));
}
if (string.IsNullOrWhiteSpace(samplingPlan.ForGroupName))
{
samplingPlan.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "ForGroupName"), new[] { "ForGroupName" }));
}
if (!string.IsNullOrWhiteSpace(samplingPlan.ForGroupName) && samplingPlan.ForGroupName.Length > 100)
{
samplingPlan.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "ForGroupName", "100"), new[] { "ForGroupName" }));
}
retStr = enums.EnumTypeOK(typeof(SampleTypeEnum), (int?)samplingPlan.SampleType);
if (!string.IsNullOrWhiteSpace(retStr))
{
samplingPlan.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "SampleType"), new[] { "SampleType" }));
}
retStr = enums.EnumTypeOK(typeof(SamplingPlanTypeEnum), (int?)samplingPlan.SamplingPlanType);
if (!string.IsNullOrWhiteSpace(retStr))
{
samplingPlan.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "SamplingPlanType"), new[] { "SamplingPlanType" }));
}
retStr = enums.EnumTypeOK(typeof(LabSheetTypeEnum), (int?)samplingPlan.LabSheetType);
if (!string.IsNullOrWhiteSpace(retStr))
{
samplingPlan.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "LabSheetType"), new[] { "LabSheetType" }));
}
TVItem TVItemProvinceTVItemID = (from c in db.TVItems where c.TVItemID == samplingPlan.ProvinceTVItemID select c).FirstOrDefault();
if (TVItemProvinceTVItemID == null)
{
samplingPlan.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "ProvinceTVItemID", samplingPlan.ProvinceTVItemID.ToString()), new[] { "ProvinceTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.Province,
};
if (!AllowableTVTypes.Contains(TVItemProvinceTVItemID.TVType))
{
samplingPlan.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "ProvinceTVItemID", "Province"), new[] { "ProvinceTVItemID" }));
}
}
TVItem TVItemCreatorTVItemID = (from c in db.TVItems where c.TVItemID == samplingPlan.CreatorTVItemID select c).FirstOrDefault();
if (TVItemCreatorTVItemID == null)
{
samplingPlan.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "CreatorTVItemID", samplingPlan.CreatorTVItemID.ToString()), new[] { "CreatorTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.Contact,
};
if (!AllowableTVTypes.Contains(TVItemCreatorTVItemID.TVType))
{
samplingPlan.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "CreatorTVItemID", "Contact"), new[] { "CreatorTVItemID" }));
}
}
if (samplingPlan.Year < 2000 || samplingPlan.Year > 2050)
{
samplingPlan.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Year", "2000", "2050"), new[] { "Year" }));
}
if (string.IsNullOrWhiteSpace(samplingPlan.AccessCode))
{
samplingPlan.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "AccessCode"), new[] { "AccessCode" }));
}
if (!string.IsNullOrWhiteSpace(samplingPlan.AccessCode) && samplingPlan.AccessCode.Length > 15)
{
samplingPlan.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "AccessCode", "15"), new[] { "AccessCode" }));
}
if (samplingPlan.DailyDuplicatePrecisionCriteria < 0 || samplingPlan.DailyDuplicatePrecisionCriteria > 100)
{
samplingPlan.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "DailyDuplicatePrecisionCriteria", "0", "100"), new[] { "DailyDuplicatePrecisionCriteria" }));
}
if (samplingPlan.IntertechDuplicatePrecisionCriteria < 0 || samplingPlan.IntertechDuplicatePrecisionCriteria > 100)
{
samplingPlan.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "IntertechDuplicatePrecisionCriteria", "0", "100"), new[] { "IntertechDuplicatePrecisionCriteria" }));
}
if (string.IsNullOrWhiteSpace(samplingPlan.ApprovalCode))
{
samplingPlan.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "ApprovalCode"), new[] { "ApprovalCode" }));
}
if (!string.IsNullOrWhiteSpace(samplingPlan.ApprovalCode) && samplingPlan.ApprovalCode.Length > 15)
{
samplingPlan.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "ApprovalCode", "15"), new[] { "ApprovalCode" }));
}
if (samplingPlan.SamplingPlanFileTVItemID != null)
{
TVItem TVItemSamplingPlanFileTVItemID = (from c in db.TVItems where c.TVItemID == samplingPlan.SamplingPlanFileTVItemID select c).FirstOrDefault();
if (TVItemSamplingPlanFileTVItemID == null)
{
samplingPlan.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "SamplingPlanFileTVItemID", (samplingPlan.SamplingPlanFileTVItemID == null ? "" : samplingPlan.SamplingPlanFileTVItemID.ToString())), new[] { "SamplingPlanFileTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.File,
};
if (!AllowableTVTypes.Contains(TVItemSamplingPlanFileTVItemID.TVType))
{
samplingPlan.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "SamplingPlanFileTVItemID", "File"), new[] { "SamplingPlanFileTVItemID" }));
}
}
}
if (samplingPlan.AnalyzeMethodDefault != null)
{
retStr = enums.EnumTypeOK(typeof(AnalyzeMethodEnum), (int?)samplingPlan.AnalyzeMethodDefault);
if (samplingPlan.AnalyzeMethodDefault == null || !string.IsNullOrWhiteSpace(retStr))
{
samplingPlan.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "AnalyzeMethodDefault"), new[] { "AnalyzeMethodDefault" }));
}
}
if (samplingPlan.SampleMatrixDefault != null)
{
retStr = enums.EnumTypeOK(typeof(SampleMatrixEnum), (int?)samplingPlan.SampleMatrixDefault);
if (samplingPlan.SampleMatrixDefault == null || !string.IsNullOrWhiteSpace(retStr))
{
samplingPlan.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "SampleMatrixDefault"), new[] { "SampleMatrixDefault" }));
}
}
if (samplingPlan.LaboratoryDefault != null)
{
retStr = enums.EnumTypeOK(typeof(LaboratoryEnum), (int?)samplingPlan.LaboratoryDefault);
if (samplingPlan.LaboratoryDefault == null || !string.IsNullOrWhiteSpace(retStr))
{
samplingPlan.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "LaboratoryDefault"), new[] { "LaboratoryDefault" }));
}
}
if (string.IsNullOrWhiteSpace(samplingPlan.BackupDirectory))
{
samplingPlan.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "BackupDirectory"), new[] { "BackupDirectory" }));
}
if (!string.IsNullOrWhiteSpace(samplingPlan.BackupDirectory) && samplingPlan.BackupDirectory.Length > 250)
{
samplingPlan.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "BackupDirectory", "250"), new[] { "BackupDirectory" }));
}
if (samplingPlan.LastUpdateDate_UTC.Year == 1)
{
samplingPlan.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "LastUpdateDate_UTC"), new[] { "LastUpdateDate_UTC" }));
}
else
{
if (samplingPlan.LastUpdateDate_UTC.Year < 1980)
{
samplingPlan.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "LastUpdateDate_UTC", "1980"), new[] { "LastUpdateDate_UTC" }));
}
}
TVItem TVItemLastUpdateContactTVItemID = (from c in db.TVItems where c.TVItemID == samplingPlan.LastUpdateContactTVItemID select c).FirstOrDefault();
if (TVItemLastUpdateContactTVItemID == null)
{
samplingPlan.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "LastUpdateContactTVItemID", samplingPlan.LastUpdateContactTVItemID.ToString()), new[] { "LastUpdateContactTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.Contact,
};
if (!AllowableTVTypes.Contains(TVItemLastUpdateContactTVItemID.TVType))
{
samplingPlan.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "LastUpdateContactTVItemID", "Contact"), new[] { "LastUpdateContactTVItemID" }));
}
}
retStr = ""; // added to stop compiling CSSPError
if (retStr != "") // will never be true
{
samplingPlan.HasErrors = true;
yield return(new ValidationResult("AAA", new[] { "AAA" }));
}
}
private IEnumerable <ValidationResult> Validate(ValidationContext validationContext, ActionDBTypeEnum actionDBType)
{
string retStr = "";
Enums enums = new Enums(LanguageRequest);
Classification classification = validationContext.ObjectInstance as Classification;
classification.HasErrors = false;
if (actionDBType == ActionDBTypeEnum.Update || actionDBType == ActionDBTypeEnum.Delete)
{
if (classification.ClassificationID == 0)
{
classification.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "ClassificationID"), new[] { "ClassificationID" }));
}
if (!(from c in db.Classifications select c).Where(c => c.ClassificationID == classification.ClassificationID).Any())
{
classification.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "Classification", "ClassificationID", classification.ClassificationID.ToString()), new[] { "ClassificationID" }));
}
}
TVItem TVItemClassificationTVItemID = (from c in db.TVItems where c.TVItemID == classification.ClassificationTVItemID select c).FirstOrDefault();
if (TVItemClassificationTVItemID == null)
{
classification.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "ClassificationTVItemID", classification.ClassificationTVItemID.ToString()), new[] { "ClassificationTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.Classification,
};
if (!AllowableTVTypes.Contains(TVItemClassificationTVItemID.TVType))
{
classification.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "ClassificationTVItemID", "Classification"), new[] { "ClassificationTVItemID" }));
}
}
retStr = enums.EnumTypeOK(typeof(ClassificationTypeEnum), (int?)classification.ClassificationType);
if (!string.IsNullOrWhiteSpace(retStr))
{
classification.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "ClassificationType"), new[] { "ClassificationType" }));
}
if (classification.Ordinal < 0 || classification.Ordinal > 10000)
{
classification.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Ordinal", "0", "10000"), new[] { "Ordinal" }));
}
if (classification.LastUpdateDate_UTC.Year == 1)
{
classification.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "LastUpdateDate_UTC"), new[] { "LastUpdateDate_UTC" }));
}
else
{
if (classification.LastUpdateDate_UTC.Year < 1980)
{
classification.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "LastUpdateDate_UTC", "1980"), new[] { "LastUpdateDate_UTC" }));
}
}
TVItem TVItemLastUpdateContactTVItemID = (from c in db.TVItems where c.TVItemID == classification.LastUpdateContactTVItemID select c).FirstOrDefault();
if (TVItemLastUpdateContactTVItemID == null)
{
classification.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "LastUpdateContactTVItemID", classification.LastUpdateContactTVItemID.ToString()), new[] { "LastUpdateContactTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.Contact,
};
if (!AllowableTVTypes.Contains(TVItemLastUpdateContactTVItemID.TVType))
{
classification.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "LastUpdateContactTVItemID", "Contact"), new[] { "LastUpdateContactTVItemID" }));
}
}
retStr = ""; // added to stop compiling CSSPError
if (retStr != "") // will never be true
{
classification.HasErrors = true;
yield return(new ValidationResult("AAA", new[] { "AAA" }));
}
}
/// <summary>
/// Validate function for all LabSheetService commands
/// </summary>
/// <param name="validationContext">System.ComponentModel.DataAnnotations.ValidationContext (Describes the context in which a validation check is performed.)</param>
/// <param name="actionDBType">[ActionDBTypeEnum] (CSSPEnums.ActionDBTypeEnum.html) action type to validate</param>
/// <returns>IEnumerable of ValidationResult (Where ValidationResult is a container for the results of a validation request.)</returns>
private IEnumerable <ValidationResult> Validate(ValidationContext validationContext, ActionDBTypeEnum actionDBType)
{
string retStr = "";
Enums enums = new Enums(LanguageRequest);
LabSheet labSheet = validationContext.ObjectInstance as LabSheet;
labSheet.HasErrors = false;
if (actionDBType == ActionDBTypeEnum.Update || actionDBType == ActionDBTypeEnum.Delete)
{
if (labSheet.LabSheetID == 0)
{
labSheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "LabSheetID"), new[] { "LabSheetID" }));
}
if (!(from c in db.LabSheets select c).Where(c => c.LabSheetID == labSheet.LabSheetID).Any())
{
labSheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "LabSheet", "LabSheetID", labSheet.LabSheetID.ToString()), new[] { "LabSheetID" }));
}
}
if (labSheet.OtherServerLabSheetID < 1)
{
labSheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MinValueIs_, "OtherServerLabSheetID", "1"), new[] { "OtherServerLabSheetID" }));
}
SamplingPlan SamplingPlanSamplingPlanID = (from c in db.SamplingPlans where c.SamplingPlanID == labSheet.SamplingPlanID select c).FirstOrDefault();
if (SamplingPlanSamplingPlanID == null)
{
labSheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "SamplingPlan", "SamplingPlanID", labSheet.SamplingPlanID.ToString()), new[] { "SamplingPlanID" }));
}
if (string.IsNullOrWhiteSpace(labSheet.SamplingPlanName))
{
labSheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "SamplingPlanName"), new[] { "SamplingPlanName" }));
}
if (!string.IsNullOrWhiteSpace(labSheet.SamplingPlanName) && (labSheet.SamplingPlanName.Length < 1 || labSheet.SamplingPlanName.Length > 250))
{
labSheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._LengthShouldBeBetween_And_, "SamplingPlanName", "1", "250"), new[] { "SamplingPlanName" }));
}
if (labSheet.Year < 1980)
{
labSheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MinValueIs_, "Year", "1980"), new[] { "Year" }));
}
if (labSheet.Month < 1 || labSheet.Month > 12)
{
labSheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Month", "1", "12"), new[] { "Month" }));
}
if (labSheet.Day < 1 || labSheet.Day > 31)
{
labSheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Day", "1", "31"), new[] { "Day" }));
}
if (labSheet.RunNumber < 1 || labSheet.RunNumber > 100)
{
labSheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "RunNumber", "1", "100"), new[] { "RunNumber" }));
}
TVItem TVItemSubsectorTVItemID = (from c in db.TVItems where c.TVItemID == labSheet.SubsectorTVItemID select c).FirstOrDefault();
if (TVItemSubsectorTVItemID == null)
{
labSheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "SubsectorTVItemID", labSheet.SubsectorTVItemID.ToString()), new[] { "SubsectorTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.Subsector,
};
if (!AllowableTVTypes.Contains(TVItemSubsectorTVItemID.TVType))
{
labSheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "SubsectorTVItemID", "Subsector"), new[] { "SubsectorTVItemID" }));
}
}
if (labSheet.MWQMRunTVItemID != null)
{
TVItem TVItemMWQMRunTVItemID = (from c in db.TVItems where c.TVItemID == labSheet.MWQMRunTVItemID select c).FirstOrDefault();
if (TVItemMWQMRunTVItemID == null)
{
labSheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "MWQMRunTVItemID", (labSheet.MWQMRunTVItemID == null ? "" : labSheet.MWQMRunTVItemID.ToString())), new[] { "MWQMRunTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.MWQMRun,
};
if (!AllowableTVTypes.Contains(TVItemMWQMRunTVItemID.TVType))
{
labSheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "MWQMRunTVItemID", "MWQMRun"), new[] { "MWQMRunTVItemID" }));
}
}
}
retStr = enums.EnumTypeOK(typeof(SamplingPlanTypeEnum), (int?)labSheet.SamplingPlanType);
if (!string.IsNullOrWhiteSpace(retStr))
{
labSheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "SamplingPlanType"), new[] { "SamplingPlanType" }));
}
retStr = enums.EnumTypeOK(typeof(SampleTypeEnum), (int?)labSheet.SampleType);
if (!string.IsNullOrWhiteSpace(retStr))
{
labSheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "SampleType"), new[] { "SampleType" }));
}
retStr = enums.EnumTypeOK(typeof(LabSheetTypeEnum), (int?)labSheet.LabSheetType);
if (!string.IsNullOrWhiteSpace(retStr))
{
labSheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "LabSheetType"), new[] { "LabSheetType" }));
}
retStr = enums.EnumTypeOK(typeof(LabSheetStatusEnum), (int?)labSheet.LabSheetStatus);
if (!string.IsNullOrWhiteSpace(retStr))
{
labSheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "LabSheetStatus"), new[] { "LabSheetStatus" }));
}
if (string.IsNullOrWhiteSpace(labSheet.FileName))
{
labSheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "FileName"), new[] { "FileName" }));
}
if (!string.IsNullOrWhiteSpace(labSheet.FileName) && (labSheet.FileName.Length < 1 || labSheet.FileName.Length > 250))
{
labSheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._LengthShouldBeBetween_And_, "FileName", "1", "250"), new[] { "FileName" }));
}
if (labSheet.FileLastModifiedDate_Local.Year == 1)
{
labSheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "FileLastModifiedDate_Local"), new[] { "FileLastModifiedDate_Local" }));
}
else
{
if (labSheet.FileLastModifiedDate_Local.Year < 1980)
{
labSheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "FileLastModifiedDate_Local", "1980"), new[] { "FileLastModifiedDate_Local" }));
}
}
if (string.IsNullOrWhiteSpace(labSheet.FileContent))
{
labSheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "FileContent"), new[] { "FileContent" }));
}
//FileContent has no StringLength Attribute
if (labSheet.AcceptedOrRejectedByContactTVItemID != null)
{
TVItem TVItemAcceptedOrRejectedByContactTVItemID = (from c in db.TVItems where c.TVItemID == labSheet.AcceptedOrRejectedByContactTVItemID select c).FirstOrDefault();
if (TVItemAcceptedOrRejectedByContactTVItemID == null)
{
labSheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "AcceptedOrRejectedByContactTVItemID", (labSheet.AcceptedOrRejectedByContactTVItemID == null ? "" : labSheet.AcceptedOrRejectedByContactTVItemID.ToString())), new[] { "AcceptedOrRejectedByContactTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.Contact,
};
if (!AllowableTVTypes.Contains(TVItemAcceptedOrRejectedByContactTVItemID.TVType))
{
labSheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "AcceptedOrRejectedByContactTVItemID", "Contact"), new[] { "AcceptedOrRejectedByContactTVItemID" }));
}
}
}
if (labSheet.AcceptedOrRejectedDateTime != null && ((DateTime)labSheet.AcceptedOrRejectedDateTime).Year < 1980)
{
labSheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "AcceptedOrRejectedDateTime", "1980"), new[] { "AcceptedOrRejectedDateTime" }));
}
if (!string.IsNullOrWhiteSpace(labSheet.RejectReason) && labSheet.RejectReason.Length > 250)
{
labSheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "RejectReason", "250"), new[] { "RejectReason" }));
}
if (labSheet.LastUpdateDate_UTC.Year == 1)
{
labSheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "LastUpdateDate_UTC"), new[] { "LastUpdateDate_UTC" }));
}
else
{
if (labSheet.LastUpdateDate_UTC.Year < 1980)
{
labSheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "LastUpdateDate_UTC", "1980"), new[] { "LastUpdateDate_UTC" }));
}
}
TVItem TVItemLastUpdateContactTVItemID = (from c in db.TVItems where c.TVItemID == labSheet.LastUpdateContactTVItemID select c).FirstOrDefault();
if (TVItemLastUpdateContactTVItemID == null)
{
labSheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "LastUpdateContactTVItemID", labSheet.LastUpdateContactTVItemID.ToString()), new[] { "LastUpdateContactTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.Contact,
};
if (!AllowableTVTypes.Contains(TVItemLastUpdateContactTVItemID.TVType))
{
labSheet.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "LastUpdateContactTVItemID", "Contact"), new[] { "LastUpdateContactTVItemID" }));
}
}
retStr = ""; // added to stop compiling CSSPError
if (retStr != "") // will never be true
{
labSheet.HasErrors = true;
yield return(new ValidationResult("AAA", new[] { "AAA" }));
}
}
/// <summary>
/// Validate function for all TVItemTVAuthService commands
/// </summary>
/// <param name="validationContext">System.ComponentModel.DataAnnotations.ValidationContext (Describes the context in which a validation check is performed.)</param>
/// <param name="actionDBType">[ActionDBTypeEnum] (CSSPEnums.ActionDBTypeEnum.html) action type to validate</param>
/// <returns>IEnumerable of ValidationResult (Where ValidationResult is a container for the results of a validation request.)</returns>
private IEnumerable <ValidationResult> Validate(ValidationContext validationContext, ActionDBTypeEnum actionDBType)
{
string retStr = "";
Enums enums = new Enums(LanguageRequest);
TVItemTVAuth tvItemTVAuth = validationContext.ObjectInstance as TVItemTVAuth;
tvItemTVAuth.HasErrors = false;
if (tvItemTVAuth.TVItemUserAuthID < 1)
{
tvItemTVAuth.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MinValueIs_, "TVItemUserAuthID", "1"), new[] { "TVItemUserAuthID" }));
}
if (string.IsNullOrWhiteSpace(tvItemTVAuth.TVText))
{
tvItemTVAuth.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "TVText"), new[] { "TVText" }));
}
if (!string.IsNullOrWhiteSpace(tvItemTVAuth.TVText) && (tvItemTVAuth.TVText.Length < 1 || tvItemTVAuth.TVText.Length > 255))
{
tvItemTVAuth.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._LengthShouldBeBetween_And_, "TVText", "1", "255"), new[] { "TVText" }));
}
if (tvItemTVAuth.TVItemID1 < 1)
{
tvItemTVAuth.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MinValueIs_, "TVItemID1", "1"), new[] { "TVItemID1" }));
}
if (string.IsNullOrWhiteSpace(tvItemTVAuth.TVTypeStr))
{
tvItemTVAuth.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "TVTypeStr"), new[] { "TVTypeStr" }));
}
if (!string.IsNullOrWhiteSpace(tvItemTVAuth.TVTypeStr) && (tvItemTVAuth.TVTypeStr.Length < 1 || tvItemTVAuth.TVTypeStr.Length > 255))
{
tvItemTVAuth.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._LengthShouldBeBetween_And_, "TVTypeStr", "1", "255"), new[] { "TVTypeStr" }));
}
retStr = enums.EnumTypeOK(typeof(TVAuthEnum), (int?)tvItemTVAuth.TVAuth);
if (!string.IsNullOrWhiteSpace(retStr))
{
tvItemTVAuth.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "TVAuth"), new[] { "TVAuth" }));
}
if (!string.IsNullOrWhiteSpace(tvItemTVAuth.TVAuthText) && tvItemTVAuth.TVAuthText.Length > 100)
{
tvItemTVAuth.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "TVAuthText", "100"), new[] { "TVAuthText" }));
}
retStr = ""; // added to stop compiling CSSPError
if (retStr != "") // will never be true
{
tvItemTVAuth.HasErrors = true;
yield return(new ValidationResult("AAA", new[] { "AAA" }));
}
}
/// <summary>
/// Validate function for all MapInfoService commands
/// </summary>
/// <param name="validationContext">System.ComponentModel.DataAnnotations.ValidationContext (Describes the context in which a validation check is performed.)</param>
/// <param name="actionDBType">[ActionDBTypeEnum] (CSSPEnums.ActionDBTypeEnum.html) action type to validate</param>
/// <returns>IEnumerable of ValidationResult (Where ValidationResult is a container for the results of a validation request.)</returns>
private IEnumerable <ValidationResult> Validate(ValidationContext validationContext, ActionDBTypeEnum actionDBType)
{
string retStr = "";
Enums enums = new Enums(LanguageRequest);
MapInfo mapInfo = validationContext.ObjectInstance as MapInfo;
mapInfo.HasErrors = false;
if (actionDBType == ActionDBTypeEnum.Update || actionDBType == ActionDBTypeEnum.Delete)
{
if (mapInfo.MapInfoID == 0)
{
mapInfo.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "MapInfoID"), new[] { "MapInfoID" }));
}
if (!(from c in db.MapInfos select c).Where(c => c.MapInfoID == mapInfo.MapInfoID).Any())
{
mapInfo.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "MapInfo", "MapInfoID", mapInfo.MapInfoID.ToString()), new[] { "MapInfoID" }));
}
}
TVItem TVItemTVItemID = (from c in db.TVItems where c.TVItemID == mapInfo.TVItemID select c).FirstOrDefault();
if (TVItemTVItemID == null)
{
mapInfo.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "TVItemID", mapInfo.TVItemID.ToString()), new[] { "TVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.Root,
TVTypeEnum.Address,
TVTypeEnum.Area,
TVTypeEnum.ClimateSite,
TVTypeEnum.Country,
TVTypeEnum.File,
TVTypeEnum.HydrometricSite,
TVTypeEnum.MikeBoundaryConditionWebTide,
TVTypeEnum.MikeBoundaryConditionMesh,
TVTypeEnum.MikeSource,
TVTypeEnum.Municipality,
TVTypeEnum.MWQMSite,
TVTypeEnum.PolSourceSite,
TVTypeEnum.Province,
TVTypeEnum.Sector,
TVTypeEnum.Subsector,
TVTypeEnum.TideSite,
TVTypeEnum.WasteWaterTreatmentPlant,
TVTypeEnum.LiftStation,
TVTypeEnum.Spill,
TVTypeEnum.Outfall,
TVTypeEnum.OtherInfrastructure,
TVTypeEnum.SeeOtherMunicipality,
TVTypeEnum.LineOverflow,
TVTypeEnum.Classification,
TVTypeEnum.Approved,
TVTypeEnum.Restricted,
TVTypeEnum.Prohibited,
TVTypeEnum.ConditionallyApproved,
TVTypeEnum.ConditionallyRestricted,
};
if (!AllowableTVTypes.Contains(TVItemTVItemID.TVType))
{
mapInfo.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "TVItemID", "Root,Address,Area,ClimateSite,Country,File,HydrometricSite,MikeBoundaryConditionWebTide,MikeBoundaryConditionMesh,MikeSource,Municipality,MWQMSite,PolSourceSite,Province,Sector,Subsector,TideSite,WasteWaterTreatmentPlant,LiftStation,Spill,Outfall,OtherInfrastructure,SeeOtherMunicipality,LineOverflow,Classification,Approved,Restricted,Prohibited,ConditionallyApproved,ConditionallyRestricted"), new[] { "TVItemID" }));
}
}
retStr = enums.EnumTypeOK(typeof(TVTypeEnum), (int?)mapInfo.TVType);
if (!string.IsNullOrWhiteSpace(retStr))
{
mapInfo.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "TVType"), new[] { "TVType" }));
}
if (mapInfo.LatMin < -90 || mapInfo.LatMin > 90)
{
mapInfo.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "LatMin", "-90", "90"), new[] { "LatMin" }));
}
if (mapInfo.LatMax < -90 || mapInfo.LatMax > 90)
{
mapInfo.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "LatMax", "-90", "90"), new[] { "LatMax" }));
}
if (mapInfo.LngMin < -180 || mapInfo.LngMin > 180)
{
mapInfo.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "LngMin", "-180", "180"), new[] { "LngMin" }));
}
if (mapInfo.LngMax < -180 || mapInfo.LngMax > 180)
{
mapInfo.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "LngMax", "-180", "180"), new[] { "LngMax" }));
}
retStr = enums.EnumTypeOK(typeof(MapInfoDrawTypeEnum), (int?)mapInfo.MapInfoDrawType);
if (!string.IsNullOrWhiteSpace(retStr))
{
mapInfo.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "MapInfoDrawType"), new[] { "MapInfoDrawType" }));
}
if (mapInfo.LastUpdateDate_UTC.Year == 1)
{
mapInfo.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "LastUpdateDate_UTC"), new[] { "LastUpdateDate_UTC" }));
}
else
{
if (mapInfo.LastUpdateDate_UTC.Year < 1980)
{
mapInfo.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "LastUpdateDate_UTC", "1980"), new[] { "LastUpdateDate_UTC" }));
}
}
TVItem TVItemLastUpdateContactTVItemID = (from c in db.TVItems where c.TVItemID == mapInfo.LastUpdateContactTVItemID select c).FirstOrDefault();
if (TVItemLastUpdateContactTVItemID == null)
{
mapInfo.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "LastUpdateContactTVItemID", mapInfo.LastUpdateContactTVItemID.ToString()), new[] { "LastUpdateContactTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.Contact,
};
if (!AllowableTVTypes.Contains(TVItemLastUpdateContactTVItemID.TVType))
{
mapInfo.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "LastUpdateContactTVItemID", "Contact"), new[] { "LastUpdateContactTVItemID" }));
}
}
retStr = ""; // added to stop compiling CSSPError
if (retStr != "") // will never be true
{
mapInfo.HasErrors = true;
yield return(new ValidationResult("AAA", new[] { "AAA" }));
}
}
private IEnumerable <ValidationResult> Validate(ValidationContext validationContext, ActionDBTypeEnum actionDBType)
{
string retStr = "";
Enums enums = new Enums(LanguageRequest);
TVItemStat tvItemStat = validationContext.ObjectInstance as TVItemStat;
tvItemStat.HasErrors = false;
if (actionDBType == ActionDBTypeEnum.Update || actionDBType == ActionDBTypeEnum.Delete)
{
if (tvItemStat.TVItemStatID == 0)
{
tvItemStat.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "TVItemStatID"), new[] { "TVItemStatID" }));
}
if (!(from c in db.TVItemStats select c).Where(c => c.TVItemStatID == tvItemStat.TVItemStatID).Any())
{
tvItemStat.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItemStat", "TVItemStatID", tvItemStat.TVItemStatID.ToString()), new[] { "TVItemStatID" }));
}
}
TVItem TVItemTVItemID = (from c in db.TVItems where c.TVItemID == tvItemStat.TVItemID select c).FirstOrDefault();
if (TVItemTVItemID == null)
{
tvItemStat.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "TVItemID", tvItemStat.TVItemID.ToString()), new[] { "TVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.Root,
TVTypeEnum.Address,
TVTypeEnum.Area,
TVTypeEnum.ClimateSite,
TVTypeEnum.Contact,
TVTypeEnum.Country,
TVTypeEnum.Email,
TVTypeEnum.File,
TVTypeEnum.HydrometricSite,
TVTypeEnum.Infrastructure,
TVTypeEnum.MikeScenario,
TVTypeEnum.MikeSource,
TVTypeEnum.Municipality,
TVTypeEnum.MWQMSite,
TVTypeEnum.PolSourceSite,
TVTypeEnum.Province,
TVTypeEnum.Sector,
TVTypeEnum.Subsector,
TVTypeEnum.Tel,
TVTypeEnum.TideSite,
TVTypeEnum.WasteWaterTreatmentPlant,
TVTypeEnum.LiftStation,
TVTypeEnum.Spill,
TVTypeEnum.BoxModel,
TVTypeEnum.VisualPlumesScenario,
TVTypeEnum.OtherInfrastructure,
TVTypeEnum.MWQMRun,
TVTypeEnum.MeshNode,
TVTypeEnum.WebTideNode,
TVTypeEnum.SamplingPlan,
TVTypeEnum.SeeOtherMunicipality,
TVTypeEnum.LineOverflow,
TVTypeEnum.MapInfo,
TVTypeEnum.MapInfoPoint,
};
if (!AllowableTVTypes.Contains(TVItemTVItemID.TVType))
{
tvItemStat.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "TVItemID", "Root,Address,Area,ClimateSite,Contact,Country,Email,File,HydrometricSite,Infrastructure,MikeScenario,MikeSource,Municipality,MWQMSite,PolSourceSite,Province,Sector,Subsector,Tel,TideSite,WasteWaterTreatmentPlant,LiftStation,Spill,BoxModel,VisualPlumesScenario,OtherInfrastructure,MWQMRun,MeshNode,WebTideNode,SamplingPlan,SeeOtherMunicipality,LineOverflow,MapInfo,MapInfoPoint"), new[] { "TVItemID" }));
}
}
retStr = enums.EnumTypeOK(typeof(TVTypeEnum), (int?)tvItemStat.TVType);
if (!string.IsNullOrWhiteSpace(retStr))
{
tvItemStat.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "TVType"), new[] { "TVType" }));
}
if (tvItemStat.ChildCount < 0 || tvItemStat.ChildCount > 10000000)
{
tvItemStat.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "ChildCount", "0", "10000000"), new[] { "ChildCount" }));
}
if (tvItemStat.LastUpdateDate_UTC.Year == 1)
{
tvItemStat.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "LastUpdateDate_UTC"), new[] { "LastUpdateDate_UTC" }));
}
else
{
if (tvItemStat.LastUpdateDate_UTC.Year < 1980)
{
tvItemStat.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "LastUpdateDate_UTC", "1980"), new[] { "LastUpdateDate_UTC" }));
}
}
TVItem TVItemLastUpdateContactTVItemID = (from c in db.TVItems where c.TVItemID == tvItemStat.LastUpdateContactTVItemID select c).FirstOrDefault();
if (TVItemLastUpdateContactTVItemID == null)
{
tvItemStat.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "LastUpdateContactTVItemID", tvItemStat.LastUpdateContactTVItemID.ToString()), new[] { "LastUpdateContactTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.Contact,
};
if (!AllowableTVTypes.Contains(TVItemLastUpdateContactTVItemID.TVType))
{
tvItemStat.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "LastUpdateContactTVItemID", "Contact"), new[] { "LastUpdateContactTVItemID" }));
}
}
retStr = ""; // added to stop compiling CSSPError
if (retStr != "") // will never be true
{
tvItemStat.HasErrors = true;
yield return(new ValidationResult("AAA", new[] { "AAA" }));
}
}
/// <summary>
/// Validate function for all EmailDistributionListContactLanguageService commands
/// </summary>
/// <param name="validationContext">System.ComponentModel.DataAnnotations.ValidationContext (Describes the context in which a validation check is performed.)</param>
/// <param name="actionDBType">[ActionDBTypeEnum] (CSSPEnums.ActionDBTypeEnum.html) action type to validate</param>
/// <returns>IEnumerable of ValidationResult (Where ValidationResult is a container for the results of a validation request.)</returns>
private IEnumerable <ValidationResult> Validate(ValidationContext validationContext, ActionDBTypeEnum actionDBType)
{
string retStr = "";
Enums enums = new Enums(LanguageRequest);
EmailDistributionListContactLanguage emailDistributionListContactLanguage = validationContext.ObjectInstance as EmailDistributionListContactLanguage;
emailDistributionListContactLanguage.HasErrors = false;
if (actionDBType == ActionDBTypeEnum.Update || actionDBType == ActionDBTypeEnum.Delete)
{
if (emailDistributionListContactLanguage.EmailDistributionListContactLanguageID == 0)
{
emailDistributionListContactLanguage.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "EmailDistributionListContactLanguageID"), new[] { "EmailDistributionListContactLanguageID" }));
}
if (!(from c in db.EmailDistributionListContactLanguages select c).Where(c => c.EmailDistributionListContactLanguageID == emailDistributionListContactLanguage.EmailDistributionListContactLanguageID).Any())
{
emailDistributionListContactLanguage.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "EmailDistributionListContactLanguage", "EmailDistributionListContactLanguageID", emailDistributionListContactLanguage.EmailDistributionListContactLanguageID.ToString()), new[] { "EmailDistributionListContactLanguageID" }));
}
}
EmailDistributionListContact EmailDistributionListContactEmailDistributionListContactID = (from c in db.EmailDistributionListContacts where c.EmailDistributionListContactID == emailDistributionListContactLanguage.EmailDistributionListContactID select c).FirstOrDefault();
if (EmailDistributionListContactEmailDistributionListContactID == null)
{
emailDistributionListContactLanguage.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "EmailDistributionListContact", "EmailDistributionListContactID", emailDistributionListContactLanguage.EmailDistributionListContactID.ToString()), new[] { "EmailDistributionListContactID" }));
}
retStr = enums.EnumTypeOK(typeof(LanguageEnum), (int?)emailDistributionListContactLanguage.Language);
if (!string.IsNullOrWhiteSpace(retStr))
{
emailDistributionListContactLanguage.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "Language"), new[] { "Language" }));
}
if (string.IsNullOrWhiteSpace(emailDistributionListContactLanguage.Agency))
{
emailDistributionListContactLanguage.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "Agency"), new[] { "Agency" }));
}
if (!string.IsNullOrWhiteSpace(emailDistributionListContactLanguage.Agency) && (emailDistributionListContactLanguage.Agency.Length < 1 || emailDistributionListContactLanguage.Agency.Length > 100))
{
emailDistributionListContactLanguage.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._LengthShouldBeBetween_And_, "Agency", "1", "100"), new[] { "Agency" }));
}
retStr = enums.EnumTypeOK(typeof(TranslationStatusEnum), (int?)emailDistributionListContactLanguage.TranslationStatus);
if (!string.IsNullOrWhiteSpace(retStr))
{
emailDistributionListContactLanguage.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "TranslationStatus"), new[] { "TranslationStatus" }));
}
if (emailDistributionListContactLanguage.LastUpdateDate_UTC.Year == 1)
{
emailDistributionListContactLanguage.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "LastUpdateDate_UTC"), new[] { "LastUpdateDate_UTC" }));
}
else
{
if (emailDistributionListContactLanguage.LastUpdateDate_UTC.Year < 1980)
{
emailDistributionListContactLanguage.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "LastUpdateDate_UTC", "1980"), new[] { "LastUpdateDate_UTC" }));
}
}
TVItem TVItemLastUpdateContactTVItemID = (from c in db.TVItems where c.TVItemID == emailDistributionListContactLanguage.LastUpdateContactTVItemID select c).FirstOrDefault();
if (TVItemLastUpdateContactTVItemID == null)
{
emailDistributionListContactLanguage.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "LastUpdateContactTVItemID", emailDistributionListContactLanguage.LastUpdateContactTVItemID.ToString()), new[] { "LastUpdateContactTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.Contact,
};
if (!AllowableTVTypes.Contains(TVItemLastUpdateContactTVItemID.TVType))
{
emailDistributionListContactLanguage.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "LastUpdateContactTVItemID", "Contact"), new[] { "LastUpdateContactTVItemID" }));
}
}
retStr = ""; // added to stop compiling CSSPError
if (retStr != "") // will never be true
{
emailDistributionListContactLanguage.HasErrors = true;
yield return(new ValidationResult("AAA", new[] { "AAA" }));
}
}
private IEnumerable <ValidationResult> Validate(ValidationContext validationContext, ActionDBTypeEnum actionDBType)
{
string retStr = "";
Enums enums = new Enums(LanguageRequest);
MWQMSitePolSourceSite mwqmSitePolSourceSite = validationContext.ObjectInstance as MWQMSitePolSourceSite;
mwqmSitePolSourceSite.HasErrors = false;
if (actionDBType == ActionDBTypeEnum.Update || actionDBType == ActionDBTypeEnum.Delete)
{
if (mwqmSitePolSourceSite.MWQMSitePolSourceSiteID == 0)
{
mwqmSitePolSourceSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "MWQMSitePolSourceSiteID"), new[] { "MWQMSitePolSourceSiteID" }));
}
if (!(from c in db.MWQMSitePolSourceSites select c).Where(c => c.MWQMSitePolSourceSiteID == mwqmSitePolSourceSite.MWQMSitePolSourceSiteID).Any())
{
mwqmSitePolSourceSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "MWQMSitePolSourceSite", "MWQMSitePolSourceSiteID", mwqmSitePolSourceSite.MWQMSitePolSourceSiteID.ToString()), new[] { "MWQMSitePolSourceSiteID" }));
}
}
TVItem TVItemMWQMSiteTVItemID = (from c in db.TVItems where c.TVItemID == mwqmSitePolSourceSite.MWQMSiteTVItemID select c).FirstOrDefault();
if (TVItemMWQMSiteTVItemID == null)
{
mwqmSitePolSourceSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "MWQMSiteTVItemID", mwqmSitePolSourceSite.MWQMSiteTVItemID.ToString()), new[] { "MWQMSiteTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.MWQMSite,
};
if (!AllowableTVTypes.Contains(TVItemMWQMSiteTVItemID.TVType))
{
mwqmSitePolSourceSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "MWQMSiteTVItemID", "MWQMSite"), new[] { "MWQMSiteTVItemID" }));
}
}
TVItem TVItemPolSourceSiteTVItemID = (from c in db.TVItems where c.TVItemID == mwqmSitePolSourceSite.PolSourceSiteTVItemID select c).FirstOrDefault();
if (TVItemPolSourceSiteTVItemID == null)
{
mwqmSitePolSourceSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "PolSourceSiteTVItemID", mwqmSitePolSourceSite.PolSourceSiteTVItemID.ToString()), new[] { "PolSourceSiteTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.PolSourceSite,
};
if (!AllowableTVTypes.Contains(TVItemPolSourceSiteTVItemID.TVType))
{
mwqmSitePolSourceSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "PolSourceSiteTVItemID", "PolSourceSite"), new[] { "PolSourceSiteTVItemID" }));
}
}
retStr = enums.EnumTypeOK(typeof(TVTypeEnum), (int?)mwqmSitePolSourceSite.TVType);
if (!string.IsNullOrWhiteSpace(retStr))
{
mwqmSitePolSourceSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "TVType"), new[] { "TVType" }));
}
if (string.IsNullOrWhiteSpace(mwqmSitePolSourceSite.LinkReasons))
{
mwqmSitePolSourceSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "LinkReasons"), new[] { "LinkReasons" }));
}
if (!string.IsNullOrWhiteSpace(mwqmSitePolSourceSite.LinkReasons) && mwqmSitePolSourceSite.LinkReasons.Length > 4000)
{
mwqmSitePolSourceSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "LinkReasons", "4000"), new[] { "LinkReasons" }));
}
if (mwqmSitePolSourceSite.LastUpdateDate_UTC.Year == 1)
{
mwqmSitePolSourceSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "LastUpdateDate_UTC"), new[] { "LastUpdateDate_UTC" }));
}
else
{
if (mwqmSitePolSourceSite.LastUpdateDate_UTC.Year < 1980)
{
mwqmSitePolSourceSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "LastUpdateDate_UTC", "1980"), new[] { "LastUpdateDate_UTC" }));
}
}
TVItem TVItemLastUpdateContactTVItemID = (from c in db.TVItems where c.TVItemID == mwqmSitePolSourceSite.LastUpdateContactTVItemID select c).FirstOrDefault();
if (TVItemLastUpdateContactTVItemID == null)
{
mwqmSitePolSourceSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "LastUpdateContactTVItemID", mwqmSitePolSourceSite.LastUpdateContactTVItemID.ToString()), new[] { "LastUpdateContactTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.Contact,
};
if (!AllowableTVTypes.Contains(TVItemLastUpdateContactTVItemID.TVType))
{
mwqmSitePolSourceSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "LastUpdateContactTVItemID", "Contact"), new[] { "LastUpdateContactTVItemID" }));
}
}
retStr = ""; // added to stop compiling CSSPError
if (retStr != "") // will never be true
{
mwqmSitePolSourceSite.HasErrors = true;
yield return(new ValidationResult("AAA", new[] { "AAA" }));
}
}
private IEnumerable <ValidationResult> Validate(ValidationContext validationContext, ActionDBTypeEnum actionDBType)
{
string retStr = "";
Enums enums = new Enums(LanguageRequest);
HydrometricDataValue hydrometricDataValue = validationContext.ObjectInstance as HydrometricDataValue;
hydrometricDataValue.HasErrors = false;
if (actionDBType == ActionDBTypeEnum.Update || actionDBType == ActionDBTypeEnum.Delete)
{
if (hydrometricDataValue.HydrometricDataValueID == 0)
{
hydrometricDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "HydrometricDataValueID"), new[] { "HydrometricDataValueID" }));
}
if (!(from c in db.HydrometricDataValues select c).Where(c => c.HydrometricDataValueID == hydrometricDataValue.HydrometricDataValueID).Any())
{
hydrometricDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "HydrometricDataValue", "HydrometricDataValueID", hydrometricDataValue.HydrometricDataValueID.ToString()), new[] { "HydrometricDataValueID" }));
}
}
HydrometricSite HydrometricSiteHydrometricSiteID = (from c in db.HydrometricSites where c.HydrometricSiteID == hydrometricDataValue.HydrometricSiteID select c).FirstOrDefault();
if (HydrometricSiteHydrometricSiteID == null)
{
hydrometricDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "HydrometricSite", "HydrometricSiteID", hydrometricDataValue.HydrometricSiteID.ToString()), new[] { "HydrometricSiteID" }));
}
if (hydrometricDataValue.DateTime_Local.Year == 1)
{
hydrometricDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "DateTime_Local"), new[] { "DateTime_Local" }));
}
else
{
if (hydrometricDataValue.DateTime_Local.Year < 1980)
{
hydrometricDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "DateTime_Local", "1980"), new[] { "DateTime_Local" }));
}
}
retStr = enums.EnumTypeOK(typeof(StorageDataTypeEnum), (int?)hydrometricDataValue.StorageDataType);
if (!string.IsNullOrWhiteSpace(retStr))
{
hydrometricDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "StorageDataType"), new[] { "StorageDataType" }));
}
if (hydrometricDataValue.Discharge_m3_s != null)
{
if (hydrometricDataValue.Discharge_m3_s < 0 || hydrometricDataValue.Discharge_m3_s > 100000)
{
hydrometricDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Discharge_m3_s", "0", "100000"), new[] { "Discharge_m3_s" }));
}
}
if (hydrometricDataValue.DischargeEntered_m3_s != null)
{
if (hydrometricDataValue.DischargeEntered_m3_s < 0 || hydrometricDataValue.DischargeEntered_m3_s > 100000)
{
hydrometricDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "DischargeEntered_m3_s", "0", "100000"), new[] { "DischargeEntered_m3_s" }));
}
}
if (hydrometricDataValue.Level_m != null)
{
if (hydrometricDataValue.Level_m < 0 || hydrometricDataValue.Level_m > 10000)
{
hydrometricDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Level_m", "0", "10000"), new[] { "Level_m" }));
}
}
//HourlyValues has no StringLength Attribute
if (hydrometricDataValue.LastUpdateDate_UTC.Year == 1)
{
hydrometricDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "LastUpdateDate_UTC"), new[] { "LastUpdateDate_UTC" }));
}
else
{
if (hydrometricDataValue.LastUpdateDate_UTC.Year < 1980)
{
hydrometricDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "LastUpdateDate_UTC", "1980"), new[] { "LastUpdateDate_UTC" }));
}
}
TVItem TVItemLastUpdateContactTVItemID = (from c in db.TVItems where c.TVItemID == hydrometricDataValue.LastUpdateContactTVItemID select c).FirstOrDefault();
if (TVItemLastUpdateContactTVItemID == null)
{
hydrometricDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "LastUpdateContactTVItemID", hydrometricDataValue.LastUpdateContactTVItemID.ToString()), new[] { "LastUpdateContactTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.Contact,
};
if (!AllowableTVTypes.Contains(TVItemLastUpdateContactTVItemID.TVType))
{
hydrometricDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "LastUpdateContactTVItemID", "Contact"), new[] { "LastUpdateContactTVItemID" }));
}
}
retStr = ""; // added to stop compiling CSSPError
if (retStr != "") // will never be true
{
hydrometricDataValue.HasErrors = true;
yield return(new ValidationResult("AAA", new[] { "AAA" }));
}
}
/// <summary>
/// Validate function for all TVItemService commands
/// </summary>
/// <param name="validationContext">System.ComponentModel.DataAnnotations.ValidationContext (Describes the context in which a validation check is performed.)</param>
/// <param name="actionDBType">[ActionDBTypeEnum] (CSSPEnums.ActionDBTypeEnum.html) action type to validate</param>
/// <returns>IEnumerable of ValidationResult (Where ValidationResult is a container for the results of a validation request.)</returns>
private IEnumerable <ValidationResult> Validate(ValidationContext validationContext, ActionDBTypeEnum actionDBType)
{
string retStr = "";
Enums enums = new Enums(LanguageRequest);
TVItem tvItem = validationContext.ObjectInstance as TVItem;
tvItem.HasErrors = false;
if (actionDBType == ActionDBTypeEnum.Update || actionDBType == ActionDBTypeEnum.Delete)
{
if (tvItem.TVItemID == 0)
{
tvItem.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "TVItemID"), new[] { "TVItemID" }));
}
if (!(from c in db.TVItems select c).Where(c => c.TVItemID == tvItem.TVItemID).Any())
{
tvItem.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "TVItemID", tvItem.TVItemID.ToString()), new[] { "TVItemID" }));
}
}
if (tvItem.TVType == TVTypeEnum.Root)
{
if ((from c in db.TVItems select c).Count() > 0)
{
tvItem.HasErrors = true;
yield return(new ValidationResult(CSSPServicesRes.TVItemRootShouldBeTheFirstOneAdded, new[] { "TVItemTVItemID" }));
}
}
if (tvItem.TVLevel < 0 || tvItem.TVLevel > 100)
{
tvItem.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "TVLevel", "0", "100"), new[] { "TVLevel" }));
}
if (string.IsNullOrWhiteSpace(tvItem.TVPath))
{
tvItem.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "TVPath"), new[] { "TVPath" }));
}
if (!string.IsNullOrWhiteSpace(tvItem.TVPath) && tvItem.TVPath.Length > 250)
{
tvItem.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "TVPath", "250"), new[] { "TVPath" }));
}
retStr = enums.EnumTypeOK(typeof(TVTypeEnum), (int?)tvItem.TVType);
if (!string.IsNullOrWhiteSpace(retStr))
{
tvItem.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "TVType"), new[] { "TVType" }));
}
if (tvItem.TVType != TVTypeEnum.Root)
{
TVItem TVItemParentID = (from c in db.TVItems where c.TVItemID == tvItem.ParentID select c).FirstOrDefault();
if (TVItemParentID == null)
{
tvItem.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "ParentID", tvItem.ParentID.ToString()), new[] { "ParentID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.Root,
TVTypeEnum.Address,
TVTypeEnum.Area,
TVTypeEnum.ClimateSite,
TVTypeEnum.Contact,
TVTypeEnum.Country,
TVTypeEnum.Email,
TVTypeEnum.HydrometricSite,
TVTypeEnum.Infrastructure,
TVTypeEnum.MikeBoundaryConditionWebTide,
TVTypeEnum.MikeBoundaryConditionMesh,
TVTypeEnum.MikeScenario,
TVTypeEnum.MikeSource,
TVTypeEnum.Municipality,
TVTypeEnum.MWQMSite,
TVTypeEnum.PolSourceSite,
TVTypeEnum.Province,
TVTypeEnum.Sector,
TVTypeEnum.Subsector,
TVTypeEnum.Tel,
TVTypeEnum.MWQMRun,
TVTypeEnum.Classification,
};
if (!AllowableTVTypes.Contains(TVItemParentID.TVType))
{
tvItem.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "ParentID", "Root,Address,Area,ClimateSite,Contact,Country,Email,HydrometricSite,Infrastructure,MikeBoundaryConditionWebTide,MikeBoundaryConditionMesh,MikeScenario,MikeSource,Municipality,MWQMSite,PolSourceSite,Province,Sector,Subsector,Tel,MWQMRun,Classification"), new[] { "ParentID" }));
}
}
}
if (tvItem.LastUpdateDate_UTC.Year == 1)
{
tvItem.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "LastUpdateDate_UTC"), new[] { "LastUpdateDate_UTC" }));
}
else
{
if (tvItem.LastUpdateDate_UTC.Year < 1980)
{
tvItem.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "LastUpdateDate_UTC", "1980"), new[] { "LastUpdateDate_UTC" }));
}
}
if (tvItem.TVType != TVTypeEnum.Root)
{
TVItem TVItemLastUpdateContactTVItemID = (from c in db.TVItems where c.TVItemID == tvItem.LastUpdateContactTVItemID select c).FirstOrDefault();
if (TVItemLastUpdateContactTVItemID == null)
{
tvItem.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "LastUpdateContactTVItemID", tvItem.LastUpdateContactTVItemID.ToString()), new[] { "LastUpdateContactTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.Contact,
};
if (!AllowableTVTypes.Contains(TVItemLastUpdateContactTVItemID.TVType))
{
tvItem.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "LastUpdateContactTVItemID", "Contact"), new[] { "LastUpdateContactTVItemID" }));
}
}
}
retStr = ""; // added to stop compiling CSSPError
if (retStr != "") // will never be true
{
tvItem.HasErrors = true;
yield return(new ValidationResult("AAA", new[] { "AAA" }));
}
}
private IEnumerable <ValidationResult> Validate(ValidationContext validationContext, ActionDBTypeEnum actionDBType)
{
string retStr = "";
Enums enums = new Enums(LanguageRequest);
TideDataValue tideDataValue = validationContext.ObjectInstance as TideDataValue;
tideDataValue.HasErrors = false;
if (actionDBType == ActionDBTypeEnum.Update || actionDBType == ActionDBTypeEnum.Delete)
{
if (tideDataValue.TideDataValueID == 0)
{
tideDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "TideDataValueID"), new[] { "TideDataValueID" }));
}
if (!(from c in db.TideDataValues select c).Where(c => c.TideDataValueID == tideDataValue.TideDataValueID).Any())
{
tideDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TideDataValue", "TideDataValueID", tideDataValue.TideDataValueID.ToString()), new[] { "TideDataValueID" }));
}
}
TVItem TVItemTideSiteTVItemID = (from c in db.TVItems where c.TVItemID == tideDataValue.TideSiteTVItemID select c).FirstOrDefault();
if (TVItemTideSiteTVItemID == null)
{
tideDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "TideSiteTVItemID", tideDataValue.TideSiteTVItemID.ToString()), new[] { "TideSiteTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.TideSite,
};
if (!AllowableTVTypes.Contains(TVItemTideSiteTVItemID.TVType))
{
tideDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "TideSiteTVItemID", "TideSite"), new[] { "TideSiteTVItemID" }));
}
}
if (tideDataValue.DateTime_Local.Year == 1)
{
tideDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "DateTime_Local"), new[] { "DateTime_Local" }));
}
else
{
if (tideDataValue.DateTime_Local.Year < 1980)
{
tideDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "DateTime_Local", "1980"), new[] { "DateTime_Local" }));
}
}
retStr = enums.EnumTypeOK(typeof(TideDataTypeEnum), (int?)tideDataValue.TideDataType);
if (!string.IsNullOrWhiteSpace(retStr))
{
tideDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "TideDataType"), new[] { "TideDataType" }));
}
retStr = enums.EnumTypeOK(typeof(StorageDataTypeEnum), (int?)tideDataValue.StorageDataType);
if (!string.IsNullOrWhiteSpace(retStr))
{
tideDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "StorageDataType"), new[] { "StorageDataType" }));
}
if (tideDataValue.Depth_m < 0 || tideDataValue.Depth_m > 10000)
{
tideDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Depth_m", "0", "10000"), new[] { "Depth_m" }));
}
if (tideDataValue.UVelocity_m_s < 0 || tideDataValue.UVelocity_m_s > 10)
{
tideDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "UVelocity_m_s", "0", "10"), new[] { "UVelocity_m_s" }));
}
if (tideDataValue.VVelocity_m_s < 0 || tideDataValue.VVelocity_m_s > 10)
{
tideDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "VVelocity_m_s", "0", "10"), new[] { "VVelocity_m_s" }));
}
if (tideDataValue.TideStart != null)
{
retStr = enums.EnumTypeOK(typeof(TideTextEnum), (int?)tideDataValue.TideStart);
if (tideDataValue.TideStart == null || !string.IsNullOrWhiteSpace(retStr))
{
tideDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "TideStart"), new[] { "TideStart" }));
}
}
if (tideDataValue.TideEnd != null)
{
retStr = enums.EnumTypeOK(typeof(TideTextEnum), (int?)tideDataValue.TideEnd);
if (tideDataValue.TideEnd == null || !string.IsNullOrWhiteSpace(retStr))
{
tideDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "TideEnd"), new[] { "TideEnd" }));
}
}
if (tideDataValue.LastUpdateDate_UTC.Year == 1)
{
tideDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "LastUpdateDate_UTC"), new[] { "LastUpdateDate_UTC" }));
}
else
{
if (tideDataValue.LastUpdateDate_UTC.Year < 1980)
{
tideDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "LastUpdateDate_UTC", "1980"), new[] { "LastUpdateDate_UTC" }));
}
}
TVItem TVItemLastUpdateContactTVItemID = (from c in db.TVItems where c.TVItemID == tideDataValue.LastUpdateContactTVItemID select c).FirstOrDefault();
if (TVItemLastUpdateContactTVItemID == null)
{
tideDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "LastUpdateContactTVItemID", tideDataValue.LastUpdateContactTVItemID.ToString()), new[] { "LastUpdateContactTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.Contact,
};
if (!AllowableTVTypes.Contains(TVItemLastUpdateContactTVItemID.TVType))
{
tideDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "LastUpdateContactTVItemID", "Contact"), new[] { "LastUpdateContactTVItemID" }));
}
}
retStr = ""; // added to stop compiling CSSPError
if (retStr != "") // will never be true
{
tideDataValue.HasErrors = true;
yield return(new ValidationResult("AAA", new[] { "AAA" }));
}
}
private IEnumerable <ValidationResult> Validate(ValidationContext validationContext, ActionDBTypeEnum actionDBType)
{
string retStr = "";
Enums enums = new Enums(LanguageRequest);
ClimateDataValue climateDataValue = validationContext.ObjectInstance as ClimateDataValue;
climateDataValue.HasErrors = false;
if (actionDBType == ActionDBTypeEnum.Update || actionDBType == ActionDBTypeEnum.Delete)
{
if (climateDataValue.ClimateDataValueID == 0)
{
climateDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "ClimateDataValueID"), new[] { "ClimateDataValueID" }));
}
if (!(from c in db.ClimateDataValues select c).Where(c => c.ClimateDataValueID == climateDataValue.ClimateDataValueID).Any())
{
climateDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "ClimateDataValue", "ClimateDataValueID", climateDataValue.ClimateDataValueID.ToString()), new[] { "ClimateDataValueID" }));
}
}
ClimateSite ClimateSiteClimateSiteID = (from c in db.ClimateSites where c.ClimateSiteID == climateDataValue.ClimateSiteID select c).FirstOrDefault();
if (ClimateSiteClimateSiteID == null)
{
climateDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "ClimateSite", "ClimateSiteID", climateDataValue.ClimateSiteID.ToString()), new[] { "ClimateSiteID" }));
}
if (climateDataValue.DateTime_Local.Year == 1)
{
climateDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "DateTime_Local"), new[] { "DateTime_Local" }));
}
else
{
if (climateDataValue.DateTime_Local.Year < 1980)
{
climateDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "DateTime_Local", "1980"), new[] { "DateTime_Local" }));
}
}
retStr = enums.EnumTypeOK(typeof(StorageDataTypeEnum), (int?)climateDataValue.StorageDataType);
if (!string.IsNullOrWhiteSpace(retStr))
{
climateDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "StorageDataType"), new[] { "StorageDataType" }));
}
if (climateDataValue.Snow_cm != null)
{
if (climateDataValue.Snow_cm < 0 || climateDataValue.Snow_cm > 10000)
{
climateDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Snow_cm", "0", "10000"), new[] { "Snow_cm" }));
}
}
if (climateDataValue.Rainfall_mm != null)
{
if (climateDataValue.Rainfall_mm < 0 || climateDataValue.Rainfall_mm > 10000)
{
climateDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Rainfall_mm", "0", "10000"), new[] { "Rainfall_mm" }));
}
}
if (climateDataValue.RainfallEntered_mm != null)
{
if (climateDataValue.RainfallEntered_mm < 0 || climateDataValue.RainfallEntered_mm > 10000)
{
climateDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "RainfallEntered_mm", "0", "10000"), new[] { "RainfallEntered_mm" }));
}
}
if (climateDataValue.TotalPrecip_mm_cm != null)
{
if (climateDataValue.TotalPrecip_mm_cm < 0 || climateDataValue.TotalPrecip_mm_cm > 10000)
{
climateDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "TotalPrecip_mm_cm", "0", "10000"), new[] { "TotalPrecip_mm_cm" }));
}
}
if (climateDataValue.MaxTemp_C != null)
{
if (climateDataValue.MaxTemp_C < -50 || climateDataValue.MaxTemp_C > 50)
{
climateDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "MaxTemp_C", "-50", "50"), new[] { "MaxTemp_C" }));
}
}
if (climateDataValue.MinTemp_C != null)
{
if (climateDataValue.MinTemp_C < -50 || climateDataValue.MinTemp_C > 50)
{
climateDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "MinTemp_C", "-50", "50"), new[] { "MinTemp_C" }));
}
}
if (climateDataValue.HeatDegDays_C != null)
{
if (climateDataValue.HeatDegDays_C < -1000 || climateDataValue.HeatDegDays_C > 100)
{
climateDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "HeatDegDays_C", "-1000", "100"), new[] { "HeatDegDays_C" }));
}
}
if (climateDataValue.CoolDegDays_C != null)
{
if (climateDataValue.CoolDegDays_C < -1000 || climateDataValue.CoolDegDays_C > 100)
{
climateDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "CoolDegDays_C", "-1000", "100"), new[] { "CoolDegDays_C" }));
}
}
if (climateDataValue.SnowOnGround_cm != null)
{
if (climateDataValue.SnowOnGround_cm < 0 || climateDataValue.SnowOnGround_cm > 10000)
{
climateDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "SnowOnGround_cm", "0", "10000"), new[] { "SnowOnGround_cm" }));
}
}
if (climateDataValue.DirMaxGust_0North != null)
{
if (climateDataValue.DirMaxGust_0North < 0 || climateDataValue.DirMaxGust_0North > 360)
{
climateDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "DirMaxGust_0North", "0", "360"), new[] { "DirMaxGust_0North" }));
}
}
if (climateDataValue.SpdMaxGust_kmh != null)
{
if (climateDataValue.SpdMaxGust_kmh < 0 || climateDataValue.SpdMaxGust_kmh > 300)
{
climateDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "SpdMaxGust_kmh", "0", "300"), new[] { "SpdMaxGust_kmh" }));
}
}
//HourlyValues has no StringLength Attribute
if (climateDataValue.LastUpdateDate_UTC.Year == 1)
{
climateDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "LastUpdateDate_UTC"), new[] { "LastUpdateDate_UTC" }));
}
else
{
if (climateDataValue.LastUpdateDate_UTC.Year < 1980)
{
climateDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "LastUpdateDate_UTC", "1980"), new[] { "LastUpdateDate_UTC" }));
}
}
TVItem TVItemLastUpdateContactTVItemID = (from c in db.TVItems where c.TVItemID == climateDataValue.LastUpdateContactTVItemID select c).FirstOrDefault();
if (TVItemLastUpdateContactTVItemID == null)
{
climateDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "LastUpdateContactTVItemID", climateDataValue.LastUpdateContactTVItemID.ToString()), new[] { "LastUpdateContactTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.Contact,
};
if (!AllowableTVTypes.Contains(TVItemLastUpdateContactTVItemID.TVType))
{
climateDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "LastUpdateContactTVItemID", "Contact"), new[] { "LastUpdateContactTVItemID" }));
}
}
retStr = ""; // added to stop compiling CSSPError
if (retStr != "") // will never be true
{
climateDataValue.HasErrors = true;
yield return(new ValidationResult("AAA", new[] { "AAA" }));
}
}
private IEnumerable <ValidationResult> Validate(ValidationContext validationContext, ActionDBTypeEnum actionDBType)
{
string retStr = "";
Enums enums = new Enums(LanguageRequest);
MWQMSample mwqmSample = validationContext.ObjectInstance as MWQMSample;
mwqmSample.HasErrors = false;
if (actionDBType == ActionDBTypeEnum.Update || actionDBType == ActionDBTypeEnum.Delete)
{
if (mwqmSample.MWQMSampleID == 0)
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "MWQMSampleID"), new[] { "MWQMSampleID" }));
}
if (!(from c in db.MWQMSamples select c).Where(c => c.MWQMSampleID == mwqmSample.MWQMSampleID).Any())
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "MWQMSample", "MWQMSampleID", mwqmSample.MWQMSampleID.ToString()), new[] { "MWQMSampleID" }));
}
}
TVItem TVItemMWQMSiteTVItemID = (from c in db.TVItems where c.TVItemID == mwqmSample.MWQMSiteTVItemID select c).FirstOrDefault();
if (TVItemMWQMSiteTVItemID == null)
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "MWQMSiteTVItemID", mwqmSample.MWQMSiteTVItemID.ToString()), new[] { "MWQMSiteTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.MWQMSite,
};
if (!AllowableTVTypes.Contains(TVItemMWQMSiteTVItemID.TVType))
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "MWQMSiteTVItemID", "MWQMSite"), new[] { "MWQMSiteTVItemID" }));
}
}
TVItem TVItemMWQMRunTVItemID = (from c in db.TVItems where c.TVItemID == mwqmSample.MWQMRunTVItemID select c).FirstOrDefault();
if (TVItemMWQMRunTVItemID == null)
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "MWQMRunTVItemID", mwqmSample.MWQMRunTVItemID.ToString()), new[] { "MWQMRunTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.MWQMRun,
};
if (!AllowableTVTypes.Contains(TVItemMWQMRunTVItemID.TVType))
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "MWQMRunTVItemID", "MWQMRun"), new[] { "MWQMRunTVItemID" }));
}
}
if (mwqmSample.SampleDateTime_Local.Year == 1)
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "SampleDateTime_Local"), new[] { "SampleDateTime_Local" }));
}
else
{
if (mwqmSample.SampleDateTime_Local.Year < 1980)
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "SampleDateTime_Local", "1980"), new[] { "SampleDateTime_Local" }));
}
}
if (!string.IsNullOrWhiteSpace(mwqmSample.TimeText) && mwqmSample.TimeText.Length > 6)
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "TimeText", "6"), new[] { "TimeText" }));
}
if (mwqmSample.Depth_m != null)
{
if (mwqmSample.Depth_m < 0 || mwqmSample.Depth_m > 1000)
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Depth_m", "0", "1000"), new[] { "Depth_m" }));
}
}
if (mwqmSample.FecCol_MPN_100ml < 0 || mwqmSample.FecCol_MPN_100ml > 10000000)
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "FecCol_MPN_100ml", "0", "10000000"), new[] { "FecCol_MPN_100ml" }));
}
if (mwqmSample.Salinity_PPT != null)
{
if (mwqmSample.Salinity_PPT < 0 || mwqmSample.Salinity_PPT > 40)
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Salinity_PPT", "0", "40"), new[] { "Salinity_PPT" }));
}
}
if (mwqmSample.WaterTemp_C != null)
{
if (mwqmSample.WaterTemp_C < -10 || mwqmSample.WaterTemp_C > 40)
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "WaterTemp_C", "-10", "40"), new[] { "WaterTemp_C" }));
}
}
if (mwqmSample.PH != null)
{
if (mwqmSample.PH < 0 || mwqmSample.PH > 14)
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "PH", "0", "14"), new[] { "PH" }));
}
}
if (string.IsNullOrWhiteSpace(mwqmSample.SampleTypesText))
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "SampleTypesText"), new[] { "SampleTypesText" }));
}
if (!string.IsNullOrWhiteSpace(mwqmSample.SampleTypesText) && mwqmSample.SampleTypesText.Length > 50)
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "SampleTypesText", "50"), new[] { "SampleTypesText" }));
}
if (mwqmSample.SampleType_old != null)
{
retStr = enums.EnumTypeOK(typeof(SampleTypeEnum), (int?)mwqmSample.SampleType_old);
if (mwqmSample.SampleType_old == null || !string.IsNullOrWhiteSpace(retStr))
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "SampleType_old"), new[] { "SampleType_old" }));
}
}
if (mwqmSample.Tube_10 != null)
{
if (mwqmSample.Tube_10 < 0 || mwqmSample.Tube_10 > 5)
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Tube_10", "0", "5"), new[] { "Tube_10" }));
}
}
if (mwqmSample.Tube_1_0 != null)
{
if (mwqmSample.Tube_1_0 < 0 || mwqmSample.Tube_1_0 > 5)
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Tube_1_0", "0", "5"), new[] { "Tube_1_0" }));
}
}
if (mwqmSample.Tube_0_1 != null)
{
if (mwqmSample.Tube_0_1 < 0 || mwqmSample.Tube_0_1 > 5)
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Tube_0_1", "0", "5"), new[] { "Tube_0_1" }));
}
}
if (!string.IsNullOrWhiteSpace(mwqmSample.ProcessedBy) && mwqmSample.ProcessedBy.Length > 10)
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "ProcessedBy", "10"), new[] { "ProcessedBy" }));
}
if (mwqmSample.LastUpdateDate_UTC.Year == 1)
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "LastUpdateDate_UTC"), new[] { "LastUpdateDate_UTC" }));
}
else
{
if (mwqmSample.LastUpdateDate_UTC.Year < 1980)
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "LastUpdateDate_UTC", "1980"), new[] { "LastUpdateDate_UTC" }));
}
}
TVItem TVItemLastUpdateContactTVItemID = (from c in db.TVItems where c.TVItemID == mwqmSample.LastUpdateContactTVItemID select c).FirstOrDefault();
if (TVItemLastUpdateContactTVItemID == null)
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "LastUpdateContactTVItemID", mwqmSample.LastUpdateContactTVItemID.ToString()), new[] { "LastUpdateContactTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.Contact,
};
if (!AllowableTVTypes.Contains(TVItemLastUpdateContactTVItemID.TVType))
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "LastUpdateContactTVItemID", "Contact"), new[] { "LastUpdateContactTVItemID" }));
}
}
retStr = ""; // added to stop compiling CSSPError
if (retStr != "") // will never be true
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult("AAA", new[] { "AAA" }));
}
}
/// <summary>
/// Validate function for all MWQMSubsectorLanguageService commands
/// </summary>
/// <param name="validationContext">System.ComponentModel.DataAnnotations.ValidationContext (Describes the context in which a validation check is performed.)</param>
/// <param name="actionDBType">[ActionDBTypeEnum] (CSSPEnums.ActionDBTypeEnum.html) action type to validate</param>
/// <returns>IEnumerable of ValidationResult (Where ValidationResult is a container for the results of a validation request.)</returns>
private IEnumerable <ValidationResult> Validate(ValidationContext validationContext, ActionDBTypeEnum actionDBType)
{
string retStr = "";
Enums enums = new Enums(LanguageRequest);
MWQMSubsectorLanguage mwqmSubsectorLanguage = validationContext.ObjectInstance as MWQMSubsectorLanguage;
mwqmSubsectorLanguage.HasErrors = false;
if (actionDBType == ActionDBTypeEnum.Update || actionDBType == ActionDBTypeEnum.Delete)
{
if (mwqmSubsectorLanguage.MWQMSubsectorLanguageID == 0)
{
mwqmSubsectorLanguage.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "MWQMSubsectorLanguageID"), new[] { "MWQMSubsectorLanguageID" }));
}
if (!(from c in db.MWQMSubsectorLanguages select c).Where(c => c.MWQMSubsectorLanguageID == mwqmSubsectorLanguage.MWQMSubsectorLanguageID).Any())
{
mwqmSubsectorLanguage.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "MWQMSubsectorLanguage", "MWQMSubsectorLanguageID", mwqmSubsectorLanguage.MWQMSubsectorLanguageID.ToString()), new[] { "MWQMSubsectorLanguageID" }));
}
}
MWQMSubsector MWQMSubsectorMWQMSubsectorID = (from c in db.MWQMSubsectors where c.MWQMSubsectorID == mwqmSubsectorLanguage.MWQMSubsectorID select c).FirstOrDefault();
if (MWQMSubsectorMWQMSubsectorID == null)
{
mwqmSubsectorLanguage.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "MWQMSubsector", "MWQMSubsectorID", mwqmSubsectorLanguage.MWQMSubsectorID.ToString()), new[] { "MWQMSubsectorID" }));
}
retStr = enums.EnumTypeOK(typeof(LanguageEnum), (int?)mwqmSubsectorLanguage.Language);
if (!string.IsNullOrWhiteSpace(retStr))
{
mwqmSubsectorLanguage.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "Language"), new[] { "Language" }));
}
if (string.IsNullOrWhiteSpace(mwqmSubsectorLanguage.SubsectorDesc))
{
mwqmSubsectorLanguage.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "SubsectorDesc"), new[] { "SubsectorDesc" }));
}
if (!string.IsNullOrWhiteSpace(mwqmSubsectorLanguage.SubsectorDesc) && mwqmSubsectorLanguage.SubsectorDesc.Length > 250)
{
mwqmSubsectorLanguage.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "SubsectorDesc", "250"), new[] { "SubsectorDesc" }));
}
retStr = enums.EnumTypeOK(typeof(TranslationStatusEnum), (int?)mwqmSubsectorLanguage.TranslationStatusSubsectorDesc);
if (!string.IsNullOrWhiteSpace(retStr))
{
mwqmSubsectorLanguage.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "TranslationStatusSubsectorDesc"), new[] { "TranslationStatusSubsectorDesc" }));
}
//LogBook has no StringLength Attribute
if (mwqmSubsectorLanguage.TranslationStatusLogBook != null)
{
retStr = enums.EnumTypeOK(typeof(TranslationStatusEnum), (int?)mwqmSubsectorLanguage.TranslationStatusLogBook);
if (mwqmSubsectorLanguage.TranslationStatusLogBook == null || !string.IsNullOrWhiteSpace(retStr))
{
mwqmSubsectorLanguage.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "TranslationStatusLogBook"), new[] { "TranslationStatusLogBook" }));
}
}
if (mwqmSubsectorLanguage.LastUpdateDate_UTC.Year == 1)
{
mwqmSubsectorLanguage.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "LastUpdateDate_UTC"), new[] { "LastUpdateDate_UTC" }));
}
else
{
if (mwqmSubsectorLanguage.LastUpdateDate_UTC.Year < 1980)
{
mwqmSubsectorLanguage.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "LastUpdateDate_UTC", "1980"), new[] { "LastUpdateDate_UTC" }));
}
}
TVItem TVItemLastUpdateContactTVItemID = (from c in db.TVItems where c.TVItemID == mwqmSubsectorLanguage.LastUpdateContactTVItemID select c).FirstOrDefault();
if (TVItemLastUpdateContactTVItemID == null)
{
mwqmSubsectorLanguage.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "LastUpdateContactTVItemID", mwqmSubsectorLanguage.LastUpdateContactTVItemID.ToString()), new[] { "LastUpdateContactTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.Contact,
};
if (!AllowableTVTypes.Contains(TVItemLastUpdateContactTVItemID.TVType))
{
mwqmSubsectorLanguage.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "LastUpdateContactTVItemID", "Contact"), new[] { "LastUpdateContactTVItemID" }));
}
}
retStr = ""; // added to stop compiling CSSPError
if (retStr != "") // will never be true
{
mwqmSubsectorLanguage.HasErrors = true;
yield return(new ValidationResult("AAA", new[] { "AAA" }));
}
}
/// <summary>
/// Validate function for all QueryService commands
/// </summary>
/// <param name="validationContext">System.ComponentModel.DataAnnotations.ValidationContext (Describes the context in which a validation check is performed.)</param>
/// <param name="actionDBType">[ActionDBTypeEnum] (CSSPEnums.ActionDBTypeEnum.html) action type to validate</param>
/// <returns>IEnumerable of ValidationResult (Where ValidationResult is a container for the results of a validation request.)</returns>
private IEnumerable <ValidationResult> Validate(ValidationContext validationContext, ActionDBTypeEnum actionDBType)
{
string retStr = "";
Enums enums = new Enums(LanguageRequest);
Query query = validationContext.ObjectInstance as Query;
query.HasErrors = false;
//CSSPError: Type not implemented [ModelType] of type [Type]
//CSSPError: Type not implemented [ModelType] of type [Type]
if (query.Language != null)
{
retStr = enums.EnumTypeOK(typeof(LanguageEnum), (int?)query.Language);
if (query.Language == null || !string.IsNullOrWhiteSpace(retStr))
{
query.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "Language"), new[] { "Language" }));
}
}
if (string.IsNullOrWhiteSpace(query.Lang))
{
query.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "Lang"), new[] { "Lang" }));
}
if (!string.IsNullOrWhiteSpace(query.Lang) && query.Lang.Length > 2)
{
query.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "Lang", "2"), new[] { "Lang" }));
}
if (query.Skip < 0 || query.Skip > 1000000)
{
query.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Skip", "0", "1000000"), new[] { "Skip" }));
}
if (query.Take < 1 || query.Take > 1000000)
{
query.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Take", "1", "1000000"), new[] { "Take" }));
}
if (string.IsNullOrWhiteSpace(query.Asc))
{
query.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "Asc"), new[] { "Asc" }));
}
if (!string.IsNullOrWhiteSpace(query.Asc) && query.Asc.Length > 200)
{
query.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "Asc", "200"), new[] { "Asc" }));
}
if (string.IsNullOrWhiteSpace(query.Desc))
{
query.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "Desc"), new[] { "Desc" }));
}
if (!string.IsNullOrWhiteSpace(query.Desc) && query.Desc.Length > 200)
{
query.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "Desc", "200"), new[] { "Desc" }));
}
if (string.IsNullOrWhiteSpace(query.Where))
{
query.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "Where"), new[] { "Where" }));
}
if (!string.IsNullOrWhiteSpace(query.Where) && query.Where.Length > 200)
{
query.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "Where", "200"), new[] { "Where" }));
}
if (string.IsNullOrWhiteSpace(query.Extra))
{
query.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "Extra"), new[] { "Extra" }));
}
if (!string.IsNullOrWhiteSpace(query.Extra) && query.Extra.Length > 1)
{
query.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "Extra", "1"), new[] { "Extra" }));
}
//CSSPError: Type not implemented [AscList] of type [List`1]
//AscList has no StringLength Attribute
//CSSPError: Type not implemented [DescList] of type [List`1]
//DescList has no StringLength Attribute
//CSSPError: Type not implemented [WhereInfoList] of type [List`1]
//CSSPError: Type not implemented [WhereInfoList] of type [WhereInfo]
retStr = ""; // added to stop compiling CSSPError
if (retStr != "") // will never be true
{
query.HasErrors = true;
yield return(new ValidationResult("AAA", new[] { "AAA" }));
}
}
private IEnumerable <ValidationResult> Validate(ValidationContext validationContext, ActionDBTypeEnum actionDBType)
{
string retStr = "";
Enums enums = new Enums(LanguageRequest);
Tel tel = validationContext.ObjectInstance as Tel;
tel.HasErrors = false;
if (actionDBType == ActionDBTypeEnum.Update || actionDBType == ActionDBTypeEnum.Delete)
{
if (tel.TelID == 0)
{
tel.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "TelID"), new[] { "TelID" }));
}
if (!(from c in db.Tels select c).Where(c => c.TelID == tel.TelID).Any())
{
tel.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "Tel", "TelID", tel.TelID.ToString()), new[] { "TelID" }));
}
}
TVItem TVItemTelTVItemID = (from c in db.TVItems where c.TVItemID == tel.TelTVItemID select c).FirstOrDefault();
if (TVItemTelTVItemID == null)
{
tel.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "TelTVItemID", tel.TelTVItemID.ToString()), new[] { "TelTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.Tel,
};
if (!AllowableTVTypes.Contains(TVItemTelTVItemID.TVType))
{
tel.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "TelTVItemID", "Tel"), new[] { "TelTVItemID" }));
}
}
if (string.IsNullOrWhiteSpace(tel.TelNumber))
{
tel.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "TelNumber"), new[] { "TelNumber" }));
}
if (!string.IsNullOrWhiteSpace(tel.TelNumber) && tel.TelNumber.Length > 50)
{
tel.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "TelNumber", "50"), new[] { "TelNumber" }));
}
retStr = enums.EnumTypeOK(typeof(TelTypeEnum), (int?)tel.TelType);
if (!string.IsNullOrWhiteSpace(retStr))
{
tel.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "TelType"), new[] { "TelType" }));
}
if (tel.LastUpdateDate_UTC.Year == 1)
{
tel.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "LastUpdateDate_UTC"), new[] { "LastUpdateDate_UTC" }));
}
else
{
if (tel.LastUpdateDate_UTC.Year < 1980)
{
tel.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "LastUpdateDate_UTC", "1980"), new[] { "LastUpdateDate_UTC" }));
}
}
TVItem TVItemLastUpdateContactTVItemID = (from c in db.TVItems where c.TVItemID == tel.LastUpdateContactTVItemID select c).FirstOrDefault();
if (TVItemLastUpdateContactTVItemID == null)
{
tel.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "LastUpdateContactTVItemID", tel.LastUpdateContactTVItemID.ToString()), new[] { "LastUpdateContactTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.Contact,
};
if (!AllowableTVTypes.Contains(TVItemLastUpdateContactTVItemID.TVType))
{
tel.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "LastUpdateContactTVItemID", "Contact"), new[] { "LastUpdateContactTVItemID" }));
}
}
retStr = ""; // added to stop compiling CSSPError
if (retStr != "") // will never be true
{
tel.HasErrors = true;
yield return(new ValidationResult("AAA", new[] { "AAA" }));
}
}
private IEnumerable <ValidationResult> Validate(ValidationContext validationContext, ActionDBTypeEnum actionDBType)
{
string retStr = "";
Enums enums = new Enums(LanguageRequest);
UseOfSite useOfSite = validationContext.ObjectInstance as UseOfSite;
useOfSite.HasErrors = false;
if (actionDBType == ActionDBTypeEnum.Update || actionDBType == ActionDBTypeEnum.Delete)
{
if (useOfSite.UseOfSiteID == 0)
{
useOfSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "UseOfSiteID"), new[] { "UseOfSiteID" }));
}
if (!(from c in db.UseOfSites select c).Where(c => c.UseOfSiteID == useOfSite.UseOfSiteID).Any())
{
useOfSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "UseOfSite", "UseOfSiteID", useOfSite.UseOfSiteID.ToString()), new[] { "UseOfSiteID" }));
}
}
TVItem TVItemSiteTVItemID = (from c in db.TVItems where c.TVItemID == useOfSite.SiteTVItemID select c).FirstOrDefault();
if (TVItemSiteTVItemID == null)
{
useOfSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "SiteTVItemID", useOfSite.SiteTVItemID.ToString()), new[] { "SiteTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.ClimateSite,
TVTypeEnum.HydrometricSite,
TVTypeEnum.TideSite,
};
if (!AllowableTVTypes.Contains(TVItemSiteTVItemID.TVType))
{
useOfSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "SiteTVItemID", "ClimateSite,HydrometricSite,TideSite"), new[] { "SiteTVItemID" }));
}
}
TVItem TVItemSubsectorTVItemID = (from c in db.TVItems where c.TVItemID == useOfSite.SubsectorTVItemID select c).FirstOrDefault();
if (TVItemSubsectorTVItemID == null)
{
useOfSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "SubsectorTVItemID", useOfSite.SubsectorTVItemID.ToString()), new[] { "SubsectorTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.Subsector,
};
if (!AllowableTVTypes.Contains(TVItemSubsectorTVItemID.TVType))
{
useOfSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "SubsectorTVItemID", "Subsector"), new[] { "SubsectorTVItemID" }));
}
}
retStr = enums.EnumTypeOK(typeof(TVTypeEnum), (int?)useOfSite.TVType);
if (!string.IsNullOrWhiteSpace(retStr))
{
useOfSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "TVType"), new[] { "TVType" }));
}
if (useOfSite.Ordinal < 0 || useOfSite.Ordinal > 1000)
{
useOfSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Ordinal", "0", "1000"), new[] { "Ordinal" }));
}
if (useOfSite.StartYear < 1980 || useOfSite.StartYear > 2050)
{
useOfSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "StartYear", "1980", "2050"), new[] { "StartYear" }));
}
if (useOfSite.EndYear != null)
{
if (useOfSite.EndYear < 1980 || useOfSite.EndYear > 2050)
{
useOfSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "EndYear", "1980", "2050"), new[] { "EndYear" }));
}
}
if (useOfSite.Weight_perc != null)
{
if (useOfSite.Weight_perc < 0 || useOfSite.Weight_perc > 100)
{
useOfSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Weight_perc", "0", "100"), new[] { "Weight_perc" }));
}
}
if (useOfSite.Param1 != null)
{
if (useOfSite.Param1 < 0 || useOfSite.Param1 > 100)
{
useOfSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Param1", "0", "100"), new[] { "Param1" }));
}
}
if (useOfSite.Param2 != null)
{
if (useOfSite.Param2 < 0 || useOfSite.Param2 > 100)
{
useOfSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Param2", "0", "100"), new[] { "Param2" }));
}
}
if (useOfSite.Param3 != null)
{
if (useOfSite.Param3 < 0 || useOfSite.Param3 > 100)
{
useOfSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Param3", "0", "100"), new[] { "Param3" }));
}
}
if (useOfSite.Param4 != null)
{
if (useOfSite.Param4 < 0 || useOfSite.Param4 > 100)
{
useOfSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Param4", "0", "100"), new[] { "Param4" }));
}
}
if (useOfSite.LastUpdateDate_UTC.Year == 1)
{
useOfSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "LastUpdateDate_UTC"), new[] { "LastUpdateDate_UTC" }));
}
else
{
if (useOfSite.LastUpdateDate_UTC.Year < 1980)
{
useOfSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "LastUpdateDate_UTC", "1980"), new[] { "LastUpdateDate_UTC" }));
}
}
TVItem TVItemLastUpdateContactTVItemID = (from c in db.TVItems where c.TVItemID == useOfSite.LastUpdateContactTVItemID select c).FirstOrDefault();
if (TVItemLastUpdateContactTVItemID == null)
{
useOfSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "LastUpdateContactTVItemID", useOfSite.LastUpdateContactTVItemID.ToString()), new[] { "LastUpdateContactTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.Contact,
};
if (!AllowableTVTypes.Contains(TVItemLastUpdateContactTVItemID.TVType))
{
useOfSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "LastUpdateContactTVItemID", "Contact"), new[] { "LastUpdateContactTVItemID" }));
}
}
retStr = ""; // added to stop compiling CSSPError
if (retStr != "") // will never be true
{
useOfSite.HasErrors = true;
yield return(new ValidationResult("AAA", new[] { "AAA" }));
}
}
/// <summary>
/// Validate function for all BoxModelLanguageService commands
/// </summary>
/// <param name="validationContext">System.ComponentModel.DataAnnotations.ValidationContext (Describes the context in which a validation check is performed.)</param>
/// <param name="actionDBType">[ActionDBTypeEnum] (CSSPEnums.ActionDBTypeEnum.html) action type to validate</param>
/// <returns>IEnumerable of ValidationResult (Where ValidationResult is a container for the results of a validation request.)</returns>
private IEnumerable <ValidationResult> Validate(ValidationContext validationContext, ActionDBTypeEnum actionDBType)
{
string retStr = "";
Enums enums = new Enums(LanguageRequest);
BoxModelLanguage boxModelLanguage = validationContext.ObjectInstance as BoxModelLanguage;
boxModelLanguage.HasErrors = false;
if (actionDBType == ActionDBTypeEnum.Update || actionDBType == ActionDBTypeEnum.Delete)
{
if (boxModelLanguage.BoxModelLanguageID == 0)
{
boxModelLanguage.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "BoxModelLanguageID"), new[] { "BoxModelLanguageID" }));
}
if (!(from c in db.BoxModelLanguages select c).Where(c => c.BoxModelLanguageID == boxModelLanguage.BoxModelLanguageID).Any())
{
boxModelLanguage.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "BoxModelLanguage", "BoxModelLanguageID", boxModelLanguage.BoxModelLanguageID.ToString()), new[] { "BoxModelLanguageID" }));
}
}
BoxModel BoxModelBoxModelID = (from c in db.BoxModels where c.BoxModelID == boxModelLanguage.BoxModelID select c).FirstOrDefault();
if (BoxModelBoxModelID == null)
{
boxModelLanguage.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "BoxModel", "BoxModelID", boxModelLanguage.BoxModelID.ToString()), new[] { "BoxModelID" }));
}
retStr = enums.EnumTypeOK(typeof(LanguageEnum), (int?)boxModelLanguage.Language);
if (!string.IsNullOrWhiteSpace(retStr))
{
boxModelLanguage.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "Language"), new[] { "Language" }));
}
if (string.IsNullOrWhiteSpace(boxModelLanguage.ScenarioName))
{
boxModelLanguage.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "ScenarioName"), new[] { "ScenarioName" }));
}
if (!string.IsNullOrWhiteSpace(boxModelLanguage.ScenarioName) && boxModelLanguage.ScenarioName.Length > 250)
{
boxModelLanguage.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "ScenarioName", "250"), new[] { "ScenarioName" }));
}
retStr = enums.EnumTypeOK(typeof(TranslationStatusEnum), (int?)boxModelLanguage.TranslationStatus);
if (!string.IsNullOrWhiteSpace(retStr))
{
boxModelLanguage.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "TranslationStatus"), new[] { "TranslationStatus" }));
}
if (boxModelLanguage.LastUpdateDate_UTC.Year == 1)
{
boxModelLanguage.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "LastUpdateDate_UTC"), new[] { "LastUpdateDate_UTC" }));
}
else
{
if (boxModelLanguage.LastUpdateDate_UTC.Year < 1980)
{
boxModelLanguage.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "LastUpdateDate_UTC", "1980"), new[] { "LastUpdateDate_UTC" }));
}
}
TVItem TVItemLastUpdateContactTVItemID = (from c in db.TVItems where c.TVItemID == boxModelLanguage.LastUpdateContactTVItemID select c).FirstOrDefault();
if (TVItemLastUpdateContactTVItemID == null)
{
boxModelLanguage.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "LastUpdateContactTVItemID", boxModelLanguage.LastUpdateContactTVItemID.ToString()), new[] { "LastUpdateContactTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.Contact,
};
if (!AllowableTVTypes.Contains(TVItemLastUpdateContactTVItemID.TVType))
{
boxModelLanguage.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "LastUpdateContactTVItemID", "Contact"), new[] { "LastUpdateContactTVItemID" }));
}
}
retStr = ""; // added to stop compiling CSSPError
if (retStr != "") // will never be true
{
boxModelLanguage.HasErrors = true;
yield return(new ValidationResult("AAA", new[] { "AAA" }));
}
}
private IEnumerable <ValidationResult> Validate(ValidationContext validationContext, ActionDBTypeEnum actionDBType)
{
string retStr = "";
Enums enums = new Enums(LanguageRequest);
WhereInfo whereInfo = validationContext.ObjectInstance as WhereInfo;
whereInfo.HasErrors = false;
if (string.IsNullOrWhiteSpace(whereInfo.PropertyName))
{
whereInfo.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "PropertyName"), new[] { "PropertyName" }));
}
if (!string.IsNullOrWhiteSpace(whereInfo.PropertyName) && whereInfo.PropertyName.Length > 100)
{
whereInfo.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "PropertyName", "100"), new[] { "PropertyName" }));
}
retStr = enums.EnumTypeOK(typeof(PropertyTypeEnum), (int?)whereInfo.PropertyType);
if (!string.IsNullOrWhiteSpace(retStr))
{
whereInfo.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "PropertyType"), new[] { "PropertyType" }));
}
retStr = enums.EnumTypeOK(typeof(WhereOperatorEnum), (int?)whereInfo.WhereOperator);
if (!string.IsNullOrWhiteSpace(retStr))
{
whereInfo.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "WhereOperator"), new[] { "WhereOperator" }));
}
if (string.IsNullOrWhiteSpace(whereInfo.Value))
{
whereInfo.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "Value"), new[] { "Value" }));
}
if (!string.IsNullOrWhiteSpace(whereInfo.Value) && whereInfo.Value.Length > 100)
{
whereInfo.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "Value", "100"), new[] { "Value" }));
}
if (whereInfo.ValueInt < -1 || whereInfo.ValueInt > -1)
{
whereInfo.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "ValueInt", "-1", "-1"), new[] { "ValueInt" }));
}
if (whereInfo.ValueDouble < -1 || whereInfo.ValueDouble > -1)
{
whereInfo.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "ValueDouble", "-1", "-1"), new[] { "ValueDouble" }));
}
if (whereInfo.ValueDateTime.Year == 1)
{
whereInfo.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "ValueDateTime"), new[] { "ValueDateTime" }));
}
else
{
if (whereInfo.ValueDateTime.Year < 1900)
{
whereInfo.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "ValueDateTime", "1900"), new[] { "ValueDateTime" }));
}
}
if (string.IsNullOrWhiteSpace(whereInfo.ValueEnumText))
{
whereInfo.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "ValueEnumText"), new[] { "ValueEnumText" }));
}
if (!string.IsNullOrWhiteSpace(whereInfo.ValueEnumText) && whereInfo.ValueEnumText.Length > 100)
{
whereInfo.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "ValueEnumText", "100"), new[] { "ValueEnumText" }));
}
//CSSPError: Type not implemented [EnumType] of type [Type]
//CSSPError: Type not implemented [EnumType] of type [Type]
retStr = ""; // added to stop compiling CSSPError
if (retStr != "") // will never be true
{
whereInfo.HasErrors = true;
yield return(new ValidationResult("AAA", new[] { "AAA" }));
}
}
/// <summary>
/// Validate function for all LabSheetTubeMPNDetailService commands
/// </summary>
/// <param name="validationContext">System.ComponentModel.DataAnnotations.ValidationContext (Describes the context in which a validation check is performed.)</param>
/// <param name="actionDBType">[ActionDBTypeEnum] (CSSPEnums.ActionDBTypeEnum.html) action type to validate</param>
/// <returns>IEnumerable of ValidationResult (Where ValidationResult is a container for the results of a validation request.)</returns>
private IEnumerable <ValidationResult> Validate(ValidationContext validationContext, ActionDBTypeEnum actionDBType)
{
string retStr = "";
Enums enums = new Enums(LanguageRequest);
LabSheetTubeMPNDetail labSheetTubeMPNDetail = validationContext.ObjectInstance as LabSheetTubeMPNDetail;
labSheetTubeMPNDetail.HasErrors = false;
if (actionDBType == ActionDBTypeEnum.Update || actionDBType == ActionDBTypeEnum.Delete)
{
if (labSheetTubeMPNDetail.LabSheetTubeMPNDetailID == 0)
{
labSheetTubeMPNDetail.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "LabSheetTubeMPNDetailID"), new[] { "LabSheetTubeMPNDetailID" }));
}
if (!(from c in db.LabSheetTubeMPNDetails select c).Where(c => c.LabSheetTubeMPNDetailID == labSheetTubeMPNDetail.LabSheetTubeMPNDetailID).Any())
{
labSheetTubeMPNDetail.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "LabSheetTubeMPNDetail", "LabSheetTubeMPNDetailID", labSheetTubeMPNDetail.LabSheetTubeMPNDetailID.ToString()), new[] { "LabSheetTubeMPNDetailID" }));
}
}
LabSheetDetail LabSheetDetailLabSheetDetailID = (from c in db.LabSheetDetails where c.LabSheetDetailID == labSheetTubeMPNDetail.LabSheetDetailID select c).FirstOrDefault();
if (LabSheetDetailLabSheetDetailID == null)
{
labSheetTubeMPNDetail.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "LabSheetDetail", "LabSheetDetailID", labSheetTubeMPNDetail.LabSheetDetailID.ToString()), new[] { "LabSheetDetailID" }));
}
if (labSheetTubeMPNDetail.Ordinal < 0 || labSheetTubeMPNDetail.Ordinal > 1000)
{
labSheetTubeMPNDetail.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Ordinal", "0", "1000"), new[] { "Ordinal" }));
}
TVItem TVItemMWQMSiteTVItemID = (from c in db.TVItems where c.TVItemID == labSheetTubeMPNDetail.MWQMSiteTVItemID select c).FirstOrDefault();
if (TVItemMWQMSiteTVItemID == null)
{
labSheetTubeMPNDetail.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "MWQMSiteTVItemID", labSheetTubeMPNDetail.MWQMSiteTVItemID.ToString()), new[] { "MWQMSiteTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.MWQMSite,
};
if (!AllowableTVTypes.Contains(TVItemMWQMSiteTVItemID.TVType))
{
labSheetTubeMPNDetail.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "MWQMSiteTVItemID", "MWQMSite"), new[] { "MWQMSiteTVItemID" }));
}
}
if (labSheetTubeMPNDetail.SampleDateTime != null && ((DateTime)labSheetTubeMPNDetail.SampleDateTime).Year < 1980)
{
labSheetTubeMPNDetail.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "SampleDateTime", "1980"), new[] { "SampleDateTime" }));
}
if (labSheetTubeMPNDetail.MPN != null)
{
if (labSheetTubeMPNDetail.MPN < 1 || labSheetTubeMPNDetail.MPN > 10000000)
{
labSheetTubeMPNDetail.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "MPN", "1", "10000000"), new[] { "MPN" }));
}
}
if (labSheetTubeMPNDetail.Tube10 != null)
{
if (labSheetTubeMPNDetail.Tube10 < 0 || labSheetTubeMPNDetail.Tube10 > 5)
{
labSheetTubeMPNDetail.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Tube10", "0", "5"), new[] { "Tube10" }));
}
}
if (labSheetTubeMPNDetail.Tube1_0 != null)
{
if (labSheetTubeMPNDetail.Tube1_0 < 0 || labSheetTubeMPNDetail.Tube1_0 > 5)
{
labSheetTubeMPNDetail.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Tube1_0", "0", "5"), new[] { "Tube1_0" }));
}
}
if (labSheetTubeMPNDetail.Tube0_1 != null)
{
if (labSheetTubeMPNDetail.Tube0_1 < 0 || labSheetTubeMPNDetail.Tube0_1 > 5)
{
labSheetTubeMPNDetail.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Tube0_1", "0", "5"), new[] { "Tube0_1" }));
}
}
if (labSheetTubeMPNDetail.Salinity != null)
{
if (labSheetTubeMPNDetail.Salinity < 0 || labSheetTubeMPNDetail.Salinity > 40)
{
labSheetTubeMPNDetail.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Salinity", "0", "40"), new[] { "Salinity" }));
}
}
if (labSheetTubeMPNDetail.Temperature != null)
{
if (labSheetTubeMPNDetail.Temperature < -10 || labSheetTubeMPNDetail.Temperature > 40)
{
labSheetTubeMPNDetail.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Temperature", "-10", "40"), new[] { "Temperature" }));
}
}
if (!string.IsNullOrWhiteSpace(labSheetTubeMPNDetail.ProcessedBy) && labSheetTubeMPNDetail.ProcessedBy.Length > 10)
{
labSheetTubeMPNDetail.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "ProcessedBy", "10"), new[] { "ProcessedBy" }));
}
retStr = enums.EnumTypeOK(typeof(SampleTypeEnum), (int?)labSheetTubeMPNDetail.SampleType);
if (!string.IsNullOrWhiteSpace(retStr))
{
labSheetTubeMPNDetail.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "SampleType"), new[] { "SampleType" }));
}
if (!string.IsNullOrWhiteSpace(labSheetTubeMPNDetail.SiteComment) && labSheetTubeMPNDetail.SiteComment.Length > 250)
{
labSheetTubeMPNDetail.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "SiteComment", "250"), new[] { "SiteComment" }));
}
if (labSheetTubeMPNDetail.LastUpdateDate_UTC.Year == 1)
{
labSheetTubeMPNDetail.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "LastUpdateDate_UTC"), new[] { "LastUpdateDate_UTC" }));
}
else
{
if (labSheetTubeMPNDetail.LastUpdateDate_UTC.Year < 1980)
{
labSheetTubeMPNDetail.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "LastUpdateDate_UTC", "1980"), new[] { "LastUpdateDate_UTC" }));
}
}
TVItem TVItemLastUpdateContactTVItemID = (from c in db.TVItems where c.TVItemID == labSheetTubeMPNDetail.LastUpdateContactTVItemID select c).FirstOrDefault();
if (TVItemLastUpdateContactTVItemID == null)
{
labSheetTubeMPNDetail.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "LastUpdateContactTVItemID", labSheetTubeMPNDetail.LastUpdateContactTVItemID.ToString()), new[] { "LastUpdateContactTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.Contact,
};
if (!AllowableTVTypes.Contains(TVItemLastUpdateContactTVItemID.TVType))
{
labSheetTubeMPNDetail.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "LastUpdateContactTVItemID", "Contact"), new[] { "LastUpdateContactTVItemID" }));
}
}
retStr = ""; // added to stop compiling CSSPError
if (retStr != "") // will never be true
{
labSheetTubeMPNDetail.HasErrors = true;
yield return(new ValidationResult("AAA", new[] { "AAA" }));
}
}
private IEnumerable <ValidationResult> Validate(ValidationContext validationContext, ActionDBTypeEnum actionDBType)
{
string retStr = "";
Enums enums = new Enums(LanguageRequest);
TVLocation tvLocation = validationContext.ObjectInstance as TVLocation;
tvLocation.HasErrors = false;
if (tvLocation.TVItemID < 1)
{
tvLocation.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MinValueIs_, "TVItemID", "1"), new[] { "TVItemID" }));
}
if (string.IsNullOrWhiteSpace(tvLocation.TVText))
{
tvLocation.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "TVText"), new[] { "TVText" }));
}
if (!string.IsNullOrWhiteSpace(tvLocation.TVText) && (tvLocation.TVText.Length < 1 || tvLocation.TVText.Length > 255))
{
tvLocation.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._LengthShouldBeBetween_And_, "TVText", "1", "255"), new[] { "TVText" }));
}
retStr = enums.EnumTypeOK(typeof(TVTypeEnum), (int?)tvLocation.TVType);
if (!string.IsNullOrWhiteSpace(retStr))
{
tvLocation.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "TVType"), new[] { "TVType" }));
}
retStr = enums.EnumTypeOK(typeof(TVTypeEnum), (int?)tvLocation.SubTVType);
if (!string.IsNullOrWhiteSpace(retStr))
{
tvLocation.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "SubTVType"), new[] { "SubTVType" }));
}
if (!string.IsNullOrWhiteSpace(tvLocation.TVTypeText) && tvLocation.TVTypeText.Length > 100)
{
tvLocation.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "TVTypeText", "100"), new[] { "TVTypeText" }));
}
if (!string.IsNullOrWhiteSpace(tvLocation.SubTVTypeText) && tvLocation.SubTVTypeText.Length > 100)
{
tvLocation.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "SubTVTypeText", "100"), new[] { "SubTVTypeText" }));
}
//CSSPError: Type not implemented [MapObjList] of type [List`1]
//CSSPError: Type not implemented [MapObjList] of type [MapObj]
retStr = ""; // added to stop compiling CSSPError
if (retStr != "") // will never be true
{
tvLocation.HasErrors = true;
yield return(new ValidationResult("AAA", new[] { "AAA" }));
}
}
