protected void InitializeTemplate(Request Request, WebTemplate Template, ResultPage Content, string[] Parts, WebUrl Url)
        {
            foreach (WebSection section in Template.Sections) {
                var sectionJson = Content.Sections.Add();

                sectionJson.Name = section.Name;

                foreach (WebMap map in section.Maps.OrderBy(x => x.SortNumber)) {
                    if (map.Url != null && map.Url.GetObjectID() != Url.GetObjectID()) {
                        continue;
                    }

                    string url = FormatUrl(map.ForeignUrl, Parts.Last());

                    ContainerPage json = Self.GET<ContainerPage>(url, () => {
                        return new ContainerPage() {
                            Key = url
                        };
                    });

                    sectionJson.Rows.Add(json);
                }

                if (section.Default && Url == null) {
                    ContainerPage json = Self.GET<ContainerPage>(Request.Uri, () => {
                        return new ContainerPage() {
                            Key = Request.Uri
                        };
                    });

                    sectionJson.Rows.Add(json);
                }
            }
        }
        public void Pages_count_calcullation_for_partially_populated_pages()
        {
            var pageSize = 50;
            var totalItemsInSystem = 151;
            var pageNumber = 2;

            var result = new ResultPage<string>(Enumerable.Repeat("test", pageSize), pageNumber, pageSize, totalItemsInSystem);

            Assert.That(result.PagesCount, Is.EqualTo(4));
        }
        public void Pages_count_calcullation_with_single_item()
        {
            var pageSize = 50;
            var totalItemsInSystem = 1;
            var pageNumber = 1;

            var result = new ResultPage<string>(Enumerable.Repeat("test", totalItemsInSystem), pageNumber, pageSize, totalItemsInSystem);

            Assert.That(result.PagesCount, Is.EqualTo(1));
        }
Example #4
0
 public void ChangeLocationToENG()
 {
     try
     {
         HomePage home = new HomePage(driver);
         home.GoToPage();
         PassengerPage passengerPage = home.GoToPassengerPage();
         ResultPage    result        = passengerPage.ChangeLocalization();
         Assert.IsTrue(result.IsUrlCorrect());
         Logger.Logger.Log.Info("Test success!");
         Logger.Logger.TakeScreenshot(driver, @"Log\success2.png");
     }
     catch (Exception error)
     {
         Logger.Logger.TakeScreenshot(driver, @"Log\error2.png");
         Logger.Logger.Log.Error("Test error:" + error.Message);
     }
 }
Example #5
0
 public void CorrectLogIn()
 {
     try
     {
         HomePage home = new HomePage(driver);
         home.GoToPage();
         PassengerPage passengerPage = home.GoToPassengerPage();
         ResultPage    result        = passengerPage.Authorization("dpitalenko", "123456789rwby");
         Assert.IsNotNull(result.IsLogIn());
         Logger.Logger.Log.Info("Test success!");
         Logger.Logger.TakeScreenshot(driver, @"Log\success.png");
     }
     catch (Exception error)
     {
         Logger.Logger.TakeScreenshot(driver, @"Log\error.png");
         Logger.Logger.Log.Error("Test error:" + error.Message);
     }
 }
    private IEnumerator CheckForResultsPage()
    {
        yield return(null);

        while (true)
        {
            ResultPage[] resultPages = FindObjectsOfType <ResultPage>();
            if (resultPages != null && resultPages.Length > 0)
            {
                ResultPage resultPageBehaviour = resultPages[0];
                _postGameCommander = new PostGameCommander(resultPageBehaviour);
                break;
            }

            yield return(null);
        }
        InputInterceptor.EnableInput();
    }
Example #7
0
        public void TestXmlWithInvalidCharacters()
        {
            // 0x1A can't be represented in XML => https://stackoverflow.com/a/8506173
            // some ascii and unicode characters
            var text      = "Title Ñ 理" + Convert.ToChar("\u001a") + Convert.ToChar("\u2813");
            var validText = "Title Ñ 理" + Convert.ToChar("\u2813");

            // link with characters that requires URL encode
            var link      = new Uri("https://example.com/" + text);
            var validLink = "https://example.com/Title%20%C3%91%20%E7%90%86%1A%E2%A0%93";

            var resultPage = new ResultPage(
                new ChannelInfo // characters in channel info are safe because are provided by us
            {
                Link = link
            })
            {
                Releases = new List <ReleaseInfo>
                {
                    new ReleaseInfo     // these fields are from websites and they can be problematic
                    {
                        Title       = text,
                        Guid        = link,
                        Link        = link,
                        Details     = link,
                        PublishDate = new DateTime(2020, 09, 22),
                        Description = text,
                        Author      = text,
                        BookTitle   = text,
                        Poster      = link,
                        InfoHash    = text,
                        MagnetUri   = link,
                        Origin      = new TestIndexer()
                    }
                }
            };
            var xml = resultPage.ToXml(link);

            Assert.AreEqual(5, Regex.Matches(xml, validText).Count);
            Assert.AreEqual(8, Regex.Matches(xml, validLink).Count);

            // this should be in another test but it's here to avoid creating the whole object again
            Assert.True(xml.Contains("Tue, 22 Sep 2020 00:00:00 "));
        }
