コード例 #1
0
        public JsonResult GetProvidersDisponibles(BusquedaRequestDTO request)
        {
            var providerDisponible = new ProviderDisponible();
            var providers          = providerDisponible.GetProvidersDisponibles(request);

            return(Json(providers));
        }
コード例 #2
0
        protected List <BusquedaResponseItemDTO> ProcessUrl(BusquedaRequestDTO request, ref int?currentPage, ref int?pagesCount)
        {
            var retorno = new List <BusquedaResponseItemDTO>();

            try
            {
                //Armamos la url
                var url = this.ProviderUrlComposer.GetUrlParsed(request, currentPage);

                //Obtenemos el html con el resultado de la búsqueda
                var htmlDocument = this.ProviderContentResolver.GetContentHtml(url);

                //Mapeamos la respuesta al formato estándar
                retorno = this.MapResponse(htmlDocument);

                //Determinamos paginación
                //currentPage = this.ProviderPaginator.GetCurrentPage(htmlDocument);
                pagesCount = this.ProviderPaginator.GetPagesCount(htmlDocument);
            }
            catch (Exception ex)
            {
                //AppLog.LogMessage("providerbase_processurl_exception", BusquedaVehiculos.Infra.Serialization.Serializer.Serialize(ex));
                //AppLog.LogMessage("providerbase_processurl_exception", ex.ToMessageAndCompleteStackTrace());
            }
            return(retorno);
        }
コード例 #3
0
        public void BuscarVehiculos(BusquedaRequestDTO request)
        {
            try
            {
                int?currentPage = null;
                int?pagesCount  = null;

                //Procesamos el request
                while ((!currentPage.HasValue && !pagesCount.HasValue) || (currentPage.Value < pagesCount.Value))
                {
                    //Procesamos la solicitud paginada
                    var result  = this.ProcessUrl(request, ref currentPage, ref pagesCount);
                    var retorno = new BusquedaResponseDTO();
                    retorno.CodProvider = this.CodProvider;
                    retorno.Items       = result;

                    //Notificamos el resultado
                    this.BusquedaLongRunningTask.Report(retorno);

                    //Aumentamos de página
                    currentPage++;
                }
            }
            catch (Exception ex)
            {
                //AppLog.LogMessage("ProviderBaseSignalR_BuscarVehiculos_exception", BusquedaVehiculos.Infra.Serialization.Serializer.Serialize(ex));
                //AppLog.LogMessage("ProviderBaseSignalR_BuscarVehiculos_exception", ex.ToMessageAndCompleteStackTrace());
            }
        }
コード例 #4
0
        public static BusquedaJob CreateJob(BusquedaRequestDTO request, IProviderManagerSignalR providerManager)
        {
            var job = new BusquedaJob(request, providerManager);

            RunningJobs.TryAdd(job.Id, job);
            return(job);
        }
コード例 #5
0
        public static BusquedaRequestDTO BuilBusquedaRequestDTO()
        {
            var retorno = new BusquedaRequestDTO();

            retorno.CodVehiculoTipo        = "usado";
            retorno.CodVehiculoMarca       = "volkswagen";
            retorno.CodVehiculoSubMarca    = "gol";
            retorno.CodVehiculoProvincia   = "buenos-aires";
            retorno.CodVehiculoSegmento    = "hatchback";
            retorno.CodVehiculoCombustible = "nafta";
            retorno.CodVehiculoDireccion   = "hidraulica"; //asistida
            retorno.CodVehiculoTransmision = "manual";
            retorno.CodVehiculoTraccion    = "4x2";
            retorno.CodVehiculoColor       = "gris";
            retorno.CodVehiculoPuerta      = "3-puertas";
            retorno.CodVehiculoCondicion   = "usado";
            retorno.Anio.ValorDesde        = 1990;
            retorno.Anio.ValorHasta        = DateTime.Now.Year;
            retorno.Kilometraje.ValorDesde = 1000;
            retorno.Kilometraje.ValorHasta = 250000;
            retorno.Precio.ValorDesde      = 500;
            retorno.Precio.ValorHasta      = 300000;
            retorno.Orden = "kilometraje-ascendenete";
            return(retorno);
        }
