// ------------------------------------------------------------------------------------
// <copyright file="TiposDocumentoDAL.cs" company="Universidad Distrital">
// Copyright (c) Universidad Distrital. All rights reserved.
// </copyright>
// <author>Camilo Prieto</author>
// ------------------------------------------------------------------------------------
namespace Biblioteca.Datos.Clases.DAL.Repositorio
{
	using System;
	using System.Collections.Generic;
	using System.Linq;
	using System.Linq.Expressions;
	using System.Threading.Tasks;
	using Biblioteca.Datos.Contexto;
	using Biblioteca.Datos.Contexto.Repositorio;
	using Biblioteca.IC.Acciones.Repositorio;
	using Biblioteca.IC.DTO.Repositorio;
	using TransaccionalNet.EF.Clases;
	using UtilitariosNet.Clases.Comunes.Entidades;
	using UtilitariosNet.Clases.Mapeador.Extensiones;

	/// <summary>
	/// Clase con las acciones de repositorio para la entidad TiposDocumento
	/// </summary>
	public class TiposDocumentoDAL : AccesoComunDAL<ContextoBiblioteca>, ITiposDocumentoRepositorioAccion
	{
		/// <summary>
		/// Objeto para entidad respuesta
		/// </summary>
		Respuesta<ITiposDocumentoDTO> respuesta;

		/// <summary>
		/// Objeto para repositorio TiposDocumento
		/// </summary>
		RepositorioGenerico<TiposDocumento> repositorio;

		/// <summary>
		/// Inicializa una nueva instancia de la clase TiposDocumentoDAL
		/// </summary>
		public TiposDocumentoDAL()
		{
			this.respuesta = new Respuesta<ITiposDocumentoDTO>();
			this.repositorio = new RepositorioGenerico<TiposDocumento>(ContextoBD);
		}

		/// <summary>
		/// Metodo editar tiposDocumento
		/// </summary>
		/// <param name="tiposDocumento">Entidad a editar</param>
		/// <returns>Respuesta tipo TiposDocumento </returns>
		public async Task<Respuesta<ITiposDocumentoDTO>> EditarTiposDocumentoAsync(ITiposDocumentoDTO tiposDocumento)
		{
			return await this.EjecutarTransaccionAsync<Respuesta<ITiposDocumentoDTO>, TiposDocumentoDAL>(async () =>
			{
				TiposDocumento TiposDocumentoEntidad = repositorio.BuscarPor(entidad => entidad
					.IdTipoDocumento == tiposDocumento.IdTipoDocumento).FirstOrDefault();
				Mapeador.MapearObjetosPorPropiedad(tiposDocumento, TiposDocumentoEntidad);
				repositorio.Editar(TiposDocumentoEntidad);
				repositorio.Guardar();
				return respuesta;
			});
		}

		/// <summary>
		/// Metodo editar  tiposDocumento por filtro 
		/// </summary>
		/// <param name="tiposDocumento">Entidad con los datos a editar</param>
		/// <param name="propiedades">Propiedades a modificar</param>
		/// <returns>Respuesta tipo TiposDocumento </returns>
		public async Task<Respuesta<ITiposDocumentoDTO>> EditarTiposDocumentoPorFiltroAsync(ITiposDocumentoDTO tiposDocumento, params string[] propiedades)
        {
            return await this.EjecutarTransaccionAsync<Respuesta<ITiposDocumentoDTO>, TiposDocumentoDAL>(async () =>
            {
                TiposDocumento tiposDocumentoEntidad = repositorio.BuscarPor(entidad => entidad
                .IdTipoDocumento == tiposDocumento.IdTipoDocumento).FirstOrDefault();
                Mapeador.MapearObjetosPorPropiedadPorFiltro(tiposDocumento, tiposDocumentoEntidad, propiedades);
                repositorio.Editar(tiposDocumentoEntidad);
                      repositorio.Guardar();
                return respuesta;
            });
        }


