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);
}
}
/// <summary>
///
/// </summary>
/// <param name="FolioCuantificacion"></param>
/// <param name="AvisoEntrada"></param>
/// <param name="bultoID"></param>
/// <param name="usuario"></param>
/// <returns></returns>
public object CambiarEstatusCuantificacion(int FolioCuantificacion, int AvisoEntrada, int bultoID, Sam3_Usuario usuario)
{
try
{
using (SamContext ctx = new SamContext())
{
if (bultoID != -1)
{
Sam3_Bulto bulto = ctx.Sam3_Bulto.Where(x => x.FolioCuantificacionID == FolioCuantificacion && x.BultoID == bultoID && x.Activo).AsParallel().SingleOrDefault();
bulto.Estatus = "En Proceso de Recepción";
bulto.UsuarioModificacion = usuario.UsuarioID;
bulto.FechaModificacion = DateTime.Now;
ctx.SaveChanges();
}
else
{
Sam3_FolioCuantificacion cuantificacion = (from fc in ctx.Sam3_FolioCuantificacion
join fe in ctx.Sam3_FolioAvisoEntrada on fc.FolioAvisoEntradaID equals fe.FolioAvisoEntradaID
where fc.Activo && fe.Activo &&
fe.FolioAvisoLlegadaID == AvisoEntrada &&
fc.FolioCuantificacionID == FolioCuantificacion
select fc).AsParallel().SingleOrDefault();
cuantificacion.Estatus = "En Proceso de Recepción";
cuantificacion.UsuarioModificacion = usuario.UsuarioID;
cuantificacion.FechaModificacion = DateTime.Now;
ctx.SaveChanges();
}
TransactionalInformation result = new TransactionalInformation();
result.ReturnMessage.Add("Ok");
result.ReturnCode = 200;
result.ReturnStatus = false;
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 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 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();
}
}
}
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 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);
}
}
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 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 EliminarRelacion(string itemCodeID, string itemCodeSteelgo, string diametro1, string diametro2, Sam3_Usuario usuario)
{
try
{
using (SamContext ctx = new SamContext())
{
int ic = Convert.ToInt32(itemCodeID);
int ics = (from itemCS in ctx.Sam3_ItemCodeSteelgo
where itemCS.Activo && itemCS.Codigo == itemCodeSteelgo
select itemCS.ItemCodeSteelgoID).AsParallel().SingleOrDefault();
int relIC_Diam = (from ricd in ctx.Sam3_Rel_ItemCode_Diametro
where ricd.Activo && ricd.Diametro1ID.ToString() == diametro1 &&
ricd.Diametro2ID.ToString() == diametro2 &&
ricd.ItemCodeID.ToString() == itemCodeID
select ricd.Rel_ItemCode_Diametro_ID).AsParallel().SingleOrDefault();
int relICS_Diam = (from ricsd in ctx.Sam3_Rel_ItemCodeSteelgo_Diametro
where ricsd.Activo && ricsd.Diametro1ID.ToString() == diametro1 &&
ricsd.Diametro2ID.ToString() == diametro2 &&
ricsd.ItemCodeSteelgoID == ics
select ricsd.Rel_ItemCodeSteelgo_Diametro_ID).AsParallel().SingleOrDefault();
Sam3_Rel_ItemCode_ItemCodeSteelgo relacion = ctx.Sam3_Rel_ItemCode_ItemCodeSteelgo.Where(x => x.Rel_ItemCode_Diametro_ID == relIC_Diam &&
x.Rel_ItemCodeSteelgo_Diametro_ID == relICS_Diam &&
x.Activo).AsParallel().SingleOrDefault();
relacion.Activo = false;
relacion.UsuarioModificacion = usuario.UsuarioID;
relacion.FechaModificacion = DateTime.Now;
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);
}
}
/// <summary>
/// Actualiza la informacion de un chofer en base de datos
/// </summary>
/// <param name="chofer"></param>
/// <param name="usuario"></param>
/// <returns></returns>
public object ActualizarChofer(Sam3_Chofer chofer, Sam3_Usuario usuario)
{
try
{
using (SamContext ctx = new SamContext())
{
if (!ctx.Sam3_Chofer.Where(x => x.Nombre == chofer.Nombre && x.Activo).AsParallel().Any())
{
Sam3_Chofer choferEnBd = ctx.Sam3_Chofer.Where(x => x.ChoferID == chofer.ChoferID && x.Activo).AsParallel().SingleOrDefault();
choferEnBd.Activo = chofer.Activo != null && chofer.Activo != choferEnBd.Activo ?
chofer.Activo : choferEnBd.Activo;
choferEnBd.Nombre = chofer.Nombre != null && chofer.Nombre != choferEnBd.Nombre ?
chofer.Nombre : choferEnBd.Nombre;
choferEnBd.TransportistaID = chofer.TransportistaID != null && chofer.TransportistaID != choferEnBd.TransportistaID ?
chofer.TransportistaID : choferEnBd.TransportistaID;
choferEnBd.UsuarioModificacion = usuario.UsuarioID;
choferEnBd.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("Chofer 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 ActualizarPatio(Sam3_Patio cambios, Sam3_Usuario Usuario)
{
try
{
using (SamContext ctx = new SamContext())
{
if (!ctx.Sam3_Patio.Where(x => x.Nombre == cambios.Nombre && x.Activo).AsParallel().Any())
{
Sam3_Patio patioEnBd = ctx.Sam3_Patio.Where(x => x.PatioID == cambios.PatioID && x.Activo).AsParallel().SingleOrDefault();
patioEnBd.Activo = cambios.Activo != null && cambios.Activo != patioEnBd.Activo ?
cambios.Activo : patioEnBd.Activo;
patioEnBd.Descripcion = cambios.Descripcion != null && cambios.Descripcion != patioEnBd.Descripcion ?
cambios.Descripcion : patioEnBd.Descripcion;
patioEnBd.Nombre = cambios.Nombre != null && cambios.Nombre != patioEnBd.Nombre ?
cambios.Nombre : patioEnBd.Nombre;
patioEnBd.Propietario = cambios.Propietario != null && cambios.Propietario != patioEnBd.Propietario ?
cambios.Propietario : patioEnBd.Propietario;
patioEnBd.RequierePermisoAduana = cambios.RequierePermisoAduana != null && cambios.RequierePermisoAduana != patioEnBd.RequierePermisoAduana ?
cambios.RequierePermisoAduana : patioEnBd.RequierePermisoAduana;
patioEnBd.UsuarioModificacion = Usuario.UsuarioID;
patioEnBd.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("Patio 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 InsertarTipoUso(string nombre, Sam3_Usuario usuario)
{
try
{
TransactionalInformation result = new TransactionalInformation();
using (SamContext ctx = new SamContext())
{
if (!ctx.Sam3_TipoUso.Where(x => x.Nombre == nombre).Any())
{
Sam3_TipoUso nuevoTipo = new Sam3_TipoUso();
nuevoTipo.Activo = true;
nuevoTipo.FechaModificacion = DateTime.Now;
nuevoTipo.Nombre = nombre;
nuevoTipo.UsuarioModificacion = usuario.UsuarioID;
ctx.Sam3_TipoUso.Add(nuevoTipo);
ctx.SaveChanges();
result.ReturnMessage.Add(nuevoTipo.TipoUsoID.ToString());
result.ReturnMessage.Add(nuevoTipo.Nombre);
result.ReturnCode = 200;
result.ReturnStatus = true;
result.IsAuthenicated = true;
return(result);
}
else
{
result.ReturnMessage.Add(string.Format("Ya existe un registro con el nombre {0}", nombre));
result.ReturnCode = 500;
result.ReturnStatus = false;
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 GenerarPaseSalida(int folioAvisoLlegadaID, string cuadrillaDescarga, Sam3_Usuario usuario)
{
try
{
using (SamContext ctx = new SamContext())
{
Sam3_FolioAvisoLlegada foliollegadaBd = ctx.Sam3_FolioAvisoLlegada.Where(x => x.FolioAvisoLlegadaID == folioAvisoLlegadaID)
.AsParallel().SingleOrDefault();
foliollegadaBd.PaseSalidaEnviado = true;
foliollegadaBd.FechaModificacion = DateTime.Now;
foliollegadaBd.UsuarioModificacion = usuario.UsuarioID;
foliollegadaBd.CuadrillaDescarga = cuadrillaDescarga;
Sam3_FolioAvisoEntrada folioEntradaBd = ctx.Sam3_FolioAvisoEntrada.Where(x => x.FolioAvisoLlegadaID == folioAvisoLlegadaID)
.AsParallel().SingleOrDefault();
folioEntradaBd.FechaFinDescarga = DateTime.Now;
folioEntradaBd.FechaModificacion = DateTime.Now;
folioEntradaBd.UsuarioModificacion = usuario.UsuarioID;
ctx.SaveChanges();
if (!(bool)EnviarAvisosBd.Instance.EnviarNotificación(3,
string.Format("Se generó un nuevo pase de salida para el folio {0} con fecha {1}",
foliollegadaBd.FolioAvisoLlegadaID, foliollegadaBd.FechaModificacion), 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 ActualizarPlana(VehiculoJson cambios, Sam3_Usuario usuario)
{
try
{
TransactionalInformation result;
using (SamContext ctx = new SamContext())
{
if (!ctx.Sam3_Vehiculo.Where(c => c.Placas == cambios.Placas && c.TipoVehiculoID == 2 && c.Activo).AsParallel().Any())
{
int vehiculoID = Convert.ToInt32(cambios.VehiculoID);
Sam3_Vehiculo planaEnBd = ctx.Sam3_Vehiculo.Where(x => x.VehiculoID == vehiculoID).AsParallel().SingleOrDefault();
planaEnBd.Activo = true;
planaEnBd.TractoID = Convert.ToInt32(cambios.TractoID);
planaEnBd.Placas = cambios.Placas;
planaEnBd.Unidad = cambios.Unidad;
planaEnBd.Modelo = cambios.Modelo;
planaEnBd.UsuarioModificacion = usuario.UsuarioID;
planaEnBd.FechaModificacion = DateTime.Now;
ctx.SaveChanges();
result = new TransactionalInformation();
result.ReturnCode = 200;
result.ReturnStatus = true;
result.ReturnMessage.Add("OK");
result.IsAuthenicated = true;
return(result);
}
else
{
throw new Exception("Plana 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 InsertarItemCodeSteelgo(ItemCodeSteelgoJson json, Sam3_Usuario usuario)
{
try
{
using (SamContext ctx = new SamContext())
{
Sam3_ItemCodeSteelgo nuevoItem = new Sam3_ItemCodeSteelgo();
nuevoItem.Activo = true;
nuevoItem.Area = json.Area;
nuevoItem.CedulaID = json.CedulaID;
nuevoItem.DescripcionEspanol = json.DescripcionEspanol;
nuevoItem.DescripcionIngles = json.DescripcionIngles;
//nuevoItem.Diametro1 = json.Diametro1;
//nuevoItem.Diametro2 = json.Diametro2;
nuevoItem.FamiliaAceroID = json.FamiliaAceroID;
nuevoItem.FechaModificacion = DateTime.Now;
nuevoItem.Peso = json.Peso;
nuevoItem.UsuarioModificacion = usuario.UsuarioID;
nuevoItem.Codigo = json.Codigo;
ctx.Sam3_ItemCodeSteelgo.Add(nuevoItem);
ctx.SaveChanges();
TransactionalInformation result = new TransactionalInformation();
result.ReturnMessage.Add(nuevoItem.ItemCodeSteelgoID.ToString());
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>
/// Guarda Registro de los documentos cargados para el pase de salida
/// </summary>
/// <param name="documentos"></param>
/// <returns></returns>
public object GuardarDocumentoPaseSalida(List <DocumentoPosteado> documentos)
{
try
{
using (SamContext ctx = new SamContext())
{
int Folio = documentos[0].FolioAvisoLlegadaID.GetValueOrDefault();
//Actualizamos el dato de Pase Salida Enviado del Folio aviso Llegada
Sam3_FolioAvisoLlegada folioBd = ctx.Sam3_FolioAvisoLlegada.Where(x => x.FolioAvisoLlegadaID == Folio && x.Activo)
.AsParallel().SingleOrDefault();
foreach (DocumentoPosteado d in documentos)
{
int tipoArchivoId = ctx.Sam3_TipoArchivo.Where(x => x.Nombre == d.TipoArchivoPaseSalida && x.Activo).Select(x => x.TipoArchivoID)
.AsParallel().SingleOrDefault();
Sam3_Rel_FolioAvisoLlegada_PaseSalida_Archivo nuevoDoc = new Sam3_Rel_FolioAvisoLlegada_PaseSalida_Archivo();
nuevoDoc.Activo = true;
nuevoDoc.ContentType = d.ContentType;
nuevoDoc.DocGuid = d.DocGuid;
nuevoDoc.DocumentoID = 0;
nuevoDoc.Extencion = d.Extencion;
nuevoDoc.FechaModificacion = DateTime.Now;
nuevoDoc.FolioAvisoLlegadaID = folioBd.FolioAvisoLlegadaID;
nuevoDoc.Nombre = d.FileName;
nuevoDoc.TipoArchivoID = tipoArchivoId;
nuevoDoc.Url = d.Path;
nuevoDoc.UsuarioModificacion = d.UserId;
nuevoDoc.IncidenciaID = d.IncidenciaID == -1 ? null : d.IncidenciaID;
ctx.Sam3_Rel_FolioAvisoLlegada_PaseSalida_Archivo.Add(nuevoDoc);
}
ctx.SaveChanges();
return(true);
}
}
catch (Exception ex)
{
//-----------------Agregar mensaje al Log -----------------------------------------------
LoggerBd.Instance.EscribirLog(ex);
//-----------------Agregar mensaje al Log -----------------------------------------------
return(false);
}
}
public object InsertarRelacionItemCodes(List <AsociacionItemCodeSteelgo> asociaciones, Sam3_Usuario usuario)
{
try
{
using (SamContext ctx = new SamContext())
{
Sam3_Rel_ItemCode_ItemCodeSteelgo nuevoRegistro;
foreach (AsociacionItemCodeSteelgo asc in asociaciones)
{
foreach (int i in asc.Itemcodes)
{
nuevoRegistro = new Sam3_Rel_ItemCode_ItemCodeSteelgo();
nuevoRegistro.Activo = true;
nuevoRegistro.FechaModificacion = DateTime.Now;
nuevoRegistro.ItemCodeID = i;
nuevoRegistro.ItemCodeSteelgoID = asc.ItemCodeSteelgo;
nuevoRegistro.UsuarioModificacion = usuario.UsuarioID;
ctx.Sam3_Rel_ItemCode_ItemCodeSteelgo.Add(nuevoRegistro);
}
}
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 ActualizarItemCodeSteelgo(ItemCodeSteelgoJson json, Sam3_Usuario usuario)
{
try
{
using (SamContext ctx = new SamContext())
{
Sam3_ItemCodeSteelgo itemBd = ctx.Sam3_ItemCodeSteelgo.Where(x => x.ItemCodeSteelgoID == json.ItemCodeSteelgoID)
.AsParallel().SingleOrDefault();
itemBd.Area = json.Area;
itemBd.CedulaID = json.CedulaID;
itemBd.DescripcionEspanol = json.DescripcionEspanol;
itemBd.DescripcionIngles = json.DescripcionIngles;
//itemBd.Diametro1 = json.Diametro1;
//itemBd.Diametro2 = json.Diametro2;
itemBd.FamiliaAceroID = json.FamiliaAceroID;
itemBd.FechaModificacion = DateTime.Now;
itemBd.Peso = json.Peso;
itemBd.UsuarioModificacion = usuario.UsuarioID;
itemBd.Codigo = json.Codigo;
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);
}
}
/// <summary>
/// Genera un nuevo registro de tipo Chofer
/// </summary>
/// <param name="chofer">Propiedades del nuevo registro</param>
/// <param name="usuario">Información del usuario</param>
/// <returns>JSON {"Nombre": "xxxx", "ChoferID":"10"}</returns>
public object InsertarChofer(Sam3_Chofer chofer, Sam3_Usuario usuario)
{
try
{
using (SamContext ctx = new SamContext())
{
if (!ctx.Sam3_Chofer.Where(x => x.Nombre == chofer.Nombre && x.TransportistaID == chofer.TransportistaID && x.Activo).AsParallel().Any())
{
Sam3_Chofer nuevoChofer = new Sam3_Chofer();
nuevoChofer.Activo = true;
nuevoChofer.FechaModificacion = DateTime.Now;
nuevoChofer.Nombre = chofer.Nombre;
nuevoChofer.UsuarioModificacion = usuario.UsuarioID;
nuevoChofer.TransportistaID = chofer.TransportistaID;
ctx.Sam3_Chofer.Add(nuevoChofer);
ctx.SaveChanges();
return(new Chofer {
Nombre = chofer.Nombre, ChoferID = chofer.ChoferID.ToString()
});
}
else
{
throw new Exception("Chofer 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);
}
}
/// <summary>
/// Guarda los documentos que se cargan para los folios de aviso de llegada
/// </summary>
/// <param name="files"></param>
/// <returns></returns>
public bool GuardarArchivosFolioAvisoLlegada(List <DocumentoPosteado> files)
{
try
{
using (SamContext ctx = new SamContext())
{
foreach (DocumentoPosteado f in files)
{
int tipoArchivoId = ctx.Sam3_TipoArchivo.Where(x => x.Nombre == f.TipoArchivoPaseSalida && x.Activo).Select(x => x.TipoArchivoID)
.AsParallel().SingleOrDefault();
Sam3_Rel_FolioAvisoLlegada_Documento nuevoDoc = new Sam3_Rel_FolioAvisoLlegada_Documento();
nuevoDoc.Activo = true;
nuevoDoc.DocumentoID = 0;
nuevoDoc.DocGuid = f.DocGuid;
nuevoDoc.Extencion = f.Extencion;
nuevoDoc.FechaModificacion = DateTime.Now;
nuevoDoc.FolioAvisoLlegadaID = f.FolioAvisoLlegadaID.Value;
nuevoDoc.Nombre = f.FileName;
nuevoDoc.Url = f.Path;
nuevoDoc.UsuarioModificacion = f.UserId;
nuevoDoc.TipoArchivoID = tipoArchivoId;
nuevoDoc.ContentType = f.ContentType;
ctx.Sam3_Rel_FolioAvisoLlegada_Documento.Add(nuevoDoc);
}
ctx.SaveChanges();
return(true);
}
}
catch (Exception ex)
{
//-----------------Agregar mensaje al Log -----------------------------------------------
LoggerBd.Instance.EscribirLog(ex);
//-----------------Agregar mensaje al Log -----------------------------------------------
return(false);
}
}
/// <summary>
/// Método para Insertar el mensaje de tipo Notificación obtenido de la cola de mensajes
/// a la Base de datos
/// </summary>
/// <param name="notification">Mensaje tipo Notificacion</param>
public static void insertNotification(Notificacion notification)
{
using (SamContext ctx = new SamContext())
{
Sam3_Notificacion noti = new Sam3_Notificacion();
//noti.NotificacionID = notification.NotificacionID;
noti.UsuarioIDReceptor = notification.UsuarioIDReceptor;
noti.UsuarioIDEmisor = notification.UsuarioIDEmisor;
noti.TipoNotificacionID = notification.TipoNotificacionID;
noti.Mensaje = notification.Mensaje;
noti.FechaEnvio = notification.FechaEnvio;
noti.FechaRecepcion = DateTime.Now; //????
noti.EstatusLectura = false;
noti.Activo = true;
noti.UsuarioModificacion = notification.UsuarioModificacion;
noti.FechaModificacion = notification.FechaModificacion;
ctx.Sam3_Notificacion.Add(noti);
ctx.SaveChanges();
}
}
/// <summary>
/// Inserta un nuevo contacto
/// </summary>
/// <param name="cambios"></param>
/// <param name="usuario"></param>
/// <returns></returns>
public object InsertatContacto(Sam3_Contacto cambios, Sam3_Usuario usuario)
{
try
{
using (SamContext ctx = new SamContext())
{
Sam3_Contacto nuevoContacto = new Sam3_Contacto();
nuevoContacto.Activo = true;
nuevoContacto.ApMaterno = cambios.ApMaterno;
nuevoContacto.ApPaterno = cambios.ApPaterno;
nuevoContacto.CorreoElectronico = cambios.CorreoElectronico;
nuevoContacto.FechaModificacion = DateTime.Now;
nuevoContacto.Nombre = cambios.Nombre;
nuevoContacto.TelefonoCelular = cambios.TelefonoCelular;
nuevoContacto.TelefonoOficina = cambios.TelefonoOficina;
nuevoContacto.TelefonoParticular = cambios.TelefonoParticular;
nuevoContacto.UsuarioModificacion = usuario.UsuarioID;
ctx.Sam3_Contacto.Add(nuevoContacto);
ctx.SaveChanges();
return(new Contacto {
ContactoID = nuevoContacto.ContactoID.ToString(), Nombre = nuevoContacto.Nombre
});
}
}
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 InsertarPatio(Sam3_Patio cambios, Sam3_Usuario usuario)
{
try
{
using (SamContext ctx = new SamContext())
{
if (!ctx.Sam3_Patio.Where(x => x.Nombre == cambios.Nombre && x.Activo).AsParallel().Any())
{
cambios.Activo = true;
cambios.UsuarioModificacion = usuario.UsuarioID;
cambios.FechaModificacion = DateTime.Now;
ctx.Sam3_Patio.Add(cambios);
ctx.SaveChanges();
return(new Patio {
Nombre = cambios.Nombre, PatioID = cambios.PatioID.ToString()
});
}
else
{
throw new Exception("Patio 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);
}
}
/// <summary>
/// Funccion para guardar un documento para un catalogo
/// </summary>
/// <param name="files"></param>
/// <returns></returns>
public bool GuardarDocumentoCatalogos(List <DocumentosEnCatalogos> files)
{
try
{
using (SamContext ctx = new SamContext())
{
foreach (DocumentosEnCatalogos f in files)
{
Sam3_Rel_Catalogos_Documento nuevoDoc = new Sam3_Rel_Catalogos_Documento();
nuevoDoc.Activo = true;
nuevoDoc.DocumentoID = 0;
nuevoDoc.DocGuid = f.DocGuid;
nuevoDoc.Extension = f.Extension;
nuevoDoc.FechaModificacion = DateTime.Now;
nuevoDoc.CatalogoID = Int32.Parse(f.CatalogoID);
nuevoDoc.ElementoCatalogoID = Int32.Parse(f.ElementoCatalogoID);
nuevoDoc.Nombre = f.FileName;
nuevoDoc.Url = f.Path;
nuevoDoc.UsuarioModificacion = f.UserId;
nuevoDoc.TipoArchivoID = f.TipoArchivoID;
nuevoDoc.ContentType = f.ContentType;
ctx.Sam3_Rel_Catalogos_Documento.Add(nuevoDoc);
}
ctx.SaveChanges();
return(true);
}
}
catch (Exception ex)
{
//-----------------Agregar mensaje al Log -----------------------------------------------
LoggerBd.Instance.EscribirLog(ex);
//-----------------Agregar mensaje al Log -----------------------------------------------
return(false);
}
}
/// <summary>
/// Elimina logicamente un documento de pase de salida
/// </summary>
/// <param name="documentoID"></param>
/// <param name="usuario"></param>
/// <returns></returns>
public object EliminarDocumentoPaseSalida(int documentoID, Sam3_Usuario usuario)
{
try
{
using (SamContext ctx = new SamContext())
{
Sam3_Rel_FolioAvisoLlegada_PaseSalida_Archivo docBd = ctx.Sam3_Rel_FolioAvisoLlegada_PaseSalida_Archivo
.Where(x => x.Rel_Folio_PaseSalida_Archivo_ID == documentoID).AsParallel().SingleOrDefault();
docBd.Activo = false;
docBd.FechaModificacion = DateTime.Now;
docBd.UsuarioModificacion = usuario.UsuarioID;
ctx.SaveChanges();
TransactionalInformation result = new TransactionalInformation();
result.ReturnMessage.Add("Ok");
result.ReturnCode = 200;
result.ReturnStatus = false;
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>
/// Guarda registrso de los documentos cargados en para los avisos de entrada
/// </summary>
/// <param name="files"></param>
/// <returns></returns>
public bool GuardarArchivosFolioAvisoEntrada(List <DocumentoPosteado> files)
{
try
{
using (SamContext ctx = new SamContext())
{
foreach (DocumentoPosteado f in files)
{
Sam3_Rel_FolioAvisoEntrada_Documento nuevoDoc = new Sam3_Rel_FolioAvisoEntrada_Documento();
nuevoDoc.Activo = true;
nuevoDoc.DocumentoID = 0;
nuevoDoc.DocGuid = f.DocGuid;
nuevoDoc.Extencion = f.Extencion;
nuevoDoc.FechaModificacion = DateTime.Now;
nuevoDoc.FolioAvisoEntradaID = f.FolioAvisoEntradaID;
nuevoDoc.Nombre = f.FileName;
nuevoDoc.Url = f.Path;
nuevoDoc.UsuarioModificacion = f.UserId;
nuevoDoc.TipoArchivoID = f.TipoArchivoID;
nuevoDoc.ContentType = f.ContentType;
nuevoDoc.Descripcion = f.Descripcion;
ctx.Sam3_Rel_FolioAvisoEntrada_Documento.Add(nuevoDoc);
}
ctx.SaveChanges();
return(true);
}
}
catch (Exception ex)
{
//-----------------Agregar mensaje al Log -----------------------------------------------
LoggerBd.Instance.EscribirLog(ex);
//-----------------Agregar mensaje al Log -----------------------------------------------
return(false);
}
}
public object ActualizarTipoArchivo(Sam3_TipoArchivo cambios, Sam3_Usuario usuario)
{
try
{
using (SamContext ctx = new SamContext())
{
Sam3_TipoArchivo tipoArchivoBd = ctx.Sam3_TipoArchivo.Where(x => x.TipoArchivoID == cambios.TipoArchivoID)
.AsParallel().SingleOrDefault();
tipoArchivoBd.Nombre = cambios.Nombre;
tipoArchivoBd.FechaModificacion = DateTime.Now;
tipoArchivoBd.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 EliminarPredespacho(string lista, Sam3_Usuario usuario)
{
JavaScriptSerializer ser = new JavaScriptSerializer();
int[] ids = ser.Deserialize <int[]>(lista);
using (SamContext ctx = new SamContext()) {
foreach (int id in ids)
{
Sam3_PreDespacho pred = ctx.Sam3_PreDespacho.Where(x => x.PreDespachoID == id).FirstOrDefault();
pred.Activo = false;
pred.FechaModificacion = DateTime.Now;
pred.UsuarioModificacion = usuario.UsuarioID;
ctx.SaveChanges();
}
}
TransactionalInformation result = new TransactionalInformation();
//result.ReturnMessage.Add(preDespacho.PreDespachoID.ToString());
result.ReturnCode = 200;
result.ReturnStatus = true;
result.IsAuthenicated = true;
return(result);
}
/// <summary>
/// Funcion para el boton Predespachar
/// Pantalla pre despacho
/// </summary>
/// <param name="lista"></param>
/// <param name="usuario"></param>
/// <returns></returns>
public object Predespachar(List <PreDespachoItems> lista, Sam3_Usuario usuario)
{
try
{
int preDespachoID = 0;
using (SamContext ctx = new SamContext())
{
using (var ctx_tran = ctx.Database.BeginTransaction())
{
using (Sam2Context ctx2 = new Sam2Context())
{
foreach (PreDespachoItems item in lista)
{
preDespachoID = item.PreDespachoID != "" ? Convert.ToInt32(item.PreDespachoID) : 0;
bool tieneHold = (from sh in ctx2.SpoolHold
where sh.SpoolID == (from odts in ctx2.OrdenTrabajoSpool
where odts.OrdenTrabajoSpoolID.ToString() == item.NumeroControl
select odts.SpoolID).FirstOrDefault() &&
(sh.TieneHoldCalidad || sh.TieneHoldIngenieria || sh.Confinado)
select sh).AsParallel().Any();
if (!tieneHold)
{
DatabaseManager.Sam2.ItemCode itemCode = (from it in ctx2.ItemCode
where it.ItemCodeID.ToString() == item.ItemCode
select it).AsParallel().SingleOrDefault();
int proyectoID = itemCode.ProyectoID;
int sam3_ProyectoID = (from eqp in ctx.Sam3_EquivalenciaProyecto
where eqp.Activo && eqp.Sam2_ProyectoID == proyectoID
select eqp.Sam3_ProyectoID).AsParallel().SingleOrDefault();
int sam3_ItemCodeID = (from eqi in ctx.Sam3_EquivalenciaItemCode
where eqi.Activo && eqi.Sam2_ItemCodeID == itemCode.ItemCodeID
select eqi.Sam3_ItemCodeID).AsParallel().SingleOrDefault();
//Dividimos el codigo del numero para buscarlo en sam3
string[] elementosCodigo = item.NumeroUnico.Split('-').ToArray();
int consecutivoNumeroUnico = Convert.ToInt32(elementosCodigo[1]);
string prefijoNumeroUnico = elementosCodigo[0];
//int sam3_ProyectoID = (from nueq in ctx.Sam3_EquivalenciaProyecto
// where nueq.Activo && nueq.Sam2_ProyectoID == proyectoID
// select nueq.Sam3_ProyectoID).AsParallel().SingleOrDefault();
//traemos los datos de la orden de trabajo spool de Sam2
OrdenTrabajoSpool odtSpool = (from odts in ctx2.OrdenTrabajoSpool
join odt in ctx2.OrdenTrabajo on odts.OrdenTrabajoID equals odt.OrdenTrabajoID
where odts.OrdenTrabajoSpoolID.ToString() == item.NumeroControl &&
odt.ProyectoID == proyectoID
select odts).AsParallel().SingleOrDefault();
//traemos los datos del material de Sam 2
MaterialSpool materialSpool = (from ms in ctx2.MaterialSpool
join odts in ctx2.OrdenTrabajoSpool on ms.SpoolID equals odts.SpoolID
where odts.OrdenTrabajoSpoolID == odtSpool.OrdenTrabajoSpoolID &&
ms.Etiqueta == item.Etiqueta
select ms).AsParallel().SingleOrDefault();
//traemos los datos de la orden de trabajo material de Sam 2
OrdenTrabajoMaterial odtMaterial = (from odtm in ctx2.OrdenTrabajoMaterial
where odtm.OrdenTrabajoSpoolID == odtSpool.OrdenTrabajoSpoolID &&
odtm.MaterialSpoolID == materialSpool.MaterialSpoolID
select odtm).AsParallel().SingleOrDefault();
//buscamos el numero unico en SAM 3
if (ctx.Sam3_NumeroUnico.Where(x => x.Prefijo == prefijoNumeroUnico &&
x.Consecutivo == consecutivoNumeroUnico && x.ProyectoID == sam3_ProyectoID).AsParallel().Any())
{
//int sam2_numeroUnicoID = 0;
// numero unico seleccionado en el grid
Sam3_NumeroUnico numeroUnico = ctx.Sam3_NumeroUnico.Where(x => x.Prefijo == prefijoNumeroUnico &&
x.Consecutivo == consecutivoNumeroUnico && x.ProyectoID == sam3_ProyectoID).AsParallel().SingleOrDefault();
if (preDespachoID > 0) // existe el predespacho
{
Sam3_PreDespacho preDespacho = (from pre in ctx.Sam3_PreDespacho
where pre.Activo &&
pre.PreDespachoID == preDespachoID
select pre).AsParallel().SingleOrDefault();
// si el numero Unico seleccionado es diferente del numero unico que se encuentra registrado en el predespacho
if (preDespachoID > 0 && preDespacho.NumeroUnicoID != numeroUnico.NumeroUnicoID)
{
preDespacho.Activo = true;
preDespacho.FechaModificacion = DateTime.Now;
preDespacho.FechaPreDespacho = DateTime.Now;
preDespacho.UsuarioModificacion = usuario.UsuarioID;
preDespacho.ProyectoID = sam3_ProyectoID;
preDespacho.NumeroUnicoID = numeroUnico.NumeroUnicoID;
preDespacho.Cantidad = (int)odtMaterial.CantidadCongelada;
ctx.SaveChanges();
}
}
else
{
Sam3_PreDespacho preDespacho = new Sam3_PreDespacho();
preDespacho.Activo = true;
preDespacho.FechaModificacion = DateTime.Now;
preDespacho.FechaPreDespacho = DateTime.Now;
preDespacho.UsuarioModificacion = usuario.UsuarioID;
preDespacho.ProyectoID = sam3_ProyectoID;
preDespacho.OrdenTrabajoSpoolID = Convert.ToInt32(item.NumeroControl);
preDespacho.NumeroUnicoID = numeroUnico.NumeroUnicoID;
preDespacho.MaterialSpoolID = odtMaterial.MaterialSpoolID;
preDespacho.ItemCodeID = sam3_ItemCodeID;
preDespacho.Cantidad = (int)odtMaterial.CantidadCongelada;
ctx.Sam3_PreDespacho.Add(preDespacho);
ctx.SaveChanges();
}
}
}
else
{
throw new Exception("El Spool cuenta con Hold, no se puede Pre-Despachar");
}
}
ctx_tran.Commit();
TransactionalInformation result = new TransactionalInformation();
//result.ReturnMessage.Add(preDespacho.PreDespachoID.ToString());
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);
}
}