コード例 #6
0
        public void ObtengoListadoOrdenado()
        {
            var provider = new ProviderAutoFocoSync();
            var request  = new BusquedaRequestDTO();

            request.CodVehiculoTipo = "usado";
            request.Orden           = "kilometraje-ascendenete";
            var result = provider.BuscarVehiculos(request);

            Assert.IsNotNull(result);
            Assert.IsTrue(result.Items.Count > 0);
        }
コード例 #7
0
        public void ObtengoListadoConFiltroCommbustible()
        {
            var provider = new ProviderAutoFocoSync();
            var request  = new BusquedaRequestDTO();

            request.CodVehiculoTipo        = "usado";
            request.CodVehiculoCombustible = "nafta";
            var result = provider.BuscarVehiculos(request);

            Assert.IsNotNull(result);
            Assert.IsTrue(result.Items.Count > 0);
        }
コード例 #8
0
        public void ObtengoListadoOrdenado()
        {
            var provider = new ProviderMercadoLibreSync();
            var request  = new BusquedaRequestDTO();

            request.CodVehiculoTipo = "usado";
            request.Orden           = "precio-ascendente";
            var result = provider.BuscarVehiculos(request);

            Assert.IsNotNull(result);
            Assert.IsTrue(result.Items.Count > 0);
        }
コード例 #9
0
        public void ObtengoListadoConFiltroColor()
        {
            var provider = new ProviderMercadoLibreSync();
            var request  = new BusquedaRequestDTO();

            request.CodVehiculoTipo  = "usado";
            request.CodVehiculoColor = "gris";
            var result = provider.BuscarVehiculos(request);

            Assert.IsNotNull(result);
            Assert.IsTrue(result.Items.Count > 0);
        }
コード例 #10
0
        public void ObtengoListadoConFiltroSegmento()
        {
            var provider = new ProviderDeAutosSync();
            var request  = new BusquedaRequestDTO();

            request.CodVehiculoTipo     = "usado";
            request.CodVehiculoSegmento = "hatchback-5p";
            var result = provider.BuscarVehiculos(request);

            Assert.IsNotNull(result);
            Assert.IsTrue(result.Items.Count > 0);
        }
コード例 #11
0
        public void ObtengoListadoConFiltroPuertas()
        {
            var provider = new ProviderDeMotoresSync();
            var request  = new BusquedaRequestDTO();

            request.CodVehiculoTipo   = "usado";
            request.CodVehiculoPuerta = "3-puertas";
            var result = provider.BuscarVehiculos(request);

            Assert.IsNotNull(result);
            Assert.IsTrue(result.Items.Count > 0);
        }
コード例 #12
0
        public void ObtengoListadoConFiltroUbicacion()
        {
            var provider = new ProviderAutoFocoSync();
            var request  = new BusquedaRequestDTO();

            request.CodVehiculoTipo      = "usado";
            request.CodVehiculoProvincia = "cordoba";
            var result = provider.BuscarVehiculos(request);

            Assert.IsNotNull(result);
            Assert.IsTrue(result.Items.Count > 0);
        }
コード例 #13
0
        public void ObtengoListadoConFiltroMarca()
        {
            var provider = new ProviderAutoFocoSync();
            var request  = new BusquedaRequestDTO();

            request.CodVehiculoTipo  = "usado";
            request.CodVehiculoMarca = "volkswagen";
            var result = provider.BuscarVehiculos(request);

            Assert.IsNotNull(result);
            Assert.IsTrue(result.Items.Count > 0);
        }
