コード例 #1
0
        public async Task ForwardReadsNextAsync()
        {
            var firstPageCount = 10;
            var nextPageCount  = 3;
            var logReader      = new PageReaderData()
            {
                Id    = Fixture.TestName,
                Count = firstPageCount
            };
            long pageTop    = PageReaderData.EOF;
            long pageBottom = (firstPageCount) * Fixture.TextLine(0).Length;

            Assert.True(Fixture.LineCount > firstPageCount + nextPageCount, "Not enough lines to perform test.");

            await PageReader.ReadFirstAsync(logReader);

            Assert.Equal(pageTop, logReader.PageTop);
            Assert.Equal(pageBottom, logReader.PageBottom);
            Assert.Equal(firstPageCount, logReader.Lines.Count());

            pageTop         = pageBottom;
            pageBottom      = (firstPageCount + nextPageCount) * Fixture.TextLine(0).Length;
            logReader.Count = nextPageCount;

            await PageReader.ReadNextAsync(logReader);

            Assert.Equal(pageTop, logReader.PageTop);
            Assert.Equal(pageBottom, logReader.PageBottom);
            Assert.Equal(nextPageCount, logReader.Lines.Count());
            for (var i = 0; i < nextPageCount; i++)
            {
                Assert.Equal(Fixture.Text(firstPageCount + i + 1), logReader.Lines.Skip(i).First());
            }
        }
コード例 #2
0
        public async Task ExportParticipantListToExcelAsync(Stream stream, IRegistrationExportService.Options options = null)
        {
            using var spreadsheetDocument = SpreadsheetDocument.Create(stream, SpreadsheetDocumentType.Workbook);

            var workbookPart = spreadsheetDocument.AddWorkbookPart();

            workbookPart.Workbook = new Workbook();

            var worksheetPart = workbookPart.AddNewPart <WorksheetPart>();
            var sheetData     = new SheetData();

            if (options?.ExportHeader == true)
            {
                WriteHeader(sheetData);
            }

            var reader = new PageReader <Registration>(async(offset, limit, token) =>
                                                       await _registrationRetrievalService.ListRegistrationsAsync(
                                                           new RegistrationListRequest
            {
                Offset     = offset,
                Limit      = limit,
                OrderBy    = RegistrationListOrder.RegistrationTime,
                Descending = true,
                Filter     = new RegistrationFilter
                {
                    EventInfoId = options?.EventInfoId
                }
            }, new RegistrationRetrievalOptions
            {
                IncludeUser      = true,
                IncludeEventInfo = true,
                IncludeOrders    = true,
                IncludeProducts  = true,
            }, token));

            while (await reader.HasMoreAsync())
            {
                foreach (var registration in await reader.ReadNextAsync())
                {
                    WriteRow(sheetData, registration);
                }
            }

            worksheetPart.Worksheet = new Worksheet(sheetData);

            // Add Sheets to the Workbook.
            var sheets = spreadsheetDocument.WorkbookPart.Workbook.AppendChild(new Sheets());

            // Append a new worksheet and associate it with the workbook.
            sheets.Append(new Sheet
            {
                Id      = spreadsheetDocument.WorkbookPart.GetIdOfPart(worksheetPart),
                SheetId = 1,
                Name    = "Participants"
            });

            workbookPart.Workbook.Save();
            spreadsheetDocument.Close();
        }
コード例 #3
0
        private async Task <EventSynchronizationResult> SyncAllRegistrationsAsync(IExternalSyncProviderService syncProviderService, EventInfo eventInfo,
                                                                                  CancellationToken cancellationToken)
        {
            var result = new EventSynchronizationResult(syncProviderService.Name);

            var reader = new PageReader <Registration>(async(offset, limit, token) =>
                                                       await _registrationRetrievalService.ListRegistrationsAsync(
                                                           new IRegistrationRetrievalService.Request
            {
                Offset             = offset,
                Limit              = limit,
                EventInfoId        = eventInfo?.EventInfoId,
                IncludingUser      = true,
                IncludingEventInfo = true,
                VerifiedOnly       = true,
                OrderBy            = IRegistrationRetrievalService.Order.RegistrationTime
            }, token));

            while (await reader.HasMoreAsync(cancellationToken))
            {
                foreach (var registration in await reader.ReadNextAsync(cancellationToken))
                {
                    var externalAccount = await CreateExternalAccountIfNotExists(syncProviderService, registration, result);

                    if (externalAccount != null)
                    {
                        await SyncRegistrationAsync(syncProviderService, registration, externalAccount, result);
                    }
                }
            }

            return(result);
        }
