public void BoxModelLanguageService_PostAddBoxModelLanguageDB_BoxModelModelOK_Error_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
using (ShimsContext.Create())
{
BoxModelModel boxModelModelRet = boxModelServiceTest.AddBoxModelModel();
LanguageEnum LangToAdd = LanguageEnum.es;
FillBoxModelLanguageModelNew(LangToAdd, boxModelModelRet, boxModelLanguageModelNew);
string ErrorText = "ErrorText";
ShimBoxModelLanguageService shimBoxModelLanguageService = new ShimBoxModelLanguageService(boxModelLanguageService);
shimBoxModelLanguageService.BoxModelLanguageModelOKBoxModelLanguageModel = (a) =>
{
return(ErrorText);
};
BoxModelLanguageModel boxModelLanguageModelRet = boxModelLanguageService.PostAddBoxModelLanguageDB(boxModelLanguageModelNew);
Assert.AreEqual(ErrorText, boxModelLanguageModelRet.Error);
}
}
}
}
public void BoxModelLanguageService_PostAddBoxModelLanguageDB_Add_Error_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
BoxModelModel boxModelModelRet = boxModelServiceTest.AddBoxModelModel();
using (ShimsContext.Create())
{
SetupShim();
LanguageEnum LangToAdd = LanguageEnum.es;
FillBoxModelLanguageModelNew(LangToAdd, boxModelModelRet, boxModelLanguageModelNew);
//string ErrorText = "ErrorText";
shimBoxModelLanguageService.FillBoxModelLanguageModelBoxModelLanguageBoxModelLanguageModelContactOK = (a, b, c) =>
{
return("");
};
BoxModelLanguageModel boxModelLanguageModelRet = boxModelLanguageService.PostAddBoxModelLanguageDB(boxModelLanguageModelNew);
Assert.IsTrue(boxModelLanguageModelRet.Error.StartsWith(string.Format(ServiceRes.CouldNotAddError_, "").Substring(0, 10)));
}
}
}
}
public void BoxModelLanguageService_FillBoxModelLanguage_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
BoxModelModel boxModelModelRet = boxModelServiceTest.AddBoxModelModel();
LanguageEnum LangToAdd = LanguageEnum.es;
FillBoxModelLanguageModelNew(LangToAdd, boxModelModelRet, boxModelLanguageModelNew);
ContactOK contactOK = boxModelLanguageService.IsContactOK();
string retStr = boxModelLanguageService.FillBoxModelLanguageModel(boxModelLanguage, boxModelLanguageModelNew, contactOK);
Assert.AreEqual("", retStr);
Assert.AreEqual(contactOK.ContactTVItemID, boxModelLanguage.LastUpdateContactTVItemID);
contactOK = null;
retStr = boxModelLanguageService.FillBoxModelLanguageModel(boxModelLanguage, boxModelLanguageModelNew, contactOK);
Assert.AreEqual("", retStr);
Assert.AreEqual(2, boxModelLanguage.LastUpdateContactTVItemID);
}
}
}
public void BoxModelLanguageService_PostUpdateBoxModelLanguageDB_DoUpdateChanges_Error_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
BoxModelModel boxModelModelRet = boxModelServiceTest.AddBoxModelModel();
LanguageEnum LangToAdd = LanguageEnum.es;
BoxModelLanguageModel boxModelLanguageModelRet = AddBoxModelLanguageModel(LangToAdd, boxModelModelRet);
using (ShimsContext.Create())
{
SetupShim();
FillBoxModelLanguageModelUpdate(boxModelLanguageModelRet);
string ErrorText = "ErrorText";
shimBoxModelLanguageService.DoUpdateChanges = () =>
{
return(ErrorText);
};
BoxModelLanguageModel boxModelLanguageModelRet2 = boxModelLanguageService.PostUpdateBoxModelLanguageDB(boxModelLanguageModelRet);
Assert.AreEqual(ErrorText, boxModelLanguageModelRet2.Error);
}
}
}
}
public void BoxModelLanguageService_PostUpdateBoxModelLanguageDB_GetBoxModelLanguageWithBoxModelIDAndLanguageDB_Error_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
BoxModelModel boxModelModelRet = boxModelServiceTest.AddBoxModelModel();
LanguageEnum LangToAdd = LanguageEnum.es;
BoxModelLanguageModel boxModelLanguageModelRet = AddBoxModelLanguageModel(LangToAdd, boxModelModelRet);
using (ShimsContext.Create())
{
SetupShim();
FillBoxModelLanguageModelUpdate(boxModelLanguageModelRet);
//string ErrorText = "ErrorText";
shimBoxModelLanguageService.GetBoxModelLanguageWithBoxModelIDAndLanguageDBInt32LanguageEnum = (a, b) =>
{
return(null);
};
BoxModelLanguageModel boxModelLanguageModelRet2 = boxModelLanguageService.PostUpdateBoxModelLanguageDB(boxModelLanguageModelRet);
Assert.AreEqual(string.Format(ServiceRes.CouldNotFind_ToUpdate, ServiceRes.BoxModelLanguage), boxModelLanguageModelRet2.Error);
}
}
}
}
public string CheckUniquenessOfBoxModelScenarioNameDB(int InfrastructureTVItemID, int BoxModelID, string ScenarioName)
{
BoxModelModel boxModelModel = (from c in db.BoxModels
let scenarioName = (from bl in db.BoxModelLanguages where bl.Language == (int)LanguageRequest && bl.BoxModelID == c.BoxModelID select bl.ScenarioName).FirstOrDefault <string>()
where c.InfrastructureTVItemID == InfrastructureTVItemID
orderby scenarioName
select new BoxModelModel
{
Error = "",
BoxModelID = c.BoxModelID,
DBCommand = (DBCommandEnum)c.DBCommand,
ScenarioName = scenarioName,
InfrastructureTVItemID = c.InfrastructureTVItemID,
Discharge_m3_day = c.Discharge_m3_day,
Depth_m = c.Depth_m,
Temperature_C = c.Temperature_C,
Dilution = c.Dilution,
DecayRate_per_day = c.DecayRate_per_day,
FCUntreated_MPN_100ml = c.FCUntreated_MPN_100ml,
FCPreDisinfection_MPN_100ml = c.FCPreDisinfection_MPN_100ml,
Concentration_MPN_100ml = c.Concentration_MPN_100ml,
DischargeDuration_hour = c.DischargeDuration_hour,
T90_hour = c.T90_hour,
LastUpdateDate_UTC = c.LastUpdateDate_UTC,
LastUpdateContactTVItemID = c.LastUpdateContactTVItemID,
}).Where(c => c.ScenarioName == ScenarioName && c.BoxModelID != BoxModelID).FirstOrDefault();
if (boxModelModel == null)
{
return("true");
}
return(string.Format(ServiceRes._AlreadyExists, ScenarioName));
}
// Fill
public string FillBoxModel(BoxModel boxModel, BoxModelModel boxModelModel, ContactOK contactOK)
{
boxModel.DBCommand = (int)boxModelModel.DBCommand;
boxModel.InfrastructureTVItemID = boxModelModel.InfrastructureTVItemID;
boxModel.Discharge_m3_day = boxModelModel.Discharge_m3_day;
boxModel.Depth_m = boxModelModel.Depth_m;
boxModel.Temperature_C = boxModelModel.Temperature_C;
boxModel.Dilution = boxModelModel.Dilution;
boxModel.DecayRate_per_day = boxModelModel.DecayRate_per_day;
boxModel.FCUntreated_MPN_100ml = boxModelModel.FCUntreated_MPN_100ml;
boxModel.FCPreDisinfection_MPN_100ml = boxModelModel.FCPreDisinfection_MPN_100ml;
boxModel.Concentration_MPN_100ml = boxModelModel.Concentration_MPN_100ml;
boxModel.DischargeDuration_hour = boxModelModel.DischargeDuration_hour;
boxModel.T90_hour = boxModelModel.T90_hour;
boxModel.LastUpdateDate_UTC = DateTime.UtcNow;
if (contactOK == null)
{
boxModel.LastUpdateContactTVItemID = 2;
}
else
{
boxModel.LastUpdateContactTVItemID = contactOK.ContactTVItemID;
}
return("");
}
public BoxModelModel GetBoxModelModelWithBoxModelIDDB(int BoxModelID)
{
BoxModelModel boxModelModel = (from c in db.BoxModels
let scenarioName = (from bl in db.BoxModelLanguages where bl.Language == (int)LanguageRequest && bl.BoxModelID == c.BoxModelID select bl.ScenarioName).FirstOrDefault <string>()
where c.BoxModelID == BoxModelID
select new BoxModelModel
{
Error = "",
BoxModelID = c.BoxModelID,
DBCommand = (DBCommandEnum)c.DBCommand,
ScenarioName = scenarioName,
InfrastructureTVItemID = c.InfrastructureTVItemID,
Discharge_m3_day = c.Discharge_m3_day,
Depth_m = c.Depth_m,
Temperature_C = c.Temperature_C,
Dilution = c.Dilution,
DecayRate_per_day = c.DecayRate_per_day,
FCUntreated_MPN_100ml = c.FCUntreated_MPN_100ml,
FCPreDisinfection_MPN_100ml = c.FCPreDisinfection_MPN_100ml,
Concentration_MPN_100ml = c.Concentration_MPN_100ml,
DischargeDuration_hour = c.DischargeDuration_hour,
T90_hour = c.T90_hour,
LastUpdateDate_UTC = c.LastUpdateDate_UTC,
LastUpdateContactTVItemID = c.LastUpdateContactTVItemID,
}).FirstOrDefault <BoxModelModel>();
if (boxModelModel == null)
{
return(ReturnError(string.Format(ServiceRes.CouldNotFind_With_Equal_, ServiceRes.BoxModel, ServiceRes.BoxModelID, BoxModelID)));
}
return(boxModelModel);
}
public void BoxModelLanguageService_GetBoxModelLanguageModelWithBoxModelIDAndLanguageDB_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
BoxModelModel boxModelModelRet = boxModelServiceTest.AddBoxModelModel();
LanguageEnum LangToAdd = LanguageEnum.es;
BoxModelLanguageModel boxModelLanguageModelRet = AddBoxModelLanguageModel(LangToAdd, boxModelModelRet);
BoxModelLanguageModel boxModelLanguageModelRet2 = boxModelLanguageService.GetBoxModelLanguageModelWithBoxModelIDAndLanguageDB(boxModelLanguageModelRet.BoxModelID, LangToAdd);
Assert.AreEqual(boxModelLanguageModelRet.BoxModelID, boxModelLanguageModelRet2.BoxModelID);
Assert.AreEqual(boxModelLanguageModelRet.Language, boxModelLanguageModelRet2.Language);
Assert.AreEqual(LangToAdd, boxModelLanguageModelRet2.Language);
int BoxModelID = 0;
LanguageEnum LangToAdd2 = LangToAdd;
BoxModelLanguageModel boxModelLanguageModelRetError = boxModelLanguageService.GetBoxModelLanguageModelWithBoxModelIDAndLanguageDB(BoxModelID, LangToAdd2);
Assert.AreEqual(string.Format(ServiceRes.CouldNotFind_With_Equal_, ServiceRes.BoxModelLanguage, ServiceRes.BoxModelID + "," + ServiceRes.Language, BoxModelID + "," + LangToAdd2), boxModelLanguageModelRetError.Error);
BoxModelID = boxModelLanguageModelRet.BoxModelID;
LangToAdd2 = (LanguageEnum)1000; // will cause error
boxModelLanguageModelRetError = boxModelLanguageService.GetBoxModelLanguageModelWithBoxModelIDAndLanguageDB(BoxModelID, LangToAdd2);
Assert.AreEqual(string.Format(ServiceRes.CouldNotFind_With_Equal_, ServiceRes.BoxModelLanguage, ServiceRes.BoxModelID + "," + ServiceRes.Language, BoxModelID + "," + LangToAdd2), boxModelLanguageModelRetError.Error);
}
}
}
public void BoxModelLanguageService_PostDeleteBoxModelLanguageDB_IsContactOK_Error_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
BoxModelModel boxModelModelRet = boxModelServiceTest.AddBoxModelModel();
LanguageEnum LangToAdd = LanguageEnum.es;
BoxModelLanguageModel boxModelLanguageModelRet = AddBoxModelLanguageModel(LangToAdd, boxModelModelRet);
BoxModelLanguageModel boxModelLanguageModelRet2 = UpdateBoxModelLanguageModel(boxModelLanguageModelRet);
using (ShimsContext.Create())
{
SetupShim();
string ErrorText = "ErrorText";
shimBoxModelLanguageService.IsContactOK = () =>
{
return(new ContactOK()
{
Error = ErrorText
});
};
BoxModelLanguageModel boxModelLanguageModelRet3 = boxModelLanguageService.PostDeleteBoxModelLanguageDB(boxModelLanguageModelRet2.BoxModelID, LangToAdd);
Assert.AreEqual(ErrorText, boxModelLanguageModelRet3.Error);
}
}
}
}
public PartialViewResult _boxModelEdit(int BoxModelID)
{
BoxModelModel boxModelModel = _BoxModelService.GetBoxModelModelWithBoxModelIDDB(BoxModelID);
ViewBag.BoxModelModel = boxModelModel;
return(PartialView());
}
public void BoxModelController_SaveBoxModelScenarioJSON_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
// Arrange
controllerAction = "_boxModelList";
// Act
SetupTest(contactModelListGood[0], culture, controllerAction);
using (TransactionScope ts = new TransactionScope())
{
// Act
TVItemModel tvItemModelMunicipality = randomService.RandomTVItem(TVTypeEnum.Municipality);
// Assert
Assert.AreEqual("", tvItemModelMunicipality.Error);
// Act
TVItemModel tvItemModelInfrastructure = tvItemService.PostAddChildTVItemDB(tvItemModelMunicipality.TVItemID, "Infras ", TVTypeEnum.Infrastructure);
// Assert
Assert.AreEqual("", tvItemModelInfrastructure.Error);
// Act
BoxModelModel boxModelModelRet = randomService.RandomBoxModelModel(tvItemModelInfrastructure, true);
// Assert
Assert.AreEqual("", boxModelModelRet.Error);
string Q = "!Login/aaa/bbb|||" + tvItemModelInfrastructure.TVItemID + "/1|||";
// Act
PartialViewResult partialViewResult = controller._boxModelList(Q) as PartialViewResult;
// Assert
Assert.IsNotNull(partialViewResult);
List <BoxModelModel> boxModelModelList = (List <BoxModelModel>)partialViewResult.ViewBag.BoxModelModelList;
Assert.IsNotNull(boxModelModelList);
Assert.AreEqual(1, boxModelModelList.Count);
int BoxModelID = boxModelModelList[0].BoxModelID;
FormCollection fc = FillFormCollection(boxModelModelList[0]);
// Act
JsonResult jsonResult = controller.SaveBoxModelScenarioJSON(fc) as JsonResult;
// Assert
Assert.IsNotNull(jsonResult);
string retStr = (string)jsonResult.Data;
Assert.AreEqual("", retStr);
}
}
}
private void FillBoxModelLanguageModelNew(LanguageEnum Language, BoxModelModel boxModelModel, BoxModelLanguageModel boxModelLanguageModel)
{
boxModelLanguageModel.BoxModelID = boxModelModel.BoxModelID;
boxModelLanguageModel.Language = Language;
boxModelLanguageModel.ScenarioName = randomService.RandomString("TV Text", 20);
boxModelLanguageModel.TranslationStatus = TranslationStatusEnum.Translated;
Assert.IsTrue(boxModelLanguageModel.BoxModelID != 0);
Assert.IsTrue(boxModelLanguageModel.Language == Language);
Assert.IsTrue(boxModelLanguageModel.ScenarioName.Length == 20);
Assert.IsTrue(boxModelLanguageModel.TranslationStatus == TranslationStatusEnum.Translated);
}
public BoxModelModel CreateNewBMScenarioDB(int InfrastructureTVItemID)
{
if (InfrastructureTVItemID == 0)
{
return(ReturnError(string.Format(ServiceRes._IsRequired, ServiceRes.InfrastructureTVItemID)));
}
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrWhiteSpace(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
double Discharge_m3_day = 1234f;
double DischargeDuration_hour = 24f;
int Dilution = 1000;
double T90_hour = 6f;
double Temperature_C = 10f;
double DecayRate_per_day = 4.6821f;
double Depth_m = 2f;
int FCUntreated_MPN_100ml = 3200000;
int FCPreDisinfection_MPN_100ml = 800;
int Concentration_MPN_100ml = 14;
BoxModelModel boxModelModelNew = new BoxModelModel()
{
DBCommand = DBCommandEnum.Original,
Concentration_MPN_100ml = Concentration_MPN_100ml,
DecayRate_per_day = DecayRate_per_day,
Depth_m = Depth_m,
Dilution = Dilution,
FCPreDisinfection_MPN_100ml = FCPreDisinfection_MPN_100ml,
FCUntreated_MPN_100ml = FCUntreated_MPN_100ml,
Discharge_m3_day = Discharge_m3_day,
DischargeDuration_hour = DischargeDuration_hour,
T90_hour = T90_hour,
Temperature_C = Temperature_C,
InfrastructureTVItemID = InfrastructureTVItemID,
ScenarioName = "__ " + ServiceRes.NewBoxModelScenario,
};
BoxModelModel boxModelModelRet = PostAddBoxModelDB(boxModelModelNew);
if (!string.IsNullOrWhiteSpace(boxModelModelRet.Error))
{
return(ReturnError(boxModelModelRet.Error));
}
return(boxModelModelRet);
}
public void ReportService_GetReportBox_Model_ResultModelListUnderTVItemIDDB_Loop_Error_Box_Model_Null_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
TVItemModel tvItemModelRoot = tvItemService.GetRootTVItemModelDB();
Assert.AreEqual("", tvItemModelRoot.Error);
TVItemModel tvItemModelCountry = tvItemService.GetChildTVItemModelWithTVItemIDAndTVTextStartWithAndTVTypeDB(tvItemModelRoot.TVItemID, "Canada", TVTypeEnum.Country);
Assert.AreEqual("", tvItemModelCountry.Error);
TVItemModel tvItemModelSubsector = tvItemService.GetChildTVItemModelWithTVItemIDAndTVTextStartWithAndTVTypeDB(tvItemModelRoot.TVItemID, "NB-06-020-002", TVTypeEnum.Subsector);
Assert.AreEqual("", tvItemModelSubsector.Error);
TVItemModel tvItemModelMunicipality = tvItemService.GetChildTVItemModelWithTVItemIDAndTVTextStartWithAndTVTypeDB(tvItemModelSubsector.TVItemID,
"Bouctouche", TVTypeEnum.Municipality);
Assert.AreEqual("", tvItemModelMunicipality.Error);
List <TVItemModel> tvItemModelInfrastructureList = tvItemService.GetChildrenTVItemModelListWithTVItemIDAndTVTypeDB(tvItemModelMunicipality.TVItemID, TVTypeEnum.Infrastructure);
Assert.IsTrue(tvItemModelInfrastructureList.Count > 0);
TVItemModel tvItemModelInfrastructure = tvItemModelInfrastructureList.Where(c => c.TVText.Contains("WWTP")).FirstOrDefault();
Assert.IsNotNull(tvItemModelInfrastructure);
List <BoxModelModel> boxModelModelList = boxModelService.GetBoxModelModelOrderByScenarioNameDB(tvItemModelInfrastructure.TVItemID);
Assert.IsTrue(boxModelModelList.Count > 0);
BoxModelModel boxModelModel = boxModelModelList.FirstOrDefault();
Assert.IsNotNull(boxModelModel);
StringBuilder sb = new StringBuilder();
sb.AppendLine("|||Loop Box_Model_Result " + culture.TwoLetterISOLanguageName);
sb.AppendLine("Box_Model_Result_ID");
sb.AppendLine("|||");
LanguageEnum Language = (culture.TwoLetterISOLanguageName == "fr" ? LanguageEnum.fr : LanguageEnum.en);
string TagText = sb.ToString();
int UnderTVItemID = 0;
string ParentTagItem = "Box_Model";
bool CountOnly = false;
int Take = 10;
List <ReportBox_Model_ResultModel> ReportBox_Model_ResultModelList = reportServiceBox_Model_Result.GetReportBox_Model_ResultModelListUnderTVItemIDDB(Language, TagText, UnderTVItemID, ParentTagItem, CountOnly, Take);
Assert.IsTrue(ReportBox_Model_ResultModelList.Count > 0);
Assert.AreEqual(string.Format(ServiceRes.CouldNotFind_With_Equal_, ServiceRes.BoxModel, ServiceRes.BoxModelID, UnderTVItemID.ToString()), ReportBox_Model_ResultModelList[0].Box_Model_Result_Error);
}
}
public void BoxModelController_CalculateDecayJSON_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
// Arrange
controllerAction = "CalculateDecayJSON";
// Act
SetupTest(contactModelListGood[0], culture, controllerAction);
using (TransactionScope ts = new TransactionScope())
{
// Act
TVItemModel tvItemModelMunicipality = randomService.RandomTVItem(TVTypeEnum.Municipality);
// Assert
Assert.AreEqual("", tvItemModelMunicipality.Error);
// Act
TVItemModel tvItemModelInfrastructure = tvItemService.PostAddChildTVItemDB(tvItemModelMunicipality.TVItemID, "Infras ", TVTypeEnum.Infrastructure);
// Assert
Assert.AreEqual("", tvItemModelInfrastructure.Error);
// Act
BoxModelModel boxModelModelRet = randomService.RandomBoxModelModel(tvItemModelInfrastructure, true);
// Act
JsonResult jsonResult = controller.CalculateDecayJSON(6, 10) as JsonResult;
// Assert
Assert.IsNotNull(jsonResult);
CalDecay calDecay = (CalDecay)jsonResult.Data;
Assert.AreEqual("", calDecay.Error);
Assert.AreEqual(4.6821, calDecay.Decay, 0.0001);
// Act
jsonResult = controller.CalculateDecayJSON(500, 10) as JsonResult;
// Assert
Assert.IsNotNull(jsonResult);
calDecay = (CalDecay)jsonResult.Data;
Assert.AreEqual("", calDecay.Error);
Assert.AreEqual(0.0562, calDecay.Decay, 0.0001);
}
}
}
public BoxModelModel CopyBoxModelScenarioDB(int BoxModelID)
{
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrWhiteSpace(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
BoxModelModel boxModelModelToCopy = GetBoxModelModelWithBoxModelIDDB(BoxModelID);
if (!string.IsNullOrWhiteSpace(boxModelModelToCopy.Error))
{
return(ReturnError(boxModelModelToCopy.Error));
}
BoxModelModel boxModelModelNew = new BoxModelModel()
{
DBCommand = DBCommandEnum.Original,
Concentration_MPN_100ml = boxModelModelToCopy.Concentration_MPN_100ml,
DecayRate_per_day = boxModelModelToCopy.DecayRate_per_day,
Depth_m = boxModelModelToCopy.Depth_m,
Dilution = boxModelModelToCopy.Dilution,
FCPreDisinfection_MPN_100ml = boxModelModelToCopy.FCPreDisinfection_MPN_100ml,
FCUntreated_MPN_100ml = boxModelModelToCopy.FCUntreated_MPN_100ml,
Discharge_m3_day = boxModelModelToCopy.Discharge_m3_day,
DischargeDuration_hour = boxModelModelToCopy.DischargeDuration_hour,
T90_hour = boxModelModelToCopy.T90_hour,
Temperature_C = boxModelModelToCopy.Temperature_C,
InfrastructureTVItemID = boxModelModelToCopy.InfrastructureTVItemID,
FixLength = boxModelModelToCopy.FixLength,
FixWidth = boxModelModelToCopy.FixWidth,
Length_m = boxModelModelToCopy.Length_m,
Width_m = boxModelModelToCopy.Width_m,
ScenarioName = "_ " + ServiceRes.CopyOf + " " + boxModelModelToCopy.ScenarioName,
};
BoxModelModel boxModelModelRet = PostAddBoxModelDB(boxModelModelNew);
if (!string.IsNullOrWhiteSpace(boxModelModelRet.Error))
{
return(ReturnError(boxModelModelRet.Error));
}
return(boxModelModelRet);
}
public void BoxModelLanguageService_GetBoxModelModelCountDB_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
BoxModelModel boxModelModelRet = boxModelServiceTest.AddBoxModelModel();
LanguageEnum LangToAdd = LanguageEnum.es;
BoxModelLanguageModel boxModelModelLanguageRet = AddBoxModelLanguageModel(LangToAdd, boxModelModelRet);
int boxModelCount = boxModelLanguageService.GetBoxModelLanguageModelCountDB();
Assert.AreEqual(testDBService.Count + 3, boxModelCount);
}
}
}
public void BoxModelController__boxModelResults_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
// Arrange
controllerAction = "_boxModelResults";
// Act
SetupTest(contactModelListGood[0], culture, controllerAction);
using (TransactionScope ts = new TransactionScope())
{
// Act
TVItemModel tvItemModelMunicipality = randomService.RandomTVItem(TVTypeEnum.Municipality);
// Assert
Assert.AreEqual("", tvItemModelMunicipality.Error);
// Act
TVItemModel tvItemModelInfrastructure = tvItemService.PostAddChildTVItemDB(tvItemModelMunicipality.TVItemID, "Infras ", TVTypeEnum.Infrastructure);
// Assert
Assert.AreEqual("", tvItemModelInfrastructure.Error);
// Act
BoxModelModel boxModelModelRet = randomService.RandomBoxModelModel(tvItemModelInfrastructure, true);
// Act
PartialViewResult partialViewResult = controller._boxModelResults(boxModelModelRet.BoxModelID) as PartialViewResult;
// Assert
Assert.IsNotNull(partialViewResult);
List <BoxModelResultModel> boxModelResultModelList = (List <BoxModelResultModel>)partialViewResult.ViewBag.BoxModelResultModelList;
Assert.IsNotNull(boxModelResultModelList);
Assert.AreEqual(5, boxModelResultModelList.Count);
Assert.AreEqual(boxModelModelRet.BoxModelID, boxModelResultModelList[0].BoxModelID);
Assert.AreEqual(BoxModelResultTypeEnum.Dilution, boxModelResultModelList[0].BoxModelResultType);
}
}
}
public void BoxModelLanguageService_PostAddBoxModelLanguageDB_Good_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
BoxModelModel boxModelModelRet = boxModelServiceTest.AddBoxModelModel();
LanguageEnum LangToAdd = LanguageEnum.es;
BoxModelLanguageModel boxModelLanguageModelRet = AddBoxModelLanguageModel(LangToAdd, boxModelModelRet);
BoxModelLanguageModel boxModelLanguageModelRet2 = UpdateBoxModelLanguageModel(boxModelLanguageModelRet);
BoxModelLanguageModel boxModelLanguageModelRet3 = boxModelLanguageService.PostDeleteBoxModelLanguageDB(boxModelLanguageModelRet2.BoxModelID, LangToAdd);
Assert.AreEqual("", boxModelLanguageModelRet3.Error);
}
}
}
public void BoxModelLanguageService_PostAddBoxModelLanguageDB_UserEmailNotValidated_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
BoxModelModel boxModelModelRet = boxModelServiceTest.AddBoxModelModel();
LanguageEnum LangToAdd = LanguageEnum.es;
ContactModel contactModelBad = contactModelListGood[2];
IPrincipal userBad = new GenericPrincipal(new GenericIdentity(contactModelBad.LoginEmail, "Forms"), null);
boxModelLanguageService = new BoxModelLanguageService((culture.TwoLetterISOLanguageName == "fr" ? LanguageEnum.fr : LanguageEnum.en), userBad);
BoxModelLanguageModel boxModelLanguageModelRet = AddBoxModelLanguageModel(LangToAdd, boxModelModelRet);
Assert.AreEqual(ServiceRes.EmailRequiresValidation, boxModelLanguageModelRet.Error);
}
}
}
public void BoxModelLanguageService_GetBoxModelLanguageWithBoxModelIDAndLanguageDB_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
BoxModelModel boxModelModelRet = boxModelServiceTest.AddBoxModelModel();
LanguageEnum LangToAdd = LanguageEnum.es;
BoxModelLanguageModel boxModelLanguageModelRet = AddBoxModelLanguageModel(LangToAdd, boxModelModelRet);
BoxModelLanguage boxModelLanguageRet2 = boxModelLanguageService.GetBoxModelLanguageWithBoxModelIDAndLanguageDB(boxModelLanguageModelRet.BoxModelID, LangToAdd);
Assert.AreEqual(boxModelLanguageModelRet.BoxModelID, boxModelLanguageRet2.BoxModelID);
Assert.AreEqual(boxModelLanguageModelRet.Language, (LanguageEnum)boxModelLanguageRet2.Language);
Assert.AreEqual(LangToAdd, (LanguageEnum)boxModelLanguageRet2.Language);
}
}
}
private FormCollection FillFormCollection(BoxModelModel boxModelModel)
{
FormCollection fc = new FormCollection();
fc.Add("BoxModelID", boxModelModel.BoxModelID.ToString());
fc.Add("ScenarioName", randomService.RandomString("ScenarioName ", 30));
fc.Add("Flow_m3_day", randomService.RandomDouble(10, 1000).ToString());
fc.Add("FlowDuration_hour", randomService.RandomDouble(10, 23).ToString());
fc.Add("Dilution", randomService.RandomDouble(10, 1000).ToString());
fc.Add("T90_hour", randomService.RandomDouble(10, 1000).ToString());
fc.Add("Temperature_C", randomService.RandomDouble(10, 15).ToString());
fc.Add("DecayRate_per_day", randomService.RandomDouble(4.0, 4.68).ToString());
fc.Add("Depth_m", randomService.RandomDouble(10, 20).ToString());
fc.Add("FCUntreated_MPN_100ml", randomService.RandomInt(10000, 1000000).ToString());
fc.Add("FCPreDisinfection_MPN_100ml", randomService.RandomInt(10000, 10000).ToString());
fc.Add("Concentration_MPN_100ml", randomService.RandomInt(100, 10000).ToString());
fc.Add("FixLength", null);
fc.Add("FixWidth", null);
fc.Add("Length_m", randomService.RandomDouble(10, 1000).ToString());
fc.Add("Width_m", randomService.RandomDouble(10, 1000).ToString());
return(fc);
}
public void BoxModelController_CopyBoxModelScenarioJSON_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
// Arrange
controllerAction = "CopyBoxModelScenarioJSON";
// Act
SetupTest(contactModelListGood[0], culture, controllerAction);
using (TransactionScope ts = new TransactionScope())
{
// Act
TVItemModel tvItemModelMunicipality = randomService.RandomTVItem(TVTypeEnum.Municipality);
// Assert
Assert.AreEqual("", tvItemModelMunicipality.Error);
// Act
TVItemModel tvItemModelInfrastructure = tvItemService.PostAddChildTVItemDB(tvItemModelMunicipality.TVItemID, "Infras ", TVTypeEnum.Infrastructure);
// Assert
Assert.AreEqual("", tvItemModelInfrastructure.Error);
// Act
BoxModelModel boxModelModelRet = randomService.RandomBoxModelModel(tvItemModelInfrastructure, true);
// Act
JsonResult jsonResult = controller.CopyBoxModelScenarioJSON(boxModelModelRet.BoxModelID) as JsonResult;
// Assert
Assert.IsNotNull(jsonResult);
string retStr = (string)jsonResult.Data;
Assert.AreEqual("", retStr);
}
}
}
public BoxModelModel PostUpdateBoxModelDB(BoxModelModel boxModelModel)
{
string retStr = BoxModelModelOK(boxModelModel);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrEmpty(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
BoxModel boxModelToUpdate = GetBoxModelWithBoxModelIDDB(boxModelModel.BoxModelID);
if (boxModelToUpdate == null)
{
return(ReturnError(string.Format(ServiceRes.CouldNotFind_ToUpdate, ServiceRes.BoxModel)));
}
retStr = FillBoxModel(boxModelToUpdate, boxModelModel, 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("BoxModels", boxModelToUpdate.BoxModelID, LogCommandEnum.Change, boxModelToUpdate);
if (!string.IsNullOrWhiteSpace(logModel.Error))
{
return(ReturnError(logModel.Error));
}
foreach (LanguageEnum Lang in LanguageListAllowable)
{
BoxModelLanguageModel boxModelLanguageModel = new BoxModelLanguageModel()
{
DBCommand = DBCommandEnum.Original,
BoxModelID = boxModelModel.BoxModelID,
Language = Lang,
ScenarioName = boxModelModel.ScenarioName,
TranslationStatus = (Lang == LanguageRequest ? TranslationStatusEnum.Translated : TranslationStatusEnum.NotTranslated),
};
BoxModelLanguageModel boxModelLanguageModelRet = _BoxModelLanguageService.PostUpdateBoxModelLanguageDB(boxModelLanguageModel);
if (!string.IsNullOrEmpty(boxModelLanguageModelRet.Error))
{
return(ReturnError(string.Format(ServiceRes.CouldNotAddError_, boxModelLanguageModelRet.Error)));
}
}
// Calculating results and adding results in BoxModelResults
boxModelModel.BoxModelID = boxModelToUpdate.BoxModelID;
BoxModelModel boxModelModelRet2 = AddOrUpdateBoxModelResultModel(boxModelModel);
if (!string.IsNullOrWhiteSpace(boxModelModelRet2.Error))
{
return(ReturnError(boxModelModelRet2.Error));
}
ts.Complete();
}
return(GetBoxModelModelWithBoxModelIDDB(boxModelToUpdate.BoxModelID));
}
// Check
public string BoxModelModelOK(BoxModelModel boxModelModel)
{
string retStr = FieldCheckNotZeroInt(boxModelModel.InfrastructureTVItemID, ServiceRes.InfraTVItemID);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
retStr = FieldCheckNotNullAndMinMaxLengthString(boxModelModel.ScenarioName, ServiceRes.ScenarioName, 2, 100);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
retStr = FieldCheckNotNullAndWithinRangeDouble(boxModelModel.Discharge_m3_day, ServiceRes.Discharge_m3_day, (double)1D, (double)30000000D);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
retStr = FieldCheckNotNullAndWithinRangeDouble(boxModelModel.Depth_m, ServiceRes.Depth_m, (double)0.01D, (double)10000D);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
retStr = FieldCheckNotNullAndWithinRangeDouble(boxModelModel.Temperature_C, ServiceRes.Temperature_C, (double)0.1D, (double)35D);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
retStr = FieldCheckNotNullAndWithinRangeDouble(boxModelModel.Dilution, ServiceRes.Dilution, (double)1D, (double)30000000D);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
retStr = FieldCheckNotNullAndWithinRangeDouble(boxModelModel.DecayRate_per_day, ServiceRes.DecayRate_per_day, (double)0.0001D, (double)1000D);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
retStr = FieldCheckNotNullAndWithinRangeInt(boxModelModel.FCUntreated_MPN_100ml, ServiceRes.FCUntreated_MPN_100ml, 1, 30000000);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
retStr = FieldCheckNotNullAndWithinRangeInt(boxModelModel.FCPreDisinfection_MPN_100ml, ServiceRes.FCPreDisinfection_MPN_100ml, 1, 30000000);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
retStr = FieldCheckNotNullAndWithinRangeInt(boxModelModel.Concentration_MPN_100ml, ServiceRes.Concentration_MPN_100ml, 1, 30000000);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
retStr = FieldCheckNotNullAndWithinRangeDouble(boxModelModel.DischargeDuration_hour, ServiceRes.DischargeDuration_hour, 1, 24);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
retStr = FieldCheckNotNullAndWithinRangeDouble(boxModelModel.T90_hour, ServiceRes.T90_hour, 1, 1000);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
retStr = _BaseEnumService.DBCommandOK(boxModelModel.DBCommand);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
return("");
}
public BoxModelModel SaveBoxModelScenarioDB(FormCollection fc)
{
int BoxModelID = 0;
double Discharge_m3_day = 0;
double DischargeDuration_hour = 0;
int Dilution = 0;
double T90_hour = 0;
double Temperature_C = 0;
double DecayRate_per_day = 0;
double Depth_m = 0;
int FCUntreated_MPN_100ml = 0;
int FCPreDisinfection_MPN_100ml = 0;
int Concentration_MPN_100ml = 0;
bool FixLength = false;
bool FixWidth = false;
double Length_m = 0.0D;
double Width_m = 0.0D;
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrWhiteSpace(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
int.TryParse(fc["BoxModelID"], out BoxModelID);
if (BoxModelID == 0)
{
return(ReturnError(string.Format(ServiceRes._IsRequired, ServiceRes.BoxModelID)));
}
BoxModelModel boxModelModelToChange = GetBoxModelModelWithBoxModelIDDB(BoxModelID);
if (!string.IsNullOrWhiteSpace(boxModelModelToChange.Error))
{
return(ReturnError(boxModelModelToChange.Error));
}
string ScenarioName = fc["ScenarioName"];
if (string.IsNullOrWhiteSpace(ScenarioName))
{
return(ReturnError(string.Format(ServiceRes._IsRequired, ServiceRes.ScenarioName)));
}
boxModelModelToChange.ScenarioName = ScenarioName;
string retStr = CheckUniquenessOfBoxModelScenarioNameDB(boxModelModelToChange.InfrastructureTVItemID, boxModelModelToChange.BoxModelID, ScenarioName);
if (retStr != "true")
{
return(ReturnError(retStr));
}
double.TryParse(fc["T90_hour"], out T90_hour);
if (T90_hour == 0)
{
return(ReturnError(string.Format(ServiceRes._IsRequired, ServiceRes.T90_hour)));
}
boxModelModelToChange.T90_hour = T90_hour;
double.TryParse(fc["Temperature_C"], out Temperature_C);
if (Temperature_C == 0)
{
return(ReturnError(string.Format(ServiceRes._IsRequired, ServiceRes.Temperature_C)));
}
boxModelModelToChange.Temperature_C = Temperature_C;
double.TryParse(fc["DecayRate_per_day"], out DecayRate_per_day);
if (DecayRate_per_day == 0)
{
return(ReturnError(string.Format(ServiceRes._IsRequired, ServiceRes.DecayRate_per_day)));
}
boxModelModelToChange.DecayRate_per_day = DecayRate_per_day;
double.TryParse(fc["Discharge_m3_day"], out Discharge_m3_day);
if (Discharge_m3_day == 0)
{
return(ReturnError(string.Format(ServiceRes._IsRequired, ServiceRes.Discharge_m3_day)));
}
boxModelModelToChange.Discharge_m3_day = Discharge_m3_day;
double.TryParse(fc["DischargeDuration_hour"], out DischargeDuration_hour);
if (DischargeDuration_hour == 0)
{
return(ReturnError(string.Format(ServiceRes._IsRequired, ServiceRes.DischargeDuration_hour)));
}
boxModelModelToChange.DischargeDuration_hour = DischargeDuration_hour;
int.TryParse(fc["Dilution"], out Dilution);
if (Dilution == 0)
{
return(ReturnError(string.Format(ServiceRes._IsRequired, ServiceRes.Dilution)));
}
boxModelModelToChange.Dilution = Dilution;
double.TryParse(fc["Depth_m"], out Depth_m);
if (Depth_m == 0)
{
return(ReturnError(string.Format(ServiceRes._IsRequired, ServiceRes.Depth_m)));
}
boxModelModelToChange.Depth_m = Depth_m;
int.TryParse(fc["FCUntreated_MPN_100ml"], out FCUntreated_MPN_100ml);
if (FCUntreated_MPN_100ml == 0)
{
return(ReturnError(string.Format(ServiceRes._IsRequired, ServiceRes.FCUntreated_MPN_100ml)));
}
boxModelModelToChange.FCUntreated_MPN_100ml = FCUntreated_MPN_100ml;
int.TryParse(fc["FCPreDisinfection_MPN_100ml"], out FCPreDisinfection_MPN_100ml);
if (FCPreDisinfection_MPN_100ml == 0)
{
return(ReturnError(string.Format(ServiceRes._IsRequired, ServiceRes.FCPreDisinfection_MPN_100ml)));
}
boxModelModelToChange.FCPreDisinfection_MPN_100ml = FCPreDisinfection_MPN_100ml;
int.TryParse(fc["Concentration_MPN_100ml"], out Concentration_MPN_100ml);
if (Concentration_MPN_100ml == 0)
{
return(ReturnError(string.Format(ServiceRes._IsRequired, ServiceRes.Concentration_MPN_100ml)));
}
boxModelModelToChange.Concentration_MPN_100ml = Concentration_MPN_100ml;
if (fc["FixLength"] != null)
{
FixLength = true;
}
else
{
FixLength = false;
}
if (fc["FixWidth"] != null)
{
FixWidth = true;
}
else
{
FixWidth = false;
}
if (FixLength)
{
double.TryParse(fc["Length_m"], out Length_m);
if (Length_m <= 0.0D)
{
return(ReturnError(string.Format(ServiceRes._IsRequired, ServiceRes.Length_m)));
}
boxModelModelToChange.Length_m = Length_m;
}
if (FixWidth)
{
double.TryParse(fc["Width_m"], out Width_m);
if (Width_m <= 0.0D)
{
return(ReturnError(string.Format(ServiceRes._IsRequired, ServiceRes.Width_m)));
}
boxModelModelToChange.Width_m = Width_m;
}
if (FixLength == true && FixWidth == true)
{
return(ReturnError(ServiceRes.FixLengthAndFixWidthShouldNotBeCheckedAtTheSameTime));
}
if (FixLength == true)
{
if (Length_m < 1.0D)
{
return(ReturnError(ServiceRes.LengthShouldNotBeZeroWhenFixLengthIsChecked));
}
}
if (FixWidth == true)
{
if (Width_m < 1.0D)
{
return(ReturnError(ServiceRes.WidthShouldNotBeZeroWhenFixWidthIsChecked));
}
}
boxModelModelToChange.FixLength = FixLength;
boxModelModelToChange.FixWidth = FixWidth;
boxModelModelToChange.DBCommand = DBCommandEnum.Original;
using (TransactionScope ts = new TransactionScope())
{
BoxModelModel boxModelModelRet = PostUpdateBoxModelDB(boxModelModelToChange);
if (!string.IsNullOrWhiteSpace(boxModelModelRet.Error))
{
return(ReturnError(boxModelModelRet.Error));
}
ts.Complete();
}
return(boxModelModelToChange);
}
public void BoxModelLanguageService_BoxModelLanguageModelOK_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
LanguageEnum LangToAdd = LanguageEnum.es;
using (TransactionScope ts = new TransactionScope())
{
BoxModelModel boxModelModelRet = boxModelServiceTest.AddBoxModelModel();
#region BoxModelID
FillBoxModelLanguageModelNew(LangToAdd, boxModelModelRet, boxModelLanguageModelNew);
boxModelLanguageModelNew.BoxModelID = 0;
string retStr = boxModelLanguageService.BoxModelLanguageModelOK(boxModelLanguageModelNew);
Assert.AreEqual(string.Format(ServiceRes._IsRequired, ServiceRes.BoxModelID), retStr);
#endregion BoxModelID
#region Language
int Min = 2;
int Max = 2;
FillBoxModelLanguageModelNew(LangToAdd, boxModelModelRet, boxModelLanguageModelNew);
boxModelLanguageModelNew.Language = LanguageEnum.en;
retStr = boxModelLanguageService.BoxModelLanguageModelOK(boxModelLanguageModelNew);
Assert.AreEqual("", retStr);
FillBoxModelLanguageModelNew(LangToAdd, boxModelModelRet, boxModelLanguageModelNew);
boxModelLanguageModelNew.Language = (LanguageEnum)10000;
retStr = boxModelLanguageService.BoxModelLanguageModelOK(boxModelLanguageModelNew);
Assert.AreEqual(string.Format(ServiceRes._IsRequired, ServiceRes.Language), retStr);
#endregion Language
#region ScenarioName
FillBoxModelLanguageModelNew(LangToAdd, boxModelModelRet, boxModelLanguageModelNew);
Max = 250;
boxModelLanguageModelNew.ScenarioName = randomService.RandomString("", Min - 1);
retStr = boxModelLanguageService.BoxModelLanguageModelOK(boxModelLanguageModelNew);
Assert.AreEqual(string.Format(ServiceRes._MinLengthIs_, ServiceRes.ScenarioName, Min), retStr);
FillBoxModelLanguageModelNew(LangToAdd, boxModelModelRet, boxModelLanguageModelNew);
boxModelLanguageModelNew.ScenarioName = randomService.RandomString("", Max + 1);
retStr = boxModelLanguageService.BoxModelLanguageModelOK(boxModelLanguageModelNew);
Assert.AreEqual(string.Format(ServiceRes._MaxLengthIs_, ServiceRes.ScenarioName, Max), retStr);
FillBoxModelLanguageModelNew(LangToAdd, boxModelModelRet, boxModelLanguageModelNew);
boxModelLanguageModelNew.ScenarioName = randomService.RandomString("", Max - 1);
retStr = boxModelLanguageService.BoxModelLanguageModelOK(boxModelLanguageModelNew);
Assert.AreEqual("", retStr);
FillBoxModelLanguageModelNew(LangToAdd, boxModelModelRet, boxModelLanguageModelNew);
boxModelLanguageModelNew.ScenarioName = randomService.RandomString("", Max);
retStr = boxModelLanguageService.BoxModelLanguageModelOK(boxModelLanguageModelNew);
Assert.AreEqual("", retStr);
#endregion ScenarioName
}
}
}
// Helper
public BoxModelModel AddOrUpdateBoxModelResultModel(BoxModelModel boxModelModel)
{
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrWhiteSpace(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
bool ShouldAdd = true;
for (int i = 1; i < 6; i++)
{
BoxModelResultModel boxModelResultModel;
BoxModelResultModel boxModelResultModelRet = _BoxModelResultService.GetBoxModelResultModelWithBoxModelIDAndResultTypeDB(boxModelModel.BoxModelID, (BoxModelResultTypeEnum)i);
if (!string.IsNullOrWhiteSpace(boxModelResultModelRet.Error))
{
ShouldAdd = true;
boxModelResultModel = new BoxModelResultModel();
}
else
{
ShouldAdd = false;
boxModelResultModel = boxModelResultModelRet;
}
boxModelResultModel.DBCommand = DBCommandEnum.Original;
boxModelResultModel.BoxModelID = boxModelModel.BoxModelID;
boxModelResultModel.BoxModelResultType = (BoxModelResultTypeEnum)i;
switch (i)
{
case (int)BoxModelResultTypeEnum.Dilution:
{
boxModelResultModel.Volume_m3 = (boxModelModel.Discharge_m3_day * (boxModelModel.DischargeDuration_hour / 24) * boxModelModel.Dilution);
}
break;
case (int)BoxModelResultTypeEnum.NoDecayUntreated:
{
boxModelResultModel.Volume_m3 = (boxModelModel.Discharge_m3_day * (boxModelModel.DischargeDuration_hour / 24) * boxModelModel.FCUntreated_MPN_100ml) / boxModelModel.Concentration_MPN_100ml;
}
break;
case (int)BoxModelResultTypeEnum.NoDecayPreDisinfection:
{
boxModelResultModel.Volume_m3 = (boxModelModel.Discharge_m3_day * (boxModelModel.DischargeDuration_hour / 24) * boxModelModel.FCPreDisinfection_MPN_100ml) / boxModelModel.Concentration_MPN_100ml;
}
break;
case (int)BoxModelResultTypeEnum.DecayUntreated:
{
boxModelResultModel.Volume_m3 = (boxModelModel.Discharge_m3_day * (boxModelModel.DischargeDuration_hour / 24) * (boxModelModel.FCUntreated_MPN_100ml - boxModelModel.Concentration_MPN_100ml)) / boxModelModel.DecayRate_per_day / boxModelModel.Concentration_MPN_100ml;
}
break;
case (int)BoxModelResultTypeEnum.DecayPreDisinfection:
{
boxModelResultModel.Volume_m3 = (boxModelModel.Discharge_m3_day * (boxModelModel.DischargeDuration_hour / 24) * (boxModelModel.FCPreDisinfection_MPN_100ml - boxModelModel.Concentration_MPN_100ml)) / boxModelModel.DecayRate_per_day / boxModelModel.Concentration_MPN_100ml;
}
break;
default:
break;
}
boxModelResultModel.Surface_m2 = boxModelResultModel.Volume_m3 / boxModelModel.Depth_m;
boxModelResultModel.Radius_m = Math.Sqrt(2 * ((double)boxModelResultModel.Volume_m3) / boxModelModel.Depth_m / Math.PI);
if (boxModelModel.FixLength == false && boxModelModel.FixWidth == false)
{
boxModelResultModel.FixLength = false;
boxModelResultModel.FixWidth = false;
boxModelResultModel.RectLength_m = Math.Sqrt((double)boxModelResultModel.Volume_m3 / boxModelModel.Depth_m);
boxModelResultModel.RectWidth_m = boxModelResultModel.RectLength_m;
}
else if (boxModelModel.FixLength == true)
{
boxModelResultModel.FixLength = true;
boxModelResultModel.FixWidth = false;
boxModelResultModel.RectLength_m = boxModelModel.Length_m;
boxModelResultModel.RectWidth_m = boxModelResultModel.Volume_m3 / (boxModelModel.Depth_m * boxModelResultModel.RectLength_m);
}
else if (boxModelModel.FixWidth == true)
{
boxModelResultModel.FixLength = false;
boxModelResultModel.FixWidth = true;
boxModelResultModel.RectWidth_m = boxModelModel.Width_m;
boxModelResultModel.RectLength_m = boxModelResultModel.Volume_m3 / (boxModelModel.Depth_m * boxModelResultModel.RectWidth_m);
}
BoxModelResultModel boxModelResultModelRet2 = new BoxModelResultModel();
if (ShouldAdd)
{
boxModelResultModelRet2 = _BoxModelResultService.PostAddBoxModelResultDB(boxModelResultModel);
}
else
{
boxModelResultModelRet2 = _BoxModelResultService.PostUpdateBoxModelResultDB(boxModelResultModel);
}
if (!string.IsNullOrWhiteSpace(boxModelResultModelRet2.Error))
{
return(ReturnError(boxModelResultModelRet2.Error));
}
}
return(GetBoxModelModelWithBoxModelIDDB(boxModelModel.BoxModelID));
}
private BoxModelLanguageModel AddBoxModelLanguageModel(LanguageEnum LangToAdd, BoxModelModel boxModelModel)
{
BoxModelLanguageModel boxModelLanguageModelNew = new BoxModelLanguageModel();
FillBoxModelLanguageModelNew(LangToAdd, boxModelModel, boxModelLanguageModelNew);
BoxModelLanguageModel boxModelLanguagModelRet = boxModelLanguageService.PostAddBoxModelLanguageDB(boxModelLanguageModelNew);
if (!string.IsNullOrWhiteSpace(boxModelLanguagModelRet.Error))
{
return(boxModelLanguagModelRet);
}
Assert.IsNotNull(boxModelLanguagModelRet);
CompareBoxModelLanguageModels(boxModelLanguageModelNew, boxModelLanguagModelRet);
return(boxModelLanguagModelRet);
}
