/// <summary>
/// Constructor
/// </summary>
/// <param name="context"></param>
/// <param name="logger"></param>
/// <param name="localizer"></param>
public BaseController(CaducaContext context, ILogger <BaseController> logger, LocService localizer)
{
this._context = context;
this._localizer = localizer;
this.logger = logger;
permiso = new PermisoDTO();
}
public static void Inicializa()
{
//Creamos un servidor de pruebas utilizando un ambiente
//de testing
var builder = new WebHostBuilder()
.UseEnvironment("IntegrationTesting")
.ConfigureAppConfiguration((c, config) =>
{
config.SetBasePath(Path.Combine(
Directory.GetCurrentDirectory(),
"..", "..", "..", "..", "CaducaRest"));
config.AddJsonFile("appsettings.json");
})
.UseStartup <Startup>();
//Esto nos crea un servidor con los servicios rest
var servidorPruebas = new TestServer(builder);
//Obtenemos el objeto caducaContext
caducaContext = servidorPruebas.Host.Services.GetService(typeof(CaducaContext)) as CaducaContext;
//Inicializamos la bd con datos de prueba
InicializaDatos.Inicializar(caducaContext);
//var total =caducaContext.Usuario.Count();
httpCliente = servidorPruebas.CreateClient();
}
/// <summary>
/// Constructor para verificar que la clave no se repite
/// en una categoría al agregar
/// </summary>
/// <param name="id">Id</param>
/// <param name="clave">Clave de la categoría</param>
/// <param name="context">Objeto para la bd</param>
/// <param name="locService">Objeto para traducuir a varuis idiomas</param>
public ReglaClaveUnico(int id, int clave, CaducaContext context, LocService locService)
{
this.clave = clave;
this.contexto = context;
this.localizacion = locService;
this.id = id;
}
/// <summary>
/// Valida que una cateogría no se llame igual al agregar
/// </summary>
/// <param name="id">Id</param>
/// <param name="nombre">Nombre de la categoría</param>
/// <param name="context">Objeto para la bd</param>
/// <param name="locService">Objeto para mensajes en varios
/// idiomas</param>
public ReglaNombreUnico(int id, string nombre, CaducaContext context, LocService locService)
{
this.nombre = nombre;
this.contexto = context;
this.localizacion = locService;
this.id = id;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="context"></param>
/// <param name="logger"></param>
/// <param name="localize"></param>
public ProductosController(CaducaContext context, ILogger <UsuariosController> logger, LocService localize)
: base(context, logger, localize)
{
_context = context;
productoDAO = new ProductoDAO(context, localize);
this.permiso.Tabla = "Producto";
this.permiso.RequiereAdministrador = false;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="context"></param>
/// <param name="localize"></param>
/// <param name="path"></param>
/// z
/// <param name="configuration"></param>
public UsuarioDAO(CaducaContext context, LocService localize, string path, IConfiguration configuration)
{
this.contexto = context;
this.localizacion = localize;
this.tokenDTO = new TokenDTO();
this._path = path;
this.Configuration = configuration;
usuarioDAO = new AccesoDAO <Usuario>(context, localize);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="context">Base de datos</param>
/// <param name="logger"></param>
/// <param name="localize">Idiomas</param>
/// <param name="config">Archivo de configuración</param>
/// <param name="hostingEnvironment">Environment</param>
/// <param name="accessor"></param>
public UsuariosController(CaducaContext context,
ILogger <UsuariosController> logger,
LocService localize,
IConfiguration config,
IWebHostEnvironment hostingEnvironment,
IHttpContextAccessor accessor) : base(context, logger, localize)
{
_config = config;
_accessor = accessor;
_hostingEnvironment = hostingEnvironment;
usuarioDAO = new UsuarioDAO(context, localize, _hostingEnvironment.ContentRootPath, config);
}
/// <summary>
/// Add caducidad with hotchocolate
/// </summary>
/// <param name="caducaContext">Caduca Context</param>
/// <param name="locService">Servicio para localization</param>
/// <param name="caducidad">Objeto caducidad a agregar</param>
/// <returns></returns>
public async Task <Caducidad> AddCaducidad([Service] CaducaContext caducaContext, [Service] LocService locService, Caducidad caducidad)
{
CaducidadDAO caducidadDAO = new CaducidadDAO(caducaContext, locService);
var correcto = await caducidadDAO.AgregarAsync(caducidad);
if (correcto)
{
return(caducidad);
}
else
{
return(new Caducidad());
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="context">Contexto para la base de datos</param>
/// <param name="logger"></param>
/// <param name="localizer">Mensajes de error en varios idiomas</param>
/// <param name="authorizationService"></param>
public CategoriasController(CaducaContext context,
ILogger <CategoriasController> logger,
LocService localizer,
IAuthorizationService authorizationService)
: base(context, logger, localizer)
{
_authorizationService = authorizationService;
categoriaDAO = new CategoriaDAO(context, localizer);
this.permiso = new PermisoDTO
{
Tabla = "Categoria",
RequiereAdministrador = false
};
}
/// <summary>
/// Delete caducidsad
/// </summary>
/// <param name="caducaContext">Caduca Contexto</param>
/// <param name="locService">Servicio para localization</param>
/// <param name="id">Id a borrar</param>
/// <returns></returns>
public async Task <string> DeleteCaducidad([Service] CaducaContext caducaContext, [Service] LocService locService, int id)
{
CaducidadDAO caducidadDAO = new CaducidadDAO(caducaContext, locService);
var correcto = await caducidadDAO.BorraAsync(id);
if (correcto)
{
return($"La caducidad con el id: {id} fue borrada correctamente");
}
else
{
return(caducidadDAO.customError.Message);
}
}
public async Task AgregaNuevaCategoria_DatosCorrectos_RegresaVerdaderoAsync()
{
//Inicialización de datos (Arrange)
Servicios.Inicializa();
contexto = Servicios.caducaContext;
var categoriaDAO = new CategoriaDAO(contexto, locService);
var categoria = new Categoria();
categoria.Clave = 2;
categoria.Nombre = "Antibióticos";
//Método a probar (Act)
var esCorrecto = await categoriaDAO.AgregarAsync(categoria);
//Comprobación de resultados (Assert)
Assert.IsTrue(esCorrecto);
}
public CaducaContext ObtenerContexto()
{
//Indicamos que utilizará base de datos en memoria
//y que no deseamos que marque error si realizamos
//transacciones en el código de nuestra aplicación
var options = new DbContextOptionsBuilder <CaducaContext>()
.ConfigureWarnings(x => x.Ignore(InMemoryEventId.TransactionIgnoredWarning))
.UseInMemoryDatabase(databaseName: "TestCaduca").Options;
//Inicializamos la configuración de la base de datos
var context = new CaducaContext(options);
//Mandamos llamar la función para inicializar los
//datos de prueba
InicializaDatos.Inicializar(context);
return(context);
}
/// <summary>
/// Update caducidad
/// </summary>
/// <param name="caducaContext">Caduca Contexto</param>
/// <param name="locService">Servicio para localization</param>
/// <param name="caducidad">Datos de caducidad a modificar</param>
/// <param name="id">Id a actualizar</param>
/// <returns></returns>
public async Task <Caducidad> UpdateCaducidad([Service] CaducaContext caducaContext,
[Service] LocService locService,
Caducidad caducidad,
int id)
{
if (id != caducidad.Id)
{
return(null);
}
CaducidadDAO caducidadDAO = new CaducidadDAO(caducaContext, locService);
var correcto = await caducidadDAO.ModificarAsync(caducidad);
if (correcto)
{
return(caducidad);
}
else
{
return(null);
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="context"></param>
/// <param name="locService"></param>
public HistorialDAO(CaducaContext context, LocService locService)
{
this.contexto = context;
this.localizacion = locService;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="context">Contexto de la bd</param>
/// <param name="localizer">Idiomas</param>
public PermisoEditHandler(CaducaContext context, LocService localizer)
{
contexto = context;
_localizer = localizer;
}
/// <summary>
/// Constructro de la clase
/// </summary>
/// <param name="contexto"></param>
public static void Inicializar(CaducaContext contexto)
{
//Si no es base de datos en memoria no se agrega nada
if (contexto.Database.ProviderName != "Microsoft.EntityFrameworkCore.InMemory" &&
contexto.Database.ProviderName != "Microsoft.EntityFrameworkCore.Sqlite")
{
return;
}
//Te aseguras que la base de datos haya sido creada
contexto.Database.EnsureCreated();
var categorias = new Categoria[]
{
/*01*/ new Categoria {
Clave = 1, Nombre = "Análgesicos"
},
};
foreach (Categoria registro in categorias)
{
contexto.Categoria.Add(registro);
}
var productos = new Producto[]
{
/*01*/ new Producto {
Clave = 1, Nombre = "Producto 1"
},
};
foreach (Producto registro in productos)
{
contexto.Producto.Add(registro);
}
var clientes = new Cliente[]
{
/*01*/ new Cliente {
Clave = 1, NombreComercial = "Cliente 1", Activo = true, RazonSocial = "Cliente 1", Direccion = "Calle #1"
},
};
foreach (Cliente registro in clientes)
{
contexto.Cliente.Add(registro);
}
contexto.SaveChanges();
var caducidades = new Caducidad[]
{
/*01*/ new Caducidad {
ClienteId = 1, ProductoId = 1, Cantidad = 5, Fecha = DateTime.Now
},
};
foreach (Caducidad registro in caducidades)
{
contexto.Caducidad.Add(registro);
}
contexto.SaveChanges();
}
/// <summary>
/// Constructor del filtro
/// </summary>
/// <param name="context">Objeto para la bd</param>
/// <param name="localizer">Objeto para mensajes de error</param>
public HistorialFilter(CaducaContext context, LocService localizer)
{
this._localizer = localizer;
this._context = context;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="context"></param>
/// <param name="localizer"></param>
public ClientesCategoriasController(CaducaContext context, LocService localizer)
{
_context = context;
_localizer = localizer;
}
/// <summary>
/// Clase para acceso a la base de datos
/// </summary>
/// <param name="context">Objeto para base de datos</param>
/// <param name="locService">Localización</param>
public ClienteDAO(CaducaContext context, LocService locService)
{
this.contexto = context;
this.localizacion = locService;
clienteDAO = new AccesoDAO <Cliente>(context, locService);
}
/// <summary>
/// Clase para acceso a la base de datos
/// </summary>
/// <param name="context">Objeto para base de datos</param>
/// <param name="locService">Localización</param>
public CategoriaDAO(CaducaContext context, LocService locService)
{
this.contexto = context;
this.localizacion = locService;
categoriaDAO = new AccesoDAO <Categoria>(context, locService);
}
public IQueryable <ClienteCategoria> GetClienteCategoria([Service] CaducaContext contexto) => contexto.ClienteCategoria;
public IQueryable <Cliente> GetCliente([Service] CaducaContext contexto) => contexto.Cliente;
public IQueryable <Caducidad> GetCaducidad([Service] CaducaContext caducaContext, [Service] LocService locService)
{
CaducidadDAO caducidadDAO = new CaducidadDAO(caducaContext, locService);
return((IQueryable <Caducidad>)caducidadDAO.ObtenerIQueryable());
}
/// <summary>
/// Clase para acceso a la base de datos
/// </summary>
/// <param name="context"></param>
/// <param name="locService"></param>
public ProductoDAO(CaducaContext context, LocService locService)
{
this.contexto = context;
this.localizacion = locService;
}
public Categorias()
{
contexto = new CaducaContextMemoria().ObtenerContexto();
locService = new MockLocService().ObtenerLocService();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="context"></param>
/// <param name="locService"></param>
public UsuarioAccesoDAO(CaducaContext context, LocService locService)
{
this.contexto = context;
this.localizacion = locService;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="context"></param>
/// <param name="localize"></param>
public RolDAO(CaducaContext context, LocService localize)
{
this.contexto = context;
this.localizacion = localize;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="context"></param>
/// <param name="localizer"></param>
public ClientesController(CaducaContext context, LocService localizer)
{
_context = context;
_localizer = localizer;
clienteDAO = new ClienteDAO(_context, _localizer);
}
/// <summary>
/// Constructor de la clase
/// </summary>
/// <param name="context"></param>
/// <param name="localizer">Mensajes de error en diferentes idiomas</param>
public PermisoFilter(CaducaContext context, LocService localizer)
{
this._localizer = localizer;
this._context = context;
}
