public HttpResponseMessage Get()
        {
            using (var service = FService.Instance.GetService(typeof(MaterialesModel), ContextService) as MaterialesService)
            {
                var nvc       = HttpUtility.ParseQueryString(Request.RequestUri.Query);
                var articulos = nvc["fkarticulos"];
                var material  = ArticulosService.GetCodigoMaterial(articulos);
                var model     = service.get(material) as MaterialesModel;

                var result = new ResultBusquedas <MaterialesLinModel>()
                {
                    values  = model.Lineas,
                    columns = new[]
                    {
                        new ColumnDefinition()
                        {
                            field = "Codigovariedad", displayName = "Id", visible = true, filter = new  Filter()
                            {
                                condition = ColumnDefinition.STARTS_WITH
                            }
                        },
                        new ColumnDefinition()
                        {
                            field = "Descripcion", displayName = "Descripción", visible = true
                        },
                    }
                };


                var response = Request.CreateResponse(HttpStatusCode.OK);
                response.Content = new StringContent(JsonConvert.SerializeObject(result), Encoding.UTF8, "application/json");
                return(response);
            }
        }
Example #2
0
        public HttpResponseMessage Get()
        {
            var nvc      = HttpUtility.ParseQueryString(Request.RequestUri.Query);
            var articulo = nvc["articulo"];

            using (var service = new ArticulosService(ContextService))
            {
                var articuloModel = service.get(articulo) as ArticulosModel;
                var result        = new ResultBusquedas <ArticulosComponentesModel>()
                {
                    values  = articuloModel.ArticulosComponentes,
                    columns = new[]
                    {
                        new ColumnDefinition()
                        {
                            field = "IdComponente", displayName = "IdComponente", visible = true, filter = new  Filter()
                            {
                                condition = ColumnDefinition.STARTS_WITH
                            }
                        },
                        new ColumnDefinition()
                        {
                            field = "FkArticulo", displayName = "Componente", visible = true
                        },
                        new ColumnDefinition()
                        {
                            field = "DescripcionComponente", displayName = "Descripcion", visible = true
                        },
                        new ColumnDefinition()
                        {
                            field = "Piezas", displayName = "Piezas", visible = true
                        },
                        new ColumnDefinition()
                        {
                            field = "Largo", displayName = "Largo", visible = true
                        },
                        new ColumnDefinition()
                        {
                            field = "Ancho", displayName = "Ancho", visible = true
                        },
                        new ColumnDefinition()
                        {
                            field = "Grueso", displayName = "Grueso", visible = true
                        },
                        new ColumnDefinition()
                        {
                            field = "Merma", displayName = "Merma", visible = true
                        }
                    }
                };

                var response = Request.CreateResponse(HttpStatusCode.OK);
                response.Content = new StringContent(JsonConvert.SerializeObject(result), Encoding.UTF8, "application/json");
                return(response);
            }
        }
Example #3
0
 // GET: api/Supercuentas/5
 public HttpResponseMessage Get(string id)
 {
     using (var service = new ArticulosService(ContextService))
     {
         var list     = service.get(id) as ArticulosComponentesModel;
         var response = Request.CreateResponse(HttpStatusCode.OK);
         response.Content = new StringContent(JsonConvert.SerializeObject(list), Encoding.UTF8,
                                              "application/json");
         return(response);
     }
 }
