static void Main(string[] args)
{
IEnumerable <Item> xmlItems = GetItemsFromXml();
IEnumerable <TVItem> dbItems = GetItemsFromDb();
var repo = new TVItemsRepository(Properties.Settings.Default.ConStr);
repo.ClearChangeLogs();
Console.WriteLine("Checking xml items against db items");
int counter = 0;
foreach (Item xmlItem in xmlItems)
{
counter++;
if (counter % 1000 == 0)
{
Console.WriteLine(counter);
}
TVItem dbItem = dbItems.FirstOrDefault(t => t.ItemNumber == xmlItem.ItemNumber);
if (dbItem == null)
{
repo.AddNewItemChangeLog(xmlItem.ItemNumber);
repo.AddItem(ConvertToTVItem(xmlItem));
}
else
{
var changes = GetChanges(dbItem, xmlItem);
if (changes.Any())
{
foreach (var change in changes)
{
repo.ChangeItemChangeLog(change);
}
repo.UpdateItem(ConvertToTVItem(xmlItem));
}
}
}
counter = 0;
Console.WriteLine("Checking db items against xml items");
foreach (TVItem dbItem in dbItems)
{
counter++;
if (counter % 1000 == 0)
{
Console.WriteLine(counter);
}
Item xmlItem = xmlItems.FirstOrDefault(t => t.ItemNumber == dbItem.ItemNumber);
if (xmlItem == null)
{
repo.RemoveItemChangeLog(dbItem.ItemNumber);
repo.DeleteItem(dbItem.ItemNumber);
}
}
Console.WriteLine("Done");
Console.ReadKey(true);
}
private TVItem GetFilledRandomTVItem(string OmitPropName)
{
TVItem tvItem = new TVItem();
if (OmitPropName != "TVLevel")
{
tvItem.TVLevel = GetRandomInt(0, 100);
}
if (OmitPropName != "TVPath")
{
tvItem.TVPath = GetRandomString("", 5);
}
if (OmitPropName != "TVType")
{
tvItem.TVType = (TVTypeEnum)GetRandomEnumType(typeof(TVTypeEnum));
}
if (OmitPropName != "ParentID")
{
tvItem.ParentID = 1;
}
if (OmitPropName != "IsActive")
{
tvItem.IsActive = true;
}
if (OmitPropName != "LastUpdateDate_UTC")
{
tvItem.LastUpdateDate_UTC = new DateTime(2005, 3, 6);
}
if (OmitPropName != "LastUpdateContactTVItemID")
{
tvItem.LastUpdateContactTVItemID = 2;
}
return(tvItem);
}
public void TVItemSubsectorAndMWQMSite_Every_Property_Has_Get_Set_Test()
{
TVItem val1 = new TVItem();
tVItemSubsectorAndMWQMSite.TVItemSubsector = val1;
Assert.AreEqual(val1, tVItemSubsectorAndMWQMSite.TVItemSubsector);
List <TVItem> val2 = new List <TVItem>()
{
new TVItem(), new TVItem()
};
tVItemSubsectorAndMWQMSite.TVItemMWQMSiteList = val2;
Assert.AreEqual(val2, tVItemSubsectorAndMWQMSite.TVItemMWQMSiteList);
TVItem val3 = new TVItem();
tVItemSubsectorAndMWQMSite.TVItemMWQMSiteDuplicate = val3;
Assert.AreEqual(val3, tVItemSubsectorAndMWQMSite.TVItemMWQMSiteDuplicate);
bool val4 = true;
tVItemSubsectorAndMWQMSite.HasErrors = val4;
Assert.AreEqual(val4, tVItemSubsectorAndMWQMSite.HasErrors);
IEnumerable <ValidationResult> val15 = new List <ValidationResult>()
{
new ValidationResult("First CSSPError Message")
}.AsEnumerable();
tVItemSubsectorAndMWQMSite.ValidationResults = val15;
Assert.AreEqual(val15, tVItemSubsectorAndMWQMSite.ValidationResults);
}
private static void Main(string[] args)
{
var xmlItems = GetItemsFromXml("tv.xml");
var dbItems = GetItemsFromDb();
var repo = new TVItemsRepo(Properties.Settings.Default.ConStr);
repo.ClearChangeLogs();
int counter = 0;
foreach (Item xmlItem in xmlItems)
{
counter++;
if (counter % 1000 == 0)
{
Console.WriteLine("Chuggin along... " + counter);
}
TVItem dbItem = dbItems.FirstOrDefault(i => i.ItemNumber == xmlItem.ItemNumber);
if (dbItem == null)
{
repo.AddChangeLog(new ChangeLog
{
ItemNumber = xmlItem.ItemNumber,
Type = "New Item Added"
});
repo.AddItem(ConvertToDbItem(xmlItem));
}
else
{
IEnumerable <ChangeLog> changes = GetChanges(xmlItem, dbItem);
if (changes.Any())
{
foreach (ChangeLog change in changes)
{
repo.AddChangeLog(change);
}
repo.Update(ConvertToDbItem(xmlItem));
}
}
}
foreach (TVItem dbItem in dbItems)
{
Item xmlItem = xmlItems.FirstOrDefault(i => i.ItemNumber == dbItem.ItemNumber);
if (xmlItem == null)
{
repo.Delete(dbItem.ItemNumber);
repo.AddChangeLog(new ChangeLog
{
ItemNumber = dbItem.ItemNumber,
Type = "Item Removed"
});
}
}
Console.WriteLine("Done");
Console.ReadKey(true);
}
public TVClass()
{
TVItem tvi = new TVItem();
tvi.csspItem = new CSSPItem();
tvi.csspItemLanguage = new CSSPItemLanguage();
tvi.csspTypeItem = new CSSPTypeItem();
tvi.csspTypeItemLanguage = new CSSPTypeItemLanguage();
}
public void TVItem_Controller_Put_Test()
{
foreach (LanguageEnum LanguageRequest in AllowableLanguages)
{
foreach (int ContactID in new List <int>()
{
AdminContactID
}) //, TestEmailValidatedContactID, TestEmailNotValidatedContactID })
{
TVItemController tvItemController = new TVItemController(DatabaseTypeEnum.SqlServerTestDB);
Assert.IsNotNull(tvItemController);
Assert.AreEqual(DatabaseTypeEnum.SqlServerTestDB, tvItemController.DatabaseType);
TVItem tvItemLast = new TVItem();
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
Query query = new Query();
query.Language = LanguageRequest;
TVItemService tvItemService = new TVItemService(query, db, ContactID);
tvItemLast = (from c in db.TVItems select c).LastOrDefault();
}
// ok with TVItem info
IHttpActionResult jsonRet = tvItemController.GetTVItemWithID(tvItemLast.TVItemID);
Assert.IsNotNull(jsonRet);
OkNegotiatedContentResult <TVItem> Ret = jsonRet as OkNegotiatedContentResult <TVItem>;
TVItem tvItemRet = Ret.Content;
Assert.AreEqual(tvItemLast.TVItemID, tvItemRet.TVItemID);
BadRequestErrorMessageResult badRequest = jsonRet as BadRequestErrorMessageResult;
Assert.IsNull(badRequest);
// Put to return success
IHttpActionResult jsonRet2 = tvItemController.Put(tvItemRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet2);
OkNegotiatedContentResult <TVItem> tvItemRet2 = jsonRet2 as OkNegotiatedContentResult <TVItem>;
Assert.IsNotNull(tvItemRet2);
BadRequestErrorMessageResult badRequest2 = jsonRet2 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest2);
// Put to return CSSPError because TVItemID of 0 does not exist
tvItemRet.TVItemID = 0;
IHttpActionResult jsonRet3 = tvItemController.Put(tvItemRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet3);
OkNegotiatedContentResult <TVItem> tvItemRet3 = jsonRet3 as OkNegotiatedContentResult <TVItem>;
Assert.IsNull(tvItemRet3);
BadRequestErrorMessageResult badRequest3 = jsonRet3 as BadRequestErrorMessageResult;
Assert.IsNotNull(badRequest3);
}
}
}
private static TVItem ConvertToTVItem(Item xmlItem)
{
var result = new TVItem();
foreach (PropertyInfo prop in xmlItem.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public))
{
var value = prop.GetValue(xmlItem);
result.GetType().GetProperty(prop.Name).SetValue(result, value);
}
return(result);
}
public void TVItem_CRUD_Test()
{
foreach (CultureInfo culture in AllowableCulture)
{
ChangeCulture(culture);
using (CSSPDBContext dbTestDB = new CSSPDBContext(DatabaseTypeEnum.SqlServerTestDB))
{
TVItemService tvItemService = new TVItemService(new Query()
{
Lang = culture.TwoLetterISOLanguageName
}, dbTestDB, ContactID);
int count = 0;
if (count == 1)
{
// just so we don't get a warning during compile [The variable 'count' is assigned but its value is never used]
}
TVItem tvItem = GetFilledRandomTVItem("");
// -------------------------------
// -------------------------------
// CRUD testing
// -------------------------------
// -------------------------------
count = tvItemService.GetTVItemList().Count();
Assert.AreEqual(count, (from c in dbTestDB.TVItems select c).Count());
tvItemService.Add(tvItem);
if (tvItem.HasErrors)
{
Assert.AreEqual("", tvItem.ValidationResults.FirstOrDefault().ErrorMessage);
}
Assert.AreEqual(true, tvItemService.GetTVItemList().Where(c => c == tvItem).Any());
tvItemService.Update(tvItem);
if (tvItem.HasErrors)
{
Assert.AreEqual("", tvItem.ValidationResults.FirstOrDefault().ErrorMessage);
}
Assert.AreEqual(count + 1, tvItemService.GetTVItemList().Count());
tvItemService.Delete(tvItem);
if (tvItem.HasErrors)
{
Assert.AreEqual("", tvItem.ValidationResults.FirstOrDefault().ErrorMessage);
}
Assert.AreEqual(count, tvItemService.GetTVItemList().Count());
}
}
}
public IHttpActionResult GetTVItemWithID([FromUri] int TVItemID, [FromUri] string lang = "en", [FromUri] string extra = "")
{
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
TVItemService tvItemService = new TVItemService(new Query()
{
Language = (lang == "fr" ? LanguageEnum.fr : LanguageEnum.en)
}, db, ContactID);
tvItemService.Query = tvItemService.FillQuery(typeof(TVItem), lang, 0, 1, "", "", extra);
if (tvItemService.Query.Extra == "A")
{
TVItemExtraA tvItemExtraA = new TVItemExtraA();
tvItemExtraA = tvItemService.GetTVItemExtraAWithTVItemID(TVItemID);
if (tvItemExtraA == null)
{
return(NotFound());
}
return(Ok(tvItemExtraA));
}
else if (tvItemService.Query.Extra == "B")
{
TVItemExtraB tvItemExtraB = new TVItemExtraB();
tvItemExtraB = tvItemService.GetTVItemExtraBWithTVItemID(TVItemID);
if (tvItemExtraB == null)
{
return(NotFound());
}
return(Ok(tvItemExtraB));
}
else
{
TVItem tvItem = new TVItem();
tvItem = tvItemService.GetTVItemWithTVItemID(TVItemID);
if (tvItem == null)
{
return(NotFound());
}
return(Ok(tvItem));
}
}
}
public TVItemModel ToggleUseForOpenDataFlagOfAllSamplesUnderMWQMSiteTVItemIDDB(int MWQMSiteTVItemID, DateTime StartDate, DateTime EndDate, bool UseForOpenData)
{
string RoutineTxt = ((int)SampleTypeEnum.Routine).ToString() + ",";
TVItem tvItemSite = new TVItem();
using (CSSPDBEntities dd = new CSSPDBEntities())
{
tvItemSite = (from c in dd.TVItems
where c.TVItemID == MWQMSiteTVItemID
select c).FirstOrDefault();
}
if (tvItemSite == null)
{
return(ReturnError(string.Format(ServiceRes.CouldNotFind_With_Equal_, ServiceRes.MWQMSite, ServiceRes.MWQMSiteTVItemID, MWQMSiteTVItemID.ToString())));
}
using (CSSPDBEntities dd = new CSSPDBEntities())
{
List <MWQMSample> mwqmSampleList = (from t in dd.TVItems
from s in dd.MWQMSamples
where t.TVItemID == s.MWQMSiteTVItemID &&
t.TVItemID == MWQMSiteTVItemID &&
t.TVType == (int)TVTypeEnum.MWQMSite &&
s.SampleTypesText.Contains(RoutineTxt) &&
s.UseForOpenData == !UseForOpenData &&
s.SampleDateTime_Local >= StartDate &&
s.SampleDateTime_Local <= EndDate
select s).ToList();
foreach (MWQMSample mwqmSample in mwqmSampleList)
{
mwqmSample.UseForOpenData = UseForOpenData;
}
try
{
dd.SaveChanges();
}
catch (Exception ex)
{
return(ReturnError(string.Format(ServiceRes.CouldNotUpdateError_, ex.Message + " InnerException: " + (ex.InnerException != null ? ex.InnerException.Message : ""))));
}
}
return(ReturnError(""));
}
/// <summary>
/// Updates an [TVItem](CSSPModels.TVItem.html) item in CSSPDB
/// </summary>
/// <param name="tvItem">Is the TVItem item the client want to add to CSSPDB. What's important here is the TVItemID</param>
/// <returns>true if TVItem item was updated to CSSPDB, false if an error happened during the DB requested transtaction</returns>
public bool Update(TVItem tvItem)
{
tvItem.ValidationResults = Validate(new ValidationContext(tvItem), ActionDBTypeEnum.Update);
if (tvItem.ValidationResults.Count() > 0)
{
return(false);
}
db.TVItems.Update(tvItem);
if (!TryToSave(tvItem))
{
return(false);
}
return(true);
}
/// <summary>
/// Tries to execute the CSSPDB transaction (add/delete/update) on an [TVItem](CSSPModels.TVItem.html) item
/// </summary>
/// <param name="tvItem">Is the TVItem item the client want to add to CSSPDB. What's important here is the TVItemID</param>
/// <returns>true if TVItem item was updated to CSSPDB, false if an error happened during the DB requested transtaction</returns>
private bool TryToSave(TVItem tvItem)
{
try
{
db.SaveChanges();
}
catch (DbUpdateException ex)
{
tvItem.ValidationResults = new List <ValidationResult>()
{
new ValidationResult(ex.Message + (ex.InnerException != null ? " Inner: " + ex.InnerException.Message : ""))
}.AsEnumerable();
return(false);
}
return(true);
}
public void TVItem_Controller_GetTVItemWithID_Test()
{
foreach (LanguageEnum LanguageRequest in AllowableLanguages)
{
foreach (int ContactID in new List <int>()
{
AdminContactID
}) //, TestEmailValidatedContactID, TestEmailNotValidatedContactID })
{
TVItemController tvItemController = new TVItemController(DatabaseTypeEnum.SqlServerTestDB);
Assert.IsNotNull(tvItemController);
Assert.AreEqual(DatabaseTypeEnum.SqlServerTestDB, tvItemController.DatabaseType);
TVItem tvItemFirst = new TVItem();
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
TVItemService tvItemService = new TVItemService(new Query(), db, ContactID);
tvItemFirst = (from c in db.TVItems select c).FirstOrDefault();
}
// ok with TVItem info
IHttpActionResult jsonRet = tvItemController.GetTVItemWithID(tvItemFirst.TVItemID);
Assert.IsNotNull(jsonRet);
OkNegotiatedContentResult <TVItem> Ret = jsonRet as OkNegotiatedContentResult <TVItem>;
TVItem tvItemRet = Ret.Content;
Assert.AreEqual(tvItemFirst.TVItemID, tvItemRet.TVItemID);
BadRequestErrorMessageResult badRequest = jsonRet as BadRequestErrorMessageResult;
Assert.IsNull(badRequest);
// Not Found
IHttpActionResult jsonRet2 = tvItemController.GetTVItemWithID(0);
Assert.IsNotNull(jsonRet2);
OkNegotiatedContentResult <TVItem> tvItemRet2 = jsonRet2 as OkNegotiatedContentResult <TVItem>;
Assert.IsNull(tvItemRet2);
NotFoundResult notFoundRequest = jsonRet2 as NotFoundResult;
Assert.IsNotNull(notFoundRequest);
}
}
}
public IHttpActionResult Delete([FromBody] TVItem tvItem, [FromUri] string lang = "en")
{
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
TVItemService tvItemService = new TVItemService(new Query()
{
Language = (lang == "fr" ? LanguageEnum.fr : LanguageEnum.en)
}, db, ContactID);
if (!tvItemService.Delete(tvItem))
{
return(BadRequest(String.Join("|||", tvItem.ValidationResults)));
}
else
{
tvItem.ValidationResults = null;
return(Ok(tvItem));
}
}
}
public void TVItemInfrastructureTypeTVItemLink_Every_Property_Has_Get_Set_Test()
{
InfrastructureTypeEnum val1 = (InfrastructureTypeEnum)3;
tVItemInfrastructureTypeTVItemLink.InfrastructureType = val1;
Assert.AreEqual(val1, tVItemInfrastructureTypeTVItemLink.InfrastructureType);
int val2 = 45;
tVItemInfrastructureTypeTVItemLink.SeeOtherMunicipalityTVItemID = val2;
Assert.AreEqual(val2, tVItemInfrastructureTypeTVItemLink.SeeOtherMunicipalityTVItemID);
string val3 = "Some text";
tVItemInfrastructureTypeTVItemLink.InfrastructureTypeText = val3;
Assert.AreEqual(val3, tVItemInfrastructureTypeTVItemLink.InfrastructureTypeText);
TVItem val4 = new TVItem();
tVItemInfrastructureTypeTVItemLink.TVItem = val4;
Assert.AreEqual(val4, tVItemInfrastructureTypeTVItemLink.TVItem);
List <TVItemLink> val5 = new List <TVItemLink>()
{
new TVItemLink(), new TVItemLink()
};
tVItemInfrastructureTypeTVItemLink.TVItemLinkList = val5;
Assert.AreEqual(val5, tVItemInfrastructureTypeTVItemLink.TVItemLinkList);
TVItemInfrastructureTypeTVItemLink val6 = new TVItemInfrastructureTypeTVItemLink();
tVItemInfrastructureTypeTVItemLink.FlowTo = val6;
Assert.AreEqual(val6, tVItemInfrastructureTypeTVItemLink.FlowTo);
bool val7 = true;
tVItemInfrastructureTypeTVItemLink.HasErrors = val7;
Assert.AreEqual(val7, tVItemInfrastructureTypeTVItemLink.HasErrors);
IEnumerable <ValidationResult> val24 = new List <ValidationResult>()
{
new ValidationResult("First CSSPError Message")
}.AsEnumerable();
tVItemInfrastructureTypeTVItemLink.ValidationResults = val24;
Assert.AreEqual(val24, tVItemInfrastructureTypeTVItemLink.ValidationResults);
}
public void GetTVItemList_Test()
{
foreach (CultureInfo culture in AllowableCulture)
{
ChangeCulture(culture);
using (CSSPDBContext dbTestDB = new CSSPDBContext(DatabaseTypeEnum.SqlServerTestDB))
{
TVItemService tvItemService = new TVItemService(new Query()
{
Lang = culture.TwoLetterISOLanguageName
}, dbTestDB, ContactID);
TVItem tvItem = (from c in dbTestDB.TVItems select c).FirstOrDefault();
Assert.IsNotNull(tvItem);
List <TVItem> tvItemDirectQueryList = new List <TVItem>();
tvItemDirectQueryList = (from c in dbTestDB.TVItems select c).Take(200).ToList();
foreach (string extra in new List <string>()
{
null, "A", "B", "C", "D", "E"
})
{
tvItemService.Query.Extra = extra;
if (string.IsNullOrWhiteSpace(extra))
{
List <TVItem> tvItemList = new List <TVItem>();
tvItemList = tvItemService.GetTVItemList().ToList();
CheckTVItemFields(tvItemList);
}
else
{
//Assert.AreEqual(true, false);
}
}
}
}
}
private static IEnumerable <ChangeLog> GetChanges(TVItem dbItem, Item xmlItem)
{
List <ChangeLog> changeLogs = new List <ChangeLog>();
foreach (PropertyInfo prop in dbItem.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public))
{
var dbValue = prop.GetValue(dbItem);
var xmlValue = xmlItem.GetType().GetProperty(prop.Name).GetValue(xmlItem);
if (!object.Equals(dbValue, xmlValue))
{
ChangeLog changeLog = new ChangeLog
{
ChangeType = prop.Name,
ItemNumber = dbItem.ItemNumber,
FromValue = dbValue.ToString(),
ToValue = xmlValue.ToString()
};
changeLogs.Add(changeLog);
}
}
return(changeLogs);
}
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);
MWQMSample mwqmSample = validationContext.ObjectInstance as MWQMSample;
mwqmSample.HasErrors = false;
if (actionDBType == ActionDBTypeEnum.Update || actionDBType == ActionDBTypeEnum.Delete)
{
if (mwqmSample.MWQMSampleID == 0)
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "MWQMSampleID"), new[] { "MWQMSampleID" }));
}
if (!(from c in db.MWQMSamples select c).Where(c => c.MWQMSampleID == mwqmSample.MWQMSampleID).Any())
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "MWQMSample", "MWQMSampleID", mwqmSample.MWQMSampleID.ToString()), new[] { "MWQMSampleID" }));
}
}
TVItem TVItemMWQMSiteTVItemID = (from c in db.TVItems where c.TVItemID == mwqmSample.MWQMSiteTVItemID select c).FirstOrDefault();
if (TVItemMWQMSiteTVItemID == null)
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "MWQMSiteTVItemID", mwqmSample.MWQMSiteTVItemID.ToString()), new[] { "MWQMSiteTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.MWQMSite,
};
if (!AllowableTVTypes.Contains(TVItemMWQMSiteTVItemID.TVType))
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "MWQMSiteTVItemID", "MWQMSite"), new[] { "MWQMSiteTVItemID" }));
}
}
TVItem TVItemMWQMRunTVItemID = (from c in db.TVItems where c.TVItemID == mwqmSample.MWQMRunTVItemID select c).FirstOrDefault();
if (TVItemMWQMRunTVItemID == null)
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "MWQMRunTVItemID", mwqmSample.MWQMRunTVItemID.ToString()), new[] { "MWQMRunTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.MWQMRun,
};
if (!AllowableTVTypes.Contains(TVItemMWQMRunTVItemID.TVType))
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "MWQMRunTVItemID", "MWQMRun"), new[] { "MWQMRunTVItemID" }));
}
}
if (mwqmSample.SampleDateTime_Local.Year == 1)
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "SampleDateTime_Local"), new[] { "SampleDateTime_Local" }));
}
else
{
if (mwqmSample.SampleDateTime_Local.Year < 1980)
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "SampleDateTime_Local", "1980"), new[] { "SampleDateTime_Local" }));
}
}
if (!string.IsNullOrWhiteSpace(mwqmSample.TimeText) && mwqmSample.TimeText.Length > 6)
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "TimeText", "6"), new[] { "TimeText" }));
}
if (mwqmSample.Depth_m != null)
{
if (mwqmSample.Depth_m < 0 || mwqmSample.Depth_m > 1000)
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Depth_m", "0", "1000"), new[] { "Depth_m" }));
}
}
if (mwqmSample.FecCol_MPN_100ml < 0 || mwqmSample.FecCol_MPN_100ml > 10000000)
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "FecCol_MPN_100ml", "0", "10000000"), new[] { "FecCol_MPN_100ml" }));
}
if (mwqmSample.Salinity_PPT != null)
{
if (mwqmSample.Salinity_PPT < 0 || mwqmSample.Salinity_PPT > 40)
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Salinity_PPT", "0", "40"), new[] { "Salinity_PPT" }));
}
}
if (mwqmSample.WaterTemp_C != null)
{
if (mwqmSample.WaterTemp_C < -10 || mwqmSample.WaterTemp_C > 40)
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "WaterTemp_C", "-10", "40"), new[] { "WaterTemp_C" }));
}
}
if (mwqmSample.PH != null)
{
if (mwqmSample.PH < 0 || mwqmSample.PH > 14)
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "PH", "0", "14"), new[] { "PH" }));
}
}
if (string.IsNullOrWhiteSpace(mwqmSample.SampleTypesText))
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "SampleTypesText"), new[] { "SampleTypesText" }));
}
if (!string.IsNullOrWhiteSpace(mwqmSample.SampleTypesText) && mwqmSample.SampleTypesText.Length > 50)
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "SampleTypesText", "50"), new[] { "SampleTypesText" }));
}
if (mwqmSample.SampleType_old != null)
{
retStr = enums.EnumTypeOK(typeof(SampleTypeEnum), (int?)mwqmSample.SampleType_old);
if (mwqmSample.SampleType_old == null || !string.IsNullOrWhiteSpace(retStr))
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "SampleType_old"), new[] { "SampleType_old" }));
}
}
if (mwqmSample.Tube_10 != null)
{
if (mwqmSample.Tube_10 < 0 || mwqmSample.Tube_10 > 5)
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Tube_10", "0", "5"), new[] { "Tube_10" }));
}
}
if (mwqmSample.Tube_1_0 != null)
{
if (mwqmSample.Tube_1_0 < 0 || mwqmSample.Tube_1_0 > 5)
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Tube_1_0", "0", "5"), new[] { "Tube_1_0" }));
}
}
if (mwqmSample.Tube_0_1 != null)
{
if (mwqmSample.Tube_0_1 < 0 || mwqmSample.Tube_0_1 > 5)
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Tube_0_1", "0", "5"), new[] { "Tube_0_1" }));
}
}
if (!string.IsNullOrWhiteSpace(mwqmSample.ProcessedBy) && mwqmSample.ProcessedBy.Length > 10)
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "ProcessedBy", "10"), new[] { "ProcessedBy" }));
}
if (mwqmSample.LastUpdateDate_UTC.Year == 1)
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "LastUpdateDate_UTC"), new[] { "LastUpdateDate_UTC" }));
}
else
{
if (mwqmSample.LastUpdateDate_UTC.Year < 1980)
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "LastUpdateDate_UTC", "1980"), new[] { "LastUpdateDate_UTC" }));
}
}
TVItem TVItemLastUpdateContactTVItemID = (from c in db.TVItems where c.TVItemID == mwqmSample.LastUpdateContactTVItemID select c).FirstOrDefault();
if (TVItemLastUpdateContactTVItemID == null)
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "LastUpdateContactTVItemID", mwqmSample.LastUpdateContactTVItemID.ToString()), new[] { "LastUpdateContactTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.Contact,
};
if (!AllowableTVTypes.Contains(TVItemLastUpdateContactTVItemID.TVType))
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "LastUpdateContactTVItemID", "Contact"), new[] { "LastUpdateContactTVItemID" }));
}
}
retStr = ""; // added to stop compiling CSSPError
if (retStr != "") // will never be true
{
mwqmSample.HasErrors = true;
yield return(new ValidationResult("AAA", new[] { "AAA" }));
}
}
/// <summary>
/// Validate function for all 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);
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" }));
}
}
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);
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);
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" }));
}
}
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" }));
}
}
/// <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);
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);
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 static IEnumerable <ChangeLog> GetChanges(Item xmlItem, TVItem dbItem)
{
List <ChangeLog> changes = new List <ChangeLog>();
if (xmlItem.ClassCode != dbItem.ClassCode)
{
var change = GetChangeLog(xmlItem.ItemNumber, "ClassCode", dbItem.ClassCode.ToString(),
xmlItem.ClassCode.ToString());
changes.Add(change);
}
if (xmlItem.Height != dbItem.Height)
{
var change = GetChangeLog(xmlItem.ItemNumber, "Height", dbItem.Height.ToString(),
xmlItem.Height.ToString());
changes.Add(change);
}
if (xmlItem.Weight != dbItem.Weight)
{
var change = GetChangeLog(xmlItem.ItemNumber, "Weight", dbItem.Weight.ToString(),
xmlItem.Weight.ToString());
changes.Add(change);
}
if (xmlItem.Width != dbItem.Width)
{
var change = GetChangeLog(xmlItem.ItemNumber, "Width", dbItem.Width.ToString(),
xmlItem.Width.ToString());
changes.Add(change);
}
if (xmlItem.Length != dbItem.Length)
{
var change = GetChangeLog(xmlItem.ItemNumber, "Length", dbItem.Length.ToString(),
xmlItem.Length.ToString());
changes.Add(change);
}
if (xmlItem.MemberCost != dbItem.MemberCost)
{
var change = GetChangeLog(xmlItem.ItemNumber, "MemberCost", dbItem.MemberCost.ToString(),
xmlItem.MemberCost.ToString());
changes.Add(change);
}
if (xmlItem.SubclassCode != dbItem.SubClassCode)
{
var change = GetChangeLog(xmlItem.ItemNumber, "SubClassCode", dbItem.SubClassCode.ToString(),
xmlItem.SubclassCode.ToString());
changes.Add(change);
}
if (xmlItem.LongDescription != dbItem.LongDescription)
{
var change = GetChangeLog(xmlItem.ItemNumber, "LongDescription", dbItem.LongDescription.ToString(),
xmlItem.LongDescription.ToString());
changes.Add(change);
}
if (xmlItem.ShortDescription != dbItem.ShortDescription)
{
var change = GetChangeLog(xmlItem.ItemNumber, "ShortDescription", dbItem.ShortDescription.ToString(),
xmlItem.ShortDescription.ToString());
changes.Add(change);
}
if (xmlItem.Model != dbItem.Model)
{
var change = GetChangeLog(xmlItem.ItemNumber, "Model", dbItem.Model.ToString(),
xmlItem.Model.ToString());
changes.Add(change);
}
if (xmlItem.Upc != dbItem.Upc)
{
var change = GetChangeLog(xmlItem.ItemNumber, "Upc", dbItem.Upc.ToString(),
xmlItem.Upc.ToString());
changes.Add(change);
}
if (xmlItem.VendorName != dbItem.VendorName)
{
var change = GetChangeLog(xmlItem.ItemNumber, "VendorName", dbItem.VendorName.ToString(),
xmlItem.VendorName.ToString());
changes.Add(change);
}
return(changes);
}