public object VerificarPermisoCreacion(int perfilID, string entidad, int paginaID)
{
try
{
using (SamContext ctx = new SamContext())
{
bool tienePermiso = (from rep in ctx.Sam3_Rel_Perfil_Entidad_Pagina
join ent in ctx.Sam3_Entidad on rep.EntidadID equals ent.EntidadID
where rep.Activo &&
rep.PerfilID == perfilID &&
ent.Nombre == entidad &&
rep.PaginaID == paginaID
select rep.PermisoCreacion).AsParallel().SingleOrDefault();
return(tienePermiso);
}
}
catch (Exception ex)
{
//-----------------Agregar mensaje al Log -----------------------------------------------
LoggerBd.Instance.EscribirLog(ex);
//-----------------Agregar mensaje al Log -----------------------------------------------
return(false);
}
}
public override void Import(string filename)
{
using (var file = File.OpenText(filename))
using (var csvReader = new CsvReader(file, CsvConfig))
{
var students = csvReader.GetRecords <Student>();
var newStudents = new List <Student>();
using (var db = new SamContext())
{
foreach (var student in students)
{
if (db.Students.Any(s => s.StudentNumber == student.StudentNumber) ||
newStudents.Any(s => s.StudentNumber == student.StudentNumber))
{
continue;
}
db.Students.Add(student);
newStudents.Add(student);
}
db.SaveChanges();
}
}
}
/// <summary>
/// Se obtienen todos los fabricantes
/// </summary>
/// <returns>lista de fabricantes</returns>
public object ObtenerFabricantes()
{
try
{
List <Fabricante> fabricante = new List <Fabricante>();
using (SamContext ctx = new SamContext())
{
fabricante = (from f in ctx.Sam3_Fabricante
where f.Activo
select new Fabricante
{
FabricanteID = f.FabricanteID,
Nombre = f.Nombre
}).AsParallel().ToList();
return(fabricante);
}
}
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 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 DeleteMessage(int notificationID)
{
try
{
using (SamContext ctx = new SamContext())
{
Sam3_Notificacion notificacion = new Sam3_Notificacion();
notificacion = ctx.Sam3_Notificacion.Where(x => x.NotificacionID == notificationID).First();
notificacion.Activo = false;
ctx.SaveChanges();
}
TransactionalInformation result = new TransactionalInformation();
result.ReturnMessage.Add("Ok");
result.ReturnCode = 200;
result.ReturnStatus = false;
result.IsAuthenicated = true;
return(result);
}
catch (Exception ex)
{
Logger.Instance.EscribirLog(ex);
TransactionalInformation result = new TransactionalInformation();
result.ReturnMessage.Add(ex.Message);
result.ReturnCode = 500;
result.ReturnStatus = false;
result.IsAuthenicated = true;
return(result);
}
}
/// <summary>
/// Obtener los tipo packing list (Tipo Material)
/// </summary>
/// <returns>Lista con los tipos de PL</returns>
public object ObtenerTipoPackingList()
{
try
{
List <TipoPackingList> PL = new List <TipoPackingList>();
using (SamContext ctx = new SamContext())
{
PL = (from m in ctx.Sam3_TipoMaterial
where m.Activo
select new TipoPackingList
{
id = m.TipoMaterialID.ToString(),
Nombre = m.Nombre
}).AsParallel().ToList();
}
return(PL);
}
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 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 PatioRequierePermiso(int patioID)
{
try
{
List <Patio> lstPatios = new List <Patio>();
using (SamContext ctx = new SamContext())
{
bool result = (from r in ctx.Sam3_Patio
where r.PatioID == patioID
select r.RequierePermisoAduana).AsParallel().SingleOrDefault();
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 void Build(string outputFile, string className, DateTime reportDate)
{
using (var db = new SamContext())
using (var excel = new NetOffice.ExcelApi.Application())
{
try
{
excel.DisplayAlerts = false;
var wb = excel.Workbooks.Open(_templateFile, false, false);
var ws = (Worksheet)wb.Worksheets.First();
var students = db.Students.Where(s => s.ClassName == className).ToList();
AppendToList(ws, students.Where(s => s.Sex == "Female"), FemaleRow);
AppendToList(ws, students.Where(s => s.Sex == "Male"), MaleRow);
wb.SaveAs(Path.Combine(_startUpPath, "output.xlsx"));
wb.Close();
Process.Start(Path.Combine(_startUpPath, "output.xlsx"));
}
catch (Exception e)
{
Console.WriteLine(e);
}
finally
{
if (excel.Workbooks.Any() == false)
{
excel.Quit();
}
}
}
}
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 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);
}
}
public object obtenerGrupoTieneD2(int ID)
{
try
{
using (SamContext ctx = new SamContext())
{
Sam3_Grupo grupo = ctx.Sam3_Grupo.Where(x => x.Activo && x.GrupoID == ID).FirstOrDefault();
grupo.TieneD2 = grupo.TieneD2 == null ? false : grupo.TieneD2 == true ? true : false;
return(grupo.TieneD2);
}
}
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>
/// Obtener los diametros para el combo
/// diametro 1 en asociar Item code steelgo vs item code
/// </summary>
/// <param name="itemCode"></param>
/// <returns></returns>
public object ObtenerDiametros1(int itemCode)
{
try
{
using (SamContext ctx = new SamContext())
{
List <ListaCombos> diametros = (from ricd in ctx.Sam3_Rel_ItemCode_Diametro
join d in ctx.Sam3_Diametro on ricd.Diametro1ID equals d.DiametroID
where ricd.Activo && d.Activo && ricd.ItemCodeID == itemCode
select new ListaCombos
{
id = d.DiametroID.ToString(),
value = d.Valor.ToString()
}).AsParallel().ToList();
return(diametros);
}
}
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>
/// 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 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>
/// Obtener los item codes a mostrar en el combo
/// de asociacion ICS - IC
/// </summary>
/// <returns></returns>
public object obtenerListadoItemCodes(string proyectoID)
{
try
{
using (SamContext ctx = new SamContext())
{
List <ListaCombosICC> itemCodes = (from icd in ctx.Sam3_Rel_ItemCode_Diametro
join ic in ctx.Sam3_ItemCode on icd.ItemCodeID equals ic.ItemCodeID
where icd.Activo && ic.Activo && ic.ProyectoID.ToString() == proyectoID
select new ListaCombosICC
{
id = icd.ItemCodeID.ToString(),
value = ic.Codigo,
tipoGrupo = ic.TipoMaterialID
}).AsParallel().GroupBy(x => x.value).Select(x => x.First()).ToList();
return(itemCodes);
}
}
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>
/// Genera un listado de los contactos activos, para mostrarse en un combo box
/// </summary>
/// <returns></returns>
public object ObtenerListadoContacto()
{
try
{
List <Contacto> lstContactos = new List <Contacto>();
//lstContactos.Add(new Contacto { ContactoID = "0", Nombre = "Agregar nuevo" });
using (SamContext ctx = new SamContext())
{
List <Contacto> result = (from r in ctx.Sam3_Contacto
where r.Activo
select new Contacto
{
Nombre = r.Nombre,
ContactoID = r.ContactoID.ToString()
}).AsParallel().ToList();
lstContactos.AddRange(result);
return(lstContactos);
}
}
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 obtenerTipoAcero(int familiaAceroID)
{
try
{
List <TipoAcero> tipoAcero = new List <TipoAcero>();
using (SamContext ctx = new SamContext())
{
tipoAcero = (from a in ctx.Sam3_Acero
where a.Activo &&
a.FamiliaAceroID == familiaAceroID
select new TipoAcero
{
AceroID = a.AceroID.ToString(),
Nomenclatura = a.Nomenclatura
}).AsParallel().ToList();
}
return(tipoAcero);
}
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>
/// Obtener los grupos para el combo del Catalogo Item Code Steelgo
/// </summary>
/// <returns>lista de Grupos</returns>
public object obtenerListadoGrupo()
{
try
{
using (SamContext ctx = new SamContext())
{
List <ListaCombos> grupo = (from g in ctx.Sam3_Grupo
where g.Activo
select new ListaCombos
{
id = g.GrupoID.ToString(),
value = g.Nombre
}).AsParallel().ToList();
return(grupo);
}
}
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);
}
}
public override void Import(string filename)
{
var newlyAdded = new List <Attendance>();
using (var file = File.OpenText(filename))
using (var csvReader = new CsvReader(file, CsvConfig))
{
var attendances = csvReader.GetRecords <Attendance>();
using (var db = new SamContext())
{
foreach (var attendance in attendances)
{
if (!db.Attendances.Any(at => at.ClassName == attendance.ClassName &&
at.StudentNumber == attendance.StudentNumber &&
at.AttendanceType == attendance.AttendanceType &&
at.AttendanceDate == attendance.AttendanceDate) &&
!newlyAdded.Any(at => at.ClassName == attendance.ClassName &&
at.StudentNumber == attendance.StudentNumber &&
at.AttendanceType == attendance.AttendanceType &&
at.AttendanceDate == attendance.AttendanceDate))
{
db.Attendances.Add(attendance);
newlyAdded.Add(attendance);
}
}
db.SaveChanges();
}
}
}
public object obtenerListadoTipoArchivosPorCatalogoID(int catalogoID)
{
try
{
using (SamContext ctx = new SamContext())
{
List <TipoArchivo> lista = (from ta in ctx.Sam3_TipoArchivo_Catalogo
where ta.Activo && ta.CatalogoID == catalogoID
select new TipoArchivo
{
Nombre = ta.Nombre,
TipoArchivoID = ta.TipoArchivoID.ToString()
}).AsParallel().ToList();
return(lista);
}
}
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 void Handle(StudentsUpdated message)
{
Students.Clear();
using (var db = new SamContext())
{
Students.AddRange(db.Students.ToList());
}
}
public void Handle(AttendancesUpdated message)
{
Attendances.Clear();
using (var db = new SamContext())
{
Attendances.AddRange(db.Attendances.ToList());
}
}
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 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 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);
}
}
/// <summary>
/// Método que obtiene las notificaciones de un usuario
/// Notificaciones Activas , leidas y no leidas
/// </summary>
/// <param name="userId">ID del usuario</param>
/// <returns>Lista de Notificaciones</returns>
public object GetNotificationsByUserID(int userId)
{
try
{
List <Notificacion> notifications = new List <Notificacion>();
using (SamContext ctx = new SamContext())
{
notifications = ctx.Sam3_Notificacion
.Join(ctx.Sam3_Usuario,
n => n.UsuarioIDEmisor, u => u.UsuarioID,
(n, u) => new
{
n.NotificacionID,
n.UsuarioIDReceptor,
n.UsuarioIDEmisor,
n.TipoNotificacionID,
n.Mensaje,
n.FechaEnvio,
n.FechaRecepcion,
n.EstatusLectura,
n.Activo,
n.UsuarioModificacion,
n.FechaModificacion,
u.NombreUsuario
})
.Where(x => x.UsuarioIDReceptor == userId && x.Activo == true)
.Select(x => new Notificacion
{
NotificacionID = x.NotificacionID,
UsuarioIDReceptor = x.UsuarioIDReceptor,
UsuarioIDEmisor = x.UsuarioIDEmisor,
TipoNotificacionID = x.TipoNotificacionID,
Mensaje = x.Mensaje,
FechaEnvio = x.FechaEnvio,
FechaRecepcion = x.FechaRecepcion,
EstatusLectura = x.EstatusLectura,
Activo = x.Activo,
UsuarioModificacion = x.UsuarioModificacion,
FechaModificacion = x.FechaModificacion,
NombreUsuarioEmisor = x.NombreUsuario
}).AsParallel().ToList();
return(notifications);
}
}
catch (Exception ex)
{
Logger.Instance.EscribirLog(ex);
TransactionalInformation result = new TransactionalInformation();
result.ReturnMessage.Add(ex.Message);
result.ReturnCode = 500;
result.ReturnStatus = false;
result.IsAuthenicated = true;
return(result);
}
}
public object ObtenerDocumentosIncidencia(int incidenciaID, string estatusDocumento, Sam3_Usuario usuario)
{
try
{
using (SamContext ctx = new SamContext())
{
int tipoDocumento = 0;
switch (estatusDocumento)
{
case "Incidencia":
tipoDocumento = 1;
break;
case "Resolver":
tipoDocumento = 2;
break;
case "Responder":
tipoDocumento = 3;
break;
case "Cancelar":
tipoDocumento = 4;
break;
}
List <ListaDocumentos> documentos = (from rid in ctx.Sam3_Rel_Incidencia_Documento
where rid.Activo && rid.IncidenciaID == incidenciaID &&
rid.EstatusIncidencia == tipoDocumento
select new ListaDocumentos
{
DocumentoID = rid.Rel_Incidencia_DocumentoID.ToString(),
Nombre = rid.Nombre,
Extencion = rid.Extencion,
Url = rid.Url,
TipoArchivo = string.Empty,
Descripcion = rid.Descripcion
}).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);
}
}
