public void FileController_FileRemoveJSON_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
controllerAction = "FileRemoveJSON";
contactModel = contactModelListGood[0];
SetupTest(contactModel, culture, controllerAction);
using (TransactionScope ts = new TransactionScope())
{
TVItemModel tvItemModelMunicipality = randomService.RandomTVItem(TVTypeEnum.Municipality);
Assert.AreEqual("", tvItemModelMunicipality.Error);
TVItemModel tvItemModelTVFile = tvItemService.PostAddChildTVItemDB(tvItemModelMunicipality.TVItemID, randomService.RandomString("FileName ", 20), TVTypeEnum.File);
Assert.AreEqual("", tvItemModelTVFile.Error);
TVFileModel tvFileModel = randomService.RandomTVFileModel(tvItemModelTVFile, true);
Assert.AreEqual("", tvFileModel.Error);
CoordModel coordModel = mapInfoService.GetParentLatLngDB(tvFileModel.TVFileTVItemID);
Assert.AreEqual("", coordModel.Error);
JsonResult jsonResult = controller.FileRemoveJSON(tvFileModel.TVFileTVItemID) as JsonResult;
Assert.IsNotNull(jsonResult);
string retStr = (string)jsonResult.Data;
Assert.AreEqual("", retStr);
}
}
}
private void FillTVFileModel(TVFileModel tvFileModel)
{
tvFileModel.TVFileTVItemID = tvFileModel.TVFileTVItemID;
tvFileModel.Language = LanguageEnum.en;
tvFileModel.FilePurpose = FilePurposeEnum.Image;
tvFileModel.FileType = FileTypeEnum.PNG;
tvFileModel.FileDescription = randomService.RandomString("File Description", 200);
tvFileModel.FileSize_kb = randomService.RandomInt(1, 2000000);
tvFileModel.FileInfo = randomService.RandomString("File Info", 200);
tvFileModel.FileCreatedDate_UTC = randomService.RandomDateTime();
tvFileModel.ClientFilePath = randomService.RandomString("ClientFilePath", 50);
tvFileModel.ServerFileName = randomService.RandomString("ServerFileName", 50) + ".html";
tvFileModel.ServerFilePath = randomService.RandomString("ServerFilePath", 50);
Assert.IsTrue(tvFileModel.TVFileTVItemID != 0);
Assert.IsTrue(tvFileModel.Language == LanguageEnum.en);
Assert.IsTrue(tvFileModel.FilePurpose == FilePurposeEnum.Image);
Assert.IsTrue(tvFileModel.FileType == FileTypeEnum.PNG);
Assert.IsTrue(tvFileModel.FileDescription.Length == 200);
Assert.IsTrue(tvFileModel.FileSize_kb >= 1 && tvFileModel.FileSize_kb <= 2000000);
Assert.IsTrue(tvFileModel.FileInfo.Length == 200);
Assert.IsTrue(tvFileModel.FileCreatedDate_UTC != null);
Assert.IsTrue(tvFileModel.ClientFilePath.Length == 50);
Assert.IsTrue(tvFileModel.ServerFileName.Length == 55);
Assert.IsTrue(tvFileModel.ServerFilePath.Length == 50);
}
public PartialViewResult _ClassificationTool(int ProvinceTVItemID)
{
ViewBag.ProvinceTVItemID = ProvinceTVItemID;
ViewBag.TVFileModelClassificationPolygons = null;
ViewBag.TVFileModelClassificationInputs = null;
ViewBag.ClassificationPolygonsFileName = null;
ViewBag.ClassificationInputsFileName = null;
TVFileModel tvFileModelClassificationPolygons = _ProvinceToolsService.GetTVFileModelClassificationPolygons(ProvinceTVItemID);
ViewBag.TVFileModelClassificationPolygons = tvFileModelClassificationPolygons;
TVFileModel TVFileModelClassificationInputs = _ProvinceToolsService.GetTVFileModelClassificationInputs(ProvinceTVItemID);
ViewBag.TVFileModelClassificationInputs = TVFileModelClassificationInputs;
string classificationPolygonsFileName = $"ClassificationPolygons_{_ProvinceToolsService.GetInit(ProvinceTVItemID)}.kml";;
ViewBag.ClassificationPolygonsFileName = classificationPolygonsFileName;
string classificationInputsFileName = $"ClassificationInputs_{_ProvinceToolsService.GetInit(ProvinceTVItemID)}.kml";;
ViewBag.ClassificationInputsFileName = classificationInputsFileName;
return(PartialView());
}
public PartialViewResult _MWQMSitePolSourceSiteGroupingTool(int ProvinceTVItemID)
{
ViewBag.ProvinceTVItemID = ProvinceTVItemID;
ViewBag.TVFileModelMWQMSitesAndPolSourceSites = null;
ViewBag.TVFileModelGroupingInputs = null;
ViewBag.MWQMSitesAndPolSourceSitesFileName = null;
ViewBag.GroupingInputsFileName = null;
TVFileModel tvFileModelMWQMSitesAndPolSourceSites = _ProvinceToolsService.GetTVFileModelMWQMSitesAndPolSourceSites(ProvinceTVItemID);
ViewBag.TVFileModelMWQMSitesAndPolSourceSites = tvFileModelMWQMSitesAndPolSourceSites;
TVFileModel tvFileModelGroupingInputs = _ProvinceToolsService.GetTVFileModelGroupingInputs(ProvinceTVItemID);
ViewBag.TVFileModelGroupingInputs = tvFileModelGroupingInputs;
string mwqmSitesAndPolSourceSitesFileName = $"MWQMSitesAndPolSourceSites_{_ProvinceToolsService.GetInit(ProvinceTVItemID)}.kml";;
ViewBag.MWQMSitesAndPolSourceSitesFileName = mwqmSitesAndPolSourceSitesFileName;
string groupingInputsFileName = $"GroupingInputs_{_ProvinceToolsService.GetInit(ProvinceTVItemID)}.kml";;
ViewBag.GroupingInputsFileName = groupingInputsFileName;
return(PartialView());
}
public ActionResult GetImageAsFile(int TVFileTVItemID)
{
TVFileModel tvFileModel = _TVFileService.GetTVFileModelWithTVFileTVItemIDDB(TVFileTVItemID);
FileInfo fi = new FileInfo(tvFileModel.ServerFilePath + tvFileModel.ServerFileName);
return(File(fi.FullName, "image/bytes"));
}
public PartialViewResult _fileUpload(FormCollection fc)
{
TVFileModel tvFileModelRet = FileUploadDB(fc, Request);
ViewBag.TVFileModel = tvFileModelRet;
return(PartialView());
}
private bool GenerateHTMLSUBSECTOR_CSSP_LOGO(StringBuilder sbTemp)
{
int Percent = 12;
string NotUsed = "";
_TaskRunnerBaseService.SendPercentToDB(_TaskRunnerBaseService._BWObj.appTaskModel.AppTaskID, Percent);
_TaskRunnerBaseService.SendStatusTextToDB(_TaskRunnerBaseService.GetTextLanguageFormat1List("Creating_", ReportGenerateObjectsKeywordEnum.SUBSECTOR_ECCC_AND_SWCP_LOGO.ToString()));
List <string> ParamValueList = Parameters.Split("|||".ToCharArray(), StringSplitOptions.RemoveEmptyEntries).ToList();
// TVItemID and Year already loaded
TVItemModel tvItemModelSubsector = _TVItemService.GetTVItemModelWithTVItemIDDB(TVItemID);
if (!string.IsNullOrWhiteSpace(tvItemModelSubsector.Error))
{
NotUsed = string.Format(TaskRunnerServiceRes.CouldNotFind_With_Equal_, TaskRunnerServiceRes.TVItem, TaskRunnerServiceRes.TVItemID, TVItemID.ToString());
_TaskRunnerBaseService._BWObj.TextLanguageList = _TaskRunnerBaseService.GetTextLanguageList(tvItemModelSubsector.Error);
return(false);
}
TVItemModel tvItemModelRoot = _TVItemService.GetRootTVItemModelDB();
if (!string.IsNullOrWhiteSpace(tvItemModelRoot.Error))
{
NotUsed = TaskRunnerServiceRes.CouldNotFindTVItemRoot;
_TaskRunnerBaseService._BWObj.TextLanguageList = _TaskRunnerBaseService.GetTextLanguageList("CouldNotFindTVItemRoot");
return(false);
}
string ServerPath = _TVFileService.GetServerFilePath(tvItemModelRoot.TVItemID);
TVFileModel tvFileModelFullReportCSSPLogo = _TVFileService.GetTVFileModelWithServerFilePathAndServerFileNameDB(ServerPath, "CSSPLogo.png");
if (!string.IsNullOrWhiteSpace(tvFileModelFullReportCSSPLogo.Error))
{
NotUsed = string.Format(TaskRunnerServiceRes.CouldNotFindFile_, ServerPath + "CSSPLogo.png");
_TaskRunnerBaseService._BWObj.TextLanguageList = _TaskRunnerBaseService.GetTextLanguageFormat1List("CouldNotFindFile_", ServerPath + "CSSPLogo.png");
return(false);
}
FileInfo fiFullReportCSSPLogo = new FileInfo(tvFileModelFullReportCSSPLogo.ServerFilePath + tvFileModelFullReportCSSPLogo.ServerFileName);
if (!fiFullReportCSSPLogo.Exists)
{
NotUsed = string.Format(TaskRunnerServiceRes.CouldNotFindFile_, fiFullReportCSSPLogo.FullName);
_TaskRunnerBaseService._BWObj.TextLanguageList = _TaskRunnerBaseService.GetTextLanguageFormat1List("CouldNotFindFile_", fiFullReportCSSPLogo.FullName);
return(false);
}
Percent = 30;
_TaskRunnerBaseService.SendPercentToDB(_TaskRunnerBaseService._BWObj.appTaskModel.AppTaskID, Percent);
sbTemp.AppendLine($@" |||Image|FileName,{ fiFullReportCSSPLogo.FullName }|width,325|height,26|||");
sbTemp.AppendLine($@" <p> </p>");
return(true);
}
// Post
//public DocTemplateModel DocTemplateAddOrModifyDB(FormCollection fc)
//{
// int tempInt = 0;
// int DocTemplateID = 0;
// TVTypeEnum TVType = TVTypeEnum.Error;
// string FileName = "";
// ContactOK contactOK = IsContactOK();
// if (!string.IsNullOrWhiteSpace(contactOK.Error))
// return ReturnError(contactOK.Error);
// int.TryParse(fc["DocTemplateID"], out DocTemplateID);
// // can be 0 if adding a new DocTemplate
// int.TryParse(fc["TVType"], out tempInt);
// if (tempInt == 0)
// return ReturnError(string.Format(ServiceRes._IsRequired, ServiceRes.TVType));
// TVType = (TVTypeEnum)tempInt;
// FileName = fc["FileName"];
// if (string.IsNullOrWhiteSpace(FileName))
// return ReturnError(string.Format(ServiceRes._IsRequired, ServiceRes.FileName));
// TVItemModel TVItemRoot = _TVItemService.GetRootTVItemModelDB();
// if (!string.IsNullOrWhiteSpace(TVItemRoot.Error))
// return ReturnError(TVItemRoot.Error);
// DocTemplateModel docTemplateModel = new DocTemplateModel();
// using (TransactionScope ts = new TransactionScope())
// {
// string ObservationInfo = ((int)PolSourceObsInfoEnum.LandBased).ToString() + ",";
// List<int> obsIntList = ObservationInfo.Split(",".ToCharArray(), StringSplitOptions.RemoveEmptyEntries).Select(int.Parse).ToList();
// string ObservationLanguageTVText = ServiceRes.Error;
// string TVText = _BaseEnumService.GetEnumText_PolSourceObsInfoTextEnum(PolSourceObsInfoEnum.Error);
// int NextSiteNumber = 0;
// if (DocTemplateID == 0)
// {
// DocTemplateModel docTemplateModelNew = new DocTemplateModel()
// {
// TVType = (int)TVType,
// FileName = FileName,
// };
// // Automatically add one Pollution Source Observation for today
// PolSourceObservationModel polSourceObservationModelNew = new PolSourceObservationModel()
// {
// PolSourceSiteTVItemID = polSourceSiteNewOrToChange.PolSourceSiteTVItemID,
// ObservationDate_Local = new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day),
// ContactTVItemID = contactOK.ContactTVItemID,
// Observation_ToBeDeleted = "",
// };
// PolSourceObservationModel polSourceObservationModelRet = _PolSourceObservationService.PostAddPolSourceObservationDB(polSourceObservationModelNew);
// if (!string.IsNullOrWhiteSpace(polSourceObservationModelRet.Error))
// return ReturnError(polSourceObservationModelRet.Error);
// // Automatically add one Pollution Source Observation Issue
// PolSourceObservationIssueModel polSourceObservationIssueModelNew = new PolSourceObservationIssueModel();
// polSourceObservationIssueModelNew.PolSourceObservationID = polSourceObservationModelRet.PolSourceObservationID;
// polSourceObservationIssueModelNew.ObservationInfo = ObservationInfo;
// polSourceObservationIssueModelNew.Ordinal = 0;
// PolSourceObservationIssueModel polSourceObservationIssueModelRet = _PolSourceObservationService._PolSourceObservationIssueService.PostAddPolSourceObservationIssueDB(polSourceObservationIssueModelNew);
// if (!string.IsNullOrWhiteSpace(polSourceObservationIssueModelRet.Error))
// return ReturnError(polSourceObservationIssueModelRet.Error);
// // doing the other language
// foreach (string lang in LanguageListAllowable.Where(c => c != LanguageRequest))
// {
// TVItemService tvItemService = new TVItemService(lang, _TVItemService.User);
// Thread.CurrentThread.CurrentCulture = new CultureInfo(lang + "-CA");
// Thread.CurrentThread.CurrentUICulture = new CultureInfo(lang + "-CA");
// ObservationInfo = ((int)PolSourceObsInfoEnum.LandBased).ToString() + ",";
// ObservationLanguageTVText = ServiceRes.Error;
// TVText = _BaseEnumService.GetEnumText_PolSourceObsInfoTextEnum(PolSourceObsInfoEnum.Error);
// TVText = (string.IsNullOrWhiteSpace(TVText) ? ServiceRes.Error : TVText);
// if (PolSourceSiteTVItemID == 0)
// {
// TVText = TVText + " - " + "000000".Substring(0, "000000".Length - NextSiteNumber.ToString().Length) + NextSiteNumber.ToString();
// }
// else
// {
// TVText = TVText + " - " + "000000".Substring(0, "000000".Length - polSourceSiteNewOrToChange.Site.ToString().Length) + polSourceSiteNewOrToChange.Site.ToString();
// }
// TVItemLanguageModel tvItemLanguageModel = new TVItemLanguageModel();
// tvItemLanguageModel.Language = lang;
// tvItemLanguageModel.TVText = TVText;
// tvItemLanguageModel.TVItemID = polSourceSiteNewOrToChange.PolSourceSiteTVItemID;
// TVItemLanguageModel tvItemLanguageModelRet = tvItemService._TVItemLanguageService.PostUpdateTVItemLanguageDB(tvItemLanguageModel);
// if (!string.IsNullOrWhiteSpace(tvItemLanguageModelRet.Error))
// return ReturnError(tvItemLanguageModelRet.Error);
// Thread.CurrentThread.CurrentCulture = new CultureInfo(LanguageRequest + "-CA");
// Thread.CurrentThread.CurrentUICulture = new CultureInfo(LanguageRequest + "-CA");
// }
// }
// else
// {
// polSourceSiteNewOrToChange = PostUpdatePolSourceSiteDB(polSourceSiteNewOrToChange);
// if (!string.IsNullOrWhiteSpace(polSourceSiteNewOrToChange.Error))
// return ReturnError(polSourceSiteNewOrToChange.Error);
// }
// // Adding map info
// List<MapInfoPointModel> mapInfoPointModelList = _MapInfoService._MapInfoPointService.GetMapInfoPointModelListWithTVItemIDAndTVTypeAndMapInfoDrawTypeDB(polSourceSiteNewOrToChange.PolSourceSiteTVItemID, TVTypeEnum.PolSourceSite, MapInfoDrawTypeEnum.Point);
// if (mapInfoPointModelList.Count == 0)
// {
// MapInfoModel mapInfoModelRet = _MapInfoService.CreateMapInfoObjectDB(coordList, MapInfoDrawTypeEnum.Point, TVTypeEnum.PolSourceSite, polSourceSiteNewOrToChange.PolSourceSiteTVItemID);
// if (!string.IsNullOrWhiteSpace(mapInfoModelRet.Error))
// return ReturnError(mapInfoModelRet.Error);
// }
// else
// {
// mapInfoPointModelList[0].Lat = coordList[0].Lat;
// mapInfoPointModelList[0].Lng = coordList[0].Lng;
// MapInfoPointModel mapInfoPointModelRet = _MapInfoService._MapInfoPointService.PostUpdateMapInfoPointDB(mapInfoPointModelList[0]);
// if (!string.IsNullOrWhiteSpace(mapInfoPointModelRet.Error))
// return ReturnError(mapInfoPointModelRet.Error);
// }
// TVItemModel tvItemModelPolSourceSite = _TVItemService.GetTVItemModelWithTVItemIDDB(polSourceSiteNewOrToChange.PolSourceSiteTVItemID);
// if (!string.IsNullOrWhiteSpace(tvItemModelPolSourceSite.Error))
// return ReturnError(tvItemModelPolSourceSite.Error);
// tvItemModelPolSourceSite.IsActive = IsActive;
// TVItemModel tvItemModelRet = _TVItemService.PostUpdateTVItemDB(tvItemModelPolSourceSite);
// if (!string.IsNullOrWhiteSpace(tvItemModelRet.Error))
// return ReturnError(tvItemModelRet.Error);
// ts.Complete();
// }
// return polSourceSiteNewOrToChange;
//}
public DocTemplateModel PostAddDocTemplateDB(DocTemplateModel docTemplateModel)
{
string retStr = DocTemplateModelOK(docTemplateModel);
if (!string.IsNullOrEmpty(retStr))
{
return(ReturnError(retStr));
}
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrEmpty(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
TVFileModel tvFileModel = _TVFileService.GetTVFileModelWithTVFileTVItemIDDB(docTemplateModel.TVFileTVItemID);
if (!string.IsNullOrWhiteSpace(tvFileModel.Error))
{
return(ReturnError(tvFileModel.Error));
}
DocTemplateModel docTemplateModelExist = GetDocTemplateModelExistDB(docTemplateModel);
if (string.IsNullOrWhiteSpace(docTemplateModelExist.Error))
{
return(ReturnError(string.Format(ServiceRes._AlreadyExists, ServiceRes.DocTemplate)));
}
DocTemplate docTemplateNew = new DocTemplate();
retStr = FillDocTemplate(docTemplateNew, docTemplateModel, contactOK);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
using (TransactionScope ts = new TransactionScope())
{
db.DocTemplates.Add(docTemplateNew);
retStr = DoAddChanges();
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
LogModel logModel = _LogService.PostAddLogForObj("DocTemplates", docTemplateNew.DocTemplateID, LogCommandEnum.Add, docTemplateNew);
if (!string.IsNullOrWhiteSpace(logModel.Error))
{
return(ReturnError(logModel.Error));
}
ts.Complete();
}
return(GetDocTemplateModelWithDocTemplateIDDB(docTemplateNew.DocTemplateID));
}
public FileResult FileDownload(int TVFileTVItemID)
{
TVFileModel tvFileModel = _TVFileService.GetTVFileModelWithTVFileTVItemIDDB(TVFileTVItemID);
string ServerFileName = _TVFileService.ChoseEDriveOrCDrive(tvFileModel.ServerFilePath + tvFileModel.ServerFileName);
FileInfo fi = new FileInfo(ServerFileName);
string ContentType = _TVFileService.GetMimeType(ServerFileName);
return(File(ServerFileName, ContentType, fi.Name));
}
public FileStreamResult ShowImage(int TVFileTVItemID)
{
TVFileModel tvFileModel = _TVFileService.GetTVFileModelWithTVFileTVItemIDDB(TVFileTVItemID);
string ServerFileName = _TVFileService.ChoseEDriveOrCDrive(tvFileModel.ServerFilePath + tvFileModel.ServerFileName);
FileInfo fi = new FileInfo(ServerFileName);
FileStream fs = fi.Open(FileMode.Open);
return(new FileStreamResult(fs, "image/png"));
}
public PartialViewResult _fileEdit(int TVFileTVItemID)
{
ViewBag.TVFileModel = null;
ViewBag.FilePurposeAndTextList = null;
TVFileModel tvFileModel = _TVFileService.GetTVFileModelWithTVFileTVItemIDDB(TVFileTVItemID);
ViewBag.TVFileModel = tvFileModel;
List <FilePurposeAndText> filePurposeAndTextList = FillFilePurposeAndTextList();
ViewBag.FilePurposeAndTextList = filePurposeAndTextList.OrderBy(c => c.FilePurposeText).ToList();
return(PartialView());
}
public void FileController_FileEditSaveJSON_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
controllerAction = "FileEditSaveJSON";
contactModel = contactModelListGood[0];
SetupTest(contactModel, culture, controllerAction);
using (TransactionScope ts = new TransactionScope())
{
TVItemModel tvItemModelMunicipality = randomService.RandomTVItem(TVTypeEnum.Municipality);
Assert.AreEqual("", tvItemModelMunicipality.Error);
TVItemModel tvItemModelTVFile = tvItemService.PostAddChildTVItemDB(tvItemModelMunicipality.TVItemID, randomService.RandomString("FileName ", 20), TVTypeEnum.File);
Assert.AreEqual("", tvItemModelTVFile.Error);
TVFileModel tvFileModel = randomService.RandomTVFileModel(tvItemModelTVFile, true);
Assert.AreEqual("", tvFileModel.Error);
System.Web.Mvc.FormCollection fc = new System.Web.Mvc.FormCollection();
fc.Add("TVFileTVItemID", tvFileModel.TVFileTVItemID.ToString());
if (tvFileModel.FilePurpose == FilePurposeEnum.Information)
{
fc.Add("FilePurpose", ((int)FilePurposeEnum.Generated).ToString());
}
else
{
fc.Add("FilePurpose", ((int)FilePurposeEnum.Information).ToString());
}
fc.Add("FileDescription", randomService.RandomString("Bonjour ", 100));
fc.Add("SaveAsFileName", randomService.RandomString("aaa ", 20));
fc.Add("FromWater", true.ToString());
JsonResult jsonResult = controller.FileEditSaveJSON(fc) as JsonResult;
Assert.IsNotNull(jsonResult);
string retStr = (string)jsonResult.Data;
Assert.AreEqual("", retStr);
}
}
}
public TVFileModel GetTVFileModelMWQMSitesAndPolSourceSites(int ProvinceTVItemID)
{
TVItemModel tvItemModelProv = _TVItemService.GetTVItemModelWithTVItemIDDB(ProvinceTVItemID);
if (!string.IsNullOrWhiteSpace(tvItemModelProv.Error))
{
return(new TVFileModel()
{
Error = tvItemModelProv.Error
});
}
if (tvItemModelProv.TVType != TVTypeEnum.Province)
{
return(new TVFileModel()
{
Error = string.Format(ServiceRes.ShouldContainTVTypeOf_, TVTypeEnum.Province.ToString())
});
}
string Init = GetInit(ProvinceTVItemID);
string ServerPath = _TVFileService.GetServerFilePath(ProvinceTVItemID);
string FileName = $"MWQMSitesAndPolSourceSites_{Init}.kml";
TVFileModel tvFileModel = _TVFileService.GetTVFileModelWithServerFilePathAndServerFileNameDB(ServerPath, FileName);
if (!string.IsNullOrWhiteSpace(tvFileModel.Error))
{
return(new TVFileModel()
{
Error = tvFileModel.Error
});
}
return(tvFileModel);
}
public void FileController_CreateDocumentFromTemplateJSON_Canada_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
controllerAction = "CreateDocumentFromTemplateJSON";
contactModel = contactModelListGood[0];
SetupTest(contactModel, culture, controllerAction);
using (TransactionScope ts = new TransactionScope())
{
TVItemModel tvItemModelRoot = tvItemService.GetRootTVItemModelDB();
Assert.AreEqual("", tvItemModelRoot.Error);
TVItemModel tvItemModelCanada = tvItemService.GetChildTVItemModelWithTVItemIDAndTVTextStartWithAndTVTypeDB(tvItemModelRoot.TVItemID, "Canada", TVTypeEnum.Country);
Assert.AreEqual("", tvItemModelRoot.Error);
DirectoryInfo di = new DirectoryInfo(tvFileService.GetServerFilePath(tvItemModelRoot.TVItemID));
if (!di.Exists)
{
di.Create();
}
di = new DirectoryInfo(tvFileService.GetServerFilePath(tvItemModelRoot.TVItemID));
Assert.IsTrue(di.Exists);
FileInfo fi = new FileInfo(tvFileService.GetServerFilePath(tvItemModelRoot.TVItemID) + "this_should_be_unique.docx");
if (!fi.Exists)
{
StreamWriter sw = new StreamWriter(fi.FullName);
sw.WriteLine("|||Testing document|||");
sw.Close();
}
string FileName = "this_should_be_unique.docx";
fi = new FileInfo(tvFileService.GetServerFilePath(tvItemModelRoot.TVItemID) + FileName);
Assert.IsTrue(fi.Exists);
TVItemModel tvItemModelFile = tvItemService.PostAddChildTVItemDB(tvItemModelRoot.TVItemID, FileName, TVTypeEnum.File);
Assert.AreEqual("", tvItemModelFile.Error);
TVFileModel tvFileModelNew = new TVFileModel();
tvFileModelNew.TVFileTVItemID = tvItemModelFile.TVItemID;
FillTVFileModel(tvFileModelNew);
tvFileModelNew.Language = controller.LanguageRequest;
tvFileModelNew.FilePurpose = FilePurposeEnum.Template;
tvFileModelNew.FileType = FileTypeEnum.DOCX;
tvFileModelNew.FileDescription = randomService.RandomString("File Description", 200);
tvFileModelNew.FileSize_kb = (int)(fi.Length / 1024);
tvFileModelNew.FileInfo = randomService.RandomString("File Info", 200);
tvFileModelNew.FileCreatedDate_UTC = DateTime.Now;
tvFileModelNew.ClientFilePath = "";
tvFileModelNew.ServerFileName = FileName;
tvFileModelNew.ServerFilePath = tvFileService.ChoseEDriveOrCDrive(tvFileService.GetServerFilePath(tvItemModelRoot.TVItemID));
TVFileModel tvFileModelRet = tvFileService.PostAddTVFileDB(tvFileModelNew);
Assert.AreEqual("", tvFileModelRet.Error);
DocTemplateModel docTemplateModelNew = new DocTemplateModel()
{
TVType = tvItemModelCanada.TVType,
TVFileTVItemID = tvFileModelRet.TVFileTVItemID,
FileName = FileName,
};
DocTemplateModel docTemplateModelRet = docTemplateService.PostAddDocTemplateDB(docTemplateModelNew);
Assert.AreEqual("", docTemplateModelRet.Error);
System.Web.Mvc.FormCollection fc = new System.Web.Mvc.FormCollection();
fc.Add("TVItemID", tvItemModelCanada.TVItemID.ToString());
fc.Add("DocTemplateID", docTemplateModelRet.DocTemplateID.ToString());
JsonResult jsonResult = controller.CreateDocumentFromTemplateJSON(fc) as JsonResult;
Assert.IsNotNull(jsonResult);
string retStr = (string)jsonResult.Data;
Assert.AreEqual("", retStr);
AppTaskModel appTaskModel = appTaskService.GetAppTaskModelWithTVItemIDTVItemID2AndCommandDB(tvItemModelCanada.TVItemID, tvItemModelCanada.TVItemID, AppTaskCommandEnum.CreateDocumentFromTemplate);
Assert.AreEqual("", appTaskModel.Error);
Assert.AreEqual("", appTaskModel.Error);
}
}
}
public void FileController__createDocument_Canada_Word_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
controllerAction = "_createDocument";
contactModel = contactModelListGood[0];
SetupTest(contactModel, culture, controllerAction);
using (TransactionScope ts = new TransactionScope())
{
TVItemModel tvItemModelRoot = tvItemService.GetRootTVItemModelDB();
Assert.AreEqual("", tvItemModelRoot.Error);
TVItemModel tvItemModelCanada = tvItemService.GetChildTVItemModelWithTVItemIDAndTVTextStartWithAndTVTypeDB(tvItemModelRoot.TVItemID, "Canada", TVTypeEnum.Country);
Assert.AreEqual("", tvItemModelRoot.Error);
DirectoryInfo di = new DirectoryInfo(tvFileService.GetServerFilePath(tvItemModelRoot.TVItemID));
if (!di.Exists)
{
di.Create();
}
di = new DirectoryInfo(tvFileService.GetServerFilePath(tvItemModelRoot.TVItemID));
Assert.IsTrue(di.Exists);
FileInfo fi = new FileInfo(tvFileService.GetServerFilePath(tvItemModelRoot.TVItemID) + "this_should_be_unique.docx");
if (!fi.Exists)
{
StreamWriter sw = new StreamWriter(fi.FullName);
sw.WriteLine("|||Testing document|||");
sw.Close();
}
string FileName = "this_should_be_unique.docx";
fi = new FileInfo(tvFileService.GetServerFilePath(tvItemModelRoot.TVItemID) + FileName);
Assert.IsTrue(fi.Exists);
TVItemModel tvItemModelFile = tvItemService.PostAddChildTVItemDB(tvItemModelRoot.TVItemID, FileName, TVTypeEnum.File);
Assert.AreEqual("", tvItemModelFile.Error);
TVFileModel tvFileModelNew = new TVFileModel();
tvFileModelNew.TVFileTVItemID = tvItemModelFile.TVItemID;
FillTVFileModel(tvFileModelNew);
tvFileModelNew.Language = controller.LanguageRequest;
tvFileModelNew.FilePurpose = FilePurposeEnum.Template;
tvFileModelNew.FileType = FileTypeEnum.DOCX;
tvFileModelNew.FileDescription = randomService.RandomString("File Description", 200);
tvFileModelNew.FileSize_kb = (int)(fi.Length / 1024);
tvFileModelNew.FileInfo = randomService.RandomString("File Info", 200);
tvFileModelNew.FileCreatedDate_UTC = DateTime.Now;
tvFileModelNew.ClientFilePath = "";
tvFileModelNew.ServerFileName = FileName;
tvFileModelNew.ServerFilePath = tvFileService.ChoseEDriveOrCDrive(tvFileService.GetServerFilePath(tvItemModelRoot.TVItemID));
TVFileModel tvFileModelRet = tvFileService.PostAddTVFileDB(tvFileModelNew);
Assert.AreEqual("", tvFileModelRet.Error);
DocTemplateModel docTemplateModelNew = new DocTemplateModel()
{
TVType = tvItemModelCanada.TVType,
TVFileTVItemID = tvFileModelRet.TVFileTVItemID,
FileName = FileName,
};
DocTemplateModel docTemplateModelRet = docTemplateService.PostAddDocTemplateDB(docTemplateModelNew);
Assert.AreEqual("", docTemplateModelRet.Error);
PartialViewResult partialViewResult = controller._createDocument(tvItemModelCanada.TVItemID) as PartialViewResult;
Assert.IsNotNull(partialViewResult);
FileController fileController = (FileController)partialViewResult.ViewBag.FileController;
Assert.IsNotNull(fileController);
TVItemModel tvItemModelRet = (TVItemModel)partialViewResult.ViewBag.TVItemModel;
Assert.AreEqual("", tvItemModelRet.Error);
Assert.AreEqual(tvItemModelRet.TVItemID, tvItemModelCanada.TVItemID);
List <DocTemplateModel> docTemplateModelList = (List <DocTemplateModel>)partialViewResult.ViewBag.DocTemplateModelList;
Assert.IsTrue(docTemplateModelList.Count > 0);
fi.Delete();
}
}
}
public void FileController__fileEdit_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
controllerAction = "_fileEdit";
contactModel = contactModelListGood[0];
SetupTest(contactModel, culture, controllerAction);
using (TransactionScope ts = new TransactionScope())
{
TVItemModel tvItemModelRoot = tvItemService.GetRootTVItemModelDB();
Assert.AreEqual("", tvItemModelRoot.Error);
DirectoryInfo di = new DirectoryInfo(tvFileService.GetServerFilePath(tvItemModelRoot.TVItemID));
if (!di.Exists)
{
di.Create();
}
di = new DirectoryInfo(tvFileService.GetServerFilePath(tvItemModelRoot.TVItemID));
Assert.IsTrue(di.Exists);
FileInfo fi = new FileInfo(tvFileService.GetServerFilePath(tvItemModelRoot.TVItemID) + "this_should_be_unique.html");
if (!fi.Exists)
{
StreamWriter sw = new StreamWriter(fi.FullName);
for (int i = 0; i < 12; i++)
{
sw.WriteLine("Testing document " + i.ToString());
}
sw.Close();
}
string FileName = "this_should_be_unique.html";
fi = new FileInfo(tvFileService.GetServerFilePath(tvItemModelRoot.TVItemID) + FileName);
Assert.IsTrue(fi.Exists);
TVItemModel tvItemModelFile = tvItemService.PostAddChildTVItemDB(tvItemModelRoot.TVItemID, FileName, TVTypeEnum.File);
Assert.AreEqual("", tvItemModelFile.Error);
TVFileModel tvFileModelNew = new TVFileModel();
tvFileModelNew.TVFileTVItemID = tvItemModelFile.TVItemID;
FillTVFileModel(tvFileModelNew);
tvFileModelNew.Language = controller.LanguageRequest;
tvFileModelNew.FilePurpose = FilePurposeEnum.Reported;
tvFileModelNew.FileType = FileTypeEnum.HTML;
tvFileModelNew.FileDescription = randomService.RandomString("File Description", 200);
tvFileModelNew.FileSize_kb = (int)(fi.Length / 1024);
tvFileModelNew.FileInfo = randomService.RandomString("File Info", 200);
tvFileModelNew.FileCreatedDate_UTC = DateTime.Now;
tvFileModelNew.ClientFilePath = "";
tvFileModelNew.ServerFileName = FileName;
tvFileModelNew.ServerFilePath = tvFileService.GetServerFilePath(tvItemModelRoot.TVItemID);
TVFileModel tvFileModelRet = tvFileService.PostAddTVFileDB(tvFileModelNew);
Assert.AreEqual("", tvFileModelRet.Error);
PartialViewResult partialViewResult = controller._fileEdit(tvFileModelRet.TVFileTVItemID) as PartialViewResult;
Assert.IsNotNull(partialViewResult);
TVFileModel tvFileModelRet2 = (TVFileModel)partialViewResult.ViewBag.TVFileModel;
Assert.IsNotNull(tvFileModelRet2);
Assert.AreEqual(tvFileModelRet.TVFileTVItemID, tvFileModelRet2.TVFileTVItemID);
List <FilePurposeAndText> filePurposeAndTextList = (List <FilePurposeAndText>)partialViewResult.ViewBag.FilePurposeAndTextList;
Assert.IsTrue(filePurposeAndTextList.Count > 0);
fi.Delete();
}
}
}
public bool GenerateWebTideNode(TVFileModel TVFileModelBC, int WebTideNodeNumb, List <Coord> CoordList, List <TVFileModel> tvFileModelList, int BoundaryConditionCodeNumber, List <List <WaterLevelResult> > AllWLResults, List <IEnumerable <CurrentResult> > AllCurrentResults)
{
List <eumItem> eumItemList = new List <eumItem>();
DfsFactory factory = new DfsFactory();
IDfsFile dfsOldFile = DfsFileFactory.DfsGenericOpen(TVFileModelBC.ServerFilePath + TVFileModelBC.ServerFileName);
DfsBuilder dfsNewFile = DfsBuilder.Create(dfsOldFile.FileInfo.FileTitle, dfsOldFile.FileInfo.ApplicationTitle, dfsOldFile.FileInfo.ApplicationVersion);
double WebTideStepsInMinutes = ((double)((IDfsEqCalendarAxis)((dfsOldFile.FileInfo).TimeAxis)).TimeStep / 60);
DateTime?dateTimeTemp = null;
int? NumberOfTimeSteps = null;
int? TimeStepInterval = null;
using (PFS pfs = new PFS(base.fi))
{
dateTimeTemp = pfs.GetVariableDateTime("FemEngineHD/TIME", "start_time");
if (dateTimeTemp == null)
{
dfsOldFile.Close();
return(false);
}
NumberOfTimeSteps = pfs.GetVariable <int>("FemEngineHD/TIME", "number_of_time_steps", 1);
if (NumberOfTimeSteps == null)
{
dfsOldFile.Close();
return(false);
}
TimeStepInterval = pfs.GetVariable <int>("FemEngineHD/TIME", "time_step_interval", 1);
if (TimeStepInterval == null)
{
dfsOldFile.Close();
return(false);
}
}
DateTime StartDate = ((DateTime)dateTimeTemp).AddHours(-1);
DateTime EndDate = ((DateTime)dateTimeTemp).AddSeconds((int)NumberOfTimeSteps * (int)TimeStepInterval).AddHours(1);
dfsNewFile.SetDataType(dfsOldFile.FileInfo.DataType);
dfsNewFile.SetGeographicalProjection(dfsOldFile.FileInfo.Projection);
dfsNewFile.SetTemporalAxis(factory.CreateTemporalEqCalendarAxis(eumUnit.eumUsec, StartDate, 0, WebTideStepsInMinutes * 60));
dfsNewFile.SetItemStatisticsType(StatType.RegularStat);
foreach (IDfsDynamicItemInfo di in dfsOldFile.ItemInfo)
{
DfsDynamicItemBuilder ddib = dfsNewFile.CreateDynamicItemBuilder();
ddib.Set(di.Name, eumQuantity.Create(di.Quantity.Item, di.Quantity.Unit), di.DataType);
ddib.SetValueType(di.ValueType);
ddib.SetAxis(factory.CreateAxisEqD1(eumUnit.eumUsec, CoordList.Count, 0, 1));
ddib.SetReferenceCoordinates(di.ReferenceCoordinateX, di.ReferenceCoordinateY, di.ReferenceCoordinateZ);
dfsNewFile.AddDynamicItem(ddib.GetDynamicItemInfo());
eumItemList.Add(di.Quantity.Item);
}
dfsOldFile.Close();
string[] NewFileErrors = dfsNewFile.Validate();
StringBuilder sbErr = new StringBuilder();
foreach (string s in NewFileErrors)
{
sbErr.AppendLine(s);
}
if (NewFileErrors.Count() > 0)
{
ErrorMessage = string.Format(CSSPDHIRes.CouldNotCreate_, TVFileModelBC.ServerFileName.Replace(".dfs0", "dfs1"));
OnCSSPDHIChanged(new CSSPDHIEventArgs(new CSSPDHIMessage("Error", -1, false, ErrorMessage)));
return(false);
}
string NewFileNameBC = TVFileModelBC.ServerFileName;
if (CoordList.Count == 0)
{
ErrorMessage = CSSPDHIRes.NumberOfWebTideNodesIsZero;
OnCSSPDHIChanged(new CSSPDHIEventArgs(new CSSPDHIMessage("Error", -1, false, ErrorMessage)));
return(false);
}
if (eumItemList.Count == 1)
{
if (eumItemList[0] == eumItem.eumIWaterLevel || eumItemList[0] == eumItem.eumIWaterDepth)
{
List <WaterLevelResult> WLResults = null;
dfsNewFile.CreateFile(TVFileModelBC.ServerFilePath + NewFileNameBC);
IDfsFile file = dfsNewFile.GetFile();
for (int i = 0; i < WLResults.ToList().Count; i++)
{
float[] floatArray = new float[AllWLResults.Count];
for (int j = 0; j < AllWLResults.Count; j++)
{
floatArray[j] = ((float)((List <WaterLevelResult>)AllWLResults[j].ToList())[i].WaterLevel);
}
file.WriteItemTimeStepNext(0, floatArray); // water level array
}
file.Close();
}
else
{
ErrorMessage = string.Format(CSSPDHIRes.FileContainsOneParamButItsNotOfTypeWLOrWDItIs_, eumItemList[0].ToString());
OnCSSPDHIChanged(new CSSPDHIEventArgs(new CSSPDHIMessage("Error", -1, false, ErrorMessage)));
return(false);
}
}
else if (eumItemList.Count == 2)
{
if (eumItemList[0] == eumItem.eumIuVelocity && eumItemList[1] == eumItem.eumIvVelocity)
{
// read web tide for the required time
List <CurrentResult> CurrentResults = null;
dfsNewFile.CreateFile(TVFileModelBC.ServerFilePath + NewFileNameBC);
IDfsFile file = dfsNewFile.GetFile();
for (int i = 0; i < CurrentResults.ToList().Count; i++)
{
float[] floatArrayX = new float[AllCurrentResults.Count];
float[] floatArrayY = new float[AllCurrentResults.Count];
for (int j = 0; j < AllCurrentResults.Count; j++)
{
floatArrayX[j] = ((float)((List <CurrentResult>)AllCurrentResults[j].ToList())[i].x_velocity);
floatArrayY[j] = ((float)((List <CurrentResult>)AllCurrentResults[j].ToList())[i].y_velocity);
}
file.WriteItemTimeStepNext(0, floatArrayX); // Current xVelocity
file.WriteItemTimeStepNext(0, floatArrayY); // Current yVelocity
}
file.Close();
}
else
{
ErrorMessage = string.Format(CSSPDHIRes.FileContains2ParamButItsNotOfUVAndVVItIs_And_, eumItemList[0].ToString(), eumItemList[1].ToString());
OnCSSPDHIChanged(new CSSPDHIEventArgs(new CSSPDHIMessage("Error", -1, false, ErrorMessage)));
return(false);
}
}
else
{
// this is not a file that is used for Water Level or Currents
}
return(false);
}
public MikeSourceModel PostDeleteMikeSourceDB(int MikeSourceID)
{
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrEmpty(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
MikeSource mikeSourceToDelete = GetMikeSourceWithMikeSourceIDDB(MikeSourceID);
if (mikeSourceToDelete == null)
{
return(ReturnError(string.Format(ServiceRes.CouldNotFind_ToDelete, ServiceRes.MikeSource)));
}
int TVItemIDToDelete = mikeSourceToDelete.MikeSourceTVItemID;
int SourceNumber = int.Parse(mikeSourceToDelete.SourceNumberString.Substring("SOURCE_".Length));
TVItemModel tvItemModelMikeSource = _TVItemService.GetTVItemModelWithTVItemIDDB(mikeSourceToDelete.MikeSourceTVItemID);
if (!string.IsNullOrWhiteSpace(tvItemModelMikeSource.Error))
{
return(ReturnError(tvItemModelMikeSource.Error));
}
int MikeScenarioTVItemID = tvItemModelMikeSource.ParentID;
TVItemModel tvItemModelMikeScenario = _TVItemService.GetTVItemModelWithTVItemIDDB(MikeScenarioTVItemID);
if (!string.IsNullOrWhiteSpace(tvItemModelMikeScenario.Error))
{
return(ReturnError(tvItemModelMikeScenario.Error));
}
string ServerPath = _TVFileService.GetServerFilePath(MikeScenarioTVItemID);
string ServerFileNameConc = $"{ tvItemModelMikeSource.TVText}_PollutionConcentration.dfs0";
TVFileModel tvFileModel = _TVFileService.GetTVFileModelWithServerFilePathAndServerFileNameDB(ServerPath, ServerFileNameConc);
if (string.IsNullOrWhiteSpace(tvFileModel.Error))
{
TVFileModel tvFileModelRet = _TVFileService.PostDeleteTVFileDB(tvFileModel.TVFileID);
if (!string.IsNullOrWhiteSpace(tvFileModelRet.Error))
{
return(ReturnError(tvFileModelRet.Error));
}
}
string ServerFileNameDischarge = $"{ tvItemModelMikeSource.TVText}_Discharge.dfs0";
TVFileModel tvFileModelDischarge = _TVFileService.GetTVFileModelWithServerFilePathAndServerFileNameDB(ServerPath, ServerFileNameDischarge);
if (string.IsNullOrWhiteSpace(tvFileModelDischarge.Error))
{
TVFileModel tvFileModelRet = _TVFileService.PostDeleteTVFileDB(tvFileModelDischarge.TVFileID);
if (!string.IsNullOrWhiteSpace(tvFileModelRet.Error))
{
return(ReturnError(tvFileModelRet.Error));
}
}
List <MikeSourceModel> mikeSourceModelList = GetMikeSourceModelListWithMikeScenarioTVItemIDDB(MikeScenarioTVItemID);
using (TransactionScope ts = new TransactionScope())
{
MapInfoModel mapInfoModelRet = _MapInfoService.PostDeleteMapInfoWithTVItemIDDB(mikeSourceToDelete.MikeSourceTVItemID);
if (!string.IsNullOrWhiteSpace(mapInfoModelRet.Error))
{
return(ReturnError(mapInfoModelRet.Error));
}
db.MikeSources.Remove(mikeSourceToDelete);
string retStr = DoDeleteChanges();
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
LogModel logModel = _LogService.PostAddLogForObj("MikeSources", mikeSourceToDelete.MikeSourceID, LogCommandEnum.Delete, mikeSourceToDelete);
if (!string.IsNullOrWhiteSpace(logModel.Error))
{
return(ReturnError(logModel.Error));
}
TVItemModel tvItemModelRet = _TVItemService.PostDeleteTVItemWithTVItemIDDB(TVItemIDToDelete);
if (!string.IsNullOrWhiteSpace(tvItemModelRet.Error))
{
return(ReturnError(tvItemModelRet.Error));
}
bool ok = false;
while (!ok)
{
SourceNumber += 1;
MikeSourceModel mikeSourceModel = mikeSourceModelList.Where(c => c.SourceNumberString == "SOURCE_" + SourceNumber.ToString()).FirstOrDefault();
if (mikeSourceModel != null)
{
mikeSourceModel.SourceNumberString = "SOURCE_" + (SourceNumber - 1).ToString();
MikeSourceModel mikeSourceModelRet = PostUpdateMikeSourceDB(mikeSourceModel);
if (!string.IsNullOrWhiteSpace(mikeSourceModelRet.Error))
{
return(ReturnError(mikeSourceModelRet.Error));
}
}
else
{
ok = true;
}
}
ts.Complete();
}
return(ReturnError(""));
}
public JsonResult FileRemoveJSON(int TVFileTVItemID)
{
TVFileModel tvFileModelRet = _TVFileService.PostDeleteTVFileWithTVItemIDDB(TVFileTVItemID);
return(Json(tvFileModelRet.Error, JsonRequestBehavior.AllowGet));
}
private bool GenerateKMZ()
{
string NotUsed = "";
//StringBuilder sbKMZ = new StringBuilder();
//DateTime CD = DateTime.Now;
//string Language = "_" + _TaskRunnerBaseService._BWObj.appTaskModel.Language;
//string DateText = "_" + CD.Year.ToString() +
// "_" + (CD.Month > 9 ? CD.Month.ToString() : "0" + CD.Month.ToString()) +
// "_" + (CD.Day > 9 ? CD.Day.ToString() : "0" + CD.Day.ToString()) +
// "_" + (CD.Hour > 9 ? CD.Hour.ToString() : "0" + CD.Hour.ToString()) +
// "_" + (CD.Minute > 9 ? CD.Minute.ToString() : "0" + CD.Minute.ToString());
switch (reportTypeModel.TVType)
{
case TVTypeEnum.MikeScenario:
break;
case TVTypeEnum.Subsector:
break;
default:
break;
}
//if (!RenameStartOfFileNameKMZ(fi))
//{
// return false;
//}
fi = new FileInfo(fi.FullName.Replace(".html", ".kml"));
if (fi.Exists)
{
try
{
fi.Delete();
fi = new FileInfo(fi.FullName);
}
catch (Exception ex)
{
NotUsed = string.Format(TaskRunnerServiceRes.CouldNotDeleteFile_Error_, fi.FullName, ex.Message + (ex.InnerException != null ? " Inner: " + ex.InnerException.Message : ""));
_TaskRunnerBaseService._BWObj.TextLanguageList = _TaskRunnerBaseService.GetTextLanguageFormat2List("CouldNotDeleteFile_Error_", fi.FullName, ex.Message + (ex.InnerException != null ? " Inner: " + ex.InnerException.Message : ""));
return(false);
}
}
switch (reportTypeModel.TVType)
{
case TVTypeEnum.Root:
{
if (!GenerateKMZRoot())
{
return(false);
}
}
break;
case TVTypeEnum.Area:
case TVTypeEnum.Country:
case TVTypeEnum.Infrastructure:
case TVTypeEnum.MikeScenario:
{
if (!GenerateKMZMikeScenario())
{
return(false);
}
}
break;
case TVTypeEnum.MikeSource:
case TVTypeEnum.Municipality:
case TVTypeEnum.MWQMSite:
case TVTypeEnum.PolSourceSite:
case TVTypeEnum.Province:
case TVTypeEnum.Sector:
case TVTypeEnum.Subsector:
{
if (!GenerateKMZSubsector())
{
return(false);
}
}
break;
case TVTypeEnum.BoxModel:
case TVTypeEnum.VisualPlumesScenario:
if (!GenerateKMZNotImplemented())
{
return(false);
}
break;
default:
break;
}
DirectoryInfo di = new DirectoryInfo(fi.DirectoryName);
if (!di.Exists)
{
try
{
di.Create();
}
catch (Exception ex)
{
NotUsed = string.Format(TaskRunnerServiceRes.CouldNotCreateDirectory__, di.FullName, ex.Message + (ex.InnerException != null ? " Inner: " + ex.InnerException.Message : ""));
_TaskRunnerBaseService._BWObj.TextLanguageList = _TaskRunnerBaseService.GetTextLanguageFormat2List("CouldNotCreateDirectory__", di.FullName, ex.Message + (ex.InnerException != null ? " Inner: " + ex.InnerException.Message : ""));
return(false);
}
}
StreamWriter sw = fi.CreateText();
sw.Write(sb.ToString());
sw.Flush();
sw.Close();
fi = new FileInfo(fi.FullName);
if (!fi.Exists)
{
NotUsed = string.Format(TaskRunnerServiceRes.CouldNotFindFile_, fi.FullName);
_TaskRunnerBaseService._BWObj.TextLanguageList = _TaskRunnerBaseService.GetTextLanguageFormat1List("CouldNotFindFile_", fi.FullName);
return(false);
}
//ProcessStartInfo pZip = new ProcessStartInfo();
//pZip.Arguments = "a -tzip \"" + fi.FullName.Replace(".kml", ".kmz") + "\" \"" + fi.FullName + "\"";
//pZip.RedirectStandardInput = true;
//pZip.UseShellExecute = false;
//pZip.CreateNoWindow = true;
//pZip.WindowStyle = ProcessWindowStyle.Hidden;
//Process processZip = new Process();
//processZip.StartInfo = pZip;
//try
//{
// pZip.FileName = @"C:\Program Files\7-Zip\7z.exe";
// processZip.Start();
//}
//catch (Exception ex)
//{
// NotUsed = string.Format(TaskRunnerServiceRes.CompressKMLDidNotWorkWith7zError_, ex.Message);
// _TaskRunnerBaseService._BWObj.TextLanguageList = _TaskRunnerBaseService.GetTextLanguageFormat1List("CompressKMLDidNotWorkWith7zError_", ex.Message);
// return false;
//}
//while (!processZip.HasExited)
//{
// // waiting for the processZip to finish then continue
//}
//fi = new FileInfo(fi.FullName);
//if (fi.Exists)
//{
// try
// {
// //fi.Delete();
// }
// catch (Exception ex)
// {
// NotUsed = string.Format(TaskRunnerServiceRes.CouldNotDeleteFile_Error_, fi.FullName, ex.Message + (ex.InnerException != null ? " Inner: " + ex.InnerException.Message : ""));
// _TaskRunnerBaseService._BWObj.TextLanguageList = _TaskRunnerBaseService.GetTextLanguageFormat2List("CouldNotDeleteFile_Error_", fi.FullName, ex.Message + (ex.InnerException != null ? " Inner: " + ex.InnerException.Message : ""));
// return false;
// }
//}
//fi = new FileInfo(fi.FullName.Replace(".kml", ".kmz"));
//if (!fi.Exists)
//{
// NotUsed = string.Format(TaskRunnerServiceRes.CouldNotFindFile_, fi.FullName);
// _TaskRunnerBaseService._BWObj.TextLanguageList = _TaskRunnerBaseService.GetTextLanguageFormat1List("CouldNotFindFile_", fi.FullName);
// return false;
//}
TVFileService tvFileService = new TVFileService(_TaskRunnerBaseService._BWObj.appTaskModel.Language, _TaskRunnerBaseService._User);
TVItemService tvItemService = new TVItemService(_TaskRunnerBaseService._BWObj.appTaskModel.Language, _TaskRunnerBaseService._User);
TVItemModel tvItemModel = tvItemService.PostAddChildTVItemDB(_TaskRunnerBaseService._BWObj.appTaskModel.TVItemID, fi.Name.Replace(fi.Extension, ""), TVTypeEnum.File);
if (!string.IsNullOrWhiteSpace(tvItemModel.Error))
{
NotUsed = string.Format(TaskRunnerServiceRes.CouldNotAdd_Error_, TaskRunnerServiceRes.TVItem, _TaskRunnerBaseService._BWObj.appTaskModel.TVItemID.ToString());
_TaskRunnerBaseService._BWObj.TextLanguageList = _TaskRunnerBaseService.GetTextLanguageFormat2List("CouldNotAdd_Error_", TaskRunnerServiceRes.TVItem, _TaskRunnerBaseService._BWObj.appTaskModel.TVItemID.ToString());
return(false);
}
TVFileModel tvFileModelNew = new TVFileModel();
tvFileModelNew.TVFileTVItemID = tvItemModel.TVItemID;
tvFileModelNew.TemplateTVType = 0;
tvFileModelNew.ReportTypeID = reportTypeModel.ReportTypeID;
tvFileModelNew.Parameters = Parameters;
tvFileModelNew.ServerFileName = fi.Name;
tvFileModelNew.FilePurpose = FilePurposeEnum.ReportGenerated;
tvFileModelNew.Language = _TaskRunnerBaseService._BWObj.appTaskModel.Language;
tvFileModelNew.Year = DateTime.Now.Year;
tvFileModelNew.FileDescription = reportTypeModel.Description;
tvFileModelNew.FileType = tvFileService.GetFileType(fi.Extension);
tvFileModelNew.FileSize_kb = (((int)fi.Length / 1024) == 0 ? 1 : (int)fi.Length / 1024);
tvFileModelNew.FileInfo = TaskRunnerServiceRes.FileName + "[" + fi.Name + "]\r\n" + TaskRunnerServiceRes.FileType + "[" + fi.Extension + "]\r\n";
tvFileModelNew.FileCreatedDate_UTC = fi.LastWriteTimeUtc;
tvFileModelNew.ServerFilePath = (fi.DirectoryName + @"\").Replace(@"C:\", @"E:\");
tvFileModelNew.LastUpdateDate_UTC = DateTime.UtcNow;
tvFileModelNew.LastUpdateContactTVItemID = _TaskRunnerBaseService._BWObj.appTaskModel.LastUpdateContactTVItemID;
TVFileModel tvFileModelRet = tvFileService.PostAddTVFileDB(tvFileModelNew);
if (!string.IsNullOrWhiteSpace(tvFileModelRet.Error))
{
NotUsed = string.Format(TaskRunnerServiceRes.CouldNotAdd_Error_, TaskRunnerServiceRes.TVFile, tvFileModelRet.Error);
_TaskRunnerBaseService._BWObj.TextLanguageList = _TaskRunnerBaseService.GetTextLanguageFormat2List("CouldNotAdd_Error_", TaskRunnerServiceRes.TVFile, tvFileModelRet.Error);
return(false);
}
return(true);
}
public string GenerateFileNameForDocTemplate(int DocTemplateID, int ParentTVItemID, string LanguageRequest)
{
List <string> ReplaceTextListWithUnderscore = new List <string>()
{
"#", "%", "&", "{", "}", "\\", "<", ">", "*", "?", "/", " ", "$", "!", "'", "\"", ":", "@", "+", "`", "|", "="
};
if (LanguageRequest == "fr")
{
Thread.CurrentThread.CurrentCulture = new CultureInfo("fr-CA");
Thread.CurrentThread.CurrentUICulture = new CultureInfo("fr-CA");
}
else
{
Thread.CurrentThread.CurrentCulture = new CultureInfo("en-CA");
Thread.CurrentThread.CurrentUICulture = new CultureInfo("en-CA");
}
DocTemplateModel docTemplateModel = GetDocTemplateModelWithDocTemplateIDDB(DocTemplateID);
if (!string.IsNullOrWhiteSpace(docTemplateModel.Error))
{
return("ERROR_" + docTemplateModel.Error.Replace(" ", "_"));
}
TVItemModel tvItemModelTemplateFile = _TVItemService.GetTVItemModelWithTVItemIDDB(docTemplateModel.TVFileTVItemID);
if (!string.IsNullOrWhiteSpace(tvItemModelTemplateFile.Error))
{
return("ERROR_" + tvItemModelTemplateFile.Error.Replace(" ", "_"));
}
TVItemModel tvItemModelParent = _TVItemService.GetTVItemModelWithTVItemIDDB(ParentTVItemID);
if (!string.IsNullOrWhiteSpace(tvItemModelParent.Error))
{
return("ERROR_" + tvItemModelParent.Error.Replace(" ", "_"));
}
TVFileModel tvFileModelTemplate = _TVFileService.GetTVFileModelWithTVFileTVItemIDDB(docTemplateModel.TVFileTVItemID);
if (!string.IsNullOrWhiteSpace(tvFileModelTemplate.Error))
{
return("ERROR_" + tvFileModelTemplate.Error.Replace(" ", "_"));
}
FileInfo fiTemplate = new FileInfo(_TVFileService.ChoseEDriveOrCDrive(_TVFileService.GetServerFilePath(tvItemModelTemplateFile.ParentID)) + tvFileModelTemplate.ServerFileName);
if (!fiTemplate.Exists)
{
return("ERROR_" + string.Format(ServiceRes.CouldNotFind_, fiTemplate.FullName).Replace(" ", "_"));
}
DateTime DateUtc = DateTime.UtcNow;
string FileName = tvFileModelTemplate.ServerFileName.Replace(fiTemplate.Extension.ToLower(), "") + "_" + DateUtc.Year.ToString() + "_" +
(DateUtc.Month < 10 ? "0" + DateUtc.Month.ToString() : DateUtc.Month.ToString()) + "_" +
(DateUtc.Day < 10 ? "0" + DateUtc.Day.ToString() : DateUtc.Day.ToString()) + "_" +
(DateUtc.Hour < 10 ? "0" + DateUtc.Hour.ToString() : DateUtc.Hour.ToString()) + "_" +
(DateUtc.Minute < 10 ? "0" + DateUtc.Minute.ToString() : DateUtc.Minute.ToString()) + "_" +
LanguageRequest + fiTemplate.Extension.ToLower();
return(FileName);
}
public TVItemModel PictureFileUploadDB(HttpRequestBase Request)
{
string AdminEmail = Request.QueryString["e"];
int TVItemID = int.Parse(Request.QueryString["t"]);
IPrincipal user = new GenericPrincipal(new GenericIdentity(AdminEmail, "Forms"), null);
ContactService contactService = new ContactService(LanguageRequest, user);
ContactModel contactModel = contactService.GetContactModelWithLoginEmailDB(AdminEmail);
if (!string.IsNullOrWhiteSpace(contactModel.Error))
{
return(new TVItemModel()
{
Error = "ERROR: " + string.Format(ServiceRes.NoUserWithEmail_, AdminEmail)
});
}
TVItemService tvItemService = new TVItemService(LanguageRequest, user);
TVFileService tvFileService = new TVFileService(LanguageRequest, user);
List <string> AllowableExt = tvFileService.GetAllowableExt();
TVFileModel tvFileModelRet = new TVFileModel();
using (TransactionScope ts = new TransactionScope())
{
string FileName = "";
if (Request.Files.Count != 1)
{
return new TVItemModel()
{
Error = "ERROR: " + ServiceRes.CanOnlyLoadOneFileAtATime
}
}
;
HttpPostedFileBase hpf = null;
foreach (string file in Request.Files)
{
hpf = Request.Files[file];
}
if (hpf == null)
{
return new TVItemModel()
{
Error = "ERROR: " + ServiceRes.PleaseSelectAFileToUpload
}
}
;
FileName = hpf.FileName;
FileInfo fi = new FileInfo(FileName);
if (!AllowableExt.Contains(fi.Extension.ToLower()))
{
string AllowableExtText = "";
foreach (string s in AllowableExt)
{
AllowableExtText += s + " ";
}
return(new TVItemModel()
{
Error = "ERROR: " + string.Format(ServiceRes.PleaseSelectAFileOfType_, AllowableExtText)
});
}
string ServerFileName = "";
if (FileName.Contains(@"\"))
{
ServerFileName = FileName.Substring(FileName.LastIndexOf(@"\") + 1);
}
else
{
ServerFileName = FileName;
}
TVItemModel tvItemModelPSS = tvItemService.GetTVItemModelWithTVItemIDDB(TVItemID);
if (!string.IsNullOrWhiteSpace(tvItemModelPSS.Error))
{
return(new TVItemModel()
{
Error = "ERROR: " + tvItemModelPSS.Error
});
}
TVItemModel tvItemModelExist = tvItemService.GetChildTVItemModelWithParentIDAndTVTextAndTVTypeDB(tvItemModelPSS.TVItemID, ServerFileName, TVTypeEnum.File);
if (string.IsNullOrEmpty(tvItemModelExist.Error))
{
return(new TVItemModel()
{
Error = "ERROR: " + string.Format(ServiceRes._AlreadyExists, ServerFileName)
});
}
TVItemModel tvItemModelTVFileRet = tvItemService.PostAddChildTVItemDB(tvItemModelPSS.TVItemID, ServerFileName, TVTypeEnum.File);
if (!string.IsNullOrEmpty(tvItemModelTVFileRet.Error))
{
return(new TVItemModel()
{
Error = "ERROR: " + tvItemModelTVFileRet.Error
});
}
string ServerFilePath = tvFileService.GetServerFilePath(tvItemModelPSS.TVItemID);
int FileLength = hpf.ContentLength;
DirectoryInfo di = new DirectoryInfo(ServerFilePath);
if (!di.Exists)
{
di.Create();
}
fi = new FileInfo(ServerFilePath + ServerFileName);
if (fi.Exists)
{
return(new TVItemModel()
{
Error = "ERROR: " + string.Format(ServiceRes.File_AlreadyExist, ServerFileName)
});
}
hpf.SaveAs(fi.FullName);
FileTypeEnum fileType = tvFileService.GetFileType(fi.Extension.ToUpper());
TVFileModel tvFileModelNew = new TVFileModel()
{
TVFileTVItemID = tvItemModelTVFileRet.TVItemID,
FilePurpose = FilePurposeEnum.Picture,
FileDescription = "Temp description",
FileType = fileType,
FileSize_kb = Math.Max(hpf.ContentLength / 1024, 1),
FileInfo = "Uploaded file",
FileCreatedDate_UTC = DateTime.Now,
FromWater = false,
ClientFilePath = FileName,
ServerFileName = ServerFileName,
ServerFilePath = ServerFilePath,
Language = LanguageEnum.en,
Year = DateTime.Now.Year,
};
tvFileModelRet = tvFileService.PostAddTVFileDB(tvFileModelNew);
if (!string.IsNullOrWhiteSpace(tvFileModelRet.Error))
{
DeleteFileFromServer(fi);
{
return(new TVItemModel()
{
Error = "ERROR: " + tvFileModelRet.Error
});
}
}
ts.Complete();
}
return(new TVItemModel()
{
Error = tvFileModelRet.TVFileTVItemID.ToString()
});
}
public JsonResult FileEditSaveJSON(FormCollection fc)
{
TVFileModel tvFileModelRet = _TVFileService.FileEditSaveDB(fc);
return(Json(tvFileModelRet.Error, JsonRequestBehavior.AllowGet));
}
public void MikeScenarioFileService_CreateInititalConditionFileSalAndTempFromTVFileItemID_Test()
{
foreach (LanguageEnum LanguageRequest in new List <LanguageEnum>()
{
LanguageEnum.en, LanguageEnum.fr
})
{
SetupTest(LanguageRequest);
int MikeScenarioTVItemID = 357139;
string Parameters = $"|||not important|||";
AppTaskModel appTaskModel = new AppTaskModel()
{
AppTaskID = 100000,
TVItemID = MikeScenarioTVItemID,
TVItemID2 = MikeScenarioTVItemID,
AppTaskCommand = AppTaskCommandEnum.Error,
AppTaskStatus = AppTaskStatusEnum.Error,
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;
MikeScenarioFileService _MikeScenarioFileService = new MikeScenarioFileService(taskRunnerBaseService);
TVItemModel tvItemModelMikeScenario = _TVItemService.GetTVItemModelWithTVItemIDDB(MikeScenarioTVItemID);
Assert.AreEqual("", tvItemModelMikeScenario.Error);
MikeScenarioModel mikeScenarioModel = _MikeScenarioService.GetMikeScenarioModelWithMikeScenarioTVItemIDDB(MikeScenarioTVItemID);
Assert.AreEqual("", mikeScenarioModel.Error);
TVFileModel tvFileModelM21_3FM = _TVFileService.GetTVFileModelWithTVItemIDAndTVFileTypeM21FMOrM3FMDB(MikeScenarioTVItemID);
Assert.AreEqual("", tvFileModelM21_3FM.Error);
string ServerPath = _TVFileService.GetServerFilePath(MikeScenarioTVItemID);
FileInfo fiM21_M3 = new FileInfo(ServerPath + tvFileModelM21_3FM.ServerFileName);
Assert.AreEqual(true, fiM21_M3.Exists);
_MikeScenarioFileService.CreateInititalConditionFileSalAndTempFromTVFileItemID(MikeScenarioTVItemID, (int)mikeScenarioModel.UseSalinityAndTemperatureInitialConditionFromTVFileTVItemID, fiM21_M3);
Assert.AreEqual(0, taskRunnerBaseService._BWObj.TextLanguageList.Count);
break;
}
}
private bool GenerateHTMLSubsectorFullReportCoverPage(FileInfo fi, StringBuilder sbHTML, string parameters, ReportTypeModel reportTypeModel)
{
string NotUsed = "";
int TVItemID = 0;
int Year = 0;
Random random = new Random();
string FileNameExtra = "";
for (int i = 0; i < 10; i++)
{
FileNameExtra = FileNameExtra + (char)random.Next(97, 122);
}
_TaskRunnerBaseService.SendPercentToDB(_TaskRunnerBaseService._BWObj.appTaskModel.AppTaskID, 3);
if (!GetTopHTML(sbHTML))
{
return(false);
}
List <string> ParamValueList = parameters.Split("|||".ToCharArray(), StringSplitOptions.RemoveEmptyEntries).ToList();
if (!int.TryParse(GetParameters("TVItemID", ParamValueList), out TVItemID))
{
NotUsed = string.Format(TaskRunnerServiceRes.CouldNotFind__, TaskRunnerServiceRes.Parameter, TaskRunnerServiceRes.TVItemID);
_TaskRunnerBaseService._BWObj.TextLanguageList = _TaskRunnerBaseService.GetTextLanguageFormat2List("CouldNotFind__", TaskRunnerServiceRes.Parameter, TaskRunnerServiceRes.TVItemID);
return(false);
}
TVItemModel tvItemModelSubsector = _TVItemService.GetTVItemModelWithTVItemIDDB(TVItemID);
if (!string.IsNullOrWhiteSpace(tvItemModelSubsector.Error))
{
NotUsed = string.Format(TaskRunnerServiceRes.CouldNotFind_With_Equal_, TaskRunnerServiceRes.TVItem, TaskRunnerServiceRes.TVItemID, TVItemID.ToString());
_TaskRunnerBaseService._BWObj.TextLanguageList = _TaskRunnerBaseService.GetTextLanguageList(tvItemModelSubsector.Error);
return(false);
}
if (!int.TryParse(GetParameters("Year", ParamValueList), out Year))
{
NotUsed = string.Format(TaskRunnerServiceRes.CouldNotFind__, TaskRunnerServiceRes.Parameter, TaskRunnerServiceRes.Year);
_TaskRunnerBaseService._BWObj.TextLanguageList = _TaskRunnerBaseService.GetTextLanguageFormat2List("CouldNotFind__", TaskRunnerServiceRes.Parameter, TaskRunnerServiceRes.Year);
return(false);
}
TVItemModel tvItemModelRoot = _TVItemService.GetRootTVItemModelDB();
if (!string.IsNullOrWhiteSpace(tvItemModelRoot.Error))
{
NotUsed = TaskRunnerServiceRes.CouldNotFindTVItemRoot;
_TaskRunnerBaseService._BWObj.TextLanguageList = _TaskRunnerBaseService.GetTextLanguageList("CouldNotFindTVItemRoot");
return(false);
}
string ServerPath = _TVFileService.GetServerFilePath(tvItemModelRoot.TVItemID);
TVFileModel tvFileModelFullReportCoverPageCanadaFlag = _TVFileService.GetTVFileModelWithServerFilePathAndServerFileNameDB(ServerPath, "CanadaFlag.png");
if (!string.IsNullOrWhiteSpace(tvFileModelFullReportCoverPageCanadaFlag.Error))
{
NotUsed = string.Format(TaskRunnerServiceRes.CouldNotFindFile_, ServerPath + "CanadaFlag.png");
_TaskRunnerBaseService._BWObj.TextLanguageList = _TaskRunnerBaseService.GetTextLanguageFormat1List("CouldNotFindFile_", ServerPath + "CanadaFlag.png");
return(false);
}
FileInfo fiFullReportCoverPageImageCanadaFlag = new FileInfo(tvFileModelFullReportCoverPageCanadaFlag.ServerFilePath + tvFileModelFullReportCoverPageCanadaFlag.ServerFileName);
if (!fiFullReportCoverPageImageCanadaFlag.Exists)
{
NotUsed = string.Format(TaskRunnerServiceRes.CouldNotFindFile_, fiFullReportCoverPageImageCanadaFlag.FullName);
_TaskRunnerBaseService._BWObj.TextLanguageList = _TaskRunnerBaseService.GetTextLanguageFormat1List("CouldNotFindFile_", fiFullReportCoverPageImageCanadaFlag.FullName);
return(false);
}
TVFileModel tvFileModelFullReportCoverPageCanadaBanner = _TVFileService.GetTVFileModelWithServerFilePathAndServerFileNameDB(ServerPath, "CanadaBanner.png");
if (!string.IsNullOrWhiteSpace(tvFileModelFullReportCoverPageCanadaBanner.Error))
{
NotUsed = string.Format(TaskRunnerServiceRes.CouldNotFindFile_, ServerPath + "CanadaBanner.png");
_TaskRunnerBaseService._BWObj.TextLanguageList = _TaskRunnerBaseService.GetTextLanguageFormat1List("CouldNotFindFile_", ServerPath + "CanadaBanner.png");
return(false);
}
FileInfo fiFullReportCoverPageImageCanadaBanner = new FileInfo(tvFileModelFullReportCoverPageCanadaBanner.ServerFilePath + tvFileModelFullReportCoverPageCanadaBanner.ServerFileName);
if (!fiFullReportCoverPageImageCanadaBanner.Exists)
{
NotUsed = string.Format(TaskRunnerServiceRes.CouldNotFindFile_, fiFullReportCoverPageImageCanadaBanner.FullName);
_TaskRunnerBaseService._BWObj.TextLanguageList = _TaskRunnerBaseService.GetTextLanguageFormat1List("CouldNotFindFile_", fiFullReportCoverPageImageCanadaBanner.FullName);
return(false);
}
TVFileModel tvFileModelFullReportCoverPageCanadaWithFlag = _TVFileService.GetTVFileModelWithServerFilePathAndServerFileNameDB(ServerPath, "CanadaWithFlag.png");
if (!string.IsNullOrWhiteSpace(tvFileModelFullReportCoverPageCanadaWithFlag.Error))
{
NotUsed = string.Format(TaskRunnerServiceRes.CouldNotFindFile_, ServerPath + "CanadaWithFlag.png");
_TaskRunnerBaseService._BWObj.TextLanguageList = _TaskRunnerBaseService.GetTextLanguageFormat1List("CouldNotFindFile_", ServerPath + "CanadaWithFlag.png");
return(false);
}
FileInfo fiFullReportCoverPageImageCanadaWithFlag = new FileInfo(tvFileModelFullReportCoverPageCanadaWithFlag.ServerFilePath + tvFileModelFullReportCoverPageCanadaWithFlag.ServerFileName);
if (!fiFullReportCoverPageImageCanadaWithFlag.Exists)
{
NotUsed = string.Format(TaskRunnerServiceRes.CouldNotFindFile_, fiFullReportCoverPageImageCanadaBanner.FullName);
_TaskRunnerBaseService._BWObj.TextLanguageList = _TaskRunnerBaseService.GetTextLanguageFormat1List("CouldNotFindFile_", fiFullReportCoverPageImageCanadaWithFlag.FullName);
return(false);
}
List <TVItemModel> tvItemModelListParent = _TVItemService.GetParentsTVItemModelList(tvItemModelSubsector.TVPath);
TVItemModel tvItemModelProvince = new TVItemModel();
foreach (TVItemModel tvItemModel in tvItemModelListParent)
{
if (tvItemModel.TVType == TVTypeEnum.Province)
{
tvItemModelProvince = tvItemModel;
break;
}
}
int Pos = tvItemModelSubsector.TVText.IndexOf(" ");
string SubsectorShort = "Error";
string SubsectorEndPart = "Error";
if (Pos > 0)
{
SubsectorShort = tvItemModelSubsector.TVText.Substring(0, Pos).Trim();
SubsectorEndPart = tvItemModelSubsector.TVText.Substring(Pos).Trim();
}
string NamesOfAuthors = "Name of authors";
string ReportDateText = DateTime.Now.ToString("MMMM yyyy");
_TaskRunnerBaseService.SendPercentToDB(_TaskRunnerBaseService._BWObj.appTaskModel.AppTaskID, 5);
sbHTML.AppendLine($@" <p> </p>");
sbHTML.AppendLine($@" <table>");
sbHTML.AppendLine($@" <tr> ");
sbHTML.AppendLine($@" <td>|||Image|FileName,{ fiFullReportCoverPageImageCanadaFlag.FullName }|width,45|height,20|||</td> ");
sbHTML.AppendLine($@" <td> </td>");
sbHTML.AppendLine($@" <td class=""textAlignLeft""><h5 class=""ECCCCoverPage"">Environment and <br />Climate Change Canada</h5></td>");
sbHTML.AppendLine($@" <td> </td>");
sbHTML.AppendLine($@" <td class=""textAlignLeft""><h5 class=""ECCCCoverPage"">Environnement et <br />Changement climatique Canada</h5></td>");
sbHTML.AppendLine($@" </tr>");
sbHTML.AppendLine($@" </table>");
sbHTML.AppendLine($@" <div class=""textAlignLeft"">");
sbHTML.AppendLine($@" |||Image|FileName,{ fiFullReportCoverPageImageCanadaBanner.FullName }|width,480|height,48|||");
sbHTML.AppendLine($@" </div>");
sbHTML.AppendLine($@" <div>");
sbHTML.AppendLine($@" <br />");
sbHTML.AppendLine($@" <br />");
sbHTML.AppendLine($@" <blockquote>");
sbHTML.AppendLine($@" <hr />");
sbHTML.AppendLine($@" <h5 class=""textAlignLeft"">{ TaskRunnerServiceRes.MarineWaterQualityReEvaluationReport }</h5>");
sbHTML.AppendLine($@" <hr />");
sbHTML.AppendLine($@" <h5 class=""textAlignLeft"">{ tvItemModelProvince.TVText } { TaskRunnerServiceRes.ShellfishGrowingArea}</h5>");
sbHTML.AppendLine($@" <h5 class=""textAlignLeft"">{ SubsectorShort }</h5>");
sbHTML.AppendLine($@" <h5 class=""textAlignLeft"">{ SubsectorEndPart }</h5>");
sbHTML.AppendLine($@" <hr />");
sbHTML.AppendLine($@" <h5 class=""textAlignLeft"">{ NamesOfAuthors }</h5>");
sbHTML.AppendLine($@" <hr />");
sbHTML.AppendLine($@" </blockquote>");
sbHTML.AppendLine($@" <h5> </h5>");
sbHTML.AppendLine($@" <h5> </h5>");
sbHTML.AppendLine($@" <h5> </h5>");
sbHTML.AppendLine($@" <h5> </h5>");
sbHTML.AppendLine($@" <h5> </h5>");
sbHTML.AppendLine($@" <h5> </h5>");
sbHTML.AppendLine($@" <h5 class=""textAlignRight"">{ TaskRunnerServiceRes.AtlanticMarineWaterQualityMonitoring }</h5>");
sbHTML.AppendLine($@" <h5 class=""textAlignRight"">{ TaskRunnerServiceRes.Report } <span>_______________________</span></h5>");
sbHTML.AppendLine($@" <h5 class=""textAlignRight"">{ ReportDateText }</h5>");
sbHTML.AppendLine($@" </div>");
sbHTML.AppendLine($@" <div class=""textAlignRight"">|||Image|FileName,{ fiFullReportCoverPageImageCanadaWithFlag.FullName }|width,76|height,22|||</div>");
sbHTML.AppendLine(@"<span>|||PageBreak|||</span>");
if (!GetBottomHTML(sbHTML, fi, parameters))
{
return(false);
}
return(true);
}
public TVFileModel FileUploadDB(FormCollection fc, HttpRequestBase Request)
{
ContactOK contactOK = _TVFileService.IsContactOK();
if (!string.IsNullOrEmpty(contactOK.Error))
{
return(_TVFileService.ReturnError(contactOK.Error));
}
int ParentTVItemID = 0;
int tempInt = 0;
LanguageEnum Language = LanguageEnum.Error;
FilePurposeEnum FilePurpose = FilePurposeEnum.Error;
string FileDescription = "";
bool KeepFileName = true;
string SaveAsFileName = "";
bool? FromWater = null;
int? Year = null;
int.TryParse(fc["ParentTVItemID"], out ParentTVItemID);
if (ParentTVItemID == 0)
{
return new TVFileModel()
{
Error = string.Format(ServiceRes._IsRequired, ServiceRes.ParentTVItemID)
}
}
;
int.TryParse(fc["Language"], out tempInt);
if (tempInt == 0)
{
return new TVFileModel()
{
Error = string.Format(ServiceRes._IsRequired, ServiceRes.Language)
}
}
;
Language = (LanguageEnum)tempInt;
int.TryParse(fc["Year"], out tempInt);
if (tempInt == 0)
{
return new TVFileModel()
{
Error = string.Format(ServiceRes._IsRequired, ServiceRes.Year)
}
}
;
Year = tempInt;
int.TryParse(fc["FilePurpose"], out tempInt);
if (tempInt == 0)
{
return new TVFileModel()
{
Error = string.Format(ServiceRes._IsRequired, ServiceRes.FilePurpose)
}
}
;
FilePurpose = (FilePurposeEnum)tempInt;
FileDescription = fc["FileDescription"];
if (string.IsNullOrWhiteSpace(FileDescription))
{
return new TVFileModel()
{
Error = string.Format(ServiceRes._IsRequired, ServiceRes.FileDescription)
}
}
;
if (fc["KeepFileName"] == null)
{
KeepFileName = false;
}
if (!KeepFileName)
{
SaveAsFileName = fc["SaveAsFileName"];
if (string.IsNullOrWhiteSpace(SaveAsFileName))
{
return new TVFileModel()
{
Error = string.Format(ServiceRes._IsRequired, ServiceRes.SaveAsFileName)
}
}
;
}
if (fc["FromWater"] != null)
{
if (string.IsNullOrWhiteSpace(fc["FromWater"]))
{
FromWater = null;
}
else
{
FromWater = true;
}
}
List <string> AllowableExt = _TVFileService.GetAllowableExt();
TVFileModel tvFileModelRet = new TVFileModel();
using (TransactionScope ts = new TransactionScope())
{
string FileName = "";
if (Request.Files.Count != 1)
{
return(_TVFileService.ReturnError(ServiceRes.CanOnlyLoadOneFileAtATime));
}
HttpPostedFileBase hpf = null;
foreach (string file in Request.Files)
{
hpf = Request.Files[file];
}
if (hpf == null)
{
return(_TVFileService.ReturnError(ServiceRes.PleaseSelectAFileToUpload));
}
FileName = hpf.FileName;
FileInfo fi = new FileInfo(FileName);
if (!AllowableExt.Contains(fi.Extension.ToLower()))
{
string AllowableExtText = "";
foreach (string s in AllowableExt)
{
AllowableExtText += s + " ";
}
return(_TVFileService.ReturnError(string.Format(ServiceRes.PleaseSelectAFileOfType_, AllowableExtText)));
}
string ServerFileName = "";
if (FileName.Contains(@"\"))
{
ServerFileName = FileName.Substring(FileName.LastIndexOf(@"\") + 1);
}
else
{
ServerFileName = FileName;
}
if (!KeepFileName)
{
ServerFileName = SaveAsFileName + fi.Extension;
}
string ServerFilePath = "";
TVItemModel tvItemModelParent = new TVItemModel();
if (FilePurpose == FilePurposeEnum.Template)
{
tvItemModelParent = _TVItemService.GetRootTVItemModelDB();
if (!string.IsNullOrEmpty(tvItemModelParent.Error))
{
return(_TVFileService.ReturnError(tvItemModelParent.Error));
}
}
else
{
tvItemModelParent = _TVFileService._TVItemService.GetTVItemModelWithTVItemIDDB(ParentTVItemID);
if (!string.IsNullOrWhiteSpace(tvItemModelParent.Error))
{
return(_TVFileService.ReturnError(tvItemModelParent.Error));
}
}
TVItemModel tvItemModelExist = _TVFileService._TVItemService.GetChildTVItemModelWithParentIDAndTVTextAndTVTypeDB(tvItemModelParent.TVItemID, ServerFileName, TVTypeEnum.File);
if (string.IsNullOrEmpty(tvItemModelExist.Error))
{
return(_TVFileService.ReturnError(string.Format(ServiceRes._AlreadyExists, ServerFileName)));
}
TVItemModel tvItemModelTVFileRet = _TVFileService._TVItemService.PostAddChildTVItemDB(tvItemModelParent.TVItemID, ServerFileName, TVTypeEnum.File);
if (!string.IsNullOrEmpty(tvItemModelTVFileRet.Error))
{
return(_TVFileService.ReturnError(tvItemModelTVFileRet.Error));
}
ServerFilePath = _TVFileService.GetServerFilePath(tvItemModelParent.TVItemID);
int FileLength = hpf.ContentLength;
DirectoryInfo di = new DirectoryInfo(ServerFilePath);
if (!di.Exists)
{
di.Create();
}
fi = new FileInfo(ServerFilePath + ServerFileName);
if (fi.Exists)
{
return(_TVFileService.ReturnError(string.Format(ServiceRes.File_AlreadyExist, ServerFileName)));
}
hpf.SaveAs(fi.FullName);
FileTypeEnum fileType = _TVFileService.GetFileType(fi.Extension.ToUpper());
if (FilePurpose == FilePurposeEnum.Template)
{
//if (!(fileType == FileTypeEnum.CSV || fileType == FileTypeEnum.XLSX || fileType == FileTypeEnum.DOCX || fileType == FileTypeEnum.KML))
//{
// DeleteFileFromServer(fi);
// return _TVFileService.ReturnError(string.Format(ServiceRes.WhenUploadingTemplateOnlyFileTypes_AreAllowed, ".csv, .docx, .xlsx, .kml"));
//}
if (!(fileType == FileTypeEnum.CSV || fileType == FileTypeEnum.DOCX || fileType == FileTypeEnum.KML || fileType == FileTypeEnum.XLSX))
{
DeleteFileFromServer(fi);
return(_TVFileService.ReturnError(string.Format(ServiceRes.WhenUploadingTemplateOnlyFileTypes_AreAllowed, ".csv, .docx, .xmlx and .kml") + " ... for now."));
}
}
TVFileModel tvFileModelNew = new TVFileModel()
{
TVFileTVItemID = tvItemModelTVFileRet.TVItemID,
FilePurpose = FilePurpose,
FileDescription = FileDescription,
FileType = fileType,
FileSize_kb = Math.Max(hpf.ContentLength / 1024, 1),
FileInfo = "Uploaded file",
FileCreatedDate_UTC = DateTime.Now,
FromWater = FromWater,
ClientFilePath = FileName,
ServerFileName = ServerFileName,
ServerFilePath = ServerFilePath,
Language = Language,
Year = Year,
};
TVFile tvFileExist = _TVFileService.GetTVFileExistDB(tvFileModelNew);
if (tvFileExist != null)
{
DeleteFileFromServer(fi);
return(_TVFileService.ReturnError(string.Format(ServiceRes._AlreadyExists, ServiceRes.TVFile)));
}
tvFileModelRet = _TVFileService.PostAddTVFileDB(tvFileModelNew);
if (!string.IsNullOrWhiteSpace(tvFileModelRet.Error))
{
DeleteFileFromServer(fi);
return(_TVFileService.ReturnError(tvFileModelRet.Error));
}
if (FilePurpose == FilePurposeEnum.Template)
{
tvItemModelParent = _TVFileService._TVItemService.GetTVItemModelWithTVItemIDDB(ParentTVItemID);
if (!string.IsNullOrWhiteSpace(tvItemModelParent.Error))
{
return(_TVFileService.ReturnError(tvItemModelParent.Error));
}
DocTemplateModel docTemplateModelNew = new DocTemplateModel()
{
TVType = tvItemModelParent.TVType,
TVFileTVItemID = tvFileModelRet.TVFileTVItemID,
FileName = ServerFileName,
};
DocTemplateModel docTemplateModelRet = _DocTemplateService.PostAddDocTemplateDB(docTemplateModelNew);
if (!string.IsNullOrWhiteSpace(docTemplateModelRet.Error))
{
DeleteFileFromServer(fi);
return(_TVFileService.ReturnError(docTemplateModelRet.Error));
}
//bool IsTrue = true;
//if (IsTrue)
//{
// DeleteFileFromServer(fi);
// return _TVFileService.ReturnError("Should parse the File to check if the first ||| tag has the right TVType");
//}
}
ts.Complete();
}
return(tvFileModelRet);
}
public JsonResult CreateArcGISDocumentJSON(FormCollection fc)
{
TVFileModel tvFileModelRet = _TVFileService.CreateArcGISDocumentDB(fc);
return(Json(tvFileModelRet.Error, JsonRequestBehavior.AllowGet));
}
private bool GenerateHTMLSUBSECTOR_RE_EVALUATION_COVER_PAGE(StringBuilder sbTemp)
{
int Percent = 10;
string NotUsed = "";
_TaskRunnerBaseService.SendPercentToDB(_TaskRunnerBaseService._BWObj.appTaskModel.AppTaskID, Percent);
_TaskRunnerBaseService.SendStatusTextToDB(_TaskRunnerBaseService.GetTextLanguageFormat1List("Creating_", ReportGenerateObjectsKeywordEnum.SUBSECTOR_RE_EVALUATION_COVER_PAGE.ToString()));
List <string> ParamValueList = Parameters.Split("|||".ToCharArray(), StringSplitOptions.RemoveEmptyEntries).ToList();
// TVItemID and Year already loaded
TVItemModel tvItemModelSubsector = _TVItemService.GetTVItemModelWithTVItemIDDB(TVItemID);
if (!string.IsNullOrWhiteSpace(tvItemModelSubsector.Error))
{
NotUsed = string.Format(TaskRunnerServiceRes.CouldNotFind_With_Equal_, TaskRunnerServiceRes.TVItem, TaskRunnerServiceRes.TVItemID, TVItemID.ToString());
_TaskRunnerBaseService._BWObj.TextLanguageList = _TaskRunnerBaseService.GetTextLanguageList(tvItemModelSubsector.Error);
return(false);
}
List <TVItemModel> tvItemModelParentList = _TVItemService.GetParentsTVItemModelList(tvItemModelSubsector.TVPath);
TVItemModel tvItemModelProv = new TVItemModel();
foreach (TVItemModel tvItemModel in tvItemModelParentList)
{
if (tvItemModel.TVType == TVTypeEnum.Province)
{
tvItemModelProv = tvItemModel;
}
}
string ProvInitCap = "";
switch (tvItemModelProv.TVText)
{
case "New Brunswick":
case "Nouveau-Brunswick":
{
ProvInitCap = "NB";
}
break;
case "Newfoundland and Labrador":
case "Terre-Neuve_et-Labrador":
{
ProvInitCap = "NL";
}
break;
case "Nova Scotia":
case "Nouvelle-Écosse":
{
ProvInitCap = "NS";
}
break;
case "Prince Edward Island":
case "Île-du-Prince-Édouard":
{
ProvInitCap = "PE";
}
break;
case "British Columbia":
case "Colombie-Britannique":
{
ProvInitCap = "BC";
}
break;
case "Quebec":
case "Québec":
{
ProvInitCap = "QC";
}
break;
default:
break;
}
TVItemModel tvItemModelRoot = _TVItemService.GetRootTVItemModelDB();
if (!string.IsNullOrWhiteSpace(tvItemModelRoot.Error))
{
NotUsed = TaskRunnerServiceRes.CouldNotFindTVItemRoot;
_TaskRunnerBaseService._BWObj.TextLanguageList = _TaskRunnerBaseService.GetTextLanguageList("CouldNotFindTVItemRoot");
return(false);
}
string ServerPath = _TVFileService.GetServerFilePath(tvItemModelRoot.TVItemID);
TVFileModel tvFileModelFullReportCoverPageCanadaFlag = _TVFileService.GetTVFileModelWithServerFilePathAndServerFileNameDB(ServerPath, "CanadaFlag.png");
if (!string.IsNullOrWhiteSpace(tvFileModelFullReportCoverPageCanadaFlag.Error))
{
NotUsed = string.Format(TaskRunnerServiceRes.CouldNotFindFile_, ServerPath + "CanadaFlag.png");
_TaskRunnerBaseService._BWObj.TextLanguageList = _TaskRunnerBaseService.GetTextLanguageFormat1List("CouldNotFindFile_", ServerPath + "CanadaFlag.png");
return(false);
}
FileInfo fiFullReportCoverPageImageCanadaFlag = new FileInfo(tvFileModelFullReportCoverPageCanadaFlag.ServerFilePath + tvFileModelFullReportCoverPageCanadaFlag.ServerFileName);
if (!fiFullReportCoverPageImageCanadaFlag.Exists)
{
NotUsed = string.Format(TaskRunnerServiceRes.CouldNotFindFile_, fiFullReportCoverPageImageCanadaFlag.FullName);
_TaskRunnerBaseService._BWObj.TextLanguageList = _TaskRunnerBaseService.GetTextLanguageFormat1List("CouldNotFindFile_", fiFullReportCoverPageImageCanadaFlag.FullName);
return(false);
}
TVFileModel tvFileModelFullReportCoverPageLeafRight = _TVFileService.GetTVFileModelWithServerFilePathAndServerFileNameDB(ServerPath, "LeafRight.png");
if (!string.IsNullOrWhiteSpace(tvFileModelFullReportCoverPageLeafRight.Error))
{
NotUsed = string.Format(TaskRunnerServiceRes.CouldNotFindFile_, ServerPath + "LeafRight.png");
_TaskRunnerBaseService._BWObj.TextLanguageList = _TaskRunnerBaseService.GetTextLanguageFormat1List("CouldNotFindFile_", ServerPath + "LeafRight.png");
return(false);
}
FileInfo fiFullReportCoverPageImageLeafRight = new FileInfo(tvFileModelFullReportCoverPageLeafRight.ServerFilePath + tvFileModelFullReportCoverPageLeafRight.ServerFileName);
if (!fiFullReportCoverPageImageLeafRight.Exists)
{
NotUsed = string.Format(TaskRunnerServiceRes.CouldNotFindFile_, fiFullReportCoverPageImageLeafRight.FullName);
_TaskRunnerBaseService._BWObj.TextLanguageList = _TaskRunnerBaseService.GetTextLanguageFormat1List("CouldNotFindFile_", fiFullReportCoverPageImageLeafRight.FullName);
return(false);
}
TVFileModel tvFileModelFullReportCoverPageBarTopBottom = _TVFileService.GetTVFileModelWithServerFilePathAndServerFileNameDB(ServerPath, "BarTopBottom.png");
if (!string.IsNullOrWhiteSpace(tvFileModelFullReportCoverPageBarTopBottom.Error))
{
NotUsed = string.Format(TaskRunnerServiceRes.CouldNotFindFile_, ServerPath + "BarTopBottom.png");
_TaskRunnerBaseService._BWObj.TextLanguageList = _TaskRunnerBaseService.GetTextLanguageFormat1List("CouldNotFindFile_", ServerPath + "BarTopBottom.png");
return(false);
}
FileInfo fiFullReportCoverPageImageBarTopBottom = new FileInfo(tvFileModelFullReportCoverPageBarTopBottom.ServerFilePath + tvFileModelFullReportCoverPageBarTopBottom.ServerFileName);
if (!fiFullReportCoverPageImageBarTopBottom.Exists)
{
NotUsed = string.Format(TaskRunnerServiceRes.CouldNotFindFile_, fiFullReportCoverPageImageBarTopBottom.FullName);
_TaskRunnerBaseService._BWObj.TextLanguageList = _TaskRunnerBaseService.GetTextLanguageFormat1List("CouldNotFindFile_", fiFullReportCoverPageImageBarTopBottom.FullName);
return(false);
}
TVFileModel tvFileModelFullReportCoverPageThreeImagesBottom = _TVFileService.GetTVFileModelWithServerFilePathAndServerFileNameDB(ServerPath, "ThreeImagesBottom.png");
if (!string.IsNullOrWhiteSpace(tvFileModelFullReportCoverPageThreeImagesBottom.Error))
{
NotUsed = string.Format(TaskRunnerServiceRes.CouldNotFindFile_, ServerPath + "ThreeImagesBottom.png");
_TaskRunnerBaseService._BWObj.TextLanguageList = _TaskRunnerBaseService.GetTextLanguageFormat1List("CouldNotFindFile_", ServerPath + "ThreeImagesBottom.png");
return(false);
}
FileInfo fiFullReportCoverPageImageThreeImagesBottom = new FileInfo(tvFileModelFullReportCoverPageThreeImagesBottom.ServerFilePath + tvFileModelFullReportCoverPageThreeImagesBottom.ServerFileName);
if (!fiFullReportCoverPageImageThreeImagesBottom.Exists)
{
NotUsed = string.Format(TaskRunnerServiceRes.CouldNotFindFile_, fiFullReportCoverPageImageThreeImagesBottom.FullName);
_TaskRunnerBaseService._BWObj.TextLanguageList = _TaskRunnerBaseService.GetTextLanguageFormat1List("CouldNotFindFile_", fiFullReportCoverPageImageThreeImagesBottom.FullName);
return(false);
}
TVFileModel tvFileModelFullReportCoverPageCanadaWithFlag = _TVFileService.GetTVFileModelWithServerFilePathAndServerFileNameDB(ServerPath, "CanadaWithFlag.png");
if (!string.IsNullOrWhiteSpace(tvFileModelFullReportCoverPageCanadaWithFlag.Error))
{
NotUsed = string.Format(TaskRunnerServiceRes.CouldNotFindFile_, ServerPath + "CanadaWithFlag.png");
_TaskRunnerBaseService._BWObj.TextLanguageList = _TaskRunnerBaseService.GetTextLanguageFormat1List("CouldNotFindFile_", ServerPath + "CanadaWithFlag.png");
return(false);
}
FileInfo fiFullReportCoverPageImageCanadaWithFlag = new FileInfo(tvFileModelFullReportCoverPageCanadaWithFlag.ServerFilePath + tvFileModelFullReportCoverPageCanadaWithFlag.ServerFileName);
if (!fiFullReportCoverPageImageCanadaWithFlag.Exists)
{
NotUsed = string.Format(TaskRunnerServiceRes.CouldNotFindFile_, fiFullReportCoverPageImageCanadaWithFlag.FullName);
_TaskRunnerBaseService._BWObj.TextLanguageList = _TaskRunnerBaseService.GetTextLanguageFormat1List("CouldNotFindFile_", fiFullReportCoverPageImageCanadaWithFlag.FullName);
return(false);
}
List <TVItemModel> tvItemModelListParent = _TVItemService.GetParentsTVItemModelList(tvItemModelSubsector.TVPath);
TVItemModel tvItemModelProvince = new TVItemModel();
foreach (TVItemModel tvItemModel in tvItemModelListParent)
{
if (tvItemModel.TVType == TVTypeEnum.Province)
{
tvItemModelProvince = tvItemModel;
break;
}
}
int Pos = tvItemModelSubsector.TVText.IndexOf(" ");
string SubsectorShort = "Error";
string SubsectorEndPart = "Error";
if (Pos > 0)
{
SubsectorShort = tvItemModelSubsector.TVText.Substring(0, Pos).Trim();
SubsectorEndPart = tvItemModelSubsector.TVText.Substring(Pos).Trim();
if (SubsectorEndPart.StartsWith("("))
{
SubsectorEndPart = SubsectorEndPart.Substring(1);
}
if (SubsectorEndPart.EndsWith(")"))
{
SubsectorEndPart = SubsectorEndPart.Substring(0, SubsectorEndPart.Length - 1);
}
}
Percent = 30;
_TaskRunnerBaseService.SendPercentToDB(_TaskRunnerBaseService._BWObj.appTaskModel.AppTaskID, Percent);
sbTemp.AppendLine($@" <table>");
sbTemp.AppendLine($@" <tr>");
sbTemp.AppendLine($@" <td>|||Image|FileName,{ fiFullReportCoverPageImageCanadaFlag.FullName }|width,45|height,20|||<br /><br /><br /><br /><br /><br /></td> ");
sbTemp.AppendLine($@" <td> <br /><br /><br /><br /><br /></td>");
sbTemp.AppendLine($@" <td class=""textAlignLeft""><p>Environment and <br />Climate Change Canada</p><br /><br /><br /><br /></td>");
sbTemp.AppendLine($@" <td> <br /><br /><br /><br /><br /></td>");
sbTemp.AppendLine($@" <td class=""textAlignLeft""><p>Environnement et <br />Changement climatique Canada</p><br /><br /><br /><br /></td>");
sbTemp.AppendLine($@" <td>|||Image|FileName,{ fiFullReportCoverPageImageLeafRight.FullName }|width,180|height,100|||</td> ");
sbTemp.AppendLine($@" </tr>");
sbTemp.AppendLine($@" <tr>");
sbTemp.AppendLine($@" <td colspan=""6"">|||Image|FileName,{ fiFullReportCoverPageImageBarTopBottom.FullName }|width,467|height,10|||</td> ");
sbTemp.AppendLine($@" </tr>");
sbTemp.AppendLine($@" </table>");
sbTemp.AppendLine($@" <div>");
sbTemp.AppendLine($@" <p> </p>");
sbTemp.AppendLine($@" <hr style=""color: blue"" />");
sbTemp.AppendLine($@" <p class=""textAlignLeft"" style=""font-size: 1.2em;"">");
sbTemp.AppendLine($@" <strong>{ TaskRunnerServiceRes.ShellfishWaterClassificationProgram } ({ TaskRunnerServiceRes.SWCP }) </strong>");
sbTemp.AppendLine($@" </p>");
sbTemp.AppendLine($@" <p class=""textAlignLeft"" style=""font-size: 1.2em;"">");
sbTemp.AppendLine($@" <strong>{ TaskRunnerServiceRes.ReEvaluationReport }</strong> |||STATISTICS_LAST_YEAR|||");
sbTemp.AppendLine($@" </p>");
sbTemp.AppendLine($@" <hr style=""color: blue"" />");
if (Thread.CurrentThread.CurrentCulture.TwoLetterISOLanguageName == "fr")
{
sbTemp.AppendLine($@" <p class=""textAlignLeft"" style=""font-size: 1.2em;""><strong>{ TaskRunnerServiceRes.ShellfishGrowingArea} (|||PROVINCE_INITIAL|||)</strong></p>");
}
else
{
sbTemp.AppendLine($@" <p class=""textAlignLeft"" style=""font-size: 1.2em;""><strong>|||PROVINCE_INITIAL||| { TaskRunnerServiceRes.ShellfishGrowingArea}</strong></p>");
}
sbTemp.AppendLine($@" <p class=""textAlignLeft"" style=""font-size: 1.2em;"">|||SUBSECTOR_NAME_SHORT|||</p>");
sbTemp.AppendLine($@" <p class=""textAlignLeft"" style=""font-size: 1.2em;"">|||SUBSECTOR_NAME_TEXT|||</p>");
sbTemp.AppendLine($@" <hr style=""color: blue"" />");
sbTemp.AppendLine($@" <p class=""textAlignLeft"" style=""font-size: 1.2em;""><strong>{ TaskRunnerServiceRes.Authors }:</strong> |||{ProvInitCap}_AUTHORS|||</p>");
if (Thread.CurrentThread.CurrentCulture.TwoLetterISOLanguageName == "fr")
{
sbTemp.AppendLine($@" <p class=""textAlignLeft"" style=""font-size: 1.2em;""><strong>{ TaskRunnerServiceRes.ReportID }:</strong> RE-|||STATISTICS_LAST_YEAR||| ({ SubsectorShort }) { TaskRunnerServiceRes.Created } { DateTime.Now.ToString("dd MMMM, yyyy") }</p>");
}
else
{
sbTemp.AppendLine($@" <p class=""textAlignLeft"" style=""font-size: 1.2em;""><strong>{ TaskRunnerServiceRes.ReportID }:</strong> RE-|||STATISTICS_LAST_YEAR||| ({ SubsectorShort }) { TaskRunnerServiceRes.Created } { DateTime.Now.ToString("MMMM dd, yyyy") }</p>");
}
sbTemp.AppendLine($@" <hr style=""color: blue"" />");
sbTemp.AppendLine($@" <p> </p>");
sbTemp.AppendLine($@" </div>");
sbTemp.AppendLine($@" <div>");
sbTemp.AppendLine($@" |||Image|FileName,{ fiFullReportCoverPageImageThreeImagesBottom.FullName }|width,467|height,110|||");
sbTemp.AppendLine($@" </div>");
sbTemp.AppendLine($@" <div class=""textAlignRight"">");
sbTemp.AppendLine($@" |||Image|FileName,{ fiFullReportCoverPageImageCanadaWithFlag.FullName }|width,76|height,22|||");
sbTemp.AppendLine($@" </div>");
return(true);
}
private TVFileLanguageModel AddTVFileLanguageModel(LanguageEnum LangToAdd)
{
TVItemModel tvItemModelRoot = tvItemService.GetRootTVItemModelDB();
if (!string.IsNullOrWhiteSpace(tvItemModelRoot.Error))
{
return new TVFileLanguageModel()
{
Error = tvItemModelRoot.Error
}
}
;
TVItemModel tvItemModelFile = tvItemService.PostAddChildTVItemDB(tvItemModelRoot.TVItemID, "Unique File Name", TVTypeEnum.File);
if (!string.IsNullOrWhiteSpace(tvItemModelFile.Error))
{
return new TVFileLanguageModel()
{
Error = tvItemModelFile.Error
}
}
;
TVFileModel tvFileModelNew = new TVFileModel()
{
ClientFilePath = randomService.RandomString("", 20),
FileCreatedDate_UTC = DateTime.Now,
FileInfo = randomService.RandomString("", 20),
FileDescription = randomService.RandomString("", 20),
FilePurpose = FilePurposeEnum.Picture,
FileSize_kb = randomService.RandomInt(10, 20),
FileType = FileTypeEnum.JPEG,
FromWater = false,
Language = LanguageEnum.en,
ServerFileName = randomService.RandomString("", 20),
ServerFilePath = randomService.RandomString("", 20),
TemplateTVType = (int)TVTypeEnum.Error,
TVFileTVItemID = tvItemModelFile.TVItemID,
};
TVFileModel tvFileModelRet = tvFileService.PostAddTVFileDB(tvFileModelNew);
if (!string.IsNullOrWhiteSpace(tvFileModelRet.Error))
{
return new TVFileLanguageModel()
{
Error = tvFileModelRet.Error
}
}
;
//TVFileLanguageModel tvFileLanguageModelNew = new TVFileLanguageModel();
//tvFileLanguageModelNew.TVFileID = tvFileModelRet.TVFileID;
//tvFileLanguageModelNew.FileDescription = tvFileModelNew.FileDescription;
//FillTVFileLanguageModelNew(LangToAdd, tvFileLanguageModelNew);
TVFileLanguageModel tvFileLanguagModelRet = tvFileLanguageService.GetTVFileLanguageModelWithTVFileIDAndLanguageDB(tvFileModelRet.TVFileID, LanguageEnum.en);
if (!string.IsNullOrWhiteSpace(tvFileLanguagModelRet.Error))
{
return(tvFileLanguagModelRet);
}
//Assert.IsNotNull(tvFileLanguagModelRet);
//CompareTVFileLanguageModels(tvFileLanguageModelNew, tvFileLanguagModelRet);
return(tvFileLanguagModelRet);
}
public DocTemplateModel PostUpdateDocTemplateDB(DocTemplateModel docTemplateModel)
{
string retStr = DocTemplateModelOK(docTemplateModel);
if (!string.IsNullOrEmpty(retStr))
{
return(ReturnError(retStr));
}
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrEmpty(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
TVFileModel tvFileModel = _TVFileService.GetTVFileModelWithTVFileTVItemIDDB(docTemplateModel.TVFileTVItemID);
if (!string.IsNullOrWhiteSpace(tvFileModel.Error))
{
return(ReturnError(tvFileModel.Error));
}
DocTemplate docTemplateToUpdate = GetDocTemplateWithDocTemplateIDDB(docTemplateModel.DocTemplateID);
if (docTemplateToUpdate == null)
{
return(ReturnError(string.Format(ServiceRes.CouldNotFind_ToUpdate, ServiceRes.DocTemplate)));
}
retStr = FillDocTemplate(docTemplateToUpdate, docTemplateModel, contactOK);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
using (TransactionScope ts = new TransactionScope())
{
if (tvFileModel.ServerFileName != docTemplateModel.FileName)
{
tvFileModel.ServerFileName = docTemplateModel.FileName;
TVFileModel tvFileModelRet = _TVFileService.PostUpdateTVFileDB(tvFileModel);
if (!string.IsNullOrWhiteSpace(tvFileModelRet.Error))
{
return(ReturnError(tvFileModelRet.Error));
}
}
retStr = DoUpdateChanges();
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
LogModel logModel = _LogService.PostAddLogForObj("DocTemplates", docTemplateToUpdate.DocTemplateID, LogCommandEnum.Change, docTemplateToUpdate);
if (!string.IsNullOrWhiteSpace(logModel.Error))
{
return(ReturnError(logModel.Error));
}
ts.Complete();
}
return(GetDocTemplateModelWithDocTemplateIDDB(docTemplateToUpdate.DocTemplateID));
}
