public JsonResult Save(string task)
{
try
{
var model = JSonConvertUtil.Deserialize <MyTaskViewModel>(task);
if (model == null)
{
return(null);
}
if (ApplicationUserCurrent.UserId == null)
{
ApplicationUserCurrent.UserId = Convert.ToString(Global.UserID);
ApplicationUserCurrent.AccountId = Global.AccountId;
ApplicationUserCurrent.ProfileId = Global.ProfileId;
ApplicationUserCurrent.PersonId = Global.PersonId;
}
_taskCampaignBusiness.SaveAnsweredPoll(model, ApplicationUserCurrent.AccountId, ApplicationUserCurrent.ProfileId, Guid.Parse(ApplicationUserCurrent.UserId), model.IdStatusTask, "");
return(Json("OK"));
}
catch (Exception e)
{
_logger.LogError(new EventId(0, "Error Index"), e.Message);
return(null);
}
}
public async void _SaveAnswerQuestionComplete(String _model, string Idtask)
{
int resp = 0;
var _task = JSonConvertUtil.Deserialize <MyTaskViewModel>(_model);
var _questionModel = new List <MyTaskQuestionsViewModel>();
var _questionModelSub = new List <MyTaskQuestionsViewModel>();
foreach (var _question in _task.ServiceCollection.First().ServiceDetailCollection)
{
_questionModel.AddRange(_question.QuestionCollection.Where(x => x.CodeTypePoll == "COMPLETE"));
}
foreach (var _question in _task.ServiceCollection.First().ServiceDetailCollection)
{
foreach (var _seccion in _question.Sections)
{
_questionModelSub.AddRange(_seccion.QuestionCollection.Where(x => x.CodeTypePoll == "COMPLETE"));
}
}
var _union = ((from a in _questionModel select a)
.Union
(from a in _questionModelSub select a)).ToList();
if (_union.Count() > 0)
{
_taskCampaignBusiness.CreateAnswerComplete(_union, Guid.Parse(Idtask), ApplicationUserCurrent.AccountId, Guid.Parse(ApplicationUserCurrent.UserId));
}
}
public TaskCampaign SaveTaskRegister(string inputTask, Guid idAccount)
{
TaskCampaign result;
var taskModelView = JSonConvertUtil.Deserialize <TaskRegisterModelView>(inputTask);
var task = new TaskCampaign()
{
IdAccount = idAccount,
IdBranch = taskModelView.IdBranch,
IdCampaign = taskModelView.IdCampaign,
IdMerchant = taskModelView.IdMerchant,
IdStatusTask = taskModelView.IdStatusTask,
Description = taskModelView.Description,
StartDate = taskModelView.StartDate,
Campaign = null,
Branch = null
};
if (taskModelView.IdStatusTask == Guid.Empty)
{
var status = _statusTaskBusiness.GeStatusTaskByName(CTask.StatusPending);
task.IdStatusTask = status.Id;
}
using (var transaccion = Context.Database.BeginTransaction())
{
try
{
if (string.IsNullOrEmpty(task.Code))
{
var nextSequence = _sequenceBusiness.NextSequence(CTask.SequenceCode,
idAccount);
task.Code = nextSequence.ToString();
}
var stateRegister = EntityState.Added;
if (Guid.Empty != task.Id)
{
stateRegister = EntityState.Modified;
}
Context.TaskCampaigns.Add(task);
Context.Entry(task).State = stateRegister;
//graba cambios en COntexto
Context.SaveChanges();
transaccion.Commit();
result = GetTaskByIdForRegisterPage(task.Id, idAccount);
}
catch
{
transaccion.Rollback();
result = null;
}
}
return(result);
}
public IActionResult Index(string filterValues, int pageSize = 15, int pageIndex = 1)
{
var filters = JSonConvertUtil.Deserialize <List <FilterValue> >(filterValues);
var viewModel = _customerBusiness.GetPaginatedCustomers(filters, pageSize, pageIndex, ApplicationUserCurrent.AccountId);
return(View(viewModel));
}
protected List <FilterValue> GetFilters(string filterValues, bool deleteFilter)
{
List <FilterValue> filters;
if (string.IsNullOrEmpty(filterValues))
{
SetSessionVariable("filter", "");
}
if (deleteFilter)
{
filters = JSonConvertUtil.Deserialize <List <FilterValue> >(filterValues);
}
else
{
var filter = JSonConvertUtil.Deserialize <FilterValue>(filterValues);
filters = JSonConvertUtil.Deserialize <List <FilterValue> >(GetSessionVariable("filter"));
if (filters == null)
{
filters = new List <FilterValue>();
}
if (filter != null)
{
filters.Add(filter);
}
}
SetSessionVariable("filter", JSonConvertUtil.Convert(filters));
return(filters);
}
public override bool Delete(string input)
{
var itemIds = JsonConvert.DeserializeObject <string[]>(input);
var campaignIds = itemIds.Select(i => Protector.Unprotect(i)).ToList();
var idTasks = "";
foreach (var tasks in itemIds.Select(item => _taskCampaignBusiness.GetAlltasksByCampaignId(new Guid(Protector.Unprotect(item)), ApplicationUserCurrent.AccountId)))
{
foreach (var tsk in tasks)
{
if ((idTasks.IndexOf(',') < 0) && (!(string.IsNullOrEmpty(idTasks))) ||
(idTasks.IndexOf(',') >= 0) && (!(string.IsNullOrEmpty(idTasks))))
{
idTasks += ",";
}
idTasks += "\"" + tsk.Id + "\"";
}
idTasks = "[" + idTasks + "]";
var idsTask = JsonConvert.DeserializeObject <string[]>(idTasks);
if (idsTask.Any())
{
_commonBusiness.DeleteId(CTask.TableName, idsTask);
}
}
return(base.Delete(JSonConvertUtil.Convert(campaignIds)));
}
public IActionResult SaveRegister(string branch, string returnUrl = null)
{
try
{
var model = JSonConvertUtil.Deserialize <BranchRegisterViewModel>(branch);
TryValidateModel(model);
if (!ModelState.IsValid)
{
return(null);
}
_branchBusiness.Save(model, ApplicationUserCurrent.AccountId);
if (string.IsNullOrEmpty(model.ReturnUrl))
{
return(RedirectToAction("Index"));
}
return(Redirect(model.ReturnUrl));
}
catch (Exception e)
{
_logger.LogError("Error al guardar datos de local: " + e.Message, null);
return(null);
}
}
public JsonResult DeleteAccounts(string selectedAccounts)
{
var results = JSonConvertUtil.Deserialize <string[]>(selectedAccounts);
_branchBusiness.DeleteAccounts(results);
return(Json("ok"));
}
public string GetResults()
{
Guid idAccount = ApplicationUserCurrent.AccountId;
var itemsResults = _bulkLoadBusiness.GetDataByAccount(idAccount);
return(JSonConvertUtil.Convert(itemsResults));
}
public string GetMerchantsByCampaign(Guid idCampaign)
{
var merchantsList = _userBusiness.GetMerchantsByCampaign(idCampaign, ApplicationUserCurrent.AccountId);
var resultList = ConvertDashBoard.ConvertUserListToDashBoardMerchantViewModelList(merchantsList);
return(JSonConvertUtil.Convert(resultList));
}
public string GetBranchesByCampaign(Guid idCampaign)
{
var taskList = _taskCampaignBusiness.GetTasksBranchesByCampaign(idCampaign, ApplicationUserCurrent.AccountId);
var resultList = ConvertTask.ConvertTaskListToCampaignBranchesViewModelList(taskList);
return(JSonConvertUtil.Convert(resultList));
}
public string GetCustomerProductList(string idCustomer)
{
idCustomer = idCustomer.Replace("\"", string.Empty);
return(JSonConvertUtil.Convert(
productBusiness.GetProductListByCustomer(
new Guid(idCustomer),
idAccount)));
}
public async Task <JsonResult> GuardarPredios(String ModelJson, String IdArea)
{
var user = await _userManager.GetUserAsync(User);
var _model = JSonConvertUtil.Deserialize <List <PredioViewModel> >(ModelJson);
_AreaProspeccionDAO.GuardarPredidios(_model, user.UserName, int.Parse(IdArea));
return(Json(""));
}
public string SaveBranch(string input)
{
Guid idAccount = ApplicationUserCurrent.AccountId;
Branch branch = JsonConvert.DeserializeObject <Branch>(input);
branch = _branchBusiness.SaveBranch(branch, idAccount);
return(JSonConvertUtil.Convert(branch));
}
public JsonResult AddSection(string task, string idSection)
{
var model = JSonConvertUtil.Deserialize <MyTaskViewModel>(task);
// _taskCampaignBusiness.AddSection(model, ApplicationUserCurrent.AccountId, ApplicationUserCurrent.ProfileId, Guid.Parse(ApplicationUserCurrent.UserId), Guid.Parse(idSection));
//model = _taskCampaignBusiness.GetSectionsPoll(model.IdTask, _idAccount,idSection);
//return RedirectToAction("Profile", new { idTask = model.IdTask });
return(Json(model));
}
public async Task <string> GetBranchProfile(string idBranch)
{
var branch = _branchBusiness.GetBranchCompleteProfile(new Guid(idBranch), ApplicationUserCurrent.AccountId);
var smslista = _smsBusiness.GetCampaignByIdSms(ApplicationUserCurrent.AccountId);
branch.BranchImages = await GetBranchImagesInBase64(branch.Id);
var itemReturn = ConvertBranch.ConvertBranchToBranchProfileViewModel(branch, smslista);
return(JSonConvertUtil.Convert(itemReturn));
}
public string DeleteImageBranch(Guid idImageBranch)
{
var imageBranch = _branchImageBusiness.GetBranchImageById(idImageBranch, ApplicationUserCurrent.AccountId);
AzureStorageUtil.DeleteBlob(CBranch.ImagesContainer, imageBranch.NameFile);
_branchImageBusiness.DeleteBranchImage(idImageBranch, ApplicationUserCurrent.AccountId);
var itemResult = _branchImageBusiness.GetBranchesImagesList(imageBranch.IdBranch, ApplicationUserCurrent.AccountId);
return(JSonConvertUtil.Convert(itemResult));
}
public IActionResult Localization(string input)
{
if (null != input)
{
string[] itemIds = JsonConvert.DeserializeObject <string[]>(input);
var locales = _branchBusiness.GetBranchesList(itemIds, ApplicationUserCurrent.AccountId);
ViewData[CBranch.ViewDataLocalizacion] = JSonConvertUtil.Convert(locales);
}
return(View());
}
public IActionResult Save(string service)
{
var model = JSonConvertUtil.Deserialize <ServiceRegisterViewModel>(service);
TryValidateModel(model);
if (!ModelState.IsValid)
{
return(null);
}
_serviceBusiness.Save(model, ApplicationUserCurrent.AccountId);
return(RedirectToAction("Index"));
}
public async Task <string> GetBranchById(string idBranch)
{
var itemReturn = new Branch();
if (!string.IsNullOrEmpty(idBranch))
{
itemReturn = _branchBusiness.GetOne(new Guid(idBranch), ApplicationUserCurrent.AccountId);
//inserto las imagenes en base 64 en el objeto
itemReturn.BranchImages = _branchImageBusiness.GetBranchesImagesList(Guid.Parse(idBranch), ApplicationUserCurrent.AccountId);
}
return(JSonConvertUtil.Convert(itemReturn));
}
public JsonResult Get(Guid idTask)
{
try
{
var model = _taskCampaignBusiness.GetSectionsPoll(idTask, _idAccount);
JSonConvertUtil.Convert(model);
return(Json(model));
}
catch (Exception e)
{
_logger.LogError(new EventId(0, "Error Index"), e.Message);
return(null);
}
}
public IActionResult SelectBranches()
{
try
{
var filters = JSonConvertUtil.Deserialize <List <FilterValue> >(GetSessionVariable("filter"));
var model = _campaignBusiness.GetBranchesSelected(ApplicationUserCurrent.AccountId, filters);
return(RedirectToAction("ImportBranches", model));
}
catch (Exception e)
{
_logger.LogError(new EventId(0, "Error Index"), e.Message);
return(RedirectToAction("Index", "StatusCode", new { statusCode = 1 }));
}
}
public string GetProductById(string idProduct)
{
var itemReturn = new Product();
if (!string.IsNullOrEmpty(idProduct))
{
itemReturn = productBusiness.GetProductById(
new Guid(idProduct));
}
var result = JSonConvertUtil.Convert(itemReturn);
return(result);
}
public JsonResult Save(string poll, string Comment)
{
try
{
var model = JSonConvertUtil.Deserialize <PedidoModel>(poll);
_pedidosBusiness.SavePedido(model, "");
return(Json(model));
}
catch (Exception ex)
{
_logger.LogError(new EventId(0, "Error Index"), ex.Message);
return(null);
}
}
public JsonResult GetPredio(String idPredio)
{
try
{
var model = _AreaProspeccionDAO.ObtenePredioId(int.Parse(idPredio));
var jsonModel = model;
JSonConvertUtil.Convert(jsonModel);
return(Json(jsonModel));
}
catch (Exception e)
{
return(null);
}
}
public JsonResult GetPropietario(String idPropietario)
{
try
{
var model = _AreaProspeccionDAO.ObtenePropietario(int.Parse(idPropietario));
JSonConvertUtil.Convert(model);
return(Json(model));
}
catch (Exception e)
{
return(null);
}
}
public string GetOneCustomer(string id)
{
var itemReturn = new Customer();
if (!String.IsNullOrEmpty(id))
{
itemReturn = _customerBusiness.GetOne(new Guid(id), ApplicationUserCurrent.AccountId);
}
else
{
itemReturn.DateCreation = DateTime.Now;
}
return(JSonConvertUtil.Convert(itemReturn));
}
public JsonResult GetGetPredio(String idPredio)
{
try
{
var model = _AreaProspeccionDAO.ObtenePredios(int.Parse(idPredio));
IList <PredioViewModel> _empyModel = new List <PredioViewModel>();
_empyModel.Add(EntyPredio());
var jsonModel = model != null ? model : _empyModel;
JSonConvertUtil.Convert(jsonModel);
return(Json(jsonModel));
}
catch (Exception e)
{
return(null);
}
}
public string SaveCampaign(Campaign campaign, string inputServices)
{
try
{
var idAccount = ApplicationUserCurrent.AccountId;
var itemServices = JsonConvert.DeserializeObject <List <ListCampaignServicesViewModel> >(inputServices);
campaign = _campaignBusiness.SaveCampaign(campaign, itemServices, idAccount);
return(JSonConvertUtil.Convert(campaign));
}
catch (Exception e)
{
_logger.LogError(new EventId(0, "Error Index"), e.Message);
return(null);
}
}
protected T ConfigurePagination <T>(T entity, int pageIndex, int pageSize, List <FilterValue> filterValues, int countTotal) where T : PaginatedList
{
entity.PageIndex = pageIndex;
entity.TotalPages = (int)Math.Ceiling(countTotal / (double)pageSize);
entity.PageSize = pageSize;
entity.Properties.FilterValues = filterValues ?? new List <FilterValue>();
entity.Properties.CurrentFilter = JSonConvertUtil.Convert(filterValues);
var filterResult = CoreFilterDao.GetCoreFilter(entity.FilterName);
if (filterResult != null)
{
entity.Properties.FilterList = CoreFilterDetailDao.GetCoreFilterDetails(filterResult.Id);
}
return(entity);
}
