public async Task OneMonthWithRangeTest()
        {
            var firstDate  = new DateTime(2019, 10, 1);
            var secondDate = new DateTime(2019, 10, 10);
            var workerId   = Guid.NewGuid();

            await workerScheduleRepository.WriteAsync(shopId, new[]
            {
                WorkerCalendarDayBuilder <WorkerScheduleRecord> .Create(workerId, firstDate)
                .AddRecord(defaultRecord)
                .Build(),
                WorkerCalendarDayBuilder <WorkerScheduleRecord> .Create(workerId, secondDate)
                .AddRecord(defaultRecord)
                .Build(),
                WorkerCalendarDayBuilder <WorkerScheduleRecord> .Create(workerId, secondDate.AddDays(2))
                .AddRecord(defaultRecord)
                .Build()
            });

            var shopCalendarRange = await workersSchedulesApiClient.Get(shopId, firstDate, secondDate);

            shopCalendarRange.ShopCalendarDays.Length.Should().Be(2);

            shopCalendarRange.Should().BeEquivalentTo(ShopCalendarRangeBuilder <WorkerScheduleRecord>
                                                      .Create(shopId, firstDate, secondDate)
                                                      .AddShopCalendarDay(firstDate,
                                                                          shopBuilder => shopBuilder.AddWorkerDay(workerId,
                                                                                                                  workerBuilder => workerBuilder.AddRecord(defaultRecord)))
                                                      .AddShopCalendarDay(secondDate,
                                                                          shopBuilder => shopBuilder.AddWorkerDay(workerId,
                                                                                                                  workerBuilder => workerBuilder.AddRecord(defaultRecord)))
                                                      .Build());
        }
        public async Task EmptyAndNonEmptyMonthRangeTest()
        {
            var firstDate  = new DateTime(2019, 10, 1);
            var secondDate = new DateTime(2019, 12, 1);
            var thirdDate  = new DateTime(2019, 12, 1);

            await workerScheduleRepository.WriteAsync(shopId, new[]
            {
                WorkerCalendarDayBuilder <T> .Create(workerId, thirdDate)
                .AddRecord(defaultRecord)
                .Build()
            });

            var shopCalendarRange = await workerScheduleRepository.ReadShopCalendarRangeAsync(shopId, firstDate, thirdDate);

            shopCalendarRange.ShopCalendarDays.Length.Should().Be(1);

            shopCalendarRange.Should().BeEquivalentTo(ShopCalendarRangeBuilder <T>
                                                      .Create(shopId, firstDate, thirdDate)
                                                      .AddShopCalendarDay(secondDate,
                                                                          shopBuilder => shopBuilder.AddWorkerDay(workerId,
                                                                                                                  workerBuilder => workerBuilder.AddRecord(defaultRecord)))
                                                      .Build());
        }
Exemplo n.º 3
0
        public void LinkServicesAndWorkersTest()
        {
            var products = new[]
            {
                new Product
                {
                    Id         = Guid.NewGuid(),
                    GroupId    = Guid.NewGuid().ToString(),
                    Name       = RandomStringGenerator.GenerateRandomCyrillic(20),
                    PricesInfo = new PriceInfo {
                        SellPrice = random.Next(100000) / 100m
                    },
                },
                new Product
                {
                    Id         = Guid.NewGuid(),
                    GroupId    = null,
                    Name       = RandomStringGenerator.GenerateRandomCyrillic(20),
                    PricesInfo = new PriceInfo {
                        SellPrice = random.Next(100000) / 100m
                    },
                },
            };

            var onlineServices = products.Select(x => new OnlineService {
                ProductId = x.Id.Value
            }).ToArray();

            var workers = new[]
            {
                new Worker
                {
                    Id                = Guid.NewGuid(),
                    FullName          = RandomStringGenerator.GenerateRandomCyrillic(50),
                    Position          = RandomStringGenerator.GenerateRandomCyrillic(50),
                    IsAvailableOnline = true,
                    IsDeleted         = false,
                },
                new Worker
                {
                    Id                = Guid.NewGuid(),
                    FullName          = RandomStringGenerator.GenerateRandomCyrillic(50),
                    Position          = RandomStringGenerator.GenerateRandomCyrillic(50),
                    IsAvailableOnline = true,
                    IsDeleted         = false,
                },
            };

            var workerSchedule =
                ShopCalendarRangeBuilder <WorkerScheduleRecord>
                .Create(Guid.Empty, 10.January(2019), 9.February(2019))
                .AddShopCalendarDay(10.January(2019),
                                    dayBuilder => dayBuilder
                                    .AddWorkerDay(workers[0].Id,
                                                  workerBuilder => workerBuilder
                                                  .AddRecord(new TimePeriod(8.Hours() + 30.Minutes(), 17.Hours())))
                                    .AddWorkerDay(workers[1].Id,
                                                  workerBuilder => workerBuilder
                                                  .AddRecord(new TimePeriod(8.Hours() + 30.Minutes(), 17.Hours()))))
                .Build();

            var info = recordingInfoConverter.CreateInfo(new Shop(),
                                                         onlineServices,
                                                         products,
                                                         workers,
                                                         workerSchedule,
                                                         new ShopCalendarRange <ServiceCalendarRecord>
            {
                StartDate        = 10.January(2019),
                EndDate          = 9.February(2019),
                ShopCalendarDays = new ShopCalendarDay <ServiceCalendarRecord> [0],
            },
                                                         10.January(2019));

            info.Services.Select(x => x.Workers).Should().AllBeEquivalentTo(workers.Select(x => x.Id).ToArray());
        }
