Beispiel #1
0
        public async Task GetReportsShouldGetOne()
        {
            var options = new DbContextOptionsBuilder <ApplicationDbContext>()
                          .UseInMemoryDatabase(Guid.NewGuid().ToString());
            var context = new ApplicationDbContext(options.Options);

            var guideRepository = new EfDeletableEntityRepository <Guide>(context);
            var guideService    = new GuidesService(guideRepository);
            var guideModel      = new CreateGuideInputModel()
            {
                Category    = "Action",
                Description = "someDesc",
                GameId      = "1",
                ImageUrl    = "google",
                Title       = "test",
            };
            var guideId = await guideService.CreateAsync(guideModel, "1");

            var repository = new EfRepository <Report>(context);
            var service    = new ReportsService(repository);
            var model      = new AddReportToGuideInputModel()
            {
                UserId  = "1",
                GuideId = guideId,
                Reason  = "tupooooo",
            };
            await service.AddReportToGuideAsync(model);

            var actual = await service.GetByGuideAsync <ReportForGuideViewModel>(model.GuideId);

            Assert.Single(actual);
        }
Beispiel #2
0
        public async Task <IActionResult> Create(CreateGuideInputModel model, IFormFile file)
        {
            var games = await this.gamesService.GetAll <GamesDropDownViewModel>();

            var user = await this.userManager.GetUserAsync(this.User);

            var userId = await this.userManager.GetUserIdAsync(user);

            var imageUrl = await this.cloudinaryHelper.UploadGuideImageAsync(this.cloudinary, file);

            model.ImageUrl = imageUrl;
            model.UserId   = userId;
            model.Games    = games;
            if (!this.ModelState.IsValid || string.IsNullOrWhiteSpace(userId) || file == null)
            {
                return(this.View(model));
            }

            if (!Enum.TryParse(typeof(CategoryOfGuide), model.Category, out _))
            {
                return(this.View(model));
            }

            if (!games.Select(x => x.Id).Contains(model.GameId))
            {
                return(this.View(model));
            }

            var guideId = await this.guidesService.CreateAsync(model, userId);

            return(this.RedirectToAction("Details", new { id = guideId }));
        }
        public async Task SearchGuideShouldFindOneByTitle()
        {
            var options = new DbContextOptionsBuilder <ApplicationDbContext>()
                          .UseInMemoryDatabase(Guid.NewGuid().ToString());
            var context = new ApplicationDbContext(options.Options);
            await context.Users.AddAsync(new ApplicationUser()
            {
                Id = "2"
            });

            await context.Games.AddAsync(new Game()
            {
                Id = "1"
            });

            var postRepository   = new EfDeletableEntityRepository <Post>(context);
            var guideRepository  = new EfDeletableEntityRepository <Guide>(context);
            var searchBarService = new SearchBarService(postRepository, guideRepository);

            var guideService = new GuidesService(guideRepository);
            var guideModel   = new CreateGuideInputModel()
            {
                Title       = "testtesttest",
                Category    = "Action",
                Description = "sssss",
                GameId      = "1",
                ImageUrl    = "test",
            };

            await guideService.CreateAsync(guideModel, "2");

            var actual = await searchBarService.SearchGuide <GuideViewModel>("test", 5, 0);

            Assert.Single(actual);
        }
Beispiel #4
0
        public async Task GetLatestShouldReturnModel()
        {
            var options = new DbContextOptionsBuilder <ApplicationDbContext>()
                          .UseInMemoryDatabase(Guid.NewGuid().ToString());
            var context = new ApplicationDbContext(options.Options);
            await context.Users.AddAsync(new ApplicationUser()
            {
                Id = "1"
            });

            await context.Games.AddAsync(new Game()
            {
                Id = "1"
            });

            var repository = new EfDeletableEntityRepository <Guide>(context);
            var service    = new GuidesService(repository);
            var model      = new CreateGuideInputModel()
            {
                Title       = "new",
                GameId      = "1",
                Category    = "Action",
                Description = "test",
                ImageUrl    = "google",
            };
            await service.CreateAsync(model, "1");

            var actual = await service.TakeLatestGuideAsync <LatestGuideViewModel>();

            Assert.IsType <LatestGuideViewModel>(actual);
        }
Beispiel #5
0
        public async Task <IActionResult> Create()
        {
            var games = await this.gamesService.GetAll <GamesDropDownViewModel>();

            var model = new CreateGuideInputModel()
            {
                Games = games
            };

            return(this.View(model));
        }
Beispiel #6
0
        public async Task EditGuideShouldEditContent()
        {
            var options = new DbContextOptionsBuilder <ApplicationDbContext>()
                          .UseInMemoryDatabase(Guid.NewGuid().ToString());
            var context = new ApplicationDbContext(options.Options);
            await context.Users.AddAsync(new ApplicationUser()
            {
                Id = "1"
            });

            await context.Games.AddAsync(new Game()
            {
                Id = "1"
            });

            var repository = new EfDeletableEntityRepository <Guide>(context);
            var service    = new GuidesService(repository);
            var model      = new CreateGuideInputModel()
            {
                Title       = "new",
                GameId      = "1",
                Category    = "Action",
                Description = "test",
                ImageUrl    = "google",
            };

            var guideId = await service.CreateAsync(model, "1");

            var oldGuide = await service.GetByIdAsync <EditGuideViewModel>(guideId);

            var contentOldValue = oldGuide.Content;

            await service.EditGuideAsync(oldGuide.Id, oldGuide.Title, "newwwwwwwwwwwwwwwwwwwwwwwwwwwww");

            var newGuide = await service.GetByIdAsync <EditGuideViewModel>(guideId);

            Assert.NotEqual(contentOldValue, newGuide.Title);
        }
