path: root/Codemerx/Gestor.Infrastructure/Gestor.Infrastructure.Repository.Logic/TarefaRepository.cs

using AutoMapper;
using Gestor.Common.Validation;
using Gestor.Infrastructure.Entities.Ferramentas;
using Gestor.Infrastructure.Entities.Generic;
using Gestor.Infrastructure.Entities.Seguros;
using Gestor.Infrastructure.Helpers;
using Gestor.Infrastructure.Mappers;
using Gestor.Infrastructure.Repository.Generic;
using Gestor.Infrastructure.Repository.Interface;
using Gestor.Infrastructure.UnitOfWork.Generic;
using Gestor.Model.Common;
using Gestor.Model.Domain.Ferramentas;
using Gestor.Model.Domain.Generic;
using Gestor.Model.Domain.Relatorios.Tarefa;
using Gestor.Model.Domain.Seguros;
using NHibernate;
using NHibernate.Connection;
using NHibernate.Impl;
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Common;
using System.Data.SqlClient;
using System.Linq;
using System.Linq.Expressions;
using System.Runtime.CompilerServices;

namespace Gestor.Infrastructure.Repository.Logic
{
	public class TarefaRepository : GenericRepository<TarefaDb>, ITarefaRepository, IGenericRepository<TarefaDb>
	{
		private readonly GenericUnitOfWork _unitOfWork;

		public TarefaRepository(GenericUnitOfWork unitOfWork) : base(unitOfWork.Session)
		{
			this._unitOfWork = unitOfWork;
		}

		public Gestor.Model.Domain.Ferramentas.Tarefa Atualizar(Gestor.Model.Domain.Ferramentas.Tarefa tarefa)
		{
			List<ResponsavelTarefa> list;
			Gestor.Model.Domain.Ferramentas.Tarefa tarefa1 = tarefa;
			List<ResponsavelTarefa> responsaveis = tarefa1.Responsaveis;
			if (responsaveis != null)
			{
				list = (
					from x in responsaveis
					where x.Usuario.Id != tarefa1.Usuario.Id
					select x).ToList<ResponsavelTarefa>();
			}
			else
			{
				list = null;
			}
			List<ResponsavelTarefa> responsavelTarefas = list;
			TarefaDb tarefaDb = ApplicationMapper.Mapper.Map<Gestor.Model.Domain.Ferramentas.Tarefa, TarefaDb>(tarefa1);
			List<ResponsavelTarefaDb> responsavelTarefaDbs = (
				from x in this._unitOfWork.Query<ResponsavelTarefaDb>()
				where x.IdTarefa == tarefa1.Id
				select x).ToList<ResponsavelTarefaDb>();
			this._unitOfWork.Repository<ResponsavelTarefaDb>().DeleteRange(responsavelTarefaDbs);
			base.Merge(tarefaDb);
			tarefa1 = ApplicationMapper.Mapper.Map<TarefaDb, Gestor.Model.Domain.Ferramentas.Tarefa>(tarefaDb);
			if (responsavelTarefas != null)
			{
				responsavelTarefas.ForEach((ResponsavelTarefa x) => {
					x.Id = (long)0;
					x.IdTarefa = tarefa1.Id;
					x = this.Save(x);
				});
			}
			tarefa1.Responsaveis = responsavelTarefas;
			return tarefa1;
		}

		public Trilha Atualizar(Trilha trilha)
		{
			TrilhaDb trilhaDb = ApplicationMapper.Mapper.Map<Trilha, TrilhaDb>(trilha);
			this._unitOfWork.Repository<TrilhaDb>().Merge(trilhaDb);
			return ApplicationMapper.Mapper.Map<TrilhaDb, Trilha>(trilhaDb);
		}

		public Fase Atualizar(Fase fase)
		{
			FaseDb faseDb = ApplicationMapper.Mapper.Map<Fase, FaseDb>(fase);
			this._unitOfWork.Repository<FaseDb>().Merge(faseDb);
			return ApplicationMapper.Mapper.Map<FaseDb, Fase>(faseDb);
		}

		public List<Fase> BuscarFases(long id)
		{
			List<FaseDb> list = (
				from x in this._unitOfWork.Query<FaseDb>()
				where x.Trilha.Id == id
				select x).ToList<FaseDb>();
			return ApplicationMapper.Mapper.Map<List<FaseDb>, List<Fase>>(list);
		}