		/// <summary>
		/// Metodo editar tiposDocumento por query 
		/// </summary>
		/// <param name="filtro">Filtro de las entidades </param>
		/// <param name="valor">Entidad a mofificar</param>
		/// <param name="propiedades">Propiedades a modificar</param>
		/// <returns>Respuesta tipo TiposDocumento </returns>
		public async Task<Respuesta<ITiposDocumentoDTO>> EditarPorQueryTiposDocumentoAsync(Expression<Func<ITiposDocumentoDTO, bool>> filtro, ITiposDocumentoDTO valor, List<string> propiedades)
        {
            return await this.EjecutarTransaccionAsync<Respuesta<ITiposDocumentoDTO>, TiposDocumentoDAL>(async () =>
            {
          TiposDocumento TiposDocumentoEntidad = Mapeador.MapearEntidadDTO(valor, new TiposDocumento());
                Expression<Func<TiposDocumento, bool>> filtros = Mapeador.MapearExpresion<ITiposDocumentoDTO, TiposDocumento>(filtro);
                await repositorio.EditarPorQueryAsync(filtros, TiposDocumentoEntidad, propiedades);
                await repositorio.GuardarAsync();
                return respuesta;
            });
        }


		/// <summary>
		/// Metodo editar tiposDocumento lista 
		/// </summary>
		/// <param name="lista"> Lista con entidades a modificar</param>
		/// <returns>Respuesta tipo TiposDocumento </returns>
		public async Task<Respuesta<ITiposDocumentoDTO>> EditarListaTiposDocumentoAsync(List<ITiposDocumentoDTO> lista)
        {
            return await this.EjecutarTransaccionAsync<Respuesta<ITiposDocumentoDTO>, TiposDocumentoDAL>(async () =>
            {
                List<TiposDocumento> listaTiposDocumento = new List<TiposDocumento>();
                listaTiposDocumento = Mapeador.MapearALista<ITiposDocumentoDTO, TiposDocumento>(lista);
               await repositorio.EditarListaAsync(listaTiposDocumento);
               await repositorio.GuardarAsync();
                return respuesta;
            });
        }

		/// <summary>
		/// Metodo eliminar tiposDocumento
		/// </summary>
		/// <param name="tiposDocumento">Entidad a eliminar</param>
		/// <returns>Respuesta tipo TiposDocumento </returns>
        public async Task<Respuesta<ITiposDocumentoDTO>> EliminarTiposDocumentoAsync(ITiposDocumentoDTO tiposDocumento)
        {
            return await this.EjecutarTransaccionAsync<Respuesta<ITiposDocumentoDTO>, TiposDocumentoDAL>(async () =>
            {
				TiposDocumento TiposDocumentoEntidad = repositorio.BuscarPor(entidad => entidad
					.IdTipoDocumento == tiposDocumento.IdTipoDocumento).FirstOrDefault();
				Mapeador.MapearObjetosPorPropiedad(tiposDocumento, TiposDocumentoEntidad);
				repositorio.Eliminar(TiposDocumentoEntidad);
                repositorio.Guardar();
                return respuesta;
            });
        }


		/// <summary>
		/// Metodo eliminar lista tiposDocumento 
		/// </summary>
		/// <param name="lista">Lista de entidad a eliminar</param>
		/// <returns>Respuesta tipo TiposDocumento </returns>
        public async Task<Respuesta<ITiposDocumentoDTO>> EliminarListaTiposDocumentoAsync(List<ITiposDocumentoDTO> lista)
        {
            return await this.EjecutarTransaccionAsync<Respuesta<ITiposDocumentoDTO>, TiposDocumentoDAL>(async () =>
            {
                List<TiposDocumento> listaTiposDocumento = new List<TiposDocumento>();
                listaTiposDocumento = Mapeador.MapearALista<ITiposDocumentoDTO, TiposDocumento>(lista);
               await repositorio.EliminarListaAsync(listaTiposDocumento);
               await repositorio.GuardarAsync();
                return respuesta;
            });
        }