Example #4
0
        private void VerificarTipoFamilia(Articulos model)
        {
            if (model.id.Length != 11)
            {
                throw new ValidationException("La longitud del código del artículo debe ser de 11");
            }

            var familia    = ArticulosService.GetCodigoFamilia(model.id);
            var familiaobj = _db.Familiasproductos.Single(f => f.empresa == model.empresa && f.id == familia);

            if ((TipoFamilia)(familiaobj.tipofamilia ?? 0) != TipoFamilia.General && (TipoFamilia)(familiaobj.tipofamilia ?? 0) != TipoFamilia.Libre)
            {
                model.tipogestionlotes = (int)Tipogestionlotes.Loteobligatorio;
                model.gestionstock     = true;
            }

            if (familiaobj.validarmaterial ?? false)
            {
                var codmaterial = ArticulosService.GetCodigoMaterial(model.id);
                if (!_db.Materiales.Any(f => f.empresa == model.empresa && f.id == codmaterial))
                {
                    throw new ValidationException("No existe el material del articulo");
                }
            }

            if (familiaobj.validarcaracteristica ?? false)
            {
                var codcaracteristica = ArticulosService.GetCodigoCaracteristica(model.id);
                if (!_db.CaracteristicasLin.Any(f => f.empresa == model.empresa && f.fkcaracteristicas == familia && f.id == codcaracteristica))
                {
                    throw new ValidationException("No existe la caracteristica del articulo");
                }
            }

            if (familiaobj.validargrosor ?? false)
            {
                var codgrosor = ArticulosService.GetCodigoGrosor(model.id);
                if (!_db.Grosores.Any(f => f.empresa == model.empresa && f.id == codgrosor))
                {
                    throw new ValidationException("No existe la grosor del articulo");
                }
            }

            if (familiaobj.validaracabado ?? false)
            {
                var codacabado = ArticulosService.GetCodigoAcabado(model.id);
                if (!_db.Acabados.Any(f => f.empresa == model.empresa && f.id == codacabado))
                {
                    throw new ValidationException("No existe la acabado del articulo");
                }
            }
        }
 // GET: api/Supercuentas/5
 public HttpResponseMessage Get(string id)
 {
     using (var service = FService.Instance.GetService(typeof(MaterialesModel), ContextService))
     {
         var nvc       = HttpUtility.ParseQueryString(Request.RequestUri.Query);
         var articulos = nvc["fkarticulos"];
         var material  = ArticulosService.GetCodigoMaterial(articulos);
         var model     = service.get(material) as MaterialesModel;
         var resultado = model.Lineas.FirstOrDefault(f => f.Codigovariedad == id);
         var response  = Request.CreateResponse(HttpStatusCode.OK);
         response.Content = new StringContent(JsonConvert.SerializeObject(resultado), Encoding.UTF8,
                                              "application/json");
         return(response);
     }
 }
        // GET: api/Supercuentas/5
        public HttpResponseMessage Get(string id)
        {
            using (var service = FService.Instance.GetService(typeof(ArticulosModel), ContextService) as ArticulosService)
            {
                var flujocadena  = HttpUtility.ParseQueryString(Request.RequestUri.Query)["flujo"];
                var fkcuentas    = HttpUtility.ParseQueryString(Request.RequestUri.Query)["fkcuentas"];
                var fkmonedas    = HttpUtility.ParseQueryString(Request.RequestUri.Query)["fkmonedas"];
                var fkregimeniva = HttpUtility.ParseQueryString(Request.RequestUri.Query)["fkregimeniva"];
                var flujo        = string.IsNullOrEmpty(flujocadena)? TipoFlujo.Venta: (TipoFlujo)Enum.Parse(typeof(TipoFlujo), flujocadena);
                var acabadodesde = HttpUtility.ParseQueryString(Request.RequestUri.Query)["FkAcabadoDesde"];
                var acabadohasta = HttpUtility.ParseQueryString(Request.RequestUri.Query)["FkAcabadoHasta"];
                var material     = HttpUtility.ParseQueryString(Request.RequestUri.Query)["Materialsalida"];

                var list = service.GetArticulo(id, fkcuentas, fkmonedas, fkregimeniva, flujo);
                if (!string.IsNullOrEmpty(acabadodesde))
                {
                    if (string.CompareOrdinal(ArticulosService.GetCodigoAcabado(list.Id), acabadodesde) < 0)
                    {
                        throw new Exception("Articulo no encontrado");
                    }
                }

                if (!string.IsNullOrEmpty(acabadohasta))
                {
                    if (string.CompareOrdinal(ArticulosService.GetCodigoAcabado(list.Id), acabadohasta) > 0)
                    {
                        throw new Exception("Articulo no encontrado");
                    }
                }

                if (!string.IsNullOrEmpty(material))
                {
                    if (material != ArticulosService.GetCodigoMaterial(list.Id))
                    {
                        throw new Exception("Articulo no encontrado");
                    }
                }
                var response = Request.CreateResponse(list == null? HttpStatusCode.InternalServerError :HttpStatusCode.OK);
                response.Content = new StringContent(JsonConvert.SerializeObject(list), Encoding.UTF8,
                                                     "application/json");
                return(response);
            }
        }
        private void ValidarLineas(Traspasosalmacen model)
        {
            if (!model.TraspasosalmacenLin.Any() && model.TraspasosalmacenCostesadicionales.Any())
            {
                throw new ValidationException(General.ErrorLineasObligatoriasCostes);
            }

            var familiasProductosService = FService.Instance.GetService(typeof(FamiliasproductosModel), Context, _db);

            foreach (var item in model.TraspasosalmacenLin)
            {
                if (string.IsNullOrEmpty(item.fkarticulos))
                {
                    throw new ValidationException(string.Format(General.ErrorCampoObligatorio, RTraspasosalmacen.Fkarticulos));
                }

                if (!item.cantidad.HasValue)
                {
                    throw new ValidationException(string.Format(General.ErrorCampoObligatorio, RTraspasosalmacen.Cantidad));
                }

                if (!item.metros.HasValue)
                {
                    throw new ValidationException(string.Format(General.ErrorCampoObligatorio, RTraspasosalmacen.Metros));
                }



                var familiacodigo = ArticulosService.GetCodigoFamilia(item.fkarticulos);
                var familiaModel  = familiasProductosService.get(familiacodigo) as FamiliasproductosModel;
                item.fkunidades = _db.Unidades.Single(f => f.id == familiaModel.Fkunidadesmedida).id;

                VerificarPertenenciaKit(model, item);
            }

            var vector = model.TraspasosalmacenLin.OrderBy(f => f.orden).ToList();

            for (var i = 0; i < vector.Count(); i++)
            {
                vector[i].orden = (i + 1) * ApplicationHelper.EspacioOrdenLineas;
            }
        }