		public Gestor.Model.Domain.Ferramentas.Tarefa BuscarTarefa(long id)
		{
			TarefaDb tarefaDb = base.FindEntityById(id);
			List<ResponsavelTarefaDb> list = (
				from x in this._unitOfWork.Query<ResponsavelTarefaDb>()
				where x.IdTarefa == id
				select x).ToList<ResponsavelTarefaDb>();
			Gestor.Model.Domain.Ferramentas.Tarefa tarefa = ApplicationMapper.Mapper.Map<TarefaDb, Gestor.Model.Domain.Ferramentas.Tarefa>(tarefaDb);
			tarefa.Responsaveis = ApplicationMapper.Mapper.Map<List<ResponsavelTarefaDb>, List<ResponsavelTarefa>>(list);
			return tarefa;
		}

		public List<Gestor.Model.Domain.Ferramentas.Tarefa> BuscarTarefa(TipoTarefa entidade, long id, bool? concluido = false)
		{
			string str;
			if (!concluido.HasValue)
			{
				str = "";
			}
			else
			{
				str = (concluido.GetValueOrDefault() ? " AND t.Conclusao IS NOT NULL" : " AND t.Conclusao IS NULL");
			}
			string str1 = str;
			return this.Select(string.Format(" AND t.Entidade = {0} AND t.IdEntidade = {1} {2}", (int)entidade, id, str1));
		}

		public List<Gestor.Model.Domain.Ferramentas.Tarefa> BuscarTarefaConcluidaPorUsuario(long id, TipoTarefa tipo)
		{
			return this.Select(string.Format(" AND t.Entidade = {0} AND t.Conclusao IS NOT NULL AND (t.IdUsuario = {1} OR r.Usuario_id = {2})", (int)tipo, id, id));
		}

		public List<Gestor.Model.Domain.Ferramentas.Tarefa> BuscarTarefaPorCliente(long id)
		{
			return this.Select(string.Format(" AND t.Entidade != 1 AND t.IdCliente = {0}", id));
		}

		public List<Gestor.Model.Domain.Ferramentas.Tarefa> BuscarTarefaPorData(DateTime data, long idUsuario, bool? concluido = false)
		{
			string str;
			if (!concluido.HasValue)
			{
				str = "";
			}
			else
			{
				str = (concluido.GetValueOrDefault() ? "AND t.Conclusao IS NOT NULL" : " AND t.Conclusao IS NULL");
			}
			string str1 = str;
			return this.Select(string.Format(" AND t.Entidade != 1 AND CAST(t.Agendamento AS DATE) == '{0:yyyy-MM-dd}' {1} AND (t.IdUsuario = {2} OR r.Usuario_id = {3})", new object[] { data, str1, idUsuario, idUsuario }));
		}

		public List<Gestor.Model.Domain.Relatorios.Tarefa.Tarefa> BuscarTarefaPorFiltro(DateTime inicio, DateTime fim)
		{
			return (
				from x in this.Select(string.Format(" AND t.Entidade != 1 AND CAST(t.agendamento AS DATE) BETWEEN '{0:yyyy-MM-dd}' AND '{1:yyyy-MM-dd}'", inicio, fim))
				select new Gestor.Model.Domain.Relatorios.Tarefa.Tarefa()
				{
					Id = x.Id,
					IdCliente = x.IdCliente,
					Cliente = x.Cliente,
					Agendamento = x.Agendamento,
					Conclusao = x.Conclusao,
					Referencia = x.Referencia,
					Titulo = x.Titulo,
					Usuario = (x.Usuario != null ? x.Usuario.Nome : ""),
					IdEntidade = x.IdEntidade,
					Entidade = x.Entidade,
					TipoTarefa = (x.TipoDeTarefa != null ? x.TipoDeTarefa.Nome : ""),
					Status = x.Status.GetDescription()
				}).ToList<Gestor.Model.Domain.Relatorios.Tarefa.Tarefa>();
		}

		public List<Gestor.Model.Domain.Ferramentas.Tarefa> BuscarTarefaPorTrilha(long id)
		{
			return this.Select(string.Format(" AND t.IdTrilha = {0}", id));
		}

