public async Task <IHttpActionResult> Edit(PresupuestoVendedor model)
{
try
{
var result = new AjaxResult();
if (ModelState.IsValid)
{
db.Entry(model).State = EntityState.Modified;
await db.SaveChangesAsync();
AddLog("", model.PlantaID, model);
return(Ok(result.True("Record saved")));
}
else
{
//return InternalServerError(new Exception("Error, All field are required"));
string s = string.Join(" | ", ModelState.Values.SelectMany(v => v.Errors).Select(e => e.ErrorMessage));
return(Ok(result.False(s)));
}
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <IHttpActionResult> Delete(string id)
{
try
{
var result = new AjaxResult();
var tipoMov = await db.TipoMovimientos.FindAsync(id);
if (tipoMov == null)
{
return(NotFound());
}
var movimiento = await db.Movimiento.Where(g => g.TipoMovimientoID == id).ToListAsync();
if (movimiento.Count == 0)
{
db.TipoMovimientos.Remove(tipoMov);
await db.SaveChangesAsync();
AddLog("", tipoMov.TipoMovimientoID, tipoMov);
}
else
{
return(Ok(result.False("Type of movement is related with some records")));
}
return(Ok(result.True()));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <IHttpActionResult> Create(TipoMovimiento tipoMovimiento)
{
try
{
var result = new AjaxResult();
var tipoMovTemp = await db.TipoActividades.Where(u => u.TipoActividadID == tipoMovimiento.TipoMovimientoID).FirstOrDefaultAsync();
if (tipoMovTemp == null)
{
db.TipoMovimientos.Add(tipoMovimiento);
await db.SaveChangesAsync();
AddLog("", tipoMovimiento.TipoMovimientoID, tipoMovimiento);
}
else
{
return(Ok(result.False("Type of movements already exists")));
}
return(Ok(result.True()));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <IHttpActionResult> Create(Gasto model)
{
var result = new AjaxResult();
try
{
Controllers.Seguridad.Seguridad seguridad = new Controllers.Seguridad.Seguridad();
model.GastoId = seguridad.generaConsecutivo("Gastos");
model.GastoLinea = 1;
model.GastoFecha = DateTime.Today;
model.GastoFechaMod = DateTime.Today;
model.GastoValor = Decimal.Parse(model.GastoValor.ToString().Replace(".", ","));
if (ModelState.IsValid)
{
db.Gasto.Add(model);
await db.SaveChangesAsync();
AddLog("", model.GastoId, model);
return(Ok(result.True("Record saved")));
}
else
{
//return InternalServerError(new Exception("Error, All field are required"));
string s = string.Join(" | ", ModelState.Values.SelectMany(v => v.Errors).Select(e => e.ErrorMessage));
return(Ok(result.False(s)));
}
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <IHttpActionResult> Create(PresupuestoVendedor model)
{
try
{
var result = new AjaxResult();
if (ModelState.IsValid)
{
var presupuesto = await db.PresupuestoVendedor.Where(
p =>
p.PresupuestoVendedorAno == model.PresupuestoVendedorAno &&
p.PlantaID == model.PlantaID &&
p.CanalID == model.CanalID &&
p.CentroCostoID == model.CentroCostoID).FirstOrDefaultAsync();
if (presupuesto == null)
{
db.PresupuestoVendedor.Add(model);
await db.SaveChangesAsync();
AddLog("", model.PlantaID, model);
}
else
{
return(Ok(result.False("Warning, This Budget already exists")));
//return InternalServerError(new Exception("Warning, This Budget already exists"));
}
return(Ok(result.True("Record saved")));
}
else
{
//return InternalServerError(new Exception("Error, All field are required"));
string s = string.Join(" | ", ModelState.Values.SelectMany(v => v.Errors).Select(e => e.ErrorMessage));
return(Ok(result.False(s)));
}
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <IHttpActionResult> Create(Correos model)
{
try
{
var result = new AjaxResult();
if (ModelState.IsValid)
{
var correo = await db.Correos.Where(c => c.Mail.Contains(model.Mail))
.FirstOrDefaultAsync();
if (correo == null)
{
db.Correos.Add(model);
await db.SaveChangesAsync();
AddLog("", model.Id, model);
}
else
{
return(Ok(result.False("Warning, This e-Mail already exists")));
//return InternalServerError(new Exception("Warning, This Budget already exists"));
}
return(Ok(result.True("Record Saved")));
}
else
{
//return InternalServerError(new Exception("Error, All field are required"));
string s = string.Join(" | ", ModelState.Values.SelectMany(v => v.Errors).Select(e => e.ErrorMessage));
return(Ok(result.False(s)));
}
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <IHttpActionResult> Edit(Gasto model)
{
var result = new AjaxResult();
try
{
model.GastoValor = Decimal.Parse(model.GastoValor.ToString().Replace(".", ","));
if (ModelState.IsValid)
{
Controllers.Transacciones.GastosController GastosCtrl = new Controllers.Transacciones.GastosController();
if (model.ActividadId != null)
{
//Devuelve el Gasto
if (model.GastoEstado == EstadoGasto.Ejecutado || model.GastoEstado == EstadoGasto.Pagado)
{
GastosCtrl.AfectaPresupuestoXGasto(model.GastoId, 1);
// AfectaPresupuestoXGasto(model.GastoId, 1);
}
}
db.Entry(model).State = EntityState.Modified;
await db.SaveChangesAsync();
if (model.ActividadId != null)
{
//Afecta el gasto
if (model.GastoEstado == EstadoGasto.Ejecutado || model.GastoEstado == EstadoGasto.Pagado)
{
//AfectaPresupuestoXGasto(model.GastoId, 2);
GastosCtrl.AfectaPresupuestoXGasto(model.GastoId, 2);
}
}
AddLog("", model.GastoId, model);
return(Ok(result.True("Record saved")));
}
else
{
//return InternalServerError(new Exception("Error, All field are required"));
string s = string.Join(" | ", ModelState.Values.SelectMany(v => v.Errors).Select(e => e.ErrorMessage));
return(Ok(result.False(s)));
}
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <IHttpActionResult> SetComplete(int id)
{
var result = new AjaxResult();
var visita = await db.Visita.FindAsync(id);
if (visita == null)
{
return(Ok(result.False("Warning, Visit not found")));
}
if (!visita.Completada)
{
visita.Completada = true;
db.Entry(visita).State = EntityState.Modified;
await db.SaveChangesAsync();
#region SendMail
var usuarioJefe = await db.Usuarios.Include(u => u.UsuarioPadre).Where(u => u.UsuarioId == visita.UsuarioId).FirstOrDefaultAsync();
List <Mails> mails = new List <Mails>();
mails.Add(new Mails {
to = usuarioJefe.UsuarioPadre.UsuarioCorreo, toName = usuarioJefe.UsuarioPadre.UsuarioNombre
});
//mails.Add(new Mails { to = "*****@*****.**", toName = "KIKE" });
string subject = "AIS - ";
subject += $"Visit [{visita.Id} - {visita.NombreEstablecimiento}] has been completed )";
string msg = $"The user <b>{usuarioJefe.UsuarioNombre}</b> completed the visit";
string action = "Details";
msg += $"<br /><br /><a style='color:#22BCE5' href={{url}}/Visitas/{action}/{visita.Id}>Click here to view the Visit.</a>";
string appLink = Seguridadcll.Aplicacion.Link;
foreach (var m in mails)
{
Task.Run(() => Fn.SendHtmlEmail(m.to, m.toName, subject, msg, appLink));
}
#endregion
}
return(Ok(result.True("the visit has been completed")));
}
public async Task <IHttpActionResult> CambioEstado(int Id = 0, int Linea = 0, EstadoGasto Estado = EstadoGasto.Abierta)
{
var result = new AjaxResult();
//bool result = false;
var gasto = await db.Gasto.Where(g => g.GastoId == Id && g.GastoLinea == Linea).FirstOrDefaultAsync();
if (gasto != null)
{
gasto.GastoEstado = Estado;
db.Entry(gasto).State = EntityState.Modified;
await db.SaveChangesAsync();
//result = true;
AddLog("", gasto.GastoId, gasto);
}
else
{
return(Ok(result.False("Record not found")));
}
return(Ok(result.True("State change successful")));
}
public async Task <IHttpActionResult> ConfigStep(FlujoPQRSConfigViewModel model)
{
var result = new AjaxResult();
try
{
if (ModelState.IsValid)
{
#region Tareas
if (model.Tareas == null)
{
model.Tareas = new List <FlujoPQRSTareas>();
}
//Edit
foreach (var t in model.Tareas.Where(t => t.Id != 0))
{
db.Entry(t).State = EntityState.Modified;
await db.SaveChangesAsync();
}
var currentTareas = await db.FlujoPQRSTareas
.Where(ft => ft.MotivoPQRSId == model.Flujo.MotivoPQRSId && ft.FlujoPQRSId == model.Flujo.Id)
.ToListAsync();
var currentTareasId = currentTareas.Select(ct => ct.Id).ToArray();
var TareasId = model.Tareas.Where(t => t.Id != 0).Select(t => t.Id).ToArray();
var tareasToDelete = currentTareas.Where(ct => !TareasId.Contains(ct.Id)).ToList();
var tareasToAdd = model.Tareas.Where(t => t.Id == 0).ToList();
//Delete
if (tareasToDelete.Count > 0)
{
db.FlujoPQRSTareas.RemoveRange(tareasToDelete);
}
//Add
if (tareasToAdd.Count > 0)
{
db.FlujoPQRSTareas.AddRange(tareasToAdd);
}
await db.SaveChangesAsync();
//AddLog("", model.Flujo.Id, model);
#endregion Tareas
#region Condiciones
if (model.Flujo.Order > 3)
{
if (model.Condiciones == null)
{
model.Condiciones = new List <FlujoPQRSCondiciones>();
}
//Edit
foreach (var c in model.Condiciones.Where(c => c.Id != 0))
{
if (c.TipoCondicion == TipoCondicion.Value)
{
c.SiNo = false;
}
else
{
c.Valor = 0;
c.CondicionesValor = CondicionesValor.Equal;
}
db.Entry(c).State = EntityState.Modified;
await db.SaveChangesAsync();
}
var currentCondiciones = await db.FlujoPQRSCondiciones
.Where(ft => ft.MotivoPQRSId == model.Flujo.MotivoPQRSId && ft.FlujoPQRSId == model.Flujo.Id)
.ToListAsync();
var currentCondicionesId = currentCondiciones.Select(ct => ct.Id).ToArray();
var CondicionesId = model.Condiciones.Where(t => t.Id != 0).Select(t => t.Id).ToArray();
var CondicionesToDelete = currentCondiciones.Where(ct => !CondicionesId.Contains(ct.Id)).ToList();
var CondicionesToAdd = model.Condiciones.Where(t => t.Id == 0).ToList();
//Delete
if (CondicionesToDelete.Count > 0)
{
db.FlujoPQRSCondiciones.RemoveRange(CondicionesToDelete);
}
//Add
if (CondicionesToAdd.Count > 0)
{
db.FlujoPQRSCondiciones.AddRange(CondicionesToAdd);
}
await db.SaveChangesAsync();
AddLog("", model.Flujo.Id, model);
}
#endregion Condiciones
}
else
{
return(Ok(result.False("All fields are required.")));
}
return(Ok(result.True()));
// return Ok(model);
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <IHttpActionResult> Duplicar(int id)
{
try
{
AjaxResult result = new AjaxResult();
var actividad = await db.Actividad.FindAsync(id);
if (actividad == null)
{
return(Ok(result.False("Actividad no encontrada")));
}
var actividadNew = new Actividad();
actividadNew = actividad;
actividadNew.ActividadCuenta = actividad.ActividadCuenta;
actividadNew.ActividadDesc = actividad.ActividadDesc;
actividadNew.ActividadObjetivo = actividad.ActividadObjetivo;
actividadNew.ActividadFechaAprob = DateTime.Now;
actividadNew.ActividadFechaDesde = DateTime.Now.AddDays(1);
actividadNew.ActividadFechaHasta = DateTime.Now.AddDays(2);
actividadNew.ActividadMetaV = actividad.ActividadMetaV;
actividadNew.ActividadMetaE = actividad.ActividadMetaE;
actividadNew.ActividadUltimoItem = actividad.ActividadUltimoItem;
actividadNew.UsuarioIdElabora = actividad.UsuarioIdElabora;
actividadNew.CanalID = actividad.CanalID;
actividadNew.PlantaID = actividad.PlantaID;
actividadNew.GastoId = actividad.GastoId;
actividadNew.TipoActividadID = actividad.TipoActividadID;
actividadNew.ClienteID = actividad.ClienteID;
actividadNew.ActividadLugarEnvioPOP = actividad.ActividadLugarEnvioPOP;
actividadNew.Marcas = actividad.Marcas;
actividadNew.ActividadEstado = EstadosActividades.Abierto;
actividadNew.ActividadFecha = DateTime.Now;
actividadNew.ActividadFechaMod = DateTime.Now;
actividadNew.ActividadTitulo = "Copia " + actividad.ActividadTitulo;
actividadNew.CumplimientoTotal = 0;
actividadNew.CumplimientoPorcentaje = 0;
actividadNew.Resultado = "";
actividadNew.EstadoCierre = EstadoCierreActividad.No_Cumplio;
db.Actividad.Add(actividadNew);
await db.SaveChangesAsync();
var items = await db.ActividadItem.Where(ai => ai.ActividadId == id).ToListAsync();
foreach (var item in items)
{
var itemNew = new ActividadItem();
itemNew.ActividadId = actividadNew.ActividadId;
itemNew.ActividadItemCantidad = item.ActividadItemCantidad;
itemNew.ActividadItemProducto = item.ActividadItemProducto;
itemNew.ActividadItemPrecio = item.ActividadItemPrecio;
itemNew.ActividadItemDescripcion = item.ActividadItemDescripcion;
itemNew.ProductoId = item.ProductoId;
itemNew.CentroCostoID = item.CentroCostoID;
db.ActividadItem.Add(itemNew);
}
await db.SaveChangesAsync();
AddLog("", actividadNew.ActividadId, actividadNew);
return(Ok(result.True("Actividad duplicada #: " + actividadNew.ActividadId)));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <IHttpActionResult> Upload(int mes, int ano)
{
string filePath = "";
try
{
var result = new AjaxResult();
var httpRequest = HttpContext.Current.Request;
if (httpRequest.Files.Count != 1)
{
return(BadRequest("File not given"));
}
var postedFile = httpRequest.Files[0];
var date = DateTime.Now;
filePath = HttpContext.Current.Server.MapPath($"~/UploadFolder/PIV_StockFile_{Seguridadcll.Usuario.UsuarioId}_{date.Year}{date.Month}{date.Day}{date.Hour}{date.Minute}{date.Second}{date.Millisecond}_{Path.GetExtension(postedFile.FileName)}");
postedFile.SaveAs(filePath);
var excel = new ExcelQueryFactory(filePath);
if (!excel.GetWorksheetNames().Any(s => s == "Formato"))
{
return(Ok(result.False("Incorrect given File")));
}
var rows = (from r in excel.WorksheetRange <StockRow>("B6", "D16384", "Formato")
select r).ToList();
var allErrors = new List <string>();
var clientesCache = new Dictionary <string, int>();
var codigos = new List <CodigoUnico>();
var disponibilidadArchivoItems = new List <DisponibilidadArchivoItem>();
for (int i = 0; i < rows.Count; i++)
{
var row = rows[i];
if (string.IsNullOrWhiteSpace(row.Cliente) && string.IsNullOrWhiteSpace(row.Codigo) && row.Cantidad == 0)
{
continue; // omitir linea en blanco
}
int line = i + 7;
var errors = new List <string>();
int coleccionPIVId = 0, itemId = 0, cantidad = 0;
if (string.IsNullOrWhiteSpace(row.Cliente))
{
AddValidationError(errors, $"Field {FileFields.Cliente} is required", line);
}
else
{
string clienteId = row.Cliente.Trim();
coleccionPIVId = clientesCache.Where(c => c.Key == clienteId).Select(c => c.Value).FirstOrDefault();
if (coleccionPIVId == 0)
{
var clienteData = await db.Clientes.Where(c => c.ClienteID == clienteId).Select(c => new
{
c.ClienteID,
c.ColeccionPIVId
}).FirstOrDefaultAsync();
if (clienteData != null)
{
if (clienteData.ColeccionPIVId == null)
{
coleccionPIVId = -1;
}
else
{
clientesCache.Add(clienteData.ClienteID, (int)clienteData.ColeccionPIVId);
coleccionPIVId = (int)clienteData.ColeccionPIVId;
}
}
}
if (coleccionPIVId == 0)
{
AddValidationError(errors, $"The Customer with ID '{clienteId}' does not exist", line);
}
else if (coleccionPIVId == -1)
{
AddValidationError(errors, $"The Customer with ID '{clienteId}' does not belong to any PIP Collection", line);
}
}
if (string.IsNullOrWhiteSpace(row.Codigo))
{
AddValidationError(errors, $"Field {FileFields.Codigo} is required", line);
}
else
{
string codigo = row.Codigo.Trim();
if (codigos.Any(c => c.ColeccionPIVId == coleccionPIVId && c.Codigo.ToLower() == codigo.ToLower()))
{
AddValidationError(errors, $"The Item with Code '{codigo}' and Customer Id '{row.Cliente.Trim()}' is duplicated", line);
}
else
{
itemId = await db.Item.Where(it => it.Codigo == codigo).Select(it => it.Id).FirstOrDefaultAsync();
if (itemId == 0)
{
AddValidationError(errors, $"The Item with Code '{codigo}' does not exist", line);
}
else
{
codigos.Add(new CodigoUnico
{
ColeccionPIVId = coleccionPIVId,
Codigo = codigo
});
}
}
}
if (row.Cantidad == 0 || row.Cantidad < 1)
{
AddValidationError(errors, $"Field {FileFields.Cantidad} must be a Number grather than 0", line);
}
else
{
cantidad = row.Cantidad;
}
if (errors.Count == 0)
{
var itemDisponibilidad = await db.ItemDisponibilidad.Where(d => d.ColeccionPIVId == coleccionPIVId && d.ItemId == itemId).FirstOrDefaultAsync();
if (itemDisponibilidad == null)
{
itemDisponibilidad = new ItemDisponibilidad()
{
ColeccionPIVId = coleccionPIVId,
ItemId = itemId,
Cantidad = cantidad
};
db.ItemDisponibilidad.Add(itemDisponibilidad);
}
else
{
itemDisponibilidad.Cantidad += cantidad;
db.Entry(itemDisponibilidad).State = EntityState.Modified;
}
disponibilidadArchivoItems.Add(new DisponibilidadArchivoItem
{
ColeccionPIVId = coleccionPIVId,
ItemId = itemId,
Cantidad = cantidad
});
}
else
{
allErrors.AddRange(errors);
}
}
if (allErrors.Count > 0)
{
return(Ok(result.False("validation", allErrors)));
}
var disponibilidadArchivo = new DisponibilidadArchivo
{
FechaSubida = DateTime.Now,
UsuarioId = Seguridadcll.Usuario.UsuarioId,
DisponibilidadArchivoItems = disponibilidadArchivoItems,
Ano = ano,
Mes = mes
};
db.DisponibilidadArchivo.Add(disponibilidadArchivo);
await db.SaveChangesAsync();
AddLog("", "", new { DisponibilidadArchivo = disponibilidadArchivo, DisponibilidadArchivoItems = disponibilidadArchivoItems });
return(Ok(result.True()));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
finally
{
if (File.Exists(filePath))
{
File.Delete(filePath);
}
}
}
public async Task <JsonResult> AddAnswer(AddCommentViewModel model)
{
var result = new AjaxResult();
if (ModelState.IsValid)
{
#region ValidaCheckList
//var tareas = await db.PQRSRecordTareas.Where(pt => pt.PQRSRecordId == model.PQRSRecordId && pt.PQRSRecordOrder == model.PQRSRecordOrder).ToListAsync();
if (model.TipoComentario == TipoComentario.Approval)
{
if (model.Tareas == null)
{
model.Tareas = new List <PQRSRecordTareas>();
}
bool flagTareas = true;
string msgTareas = "";
foreach (var t in model.Tareas)
{
if (t.Requerido && !t.Terminado)
{
flagTareas = false;
msgTareas += $" Task: '{t.Descripcion}' is required to advance" + System.Environment.NewLine;
}
}
if (!flagTareas)
{
return(Json(result.False(msgTareas), JsonRequestBehavior.AllowGet));
}
}
#endregion
// Crear Comment (primer paso Success)
PQRSRecordComentario nPQRSComment = new PQRSRecordComentario();
nPQRSComment.PQRSRecordId = model.PQRSRecordId;
nPQRSComment.PQRSRecordOrder = model.PQRSRecordOrder;
nPQRSComment.UsuarioId = Seguridadcll.Usuario.UsuarioId;
nPQRSComment.FechaCreacion = DateTime.Now;
nPQRSComment.Comentario = model.Comment;
nPQRSComment.TipoComentario = model.TipoComentario;
db.PQRSRecordComentarios.Add(nPQRSComment);
await db.SaveChangesAsync();
AddLog("PQRS/AddAnswer", nPQRSComment.Id, nPQRSComment);
if (model.PQRSRecordDocumentos != null)
{
await SaveDocuments(nPQRSComment.Id, model.PQRSRecordDocumentos);
}
if (model.Files != null)
{
await UploadFiles(nPQRSComment.Id, model.Files);
}
if (model.Tareas != null)
{
await SaveCheckList(model.Tareas);
}
if (model.Condiciones != null)
{
foreach (var c in model.Condiciones)
{
await SaveConditions(c.Condiciones);
}
}
//Users in step
var usuarioStep = await db.PQRSRecordUsuarios
.Where(pu => pu.PQRSRecordId == model.PQRSRecordId && pu.PQRSRecordOrder == model.PQRSRecordOrder && pu.UsuarioId == Seguridadcll.Usuario.UsuarioId)
.FirstOrDefaultAsync();
if (usuarioStep != null)
{
if (model.TipoComentario == TipoComentario.Approval)
{
//usuarioStep.EstadoUsuarioFlujoPQRS = EstadoUsuarioFlujoPQRS.Approved;
usuarioStep.EstadoUsuarioFlujoPQRS = EstadoUsuarioFlujoPQRS.Done;
}
else if (model.TipoComentario == TipoComentario.Rejection)
{
//usuarioStep.EstadoUsuarioFlujoPQRS = EstadoUsuarioFlujoPQRS.Rejected;
usuarioStep.EstadoUsuarioFlujoPQRS = EstadoUsuarioFlujoPQRS.Returned;
}
else if (model.TipoComentario == TipoComentario.Close)
{
usuarioStep.EstadoUsuarioFlujoPQRS = EstadoUsuarioFlujoPQRS.Closed;
}
db.Entry(usuarioStep).State = EntityState.Modified;
await db.SaveChangesAsync();
}
API.PQRSController ApiPQRS = new API.PQRSController();
if (model.TipoComentario == TipoComentario.Close)
{
await ApiPQRS.CloseFlow(model.TipoComentario, model.PQRSRecordId, model.PQRSRecordOrder);
//Notificación Close Flow
ApiPQRS.SendNotificationEmailTask(API.PQRSController.TipoNotificacion.Close, model.TipoComentario, model.TipoPQRS, model.PQRSRecordId, model.PQRSRecordOrder, model.DataId, nPQRSComment.Id, Seguridadcll.Usuario.UsuarioNombre, Seguridadcll.Aplicacion.Link);
}
else
{
await ApiPQRS.ChangeStep(model.TipoComentario, model.PQRSRecordId, model.PQRSRecordOrder, model.DataId, model.TipoPQRS);
//Notificación Current Step
ApiPQRS.SendNotificationEmailTask(API.PQRSController.TipoNotificacion.CurrentStep, model.TipoComentario, model.TipoPQRS, model.PQRSRecordId, model.PQRSRecordOrder, model.DataId, nPQRSComment.Id, Seguridadcll.Usuario.UsuarioNombre, Seguridadcll.Aplicacion.Link);
}
await ApiPQRS.CompleteFormat(model.TipoPQRS, model.DataId);
}
else
{
return(Json(result.False("All fields are required."), JsonRequestBehavior.AllowGet));
}
return(Json(result.True(), JsonRequestBehavior.AllowGet));
}
