public void VPResultService_FillVPResult_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
VPResultModel vpResultModelRet = AddVPResultModel();
FillVPResultModel(vpResultModelRet);
ContactOK contactOK = vpResultService.IsContactOK();
string retStr = vpResultService.FillVPResult(vpResult, vpResultModelRet, contactOK);
Assert.AreEqual("", retStr);
Assert.AreEqual(contactOK.ContactTVItemID, vpResult.LastUpdateContactTVItemID);
contactOK = null;
retStr = vpResultService.FillVPResult(vpResult, vpResultModelRet, contactOK);
Assert.AreEqual("", retStr);
Assert.AreEqual(2, vpResult.LastUpdateContactTVItemID);
}
}
}
public PolSourceSiteModel PostDeletePolSourceSiteWithPolSourceSiteTVItemIDDB(int PolSourceSiteTVItemID)
{
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrEmpty(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
PolSourceSite polSourceSiteToDelete = GetPolSourceSiteWithPolSourceSiteWithPolSourceSiteTVItemIDDB(PolSourceSiteTVItemID);
if (polSourceSiteToDelete == null)
{
return(ReturnError(string.Format(ServiceRes.CouldNotFind_ToDelete, ServiceRes.PolSourceSite)));
}
PolSourceSiteModel polSourceSiteModelRet = PostDeletePolSourceSiteDB(polSourceSiteToDelete.PolSourceSiteID);
if (!string.IsNullOrWhiteSpace(polSourceSiteModelRet.Error))
{
return(ReturnError(polSourceSiteModelRet.Error));
}
return(ReturnError(""));
}
public TVItemLinkModel PostDeleteTVItemLinkWithFromTVItemIDAndFromTVTypeAndToTVTypeDB(int FromTVItemID, TVTypeEnum FromTVType, TVTypeEnum ToTVType)
{
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrEmpty(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
TVItemLink tvItemLinkToDelete = GetTVItemLinkWithFromTVItemIDAndFromTVTypeAndToTVTypeDB(FromTVItemID, FromTVType, ToTVType);
if (tvItemLinkToDelete == null)
{
return(ReturnError(string.Format(ServiceRes.CouldNotFind_ToDelete, ServiceRes.TVItemLink)));
}
using (TransactionScope ts = new TransactionScope())
{
db.TVItemLinks.Remove(tvItemLinkToDelete);
string retStr = DoDeleteChanges();
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
LogModel logModel = _LogService.PostAddLogForObj("TVItemLinks", tvItemLinkToDelete.TVItemLinkID, LogCommandEnum.Delete, tvItemLinkToDelete);
if (!string.IsNullOrWhiteSpace(logModel.Error))
{
return(ReturnError(logModel.Error));
}
ts.Complete();
}
return(ReturnError(""));
}
public AppTaskModel PostDeleteAppTaskDB(int AppTaskID)
{
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrEmpty(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
AppTask appTaskToDelete = GetAppTaskWithAppTaskIDDB(AppTaskID);
if (appTaskToDelete == null)
{
return(ReturnError(string.Format(ServiceRes.CouldNotFind_ToDelete, ServiceRes.AppTask)));
}
using (TransactionScope ts = new TransactionScope())
{
db.AppTasks.Remove(appTaskToDelete);
string retStr = DoDeleteChanges();
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
ts.Complete();
}
return(ReturnError(""));
}
public HelpDocModel PostDeleteHelpDocDB(int HelpDocID, LanguageEnum Language)
{
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrEmpty(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
HelpDoc helpDocToDelete = GetHelpDocWithHelpDocIDDB(HelpDocID);
if (helpDocToDelete == null)
{
return(ReturnError(string.Format(ServiceRes.CouldNotFind_ToDelete, ServiceRes.HelpDoc)));
}
using (TransactionScope ts = new TransactionScope())
{
db.HelpDocs.Remove(helpDocToDelete);
string retStr = DoDeleteChanges();
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
LogModel logModel = _LogService.PostAddLogForObj("HelpDocs", helpDocToDelete.HelpDocID, LogCommandEnum.Delete, helpDocToDelete);
if (!string.IsNullOrWhiteSpace(logModel.Error))
{
return(ReturnError(logModel.Error));
}
ts.Complete();
}
return(ReturnError(""));
}
public MikeScenarioResultModel PostDeleteMikeScenarioResultWithMikeScenarioTVItemIDDB(int MikeScenarioTVItemID)
{
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrEmpty(contactOK.Error))
{
return(ReturnMikeScenarioResultError(contactOK.Error));
}
MikeScenarioResult mikeScenarioResultToDelete = GetMikeScenarioResultWithMikeScenarioTVItemIDDB(MikeScenarioTVItemID);
if (mikeScenarioResultToDelete == null)
{
return(ReturnMikeScenarioResultError(string.Format(ServiceRes.CouldNotFind_ToDelete, ServiceRes.MikeScenarioResult)));
}
db.MikeScenarioResults.Remove(mikeScenarioResultToDelete);
string retStr = DoDeleteChanges();
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnMikeScenarioResultError(retStr));
}
return(ReturnMikeScenarioResultError(""));
}
public void MWQMSampleLanguageService_FillMWQMSampleLanguage_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
MWQMSampleModel mwqmSampleModelRet = mwqmSampleServiceTest.AddMWQMSampleModel();
LanguageEnum LangToAdd = LanguageEnum.es;
FillMWQMSampleLanguageModelNew(LangToAdd, mwqmSampleModelRet, mwqmSampleLanguageModelNew);
ContactOK contactOK = mwqmSampleLanguageService.IsContactOK();
string retStr = mwqmSampleLanguageService.FillMWQMSampleLanguage(mwqmSampleLanguage, mwqmSampleLanguageModelNew, contactOK);
Assert.AreEqual("", retStr);
Assert.AreEqual(contactOK.ContactTVItemID, mwqmSampleLanguage.LastUpdateContactTVItemID);
contactOK = null;
retStr = mwqmSampleLanguageService.FillMWQMSampleLanguage(mwqmSampleLanguage, mwqmSampleLanguageModelNew, contactOK);
Assert.AreEqual("", retStr);
Assert.AreEqual(contactModelListGood[0].ContactTVItemID, mwqmSampleLanguage.LastUpdateContactTVItemID);
}
}
}
public void BoxModelLanguageService_FillBoxModelLanguage_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
BoxModelModel boxModelModelRet = boxModelServiceTest.AddBoxModelModel();
LanguageEnum LangToAdd = LanguageEnum.es;
FillBoxModelLanguageModelNew(LangToAdd, boxModelModelRet, boxModelLanguageModelNew);
ContactOK contactOK = boxModelLanguageService.IsContactOK();
string retStr = boxModelLanguageService.FillBoxModelLanguageModel(boxModelLanguage, boxModelLanguageModelNew, contactOK);
Assert.AreEqual("", retStr);
Assert.AreEqual(contactOK.ContactTVItemID, boxModelLanguage.LastUpdateContactTVItemID);
contactOK = null;
retStr = boxModelLanguageService.FillBoxModelLanguageModel(boxModelLanguage, boxModelLanguageModelNew, contactOK);
Assert.AreEqual("", retStr);
Assert.AreEqual(2, boxModelLanguage.LastUpdateContactTVItemID);
}
}
}
public MapInfoPointModel PostDeleteMapInfoPointDB(int MapInfoPointID)
{
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrEmpty(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
MapInfoPoint mapInfoPointToDelete = GetMapInfoPointWithMapInfoPointIDDB(MapInfoPointID);
if (mapInfoPointToDelete == null)
{
return(ReturnError(string.Format(ServiceRes.CouldNotFind_ToDelete, ServiceRes.MapInfoPoint)));
}
using (TransactionScope ts = new TransactionScope())
{
db.MapInfoPoints.Remove(mapInfoPointToDelete);
string retStr = DoDeleteChanges();
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
LogModel logModel = _LogService.PostAddLogForObj("MapInfoPoints", mapInfoPointToDelete.MapInfoPointID, LogCommandEnum.Delete, mapInfoPointToDelete);
if (!string.IsNullOrWhiteSpace(logModel.Error))
{
return(ReturnError(logModel.Error));
}
ts.Complete();
}
return(ReturnError(""));
}
/// <summary>
/// Validate function for all ContactOKService 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);
ContactOK contactOK = validationContext.ObjectInstance as ContactOK;
contactOK.HasErrors = false;
if (contactOK.ContactID < 1)
{
contactOK.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MinValueIs_, "ContactID", "1"), new[] { "ContactID" }));
}
if (contactOK.ContactTVItemID < 1)
{
contactOK.HasErrors = true;
yield return(new ValidationResult(string.Format(CSSPServicesRes._MinValueIs_, "ContactTVItemID", "1"), new[] { "ContactTVItemID" }));
}
retStr = ""; // added to stop compiling CSSPError
if (retStr != "") // will never be true
{
contactOK.HasErrors = true;
yield return(new ValidationResult("AAA", new[] { "AAA" }));
}
}
public LabSheetTubeMPNDetailModel PostDeleteLabSheetTubeMPNDetailDB(int LabSheetTubeMPNDetailID)
{
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrEmpty(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
LabSheetTubeMPNDetail labSheetTubeMPNDetailToDelete = GetLabSheetTubeMPNDetailWithLabSheetTubeMPNDetailIDDB(LabSheetTubeMPNDetailID);
if (labSheetTubeMPNDetailToDelete == null)
{
return(ReturnError(string.Format(ServiceRes.CouldNotFind_ToDelete, ServiceRes.LabSheetTubeMPNDetail)));
}
using (TransactionScope ts = new TransactionScope())
{
db.LabSheetTubeMPNDetails.Remove(labSheetTubeMPNDetailToDelete);
string retStr = DoDeleteChanges();
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
LogModel logModel = _LogService.PostAddLogForObj("LabSheetTubeMPNDetails", labSheetTubeMPNDetailToDelete.LabSheetTubeMPNDetailID, LogCommandEnum.Delete, labSheetTubeMPNDetailToDelete);
if (!string.IsNullOrWhiteSpace(logModel.Error))
{
return(ReturnError(logModel.Error));
}
ts.Complete();
}
return(ReturnError(""));
}
public void InfrastructureLanguageService_FillInfrastructureLanguage_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
InfrastructureModel infrastructureModelRet = infrastructureServiceTest.AddInfrastructureModel();
Assert.AreEqual("", infrastructureModelRet.Error);
infrastructureLanguageModelNew.InfrastructureID = infrastructureModelRet.InfrastructureID;
FillInfrastructureLanguageModel(infrastructureLanguageModelNew);
ContactOK contactOK = infrastructureLanguageService.IsContactOK();
string retStr = infrastructureLanguageService.FillInfrastructureLanguage(infrastructureLanguage, infrastructureLanguageModelNew, contactOK);
Assert.AreEqual("", retStr);
Assert.AreEqual(contactOK.ContactTVItemID, infrastructureLanguage.LastUpdateContactTVItemID);
contactOK = null;
retStr = infrastructureLanguageService.FillInfrastructureLanguage(infrastructureLanguage, infrastructureLanguageModelNew, contactOK);
Assert.AreEqual("", retStr);
Assert.AreEqual(2, infrastructureLanguage.LastUpdateContactTVItemID);
}
}
}
public AppTaskLanguageModel PostDeleteAppTaskLanguageDB(int AppTaskID, LanguageEnum Language)
{
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrEmpty(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
AppTaskLanguage appTaskLanguageToDelete = GetAppTaskLanguageWithAppTaskIDAndLanguageDB(AppTaskID, Language);
if (appTaskLanguageToDelete == null)
{
return(ReturnError(string.Format(ServiceRes.CouldNotFind_ToDelete, ServiceRes.AppTaskLanguage)));
}
using (TransactionScope ts = new TransactionScope())
{
db.AppTaskLanguages.Remove(appTaskLanguageToDelete);
string retStr = DoDeleteChanges();
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
LogModel logModel = _LogService.PostAddLogForObj("AppTaskLanguages", appTaskLanguageToDelete.AppTaskLanguageID, LogCommandEnum.Delete, appTaskLanguageToDelete);
if (!string.IsNullOrWhiteSpace(logModel.Error))
{
return(ReturnError(logModel.Error));
}
ts.Complete();
}
return(ReturnError(""));;
}
public MWQMSubsectorLanguageModel PostDeleteMWQMSubsectorLanguageDB(int MWQMSubsectorID, LanguageEnum Language)
{
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrEmpty(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
MWQMSubsectorLanguage mwqmSubsectorLanguageToDelete = GetMWQMSubsectorLanguageWithMWQMSubsectorIDAndLanguageDB(MWQMSubsectorID, Language);
if (mwqmSubsectorLanguageToDelete == null)
{
return(ReturnError(string.Format(ServiceRes.CouldNotFind_ToDelete, ServiceRes.MWQMSubsectorLanguage)));
}
using (TransactionScope ts = new TransactionScope())
{
db.MWQMSubsectorLanguages.Remove(mwqmSubsectorLanguageToDelete);
string retStr = DoDeleteChanges();
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
LogModel logModel = _LogService.PostAddLogForObj("MWQMSubsectorLanguages", mwqmSubsectorLanguageToDelete.MWQMSubsectorLanguageID, LogCommandEnum.Delete, mwqmSubsectorLanguageToDelete);
if (!string.IsNullOrWhiteSpace(logModel.Error))
{
return(ReturnError(logModel.Error));
}
ts.Complete();
}
return(ReturnError(""));
}
// Fill
public string FillBoxModel(BoxModel boxModel, BoxModelModel boxModelModel, ContactOK contactOK)
{
boxModel.DBCommand = (int)boxModelModel.DBCommand;
boxModel.InfrastructureTVItemID = boxModelModel.InfrastructureTVItemID;
boxModel.Discharge_m3_day = boxModelModel.Discharge_m3_day;
boxModel.Depth_m = boxModelModel.Depth_m;
boxModel.Temperature_C = boxModelModel.Temperature_C;
boxModel.Dilution = boxModelModel.Dilution;
boxModel.DecayRate_per_day = boxModelModel.DecayRate_per_day;
boxModel.FCUntreated_MPN_100ml = boxModelModel.FCUntreated_MPN_100ml;
boxModel.FCPreDisinfection_MPN_100ml = boxModelModel.FCPreDisinfection_MPN_100ml;
boxModel.Concentration_MPN_100ml = boxModelModel.Concentration_MPN_100ml;
boxModel.DischargeDuration_hour = boxModelModel.DischargeDuration_hour;
boxModel.T90_hour = boxModelModel.T90_hour;
boxModel.LastUpdateDate_UTC = DateTime.UtcNow;
if (contactOK == null)
{
boxModel.LastUpdateContactTVItemID = 2;
}
else
{
boxModel.LastUpdateContactTVItemID = contactOK.ContactTVItemID;
}
return("");
}
public TVFileLanguageModel PostDeleteTVFileLanguageDB(int TVFileID, LanguageEnum Language)
{
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrWhiteSpace(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
TVFileLanguage tvFileLanguageToDelete = GetTVFileLanguageWithTVFileIDAndLanguageDB(TVFileID, Language);
if (tvFileLanguageToDelete == null)
{
return(ReturnError(string.Format(ServiceRes.CouldNotFind_ToDelete, ServiceRes.TVFileLanguage)));
}
using (TransactionScope ts = new TransactionScope())
{
db.TVFileLanguages.Remove(tvFileLanguageToDelete);
string retStr = DoDeleteChanges();
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
LogModel logModel = _LogService.PostAddLogForObj("TVFileLanguages", tvFileLanguageToDelete.TVFileLanguageID, LogCommandEnum.Delete, tvFileLanguageToDelete);
if (!string.IsNullOrWhiteSpace(logModel.Error))
{
return(ReturnError(logModel.Error));
}
ts.Complete();
}
return(ReturnError(""));
}
public BoxModelModel PostDeleteBoxModelDB(int BoxModelID)
{
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrEmpty(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
BoxModel boxModelToDelete = GetBoxModelWithBoxModelIDDB(BoxModelID);
if (boxModelToDelete == null)
{
return(ReturnError(string.Format(ServiceRes.CouldNotFind_ToDelete, ServiceRes.BoxModel)));
}
using (TransactionScope ts = new TransactionScope())
{
db.BoxModels.Remove(boxModelToDelete);
string retStr = DoDeleteChanges();
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
LogModel logModel = _LogService.PostAddLogForObj("BoxModels", boxModelToDelete.BoxModelID, LogCommandEnum.Delete, boxModelToDelete);
if (!string.IsNullOrWhiteSpace(logModel.Error))
{
return(ReturnError(logModel.Error));
}
ts.Complete();
}
return(ReturnError(""));
}
// Post
public PolSourceSiteEffectModel PolSourceSiteEffectTermsSaveAllDB(int PolSourceSiteEffectID, string PolSourceSiteEffectTermIDs)
{
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrWhiteSpace(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
PolSourceSiteEffectModel polSourceSiteEffectToChange = GetPolSourceSiteEffectModelWithPolSourceSiteEffectIDDB(PolSourceSiteEffectID);
if (!string.IsNullOrWhiteSpace(polSourceSiteEffectToChange.Error))
{
return(ReturnError(polSourceSiteEffectToChange.Error));
}
polSourceSiteEffectToChange.PolSourceSiteEffectTermIDs = PolSourceSiteEffectTermIDs.Replace("|", ",");
PolSourceSiteEffectModel polSourceSiteEffectToChangeRet = PostUpdatePolSourceSiteEffectDB(polSourceSiteEffectToChange);
if (!string.IsNullOrWhiteSpace(polSourceSiteEffectToChangeRet.Error))
{
return(ReturnError(polSourceSiteEffectToChangeRet.Error));
}
return(polSourceSiteEffectToChangeRet);
}
public EmailDistributionListLanguageModel PostDeleteEmailDistributionListLanguageDB(int EmailDistributionListID, LanguageEnum Language)
{
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrEmpty(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
EmailDistributionListLanguage emailDistributionListLanguageToDelete = GetEmailDistributionListLanguageWithEmailDistributionListIDAndLanguageDB(EmailDistributionListID, Language);
if (emailDistributionListLanguageToDelete == null)
{
return(ReturnError(string.Format(ServiceRes.CouldNotFind_ToDelete, ServiceRes.EmailDistributionListLanguage)));
}
using (TransactionScope ts = new TransactionScope())
{
db.EmailDistributionListLanguages.Remove(emailDistributionListLanguageToDelete);
string retStr = DoDeleteChanges();
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
LogModel logModel = _LogService.PostAddLogForObj("EmailDistributionListLanguages", emailDistributionListLanguageToDelete.EmailDistributionListLanguageID, LogCommandEnum.Delete, emailDistributionListLanguageToDelete);
if (!string.IsNullOrWhiteSpace(logModel.Error))
{
return(ReturnError(logModel.Error));
}
ts.Complete();
}
return(ReturnError(""));
}
public PolSourceSiteEffectModel PostDeletePolSourceSiteEffectDB(int PolSourceSiteEffectID)
{
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrEmpty(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
PolSourceSiteEffect polSourceSiteEffectToDelete = GetPolSourceSiteEffectWithPolSourceSiteEffectIDDB(PolSourceSiteEffectID);
if (polSourceSiteEffectToDelete == null)
{
return(ReturnError(string.Format(ServiceRes.CouldNotFind_ToDelete, ServiceRes.PolSourceSiteEffect)));
}
using (TransactionScope ts = new TransactionScope())
{
db.PolSourceSiteEffects.Remove(polSourceSiteEffectToDelete);
string retStr = DoDeleteChanges();
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
LogModel logModel = _LogService.PostAddLogForObj("PolSourceSiteEffects", polSourceSiteEffectToDelete.PolSourceSiteEffectID, LogCommandEnum.Delete, polSourceSiteEffectToDelete);
if (!string.IsNullOrWhiteSpace(logModel.Error))
{
return(ReturnError(logModel.Error));
}
ts.Complete();
}
return(ReturnError(""));
}
// Fill
public string FillAppTask(AppTask appTask, AppTaskModel appTaskModel, ContactOK contactOK)
{
appTask.DBCommand = (int)appTaskModel.DBCommand;
appTask.TVItemID = appTaskModel.TVItemID;
appTask.TVItemID2 = appTaskModel.TVItemID2;
appTask.AppTaskCommand = (int)appTaskModel.AppTaskCommand;
appTask.AppTaskStatus = (int)appTaskModel.AppTaskStatus;
appTask.PercentCompleted = appTaskModel.PercentCompleted;
appTask.Parameters = appTaskModel.Parameters;
appTask.Language = (int)appTaskModel.Language;
appTask.EndDateTime_UTC = appTaskModel.EndDateTime_UTC;
appTask.StartDateTime_UTC = appTaskModel.StartDateTime_UTC;
appTask.EstimatedLength_second = appTaskModel.EstimatedLength_second;
appTask.RemainingTime_second = appTaskModel.RemainingTime_second;
appTask.LastUpdateDate_UTC = DateTime.UtcNow;
if (contactOK == null)
{
appTask.LastUpdateContactTVItemID = 2;
}
else
{
appTask.LastUpdateContactTVItemID = contactOK.ContactTVItemID;
}
return("");
}
public ClimateDataValueModel PostDeleteClimateDataValueDB(int climateDataValueID)
{
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrEmpty(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
ClimateDataValue climateDataValueToDelete = GetClimateDataValueWithClimateDataValueIDDB(climateDataValueID);
if (climateDataValueToDelete == null)
{
return(ReturnError(string.Format(ServiceRes.CouldNotFind_ToDelete, ServiceRes.ClimateDataValue)));
}
using (TransactionScope ts = new TransactionScope())
{
db.ClimateDataValues.Remove(climateDataValueToDelete);
string retStr = DoDeleteChanges();
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
LogModel logModel = _LogService.PostAddLogForObj("ClimateDataValues", climateDataValueToDelete.ClimateDataValueID, LogCommandEnum.Delete, climateDataValueToDelete);
if (!string.IsNullOrWhiteSpace(logModel.Error))
{
return(ReturnError(logModel.Error));
}
ts.Complete();
}
return(ReturnError(""));
}
public AppTaskModel PostUpdateAppTask(AppTaskModel appTaskModel)
{
string retStr = AppTaskModelOK(appTaskModel);
if (!string.IsNullOrEmpty(retStr))
{
return(ReturnError(retStr));
}
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrEmpty(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
AppTask appTaskToUpdate = GetAppTaskWithAppTaskIDDB(appTaskModel.AppTaskID);
if (appTaskToUpdate == null)
{
return(ReturnError(string.Format(ServiceRes.CouldNotFind_ToUpdate, ServiceRes.AppTask)));
}
retStr = FillAppTask(appTaskToUpdate, appTaskModel, contactOK);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
using (TransactionScope ts = new TransactionScope())
{
retStr = DoUpdateChanges();
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
foreach (LanguageEnum Lang in LanguageListAllowable)
{
AppTaskLanguageModel appTaskLanguageModel = new AppTaskLanguageModel()
{
AppTaskID = appTaskModel.AppTaskID,
DBCommand = DBCommandEnum.Original,
ErrorText = appTaskModel.ErrorText,
StatusText = appTaskModel.StatusText,
Language = Lang,
TranslationStatus = (Lang == LanguageRequest ? TranslationStatusEnum.Translated : TranslationStatusEnum.NotTranslated),
};
AppTaskLanguageModel appTaskLanguageModelRet = _AppTaskLanguageService.PostUpdateAppTaskLanguageDB(appTaskLanguageModel);
if (!string.IsNullOrEmpty(appTaskLanguageModelRet.Error))
{
return(ReturnError(appTaskLanguageModelRet.Error));
}
}
ts.Complete();
}
return(GetAppTaskModelWithAppTaskIDDB(appTaskToUpdate.AppTaskID));
}
public void AppTaskLanguageService_FillAppTaskLanguage_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
AppTaskModel appTaskModel = appTaskServiceTest.AddAppTaskModel();
Assert.AreEqual("", appTaskModel.Error);
LanguageEnum LangToAdd = LanguageEnum.es;
appTaskLanguageModelNew.AppTaskID = appTaskModel.AppTaskID;
FillAppTaskLanguageModel(LangToAdd, appTaskLanguageModelNew);
ContactOK contactOK = appTaskLanguageService.IsContactOK();
string retStr = appTaskLanguageService.FillAppTaskLanguage(appTaskLanguage, appTaskLanguageModelNew, contactOK);
Assert.AreEqual("", retStr);
Assert.AreEqual(contactOK.ContactTVItemID, appTaskLanguage.LastUpdateContactTVItemID);
contactOK = null;
retStr = appTaskLanguageService.FillAppTaskLanguage(appTaskLanguage, appTaskLanguageModelNew, contactOK);
Assert.AreEqual("", retStr);
Assert.AreEqual(2, appTaskLanguage.LastUpdateContactTVItemID);
}
}
}
public void RatingCurveValueService_FillRatingCurveValue_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
RatingCurveValueModel ratingCurveModelRet = AddRatingCurveValueModel();
Assert.AreEqual("", ratingCurveModelRet.Error);
ratingCurveValueModelNew.RatingCurveID = ratingCurveModelRet.RatingCurveID;
FillRatingCurveValueModel(ratingCurveValueModelNew);
ContactOK contactOK = ratingCurveValueService.IsContactOK();
string retStr = ratingCurveValueService.FillRatingCurveValue(ratingCurveValue, ratingCurveValueModelNew, contactOK);
Assert.AreEqual("", retStr);
Assert.AreEqual(contactOK.ContactTVItemID, ratingCurveValue.LastUpdateContactTVItemID);
contactOK = null;
retStr = ratingCurveValueService.FillRatingCurveValue(ratingCurveValue, ratingCurveValueModelNew, contactOK);
Assert.AreEqual("", retStr);
Assert.AreEqual(2, ratingCurveValue.LastUpdateContactTVItemID);
}
}
}
public ClassificationModel PostDeleteClassificationWithClassificationTVItemIDDB(int ClassificationTVItemID)
{
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrEmpty(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
Classification ClassificationToDelete = GetClassificationWithClassificationWithClassificationTVItemIDDB(ClassificationTVItemID);
if (ClassificationToDelete == null)
{
return(ReturnError(string.Format(ServiceRes.CouldNotFind_ToDelete, ServiceRes.Classification)));
}
ClassificationModel ClassificationModelRet = PostDeleteClassificationDB(ClassificationToDelete.ClassificationID);
if (!string.IsNullOrWhiteSpace(ClassificationModelRet.Error))
{
return(ReturnError(ClassificationModelRet.Error));
}
return(ReturnError(""));
}
public MWQMSiteModel PostDeleteMWQMSiteTVItemDB(int MWQMSiteTVItemID)
{
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrEmpty(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
MWQMSiteModel mwqmSiteModelToDelete = GetMWQMSiteModelWithMWQMSiteTVItemIDDB(MWQMSiteTVItemID);
if (!string.IsNullOrWhiteSpace(mwqmSiteModelToDelete.Error))
{
return(ReturnError(mwqmSiteModelToDelete.Error));
}
MWQMSiteModel mwqmSiteModelRet = PostDeleteMWQMSiteDB(mwqmSiteModelToDelete.MWQMSiteID);
if (!string.IsNullOrWhiteSpace(mwqmSiteModelRet.Error))
{
return(ReturnError(mwqmSiteModelRet.Error));
}
return(ReturnError(""));
}
public LogModel PostDeleteLogDB(int LogID)
{
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrEmpty(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
Log log = GetLogWithLogIDDB(LogID);
if (log == null)
{
return(ReturnError(string.Format(ServiceRes.CouldNotFind_With_Equal_, ServiceRes.Log, ServiceRes.LogID, LogID.ToString())));
}
using (TransactionScope ts = new TransactionScope())
{
db.Logs.Remove(log);
string retStr = DoDeleteChanges();
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
ts.Complete();
}
return(ReturnError(""));
}
public TVItemLinkModel PostDeleteTVItemLinkWithToTVItemIDDB(int ToTVItemID)
{
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrEmpty(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
List <TVItemLink> tvItemLinkListToDelete = GetTVItemLinkListWithToTVItemIDDB(ToTVItemID);
foreach (TVItemLink tvil in tvItemLinkListToDelete)
{
LogModel logModel = _LogService.PostAddLogForObj("TVItemLinks", tvil.TVItemLinkID, LogCommandEnum.Delete, tvil);
if (!string.IsNullOrWhiteSpace(logModel.Error))
{
return(ReturnError(logModel.Error));
}
db.TVItemLinks.Remove(tvil);
}
using (TransactionScope ts = new TransactionScope())
{
string retStr = DoDeleteChanges();
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
ts.Complete();
}
return(ReturnError(""));
}
public CoCoRaHSValueModel PostDeleteCoCoRaHSValueDB(int CoCoRaHSValueID)
{
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrEmpty(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
CoCoRaHSValue coCoRaHSValueToDelete = GetCoCoRaHSValueWithCoCoRaHSValueIDDB(CoCoRaHSValueID);
if (coCoRaHSValueToDelete == null)
{
return(ReturnError(string.Format(ServiceRes.CouldNotFind_ToDelete, ServiceRes.CoCoRaHSValue)));
}
using (TransactionScope ts = new TransactionScope())
{
db.CoCoRaHSValues.Remove(coCoRaHSValueToDelete);
string retStr = DoDeleteChanges();
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
ts.Complete();
}
return(ReturnError(""));
}
