public virtual ActionResult GetPackageDetail(int procurementId, int bidPackageConfProcId, bool isEditMode = false)
{
var responseView = new SaveResponse {
IsValid = true
};
var html = string.Empty;
var response = _procurementDetailsService.GetPackageDetail(procurementId, bidPackageConfProcId);
responseView.IsValid = response.IsValid;
responseView.ErrorMessage = response.ErrorMessage;
if (isEditMode)
{
html = this.RenderRazorViewToString("EditPartial/BiddingDocuments/BiddingDocTablePartial", response.Model);
}
else
{
if (response.Model.CanModifyPackage)
{
html = this.RenderRazorViewToString("ReadPartial/BiddingDocuments/BiddingDocPartial", response.Model);
}
else
{
html = this.RenderRazorViewToString("ReadPartial/BiddingDocuments/BiddingDocReadPartial", response.Model);
}
}
if (responseView.IsValid)
{
responseView.ContentHTML = html;
}
return(Json(responseView));
}
public async Task<SaveResponse> SaveSessionStateAsync(IUser user)
{
var response = new SaveResponse();
try
{
const string sql =
@"UPDATE [Identity].[User] SET [LastAccessedDate] = SYSDATETIMEOFFSET() WHERE [Id] = @id;
INSERT INTO [Identity].[UserSession](UserId, LoginDate) VALUES(@id, SYSDATETIMEOFFSET());";
var parms = new { id = user.Id };
using (var connection = ConnectionFactory.GetConnection())
{
var x = await connection.ExecuteAsync(sql, parms);
}
}
catch (Exception e)
{
Console.WriteLine(e);
response.AddError(e);
LogManager.LogError(e, $@"Error saving login state for user: {user.Email}.");
}
return response;
}
public virtual JsonResult SaveChecklist(int procurementId)
{
var responseView = new SaveResponse()
{
IsValid = true
};
var jsonDataRequest = PageSerializationHelper.DeserializeJsonForm(Request.Form[0]);
var model = PageSerializationHelper.DeserializeObject <ProcurementDetailViewModel>(jsonDataRequest.SerializedData);
var formData = jsonDataRequest.ClientFieldData;
model.UpdateChecklist(formData);
var errorMessage = SynchronizationHelper.AccessToResources(SynchronizationHelper.EDIT_MODE, SGP_PROCUREMENT_DETAIL_URL + procurementId, IDBContext.Current.Operation, IDBContext.Current.UserLoginName);
if (!string.IsNullOrWhiteSpace(errorMessage))
{
responseView.IsValid = false;
responseView.ErrorMessage = errorMessage;
return(Json(responseView));
}
var response = _procurementDetailsService.SaveProcurementChecklist(procurementId, model);
responseView.IsValid = response.IsValid;
responseView.ErrorMessage = response.ErrorMessage;
if (responseView.IsValid)
{
var url = Url.Action("Read", "ProcurementDetail", new { area = "SGP", tabName = ProcurementDetailNavigation.TAB_NAME_CHECKLIST, procurementId = procurementId });
responseView.UrlRedirect = url;
}
return(Json(responseView));
}
public static SaveResponse SaveFile(string path, HttpPostedFileBase file)
{
var physicalPath = HttpContext.Current.Request.MapPath("~" + FormatPath(path));
var response = new SaveResponse(SaveResponseStatus.InvalidFileType){Path = path};
var fileOk = false;
if (file != null)
{
response.Filename = file.FileName;
var extension = Path.GetExtension(response.Filename);
if (extension != null)
{
var fileExtension = extension.ToLower();
var allowedExtensions = new[] { ".png", ".jpeg", ".jpg", ".gif" };
fileOk = allowedExtensions.Any(t => fileExtension == t);
}
}
if (fileOk)
{
try
{
file.SaveAs(physicalPath + response.Filename);
response.Status = SaveResponseStatus.Success;
}
catch (Exception ex)
{
response.Status = SaveResponseStatus.UploadError;
response.Message = ex.Message;
}
}
return response;
}
public virtual ActionResult SaveTemplateList()
{
var responseView = new SaveResponse()
{
IsValid = true
};
var jsonDataRequest = PageSerializationHelper.DeserializeJsonForm(Request.Form[0]);
var viewModel = PageSerializationHelper.DeserializeObject <TemplatePageViewModel>(jsonDataRequest.SerializedData);
var formData = jsonDataRequest.ClientFieldData;
viewModel.UpdateTemplateListPage(formData);
var response = _resultFrameworkService.SaveTemplates(viewModel.Templates);
responseView.IsValid = response.IsValid;
responseView.ErrorMessage = response.ErrorMessage;
if (responseView.IsValid)
{
var url = Url.Action("TemplatesPage", base.ControllerName, new { area = "Indicators" });
responseView.UrlRedirect = url;
}
return(Json(responseView));
}
///<Summary>
/// Convert method to convert file to other format
///</Summary>
public Response Convert(string fileName, string outputType)
{
string fileNamewithOutExtension = Path.GetFileNameWithoutExtension(fileName);
string outputFileName = fileNamewithOutExtension + "." + outputType;
bool isAutoFitRows = false;
bool isAutoFitColumns = false;
SaveOptions body = new SaveOptions();
body.SaveFormat = outputType;
if (cellsApi != null)
{
SaveResponse apiResponse = cellsApi.CellsSaveAsPostDocumentSaveAs(fileName, body, outputFileName, isAutoFitRows, isAutoFitColumns, null, null);
return(new Response
{
FileName = outputFileName,
Status = "OK",
StatusCode = 200,
});
}
return(new Response
{
FileName = null,
Status = "Output type not found",
StatusCode = 500
});
}
public virtual JsonResult SaveProcurementList(string operationNumber)
{
var responseView = new SaveResponse()
{
IsValid = true
};
var errorMessage = SynchronizationHelper.AccessToResources(SynchronizationHelper.EDIT_MODE, SYNC_PROCUREMENT_LIST, operationNumber, IDBContext.Current.UserLoginName);
if (!string.IsNullOrWhiteSpace(errorMessage))
{
responseView.IsValid = false;
responseView.ErrorMessage = errorMessage;
return(Json(responseView));
}
var jsonDataRequest = PageSerializationHelper.DeserializeJsonForm(Request.Form[0]);
var model = PageSerializationHelper.DeserializeObject <ProcurementViewModel>(jsonDataRequest.SerializedData);
model.UpdateProcurementList(jsonDataRequest.ClientFieldData, _enumMappingService);
var response = _firmProcurementService.SaveProcurementList(operationNumber, model);
responseView.IsValid = response.IsValid;
responseView.ErrorMessage = response.ErrorMessage;
if (responseView.IsValid)
{
SynchronizationHelper.TryReleaseLock(SYNC_PROCUREMENT_LIST, operationNumber, IDBContext.Current.UserLoginName);
var url = Url.Action("ProcurementList", "FirmProcurement", new { area = "Procurement" });
responseView.UrlRedirect = url;
}
return(Json(responseView));
}
// Todo [Test] Test completely broken ILocationServiceListener not bound to real implementatio, cannot be resolved
public async Task SaveCustomerTest()
{
Customer customer = new Customer
{
Id = Guid.NewGuid()
,
Channel = DataChannel.Fallback
,
DsrPhone = "0721553229"
,
FirstName = "Jake"
,
LastName = "Roberts"
,
NationalId = "22932568"
,
Phone = "0722456789"
,
UserId = Guid.NewGuid()
};
SaveResponse <Customer> saveResponse = await new CustomersController().SaveAsync(customer);
SyncRecord syncRecord = await new SyncingController().GetSyncRecordAsync(saveResponse.SavedModel.RequestId);
Assert.NotNull(syncRecord, "No sync record found");
}
// [Test] Todo ILocationServiceListener not bound to a real implementation, cannot be resolved
public async void SelectQueryTest()
{
const string firstname = "Mr";
const string lastname = "Waweru";
List <Prospect> results = await prospectsController.SelectQueryAsync(
new[]
{
new Criterion("FirstName", firstname),
new Criterion("LastName", lastname)
});
foreach (var prosp in results)
{
await prospectsController.DeleteAsync(prosp);
}
SaveResponse <Prospect> prospectResponse = await SaveAsync(firstname, lastname, "0724569852");
results = await prospectsController.SelectQueryAsync(
new []
{
new Criterion("FirstName", firstname),
new Criterion("LastName", lastname)
});
Assert.AreEqual(prospectResponse.SavedModel.Id, results[0].Id);
}
public async Task <SaveResponse <IReadOnlyList <ISalesVerification> > > SaveAllSalesVerficationAsync(List <ISalesVerification> salesVerifications)
{
var saveResponse = new SaveResponse <IReadOnlyList <ISalesVerification> >();
try
{
// Save verification files
var filesToSave = salesVerifications
.Where(s => s.VerificationFile != null)
.Select(s => s.VerificationFile)
.ToList();
var uploadSaveResponse = await _fileUploadApplicationService.SaveAllAsync(filesToSave);
if (uploadSaveResponse.IsSuccessful)
{
foreach (var file in uploadSaveResponse.Content)
{
var sale = salesVerifications.First(s => s.VerificationFile.OriginalFileName == file.OriginalFileName)
.VerificationFile = file;
}
}
saveResponse = await _salesRepository.SaveAllSalesVerificationAsync(salesVerifications);
}
catch (Exception ex)
{
Console.WriteLine(ex);
saveResponse.AddError(ex);
_logManager.LogError(ex, "Error saving saless");
}
return(saveResponse);
}
public async Task <SaveResponse <IList <IDocumentHistory> > > SaveAllDocumentHistoryAsync(IList <IDocumentHistory> items)
{
var response = new SaveResponse <IList <IDocumentHistory> >();
try
{
using (var connection = ConnectionFactory.GetConnection())
{
var sql = GetDocumentHistoryMergeStatement();
var dtos = items.Select(i =>
{
var dto = new DocumentHistoryDto();
return(dto.FromModel(i));
}).ToList();
var trans = connection.BeginTransaction();
var result = await connection.ExecuteAsync(sql, dtos, trans);
trans.Commit();
response.Content = items;
response.Message = $@"Document history was inserted/updated successfully.";
}
}
catch (Exception e)
{
var message = $@"Error saving document history.";
LogManager.LogError(e, message);
response.AddError(e);
Console.WriteLine(e);
}
return(response);
}
public async Task <SaveResponse> SaveAsync(IUser user)
{
var response = new SaveResponse();
try
{
var validateResponse = await _userValidator.ValidateAsync(user);
if (validateResponse.IsValid)
{
response = await _userRepository.SaveAsync(user);
}
else
{
response.AddErrors(validateResponse.Errors);
}
}
catch (Exception e)
{
response.AddError(e);
Console.WriteLine(e);
}
return(response);
}
public async Task <JsonResult> ChangeStatusFromPhoneNumber(int PrankCallFromId, bool IsDefault)
{
IsDefault = IsDefault ? false : true;
var data = new ResponseModel();
var objResponse = new SaveResponse();
string viewFromCurrentController = string.Empty;
if (PrankCallFromId > 0)
{
string token = string.Empty;
var claimsIdentity = (ClaimsIdentity)HttpContext.User.Identity;
var userTokenClaim = claimsIdentity.Claims.SingleOrDefault(c => c.Type == "Token");
if (userTokenClaim != null)
{
token = userTokenClaim.Value;
}
data = await ApiClientFactory.Instance.ChangeStatusPrankCallFromPhoneNumber(token, PrankCallFromId, IsDefault);
objResponse.StatusCode = Convert.ToInt32(data.StatusCode);
if (objResponse.StatusCode == 200)
{
objResponse.Message = "Record status changed successfully";
await TrackingInfo.TrackInfo(token, EmployeeId, ControllerContext.ActionDescriptor.ControllerName, PrankCallFromId.ToString(), PrankCallFromId, "ChangeStatusFromPhoneNumber");
}
else
{
objResponse.Message = "Record not status changed successfully";
}
}
return(new JsonResult(new
{
objResponse
}));
}
public virtual ActionResult SaveUseOfCountrySystems(string operationNumber)
{
var responseView = new SaveResponse()
{
IsValid = true, ErrorMessage = string.Empty
};
var jsonDataRequest = PageSerializationHelper.DeserializeJsonForm(Request.Form[0]);
var viewModel = PageSerializationHelper.DeserializeObject <CSPDUseOfCountrySystemsTabViewModel>(jsonDataRequest.SerializedData);
var formData = jsonDataRequest.ClientFieldData;
viewModel.UpdateUseOfCountrySystemsTabCSViewModel(formData);
var errorMessage = SynchronizationHelper.AccessToResources(SynchronizationHelper.EDIT_MODE, CPD_PROGRESS_DATE_UCS_URL, operationNumber, IDBContext.Current.UserLoginName);
if (!string.IsNullOrWhiteSpace(errorMessage))
{
responseView.IsValid = false;
responseView.ErrorMessage = errorMessage;
return(Json(responseView));
}
var response = _csProgressToDateService.SaveUseOfCSTab(operationNumber, viewModel);
responseView.IsValid = response.IsValid;
responseView.ErrorMessage = response.ErrorMessage;
if (responseView.IsValid)
{
SynchronizationHelper.TryReleaseLock(CPD_PROGRESS_DATE_UCS_URL, operationNumber, IDBContext.Current.UserLoginName);
responseView.UrlRedirect = Url.Action("Read", "CSProgressToDate", new { area = "CPD", tabName = NavigationAttributes.TAB_NAME_PD_USEOFCS });
}
return(Json(responseView));
}
public virtual async Task <SaveResponse <TModel> > SaveAsync(TModel item)
{
var response = new SaveResponse <TModel>();
try
{
using (var connection = ConnectionFactory.GetConnection())
{
var sql = GetMergeStatement();
var results = await connection.QuerySingleAsync <TDto>(sql, Dto.FromModel(item));
response.Content = results.ToModel();
response.Message = $@"{results} {typeof(TModel).Name} record was inserted/updated.";
}
}
catch (Exception e)
{
var message = $@"Error saving {typeof(TModel).Name} information.";
LogManager.LogError(e, message);
response.AddError(e);
Console.WriteLine(e);
}
return(response);
}
public async Task <SaveResponse <IReadOnlyList <ISalesVerification> > > SaveAllSalesVerificationAsync(List <ISalesVerification> items)
{
var response = new SaveResponse <IReadOnlyList <ISalesVerification> >();
try
{
if (items.Any())
{
var dto = new SalesVerificationDto();
using (var connection = ConnectionFactory.GetConnection())
{
var sql = "spmSalesVerification";
var results = await connection.ExecuteAsync(sql, items.Select(m => dto.FromModel(m)), commandType : CommandType.StoredProcedure);
response.Content = items;
response.Message = $@"Sales verification records were inserted/updated.";
}
}
}
catch (Exception e)
{
var message = $@"Error saving Sales information.";
LogManager.LogError(e, message);
response.AddError(e);
Console.WriteLine(e);
}
return(response);
}
public async Task <SaveResponse> SaveFlip(FlipModel Flip)
{
dbContext.Flips.Add(Flip);
SaveResponse response = await dbContext.SaveWithResponseAsync();
return(response);
}
public async Task <SaveResponse <IContact> > SaveAsync(IContact model)
{
var saveResponse = new SaveResponse <IContact>();
try
{
// Make sure contact is valid before saving
var validationResult = await _contactValidator.ValidateAsync(model);
if (validationResult.IsValid)
{
saveResponse = await _contactRepository.SaveAsync(model);
}
else
{
saveResponse.AddErrors(validationResult.Errors);
saveResponse.Message = string.Join <ValidationFailure>(". \n", validationResult.Errors.ToArray());
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
saveResponse.AddError(ex);
_logManager.LogError(ex, "Error saving contact");
}
return(saveResponse);
}
public async Task <SaveResponse <IReadOnlyList <IPayrollClassification> > > SaveAllPayrollClassification(IReadOnlyList <IPayrollClassification> items)
{
var response = new SaveResponse <IReadOnlyList <IPayrollClassification> >();
try
{
using (var connection = ConnectionFactory.GetConnection())
{
var sql = GetPayrollClassificationUpdateSqlStatement();
var results = await connection.ExecuteAsync(sql, items.Select(m =>
{
var dto = new PayrollClassificationDto();
return(dto.FromModel(m));
}));
response.Content = items;
response.Message = $@"{results} payroll classification record were inserted/updated.";
}
}
catch (Exception ex)
{
var messaage = $@"Unable to save payroll classification records.";
response.AddError(ex);
LogManager.LogError(ex, messaage);
Console.WriteLine(ex);
}
return(response);
}
public async Task <SaveResponse <ILabor> > SaveAsync(ILabor labor)
{
var saveResponse = new SaveResponse <ILabor>();
try
{
saveResponse = await _laborRepository.SaveAsync(labor);
if (saveResponse.IsSuccessful)
{
// Save certificate of insurance
var savedLabor = saveResponse.Content;
if (labor.CertificateOfInsurance != null)
{
savedLabor.CertificateOfInsurance = labor.CertificateOfInsurance;
var certificateResponse = await
_certificateOfInsuranceApplicationService.SaveAsync(savedLabor.CertificateOfInsurance);
if (certificateResponse.IsSuccessful)
{
savedLabor.CertificateOfInsurance = certificateResponse.Content;
}
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
saveResponse.AddError(ex);
_logManager.LogError(ex, "Error saving labor");
}
return(saveResponse);
}
public virtual JsonResult SaveBasicData(string operationNumber)
{
var responseView = new SaveResponse()
{
IsValid = true
};
var jsonDataRequest = PageSerializationHelper.DeserializeJsonForm(Request.Form[0]);
var model = PageSerializationHelper.DeserializeObject <BasicDataViewModel>(jsonDataRequest.SerializedData);
model.UpdateProductDataBasicData(jsonDataRequest.ClientFieldData);
var userName = IDBContext.Current.UserLoginName;
var errorMessage = SynchronizationHelper.AccessToResources(OPUS_EDIT, URL_OPERATION_BASIC_DATA, operationNumber, userName);
if (!string.IsNullOrWhiteSpace(errorMessage))
{
responseView.IsValid = false;
responseView.ErrorMessage = errorMessage;
}
else
{
var response = _productProfileService.SaveBasicData(operationNumber, model);
responseView.IsValid = response.IsValid;
responseView.ErrorMessage = response.ErrorMessage;
}
if (responseView.IsValid)
{
SynchronizationHelper.TryReleaseLock(URL_OPERATION_BASIC_DATA, operationNumber, userName);
var url = Url.Action(READ_ACTION, PP_CONTROLLER, new { area = AttributeValue.CPD, tabName = TAB_NAME_BASICDATA });
responseView.UrlRedirect = url;
}
return(Json(responseView));
}
public virtual ActionResult SaveIndicativePipeline(string operationNumber)
{
var responseView = new SaveResponse()
{
IsValid = true, ErrorMessage = string.Empty
};
var jsonDataRequest = PageSerializationHelper.DeserializeJsonForm(Request.Form[0]);
var viewModel = PageSerializationHelper.DeserializeObject <IndicativePipelineTabViewModel>(jsonDataRequest.SerializedData);
var formData = jsonDataRequest.ClientFieldData;
viewModel.UpdateIndicativePipelineTabViewModel(formData);
var errorMessage = SynchronizationHelper.AccessToResources(SynchronizationHelper.EDIT_MODE, CPD_ANNEXES_INDICATIVE_PIPELINE, operationNumber, IDBContext.Current.UserLoginName);
if (!string.IsNullOrEmpty(errorMessage))
{
responseView.IsValid = false;
responseView.ErrorMessage = errorMessage;
return(Json(responseView));
}
var response = _annexesService.SaveIndicativePipelineTab(operationNumber, viewModel);
responseView.IsValid = response.IsValid;
responseView.ErrorMessage = response.ErrorMessage;
if (responseView.IsValid)
{
SynchronizationHelper.TryReleaseLock(CPD_ANNEXES_INDICATIVE_PIPELINE, operationNumber, IDBContext.Current.UserLoginName);
responseView.UrlRedirect = Url.Action("Read", "Annexes", new { area = "CPD", tabName = NavigationAttributes.TAB_NAME_INDICATIVE_PIPELINE });
}
return(Json(responseView));
}
public virtual ActionResult GetProcurementsProcLevelByFilter(int taskBucketId, ModelFilterRequest filter, bool isEditMode = false)
{
var responseView = new SaveResponse {
IsValid = true
};
var html = string.Empty;
_cacheService.Add(FILTER_CACHE_KEY, filter);
var response = _procurementPlanService.GetFilterProcurementLevel(taskBucketId, filter);
responseView.IsValid = response.IsValid;
responseView.ErrorMessage = response.ErrorMessage;
if (isEditMode)
{
html = this.RenderRazorViewToString("EditPartial/PlanForAgencyDataTable", response.Model.ProcurementLevel);
}
else
{
html = this.RenderRazorViewToString("ReadPartial/PlanForAgencyDataTable", response.Model.ProcurementLevel);
}
if (responseView.IsValid)
{
responseView.ContentHTML = html;
}
return(Json(responseView));
}
public SaveResponse Save(SaveRequest request)
{
var result = new SaveResponse()
{
Success = false,
Message = "Something went wrong, please contact administrator"
};
try
{
//add new
if (request.ProductId == 0)
{
var product = new Product()
{
Id = request.ProductId,
PricePerUnit = request.Price,
Name = request.ProductName
};
context.Add(product);
result.Success = context.SaveChanges() > 0;
result.Message = "Product has been created successfully";
}
}
catch (Exception ex)
{
}
return(result);
}
public int saveSurveyresult(SaveResponse responseRating)
{
using (IDbConnection con = Connection)
{
con.Open();
using (IDbTransaction tran = con.BeginTransaction())
{
var param = new DynamicParameters();
param.Add("@Comment", responseRating.Comment);
param.Add("@Response", responseRating.Response);
param.Add("@QuestionID", responseRating.QuestionID);
param.Add("@CompetencyID", responseRating.CompetencyID);
param.Add("@CycleID", responseRating.CycleID);
param.Add("@EmpID", responseRating.EmpID);
int temp = con.Execute("usp_SaveCompetencySurvey", param, tran, null, CommandType.StoredProcedure);
if (temp > 0)
{
tran.Commit();
}
else
{
tran.Rollback();
}
return(temp);
}
}
}
public virtual JsonResult SaveAttributeForm(int attributeFormId)
{
var jsonDataRequest = PageSerializationHelper.DeserializeJsonForm(Request.Form[0]);
var viewModel = PageSerializationHelper.DeserializeObject <AttributeFormViewModel>(jsonDataRequest.SerializedData);
viewModel.UpdateAttributesFormViewModel(jsonDataRequest.ClientFieldData);
var userName = IDBContext.Current.UserLoginName;
var errorMessage = string.Empty;
SaveResponse response = new SaveResponse();
if (!string.IsNullOrWhiteSpace(errorMessage))
{
response.IsValid = false;
response.ErrorMessage = errorMessage;
}
else
{
response = _attributesEngineService.SaveAttributeFormResponse(viewModel);
if (response.IsValid)
{
}
else
{
return(Json(new
{
response.ErrorMessage
}));
}
}
response.IsValid = true;
return(Json(response));
}
public virtual ActionResult SaveStrategicAlignment(string operationNumber)
{
var responseView = new SaveResponse()
{
IsValid = true, ErrorMessage = string.Empty
};
var jsonDataRequest = PageSerializationHelper.DeserializeJsonForm(Request.Form[0]);
var viewModel = PageSerializationHelper.DeserializeObject <StrategicAlignmentTabViewModel>(jsonDataRequest.SerializedData);
var formData = jsonDataRequest.ClientFieldData;
viewModel.UpdateStrategicAlignmentTabViewModel(formData, operationNumber);
var errorMessage = SynchronizationHelper.AccessToResources(SynchronizationHelper.EDIT_MODE, CPD_COUNTRY_PROGRAM_SA_URL, operationNumber, IDBContext.Current.UserLoginName);
if (!string.IsNullOrWhiteSpace(errorMessage))
{
responseView.IsValid = false;
responseView.ErrorMessage = errorMessage;
return(Json(responseView));
}
var response = _countryProgramService.SaveStrategicAligmentTab(operationNumber, viewModel);
responseView.IsValid = response.IsValid;
responseView.ErrorMessage = response.ErrorMessage;
if (responseView.IsValid)
{
SynchronizationHelper.TryReleaseLock(CPD_COUNTRY_PROGRAM_SA_URL, operationNumber, IDBContext.Current.UserLoginName);
responseView.UrlRedirect = Url.Action("Read", "CountryProgram", new { area = "CPD", tabName = NavigationAttributes.TAB_NAME_STRATEGICALIGNMENT });
}
return(Json(responseView));
}
public string UpdateClient(string userId, NewClient x)
{
SaveResponse r = new SaveResponse();
try {
using (SQLiteConnection connection = new SQLiteConnection("Data Source=" + db.GetDataBasePath(userId, dataBase))) {
connection.Open();
string sql = string.Format(@"UPDATE clients SET
firstName = '{0}', lastName = '{1}', birthDate = '{2}', gender = '{3}', phone = '{4}', email = '{5}'
WHERE clientId = '{6}'"
, x.firstName, x.lastName, x.birthDate, x.gender.value, x.phone, x.email, x.clientId);
using (SQLiteCommand command = new SQLiteCommand(sql, connection)) {
using (SQLiteTransaction transaction = connection.BeginTransaction()) {
command.ExecuteNonQuery();
transaction.Commit();
}
}
}
r.data = x;
r.msg = "saved";
r.isSuccess = true;
return(JsonConvert.SerializeObject(r, Formatting.None));
} catch (Exception e) {
r.data = null;
r.msg = e.Message;
r.isSuccess = false;
L.SendErrorLog(e, x.clientId, userId, "Clients", "UpdateClient");
return(JsonConvert.SerializeObject(r, Formatting.None));
}
}
public async Task <SaveResponse> Save(IEnumerable <SkillAction> SkillActions)
{
dbContext.SkillActions.AddRange(SkillActions);
SaveResponse response = await dbContext.SaveWithResponseAsync();
return(response);
}
public async Task <SaveResponse <IDocumentHistory> > SaveDocumentHistoryAsync(IDocumentHistory item)
{
var response = new SaveResponse <IDocumentHistory>();
try
{
using (var connection = ConnectionFactory.GetConnection())
{
var sql = GetDocumentHistoryMergeStatement();
var dto = new DocumentHistoryDto();
var result = await connection.QuerySingleAsync <DocumentHistoryDto>(sql, dto.FromModel(item));
response.Content = result.ToModel();
response.Message = $@"Document history was inserted/updated successfully.";
}
}
catch (Exception e)
{
var message = $@"Error saving document history.";
LogManager.LogError(e, message);
response.AddError(e);
Console.WriteLine(e);
}
return(response);
}
public async Task <SaveResponse> Save(SkillActionViewModel[] Actions)
{
var skillNames = Actions.Select(action => action.SkillName).Distinct();
SaveRequest <SkillActionViewModel[]> request = new SaveRequest <SkillActionViewModel[]>();
request.ViewModel = Actions;
this.ValidateSaveRequest(request);
SaveResponse response = new SaveResponse();
if (request.Messages.HasErrors)
{
response.Messages.AddMessages(request.Messages);
return(response);
}
SkillAction[] actionModels = ModelConverter.Convert <SkillActionViewModel, SkillAction>(Actions);
foreach (string skillName in skillNames)
{
await skillsActionService.DeleteAllForSkill(skillName);
}
response = await skillsActionService.Save(actionModels);
return(response);
}
private void IndexSave_Callback(string name, IndexDefinition entity, HttpJsonRequest request,
IAsyncResult result,
CallbackFunction.SaveOne<KeyValuePair<string, IndexDefinition>> callback)
{
SynchronizationContext context = GetContext(request);
DeleteContext(request);
HttpStatusCode statusCode;
Exception exception;
NameValueCollection headers;
string json = GetResponseStream(request.HttpWebRequest, result, out statusCode, out exception, out headers);
var saveResponse = new SaveResponse<KeyValuePair<string, IndexDefinition>>
{
Data = new KeyValuePair<string, IndexDefinition>(name, entity),
StatusCode = statusCode,
Exception = exception
};
context.Post(
delegate { callback.Invoke(saveResponse); },
null);
}
private void DocumentSave_Callback(JsonDocument document, HttpJsonRequest request, IAsyncResult result,
CallbackFunction.SaveMany<JsonDocument> callback)
{
SynchronizationContext context = GetContext(request);
DeleteContext(request);
HttpStatusCode statusCode;
Exception exception;
NameValueCollection headers;
string json = GetResponseStream(request.HttpWebRequest, result, out statusCode, out exception, out headers);
if (exception == null)
{
JObject responseJson = JObject.Parse(json);
document.Etag = new Guid(responseJson["ETag"].ToString().Replace("\"", string.Empty));
document.Key = responseJson["Key"].ToString().Replace("\"", string.Empty);
}
var saveResponse = new SaveResponse<JsonDocument>
{
Data = document,
StatusCode = statusCode,
Exception = exception
};
context.Post(
delegate { callback.Invoke(new List<Response<JsonDocument>> { saveResponse }); },
null);
}
private void AttachmentPut_Callback(string key, Guid? etag, byte[] data, JObject metadata,
HttpJsonRequest request, IAsyncResult result,
CallbackFunction.SaveMany<Attachment> callback)
{
SynchronizationContext context = GetContext(request);
DeleteContext(request);
HttpStatusCode statusCode;
Exception exception;
NameValueCollection headers;
string json = GetResponseStream(request.HttpWebRequest, result, out statusCode, out exception, out headers);
var saveResponse = new SaveResponse<Attachment>
{
Data = new Attachment
{
Data = data,
Metadata = metadata
},
StatusCode = statusCode,
Exception = exception
};
context.Post(
delegate { callback.Invoke(new List<Response<Attachment>> { saveResponse }); },
null);
}
