public CommandContracts.Common.CommandResult Handle(ActualizarGuiaOrdenCommand command)
{
if (command == null)
{
throw new ArgumentException("Tiene que seleccionar una orden");
}
//Actualiza la guia de remision transportista
OrdenTrabajo orden = null;
orden = _ActualizarGuiaOrdenRepository.Get(x => x.idordentrabajo == command.idordentransporte).LastOrDefault();
orden.guiatransportista = command.guiatransportista;
try
{
_ActualizarGuiaOrdenRepository.SaveChanges();
return(new TransbordarVehiculoOutput()
{
idvehiculo = 1
});
}
catch (Exception ex)
{
throw;
}
}
public async Task <OrdenTrabajo> ConsultarOrdenDeTrabajoPorGuid(string guidOrdenDeTrabajo, UsuarioDTO usuario)
{
try
{
OrdenTrabajo ordenTrabajo = await _context.OrdenTrabajo
.Include(c => c.Anexos)
.Include(c => c.Cliente)
.Include(c => c.Linea)
.Include(c => c.Herramienta)
.Include(c => c.TamanoHerramienta)
.Include(c => c.Material)
.Include(c => c.Prioridad)
.Include(c => c.Material.Material)
.Include(c => c.Herramienta.TamanosHerramienta)
.Include(c => c.TipoServicio)
.Include(c => c.Estado)
.Include(c => c.Responsable)
.FirstOrDefaultAsync(c => c.Guid.ToString() == guidOrdenDeTrabajo);
ordenTrabajo.Anexos = await _context.OrdenTrabajoAnexos
.Include(c => c.DocumentoAdjunto)
.Include(c => c.OrdenTrabajo)
.Where(c => c.OrdenTrabajo.Guid.ToString() == guidOrdenDeTrabajo).ToListAsync();
return(ordenTrabajo);
}
catch (Exception)
{
throw;
}
}
public async Task <HttpResponseMessage> DeleteOrdenTrabajo(IdModelOrdenTrabajo Id)
{
try
{
_ordenTrabajo = await db.OrdenTrabajo.FindAsync(Id.IdOrdenTrabajo);
if (_ordenTrabajo == null)
{
return(new HttpResponseMessage(HttpStatusCode.NoContent));
}
else
{
_ordenTrabajo.Activo_Inactivo = false;
db.Entry(_ordenTrabajo).State = EntityState.Modified;
await db.SaveChangesAsync();
return(new HttpResponseMessage(HttpStatusCode.OK));
}
}
catch (Exception ex)
{
return(new HttpResponseMessage(HttpStatusCode.InternalServerError)
{
Content = new StringContent(ex.Message)
});
}
}
public int AddOrdenTrabajoGarantia(OrdenTrabajo ot)
{
using (var sqlConn = new SqlConnection(strConn))
{
sqlConn.Open();
var cmd = new SqlCommand(strConn, sqlConn)
{
CommandType = CommandType.StoredProcedure, CommandText = "sp_add_ordenTrabajo_garantia"
};
SqlParameter oParam =
cmd.Parameters.AddWithValue("@id_orden_trabajo", 0);
cmd.Parameters.AddWithValue("@patente", ot.Patente);
cmd.Parameters.AddWithValue("@correo", ot.Observacion);
cmd.Parameters.AddWithValue("@cuenta_usuario", ot.CuentaUsuario);
cmd.Parameters.AddWithValue("@rut", ot.RutAdquiriente);
cmd.Parameters.AddWithValue("@id_cliente", ot.IdCliente);
cmd.Parameters.AddWithValue("@id_sucursal", ot.IdSucursal);
cmd.Parameters.AddWithValue("@numero_orden", ot.NumeroOrden);//numero operacion
oParam.Direction = ParameterDirection.Output;
cmd.ExecuteNonQuery();
var nTheNewId = Convert.ToInt32(cmd.Parameters["@id_orden_trabajo"].Value);
sqlConn.Close();
return(nTheNewId);
}
}
public async Task <HttpResponseMessage> GetOrdenTrabajo(IdModelOrdenTrabajo Id)
{
try
{
_ordenTrabajo = await db.OrdenTrabajo.FindAsync(Id.IdOrdenTrabajo);
if (_ordenTrabajo == null)
{
return(new HttpResponseMessage(HttpStatusCode.NoContent));
}
else
{
return(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(JsonConvert.SerializeObject(_ordenTrabajo), System.Text.Encoding.UTF8, "application/json")
});
}
}
catch (Exception ex)
{
return(new HttpResponseMessage(HttpStatusCode.InternalServerError)
{
Content = new StringContent(ex.Message)
});
}
}
public async Task <IActionResult> PutOrdenTrabajo(int id, OrdenTrabajo ordenTrabajo)
{
if (id != ordenTrabajo.Id)
{
return(BadRequest());
}
_context.Entry(ordenTrabajo).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!OrdenTrabajoExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <ActionResult <OrdenTrabajo> > PostOrdenTrabajo(OrdenTrabajo ordenTrabajo)
{
_context.OrdenTrabajo.Add(ordenTrabajo);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetOrdenTrabajo", new { id = ordenTrabajo.Id }, ordenTrabajo));
}
protected void dgPrensaOrdenTrabajo_BatchUpdate(object sender, DevExpress.Web.Data.ASPxDataBatchUpdateEventArgs e)
{
try
{
using (var db = new UnidadDeTrabajo())
{
OrdenTrabajo ordenTrabajo = db.OrdenTrabajo.ObtenerPorId(int.Parse(lblIdOrden.Text));
ordenTrabajo.OperadoresPrensa = cmbOperadorP.Text;
ordenTrabajo.ComentariosPrensa = txtObservacionesP.Text;
db.OrdenTrabajo.Actualizar(ordenTrabajo);
db.Grabar();
foreach (var item in e.InsertValues)
{
db.PrensaOrdenTrabajo.InsertarValoresPrensaOrdenTrabajo(item.NewValues, int.Parse(lblIdOrden.Text.ToString()));
}
foreach (var item in e.UpdateValues)
{
db.PrensaOrdenTrabajo.ActualizarValoresPrensaOrden(item.Keys, item.NewValues);
}
}
//pcEditorOrdenesTrabajo.ShowOnPageLoad = false;
dgPrensaOrdenTrabajo.JSProperties["cpPrensaOrden"] = "Operación realizada con éxito";
CargarDatosPrensaOrdenTrabajo(int.Parse(lblIdOrden.Text));
}
catch (Exception ex)
{
dgPrensaOrdenTrabajo.JSProperties["cpPrensaOrden"] = "Ha ocurrido un error inesperado: " + ex.Message;
}
e.Handled = true;
}
protected void cpSaveDatosOT_Callback(object sender, CallbackEventArgsBase e)
{
try
{
using (var db = new UnidadDeTrabajo())
{
OrdenTrabajo ot = db.OrdenTrabajo.ObtenerPorId(int.Parse(lblIdOrden.Text));
switch (int.Parse(e.Parameter))
{
case 1:
//ot.OperadoresBodegaInventario = cmbOperadorB.Text;
//ot.ComentariosBodegaInventario = txtObservacionesB.Text;
break;
case 2:
ot.OperadoresPrensa = cmbOperadorP.Text;
ot.ComentariosPrensa = txtObservacionesP.Text;
break;
}
db.OrdenTrabajo.Actualizar(ot);
db.Grabar();
cpSaveDatosOT.JSProperties["cpResultado"] = "Operación realizada con éxito";
}
}
catch (Exception ex)
{
cpSaveDatosOT.JSProperties["cpResultado"] = "Error: " + ex.Message;
}
}
/// <summary>
/// Metodo encargado de insertar un registro falla
/// </summary>
/// <param name="id_orden_trabajo"></param>
/// <param name="descripcion"></param>
/// <param name="fecha"></param>
/// <param name="id_usuario"></param>
/// <returns></returns>
public static RetornoOperacion InsertaFalla(int id_orden_trabajo, string descripcion, DateTime fecha, int id_usuario)
{
//Declarando objeto de retorno
RetornoOperacion resultado = new RetornoOperacion();
//Instanciando la Orden de Trabajo a la cual se asociará
using (OrdenTrabajo ot = new OrdenTrabajo(id_orden_trabajo))
{
//Si el estatus de la OT es distinto de terminado
if (ot.EstatusOrden != OrdenTrabajo.EstatusOrdenTrabajo.Terminada)
{
//Inicializando arreglo de parámetros
object[] param = { 1, 0, id_orden_trabajo, descripcion, TSDK.Base.Fecha.ConvierteDateTimeObjeto(fecha), id_usuario, true, "", "" };
//Realizamos la inserción del registro
resultado = CapaDatos.m_capaDeDatos.EjecutaProcAlmacenadoObjeto(nombre_stored_procedure, param);
}
else
{
//De lo contrario
resultado = new RetornoOperacion("No es posible añadir fallas a una Orden de Trabajo ya Terminada.");
}
}
//Devolvineod el resultado
return(resultado);
}
/// <summary>
/// Metodo encargado de editar un registro falla
/// </summary>
/// <param name="id_orden_trabajo"></param>
/// <param name="descripcion"></param>
/// <param name="fecha"></param>
/// <param name="id_usuario"></param>
/// <param name="habilitar"></param>
/// <returns></returns>
private RetornoOperacion editaRegistroFalla(int id_orden_trabajo, string descripcion, DateTime fecha, int id_usuario, bool habilitar)
{
//Declarando objeto de retorno
RetornoOperacion resultado = new RetornoOperacion();
//Instanciando la Orden de Trabajo a la cual se asociará
using (OrdenTrabajo ot = new OrdenTrabajo(id_orden_trabajo))
{
//Si el estatus de la OT es distinto de terminado
if (ot.EstatusOrden != OrdenTrabajo.EstatusOrdenTrabajo.Terminada)
{
//Inicializando arreglo de parámetros
object[] param = { 2, this.id_falla, id_orden_trabajo, descripcion, TSDK.Base.Fecha.ConvierteDateTimeObjeto(fecha), id_usuario, habilitar, "", "" };
//Realizando actualizacion
return(CapaDatos.m_capaDeDatos.EjecutaProcAlmacenadoObjeto(nombre_stored_procedure, param));
}
else
{
//De lo contrario
resultado = new RetornoOperacion("No es posible modificar fallas de una Orden de Trabajo ya Terminada.");
}
}
//Devolvineod el resultado
return(resultado);
}
public OrdenTrabajo Post([FromBody]OrdenTrabajo orden)
{
// Console.Write("HOLA " + orden.ListaDetalleVehiculo[1].Estado.Descripcion);
OrdenData ordenData =
new OrdenData(configuration.GetConnectionString("TallerContext").ToString());
return ordenData.insertar(orden);
}
public CommandContracts.Common.CommandResult Handle(AgregarRecargoCommand command)
{
OrdenTrabajo dominio = null;
if (command.idordentrabajo.HasValue)
{
dominio = _OrdenTrabajoRepository.Get(x => x.idordentrabajo == command.idordentrabajo).LastOrDefault();
}
else
{
throw new ArgumentException("Tiene que ingresar una OT");
}
dominio.recargo = command.recargo;
dominio.subtotalfinal = dominio.subtotal.Value + dominio.recargo;
try
{
_OrdenTrabajoRepository.SaveChanges();
return(new InsertarActualizarPreliquidacionOutput()
{
idordentrabajo = dominio.idordentrabajo
});
}
catch (Exception ex)
{
// _ValortablaRepository.Delete(dominio);
//_ValortablaRepository.Commit();
throw;
}
}
public async Task <HttpResponseMessage> PutOrdenTrabajo(OrdenTrabajo OrdenTrabajo)
{
try
{
_ordenTrabajo = await db.OrdenTrabajo.FindAsync(OrdenTrabajo.IdOrdenTrabajo);
if (_ordenTrabajo == null)
{
return(new HttpResponseMessage(HttpStatusCode.NoContent));
}
else
{
await db.SaveChangesAsync();
return(new HttpResponseMessage(HttpStatusCode.OK));
}
}
catch (Exception ex)
{
return(new HttpResponseMessage(HttpStatusCode.InternalServerError)
{
Content = new StringContent(ex.Message)
});
}
}
public OrdenTrabajo GetOrdenTrabajo(int idOt)
{
using (var sqlConn = new SqlConnection(strConn))
{
sqlConn.Open();
var cmd = new SqlCommand(strConn, sqlConn)
{
CommandType = System.Data.CommandType.StoredProcedure, CommandText = "sp_getOrdenTrabajo"
};
cmd.Parameters.AddWithValue("@id_orden_trabajo", idOt);
var reader = cmd.ExecuteReader();
var ot = new OrdenTrabajo();
if (reader.Read())
{
ot.IdOrden = Convert.ToInt32(reader["id_orden_trabajo"]);
ot.Activo = Convert.ToBoolean(reader["activo"]);
ot.CuentaUsuario = reader["id_usuario"].ToString();
ot.QuienPaga = reader["responsable_pago"].ToString();
ot.TmEspecial = reader["terminacion_especial"].ToString();
ot.FechaIngreso = reader["fecha_ingreso"].ToString();
ot.NumeroOrden = reader["num_orden_trabajo"].ToString();
ot.NumeroFactura = reader["num_factura"].ToString();
ot.IdCliente = Convert.ToInt32(reader["id_cliente"]);
ot.RutAdquiriente = reader["rut_adquiriente"].ToString();
ot.UrlFactura = reader["url_factura"].ToString();
ot.IdSucursal = Convert.ToInt32(reader["id_sucursal"]);
ot.CodigoFormaPago = reader["codigoFormaPago"].ToString();
ot.CodigoFinanciera = reader["codigoFinanciera"].ToString();
ot.CompraPara = reader["compraPara"].ToString();
ot.ImpuestoVerde = reader["impuestoVerde"].ToString();
ot.Observacion = reader["observacion"].ToString();
ot.FacturaNeto = reader["factura_neto"].ToString();
ot.FechaFactura = reader["factura_fecha"].ToString();
ot.VehiculoMarca = reader["vehiculo_marca"].ToString();
ot.VehiculoModelo = reader["vehiculo_modelo"].ToString();
ot.VehiculoAnio = reader["vehiculo_anio"].ToString();
ot.VehiculoCilindrada = reader["vehiculo_cilindrada"].ToString();
ot.VehiculoPuertas = Convert.ToInt32(reader["vehiculo_puertas"]);
ot.VehiculoAsientos = Convert.ToInt32(reader["vehiculo_asientos"]);
ot.VehiculoPesoBruto = Convert.ToInt32(reader["vehiculo_peso_bruto"]);
ot.VehiculoCarga = Convert.ToInt32(reader["vehiculo_carga"]);
ot.VehiculoCombustible = reader["vehiculo_combustible"].ToString();
ot.VehiculoColor = reader["vehiculo_color"].ToString();
ot.VehiculoMotor = reader["vehiculo_motor"].ToString();
ot.VehiculoVin = reader["vehiculo_vin"].ToString();
ot.VehiculoCit = reader["vehiculo_cit"].ToString();
ot.VehiculoChasis = reader["vehiculo_chasis"].ToString();
ot.AbonoCliente = Convert.ToInt32(reader["abono_cliente"]);
ot.TieneCompraPara = Convert.ToBoolean(reader["tiene_compra_para"]);
ot.CompraParaRut = Convert.ToInt32(reader["compra_para_rut"]);
ot.CompraParaDv = Convert.ToString(reader["compra_para_dv"]);
ot.CompraParaNombre = Convert.ToString(reader["compra_para_nombre"]);
ot.Patente = Convert.ToString(reader["vehiculo_patente"]);
ot.ConCreditoAmicar = Convert.ToBoolean(reader["credito_amicar"]);
}
sqlConn.Close();
return(ot);
}
}
public CommandContracts.Common.CommandResult Handle(ActualizarLiquidacionCommand command)
{
OrdenTrabajo dominio =
_OrdenTrabajoRepository.Get(x => x.idordentrabajo.Equals(command.idordentrabajo)).FirstOrDefault();
dominio.idordentrabajo = command.idordentrabajo;
dominio.fechaentregaconciliacion = command.fechaentregaconciliacion;
dominio.idusuarioconciliacion = command.idusuarioconciliacion;
dominio.idestado = command.idestado;
dominio.archivado = command.archivado;
try
{
_OrdenTrabajoRepository.SaveChanges();
return(new ActualizarLiquidacionOutput()
{
idordentrabajo = dominio.idordentrabajo
});
}
catch (Exception ex)
{
// _ValortablaRepository.Delete(dominio);
//_ValortablaRepository.Commit();
throw;
}
}
public CommandContracts.Common.CommandResult Handle(ActualizarMontosOTCommand command)
{
OrdenTrabajo dominio = null;
if (command.idordentrabajo.HasValue)
{
dominio = _OrdenTrabajoRepository.Get(x => x.idordentrabajo == command.idordentrabajo).LastOrDefault();
}
else
{
throw new ArgumentException("Tiene que ingresar una OT");
}
dominio.subtotal = command.subtotal;
dominio.igv = command.igv;
dominio.total = command.total;
try
{
_OrdenTrabajoRepository.SaveChanges();
return(new ActualizarMontosOTOutput()
{
idordentrabajo = dominio.idordentrabajo
});
}
catch (Exception ex)
{
// _ValortablaRepository.Delete(dominio);
//_ValortablaRepository.Commit();
throw;
}
}
/// <summary>
/// Metodo encargado de insertar un registro orden actividad
/// </summary>
/// <param name="id_actividad"></param>
/// <param name="id_orden"></param>
/// <param name="id_falla"></param>
/// <param name="id_estatus"></param>
/// <param name="fecha_inicio"></param>
/// <param name="fecha_fin"></param>
/// <param name="duracion"></param>
/// <param name="id_usuario"></param>
/// <returns></returns>
public static RetornoOperacion InsertaOrdenActividad(int id_actividad, int id_orden, int id_falla, int id_usuario)
{
//Declarando objeto de retorno
RetornoOperacion resultado = new RetornoOperacion();
//Instanciando Orden de Trabajo
using (OrdenTrabajo ot = new OrdenTrabajo(id_orden))
{
//Si la OT no se encuentra cerrada aún
if ((OrdenTrabajo.EstatusOrdenTrabajo)ot.id_estatus != OrdenTrabajo.EstatusOrdenTrabajo.Terminada)
{
//Inicializando arreglo de parámetros
object[] param = { 1, 0, id_actividad, id_orden, id_falla, EstatusOrdenActividad.Registrada, null, null, 0, id_usuario, true, "", "" };
// Realizando actualizacion
resultado = CapaDatos.m_capaDeDatos.EjecutaProcAlmacenadoObjeto(nombre_stored_procedure, param);
}
//De lo contrario
else
{
resultado = new RetornoOperacion("Imposible añadir actividades a una Orden de Trabajo ya Terminada.");
}
}
//Devolviendo resultado
return(resultado);
}
//Unicamente se pone en borrado el campo e la tabla ordenes, los detalles y los rXT permancerán aunque no podrán ser accedidos desde
//el programa.
public void EliminarOT(OrdenTrabajo ot)
{
string Esql = "UPDATE Ordenes set borrado = 1 " +
"WHERE codOrden = " + ot.CodOrden;
otDB.Insertar(Esql);
}
public async Task <OrdenTrabajo> CrearOrdenDeTrabajo(OrdenTrabajo ordenTrabajo, UsuarioDTO usuario)
{
try
{
ordenTrabajo.Guid = Guid.NewGuid();
ordenTrabajo.EstadoId = (int)ESTADOSORDENTRABAJO.PENDIENTE;
ordenTrabajo.FechaRegistro = DateTime.Now;
ordenTrabajo.TipoServicioId = (int)TIPOSERVICIOS.REPARACIÓN;
ordenTrabajo.ResponsableId = (int)RESPONSABLES.JUAN_MARQUEZ;
if (ordenTrabajo.TamanoHerramientaId == 0)
{
ordenTrabajo.TamanoHerramientaId = null;
}
ordenTrabajo.CantidadInspeccionar = CalcularCantidadInpseccionar(ordenTrabajo.Cantidad);
OrdenTrabajo ordenTrabajoBD = new OrdenTrabajo();
_context.Entry(ordenTrabajoBD).CurrentValues.SetValues(ordenTrabajo);
if (ordenTrabajoBD.TamanoHerramienta != null)
{
_context.Entry(ordenTrabajoBD.TamanoHerramienta).State = EntityState.Unchanged;
}
ordenTrabajoBD.NombreUsuarioCrea = USUARIO_CREA.ADMIN.ToString();
_context.OrdenTrabajo.Add(ordenTrabajoBD);
await _context.SaveChangesAsync();
OrdenTrabajo oit = await _context.OrdenTrabajo.FirstOrDefaultAsync(c => c.Guid == ordenTrabajo.Guid);
return(oit);
}
catch (Exception e)
{
throw e;
}
}
public ActionResult DeleteConfirmed(int id)
{
OrdenTrabajo ordenTrabajo = db.OrdenTrabajo.Find(id);
db.OrdenTrabajo.Remove(ordenTrabajo);
db.SaveChanges();
return(RedirectToAction("IndexEmpleado"));
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
_ordenesTrabajo = null;
_ordenTrabajo = null;
db.Dispose();
}
base.Dispose(disposing);
}
private static Proceso AsignarValoresOrdenTrabajoAProceso(OrdenTrabajo ordenTrabajo)
{
Proceso proceso = new Proceso()
{
CantidadInspeccion = ordenTrabajo.CantidadInspeccionar,
OrdenTrabajoId = ordenTrabajo.Id
};
return(proceso);
}
private void BtnEditar_Click(object sender, EventArgs e)
{
OrdenTrabajo otEdicion = (OrdenTrabajo)dgvOrdenes.CurrentRow.DataBoundItem;
frmCrearOrden frmCrearOrden = new frmCrearOrden(empleadoSesion);
AddOwnedForm(frmCrearOrden);
frmCrearOrden.FormClosing += frmCrearOrden_FormClosing;
frmCrearOrden.SeleccionarOT(frmCrearOrden.FormMode.update, otEdicion);
frmCrearOrden.Show();
this.Hide();
}
public async Task <IActionResult> ActualizarOrdenDeTrabajo([FromBody] OrdenTrabajo ordenTrabajo)
{
try
{
return(Ok(await _ordenTrabajoServicio.ActualizarOrdenDeTrabajo(ordenTrabajo, new UsuarioDTO())));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public ActionResult ActualizarFaseOrden(string ordenId, short fase)
{
OrdenTrabajo oOrden = db.OrdenTrabajo.First(x => x.OrdenId == ordenId);
oOrden.Fase = fase;
oOrden.MFechaHora = DateTime.Now;
oOrden.MUsuarioId = ObtenerUsuario();
db.SaveChanges();
return(Json(new { result = true }, JsonRequestBehavior.AllowGet));
}
public CommandResult Handle(CerrarOperacionCommand command)
{
if (command == null)
{
throw new ArgumentException("Tiene que ingresar una cliente");
}
if (command.idmanifiesto == null)
{
OrdenTrabajo dominio = null;
if (command.idorden.HasValue)
{
dominio = _OrdenTrabajoRepository.Get(x => x.idordentrabajo == command.idorden).LastOrDefault();
}
else
{
dominio = new OrdenTrabajo();
}
// dominio.cierreoperativo = command.cierreoperativo;
try
{
_OrdenTrabajoRepository.SaveChanges();
return(new InsertarActualizarIncidenteOutput()
{
idincidencia = dominio.idordentrabajo
});
}
catch (Exception ex)
{
throw;
}
}
else
{
Manifiesto dominio = null;
dominio = _ManfiestoRepository.Get(x => x.idmanifiesto == command.idmanifiesto).LastOrDefault();
//dominio.cierreoperativo = true;
try
{
_ManfiestoRepository.SaveChanges();
return(new InsertarActualizarIncidenteOutput()
{
idincidencia = dominio.idmanifiesto
});
}
catch (Exception ex)
{
throw;
}
}
}
public HttpResponseMessage GenerateWorkPlan(IdModelPlanTrabajo guiam)
{
try
{
OrdenTrabajo ordenTrabajo = new OrdenTrabajo();
List <DetalleOrdenTrabajo> detalleOrdenTrabajos = new List <DetalleOrdenTrabajo>();
if (guiam.IdOrdenTrabajo != 0)
{
ordenTrabajo = db.OrdenTrabajo.Where(x => x.IdOrdenTrabajo == guiam.IdOrdenTrabajo).FirstOrDefault();
if (ordenTrabajo != null)
{
detalleOrdenTrabajos = db.DetalleOrdenTrabajo.Where(x => x.IdOrdenTrabajo == ordenTrabajo.IdOrdenTrabajo).ToList();
}
else
{
throw new Exception("No existe Orden Trabajo");
}
}
else
{
throw new Exception("Datos Requeridos no enviados");
}
PlanTrabajo planTrabajo = new PlanTrabajo();
foreach (DetalleOrdenTrabajo detalle in detalleOrdenTrabajos)
{
planTrabajo.IdOrdenTrabajo = detalle.IdOrdenTrabajo;
planTrabajo.IdDetalleOrdenTrabajo = detalle.IdDetalleOrdenTrabajo;
planTrabajo.IdArea = ordenTrabajo.IdArea;
planTrabajo.TipoServicio = detalle.TipoServicio;
planTrabajo.Actividad = detalle.Actividad;
planTrabajo.Tiempo = detalle.Tiempo;
planTrabajo.FechaPlanInicio = DateTime.Now;
planTrabajo.FechaPlanFin = DateTime.Now;
planTrabajo.Comienza = TimeSpan.FromHours(0);
db.PlanTrabajo.Add(planTrabajo);
db.SaveChangesAsync();
ordenTrabajo.Planeada = true;
db.SaveChangesAsync();
}
return(new HttpResponseMessage(System.Net.HttpStatusCode.OK)
{
Content = null
});
}
catch (Exception ex)
{
return(Request.CreateResponse <string>(HttpStatusCode.InternalServerError, ex.Message + Environment.NewLine + "PlanTrabajo"));
}
}
public RespuestaAgp AddOrdenTrabajoWebservice(OrdenTrabajo ot)
{
using (var sqlConn = new SqlConnection(strConn))
{
sqlConn.Open();
var cmd = new SqlCommand(strConn, sqlConn)
{
CommandType = CommandType.StoredProcedure, CommandText = "sp_addOrdenTrabajoWebservice"
};
var oParam =
cmd.Parameters.AddWithValue("@activo", ot.Activo);
cmd.Parameters.AddWithValue("@id_usuario", ot.CuentaUsuario);
cmd.Parameters.AddWithValue("@num_orden_trabajo", ot.NumeroOrden);
cmd.Parameters.AddWithValue("@num_factura", ot.NumeroFactura);
cmd.Parameters.AddWithValue("@rut_adquiriente", ot.RutAdquiriente);
cmd.Parameters.AddWithValue("@dv_adquiriente", ot.DvAdquiriente);
cmd.Parameters.AddWithValue("@nombre_adquiriente", ot.NombreAdquiriente);
cmd.Parameters.AddWithValue("@apepat_adquiriente", ot.ApepatAdquiriente);
cmd.Parameters.AddWithValue("@apemat_adquiriente", ot.ApematAdquiriente);
cmd.Parameters.AddWithValue("@factura_neto", ot.FacturaNeto);
cmd.Parameters.AddWithValue("@fecha_factura", ot.FechaFactura);
cmd.Parameters.AddWithValue("@vehiculo_marca", ot.VehiculoMarca);
cmd.Parameters.AddWithValue("@vehiculo_modelo", ot.VehiculoModelo);
cmd.Parameters.AddWithValue("@vehiculo_anio", ot.VehiculoAnio);
cmd.Parameters.AddWithValue("@vehiculo_cilindrada", ot.VehiculoCilindrada);
cmd.Parameters.AddWithValue("@vehiculo_puertas", ot.VehiculoPuertas);
cmd.Parameters.AddWithValue("@vehiculo_asientos", ot.VehiculoAsientos);
cmd.Parameters.AddWithValue("@vehiculo_peso_bruto", ot.VehiculoPesoBruto);
cmd.Parameters.AddWithValue("@vehiculo_carga", ot.VehiculoCarga);
cmd.Parameters.AddWithValue("@vehiculo_combustible", ot.VehiculoCombustible);
cmd.Parameters.AddWithValue("@vehiculo_color", ot.VehiculoColor);
cmd.Parameters.AddWithValue("@vehiculo_motor", ot.VehiculoMotor);
cmd.Parameters.AddWithValue("@vehiculo_vin", ot.VehiculoVin);
cmd.Parameters.AddWithValue("@vehiculo_chasis", ot.VehiculoChasis);
cmd.Parameters.AddWithValue("@url_factura", ot.UrlFactura);
cmd.Parameters.AddWithValue("@vin_corto", ot.VinCorto.Trim());
cmd.Parameters.AddWithValue("@Nacionalidad", ot.Nacionalidad);
cmd.Parameters.AddWithValue("@sexo", ot.Sexo);
var reader = cmd.ExecuteReader();
var respuesta = new RespuestaAgp();
if (reader.Read())
{
respuesta.IdRespuesta = Convert.ToInt32(reader["id"].ToString().Trim());
respuesta.MensajeError = reader["mensajeError"].ToString().Trim();
}
sqlConn.Close();
return(respuesta);
}
}
public async Task <IActionResult> CrearOrdenDeTrabajo([FromBody] OrdenTrabajo ordenTrabajo)
{
try
{
Guid OrdenDeTrabajoGuid = await _ordenTrabajoServicio.CrearOrdenDeTrabajo(ordenTrabajo, new UsuarioDTO());
return(Ok(OrdenDeTrabajoGuid));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public static object Agregar(Sesion sesion, OrdenTrabajo orden)
{
object resultado = new { };
try
{
blOrdenTrabajo blOrdenTrabajo = new blOrdenTrabajo(sesion);
blOrdenTrabajo.Agregar(orden);
resultado = new { correcto = true };
}
catch (Exception)
{
resultado = new { correcto = false };
}
return resultado;
}
public bool Agregar(OrdenTrabajo orden)
{
try
{
daOrdenTrabajo = new daOrdenTrabajo();
daOrdenTrabajo.IniciarTransaccion();
daOrdenTrabajo.Agregar(orden);
daOrdenTrabajoGrupo = new daOrdenTrabajoGrupo();
daOrdenTrabajoGrupo.AsignarSesion(daOrdenTrabajo);
daOrdenTrabajoItem = new daOrdenTrabajoItem();
daOrdenTrabajoItem.AsignarSesion(daOrdenTrabajo);
daOrdenTrabajoServicio = new daOrdenTrabajoServicio();
daOrdenTrabajoServicio.AsignarSesion(daOrdenTrabajo);
foreach (OrdenTrabajoGrupo grupo in orden.grupos)
{
grupo.idOrdenTrabajo = orden.idOrdenTrabajo;
daOrdenTrabajoGrupo.Agregar(grupo);
foreach (OrdenTrabajoItem item in grupo.items)
{
item.idOrdenTrabajoGrupo = grupo.idOrdenTrabajoGrupo;
daOrdenTrabajoItem.Agregar(item);
foreach (OrdenTrabajoServicio servicio in item.servicios)
{
servicio.idOrdenTrabajoItem = item.idOrdenTrabajoItem;
daOrdenTrabajoServicio.Agregar(servicio);
}
}
}
daOrdenTrabajo.ConfirmarTransaccion();
}
catch (Exception)
{
daOrdenTrabajo.AbortarTransaccion();
throw;
}
finally
{
daOrdenTrabajo.CerrarSesion();
}
return true;
}
public bool Actualizar(OrdenTrabajo orden)
{
try
{
daOrdenTrabajo = new daOrdenTrabajo();
daOrdenTrabajo.IniciarTransaccion();
OrdenTrabajo orden_ = daOrdenTrabajo.ObtenerPorId(orden.idOrdenTrabajo);
orden_.descripcion = orden.descripcion;
orden_.cliente = orden.cliente;
orden_.cotizador = orden.cotizador;
orden_.linea = orden.linea;
orden_.lpMaterial = orden.lpMaterial;
orden_.lpServicio = orden.lpServicio;
orden_.lpMaquina = orden.lpMaquina;
orden_.moneda = orden.moneda;
orden_.vendedor = orden.vendedor;
orden_.contacto = orden.contacto;
orden_.observacion = orden.observacion;
daOrdenTrabajoGrupo = new daOrdenTrabajoGrupo();
daOrdenTrabajoGrupo.AsignarSesion(daOrdenTrabajo);
daOrdenTrabajoItem = new daOrdenTrabajoItem();
daOrdenTrabajoItem.AsignarSesion(daOrdenTrabajo);
daOrdenTrabajoServicio = new daOrdenTrabajoServicio();
daOrdenTrabajoServicio.AsignarSesion(daOrdenTrabajo);
foreach (OrdenTrabajoGrupo grupo in orden.grupos)
{
if (grupo.idOrdenTrabajoGrupo == 0)
{
grupo.idOrdenTrabajo = orden.idOrdenTrabajo;
daOrdenTrabajoGrupo.Agregar(grupo);
foreach (OrdenTrabajoItem item in grupo.items)
{
item.idOrdenTrabajoGrupo = grupo.idOrdenTrabajoGrupo;
daOrdenTrabajoItem.Agregar(item);
foreach (OrdenTrabajoServicio servicio in item.servicios)
{
servicio.idOrdenTrabajoItem = item.idOrdenTrabajoItem;
daOrdenTrabajoServicio.Agregar(servicio);
}
}
}
else {
OrdenTrabajoGrupo grupo_ = daOrdenTrabajoGrupo.ObtenerPorId(grupo.idOrdenTrabajoGrupo);
grupo_.titulo = grupo.titulo;
grupo_.cantidad = grupo.cantidad;
foreach (OrdenTrabajoItem item in grupo.items)
{
if (item.idOrdenTrabajoItem == 0)
{
item.idOrdenTrabajoGrupo = grupo.idOrdenTrabajoGrupo;
daOrdenTrabajoItem.Agregar(item);
foreach (OrdenTrabajoServicio servicio in item.servicios)
{
servicio.idOrdenTrabajoItem = item.idOrdenTrabajoItem;
daOrdenTrabajoServicio.Agregar(servicio);
}
}
else {
OrdenTrabajoItem item_ = daOrdenTrabajoItem.ObtenerPorId(item.idOrdenTrabajoItem);
item_.titulo = item.titulo;
item_.servicio = item.servicio;
item_.maquina = item.maquina;
item_.material = item.material;
item_.conMdA = item.conMdA;
item_.conMdC = item.conMdC;
item_.conTyr = item.conTyr;
item_.conGrf = item.conGrf;
item_.conMat = item.conMat;
item_.conSrv = item.conSrv;
item_.conFnd = item.conFnd;
item_.xMa = item.xMa;
item_.yMa = item.yMa;
item_.xMc = item.xMc;
item_.yMc = item.yMc;
item_.tC = item.tC;
item_.rC = item.rC;
item_.fnd = item.fnd;
item_.xFI = item.xFI;
item_.yFI = item.yFI;
item_.sX = item.sX;
item_.sY = item.sY;
item_.pliegos = item.pliegos;
item_.gp180 = item.gp180;
item_.gi180 = item.gi180;
item_.metodoImpresion = item.metodoImpresion;
item_.scntMat = item.scntMat;
item_.cntDem = item.cntDem;
item_.cntMat = item.cntMat;
item_.cntPrd = item.cntPrd;
item_.cantidad = item.cantidad;
item_.cntPs = item.cntPs;
item_.observacion = item.observacion;
foreach (OrdenTrabajoServicio servicio in item.servicios)
{
if (servicio.idOrdenTrabajoServicio == 0)
{
servicio.idOrdenTrabajoItem = item.idOrdenTrabajoItem;
daOrdenTrabajoServicio.Agregar(servicio);
}
else {
OrdenTrabajoServicio servicio_ = daOrdenTrabajoServicio.ObtenerPorId(servicio.idOrdenTrabajoServicio);
servicio_.cantidad = servicio.cantidad;
servicio_.unidad = servicio.unidad;
}
}
foreach (int idServicio in item.idsServicios)
{
daOrdenTrabajoServicio.EliminarPorId(idServicio, constantes.esquemas.Ventas);
}
}
}
foreach (int idItem in grupo.idsItems)
{
daOrdenTrabajoItem.EliminarPorId(idItem, constantes.esquemas.Ventas);
}
}
}
foreach (int idGrupo in orden.idsGrupos)
{
daOrdenTrabajoGrupo.EliminarPorId(idGrupo, constantes.esquemas.Ventas);
daOrdenTrabajoItem.EliminarPorIdOrdenTrabajoGrupo(idGrupo);
}
daOrdenTrabajo.ConfirmarTransaccion();
}
catch (Exception)
{
daOrdenTrabajo.AbortarTransaccion();
throw;
}
finally
{
daOrdenTrabajo.CerrarSesion();
}
return true;
}
