/// <summary>
/// Validate function for all MapInfoPointService 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);
MapInfoPoint mapInfoPoint = validationContext.ObjectInstance as MapInfoPoint;
mapInfoPoint.HasErrors = false;
if (actionDBType == ActionDBTypeEnum.Update || actionDBType == ActionDBTypeEnum.Delete)
{
if (mapInfoPoint.MapInfoPointID == 0)
{
mapInfoPoint.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "MapInfoPointID"), new[] { "MapInfoPointID" }));
}
if (!(from c in db.MapInfoPoints select c).Where(c => c.MapInfoPointID == mapInfoPoint.MapInfoPointID).Any())
{
mapInfoPoint.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "MapInfoPoint", "MapInfoPointID", mapInfoPoint.MapInfoPointID.ToString()), new[] { "MapInfoPointID" }));
}
}
MapInfo MapInfoMapInfoID = (from c in db.MapInfos where c.MapInfoID == mapInfoPoint.MapInfoID select c).FirstOrDefault();
if (MapInfoMapInfoID == null)
{
mapInfoPoint.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "MapInfo", "MapInfoID", mapInfoPoint.MapInfoID.ToString()), new[] { "MapInfoID" }));
}
if (mapInfoPoint.Ordinal < 0)
{
mapInfoPoint.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MinValueIs_, "Ordinal", "0"), new[] { "Ordinal" }));
}
if (mapInfoPoint.Lat < -90 || mapInfoPoint.Lat > 90)
{
mapInfoPoint.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Lat", "-90", "90"), new[] { "Lat" }));
}
if (mapInfoPoint.Lng < -180 || mapInfoPoint.Lng > 180)
{
mapInfoPoint.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Lng", "-180", "180"), new[] { "Lng" }));
}
if (mapInfoPoint.LastUpdateDate_UTC.Year == 1)
{
mapInfoPoint.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "LastUpdateDate_UTC"), new[] { "LastUpdateDate_UTC" }));
}
else
{
if (mapInfoPoint.LastUpdateDate_UTC.Year < 1980)
{
mapInfoPoint.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 == mapInfoPoint.LastUpdateContactTVItemID select c).FirstOrDefault();
if (TVItemLastUpdateContactTVItemID == null)
{
mapInfoPoint.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "LastUpdateContactTVItemID", mapInfoPoint.LastUpdateContactTVItemID.ToString()), new[] { "LastUpdateContactTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.Contact,
};
if (!AllowableTVTypes.Contains(TVItemLastUpdateContactTVItemID.TVType))
{
mapInfoPoint.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
{
mapInfoPoint.HasErrors = true;
yield return(new ValidationResult("AAA", new[] { "AAA" }));
}
}
/// <summary>
/// Validate function for all ElementLayerService 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);
ElementLayer elementLayer = validationContext.ObjectInstance as ElementLayer;
elementLayer.HasErrors = false;
if (elementLayer.Layer < 1 || elementLayer.Layer > 1000)
{
elementLayer.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Layer", "1", "1000"), new[] { "Layer" }));
}
//ZMin has no Range Attribute
//ZMax has no Range Attribute
//CSSPError: Type not implemented [Element] of type [Element]
//CSSPError: Type not implemented [Element] of type [Element]
retStr = ""; // added to stop compiling CSSPError
if (retStr != "") // will never be true
{
elementLayer.HasErrors = true;
yield return(new ValidationResult("AAA", new[] { "AAA" }));
}
}
private IEnumerable <ValidationResult> Validate(ValidationContext validationContext, ActionDBTypeEnum actionDBType)
{
string retStr = "";
Enums enums = new Enums(LanguageRequest);
LabSheetAndA1Sheet labSheetAndA1Sheet = validationContext.ObjectInstance as LabSheetAndA1Sheet;
labSheetAndA1Sheet.HasErrors = false;
//CSSPError: Type not implemented [LabSheet] of type [LabSheet]
//CSSPError: Type not implemented [LabSheet] of type [LabSheet]
//CSSPError: Type not implemented [LabSheetA1Sheet] of type [LabSheetA1Sheet]
//CSSPError: Type not implemented [LabSheetA1Sheet] of type [LabSheetA1Sheet]
retStr = ""; // added to stop compiling CSSPError
if (retStr != "") // will never be true
{
labSheetAndA1Sheet.HasErrors = true;
yield return(new ValidationResult("AAA", new[] { "AAA" }));
}
}
/// <summary>
/// Validate function for all SearchService 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);
Search search = validationContext.ObjectInstance as Search;
search.HasErrors = false;
if (string.IsNullOrWhiteSpace(search.value))
{
search.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "value"), new[] { "value" }));
}
if (!string.IsNullOrWhiteSpace(search.value) && (search.value.Length < 1 || search.value.Length > 255))
{
search.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._LengthShouldBeBetween_And_, "value", "1", "255"), new[] { "value" }));
}
if (search.id < 1)
{
search.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MinValueIs_, "id", "1"), new[] { "id" }));
}
retStr = ""; // added to stop compiling CSSPError
if (retStr != "") // will never be true
{
search.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 CSSPWQInputAppService 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);
CSSPWQInputApp cSSPWQInputApp = validationContext.ObjectInstance as CSSPWQInputApp;
cSSPWQInputApp.HasErrors = false;
if (string.IsNullOrWhiteSpace(cSSPWQInputApp.AccessCode))
{
cSSPWQInputApp.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "AccessCode"), new[] { "AccessCode" }));
}
if (!string.IsNullOrWhiteSpace(cSSPWQInputApp.AccessCode) && (cSSPWQInputApp.AccessCode.Length < 1 || cSSPWQInputApp.AccessCode.Length > 100))
{
cSSPWQInputApp.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._LengthShouldBeBetween_And_, "AccessCode", "1", "100"), new[] { "AccessCode" }));
}
if (string.IsNullOrWhiteSpace(cSSPWQInputApp.ActiveYear))
{
cSSPWQInputApp.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "ActiveYear"), new[] { "ActiveYear" }));
}
if (!string.IsNullOrWhiteSpace(cSSPWQInputApp.ActiveYear) && (cSSPWQInputApp.ActiveYear.Length < 4 || cSSPWQInputApp.ActiveYear.Length > 4))
{
cSSPWQInputApp.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._LengthShouldBeBetween_And_, "ActiveYear", "4", "4"), new[] { "ActiveYear" }));
}
if (cSSPWQInputApp.DailyDuplicatePrecisionCriteria < 0 || cSSPWQInputApp.DailyDuplicatePrecisionCriteria > 100)
{
cSSPWQInputApp.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "DailyDuplicatePrecisionCriteria", "0", "100"), new[] { "DailyDuplicatePrecisionCriteria" }));
}
if (cSSPWQInputApp.IntertechDuplicatePrecisionCriteria < 0 || cSSPWQInputApp.IntertechDuplicatePrecisionCriteria > 100)
{
cSSPWQInputApp.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "IntertechDuplicatePrecisionCriteria", "0", "100"), new[] { "IntertechDuplicatePrecisionCriteria" }));
}
if (string.IsNullOrWhiteSpace(cSSPWQInputApp.ApprovalCode))
{
cSSPWQInputApp.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "ApprovalCode"), new[] { "ApprovalCode" }));
}
if (!string.IsNullOrWhiteSpace(cSSPWQInputApp.ApprovalCode) && (cSSPWQInputApp.ApprovalCode.Length < 1 || cSSPWQInputApp.ApprovalCode.Length > 100))
{
cSSPWQInputApp.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._LengthShouldBeBetween_And_, "ApprovalCode", "1", "100"), new[] { "ApprovalCode" }));
}
if (cSSPWQInputApp.ApprovalDate.Year == 1)
{
cSSPWQInputApp.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "ApprovalDate"), new[] { "ApprovalDate" }));
}
else
{
if (cSSPWQInputApp.ApprovalDate.Year < 1980)
{
cSSPWQInputApp.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "ApprovalDate", "1980"), new[] { "ApprovalDate" }));
}
}
retStr = ""; // added to stop compiling CSSPError
if (retStr != "") // will never be true
{
cSSPWQInputApp.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);
MWQMLookupMPN mwqmLookupMPN = validationContext.ObjectInstance as MWQMLookupMPN;
mwqmLookupMPN.HasErrors = false;
if (actionDBType == ActionDBTypeEnum.Update || actionDBType == ActionDBTypeEnum.Delete)
{
if (mwqmLookupMPN.MWQMLookupMPNID == 0)
{
mwqmLookupMPN.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "MWQMLookupMPNID"), new[] { "MWQMLookupMPNID" }));
}
if (!(from c in db.MWQMLookupMPNs select c).Where(c => c.MWQMLookupMPNID == mwqmLookupMPN.MWQMLookupMPNID).Any())
{
mwqmLookupMPN.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "MWQMLookupMPN", "MWQMLookupMPNID", mwqmLookupMPN.MWQMLookupMPNID.ToString()), new[] { "MWQMLookupMPNID" }));
}
}
if (mwqmLookupMPN.Tubes10 < 0 || mwqmLookupMPN.Tubes10 > 5)
{
mwqmLookupMPN.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Tubes10", "0", "5"), new[] { "Tubes10" }));
}
if (mwqmLookupMPN.Tubes1 < 0 || mwqmLookupMPN.Tubes1 > 5)
{
mwqmLookupMPN.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Tubes1", "0", "5"), new[] { "Tubes1" }));
}
if (mwqmLookupMPN.Tubes01 < 0 || mwqmLookupMPN.Tubes01 > 5)
{
mwqmLookupMPN.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Tubes01", "0", "5"), new[] { "Tubes01" }));
}
if (mwqmLookupMPN.MPN_100ml < 1 || mwqmLookupMPN.MPN_100ml > 10000)
{
mwqmLookupMPN.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "MPN_100ml", "1", "10000"), new[] { "MPN_100ml" }));
}
if (mwqmLookupMPN.LastUpdateDate_UTC.Year == 1)
{
mwqmLookupMPN.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "LastUpdateDate_UTC"), new[] { "LastUpdateDate_UTC" }));
}
else
{
if (mwqmLookupMPN.LastUpdateDate_UTC.Year < 1980)
{
mwqmLookupMPN.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 == mwqmLookupMPN.LastUpdateContactTVItemID select c).FirstOrDefault();
if (TVItemLastUpdateContactTVItemID == null)
{
mwqmLookupMPN.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "LastUpdateContactTVItemID", mwqmLookupMPN.LastUpdateContactTVItemID.ToString()), new[] { "LastUpdateContactTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.Contact,
};
if (!AllowableTVTypes.Contains(TVItemLastUpdateContactTVItemID.TVType))
{
mwqmLookupMPN.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
{
mwqmLookupMPN.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);
MikeSourceStartEnd mikeSourceStartEnd = validationContext.ObjectInstance as MikeSourceStartEnd;
mikeSourceStartEnd.HasErrors = false;
if (actionDBType == ActionDBTypeEnum.Update || actionDBType == ActionDBTypeEnum.Delete)
{
if (mikeSourceStartEnd.MikeSourceStartEndID == 0)
{
mikeSourceStartEnd.HasErrors = true;
yield return new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "MikeSourceStartEndID"), new[] { "MikeSourceStartEndID" });
}
if (!(from c in db.MikeSourceStartEnds select c).Where(c => c.MikeSourceStartEndID == mikeSourceStartEnd.MikeSourceStartEndID).Any())
{
mikeSourceStartEnd.HasErrors = true;
yield return new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "MikeSourceStartEnd", "MikeSourceStartEndID", mikeSourceStartEnd.MikeSourceStartEndID.ToString()), new[] { "MikeSourceStartEndID" });
}
}
MikeSource MikeSourceMikeSourceID = (from c in db.MikeSources where c.MikeSourceID == mikeSourceStartEnd.MikeSourceID select c).FirstOrDefault();
if (MikeSourceMikeSourceID == null)
{
mikeSourceStartEnd.HasErrors = true;
yield return new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "MikeSource", "MikeSourceID", mikeSourceStartEnd.MikeSourceID.ToString()), new[] { "MikeSourceID" });
}
if (mikeSourceStartEnd.StartDateAndTime_Local.Year == 1)
{
mikeSourceStartEnd.HasErrors = true;
yield return new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "StartDateAndTime_Local"), new[] { "StartDateAndTime_Local" });
}
else
{
if (mikeSourceStartEnd.StartDateAndTime_Local.Year < 1980)
{
mikeSourceStartEnd.HasErrors = true;
yield return new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "StartDateAndTime_Local", "1980"), new[] { "StartDateAndTime_Local" });
}
}
if (mikeSourceStartEnd.EndDateAndTime_Local.Year == 1)
{
mikeSourceStartEnd.HasErrors = true;
yield return new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "EndDateAndTime_Local"), new[] { "EndDateAndTime_Local" });
}
else
{
if (mikeSourceStartEnd.EndDateAndTime_Local.Year < 1980)
{
mikeSourceStartEnd.HasErrors = true;
yield return new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "EndDateAndTime_Local", "1980"), new[] { "EndDateAndTime_Local" });
}
}
if (mikeSourceStartEnd.StartDateAndTime_Local > mikeSourceStartEnd.EndDateAndTime_Local)
{
mikeSourceStartEnd.HasErrors = true;
yield return new ValidationResult(string.Format(CSSPServicesRes._DateIsBiggerThan_, "EndDateAndTime_Local", "MikeSourceStartEndStartDateAndTime_Local"), new[] { "EndDateAndTime_Local" });
}
if (mikeSourceStartEnd.SourceFlowStart_m3_day < 0 || mikeSourceStartEnd.SourceFlowStart_m3_day > 1000000)
{
mikeSourceStartEnd.HasErrors = true;
yield return new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "SourceFlowStart_m3_day", "0", "1000000"), new[] { "SourceFlowStart_m3_day" });
}
if (mikeSourceStartEnd.SourceFlowEnd_m3_day < 0 || mikeSourceStartEnd.SourceFlowEnd_m3_day > 1000000)
{
mikeSourceStartEnd.HasErrors = true;
yield return new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "SourceFlowEnd_m3_day", "0", "1000000"), new[] { "SourceFlowEnd_m3_day" });
}
if (mikeSourceStartEnd.SourcePollutionStart_MPN_100ml < 0 || mikeSourceStartEnd.SourcePollutionStart_MPN_100ml > 10000000)
{
mikeSourceStartEnd.HasErrors = true;
yield return new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "SourcePollutionStart_MPN_100ml", "0", "10000000"), new[] { "SourcePollutionStart_MPN_100ml" });
}
if (mikeSourceStartEnd.SourcePollutionEnd_MPN_100ml < 0 || mikeSourceStartEnd.SourcePollutionEnd_MPN_100ml > 10000000)
{
mikeSourceStartEnd.HasErrors = true;
yield return new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "SourcePollutionEnd_MPN_100ml", "0", "10000000"), new[] { "SourcePollutionEnd_MPN_100ml" });
}
if (mikeSourceStartEnd.SourceTemperatureStart_C < -10 || mikeSourceStartEnd.SourceTemperatureStart_C > 40)
{
mikeSourceStartEnd.HasErrors = true;
yield return new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "SourceTemperatureStart_C", "-10", "40"), new[] { "SourceTemperatureStart_C" });
}
if (mikeSourceStartEnd.SourceTemperatureEnd_C < -10 || mikeSourceStartEnd.SourceTemperatureEnd_C > 40)
{
mikeSourceStartEnd.HasErrors = true;
yield return new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "SourceTemperatureEnd_C", "-10", "40"), new[] { "SourceTemperatureEnd_C" });
}
if (mikeSourceStartEnd.SourceSalinityStart_PSU < 0 || mikeSourceStartEnd.SourceSalinityStart_PSU > 40)
{
mikeSourceStartEnd.HasErrors = true;
yield return new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "SourceSalinityStart_PSU", "0", "40"), new[] { "SourceSalinityStart_PSU" });
}
if (mikeSourceStartEnd.SourceSalinityEnd_PSU < 0 || mikeSourceStartEnd.SourceSalinityEnd_PSU > 40)
{
mikeSourceStartEnd.HasErrors = true;
yield return new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "SourceSalinityEnd_PSU", "0", "40"), new[] { "SourceSalinityEnd_PSU" });
}
if (mikeSourceStartEnd.LastUpdateDate_UTC.Year == 1)
{
mikeSourceStartEnd.HasErrors = true;
yield return new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "LastUpdateDate_UTC"), new[] { "LastUpdateDate_UTC" });
}
else
{
if (mikeSourceStartEnd.LastUpdateDate_UTC.Year < 1980)
{
mikeSourceStartEnd.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 == mikeSourceStartEnd.LastUpdateContactTVItemID select c).FirstOrDefault();
if (TVItemLastUpdateContactTVItemID == null)
{
mikeSourceStartEnd.HasErrors = true;
yield return new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "LastUpdateContactTVItemID", mikeSourceStartEnd.LastUpdateContactTVItemID.ToString()), new[] { "LastUpdateContactTVItemID" });
}
else
{
List<TVTypeEnum> AllowableTVTypes = new List<TVTypeEnum>()
{
TVTypeEnum.Contact,
};
if (!AllowableTVTypes.Contains(TVItemLastUpdateContactTVItemID.TVType))
{
mikeSourceStartEnd.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
{
mikeSourceStartEnd.HasErrors = true;
yield return new ValidationResult("AAA", new[] { "AAA" });
}
}
private IEnumerable <ValidationResult> Validate(ValidationContext validationContext, ActionDBTypeEnum actionDBType)
{
string retStr = "";
Enums enums = new Enums(LanguageRequest);
EmailDistributionList emailDistributionList = validationContext.ObjectInstance as EmailDistributionList;
emailDistributionList.HasErrors = false;
if (actionDBType == ActionDBTypeEnum.Update || actionDBType == ActionDBTypeEnum.Delete)
{
if (emailDistributionList.EmailDistributionListID == 0)
{
emailDistributionList.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "EmailDistributionListID"), new[] { "EmailDistributionListID" }));
}
if (!(from c in db.EmailDistributionLists select c).Where(c => c.EmailDistributionListID == emailDistributionList.EmailDistributionListID).Any())
{
emailDistributionList.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "EmailDistributionList", "EmailDistributionListID", emailDistributionList.EmailDistributionListID.ToString()), new[] { "EmailDistributionListID" }));
}
}
TVItem TVItemParentTVItemID = (from c in db.TVItems where c.TVItemID == emailDistributionList.ParentTVItemID select c).FirstOrDefault();
if (TVItemParentTVItemID == null)
{
emailDistributionList.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "ParentTVItemID", emailDistributionList.ParentTVItemID.ToString()), new[] { "ParentTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.Country,
};
if (!AllowableTVTypes.Contains(TVItemParentTVItemID.TVType))
{
emailDistributionList.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "ParentTVItemID", "Country"), new[] { "ParentTVItemID" }));
}
}
if (emailDistributionList.Ordinal < 0 || emailDistributionList.Ordinal > 1000)
{
emailDistributionList.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Ordinal", "0", "1000"), new[] { "Ordinal" }));
}
if (emailDistributionList.LastUpdateDate_UTC.Year == 1)
{
emailDistributionList.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "LastUpdateDate_UTC"), new[] { "LastUpdateDate_UTC" }));
}
else
{
if (emailDistributionList.LastUpdateDate_UTC.Year < 1980)
{
emailDistributionList.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 == emailDistributionList.LastUpdateContactTVItemID select c).FirstOrDefault();
if (TVItemLastUpdateContactTVItemID == null)
{
emailDistributionList.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "LastUpdateContactTVItemID", emailDistributionList.LastUpdateContactTVItemID.ToString()), new[] { "LastUpdateContactTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.Contact,
};
if (!AllowableTVTypes.Contains(TVItemLastUpdateContactTVItemID.TVType))
{
emailDistributionList.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
{
emailDistributionList.HasErrors = true;
yield return(new ValidationResult("AAA", new[] { "AAA" }));
}
}
/// <summary>
/// Validate function for all VPFullService 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);
VPFull vpFull = validationContext.ObjectInstance as VPFull;
vpFull.HasErrors = false;
//CSSPError: Type not implemented [VPScenario] of type [VPScenario]
//CSSPError: Type not implemented [VPScenario] of type [VPScenario]
//CSSPError: Type not implemented [VPAmbientList] of type [List`1]
//CSSPError: Type not implemented [VPAmbientList] of type [VPAmbient]
//CSSPError: Type not implemented [VPResultList] of type [List`1]
//CSSPError: Type not implemented [VPResultList] of type [VPResult]
retStr = ""; // added to stop compiling CSSPError
if (retStr != "") // will never be true
{
vpFull.HasErrors = true;
yield return(new ValidationResult("AAA", new[] { "AAA" }));
}
}
/// <summary>
/// Validate function for all RatingCurveValueService 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);
RatingCurveValue ratingCurveValue = validationContext.ObjectInstance as RatingCurveValue;
ratingCurveValue.HasErrors = false;
if (actionDBType == ActionDBTypeEnum.Update || actionDBType == ActionDBTypeEnum.Delete)
{
if (ratingCurveValue.RatingCurveValueID == 0)
{
ratingCurveValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "RatingCurveValueID"), new[] { "RatingCurveValueID" }));
}
if (!(from c in db.RatingCurveValues select c).Where(c => c.RatingCurveValueID == ratingCurveValue.RatingCurveValueID).Any())
{
ratingCurveValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "RatingCurveValue", "RatingCurveValueID", ratingCurveValue.RatingCurveValueID.ToString()), new[] { "RatingCurveValueID" }));
}
}
RatingCurve RatingCurveRatingCurveID = (from c in db.RatingCurves where c.RatingCurveID == ratingCurveValue.RatingCurveID select c).FirstOrDefault();
if (RatingCurveRatingCurveID == null)
{
ratingCurveValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "RatingCurve", "RatingCurveID", ratingCurveValue.RatingCurveID.ToString()), new[] { "RatingCurveID" }));
}
if (ratingCurveValue.StageValue_m < 0 || ratingCurveValue.StageValue_m > 1000)
{
ratingCurveValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "StageValue_m", "0", "1000"), new[] { "StageValue_m" }));
}
if (ratingCurveValue.DischargeValue_m3_s < 0 || ratingCurveValue.DischargeValue_m3_s > 1000000)
{
ratingCurveValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "DischargeValue_m3_s", "0", "1000000"), new[] { "DischargeValue_m3_s" }));
}
if (ratingCurveValue.LastUpdateDate_UTC.Year == 1)
{
ratingCurveValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "LastUpdateDate_UTC"), new[] { "LastUpdateDate_UTC" }));
}
else
{
if (ratingCurveValue.LastUpdateDate_UTC.Year < 1980)
{
ratingCurveValue.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 == ratingCurveValue.LastUpdateContactTVItemID select c).FirstOrDefault();
if (TVItemLastUpdateContactTVItemID == null)
{
ratingCurveValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "LastUpdateContactTVItemID", ratingCurveValue.LastUpdateContactTVItemID.ToString()), new[] { "LastUpdateContactTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.Contact,
};
if (!AllowableTVTypes.Contains(TVItemLastUpdateContactTVItemID.TVType))
{
ratingCurveValue.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
{
ratingCurveValue.HasErrors = true;
yield return(new ValidationResult("AAA", new[] { "AAA" }));
}
}
/// <summary>
/// Validate function for all TVTypeNamesAndPathService 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);
TVTypeNamesAndPath tvTypeNamesAndPath = validationContext.ObjectInstance as TVTypeNamesAndPath;
tvTypeNamesAndPath.HasErrors = false;
if (string.IsNullOrWhiteSpace(tvTypeNamesAndPath.TVTypeName))
{
tvTypeNamesAndPath.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "TVTypeName"), new[] { "TVTypeName" }));
}
if (!string.IsNullOrWhiteSpace(tvTypeNamesAndPath.TVTypeName) && (tvTypeNamesAndPath.TVTypeName.Length < 1 || tvTypeNamesAndPath.TVTypeName.Length > 255))
{
tvTypeNamesAndPath.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._LengthShouldBeBetween_And_, "TVTypeName", "1", "255"), new[] { "TVTypeName" }));
}
if (tvTypeNamesAndPath.Index < 1)
{
tvTypeNamesAndPath.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MinValueIs_, "Index", "1"), new[] { "Index" }));
}
if (string.IsNullOrWhiteSpace(tvTypeNamesAndPath.TVPath))
{
tvTypeNamesAndPath.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "TVPath"), new[] { "TVPath" }));
}
if (!string.IsNullOrWhiteSpace(tvTypeNamesAndPath.TVPath) && (tvTypeNamesAndPath.TVPath.Length < 1 || tvTypeNamesAndPath.TVPath.Length > 255))
{
tvTypeNamesAndPath.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._LengthShouldBeBetween_And_, "TVPath", "1", "255"), new[] { "TVPath" }));
}
retStr = ""; // added to stop compiling CSSPError
if (retStr != "") // will never be true
{
tvTypeNamesAndPath.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" }));
}
}
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" }));
}
}
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" }));
}
}
private IEnumerable <ValidationResult> Validate(ValidationContext validationContext, ActionDBTypeEnum actionDBType)
{
string retStr = "";
Enums enums = new Enums(LanguageRequest);
PolSourceSiteEffect polSourceSiteEffect = validationContext.ObjectInstance as PolSourceSiteEffect;
polSourceSiteEffect.HasErrors = false;
if (actionDBType == ActionDBTypeEnum.Update || actionDBType == ActionDBTypeEnum.Delete)
{
if (polSourceSiteEffect.PolSourceSiteEffectID == 0)
{
polSourceSiteEffect.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "PolSourceSiteEffectID"), new[] { "PolSourceSiteEffectID" }));
}
if (!(from c in db.PolSourceSiteEffects select c).Where(c => c.PolSourceSiteEffectID == polSourceSiteEffect.PolSourceSiteEffectID).Any())
{
polSourceSiteEffect.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "PolSourceSiteEffect", "PolSourceSiteEffectID", polSourceSiteEffect.PolSourceSiteEffectID.ToString()), new[] { "PolSourceSiteEffectID" }));
}
}
TVItem TVItemPolSourceSiteOrInfrastructureTVItemID = (from c in db.TVItems where c.TVItemID == polSourceSiteEffect.PolSourceSiteOrInfrastructureTVItemID select c).FirstOrDefault();
if (TVItemPolSourceSiteOrInfrastructureTVItemID == null)
{
polSourceSiteEffect.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "PolSourceSiteOrInfrastructureTVItemID", polSourceSiteEffect.PolSourceSiteOrInfrastructureTVItemID.ToString()), new[] { "PolSourceSiteOrInfrastructureTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.Infrastructure,
TVTypeEnum.PolSourceSite,
};
if (!AllowableTVTypes.Contains(TVItemPolSourceSiteOrInfrastructureTVItemID.TVType))
{
polSourceSiteEffect.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "PolSourceSiteOrInfrastructureTVItemID", "Infrastructure,PolSourceSite"), new[] { "PolSourceSiteOrInfrastructureTVItemID" }));
}
}
TVItem TVItemMWQMSiteTVItemID = (from c in db.TVItems where c.TVItemID == polSourceSiteEffect.MWQMSiteTVItemID select c).FirstOrDefault();
if (TVItemMWQMSiteTVItemID == null)
{
polSourceSiteEffect.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "MWQMSiteTVItemID", polSourceSiteEffect.MWQMSiteTVItemID.ToString()), new[] { "MWQMSiteTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.MWQMSite,
};
if (!AllowableTVTypes.Contains(TVItemMWQMSiteTVItemID.TVType))
{
polSourceSiteEffect.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "MWQMSiteTVItemID", "MWQMSite"), new[] { "MWQMSiteTVItemID" }));
}
}
if (!string.IsNullOrWhiteSpace(polSourceSiteEffect.PolSourceSiteEffectTermIDs) && polSourceSiteEffect.PolSourceSiteEffectTermIDs.Length > 250)
{
polSourceSiteEffect.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "PolSourceSiteEffectTermIDs", "250"), new[] { "PolSourceSiteEffectTermIDs" }));
}
//Comments has no StringLength Attribute
if (polSourceSiteEffect.AnalysisDocumentTVItemID != null)
{
TVItem TVItemAnalysisDocumentTVItemID = (from c in db.TVItems where c.TVItemID == polSourceSiteEffect.AnalysisDocumentTVItemID select c).FirstOrDefault();
if (TVItemAnalysisDocumentTVItemID == null)
{
polSourceSiteEffect.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "AnalysisDocumentTVItemID", (polSourceSiteEffect.AnalysisDocumentTVItemID == null ? "" : polSourceSiteEffect.AnalysisDocumentTVItemID.ToString())), new[] { "AnalysisDocumentTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.File,
};
if (!AllowableTVTypes.Contains(TVItemAnalysisDocumentTVItemID.TVType))
{
polSourceSiteEffect.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "AnalysisDocumentTVItemID", "File"), new[] { "AnalysisDocumentTVItemID" }));
}
}
}
if (polSourceSiteEffect.LastUpdateDate_UTC.Year == 1)
{
polSourceSiteEffect.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "LastUpdateDate_UTC"), new[] { "LastUpdateDate_UTC" }));
}
else
{
if (polSourceSiteEffect.LastUpdateDate_UTC.Year < 1980)
{
polSourceSiteEffect.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 == polSourceSiteEffect.LastUpdateContactTVItemID select c).FirstOrDefault();
if (TVItemLastUpdateContactTVItemID == null)
{
polSourceSiteEffect.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "LastUpdateContactTVItemID", polSourceSiteEffect.LastUpdateContactTVItemID.ToString()), new[] { "LastUpdateContactTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.Contact,
};
if (!AllowableTVTypes.Contains(TVItemLastUpdateContactTVItemID.TVType))
{
polSourceSiteEffect.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
{
polSourceSiteEffect.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" }));
}
}
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" }));
}
}
/// <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);
ClimateSite climateSite = validationContext.ObjectInstance as ClimateSite;
climateSite.HasErrors = false;
if (actionDBType == ActionDBTypeEnum.Update || actionDBType == ActionDBTypeEnum.Delete)
{
if (climateSite.ClimateSiteID == 0)
{
climateSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "ClimateSiteID"), new[] { "ClimateSiteID" }));
}
if (!(from c in db.ClimateSites select c).Where(c => c.ClimateSiteID == climateSite.ClimateSiteID).Any())
{
climateSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "ClimateSite", "ClimateSiteID", climateSite.ClimateSiteID.ToString()), new[] { "ClimateSiteID" }));
}
}
TVItem TVItemClimateSiteTVItemID = (from c in db.TVItems where c.TVItemID == climateSite.ClimateSiteTVItemID select c).FirstOrDefault();
if (TVItemClimateSiteTVItemID == null)
{
climateSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "ClimateSiteTVItemID", climateSite.ClimateSiteTVItemID.ToString()), new[] { "ClimateSiteTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.ClimateSite,
};
if (!AllowableTVTypes.Contains(TVItemClimateSiteTVItemID.TVType))
{
climateSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "ClimateSiteTVItemID", "ClimateSite"), new[] { "ClimateSiteTVItemID" }));
}
}
if (climateSite.ECDBID != null)
{
if (climateSite.ECDBID < 1 || climateSite.ECDBID > 100000)
{
climateSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "ECDBID", "1", "100000"), new[] { "ECDBID" }));
}
}
if (string.IsNullOrWhiteSpace(climateSite.ClimateSiteName))
{
climateSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "ClimateSiteName"), new[] { "ClimateSiteName" }));
}
if (!string.IsNullOrWhiteSpace(climateSite.ClimateSiteName) && climateSite.ClimateSiteName.Length > 100)
{
climateSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "ClimateSiteName", "100"), new[] { "ClimateSiteName" }));
}
if (string.IsNullOrWhiteSpace(climateSite.Province))
{
climateSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "Province"), new[] { "Province" }));
}
if (!string.IsNullOrWhiteSpace(climateSite.Province) && climateSite.Province.Length > 4)
{
climateSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "Province", "4"), new[] { "Province" }));
}
if (climateSite.Elevation_m != null)
{
if (climateSite.Elevation_m < 0 || climateSite.Elevation_m > 10000)
{
climateSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Elevation_m", "0", "10000"), new[] { "Elevation_m" }));
}
}
if (!string.IsNullOrWhiteSpace(climateSite.ClimateID) && climateSite.ClimateID.Length > 10)
{
climateSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "ClimateID", "10"), new[] { "ClimateID" }));
}
if (climateSite.WMOID != null)
{
if (climateSite.WMOID < 1 || climateSite.WMOID > 100000)
{
climateSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "WMOID", "1", "100000"), new[] { "WMOID" }));
}
}
if (!string.IsNullOrWhiteSpace(climateSite.TCID) && climateSite.TCID.Length > 3)
{
climateSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "TCID", "3"), new[] { "TCID" }));
}
if (climateSite.TimeOffset_hour != null)
{
if (climateSite.TimeOffset_hour < -10 || climateSite.TimeOffset_hour > 0)
{
climateSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "TimeOffset_hour", "-10", "0"), new[] { "TimeOffset_hour" }));
}
}
if (!string.IsNullOrWhiteSpace(climateSite.File_desc) && climateSite.File_desc.Length > 50)
{
climateSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "File_desc", "50"), new[] { "File_desc" }));
}
if (climateSite.HourlyStartDate_Local != null && ((DateTime)climateSite.HourlyStartDate_Local).Year < 1980)
{
climateSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "HourlyStartDate_Local", "1980"), new[] { "HourlyStartDate_Local" }));
}
if (climateSite.HourlyEndDate_Local != null && ((DateTime)climateSite.HourlyEndDate_Local).Year < 1980)
{
climateSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "HourlyEndDate_Local", "1980"), new[] { "HourlyEndDate_Local" }));
}
if (climateSite.DailyStartDate_Local != null && ((DateTime)climateSite.DailyStartDate_Local).Year < 1980)
{
climateSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "DailyStartDate_Local", "1980"), new[] { "DailyStartDate_Local" }));
}
if (climateSite.DailyEndDate_Local != null && ((DateTime)climateSite.DailyEndDate_Local).Year < 1980)
{
climateSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "DailyEndDate_Local", "1980"), new[] { "DailyEndDate_Local" }));
}
if (climateSite.MonthlyStartDate_Local != null && ((DateTime)climateSite.MonthlyStartDate_Local).Year < 1980)
{
climateSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "MonthlyStartDate_Local", "1980"), new[] { "MonthlyStartDate_Local" }));
}
if (climateSite.MonthlyEndDate_Local != null && ((DateTime)climateSite.MonthlyEndDate_Local).Year < 1980)
{
climateSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "MonthlyEndDate_Local", "1980"), new[] { "MonthlyEndDate_Local" }));
}
if (climateSite.LastUpdateDate_UTC.Year == 1)
{
climateSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "LastUpdateDate_UTC"), new[] { "LastUpdateDate_UTC" }));
}
else
{
if (climateSite.LastUpdateDate_UTC.Year < 1980)
{
climateSite.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 == climateSite.LastUpdateContactTVItemID select c).FirstOrDefault();
if (TVItemLastUpdateContactTVItemID == null)
{
climateSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "LastUpdateContactTVItemID", climateSite.LastUpdateContactTVItemID.ToString()), new[] { "LastUpdateContactTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.Contact,
};
if (!AllowableTVTypes.Contains(TVItemLastUpdateContactTVItemID.TVType))
{
climateSite.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
{
climateSite.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" }));
}
}
/// <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);
AppTaskParameter appTaskParameter = validationContext.ObjectInstance as AppTaskParameter;
appTaskParameter.HasErrors = false;
if (string.IsNullOrWhiteSpace(appTaskParameter.Name))
{
appTaskParameter.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "Name"), new[] { "Name" }));
}
if (!string.IsNullOrWhiteSpace(appTaskParameter.Name) && appTaskParameter.Name.Length > 255)
{
appTaskParameter.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "Name", "255"), new[] { "Name" }));
}
if (string.IsNullOrWhiteSpace(appTaskParameter.Value))
{
appTaskParameter.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "Value"), new[] { "Value" }));
}
if (!string.IsNullOrWhiteSpace(appTaskParameter.Value) && appTaskParameter.Value.Length > 255)
{
appTaskParameter.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "Value", "255"), new[] { "Value" }));
}
retStr = ""; // added to stop compiling CSSPError
if (retStr != "") // will never be true
{
appTaskParameter.HasErrors = true;
yield return(new ValidationResult("AAA", new[] { "AAA" }));
}
}
private IEnumerable <ValidationResult> Validate(ValidationContext validationContext, ActionDBTypeEnum actionDBType)
{
string retStr = "";
Enums enums = new Enums(LanguageRequest);
PolSourceInactiveReasonEnumTextAndID polSourceInactiveReasonEnumTextAndID = validationContext.ObjectInstance as PolSourceInactiveReasonEnumTextAndID;
polSourceInactiveReasonEnumTextAndID.HasErrors = false;
if (string.IsNullOrWhiteSpace(polSourceInactiveReasonEnumTextAndID.Text))
{
polSourceInactiveReasonEnumTextAndID.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "Text"), new[] { "Text" }));
}
//Text has no StringLength Attribute
if (polSourceInactiveReasonEnumTextAndID.ID < 1)
{
polSourceInactiveReasonEnumTextAndID.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MinValueIs_, "ID", "1"), new[] { "ID" }));
}
retStr = ""; // added to stop compiling CSSPError
if (retStr != "") // will never be true
{
polSourceInactiveReasonEnumTextAndID.HasErrors = true;
yield return(new ValidationResult("AAA", new[] { "AAA" }));
}
}
private IEnumerable <ValidationResult> Validate(ValidationContext validationContext, ActionDBTypeEnum actionDBType)
{
string retStr = "";
Enums enums = new Enums(LanguageRequest);
VPAmbient vpAmbient = validationContext.ObjectInstance as VPAmbient;
vpAmbient.HasErrors = false;
if (actionDBType == ActionDBTypeEnum.Update || actionDBType == ActionDBTypeEnum.Delete)
{
if (vpAmbient.VPAmbientID == 0)
{
vpAmbient.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "VPAmbientID"), new[] { "VPAmbientID" }));
}
if (!(from c in db.VPAmbients select c).Where(c => c.VPAmbientID == vpAmbient.VPAmbientID).Any())
{
vpAmbient.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "VPAmbient", "VPAmbientID", vpAmbient.VPAmbientID.ToString()), new[] { "VPAmbientID" }));
}
}
VPScenario VPScenarioVPScenarioID = (from c in db.VPScenarios where c.VPScenarioID == vpAmbient.VPScenarioID select c).FirstOrDefault();
if (VPScenarioVPScenarioID == null)
{
vpAmbient.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "VPScenario", "VPScenarioID", vpAmbient.VPScenarioID.ToString()), new[] { "VPScenarioID" }));
}
if (vpAmbient.Row < 0 || vpAmbient.Row > 10)
{
vpAmbient.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Row", "0", "10"), new[] { "Row" }));
}
if (vpAmbient.MeasurementDepth_m != null)
{
if (vpAmbient.MeasurementDepth_m < 0 || vpAmbient.MeasurementDepth_m > 1000)
{
vpAmbient.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "MeasurementDepth_m", "0", "1000"), new[] { "MeasurementDepth_m" }));
}
}
if (vpAmbient.CurrentSpeed_m_s != null)
{
if (vpAmbient.CurrentSpeed_m_s < 0 || vpAmbient.CurrentSpeed_m_s > 10)
{
vpAmbient.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "CurrentSpeed_m_s", "0", "10"), new[] { "CurrentSpeed_m_s" }));
}
}
if (vpAmbient.CurrentDirection_deg != null)
{
if (vpAmbient.CurrentDirection_deg < -180 || vpAmbient.CurrentDirection_deg > 180)
{
vpAmbient.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "CurrentDirection_deg", "-180", "180"), new[] { "CurrentDirection_deg" }));
}
}
if (vpAmbient.AmbientSalinity_PSU != null)
{
if (vpAmbient.AmbientSalinity_PSU < 0 || vpAmbient.AmbientSalinity_PSU > 40)
{
vpAmbient.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "AmbientSalinity_PSU", "0", "40"), new[] { "AmbientSalinity_PSU" }));
}
}
if (vpAmbient.AmbientTemperature_C != null)
{
if (vpAmbient.AmbientTemperature_C < -10 || vpAmbient.AmbientTemperature_C > 40)
{
vpAmbient.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "AmbientTemperature_C", "-10", "40"), new[] { "AmbientTemperature_C" }));
}
}
if (vpAmbient.BackgroundConcentration_MPN_100ml != null)
{
if (vpAmbient.BackgroundConcentration_MPN_100ml < 0 || vpAmbient.BackgroundConcentration_MPN_100ml > 10000000)
{
vpAmbient.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "BackgroundConcentration_MPN_100ml", "0", "10000000"), new[] { "BackgroundConcentration_MPN_100ml" }));
}
}
if (vpAmbient.PollutantDecayRate_per_day != null)
{
if (vpAmbient.PollutantDecayRate_per_day < 0 || vpAmbient.PollutantDecayRate_per_day > 100)
{
vpAmbient.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "PollutantDecayRate_per_day", "0", "100"), new[] { "PollutantDecayRate_per_day" }));
}
}
if (vpAmbient.FarFieldCurrentSpeed_m_s != null)
{
if (vpAmbient.FarFieldCurrentSpeed_m_s < 0 || vpAmbient.FarFieldCurrentSpeed_m_s > 10)
{
vpAmbient.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "FarFieldCurrentSpeed_m_s", "0", "10"), new[] { "FarFieldCurrentSpeed_m_s" }));
}
}
if (vpAmbient.FarFieldCurrentDirection_deg != null)
{
if (vpAmbient.FarFieldCurrentDirection_deg < -180 || vpAmbient.FarFieldCurrentDirection_deg > 180)
{
vpAmbient.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "FarFieldCurrentDirection_deg", "-180", "180"), new[] { "FarFieldCurrentDirection_deg" }));
}
}
if (vpAmbient.FarFieldDiffusionCoefficient != null)
{
if (vpAmbient.FarFieldDiffusionCoefficient < 0 || vpAmbient.FarFieldDiffusionCoefficient > 1)
{
vpAmbient.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "FarFieldDiffusionCoefficient", "0", "1"), new[] { "FarFieldDiffusionCoefficient" }));
}
}
if (vpAmbient.LastUpdateDate_UTC.Year == 1)
{
vpAmbient.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "LastUpdateDate_UTC"), new[] { "LastUpdateDate_UTC" }));
}
else
{
if (vpAmbient.LastUpdateDate_UTC.Year < 1980)
{
vpAmbient.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 == vpAmbient.LastUpdateContactTVItemID select c).FirstOrDefault();
if (TVItemLastUpdateContactTVItemID == null)
{
vpAmbient.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "LastUpdateContactTVItemID", vpAmbient.LastUpdateContactTVItemID.ToString()), new[] { "LastUpdateContactTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.Contact,
};
if (!AllowableTVTypes.Contains(TVItemLastUpdateContactTVItemID.TVType))
{
vpAmbient.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
{
vpAmbient.HasErrors = true;
yield return(new ValidationResult("AAA", new[] { "AAA" }));
}
}
private IEnumerable <ValidationResult> Validate(ValidationContext validationContext, ActionDBTypeEnum actionDBType)
{
string retStr = "";
Enums enums = new Enums(LanguageRequest);
MWQMSampleDuplicateItem mwqmSampleDuplicateItem = validationContext.ObjectInstance as MWQMSampleDuplicateItem;
mwqmSampleDuplicateItem.HasErrors = false;
if (string.IsNullOrWhiteSpace(mwqmSampleDuplicateItem.ParentSite))
{
mwqmSampleDuplicateItem.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "ParentSite"), new[] { "ParentSite" }));
}
if (!string.IsNullOrWhiteSpace(mwqmSampleDuplicateItem.ParentSite) && (mwqmSampleDuplicateItem.ParentSite.Length < 1 || mwqmSampleDuplicateItem.ParentSite.Length > 200))
{
mwqmSampleDuplicateItem.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._LengthShouldBeBetween_And_, "ParentSite", "1", "200"), new[] { "ParentSite" }));
}
if (string.IsNullOrWhiteSpace(mwqmSampleDuplicateItem.DuplicateSite))
{
mwqmSampleDuplicateItem.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "DuplicateSite"), new[] { "DuplicateSite" }));
}
if (!string.IsNullOrWhiteSpace(mwqmSampleDuplicateItem.DuplicateSite) && (mwqmSampleDuplicateItem.DuplicateSite.Length < 1 || mwqmSampleDuplicateItem.DuplicateSite.Length > 200))
{
mwqmSampleDuplicateItem.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._LengthShouldBeBetween_And_, "DuplicateSite", "1", "200"), new[] { "DuplicateSite" }));
}
retStr = ""; // added to stop compiling CSSPError
if (retStr != "") // will never be true
{
mwqmSampleDuplicateItem.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);
PolSourceSiteEffectTerm polSourceSiteEffectTerm = validationContext.ObjectInstance as PolSourceSiteEffectTerm;
polSourceSiteEffectTerm.HasErrors = false;
if (actionDBType == ActionDBTypeEnum.Update || actionDBType == ActionDBTypeEnum.Delete)
{
if (polSourceSiteEffectTerm.PolSourceSiteEffectTermID == 0)
{
polSourceSiteEffectTerm.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "PolSourceSiteEffectTermID"), new[] { "PolSourceSiteEffectTermID" }));
}
if (!(from c in db.PolSourceSiteEffectTerms select c).Where(c => c.PolSourceSiteEffectTermID == polSourceSiteEffectTerm.PolSourceSiteEffectTermID).Any())
{
polSourceSiteEffectTerm.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "PolSourceSiteEffectTerm", "PolSourceSiteEffectTermID", polSourceSiteEffectTerm.PolSourceSiteEffectTermID.ToString()), new[] { "PolSourceSiteEffectTermID" }));
}
}
if (polSourceSiteEffectTerm.UnderGroupID != null)
{
PolSourceSiteEffectTerm PolSourceSiteEffectTermUnderGroupID = (from c in db.PolSourceSiteEffectTerms where c.PolSourceSiteEffectTermID == polSourceSiteEffectTerm.UnderGroupID select c).FirstOrDefault();
if (PolSourceSiteEffectTermUnderGroupID == null)
{
polSourceSiteEffectTerm.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "PolSourceSiteEffectTerm", "UnderGroupID", (polSourceSiteEffectTerm.UnderGroupID == null ? "" : polSourceSiteEffectTerm.UnderGroupID.ToString())), new[] { "UnderGroupID" }));
}
}
if (string.IsNullOrWhiteSpace(polSourceSiteEffectTerm.EffectTermEN))
{
polSourceSiteEffectTerm.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "EffectTermEN"), new[] { "EffectTermEN" }));
}
if (!string.IsNullOrWhiteSpace(polSourceSiteEffectTerm.EffectTermEN) && polSourceSiteEffectTerm.EffectTermEN.Length > 100)
{
polSourceSiteEffectTerm.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "EffectTermEN", "100"), new[] { "EffectTermEN" }));
}
if (string.IsNullOrWhiteSpace(polSourceSiteEffectTerm.EffectTermFR))
{
polSourceSiteEffectTerm.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "EffectTermFR"), new[] { "EffectTermFR" }));
}
if (!string.IsNullOrWhiteSpace(polSourceSiteEffectTerm.EffectTermFR) && polSourceSiteEffectTerm.EffectTermFR.Length > 100)
{
polSourceSiteEffectTerm.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "EffectTermFR", "100"), new[] { "EffectTermFR" }));
}
if (polSourceSiteEffectTerm.LastUpdateDate_UTC.Year == 1)
{
polSourceSiteEffectTerm.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "LastUpdateDate_UTC"), new[] { "LastUpdateDate_UTC" }));
}
else
{
if (polSourceSiteEffectTerm.LastUpdateDate_UTC.Year < 1980)
{
polSourceSiteEffectTerm.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 == polSourceSiteEffectTerm.LastUpdateContactTVItemID select c).FirstOrDefault();
if (TVItemLastUpdateContactTVItemID == null)
{
polSourceSiteEffectTerm.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "LastUpdateContactTVItemID", polSourceSiteEffectTerm.LastUpdateContactTVItemID.ToString()), new[] { "LastUpdateContactTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.Contact,
};
if (!AllowableTVTypes.Contains(TVItemLastUpdateContactTVItemID.TVType))
{
polSourceSiteEffectTerm.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
{
polSourceSiteEffectTerm.HasErrors = true;
yield return(new ValidationResult("AAA", new[] { "AAA" }));
}
}
