public void SamplingPlanAndFilesLabSheetCount_Every_Property_Has_Get_Set_Test()
{
int val1 = 45;
samplingPlanAndFilesLabSheetCount.LabSheetHistoryCount = val1;
Assert.AreEqual(val1, samplingPlanAndFilesLabSheetCount.LabSheetHistoryCount);
int val2 = 45;
samplingPlanAndFilesLabSheetCount.LabSheetTransferredCount = val2;
Assert.AreEqual(val2, samplingPlanAndFilesLabSheetCount.LabSheetTransferredCount);
SamplingPlan val3 = new SamplingPlan();
samplingPlanAndFilesLabSheetCount.SamplingPlan = val3;
Assert.AreEqual(val3, samplingPlanAndFilesLabSheetCount.SamplingPlan);
TVFile val4 = new TVFile();
samplingPlanAndFilesLabSheetCount.TVFileSamplingPlanFileTXT = val4;
Assert.AreEqual(val4, samplingPlanAndFilesLabSheetCount.TVFileSamplingPlanFileTXT);
bool val5 = true;
samplingPlanAndFilesLabSheetCount.HasErrors = val5;
Assert.AreEqual(val5, samplingPlanAndFilesLabSheetCount.HasErrors);
IEnumerable <ValidationResult> val18 = new List <ValidationResult>()
{
new ValidationResult("First CSSPError Message")
}.AsEnumerable();
samplingPlanAndFilesLabSheetCount.ValidationResults = val18;
Assert.AreEqual(val18, samplingPlanAndFilesLabSheetCount.ValidationResults);
}
public void TVFile_Controller_Put_Test()
{
foreach (LanguageEnum LanguageRequest in AllowableLanguages)
{
foreach (int ContactID in new List <int>()
{
AdminContactID
}) //, TestEmailValidatedContactID, TestEmailNotValidatedContactID })
{
TVFileController tvFileController = new TVFileController(DatabaseTypeEnum.SqlServerTestDB);
Assert.IsNotNull(tvFileController);
Assert.AreEqual(DatabaseTypeEnum.SqlServerTestDB, tvFileController.DatabaseType);
TVFile tvFileLast = new TVFile();
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
Query query = new Query();
query.Language = LanguageRequest;
TVFileService tvFileService = new TVFileService(query, db, ContactID);
tvFileLast = (from c in db.TVFiles select c).FirstOrDefault();
}
// ok with TVFile info
IHttpActionResult jsonRet = tvFileController.GetTVFileWithID(tvFileLast.TVFileID);
Assert.IsNotNull(jsonRet);
OkNegotiatedContentResult <TVFile> Ret = jsonRet as OkNegotiatedContentResult <TVFile>;
TVFile tvFileRet = Ret.Content;
Assert.AreEqual(tvFileLast.TVFileID, tvFileRet.TVFileID);
BadRequestErrorMessageResult badRequest = jsonRet as BadRequestErrorMessageResult;
Assert.IsNull(badRequest);
// Put to return success
IHttpActionResult jsonRet2 = tvFileController.Put(tvFileRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet2);
OkNegotiatedContentResult <TVFile> tvFileRet2 = jsonRet2 as OkNegotiatedContentResult <TVFile>;
Assert.IsNotNull(tvFileRet2);
BadRequestErrorMessageResult badRequest2 = jsonRet2 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest2);
// Put to return CSSPError because TVFileID of 0 does not exist
tvFileRet.TVFileID = 0;
IHttpActionResult jsonRet3 = tvFileController.Put(tvFileRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet3);
OkNegotiatedContentResult <TVFile> tvFileRet3 = jsonRet3 as OkNegotiatedContentResult <TVFile>;
Assert.IsNull(tvFileRet3);
BadRequestErrorMessageResult badRequest3 = jsonRet3 as BadRequestErrorMessageResult;
Assert.IsNotNull(badRequest3);
}
}
}
public void TVFile_CRUD_Test()
{
foreach (CultureInfo culture in AllowableCulture)
{
ChangeCulture(culture);
using (CSSPDBContext dbTestDB = new CSSPDBContext(DatabaseTypeEnum.SqlServerTestDB))
{
TVFileService tvFileService = new TVFileService(new Query()
{
Lang = culture.TwoLetterISOLanguageName
}, dbTestDB, ContactID);
int count = 0;
if (count == 1)
{
// just so we don't get a warning during compile [The variable 'count' is assigned but its value is never used]
}
TVFile tvFile = GetFilledRandomTVFile("");
// -------------------------------
// -------------------------------
// CRUD testing
// -------------------------------
// -------------------------------
count = tvFileService.GetTVFileList().Count();
Assert.AreEqual(count, (from c in dbTestDB.TVFiles select c).Count());
tvFileService.Add(tvFile);
if (tvFile.HasErrors)
{
Assert.AreEqual("", tvFile.ValidationResults.FirstOrDefault().ErrorMessage);
}
Assert.AreEqual(true, tvFileService.GetTVFileList().Where(c => c == tvFile).Any());
tvFileService.Update(tvFile);
if (tvFile.HasErrors)
{
Assert.AreEqual("", tvFile.ValidationResults.FirstOrDefault().ErrorMessage);
}
Assert.AreEqual(count + 1, tvFileService.GetTVFileList().Count());
tvFileService.Delete(tvFile);
if (tvFile.HasErrors)
{
Assert.AreEqual("", tvFile.ValidationResults.FirstOrDefault().ErrorMessage);
}
Assert.AreEqual(count, tvFileService.GetTVFileList().Count());
}
}
}
public IHttpActionResult GetTVFileWithID([FromUri] int TVFileID, [FromUri] string lang = "en", [FromUri] string extra = "")
{
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
TVFileService tvFileService = new TVFileService(new Query()
{
Language = (lang == "fr" ? LanguageEnum.fr : LanguageEnum.en)
}, db, ContactID);
tvFileService.Query = tvFileService.FillQuery(typeof(TVFile), lang, 0, 1, "", "", extra);
if (tvFileService.Query.Extra == "A")
{
TVFileExtraA tvFileExtraA = new TVFileExtraA();
tvFileExtraA = tvFileService.GetTVFileExtraAWithTVFileID(TVFileID);
if (tvFileExtraA == null)
{
return(NotFound());
}
return(Ok(tvFileExtraA));
}
else if (tvFileService.Query.Extra == "B")
{
TVFileExtraB tvFileExtraB = new TVFileExtraB();
tvFileExtraB = tvFileService.GetTVFileExtraBWithTVFileID(TVFileID);
if (tvFileExtraB == null)
{
return(NotFound());
}
return(Ok(tvFileExtraB));
}
else
{
TVFile tvFile = new TVFile();
tvFile = tvFileService.GetTVFileWithTVFileID(TVFileID);
if (tvFile == null)
{
return(NotFound());
}
return(Ok(tvFile));
}
}
}
/// <summary>
/// Updates an [TVFile](CSSPModels.TVFile.html) item in CSSPDB
/// </summary>
/// <param name="tvFile">Is the TVFile item the client want to add to CSSPDB. What's important here is the TVFileID</param>
/// <returns>true if TVFile item was updated to CSSPDB, false if an error happened during the DB requested transtaction</returns>
public bool Update(TVFile tvFile)
{
tvFile.ValidationResults = Validate(new ValidationContext(tvFile), ActionDBTypeEnum.Update);
if (tvFile.ValidationResults.Count() > 0)
{
return(false);
}
db.TVFiles.Update(tvFile);
if (!TryToSave(tvFile))
{
return(false);
}
return(true);
}
/// <summary>
/// Tries to execute the CSSPDB transaction (add/delete/update) on an [TVFile](CSSPModels.TVFile.html) item
/// </summary>
/// <param name="tvFile">Is the TVFile item the client want to add to CSSPDB. What's important here is the TVFileID</param>
/// <returns>true if TVFile item was updated to CSSPDB, false if an error happened during the DB requested transtaction</returns>
private bool TryToSave(TVFile tvFile)
{
try
{
db.SaveChanges();
}
catch (DbUpdateException ex)
{
tvFile.ValidationResults = new List <ValidationResult>()
{
new ValidationResult(ex.Message + (ex.InnerException != null ? " Inner: " + ex.InnerException.Message : ""))
}.AsEnumerable();
return(false);
}
return(true);
}
public void TVFile_Controller_GetTVFileWithID_Test()
{
foreach (LanguageEnum LanguageRequest in AllowableLanguages)
{
foreach (int ContactID in new List <int>()
{
AdminContactID
}) //, TestEmailValidatedContactID, TestEmailNotValidatedContactID })
{
TVFileController tvFileController = new TVFileController(DatabaseTypeEnum.SqlServerTestDB);
Assert.IsNotNull(tvFileController);
Assert.AreEqual(DatabaseTypeEnum.SqlServerTestDB, tvFileController.DatabaseType);
TVFile tvFileFirst = new TVFile();
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
TVFileService tvFileService = new TVFileService(new Query(), db, ContactID);
tvFileFirst = (from c in db.TVFiles select c).FirstOrDefault();
}
// ok with TVFile info
IHttpActionResult jsonRet = tvFileController.GetTVFileWithID(tvFileFirst.TVFileID);
Assert.IsNotNull(jsonRet);
OkNegotiatedContentResult <TVFile> Ret = jsonRet as OkNegotiatedContentResult <TVFile>;
TVFile tvFileRet = Ret.Content;
Assert.AreEqual(tvFileFirst.TVFileID, tvFileRet.TVFileID);
BadRequestErrorMessageResult badRequest = jsonRet as BadRequestErrorMessageResult;
Assert.IsNull(badRequest);
// Not Found
IHttpActionResult jsonRet2 = tvFileController.GetTVFileWithID(0);
Assert.IsNotNull(jsonRet2);
OkNegotiatedContentResult <TVFile> tvFileRet2 = jsonRet2 as OkNegotiatedContentResult <TVFile>;
Assert.IsNull(tvFileRet2);
NotFoundResult notFoundRequest = jsonRet2 as NotFoundResult;
Assert.IsNotNull(notFoundRequest);
}
}
}
public IHttpActionResult Delete([FromBody] TVFile tvFile, [FromUri] string lang = "en")
{
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
TVFileService tvFileService = new TVFileService(new Query()
{
Language = (lang == "fr" ? LanguageEnum.fr : LanguageEnum.en)
}, db, ContactID);
if (!tvFileService.Delete(tvFile))
{
return(BadRequest(String.Join("|||", tvFile.ValidationResults)));
}
else
{
tvFile.ValidationResults = null;
return(Ok(tvFile));
}
}
}
public void GetTVFileList_Test()
{
foreach (CultureInfo culture in AllowableCulture)
{
ChangeCulture(culture);
using (CSSPDBContext dbTestDB = new CSSPDBContext(DatabaseTypeEnum.SqlServerTestDB))
{
TVFileService tvFileService = new TVFileService(new Query()
{
Lang = culture.TwoLetterISOLanguageName
}, dbTestDB, ContactID);
TVFile tvFile = (from c in dbTestDB.TVFiles select c).FirstOrDefault();
Assert.IsNotNull(tvFile);
List <TVFile> tvFileDirectQueryList = new List <TVFile>();
tvFileDirectQueryList = (from c in dbTestDB.TVFiles select c).Take(200).ToList();
foreach (string extra in new List <string>()
{
null, "A", "B", "C", "D", "E"
})
{
tvFileService.Query.Extra = extra;
if (string.IsNullOrWhiteSpace(extra))
{
List <TVFile> tvFileList = new List <TVFile>();
tvFileList = tvFileService.GetTVFileList().ToList();
CheckTVFileFields(tvFileList);
}
else
{
//Assert.AreEqual(true, false);
}
}
}
}
}
public TVFileTest()
{
tVFile = new TVFile();
tVFileExtraA = new TVFileExtraA();
tVFileExtraB = new TVFileExtraB();
}
public void TVFile_Controller_GetTVFileList_Test()
{
foreach (LanguageEnum LanguageRequest in AllowableLanguages)
{
foreach (int ContactID in new List <int>()
{
AdminContactID
}) //, TestEmailValidatedContactID, TestEmailNotValidatedContactID })
{
TVFileController tvFileController = new TVFileController(DatabaseTypeEnum.SqlServerTestDB);
Assert.IsNotNull(tvFileController);
Assert.AreEqual(DatabaseTypeEnum.SqlServerTestDB, tvFileController.DatabaseType);
TVFile tvFileFirst = new TVFile();
int count = -1;
Query query = new Query();
using (CSSPDBContext db = new CSSPDBContext(DatabaseTypeEnum.SqlServerTestDB))
{
TVFileService tvFileService = new TVFileService(query, db, ContactID);
tvFileFirst = (from c in db.TVFiles select c).FirstOrDefault();
count = (from c in db.TVFiles select c).Count();
count = (query.Take > count ? count : query.Take);
}
// ok with TVFile info
IHttpActionResult jsonRet = tvFileController.GetTVFileList();
Assert.IsNotNull(jsonRet);
OkNegotiatedContentResult <List <TVFile> > ret = jsonRet as OkNegotiatedContentResult <List <TVFile> >;
Assert.AreEqual(tvFileFirst.TVFileID, ret.Content[0].TVFileID);
Assert.AreEqual((count > query.Take ? query.Take : count), ret.Content.Count);
List <TVFile> tvFileList = new List <TVFile>();
count = -1;
query = new Query();
using (CSSPDBContext db = new CSSPDBContext(DatabaseTypeEnum.SqlServerTestDB))
{
TVFileService tvFileService = new TVFileService(query, db, ContactID);
tvFileList = (from c in db.TVFiles select c).OrderBy(c => c.TVFileID).Skip(0).Take(2).ToList();
count = (from c in db.TVFiles select c).Count();
}
if (count > 0)
{
query.Skip = 0;
query.Take = 5;
count = (query.Take > count ? query.Take : count);
// ok with TVFile info
jsonRet = tvFileController.GetTVFileList(query.Language.ToString(), query.Skip, query.Take);
Assert.IsNotNull(jsonRet);
ret = jsonRet as OkNegotiatedContentResult <List <TVFile> >;
Assert.AreEqual(tvFileList[0].TVFileID, ret.Content[0].TVFileID);
Assert.AreEqual((count > query.Take ? query.Take : count), ret.Content.Count);
if (count > 1)
{
query.Skip = 1;
query.Take = 5;
count = (query.Take > count ? query.Take : count);
// ok with TVFile info
IHttpActionResult jsonRet2 = tvFileController.GetTVFileList(query.Language.ToString(), query.Skip, query.Take);
Assert.IsNotNull(jsonRet2);
OkNegotiatedContentResult <List <TVFile> > ret2 = jsonRet2 as OkNegotiatedContentResult <List <TVFile> >;
Assert.AreEqual(tvFileList[1].TVFileID, ret2.Content[0].TVFileID);
Assert.AreEqual((count > query.Take ? query.Take : count), ret2.Content.Count);
}
}
}
}
}
public void TVFile_Controller_Post_Test()
{
foreach (LanguageEnum LanguageRequest in AllowableLanguages)
{
foreach (int ContactID in new List <int>()
{
AdminContactID
}) //, TestEmailValidatedContactID, TestEmailNotValidatedContactID })
{
TVFileController tvFileController = new TVFileController(DatabaseTypeEnum.SqlServerTestDB);
Assert.IsNotNull(tvFileController);
Assert.AreEqual(DatabaseTypeEnum.SqlServerTestDB, tvFileController.DatabaseType);
TVFile tvFileLast = new TVFile();
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
Query query = new Query();
query.Language = LanguageRequest;
query.Asc = "";
query.Desc = "";
TVFileService tvFileService = new TVFileService(query, db, ContactID);
tvFileLast = (from c in db.TVFiles select c).FirstOrDefault();
}
// ok with TVFile info
IHttpActionResult jsonRet = tvFileController.GetTVFileWithID(tvFileLast.TVFileID);
Assert.IsNotNull(jsonRet);
OkNegotiatedContentResult <TVFile> Ret = jsonRet as OkNegotiatedContentResult <TVFile>;
TVFile tvFileRet = Ret.Content;
Assert.AreEqual(tvFileLast.TVFileID, tvFileRet.TVFileID);
BadRequestErrorMessageResult badRequest = jsonRet as BadRequestErrorMessageResult;
Assert.IsNull(badRequest);
// Post to return CSSPError because TVFileID exist
IHttpActionResult jsonRet2 = tvFileController.Post(tvFileRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet2);
OkNegotiatedContentResult <TVFile> tvFileRet2 = jsonRet2 as OkNegotiatedContentResult <TVFile>;
Assert.IsNull(tvFileRet2);
BadRequestErrorMessageResult badRequest2 = jsonRet2 as BadRequestErrorMessageResult;
Assert.IsNotNull(badRequest2);
// Post to return newly added TVFile
tvFileRet.TVFileID = 0;
tvFileController.Request = new System.Net.Http.HttpRequestMessage();
tvFileController.Request.RequestUri = new System.Uri("http://localhost:5000/api/tvFile");
IHttpActionResult jsonRet3 = tvFileController.Post(tvFileRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet3);
CreatedNegotiatedContentResult <TVFile> tvFileRet3 = jsonRet3 as CreatedNegotiatedContentResult <TVFile>;
Assert.IsNotNull(tvFileRet3);
BadRequestErrorMessageResult badRequest3 = jsonRet3 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest3);
IHttpActionResult jsonRet4 = tvFileController.Delete(tvFileRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet4);
OkNegotiatedContentResult <TVFile> tvFileRet4 = jsonRet4 as OkNegotiatedContentResult <TVFile>;
Assert.IsNotNull(tvFileRet4);
BadRequestErrorMessageResult badRequest4 = jsonRet4 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest4);
}
}
}
public void TVFile_Properties_Test()
{
foreach (CultureInfo culture in AllowableCulture)
{
ChangeCulture(culture);
using (CSSPDBContext dbTestDB = new CSSPDBContext(DatabaseTypeEnum.SqlServerTestDB))
{
TVFileService tvFileService = new TVFileService(new Query()
{
Lang = culture.TwoLetterISOLanguageName
}, dbTestDB, ContactID);
int count = 0;
if (count == 1)
{
// just so we don't get a warning during compile [The variable 'count' is assigned but its value is never used]
}
count = tvFileService.GetTVFileList().Count();
TVFile tvFile = GetFilledRandomTVFile("");
// -------------------------------
// -------------------------------
// Properties testing
// -------------------------------
// -------------------------------
// -----------------------------------
// [Key]
// Is NOT Nullable
// tvFile.TVFileID (Int32)
// -----------------------------------
tvFile = null;
tvFile = GetFilledRandomTVFile("");
tvFile.TVFileID = 0;
tvFileService.Update(tvFile);
Assert.AreEqual(string.Format(CSSPServicesRes._IsRequired, "TVFileID"), tvFile.ValidationResults.FirstOrDefault().ErrorMessage);
tvFile = null;
tvFile = GetFilledRandomTVFile("");
tvFile.TVFileID = 10000000;
tvFileService.Update(tvFile);
Assert.AreEqual(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVFile", "TVFileID", tvFile.TVFileID.ToString()), tvFile.ValidationResults.FirstOrDefault().ErrorMessage);
// -----------------------------------
// Is NOT Nullable
// [CSSPExist(ExistTypeName = "TVItem", ExistPlurial = "s", ExistFieldID = "TVItemID", AllowableTVtypeList = File)]
// tvFile.TVFileTVItemID (Int32)
// -----------------------------------
tvFile = null;
tvFile = GetFilledRandomTVFile("");
tvFile.TVFileTVItemID = 0;
tvFileService.Add(tvFile);
Assert.AreEqual(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "TVFileTVItemID", tvFile.TVFileTVItemID.ToString()), tvFile.ValidationResults.FirstOrDefault().ErrorMessage);
tvFile = null;
tvFile = GetFilledRandomTVFile("");
tvFile.TVFileTVItemID = 1;
tvFileService.Add(tvFile);
Assert.AreEqual(string.Format(CSSPServicesRes._IsNotOfType_, "TVFileTVItemID", "File"), tvFile.ValidationResults.FirstOrDefault().ErrorMessage);
// -----------------------------------
// Is Nullable
// [CSSPEnumType]
// tvFile.TemplateTVType (TVTypeEnum)
// -----------------------------------
tvFile = null;
tvFile = GetFilledRandomTVFile("");
tvFile.TemplateTVType = (TVTypeEnum)1000000;
tvFileService.Add(tvFile);
Assert.AreEqual(string.Format(CSSPServicesRes._IsRequired, "TemplateTVType"), tvFile.ValidationResults.FirstOrDefault().ErrorMessage);
// -----------------------------------
// Is Nullable
// [CSSPExist(ExistTypeName = "ReportType", ExistPlurial = "s", ExistFieldID = "ReportTypeID", AllowableTVtypeList = )]
// tvFile.ReportTypeID (Int32)
// -----------------------------------
tvFile = null;
tvFile = GetFilledRandomTVFile("");
tvFile.ReportTypeID = 0;
tvFileService.Add(tvFile);
Assert.AreEqual(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "ReportType", "ReportTypeID", tvFile.ReportTypeID.ToString()), tvFile.ValidationResults.FirstOrDefault().ErrorMessage);
// -----------------------------------
// Is Nullable
// tvFile.Parameters (String)
// -----------------------------------
// -----------------------------------
// Is Nullable
// [Range(1980, 2050)]
// tvFile.Year (Int32)
// -----------------------------------
tvFile = null;
tvFile = GetFilledRandomTVFile("");
tvFile.Year = 1979;
Assert.AreEqual(false, tvFileService.Add(tvFile));
Assert.AreEqual(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Year", "1980", "2050"), tvFile.ValidationResults.FirstOrDefault().ErrorMessage);
Assert.AreEqual(count, tvFileService.GetTVFileList().Count());
tvFile = null;
tvFile = GetFilledRandomTVFile("");
tvFile.Year = 2051;
Assert.AreEqual(false, tvFileService.Add(tvFile));
Assert.AreEqual(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Year", "1980", "2050"), tvFile.ValidationResults.FirstOrDefault().ErrorMessage);
Assert.AreEqual(count, tvFileService.GetTVFileList().Count());
// -----------------------------------
// Is NOT Nullable
// [CSSPEnumType]
// tvFile.Language (LanguageEnum)
// -----------------------------------
tvFile = null;
tvFile = GetFilledRandomTVFile("");
tvFile.Language = (LanguageEnum)1000000;
tvFileService.Add(tvFile);
Assert.AreEqual(string.Format(CSSPServicesRes._IsRequired, "Language"), tvFile.ValidationResults.FirstOrDefault().ErrorMessage);
// -----------------------------------
// Is NOT Nullable
// [CSSPEnumType]
// tvFile.FilePurpose (FilePurposeEnum)
// -----------------------------------
tvFile = null;
tvFile = GetFilledRandomTVFile("");
tvFile.FilePurpose = (FilePurposeEnum)1000000;
tvFileService.Add(tvFile);
Assert.AreEqual(string.Format(CSSPServicesRes._IsRequired, "FilePurpose"), tvFile.ValidationResults.FirstOrDefault().ErrorMessage);
// -----------------------------------
// Is NOT Nullable
// [CSSPEnumType]
// tvFile.FileType (FileTypeEnum)
// -----------------------------------
tvFile = null;
tvFile = GetFilledRandomTVFile("");
tvFile.FileType = (FileTypeEnum)1000000;
tvFileService.Add(tvFile);
Assert.AreEqual(string.Format(CSSPServicesRes._IsRequired, "FileType"), tvFile.ValidationResults.FirstOrDefault().ErrorMessage);
// -----------------------------------
// Is NOT Nullable
// [Range(0, 100000000)]
// tvFile.FileSize_kb (Int32)
// -----------------------------------
tvFile = null;
tvFile = GetFilledRandomTVFile("");
tvFile.FileSize_kb = -1;
Assert.AreEqual(false, tvFileService.Add(tvFile));
Assert.AreEqual(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "FileSize_kb", "0", "100000000"), tvFile.ValidationResults.FirstOrDefault().ErrorMessage);
Assert.AreEqual(count, tvFileService.GetTVFileList().Count());
tvFile = null;
tvFile = GetFilledRandomTVFile("");
tvFile.FileSize_kb = 100000001;
Assert.AreEqual(false, tvFileService.Add(tvFile));
Assert.AreEqual(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "FileSize_kb", "0", "100000000"), tvFile.ValidationResults.FirstOrDefault().ErrorMessage);
Assert.AreEqual(count, tvFileService.GetTVFileList().Count());
// -----------------------------------
// Is Nullable
// tvFile.FileInfo (String)
// -----------------------------------
// -----------------------------------
// Is NOT Nullable
// [CSSPAfter(Year = 1980)]
// tvFile.FileCreatedDate_UTC (DateTime)
// -----------------------------------
tvFile = null;
tvFile = GetFilledRandomTVFile("");
tvFile.FileCreatedDate_UTC = new DateTime();
tvFileService.Add(tvFile);
Assert.AreEqual(string.Format(CSSPServicesRes._IsRequired, "FileCreatedDate_UTC"), tvFile.ValidationResults.FirstOrDefault().ErrorMessage);
tvFile = null;
tvFile = GetFilledRandomTVFile("");
tvFile.FileCreatedDate_UTC = new DateTime(1979, 1, 1);
tvFileService.Add(tvFile);
Assert.AreEqual(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "FileCreatedDate_UTC", "1980"), tvFile.ValidationResults.FirstOrDefault().ErrorMessage);
// -----------------------------------
// Is Nullable
// tvFile.FromWater (Boolean)
// -----------------------------------
// -----------------------------------
// Is Nullable
// [StringLength(250))]
// tvFile.ClientFilePath (String)
// -----------------------------------
tvFile = null;
tvFile = GetFilledRandomTVFile("");
tvFile.ClientFilePath = GetRandomString("", 251);
Assert.AreEqual(false, tvFileService.Add(tvFile));
Assert.AreEqual(string.Format(CSSPServicesRes._MaxLengthIs_, "ClientFilePath", "250"), tvFile.ValidationResults.FirstOrDefault().ErrorMessage);
Assert.AreEqual(count, tvFileService.GetTVFileList().Count());
// -----------------------------------
// Is NOT Nullable
// [StringLength(250))]
// tvFile.ServerFileName (String)
// -----------------------------------
tvFile = null;
tvFile = GetFilledRandomTVFile("ServerFileName");
Assert.AreEqual(false, tvFileService.Add(tvFile));
Assert.AreEqual(1, tvFile.ValidationResults.Count());
Assert.IsTrue(tvFile.ValidationResults.Where(c => c.ErrorMessage == string.Format(CSSPServicesRes._IsRequired, "ServerFileName")).Any());
Assert.AreEqual(null, tvFile.ServerFileName);
Assert.AreEqual(count, tvFileService.GetTVFileList().Count());
tvFile = null;
tvFile = GetFilledRandomTVFile("");
tvFile.ServerFileName = GetRandomString("", 251);
Assert.AreEqual(false, tvFileService.Add(tvFile));
Assert.AreEqual(string.Format(CSSPServicesRes._MaxLengthIs_, "ServerFileName", "250"), tvFile.ValidationResults.FirstOrDefault().ErrorMessage);
Assert.AreEqual(count, tvFileService.GetTVFileList().Count());
// -----------------------------------
// Is NOT Nullable
// [StringLength(250))]
// tvFile.ServerFilePath (String)
// -----------------------------------
tvFile = null;
tvFile = GetFilledRandomTVFile("ServerFilePath");
Assert.AreEqual(false, tvFileService.Add(tvFile));
Assert.AreEqual(1, tvFile.ValidationResults.Count());
Assert.IsTrue(tvFile.ValidationResults.Where(c => c.ErrorMessage == string.Format(CSSPServicesRes._IsRequired, "ServerFilePath")).Any());
Assert.AreEqual(null, tvFile.ServerFilePath);
Assert.AreEqual(count, tvFileService.GetTVFileList().Count());
tvFile = null;
tvFile = GetFilledRandomTVFile("");
tvFile.ServerFilePath = GetRandomString("", 251);
Assert.AreEqual(false, tvFileService.Add(tvFile));
Assert.AreEqual(string.Format(CSSPServicesRes._MaxLengthIs_, "ServerFilePath", "250"), tvFile.ValidationResults.FirstOrDefault().ErrorMessage);
Assert.AreEqual(count, tvFileService.GetTVFileList().Count());
// -----------------------------------
// Is NOT Nullable
// [CSSPAfter(Year = 1980)]
// tvFile.LastUpdateDate_UTC (DateTime)
// -----------------------------------
tvFile = null;
tvFile = GetFilledRandomTVFile("");
tvFile.LastUpdateDate_UTC = new DateTime();
tvFileService.Add(tvFile);
Assert.AreEqual(string.Format(CSSPServicesRes._IsRequired, "LastUpdateDate_UTC"), tvFile.ValidationResults.FirstOrDefault().ErrorMessage);
tvFile = null;
tvFile = GetFilledRandomTVFile("");
tvFile.LastUpdateDate_UTC = new DateTime(1979, 1, 1);
tvFileService.Add(tvFile);
Assert.AreEqual(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "LastUpdateDate_UTC", "1980"), tvFile.ValidationResults.FirstOrDefault().ErrorMessage);
// -----------------------------------
// Is NOT Nullable
// [CSSPExist(ExistTypeName = "TVItem", ExistPlurial = "s", ExistFieldID = "TVItemID", AllowableTVtypeList = Contact)]
// tvFile.LastUpdateContactTVItemID (Int32)
// -----------------------------------
tvFile = null;
tvFile = GetFilledRandomTVFile("");
tvFile.LastUpdateContactTVItemID = 0;
tvFileService.Add(tvFile);
Assert.AreEqual(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "LastUpdateContactTVItemID", tvFile.LastUpdateContactTVItemID.ToString()), tvFile.ValidationResults.FirstOrDefault().ErrorMessage);
tvFile = null;
tvFile = GetFilledRandomTVFile("");
tvFile.LastUpdateContactTVItemID = 1;
tvFileService.Add(tvFile);
Assert.AreEqual(string.Format(CSSPServicesRes._IsNotOfType_, "LastUpdateContactTVItemID", "Contact"), tvFile.ValidationResults.FirstOrDefault().ErrorMessage);
// -----------------------------------
// Is NOT Nullable
// [NotMapped]
// tvFile.HasErrors (Boolean)
// -----------------------------------
// No testing requied
// -----------------------------------
// Is NOT Nullable
// [NotMapped]
// tvFile.ValidationResults (IEnumerable`1)
// -----------------------------------
// No testing requied
}
}
}
private IEnumerable <ValidationResult> Validate(ValidationContext validationContext, ActionDBTypeEnum actionDBType)
{
string retStr = "";
Enums enums = new Enums(LanguageRequest);
TVFileLanguage tvFileLanguage = validationContext.ObjectInstance as TVFileLanguage;
tvFileLanguage.HasErrors = false;
if (actionDBType == ActionDBTypeEnum.Update || actionDBType == ActionDBTypeEnum.Delete)
{
if (tvFileLanguage.TVFileLanguageID == 0)
{
tvFileLanguage.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "TVFileLanguageID"), new[] { "TVFileLanguageID" }));
}
if (!(from c in db.TVFileLanguages select c).Where(c => c.TVFileLanguageID == tvFileLanguage.TVFileLanguageID).Any())
{
tvFileLanguage.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVFileLanguage", "TVFileLanguageID", tvFileLanguage.TVFileLanguageID.ToString()), new[] { "TVFileLanguageID" }));
}
}
TVFile TVFileTVFileID = (from c in db.TVFiles where c.TVFileID == tvFileLanguage.TVFileID select c).FirstOrDefault();
if (TVFileTVFileID == null)
{
tvFileLanguage.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVFile", "TVFileID", tvFileLanguage.TVFileID.ToString()), new[] { "TVFileID" }));
}
retStr = enums.EnumTypeOK(typeof(LanguageEnum), (int?)tvFileLanguage.Language);
if (!string.IsNullOrWhiteSpace(retStr))
{
tvFileLanguage.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "Language"), new[] { "Language" }));
}
//FileDescription has no StringLength Attribute
retStr = enums.EnumTypeOK(typeof(TranslationStatusEnum), (int?)tvFileLanguage.TranslationStatus);
if (!string.IsNullOrWhiteSpace(retStr))
{
tvFileLanguage.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "TranslationStatus"), new[] { "TranslationStatus" }));
}
if (tvFileLanguage.LastUpdateDate_UTC.Year == 1)
{
tvFileLanguage.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "LastUpdateDate_UTC"), new[] { "LastUpdateDate_UTC" }));
}
else
{
if (tvFileLanguage.LastUpdateDate_UTC.Year < 1980)
{
tvFileLanguage.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "LastUpdateDate_UTC", "1980"), new[] { "LastUpdateDate_UTC" }));
}
}
TVItem TVItemLastUpdateContactTVItemID = (from c in db.TVItems where c.TVItemID == tvFileLanguage.LastUpdateContactTVItemID select c).FirstOrDefault();
if (TVItemLastUpdateContactTVItemID == null)
{
tvFileLanguage.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "LastUpdateContactTVItemID", tvFileLanguage.LastUpdateContactTVItemID.ToString()), new[] { "LastUpdateContactTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.Contact,
};
if (!AllowableTVTypes.Contains(TVItemLastUpdateContactTVItemID.TVType))
{
tvFileLanguage.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "LastUpdateContactTVItemID", "Contact"), new[] { "LastUpdateContactTVItemID" }));
}
}
retStr = ""; // added to stop compiling CSSPError
if (retStr != "") // will never be true
{
tvFileLanguage.HasErrors = true;
yield return(new ValidationResult("AAA", new[] { "AAA" }));
}
}
/// <summary>
/// Validate function for all TVFileService commands
/// </summary>
/// <param name="validationContext">System.ComponentModel.DataAnnotations.ValidationContext (Describes the context in which a validation check is performed.)</param>
/// <param name="actionDBType">[ActionDBTypeEnum] (CSSPEnums.ActionDBTypeEnum.html) action type to validate</param>
/// <returns>IEnumerable of ValidationResult (Where ValidationResult is a container for the results of a validation request.)</returns>
private IEnumerable <ValidationResult> Validate(ValidationContext validationContext, ActionDBTypeEnum actionDBType)
{
string retStr = "";
Enums enums = new Enums(LanguageRequest);
TVFile tvFile = validationContext.ObjectInstance as TVFile;
tvFile.HasErrors = false;
if (actionDBType == ActionDBTypeEnum.Update || actionDBType == ActionDBTypeEnum.Delete)
{
if (tvFile.TVFileID == 0)
{
tvFile.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "TVFileID"), new[] { "TVFileID" }));
}
if (!(from c in db.TVFiles select c).Where(c => c.TVFileID == tvFile.TVFileID).Any())
{
tvFile.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVFile", "TVFileID", tvFile.TVFileID.ToString()), new[] { "TVFileID" }));
}
}
TVItem TVItemTVFileTVItemID = (from c in db.TVItems where c.TVItemID == tvFile.TVFileTVItemID select c).FirstOrDefault();
if (TVItemTVFileTVItemID == null)
{
tvFile.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "TVFileTVItemID", tvFile.TVFileTVItemID.ToString()), new[] { "TVFileTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.File,
};
if (!AllowableTVTypes.Contains(TVItemTVFileTVItemID.TVType))
{
tvFile.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "TVFileTVItemID", "File"), new[] { "TVFileTVItemID" }));
}
}
if (tvFile.TemplateTVType != null)
{
retStr = enums.EnumTypeOK(typeof(TVTypeEnum), (int?)tvFile.TemplateTVType);
if (tvFile.TemplateTVType == null || !string.IsNullOrWhiteSpace(retStr))
{
tvFile.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "TemplateTVType"), new[] { "TemplateTVType" }));
}
}
if (tvFile.ReportTypeID != null)
{
ReportType ReportTypeReportTypeID = (from c in db.ReportTypes where c.ReportTypeID == tvFile.ReportTypeID select c).FirstOrDefault();
if (ReportTypeReportTypeID == null)
{
tvFile.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "ReportType", "ReportTypeID", (tvFile.ReportTypeID == null ? "" : tvFile.ReportTypeID.ToString())), new[] { "ReportTypeID" }));
}
}
//Parameters has no StringLength Attribute
if (tvFile.Year != null)
{
if (tvFile.Year < 1980 || tvFile.Year > 2050)
{
tvFile.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Year", "1980", "2050"), new[] { "Year" }));
}
}
retStr = enums.EnumTypeOK(typeof(LanguageEnum), (int?)tvFile.Language);
if (!string.IsNullOrWhiteSpace(retStr))
{
tvFile.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "Language"), new[] { "Language" }));
}
retStr = enums.EnumTypeOK(typeof(FilePurposeEnum), (int?)tvFile.FilePurpose);
if (!string.IsNullOrWhiteSpace(retStr))
{
tvFile.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "FilePurpose"), new[] { "FilePurpose" }));
}
retStr = enums.EnumTypeOK(typeof(FileTypeEnum), (int?)tvFile.FileType);
if (!string.IsNullOrWhiteSpace(retStr))
{
tvFile.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "FileType"), new[] { "FileType" }));
}
if (tvFile.FileSize_kb < 0 || tvFile.FileSize_kb > 100000000)
{
tvFile.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "FileSize_kb", "0", "100000000"), new[] { "FileSize_kb" }));
}
//FileInfo has no StringLength Attribute
if (tvFile.FileCreatedDate_UTC.Year == 1)
{
tvFile.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "FileCreatedDate_UTC"), new[] { "FileCreatedDate_UTC" }));
}
else
{
if (tvFile.FileCreatedDate_UTC.Year < 1980)
{
tvFile.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "FileCreatedDate_UTC", "1980"), new[] { "FileCreatedDate_UTC" }));
}
}
if (!string.IsNullOrWhiteSpace(tvFile.ClientFilePath) && tvFile.ClientFilePath.Length > 250)
{
tvFile.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "ClientFilePath", "250"), new[] { "ClientFilePath" }));
}
if (string.IsNullOrWhiteSpace(tvFile.ServerFileName))
{
tvFile.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "ServerFileName"), new[] { "ServerFileName" }));
}
if (!string.IsNullOrWhiteSpace(tvFile.ServerFileName) && tvFile.ServerFileName.Length > 250)
{
tvFile.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "ServerFileName", "250"), new[] { "ServerFileName" }));
}
if (string.IsNullOrWhiteSpace(tvFile.ServerFilePath))
{
tvFile.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "ServerFilePath"), new[] { "ServerFilePath" }));
}
if (!string.IsNullOrWhiteSpace(tvFile.ServerFilePath) && tvFile.ServerFilePath.Length > 250)
{
tvFile.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MaxLengthIs_, "ServerFilePath", "250"), new[] { "ServerFilePath" }));
}
if (tvFile.LastUpdateDate_UTC.Year == 1)
{
tvFile.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsRequired, "LastUpdateDate_UTC"), new[] { "LastUpdateDate_UTC" }));
}
else
{
if (tvFile.LastUpdateDate_UTC.Year < 1980)
{
tvFile.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "LastUpdateDate_UTC", "1980"), new[] { "LastUpdateDate_UTC" }));
}
}
TVItem TVItemLastUpdateContactTVItemID = (from c in db.TVItems where c.TVItemID == tvFile.LastUpdateContactTVItemID select c).FirstOrDefault();
if (TVItemLastUpdateContactTVItemID == null)
{
tvFile.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "LastUpdateContactTVItemID", tvFile.LastUpdateContactTVItemID.ToString()), new[] { "LastUpdateContactTVItemID" }));
}
else
{
List <TVTypeEnum> AllowableTVTypes = new List <TVTypeEnum>()
{
TVTypeEnum.Contact,
};
if (!AllowableTVTypes.Contains(TVItemLastUpdateContactTVItemID.TVType))
{
tvFile.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._IsNotOfType_, "LastUpdateContactTVItemID", "Contact"), new[] { "LastUpdateContactTVItemID" }));
}
}
retStr = ""; // added to stop compiling CSSPError
if (retStr != "") // will never be true
{
tvFile.HasErrors = true;
yield return(new ValidationResult("AAA", new[] { "AAA" }));
}
}
private TVFile GetFilledRandomTVFile(string OmitPropName)
{
TVFile tvFile = new TVFile();
if (OmitPropName != "TVFileTVItemID")
{
tvFile.TVFileTVItemID = 42;
}
if (OmitPropName != "TemplateTVType")
{
tvFile.TemplateTVType = (TVTypeEnum)GetRandomEnumType(typeof(TVTypeEnum));
}
if (OmitPropName != "ReportTypeID")
{
tvFile.ReportTypeID = 1;
}
if (OmitPropName != "Parameters")
{
tvFile.Parameters = GetRandomString("", 20);
}
if (OmitPropName != "Year")
{
tvFile.Year = GetRandomInt(1980, 2050);
}
if (OmitPropName != "Language")
{
tvFile.Language = LanguageRequest;
}
if (OmitPropName != "FilePurpose")
{
tvFile.FilePurpose = (FilePurposeEnum)GetRandomEnumType(typeof(FilePurposeEnum));
}
if (OmitPropName != "FileType")
{
tvFile.FileType = (FileTypeEnum)GetRandomEnumType(typeof(FileTypeEnum));
}
if (OmitPropName != "FileSize_kb")
{
tvFile.FileSize_kb = GetRandomInt(0, 100000000);
}
if (OmitPropName != "FileInfo")
{
tvFile.FileInfo = GetRandomString("", 20);
}
if (OmitPropName != "FileCreatedDate_UTC")
{
tvFile.FileCreatedDate_UTC = new DateTime(2005, 3, 6);
}
if (OmitPropName != "FromWater")
{
tvFile.FromWater = true;
}
if (OmitPropName != "ClientFilePath")
{
tvFile.ClientFilePath = GetRandomString("", 5);
}
if (OmitPropName != "ServerFileName")
{
tvFile.ServerFileName = GetRandomString("", 5);
}
if (OmitPropName != "ServerFilePath")
{
tvFile.ServerFilePath = GetRandomString("", 5);
}
if (OmitPropName != "LastUpdateDate_UTC")
{
tvFile.LastUpdateDate_UTC = new DateTime(2005, 3, 6);
}
if (OmitPropName != "LastUpdateContactTVItemID")
{
tvFile.LastUpdateContactTVItemID = 2;
}
return(tvFile);
}
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);
}