		/// <summary>
		/// Metodo guardar tiposDocumento
		/// </summary>
		/// <param name="tiposDocumento">Entidad a guardar</param>
		/// <returns>Respuesta tipo TiposDocumento </returns>
        public async Task<Respuesta<ITiposDocumentoDTO>> GuardarTiposDocumentoAsync(ITiposDocumentoDTO tiposDocumento)
        {
            return await this.EjecutarTransaccionAsync<Respuesta<ITiposDocumentoDTO>, TiposDocumentoDAL>(async () =>
            {
                TiposDocumento TiposDocumentoEntidad = Mapeador.MapearEntidadDTO(tiposDocumento, new TiposDocumento());
               await repositorio.AgregarAsync(TiposDocumentoEntidad);
               await repositorio.GuardarAsync();
                respuesta.Entidades.Add(TiposDocumentoEntidad);
                return respuesta;

            });
        }

		/// <summary>
		/// Metodo Guardar lista tiposDocumento
		/// </summary>
		/// <param name="listaTiposDocumento">Lista de entidades a guardar</param>
		/// <returns>Respuesta tipo TiposDocumento </returns>
        public async Task<Respuesta<ITiposDocumentoDTO>> GuardarListaTiposDocumentoAsync(List<ITiposDocumentoDTO> listaTiposDocumento)
        {
            return await this.EjecutarTransaccionAsync<Respuesta<ITiposDocumentoDTO>, TiposDocumentoDAL>(async () =>
            {
                List<TiposDocumento> listaTiposDocumentoEntidad = Mapeador.MapearALista<ITiposDocumentoDTO, TiposDocumento>(listaTiposDocumento);
               await repositorio.AgregarListaAsync(listaTiposDocumentoEntidad);
                respuesta.Entidades.AddRange(listaTiposDocumentoEntidad);
                return respuesta;
            });
        }

		/// <summary>
		/// Metodo consultar lista tiposDocumento
		/// </summary>
		/// <returns>Respuesta tipo TiposDocumento </returns>
        public async Task<Respuesta<ITiposDocumentoDTO>> ConsultarListaTiposDocumentoAsync()
        {
            return await this.EjecutarTransaccionAsync<Respuesta<ITiposDocumentoDTO>, TiposDocumentoDAL>(async () =>
            {
                respuesta.Entidades = repositorio.BuscarTodos().ToList<ITiposDocumentoDTO>();
                return respuesta;

            });
        }

		/// <summary>
		/// Metodo consultar lista tiposDocumento por filtro 
		/// </summary>
		/// <param name="tiposDocumento">Entidad con los datos a filtrar</param>
		/// <param name="filtro">Filtro de las entidades </param>
		/// <returns>Respuesta tipo TiposDocumento </returns>
        public async Task<Respuesta<ITiposDocumentoDTO>> ConsultarListaTiposDocumentoPorFiltroAsync(Expression<Func<ITiposDocumentoDTO, bool>> filtro)
        {
            return await this.EjecutarTransaccionAsync<Respuesta<ITiposDocumentoDTO>, TiposDocumentoDAL>(async () =>
            {
                respuesta.Entidades = repositorio.BuscarPor(Mapeador.MapearExpresion<ITiposDocumentoDTO, TiposDocumento>(filtro)).ToList<ITiposDocumentoDTO>();
                return respuesta;

            });
        }

		/// <summary>
		/// Metodo consultar por llave tiposDocumento
		/// </summary>
		/// <param name="tiposDocumento">Entidad a consultar</param>
		/// <returns>Respuesta tipo TiposDocumento </returns>
        public async Task<Respuesta<ITiposDocumentoDTO>> ConsultarTiposDocumentoLlaveAsync(ITiposDocumentoDTO tiposDocumento)
        {
            return await this.EjecutarTransaccionAsync<Respuesta<ITiposDocumentoDTO>, TiposDocumentoDAL>(async () =>
            {
                respuesta.Entidades = (from entidad in ContextoBD.TiposDocumento
                                       where entidad.IdTipoDocumento == tiposDocumento.IdTipoDocumento
                                       select entidad).ToList<ITiposDocumentoDTO>();

                return respuesta;

            });
        }
    }
}