Example #8
0
        public ActionResult GetAllArticulos(int page, int start, int limit, string sort, string dir, long _dc, string callback, string condicion = null, string codigo = null)
        {
            var filter = new PagingInfo
            {
                page     = page,
                start    = start,
                limit    = limit,
                sort     = sort,
                dir      = dir,
                _dc      = _dc,
                callback = callback,
                search   = condicion
            };
            var service  = new ArticulosService();
            var jsondata = service.GetAllArticulos(filter, codigo);
            JavaScriptSerializer javaScriptSerializer = new JavaScriptSerializer();
            string callback1 = callback + "(" + javaScriptSerializer.Serialize(jsondata) + ");";

            return(JavaScript(callback1));
        }
        public override IModelView CreateView(string id)
        {
            var obj                    = _db.Set <Articulos>().Single(f => f.id == id && f.empresa == Empresa);
            var result                 = GetModelView(obj) as ArticulosModel;
            var familiasService        = FService.Instance.GetService(typeof(FamiliasproductosModel), Context, _db);
            var materialesService      = FService.Instance.GetService(typeof(MaterialesModel), Context, _db);
            var caracteristicasService = FService.Instance.GetService(typeof(CaracteristicasModel), Context, _db);
            var grosoresService        = FService.Instance.GetService(typeof(GrosoresModel), Context, _db);
            var acabadosService        = FService.Instance.GetService(typeof(AcabadosModel), Context, _db);


            result.Familia = ArticulosService.GetCodigoFamilia(result.Id);
            var familiaObj = familiasService.get(result.Familia) as FamiliasproductosModel;

            result.Validarmateriales      = familiaObj.Validarmaterial;
            result.Validarcaracteristicas = familiaObj.Validarcaracteristica;
            result.Validargrosores        = familiaObj.Validargrosor;
            result.Validaracabados        = familiaObj.Validaracabado;
            result.Fkcontadores           = familiaObj.Fkcontador;
            result.Materiales             = familiaObj.Validarmaterial ? ArticulosService.GetCodigoMaterial(result.Id):string.Empty;
            result.Caracteristicas        = familiaObj.Validarcaracteristica ? ArticulosService.GetCodigoCaracteristica(result.Id): string.Empty;
            result.Grosores         = familiaObj.Validargrosor ? ArticulosService.GetCodigoGrosor(result.Id) :string.Empty;
            result.Acabados         = familiaObj.Validaracabado ? ArticulosService.GetCodigoAcabado(result.Id) : string.Empty;
            result.Lotefraccionable = obj.lotefraccionable;
            result.Codigolibre      = ArticulosService.GetCodigoLibre(result.Id, familiaObj.Validarmaterial, familiaObj.Validarcaracteristica);
            result.Tipoivavariable  = obj.tipoivavariable;
            var materialesObj = familiaObj.Validarmaterial ? materialesService.get(result.Materiales) as MaterialesModel : null;

            result.FamiliaDescripcion = familiaObj.Descripcion;
            result.Tipofamilia        = (int)familiaObj.Tipofamilia;
            result.Fkcontadores       = familiaObj.Fkcontador;

            result.MaterialesDescripcion      = familiaObj.Validarmaterial ? materialesObj.Descripcion : string.Empty;
            result.CaracteristicasDescripcion = familiaObj.Validarcaracteristica ? ((CaracteristicasModel)caracteristicasService.get(result.Familia)).Lineas.Single(f => f.Id == result.Caracteristicas).Descripcion : string.Empty;
            result.GrosoresDescripcion        = familiaObj.Validargrosor ? grosoresService.get(result.Grosores).get("Descripcion").ToString() : string.Empty;
            result.AcabadosDescripcion        = familiaObj.Validaracabado ? acabadosService.get(result.Acabados).get("Descripcion").ToString() :string.Empty;
            result.Fkunidades         = familiaObj.Fkunidadesmedida;
            result.Fkgruposmateriales = obj.fkgruposmateriales;
            //ser tarifas
            result.TarifasSistemaVenta      = GetTarifas(TipoFlujo.Venta, result.Id);
            result.TarifasSistemaCompra     = GetTarifas(TipoFlujo.Compra, result.Id);
            result.TarifasEspecificasVentas = new TarifaEspecificaArticulo()
            {
                Tipo   = TipoFlujo.Venta,
                Lineas = _appService.GetTarifasEspecificas(TipoFlujo.Venta, id, Empresa).ToList()
            };
            result.TarifasEspecificasCompras = new TarifaEspecificaArticulo()
            {
                Tipo   = TipoFlujo.Compra,
                Lineas = _appService.GetTarifasEspecificas(TipoFlujo.Compra, id, Empresa).ToList()
            };

            //articulos documentos
            result.Largo  = obj.largo ?? 0;
            result.Ancho  = obj.ancho ?? 0;
            result.Grueso = obj.grueso ?? 0;

            var unidad = _db.Unidades.Single(f => f.id == familiaObj.Fkunidadesmedida);

            result.Decimalestotales       = unidad.decimalestotales;
            result.Formulas               = (TipoStockFormulas)Enum.Parse(typeof(TipoStockFormulas), unidad.formula.ToString());
            result.Fkunidades             = familiaObj.Fkunidadesmedida;
            result.Permitemodificarmetros = unidad.tipototal == (int)TipoStockTotal.Editado;

            result.Fechaultimaentrada = obj.fechaultimaentrada;
            result.Ultimaentrada      = obj.ultimaentrada;
            result.Fechaultimasalida  = obj.fechaultimasalida;
            result.Ultimasalida       = obj.ultimasalida;


            // Necesario para crear la url para el último albarán de salida/entrada
            result.idAlbaranEntrada   = _db.AlbaranesCompras.Where(f => f.empresa == Empresa && f.referencia == result.Ultimaentrada).Select(f => f.id).SingleOrDefault();
            result.modoAlbaranEntrada = _db.AlbaranesCompras.Where(f => f.empresa == Empresa && f.referencia == result.Ultimaentrada).Select(f => f.modo).SingleOrDefault();

            result.idAlbaranSalida   = _db.Albaranes.Where(f => f.empresa == Empresa && f.referencia == result.Ultimasalida).Select(f => f.id).SingleOrDefault();
            result.modoAlbaranSalida = _db.Albaranes.Where(f => f.empresa == Empresa && f.referencia == result.Ultimasalida).Select(f => f.modo).SingleOrDefault();

            return(result);
        }
        private void ValidarLineas(Pedidos model)
        {
            var familiasProductosService = FService.Instance.GetService(typeof(FamiliasproductosModel), Context, _db) as FamiliasproductosService;

            foreach (var item in model.PedidosLin)
            {
                if (string.IsNullOrEmpty(item.fkarticulos))
                {
                    throw new ValidationException(string.Format(General.ErrorCampoObligatorio, RPedidos.Fkarticulos));
                }

                if (!item.cantidad.HasValue)
                {
                    throw new ValidationException(string.Format(General.ErrorCampoObligatorio, RPedidos.Cantidad));
                }

                if (!item.metros.HasValue)
                {
                    throw new ValidationException(string.Format(General.ErrorCampoObligatorio, RPedidos.Metros));
                }

                if (!item.precio.HasValue)
                {
                    throw new ValidationException(string.Format(General.ErrorCampoObligatorio, RPedidos.Precio));
                }

                if (string.IsNullOrEmpty(item.fktiposiva))
                {
                    throw new ValidationException(string.Format(General.ErrorCampoObligatorio, RPedidos.Fktiposiva));
                }

                if (item.porcentajedescuento.HasValue)
                {
                    item.importedescuento = Math.Round((double)(item.precio * item.metros * item.porcentajedescuento) / 100.0, 2);
                }

                var familiacodigo = ArticulosService.GetCodigoFamilia(item.fkarticulos);
                var familiaModel  = familiasProductosService.get(familiacodigo) as FamiliasproductosModel;
                item.fkunidades = _db.Unidades.Single(f => f.id == familiaModel.Fkunidadesmedida).id;

                var art      = _db.Articulos.Single(f => f.empresa == model.empresa && f.id == item.fkarticulos);
                var codGrupo = art.fkgruposiva;
                if (!art.tipoivavariable)
                {
                    var tiposivaService = FService.Instance.GetService(typeof(TiposIvaModel), Context, _db) as TiposivaService;
                    item.fktiposiva = tiposivaService.GetTipoIva(codGrupo, model.fkregimeniva).Id;
                }


                double cantidad         = item.metros ?? 0;
                double precio           = item.precio ?? 0;
                double importedescuento = item.importedescuento ?? 0;

                var baseimponible = cantidad * precio - importedescuento;

                item.importe = baseimponible;

                if (!item.importe.HasValue)
                {
                    throw new ValidationException(string.Format(General.ErrorCampoObligatorio, RPedidos.Importe));
                }

                familiasProductosService.ValidarDimensiones(familiacodigo, item.largo, item.ancho, item.grueso, art.id);
            }

            var vector = model.PedidosLin.OrderBy(f => f.orden).ToList();

            for (var i = 0; i < vector.Count(); i++)
            {
                vector[i].orden = (i + 1) * ApplicationHelper.EspacioOrdenLineas;
            }
        }