コード例 #14
0
        public void ObtengoListadoConFiltroTransmision()
        {
            var provider = new ProviderOlxSync();
            var request  = new BusquedaRequestDTO();

            request.CodVehiculoTipo        = "usado";
            request.CodVehiculoTransmision = "manual";
            var result = provider.BuscarVehiculos(request);

            Assert.IsNotNull(result);
            Assert.IsTrue(result.Items.Count > 0);
        }
コード例 #15
0
        public void ObtengoListadoConFiltroPrecio()
        {
            var provider = new ProviderAlaMaulaSync();
            var request  = new BusquedaRequestDTO();

            request.CodVehiculoTipo   = "usado";
            request.Precio.ValorDesde = 500;
            request.Precio.ValorHasta = 300000;
            var result = provider.BuscarVehiculos(request);

            Assert.IsNotNull(result);
            Assert.IsTrue(result.Items.Count > 0);
        }
コード例 #16
0
        public void ObtengoListadoConFiltroKilometraje()
        {
            var provider = new ProviderAutoFocoSync();
            var request  = new BusquedaRequestDTO();

            request.CodVehiculoTipo        = "usado";
            request.Kilometraje.ValorDesde = 1000;
            request.Kilometraje.ValorHasta = 250000;
            var result = provider.BuscarVehiculos(request);

            Assert.IsNotNull(result);
            Assert.IsTrue(result.Items.Count > 0);
        }
コード例 #17
0
        public void ObtengoListadoConFiltroAnio()
        {
            var provider = new ProviderAutoFocoSync();
            var request  = new BusquedaRequestDTO();

            request.CodVehiculoTipo = "usado";
            request.Anio.ValorDesde = 2010;
            request.Anio.ValorHasta = DateTime.Now.Year;
            var result = provider.BuscarVehiculos(request);

            Assert.IsNotNull(result);
            Assert.IsTrue(result.Items.Count > 0);
        }
コード例 #18
0
        public void EjecutarBusqueda(BusquedaRequestDTO request)
        {
            var retorno = new List <BusquedaResponseDTO>();

            try
            {
                Parallel.ForEach(this.Providers, (itemProvider) =>
                {
                    itemProvider.BuscarVehiculos(request);
                });
            }
            catch (Exception)
            {
            }
        }
コード例 #19
0
        public List <String> GetProvidersDisponibles(BusquedaRequestDTO request)
        {
            var retorno = enProvider.GetProviders();

            retorno = this.VerificarItemProvider(retorno, enCatalogo.Provincia, request.CodVehiculoProvincia);
            retorno = this.VerificarItemProvider(retorno, enCatalogo.Marca, request.CodVehiculoMarca);
            retorno = this.VerificarItemProvider(retorno, enCatalogo.Modelo, request.CodVehiculoSubMarca);
            retorno = this.VerificarItemProvider(retorno, enCatalogo.Color, request.CodVehiculoColor);
            retorno = this.VerificarItemProvider(retorno, enCatalogo.Combustible, request.CodVehiculoCombustible);
            retorno = this.VerificarItemProvider(retorno, enCatalogo.Direccion, request.CodVehiculoDireccion);
            retorno = this.VerificarItemProvider(retorno, enCatalogo.Puertas, request.CodVehiculoPuerta);
            retorno = this.VerificarItemProvider(retorno, enCatalogo.Segmento, request.CodVehiculoSegmento);
            retorno = this.VerificarItemProvider(retorno, enCatalogo.Traccion, request.CodVehiculoTraccion);
            retorno = this.VerificarItemProvider(retorno, enCatalogo.Transmision, request.CodVehiculoTransmision);
            return(retorno);
        }
コード例 #20
0
        public List <BusquedaResponseDTO> EjecutarBusqueda(BusquedaRequestDTO request)
        {
            var retorno = new List <BusquedaResponseDTO>();

            try
            {
                //TODO: Poner un Paralell
                foreach (var itemProvider in this.Providers)
                {
                    //Agregamos a la lista de resultados
                    var resultado = itemProvider.BuscarVehiculos(request);
                    retorno.Add(resultado);
                }
            }
            catch (Exception)
            {
            }
            return(retorno);
        }
