public ClimateSite GetClimateSiteWithClimateSiteIDDB(int ClimateSiteID)
{
ClimateSite ClimateSite = (from c in db.ClimateSites
where c.ClimateSiteID == ClimateSiteID
select c).FirstOrDefault <ClimateSite>();
return(ClimateSite);
}
public void ClimateSite_Controller_Put_Test()
{
foreach (LanguageEnum LanguageRequest in AllowableLanguages)
{
foreach (int ContactID in new List <int>()
{
AdminContactID
}) //, TestEmailValidatedContactID, TestEmailNotValidatedContactID })
{
ClimateSiteController climateSiteController = new ClimateSiteController(DatabaseTypeEnum.SqlServerTestDB);
Assert.IsNotNull(climateSiteController);
Assert.AreEqual(DatabaseTypeEnum.SqlServerTestDB, climateSiteController.DatabaseType);
ClimateSite climateSiteLast = new ClimateSite();
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
Query query = new Query();
query.Language = LanguageRequest;
ClimateSiteService climateSiteService = new ClimateSiteService(query, db, ContactID);
climateSiteLast = (from c in db.ClimateSites select c).FirstOrDefault();
}
// ok with ClimateSite info
IHttpActionResult jsonRet = climateSiteController.GetClimateSiteWithID(climateSiteLast.ClimateSiteID);
Assert.IsNotNull(jsonRet);
OkNegotiatedContentResult <ClimateSite> Ret = jsonRet as OkNegotiatedContentResult <ClimateSite>;
ClimateSite climateSiteRet = Ret.Content;
Assert.AreEqual(climateSiteLast.ClimateSiteID, climateSiteRet.ClimateSiteID);
BadRequestErrorMessageResult badRequest = jsonRet as BadRequestErrorMessageResult;
Assert.IsNull(badRequest);
// Put to return success
IHttpActionResult jsonRet2 = climateSiteController.Put(climateSiteRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet2);
OkNegotiatedContentResult <ClimateSite> climateSiteRet2 = jsonRet2 as OkNegotiatedContentResult <ClimateSite>;
Assert.IsNotNull(climateSiteRet2);
BadRequestErrorMessageResult badRequest2 = jsonRet2 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest2);
// Put to return CSSPError because ClimateSiteID of 0 does not exist
climateSiteRet.ClimateSiteID = 0;
IHttpActionResult jsonRet3 = climateSiteController.Put(climateSiteRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet3);
OkNegotiatedContentResult <ClimateSite> climateSiteRet3 = jsonRet3 as OkNegotiatedContentResult <ClimateSite>;
Assert.IsNull(climateSiteRet3);
BadRequestErrorMessageResult badRequest3 = jsonRet3 as BadRequestErrorMessageResult;
Assert.IsNotNull(badRequest3);
}
}
}
// Post
public ClimateSiteModel PostAddClimateSiteDB(ClimateSiteModel climateSiteModel)
{
string retStr = ClimateSiteModelOK(climateSiteModel);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrEmpty(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
TVItemModel tvItemModelExist = _TVItemService.GetTVItemModelWithTVItemIDDB(climateSiteModel.ClimateSiteTVItemID);
if (!string.IsNullOrWhiteSpace(tvItemModelExist.Error))
{
return(ReturnError(tvItemModelExist.Error));
}
ClimateSite climateSiteNew = new ClimateSite();
retStr = FillClimateSite(climateSiteNew, climateSiteModel, contactOK);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
using (TransactionScope ts = new TransactionScope())
{
db.ClimateSites.Add(climateSiteNew);
retStr = DoAddChanges();
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
LogModel logModel = _LogService.PostAddLogForObj("ClimateSites", climateSiteNew.ClimateSiteID, LogCommandEnum.Add, climateSiteNew);
if (!string.IsNullOrWhiteSpace(logModel.Error))
{
return(ReturnError(logModel.Error));
}
ts.Complete();
}
return(GetClimateSiteModelWithClimateSiteIDDB(climateSiteNew.ClimateSiteID));
}
public IHttpActionResult GetClimateSiteWithID([FromUri] int ClimateSiteID, [FromUri] string lang = "en", [FromUri] string extra = "")
{
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
ClimateSiteService climateSiteService = new ClimateSiteService(new Query()
{
Language = (lang == "fr" ? LanguageEnum.fr : LanguageEnum.en)
}, db, ContactID);
climateSiteService.Query = climateSiteService.FillQuery(typeof(ClimateSite), lang, 0, 1, "", "", extra);
if (climateSiteService.Query.Extra == "A")
{
ClimateSiteExtraA climateSiteExtraA = new ClimateSiteExtraA();
climateSiteExtraA = climateSiteService.GetClimateSiteExtraAWithClimateSiteID(ClimateSiteID);
if (climateSiteExtraA == null)
{
return(NotFound());
}
return(Ok(climateSiteExtraA));
}
else if (climateSiteService.Query.Extra == "B")
{
ClimateSiteExtraB climateSiteExtraB = new ClimateSiteExtraB();
climateSiteExtraB = climateSiteService.GetClimateSiteExtraBWithClimateSiteID(ClimateSiteID);
if (climateSiteExtraB == null)
{
return(NotFound());
}
return(Ok(climateSiteExtraB));
}
else
{
ClimateSite climateSite = new ClimateSite();
climateSite = climateSiteService.GetClimateSiteWithClimateSiteID(ClimateSiteID);
if (climateSite == null)
{
return(NotFound());
}
return(Ok(climateSite));
}
}
}
private bool TryToSave(ClimateSite climateSite)
{
try
{
db.SaveChanges();
}
catch (DbUpdateException ex)
{
climateSite.ValidationResults = new List <ValidationResult>()
{
new ValidationResult(ex.Message + (ex.InnerException != null ? " Inner: " + ex.InnerException.Message : ""))
}.AsEnumerable();
return(false);
}
return(true);
}
public bool Update(ClimateSite climateSite)
{
climateSite.ValidationResults = Validate(new ValidationContext(climateSite), ActionDBTypeEnum.Update);
if (climateSite.ValidationResults.Count() > 0)
{
return(false);
}
db.ClimateSites.Update(climateSite);
if (!TryToSave(climateSite))
{
return(false);
}
return(true);
}
public ClimateSiteModel PostDeleteClimateSiteDB(int ClimateSiteID)
{
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrEmpty(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
ClimateSite climateSiteToDelete = GetClimateSiteWithClimateSiteIDDB(ClimateSiteID);
if (climateSiteToDelete == null)
{
return(ReturnError(string.Format(ServiceRes.CouldNotFind_ToDelete, ServiceRes.ClimateSite)));
}
int TVItemIDToDelete = climateSiteToDelete.ClimateSiteTVItemID;
using (TransactionScope ts = new TransactionScope())
{
db.ClimateSites.Remove(climateSiteToDelete);
string retStr = DoDeleteChanges();
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
LogModel logModel = _LogService.PostAddLogForObj("ClimateSites", climateSiteToDelete.ClimateSiteID, LogCommandEnum.Delete, climateSiteToDelete);
if (!string.IsNullOrWhiteSpace(logModel.Error))
{
return(ReturnError(logModel.Error));
}
TVItemModel tvItemModelRet = _TVItemService.PostDeleteTVItemWithTVItemIDDB(TVItemIDToDelete);
if (!string.IsNullOrWhiteSpace(tvItemModelRet.Error))
{
return(ReturnError(tvItemModelRet.Error));
}
ts.Complete();
}
return(ReturnError(""));
}
public void ClimateSite_Controller_GetClimateSiteWithID_Test()
{
foreach (LanguageEnum LanguageRequest in AllowableLanguages)
{
foreach (int ContactID in new List <int>()
{
AdminContactID
}) //, TestEmailValidatedContactID, TestEmailNotValidatedContactID })
{
ClimateSiteController climateSiteController = new ClimateSiteController(DatabaseTypeEnum.SqlServerTestDB);
Assert.IsNotNull(climateSiteController);
Assert.AreEqual(DatabaseTypeEnum.SqlServerTestDB, climateSiteController.DatabaseType);
ClimateSite climateSiteFirst = new ClimateSite();
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
ClimateSiteService climateSiteService = new ClimateSiteService(new Query(), db, ContactID);
climateSiteFirst = (from c in db.ClimateSites select c).FirstOrDefault();
}
// ok with ClimateSite info
IHttpActionResult jsonRet = climateSiteController.GetClimateSiteWithID(climateSiteFirst.ClimateSiteID);
Assert.IsNotNull(jsonRet);
OkNegotiatedContentResult <ClimateSite> Ret = jsonRet as OkNegotiatedContentResult <ClimateSite>;
ClimateSite climateSiteRet = Ret.Content;
Assert.AreEqual(climateSiteFirst.ClimateSiteID, climateSiteRet.ClimateSiteID);
BadRequestErrorMessageResult badRequest = jsonRet as BadRequestErrorMessageResult;
Assert.IsNull(badRequest);
// Not Found
IHttpActionResult jsonRet2 = climateSiteController.GetClimateSiteWithID(0);
Assert.IsNotNull(jsonRet2);
OkNegotiatedContentResult <ClimateSite> climateSiteRet2 = jsonRet2 as OkNegotiatedContentResult <ClimateSite>;
Assert.IsNull(climateSiteRet2);
NotFoundResult notFoundRequest = jsonRet2 as NotFoundResult;
Assert.IsNotNull(notFoundRequest);
}
}
}
public IHttpActionResult Delete([FromBody] ClimateSite climateSite, [FromUri] string lang = "en")
{
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
ClimateSiteService climateSiteService = new ClimateSiteService(new Query()
{
Language = (lang == "fr" ? LanguageEnum.fr : LanguageEnum.en)
}, db, ContactID);
if (!climateSiteService.Delete(climateSite))
{
return(BadRequest(String.Join("|||", climateSite.ValidationResults)));
}
else
{
climateSite.ValidationResults = null;
return(Ok(climateSite));
}
}
}
// Fill
public string FillClimateSite(ClimateSite climateSiteNew, ClimateSiteModel climateSiteModel, ContactOK contactOK)
{
climateSiteNew.DBCommand = (int)climateSiteModel.DBCommand;
climateSiteNew.ClimateSiteTVItemID = climateSiteModel.ClimateSiteTVItemID;
climateSiteNew.ClimateID = climateSiteModel.ClimateID;
climateSiteNew.ClimateSiteName = climateSiteModel.ClimateSiteName;
climateSiteNew.DailyEndDate_Local = climateSiteModel.DailyEndDate_Local;
climateSiteNew.DailyNow = climateSiteModel.DailyNow;
climateSiteNew.DailyStartDate_Local = climateSiteModel.DailyStartDate_Local;
climateSiteNew.ECDBID = climateSiteModel.ECDBID;
climateSiteNew.Elevation_m = climateSiteModel.Elevation_m;
climateSiteNew.File_desc = climateSiteModel.File_desc;
climateSiteNew.HourlyEndDate_Local = climateSiteModel.HourlyEndDate_Local;
climateSiteNew.HourlyNow = climateSiteModel.HourlyNow;
climateSiteNew.HourlyStartDate_Local = climateSiteModel.HourlyStartDate_Local;
climateSiteNew.IsQuebecSite = climateSiteModel.IsQuebecSite;
climateSiteNew.IsCoCoRaHS = climateSiteModel.IsCoCoRaHS;
climateSiteNew.MonthlyEndDate_Local = climateSiteModel.MonthlyEndDate_Local;
climateSiteNew.MonthlyNow = climateSiteModel.MonthlyNow;
climateSiteNew.MonthlyStartDate_Local = climateSiteModel.MonthlyStartDate_Local;
climateSiteNew.Province = climateSiteModel.Province;
climateSiteNew.TCID = climateSiteModel.TCID;
climateSiteNew.TimeOffset_hour = climateSiteModel.TimeOffset_hour;
climateSiteNew.WMOID = climateSiteModel.WMOID;
climateSiteNew.LastUpdateDate_UTC = DateTime.UtcNow;
if (contactOK == null)
{
climateSiteNew.LastUpdateContactTVItemID = 2;
}
else
{
climateSiteNew.LastUpdateContactTVItemID = contactOK.ContactTVItemID;
}
return("");
}
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" }));
}
}
public ClimateSiteModel PostUpdateClimateSiteDB(ClimateSiteModel climateSiteModel)
{
string retStr = ClimateSiteModelOK(climateSiteModel);
if (!string.IsNullOrEmpty(retStr))
{
return(ReturnError(retStr));
}
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrEmpty(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
ClimateSite climateSiteToUpdate = GetClimateSiteWithClimateSiteIDDB(climateSiteModel.ClimateSiteID);
if (climateSiteToUpdate == null)
{
return(ReturnError(string.Format(ServiceRes.CouldNotFind_ToUpdate, ServiceRes.ClimateSite)));
}
retStr = FillClimateSite(climateSiteToUpdate, climateSiteModel, contactOK);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
using (TransactionScope ts = new TransactionScope())
{
retStr = DoUpdateChanges();
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
LogModel logModel = _LogService.PostAddLogForObj("ClimateSites", climateSiteToUpdate.ClimateSiteID, LogCommandEnum.Change, climateSiteToUpdate);
if (!string.IsNullOrWhiteSpace(logModel.Error))
{
return(ReturnError(logModel.Error));
}
foreach (LanguageEnum Lang in LanguageListAllowable)
{
if (Lang == LanguageRequest)
{
TVItemLanguageModel tvItemLanguageModelToUpdate = _TVItemService._TVItemLanguageService.GetTVItemLanguageModelWithTVItemIDAndLanguageDB(climateSiteToUpdate.ClimateSiteTVItemID, Lang);
if (!string.IsNullOrWhiteSpace(tvItemLanguageModelToUpdate.Error))
{
return(ReturnError(tvItemLanguageModelToUpdate.Error));
}
tvItemLanguageModelToUpdate.TVText = CreateTVText(climateSiteModel);
if (string.IsNullOrWhiteSpace(tvItemLanguageModelToUpdate.TVText))
{
return(ReturnError(string.Format(ServiceRes._IsRequired, ServiceRes.TVText)));
}
TVItemLanguageModel tvItemLanguageModel = _TVItemService._TVItemLanguageService.PostUpdateTVItemLanguageDB(tvItemLanguageModelToUpdate);
if (!string.IsNullOrWhiteSpace(tvItemLanguageModel.Error))
{
return(ReturnError(tvItemLanguageModel.Error));
}
}
}
ts.Complete();
}
return(GetClimateSiteModelWithClimateSiteIDDB(climateSiteToUpdate.ClimateSiteID));
}
private IEnumerable <ValidationResult> Validate(ValidationContext validationContext, ActionDBTypeEnum actionDBType)
{
string retStr = "";
Enums enums = new Enums(LanguageRequest);
ClimateDataValue climateDataValue = validationContext.ObjectInstance as ClimateDataValue;
climateDataValue.HasErrors = false;
if (actionDBType == ActionDBTypeEnum.Update || actionDBType == ActionDBTypeEnum.Delete)
{
if (climateDataValue.ClimateDataValueID == 0)
{
climateDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "ClimateDataValueID"), new[] { "ClimateDataValueID" }));
}
if (!(from c in db.ClimateDataValues select c).Where(c => c.ClimateDataValueID == climateDataValue.ClimateDataValueID).Any())
{
climateDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "ClimateDataValue", "ClimateDataValueID", climateDataValue.ClimateDataValueID.ToString()), new[] { "ClimateDataValueID" }));
}
}
ClimateSite ClimateSiteClimateSiteID = (from c in db.ClimateSites where c.ClimateSiteID == climateDataValue.ClimateSiteID select c).FirstOrDefault();
if (ClimateSiteClimateSiteID == null)
{
climateDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "ClimateSite", "ClimateSiteID", climateDataValue.ClimateSiteID.ToString()), new[] { "ClimateSiteID" }));
}
if (climateDataValue.DateTime_Local.Year == 1)
{
climateDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "DateTime_Local"), new[] { "DateTime_Local" }));
}
else
{
if (climateDataValue.DateTime_Local.Year < 1980)
{
climateDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "DateTime_Local", "1980"), new[] { "DateTime_Local" }));
}
}
retStr = enums.EnumTypeOK(typeof(StorageDataTypeEnum), (int?)climateDataValue.StorageDataType);
if (!string.IsNullOrWhiteSpace(retStr))
{
climateDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "StorageDataType"), new[] { "StorageDataType" }));
}
if (climateDataValue.Snow_cm != null)
{
if (climateDataValue.Snow_cm < 0 || climateDataValue.Snow_cm > 10000)
{
climateDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Snow_cm", "0", "10000"), new[] { "Snow_cm" }));
}
}
if (climateDataValue.Rainfall_mm != null)
{
if (climateDataValue.Rainfall_mm < 0 || climateDataValue.Rainfall_mm > 10000)
{
climateDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Rainfall_mm", "0", "10000"), new[] { "Rainfall_mm" }));
}
}
if (climateDataValue.RainfallEntered_mm != null)
{
if (climateDataValue.RainfallEntered_mm < 0 || climateDataValue.RainfallEntered_mm > 10000)
{
climateDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "RainfallEntered_mm", "0", "10000"), new[] { "RainfallEntered_mm" }));
}
}
if (climateDataValue.TotalPrecip_mm_cm != null)
{
if (climateDataValue.TotalPrecip_mm_cm < 0 || climateDataValue.TotalPrecip_mm_cm > 10000)
{
climateDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "TotalPrecip_mm_cm", "0", "10000"), new[] { "TotalPrecip_mm_cm" }));
}
}
if (climateDataValue.MaxTemp_C != null)
{
if (climateDataValue.MaxTemp_C < -50 || climateDataValue.MaxTemp_C > 50)
{
climateDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "MaxTemp_C", "-50", "50"), new[] { "MaxTemp_C" }));
}
}
if (climateDataValue.MinTemp_C != null)
{
if (climateDataValue.MinTemp_C < -50 || climateDataValue.MinTemp_C > 50)
{
climateDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "MinTemp_C", "-50", "50"), new[] { "MinTemp_C" }));
}
}
if (climateDataValue.HeatDegDays_C != null)
{
if (climateDataValue.HeatDegDays_C < -1000 || climateDataValue.HeatDegDays_C > 100)
{
climateDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "HeatDegDays_C", "-1000", "100"), new[] { "HeatDegDays_C" }));
}
}
if (climateDataValue.CoolDegDays_C != null)
{
if (climateDataValue.CoolDegDays_C < -1000 || climateDataValue.CoolDegDays_C > 100)
{
climateDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "CoolDegDays_C", "-1000", "100"), new[] { "CoolDegDays_C" }));
}
}
if (climateDataValue.SnowOnGround_cm != null)
{
if (climateDataValue.SnowOnGround_cm < 0 || climateDataValue.SnowOnGround_cm > 10000)
{
climateDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "SnowOnGround_cm", "0", "10000"), new[] { "SnowOnGround_cm" }));
}
}
if (climateDataValue.DirMaxGust_0North != null)
{
if (climateDataValue.DirMaxGust_0North < 0 || climateDataValue.DirMaxGust_0North > 360)
{
climateDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "DirMaxGust_0North", "0", "360"), new[] { "DirMaxGust_0North" }));
}
}
if (climateDataValue.SpdMaxGust_kmh != null)
{
if (climateDataValue.SpdMaxGust_kmh < 0 || climateDataValue.SpdMaxGust_kmh > 300)
{
climateDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "SpdMaxGust_kmh", "0", "300"), new[] { "SpdMaxGust_kmh" }));
}
}
//HourlyValues has no StringLength Attribute
if (climateDataValue.LastUpdateDate_UTC.Year == 1)
{
climateDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "LastUpdateDate_UTC"), new[] { "LastUpdateDate_UTC" }));
}
else
{
if (climateDataValue.LastUpdateDate_UTC.Year < 1980)
{
climateDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "LastUpdateDate_UTC", "1980"), new[] { "LastUpdateDate_UTC" }));
}
}
TVItem TVItemLastUpdateContactTVItemID = (from c in db.TVItems where c.TVItemID == climateDataValue.LastUpdateContactTVItemID select c).FirstOrDefault();
if (TVItemLastUpdateContactTVItemID == null)
{
climateDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "LastUpdateContactTVItemID", climateDataValue.LastUpdateContactTVItemID.ToString()), new[] { "LastUpdateContactTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.Contact,
};
if (!AllowableTVTypes.Contains(TVItemLastUpdateContactTVItemID.TVType))
{
climateDataValue.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "LastUpdateContactTVItemID", "Contact"), new[] { "LastUpdateContactTVItemID" }));
}
}
retStr = ""; // added to stop compiling CSSPError
if (retStr != "") // will never be true
{
climateDataValue.HasErrors = true;
yield return(new ValidationResult("AAA", new[] { "AAA" }));
}
}
public void ClimateSite_Controller_GetClimateSiteList_Test()
{
foreach (LanguageEnum LanguageRequest in AllowableLanguages)
{
foreach (int ContactID in new List <int>()
{
AdminContactID
}) //, TestEmailValidatedContactID, TestEmailNotValidatedContactID })
{
ClimateSiteController climateSiteController = new ClimateSiteController(DatabaseTypeEnum.SqlServerTestDB);
Assert.IsNotNull(climateSiteController);
Assert.AreEqual(DatabaseTypeEnum.SqlServerTestDB, climateSiteController.DatabaseType);
ClimateSite climateSiteFirst = new ClimateSite();
int count = -1;
Query query = new Query();
using (CSSPDBContext db = new CSSPDBContext(DatabaseTypeEnum.SqlServerTestDB))
{
ClimateSiteService climateSiteService = new ClimateSiteService(query, db, ContactID);
climateSiteFirst = (from c in db.ClimateSites select c).FirstOrDefault();
count = (from c in db.ClimateSites select c).Count();
count = (query.Take > count ? count : query.Take);
}
// ok with ClimateSite info
IHttpActionResult jsonRet = climateSiteController.GetClimateSiteList();
Assert.IsNotNull(jsonRet);
OkNegotiatedContentResult <List <ClimateSite> > ret = jsonRet as OkNegotiatedContentResult <List <ClimateSite> >;
Assert.AreEqual(climateSiteFirst.ClimateSiteID, ret.Content[0].ClimateSiteID);
Assert.AreEqual((count > query.Take ? query.Take : count), ret.Content.Count);
List <ClimateSite> climateSiteList = new List <ClimateSite>();
count = -1;
query = new Query();
using (CSSPDBContext db = new CSSPDBContext(DatabaseTypeEnum.SqlServerTestDB))
{
ClimateSiteService climateSiteService = new ClimateSiteService(query, db, ContactID);
climateSiteList = (from c in db.ClimateSites select c).OrderBy(c => c.ClimateSiteID).Skip(0).Take(2).ToList();
count = (from c in db.ClimateSites select c).Count();
}
if (count > 0)
{
query.Skip = 0;
query.Take = 5;
count = (query.Take > count ? query.Take : count);
// ok with ClimateSite info
jsonRet = climateSiteController.GetClimateSiteList(query.Language.ToString(), query.Skip, query.Take);
Assert.IsNotNull(jsonRet);
ret = jsonRet as OkNegotiatedContentResult <List <ClimateSite> >;
Assert.AreEqual(climateSiteList[0].ClimateSiteID, ret.Content[0].ClimateSiteID);
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 ClimateSite info
IHttpActionResult jsonRet2 = climateSiteController.GetClimateSiteList(query.Language.ToString(), query.Skip, query.Take);
Assert.IsNotNull(jsonRet2);
OkNegotiatedContentResult <List <ClimateSite> > ret2 = jsonRet2 as OkNegotiatedContentResult <List <ClimateSite> >;
Assert.AreEqual(climateSiteList[1].ClimateSiteID, ret2.Content[0].ClimateSiteID);
Assert.AreEqual((count > query.Take ? query.Take : count), ret2.Content.Count);
}
}
}
}
}
public void ClimateSite_Controller_Post_Test()
{
foreach (LanguageEnum LanguageRequest in AllowableLanguages)
{
foreach (int ContactID in new List <int>()
{
AdminContactID
}) //, TestEmailValidatedContactID, TestEmailNotValidatedContactID })
{
ClimateSiteController climateSiteController = new ClimateSiteController(DatabaseTypeEnum.SqlServerTestDB);
Assert.IsNotNull(climateSiteController);
Assert.AreEqual(DatabaseTypeEnum.SqlServerTestDB, climateSiteController.DatabaseType);
ClimateSite climateSiteLast = new ClimateSite();
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
Query query = new Query();
query.Language = LanguageRequest;
query.Asc = "";
query.Desc = "";
ClimateSiteService climateSiteService = new ClimateSiteService(query, db, ContactID);
climateSiteLast = (from c in db.ClimateSites select c).FirstOrDefault();
}
// ok with ClimateSite info
IHttpActionResult jsonRet = climateSiteController.GetClimateSiteWithID(climateSiteLast.ClimateSiteID);
Assert.IsNotNull(jsonRet);
OkNegotiatedContentResult <ClimateSite> Ret = jsonRet as OkNegotiatedContentResult <ClimateSite>;
ClimateSite climateSiteRet = Ret.Content;
Assert.AreEqual(climateSiteLast.ClimateSiteID, climateSiteRet.ClimateSiteID);
BadRequestErrorMessageResult badRequest = jsonRet as BadRequestErrorMessageResult;
Assert.IsNull(badRequest);
// Post to return CSSPError because ClimateSiteID exist
IHttpActionResult jsonRet2 = climateSiteController.Post(climateSiteRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet2);
OkNegotiatedContentResult <ClimateSite> climateSiteRet2 = jsonRet2 as OkNegotiatedContentResult <ClimateSite>;
Assert.IsNull(climateSiteRet2);
BadRequestErrorMessageResult badRequest2 = jsonRet2 as BadRequestErrorMessageResult;
Assert.IsNotNull(badRequest2);
// Post to return newly added ClimateSite
climateSiteRet.ClimateSiteID = 0;
climateSiteController.Request = new System.Net.Http.HttpRequestMessage();
climateSiteController.Request.RequestUri = new System.Uri("http://localhost:5000/api/climateSite");
IHttpActionResult jsonRet3 = climateSiteController.Post(climateSiteRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet3);
CreatedNegotiatedContentResult <ClimateSite> climateSiteRet3 = jsonRet3 as CreatedNegotiatedContentResult <ClimateSite>;
Assert.IsNotNull(climateSiteRet3);
BadRequestErrorMessageResult badRequest3 = jsonRet3 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest3);
IHttpActionResult jsonRet4 = climateSiteController.Delete(climateSiteRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet4);
OkNegotiatedContentResult <ClimateSite> climateSiteRet4 = jsonRet4 as OkNegotiatedContentResult <ClimateSite>;
Assert.IsNotNull(climateSiteRet4);
BadRequestErrorMessageResult badRequest4 = jsonRet4 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest4);
}
}
}
public ClimateSiteTest()
{
climateSite = new ClimateSite();
climateSiteExtraA = new ClimateSiteExtraA();
climateSiteExtraB = new ClimateSiteExtraB();
}