コード例 #4
0
        public async Task ForwardReadsPrevAsync()
        {
            var lastPageCount = 10;
            var prevPageCount = 3;
            var logReader     = new PageReaderData()
            {
                Id    = Fixture.TestName,
                Count = lastPageCount
            };
            long pageTop    = (Fixture.LineCount - lastPageCount) * Fixture.TextLine(0).Length;
            long pageBottom = PageReaderData.EOF;

            Assert.True(Fixture.LineCount > lastPageCount, "Not enough lines to perform test.");

            await PageReader.ReadLastAsync(logReader);

            Assert.Equal(pageTop, logReader.PageTop);
            Assert.Equal(pageBottom, logReader.PageBottom);
            Assert.Equal(lastPageCount, logReader.Lines.Count());

            pageBottom      = pageTop;
            pageTop         = (Fixture.LineCount - lastPageCount - prevPageCount) * Fixture.TextLine(0).Length;
            logReader.Count = prevPageCount;

            await PageReader.ReadPrevAsync(logReader);

            Assert.Equal(pageTop, logReader.PageTop);
            Assert.Equal(pageBottom, logReader.PageBottom);
            Assert.Equal(prevPageCount, logReader.Lines.Count());
            for (var i = 0; i < prevPageCount; i++)
            {
                Assert.Equal(Fixture.Text(lastPageCount + prevPageCount + i), logReader.Lines.Skip(i).First());
            }
        }
コード例 #5
0
        private async Task <AllocationMapPage> GetAllocationPage(int databaseId, PageAddress addresss)
        {
            var page = await PageReader.Read(databaseId, addresss);

            var result = new AllocationMapParser().Parse(page);

            return(result);
        }
コード例 #6
0
 public async Task <ActionResult> Forward(string id)
 {
     return(List(await PageReader.ReadFirstAsync(new PageReaderData()
     {
         Id = id,
         Count = CountOptions[0]
     })));
 }
コード例 #7
0
        public async Task <ActionResult> Index()
        {
            var fileList = await PageReader.GetFilesAsync();

            var model = fileList.Select(file => new LogFileListModel(file));

            return(View(model));
        }
コード例 #8
0
ファイル: Page.cs プロジェクト: imzjy/internals-viewer
        /// <summary>
        /// Create a Page with a supplied PageReader
        /// </summary>
        public Page(PageReader reader)
        {
            this.reader = reader;

            LoadPage();

            PageAddress = reader.Header.PageAddress;
        }
コード例 #9
0
        public void ListsFiles()
        {
            var fileList = PageReader.GetFiles();

            Assert.Single(fileList);

            Assert.Equal(Fixture.TestName, fileList.First().Name);
            Assert.Equal(Fixture.FileLength, fileList.First().Length);
        }
コード例 #10
0
        public async Task ListsFilesAsync()
        {
            var fileList = await PageReader.GetFilesAsync();

            Assert.Single(fileList);

            Assert.Equal(Fixture.TestName, fileList.First().Name);
            Assert.Equal(Fixture.FileLength, fileList.First().Length);
        }
コード例 #11
0
        private async Task <List <NotificationRecipient> > GetRecipientsAsync(
            NotificationType notificationType,
            int eventId,
            int?productId,
            Registration.RegistrationStatus[] registrationStatuses,
            Registration.RegistrationType[] registrationTypes)
        {
            var recipients = new List <NotificationRecipient>();

            // Default status if not provided: Verified, attended and finished
            registrationStatuses ??= new[]
            {
                Registration.RegistrationStatus.Verified,
                Registration.RegistrationStatus.Attended,
                Registration.RegistrationStatus.Finished
            };

            // Default registration type is participants
            registrationTypes ??= new[]
            {
                Registration.RegistrationType.Participant
            };

            var reader = new PageReader <Registration>(async(offset, limit, token) =>
                                                       await _registrationRetrievalService.ListRegistrationsAsync(
                                                           new RegistrationListRequest
            {
                Limit  = limit,
                Offset = offset,
                Filter = new RegistrationFilter
                {
                    EventInfoId = eventId,
                    ProductIds  = productId.HasValue
                                ? new[] { productId.Value }
                                : null,
                    ActiveUsersOnly = true,
                    HavingStatuses  = registrationStatuses,
                    HavingTypes     = registrationTypes
                }
            },
                                                           new RegistrationRetrievalOptions
            {
                LoadUser  = true,
                ForUpdate = true
            }, token));

            while (await reader.HasMoreAsync())
            {
                recipients.AddRange((from registration in await reader
                                     .ReadNextAsync()
                                     select NotificationRecipient.Create(registration, notificationType))
                                    .Where(r => r != null)); // user may have no phone, or email
            }

            return(recipients);
        }
