public static List<CatalogoExpensas.Pagos> registrarPagosAutomaticos(DateTime periodo, List<Pagos> pagos)
        {
            try
            {
                admEntities db = new admEntities();

                //Si alguien paga por automatico, queda totalmente al dia. Sumar recargos cobrados de meses anteriores o si pago en 2 vto
                List<expensas> expensas = new List<expensas>();
                List<Recargo> gastosExclusivos = new List<Recargo>();
                List<recargos> recargos = new List<recargos>();

                foreach (var p in pagos)
                {
                    var exp = db.expensas.Where(x => x.nro_referencia == p.nroReferencia).OrderByDescending(x => x.fecha).First();
                    var uni = new unidad();
                    uni.dir_edificio = exp.dir_edificio;
                    uni.id_unidad = exp.id_unidad;
                    p.Edificio = uni.dir_edificio;
                    p.Unidad = uni.id_unidad;
                    p.Periodo = exp.fecha.Month + "/" + exp.fecha.Year;

                    var expensasMismaUnidad = db.expensas.Where(x => x.dir_edificio == uni.dir_edificio && x.id_unidad == uni.id_unidad && x.pagado == 0).ToList();
                    var exclusivosMismaUnidad = CatalogoGastosExclusivos.getAllRecargos(uni);

                    expensas.AddRange(expensasMismaUnidad);
                    gastosExclusivos.AddRange(exclusivosMismaUnidad);
                }

                var expGrouped = expensas.GroupBy(x => new { x.dir_edificio, x.id_unidad })
                                        .Select(x => new expensas { dir_edificio = x.Key.dir_edificio, id_unidad = x.Key.id_unidad })
                                        .Cast<expensas>()
                                        .ToList();

                foreach (expensas e in expensas)
                {
                    e.pagado = 1;
                    db.Entry(e).State = System.Data.EntityState.Modified;
                }

                foreach (expensas e in expGrouped)
                {
                    recargos r = new recargos();
                    var uni = new unidad();
                    uni.dir_edificio = e.dir_edificio;
                    uni.id_unidad = e.id_unidad;
                    r.dir_edificio = e.dir_edificio;
                    r.periodo = DateTime.Parse("1/" + DateTime.Now.Month + "/" + DateTime.Now.Year);
                    var detalles = CatalogoDeudores.getDetalleDeudaUnidad(uni);
                    r.importe = detalles.Sum(x => x.Recargo);

                    var rExistente = recargos.Where(x => x.dir_edificio == r.dir_edificio && x.periodo == r.periodo).SingleOrDefault();

                    if (rExistente != null)
                        rExistente.importe += r.importe;
                    else
                        recargos.Add(r);
                }

                db.SaveChanges();

                foreach (var excl in gastosExclusivos)
                {
                    switch (excl.Tipo)
                    {
                        case "Exclusivos":
                            CatalogoGastosExclusivos.pagarRecargoExclusivo(excl.Edificio, excl.Unidad, excl.Concepto, excl.Fecha);
                            break;
                        case "Legales":
                            CatalogoGastosExclusivos.pagarRecargoLegales(excl.Edificio, excl.Unidad, excl.Concepto, excl.Fecha);
                            break;
                        case "Varios":
                            CatalogoGastosExclusivos.pagarRecargoVarios(excl.Edificio, excl.Unidad, excl.Concepto, excl.Fecha);
                            break;
                    }
                }

                CatalogoRecargos.addRecargos(recargos);

                return pagos;

            }
            catch (Exception e)
            {
                Logger.Log.write(e.InnerException == null ? e.Message : e.InnerException.Message);
                var str = "";
                str = e.InnerException?.InnerException?.Message;
                Logger.Log.write("Otro error: " + str);
                throw e;
            }
        }
        public static ExpensasEdificio getExpensasEdificio(edificio edificio, DateTime periodo, DateTime vto1, DateTime vto2, ref int correlativo, admEntities db, List<expensas> allExpensasExistentes)
        {
            try
            {
                ExpensasEdificio expensasEdificio = new ExpensasEdificio();
                {

                    expensasEdificio.Periodo = periodo;
                    expensasEdificio.Edificio = edificio;//db.edificio.Where(x => x.direccion == edificio.direccion).SingleOrDefault();
                    List<unidad> unidades = CatalogoUnidades.getAllUnidades(edificio);
                    // expensasEdificio.Sectores = (from es in db.edificios_sectores join e in db.edificio on es.dir_edificio equals e.direccion join s in db.sector on es.id_sector equals s.idsector where e.direccion == edificio.direccion select s).ToList();
                    expensasEdificio.Conceptos = db.Database.SqlQuery<Conceptos>(@"select  s.descripcion 'Sector', f.numero_factura 'NumeroFactura', p.razon_social 'Proveedor', concat(tg.descripcion, ' ', f.detalle) 'concepto', f.importe from factura f                                                     left join provedor p                            on p.razon_social = f.razon_provedor   join sector s on id_sector = s.idsector      join tipo_gasto tg  on f.id_tipogasto = tg.idtipo_gasto                    where dir_edificio = '" + edificio.direccion + "' and month(f.fecha) = " + periodo.Month + " and year(f.fecha) = " + periodo.Year).ToList();
                    expensasEdificio.TotalUnidad = new List<TotalUnidad>();
                    expensasEdificio.EstadoDeCaja = new EstadoCaja();
                    expensasEdificio.EstadoDeCaja.MovimientosDeCaja = db.Database.SqlQuery<MovimientosCaja>("select * from movimiento_caja mc where dir_edificio = '" + edificio.direccion + @"' and month(periodo)=" + periodo.Month + " and year(periodo)=" + periodo.Year).ToList();

                    List<provedor> proveedores = db.edificio.Where(x => x.direccion == edificio.direccion).SingleOrDefault().provedor.ToList();
                    expensasEdificio.Proveedores = new List<Proveedor>();
                    foreach (var pr in proveedores)
                    {
                        Proveedor prov = new Proveedor();
                        prov.cargo = pr.cargo;
                        prov.nombre = pr.razon_social;
                        prov.telefono = pr.telefono1;
                        expensasEdificio.Proveedores.Add(prov);
                    }

                    DateTime fechaActual = DateTime.Parse(1 + "/" + periodo.Month + "/" + periodo.Year);
                    DateTime fechaAnterior = fechaActual.AddMonths(-1);
                    expensasEdificio.EstadoDeCaja.FechaActual = fechaActual.ToShortDateString();
                    expensasEdificio.EstadoDeCaja.FechaAnterior = fechaAnterior.ToShortDateString();
                    expensasEdificio.Deudores = CatalogoDeudores.getDeudoresFromEdificio(edificio, periodo);
                    int tasaRecargoVto = CatalogoTasas.getTasaVto();
                    expensasEdificio.Tasa2Vto = tasaRecargoVto;

                    Double saldoCajaMesAnterior = CatalogoCajaEdificio.getSaldoCajaMes(edificio, fechaAnterior.AddMonths(1).AddDays(-1));
                    Double saldoCajaMesActual = CatalogoCajaEdificio.getSaldoCajaMes(edificio, fechaActual.AddMonths(1).AddDays(-1));

                    expensasEdificio.EstadoDeCaja.ImporteAnterior = saldoCajaMesAnterior;
                    expensasEdificio.EstadoDeCaja.ImporteActual = saldoCajaMesActual;

                    DateTime asd = DateTime.Parse("1 /" + periodo.Month + "/" + periodo.Year);

                    List<expensas> expensasExistentes = allExpensasExistentes.Where(x => x.dir_edificio == edificio.direccion).ToList();

                    foreach (unidad u in unidades)
                    {
                        unidad tempUni = new unidad();
                        if (u.titular == null)
                        {
                            tempUni.titular = new titular();
                            tempUni.titular.nombre = "<<ninguno>>";
                        }
                        else
                            tempUni.titular = u.titular;

                        TotalUnidad totalUnidad = new TotalUnidad();
                        totalUnidad.Unidad = tempUni;
                        string idUnidad = u.id_unidad;
                        tempUni.id_unidad = idUnidad;

                        totalUnidad.Exclusivos = db.recargo_exclusivo.Where(x => x.dir_edificio == u.dir_edificio && x.id_unidad == u.id_unidad && x.fecha.Month == periodo.Month && x.fecha.Year == periodo.Year && x.pagado != 1).Sum(x => (double?)x.importe) ?? 0; ;
                        totalUnidad.Legales = db.recargo_legal.Where(x => x.dir_edificio == u.dir_edificio && x.id_unidad == u.id_unidad && x.fecha.Month == periodo.Month && x.fecha.Year == periodo.Year && x.pagado != 1).Sum(x => (double?)x.importe) ?? 0; ;
                        totalUnidad.Varios = db.recargo_vario.Where(x => x.dir_edificio == u.dir_edificio && x.id_unidad == u.id_unidad && x.fecha.Month == periodo.Month && x.fecha.Year == periodo.Year && x.pagado != 1).Sum(x => (double?)x.importe) ?? 0; ;

                        totalUnidad.TotalSector = db.Database.SqlQuery<Totales>(@"DROP TEMPORARY TABLE IF EXISTS asd;                        CREATE TEMPORARY TABLE IF NOT EXISTS asd AS (                        select id_sector,porcentaje from unidades_sectores us                        where us.dir_edificio = '" + edificio.direccion + @"' and us.id_unidad = '" + u.id_unidad + @"');                        SELECT descripcion 'sector', sum(importe)'importe', porcentaje 'distribucion', (sum(importe) / 100 * porcentaje) 'corresponde' FROM factura f                        join sector s                        on s.idsector = f.id_sector                        join asd r1                        on r1.id_sector = s.idsector                        where month(f.fecha) = " + periodo.Month + @" and year(f.fecha) = " + periodo.Year + @" and f.dir_edificio = '" + edificio.direccion + @"'                        group by  descripcion                        order by r1.id_sector                        ").ToList();

                        double deuda = 0;
                        double recargo = 0;

                        foreach (CatalogoDeudores.Deudor d in expensasEdificio.Deudores)
                        {
                            if (u.id_unidad == d.Unidad)
                            {
                                deuda += d.Importe;
                                recargo += d.Recargo;
                            }
                        }
                        totalUnidad.Deuda = deuda;
                        totalUnidad.Recargo = recargo;
                        totalUnidad.NroFactura = (correlativo++).ToString();
                        expensasEdificio.TotalUnidad.Add(totalUnidad);

                        double importe1 = 0;
                        double importe2 = 0;
                        double mesEnEmision = 0;
                        foreach (Totales total in totalUnidad.TotalSector) //CatalogoExpensas.getTotales(edificio, unidad, periodo))
                        {
                            mesEnEmision += total.corresponde;
                        }

                        importe1 = mesEnEmision + totalUnidad.Deuda + totalUnidad.Recargo;
                        Double importeSinExclusivos = importe1;

                        importe1 += totalUnidad.Exclusivos;
                        importe1 += totalUnidad.Varios;
                        importe1 += totalUnidad.Legales;

                        importe2 = importe1 * (1 + (Double)tasaRecargoVto / 100);

                        expensas expensa = new expensas();
                        expensa.dir_edificio = edificio.direccion;
                        expensa.fecha = DateTime.Parse("1 /" + periodo.Month + "/" + periodo.Year);
                        expensa.id_unidad = u.id_unidad;
                        expensa.importeVto1 = double.Parse(importe1.ToString("n2"));
                        expensa.importeVto2 = double.Parse(importe2.ToString("n2"));
                        expensa.nro_factura = totalUnidad.NroFactura;
                        expensa.fechaVto1 = vto1;
                        expensa.fechaVto2 = vto2;
                        expensa.importeSinExclusivos = importeSinExclusivos;
                        expensa.nro_referencia = completarCadena(Math.Abs((expensa.dir_edificio.ToLower() + u.id_unidad.Replace("-", "")).GetHashCode()).ToString(), 12, "0");
                        expensa.pagado = 0;
                        expensa.mesEnEmision = mesEnEmision;
                        expensa.importeVto1 = importe1;
                        expensa.importeVto2 = importe2;

                        bool update = false;

                        foreach (expensas exp in expensasExistentes)
                        {

                            if (exp.id_unidad == expensa.id_unidad)
                            {
                                {
                                    exp.importeVto1 = expensa.importeVto1;
                                    exp.importeVto2 = expensa.importeVto2;
                                    exp.nro_factura = expensa.nro_factura;
                                    exp.fechaVto1 = vto1;
                                    exp.fechaVto2 = vto2;
                                    expensa.mesEnEmision = mesEnEmision;
                                    exp.importeSinExclusivos = importeSinExclusivos;
                                    exp.nro_referencia = completarCadena(Math.Abs((expensa.dir_edificio.ToLower() + u.id_unidad.Replace("-", "")).GetHashCode()).ToString(), 12, "0");
                                    db.Entry(exp).State = System.Data.EntityState.Modified;
                                    update = true;
                                    break;
                                }
                            }
                        }

                        if (update == false)
                            db.expensas.Add(expensa);

                        //db.Database.ExecuteSqlCommand("delete from expensas where dir_edificio={0} and fecha = {1} and id_unidad ={2}", expensa.dir_edificio, expensa.fecha, expensa.id_unidad);

                    }
                    db.SaveChanges();
                }

                return expensasEdificio;
            }
            catch (Exception ex)
            {
                Logger.Log.write(ex.InnerException == null ? ex.Message : ex.InnerException.Message);
                throw ex;
            }
        }
        public static List<expensas> registrarPagos(DateTime periodo, List<Pagos> pagos, unidad unidad)
        {
            try
            {
                admEntities db = new admEntities();
                List<expensas> expensas = db.expensas.Where(x => x.fecha.Month == periodo.Month && x.fecha.Year == periodo.Year && x.dir_edificio == unidad.dir_edificio && x.id_unidad == unidad.id_unidad).ToList();
                List<expensas> expensasPagadas = new List<Data.expensas>();
                foreach (Pagos p in pagos)
                {
                    foreach (expensas e in expensas)
                    {
                        if (p.nroReferencia == e.nro_referencia && p.nroFactura == e.nro_factura)
                        {
                            e.pagado = 1;
                            db.Entry(e).State = System.Data.EntityState.Modified;
                            expensasPagadas.Add(e);
                        }

                    }
                }
                db.SaveChanges();
                return expensas;
            }
            catch (Exception e)
            {
                Logger.Log.write(e.InnerException == null ? e.Message : e.InnerException.Message);
                throw e;
            }
        }
 private static estado_caja agregarEstadoCaja(estado_caja ec)
 {
     try {
         admEntities db = new admEntities();
         ec = db.estado_caja.Add(ec);
         db.SaveChanges();
         return ec;
     }
     catch (Exception e)
     {
         Logger.Log.write(e.InnerException == null ? e.Message : e.InnerException.Message);
         throw e;
     }
 }