/// <summary>
/// DEVUELVE LOS ADMINISTRATIVOS DEL SISTEMA
/// DEJA POR FUERA UN USUARIO "SUPER" PARA QUE NO PUEDA SER MODIFICADO
/// </summary>
/// <returns>LISTA DE ADMINISTRATIVOS</returns>
public async Task<List<Administrativo>> getAdministrativos()
{
try
{
var items = await DBRepositoryMongo<Administrativo>.GetItemsAsync("Administrativos");
List<Administrativo> aux = items.ToList();
List<Administrativo> salida = new List<Administrativo>();
Administrativo admin = null;
foreach (Administrativo a in aux)
{
admin = a.Desencriptar(a);
salida.Add(admin);
}
Administrativo eliminar = null;
foreach (Administrativo a in salida)
{
if (a.User.Equals("super"))
{
eliminar = a;
}
}
salida.Remove(eliminar);
return salida;
}
catch (MensajeException msg)
{
throw msg;
}
catch (Exception)
{
throw new MensajeException("Se produjo un error inesperado, intente de nuevo mas tarde");
}
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, IOptions <AppSettingsMongo> appSettingsMongo)
{
if (env.IsDevelopment())
{
app.UseBrowserLink();
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Home/Error");
}
app.UseAuthentication();
app.UseStaticFiles();
app.UseSession();
app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});
_settingsMongo = appSettingsMongo;
//DBRepository<AppSettings>.Iniciar(_settings);
DBRepositoryMongo <AppSettingsMongo> .Iniciar(_settingsMongo);
}
/// <summary>
/// ingresa un nuevo chofer al sistema y lo devuelve
/// </summary>
/// <param name="chofer"></param>
/// <param name="libreta"></param>
/// <returns>Chofer</returns>
public async Task<Chofer> CrearChofer(Chofer chofer, LibretaDeConducir libreta)
{
Chofer salida = null;
try
{
Chofer c = await DBRepositoryMongo<Chofer>.GetUsuario(chofer.User, "Choferes");
if (c != null)
{
throw new MensajeException("El chofer ya existe");
}
else
{
salida = chofer;
salida.Tipo = "Chofer";
salida.Disponible = true;
salida.LibretaDeConducir = libreta;
salida.Leyenda = chofer.Numero + " - " + chofer.Nombre + " " + chofer.Apellido;
if (salida.Ubicacion == null)
{
salida.Ubicacion = new PosicionSatelital() { Latitud = "", Longitud = "" };
}
salida = salida.Encriptar(salida);
await DBRepositoryMongo<Chofer>.Create(salida, "Choferes");
}
return salida;
}
catch(MensajeException msg)
{
throw msg;
}catch(Exception ex)
{
throw ex;
}
}
/// <summary>
/// se devuelve el chofer con el id seleccionado
/// se desencripta antes de devolverlo
/// </summary>
/// <param name="idChofer"></param>
/// <returns>Chofer</returns>
public async Task <Chofer> getChofer(string idChofer)
{
try
{
if (idChofer != null)
{
Chofer chofer = await DBRepositoryMongo <Chofer> .GetItemAsync(idChofer, "Choferes");
chofer = chofer.Desencriptar(chofer);
return(chofer);
}
else
{
throw new MensajeException("El Id del chofer no existe");
}
}
catch (MensajeException msg)
{
throw msg;
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// SE ELIMINA EL CHOFER Y SE ACTUALIZAN LOS VEHICULOS EN MEMORIA Y EN LA BD
/// </summary>
/// <param name="chofer"></param>
/// <param name="id"></param>
/// <returns></returns>
public async Task EliminarChofer(Chofer chofer, string id)
{
try
{
if (chofer != null && id != null)
{
await DBRepositoryMongo<Usuario>.DeleteAsync(id, "Choferes");
var vehiculos = await ControladoraVehiculos.getInstance(_settings).getVehiculos();
List<Vehiculo> aux = vehiculos.ToList();
foreach (Vehiculo v in aux)
{
if (v.Chofer.Id.ToString().Equals(id))
{
v.Chofer = new Chofer();
await ControladoraVehiculos.getInstance(_settings).editarVehiculo(v, v.Id.ToString(), v.Chofer.Id.ToString(), v.Tipo); // se acualiza el vehiculo en memoria y en la bd
}
}
}
else
{
throw new MensajeException("Ha ocurrido un error inesperado, vuelva a intentarlo mas tarde");
}
}
catch (MensajeException msg)
{
throw msg;
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// SE ELIMINA EL CLIENTE SELECCIONADO
/// </summary>
/// <param name="cliente"></param>
/// <param name="id"></param>
/// <returns></returns>
public async Task EliminarCliente(Cliente cliente, string id)
{
try
{
if (cliente != null && id != null)
{
await DBRepositoryMongo<Usuario>.DeleteAsync(id, "Clientes");
}
else
{
throw new MensajeException("Ha ocurrido un error inesperado, vuelva a intentarlo mas tarde");
}
}
catch (MensajeException msg)
{
throw msg;
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// SE MODIFICA EL PEON SELECCIONADO EN LA BD
/// </summary>
/// <param name="peon"></param>
/// <param name="id"></param>
/// <returns></returns>
public async Task ModificarPeon(Peon peon, string id)
{
try
{
if (peon != null && id != null)
{
peon.Id = new ObjectId(id);
peon.Encriptar(peon);
await DBRepositoryMongo<Peon>.UpdateAsync(peon.Id, peon, "Peones");
}
else
{
throw new MensajeException("Ha ocurrido un error inesperado. Vuelva a intentarlo mas tarde");
}
}
catch (MensajeException msg)
{
throw msg;
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// SE MODIFICA EL CLIENTE SELECCIONADO
/// </summary>
/// <param name="cliente"></param>
/// <param name="id"></param>
/// <param name="tarjeta"></param>
/// <returns></returns>
public async Task ModificarCliente(Cliente cliente, string id, TarjetaDeCredito tarjeta)
{
try
{
if (cliente != null && id != null)
{
cliente.Id = new ObjectId(id);
cliente.Tarjeta = tarjeta;
cliente.Encriptar(cliente);
await DBRepositoryMongo<Cliente>.UpdateAsync(cliente.Id, cliente, "Clientes");
}
else
{
throw new MensajeException("Ha ocurrido un error inesperado. Vuelva a intentarlo mas tarde");
}
}
catch (MensajeException msg)
{
throw msg;
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// SE CREA UN NUEVO PEON EN LA BD
/// </summary>
/// <param name="peon"></param>
/// <returns></returns>
public async Task CrearPeon(Peon peon)
{
try
{
Peon salida = null;
Peon p = await DBRepositoryMongo<Peon>.GetPeon(Seguridad.Encriptar(peon.Documento), "Peones");
if (p == null)
{
salida = peon;
salida = salida.Encriptar(salida);
await DBRepositoryMongo<Peon>.Create(salida, "Peones");
}
else
{
throw new MensajeException("Ya existe el peon");
}
}
catch (MensajeException msg)
{
throw msg;
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// se toma en cuenta los vehiculos de la bd
/// se desencriptan los choferes antes de devolverlos
/// </summary>
/// <returns>lista de vehiculos que estan ingresados al sistema</returns>
public async Task <IEnumerable <Vehiculo> > getVehiculos()
{
try
{
var items = await DBRepositoryMongo <Vehiculo> .GetItemsAsync("Vehiculos");
List <Vehiculo> salida = new List <Vehiculo>();
foreach (Vehiculo v in items)
{
if (!v.Chofer.Id.ToString().Equals("000000000000000000000000"))
{
Chofer c = v.Chofer;
v.Chofer = c.Desencriptar(c);
salida.Add(v);
}
else
{
salida.Add(v);
}
}
return(salida);
}
catch (MensajeException msg)
{
throw msg;
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// modifica un administrativo pasado como parametro
/// </summary>
/// <param name="usuario"></param>
/// <param name="id"></param>
/// <returns></returns>
public async Task ModificarAdministrativo(Administrativo usuario, string id)
{
try
{
if (usuario != null && id!=null)
{
usuario.Id = new ObjectId(id);
if (usuario.Ubicacion == null)
{
usuario.Ubicacion = new PosicionSatelital() { Latitud = "", Longitud = "" };
}
usuario = usuario.Encriptar(usuario);
await DBRepositoryMongo<Usuario>.UpdateAsync(usuario.Id, usuario, "Administrativos");
}
else
{
throw new MensajeException("Ha ocurrido un error inesperado. Vuelva a intentarlo mas tarde");
}
}
catch(MensajeException msg)
{
throw msg;
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// se elimina el vehiculo y se actualiza el estado del chofer.
/// </summary>
/// <param name="id"></param>
/// <param name="vehiculo"></param>
/// <returns></returns>
public async Task eliminarVehiculo(string id)
{
try
{
if (id != null)
{
Vehiculo eliminar = await DBRepositoryMongo <Vehiculo> .GetItemAsync(id, "Vehiculos");
await DBRepositoryMongo <Vehiculo> .DeleteAsync(id, "Vehiculos");
Vehiculos.Remove(eliminar);
eliminar.Chofer.Disponible = true;
await DBRepositoryMongo <Chofer> .UpdateAsync(eliminar.Chofer.Id, eliminar.Chofer, "Choferes");
}
else
{
throw new MensajeException("Ha ocurrido un error inesperado vuelva a intentarlo mas tarde");
}
}
catch (MensajeException msg)
{
throw msg;
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// devuelve la lista de choferes de la bd que no tienen vehiculos asociados
/// </summary>
/// <returns>lista de choferes</returns>
public async Task <List <Chofer> > choferesDisponibles()
{
try
{
List <Chofer> salida = new List <Chofer>();
var lista = await DBRepositoryMongo <Chofer> .GetItemsAsync("Choferes");
List <Chofer> aux = new List <Chofer>();
foreach (Chofer c in lista)
{
Chofer chofer = c.Desencriptar(c);
aux.Add(chofer);
}
foreach (Chofer c in aux)
{
if (c.Disponible)
{
salida.Add(c);
}
}
return(salida);
}
catch (MensajeException msg)
{
throw msg;
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// devuelve el chofer si lo puede validar o si no devuelve null
/// </summary>
/// <param name="usuario"></param>
/// <param name="pass"></param>
/// <returns>el chofer con las credenciales solicitadas</returns>
public async Task<Chofer>LoginChofer(string usuario, string pass)
{
try
{
Chofer chofer = await DBRepositoryMongo<Chofer>.Login(Seguridad.Encriptar(usuario), "Choferes");
if (chofer != null)
{
chofer = chofer.Desencriptar(chofer);
if (chofer.Password == pass)
{
return chofer;
}
else
{
throw new MensajeException("Usuario y/o contraseña incorrecta");
}
}
else
{
throw new MensajeException("Usuario y/o contraseña incorrecta");
}
}
catch(MensajeException msg)
{
throw msg;
}
catch (Exception ex)
{
throw ex;
}
}
public PeonController(IOptions <AppSettingsMongo> settings, IHttpContextAccessor httpContextAccessor, IConfiguration configuration)
{
_session = httpContextAccessor.HttpContext.Session;
_configuration = configuration;
_httpContext = httpContextAccessor;
_settings = settings;
DBRepositoryMongo <Peon> .Iniciar(_settings);
}
/// <summary>
/// Inserta un cliente encriptado en la base de datos
/// </summary>
/// <param name="cliente"></param>
/// <param name="tarjeta"></param>
/// <returns></returns>
public async Task CrearCliente(Cliente cliente, TarjetaDeCredito tarjeta)
{
try
{
Cliente salida = null;
Usuario usuario = await DBRepositoryMongo<Usuario>.GetUsuario(Seguridad.Encriptar(cliente.User), "Usuarios");
Cliente cli = await DBRepositoryMongo<Cliente>.GetUsuario(Seguridad.Encriptar(cliente.User), "Clientes");
Chofer chofer = await DBRepositoryMongo<Chofer>.GetUsuario(Seguridad.Encriptar(cliente.User), "Choferes");
if (usuario == null && cli == null && chofer == null)
{
cliente.Tipo = "Cliente";
cliente.Tarjeta = tarjeta;
if (cliente.RazonSocial != null)
{
cliente.Leyenda = cliente.RazonSocial;
}
else
{
cliente.Leyenda = cliente.Nombre + " " + cliente.Apellido;
cliente.RazonSocial = "";
}
if (cliente.Rut == null)
{
cliente.Rut = "";
}
if (cliente.Ubicacion == null)
{
cliente.Ubicacion = new PosicionSatelital() { Latitud = "", Longitud = "" };
}
if (string.IsNullOrEmpty(cliente.Tarjeta.fVencimiento))
{
cliente.Tarjeta.fVencimiento = "";
}
if (string.IsNullOrEmpty(cliente.Tarjeta.Numero))
{
cliente.Tarjeta.Numero = "";
}
salida = cliente.Encriptar(cliente);
await DBRepositoryMongo<Cliente>.Create(salida, "Clientes");
}
else
{
throw new MensajeException("Ya existe un usuario con ese nick");
}
}
catch (MensajeException msg)
{
throw msg;
}
catch (Exception ex)
{
throw ex;
}
}
private ControladoraUsuarios(IOptions<AppSettingsMongo> settings)
{
_settings = settings;
DBRepositoryMongo<Administrativo>.Iniciar(_settings);
DBRepositoryMongo<Chofer>.Iniciar(_settings);
DBRepositoryMongo<Cliente>.Iniciar(_settings);
DBRepositoryMongo<Peon>.Iniciar(_settings);
UbicacionesClientes = new Hashtable();
}
public AdministrativoController(IOptions <AppSettingsMongo> settings, IHttpContextAccessor httpContextAccessor, IConfiguration configuration)
{
_session = httpContextAccessor.HttpContext.Session;
_configuration = configuration;
_httpContext = httpContextAccessor;
_settings = settings;
DBRepositoryMongo <Usuario> .Iniciar(_settings);
_controladoraUsuarios = ControladoraUsuarios.getInstance(_settings);
}
private ControladoraVehiculos(IOptions <AppSettingsMongo> settings)
{
_settings = settings;
_controladoraViajes = ControladoraViajes.getInstancia(_settings);
UbicacionVehiculos = new Hashtable();
DBRepositoryMongo <Vehiculo> .Iniciar(_settings);
DBRepositoryMongo <Chofer> .Iniciar(_settings);
cargarVehicuos();
datos();
}
/// <summary>
/// DEVUELVE EL CHOFER CON EL ID SOLICITADO
/// </summary>
/// <param name="id"></param>
/// <returns>CHOFER</returns>
public async Task<Chofer> getChofer(string id)
{
Chofer usuario = null;
if (id == null)
{
throw new MensajeException("Id de usuario inexistente");
}
else
{
usuario = await DBRepositoryMongo<Chofer>.GetItemAsync(id, "Choferes");
usuario.Desencriptar(usuario);
return usuario;
}
}
/// <summary>
/// DEVUELVE EL ADMINISTRATIVO CON EL SOLICITADO
/// </summary>
/// <param name="id"></param>
/// <returns>ADMINISTRATIVO</returns>
public async Task<Administrativo>getAdministrativo(string id)
{
Administrativo administrativo = null;
if (id == null)
{
throw new MensajeException("Id de usuario inexistente");
}
else
{
administrativo = await DBRepositoryMongo<Administrativo>.GetItemAsync(id, "Administrativos");
administrativo = administrativo.Desencriptar(administrativo);
return administrativo;
}
}
/// <summary>
/// DEVUELVE UNA LISTA DE LOS CLIENTES QUE HAY EN EL SISTEMA
/// </summary>
/// <param name="id"></param>
/// <returns>LISTA DE CLIENTE</returns>
public async Task<Cliente> getCliente(string id)
{
Cliente cliente = null;
if (id == null)
{
throw new MensajeException("Id de usuario inexistente");
}
else
{
cliente = await DBRepositoryMongo<Cliente>.GetItemAsync(id, "Clientes");
cliente = cliente.Desencriptar(cliente);
return cliente;
}
}
public APIController(IOptions <AppSettingsMongo> settings, IHttpContextAccessor httpContextAccessor, IConfiguration configuration)
{
_session = httpContextAccessor.HttpContext.Session;
_configuration = configuration;
_httpContext = httpContextAccessor;
_settings = settings;
DBRepositoryMongo <Usuario> .Iniciar(_settings);
DBRepositoryMongo <Cliente> .Iniciar(_settings);
DBRepositoryMongo <Chofer> .Iniciar(_settings);
_controladoraViajes = ControladoraViajes.getInstancia(_settings);
_controladoraVehiculos = ControladoraVehiculos.getInstance(_settings);
_controladoraUsuarios = ControladoraUsuarios.getInstance(_settings);
}
/// <summary>
/// DEVUELVE EL PEON CON EL ID SOLICITADO
/// </summary>
/// <param name="idPeon"></param>
/// <returns>PEON</returns>
public async Task<Peon> getPeon(string idPeon)
{
try
{
Peon peon = await DBRepositoryMongo<Peon>.GetItemAsync(idPeon, "Peones");
peon = peon.Desencriptar(peon);
return peon;
}
catch (MensajeException msg)
{
throw msg;
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// devuelve el administrativo o el cliente si lo puede validar o si no devuelve null
/// </summary>
/// <param name="administrativo"></param>
/// <param name="pass"></param>
/// <returns>el administrativo o cliente con las credenciales solicitadas</returns>
public async Task<Usuario> Login(string administrativo, string pass)
{
MensajeException mensajeError = new MensajeException("Usuario y/o contraseña incorrecta");
Usuario salida = null;
try
{
Administrativo user = await DBRepositoryMongo<Administrativo>.Login(Seguridad.Encriptar(administrativo), "Administrativos");
if (user == null)
{
Cliente cliente = await DBRepositoryMongo<Cliente>.Login(Seguridad.Encriptar(administrativo), "Clientes");
if (cliente != null)
{
cliente = cliente.Desencriptar(cliente);
if (cliente.Password == pass)
{
salida = cliente;
}
else
{
throw mensajeError;
}
}
else
{
throw new MensajeException("Usuario incorrecto");
}
}
else
{
user = user.Desencriptar(user);
if (user.Password == pass)
{
salida = user;
}
else
{
throw mensajeError;
}
}
return salida;
}catch(MensajeException msg)
{
throw msg;
}
}
/// <summary>
/// se toma en cuenta los vehiculos de la bd. se utiliza para el abm
/// </summary>
/// <param name="idVehiculo"></param>
/// <returns>vehiculo solicitado</returns>
public async Task <Vehiculo> getVehiculoBaseDatos(string idVehiculo)
{
try
{
Vehiculo vehiculo = await DBRepositoryMongo <Vehiculo> .GetItemAsync(idVehiculo, "Vehiculos");
return(vehiculo);
}
catch (MensajeException msg)
{
throw msg;
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// se devuelve el vehiculo que tiene un chofer determinado desde la bd
/// </summary>
/// <param name="idChofer"></param>
/// <returns></returns>
public async Task <Vehiculo> getVehiculoChofer(string idChofer)
{
try
{
var aux = await DBRepositoryMongo <Vehiculo> .GetItemsAsync("Vehiculos");
Vehiculo vehiculo = aux.Where(v => v.Chofer.Id.ToString().Equals(idChofer)).FirstOrDefault();
return(vehiculo);
}
catch (MensajeException msg)
{
throw msg;
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <JsonResult> RegistroChofer([FromBody] Chofer nuevo)
{
Usuario usu = await DBRepositoryMongo <Usuario> .GetUsuario(nuevo.User, "Usuarios");
Usuario cliente = await DBRepositoryMongo <Cliente> .GetUsuario(nuevo.User, "Clientes");
Usuario chofer = await DBRepositoryMongo <Chofer> .GetUsuario(nuevo.User, "Choferes");
if (cliente == null && usu == null && chofer == null)
{
await DBRepositoryMongo <Chofer> .Create(nuevo, "Choferes");
return(Json(nuevo));
}
else
{
return(Json(null));
}
}
/// <summary>
/// crea un usuario administrativo
/// </summary>
/// <param name="usuario"></param>
/// <param name="administrador"></param>
/// <returns>el administrativo creado</returns>
public async Task<Usuario> CrearAdministrativo(Administrativo usuario, bool administrador)
{
try
{
Usuario salida = null;
Usuario u = await DBRepositoryMongo<Usuario>.GetUsuario(Seguridad.Encriptar(usuario.User), "Administrativos");
if (u != null)
{
throw new MensajeException("El usuario ya existe");
}
else
{
if (usuario.Ubicacion == null)
{
usuario.Ubicacion = new PosicionSatelital() { Latitud = "", Longitud = "" };
}
Administrativo nuevo = new Administrativo();
nuevo = usuario;
nuevo.Tipo = "Administrador";
if (administrador)
{
nuevo.Administrador = true;
}
else
{
nuevo.Administrador = false;
}
nuevo = nuevo.Encriptar(nuevo);
await DBRepositoryMongo<Usuario>.Create(nuevo, "Administrativos");
salida = nuevo;
}
return salida;
}
catch (MensajeException msg)
{
throw msg;
}
catch(Exception ex)
{
throw ex;
}
}
public async Task <JsonResult> RegistroCliente([FromBody] Cliente cliente)
{
Cliente cli = await DBRepositoryMongo <Cliente> .GetUsuario(cliente.User, "Clientes");
Chofer chofer = await DBRepositoryMongo <Chofer> .GetUsuario(cliente.User, "Choferes");
Usuario usu = await DBRepositoryMongo <Usuario> .GetUsuario(cliente.User, "Usuarios");
if (cli == null && chofer == null && usu == null)
{
Cliente nuevo = cliente;
await DBRepositoryMongo <Cliente> .Create(nuevo, "Clientes");
return(Json(nuevo));
}
else
{
return(Json(null));
}
}
