public object Get(string numeroUnico, string token)
{
JavaScriptSerializer serializer = new JavaScriptSerializer();
string payload = "";
string newToken = "";
bool tokenValido = ManageTokens.Instance.ValidateToken(token, out payload, out newToken);
if (tokenValido)
{
Sam3_Usuario usuario = serializer.Deserialize <Sam3_Usuario>(payload);
string[] elementos = numeroUnico.Split('-').ToArray();
string prefijo = elementos[0];
int consecutivo = 0;
int.TryParse(elementos[1], out consecutivo);
string segmento = elementos[2];
return(CorteBd.Instance.ListadoNumerosDeControl(prefijo, consecutivo, usuario));
}
else
{
TransactionalInformation result = new TransactionalInformation();
result.ReturnMessage.Add(payload);
result.ReturnCode = 401;
result.ReturnStatus = false;
result.IsAuthenicated = false;
return(result);
}
}
public object Get(int Folio, string token)
{
try
{
string newToken = "";
string payload = "";
bool tokenValido = ManageTokens.Instance.ValidateToken(token, out payload, out newToken);
if (tokenValido)
{
JavaScriptSerializer serializer = new JavaScriptSerializer();
Sam3_Usuario usuario = serializer.Deserialize <Sam3_Usuario>(payload);
return(AvisoLlegadaBd.Instance.VerificarDocumentoAduana(Folio, usuario));
}
else
{
TransactionalInformation result = new TransactionalInformation();
result.ReturnCode = 401;
result.ReturnStatus = false;
result.ReturnMessage.Add(payload);
result.IsAuthenicated = false;
return(result);
}
}
catch (Exception ex)
{
TransactionalInformation result = new TransactionalInformation();
result.ReturnCode = 500;
result.ReturnStatus = false;
result.ReturnMessage.Add(ex.Message);
result.IsAuthenicated = false;
return(result);
}
}
public object listadoUsuarios(Sam3_Usuario usuario)
{
try
{
using (SamContext ctx = new SamContext())
{
List <ListaCombos> listado = (from us in ctx.Sam3_Usuario
where us.Activo
select new ListaCombos
{
id = us.UsuarioID.ToString(),
value = us.Nombre + " " + us.ApellidoPaterno
}).AsParallel().Distinct().ToList();
return(listado);
}
}
catch (Exception ex)
{
//-----------------Agregar mensaje al Log -----------------------------------------------
LoggerBd.Instance.EscribirLog(ex);
//-----------------Agregar mensaje al Log -----------------------------------------------
TransactionalInformation result = new TransactionalInformation();
result.ReturnMessage.Add(ex.Message);
result.ReturnCode = 500;
result.ReturnStatus = false;
result.IsAuthenicated = true;
return(result);
}
}
public object get(string data)
{
string payload = "";
string newToken = "";
JavaScriptSerializer serializer = new JavaScriptSerializer();
MaterialPendiente filtros = serializer.Deserialize <MaterialPendiente>(data);
bool tokenValido = ManageTokens.Instance.ValidateToken(filtros.token, out payload, out newToken);
if (tokenValido)
{
Sam3_Usuario usuario = serializer.Deserialize <Sam3_Usuario>(payload);
// return CorteBd.Instance.GenerarCorte(cortes, usuario);
return("");
}
else
{
TransactionalInformation result = new TransactionalInformation();
result.ReturnMessage.Add(payload);
result.ReturnCode = 401;
result.ReturnStatus = false;
result.IsAuthenicated = false;
return(result);
}
}
// PUT api/<controller>/5
public object Put(int ordenTrabajoID, string datosDeficit, string datosSpools, string token)
{
string payload = "";
string newToken = "";
bool tokenValido = ManageTokens.Instance.ValidateToken(token, out payload, out newToken);
if (tokenValido)
{
JavaScriptSerializer ser = new JavaScriptSerializer();
Sam3_Usuario usuario = ser.Deserialize <Sam3_Usuario>(payload);
List <SolucionarRevision> datos = ser.Deserialize <List <SolucionarRevision> >(datosDeficit);
List <SpoolsSeleccionados> spoolsID = ser.Deserialize <List <SpoolsSeleccionados> >(datosSpools);
return(DeficitBd.Instance.SolucionarDeficit(ordenTrabajoID, datos, spoolsID, usuario));
}
else
{
TransactionalInformation result = new TransactionalInformation();
result.ReturnMessage.Add(payload);
result.ReturnCode = 401;
result.ReturnStatus = false;
result.IsAuthenicated = false;
return(result);
}
}
public object Get(int folioAvisoEntrada, string token)
{
string payload = "";
string newToken = "";
bool tokenValido = ManageTokens.Instance.ValidateToken(token, out payload, out newToken);
if (tokenValido)
{
JavaScriptSerializer serializer = new JavaScriptSerializer();
Sam3_Usuario usuario = serializer.Deserialize <Sam3_Usuario>(payload);
bool tieneOrdenDescarga = (bool)FolioAvisoEntradaBd.Instance.TieneOrdenDescarga(folioAvisoEntrada, usuario);
TransactionalInformation result = new TransactionalInformation();
result.ReturnMessage.Add(tieneOrdenDescarga.ToString());
result.ReturnCode = 200;
result.ReturnStatus = true;
result.IsAuthenicated = true;
return(result);
}
else
{
TransactionalInformation result = new TransactionalInformation();
result.ReturnMessage.Add(payload);
result.ReturnCode = 401;
result.ReturnStatus = false;
result.IsAuthenicated = false;
return(result);
}
}
public object Post(int folioLlegada, string token)
{
try
{
string newToken = "";
string payload = "";
bool tokenValido = ManageTokens.Instance.ValidateToken(token, out payload, out newToken);
if (tokenValido)
{
JavaScriptSerializer serializer = new JavaScriptSerializer();
Sam3_Usuario usuario = serializer.Deserialize <Sam3_Usuario>(payload);
var httpRequest = HttpContext.Current.Request;
return(Ok());
}
else
{
TransactionalInformation result = new TransactionalInformation();
result.ReturnCode = 401;
result.ReturnStatus = false;
result.ReturnMessage.Add(payload);
result.IsAuthenicated = false;
return(result);
}
}
catch (Exception ex)
{
TransactionalInformation result = new TransactionalInformation();
result.ReturnCode = 500;
result.ReturnStatus = false;
result.ReturnMessage.Add(ex.Message);
result.IsAuthenicated = false;
return(result);
}
}
//GET api/<controller>/5
public object Get(int ordenAlmacenajeID, string token)
{
JavaScriptSerializer serializer = new JavaScriptSerializer();
string payload = "";
string newToken = "";
bool tokenValido = ManageTokens.Instance.ValidateToken(token, out payload, out newToken);
if (tokenValido)
{
JavaScriptSerializer ser = new JavaScriptSerializer();
Sam3_Usuario usuario = ser.Deserialize <Sam3_Usuario>(payload);
return(OrdenAlmacenajeBd.Instance.ObtenerDetalleOrdenAlmacenaje(ordenAlmacenajeID, usuario));
}
else
{
TransactionalInformation result = new TransactionalInformation();
result.ReturnMessage.Add(payload);
result.ReturnCode = 401;
result.ReturnStatus = false;
result.IsAuthenicated = false;
return(result);
}
}
public object ObtenerProyectosPorFolio(int folio, Sam3_Usuario usuario)
{
try
{
using (SamContext ctx = new SamContext())
{
List <int> Proyectos = ctx.Sam3_Rel_FolioAvisoLlegada_Proyecto.Where(x => x.FolioAvisoLlegadaID == folio)
.Select(x => x.ProyectoID).AsParallel().ToList();
Proyectos = Proyectos.GroupBy(x => x).Select(x => x.First()).ToList();
return(Proyectos);
}
}
catch (Exception ex)
{
//-----------------Agregar mensaje al Log -----------------------------------------------
LoggerBd.Instance.EscribirLog(ex);
//-----------------Agregar mensaje al Log -----------------------------------------------
TransactionalInformation result = new TransactionalInformation();
result.ReturnMessage.Add(ex.Message);
result.ReturnCode = 500;
result.ReturnStatus = false;
result.IsAuthenicated = true;
return(result);
}
}
public object InsertarTipoArchivo(Sam3_TipoArchivo nuevo, Sam3_Usuario usuario)
{
try
{
using (SamContext ctx = new SamContext())
{
Sam3_TipoArchivo tipoArchivo = new Sam3_TipoArchivo();
tipoArchivo.Activo = true;
tipoArchivo.FechaModificacion = DateTime.Now;
tipoArchivo.Nombre = nuevo.Nombre;
tipoArchivo.UsuarioModificacion = usuario.UsuarioID;
ctx.Sam3_TipoArchivo.Add(tipoArchivo);
ctx.SaveChanges();
return(new TipoArchivo {
Nombre = tipoArchivo.Nombre, TipoArchivoID = tipoArchivo.TipoArchivoID.ToString()
});
}
}
catch (Exception ex)
{
//-----------------Agregar mensaje al Log -----------------------------------------------
LoggerBd.Instance.EscribirLog(ex);
//-----------------Agregar mensaje al Log -----------------------------------------------
TransactionalInformation result = new TransactionalInformation();
result.ReturnMessage.Add(ex.Message);
result.ReturnCode = 500;
result.ReturnStatus = false;
result.IsAuthenicated = true;
return(result);
}
}
/// <summary>
/// Crea el mensaje en la cola de mensajes
/// </summary>
/// <param name="objectEncrypted">Mensaje encriptado</param>
/// <param name="typeMessage">Tipo de Mensaje (1: Bitácora, 2: Notificación)</param>
public object Post(string token, string objectEncrypted, string typeMessage)
{
string payload = "";
string newToken = "";
bool tokenValido = ManageTokens.Instance.ValidateToken(token, out payload, out newToken);
if (tokenValido)
{
JavaScriptSerializer serializer = new JavaScriptSerializer();
Sam3_Usuario usuario = serializer.Deserialize <Sam3_Usuario>(payload);
string message = dataSecurity.Decode(objectEncrypted);
int typeMsg = Convert.ToInt32(typeMessage);
return(MessageLibrary.Instance.SendMessageToQueue(message, typeMsg, usuario));
}
else
{
TransactionalInformation result = new TransactionalInformation();
result.ReturnMessage.Add(payload);
result.ReturnCode = 401;
result.ReturnStatus = false;
result.IsAuthenicated = false;
return(result);
}
}
public object ObtnerEtiquetasMaterialPorODTS(string odtsm, Sam3_Usuario usuario)
{
try
{
int odtsID = string.IsNullOrEmpty(odtsm) ? 0 : Convert.ToInt32(odtsm);
List <ListaCombos> listado = new List <ListaCombos>();
using (Sam2Context ctx2 = new Sam2Context())
{
listado = (from ms in ctx2.MaterialSpool
where ms.SpoolID == (from odts in ctx2.OrdenTrabajoSpool
where odts.OrdenTrabajoSpoolID == odtsID
select odts.SpoolID).FirstOrDefault()
select new ListaCombos
{
id = ms.MaterialSpoolID.ToString(),
value = ms.Etiqueta
}).AsParallel().Distinct().OrderBy(x => x.value).ToList();
}
return(listado);
}
catch (Exception ex)
{
//-----------------Agregar mensaje al Log -----------------------------------------------
LoggerBd.Instance.EscribirLog(ex);
//-----------------Agregar mensaje al Log -----------------------------------------------
TransactionalInformation result = new TransactionalInformation();
result.ReturnMessage.Add(ex.Message);
result.ReturnCode = 500;
result.ReturnStatus = false;
result.IsAuthenicated = true;
return(result);
}
}
/// <summary>
/// Funcion para obtener los proyectos del usuario
/// Combo Proyectos Listado de Materiales
/// </summary>
/// <param name="patioID"></param>
/// <param name="usuario"></param>
/// <returns></returns>
public object obtenerProyectoListadoMateriales(string patioID, Sam3_Usuario usuario)
{
try
{
using (SamContext ctx = new SamContext())
{
List <Proyecto> proyectos = (from rup in ctx.Sam3_Rel_Usuario_Proyecto
join pr in ctx.Sam3_Proyecto on rup.ProyectoID equals pr.ProyectoID
where rup.Activo && pr.Activo &&
rup.UsuarioID == usuario.UsuarioID &&
pr.PatioID.ToString() == patioID
select new Proyecto
{
ProyectoID = pr.ProyectoID.ToString(),
Nombre = pr.Nombre
}).AsParallel().ToList();
return(proyectos);
}
}
catch (Exception ex)
{
//-----------------Agregar mensaje al Log -----------------------------------------------
LoggerBd.Instance.EscribirLog(ex);
//-----------------Agregar mensaje al Log -----------------------------------------------
TransactionalInformation result = new TransactionalInformation();
result.ReturnMessage.Add(ex.Message);
result.ReturnCode = 500;
result.ReturnStatus = false;
result.IsAuthenicated = true;
return(result);
}
}
public object ObtenerListadoTipoArchivos(Sam3_Usuario usuario)
{
try
{
using (SamContext ctx = new SamContext())
{
List <TipoArchivo> lstTipoArchivo = (from r in ctx.Sam3_TipoArchivo
where r.Activo
select new TipoArchivo
{
Nombre = r.Nombre,
TipoArchivoID = r.TipoArchivoID.ToString()
}).AsParallel().ToList();
return(lstTipoArchivo);
}
}
catch (Exception ex)
{
//-----------------Agregar mensaje al Log -----------------------------------------------
LoggerBd.Instance.EscribirLog(ex);
//-----------------Agregar mensaje al Log -----------------------------------------------
TransactionalInformation result = new TransactionalInformation();
result.ReturnMessage.Add(ex.Message);
result.ReturnCode = 500;
result.ReturnStatus = false;
result.IsAuthenicated = true;
return(result);
}
}
/// <summary>
/// Funcion para obtener los patios del usuario
/// Combo para el Listado de Materiales
/// </summary>
/// <param name="usuario"></param>
/// <returns></returns>
public object obtenerPatioListadoMateriales(Sam3_Usuario usuario)
{
try
{
using (SamContext ctx = new SamContext())
{
//Patios y proyectos del usuario
List <int> proyectos = ctx.Sam3_Rel_Usuario_Proyecto.Where(x => x.UsuarioID == usuario.UsuarioID).Select(x => x.ProyectoID).AsParallel().ToList();
List <Patio> patios = (from r in ctx.Sam3_Proyecto
join p in ctx.Sam3_Patio on r.PatioID equals p.PatioID
where r.Activo && p.Activo && proyectos.Contains(r.ProyectoID)
select new Patio
{
PatioID = p.PatioID.ToString(),
Nombre = p.Nombre
}).AsParallel().GroupBy(x => x.PatioID).Select(x => x.First()).ToList();
return(patios);
}
}
catch (Exception ex)
{
//-----------------Agregar mensaje al Log -----------------------------------------------
LoggerBd.Instance.EscribirLog(ex);
//-----------------Agregar mensaje al Log -----------------------------------------------
TransactionalInformation result = new TransactionalInformation();
result.ReturnMessage.Add(ex.Message);
result.ReturnCode = 500;
result.ReturnStatus = false;
result.IsAuthenicated = true;
return(result);
}
}
// GET api/<controller>/5
public TransactionalInformation Get(int folio, string token)
{
string payload = "";
string newToken = "";
bool tokenValido = ManageTokens.Instance.ValidateToken(token, out payload, out newToken);
if (tokenValido)
{
JavaScriptSerializer serializer = new JavaScriptSerializer();
Sam3_Usuario usuario = serializer.Deserialize <Sam3_Usuario>(payload);
TransactionalInformation resultObtener = PermisoAduanaBd.Instance.ObtenerDatosAvisoLlegada(folio);
if (resultObtener.ReturnCode == 200)
{
return(PermisoAduanaBd.Instance.InsertarPermisoADuana(folio, usuario));
}
else
{
resultObtener.ReturnCode = 500;
resultObtener.ReturnStatus = false;
resultObtener.IsAuthenicated = false;
return(resultObtener);
}
}
else
{
TransactionalInformation result = new TransactionalInformation();
result.ReturnMessage.Add(payload);
result.ReturnCode = 401;
result.ReturnStatus = false;
result.IsAuthenicated = false;
return(result);
}
}
// POST api/<controller>
public object Post(ListadosFolios OrdenAlmacenaje, string token)
{
string payload = "";
string newToken = "";
bool tokenValido = ManageTokens.Instance.ValidateToken(token, out payload, out newToken);
if (tokenValido)
{
JavaScriptSerializer ser = new JavaScriptSerializer();
Sam3_Usuario usuario = ser.Deserialize <Sam3_Usuario>(payload);
if (OrdenAlmacenaje.listaFoliosCuantificacion.Count > 0 || OrdenAlmacenaje.listaItemCodes.Count > 0 || OrdenAlmacenaje.listaNumerosUnicos.Count > 0)
{
return(OrdenAlmacenajeBd.Instance.GenerarOrdenAlmacenaje(OrdenAlmacenaje, usuario));
}
else
{
TransactionalInformation result = new TransactionalInformation();
result.ReturnMessage.Add("No se encontro ningun ID en los datos enviados");
result.ReturnCode = 500;
result.ReturnStatus = false;
result.IsAuthenicated = true;
return(result);
}
}
else
{
TransactionalInformation result = new TransactionalInformation();
result.ReturnMessage.Add(payload);
result.ReturnCode = 401;
result.ReturnStatus = false;
result.IsAuthenicated = false;
return(result);
}
}
/// <summary>
/// Genera un listado de los documentos relacionados a un permiso de aduana
/// </summary>
/// <param name="folioAvisoLlegadaId"></param>
/// <param name="usuario"></param>
/// <returns></returns>
public object ObtenerDocumentosPermisoAduana(int folioAvisoLlegadaId, Sam3_Usuario usuario)
{
try
{
using (SamContext ctx = new SamContext())
{
List <ListaDocumentos> documentos = (from r in ctx.Sam3_FolioAvisoLlegada
join p in ctx.Sam3_PermisoAduana on r.FolioAvisoLlegadaID equals p.FolioAvisoLlegadaID
join d in ctx.Sam3_Rel_PermisoAduana_Documento on p.PermisoAduanaID equals d.PermisoAduanaID
where r.Activo == true && r.FolioAvisoLlegadaID == folioAvisoLlegadaId && d.Activo
select new ListaDocumentos
{
DocumentoID = d.Rel_Permiso_Documento_ID.ToString(),
Nombre = d.Nombre,
Extencion = d.Extencion,
Url = d.Url
}).AsParallel().ToList();
return(documentos);
}
}
catch (Exception ex)
{
//-----------------Agregar mensaje al Log -----------------------------------------------
LoggerBd.Instance.EscribirLog(ex);
//-----------------Agregar mensaje al Log -----------------------------------------------
TransactionalInformation result = new TransactionalInformation();
result.ReturnMessage.Add(ex.Message);
result.ReturnCode = 500;
result.ReturnStatus = false;
result.IsAuthenicated = true;
return(result);
}
}
public object Get(string token, int paginaID)
{
PerfilJson perfil = new PerfilJson();
string payload = "";
string newToken = "";
bool validToken = ManageTokens.Instance.ValidateToken(token, out payload, out newToken);
JavaScriptSerializer serializer = new JavaScriptSerializer();
if (validToken)
{
dynamic obj = serializer.DeserializeObject(payload);
int perfilId = Convert.ToInt32(obj["PerfilID"].ToString());
Sam3_Usuario usuario = serializer.Deserialize <Sam3_Usuario>(payload);
perfil = PerfilBd.Instance.ObtenerPerfilJsonPorID(perfilId, paginaID, usuario);
perfil.token = newToken;
return(perfil);
}
else
{
TransactionalInformation infoError = new TransactionalInformation();
infoError.ReturnCode = 401;
infoError.ReturnStatus = false;
infoError.IsAuthenicated = false;
infoError.ReturnMessage.Add(payload);
return(infoError);
}
}
// POST api/TipoArchivo
public object Post(Sam3_TipoArchivo tipoArchivo, string token)
{
try
{
string newToken = "";
string payload = "";
bool tokenValido = ManageTokens.Instance.ValidateToken(token, out payload, out newToken);
if (tokenValido)
{
JavaScriptSerializer serializer = new JavaScriptSerializer();
Sam3_Usuario usuario = serializer.Deserialize <Sam3_Usuario>(payload);
return(TipoArchivoBd.Instance.InsertarTipoArchivo(tipoArchivo, usuario));
}
else
{
TransactionalInformation result = new TransactionalInformation();
result.ReturnCode = 401;
result.ReturnStatus = false;
result.ReturnMessage.Add(payload);
result.IsAuthenicated = false;
return(result);
}
}
catch (Exception ex)
{
TransactionalInformation result = new TransactionalInformation();
result.ReturnCode = 500;
result.ReturnStatus = false;
result.ReturnMessage.Add(ex.Message);
result.IsAuthenicated = false;
return(result);
}
}
public object Get(int transportistaID, int paginaID, string idioma, string token)
{
try
{
string newToken = "";
string payload = "";
bool tokenValido = ManageTokens.Instance.ValidateToken(token, out payload, out newToken);
if (tokenValido)
{
JavaScriptSerializer serializer = new JavaScriptSerializer();
Sam3_Usuario usuario = serializer.Deserialize <Sam3_Usuario>(payload);
return(PlanaBd.Instance.ObtenerListadoPlanas(usuario, transportistaID, paginaID, idioma));
}
else
{
TransactionalInformation result = new TransactionalInformation();
result.ReturnCode = 401;
result.ReturnStatus = false;
result.ReturnMessage.Add(payload);
result.IsAuthenicated = false;
return(result);
}
}
catch (Exception ex)
{
TransactionalInformation result = new TransactionalInformation();
result.ReturnCode = 500;
result.ReturnStatus = false;
result.ReturnMessage.Add(ex.Message);
result.IsAuthenicated = false;
return(result);
}
}
public object EliminarEntrega(int entregaID, Sam3_Usuario usuario)
{
try
{
using (SamContext ctx = new SamContext())
{
Sam3_Entrega entrega = ctx.Sam3_Entrega.Where(x => x.EntregaID == entregaID).AsParallel().SingleOrDefault();
entrega.Activo = false;
entrega.FechaModificacion = DateTime.Now;
entrega.UsuarioModificacion = usuario.UsuarioID;
ctx.SaveChanges();
}
TransactionalInformation result = new TransactionalInformation();
result.ReturnMessage.Add("OK");
result.ReturnCode = 200;
result.ReturnStatus = true;
result.IsAuthenicated = true;
return(result);
}
catch (Exception ex)
{
//-----------------Agregar mensaje al Log -----------------------------------------------
LoggerBd.Instance.EscribirLog(ex);
//-----------------Agregar mensaje al Log -----------------------------------------------
TransactionalInformation result = new TransactionalInformation();
result.ReturnMessage.Add(ex.Message);
result.ReturnCode = 500;
result.ReturnStatus = false;
result.IsAuthenicated = true;
return(result);
}
}
public bool ValidateToken(string token, out string result, out string newToken)
{
try
{
result = JsonWebToken.Decode(token, ConfigurationManager.AppSettings["scrKey"]);
JavaScriptSerializer serializer = new JavaScriptSerializer();
Sam3_Usuario usuario = serializer.Deserialize <Sam3_Usuario>(result);
//Logger.Instance.EscribirLog("Resultado de validar el token: " + result);
newToken = CreateJwtToken(usuario);
return(true);
}
catch (JWT.SignatureVerificationException ex)
{
//-----------------Agregar mensaje al Log -----------------------------------------------
Logger.Instance.EscribirLog(ex.InnerException + "Source: " + ex.Source + "stack :" + ex.StackTrace);
result = ex.InnerException + "Source: " + ex.Source + "stack :" + ex.StackTrace;
newToken = "";
return(false);
}
catch (Exception ex)
{
Logger.Instance.EscribirLog(ex.InnerException + "Source: " + ex.Source + "stack :" + ex.StackTrace);
result = ex.InnerException + "Source: " + ex.Source + "stack :" + ex.StackTrace;
newToken = "";
return(false);
}
}
public string CreateJwtToken(Sam3_Usuario usuario)
{
try
{
DateTime unixEpoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
double now = Math.Round((DateTime.UtcNow.AddMinutes(30) - unixEpoch).TotalSeconds);
Dictionary <string, object> payload = new Dictionary <string, object>()
{
{ "UsuarioID", usuario.UsuarioID },
{ "NombreUsuario", usuario.NombreUsuario },
{ "ContrasenaHash", usuario.ContrasenaHash },
{ "PerfilID", usuario.PerfilID },
{ "BloqueadoPorAdministracion", usuario.BloqueadoPorAdministracion },
{ "Activo", usuario.Activo },
{ "exp", now }
};
string token = JWT.JsonWebToken.Encode(payload, ConfigurationManager.AppSettings["scrKey"], JWT.JwtHashAlgorithm.HS256);
return(token);
}
catch (Exception ex)
{
//-----------------Agregar mensaje al Log -----------------------------------------------
Logger.Instance.EscribirLog(ex.Message + "Stack: " + ex.StackTrace + "----" + ex.InnerException);
return(ex.Message + "Stack: " + ex.StackTrace + "----" + ex.InnerException);
}
}
// POST api/<controller>
public object Post(int ordenTrabajoID, string spoolID, string deficit, string token)
{
string payload = "";
string newToken = "";
bool tokenValido = ManageTokens.Instance.ValidateToken(token, out payload, out newToken);
if (tokenValido)
{
JavaScriptSerializer ser = new JavaScriptSerializer();
Sam3_Usuario usuario = ser.Deserialize <Sam3_Usuario>(payload);
List <string> listaSpool = ser.Deserialize <List <string> >(spoolID);
List <DatosDeficitItemCodes> listaDeficit = ser.Deserialize <List <DatosDeficitItemCodes> >(deficit);
return(DeficitBd.Instance.GuardarDeficit(ordenTrabajoID, listaSpool, listaDeficit, usuario));
}
else
{
TransactionalInformation result = new TransactionalInformation();
result.ReturnMessage.Add(payload);
result.ReturnCode = 401;
result.ReturnStatus = false;
result.IsAuthenicated = false;
return(result);
}
}
public object CambiarEstatusFolio(int FolioAviso, string NumeroPermiso, Sam3_Usuario usuario)
{
try
{
using (SamContext ctx = new SamContext())
{
int permisoID = (from per in ctx.Sam3_PermisoAduana
where per.FolioAvisoLlegadaID == FolioAviso && per.Activo && per.Estatus == "Autorizado"
select per.PermisoAduanaID).AsParallel().SingleOrDefault();
if (ctx.Sam3_PermisoAduana.Where(x => x.FolioAvisoLlegadaID == FolioAviso && x.Activo).Any())
{
Sam3_PermisoAduana permisoBd = ctx.Sam3_PermisoAduana.Where(x => x.FolioAvisoLlegadaID == FolioAviso && x.Activo)
.AsParallel().SingleOrDefault();
permisoBd.PermisoAutorizado = true;
permisoBd.PermisoTramite = false;
permisoBd.NumeroPermiso = NumeroPermiso;
permisoBd.Estatus = "Autorizado";
permisoBd.FechaAutorización = DateTime.Now;
permisoBd.FechaModificacion = DateTime.Now;
permisoBd.UsuarioModificacion = usuario.UsuarioID;
ctx.SaveChanges();
}
if (ctx.Sam3_Rel_PermisoAduana_Documento.Where(x => x.PermisoAduanaID == permisoID && x.Activo).Any())
{
//Actualizar estatus de FolioAvisoLlegada
Sam3_FolioAvisoLlegada aviso = ctx.Sam3_FolioAvisoLlegada.Where(x => x.FolioAvisoLlegadaID == FolioAviso)
.AsParallel().SingleOrDefault();
aviso.Estatus = "Autorizado";
aviso.FechaModificacion = DateTime.Now;
aviso.UsuarioModificacion = usuario.UsuarioID;
ctx.SaveChanges();
return(true);
}
else
{
throw new Exception("El folio no cuenta con un permiso Autorizado");
}
}
}
catch (Exception ex)
{
//-----------------Agregar mensaje al Log -----------------------------------------------
LoggerBd.Instance.EscribirLog(ex);
//-----------------Agregar mensaje al Log -----------------------------------------------
TransactionalInformation result = new TransactionalInformation();
result.ReturnMessage.Add(ex.Message);
result.ReturnCode = 500;
result.ReturnStatus = false;
result.IsAuthenicated = true;
return(result);
}
}
public object ActualizarTransportista(Sam3_Transportista cambios, Sam3_Usuario usuario)
{
try
{
using (SamContext ctx = new SamContext())
{
if (!ctx.Sam3_Transportista.Where(x => x.Nombre == cambios.Nombre && x.Activo).AsParallel().Any())
{
Sam3_Transportista registroEnBd = ctx.Sam3_Transportista.Where(x => x.TransportistaID == cambios.TransportistaID)
.AsParallel().SingleOrDefault();
registroEnBd.Activo = registroEnBd.Activo != null && cambios.Activo != registroEnBd.Activo ?
cambios.Activo : registroEnBd.Activo;
registroEnBd.ContactoID = cambios.ContactoID != null && cambios.ContactoID != registroEnBd.ContactoID ?
cambios.ContactoID : registroEnBd.ContactoID;
registroEnBd.Descripcion = cambios.Descripcion != null && cambios.Descripcion != registroEnBd.Descripcion ?
cambios.Descripcion : registroEnBd.Descripcion;
registroEnBd.Direccion = cambios.Direccion != null && cambios.Direccion != registroEnBd.Direccion ?
cambios.Direccion : registroEnBd.Direccion;
registroEnBd.Nombre = cambios.Nombre != null && cambios.Nombre != registroEnBd.Nombre ?
cambios.Nombre : registroEnBd.Nombre;
registroEnBd.Telefono = cambios.Telefono != null && cambios.Telefono != registroEnBd.Telefono ?
cambios.Telefono : registroEnBd.Telefono;
registroEnBd.TransportistaID = cambios.TransportistaID != null && cambios.TransportistaID != registroEnBd.TransportistaID ?
cambios.TransportistaID : registroEnBd.TransportistaID;
registroEnBd.UsuarioModificacion = usuario.UsuarioID;
registroEnBd.FechaModificacion = DateTime.Now;
ctx.SaveChanges();
TransactionalInformation result = new TransactionalInformation();
result.ReturnMessage.Add("OK");
result.ReturnCode = 200;
result.ReturnStatus = true;
result.IsAuthenicated = true;
return(result);
}
else
{
throw new Exception("Transportista existente");
}
}
}
catch (Exception ex)
{
//-----------------Agregar mensaje al Log -----------------------------------------------
LoggerBd.Instance.EscribirLog(ex);
//-----------------Agregar mensaje al Log -----------------------------------------------
TransactionalInformation result = new TransactionalInformation();
result.ReturnMessage.Add(ex.Message);
result.ReturnCode = 500;
result.ReturnStatus = false;
result.IsAuthenicated = true;
return(result);
}
}
public object GenerarAlmacenaje(Items listados, Sam3_Usuario usuario)
{
try
{
List <ListaNumerosUnicos> ids = listados.NumerosUnicos.GroupBy(x => x.NumeroUnicoID).Select(x => x.First()).OrderBy(x => x.NumeroUnicoID).AsParallel().ToList();
List <int> nuids = new List <int>();
foreach (var i in ids)
{
nuids.Add(Convert.ToInt32(i.NumeroUnicoID));
}
string rack = ids.Select(x => x.Rack).FirstOrDefault();
using (SamContext ctx = new SamContext())
{
using (var ctx_tran = ctx.Database.BeginTransaction())
{
List <Sam3_NumeroUnico> list = (from nu in ctx.Sam3_NumeroUnico
where nu.Activo &&
nuids.Contains(nu.NumeroUnicoID)
select nu).AsParallel().ToList();
list.ForEach(x => x.Rack = getRack(ids, x.NumeroUnicoID));
ctx.SaveChanges();
ctx_tran.Commit();
}
}
//if (!(bool)EnviarAvisosBd.Instance.EnviarNotificación(1,
// string.Format("Se guardaron los almacenajes del orden de almacenaje Folio: {0}",
// listados.OrdenAlmacenajeID), usuario))
//{
// //Agregar error a la bitacora PENDIENTE
//}
TransactionalInformation result = new TransactionalInformation();
result.ReturnMessage.Add("Ok");
result.ReturnCode = 200;
result.ReturnStatus = true;
result.IsAuthenicated = true;
return(result);
}
catch (Exception ex)
{
//-----------------Agregar mensaje al Log -----------------------------------------------
LoggerBd.Instance.EscribirLog(ex);
//-----------------Agregar mensaje al Log -----------------------------------------------
TransactionalInformation result = new TransactionalInformation();
result.ReturnMessage.Add(ex.Message);
result.ReturnCode = 500;
result.ReturnStatus = false;
result.IsAuthenicated = true;
return(result);
}
}
public object ListadoCortadores(Sam3_Usuario usuario)
{
try
{
List <int> proyectos = new List <int>();
List <int> patios = new List <int>();
List <Operador> listado = new List <Operador>();
using (SamContext ctx = new SamContext())
{
using (Sam2Context ctx2 = new Sam2Context())
{
proyectos = (from p in ctx.Sam3_Rel_Usuario_Proyecto
join eqp in ctx.Sam3_EquivalenciaProyecto on p.ProyectoID equals eqp.Sam3_ProyectoID
where p.Activo && eqp.Activo &&
p.UsuarioID == usuario.UsuarioID
select eqp.Sam2_ProyectoID).Distinct().AsParallel().ToList();
proyectos = proyectos.Where(x => x > 0).ToList();
patios = (from p in ctx.Sam3_Proyecto
join pa in ctx.Sam3_Patio on p.PatioID equals pa.PatioID
join eq in ctx.Sam3_EquivalenciaPatio on pa.PatioID equals eq.Sam3_PatioID
join up in ctx.Sam3_Rel_Usuario_Proyecto on p.ProyectoID equals up.ProyectoID
where p.Activo && pa.Activo && eq.Activo &&
up.UsuarioID == usuario.UsuarioID
select eq.Sam2_PatioID).Distinct().AsParallel().ToList();
patios = patios.Where(x => x > 0).ToList();
listado = (from co in ctx2.Cortador
where patios.Contains(co.PatioID)
select new Operador
{
OperadorID = co.CortadorID.ToString(),
Nombre = co.Nombre
}).AsParallel().Distinct().ToList();
}
}
return(listado);
}
catch (Exception ex)
{
//-----------------Agregar mensaje al Log -----------------------------------------------
LoggerBd.Instance.EscribirLog(ex);
//-----------------Agregar mensaje al Log -----------------------------------------------
TransactionalInformation result = new TransactionalInformation();
result.ReturnMessage.Add(ex.Message);
result.ReturnCode = 500;
result.ReturnStatus = false;
result.IsAuthenicated = true;
return(result);
}
}
/// <summary>
/// Metodo comun para listados simples, para combos, o grids
/// </summary>
/// <param name="tipoListado">Tipo de listado a devolver</param>
/// <param name="token">credenciales del usuario</param>
/// <param name="parametroBusqueda">cadena de busqueda</param>
/// <returns>Devuelve el listado aporpiado de acuerdo al tipo solicitado</returns>
public object Get(int tipoListado, string token, string idioma = "", int paginaID = 0, string parametroBusqueda = "")
{
string payload = "";
string newToken = "";
bool tokenValido = ManageTokens.Instance.ValidateToken(token, out payload, out newToken);
if (tokenValido)
{
JavaScriptSerializer serializer = new JavaScriptSerializer();
Sam3_Usuario usuario = serializer.Deserialize <Sam3_Usuario>(payload);
switch (tipoListado)
{
//case 1: //Folios aviso llegada
// return AvisoLlegadaBd.Instance.ObtenerListadoFoliosParaFiltro(new Sam3_Usuario());
case 2: // Folios de aviso de llegada con permiso de aduana autorizados
return(AvisoLlegadaBd.Instance.ObtenerListadoFoliosRequierePermiso(new Sam3_Usuario()));
case 3: // listado de choferes por transportista
return(ChoferBd.Instance.ObtenerChoferesProTransportista(Convert.ToInt32(parametroBusqueda), paginaID, idioma, usuario));
case 4: //Obtener cantidades para dashboard
TransactionalInformation rest = new TransactionalInformation();
rest.ReturnMessage.Add("El listado de cantidades de Dashboard requiere de parametros de filtrado");
rest.ReturnCode = 500;
rest.ReturnStatus = false;
rest.IsAuthenicated = false;
return(rest);
//case 5:
// return AvisoLlegadaBd.Instance.ObtenerFoliosAvisoLlegadaSinEntrada();
//case 6: //Obtener listado de folios que ya tienen llegada de material
// return AvisoLlegadaBd.Instance.ObtenerListadoSinPaseSalida();
case 18: // Listado para combo de packing list
return(ListadoBd.Instance.PackingListsParaComboFiltros(usuario));
default:
TransactionalInformation result = new TransactionalInformation();
result.ReturnMessage.Add("Listado no encontrado");
result.ReturnCode = 500;
result.ReturnStatus = false;
result.IsAuthenicated = false;
return(result);
}
}
else
{
TransactionalInformation result = new TransactionalInformation();
result.ReturnMessage.Add(payload);
result.ReturnCode = 401;
result.ReturnStatus = false;
result.IsAuthenicated = false;
return(result);
}
}