コード例 #21
0
        public BusquedaResponseDTO BuscarVehiculos(BusquedaRequestDTO request)
        {
            var retorno = new BusquedaResponseDTO()
            {
                CodProvider = this.CodProvider
            };

            try
            {
                int?currentPage = null;
                int?pagesCount  = null;

                //Procesamos el request
                while ((!currentPage.HasValue && !pagesCount.HasValue) || (currentPage.Value < pagesCount.Value))
                {
                    //Procesamos la solicitud paginada
                    var result = this.ProcessUrl(request, ref currentPage, ref pagesCount);
                    retorno.Items.AddRange(result);

                    //Aumentamos de página si no es ambiente de test
                    if (ParametrosAppSetting.ConfigAmbienteTest == "N")
                    {
                        currentPage++;
                    }
                    else
                    {
                        //Cortamos el ciclo
                        currentPage = 1;
                        pagesCount  = 1;
                    }
                }
            }
            catch (Exception ex)
            {
                //AppLog.LogMessage("ProviderBaseSync_BuscarVehiculos_exception", BusquedaVehiculos.Infra.Serialization.Serializer.Serialize(ex));
                AppLog.LogMessage("ProviderBaseSync_BuscarVehiculos_exception", ex.Message);
            }
            return(retorno);
        }