		public List<Gestor.Model.Domain.Ferramentas.Tarefa> BuscarTarefaPorUsuario(long id, bool? concluido = false)
		{
			string str;
			if (!concluido.HasValue)
			{
				str = "";
			}
			else
			{
				str = (concluido.GetValueOrDefault() ? " AND t.Conclusao IS NOT NULL" : " AND t.Conclusao IS NULL");
			}
			string str1 = str;
			return this.Select(string.Format(" AND {0} AND (t.IdUsuario = {1} OR r.Usuario_id = {2})", str1, id, id));
		}

		public List<Gestor.Model.Domain.Ferramentas.Tarefa> BuscarTarefaPorUsuario(long id, DateTime inicio, DateTime fim, bool? concluido)
		{
			string str;
			fim = fim.AddDays(1);
			if (!concluido.HasValue)
			{
				str = "";
			}
			else
			{
				str = (concluido.GetValueOrDefault() ? " AND t.Conclusao IS NOT NULL" : " AND t.Conclusao IS NULL");
			}
			string str1 = str;
			string str2 = (id == 0 ? "" : string.Format(" AND (t.IdUsuario = {0} OR r.Usuario_id = {1})", id, id));
			return this.Select(string.Format(" AND t.Entidade != 1 AND t.Agendamento >= '{0:yyyy-MM-dd}' AND t.Agendamento <= '{1:yyyy-MM-dd}' {2} {3}", new object[] { inicio, fim, str1, str2 }));
		}

		public List<Gestor.Model.Domain.Ferramentas.Tarefa> BuscarTarefaPorUsuario(long id, TipoTarefa tipo)
		{
			return this.Select(string.Format(" AND t.Entidade = {0} AND t.Conclusao IS NULL AND (t.IdUsuario = {1} OR r.Usuario_id = {2})", (int)tipo, id, id));
		}

		public List<Gestor.Model.Domain.Ferramentas.Tarefa> BuscarTarefasPorTipo(long id)
		{
			return this.Select(string.Format(" AND t.IdTipoTarefa = {0}", id));
		}

		public Trilha BuscarTrilha(long id)
		{
			TrilhaDb trilhaDb = this._unitOfWork.Query<TrilhaDb>().FirstOrDefault<TrilhaDb>((TrilhaDb x) => x.Id == id);
			return ApplicationMapper.Mapper.Map<TrilhaDb, Trilha>(trilhaDb);
		}

		public List<Trilha> BuscarTrilhas(bool ativo = true)
		{
			List<TrilhaDb> list = (
				from x in this._unitOfWork.Query<TrilhaDb>()
				where x.Ativo == ativo
				select x).ToList<TrilhaDb>();
			return ApplicationMapper.Mapper.Map<List<TrilhaDb>, List<Trilha>>(list);
		}

		public List<Trilha> BuscarTrilhas(string titulo, bool ativo = true)
		{
			List<TrilhaDb> list = this._unitOfWork.Query<TrilhaDb>().ToList<TrilhaDb>().Where<TrilhaDb>((TrilhaDb x) => {
				if (x.Ativo != ativo)
				{
					return false;
				}
				return x.Titulo.Normalized() == titulo.Normalized();
			}).ToList<TrilhaDb>();
			return ApplicationMapper.Mapper.Map<List<TrilhaDb>, List<Trilha>>(list);
		}

		public int[] ContarTarefas(long id)
		{
			int[] numArray = new int[] { this.Count(string.Format(" AND t.Entidade = 1 AND t.Conclusao IS NULL AND (t.IdUsuario = {0} OR r.Usuario_id = {1})", id, id)), 0 };
			DateTime date = Funcoes.GetNetworkTime().Date;
			numArray[1] = this.Count(string.Format(" AND t.Entidade != 1 AND t.Conclusao IS NULL AND t.Agendamento < '{0:yyyy-MM-dd}' AND (t.IdUsuario = {1} OR r.Usuario_id = {2})", date.AddDays(1), id, id));
			return numArray;
		}

		private int Count(string condition)
		{
			int num;
			object connection;
			SessionFactoryImpl sessionFactory = this._unitOfWork.Session.SessionFactory as SessionFactoryImpl;
			if (sessionFactory != null)
			{
				connection = sessionFactory.ConnectionProvider.GetConnection();
			}
			else
			{
				connection = null;
			}
			using (SqlConnection sqlConnection = connection as SqlConnection)
			{
				using (SqlCommand sqlCommand = sqlConnection.CreateCommand())
				{
					sqlCommand.CommandText = string.Concat("SELECT  Count(DISTINCT t.Id) as quantidade FROM Tarefa t LEFT OUTER JOIN ResponsavelTarefa r on r.IdTarefa = t.id WHERE 1=1 ", condition);
					SqlDataReader sqlDataReader = sqlCommand.ExecuteReader();
					sqlDataReader.Read();
					num = int.Parse(sqlDataReader["quantidade"].ToString());
				}
			}
			return num;
		}