コード例 #12
0
 static void Main(string[] args)
 {
     string path = @"D:\Wikipedia\jawiki-latest-pages-articles.xml";
     using (var reader = new PageReader(path))
     {
         foreach (var item in reader.Read())
         {
             Console.WriteLine(item.title);
         }
     }
 }
コード例 #13
0
        static void Main(string[] args)
        {
            string path = @"D:\Wikipedia\jawiki-latest-pages-articles.xml";

            using (var reader = new PageReader(path))
            {
                foreach (var item in reader.Read())
                {
                    Console.WriteLine(item.title);
                }
            }
        }
コード例 #14
0
 public static async Task <List <ApplicationUser> > ListUsersAsync(
     this IUserRetrievalService userRetrievalService)
 {
     return((await PageReader <ApplicationUser> .ReadAllAsync(
                 (offset, limit, token) => userRetrievalService
                 .ListUsers(new UserListRequest
     {
         Limit = limit,
         Offset = offset
     }, UserRetrievalOptions.Default, token)))
            .ToList());
 }
コード例 #15
0
 public static async Task <List <EventInfo> > GetPastEventsAsync(
     this IEventInfoRetrievalService service,
     EventInfoFilter filter              = null,
     EventInfoRetrievalOptions options   = null,
     CancellationToken cancellationToken = default)
 {
     return((await PageReader <EventInfo> .ReadAllAsync((offset, limit, token) =>
                                                        service.ListEventsAsync(new EventListRequest(offset, limit)
     {
         Filter = EventInfoFilter.PastEvents(filter)
     }, options, token), cancellationToken))
            .ToList());
 }
コード例 #16
0
ファイル: Page.cs プロジェクト: imzjy/internals-viewer
        public Page(string connectionString, string database, PageAddress pageAddress)
        {
            PageAddress = pageAddress;

            DatabaseId = GetDatabaseId(connectionString, database);

            var compatabilityLevel = Database.GetCompatabilityLevel(connectionString, database);

            Database = new Database(connectionString, DatabaseId, database, 1, compatabilityLevel);

            reader = new DatabasePageReader(connectionString, PageAddress, DatabaseId);

            LoadPage();
        }
コード例 #17
0
ファイル: Page.cs プロジェクト: imzjy/internals-viewer
        /// <summary>
        /// Create a Page with a DatabasePageReader
        /// </summary>
        public Page(Database database, PageAddress pageAddress)
        {
            PageAddress = pageAddress;
            Database    = database;
            DatabaseId  = database.DatabaseId;

            if (pageAddress.FileId == 0)
            {
                return;
            }

            reader = new DatabasePageReader(Database.ConnectionString, PageAddress, DatabaseId);

            LoadPage();
        }
コード例 #18
0
        public void DoTheJob()
        {
            try
            {
                string page = PageReader.ReadPage(url, true);

                int resultsStart = page.IndexOf("Search Results", StringComparison.InvariantCulture);
                if (resultsStart != -1)
                {
                    page = page.Substring(resultsStart);
                }

                Regex           rex   = new Regex(@"<a.*?href=.*?</\s*a>", RegexOptions.IgnoreCase | RegexOptions.Singleline);
                MatchCollection coll  = rex.Matches(page);
                int             total = coll.Count;
                if (total > 0)
                {
                    for (int i = 0; i < coll.Count; i++)
                    {
                        if (coll[i].Value.Contains(searchFor))
                        {
                            string description = Regex.Replace(coll[i].Value, "(<.*?>)|(;.*?&)|(&.*?;)", "", RegexOptions.IgnoreCase | RegexOptions.Singleline);
                            Positions.Add(new KeyValuePair <int, string>(i + 1, description));
                        }
                    }

                    double normalizer = 2.5;
                    double newOne     = (double)total / (double)resultsPerPage;
                    if (newOne > normalizer)
                    {
                        normalizer = newOne;
                    }

                    for (int i = 0; i < Positions.Count; i++)
                    {
                        Positions[i] = new KeyValuePair <int, string>((int)(Math.Round((double)Positions[i].Key / normalizer, 0)), Positions[i].Value);
                        if (Positions[i].Key == 0)
                        {
                            Positions[i] = new KeyValuePair <int, string>(Positions[i].Key + 1, Positions[i].Value);
                        }
                    }
                }
            }
            catch (Exception e)
            {
                this.Error = e.Message;
            }
        }
