protected void Button1_Click(object sender, EventArgs e)
{
Servicio serv = new Servicio();
serv.guardar(Int32.Parse(txt1.Text), txt2.Text,txt3.Text,txt4.Text,Int32.Parse(txt5.Text),txt6.Text,Int32.Parse(txt7.Text),txt8.Text,txt9.Text);
Label10.Text = "datos Guardados";
}
protected void Button1_Click(object sender, EventArgs e)
{
FileUpload1.SaveAs(MapPath(FileUpload1.FileName));
//String linea = MapPath(FileUpload1.FileName);
string linea = FileUpload1.FileName;
Servicio serv = new Servicio();
serv.AgregarFoto(linea, Convert.ToInt32(TextBox1.Text));
Server.Transfer("VerPaqueteIndi.aspx");
}
private void btnAceptar_Click(object sender, EventArgs e)
{
try
{
double precio = 0;
if (!Double.TryParse(this.txtPrecio.Text, out precio))
{
MessageBox.Show("Ingrese un valor numérico.", "Gestión de Servicios.", MessageBoxButtons.OK, MessageBoxIcon.Warning);
this.txtPrecio.Focus();
return;
}
Servicio servicio = new Servicio();
servicio.Descripcion = txtDescripcion.Text;
servicio.Precio = precio;
servicio.Estado = 1;
bool resultado = false;
if (Operacion == Accion.Alta)
{
resultado = GestorReserva.ObtenerInstancia().InsertarNuevoServicio(servicio);
}
else if (Operacion == Accion.Modificacion)
{
servicio.ID = servicioSeleccionado.ID;
resultado = GestorReserva.ObtenerInstancia().ActualizarServicio(servicio);
}
if (resultado)
{
MessageBox.Show("Se ha creado/modificado el Servicio correctamente.", "Gestión de Servicios", MessageBoxButtons.OK, MessageBoxIcon.Information);
HabilitarControles(true);
this.gbDatosServicio.Enabled = false;
LimpiarControles();
CargarServicios();
}
}
catch (Exception ex)
{
string mensajeError = string.Empty;
if (this.Operacion == Accion.Alta)
{
mensajeError = ErrorManager.ObtenerInstancia().LoguearGenerarMensajeError(ex, MensajeError.AltaServicioFallida, FormHelper.ObtenerInstancia().TraerUltimoIdioma());
}
else
{
mensajeError = ErrorManager.ObtenerInstancia().LoguearGenerarMensajeError(ex, MensajeError.ModificacionServicioFallida, FormHelper.ObtenerInstancia().TraerUltimoIdioma());
}
MessageBox.Show(mensajeError, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
protected void Button2_Click(object sender, EventArgs e)
{
List<string> b = new List<string>();
Servicio ser = new Servicio();
b = ser.Despedir(Convert.ToInt32( TextBox1.Text));
TextBox2.Text = b[1];
TextBox3.Text = b[0];
TextBox4.Text = b[2];
TextBox5.Text = b[3];
TextBox6.Text = b[4];
}
protected void Button1_Click(object sender, EventArgs e)
{
List<string> b = new List<string>();
Servicio ser = new Servicio();
b = ser.ModificarCliente(TextBox8.Text,TextBox9.Text);
TextBox1.Text = b[0];
TextBox2.Text = b[1];
TextBox3.Text = b[2];
TextBox4.Text = b[3];
TextBox5.Text = b[4];
TextBox6.Text = b[5];
TextBox7.Text = b[6];
}
public List <Producto> ObtenerProductoXIDServicio(Servicio Datos)
{
try
{
List <Producto> Lista = new List <Producto>();
Producto Item;
SqlDataReader Dr = SqlHelper.ExecuteReader(Datos.Conexion, "spCSLDB_get_ProductoXServicio", Datos.IDServicio);
while (Dr.Read())
{
Item = new Producto();
Item.IDProductoXServicio = Dr.IsDBNull(Dr.GetOrdinal("IDProductoXServicio")) ? string.Empty : Dr.GetString(Dr.GetOrdinal("IDProductoXServicio"));
Item.IDProducto = Dr.IsDBNull(Dr.GetOrdinal("IDProducto")) ? string.Empty : Dr.GetString(Dr.GetOrdinal("IDProducto"));
Item.NombreProducto = Dr.IsDBNull(Dr.GetOrdinal("NombreProducto")) ? string.Empty : Dr.GetString(Dr.GetOrdinal("NombreProducto"));
Item.Cantidad = Dr.IsDBNull(Dr.GetOrdinal("Cantidad")) ? 0 : Dr.GetInt32(Dr.GetOrdinal("Cantidad"));
Lista.Add(Item);
}
Dr.Close();
return(Lista);
}
catch (Exception ex)
{
throw ex;
}
}
private ObservableCollection <Servicio> SelectAllByFilter(String x_procedure, ObservableCollection <Infrastructure.Aspect.DataAccess.DataAccessFilterSQL> x_filters)
{
try
{
ObservableCollection <Servicio> items = new ObservableCollection <Servicio>();
Servicio item = new Servicio();
if (!String.IsNullOrEmpty(x_procedure))
{
DataAccessEnterpriseSQL.DAAsignarProcedure(x_procedure);
}
else
{
DataAccessEnterpriseSQL.DAAsignarProcedure("COM_SERVSS_TodosByFilters");
}
if (x_filters != null && x_filters.Count > 0)
{
foreach (Infrastructure.Aspect.DataAccess.DataAccessFilterSQL _itemFilter in x_filters)
{
DataAccessEnterpriseSQL.DAAgregarParametro(_itemFilter.FilterName, _itemFilter.FilterValue, _itemFilter.FilterSQLType, _itemFilter.FilterSize);
}
}
using (IDataReader reader = DataAccessEnterpriseSQL.DAExecuteReader())
{
while (reader.Read())
{
item = new Servicio();
Loader.LoadEntity(reader, item);
item.Instance = InstanceEntity.Unchanged;
items.Add(item);
}
}
return(items);
}
catch (Exception)
{ throw; }
}
private void bApagar_Click(object sender, EventArgs e)
{
J1.Realizar_Jugada();
MessageBox.Show("Casilla Jugador: " + J1.Posicion.ToString() + " d1: " + Dado.Dado_1.ToString() + " d2: " + Dado.Dado_2.ToString() + " Doble: " + Dado.Doble.ToString());
Casilla c_destino = Juego.Casillas.Find(c => c.Posicion == J1.Posicion);
if (c_destino.Tipo == Tipo_Casilla.Propiedad)
{
Propiedad p_destino = (Propiedad)c_destino;
MessageBox.Show(p_destino.Posicion.ToString() + " - " + p_destino.Tipo.ToString() + " " + p_destino.Color.ToString() + " - " + p_destino.Nombre.ToString() + " Penitencia: " + p_destino.Precio);
}
else if (c_destino.Tipo == Tipo_Casilla.Tren)
{
Tren t_destino = (Tren)c_destino;
MessageBox.Show(t_destino.Posicion.ToString() + " - " + t_destino.Tipo.ToString() + " " + t_destino.Tipo_Tren.ToString() + " Penitencia: " + t_destino.Precio);
}
else if (c_destino.Tipo == Tipo_Casilla.Servicio)
{
Servicio s_destino = (Servicio)c_destino;
MessageBox.Show(s_destino.Posicion.ToString() + " - " + s_destino.Tipo.ToString() + " " + s_destino.Tipo_Servicio.ToString() + " Penitencia: " + s_destino.Precio);
}
else if (c_destino.Tipo == Tipo_Casilla.Detencion)
{
J1.Detenido = true;
J1.Posicion = 10;
MessageBox.Show(c_destino.Posicion.ToString() + " - " + c_destino.Tipo.ToString());
}
else
{
J1.Detenido = true;
J1.Posicion = 10;
MessageBox.Show(c_destino.Posicion.ToString() + " - " + c_destino.Tipo.ToString());
}
}
private List <Pedido> CrearPedidos(DataSetFacturacion.pedidoRow[] pedidoRow)
{
List <Pedido> listapedidos = new List <Pedido>();
foreach (var item in pedidoRow)
{
Pedido newpedido = new Pedido();
newpedido.Id = ((DataSetFacturacion.pedidoRow)item).Id;
newpedido.Cantidad_Ejemplares = ((DataSetFacturacion.pedidoRow)item).cant_ejemplares;
newpedido.Color_impresion = ((DataSetFacturacion.pedidoRow)item).color_impresion;
newpedido.Coste_total = ((DataSetFacturacion.pedidoRow)item).coste_total;
newpedido.Descuentos = ((DataSetFacturacion.pedidoRow)item).descuentos;
newpedido.Estado = ((DataSetFacturacion.pedidoRow)item).estado;
newpedido.ValorAgregado = ((DataSetFacturacion.pedidoRow)item).valor_agregado;
newpedido.Fecha_entrega = ((DataSetFacturacion.pedidoRow)item).fecha_entrega;
newpedido.Fecha_expedicion = ((DataSetFacturacion.pedidoRow)item).fecha_expedicion;
newpedido.Forma_pago = ((DataSetFacturacion.pedidoRow)item).forma_pago;
newpedido.Observaciones = ((DataSetFacturacion.pedidoRow)item).observaciones;
newpedido.Paginas_por_Cara = ((DataSetFacturacion.pedidoRow)item).paginas_x_cara;
newpedido.Pago_adelantado = ((DataSetFacturacion.pedidoRow)item).pago_adelantado;
newpedido.Tipo_documento = ((DataSetFacturacion.pedidoRow)item).tipo_documento;
newpedido.Tipo_impresion = ((DataSetFacturacion.pedidoRow)item).tipo_impresion;
foreach (var item_cost in ((DataSetFacturacion.pedidoRow)item).Getpedidos_costosRows())
{
ServicioAccess servicioap = new ServicioAccess(ClienteTB, ds, PedidoTB, CostosTB, FichaCostosTB);
Servicio sv = servicioap.ServicioDadoId(item_cost.idpedido);
if (sv != null)
{
newpedido.Servicios.Add(sv);
}
}
listapedidos.Add(newpedido);
}
return(listapedidos);
}
public async Task inicioDiurnoAsync(Servicio servicio)
{
if (servicio.horaDeFinalizacion >= 7 && servicio.horaDeFinalizacion < 20)
{
//fin diurno
servicio.cantidadDeHoras = servicio.horaDeFinalizacion - servicio.horaDeInicio;
servicio.tipoDeHora = "Diurnas";
}
else
{
//fin nocturno
//Las horas son diurnas hasta las 20
servicio.cantidadDeHoras = 20 - servicio.horaDeInicio;
if (servicio.horaDeFinalizacion < 24)
{
await IngresarServicioALaBaseDeDatos(CrearServicioNocturno(servicio));
}
else
{
await IngresarServicioALaBaseDeDatos(CrearServicioDiaSiguiente(servicio));
}
}
}
// GET: Servicio/Details/5
public ActionResult Details(int id)
{
Servicio serv = null;
ServicioEN servicioEN = new ServicioCAD(session).ReadOID(id);
serv = new AssemblerServicio().ConvertENToModelUI(servicioEN);
ArrayList listaFotos = new ArrayList();
foreach (string foto in servicioEN.FotosServicio)
{
listaFotos.Add(foto);
}
ViewData["listaFotos"] = listaFotos;
ViewData["servicio"] = servicioEN.Nombre;
if (Session["usuario"] != null && Session["esAdmin"].ToString() == "true" && Session["modoAdmin"].ToString() == "true")
{
return(View(serv));
}
else
{
return(View("./VistaUsuario/Detalles", serv));
}
}
public void Call(Servicio currentServiceInstance)
{
if (Destinatario.UserName.ToLower() == "all")
{
// Enviamos el mensaje a todos los operadores conectados al servicio
currentServiceInstance.MessageToAllOperators(Contenido);
}
else if (Destinatario.UserName.ToLower() == "backoffice")
{
// Checks if a backoffice is logged in
if (currentServiceInstance.connectedBackoffice != null)
{
// if To is a backoffice, send message to the current backoffice
currentServiceInstance.connectedBackoffice.Callback.Mensaje(Contenido);
// Notify on console the message sent
Console.WriteLine(currentServiceInstance.GetFullShortDateTime + ": message sent to backoffice + " + currentServiceInstance.connectedBackoffice.Operator.UserName + ".");
}
else
{
// Notifies on console the message sent
Console.WriteLine(currentServiceInstance.GetFullShortDateTime + ": no logged backoffice on the service.");
}
}
}
public IHttpActionResult Guardar(Servicio servicio)
{
//if (!ModelState.IsValid)
//{
// return BadRequest(ModelState);
//}
if (servicio.Id == 0)
{
servicio.UsuarioRegistroId = HttpContext.Current.User.Identity.GetUserId();
servicio.SucursalId = IdSucursal;
}
else
{
servicio.UsuarioModificacionId = HttpContext.Current.User.Identity.GetUserId();
}
var servicioId = _servicioService.Guardar(servicio).Id;
var servicioRepo = new Servicio {
Id = servicioId
};
return(Ok(servicioRepo));
}
public void CrearServicio()
{
Servicio servicio1 = new Servicio();
servicio1.Fecha = DateTime.Parse(DateTime.Now.Date.ToString("dd/MM/yy"));
servicio1.NombreEstudiante = "Felipe";
Servicio servicio2 = new Servicio();
servicio2.Fecha = DateTime.Parse(DateTime.Now.Date.ToString("dd/MM/yy"));
servicio2.NombreEstudiante = "Jose";
bool paso1 = true;
bool paso2 = true;
RepositorioServicio repositorio = new RepositorioServicio();
paso1 = repositorio.Guardar(servicio1);
paso2 = repositorio.Guardar(servicio2);
Assert.IsTrue(paso1 && paso2);
}
private void GuardarCama(Cama oRegistro)
{
Habitacion oHab = new Habitacion();
oHab = (Habitacion)oHab.Get(typeof(Habitacion), int.Parse(lblIdHabitacion.Text));
Servicio oServicio = new Servicio();
oServicio = (Servicio)oServicio.Get(typeof(Servicio), int.Parse(ddlServicioCama.SelectedValue));
TipoCama oTipo = new TipoCama();
oTipo = (TipoCama)oTipo.Get(typeof(TipoCama), int.Parse(ddlTipoCama.SelectedValue));
oRegistro.IdHabitacion = oHab;
oRegistro.Nombre = txtCama.Text;
oRegistro.IdServicioInternacion = oServicio;
oRegistro.IdTipoCama = oTipo;
oRegistro.IdUsuarioRegistro = SSOHelper.CurrentIdentity.Id;
oRegistro.FechaRegistro = DateTime.Now;
oRegistro.IdEfector.IdEfector = SSOHelper.CurrentIdentity.IdEfector;
oRegistro.Save(oRegistro);
}
public bool Update(ServiceCategory entity)
{
ServiceCategory categoria = new ServiceCategory {
IdCategory = entity.IdCategory,
Name = entity.Name,
};
try {
context.serviceCategory.Add(categoria);
context.SaveChanges();
var categoryId = categoria.IdCategory;
foreach (var item in entity.services)
{
Servicio detalle = new Servicio {
CategoryId = categoryId,
};
context.servicio.Add(detalle);
}
context.SaveChanges();
} catch (Exception) {
return(false);
}
return(true);
}
private void Window_Loaded(object sender, RoutedEventArgs e)
{
Servicio oServicio = _servicioRepositorio.buscarServicio(codigoServicio);
Terminal oDestino = _terminalRepositorio.buscarTerminal((int)oServicio.ter_codigo_destino);
Terminal oOrigen = _terminalRepositorio.buscarTerminal((int)oServicio.ter_codigo_origen);
Autobus oAutobus = _autobusRepositorio.buscarAutobus((int)oServicio.aut_codigo);
Empresa oEmpresa = _empresaRepositorio.buscarEmpresa((int)codigoEmpresa);
txtEmplesa.Text = oEmpresa.emp_nombre;
txtDireccion.Text = oEmpresa.emp_direccion;
txtTelefono.Text = oEmpresa.emp_telefono;
txtEmail.Text = oEmpresa.emp_email;
txtFechaOperacion.Text = Convert.ToString(fechaOperacion);
txtNumeroPasaje.Text = Convert.ToString(codigoPasaje);
txtfechaHoraSalida.Text = Convert.ToString(oServicio.ser_fecha);
txtOrigen.Text = oOrigen.ter_nombre;
txtDestino.Text = oDestino.ter_nombre;
txtTipoServicio.Text = oAutobus.aut_tiposervicio;
txtPrecio.Text = Convert.ToString(precio);
txtButaca.Text = Convert.ToString(numeroAsiento);
txtCliente.Text = _clienteRepositorio.buscarCliente(dniCliente).cli_nombre + " " +
_clienteRepositorio.buscarCliente(dniCliente).cli_apellido;
txtUsuario.Text = nombreUsuario;
}
protected void Page_Load(object sender, EventArgs e)
{
usuario = new Servicio();
}
protected void Button1_Click(object sender, EventArgs e)
{
Servicio serv = new Servicio();
serv.guardarPaquete(Convert.ToInt32(TextBox1.Text),Convert.ToDouble(TextBox2.Text),TextBox3.Text,TextBox4.Text,TextBox5.Text,Convert.ToInt32(TextBox6.Text));
}
static void registrarEvento()
{
Console.Clear();
Console.WriteLine("\n---------- REGISTRAR EVENTO ----------\n");
Console.WriteLine("Ingrese el email");
string email = Console.ReadLine();
Console.WriteLine("Ingrese el password");
string password = Console.ReadLine();
if (emp.verificarUsuario(email, password) != null)
{
success("Se a ingresado con exito");
Console.WriteLine("Introduce la fecha del evento");
DateTime fecha;
DateTime.TryParse(Console.ReadLine(), out fecha);
fecha = fecha.Date;
DateTime fechaMax = new DateTime(DateTime.Now.Year + 1, DateTime.Now.Month, DateTime.Now.Day);
if (fecha.Date >= DateTime.Now.Date && fecha.Date <= fechaMax.Date)
{
Console.WriteLine("Seleccione el tipo de evento");
Console.WriteLine("1 - Evento estandar");
Console.WriteLine("2 - Evento premium");
int tipo = 0;
int.TryParse(Console.ReadLine(), out tipo);
if (tipo == 1 || tipo == 2)
{
Console.WriteLine("Seleccione el turno");
Console.WriteLine("1 - Mañana");
Console.WriteLine("2 - Tarde");
Console.WriteLine("3 - Noche");
int turnoNumerico = 0;
int.TryParse(Console.ReadLine(), out turnoNumerico);
Console.WriteLine("Ingrese la descripcion");
string descripcion = Console.ReadLine();
Console.WriteLine("Ingrese el nombre del cliente");
string cliente = Console.ReadLine();
Console.WriteLine("Ingrese la cantidad de asistentes");
int cantidadAsistentes = 0;
int.TryParse(Console.ReadLine(), out cantidadAsistentes);
if (turnoNumerico >= 1 && turnoNumerico <= 3 && descripcion != "" && cliente != "" && cantidadAsistentes > 0)
{
string turno = "";
switch (turnoNumerico)
{
case 1:
turno = "Mañana";
break;
case 2:
turno = "Tarde";
break;
case 3:
turno = "Noche";
break;
}
/*
* Imprimo la lista de servicios, creo dos listas una de tipo Servicio y la otra de tipo entero
* entro en un while donde su condicion de salida es que la variable de tipo string "nombreServicio" sea "salir"
* mientras eso no se cumpla, el usuario estara ingresando nombres de servicios los cuales seran verificados
* en la lista de servicios que posee empresa. Para la lista de enteros cantPersonasServicio se valida que
* el usuario ingrese correctamente algo que sea numerico y que sea menor a la cantidad de personas
* asistentes al evento. Una vez cumplido todo esto quedan ambas listas una con servicios y la otra con la cantidad de asistentes
* para el mismo.
*/
Console.WriteLine(emp.listarServicios());
string nombreServicio = "";
int cantPersonasServicio = 0;
List <Servicio> servicios = new List <Servicio>();
List <int> cantPersonasServicioLista = new List <int>();
while (nombreServicio != "salir")
{
success("Ingrese 'salir' para dejar de agregar servicios");
Console.WriteLine("Ingrese el nombre de un servicio");
nombreServicio = Console.ReadLine();
if (nombreServicio.ToLower() != "salir" && nombreServicio != "")
{
Console.WriteLine("Ingrese la cantidad de personas para el servicio MAX(" + cantidadAsistentes + ")");
string cantPersonas = Console.ReadLine();
if (verificarNumerico(cantPersonas))
{
int.TryParse(cantPersonas, out cantPersonasServicio);
if (cantPersonasServicio <= cantidadAsistentes && cantPersonasServicio > 0)
{
Servicio servicio = emp.buscarServicio(nombreServicio);
if (servicio != null)
{
servicios.Add(servicio);
cantPersonasServicioLista.Add(cantPersonasServicio);
}
else
{
error("No existe el servicio");
}
}
else
{
error("La cantidad de asistentes debe ser mayor a 0 y menor a la cantidad de asistentes al evento");
}
}
else
{
error("La cantidad de personas para el servicio debe ser numerico");
}
}
}
if (servicios.Count > 0 || cantPersonasServicioLista.Count > 0)
{
if (tipo == 1)
{
//Filtros para eventos estandar
Console.WriteLine("Ingrese la duracion (horas)");
int duracion = 0;
int.TryParse(Console.ReadLine(), out duracion);
if (duracion > 0 && duracion <= 4 && cantidadAsistentes > 0 && cantidadAsistentes <= 10)
{
Console.WriteLine(emp.altaEvento(email, password, fecha, turno, descripcion, cliente, cantidadAsistentes, duracion, servicios, cantPersonasServicioLista));
}
else
{
error("La duracion del evento o la cantidad de asistentes no corresponde");
}
}
else
{
//Filtros para eventos premium
if (cantidadAsistentes > 0 && cantidadAsistentes <= 100)
{
Console.WriteLine(emp.altaEvento(email, password, fecha, turno, descripcion, cliente, cantidadAsistentes, servicios, cantPersonasServicioLista));
}
else
{
error("Cantidad de asistentes incorrecto, debe ser mayor a 0 y/o menor o igual a 100");
}
}
}
else
{
error("No se pueden registrar eventos sin servicios");
}
}
else
{
error("Algun campo es esta vacio o no corresponde con lo solicitado");
}
}
else
{
error("Opcion invalida");
}
}
else
{
error("La fecha del evento no puede ser menor a la fecha acual / Solo se permiten agregar eventos con la fecha no superior a un año de diferencia con la actual");
}
}
else
{
error("El usuario no existe");
}
}
public void AllMethodsTest()
{
_output.WriteLine("Starting Sistema test ...");
Sistema _sistema = Startup.BuildSistema();
// Insert null
{
Assert.Throws <ModelException>(() => _sistema.Anadir((Persona)null));
cantTest += 1;
}
Persona p = new Persona()
{
Rut = "194460880",
Email = "*****@*****.**",
Nombre = "German",
Paterno = "Rojo",
Materno = "Arce"
};
Cliente cliente = new Cliente()
{
Persona = p,
Tipo = TipoCliente.UnidadInterna
};
//------------------------------------------------------------------------------
// Operaciones de Sistema: Cotizaciones (OS_COXXX)
//------------------------------------------------------------------------------
_output.WriteLine("TEST COTIZACIONES \n--------------------- ");
/**
* UnitTest Añadir Cotizacion
*/
{
var cotizacionAnadir = Assert.Throws <ModelException>(() => _sistema.Anadir((Cotizacion)null));
Assert.Equal("La cotizacion es null", cotizacionAnadir.Message);
_output.WriteLine("Cotizacion añadida es null --> Success");
cantTest++;
}
/**
* UnitTest Borrar Cotizacion
*/
{
var cotizacionBorrar = Assert.Throws <ModelException>(() => _sistema.Borrar(null));
Assert.Equal("El identificador ingresado fue nulo.", cotizacionBorrar.Message);
_output.WriteLine("id Cotizacion es null --> Success");
cantTest++;
}
/**
* UniTest Editar Cotizacion
*/
{
var cotizacionEditar = Assert.Throws <ModelException>(() => _sistema.Editar((Cotizacion)null));
Assert.Equal("La cotizacion es null.", cotizacionEditar.Message);
_output.WriteLine("Cotizacion a editar es null --> Success");
cantTest++;
}
List <Servicio> list = new List <Servicio>();
list.Add(new Servicio()
{
Cantidad = 2,
CostoUnidad = 3000,
Descripcion = "test servicio"
});
/**
* UnitTest BuscarCotizacion
*/
{
//id Cotizacion es null
var cotizacionBuscar =
Assert.Throws <ModelException>(() => _sistema.BuscarCotizacion((string)null));
Assert.Equal("El identificador ingresado fue nulo.", cotizacionBuscar.Message);
_output.WriteLine("id Cotizacion en BuscarCotizacion es null --> Success");
cantTest++;
//Buscar repositorio vacio
var cotizacionBuscarReferenceException =
Assert.Throws <NullReferenceException>(() => _sistema.BuscarCotizacion("idtest"));
Assert.Equal("Repositorio de Cotizaciones se encuentra vacio", cotizacionBuscarReferenceException.Message);
_output.WriteLine("Repositorio cotizacion vacio --> Success");
cantTest++;
_sistema.Anadir(new Cotizacion()
{
Titulo = "Testing",
Descripcion = "Cotizacion de testing",
Cliente = cliente,
CostoTotal = 2000000,
Servicios = list
});
// No se encuentra una cotizacion con esa id asociada
cotizacionBuscar = Assert.Throws <ModelException>(() => _sistema.BuscarCotizacion("id"));
Assert.Equal("No se encontro la cotizacion con el identificador ingresado.", cotizacionBuscar.Message);
_output.WriteLine("id no existe en el repositorio cotizacion --> Success");
cantTest++;
// Se encuentra una cotizacion
Assert.NotNull(_sistema.BuscarCotizacion("301v1"));
_output.WriteLine("id no existe en el repositorio cotizacion --> Success");
cantTest++;
}
/**
* UnitTest CambiarEstadoCotizacion
*/
{
//id Cotizacion es null
var cambioEstado =
Assert.Throws <ModelException>(() => _sistema.CambiarEstado((string)null, EstadoCotizacion.Aprobada));
Assert.Equal("El identificador ingresado fue nulo.", cambioEstado.Message);
_output.WriteLine("id cotizacion Cambiar estado es null --> Success");
cantTest++;
//id cotizacion no existe en el repositorio
cambioEstado =
Assert.Throws <ModelException>(() => _sistema.CambiarEstado("id1test", EstadoCotizacion.Aprobada));
Assert.Equal("No se encontro la cotizacion con el identificador ingresado.", cambioEstado.Message);
_output.WriteLine("id no existe en el repositorio cotizacion --> Success");
cantTest++;
// Tratar de cambiar cotizacion a un estado invalido
cambioEstado =
Assert.Throws <ModelException>(() => _sistema.CambiarEstado("301v1", EstadoCotizacion.Aprobada));
Assert.Equal("Esta cotizacion solo puede ser enviada o rechazada!", cambioEstado.Message);
_output.WriteLine("Estado cotizacion Borrador limitado a enviada o rechazada --> Success");
cantTest++;
}
//------------------------------------------------------------------------------
// Operaciones de Sistema: Usuario (OS_USXXX)
//------------------------------------------------------------------------------
_output.WriteLine("TEST USUARIO \n--------------------- ");
/*
* UnitTest Añadir Usuario
*/
{
// Contraseña es null
var usuarioAnadirParam =
Assert.Throws <ModelException>(() => _sistema.Anadir(p, (string)null));
Assert.Equal("La password no puede ser null.", usuarioAnadirParam.Message);
_output.WriteLine("Password del usuario es null --> Success");
cantTest++;
// Persona es null
var usuarioAnadir =
Assert.Throws <ModelException>(() => _sistema.Anadir(null, "pwtest"));
Assert.Equal("Persona es null", usuarioAnadir.Message);
_output.WriteLine("Persona del usuario es null --> Success");
cantTest++;
}
/*
* UnitTest LoginUsuario
*/
{
// Contraseña null
var loginUsuario =
Assert.Throws <ModelException>(() => _sistema.Login(null, null));
Assert.Equal("Password no puede ser null", loginUsuario.Message);
_output.WriteLine("Password es nulo en login --> Success");
cantTest++;
// Usuario no existe en el repositorio
loginUsuario =
Assert.Throws <ModelException>(() => _sistema.Login("100875713", "pw123"));
Assert.Equal("Usuario no encontrado", loginUsuario.Message);
_output.WriteLine("Usuario no encontrado login --> Success");
cantTest++;
_sistema.Anadir(p);
//Persona sin credenciales (no tiene instancia como usuario)
loginUsuario =
Assert.Throws <ModelException>(() => _sistema.Login("194460880", "pwtest"));
Assert.Equal("Existe la Persona pero no tiene credenciales de acceso", loginUsuario.Message);
_output.WriteLine("Persona sin credenciales --> Success");
cantTest++;
//Add usuario al repositorio para la siguiente unitTest
_sistema.Anadir(p, "1234");
// Login con contraseña incorrecta
loginUsuario =
Assert.Throws <ModelException>(() => _sistema.Login("194460880", "pwtest"));
Assert.Equal("Contrasena incorrecta!", loginUsuario.Message);
_output.WriteLine("Login contraseña incorrecta --> Success");
cantTest++;
//Se hace un login exitoso, asegurando que se retornara un usuario
Assert.NotNull(_sistema.Login("194460880", "1234"));
_output.WriteLine("Login Existoso --> Success");
cantTest++;
}
//------------------------------------------------------------------------------
// Operaciones de Sistema: Persona (OS_PEXXX)
//------------------------------------------------------------------------------
_output.WriteLine("TEST PERSONA \n--------------------- ");
/*
* UnitTest Añadir Persona
*/
{
//Añadir persona null
var personaAnadir =
Assert.Throws <ModelException>(() => _sistema.Anadir((Persona)null));
Assert.Equal("Persona es null", personaAnadir.Message);
_output.WriteLine("Persona es null al agregar al repositorio --> Success");
cantTest++;
}
/*
* UnitTest BuscarPersona
*/
{
// rutEmail es null
var personaBuscar =
Assert.Throws <ModelException>(() => _sistema.BuscarPersona((string)null));
Assert.Equal("El rut o email ingresado fue nulo.", personaBuscar.Message);
_output.WriteLine("Rut ingresado para buscar persona es null --> Success");
cantTest++;
// se busca la persona asegurando exito de busqueda
Assert.NotNull(_sistema.BuscarPersona("194460880"));
_output.WriteLine("Persona encontrada con exito--> Success");
cantTest++;
}
//------------------------------------------------------------------------------
// Operaciones de Sistema: Servicio (OS_SEXXX)
//------------------------------------------------------------------------------
_output.WriteLine("TEST SERVICIOS \n--------------------- ");
Servicio service = new Servicio();
/*
* UnitTest Añadir Servicio
*/
{
//Añadir servicio nulo
var servicioAnadir =
Assert.Throws <ModelException>(() => _sistema.Anadir((Servicio)null, (Cotizacion)null));
Assert.Equal("El servicio ingresado fue nulo.", servicioAnadir.Message);
_output.WriteLine("Añadir servicio nulo --> Success");
cantTest++;
//Añadir servicio a una cotizacion nula
servicioAnadir =
Assert.Throws <ModelException>(() => _sistema.Anadir(service, (Cotizacion)null));
Assert.Equal("La cotizacion ingresada fue nula.", servicioAnadir.Message);
_output.WriteLine("Añadir servicio a cotizacion nula --> Success");
cantTest++;
}
/*
* UnitTest Cambiar Estado Servicio
*/
{
var personaAnadir =
Assert.Throws <ModelException>(() => _sistema.Anadir((Persona)null));
Assert.Equal("Persona es null", personaAnadir.Message);
_output.WriteLine("Persona es null al agregar al repositorio --> Success");
cantTest++;
}
//------------------------------------------------------------------------------
// Operaciones de Sistema: Cliente (OS_CLXXX)
//------------------------------------------------------------------------------
_output.WriteLine("TEST CLIENTE \n--------------------- ");
/*
* UnitTest añadir Cliente
*/
{
//Persona es nula al agregar como cliente
var clienteAnadir =
Assert.Throws <ModelException>(() => _sistema.Anadir((Persona)null, TipoCliente.Otro));
Assert.Equal("Persona es null", clienteAnadir.Message);
_output.WriteLine("Persona es null al añadir como cliente --> Success");
cantTest++;
}
/**
* UnitTest BuscarCliente
*/
{
//Persona es nula al agregar como cliente
var clienteBuscar =
Assert.Throws <ModelException>(() => _sistema.BuscarCliente(null));
Assert.Equal("El rut o email ingresado fue nulo.", clienteBuscar.Message);
_output.WriteLine("Rut null en buscarCliente --> Success");
cantTest++;
//Persona retorna un cliente, asegurando exito de busqueda
Assert.NotNull(_sistema.BuscarCliente("194460880"));
_output.WriteLine("Busqueda exitosa BuscarCliente --> Success");
cantTest++;
}
_output.WriteLine("\n---------------- \nCantidad de Test Success :" + cantTest);
}
private void LimpiarControles()
{
this.txtDescripcion.Clear();
this.txtPrecio.Clear();
servicioSeleccionado = null;
}
public void ABCCatServicio(Servicio Datos)
{
try
{
Datos.Completado = false;
int Resultado = 0;
SqlDataReader dr = SqlHelper.ExecuteReader(Datos.Conexion, CommandType.StoredProcedure, "spCSLDB_abc_CatServicio",
new SqlParameter("@Opcion", Datos.Opcion),
new SqlParameter("@IDProducto", Datos.IDServicio),
new SqlParameter("@IDFamilia", Datos.IDFamilia),
new SqlParameter("@Clave", Datos.Clave),
new SqlParameter("@Nombre", Datos.NombreServicio),
new SqlParameter("@PrecioNormal", Datos.PrecioNormal),
new SqlParameter("@Descripcion", Datos.Descripcion),
new SqlParameter("@AplicaIVA", Datos.AplicaIVA),
new SqlParameter("@AplicaPrecioMay", Datos.AplicaPrecioMayoreo),
new SqlParameter("@PrecioMayoreo", Datos.PrecioMayoreo),
new SqlParameter("@CantidadMayoreo", Datos.CantidadMayoreo),
new SqlParameter("@AplicaPrecioTemp", Datos.AplicaPrecioTemporada),
new SqlParameter("@PrecioTemp", Datos.PrecioTemporada),
new SqlParameter("@TiempoMinuto", Datos.TiempoMinutos),
new SqlParameter("@FechaInicioTemp", Datos.FechaInicioTemp),
new SqlParameter("@FechaFinTemp", Datos.FechaFinTemp),
new SqlParameter("@AplicaPrecioEsp", Datos.AplicaPrecioEspecial),
new SqlParameter("@PrecioEspecial", Datos.PrecioEspecial),
new SqlParameter("@LunesPrecioEsp", Datos.PrecioEspecialLunes),
new SqlParameter("@MartesPrecioEsp", Datos.PrecioEspecialMartes),
new SqlParameter("@MiercolesPrecioEsp", Datos.PrecioEspecialMiercoles),
new SqlParameter("@JuevesPrecioEsp", Datos.PrecioEspecialJueves),
new SqlParameter("@ViernesPrecioEsp", Datos.PrecioEspecialViernes),
new SqlParameter("@SabadoPrecioEsp", Datos.PrecioEspecialSabado),
new SqlParameter("@DomingoPrecioEsp", Datos.PrecioEspecialDomingo),
new SqlParameter("@UrlImagen", Datos.UrlImagen),
new SqlParameter("@Imagen", Datos.Imagen),
new SqlParameter("@TablaServicio", Datos.TablaProductos),
new SqlParameter("@TablaMonedero", Datos.TablaMonederos),
new SqlParameter("@IDUsuario", Datos.IDUsuario)
);
while (dr.Read())
{
Resultado = !dr.IsDBNull(dr.GetOrdinal("Resultado")) ? dr.GetInt32(dr.GetOrdinal("Resultado")) : 0;
if (Resultado == 1)
{
Datos.Completado = true;
Datos.IDProducto = dr.GetString(dr.GetOrdinal("IDProducto"));
Datos.UrlImagen = Datos.IDProducto + ".JPG";
}
else
{
Datos.Completado = false;
Datos.Resultado = Resultado;
Datos.MensajeError = dr.GetString(dr.GetOrdinal("Mensaje"));
}
break;
}
}
catch (Exception ex)
{
throw ex;
}
}
public bool ActualizarServicio(Servicio servicio)
{
try
{
return reservaDAO.ActualizarServicio(servicio);
}
catch (Exception)
{
throw;
}
}
public void Load()
{
try
{
Client = ContainerService.Resolve <IDelfinServices>();
/************** Servicios/Documentos *****************/
Infrastructure.WinForms.Controls.ComboBox.ComboxBoxItem.AddComboBoxItem("I", "INGRESO", true);
Infrastructure.WinForms.Controls.ComboBox.ComboxBoxItem.AddComboBoxItem("C", "COSTO");
ListIngresoCosto = Infrastructure.WinForms.Controls.ComboBox.ComboxBoxItem.GetComboBoxItems();
ListTiposEntidadDocumentos = Client.GetAllTiposEntidad();
ListTiposTDO = Client.GetAllTiposByTipoCodTabla("TDO");
/*****************************************************/
/************** Servicios/Linea Negocio *****************/
ListTiposLNG = Client.GetAllConstantesByConstanteTabla("LNG");
ListTiposEntidad = Client.GetAllTiposEntidad();
/*****************************************************/
/************** Servicios/RegimenVia *****************/
ListTiposRGM = Client.GetAllConstantesByConstanteTabla("RGM");
ListTiposVIA = Client.GetAllConstantesByConstanteTabla("VIA");
/*****************************************************/
//SAP mcomun
//String Codigo =Item.SERV_Codigo.ToString;
Servicio servSeleccionar = new Servicio();
servSeleccionar.SERV_Codigo = 0;
servSeleccionar.SERV_Nombre_SPA = "< Seleccionar Servicio >";
ListServiciosAgrupador = Client.GetAllServicio();
ListServiciosAgrupador.Insert(0, servSeleccionar);
ListServiciosUnificador = Client.GetAllServicio();
ListServiciosUnificador.Insert(0, servSeleccionar);
Constantes consSeleccionar = new Constantes();
consSeleccionar.CONS_CodTipo = "";
consSeleccionar.CONS_Desc_SPA = "< Seleccionar Tipo >";
ListTiposServicios = Client.GetAllConstantesByConstanteTabla("TSV");
foreach (var item in ListTiposServicios)
{
item.CONS_CodTipo = item.CONS_CodTipo.Trim();
item.CONS_CodTipoTipo = item.CONS_CodTipoTipo.Trim();
}
ListTiposServicios.Insert(0, consSeleccionar);
DSPeriodos = new DataSet();
DSPeriodos = Client.GetDSDocsVta("CON_CENTSS_PeriodosDisponibles", null);
string x_year = Client.GetFecha().Year.ToString();
ObservableCollection <Infrastructure.Aspect.DataAccess.DataAccessFilterSQL> _listFilters = new ObservableCollection <Infrastructure.Aspect.DataAccess.DataAccessFilterSQL>();
_listFilters.Add(new Infrastructure.Aspect.DataAccess.DataAccessFilterSQL()
{
FilterName = "@TIPO_CodTabla", FilterValue = "OPE", FilterType = Infrastructure.Aspect.DataAccess.DataAccessFilterTypes.Char, FilterSize = 3
});
_listFilters.Add(new Infrastructure.Aspect.DataAccess.DataAccessFilterSQL()
{
FilterName = "@TIPO_ano", FilterValue = x_year, FilterType = Infrastructure.Aspect.DataAccess.DataAccessFilterTypes.Char, FilterSize = 4
});
_listFilters.Add(new Infrastructure.Aspect.DataAccess.DataAccessFilterSQL()
{
FilterName = "@Tipo", FilterValue = "V", FilterType = Infrastructure.Aspect.DataAccess.DataAccessFilterTypes.Char, FilterSize = 1
});
DSTiposOPE = Client.GetDSDocsVta("CON_TABLSS_TodosPorTipo", _listFilters);
_listFilters = new ObservableCollection <Infrastructure.Aspect.DataAccess.DataAccessFilterSQL>();
_listFilters.Add(new Infrastructure.Aspect.DataAccess.DataAccessFilterSQL()
{
FilterName = "@TIPO_CodTabla", FilterValue = "OPE", FilterType = Infrastructure.Aspect.DataAccess.DataAccessFilterTypes.Char, FilterSize = 3
});
_listFilters.Add(new Infrastructure.Aspect.DataAccess.DataAccessFilterSQL()
{
FilterName = "@TIPO_ano", FilterValue = x_year, FilterType = Infrastructure.Aspect.DataAccess.DataAccessFilterTypes.Char, FilterSize = 4
});
_listFilters.Add(new Infrastructure.Aspect.DataAccess.DataAccessFilterSQL()
{
FilterName = "@Tipo", FilterValue = "C", FilterType = Infrastructure.Aspect.DataAccess.DataAccessFilterTypes.Char, FilterSize = 1
});
DSTiposOPE_Costo = Client.GetDSDocsVta("CON_TABLSS_TodosPorTipo", _listFilters);
LoadParameteres();
LView.LoadView();
MView.LoadView();
}
catch (Exception ex)
{ Infrastructure.WinForms.Controls.Dialogos.MostrarMensajeError(Title, "Ha ocurrido un error inicializando la vista.", ex); }
}
public bool ActualizarServicio(Servicio servicio)
{
try
{
int filasAfectadas = 0;
using (SqlConnection conexion = Conexion.ObtenerInstancia().CrearConexionSQL())
{
using (SqlCommand comando = conexion.CreateCommand())
{
comando.CommandType = CommandType.StoredProcedure;
comando.CommandText = "SPU_Servicio";
comando.Parameters.Add(new SqlParameter("@IdServicio", servicio.ID));
comando.Parameters.Add(new SqlParameter("@Descripcion", servicio.Descripcion));
comando.Parameters.Add(new SqlParameter("@Precio", servicio.Precio));
comando.Parameters.Add(new SqlParameter("@Estado", servicio.Estado));
comando.Connection.Open();
filasAfectadas = comando.ExecuteNonQuery();
}
}
if (filasAfectadas > 0)
{
return true;
}
else
{
return false;
}
}
catch (AccesoBDException ex)
{
throw new DALException("ReservaDAO", "ActualizarServicio", "AccesoBD", ex.Message, ex);
}
catch (SqlException ex)
{
throw new DALException("ReservaDAO", "ActualizarServicio", "SQL", ex.Message, ex);
}
catch (Exception ex)
{
throw new DALException("ReservaDAO", "ActualizarServicio", "General: " + ex.GetType().ToString(), ex.Message, ex);
}
}
public List<Servicio> ConsultarServicios()
{
try
{
List<Servicio> listaServicios = null;
Servicio servicio = null;
using (SqlConnection conexion = Conexion.ObtenerInstancia().CrearConexionSQL())
{
using (SqlCommand comando = conexion.CreateCommand())
{
comando.CommandType = CommandType.StoredProcedure;
comando.CommandText = "SPS_Servicios_Todos";
comando.Connection.Open();
SqlDataReader dataReader = comando.ExecuteReader(CommandBehavior.CloseConnection);
if (dataReader.HasRows)
{
listaServicios = new List<Servicio>();
while (dataReader.Read())
{
servicio = new Servicio();
servicio.ID = Convert.ToInt32(dataReader["ID"]);
servicio.Descripcion = dataReader["DESCRIPCION"].ToString();
servicio.Precio = Convert.ToDouble(dataReader["PRECIO"]);
servicio.Estado = Convert.ToInt16(dataReader["ESTADO"]);
listaServicios.Add(servicio);
}
}
}
}
return listaServicios;
}
catch (AccesoBDException ex)
{
throw new DALException("ReservaDAO", "ConsultarServicios", "AccesoBD", ex.Message, ex);
}
catch (SqlException ex)
{
throw new DALException("ReservaDAO", "ConsultarServicios", "SQL", ex.Message, ex);
}
catch (Exception ex)
{
throw new DALException("ReservaDAO", "ConsultarServicios", "General: " + ex.GetType().ToString(), ex.Message, ex);
}
}
public JsonResult ModificarDIngreso(int lineaNegocio, int Id, DateTime mes, int movimiento, int moneda, string servicio, int grupo, string operador, string deudor, string trafico, decimal segundos, decimal min_fact, decimal tarifa_ext, decimal tarifa_final, decimal cantidad, decimal importe_ingreso, string no_factura, decimal monto_fact, decimal prov_nc, decimal ajuste, decimal nc_emitida, decimal saldo_prov, string motivo_ajuste, string periodo_ajuste, DateTime fecha_ajuste, string responsable_ajuste, string sociedad_sap, string sociedad, string nombre_empresa)
{
object respuesta = null;
string noEncontrados = "";
bool valido = false;
try {
Movimiento oMovimiento = db.Movimiento.Where(x => x.Id == movimiento && x.Activo == 1 && x.Id_LineaNegocio == lineaNegocio).SingleOrDefault();
Moneda oMoneda = db.Moneda.Where(x => x.Id == moneda && x.Activo == 1 && x.Id_LineaNegocio == lineaNegocio).SingleOrDefault();
Servicio oServicio = db.Servicio.Where(x => x.Id_Servicio == servicio && x.Activo == 1 && x.Id_LineaNegocio == lineaNegocio).SingleOrDefault();
Grupo oGrupo = db.Grupo.Where(x => x.Id == grupo && x.Activo == 1 && x.Id_LineaNegocio == lineaNegocio).SingleOrDefault();
Operador oOperador = db.Operador.Where(x => x.Id_Operador == operador && x.Activo == 1 && x.Id_LineaNegocio == lineaNegocio).SingleOrDefault();
Deudor oDeudor = db.Deudor.Where(x => x.Deudor1 == deudor && x.Activo == 1 && x.Id_LineaNegocio == lineaNegocio).SingleOrDefault();
Trafico oTrafico = db.Trafico.Where(x => x.Id_TraficoTR == trafico && x.Activo == 1 && x.Id_LineaNegocio == lineaNegocio).SingleOrDefault();
DataIngresoLDI oDI = db.DataIngresoLDI.Where(a => a.id == Id).SingleOrDefault();
if (oMovimiento == null)
{
noEncontrados = noEncontrados + "Sociedad " + sociedad + ",";
}
if (oMoneda == null)
{
noEncontrados = noEncontrados + "Tráfico: " + trafico + ",";
}
if (oServicio == null)
{
noEncontrados = noEncontrados + "Servico: " + servicio + ",";
}
if (oGrupo == null)
{
noEncontrados = noEncontrados + "Grupo: " + grupo + ",";
}
if (oOperador == null)
{
noEncontrados = noEncontrados + "Sociedad " + operador + ",";
}
if (oDeudor == null)
{
noEncontrados = noEncontrados + "Tráfico: " + deudor + ",";
}
if (oMovimiento != null && oTrafico != null && oServicio != null && oMoneda != null && oGrupo != null && oOperador != null && oDeudor != null && valido == true)
{
oDI.mes = mes;
oDI.id_moneda = oMoneda.Id;
oDI.id_servicio = oServicio.Id;
oDI.id_grupo = oGrupo.Id;
oDI.id_operador = oOperador.Id;
oDI.id_trafico = oTrafico.Id;
oDI.segundos = segundos;
//oDI.llamadas = llamadas;
oDI.importe_ingreso = importe_ingreso;
oDI.tarifa_ext = tarifa_ext;
oDI.id_deudor = oDeudor.Id;
oDI.min_fact = min_fact;
oDI.cantidad = cantidad;
oDI.no_factura_referencia = no_factura;
oDI.monto_facturado = monto_fact;
Log log = new Log();
log.insertaBitacoraModificacion(oDI, "id", oDI.id, "DataIngresoLDI.html", Request.UserHostAddress);
db.SaveChanges();
respuesta = new { success = true, results = "ok" };
}
respuesta = new { success = true, results = "" };
} catch (Exception ex) {
respuesta = new { success = false, results = ex.Message };
}
return(Json(respuesta, JsonRequestBehavior.AllowGet));
}
public static Orden_trabajo OrdenTrabajoGet(string folio)
{
Orden_trabajo o = new Orden_trabajo()
{
Folio = folio
};
try
{
Orden_trabajoMng oMng = new Orden_trabajoMng()
{
O_Orden_trabajo = o
};
oMng.selByFolio();
Orden_trabajo_servicioMng oOTSMng = new Orden_trabajo_servicioMng()
{
O_Orden_trabajo_servicio = new Orden_trabajo_servicio()
{
Id_orden_trabajo = o.Id
}
};
oOTSMng.fillLstByIdOT();
o.PLstOTSer = oOTSMng.Lst;
Entrada_liverpoolMng oELMng = new Entrada_liverpoolMng();
MaquilaMng oMMng = new MaquilaMng();
Maquila_pasoMng oMPMng = new Maquila_pasoMng();
ServicioMng oSMng = new ServicioMng();
foreach (Orden_trabajo_servicio itemOTS in o.PLstOTSer)
{
int ref2 = 0;
int.TryParse(itemOTS.Ref2, out ref2);
Entrada_liverpool oEL = new Entrada_liverpool()
{
Trafico = itemOTS.Ref1, Pedido = ref2
};
oELMng.O_Entrada_liverpool = oEL;
oELMng.selByUniqueKey();
itemOTS.PEntLiv = oEL;
Servicio oS = new Servicio()
{
Id = itemOTS.Id_servicio
};
oSMng.O_Servicio = oS;
oSMng.selById();
itemOTS.PServ = oS;
Maquila oM = new Maquila()
{
Id_ord_tbj_srv = itemOTS.Id
};
oMMng.O_Maquila = oM;
oMMng.fillLstByOTS();
itemOTS.PLstMaq = oMMng.Lst;
itemOTS.PalletMaq = itemOTS.PLstMaq.Sum(p => p.Pallets);
itemOTS.BultosMaq = itemOTS.PLstMaq.Sum(p => p.Bultos);
itemOTS.PiezasMaq = itemOTS.PLstMaq.Sum(p => p.Piezas);
int dif = itemOTS.Piezas - itemOTS.PiezasMaq;
itemOTS.Faltantes = 0;
itemOTS.Sobrantes = 0;
if (itemOTS.PiezasMaq > 0)
{
if (dif > 0)
{
itemOTS.Faltantes = dif;
}
else
{
itemOTS.Sobrantes = Math.Abs(dif);
}
}
Maquila_paso oMP = new Maquila_paso()
{
Id_ord_tbj_srv = itemOTS.Id
};
oMPMng.O_Maquila_paso = oMP;
oMPMng.fillByIdOTS();
itemOTS.PLstPasos = oMPMng.Lst;
int numPaso = 1;
foreach (Maquila_paso itemMP in oMPMng.Lst)
{
itemMP.NumPaso = numPaso;
numPaso++;
}
itemOTS.PasosMaq = itemOTS.PLstPasos.Count();
}
}
catch
{
throw;
}
return(o);
}
private void btnAgregarServicio_Click(object sender, EventArgs e)
{
try
{
Servicio ser = new Servicio();
bool estado, pagado;
if (rboAtendido.Checked)
{
estado = true;
}
else
{
estado = false;
}
if (rboSiPagado.Checked)
{
pagado = true;
}
else
{
pagado = false;
}
try
{
ser.PacienteId = Convert.ToInt32(txtIdPac.Text);
ser.MedicoCanId = Convert.ToInt32(txtIdMedCan.Text);
ser.MedicoRF02Id = Convert.ToInt32(txtMedEst.Text);
ser.Estado = estado;
ser.Pagado = pagado;
ser.Estudio = cboEstudio.SelectedItem.ToString();
ser.Fecha_hora = Convert.ToDateTime(txtFecha.Text);
}
catch
{
}
string mensaje = BusinessLogicLayer.ServicioBLL.insertar(ser);
if (string.IsNullOrEmpty(mensaje))
{
MessageBox.Show("El servicio se registro correctamente");
txtApellidoMedCan.Text = "";
txtApellidosMedes.Text = "";
txtApellidosPac.Text = "";
txtCedMedCan.Text = "";
txtCedulaMedes.Text = "";
txtEdadPac.Text = "";
txtEspecialidadMedes.Text = "";
txtIdMedCan.Text = "";
txtIdPac.Text = "";
txtMedEst.Text = "";
txtNombreMedCan.Text = "";
txtNombreMedes.Text = "";
txtNomPaciente.Text = "";
txtResidenciaPac.Text = "";
cboArea.SelectedItem = null;
cboEstudio.SelectedItem = null;
cboSexo.SelectedItem = null;
rboAtendido.Checked = false;
rboNoAtendido.Checked = true;
rboSiPagado.Checked = false;
rboNoPagado.Checked = true;
txtIdMedCan.Enabled = true;
txtIdPac.Enabled = true;
txtMedEst.Enabled = true;
}
else
{
MessageBox.Show(mensaje, "Error");
}
}
catch {
MessageBox.Show("Favor de verificar los datos ingresados", "Error");
}
}
public bool InsertarNuevoServicio(Servicio servicio)
{
try
{
return reservaDAO.InsertarServicio(servicio);
}
catch (Exception)
{
throw;
}
}
public bool EliminarServicio(Servicio servicio)
{
try
{
return reservaDAO.EliminarServicio(servicio);
}
catch (Exception)
{
throw;
}
}
protected void Button2_Click(object sender, EventArgs e)
{
Servicio serv = new Servicio();
serv.AgregarPrecio(Convert.ToDecimal(TextBox2.Text), Convert.ToInt32(TextBox1.Text));
Server.Transfer("AñadirPrecio.aspx");
}
private void _servicio_ItemSelected(object sender, AdapterView.ItemSelectedEventArgs e)
{
var spinner = (Spinner)sender;
_servicioSeleccionado = ((ArrayAdapter <Servicio>)spinner.Adapter).GetItem(e.Position);
}
protected void Button4_Click(object sender, EventArgs e)
{
Servicio serv = new Servicio();
serv.ConfirmarEstado(Convert.ToInt32(TextBox1.Text));
Server.Transfer("AñadirPrecio.aspx");
}
private void btnModificacion_Click(object sender, EventArgs e)
{
try
{
HabilitarControles(false);
if (this.gridServicios.CurrentRow != null)
{
this.Operacion = Accion.Modificacion;
this.gbDatosServicio.Enabled = true;
Servicio servicio = (Servicio)this.gridServicios.CurrentRow.DataBoundItem;
servicioSeleccionado = servicio;
this.txtDescripcion.Text = servicio.Descripcion;
this.txtPrecio.Text = servicio.Precio.ToString("N2");
}
}
catch (Exception ex)
{
ErrorManager.ObtenerInstancia().LoguearErrorBD(ex);
MessageBox.Show(ex.ToString(), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
protected void Button1_Click(object sender, EventArgs e)
{
Servicio serv = new Servicio();
serv.guardaCobro(TextBox1.Text,Double.Parse(TextBox2.Text));
}
public static Servicio CreateServicio(int id_servicio_Contratado, string descripcion_Servicio, string lugar_prest_Servicio, int id_empresa)
{
Servicio servicio = new Servicio();
servicio.id_servicio_Contratado = id_servicio_Contratado;
servicio.descripcion_Servicio = descripcion_Servicio;
servicio.lugar_prest_Servicio = lugar_prest_Servicio;
servicio.id_empresa = id_empresa;
return servicio;
}
void ProcessNode(IXmlNode root, Folder currentItem)
{
foreach (IXmlNode nodo in root.ChildNodes)
{
string nombre = nodo.NodeName;
if (nodo.NodeType == NodeType.ElementNode)
{
if (nombre == "settings")
{
HandleSettings(nodo);
}
else if (nombre == "folder")
{
string NombreFolder = nodo.Attributes.GetNamedItem("text").NodeValue.ToString();
Folder thisfolder = new Folder(NombreFolder, currentItem);
currentItem.items.Add(thisfolder);
ProcessNode(nodo, thisfolder);
}
else if (nombre == "widget")
{
string NombreWidget = nodo.Attributes.GetNamedItem("text").NodeValue.ToString();
string Funcion = nodo.Attributes.GetNamedItem("function").NodeValue.ToString();
Widget thiswidget = new Widget(NombreWidget, Funcion);
currentItem.items.Add(thiswidget);
}
else if (nombre == "service")
{
string NombreService = nodo.Attributes.GetNamedItem("text").NodeValue.ToString();
string FuncionService = nodo.Attributes.GetNamedItem("function").NodeValue.ToString();
string TagService = nodo.Attributes.GetNamedItem("tag").NodeValue.ToString();
Servicio thisservice = new Servicio(NombreService, FuncionService, TagService);
currentItem.items.Add(thisservice);
}
else if (nombre == "run")
{
//thisCommand = CommandToRun(child.getAttribute('text'), child.firstChild.data)
//currentItem.items.append(thisCommand)
}
}
}
}
/* Import files */
public CabeceroRespuesta SalvarArchivos(ImportarArchivosViewModel viewModel)
{
CabeceroRespuesta cabeceroRespuesta;
Servicio servicio = new Servicio();
/* Processing uploaded files */
HttpPostedFileBase sinacFileBase = viewModel.SinacFile;
HttpPostedFileBase sicFileBase = viewModel.SicFile;
/* Validation .*/
//if (sinacFileBase.ContentLength <= 0 || sicFileBase.ContentLength <= 0)
//{
// cabeceroRespuesta = new CabeceroRespuesta();
// cabeceroRespuesta.CodigoRespuesta = -1;
// cabeceroRespuesta.MensajeRespuesta = "Los archivos son incorrectos o no tienen datos.";
// return cabeceroRespuesta;
//}
/* Temp location */
var tempPath = Path.GetTempPath();
/* Preparing request to service */
CabeceroPeticion cabeceroPeticion = new CabeceroPeticion
{
SesionId = viewModel.Usuario.SesionId
};
PreCargaPeticion preCargaPeticion = new PreCargaPeticion()
{
Cabecero = cabeceroPeticion,
ColArchivo = new Collection <Archivo>()
};
/* SINAC */
if (sinacFileBase != null && sinacFileBase.ContentLength > 0)
{
var pathSINAC = Path.Combine(tempPath, Path.GetFileName(sinacFileBase.FileName));
sinacFileBase.SaveAs(pathSINAC);
var index_anio = sinacFileBase.FileName.IndexOf(".SINAC_");
var anio = sinacFileBase.FileName.Substring(index_anio + 7, 4);
Archivo archivoSINAC = new Archivo
{
Extension = sinacFileBase.ContentType,
Nombre = pathSINAC,
Ano = anio
};
archivoSINAC.IdentificarTablaSINAC();
preCargaPeticion.ColArchivo.Add(archivoSINAC);
}
/* SIC */
if (sicFileBase != null && sicFileBase.ContentLength > 0)
{
var pathSIC = Path.Combine(tempPath, Path.GetFileName(sicFileBase.FileName));
var index_anio = sicFileBase.FileName.IndexOf(".SIC_");
var anio = sicFileBase.FileName.Substring(index_anio + 5, 4);
sicFileBase.SaveAs(pathSIC);
Archivo archivoSIC = new Archivo
{
Extension = sicFileBase.ContentType,
Nombre = pathSIC,
Ano = anio
};
archivoSIC.IdentificarTablaSIC();
preCargaPeticion.ColArchivo.Add(archivoSIC);
}
/* Almacenar archivos */
cabeceroRespuesta = servicio.PreCargarDatos(preCargaPeticion);
if (cabeceroRespuesta.EsRespuestaExistosa())
{
cabeceroRespuesta.MensajeRespuesta = "Archivos guardados exitosamente.";
}
else
{
return(cabeceroRespuesta);
}
/* Procesar archivos. */
cabeceroRespuesta = servicio.ProcesarCarga(preCargaPeticion);
if (cabeceroRespuesta.EsRespuestaExistosa())
{
cabeceroRespuesta.MensajeRespuesta = "Los archivos han sido guardados y procesados exitosamente, los datos pueden ser consultados ahora.";
}
else
{
return(cabeceroRespuesta);
}
return(cabeceroRespuesta);
}
protected void Button2_Click(object sender, EventArgs e)
{
Servicio ser = new Servicio();
ser.modificarCl(Convert.ToInt32(TextBox1.Text), TextBox2.Text, TextBox3.Text, TextBox4.Text, Convert.ToInt32(TextBox5.Text), TextBox6.Text, Convert.ToInt32(TextBox7.Text), TextBox8.Text, TextBox9.Text);
}
static void agregarServicioAEvento()
{
Console.Clear();
Console.WriteLine("\n---------- AÑADIR SERVICIOS A EVENTOS ----------\n");
Console.WriteLine("Ingrese el email");
string email = Console.ReadLine();
Console.WriteLine("Ingrese la contraseña");
string password = Console.ReadLine();
Administrador adm = emp.verificarUsuario(email, password);
if (adm is Organizador)
{
Organizador org = (Organizador)adm;
Console.WriteLine("Ingrese la fecha del evento");
DateTime fecha;
DateTime.TryParse(Console.ReadLine(), out fecha);
if (fecha.Date >= DateTime.Now.Date)
{
Evento ev = emp.verificarFechaEvento(fecha, org);
if (ev != null)
{
Console.WriteLine(ev.ToString());
listarServicios();
string nombreServicio = "";
int cantPersonasServicio = 0;
List <Servicio> servicios = new List <Servicio>();
List <int> cantPersonasServicioLista = new List <int>();
//Tengo algunas dudas con esta variable ya que no se si es muy correcto hacer
//esto, es la unica forma que encontre de poder consultar la cantidad de personas
//para un evento, ya que podria haberlo hecho simplemente llamando a la property
//del evento, pero como Program no tiene acceso a dicho contenido lo que hice
//fue como ir paso a paso de clase a clase hasta poder retornar dicho valor.
int cantPersonasEvento = emp.cantAsistentesEvento(org, ev);
while (nombreServicio != "salir")
{
success("Ingrese 'salir' para dejar de agregar servicios");
Console.WriteLine("Ingrese el nombre de un servicio");
nombreServicio = Console.ReadLine();
if (nombreServicio.ToLower() != "salir" && nombreServicio != "")
{
Console.WriteLine("Ingrese la cantidad de personas para el servicio MAX(" + cantPersonasEvento + ")");
string cantPersonas = Console.ReadLine();
if (verificarNumerico(cantPersonas))
{
int.TryParse(cantPersonas, out cantPersonasServicio);
//if (cantPersonasServicio > 0 && cantPersonasServicio <= ev.CantAsistentes)
if (cantPersonasServicio > 0 && cantPersonasServicio <= cantPersonasEvento)
{
Servicio serv = emp.buscarServicio(nombreServicio);
if (serv != null)
{
servicios.Add(serv);
cantPersonasServicioLista.Add(cantPersonasServicio);
}
else
{
error("No existe el servicio");
}
}
else
{
error("La cantidad de asistentes debe ser mayor a 0 y menor a la cantidad de asistentes al evento");
}
}
else
{
error("La cantidad de personas para el servicio debe ser numerico");
}
}
}
Console.WriteLine(emp.agregarServicioAEvento(org, ev, servicios, cantPersonasServicioLista));
}
else
{
error("No existe un evento con esa fecha");
}
}
else
{
error("La fecha ya ah transcurrido");
}
}
else
{
error("No existe el organizador");
}
}
public void AgregarServicio(Servicio servicio)
{
if (!Servicios.Contains(servicio))
{
Servicios.Add(servicio);
}
}
public static bool insertar(Servicio s)
{
db.Servicios.Add(s);
return(db.SaveChanges() > 0);
}
public void QuitarServicio(Servicio servicio)
{
if (Servicios.Contains(servicio))
{
Servicios.Remove(servicio);
}
}
private async void btnGuardar_Click(object sender, EventArgs e)
{
try
{
btnGuardar.Enabled = false;
this.CleanErrors(errorProvider1, typeof(ServicioViewModel));
var validationResults = Model.Validate();
validationResults.ToString();
if (validationResults.IsValid)
{
if (Model.UpdateImagen || (ClaveAux != Model.Clave && ClaveAux != null))//SI se cambia la clave o la imagen se sube la imagen
{
bool subir = false;
CIDWait.Show(async() =>
{
//Subimos la imagen al Servidor FTP
subir = await Model.UploadFTP(Model.RutaImagen,
ConfigurationManager.AppSettings.Get("ServerFtpTxt") + @"/imgServicios/" + Model.Clave + Model.Extencion,
ConfigurationManager.AppSettings.Get("UsuarioFtpTxt"),
ConfigurationManager.AppSettings.Get("ContraseñaFtpTxt"));
}, "Espere");
if (!subir)
{
//Mensaje de avertencia que la imagen no se pudo cargar
CIDMessageBox.ShowAlert(Messages.SystemName, "NO SE PUDO SUBIR LA IMAGEN", TypeMessage.informacion);
}
}
Model.UpdateImagen = false;
var aux = Model.Duracion;
var otroAux = DuracionControl.Value;
Servicio Resul = await Model.GuardarCambios(CurrentSession.IdCuentaUsuario);
if (Resul.Resultado == 1)
{
if (Model.RutaAux != "" && Model.RutaAux != null)
{
File.Delete(Model.RutaAux);//Borramos la imagen desde la carpeta RESOURCES
}
CIDMessageBox.ShowAlert(Messages.SystemName, Messages.SuccessMessage, TypeMessage.correcto);
LimpiarPropiedades();
//await Model.GetAllAsync();
this.Close();
}
else
{
CIDMessageBox.ShowAlert(Messages.ErrorMessage, "Error", TypeMessage.error);
}
}
else
{
this.ShowErrors(errorProvider1, typeof(ServicioViewModel), validationResults);
}
}
catch (Exception ex)
{
ErrorLogHelper.AddExcFileTxt(ex, "FrmServicioNuevo ~ btnGuardar_Click(object sender, EventArgs e)");
CIDMessageBox.ShowAlert(Messages.SystemName, Messages.ErrorMessage, TypeMessage.error);
}
finally
{
btnGuardar.Enabled = true;
}
}
public void AddToServicio_Subcontratado(Servicio servicio)
{
base.AddObject("Servicio_Subcontratado", servicio);
}
/// <summary>
/// Registro de un nuevo servicio
/// </summary>
/// <param name="idPlaya">id de la playa</param>
/// <param name="idTipoVechiculo">id del tipo de vehiculo</param>
/// <param name="capacidad">capacidad (lugares para el tipo de vehiculo)</param>
/// <param name="x1">precio por hora</param>
/// <param name="x6">precio por 6 horas</param>
/// <param name="x12">precio por 12 horas</param>
/// <param name="x24">precio por 24 horas</param>
/// <param name="abono">precio por mes</param>
/// <returns>Objeto resultado configurado de acuerdo a como se realizo la operacion</returns>
public Resultado RegistrarServicioPlaya(int idPlaya, int idTipoVechiculo, int capacidad, double x1, double x6, double x12, double x24, double abono)
{
Resultado resultado = new Resultado();
try
{
Servicio servicio = new Servicio();
servicio.TipoVehiculoId = idTipoVechiculo;
//capacidad
Capacidad cap = new Capacidad();
cap.Cantidad = capacidad;
servicio.Capacidad = cap;
//precios
List <Precio> precios = new List <Precio>();
//por hora
if (x1 != 0)
{
Precio p1 = new Precio();
p1.TiempoId = 1;
p1.Monto = Decimal.Parse(x1.ToString());
precios.Add(p1);
}
//por 6 horas
if (x6 != 0)
{
Precio p2 = new Precio();
p2.TiempoId = 2;
p2.Monto = Decimal.Parse(x6.ToString());
precios.Add(p2);
}
//por 12 horas
if (x12 != 0)
{
Precio p3 = new Precio();
p3.TiempoId = 3;
p3.Monto = Decimal.Parse(x12.ToString());
precios.Add(p3);
}
//por 24 horas
if (x24 != 0)
{
Precio p4 = new Precio();
p4.TiempoId = 1;
p4.Monto = Decimal.Parse(x24.ToString());
precios.Add(p4);
}
//abono mensual
if (abono != 0)
{
Precio p5 = new Precio();
p5.TiempoId = 1;
p5.Monto = Decimal.Parse(abono.ToString());
precios.Add(p5);
}
servicio.Precios = precios;
servicio.DisponibilidadPlayas = new DisponibilidadPlayas();
servicio.DisponibilidadPlayas.Disponibilidad = servicio.Capacidad.Cantidad;
//buscamos la playa a la que agregamos el servicio
PlayaDeEstacionamiento playa = playaDao.FindById(idPlaya);
//agregamos el servicio
playa.Servicios.Add(servicio);
//actualizamos la playa
playaDao.Update(playa);
}
catch (Exception)
{
resultado.AgregarMensaje("Se ha producido un error de base de datos.");
}
return(resultado);
}
public static bool validarBus(Servicio servicio)
{
return(_unitOfWork.Servicios.FindServiceByDate(servicio).Rows.Count == 0);
}
private void CollectionViewSource_Filter(object sender, FilterEventArgs e)
{
//Filtra por origen y destino
if (cmbOrigen.SelectedIndex != -1 && cmbDestino.SelectedIndex != -1 && dpFecha.SelectedDate == null)
{
int origen = (int)cmbOrigen.SelectedValue;
int desttino = (int)cmbDestino.SelectedValue;
Servicio oServicio = e.Item as Servicio;
if (oServicio != null)
{
if (oServicio.Ter_Codigo_Origen.Equals(origen) && oServicio.Ter_Codigo_Destino.Equals(desttino))
{
e.Accepted = true;
}
else
{
e.Accepted = false;
}
}
else
{
MessageBox.Show("No se encontraron datos.", "¡Información!", MessageBoxButton.OK, MessageBoxImage.Exclamation);
}
}
//Filtra solo por origen
if (cmbOrigen.SelectedIndex != -1 && cmbDestino.SelectedIndex == -1 && dpFecha.SelectedDate == null)
{
int origen = (int)cmbOrigen.SelectedValue;
Servicio oServicio = e.Item as Servicio;
if (oServicio != null)
{
if (oServicio.Ter_Codigo_Origen.Equals(origen))
{
e.Accepted = true;
}
else
{
e.Accepted = false;
}
}
else
{
MessageBox.Show("No se encontraron datos.", "¡Información!", MessageBoxButton.OK, MessageBoxImage.Exclamation);
}
}
//Filtra solo por destino
if (cmbDestino.SelectedIndex != -1 && cmbOrigen.SelectedIndex == -1 && dpFecha.SelectedDate == null)
{
int desttino = (int)cmbDestino.SelectedValue;
Servicio oServicio = e.Item as Servicio;
if (oServicio != null)
{
if (oServicio.Ter_Codigo_Destino.Equals(desttino))
{
e.Accepted = true;
}
else
{
e.Accepted = false;
}
}
else
{
MessageBox.Show("No se encontraron datos.", "¡Información!", MessageBoxButton.OK, MessageBoxImage.Exclamation);
}
}
//Filtra solo por Fecha
if (dpFecha.SelectedDate != null && cmbDestino.SelectedIndex == -1 && cmbOrigen.SelectedIndex == -1)
{
DateTime dtFiltro = new DateTime(dpFecha.SelectedDate.Value.Year, dpFecha.SelectedDate.Value.Month, dpFecha.SelectedDate.Value.Day, 0, 0, 0);
Servicio oServicio = e.Item as Servicio;
if (oServicio != null)
{
DateTime fecha = new DateTime(oServicio.Ser_FechaHora.Year, oServicio.Ser_FechaHora.Month, oServicio.Ser_FechaHora.Day, 0, 0, 0);
if (dtFiltro == fecha)
{
e.Accepted = true;
}
else
{
e.Accepted = false;
}
}
else
{
MessageBox.Show("No se encontraron datos.", "¡Información!", MessageBoxButton.OK, MessageBoxImage.Exclamation);
}
}
//Filtra por orige, destino y fecha
if (cmbOrigen.SelectedIndex != -1 && cmbDestino.SelectedIndex != -1 && dpFecha.SelectedDate != null)
{
int origen = (int)cmbOrigen.SelectedValue;
int desttino = (int)cmbDestino.SelectedValue;
DateTime dtFiltro = new DateTime(dpFecha.SelectedDate.Value.Year, dpFecha.SelectedDate.Value.Month, dpFecha.SelectedDate.Value.Day, 0, 0, 0);
Servicio oServicio = e.Item as Servicio;
if (oServicio != null)
{
DateTime fecha = new DateTime(oServicio.Ser_FechaHora.Year, oServicio.Ser_FechaHora.Month, oServicio.Ser_FechaHora.Day, 0, 0, 0);
if (oServicio.Ter_Codigo_Origen.Equals(origen) && oServicio.Ter_Codigo_Destino.Equals(desttino) && dtFiltro == fecha)
{
e.Accepted = true;
}
else
{
e.Accepted = false;
}
}
else
{
MessageBox.Show("No se encontraron datos.", "¡Información!", MessageBoxButton.OK, MessageBoxImage.Exclamation);
}
}
//Filtra por origen y fecha
if (cmbOrigen.SelectedIndex != -1 && dpFecha.SelectedDate != null && cmbDestino.SelectedIndex == -1)
{
int origen = (int)cmbOrigen.SelectedValue;
DateTime dtFiltro = new DateTime(dpFecha.SelectedDate.Value.Year, dpFecha.SelectedDate.Value.Month, dpFecha.SelectedDate.Value.Day, 0, 0, 0);
Servicio oServicio = e.Item as Servicio;
if (oServicio != null)
{
DateTime fecha = new DateTime(oServicio.Ser_FechaHora.Year, oServicio.Ser_FechaHora.Month, oServicio.Ser_FechaHora.Day, 0, 0, 0);
if (oServicio.Ter_Codigo_Origen.Equals(origen) && dtFiltro == fecha)
{
e.Accepted = true;
}
else
{
e.Accepted = false;
}
}
else
{
MessageBox.Show("No se encontraron datos.", "¡Información!", MessageBoxButton.OK, MessageBoxImage.Exclamation);
}
}
//Filtra por destino y fecha
if (cmbDestino.SelectedIndex != -1 && dpFecha.SelectedDate != null && cmbOrigen.SelectedIndex == -1)
{
int desttino = (int)cmbDestino.SelectedValue;
DateTime dtFiltro = new DateTime(dpFecha.SelectedDate.Value.Year, dpFecha.SelectedDate.Value.Month, dpFecha.SelectedDate.Value.Day, 0, 0, 0);
Servicio oServicio = e.Item as Servicio;
if (oServicio != null)
{
DateTime fecha = new DateTime(oServicio.Ser_FechaHora.Year, oServicio.Ser_FechaHora.Month, oServicio.Ser_FechaHora.Day, 0, 0, 0);
if (oServicio.Ter_Codigo_Destino.Equals(desttino) && dtFiltro == fecha)
{
e.Accepted = true;
}
else
{
e.Accepted = false;
}
}
else
{
MessageBox.Show("No se encontraron datos.", "¡Información!", MessageBoxButton.OK, MessageBoxImage.Exclamation);
}
}
}
public RegisterService(Servicio service)
{
Service = service;
}
public async Task <IActionResult> GetCostoServicio(int id)
{
Servicio obj = await BDServicio.Buscar(id);
return(new JsonResult(obj.Costo));
}
protected void Button2_Click(object sender, EventArgs e)
{
Servicio ser = new Servicio();
ser.DespedirEmpleado(Convert.ToInt32(TextBox1.Text), TextBox2.Text, TextBox3.Text, Convert.ToDouble(TextBox4.Text), TextBox5.Text, TextBox6.Text, TextBox7.Text, TextBox8.Text);
}