Example #8
0
        /// <summary>
        /// Asynchronously Starts the requests to download the users from the search pages.
        /// </summary>
        /// <param name="username">The username.</param>
        /// <param name="threads">The max thread count.</param>
        private async Task startRequestsAsync(string username, int threads)
        {
            status = Status.Preparing;
            PageRequest pageRequest    = new PageRequest();
            ResultPage  initialRequest = null;

            while (initialRequest?.Success != true)
            {
                initialRequest = await pageRequest.GetPageUsersAsync(username, 1).ConfigureAwait(false);
            }

            // Limit of 500 pages or 10,000 users. If less than that then we divide user count by users per page (20)
            int pages          = initialRequest.SearchResultCount > 10000 ? 500 : (int)Math.Ceiling((double)(initialRequest.SearchResultCount / 20.0));
            int pagesPerThread = pages <= threads ? 1 : pages / threads;

            totalUsersSearching = initialRequest.SearchResultCount > 10000 ? 10000 : initialRequest.SearchResultCount;

            List <List <int> > pagesLists = new List <List <int> >();
            List <int>         tempPages  = new List <int>();

            for (int i = 1; i <= pages; i++)
            {
                if (tempPages.Count < pagesPerThread)
                {
                    tempPages.Add(i);
                }
                if (tempPages.Count >= pagesPerThread)
                {
                    pagesLists.Add(new List <int>(tempPages));
                    tempPages.Clear();
                }
            }
            pagesLists[0].AddRange(new List <int>(tempPages)); // Add rest of pages to first list

            status = Status.DownloadingUsers;
            foreach (var pageList in pagesLists)
            {
                var task = new Task(async() => await getUsersAsync(username, pageList).ConfigureAwait(false));
                taskList.Add(task);
                task.Start();
            }
            Task.WaitAll(taskList.ToArray());
        }