コード例 #19
0
        public void ForwardReadsLast()
        {
            var count     = 3;
            var logReader = new PageReaderData()
            {
                Id    = Fixture.TestName,
                Count = count
            };
            long pageTop    = (Fixture.LineCount - count) * Fixture.TextLine(0).Length;
            long pageBottom = PageReaderData.EOF;

            Assert.True(Fixture.LineCount > logReader.Count, "Not enough lines to perform test.");

            PageReader.ReadLast(logReader);

            Assert.Equal(pageTop, logReader.PageTop);
            Assert.Equal(pageBottom, logReader.PageBottom);
            Assert.Equal(count, logReader.Lines.Count());
            for (var i = 0; i < count; i++)
            {
                Assert.Equal(Fixture.Text(Fixture.LineCount - count + i + 1), logReader.Lines.Skip(i).First());
            }
        }
コード例 #20
0
 public void Initialize(IProvider linkage, IProvider command)
 {
     _loader = new PageLoader(command.Get <WorkerPool>(), command.Get <Book>());
     _reader = new PageReader();
 }
コード例 #21
0
 public async Task <ActionResult> ForwardPrev(PageReaderData logReader)
 {
     return(List(await PageReader.ReadPrevAsync(logReader)));
 }
コード例 #22
0
        public async Task <ActionResult <NotificationResponseDto> > SendEmail(EmailNotificationDto dto, CancellationToken cancellationToken)
        {
            var email = new EmailNotification
            {
                Subject      = dto.Subject,
                BodyMarkdown = dto.BodyMarkdown
            };

            if (dto.Recipients?.Any() != true && dto.Filter?.IsDefined != true)
            {
                return(BadRequest("Either recipient list of registrant filter must be specified"));
            }

            var recipients = dto.Recipients ?? Array.Empty <string>();

            if (dto.Filter?.IsDefined == true)
            {
                var reader = new PageReader <Registration>(async(offset, limit, token) =>
                                                           await _registrationRetrievalService.ListRegistrationsAsync(
                                                               new RegistrationListRequest
                {
                    Limit  = limit,
                    Offset = offset,
                    Filter = new RegistrationFilter
                    {
                        EventInfoId              = dto.Filter.EventId,
                        AccessibleOnly           = true,
                        ActiveUsersOnly          = true,
                        HavingEmailConfirmedOnly = true,
                        HavingStatuses           = dto.Filter.RegistrationStatuses,
                        HavingTypes              = dto.Filter.RegistrationTypes
                    }
                },
                                                               new RegistrationRetrievalOptions
                {
                    IncludeUser = true
                }, token));

                var recipientList = new List <string>();

                while (await reader.HasMoreAsync(cancellationToken))
                {
                    recipientList.AddRange(from registration in await reader
                                           .ReadNextAsync(cancellationToken)
                                           let userName = registration.User?.Name
                                                          let userEmail = registration.User?.Email
                                                                          where !string.IsNullOrEmpty(userEmail)
                                                                          select $"{userName} <{userEmail}>");
                }

                recipients = recipientList
                             .Distinct()
                             .ToArray();
            }

            if (recipients.Any())
            {
                await _emailNotificationService.SendEmailToRecipientsAsync(email, recipients, cancellationToken);
            }
            else
            {
                _logger.LogWarning("No recipients were selected by the notification filter criteria");
            }

            return(Ok(new NotificationResponseDto
            {
                TotalRecipients = recipients.Length
            }));
        }
コード例 #23
0
 public void PageReaderWithEmptyXmlReader()
 {
     var reader = new PageReader(reader: null);
 }
コード例 #24
0
 public void PageReaderWithEmptyPath()
 {
     var reader = new PageReader(path: "");
 }