Example #11
0
        public ActionResult GetLotesAutomaticos(string fkarticulo)
        {
            var errormessage = "";

            try
            {
                var listado = Session[sessionentrada] as List <TransformacionesentradaLinModel>;

                return(Content(JsonConvert.SerializeObject(listado.Where(f => f.Nueva && !string.IsNullOrEmpty(f.Loteautomaticoid) && ArticulosService.GetCodigoFamilia(f.Fkarticulos) == ArticulosService.GetCodigoFamilia(fkarticulo) && ArticulosService.GetCodigoMaterial(f.Fkarticulos) == ArticulosService.GetCodigoMaterial(fkarticulo)).GroupBy(f => f.Loteautomaticoid).Select(f => new StContadoresLotes()
                {
                    IdLote = f.Key, Texto = listado.First(j => j.Loteautomaticoid == f.Key).Lote
                }).ToList()), "application/json", Encoding.UTF8));
            }
            catch (Exception ex)
            {
                errormessage        = ex.Message;
                Response.StatusCode = 500;
            }

            return(Content(errormessage));
        }
Example #12
0
        public override IModelView CreateView(string id)
        {
            var identificador = Funciones.Qint(id);
            var obj           = _db.Set <Transformaciones>().Where(f => f.empresa == Empresa && f.id == identificador).Include(f => f.Transformacionesentradalin).Include(f => f.Transformacionessalidalin).Include(f => f.Transformacionescostesadicionales).Single();

            var result = GetModelView(obj) as TransformacionesModel;

            result.Tipodealmacenlote = (TipoAlmacenlote?)obj.tipoalmacenlote;
            var configuracion = _appService.GetConfiguracion(_db);

            result.Materialsalidaigualentrada = configuracion.Materialentradaigualsalida;
            result.Lineasentrada = obj.Transformacionesentradalin.ToList().Select(f => new TransformacionesentradaLinModel()
            {
                Id                     = f.id,
                Fkarticulos            = f.fkarticulos,
                Descripcion            = f.descripcion,
                Lote                   = f.lote,
                Tabla                  = f.tabla,
                Cantidad               = f.cantidad,
                Largo                  = f.largo,
                Ancho                  = f.ancho,
                Grueso                 = f.grueso,
                Fkunidades             = f.fkunidades,
                Metros                 = f.metros,
                Notas                  = f.notas,
                Canal                  = f.canal,
                Revision               = f.revision,
                Decimalesmonedas       = f.decimalesmonedas,
                Decimalesmedidas       = f.decimalesmedidas,
                Orden                  = f.orden ?? f.id,
                Fkcontadoreslotes      = f.fkcontadoreslotes,
                Flagidentifier         = f.flagidentifier,
                Costeadicionalvariable = f.costeacicionalvariable,
                Costeadicionalmaterial = f.costeadicionalmaterial,
                Costeadicionalotro     = f.costeadicionalotro,
                Costeadicionalportes   = f.costeadicionalportes,
                Loteautomaticoid       = f.loteautomaticoid,
                Lotenuevocontador      = f.lotenuevocontador ?? 0,
                Nueva                  = f.nuevo ?? false,
                Precio                 = f.precio
            }).ToList();



            result.Lineassalida = obj.Transformacionessalidalin.ToList().Select(f => new TransformacionessalidaLinModel()
            {
                Id               = f.id,
                Fkarticulos      = f.fkarticulos,
                Descripcion      = f.descripcion,
                Lote             = f.lote,
                Tabla            = f.tabla,
                Cantidad         = f.cantidad,
                Largo            = f.largo,
                Ancho            = f.ancho,
                Grueso           = f.grueso,
                Fkunidades       = f.fkunidades,
                Metros           = f.metros,
                Notas            = f.notas,
                Canal            = f.canal,
                Revision         = f.revision,
                Decimalesmonedas = f.decimalesmonedas,
                Decimalesmedidas = f.decimalesmedidas,
                Orden            = f.orden ?? f.id,
                Flagidentifier   = f.flagidentifier,
                Precio           = f.precio,
            }).ToList();

            var primeritem = result.Lineassalida.FirstOrDefault();

            if (primeritem != null)
            {
                var serviceFamilia = FService.Instance.GetService(typeof(FamiliasproductosModel), Context, _db) as FamiliasproductosService;
                var familia        = serviceFamilia.get(ArticulosService.GetCodigoFamilia(primeritem.Fkarticulos)) as FamiliasproductosModel;
                if (familia.Tipofamilia == TipoFamilia.Bloque)
                {
                    result.Lotesalida = primeritem.Lote;
                }
            }
            result.Costes = obj.Transformacionescostesadicionales.ToList().Select(f => new TransformacionesCostesadicionalesModel()
            {
                Id                  = f.id,
                Tipodocumento       = (TipoCosteAdicional)f.tipodocumento,
                Referenciadocumento = f.referenciadocumento,
                Importe             = f.importe,
                Porcentaje          = f.porcentaje,
                Total               = f.total,
                Tipocoste           = (TipoCoste)f.tipocoste,
                Tiporeparto         = (TipoReparto)f.tiporeparto,
                Notas               = f.notas
            }).ToList();
            return(result);
        }
 public ImportacionService(IContextService context)
 {
     _context          = context;
     _serviceArticulos = FService.Instance.GetService(typeof(ArticulosModel), _context) as ArticulosService;
     _serviceUnidades  = FService.Instance.GetService(typeof(UnidadesModel), _context) as UnidadesService;
 }
        private async Task Synchronize()
        {
            try
            {
                if (CheckNetworkState.hasConnectivity)
                {
                    if (!_synchronizeDataConfig.isFirstTimeSynchronizedReady)
                    {
                        if (!_synchronizeDataConfig.isArticulosReady)
                        {
                            //TABLA ARTICULOS
                            var articulosService = new ArticulosService();
                            Task.Run(async() => await articulosService.SynchronizeArticulos()).GetAwaiter().GetResult();

                            //para debug Articulos
                            var countArticulos = 0;
                            using (SQLite.SQLiteConnection conexion = new SQLiteConnection(App.RutaBD))
                            {
                                //73
                                countArticulos = conexion.Table <_ARTICULOS>().Count();
                            }

                            using (SQLite.SQLiteConnection conexion = new SQLiteConnection(App.RutaBD))
                            {
                                _synchronizeDataConfig.isArticulosReady = true;
                                conexion.Update(_synchronizeDataConfig);
                            }
                        }

                        if (!_synchronizeDataConfig.isAsesoresReady)
                        {
                            //TABLA ASESORES
                            var asesoresService = new ErpAsesoresService();
                            Task.Run(async() => await asesoresService.SynchronizeAsesores()).GetAwaiter().GetResult();

                            //para debug Asesores
                            var countAsesores = 0;
                            using (SQLite.SQLiteConnection conexion = new SQLiteConnection(App.RutaBD))
                            {
                                //116
                                countAsesores = conexion.Table <ERP_ASESORES>().Count();
                            }

                            using (SQLite.SQLiteConnection conexion = new SQLiteConnection(App.RutaBD))
                            {
                                _synchronizeDataConfig.isAsesoresReady = true;
                                conexion.Update(_synchronizeDataConfig);
                            }
                        }


                        if (!_synchronizeDataConfig.isEmpresasReady)
                        {
                            //TABLA EMPRESAS
                            var empresasService = new ErpEmpresasService();
                            Task.Run(async() => await empresasService.SynchronizeEmpresas()).GetAwaiter().GetResult();

                            //para debug Empresas
                            var countEmpresas = 0;
                            using (SQLite.SQLiteConnection conexion = new SQLiteConnection(App.RutaBD))
                            {
                                //3133
                                countEmpresas = conexion.Table <ERP_EMPRESAS>().Count();
                            }

                            using (SQLite.SQLiteConnection conexion = new SQLiteConnection(App.RutaBD))
                            {
                                _synchronizeDataConfig.isEmpresasReady = true;
                                conexion.Update(_synchronizeDataConfig);
                            }
                        }

                        //if (!_synchronizeDataConfig.isLocalidadesReady)
                        //{
                        //    var countLocalidades = 0;
                        //    using (SQLite.SQLiteConnection conexion = new SQLiteConnection(App.RutaBD))
                        //    {
                        //        //21683
                        //        countLocalidades = conexion.Table<ERP_LOCALIDADES>().Count();
                        //    }

                        //    if (countLocalidades < 21683)
                        //    {
                        //        var localidadesService = new ErpLocalidadesService();
                        //        Task.Run(async () => await localidadesService.SynchronizeLocalidades()).GetAwaiter().GetResult();
                        //    }

                        //    using (SQLite.SQLiteConnection conexion = new SQLiteConnection(App.RutaBD))
                        //    {
                        //        _synchronizeDataConfig.isLocalidadesReady = true;
                        //        conexion.Update(_synchronizeDataConfig);
                        //    }
                        //}

                        //if (_synchronizeDataConfig.isArticulosReady &&
                        //	_synchronizeDataConfig.isAsesoresReady &&
                        //	_synchronizeDataConfig.isEmpresasReady &&
                        //	_synchronizeDataConfig.isLocalidadesReady)

                        if (_synchronizeDataConfig.isArticulosReady &&
                            _synchronizeDataConfig.isAsesoresReady &&
                            _synchronizeDataConfig.isEmpresasReady)
                        {
                            using (SQLite.SQLiteConnection conexion = new SQLiteConnection(App.RutaBD))
                            {
                                //_synchronizeDataConfig.isSynchronized = true;
                                //_synchronizeDataConfig.lastSynchronized = DateTime.Today;
                                _synchronizeDataConfig.isFirstTimeSynchronizedReady = true;
                                conexion.Update(_synchronizeDataConfig);
                            }
                        }
                    }
                    //valido equipo con IMEI. Por politicas no se usa por el momento, gestionarlas
                    //Task.Run(async () => await ValidarEquipo()).GetAwaiter().GetResult();
                    //Se valida por nombre de usuario y sin pass por el tema de arriba, descomentar y se usa la anterior
                    ValidarEquipo(true);
                }
                else
                {
                    if (_synchronizeDataConfig.isFirstTimeSynchronizedReady)
                    {
                        ValidarEquipo(true);
                    }
                    else
                    {
                        aiLogin.IsVisible = false;
                        aiLogin.IsRunning = false;
                        aiLogin.IsEnabled = false;

                        lblMensaje.Text = "";

                        await DisplayAlert("Aviso", "No se ha podido sincronizar por 1era vez. Sin conexión a internet.\nCierre la aplicación y vuelva a abrirla cuando tenga acceso a internet.", "Ok");

                        isSynchronizing = false;
                    }
                }
            }
            catch (Exception ex)
            {
                Device.BeginInvokeOnMainThread(async() => {
                    await DisplayAlert("Aviso", "Se ha perdido la conexión a datos. Asegurese de contar con buena señal para realizar el proceso de sincronización.\nCierre la aplicación y vuelva a intentar cuando tenga acceso a internet.", "Ok");

                    aiLogin.IsVisible = false;
                    aiLogin.IsRunning = false;
                    aiLogin.IsEnabled = false;

                    lblMensaje.Text = "";

                    isSynchronizing = false;
                });
            }
        }