		public void Excluir(long id)
		{
			TarefaDb tarefaDb = base.FindEntityById(id);
			if (tarefaDb == null)
			{
				return;
			}
			List<ResponsavelTarefaDb> list = (
				from x in this._unitOfWork.Query<ResponsavelTarefaDb>()
				where x.IdTarefa == id
				select x).ToList<ResponsavelTarefaDb>();
			this._unitOfWork.Repository<ResponsavelTarefaDb>().DeleteRange(list);
			(
				from x in this._unitOfWork.Query<ProspeccaoDb>()
				where x.Tarefa.Id == tarefaDb.Id
				select x).ToList<ProspeccaoDb>().ForEach((ProspeccaoDb x) => {
				x.Tarefa = null;
				this._unitOfWork.Repository<ProspeccaoDb>().Merge(x);
			});
			base.Delete(tarefaDb);
		}

		public void ExcluirFase(long id)
		{
			FaseDb faseDb = this._unitOfWork.Query<FaseDb>().FirstOrDefault<FaseDb>((FaseDb x) => x.Id == id);
			if (faseDb == null)
			{
				return;
			}
			this._unitOfWork.Repository<FaseDb>().Delete(faseDb);
		}

		public void ExcluirTrilha(long id)
		{
			TrilhaDb trilhaDb = this._unitOfWork.Query<TrilhaDb>().FirstOrDefault<TrilhaDb>((TrilhaDb x) => x.Id == id);
			if (trilhaDb == null)
			{
				return;
			}
			this._unitOfWork.Repository<TrilhaDb>().Delete(trilhaDb);
		}

		public Gestor.Model.Domain.Ferramentas.Tarefa Salvar(Gestor.Model.Domain.Ferramentas.Tarefa tarefa)
		{
			List<ResponsavelTarefa> list;
			Gestor.Model.Domain.Ferramentas.Tarefa tarefa1 = tarefa;
			List<ResponsavelTarefa> responsaveis = tarefa1.Responsaveis;
			if (responsaveis != null)
			{
				list = (
					from x in responsaveis
					where x.Usuario.Id != tarefa1.Usuario.Id
					select x).ToList<ResponsavelTarefa>();
			}
			else
			{
				list = null;
			}
			List<ResponsavelTarefa> responsavelTarefas = list;
			TarefaDb tarefaDb = ApplicationMapper.Mapper.Map<Gestor.Model.Domain.Ferramentas.Tarefa, TarefaDb>(tarefa1);
			this.SaveOrUpdate(tarefaDb);
			tarefa1 = ApplicationMapper.Mapper.Map<TarefaDb, Gestor.Model.Domain.Ferramentas.Tarefa>(tarefaDb);
			if (responsavelTarefas != null)
			{
				responsavelTarefas.ForEach((ResponsavelTarefa x) => {
					x.IdTarefa = tarefa1.Id;
					x = this.Save(x);
				});
			}
			tarefa1.Responsaveis = responsavelTarefas;
			return tarefa1;
		}

		public List<Gestor.Model.Domain.Ferramentas.Tarefa> Salvar(List<Gestor.Model.Domain.Ferramentas.Tarefa> tarefas)
		{
			tarefas.ForEach((Gestor.Model.Domain.Ferramentas.Tarefa x) => x = this.Salvar(x));
			return tarefas;
		}

		public Trilha Salvar(Trilha trilha)
		{
			TrilhaDb trilhaDb = ApplicationMapper.Mapper.Map<Trilha, TrilhaDb>(trilha);
			this._unitOfWork.Repository<TrilhaDb>().SaveOrUpdate(trilhaDb);
			return ApplicationMapper.Mapper.Map<TrilhaDb, Trilha>(trilhaDb);
		}

