// Post
public RatingCurveModel PostAddRatingCurveDB(RatingCurveModel ratingCurveModel)
{
string retStr = RatingCurveModelOK(ratingCurveModel);
if (!string.IsNullOrEmpty(retStr))
{
return(ReturnError(retStr));
}
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrEmpty(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
HydrometricSiteModel hydrometricSiteModel = _HydrometricSiteService.GetHydrometricSiteModelWithHydrometricSiteIDDB(ratingCurveModel.HydrometricSiteID);
if (!string.IsNullOrWhiteSpace(hydrometricSiteModel.Error))
{
return(ReturnError(hydrometricSiteModel.Error));
}
RatingCurve ratingCurveExist = GetRatingCurveExistDB(ratingCurveModel);
if (ratingCurveExist != null)
{
return(ReturnError(string.Format(ServiceRes._AlreadyExists, ServiceRes.RatingCurve)));
}
RatingCurve ratingCurveNew = new RatingCurve();
retStr = FillRatingCurve(ratingCurveNew, ratingCurveModel, contactOK);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
using (TransactionScope ts = new TransactionScope())
{
db.RatingCurves.Add(ratingCurveNew);
retStr = DoAddChanges();
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
LogModel logModel = _LogService.PostAddLogForObj("RatingCurves", ratingCurveNew.RatingCurveID, LogCommandEnum.Add, ratingCurveNew);
if (!string.IsNullOrWhiteSpace(logModel.Error))
{
return(ReturnError(logModel.Error));
}
ts.Complete();
}
return(GetRatingCurveModelWithRatingCurveIDDB(ratingCurveNew.RatingCurveID));
}
// Post
public HydrometricSiteModel PostAddHydrometricSiteDB(HydrometricSiteModel hydrometricSiteModel)
{
string retStr = HydrometricSiteModelOK(hydrometricSiteModel);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrEmpty(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
TVItemModel tvItemModelExist = _TVItemService.GetTVItemModelWithTVItemIDDB(hydrometricSiteModel.HydrometricSiteTVItemID);
if (!string.IsNullOrWhiteSpace(tvItemModelExist.Error))
{
return(ReturnError(tvItemModelExist.Error));
}
HydrometricSite hydrometricSiteNew = new HydrometricSite();
retStr = FillHydrometricSite(hydrometricSiteNew, hydrometricSiteModel, contactOK);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
using (TransactionScope ts = new TransactionScope())
{
db.HydrometricSites.Add(hydrometricSiteNew);
retStr = DoAddChanges();
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
LogModel logModel = _LogService.PostAddLogForObj("HydrometricSites", hydrometricSiteNew.HydrometricSiteID, LogCommandEnum.Add, hydrometricSiteNew);
if (!string.IsNullOrWhiteSpace(logModel.Error))
{
return(ReturnError(logModel.Error));
}
ts.Complete();
}
return(GetHydrometricSiteModelWithHydrometricSiteIDDB(hydrometricSiteNew.HydrometricSiteID));
}
public HydrometricSiteModel GetHydrometricSiteModelExistDB(HydrometricSiteModel hydrometricSiteModel)
{
HydrometricSiteModel HydrometricSiteModel = (from c in db.HydrometricSites
where c.HydrometricSiteName == hydrometricSiteModel.HydrometricSiteName &&
c.Province == hydrometricSiteModel.Province &&
c.FedSiteNumber == hydrometricSiteModel.FedSiteNumber
select new HydrometricSiteModel
{
Error = "",
HydrometricSiteID = c.HydrometricSiteID,
DBCommand = (DBCommandEnum)c.DBCommand,
HydrometricSiteTVItemID = c.HydrometricSiteTVItemID,
FedSiteNumber = c.FedSiteNumber,
QuebecSiteNumber = c.QuebecSiteNumber,
HydrometricSiteName = c.HydrometricSiteName,
Description = c.Description,
Province = c.Province,
Elevation_m = c.Elevation_m,
StartDate_Local = c.StartDate_Local,
EndDate_Local = c.EndDate_Local,
TimeOffset_hour = c.TimeOffset_hour,
DrainageArea_km2 = c.DrainageArea_km2,
IsNatural = c.IsNatural,
IsActive = c.IsActive,
Sediment = c.Sediment,
RHBN = c.RHBN,
RealTime = c.RealTime,
HasDischarge = c.HasDischarge,
HasLevel = c.HasLevel,
HasRatingCurve = c.HasRatingCurve,
LastUpdateDate_UTC = c.LastUpdateDate_UTC,
LastUpdateContactTVItemID = c.LastUpdateContactTVItemID,
}).FirstOrDefault <HydrometricSiteModel>();
if (HydrometricSiteModel == null)
{
return(ReturnError(string.Format(ServiceRes.CouldNotFind_With_Equal_, ServiceRes.HydrometricSite,
ServiceRes.HydrometricSiteName + "," +
ServiceRes.Province + "," +
ServiceRes.FedSiteNumber + "," +
ServiceRes.QuebecSiteNumber,
hydrometricSiteModel.HydrometricSiteName + "," +
hydrometricSiteModel.Province + "," +
hydrometricSiteModel.FedSiteNumber + "," +
hydrometricSiteModel.QuebecSiteNumber)));
}
return(HydrometricSiteModel);
}
public void HydrometricDataValueService_PostAddDeleteHydrometricDataValueDB_UserEmailNotValidated_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
HydrometricSiteModel hydrometricSiteModelRet = hydrometricSiteServiceTest.AddHydrometricSiteModel();
SetupTest(contactModelListGood[2], culture);
FillHydrometricDataValueModel(hydrometricDataValueModelNew);
HydrometricDataValueModel hydrometricDataValueModelRet = hydrometricDataValueService.PostAddHydrometricDataValueDB(hydrometricDataValueModelNew);
Assert.AreEqual(ServiceRes.EmailRequiresValidation, hydrometricDataValueModelRet.Error);
}
}
}
private HydrometricDataValueModel AddHydrometricDataValue()
{
HydrometricSiteModel hydrometricSiteModelRet = hydrometricSiteServiceTest.AddHydrometricSiteModel();
HydrometricDataValueModel hydrometricDataValueModelNew = new HydrometricDataValueModel();
FillHydrometricDataValueModel(hydrometricDataValueModelNew);
HydrometricDataValueModel hydrometricDataValueModelRet = hydrometricDataValueService.PostAddHydrometricDataValueDB(hydrometricDataValueModelNew);
if (!string.IsNullOrWhiteSpace(hydrometricDataValueModelRet.Error))
{
return(hydrometricDataValueModelRet);
}
Assert.IsNotNull(hydrometricDataValueModelRet);
CompareHydrometricDataValueModels(hydrometricDataValueModelNew, hydrometricDataValueModelRet);
return(hydrometricDataValueModelRet);
}
public void HydrometricDataValueService_PostAddDeleteHydrometricDataValueDB_BadUser_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
HydrometricSiteModel hydrometricSiteModelRet = hydrometricSiteServiceTest.AddHydrometricSiteModel();
ContactModel contactModelBad = contactModelListBad[0];
IPrincipal userBad = new GenericPrincipal(new GenericIdentity(contactModelBad.LoginEmail, "Forms"), null);
HydrometricSiteService hydrometricSiteServiceBad = new HydrometricSiteService((culture.TwoLetterISOLanguageName == "fr" ? LanguageEnum.fr : LanguageEnum.en), userBad);
HydrometricDataValueService hydrometricDataValueServiceBad = new HydrometricDataValueService((culture.TwoLetterISOLanguageName == "fr" ? LanguageEnum.fr : LanguageEnum.en), userBad);
FillHydrometricDataValueModel(hydrometricDataValueModelNew);
HydrometricDataValueModel hydrometricDataValueModelRet = hydrometricDataValueServiceBad.PostAddHydrometricDataValueDB(hydrometricDataValueModelNew);
Assert.AreEqual(ServiceRes.NeedToBeLoggedIn, hydrometricDataValueModelRet.Error);
}
}
}
// Fill
public string FillHydrometricSite(HydrometricSite hydrometricSiteNew, HydrometricSiteModel hydrometricSiteModel, ContactOK contactOK)
{
hydrometricSiteNew.DBCommand = (int)hydrometricSiteModel.DBCommand;
hydrometricSiteNew.HydrometricSiteTVItemID = hydrometricSiteModel.HydrometricSiteTVItemID;
hydrometricSiteNew.FedSiteNumber = hydrometricSiteModel.FedSiteNumber;
hydrometricSiteNew.QuebecSiteNumber = hydrometricSiteModel.QuebecSiteNumber;
hydrometricSiteNew.HydrometricSiteName = hydrometricSiteModel.HydrometricSiteName;
hydrometricSiteNew.Description = hydrometricSiteModel.Description;
hydrometricSiteNew.Province = hydrometricSiteModel.Province;
hydrometricSiteNew.Elevation_m = hydrometricSiteModel.Elevation_m;
hydrometricSiteNew.Elevation_m = hydrometricSiteModel.Elevation_m;
hydrometricSiteNew.StartDate_Local = hydrometricSiteModel.StartDate_Local;
hydrometricSiteNew.EndDate_Local = hydrometricSiteModel.EndDate_Local;
hydrometricSiteNew.TimeOffset_hour = hydrometricSiteModel.TimeOffset_hour;
hydrometricSiteNew.DrainageArea_km2 = hydrometricSiteModel.DrainageArea_km2;
hydrometricSiteNew.IsNatural = hydrometricSiteModel.IsNatural;
hydrometricSiteNew.IsActive = hydrometricSiteModel.IsActive;
hydrometricSiteNew.Sediment = hydrometricSiteModel.Sediment;
hydrometricSiteNew.RHBN = hydrometricSiteModel.RHBN;
hydrometricSiteNew.Province = hydrometricSiteModel.Province;
hydrometricSiteNew.RealTime = hydrometricSiteModel.RealTime;
hydrometricSiteNew.HasDischarge = hydrometricSiteModel.HasDischarge;
hydrometricSiteNew.HasLevel = hydrometricSiteModel.HasLevel;
hydrometricSiteNew.HasRatingCurve = hydrometricSiteModel.HasRatingCurve;
hydrometricSiteNew.TimeOffset_hour = hydrometricSiteModel.TimeOffset_hour;
hydrometricSiteNew.LastUpdateDate_UTC = DateTime.UtcNow;
if (contactOK == null)
{
hydrometricSiteNew.LastUpdateContactTVItemID = 2;
}
else
{
hydrometricSiteNew.LastUpdateContactTVItemID = contactOK.ContactTVItemID;
}
return("");
}
public RatingCurveModel AddRatingCurveModel()
{
TVItemModel tvItemModel = randomService.RandomTVItem(TVTypeEnum.HydrometricSite);
Assert.AreEqual("", tvItemModel.Error);
HydrometricSiteModel hydrometricSiteModel = hydrometricSiteService.GetHydrometricSiteModelWithHydrometricSiteTVItemIDDB(tvItemModel.TVItemID);
Assert.AreEqual("", hydrometricSiteModel.Error);
ratingCurveModelNew.HydrometricSiteID = hydrometricSiteModel.HydrometricSiteID;
FillRatingCurveModel(ratingCurveModelNew);
RatingCurveModel ratingCurveModelRet = ratingCurveService.PostAddRatingCurveDB(ratingCurveModelNew);
if (!string.IsNullOrWhiteSpace(ratingCurveModelRet.Error))
{
return(ratingCurveModelRet);
}
CompareRatingCurveModels(ratingCurveModelNew, ratingCurveModelRet);
return(ratingCurveModelRet);
}
public void HydrometricDataValueService_HydrometricDataValueModelOK_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
HydrometricSiteModel hydrometricSiteModelRet = hydrometricSiteServiceTest.AddHydrometricSiteModel();
hydrometricDataValueModelNew.HydrometricSiteID = hydrometricSiteModelRet.HydrometricSiteID;
#region Good
FillHydrometricDataValueModel(hydrometricDataValueModelNew);
string retStr = hydrometricDataValueService.HydrometricDataValueModelOK(hydrometricDataValueModelNew);
Assert.AreEqual("", retStr);
#endregion Good
#region HydrometricSiteID
FillHydrometricDataValueModel(hydrometricDataValueModelNew);
hydrometricDataValueModelNew.HydrometricSiteID = 0;
retStr = hydrometricDataValueService.HydrometricDataValueModelOK(hydrometricDataValueModelNew);
Assert.AreEqual(string.Format(ServiceRes._IsRequired, ServiceRes.HydrometricSiteID), retStr);
FillHydrometricDataValueModel(hydrometricDataValueModelNew);
hydrometricDataValueModelNew.HydrometricSiteID = 1;
retStr = hydrometricDataValueService.HydrometricDataValueModelOK(hydrometricDataValueModelNew);
Assert.AreEqual("", retStr);
#endregion HydrometricSiteID
#region DateTime_Local
FillHydrometricDataValueModel(hydrometricDataValueModelNew);
hydrometricDataValueModelNew.DateTime_Local = DateTime.UtcNow;
retStr = hydrometricDataValueService.HydrometricDataValueModelOK(hydrometricDataValueModelNew);
Assert.AreEqual("", retStr);
FillHydrometricDataValueModel(hydrometricDataValueModelNew);
hydrometricDataValueModelNew.DateTime_Local = DateTime.UtcNow;
using (ShimsContext.Create())
{
string ErrorText = "ErrorText";
SetupShim();
shimHydrometricDataValueService.FieldCheckNotNullDateTimeNullableOfDateTimeString = (a, b) =>
{
return(ErrorText);
};
retStr = hydrometricDataValueService.HydrometricDataValueModelOK(hydrometricDataValueModelNew);
Assert.AreEqual(ErrorText, retStr);
}
#endregion DateTime_Local
#region Keep
FillHydrometricDataValueModel(hydrometricDataValueModelNew);
hydrometricDataValueModelNew.Keep = false;
retStr = hydrometricDataValueService.HydrometricDataValueModelOK(hydrometricDataValueModelNew);
Assert.AreEqual("", retStr);
FillHydrometricDataValueModel(hydrometricDataValueModelNew);
hydrometricDataValueModelNew.Keep = true;
retStr = hydrometricDataValueService.HydrometricDataValueModelOK(hydrometricDataValueModelNew);
Assert.AreEqual("", retStr);
#endregion Keep
#region StorageDataType
FillHydrometricDataValueModel(hydrometricDataValueModelNew);
hydrometricDataValueModelNew.StorageDataType = (StorageDataTypeEnum)1000;
retStr = hydrometricDataValueService.HydrometricDataValueModelOK(hydrometricDataValueModelNew);
Assert.AreEqual(string.Format(ServiceRes._IsRequired, ServiceRes.StorageDataType), retStr);
FillHydrometricDataValueModel(hydrometricDataValueModelNew);
hydrometricDataValueModelNew.StorageDataType = StorageDataTypeEnum.Archived;
retStr = hydrometricDataValueService.HydrometricDataValueModelOK(hydrometricDataValueModelNew);
Assert.AreEqual("", retStr);
#endregion StorageDataType
#region Flow_m3_s
FillHydrometricDataValueModel(hydrometricDataValueModelNew);
double Min = 0D;
double Max = 100000D;
hydrometricDataValueModelNew.Flow_m3_s = Min - 1;
retStr = hydrometricDataValueService.HydrometricDataValueModelOK(hydrometricDataValueModelNew);
Assert.AreEqual(string.Format(ServiceRes._RangeIsBetween_And_, ServiceRes.Flow_m3_s, Min, Max), retStr);
FillHydrometricDataValueModel(hydrometricDataValueModelNew);
hydrometricDataValueModelNew.Flow_m3_s = Max + 1;
retStr = hydrometricDataValueService.HydrometricDataValueModelOK(hydrometricDataValueModelNew);
Assert.AreEqual(string.Format(ServiceRes._RangeIsBetween_And_, ServiceRes.Flow_m3_s, Min, Max), retStr);
FillHydrometricDataValueModel(hydrometricDataValueModelNew);
hydrometricDataValueModelNew.Flow_m3_s = Max - 1;
retStr = hydrometricDataValueService.HydrometricDataValueModelOK(hydrometricDataValueModelNew);
Assert.AreEqual("", retStr);
FillHydrometricDataValueModel(hydrometricDataValueModelNew);
hydrometricDataValueModelNew.Flow_m3_s = Min;
retStr = hydrometricDataValueService.HydrometricDataValueModelOK(hydrometricDataValueModelNew);
Assert.AreEqual("", retStr);
FillHydrometricDataValueModel(hydrometricDataValueModelNew);
hydrometricDataValueModelNew.Flow_m3_s = Max;
retStr = hydrometricDataValueService.HydrometricDataValueModelOK(hydrometricDataValueModelNew);
Assert.AreEqual("", retStr);
#endregion Flow_m3_s
#region HourlyValues
FillHydrometricDataValueModel(hydrometricDataValueModelNew);
hydrometricDataValueModelNew.HourlyValues = "";
retStr = hydrometricDataValueService.HydrometricDataValueModelOK(hydrometricDataValueModelNew);
Assert.AreEqual("", retStr);
FillHydrometricDataValueModel(hydrometricDataValueModelNew);
hydrometricDataValueModelNew.HourlyValues = randomService.RandomString("", 30);
retStr = hydrometricDataValueService.HydrometricDataValueModelOK(hydrometricDataValueModelNew);
Assert.AreEqual("", retStr);
#endregion HourlyValues
}
}
}
public void RatingCurveService_RatingCurveModelOK_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[2], culture);
using (TransactionScope ts = new TransactionScope())
{
TVItemModel tvItemModelHydrometricSite = randomService.RandomTVItem(TVTypeEnum.HydrometricSite);
Assert.AreEqual("", tvItemModelHydrometricSite.Error);
HydrometricSiteModel hydrometricSiteModel = hydrometricSiteService.GetHydrometricSiteModelWithHydrometricSiteTVItemIDDB(tvItemModelHydrometricSite.TVItemID);
Assert.AreEqual("", hydrometricSiteModel.Error);
#region Good
ratingCurveModelNew.HydrometricSiteID = hydrometricSiteModel.HydrometricSiteID;
FillRatingCurveModel(ratingCurveModelNew);
string retStr = ratingCurveService.RatingCurveModelOK(ratingCurveModelNew);
Assert.AreEqual("", retStr);
#endregion Good
#region HydrometricSiteID
FillRatingCurveModel(ratingCurveModelNew);
ratingCurveModelNew.HydrometricSiteID = 0;
retStr = ratingCurveService.RatingCurveModelOK(ratingCurveModelNew);
Assert.AreEqual(string.Format(ServiceRes._IsRequired, ServiceRes.HydrometricSiteID), retStr);
ratingCurveModelNew.HydrometricSiteID = hydrometricSiteModel.HydrometricSiteID;
FillRatingCurveModel(ratingCurveModelNew);
retStr = ratingCurveService.RatingCurveModelOK(ratingCurveModelNew);
Assert.AreEqual("", retStr);
#endregion HydrometricSiteID
#region RatingCurveNumber
FillRatingCurveModel(ratingCurveModelNew);
int Max = 50;
ratingCurveModelNew.RatingCurveNumber = randomService.RandomString("", 0);
retStr = ratingCurveService.RatingCurveModelOK(ratingCurveModelNew);
Assert.AreEqual(string.Format(ServiceRes._IsRequired, ServiceRes.RatingCurveNumber), retStr);
FillRatingCurveModel(ratingCurveModelNew);
ratingCurveModelNew.RatingCurveNumber = randomService.RandomString("", Max + 1);
retStr = ratingCurveService.RatingCurveModelOK(ratingCurveModelNew);
Assert.AreEqual(string.Format(ServiceRes._MaxLengthIs_, ServiceRes.RatingCurveNumber, Max), retStr);
FillRatingCurveModel(ratingCurveModelNew);
ratingCurveModelNew.RatingCurveNumber = randomService.RandomString("", Max - 1);
retStr = ratingCurveService.RatingCurveModelOK(ratingCurveModelNew);
Assert.AreEqual("", retStr);
FillRatingCurveModel(ratingCurveModelNew);
ratingCurveModelNew.RatingCurveNumber = randomService.RandomString("", Max);
retStr = ratingCurveService.RatingCurveModelOK(ratingCurveModelNew);
Assert.AreEqual("", retStr);
#endregion RatingCurveNumber
}
}
}
public void HydrometricService_GetHydrometricSiteDataForYear_Test()
{
// AppTaskID TVItemID TVItemID2 AppTaskCommand AppTaskStatus PercentCompleted Parameters Language StartDateTime_UTC EndDateTime_UTC EstimatedLength_second RemainingTime_second LastUpdateDate_UTC LastUpdateContactTVItemID
// 14775 361210 361210 44 2 1 |||MikeSourceTVItemID,361210|||MikeScenarioTVItemID,357139||| 1 2018-10-02 14:15:24.317 NULL NULL NULL 2018-10-02 14:15:25.307 2
foreach (LanguageEnum LanguageRequest in new List <LanguageEnum>()
{
LanguageEnum.en, LanguageEnum.fr
})
{
SetupTest(LanguageRequest);
int MikeSourceTVItemID = 361210;
int MikeScenarioTVItemID = 357139;
string Parameters = $"|||MikeSourceTVItemID,{ MikeSourceTVItemID }|||MikeScenarioTVItemID,{ MikeScenarioTVItemID }|||";
AppTaskModel appTaskModel = new AppTaskModel()
{
AppTaskID = 100000,
TVItemID = MikeSourceTVItemID,
TVItemID2 = MikeSourceTVItemID,
AppTaskCommand = AppTaskCommandEnum.LoadHydrometricDataValue,
AppTaskStatus = AppTaskStatusEnum.Created,
PercentCompleted = 1,
Parameters = Parameters,
Language = LanguageRequest,
StartDateTime_UTC = DateTime.Now,
EndDateTime_UTC = null,
EstimatedLength_second = null,
RemainingTime_second = null,
LastUpdateDate_UTC = DateTime.Now,
LastUpdateContactTVItemID = 2, // Charles LeBlanc
};
appTaskModel.AppTaskStatus = AppTaskStatusEnum.Running;
BWObj bwObj = new BWObj()
{
Index = 1,
appTaskModel = appTaskModel,
appTaskCommand = appTaskModel.AppTaskCommand,
TextLanguageList = new List <TextLanguage>(),
bw = new BackgroundWorker(),
};
TaskRunnerBaseService taskRunnerBaseService = new TaskRunnerBaseService(new List <BWObj>()
{
bwObj
});
taskRunnerBaseService._BWObj = bwObj;
HydrometricService _HydrometricService = new HydrometricService(taskRunnerBaseService);
_HydrometricService.FedStationNameToDo = "02ZJ001"; // HydrometricTVItemID = 56367;
_HydrometricService.DataTypeToDo = "Flow";
_HydrometricService.YearToDo = 2015;
_HydrometricService.HydrometricSiteIDToDo = 288;
HydrometricSiteModel hydrometricSiteModel = hydrometricSiteService.GetHydrometricSiteModelWithHydrometricSiteTVItemIDDB(56367);
string url = string.Format(_HydrometricService.UrlToGetHydrometricSiteDataForYear, _HydrometricService.FedStationNameToDo, _HydrometricService.DataTypeToDo, _HydrometricService.YearToDo);
ChromeOptions chromeOptions = new ChromeOptions();
chromeOptions.AddArgument("headless");
using (IWebDriver driver = new ChromeDriver()) // chromeOptions))
{
_HydrometricService.GetHydrometricSiteDataForYear(driver, hydrometricSiteModel, _HydrometricService.DataTypeToDo, _HydrometricService.YearToDo);
Assert.AreEqual(0, taskRunnerBaseService._BWObj.TextLanguageList.Count);
}
break;
}
}
public HydrometricSiteModel PostUpdateHydrometricSiteDB(HydrometricSiteModel hydrometricSiteModel)
{
string retStr = HydrometricSiteModelOK(hydrometricSiteModel);
if (!string.IsNullOrEmpty(retStr))
{
return(ReturnError(retStr));
}
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrEmpty(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
HydrometricSite hydrometricSiteToUpdate = GetHydrometricSiteWithHydrometricSiteIDDB(hydrometricSiteModel.HydrometricSiteID);
if (hydrometricSiteToUpdate == null)
{
return(ReturnError(string.Format(ServiceRes.CouldNotFind_ToUpdate, ServiceRes.HydrometricSite)));
}
retStr = FillHydrometricSite(hydrometricSiteToUpdate, hydrometricSiteModel, 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("HydrometricSites", hydrometricSiteToUpdate.HydrometricSiteID, LogCommandEnum.Change, hydrometricSiteToUpdate);
if (!string.IsNullOrWhiteSpace(logModel.Error))
{
return(ReturnError(logModel.Error));
}
foreach (LanguageEnum Lang in LanguageListAllowable)
{
if (Lang == LanguageRequest)
{
TVItemLanguageModel tvItemLanguageModelToUpdate = _TVItemService._TVItemLanguageService.GetTVItemLanguageModelWithTVItemIDAndLanguageDB(hydrometricSiteToUpdate.HydrometricSiteTVItemID, Lang);
if (!string.IsNullOrWhiteSpace(tvItemLanguageModelToUpdate.Error))
{
return(ReturnError(string.Format(ServiceRes.CouldNotFind_With_Equal_, ServiceRes.TVItemLanguage, ServiceRes.TVItemID + "," + ServiceRes.Language, hydrometricSiteToUpdate.HydrometricSiteTVItemID.ToString() + "," + Lang)));
}
tvItemLanguageModelToUpdate.TVText = CreateTVText(hydrometricSiteModel);
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(GetHydrometricSiteModelWithHydrometricSiteIDDB(hydrometricSiteToUpdate.HydrometricSiteID));
}
// Check
public string HydrometricSiteModelOK(HydrometricSiteModel hydrometricSiteModel)
{
string retStr = FieldCheckNotZeroInt(hydrometricSiteModel.HydrometricSiteTVItemID, ServiceRes.HydrometricSiteTVItemID);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
retStr = FieldCheckNotNullAndMinMaxLengthString(hydrometricSiteModel.HydrometricSiteName, ServiceRes.HydrometricSiteName, 2, 200);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
retStr = FieldCheckNotNullAndMinMaxLengthString(hydrometricSiteModel.Province, ServiceRes.Province, 2, 2);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
List <string> ProvinceList = new List <string>()
{
"AB", "BC", "MB", "NB", "NL", "NS", "NT", "NU", "ON", "PE", "QC", "SK", "YT"
};
string ProvinceListTxt = "";
foreach (string s in ProvinceList)
{
ProvinceListTxt += "," + s;
}
ProvinceListTxt = ProvinceListTxt.Substring(1);
if (!ProvinceList.Contains(hydrometricSiteModel.Province))
{
return(string.Format(ServiceRes.ProvinceNotCorrectNeedToBeOneOf_Its_, ProvinceListTxt.ToString(), hydrometricSiteModel.Province));
}
retStr = FieldCheckIfNotNullMaxLengthString(hydrometricSiteModel.FedSiteNumber, ServiceRes.FedSiteNumber, 7);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
retStr = FieldCheckIfNotNullMaxLengthString(hydrometricSiteModel.QuebecSiteNumber, ServiceRes.QuebecSiteNumber, 7);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
retStr = FieldCheckIfNotNullMaxLengthString(hydrometricSiteModel.Description, ServiceRes.Description, 200);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
retStr = FieldCheckIfNotNullWithinRangeDouble(hydrometricSiteModel.Elevation_m, ServiceRes.Elevation_m, 0, 10000);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
if (hydrometricSiteModel.StartDate_Local != null && hydrometricSiteModel.EndDate_Local != null)
{
if (hydrometricSiteModel.EndDate_Local < hydrometricSiteModel.StartDate_Local)
{
return(string.Format(ServiceRes._IsBiggerOrEqualTo_, ServiceRes.StartDate_Local, ServiceRes.EndDate_Local));
}
}
retStr = FieldCheckIfNotNullWithinRangeDouble(hydrometricSiteModel.TimeOffset_hour, ServiceRes.TimeOffset_hour, -8, -3);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
retStr = FieldCheckIfNotNullWithinRangeDouble(hydrometricSiteModel.DrainageArea_km2, ServiceRes.DrainageArea_km2, 0, 10000000);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
retStr = _BaseEnumService.DBCommandOK(hydrometricSiteModel.DBCommand);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
return("");
}
// Helper
public string CreateTVText(HydrometricSiteModel hydrometricSiteModel)
{
return(hydrometricSiteModel.HydrometricSiteName +
(hydrometricSiteModel.FedSiteNumber == null ? "" : " Fed:[" + hydrometricSiteModel.FedSiteNumber + "]") +
(hydrometricSiteModel.QuebecSiteNumber == null ? "" : " QC:[" + hydrometricSiteModel.QuebecSiteNumber + "]"));
}