Example #9
0
 public void Test1()
 {
     using (IWebDriver driver = new ChromeDriver(@"D:\"))
     {
         var google = new Google(driver);
         google.NavigateToGoogle();
         google.SearchText("hdrezka");
         Thread.Sleep(2000);
         ResultPage result  = google.Click();
         HDrezka    hdrezka = result.Click();
         hdrezka.SearchText("Люцифер");
         Thread.Sleep(2000);
         Lucifer lucifer = hdrezka.Click();
         Thread.Sleep(2000);
         LuciferMovie luciferMovie = lucifer.Click();
         Thread.Sleep(2000);
         Assert.True(luciferMovie.isResultPresent());
     }
 }
Example #10
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="request"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task <ResultPage <BillOutput> > Handle(BillPageQuery request, CancellationToken cancellationToken)
        {
            StringBuilder sqlBuilder = new StringBuilder("select SQL_CALC_FOUND_ROWS ");

            sqlBuilder.Append(@" * FROM Bill where BillCreateTime>@beginTime and BillCreateTime<@endTime
                                ORDER BY BillCreateTime DESC ");
            sqlBuilder.Append("limit @Skip,@Take;");
            sqlBuilder.Append("SELECT FOUND_ROWS() as Total;");

            var sql            = sqlBuilder.ToString();
            var dapperPageInfo = await _dapper.QueryPage <BillOutput>(sql, new { beginTime = request.BeginTime, endTime = request.EndTime, Skip = (request.Index - 1) * request.Size, Take = request.Size });

            ResultPage <BillOutput> result = new ResultPage <BillOutput>()
            {
                TotalCount = (int)dapperPageInfo.TotalCount,
                Data       = dapperPageInfo.Data
            };

            return(result);
        }
Example #11
0
        public void When_casting_Then_works()
        {
            var list = new List <Class1>()
            {
                new Class2()
                {
                    Prop1 = "Prop1-1", Prop2 = "Prop2-1"
                }, new Class2()
                {
                    Prop1 = "Prop1-2", Prop2 = "Prop2-2"
                }
            };

            var page = new ResultPage <Class1>(list, 1, 2, 2);

            var actual = page.Cast <Class2>();

            Assert.That(actual, Is.InstanceOf <ResultPage <Class2> >());
            Assert.That(actual.First().Prop2, Is.EqualTo("Prop2-1"));
            Assert.That(actual.Last().Prop2, Is.EqualTo("Prop2-2"));
        }
Example #12
0
        static void Main(string[] args)
        {
            try
            {
                IWebDriver driver = new ChromeDriver();
                driver.Manage().Window.Maximize();
                driver.Navigate().GoToUrl("https://av.by");

                MainPage mainPage = new MainPage(driver);
                mainPage.SelectBrand("Jaguar");
                mainPage.NavigateTo();

                ResultPage resultPage = new ResultPage(driver);
                resultPage.CalculateNumberOfEachModels();
                resultPage.SortListCars();
                resultPage.PrintListCars();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
Example #13
0
        public void Fail_if_avg_less_3()
        {
            int[] paragraph = new int[10];
            for (int i = 0; i < 10; i = i + 1)
            {
                HomePage   home   = new HomePage(driver);
                ResultPage result = new ResultPage(driver);
                home.goToPage();
                home.clickOnGenerate();
                IList <IWebElement> all = result.Lipsum_contains_Lorem;
                var list_of_paragraphs  = all.Count;
                Console.WriteLine(list_of_paragraphs);
                paragraph[i] = list_of_paragraphs;
            }
            int sum = paragraph.Sum();

            Console.WriteLine("Sum:" + sum);
            var avg = sum / 10;

            Console.WriteLine("Average:" + avg);
            Assert.IsTrue(avg >= 3);
        }
Example #14
0
        public void DidTimeoutFacialRecognition(byte[] lastImage)
        {
            UserDialogs.Instance.ShowLoading("Capturing data...");
            Task.Run(async() =>
            {
                _ReadyToStop.WaitOne();

                Device.BeginInvokeOnMainThread(() =>
                {
                    if (faceImageBytes != null && lastImage != null)
                    {
                        App.AcuantSDKWrapper.processFacialMatch(lastImage, faceImageBytes, true);
                    }
                    else
                    {
                        UserDialogs.Instance.HideLoading();
                        var resultPage = new ResultPage(processedData, (int)cardType, App.AcuantSDKWrapper.platform());
                        Navigation.PushModalAsync(resultPage);
                    }
                });
            });
            UserDialogs.Instance.ShowLoading("Capturing data...");
        }
Example #15
0
    public static string GetCustomersData(int pageIndex)
    {
        ResultPage            result  = null;
        DailyMotionAPIManager Manager = new DailyMotionAPIManager();

        if (string.IsNullOrWhiteSpace(Query))
        {
            result = Manager.GetDefaultPage(pageIndex, LimitPerPage, CurrentCulture); //No query, display default page
        }
        else
        {
            result = Manager.Search(Query, pageIndex, LimitPerPage, CurrentCulture);
        }

        StringBuilder sb = new StringBuilder();

        foreach (var video in result.Videos)
        {
            sb.Append(video.ToListHTML());
        }

        return(sb.ToString());
    }
Example #16
0
        private void Result(DataBaseLite data, bool compareFromListSubmit)
        {
            ResultPage result;

            if (!compareFromListSubmit)
            {
                result = new ResultPage(data.GetOrignCodeFromId(data.IdMainFileForHist),
                                        data.GetOrignCodeFromId(data.IdiDenticalFie), ref _db);
            }
            else
            {
                result = new ResultPage(data.GetOrignCodeFromId(data.IdMainFileForHist),
                                        data.GetOrignCodeFromId(data.IdiDenticalFie), ref _db);
            }



            //textCode.ToolTip = db.GetInfoSubm(true);
            //textCode2.ToolTip = db.GetInfoSubm(false);

            GridContentAction.Children.Clear();
            GridContentAction.Children.Add(result);
        }
Example #17
0
        public void EtoEtest(Browsers browser)
        {
            driver = Helper.startBrowser(browser);
            MainPage           mainPage           = new MainPage(driver);
            ResultPage         resultPage         = new ResultPage(driver);
            ProductComparePage productComparePage = new ProductComparePage(driver);
            ShoppingCartPage   shoppingCartPage   = new ShoppingCartPage(driver);

            mainPage.VerifyPage();
            mainPage.CurrencyDropdownClick();
            mainPage.ChooseGBP();
            mainPage.SearchForIpod();
            resultPage.AddIpodsToProductCompare();
            resultPage.GoToProductComparison();
            productComparePage.IsProductComparison();
            productComparePage.removeIpodShuffle();
            var productPrice = productComparePage.addRandomIpodToCart();

            productComparePage.GoToShoppingCart();
            var totalPrice = shoppingCartPage.GetTotalPrice();

            Assert.Equal(productPrice, totalPrice);
        }
Example #18
0
        public void CalculateNumberOfEachModels()
        {
            MainPage mainPage = new MainPage(driver);
            string   brand    = "Acura";
            string   model    = "RL";

            mainPage.SelectBrand(brand);
            IWebElement selectModel = driver.FindElement(By.XPath("//select[@name = 'model_id[]']"));

            selectModel.SendKeys(model);
            var expextedList = driver.FindElements(By.XPath(Locator.elementsLocator));

            ResultPage resultPage = new ResultPage(driver);

            resultPage.CalculateNumberOfEachModels();
            foreach (Car c in resultPage.cars)
            {
                if (c.Model == model)
                {
                    Assert.AreEqual(expextedList.Count, c.CountCars);
                }
            }
        }
Example #19
0
        public void ClickResultLink()
        {
            IWebDriver driver      = new ChromeDriver();
            string     searchQuery = "Hamptons Lamp";

            var homePage = new HomePage();

            PageFactory.InitElements(driver, homePage);

            var resultsPage = new ResultsPage();

            PageFactory.InitElements(driver, resultsPage);

            var resultPage = new ResultPage();

            PageFactory.Equals(driver, resultPage);

            // Launch browser at page
            driver.Url = Address;

            // Close cookie policy banner, if open
            homePage.CloseCookiesBanner();

            // Enter search query
            homePage.CreateAndRunSearch(searchQuery);

            // Validate result is returned
            Assert.IsTrue(UtilityClasses.ExtensionsClass.CheckElementExists(resultsPage.SearchResult));

            // Click into result link
            resultsPage.SearchResult.Click();

            // Validate page is loaded
            Assert.AreEqual("Dunnes Stores | Blue Paul Costelloe Living Hamptons Lamp", driver.Title);

            driver.Close();
        }
Example #20
0
        /// <summary>
        /// Asynchronously gets the users in the specified pages.
        /// </summary>
        /// <param name="username">The username.</param>
        /// <param name="pages">The pages to check.</param>
        private async Task getUsersAsync(string username, List <int> pages)
        {
            PageRequest pageRequest = new PageRequest();

            for (int i = 0; i < pages.Count;)
            {
                ResultPage resultPage = await pageRequest.GetPageUsersAsync(username, pages[i]).ConfigureAwait(false);

                if (resultPage.Success)
                {
                    bool goodResult = true;
                    foreach (User user in resultPage.Users)
                    {
                        if (!user.ValidProfilePicUrl)
                        {
                            user.ProfilePic = Properties.Resources.default_profile_full;
                        }
                        if (user.ProfilePic == null || user.Id == "NOTFOUND")
                        {
                            goodResult = false;
                        }
                    }

                    // If the result was satisfactory then we
                    // add the users in the page to the rest of
                    // of the users found, and increment i to continue
                    if (goodResult)
                    {
                        semaphore.WaitOne();
                        addUsers(username, resultPage.Users);
                        semaphore.Release();
                        i++;
                    }
                }
            }
        }
Example #21
0
        public async Task <ResultPage <PersonaDto> > BuscarAsync(OptionSearchPersonasDto dto)
        {
            var result        = new ResultPage <PersonaDto>();
            var totales       = _uow.Personas.Count();
            var totalFiltered = 0;

            #region Filtro

            Expression <Func <Persona, bool> > filter = ele => true;

            if (!string.IsNullOrWhiteSpace(dto.TextSearch))
            {
                filter = filter.And(ele => ele.Id.ToString().Contains(dto.TextSearch.ToLower()) ||
                                    ele.Nombres.ToLower().Contains(dto.TextSearch.ToLower()) ||
                                    ele.Apellidos.ToLower().Contains(dto.TextSearch.ToLower()) ||
                                    ele.Oficina.ToLower().Contains(dto.TextSearch.ToLower()));
            }

            var query = _uow.Personas.Where(filter).ProjectTo <PersonaDto>(_mapperConfig).ToListAsync();

            IList <PersonaDto> list = await query;

            totalFiltered = list.Count;

            #endregion

            #region Ordenacion

            switch (dto.OrderBy)
            {
            case PersonaOrderColumn.Codigo:
            {
                list = dto.IsAscending ? list.OrderBy(ele => ele.Id).ThenBy(ele => ele.Id).ToList()
                            : list.OrderByDescending(ele => ele.Id).ThenBy(ele => ele.Id).ToList();
            }
            break;

            case PersonaOrderColumn.Nombres:
            {
                list = dto.IsAscending ? list.OrderBy(ele => ele.Nombres).ThenBy(ele => ele.Nombres).ToList()
                            : list.OrderByDescending(ele => ele.Nombres).ThenBy(ele => ele.Nombres).ToList();
            }
            break;

            case PersonaOrderColumn.Apellidos:
            {
                list = dto.IsAscending ? list.OrderBy(ele => ele.Apellidos).ThenBy(ele => ele.Apellidos).ToList()
                           : list.OrderByDescending(ele => ele.Apellidos).ThenBy(ele => ele.Apellidos).ToList();
            }
            break;

            case PersonaOrderColumn.Oficina:
            {
                list = dto.IsAscending ? list.OrderBy(ele => ele.Oficina).ThenBy(ele => ele.Oficina).ToList()
                           : list.OrderByDescending(ele => ele.Oficina).ThenBy(ele => ele.Oficina).ToList();
            }
            break;

            case PersonaOrderColumn.Salario:
            {
                list = dto.IsAscending ? list.OrderBy(ele => ele.Salario).ThenBy(ele => ele.Salario).ToList()
                           : list.OrderByDescending(ele => ele.Salario).ThenBy(ele => ele.Salario).ToList();
            }
            break;

            case PersonaOrderColumn.Experiencia:
            {
                list = dto.IsAscending ? list.OrderBy(ele => ele.Experiencia).ThenBy(ele => ele.Experiencia).ToList()
                           : list.OrderByDescending(ele => ele.Experiencia).ThenBy(ele => ele.Experiencia).ToList();
            }
            break;

            case PersonaOrderColumn.FechaInicio:
            {
                list = dto.IsAscending ? list.OrderBy(ele => ele.FechaInicio).ThenBy(ele => ele.FechaInicio).ToList()
                           : list.OrderByDescending(ele => ele.FechaInicio).ThenBy(ele => ele.FechaInicio).ToList();
            }
            break;

            default:
            {
                list = dto.IsAscending ? list.OrderBy(ele => ele.Id).ThenBy(ele => ele.Id).ToList()
                          : list.OrderByDescending(ele => ele.Id).ThenBy(ele => ele.Id).ToList();
            }
            break;
            }


            #endregion

            #region Paginacion

            var pageIndex = dto.PageIndex;
            var pageSize  = dto.PageSize;

            if (pageIndex < 1)
            {
                pageIndex = 1;
            }
            if (pageSize < 1)
            {
                pageSize = 1;
            }

            result.PageIndex = pageIndex;
            result.PageSize  = pageSize;

            list = list.Skip((pageIndex - 1) * pageSize)
                   .Take(pageSize).ToList();

            #endregion

            result.Elements      = list.ToList();
            result.TotalElements = totales;
            result.TotalPage     = (result.TotalElements / result.PageSize) + (result.TotalElements % result.PageSize == 0 ? 0 : 1);
            result.TotalFiltered = totalFiltered;

            return(result);
        }
Example #22
0
        public async Task <HttpResponseMessage> Call(string indexerID)
        {
            var indexer      = indexerService.GetIndexer(indexerID);
            var torznabQuery = TorznabQuery.FromHttpQuery(HttpUtility.ParseQueryString(Request.RequestUri.Query));

            if (string.Equals(torznabQuery.QueryType, "caps", StringComparison.InvariantCultureIgnoreCase))
            {
                return(new HttpResponseMessage()
                {
                    Content = new StringContent(indexer.TorznabCaps.ToXml(), Encoding.UTF8, "application/xml")
                });
            }

            torznabQuery.ExpandCatsToSubCats();
            var allowBadApiDueToDebug = false;

#if DEBUG
            allowBadApiDueToDebug = Debugger.IsAttached;
#endif

            if (!allowBadApiDueToDebug && !string.Equals(torznabQuery.ApiKey, serverService.Config.APIKey, StringComparison.InvariantCultureIgnoreCase))
            {
                logger.Warn(string.Format("A request from {0} was made with an incorrect API key.", Request.GetOwinContext().Request.RemoteIpAddress));
                return(Request.CreateResponse(HttpStatusCode.Forbidden, "Incorrect API key"));
            }

            if (!indexer.IsConfigured)
            {
                logger.Warn(string.Format("Rejected a request to {0} which is unconfigured.", indexer.DisplayName));
                return(Request.CreateResponse(HttpStatusCode.Forbidden, "This indexer is not configured."));
            }

            if (torznabQuery.ImdbID != null)
            {
                if (torznabQuery.QueryType != "movie")
                {
                    logger.Warn(string.Format("A non movie request with an imdbid was made from {0}.", Request.GetOwinContext().Request.RemoteIpAddress));
                    return(GetErrorXML(201, "Incorrect parameter: only movie-search supports the imdbid parameter"));
                }

                if (!string.IsNullOrEmpty(torznabQuery.SearchTerm))
                {
                    logger.Warn(string.Format("A movie-search request from {0} was made contining q and imdbid.", Request.GetOwinContext().Request.RemoteIpAddress));
                    return(GetErrorXML(201, "Incorrect parameter: please specify either imdbid or q"));
                }

                torznabQuery.ImdbID = ParseUtil.GetFullImdbID(torznabQuery.ImdbID); // normalize ImdbID
                if (torznabQuery.ImdbID == null)
                {
                    logger.Warn(string.Format("A movie-search request from {0} was made with an invalid imdbid.", Request.GetOwinContext().Request.RemoteIpAddress));
                    return(GetErrorXML(201, "Incorrect parameter: invalid imdbid format"));
                }

                if (!indexer.TorznabCaps.SupportsImdbSearch)
                {
                    logger.Warn(string.Format("A movie-search request with imdbid from {0} was made but the indexer {1} doesn't support it.", Request.GetOwinContext().Request.RemoteIpAddress, indexer.DisplayName));
                    return(GetErrorXML(203, "Function Not Available: imdbid is not supported by this indexer"));
                }
            }

            var releases = await indexer.PerformQuery(torznabQuery);

            releases = indexer.CleanLinks(releases);

            // Some trackers do not keep their clocks up to date and can be ~20 minutes out!
            foreach (var release in releases.Where(r => r.PublishDate > DateTime.Now))
            {
                release.PublishDate = DateTime.Now;
            }

            // Some trackers do not support multiple category filtering so filter the releases that match manually.
            var filteredReleases = releases = indexer.FilterResults(torznabQuery, releases);
            int?newItemCount     = null;

            // Cache non query results
            if (string.IsNullOrEmpty(torznabQuery.SanitizedSearchTerm))
            {
                newItemCount = cacheService.GetNewItemCount(indexer, filteredReleases);
                cacheService.CacheRssResults(indexer, releases);
            }

            // Log info
            var logBuilder = new StringBuilder();
            if (newItemCount != null)
            {
                logBuilder.AppendFormat(string.Format("Found {0} ({1} new) releases from {2}", releases.Count(), newItemCount, indexer.DisplayName));
            }
            else
            {
                logBuilder.AppendFormat(string.Format("Found {0} releases from {1}", releases.Count(), indexer.DisplayName));
            }

            if (!string.IsNullOrWhiteSpace(torznabQuery.SanitizedSearchTerm))
            {
                logBuilder.AppendFormat(" for: {0}", torznabQuery.GetQueryString());
            }

            logger.Info(logBuilder.ToString());

            var serverUrl  = string.Format("{0}://{1}:{2}{3}", Request.RequestUri.Scheme, Request.RequestUri.Host, Request.RequestUri.Port, serverService.BasePath());
            var resultPage = new ResultPage(new ChannelInfo
            {
                Title            = indexer.DisplayName,
                Description      = indexer.DisplayDescription,
                Link             = new Uri(indexer.SiteLink),
                ImageUrl         = new Uri(serverUrl + "logos/" + indexer.ID + ".png"),
                ImageTitle       = indexer.DisplayName,
                ImageLink        = new Uri(indexer.SiteLink),
                ImageDescription = indexer.DisplayName
            });


            foreach (var result in releases)
            {
                var clone = Mapper.Map <ReleaseInfo>(result);
                clone.Link = serverService.ConvertToProxyLink(clone.Link, serverUrl, indexerID, "dl", result.Title + ".torrent");
                resultPage.Releases.Add(clone);
            }

            var xml = resultPage.ToXml(new Uri(serverUrl));
            // Force the return as XML
            return(new HttpResponseMessage()
            {
                Content = new StringContent(xml, Encoding.UTF8, "application/rss+xml")
            });
        }
Example #23
0
 public void WhenSearchFor(string term)
 {
     home_page.search_product(term);
     result_page = new ResultPage(driver);
 }
Example #24
0
        public string FlightResultDuration()
        {
            ResultPage resultPage = new ResultPage();

            return(resultPage.FlightDuration());
        }
Example #25
0
        public string FlightNotFoundError()
        {
            ResultPage resultPage = new ResultPage();

            return(resultPage.FlighNotFoundError());
        }
Example #26
0
        void HandleScanResult(ZXing.Result result)
        {
            string msg = "";

            alert.AddButton("OK");
            System.Diagnostics.Debug.WriteLine("Đợi Ktra kết quả");
            if (result != null && !string.IsNullOrEmpty(result.Text))
            {
                string message = result.Text;
                System.Diagnostics.Debug.WriteLine("bắt đầu ktra");
                bool checkresult = Uri.TryCreate(message, UriKind.Absolute, out Uri uriResult) && (uriResult.Scheme == Uri.UriSchemeHttp || uriResult.Scheme == Uri.UriSchemeHttps);
                if (checkresult)
                {
                    System.Diagnostics.Debug.WriteLine("đây là URL");
                    if (message.Contains("ezcheck") == true)
                    {
                        string[] splitlink;
                        splitlink = message.Split(new string[] { "/" }, StringSplitOptions.None);
                        System.Diagnostics.Debug.WriteLine("đây là url ezcheck");
                        string itemcode   = splitlink[splitlink.Length - 1];
                        bool   isNumberic = long.TryParse(itemcode, out long itemcodenum);
                        if (isNumberic)
                        {
                            msg = "Tìm thấy mã sản phẩm: " + itemcode;
                            System.Diagnostics.Debug.WriteLine("bắt đầu đẩy");
                            alert.Message = msg;
                            alert.Show();
                            var newResultPage = new ResultPage(itemcode);
                            Xamarin.Forms.Application.Current.MainPage.Navigation.PushAsync(newResultPage);
                        }
                        else
                        {
                            msg = "Tìm thấy URL: " + message;
                            if (itemcode[0].ToString().Equals("B"))
                            {
                                Xamarin.Forms.Application.Current.MainPage.Navigation.PushAsync(new ResultPage(itemcode));
                            }
                            else
                            {
                                System.Diagnostics.Debug.WriteLine("đây URL ezcheck thuần");
                                Device.OpenUri(new Uri(message));
                            }
                            alert.Message = msg;
                            alert.Show();
                        }
                    }
                    else
                    {
                        msg           = "Tìm thấy URL: " + message;
                        alert.Message = msg;
                        alert.Show();
                    }
                }
                else
                {
                    msg           = "Tìm thấy nội dung: " + message;
                    alert.Message = msg;
                    alert.Show();
                }
            }

            else
            {
                msg = "Scanning Canceled!";
            }
        }
Example #27
0
        public static Page GetPage(ApplicationPages page)
        {
            Page result = null;

            using (_pageLocker.GetUpgradeableReadLock())
            {
                if (!_pages.ContainsKey(page))
                {
                    using (_pageLocker.GetWriteLock())
                    {
                        if (!_pages.ContainsKey(page))
                        {
                            switch (page)
                            {
                                case ApplicationPages.UserFormPage:
                                    _pages[page] = (result = new UserFormPage {DataContext = new UserFormViewModel()});
                                    break;
                                case ApplicationPages.IssuePage:
                                    _pages[page] = (result = new IssuePage {DataContext = new IssueViewModel()});
                                    break;
                                case ApplicationPages.TimeOverPage:
                                    _pages[page] = (result = new TimeOverPage());
                                    break;
                                case ApplicationPages.ResultPage:
                                    _pages[page] = (result = new ResultPage {DataContext = new ResultViewModel()});
                                    break;
                            }
                        }
                    }
                }
                else
                    result = _pages[page];
            }

            return result;
        }
Example #28
0
        public async Task <IActionResult> Torznab([FromQuery] TorznabRequest request)
        {
            if (string.Equals(CurrentQuery.QueryType, "caps", StringComparison.InvariantCultureIgnoreCase))
            {
                return(Content(CurrentIndexer.TorznabCaps.ToXml(), "application/rss+xml", Encoding.UTF8));
            }

            // indexers - returns a list of all included indexers (meta indexers only)
            if (string.Equals(CurrentQuery.QueryType, "indexers", StringComparison.InvariantCultureIgnoreCase))
            {
                if (!(CurrentIndexer is BaseMetaIndexer)) // shouldn't be needed because CanHandleQuery should return false
                {
                    logger.Warn($"A search request with t=indexers from {Request.HttpContext.Connection.RemoteIpAddress} was made but the indexer {CurrentIndexer.DisplayName} isn't a meta indexer.");
                    return(GetErrorXML(203, "Function Not Available: this isn't a meta indexer"));
                }
                var CurrentBaseMetaIndexer = (BaseMetaIndexer)CurrentIndexer;
                var indexers = CurrentBaseMetaIndexer.Indexers;
                if (string.Equals(request.configured, "true", StringComparison.InvariantCultureIgnoreCase))
                {
                    indexers = indexers.Where(i => i.IsConfigured);
                }
                else if (string.Equals(request.configured, "false", StringComparison.InvariantCultureIgnoreCase))
                {
                    indexers = indexers.Where(i => !i.IsConfigured);
                }

                var xdoc = new XDocument(
                    new XDeclaration("1.0", "UTF-8", null),
                    new XElement("indexers",
                                 from i in indexers
                                 select new XElement("indexer",
                                                     new XAttribute("id", i.ID),
                                                     new XAttribute("configured", i.IsConfigured),
                                                     new XElement("title", i.DisplayName),
                                                     new XElement("description", i.DisplayDescription),
                                                     new XElement("link", i.SiteLink),
                                                     new XElement("language", i.Language),
                                                     new XElement("type", i.Type),
                                                     i.TorznabCaps.GetXDocument().FirstNode
                                                     )
                                 )
                    );

                return(Content(xdoc.Declaration.ToString() + Environment.NewLine + xdoc.ToString(), "application/xml", Encoding.UTF8));
            }

            if (CurrentQuery.ImdbID != null)
            {
                if (!string.IsNullOrEmpty(CurrentQuery.SearchTerm))
                {
                    logger.Warn($"A search request from {Request.HttpContext.Connection.RemoteIpAddress} was made containing q and imdbid.");
                    return(GetErrorXML(201, "Incorrect parameter: please specify either imdbid or q"));
                }

                CurrentQuery.ImdbID = ParseUtil.GetFullImdbID(CurrentQuery.ImdbID); // normalize ImdbID
                if (CurrentQuery.ImdbID == null)
                {
                    logger.Warn($"A search request from {Request.HttpContext.Connection.RemoteIpAddress} was made with an invalid imdbid.");
                    return(GetErrorXML(201, "Incorrect parameter: invalid imdbid format"));
                }

                if (!CurrentIndexer.TorznabCaps.SupportsImdbSearch)
                {
                    logger.Warn($"A search request with imdbid from {Request.HttpContext.Connection.RemoteIpAddress} was made but the indexer {CurrentIndexer.DisplayName} doesn't support it.");
                    return(GetErrorXML(203, "Function Not Available: imdbid is not supported by this indexer"));
                }
            }

            try
            {
                var result = await CurrentIndexer.ResultsForQuery(CurrentQuery);

                // Some trackers do not support multiple category filtering so filter the releases that match manually.
                int?newItemCount = null;

                // Cache non query results
                if (string.IsNullOrEmpty(CurrentQuery.SanitizedSearchTerm))
                {
                    newItemCount = cacheService.GetNewItemCount(CurrentIndexer, result.Releases);
                    cacheService.CacheRssResults(CurrentIndexer, result.Releases);
                }

                // Log info
                var logBuilder = new StringBuilder();
                if (newItemCount != null)
                {
                    logBuilder.AppendFormat("Found {0} ({1} new) releases from {2}", result.Releases.Count(), newItemCount, CurrentIndexer.DisplayName);
                }
                else
                {
                    logBuilder.AppendFormat("Found {0} releases from {1}", result.Releases.Count(), CurrentIndexer.DisplayName);
                }

                if (!string.IsNullOrWhiteSpace(CurrentQuery.SanitizedSearchTerm))
                {
                    logBuilder.AppendFormat(" for: {0}", CurrentQuery.GetQueryString());
                }

                logger.Info(logBuilder.ToString());

                var serverUrl  = serverService.GetServerUrl(Request);
                var resultPage = new ResultPage(new ChannelInfo
                {
                    Title            = CurrentIndexer.DisplayName,
                    Description      = CurrentIndexer.DisplayDescription,
                    Link             = new Uri(CurrentIndexer.SiteLink),
                    ImageUrl         = new Uri(serverUrl + "logos/" + CurrentIndexer.ID + ".png"),
                    ImageTitle       = CurrentIndexer.DisplayName,
                    ImageLink        = new Uri(CurrentIndexer.SiteLink),
                    ImageDescription = CurrentIndexer.DisplayName
                });

                var proxiedReleases = result.Releases.Select(r => AutoMapper.Mapper.Map <ReleaseInfo>(r)).Select(r =>
                {
                    r.Link = serverService.ConvertToProxyLink(r.Link, serverUrl, r.Origin.ID, "dl", r.Title);
                    return(r);
                });

                resultPage.Releases = proxiedReleases.ToList();

                var xml = resultPage.ToXml(new Uri(serverUrl));
                // Force the return as XML

                return(Content(xml, "application/rss+xml", Encoding.UTF8));
            }
            catch (Exception ex)
            {
                logger.Error(ex);
                return(GetErrorXML(900, ex.ToString()));
            }
        }
 public void WhenIClickOnSubmitButton()
 {
     resultPage = amazonHomePage.ClickOnButton();
 }
 private SearchIndexQueryResultDrop[] GetResults()
 {
     return(ResultPage.Select(e => new SearchIndexQueryResultDrop(this, e)).ToArray());
 }
Example #31
0
        public void FindCars(string brand, string model)
        {
            var mainPage = new MainPage();

            _resultPage = mainPage.FilterCars(brand, model);
        }
Example #32
0
        public FlightDepartureCheck()
        {
            ResultPage resultPage = new ResultPage();

            return(resultPage.DepartureFlightText());
        }
        protected void RegisterFilter()
        {
            Handle.AddFilterToMiddleware((request) => {
                if (request.Uri.StartsWith("/website/cms")) {
                    return null;
                }

                string[] parts = request.Uri.Split(new char[] { '/' });
                WebUrl webUrl = Db.SQL<WebUrl>("SELECT wu FROM Simplified.Ring6.WebUrl wu WHERE wu.Url = ?", request.Uri).First;

                if (webUrl == null) {
                    string wildCard = GetWildCardUrl(request.Uri);

                    webUrl = Db.SQL<WebUrl>("SELECT wu FROM Simplified.Ring6.WebUrl wu WHERE wu.Url = ?", wildCard).First;
                }

                WebTemplate template;

                if (webUrl != null) {
                    template = webUrl.Template;
                } else {
                    template = Db.SQL<WebTemplate>("SELECT wt FROM Simplified.Ring6.WebTemplate wt WHERE wt.Default = ?", true).First;
                }

                if (template == null) {
                    return null;
                }

                LayoutPage master = GetLayoutPage();

                if (master == null) {
                    return null;
                }

                ResultPage content = master.TemplateModel as ResultPage;

                if (content == null || master.TemplateName != template.Name) {
                    content = new ResultPage();

                    InitializeTemplate(request, template, content, parts, webUrl);

                    master.TemplateName = template.Name;
                    master.TemplateHtml = template.Html;
                    if(IsFullHtml(template.Html) == true) {
                        master.Html = template.Html;
                    }
                    master.TemplateModel = content;
                } else {
                    UpdateTemplate(request, template, content, parts, webUrl);
                }

                return master;
            });
        }
Example #34
0
        public string ChooseSpechialOffers()
        {
            ResultPage resultPage = new ResultPage();

            return(resultPage.FindSpechialOfferForFlight("lgw"));
        }
Example #35
0
        public async Task <IHttpActionResult> Torznab([FromUri] Models.DTO.TorznabRequest request)
        {
            if (string.Equals(CurrentQuery.QueryType, "caps", StringComparison.InvariantCultureIgnoreCase))
            {
                return(ResponseMessage(new HttpResponseMessage()
                {
                    Content = new StringContent(CurrentIndexer.TorznabCaps.ToXml(), Encoding.UTF8, "application/xml")
                }));
            }

            if (CurrentQuery.ImdbID != null)
            {
                if (CurrentQuery.QueryType != "movie")
                {
                    logger.Warn($"A non movie request with an imdbid was made from {Request.GetOwinContext().Request.RemoteIpAddress}.");
                    return(GetErrorXML(201, "Incorrect parameter: only movie-search supports the imdbid parameter"));
                }

                if (!string.IsNullOrEmpty(CurrentQuery.SearchTerm))
                {
                    logger.Warn($"A movie-search request from {Request.GetOwinContext().Request.RemoteIpAddress} was made contining q and imdbid.");
                    return(GetErrorXML(201, "Incorrect parameter: please specify either imdbid or q"));
                }

                CurrentQuery.ImdbID = ParseUtil.GetFullImdbID(CurrentQuery.ImdbID); // normalize ImdbID
                if (CurrentQuery.ImdbID == null)
                {
                    logger.Warn($"A movie-search request from {Request.GetOwinContext().Request.RemoteIpAddress} was made with an invalid imdbid.");
                    return(GetErrorXML(201, "Incorrect parameter: invalid imdbid format"));
                }

                if (!CurrentIndexer.TorznabCaps.SupportsImdbSearch)
                {
                    logger.Warn($"A movie-search request with imdbid from {Request.GetOwinContext().Request.RemoteIpAddress} was made but the indexer {CurrentIndexer.DisplayName} doesn't support it.");
                    return(GetErrorXML(203, "Function Not Available: imdbid is not supported by this indexer"));
                }
            }

            var result = await CurrentIndexer.ResultsForQuery(CurrentQuery);

            // Some trackers do not support multiple category filtering so filter the releases that match manually.
            int?newItemCount = null;

            // Cache non query results
            if (string.IsNullOrEmpty(CurrentQuery.SanitizedSearchTerm))
            {
                newItemCount = cacheService.GetNewItemCount(CurrentIndexer, result.Releases);
                cacheService.CacheRssResults(CurrentIndexer, result.Releases);
            }

            // Log info
            var logBuilder = new StringBuilder();

            if (newItemCount != null)
            {
                logBuilder.AppendFormat("Found {0} ({1} new) releases from {2}", result.Releases.Count(), newItemCount, CurrentIndexer.DisplayName);
            }
            else
            {
                logBuilder.AppendFormat("Found {0} releases from {1}", result.Releases.Count(), CurrentIndexer.DisplayName);
            }

            if (!string.IsNullOrWhiteSpace(CurrentQuery.SanitizedSearchTerm))
            {
                logBuilder.AppendFormat(" for: {0}", CurrentQuery.GetQueryString());
            }

            logger.Info(logBuilder.ToString());

            var serverUrl  = serverService.GetServerUrl(Request);
            var resultPage = new ResultPage(new ChannelInfo
            {
                Title            = CurrentIndexer.DisplayName,
                Description      = CurrentIndexer.DisplayDescription,
                Link             = new Uri(CurrentIndexer.SiteLink),
                ImageUrl         = new Uri(serverUrl + "logos/" + CurrentIndexer.ID + ".png"),
                ImageTitle       = CurrentIndexer.DisplayName,
                ImageLink        = new Uri(CurrentIndexer.SiteLink),
                ImageDescription = CurrentIndexer.DisplayName
            });

            var proxiedReleases = result.Releases.Select(r => AutoMapper.Mapper.Map <ReleaseInfo>(r)).Select(r =>
            {
                r.Link = serverService.ConvertToProxyLink(r.Link, serverUrl, r.Origin.ID, "dl", r.Title + ".torrent");
                return(r);
            });

            resultPage.Releases = proxiedReleases.ToList();

            var xml = resultPage.ToXml(new Uri(serverUrl));

            // Force the return as XML
            return(ResponseMessage(new HttpResponseMessage()
            {
                Content = new StringContent(xml, Encoding.UTF8, "application/rss+xml")
            }));
        }
        protected void UpdateTemplate(Request Request, WebTemplate Template, ResultPage Content, string[] UrlParts, WebUrl Url)
        {
            foreach (WebSection section in Template.Sections) {
                var sectionJson = Content.Sections.FirstOrDefault(x => x.Name == section.Name);
                var maps = section.Maps.Where(x => x.Url == null || x.Url.GetObjectID() == Url.GetObjectID()).OrderBy(x => x.SortNumber).ToList();
                int index = 0;

                if (sectionJson.Rows.Count == maps.Count) {
                    foreach (WebMap map in maps) {
                        string url = FormatUrl(map.ForeignUrl, UrlParts.Last());

                        if ((sectionJson.Rows[index] as ContainerPage).Key != url) {
                            sectionJson.Rows[index] = Self.GET<ContainerPage>(url, () => {
                                return new ContainerPage() {
                                    Key = url
                                };
                            });
                        }

                        index++;
                    }
                } else {
                    sectionJson.Rows.Clear();

                    foreach (WebMap map in maps) {
                        string url = FormatUrl(map.ForeignUrl, UrlParts.Last());

                        sectionJson.Rows.Add(Self.GET<ContainerPage>(url, () => {
                            return new ContainerPage() {
                                Key = url
                            };
                        }));

                        index++;
                    }
                }

                if (section.Default && Url == null && (sectionJson.Rows[index] as ContainerPage).Key != Request.Uri) {
                    sectionJson.Rows[index] = Self.GET<ContainerPage>(Request.Uri, () => {
                        return new ContainerPage() {
                            Key = Request.Uri
                        };
                    });
                }
            }
        }