		public Fase Salvar(Fase fase)
		{
			FaseDb faseDb = ApplicationMapper.Mapper.Map<Fase, FaseDb>(fase);
			this._unitOfWork.Repository<FaseDb>().SaveOrUpdate(faseDb);
			return ApplicationMapper.Mapper.Map<FaseDb, Fase>(faseDb);
		}

		public List<Fase> Salvar(List<Fase> fases)
		{
			List<FaseDb> faseDbs = new List<FaseDb>();
			List<Fase> list = (
				from x in fases
				where x.Id == (long)0
				select x).ToList<Fase>();
			List<Fase> list1 = fases.Except<Fase>(list).ToList<Fase>();
			if (list.Count > 0)
			{
				faseDbs = ApplicationMapper.Mapper.Map<List<Fase>, List<FaseDb>>(list);
				this._unitOfWork.Repository<FaseDb>().AddRange(faseDbs);
			}
			if (list1 != null)
			{
				list1.ForEach((Fase x) => {
					FaseDb faseDb = ApplicationMapper.Mapper.Map<Fase, FaseDb>(x);
					this._unitOfWork.Repository<FaseDb>().SaveOrUpdate(faseDb);
					faseDbs.Add(faseDb);
				});
			}
			else
			{
			}
			return ApplicationMapper.Mapper.Map<List<FaseDb>, List<Fase>>(faseDbs);
		}

		public ResponsavelTarefa Save(ResponsavelTarefa responsavel)
		{
			ResponsavelTarefaDb responsavelTarefaDb = ApplicationMapper.Mapper.Map<ResponsavelTarefa, ResponsavelTarefaDb>(responsavel);
			this._unitOfWork.Repository<ResponsavelTarefaDb>().SaveOrUpdate(responsavelTarefaDb);
			return ApplicationMapper.Mapper.Map<ResponsavelTarefaDb, ResponsavelTarefa>(responsavelTarefaDb);
		}

		private List<Gestor.Model.Domain.Ferramentas.Tarefa> Select(string condition)
		{
			object connection;
			List<long> nums = null;
			DataTable dataTable = new DataTable();
			DataTable dataTable1 = new DataTable();
			SessionFactoryImpl sessionFactory = this._unitOfWork.Session.SessionFactory as SessionFactoryImpl;
			if (sessionFactory != null)
			{
				connection = sessionFactory.ConnectionProvider.GetConnection();
			}
			else
			{
				connection = null;
			}
			using (SqlConnection sqlConnection = connection as SqlConnection)
			{
				using (SqlCommand sqlCommand = sqlConnection.CreateCommand())
				{
					sqlCommand.CommandTimeout = 15000;
					Auxiliar.LoadTipoTarefa(sqlCommand);
					Auxiliar.CriarAuxiliar(sqlCommand, false);
					sqlCommand.CommandText = string.Concat("SELECT DISTINCT t.* FROM Tarefa t LEFT OUTER JOIN ResponsavelTarefa r on r.IdTarefa = t.id WHERE 1=1 ", condition);
					using (SqlDataAdapter sqlDataAdapter = new SqlDataAdapter())
					{
						sqlDataAdapter.SelectCommand = sqlCommand;
						sqlDataAdapter.Fill(dataTable);
					}
					for (List<long> i = dataTable.AsEnumerable().Select<DataRow, long>((DataRow x) => x.Field<long>("Id")).ToList<long>(); i.Count > 0; i = nums)
					{
						List<long> list = i.Take<long>(2100).ToList<long>();
						string str = string.Concat(" AND IdTarefa IN (", string.Join<long>(",", list), ")");
						DataTable dataTable2 = new DataTable();
						sqlCommand.CommandText = string.Concat("SELECT * FROM ResponsavelTarefa WHERE 1=1 ", str);
						using (SqlDataAdapter sqlDataAdapter1 = new SqlDataAdapter())
						{
							sqlDataAdapter1.SelectCommand = sqlCommand;
							sqlDataAdapter1.Fill(dataTable2);
						}
						dataTable1.Merge(dataTable2);
						nums = (list.Count < 2100 ? new List<long>() : i.Except<long>(list).ToList<long>());
					}
				}
			}
			return CustomMap.MapTarefa(dataTable, dataTable1);
		}

		public List<long> Validar(List<long> ids, long trilha)
		{
			return (
				from x in base.All()
				where ids.Contains(x.IdEntidade) && x.Trilha != null && x.Trilha.Id == trilha
				select x.Id).ToList<long>();
		}
	}
}