/// <summary>
/// Busqueda de Tarifas Locales
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public ResponseBusquedaTarifaLocal BusquedaTarifaLocal(RequestBusquedaTarifaLocalViewModel request)
{
var responseTarifaPlana = new ResponseBusquedaTarifaLocal();
try
{
var requestAgente = new RequestBusquedaTarifaLocal
{
CodigoLinea = request.filtro.CodigoLinea,
DescripcionTarifa = request.filtro.DescripcionTarifa,
CodigoSucursal = request.filtro.CodigoSucursal,
CodigoTerminalPortuario = request.filtro.CodigoTerminalPortuario,
FlagTarifaLigada = request.filtro.FlagTarifaLigada,
FechaVigencia = request.filtro.FechaVigencia,
NroRegistrosPorPagina = request.paginacionDTO.rows,
OrdenCampo = request.paginacionDTO.sord,
OrdenOrientacion = request.paginacionDTO.sidx,
PaginaActual = request.paginacionDTO.page
};
responseTarifaPlana = new TransmisionesProxyrest().BusquedaTarifaLocal(requestAgente);
}
catch (Exception ex)
{
responseTarifaPlana.Result = new Result {
Satisfactorio = false
};
ManejadorExcepciones.PublicarExcepcion(ex, PoliticaExcepcion.AgenteServicios);
}
return(responseTarifaPlana);
}
public ConsultarSolicitudResponseDTO ConsultarSolicitud(ConsultarSolicitudRequestDTO req)
{
ConsultarSolicitudResponseDTO response = new ConsultarSolicitudResponseDTO();
try
{
List <SolicitudDTO> lista_solicitud = new List <SolicitudDTO>();
var contextoParaBaseDatos = new ContextoParaBaseDatos(ConstantesDB.Petcenterdb);
var repo = new RepositorioSolicitud(contextoParaBaseDatos);
int totalRegistros, cantPaginas;
lista_solicitud = repo.ConsultarSolicitud(req, out totalRegistros, out cantPaginas);
response.SolicitudList = lista_solicitud;
response.TotalRegistros = totalRegistros;
response.CantidadPaginas = cantPaginas;
}
catch (Exception e)
{
response.Result = new Result {
IdError = Guid.NewGuid(), Satisfactorio = false, Mensaje = "Ocurrio un problema interno en el servicio"
};
ManejadorExcepciones.PublicarExcepcion(e, PoliticaExcepcion.LogicaNegocio);
}
return(response);
}
public ConsultarActividadResponseDTO ConsultarActividad(ConsultarActividadesRequestDTO request)
{
ConsultarActividadResponseDTO result = new ConsultarActividadResponseDTO();
List <Actividad> lstDatos = new List <Actividad>();
try
{
string keyCache = Convert.ToString(KeyCache.Sede);
//ManejadorCache manejadorCache = new ManejadorCache();
//lstDatos = manejadorCache.ObtenerValorCache<List<Actividad >>(keyCache);
//if (lstDatos == null || lstDatos.Count == 0)
//{
var contextoParaBaseDatos = new ContextoParaBaseDatos(ConstantesDB.Petcenterdb);
var repo = new RepositorioActividad(contextoParaBaseDatos);
lstDatos = repo.ConsultarActividad(request);
//}
result.ActividadList = (from Origen in lstDatos
select Helper.MiMapper <Actividad, ActividadDTO>(Origen)).ToList();
}
catch (Exception ex)
{
ManejadorExcepciones.PublicarExcepcion(ex, PoliticaExcepcion.LogicaNegocio);
}
return(result);
}
public async Task <ActionResult> Login(LoginViewModel model, string returnUrl)
{
try
{
if (ModelState.IsValid)
{
var user = LoginCmd.Execute(model.UserName, model.Password);
if (user != null)
{
FormsAuthentication.SetAuthCookie(user.Identity.Name, false);
if (ControllerContext.HttpContext.Session != null)
{
ControllerContext.HttpContext.Session["user"] = model.UserName;
}
//System.Web.HttpContext.Current.User =new System.Security.Principal.GenericPrincipal()
FormsAuthentication.RedirectFromLoginPage(model.UserName, false);
return(RedirectToLocal("~/JusHome/Index"));
}
}
model.ShowMessage = true;
return(View("Login", model));
}
catch (Exception ex)
{
ModelState.AddModelError("", ManejadorExcepciones.GetMensaje(ex));
//Flash.Error();
}
return(null);
//return System.Web.UI.WebControls.View(model);
}
public ParametroNegocio ObtenerParametroNegocio(string codigo)
{
List <ParametroNegocio> lstParametrosNegocio = new List <ParametroNegocio>();
ParametroNegocio parametroNegocio = new ParametroNegocio();
try
{
string keyCache = Convert.ToString(KeyCache.ParametrosNegocio);
ManejadorCache manejadorCache = new ManejadorCache();
lstParametrosNegocio = manejadorCache.ObtenerValorCache <List <ParametroNegocio> >(keyCache);
if (lstParametrosNegocio == null || lstParametrosNegocio.Count == 0)
{
var contextoParaBaseDatos = new ContextoParaBaseDatos(ConstantesDB.AcuerdoComercialAGMADB);
var repo = new RepositorioAcuerdoComercial(contextoParaBaseDatos);
lstParametrosNegocio = repo.ObtenerParametrosNegocio();
manejadorCache.InsertarValorCache(keyCache, lstParametrosNegocio);
}
if (lstParametrosNegocio.Count > 0)
{
parametroNegocio = lstParametrosNegocio.Where(x => x.Codigo == codigo).FirstOrDefault();
}
}
catch (Exception ex)
{
ManejadorExcepciones.PublicarExcepcion(ex, PoliticaExcepcion.LogicaNegocio);
}
return(parametroNegocio);
}
public async Task <ActionResult> Reseteo(int id, FormCollection formCollection)
{
try
{
if (ModelState.IsValid)
{
var usuarioService = Service as IUsuarioService;
var loginResult = await usuarioService.ResetPassword(id);
if (loginResult.Result == LoginResultType.Success)
{
return(new JsonResult
{
Data = new { success = true }
});
}
ModelState.AddModelError("", loginResult.Result.ToString());
}
}
catch (Exception ex)
{
var result = ManejadorExcepciones.HandleException(ex);
ModelState.AddModelError("", result.Message);
}
return(new JsonResult
{
Data = new { success = false, errors = ModelState.ToSerializedDictionary() }
});
}
public override async Task <ActionResult> Create(CrearUsuarioDto modelo, FormCollection formCollection)
{
try
{
if (ModelState.IsValid)
{
var usuarioDto = await Service.InsertOrUpdateAsync(modelo);
return(RedirectToAction("Index", new { msg = "Proceso guardado exitosamente", TipoMensaje = TipoMensaje.Correcto }));
}
}
catch (Exception ex)
{
var result = ManejadorExcepciones.HandleException(ex);
ModelState.AddModelError("", result.Message);
}
var modelView = new CrearUsuarioViewModel();
modelView.Roles = new ReadOnlyCollection <RolDto>(await RolService.GetAll());
modelView.Modulos = new ReadOnlyCollection <ModuloDto>(await ModuloService.GetAll());
modelView.Model = modelo;
return(View(modelView));
}
public virtual ActionResult DeleteConfirmed(int id)
{
try
{
var entity = EntityService.Get(id);
if (entity == null)
{
var msg = string.Format("El Registro de {0} con identificacion {1} no existe, o sus datos asociados no existen",
typeof(Entity).GetDescription(), id);
return(HttpNotFound(msg));
}
//Verificar si se puede eliminar.
var check = CanRemoved(entity);
if (check.Item1)
{
EntityService.Eliminar(id);
return(RedirectToAction("Index", new { msg = "Proceso guardado exitosamente", TipoMensaje = TipoMensaje.Correcto }));
}
return(RedirectToAction("Index", new { msg = string.Format("El registro no se puede eliminar : {0}", check.Item2), TipoMensaje = TipoMensaje.Error }));
}
catch (Exception ex)
{
var result = ManejadorExcepciones.HandleException(ex);
return(RedirectToAction("Index", new { msg = result.Message, TipoMensaje = TipoMensaje.Error }));
}
}
public ResponseActualizarNotificacion ActualizarNotificacionIntegracion(RequestActualizaNotificacionIntegracionViewModel request)
{
var responseData = new ResponseActualizarNotificacion();
try
{
ActualizaNotificacionIntegracionRequestDTO requestAgente = new ActualizaNotificacionIntegracionRequestDTO();
requestAgente.CodigoLinea = request.CodigoLinea;
requestAgente.CodigoNotificacion = request.CodigoNotificacion;
requestAgente.ConCopia = request.ConCopia;
requestAgente.Destinatario = request.Destinatario;
requestAgente.Asunto = request.Asunto;
requestAgente.Nombre = request.Nombre;
requestAgente.Cuerpo = HttpUtility.UrlDecode(request.DetalleCorreo); //request.DetalleCorreo;
requestAgente.EstadoRegistro = request.EstadoRegistro;
requestAgente.UsuarioActualizacion = request.UsuarioActualizacion;
requestAgente.FechaHoraActualizacion = request.FechaHoraActualizacion;
responseData = new TransmisionesProxyrest().ActualizarNotificacionIntegracion(requestAgente);
}
catch (Exception ex)
{
responseData.Result = new Result {
Satisfactorio = false
};
ManejadorExcepciones.PublicarExcepcion(ex, PoliticaExcepcion.AgenteServicios);
}
return(responseData);
}
/// <summary>
/// Lista Terminal Portuario
/// </summary>
/// <returns></returns>
public ResponseListarTerminalPortuario ListarTerminalPortuario()
{
ResponseListarTerminalPortuario responseListarTerminalPortuario = new ResponseListarTerminalPortuario();
try
{
var clases = new List <ListaTerminalPortuarioDTO>();
var manejadorCache = new ManejadorCache();
var keyCache = Convert.ToString(KeyCache.TerminalPortuario);
clases = manejadorCache.ObtenerValorCache <List <ListaTerminalPortuarioDTO> >(keyCache);
if (clases == null || clases.Count == 0)
{
responseListarTerminalPortuario = (new TransmisionesProxyrest()).ListarTerminalPortuario();
manejadorCache.InsertarValorCache(keyCache, responseListarTerminalPortuario.TerminalPortuarioList);
}
else
{
responseListarTerminalPortuario.TerminalPortuarioList = clases;
}
responseListarTerminalPortuario.Result = new GR.Comun.DTO.Result();
responseListarTerminalPortuario.Result.Satisfactorio = true;
}
catch (Exception ex)
{
responseListarTerminalPortuario.Result = new GR.Comun.DTO.Result();
responseListarTerminalPortuario.Result.Satisfactorio = false;
ManejadorExcepciones.PublicarExcepcion(ex, PoliticaExcepcion.AgenteServicios);
}
return(responseListarTerminalPortuario);
}
//[ValidateAntiForgeryToken]
public JsonResult Create(Catalogo catalogo)
{
try
{
catalogo.SistemaId = _application.GetCurrentSistema().Id;
foreach (var item in catalogo.Items)
{
item.CodigoCatalogo = catalogo.Codigo;
item.Estado = true;
}
_catalogoService.Guardar(catalogo, new List <ItemCatalogo>());
var catalogoVista = new
{
catalogo.Id,
catalogo.Codigo,
catalogo.Nombre,
catalogo.Descripcion,
catalogo.FechaCreacion,
Items = getItems(catalogo.Items)
};
var result = new JsonResult
{
Data = catalogoVista,
JsonRequestBehavior = JsonRequestBehavior.AllowGet
};
return(result);
}
catch (Exception ex)
{
var result = ManejadorExcepciones.HandleException(ex);
return(StatusResponseHelper.JsonErrorServidor(result.Message, true));
}
}
/// <summary>
/// Busqueda de naves
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public ResponseBusquedaNave ListarNave(RequestBusquedaNaveViewModel request)
{
var responseListarNave = new ResponseBusquedaNave();
try
{
var requestAgente = new RequestConsultaNave
{
Codigo = request.filtro.Codigo,
Nombre = request.filtro.Nombre,
NumeroViaje = request.filtro.NumeroViaje,
NroRegistrosPorPagina = request.paginacionDTO.rows,
OrdenCampo = request.paginacionDTO.sord,
OrdenOrientacion = request.paginacionDTO.sidx,
PaginaActual = request.paginacionDTO.page
};
responseListarNave = new TransmisionesProxyrest().ListarNave(requestAgente);
}
catch (Exception ex)
{
responseListarNave.Result = new Result {
Satisfactorio = false
};
ManejadorExcepciones.PublicarExcepcion(ex, PoliticaExcepcion.AgenteServicios);
}
return(responseListarNave);
}
/// <summary>
/// Lista tarifa
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public ResponseBusquedaTarifa ListarTarifa(RequestBusquedaTarifaViewModel request)
{
var responseListarTarifa = new ResponseBusquedaTarifa();
try
{
var requestAgente = new RequestConsultaTarifa
{
CodigoRegimen = request.filtro.CodigoRegimen,
CodigoConcepto = request.filtro.CodigoConcepto,
CodigoTarifa = request.filtro.CodigoTarifa,
DescripcionTarifa = request.filtro.DescripcionTarifa,
CodigoLinea = request.filtro.CodigoLinea,
NroRegistrosPorPagina = request.paginacionDTO.rows,
OrdenCampo = request.paginacionDTO.sord,
OrdenOrientacion = request.paginacionDTO.sidx,
PaginaActual = request.paginacionDTO.page
};
responseListarTarifa = new TransmisionesProxyrest().ListarTarifa(requestAgente);
}
catch (Exception ex)
{
responseListarTarifa.Result = new Result {
Satisfactorio = false
};
ManejadorExcepciones.PublicarExcepcion(ex, PoliticaExcepcion.AgenteServicios);
}
return(responseListarTarifa);
}
/// <summary>
/// Registro de Tarifas Locales
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public ResponseRegistrarTarifaLocal RegistroTarifaLocal(RequestRegistrarTarifaLocal request)
{
var responseRegistroTarifa = new ResponseRegistrarTarifaLocal();
try
{
//var requestAgente = new RequestRegistrarTarifaLocal
//{
// CodigoLinea = request.filtro.CodigoLinea,
// DescripcionTarifa = request.filtro.DescripcionTarifa,
// Codigo = request.filtro.Codigo,
// CodigoAlmacen = request.filtro.CodigoAlmacen,
// FlagTarifaLigada = request.filtro.FlagTarifaLigada,
// FechaVigencia = request.filtro.FechaVigencia,
// NroRegistrosPorPagina = request.paginacionDTO.rows,
// OrdenCampo = request.paginacionDTO.sord,
// OrdenOrientacion = request.paginacionDTO.sidx,
// PaginaActual = request.paginacionDTO.page
//};
responseRegistroTarifa = new TransmisionesProxyrest().RegistroTarifaLocal(request);
}
catch (Exception ex)
{
responseRegistroTarifa.Result = new Result {
Satisfactorio = false
};
ManejadorExcepciones.PublicarExcepcion(ex, PoliticaExcepcion.AgenteServicios);
}
return(responseRegistroTarifa);
}
public async Task <ActionResult> MyInfoSave(MyUsuarioDto modelo, FormCollection formCollection)
{
try
{
if (ModelState.IsValid)
{
var usuarioService = Service as IUsuarioService;
var usuarioDto = await usuarioService.Update(modelo);
return(new JsonResult
{
Data = new { success = true }
});
}
}
catch (Exception ex)
{
var result = ManejadorExcepciones.HandleException(ex);
ModelState.AddModelError("", result.Message);
}
return(new JsonResult
{
Data = new { success = false, errors = ModelState.ToSerializedDictionary() }
});
}
public Result LimpiarCache()
{
var oResult = new Result();
try
{
foreach (var value in Enum.GetValues(typeof(KeyCache)))
{
ManejadorCache manejadorCache = new ManejadorCache();
manejadorCache.EliminarValorCache(value.ToString());
oResult.Mensajes.Add(new Result()
{
Mensaje = value.ToString()
});
}
oResult.Satisfactorio = true;
oResult.Mensaje = "El caché se ha limpiado correctamente. Revise la lista de mensajes donde figura las variables eliminadas.";
return(oResult);
}
catch (ResultException ex)
{
ManejadorExcepciones.PublicarExcepcion(string.Format("{0}: {1}", MethodBase.GetCurrentMethod().Name, ex.Result.Mensaje));
oResult.Satisfactorio = false;
oResult.Mensaje = "Ocurrio un problema interno en el servicio";
}
catch (Exception ex)
{
ManejadorExcepciones.PublicarExcepcion(ex, PoliticaExcepcion.ServicioWCF);
oResult.Satisfactorio = false;
oResult.Mensaje = "Ocurrio un problema interno en el servicio";
}
return(oResult);
}
public async Task <ActionResult> MyChangePasswordSave(ChangeMyPasswordViewModel modelo, FormCollection formCollection)
{
try
{
if (ModelState.IsValid)
{
var usuarioService = Service as IUsuarioService;
var loginResult = await usuarioService.ChangePassword(modelo.PasswordCurrent, modelo.Password);
if (loginResult.Succeeded)
{
return(new JsonResult
{
Data = new { success = true }
});
}
ModelState.AddModelError("", string.Join(", ", loginResult.Errors));
}
}
catch (Exception ex)
{
var result = ManejadorExcepciones.HandleException(ex);
ModelState.AddModelError("", result.Message);
}
return(new JsonResult
{
Data = new { success = false, errors = ModelState.ToSerializedDictionary() }
});
}
public ConsultarTipoMantenimientoResponseDTO ConsultarTipoMantenimiento()
{
ConsultarTipoMantenimientoResponseDTO response = new ConsultarTipoMantenimientoResponseDTO();
try
{
MaestrosBL maestrosBL = new MaestrosBL();
response = maestrosBL.ConsultarTipoMantenimiento();
return(response);
}
catch (ResultException ex)
{
ManejadorExcepciones.PublicarExcepcion(string.Format("{0}: {1}", MethodBase.GetCurrentMethod().Name, ex.Result.Mensaje));
ex.Result.Satisfactorio = false;
response.Result = ex.Result;
return(response);
}
catch (Exception ex)
{
ManejadorExcepciones.PublicarExcepcion(ex, PoliticaExcepcion.ServicioWCF);
response.Result = new Result {
Satisfactorio = false, Mensaje = "Ocurrio un problema interno en el servicio", IdError = Guid.NewGuid()
};
return(response);
}
}
public async Task <ActionResult> GetExternal(string userName)
{
try
{
if (ModelState.IsValid)
{
var externalUser = UserExternalSouce.GetUser(userName);
if (externalUser != null)
{
return(new JsonResult
{
Data = new { success = true, user = externalUser }
});
}
else
{
return(new JsonResult
{
Data = new { success = false, error = string.Format("Usuario {0} no existe", userName) }
});
}
}
}
catch (Exception ex)
{
var result = ManejadorExcepciones.HandleException(ex);
ModelState.AddModelError("", result.Message);
}
return(new JsonResult
{
Data = new { success = false, errors = ModelState.ToSerializedDictionary() }
});
}
public JsonResult Create(Menu entidad)
{
try
{
entidad.SistemaId = _application.GetCurrentSistema().Id;
_menuService.Guardar(entidad);
var menuVista = new
{
entidad.Id,
entidad.Codigo,
entidad.Nombre,
entidad.Descripcion,
Items = getItems(entidad.Items)
};
var result = new JsonResult
{
Data = menuVista,
JsonRequestBehavior = JsonRequestBehavior.AllowGet
};
return(result);
}
catch (Exception ex)
{
var result = ManejadorExcepciones.HandleException(ex);
return(StatusResponseHelper.JsonErrorServidor(result.Message, true));
}
}
public ResponseRegistrarTransmisionDocumentoDTO RegistraTransmisionDocumento(RegistraTransmisionDocumentoDTO request)
{
long result = 0;
ResponseRegistrarTransmisionDocumentoDTO response = new ResponseRegistrarTransmisionDocumentoDTO();
CoreBL coreBL = new CoreBL();
try
{
var contextoParaBaseDatos = new ContextoParaBaseDatos(ConstantesDB.Transmisiones);
var repo = new RepositorioTransmisiones(contextoParaBaseDatos);
Mapper.CreateMap <DetalleTransmisionDocumentoDTO, DetalleTransmisionDocumento>();
var requestBE = Helper.MiMapper <RegistraTransmisionDocumentoDTO, RegistraTransmisionDocumento>(request);
using (TransactionScope Transaccion = new TransactionScope())
{
result = repo.RegistraTransmisionDocumento(requestBE);
Transaccion.Complete();
}
//}
}
catch (Exception ex)
{
response.Result = new Result {
IdError = Guid.NewGuid(), Satisfactorio = false, Mensaje = "Ocurrio un problema interno en el servicio"
};
ManejadorExcepciones.PublicarExcepcion(ex, PoliticaExcepcion.LogicaNegocio);
}
return(response);
}
public JsonResult Edit(Menu entidad)
{
try
{
var menu = _menuService.Get(entidad.Id);
menu.Codigo = entidad.Codigo;
menu.Nombre = entidad.Nombre;
menu.Descripcion = entidad.Descripcion;
//Actualizados
var actualizados = menu.Items.Where(c => entidad.Items.Any(d => c.Id == d.Id));
foreach (var actualizado in actualizados)
{
var elemento = entidad.Items.FirstOrDefault(i => i.Id == actualizado.Id);
if (elemento != null)
{
actualizado.Nombre = elemento.Nombre;
actualizado.Codigo = elemento.Codigo;
actualizado.Descripcion = elemento.Descripcion;
actualizado.EstadoId = elemento.EstadoId;
actualizado.FuncionalidadId = elemento.FuncionalidadId;
actualizado.Icono = elemento.Icono;
actualizado.Orden = elemento.Orden;
actualizado.PadreCodigo = elemento.PadreCodigo;
actualizado.TipoId = elemento.TipoId;
actualizado.Url = elemento.Url;
}
}
//Nuevos
var nuevos = entidad.Items.Where(c => c.Id == 0);
foreach (var nuevo in nuevos)
{
menu.Items.Add(nuevo);
}
//Eliminados
var eliminados = menu.Items.Where(c => entidad.Items.All(d => c.Id != d.Id)).ToList();
_menuService.EliminarItems(eliminados);
_menuService.Guardar(menu);
var catalogoVista = new
{
menu.Id,
menu.Codigo,
menu.Nombre,
menu.Descripcion,
Items = getItems(menu.Items)
};
return(Json(catalogoVista, JsonRequestBehavior.AllowGet));
}
catch (Exception ex)
{
var result = ManejadorExcepciones.HandleException(ex);
return(StatusResponseHelper.JsonErrorServidor(result.Message, true));
}
}
public ResponseEliminarAdjuntarArchivoDTO EliminarArchivo(EliminarArchivoAdjuntoDTO request)
{
var filtro = request;
String error = "";
foreach (var item in request.Archivos)
{
try
{
//String nombreInterno = getNombreInterno(request.SociedadPropietaria, item);
String rutaReal = Path.Combine(getRutaFisica(request.SociedadPropietaria), item);
System.IO.File.Delete(rutaReal);
}
catch (Exception ex)
{
ManejadorExcepciones.PublicarExcepcion(ex, PoliticaExcepcion.LogicaNegocio);
error += ex.Message + "\n";
}
}
return(new ResponseEliminarAdjuntarArchivoDTO()
{
Archivos = request.Archivos,
error = error
});
}
public ConsultarMantenimientoResponseDTO ConsultarMantenimiento(ConsultarMantenimientoRequestDTO request)
{
ManejadorLog manejadorLog = new ManejadorLog();
manejadorLog.GrabarLog(request.FechaFin.ToString());
manejadorLog.GrabarLog(request.FechaFin.ToString());
ConsultarMantenimientoResponseDTO result = new ConsultarMantenimientoResponseDTO();
try
{
FichaMantenimientoBL mantenimiento = new FichaMantenimientoBL();
result = mantenimiento.ConsultarMantenimiento(request);
}
catch (ResultException ex)
{
ManejadorExcepciones.PublicarExcepcion(string.Format("{0}: {1}", MethodBase.GetCurrentMethod().Name,
ex.Result.Mensaje));
ex.Result.Satisfactorio = false;
result.Result = ex.Result;
}
catch (Exception ex)
{
ManejadorExcepciones.PublicarExcepcion(ex, PoliticaExcepcion.ServicioWCF);
result.Result = new Result
{
Satisfactorio = false,
Mensaje = "Ocurrio un problema interno en el servicio",
IdError = Guid.NewGuid()
};
}
return(result);
}
public JsonResult DoQuery(string query)
{
string error = "";
try
{
if (ModelState.IsValid)
{
var result = _catalogoService.DoQuery(query);
return(new JsonResult
{
Data = result
});
}
}
catch (Exception ex)
{
var result = ManejadorExcepciones.HandleException(ex);
error = result.Message;
return(new JsonResult
{
Data = new { success = false, errors = error }
});
}
return(new JsonResult
{
Data = new { success = false, errors = error }
});
}
public ObtenerFichaMantenimientoResponseDTO ObtenerFichaMantenimiento(ObtenerFichaMantenimientoRequestDTO request)
{
ObtenerFichaMantenimientoResponseDTO response = new ObtenerFichaMantenimientoResponseDTO();
try
{
var ficha_mantenimientoBL = new FichaMantenimientoBL();
response = ficha_mantenimientoBL.ObtenerFichaMantenimiento(request);
return(response);
}
catch (ResultException ex)
{
ManejadorExcepciones.PublicarExcepcion(string.Format("{0}: {1}", MethodBase.GetCurrentMethod().Name, ex.Result.Mensaje));
ex.Result.Satisfactorio = false;
response.Result = ex.Result;
return(response);
}
catch (Exception ex)
{
ManejadorExcepciones.PublicarExcepcion(ex, PoliticaExcepcion.ServicioWCF);
response.Result = new Result {
Satisfactorio = false, Mensaje = "Ocurrio un problema interno en el servicio", IdError = Guid.NewGuid()
};
return(response);
}
}
public ResponseAgregarDepositoDefaultViewModel AgregarDepositoDefault(RequestAgregarDepositoDefaultViewModel request)
{
var responseResult = new ResponseAgregarDepositoDefaultViewModel();
try
{
var requestAge = new AgregaDepositoDefaultRequestDTO
{
CodigoDeposito = request.CodigoDeposito,
CodigoTipoContenedor = request.CodigoTipoContenedor,
CodigoSucursal = request.CodigoSucursal,
CodigoLinea = request.CodigoLinea,
Observacion = request.Observacion,
UsuarioCreacion = request.UsuarioCreacion
};
var response = new TransmisionesProxyrest().AgregaDepositoDefault(requestAge);
responseResult.Result = response.Result;
}
catch (Exception ex)
{
responseResult.Result = new Result();
responseResult.Result.Satisfactorio = false;
ManejadorExcepciones.PublicarExcepcion(ex, PoliticaExcepcion.AgenteServicios);
}
return(responseResult);
}
// This method is executed at runtime inside your application,
// before target methods.
public override void OnEntry(MethodExecutionArgs args)
{
try
{
manejadorLogEventos = new ManejadorLogEventos();
url = OperationContext.Current.IncomingMessageHeaders.To.AbsoluteUri;
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append("+ Entering ");
nombreUsuario = "";
if (args.Arguments != null && args.Arguments.Count > 0)
{
tramaInput = Helper.SerializarJsonObjecto(args.Arguments[0]);
nombreUsuario = getUsuario(args.Arguments[0]);
////
//ObjetoTrazabilidad objetoTrazabilidad = GR.COMEX.Framework.Helper.ConvertirAObjeto<ObjetoTrazabilidad>("ObjetoTrazabilidad", Helper.SerializarJsonObjecto(args.Arguments[0]));
//if (objetoTrazabilidad != null)
//{
// //Helper.SetSession("ObjetoTrazabilidad", objetoTrazabilidad);
// //Helper.SetSession("ObjetoTrazabilidad", objetoTrazabilidad);
//}
////
}
args.MethodExecutionTag = stringBuilder;
}
catch (Exception ex)
{
ManejadorExcepciones.PublicarExcepcion(ex, PoliticaExcepcion.ServicioWCF);
}
}
public ConsultarEstadoSolicitudResponseDTO ConsultarEstadoSolicitud()
{
ConsultarEstadoSolicitudResponseDTO result = new ConsultarEstadoSolicitudResponseDTO();
List <EstadoSolicitud> lstDatos = new List <EstadoSolicitud>();
try
{
string keyCache = Convert.ToString(KeyCache.EstadoSolicitud);
ManejadorCache manejadorCache = new ManejadorCache();
lstDatos = manejadorCache.ObtenerValorCache <List <EstadoSolicitud> >(keyCache);
if (lstDatos == null || lstDatos.Count == 0)
{
var contextoParaBaseDatos = new ContextoParaBaseDatos(ConstantesDB.Petcenterdb);
var repo = new RepositorioEstadoSolicitud(contextoParaBaseDatos);
lstDatos = repo.ConsultarEstadoSolicitud();
}
result.EstadoSilicitudList = (from Origen in lstDatos
select Helper.MiMapper <EstadoSolicitud, EstadoSolicitudDTO>(Origen)).ToList();
}
catch (Exception ex)
{
ManejadorExcepciones.PublicarExcepcion(ex, PoliticaExcepcion.LogicaNegocio);
}
return(result);
}
public ResponseConsultarLogTransmisionNaveDTO ConsultarLogTransmisionNave(RequestConsultarLogTransmisionNaveDTO request)
{
var response = new ResponseConsultarLogTransmisionNaveDTO();
try
{
response = (new TransmisionesBL()).ConsultarLogTransmisionNave(request);
return(response);
}
catch (ResultException ex)
{
ManejadorExcepciones.PublicarExcepcion(string.Format("{0}: {1}", MethodBase.GetCurrentMethod().Name, ex.Result.Mensaje));
ex.Result.Satisfactorio = false;
response.Result = ex.Result;
return(response);
}
catch (Exception ex)
{
ManejadorExcepciones.PublicarExcepcion(ex, PoliticaExcepcion.ServicioWCF);
response.Result = new Result {
Satisfactorio = false, Mensaje = "Ocurrio un problema interno en el servicio", IdError = Guid.NewGuid()
};
return(response);
}
}