Exemplo n.º 4
0
        public void WorkerInfoTest()
        {
            #region Arrange

            var workers = new[]
            {
                new Worker
                {
                    Id                = Guid.NewGuid(),
                    FullName          = RandomStringGenerator.GenerateRandomCyrillic(50),
                    Position          = RandomStringGenerator.GenerateRandomCyrillic(50),
                    IsAvailableOnline = true,
                    IsDeleted         = false,
                },
                new Worker
                {
                    Id                = Guid.NewGuid(),
                    FullName          = RandomStringGenerator.GenerateRandomCyrillic(50),
                    Position          = RandomStringGenerator.GenerateRandomCyrillic(50),
                    IsAvailableOnline = true,
                    IsDeleted         = false,
                },
                new Worker
                {
                    Id                = Guid.NewGuid(),
                    FullName          = RandomStringGenerator.GenerateRandomCyrillic(50),
                    Position          = RandomStringGenerator.GenerateRandomCyrillic(50),
                    IsAvailableOnline = true,
                    IsDeleted         = false,
                },
                new Worker
                {
                    Id                = Guid.NewGuid(),
                    FullName          = RandomStringGenerator.GenerateRandomCyrillic(50),
                    Position          = RandomStringGenerator.GenerateRandomCyrillic(50),
                    IsAvailableOnline = false,
                    IsDeleted         = false,
                },
                new Worker
                {
                    Id                = Guid.NewGuid(),
                    FullName          = RandomStringGenerator.GenerateRandomCyrillic(50),
                    Position          = RandomStringGenerator.GenerateRandomCyrillic(50),
                    IsAvailableOnline = true,
                    IsDeleted         = true,
                },
                new Worker
                {
                    Id                = Guid.NewGuid(),
                    FullName          = RandomStringGenerator.GenerateRandomCyrillic(50),
                    Position          = RandomStringGenerator.GenerateRandomCyrillic(50),
                    IsAvailableOnline = true,
                    IsDeleted         = false,
                },
            };

            var workerSchedule =
                ShopCalendarRangeBuilder <WorkerScheduleRecord>
                .Create(Guid.Empty, 10.January(2019), 9.February(2019))
                .AddShopCalendarDay(10.January(2019),
                                    dayBuilder => dayBuilder
                                    .AddWorkerDay(workers[0].Id,
                                                  workerBuilder => workerBuilder
                                                  .AddRecord(new TimePeriod(8.Hours() + 30.Minutes(), 17.Hours())))
                                    .AddWorkerDay(workers[1].Id,
                                                  workerBuilder => workerBuilder
                                                  .AddRecord(new TimePeriod(4.Hours() + 30.Minutes(), 8.Hours()))
                                                  .AddRecord(new TimePeriod(17.Hours() + 30.Minutes(), 22.Hours())))
                                    .AddWorkerDay(workers[5].Id,
                                                  workerBuilder => workerBuilder
                                                  .AddRecord(new TimePeriod(12.Hours(), 14.Hours()))))
                .AddShopCalendarDay(22.January(2019),
                                    dayBuilder => dayBuilder
                                    .AddWorkerDay(workers[0].Id,
                                                  workerBuilder => workerBuilder
                                                  .AddRecord(new TimePeriod(8.Hours() + 30.Minutes(), 17.Hours())))
                                    .AddWorkerDay(workers[3].Id,
                                                  workerBuilder => workerBuilder
                                                  .AddRecord(new TimePeriod(8.Hours() + 30.Minutes(), 17.Hours())))
                                    .AddWorkerDay(workers[4].Id,
                                                  workerBuilder => workerBuilder
                                                  .AddRecord(new TimePeriod(8.Hours() + 30.Minutes(), 17.Hours()))))
                .Build();

            var serviceCalendar =
                ShopCalendarRangeBuilder <ServiceCalendarRecord>
                .Create(Guid.Empty, 10.January(2019), 9.February(2019))
                .AddShopCalendarDay(10.January(2019),
                                    dayBuilder => dayBuilder
                                    .AddWorkerDay(workers[0].Id,
                                                  workerBuilder => workerBuilder
                                                  .AddRecord(Guid.NewGuid(), TimePeriod.CreateByHours(10, 11))
                                                  .AddRecord(Guid.NewGuid(), TimePeriod.CreateByHours(11, 12), r => r.WithRecordStatus(RecordStatus.Canceled))
                                                  .AddRecord(Guid.NewGuid(), new TimePeriod(13.Hours() + 15.Minutes(), 13.Hours() + 45.Minutes())))
                                    .AddWorkerDay(workers[2].Id,
                                                  workerBuilder => workerBuilder
                                                  .AddRecord(Guid.NewGuid(), TimePeriod.CreateByHours(10, 11)))
                                    .AddWorkerDay(workers[5].Id,
                                                  workerBuilder => workerBuilder
                                                  .AddRecord(Guid.NewGuid(), new TimePeriod(11.Hours(), 15.Hours()))))
                .AddShopCalendarDay(22.January(2019),
                                    dayBuilder => dayBuilder
                                    .AddWorkerDay(workers[0].Id,
                                                  workerBuilder => workerBuilder
                                                  .AddRecord(Guid.NewGuid(), TimePeriod.CreateByHours(8, 9))
                                                  .AddRecord(Guid.NewGuid(), new TimePeriod(16.Hours() + 30.Minutes(), 17.Hours() + 30.Minutes())))
                                    .AddWorkerDay(workers[3].Id,
                                                  workerBuilder => workerBuilder
                                                  .AddRecord(Guid.NewGuid(), TimePeriod.CreateByHours(10, 11)))
                                    .AddWorkerDay(workers[4].Id,
                                                  workerBuilder => workerBuilder
                                                  .AddRecord(Guid.NewGuid(), TimePeriod.CreateByHours(10, 11))))
                .Build();

            #endregion

            var info = recordingInfoConverter.CreateInfo(new Shop(),
                                                         new OnlineService[0],
                                                         new Product[0],
                                                         workers,
                                                         workerSchedule,
                                                         serviceCalendar,
                                                         10.January(2019));

            #region Assert

            info.Should().BeEquivalentTo(new RecordingInfoDto
            {
                Services = new ServiceDto[0],
                Workers  = new[]
                {
                    new WorkerDto
                    {
                        WorkerId = workers[0].Id,
                        Name     = workers[0].FullName,
                        Position = workers[0].Position,
                        Schedule = new[]
                        {
                            new WorkerCalendarRecordDto
                            {
                                Date          = 10.January(2019),
                                WorkingTime   = new[] { new TimePeriodDto(9.Hours(), 17.Hours()) },
                                AvailableTime = new[]
                                {
                                    new TimePeriodDto(9.Hours(), 10.Hours()),
                                    new TimePeriodDto(11.Hours(), 13.Hours()),
                                    new TimePeriodDto(14.Hours(), 17.Hours()),
                                }
                            },
                            new WorkerCalendarRecordDto
                            {
                                Date          = 22.January(2019),
                                WorkingTime   = new[] { new TimePeriodDto(9.Hours(), 17.Hours()) },
                                AvailableTime = new[] { new TimePeriodDto(9.Hours(), 16.Hours()) },
                            },
                        },
                    },
                    new WorkerDto
                    {
                        WorkerId = workers[1].Id,
                        Name     = workers[1].FullName,
                        Position = workers[1].Position,
                        Schedule = new[]
                        {
                            new WorkerCalendarRecordDto
                            {
                                Date        = 10.January(2019),
                                WorkingTime = new[]
                                {
                                    new TimePeriodDto(5.Hours(), 8.Hours()),
                                    new TimePeriodDto(18.Hours(), 22.Hours()),
                                },
                                AvailableTime = new[]
                                {
                                    new TimePeriodDto(5.Hours(), 8.Hours()),
                                    new TimePeriodDto(18.Hours(), 22.Hours()),
                                },
                            },
                        },
                    },
                    new WorkerDto
                    {
                        WorkerId = workers[5].Id,
                        Name     = workers[5].FullName,
                        Position = workers[5].Position,
                        Schedule = new[]
                        {
                            new WorkerCalendarRecordDto
                            {
                                Date          = 10.January(2019),
                                WorkingTime   = new[] { new TimePeriodDto(12.Hours(), 14.Hours()) },
                                AvailableTime = new TimePeriodDto[0],
                            },
                        }
                    },
                },
                Today = 10.January(2019),
            });

            #endregion
        }