private TideSite GetFilledRandomTideSite(string OmitPropName)
{
TideSite tideSite = new TideSite();
if (OmitPropName != "TideSiteTVItemID")
{
tideSite.TideSiteTVItemID = 38;
}
if (OmitPropName != "TideSiteName")
{
tideSite.TideSiteName = GetRandomString("", 5);
}
if (OmitPropName != "Province")
{
tideSite.Province = GetRandomString("", 2);
}
if (OmitPropName != "sid")
{
tideSite.sid = GetRandomInt(0, 10000);
}
if (OmitPropName != "Zone")
{
tideSite.Zone = GetRandomInt(0, 10000);
}
if (OmitPropName != "LastUpdateDate_UTC")
{
tideSite.LastUpdateDate_UTC = new DateTime(2005, 3, 6);
}
if (OmitPropName != "LastUpdateContactTVItemID")
{
tideSite.LastUpdateContactTVItemID = 2;
}
return(tideSite);
}
public TideSite GetTideSiteWithTideSiteIDDB(int TideSiteID)
{
TideSite TideSite = (from c in db.TideSites
where c.TideSiteID == TideSiteID
select c).FirstOrDefault <TideSite>();
return(TideSite);
}
public void TideSite_Controller_Put_Test()
{
foreach (LanguageEnum LanguageRequest in AllowableLanguages)
{
foreach (int ContactID in new List <int>()
{
AdminContactID
}) //, TestEmailValidatedContactID, TestEmailNotValidatedContactID })
{
TideSiteController tideSiteController = new TideSiteController(DatabaseTypeEnum.SqlServerTestDB);
Assert.IsNotNull(tideSiteController);
Assert.AreEqual(DatabaseTypeEnum.SqlServerTestDB, tideSiteController.DatabaseType);
TideSite tideSiteLast = new TideSite();
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
Query query = new Query();
query.Language = LanguageRequest;
TideSiteService tideSiteService = new TideSiteService(query, db, ContactID);
tideSiteLast = (from c in db.TideSites select c).FirstOrDefault();
}
// ok with TideSite info
IHttpActionResult jsonRet = tideSiteController.GetTideSiteWithID(tideSiteLast.TideSiteID);
Assert.IsNotNull(jsonRet);
OkNegotiatedContentResult <TideSite> Ret = jsonRet as OkNegotiatedContentResult <TideSite>;
TideSite tideSiteRet = Ret.Content;
Assert.AreEqual(tideSiteLast.TideSiteID, tideSiteRet.TideSiteID);
BadRequestErrorMessageResult badRequest = jsonRet as BadRequestErrorMessageResult;
Assert.IsNull(badRequest);
// Put to return success
IHttpActionResult jsonRet2 = tideSiteController.Put(tideSiteRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet2);
OkNegotiatedContentResult <TideSite> tideSiteRet2 = jsonRet2 as OkNegotiatedContentResult <TideSite>;
Assert.IsNotNull(tideSiteRet2);
BadRequestErrorMessageResult badRequest2 = jsonRet2 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest2);
// Put to return CSSPError because TideSiteID of 0 does not exist
tideSiteRet.TideSiteID = 0;
IHttpActionResult jsonRet3 = tideSiteController.Put(tideSiteRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet3);
OkNegotiatedContentResult <TideSite> tideSiteRet3 = jsonRet3 as OkNegotiatedContentResult <TideSite>;
Assert.IsNull(tideSiteRet3);
BadRequestErrorMessageResult badRequest3 = jsonRet3 as BadRequestErrorMessageResult;
Assert.IsNotNull(badRequest3);
}
}
}
public void TideSite_CRUD_Test()
{
foreach (CultureInfo culture in AllowableCulture)
{
ChangeCulture(culture);
using (CSSPDBContext dbTestDB = new CSSPDBContext(DatabaseTypeEnum.SqlServerTestDB))
{
TideSiteService tideSiteService = new TideSiteService(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]
}
TideSite tideSite = GetFilledRandomTideSite("");
// -------------------------------
// -------------------------------
// CRUD testing
// -------------------------------
// -------------------------------
count = tideSiteService.GetTideSiteList().Count();
Assert.AreEqual(count, (from c in dbTestDB.TideSites select c).Count());
tideSiteService.Add(tideSite);
if (tideSite.HasErrors)
{
Assert.AreEqual("", tideSite.ValidationResults.FirstOrDefault().ErrorMessage);
}
Assert.AreEqual(true, tideSiteService.GetTideSiteList().Where(c => c == tideSite).Any());
tideSiteService.Update(tideSite);
if (tideSite.HasErrors)
{
Assert.AreEqual("", tideSite.ValidationResults.FirstOrDefault().ErrorMessage);
}
Assert.AreEqual(count + 1, tideSiteService.GetTideSiteList().Count());
tideSiteService.Delete(tideSite);
if (tideSite.HasErrors)
{
Assert.AreEqual("", tideSite.ValidationResults.FirstOrDefault().ErrorMessage);
}
Assert.AreEqual(count, tideSiteService.GetTideSiteList().Count());
}
}
}
public TideSiteModel PostAddTideSiteDB(TideSiteModel tideSiteModel)
{
string retStr = TideSiteModelOK(tideSiteModel);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnTideSiteError(retStr));
}
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrEmpty(contactOK.Error))
{
return(ReturnTideSiteError(contactOK.Error));
}
TVItemModel tvItemModelExist = _TVItemService.GetTVItemModelWithTVItemIDDB(tideSiteModel.TideSiteTVItemID);
if (!string.IsNullOrWhiteSpace(tvItemModelExist.Error))
{
return(ReturnTideSiteError(tvItemModelExist.Error));
}
TideSite tideSiteNew = new TideSite();
retStr = FillTideSite(tideSiteNew, tideSiteModel, contactOK);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnTideSiteError(retStr));
}
using (TransactionScope ts = new TransactionScope())
{
db.TideSites.Add(tideSiteNew);
retStr = DoAddChanges();
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnTideSiteError(retStr));
}
LogModel logModel = _LogService.PostAddLogForObj("TideSites", tideSiteNew.TideSiteID, LogCommandEnum.Add, tideSiteNew);
if (!string.IsNullOrWhiteSpace(logModel.Error))
{
return(ReturnTideSiteError(logModel.Error));
}
ts.Complete();
}
return(GetTideSiteModelWithTideSiteIDDB(tideSiteNew.TideSiteID));
}
public IHttpActionResult GetTideSiteWithID([FromUri] int TideSiteID, [FromUri] string lang = "en", [FromUri] string extra = "")
{
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
TideSiteService tideSiteService = new TideSiteService(new Query()
{
Language = (lang == "fr" ? LanguageEnum.fr : LanguageEnum.en)
}, db, ContactID);
tideSiteService.Query = tideSiteService.FillQuery(typeof(TideSite), lang, 0, 1, "", "", extra);
if (tideSiteService.Query.Extra == "A")
{
TideSiteExtraA tideSiteExtraA = new TideSiteExtraA();
tideSiteExtraA = tideSiteService.GetTideSiteExtraAWithTideSiteID(TideSiteID);
if (tideSiteExtraA == null)
{
return(NotFound());
}
return(Ok(tideSiteExtraA));
}
else if (tideSiteService.Query.Extra == "B")
{
TideSiteExtraB tideSiteExtraB = new TideSiteExtraB();
tideSiteExtraB = tideSiteService.GetTideSiteExtraBWithTideSiteID(TideSiteID);
if (tideSiteExtraB == null)
{
return(NotFound());
}
return(Ok(tideSiteExtraB));
}
else
{
TideSite tideSite = new TideSite();
tideSite = tideSiteService.GetTideSiteWithTideSiteID(TideSiteID);
if (tideSite == null)
{
return(NotFound());
}
return(Ok(tideSite));
}
}
}
public TideSiteModel PostUpdateTideSiteDB(TideSiteModel tideSiteModel)
{
string retStr = TideSiteModelOK(tideSiteModel);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnTideSiteError(retStr));
}
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrEmpty(contactOK.Error))
{
return(ReturnTideSiteError(contactOK.Error));
}
TideSite tideSiteToUpdate = GetTideSiteWithTideSiteIDDB(tideSiteModel.TideSiteID);
if (tideSiteToUpdate == null)
{
return(ReturnTideSiteError(string.Format(ServiceRes.CouldNotFind_ToUpdate, ServiceRes.TideSite)));
}
retStr = FillTideSite(tideSiteToUpdate, tideSiteModel, contactOK);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnTideSiteError(retStr));
}
using (TransactionScope ts = new TransactionScope())
{
retStr = DoUpdateChanges();
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnTideSiteError(retStr));
}
LogModel logModel = _LogService.PostAddLogForObj("TideSites", tideSiteToUpdate.TideSiteID, LogCommandEnum.Change, tideSiteToUpdate);
if (!string.IsNullOrWhiteSpace(logModel.Error))
{
return(ReturnTideSiteError(logModel.Error));
}
ts.Complete();
}
return(GetTideSiteModelWithTideSiteIDDB(tideSiteToUpdate.TideSiteID));
}
private bool TryToSave(TideSite tideSite)
{
try
{
db.SaveChanges();
}
catch (DbUpdateException ex)
{
tideSite.ValidationResults = new List <ValidationResult>()
{
new ValidationResult(ex.Message + (ex.InnerException != null ? " Inner: " + ex.InnerException.Message : ""))
}.AsEnumerable();
return(false);
}
return(true);
}
public bool Update(TideSite tideSite)
{
tideSite.ValidationResults = Validate(new ValidationContext(tideSite), ActionDBTypeEnum.Update);
if (tideSite.ValidationResults.Count() > 0)
{
return(false);
}
db.TideSites.Update(tideSite);
if (!TryToSave(tideSite))
{
return(false);
}
return(true);
}
public TideSiteModel PostDeleteTideSiteDB(int TideSiteID)
{
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrEmpty(contactOK.Error))
{
return(ReturnTideSiteError(contactOK.Error));
}
TideSite tideSiteToDelete = GetTideSiteWithTideSiteIDDB(TideSiteID);
if (tideSiteToDelete == null)
{
return(ReturnTideSiteError(string.Format(ServiceRes.CouldNotFind_ToDelete, ServiceRes.TideSite)));
}
int TVItemIDToDelete = tideSiteToDelete.TideSiteTVItemID;
using (TransactionScope ts = new TransactionScope())
{
db.TideSites.Remove(tideSiteToDelete);
string retStr = DoDeleteChanges();
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnTideSiteError(retStr));
}
LogModel logModel = _LogService.PostAddLogForObj("TideSites", tideSiteToDelete.TideSiteID, LogCommandEnum.Delete, tideSiteToDelete);
if (!string.IsNullOrWhiteSpace(logModel.Error))
{
return(ReturnTideSiteError(logModel.Error));
}
TVItemModel tvItemModelRet = _TVItemService.PostDeleteTVItemWithTVItemIDDB(TVItemIDToDelete);
if (!string.IsNullOrWhiteSpace(tvItemModelRet.Error))
{
return(ReturnTideSiteError(tvItemModelRet.Error));
}
ts.Complete();
}
return(ReturnTideSiteError(""));
}
public void TideSite_Controller_GetTideSiteWithID_Test()
{
foreach (LanguageEnum LanguageRequest in AllowableLanguages)
{
foreach (int ContactID in new List <int>()
{
AdminContactID
}) //, TestEmailValidatedContactID, TestEmailNotValidatedContactID })
{
TideSiteController tideSiteController = new TideSiteController(DatabaseTypeEnum.SqlServerTestDB);
Assert.IsNotNull(tideSiteController);
Assert.AreEqual(DatabaseTypeEnum.SqlServerTestDB, tideSiteController.DatabaseType);
TideSite tideSiteFirst = new TideSite();
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
TideSiteService tideSiteService = new TideSiteService(new Query(), db, ContactID);
tideSiteFirst = (from c in db.TideSites select c).FirstOrDefault();
}
// ok with TideSite info
IHttpActionResult jsonRet = tideSiteController.GetTideSiteWithID(tideSiteFirst.TideSiteID);
Assert.IsNotNull(jsonRet);
OkNegotiatedContentResult <TideSite> Ret = jsonRet as OkNegotiatedContentResult <TideSite>;
TideSite tideSiteRet = Ret.Content;
Assert.AreEqual(tideSiteFirst.TideSiteID, tideSiteRet.TideSiteID);
BadRequestErrorMessageResult badRequest = jsonRet as BadRequestErrorMessageResult;
Assert.IsNull(badRequest);
// Not Found
IHttpActionResult jsonRet2 = tideSiteController.GetTideSiteWithID(0);
Assert.IsNotNull(jsonRet2);
OkNegotiatedContentResult <TideSite> tideSiteRet2 = jsonRet2 as OkNegotiatedContentResult <TideSite>;
Assert.IsNull(tideSiteRet2);
NotFoundResult notFoundRequest = jsonRet2 as NotFoundResult;
Assert.IsNotNull(notFoundRequest);
}
}
}
public IHttpActionResult Delete([FromBody] TideSite tideSite, [FromUri] string lang = "en")
{
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
TideSiteService tideSiteService = new TideSiteService(new Query()
{
Language = (lang == "fr" ? LanguageEnum.fr : LanguageEnum.en)
}, db, ContactID);
if (!tideSiteService.Delete(tideSite))
{
return(BadRequest(String.Join("|||", tideSite.ValidationResults)));
}
else
{
tideSite.ValidationResults = null;
return(Ok(tideSite));
}
}
}
// Fill
public string FillTideSite(TideSite tideSiteNew, TideSiteModel tideSiteModel, ContactOK contactOK)
{
tideSiteNew.DBCommand = (int)tideSiteModel.DBCommand;
tideSiteNew.TideSiteTVItemID = tideSiteModel.TideSiteTVItemID;
tideSiteNew.TideSiteName = tideSiteModel.TideSiteName;
tideSiteNew.Province = tideSiteModel.Province;
tideSiteNew.sid = tideSiteModel.sid;
tideSiteNew.Zone = tideSiteModel.Zone;
tideSiteNew.LastUpdateDate_UTC = DateTime.UtcNow;
if (contactOK == null)
{
tideSiteNew.LastUpdateContactTVItemID = 2;
}
else
{
tideSiteNew.LastUpdateContactTVItemID = contactOK.ContactTVItemID;
}
return("");
}
public void GetTideSiteList_Test()
{
foreach (CultureInfo culture in AllowableCulture)
{
ChangeCulture(culture);
using (CSSPDBContext dbTestDB = new CSSPDBContext(DatabaseTypeEnum.SqlServerTestDB))
{
TideSiteService tideSiteService = new TideSiteService(new Query()
{
Lang = culture.TwoLetterISOLanguageName
}, dbTestDB, ContactID);
TideSite tideSite = (from c in dbTestDB.TideSites select c).FirstOrDefault();
Assert.IsNotNull(tideSite);
List <TideSite> tideSiteDirectQueryList = new List <TideSite>();
tideSiteDirectQueryList = (from c in dbTestDB.TideSites select c).Take(200).ToList();
foreach (string extra in new List <string>()
{
null, "A", "B", "C", "D", "E"
})
{
tideSiteService.Query.Extra = extra;
if (string.IsNullOrWhiteSpace(extra))
{
List <TideSite> tideSiteList = new List <TideSite>();
tideSiteList = tideSiteService.GetTideSiteList().ToList();
CheckTideSiteFields(tideSiteList);
}
else
{
//Assert.AreEqual(true, false);
}
}
}
}
}
public void TideSite_Controller_GetTideSiteList_Test()
{
foreach (LanguageEnum LanguageRequest in AllowableLanguages)
{
foreach (int ContactID in new List <int>()
{
AdminContactID
}) //, TestEmailValidatedContactID, TestEmailNotValidatedContactID })
{
TideSiteController tideSiteController = new TideSiteController(DatabaseTypeEnum.SqlServerTestDB);
Assert.IsNotNull(tideSiteController);
Assert.AreEqual(DatabaseTypeEnum.SqlServerTestDB, tideSiteController.DatabaseType);
TideSite tideSiteFirst = new TideSite();
int count = -1;
Query query = new Query();
using (CSSPDBContext db = new CSSPDBContext(DatabaseTypeEnum.SqlServerTestDB))
{
TideSiteService tideSiteService = new TideSiteService(query, db, ContactID);
tideSiteFirst = (from c in db.TideSites select c).FirstOrDefault();
count = (from c in db.TideSites select c).Count();
count = (query.Take > count ? count : query.Take);
}
// ok with TideSite info
IHttpActionResult jsonRet = tideSiteController.GetTideSiteList();
Assert.IsNotNull(jsonRet);
OkNegotiatedContentResult <List <TideSite> > ret = jsonRet as OkNegotiatedContentResult <List <TideSite> >;
Assert.AreEqual(tideSiteFirst.TideSiteID, ret.Content[0].TideSiteID);
Assert.AreEqual((count > query.Take ? query.Take : count), ret.Content.Count);
List <TideSite> tideSiteList = new List <TideSite>();
count = -1;
query = new Query();
using (CSSPDBContext db = new CSSPDBContext(DatabaseTypeEnum.SqlServerTestDB))
{
TideSiteService tideSiteService = new TideSiteService(query, db, ContactID);
tideSiteList = (from c in db.TideSites select c).OrderBy(c => c.TideSiteID).Skip(0).Take(2).ToList();
count = (from c in db.TideSites select c).Count();
}
if (count > 0)
{
query.Skip = 0;
query.Take = 5;
count = (query.Take > count ? query.Take : count);
// ok with TideSite info
jsonRet = tideSiteController.GetTideSiteList(query.Language.ToString(), query.Skip, query.Take);
Assert.IsNotNull(jsonRet);
ret = jsonRet as OkNegotiatedContentResult <List <TideSite> >;
Assert.AreEqual(tideSiteList[0].TideSiteID, ret.Content[0].TideSiteID);
Assert.AreEqual((count > query.Take ? query.Take : count), ret.Content.Count);
if (count > 1)
{
query.Skip = 1;
query.Take = 5;
count = (query.Take > count ? query.Take : count);
// ok with TideSite info
IHttpActionResult jsonRet2 = tideSiteController.GetTideSiteList(query.Language.ToString(), query.Skip, query.Take);
Assert.IsNotNull(jsonRet2);
OkNegotiatedContentResult <List <TideSite> > ret2 = jsonRet2 as OkNegotiatedContentResult <List <TideSite> >;
Assert.AreEqual(tideSiteList[1].TideSiteID, ret2.Content[0].TideSiteID);
Assert.AreEqual((count > query.Take ? query.Take : count), ret2.Content.Count);
}
}
}
}
}
private IEnumerable <ValidationResult> Validate(ValidationContext validationContext, ActionDBTypeEnum actionDBType)
{
string retStr = "";
Enums enums = new Enums(LanguageRequest);
TideSite tideSite = validationContext.ObjectInstance as TideSite;
tideSite.HasErrors = false;
if (actionDBType == ActionDBTypeEnum.Update || actionDBType == ActionDBTypeEnum.Delete)
{
if (tideSite.TideSiteID == 0)
{
tideSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "TideSiteID"), new[] { "TideSiteID" }));
}
if (!(from c in db.TideSites select c).Where(c => c.TideSiteID == tideSite.TideSiteID).Any())
{
tideSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TideSite", "TideSiteID", tideSite.TideSiteID.ToString()), new[] { "TideSiteID" }));
}
}
TVItem TVItemTideSiteTVItemID = (from c in db.TVItems where c.TVItemID == tideSite.TideSiteTVItemID select c).FirstOrDefault();
if (TVItemTideSiteTVItemID == null)
{
tideSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "TideSiteTVItemID", tideSite.TideSiteTVItemID.ToString()), new[] { "TideSiteTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.TideSite,
};
if (!AllowableTVTypes.Contains(TVItemTideSiteTVItemID.TVType))
{
tideSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "TideSiteTVItemID", "TideSite"), new[] { "TideSiteTVItemID" }));
}
}
if (string.IsNullOrWhiteSpace(tideSite.TideSiteName))
{
tideSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "TideSiteName"), new[] { "TideSiteName" }));
}
if (!string.IsNullOrWhiteSpace(tideSite.TideSiteName) && tideSite.TideSiteName.Length > 100)
{
tideSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "TideSiteName", "100"), new[] { "TideSiteName" }));
}
if (string.IsNullOrWhiteSpace(tideSite.Province))
{
tideSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "Province"), new[] { "Province" }));
}
if (!string.IsNullOrWhiteSpace(tideSite.Province) && (tideSite.Province.Length < 2 || tideSite.Province.Length > 2))
{
tideSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._LengthShouldBeBetween_And_, "Province", "2", "2"), new[] { "Province" }));
}
if (tideSite.sid < 0 || tideSite.sid > 10000)
{
tideSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "sid", "0", "10000"), new[] { "sid" }));
}
if (tideSite.Zone < 0 || tideSite.Zone > 10000)
{
tideSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Zone", "0", "10000"), new[] { "Zone" }));
}
if (tideSite.LastUpdateDate_UTC.Year == 1)
{
tideSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "LastUpdateDate_UTC"), new[] { "LastUpdateDate_UTC" }));
}
else
{
if (tideSite.LastUpdateDate_UTC.Year < 1980)
{
tideSite.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 == tideSite.LastUpdateContactTVItemID select c).FirstOrDefault();
if (TVItemLastUpdateContactTVItemID == null)
{
tideSite.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "LastUpdateContactTVItemID", tideSite.LastUpdateContactTVItemID.ToString()), new[] { "LastUpdateContactTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.Contact,
};
if (!AllowableTVTypes.Contains(TVItemLastUpdateContactTVItemID.TVType))
{
tideSite.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
{
tideSite.HasErrors = true;
yield return(new ValidationResult("AAA", new[] { "AAA" }));
}
}
public TideSiteTest()
{
tideSite = new TideSite();
tideSiteExtraA = new TideSiteExtraA();
tideSiteExtraB = new TideSiteExtraB();
}
public void TideSite_Properties_Test()
{
foreach (CultureInfo culture in AllowableCulture)
{
ChangeCulture(culture);
using (CSSPDBContext dbTestDB = new CSSPDBContext(DatabaseTypeEnum.SqlServerTestDB))
{
TideSiteService tideSiteService = new TideSiteService(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]
}
count = tideSiteService.GetTideSiteList().Count();
TideSite tideSite = GetFilledRandomTideSite("");
// -------------------------------
// -------------------------------
// Properties testing
// -------------------------------
// -------------------------------
// -----------------------------------
// [Key]
// Is NOT Nullable
// tideSite.TideSiteID (Int32)
// -----------------------------------
tideSite = null;
tideSite = GetFilledRandomTideSite("");
tideSite.TideSiteID = 0;
tideSiteService.Update(tideSite);
Assert.AreEqual(string.Format(CSSPServicesRes._IsRequired, "TideSiteID"), tideSite.ValidationResults.FirstOrDefault().ErrorMessage);
tideSite = null;
tideSite = GetFilledRandomTideSite("");
tideSite.TideSiteID = 10000000;
tideSiteService.Update(tideSite);
Assert.AreEqual(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TideSite", "TideSiteID", tideSite.TideSiteID.ToString()), tideSite.ValidationResults.FirstOrDefault().ErrorMessage);
// -----------------------------------
// Is NOT Nullable
// [CSSPExist(ExistTypeName = "TVItem", ExistPlurial = "s", ExistFieldID = "TVItemID", AllowableTVtypeList = TideSite)]
// tideSite.TideSiteTVItemID (Int32)
// -----------------------------------
tideSite = null;
tideSite = GetFilledRandomTideSite("");
tideSite.TideSiteTVItemID = 0;
tideSiteService.Add(tideSite);
Assert.AreEqual(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "TideSiteTVItemID", tideSite.TideSiteTVItemID.ToString()), tideSite.ValidationResults.FirstOrDefault().ErrorMessage);
tideSite = null;
tideSite = GetFilledRandomTideSite("");
tideSite.TideSiteTVItemID = 1;
tideSiteService.Add(tideSite);
Assert.AreEqual(string.Format(CSSPServicesRes._IsNotOfType_, "TideSiteTVItemID", "TideSite"), tideSite.ValidationResults.FirstOrDefault().ErrorMessage);
// -----------------------------------
// Is NOT Nullable
// [StringLength(100))]
// tideSite.TideSiteName (String)
// -----------------------------------
tideSite = null;
tideSite = GetFilledRandomTideSite("TideSiteName");
Assert.AreEqual(false, tideSiteService.Add(tideSite));
Assert.AreEqual(1, tideSite.ValidationResults.Count());
Assert.IsTrue(tideSite.ValidationResults.Where(c => c.ErrorMessage == string.Format(CSSPServicesRes._IsRequired, "TideSiteName")).Any());
Assert.AreEqual(null, tideSite.TideSiteName);
Assert.AreEqual(count, tideSiteService.GetTideSiteList().Count());
tideSite = null;
tideSite = GetFilledRandomTideSite("");
tideSite.TideSiteName = GetRandomString("", 101);
Assert.AreEqual(false, tideSiteService.Add(tideSite));
Assert.AreEqual(string.Format(CSSPServicesRes._MaxLengthIs_, "TideSiteName", "100"), tideSite.ValidationResults.FirstOrDefault().ErrorMessage);
Assert.AreEqual(count, tideSiteService.GetTideSiteList().Count());
// -----------------------------------
// Is NOT Nullable
// [StringLength(2, MinimumLength = 2)]
// tideSite.Province (String)
// -----------------------------------
tideSite = null;
tideSite = GetFilledRandomTideSite("Province");
Assert.AreEqual(false, tideSiteService.Add(tideSite));
Assert.AreEqual(1, tideSite.ValidationResults.Count());
Assert.IsTrue(tideSite.ValidationResults.Where(c => c.ErrorMessage == string.Format(CSSPServicesRes._IsRequired, "Province")).Any());
Assert.AreEqual(null, tideSite.Province);
Assert.AreEqual(count, tideSiteService.GetTideSiteList().Count());
tideSite = null;
tideSite = GetFilledRandomTideSite("");
tideSite.Province = GetRandomString("", 1);
Assert.AreEqual(false, tideSiteService.Add(tideSite));
Assert.AreEqual(string.Format(CSSPServicesRes._LengthShouldBeBetween_And_, "Province", "2", "2"), tideSite.ValidationResults.FirstOrDefault().ErrorMessage);
Assert.AreEqual(count, tideSiteService.GetTideSiteList().Count());
tideSite = null;
tideSite = GetFilledRandomTideSite("");
tideSite.Province = GetRandomString("", 3);
Assert.AreEqual(false, tideSiteService.Add(tideSite));
Assert.AreEqual(string.Format(CSSPServicesRes._LengthShouldBeBetween_And_, "Province", "2", "2"), tideSite.ValidationResults.FirstOrDefault().ErrorMessage);
Assert.AreEqual(count, tideSiteService.GetTideSiteList().Count());
// -----------------------------------
// Is NOT Nullable
// [Range(0, 10000)]
// tideSite.sid (Int32)
// -----------------------------------
tideSite = null;
tideSite = GetFilledRandomTideSite("");
tideSite.sid = -1;
Assert.AreEqual(false, tideSiteService.Add(tideSite));
Assert.AreEqual(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "sid", "0", "10000"), tideSite.ValidationResults.FirstOrDefault().ErrorMessage);
Assert.AreEqual(count, tideSiteService.GetTideSiteList().Count());
tideSite = null;
tideSite = GetFilledRandomTideSite("");
tideSite.sid = 10001;
Assert.AreEqual(false, tideSiteService.Add(tideSite));
Assert.AreEqual(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "sid", "0", "10000"), tideSite.ValidationResults.FirstOrDefault().ErrorMessage);
Assert.AreEqual(count, tideSiteService.GetTideSiteList().Count());
// -----------------------------------
// Is NOT Nullable
// [Range(0, 10000)]
// tideSite.Zone (Int32)
// -----------------------------------
tideSite = null;
tideSite = GetFilledRandomTideSite("");
tideSite.Zone = -1;
Assert.AreEqual(false, tideSiteService.Add(tideSite));
Assert.AreEqual(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Zone", "0", "10000"), tideSite.ValidationResults.FirstOrDefault().ErrorMessage);
Assert.AreEqual(count, tideSiteService.GetTideSiteList().Count());
tideSite = null;
tideSite = GetFilledRandomTideSite("");
tideSite.Zone = 10001;
Assert.AreEqual(false, tideSiteService.Add(tideSite));
Assert.AreEqual(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Zone", "0", "10000"), tideSite.ValidationResults.FirstOrDefault().ErrorMessage);
Assert.AreEqual(count, tideSiteService.GetTideSiteList().Count());
// -----------------------------------
// Is NOT Nullable
// [CSSPAfter(Year = 1980)]
// tideSite.LastUpdateDate_UTC (DateTime)
// -----------------------------------
tideSite = null;
tideSite = GetFilledRandomTideSite("");
tideSite.LastUpdateDate_UTC = new DateTime();
tideSiteService.Add(tideSite);
Assert.AreEqual(string.Format(CSSPServicesRes._IsRequired, "LastUpdateDate_UTC"), tideSite.ValidationResults.FirstOrDefault().ErrorMessage);
tideSite = null;
tideSite = GetFilledRandomTideSite("");
tideSite.LastUpdateDate_UTC = new DateTime(1979, 1, 1);
tideSiteService.Add(tideSite);
Assert.AreEqual(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "LastUpdateDate_UTC", "1980"), tideSite.ValidationResults.FirstOrDefault().ErrorMessage);
// -----------------------------------
// Is NOT Nullable
// [CSSPExist(ExistTypeName = "TVItem", ExistPlurial = "s", ExistFieldID = "TVItemID", AllowableTVtypeList = Contact)]
// tideSite.LastUpdateContactTVItemID (Int32)
// -----------------------------------
tideSite = null;
tideSite = GetFilledRandomTideSite("");
tideSite.LastUpdateContactTVItemID = 0;
tideSiteService.Add(tideSite);
Assert.AreEqual(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "LastUpdateContactTVItemID", tideSite.LastUpdateContactTVItemID.ToString()), tideSite.ValidationResults.FirstOrDefault().ErrorMessage);
tideSite = null;
tideSite = GetFilledRandomTideSite("");
tideSite.LastUpdateContactTVItemID = 1;
tideSiteService.Add(tideSite);
Assert.AreEqual(string.Format(CSSPServicesRes._IsNotOfType_, "LastUpdateContactTVItemID", "Contact"), tideSite.ValidationResults.FirstOrDefault().ErrorMessage);
// -----------------------------------
// Is NOT Nullable
// [NotMapped]
// tideSite.HasErrors (Boolean)
// -----------------------------------
// No testing requied
// -----------------------------------
// Is NOT Nullable
// [NotMapped]
// tideSite.ValidationResults (IEnumerable`1)
// -----------------------------------
// No testing requied
}
}
}
public void TideSite_Controller_Post_Test()
{
foreach (LanguageEnum LanguageRequest in AllowableLanguages)
{
foreach (int ContactID in new List <int>()
{
AdminContactID
}) //, TestEmailValidatedContactID, TestEmailNotValidatedContactID })
{
TideSiteController tideSiteController = new TideSiteController(DatabaseTypeEnum.SqlServerTestDB);
Assert.IsNotNull(tideSiteController);
Assert.AreEqual(DatabaseTypeEnum.SqlServerTestDB, tideSiteController.DatabaseType);
TideSite tideSiteLast = new TideSite();
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
Query query = new Query();
query.Language = LanguageRequest;
query.Asc = "";
query.Desc = "";
TideSiteService tideSiteService = new TideSiteService(query, db, ContactID);
tideSiteLast = (from c in db.TideSites select c).FirstOrDefault();
}
// ok with TideSite info
IHttpActionResult jsonRet = tideSiteController.GetTideSiteWithID(tideSiteLast.TideSiteID);
Assert.IsNotNull(jsonRet);
OkNegotiatedContentResult <TideSite> Ret = jsonRet as OkNegotiatedContentResult <TideSite>;
TideSite tideSiteRet = Ret.Content;
Assert.AreEqual(tideSiteLast.TideSiteID, tideSiteRet.TideSiteID);
BadRequestErrorMessageResult badRequest = jsonRet as BadRequestErrorMessageResult;
Assert.IsNull(badRequest);
// Post to return CSSPError because TideSiteID exist
IHttpActionResult jsonRet2 = tideSiteController.Post(tideSiteRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet2);
OkNegotiatedContentResult <TideSite> tideSiteRet2 = jsonRet2 as OkNegotiatedContentResult <TideSite>;
Assert.IsNull(tideSiteRet2);
BadRequestErrorMessageResult badRequest2 = jsonRet2 as BadRequestErrorMessageResult;
Assert.IsNotNull(badRequest2);
// Post to return newly added TideSite
tideSiteRet.TideSiteID = 0;
tideSiteController.Request = new System.Net.Http.HttpRequestMessage();
tideSiteController.Request.RequestUri = new System.Uri("http://localhost:5000/api/tideSite");
IHttpActionResult jsonRet3 = tideSiteController.Post(tideSiteRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet3);
CreatedNegotiatedContentResult <TideSite> tideSiteRet3 = jsonRet3 as CreatedNegotiatedContentResult <TideSite>;
Assert.IsNotNull(tideSiteRet3);
BadRequestErrorMessageResult badRequest3 = jsonRet3 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest3);
IHttpActionResult jsonRet4 = tideSiteController.Delete(tideSiteRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet4);
OkNegotiatedContentResult <TideSite> tideSiteRet4 = jsonRet4 as OkNegotiatedContentResult <TideSite>;
Assert.IsNotNull(tideSiteRet4);
BadRequestErrorMessageResult badRequest4 = jsonRet4 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest4);
}
}
}