Beispiel #7
0
        public async Task AddOnGuideShouldAdd()
        {
            var options = new DbContextOptionsBuilder <ApplicationDbContext>()
                          .UseInMemoryDatabase(Guid.NewGuid().ToString());
            var context = new ApplicationDbContext(options.Options);

            var repository = new EfDeletableEntityRepository <Guide>(context);
            var service    = new GuidesService(repository);
            var model      = new CreateGuideInputModel()
            {
                Title       = "test",
                Category    = "Action",
                Description = "test",
                GameId      = "1",
                ImageUrl    = "test",
            };

            await service.CreateAsync(model, "1");

            var actual = await service.GetAllCountAsync();

            Assert.Equal(1, actual);
        }
Beispiel #8
0
        public async Task <CreateGuideResponseViewModel> GuideAdd([FromBody] CreateGuideInputModel model)
        {
            try
            {
                var data = await _sessionProvider.Get();

                //sample API call
                var createGuideCommandResult = await _commandSender.Send <Contracts.Commands.Redemption.GuideDetailsCommand, Contracts.Commands.Redemption.GuideDetailsCommandResult>(new Contracts.Commands.Redemption.GuideDetailsCommand
                {
                    AccountNumber    = model.AccountNumber,
                    AddressLineOne   = model.AddressLineOne,
                    AddressLineTwo   = model.AddressLineTwo,
                    CityId           = model.ResidentCityId,
                    ZipCode          = model.Zip,
                    AddressProofType = "AddressProofType",
                    BankName         = model.BankName,
                    BranchName       = model.BranchCode,
                    CountryCode      = model.PhoneCode,
                    CurrencyId       = model.CurrencyId,
                    EmailId          = model.Email,
                    EventIDs         = model.EventIDs,
                    FirstName        = model.FirstName,
                    IPAddress        = "IPAddress",
                    LanguageIds      = model.LanguageId,
                    LastName         = model.LastName,
                    MobileNo         = model.PhoneNumber,
                    Notes            = model.ServiceNotes,
                    ModifiedBy       = data.IsAuthenticated ? data.User.AltId : new Guid("A101F398-2FFE-47A2-82AE-11A9220C06F4"),
                    Services         = model.Services,
                    State            = model.FinanceStateId,
                    SwiftCode        = model.BranchCode,
                    TaxCountry       = model.FinanceCountryAltId,
                    TaxNumber        = model.TaxId,
                    Url             = "Url",
                    VenueID         = 1,
                    RoutingNumber   = model.RoutingNumber,
                    BankAccountType = model.BankAccountType,
                    AccountType     = model.AccountType,
                    Document        = model.Document
                });

                if (createGuideCommandResult.Success)
                {
                    return(new CreateGuideResponseViewModel
                    {
                        Success = true,
                        IsSaving = true,
                    });
                }
                else
                {
                    return(new CreateGuideResponseViewModel
                    {
                        Success = false,
                        IsSaving = false
                    });
                }
            }
            catch (Exception e)
            {
                _logger.Log(LogCategory.Error, e);
                return(new CreateGuideResponseViewModel {
                });
            }
        }
Beispiel #9
0
        public async Task GetCountBySearchShouldGetFour()
        {
            var options = new DbContextOptionsBuilder <ApplicationDbContext>()
                          .UseInMemoryDatabase(Guid.NewGuid().ToString());
            var context = new ApplicationDbContext(options.Options);
            await context.Users.AddAsync(new ApplicationUser()
            {
                Id = "1"
            });

            await context.Games.AddAsync(new Game()
            {
                Id = "1"
            });

            var repository = new EfDeletableEntityRepository <Guide>(context);
            var service    = new GuidesService(repository);
            var models     = new List <CreateGuideInputModel>()
            {
                new CreateGuideInputModel()
                {
                    Title       = "new",
                    GameId      = "1",
                    Category    = "Action",
                    Description = "test",
                    ImageUrl    = "google",
                },
                new CreateGuideInputModel()
                {
                    Title       = "new2",
                    GameId      = "1",
                    Category    = "Action",
                    Description = "test2",
                    ImageUrl    = "google2",
                },
                new CreateGuideInputModel()
                {
                    Title       = "new3",
                    GameId      = "1",
                    Category    = "Mmo",
                    Description = "test3",
                    ImageUrl    = "google3",
                },
            };

            foreach (var model in models)
            {
                await service.CreateAsync(model, "1");
            }

            var lastModel = new CreateGuideInputModel()
            {
                Title       = "teeest",
                GameId      = "1",
                Category    = "Mmo",
                Description = "newwwwwwww",
                ImageUrl    = "google4",
            };
            await service.CreateAsync(lastModel, "2");

            var actual = await service.GetCountBySearchAsync("new");

            Assert.Equal(4, actual);
        }