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" })); } }