コード例 #22
0
        public Uri GetUrlParsed(BusquedaRequestDTO request, int?page = null)
        {
            Uri retorno = null;

            try
            {
                using (var dbContext = new ModelContext())
                {
                    var provider = dbContext.ProviderDataSet.Single(x => x.CodProvider == this.CodProvider);
                    this.UrlBuild = provider.UrlCompleta;

                    //Filtro por tipo
                    if (!String.IsNullOrEmpty(request.CodVehiculoTipo))
                    {
                        this.UrlBuild = this.TratarUrl(dbContext, provider, this.UrlBuild, enComponenteUrl.FiltroTipo, enCatalogo.Tipo, request.CodVehiculoTipo);
                    }

                    //Filtro por marca
                    if (!String.IsNullOrEmpty(request.CodVehiculoMarca))
                    {
                        this.UrlBuild = this.TratarUrl(dbContext, provider, this.UrlBuild, enComponenteUrl.FiltroMarca, enCatalogo.Marca, request.CodVehiculoMarca);
                    }

                    //Filtro por modelo
                    if (!String.IsNullOrEmpty(request.CodVehiculoSubMarca))
                    {
                        var codModelo = String.Format("{0}@{1}", request.CodVehiculoMarca, request.CodVehiculoSubMarca);
                        this.UrlBuild = this.TratarUrl(dbContext, provider, this.UrlBuild, enComponenteUrl.FiltroModelo, enCatalogo.Modelo, codModelo);
                    }

                    //Filtro por provincia
                    if (!String.IsNullOrEmpty(request.CodVehiculoProvincia))
                    {
                        this.UrlBuild = this.TratarUrl(dbContext, provider, this.UrlBuild, enComponenteUrl.FiltroUbicacion, enCatalogo.Provincia, request.CodVehiculoProvincia);
                    }

                    //Filtro por segmento
                    if (!String.IsNullOrEmpty(request.CodVehiculoSegmento))
                    {
                        this.UrlBuild = this.TratarUrl(dbContext, provider, this.UrlBuild, enComponenteUrl.FiltroSegmento, enCatalogo.Segmento, request.CodVehiculoSegmento);
                    }

                    //Filtro por combustible
                    if (!String.IsNullOrEmpty(request.CodVehiculoCombustible))
                    {
                        this.UrlBuild = this.TratarUrl(dbContext, provider, this.UrlBuild, enComponenteUrl.FiltroCombustible, enCatalogo.Combustible, request.CodVehiculoCombustible);
                    }

                    //Filtro por dirección
                    if (!String.IsNullOrEmpty(request.CodVehiculoDireccion))
                    {
                        this.UrlBuild = this.TratarUrl(dbContext, provider, this.UrlBuild, enComponenteUrl.FiltroDireccion, enCatalogo.Direccion, request.CodVehiculoDireccion);
                    }

                    //Filtro por transmisión
                    if (!String.IsNullOrEmpty(request.CodVehiculoTransmision))
                    {
                        this.UrlBuild = this.TratarUrl(dbContext, provider, this.UrlBuild, enComponenteUrl.FiltroTransmision, enCatalogo.Transmision, request.CodVehiculoTransmision);
                    }

                    //Filtro por tracción
                    if (!String.IsNullOrEmpty(request.CodVehiculoTraccion))
                    {
                        this.UrlBuild = this.TratarUrl(dbContext, provider, this.UrlBuild, enComponenteUrl.FiltroTraccion, enCatalogo.Traccion, request.CodVehiculoTraccion);
                    }

                    //Filtro por color
                    if (!String.IsNullOrEmpty(request.CodVehiculoColor))
                    {
                        this.UrlBuild = this.TratarUrl(dbContext, provider, this.UrlBuild, enComponenteUrl.FiltroColor, enCatalogo.Color, request.CodVehiculoColor);
                    }

                    //Filtro por puertas
                    if (!String.IsNullOrEmpty(request.CodVehiculoPuerta))
                    {
                        this.UrlBuild = this.TratarUrl(dbContext, provider, this.UrlBuild, enComponenteUrl.FiltroPuertas, enCatalogo.Puertas, request.CodVehiculoPuerta);
                    }

                    //Filtro por condicion
                    if (!String.IsNullOrEmpty(request.CodVehiculoCondicion))
                    {
                        this.UrlBuild = this.TratarUrl(dbContext, provider, this.UrlBuild, enComponenteUrl.FiltroCondicion, enCatalogo.Condicion, request.CodVehiculoCondicion);
                    }

                    //Filtro por año
                    if (request.Anio != null && this.CodProvider != enProvider.AutoFoco)
                    {
                        this.UrlBuild = this.TratarUrlRango(provider, this.UrlBuild, enComponenteUrl.FiltroAnio, request.Anio);
                    }
                    else if (request.Anio != null && this.CodProvider == enProvider.AutoFoco)
                    {
                        //TODO: Autofoco tiene implementacion rara para años
                        //&type_autos_year=2005&type_autos_year=2006&type_autos_year=2007&type_autos_year=2008&
                        var filtroAnio = new StringBuilder();
                        for (long iPos = request.Anio.ValorDesde; iPos <= request.Anio.ValorHasta; iPos++)
                        {
                            filtroAnio.Append(String.Format("&type_autos_year={0}", iPos));
                        }

                        if (filtroAnio.Length > 0)
                        {
                            this.UrlBuild = this.UrlBuild.Replace(String.Format("[{0}]", enComponenteUrl.FiltroAnio), filtroAnio.ToString());
                        }
                    }

                    //Filtro por kilometraje
                    if (request.Kilometraje != null)
                    {
                        this.UrlBuild = this.TratarUrlRango(provider, this.UrlBuild, enComponenteUrl.FiltroKilometros, request.Kilometraje);
                    }

                    //Filtro por precio
                    if (request.Precio != null)
                    {
                        this.UrlBuild = this.TratarUrlRango(provider, this.UrlBuild, enComponenteUrl.FiltroPrecio, request.Precio);
                    }

                    //Orden
                    if (!String.IsNullOrEmpty(request.Orden))
                    {
                        this.UrlBuild = this.TratarUrl(dbContext, provider, this.UrlBuild, enComponenteUrl.Orden, enCatalogo.Orden, request.Orden);
                    }

                    //Aplicamos el paginado en cada provider
                    var componenteUrlPage = provider.ComponetentesUrl.SingleOrDefault(x => x.CodComponente == enComponenteUrl.Pagina);
                    if (componenteUrlPage != null)
                    {
                        var pageCalculated      = this.ParsePageProvider(page.GetValueOrDefault(1));
                        var componentePageSplit = componenteUrlPage.Expresion.Split('@');
                        for (int iPos = 0; iPos < componentePageSplit.Length; iPos++)
                        {
                            var replaceWith = componentePageSplit[iPos].Replace("[Value]", pageCalculated.ToString());

                            //Reemplazamos el valor en la cadena
                            if (!String.IsNullOrEmpty(replaceWith))
                            {
                                var indexToRemove = this.UrlBuild.IndexOf(String.Format("[{0}]", enComponenteUrl.Pagina));
                                this.UrlBuild = this.UrlBuild.Remove(indexToRemove, String.Format("[{0}]", enComponenteUrl.Pagina).Length);
                                this.UrlBuild = this.UrlBuild.Insert(indexToRemove, replaceWith);
                            }
                        }
                    }

                    //Ejecutamos lógica específica de cada provider
                    this.TratamientoUrlProvider();

                    //Eliminamos de la url los componentes que no se aplicaron
                    var componentes = enComponenteUrl.GetList();
                    foreach (var itemComponente in componentes)
                    {
                        this.UrlBuild = this.UrlBuild.Replace(String.Format("[{0}]", itemComponente), String.Empty);
                    }

                    //Eliminamos caracteres adicionales
                    var normalizar = new List <String>()
                    {
                        "&&", "~~", "//", "--", "__"
                    };
                    foreach (var item in normalizar)
                    {
                        while (this.UrlBuild.Contains(item))
                        {
                            this.UrlBuild = this.UrlBuild.Replace(item, item[0].ToString());
                        }
                    }

                    //Verificamos el formato del protocolo
                    if ((!this.UrlBuild.StartsWith("http://")) && (!this.UrlBuild.StartsWith("https://")))
                    {
                        if (this.UrlBuild.StartsWith("http:/"))
                        {
                            this.UrlBuild = this.UrlBuild.Replace("http:/", "http://");
                        }
                        else if (this.UrlBuild.StartsWith("https:/"))
                        {
                            this.UrlBuild = this.UrlBuild.Replace("https:/", "https://");
                        }
                    }
                    if (this.UrlBuild.StartsWith("https://."))
                    {
                        this.UrlBuild = this.UrlBuild.Replace("https://.", "https://www.");
                    }

                    if (this.UrlBuild.Contains("/~"))
                    {
                        this.UrlBuild = this.UrlBuild.Replace("/~", "/");
                    }
                    if (this.UrlBuild.Contains("~/"))
                    {
                        this.UrlBuild = this.UrlBuild.Replace("~/", "/");
                    }
                    if (this.UrlBuild.Contains("-/") && (this.CodProvider != enProvider.AutoFoco))
                    {
                        this.UrlBuild = this.UrlBuild.Replace("-/", "/");
                    }

                    //Verificacion autofoco
                    if (this.UrlBuild.Contains("/?"))
                    {
                        this.UrlBuild = this.UrlBuild.Replace("/?", "?");
                    }

                    //Verificamos que no quede ultimo caracter
                    if (this.UrlBuild.EndsWith("&"))
                    {
                        this.UrlBuild = this.UrlBuild.Substring(0, this.UrlBuild.Length - 1);
                    }

                    //Asignamos el resultado
                    retorno = new Uri(this.UrlBuild);
                }
            }
            catch (Exception)
            {
                throw;
            }
            return(retorno);
        }
コード例 #23
0
 public BusquedaJob(String id, BusquedaRequestDTO request, IProviderManagerSignalR providerManager)
 {
     this.Id              = id;
     this.Request         = request;
     this.ProviderManager = providerManager;
 }
コード例 #24
0
 public BusquedaJob(BusquedaRequestDTO request, IProviderManagerSignalR providerManager)
     : this(Guid.NewGuid().ToString(), request, providerManager)
 {
 }