Пример #1
0
        public async Task <IActionResult> Index(DonateViewModel model)
        {
            if (model.UserName == null)
            {
                model.IsAnonymous = true;
            }
            var request = _mapper.Map <MakeDonationRequest>(model);

            if (!request.IsAnonymous)
            {
                if (HttpContext.User.Claims.Any(c => c.Type == ClaimTypes.Sid))
                {
                    request.UserKey = Guid.Parse(HttpContext.User.Claims.Single(c => c.Type == ClaimTypes.Sid).Value);
                }
                else
                {
                    request.UserKey = null;
                }
            }
            var response = await _bus.RequestAsync(request);

            if (response.IsRequestSuccessful)
            {
                var viewModel = _mapper.Map <DonateResultViewModel>(response);

                return(View("_ThankYou", viewModel));
            }

            HttpContext.Response.StatusCode = 400;
            return(Content("Something has gone wrong"));
        }
Пример #2
0
        public async Task <RegisterAccountResultViewModel> RegisterAccount(RegisterAccountViewModel model)
        {
            var emailExistsMessage = "Dit e-mailadres kan niet worden gebruikt om een account te registeren!";

            var emailExistsRequest  = _mapper.Map <UserEmailExistsRequest>(model);
            var emailExistsResponse = await _bus.RequestAsync(emailExistsRequest);

            if (emailExistsResponse.EmailExists)
            {
                return(new RegisterAccountResultViewModel
                {
                    Message = emailExistsMessage
                });
            }

            var userKey = Guid.NewGuid();
            var createIdentityRequest = _mapper.Map <CreateIdentityRequest>(model);

            createIdentityRequest.UserKey = userKey;

            var createIdentityResponse = await _bus.RequestAsync(createIdentityRequest);

            if (createIdentityResponse.IsSuccess)
            {
                var createUserRequest = _mapper.Map <CreateUserRequest>(model);
                createUserRequest.UserKey = userKey;
                var createUserResponse = await _bus.RequestAsync(createUserRequest);

                if (createUserResponse.IsSuccess)
                {
                    await SendActivationTokenEmail(createIdentityRequest.UserName, model.EmailAddress, createIdentityResponse.ActivationToken);

                    return(new RegisterAccountResultViewModel
                    {
                        Success = true,
                        Message = $"Het account is succesvol geregistreerd! Er is een e-mail verzonden naar {model.EmailAddress} om het account te activeren."
                    });
                }

                return(new RegisterAccountResultViewModel
                {
                    Message = "Er is een fout opgetreden bij het afronden van de registratie van je account. Probeer het later opnieuw!"
                });
            }

            if (createIdentityResponse.ErrorType == ErrorType.EmailExists)
            {
                return(new RegisterAccountResultViewModel
                {
                    Message = emailExistsMessage
                });
            }
            return(new RegisterAccountResultViewModel
            {
                Message = "Er is een fout opgetreden bij het registeren van je account. Probeer het later opnieuw!"
            });
        }
Пример #3
0
        public async Task <IActionResult> SearchCharities(SearchQuery query)
        {
            var request  = _mapper.Map <GetCharitiesRequest>(query);
            var response = await _bus.RequestAsync(request);

            if (response.IsRequestSuccessful)
            {
                var model = _mapper.Map <SearchResultsViewModel>(response);
                model.PageNumber = query.PageNumber;
                model.PageSize   = query.PageSize;

                return(View("_SearchResultsWrapper", model));
            }

            return(View("_SearchResultsWrapper", new SearchResultsViewModel()));
        }
Пример #4
0
        public async Task <IActionResult> Detail(StoryQuery query)
        {
            var request  = _mapper.Map <GetStoryByUrlRequest>(query);
            var response = await _bus.RequestAsync(request);

            if (!response.IsRequestSuccessful)
            {
                return(new StatusCodeResult((int)HttpStatusCode.ServiceUnavailable));
            }
            if (!response.IsSuccess || !response.Story.IsApproved)
            {
                return(new StatusCodeResult((int)HttpStatusCode.NotFound));
            }
            var model = _mapper.Map <StoryViewModel>(response.Story);

            return(View("Detail", model));
        }
Пример #5
0
        public async Task <IActionResult> GetTopCharities(TopCharitiesQuery query)
        {
            var request  = _mapper.Map <GetRandomCharitiesRequest>(query);
            var response = await _bus.RequestAsync(request);

            var model = new TopCharitiesViewModel
            {
                RequestedAmount = query.Amount
            };

            if (response.IsRequestSuccessful)
            {
                model.Charities = _mapper.Map <List <CharityItemViewModel> >(response.Results);
                return(PartialView("_CharityItemsWrapper", model));
            }

            return(PartialView("_CharityItemsWrapper", model));
        }
Пример #6
0
        public async Task <IActionResult> GetCharities()
        {
            var request  = new GetCharitiesRequest();
            var response = await _bus.RequestAsync(request);

            if (!response.IsRequestSuccessful)
            {
                return(new StatusCodeResult((int)HttpStatusCode.ServiceUnavailable));
            }

            var charities = _mapper.Map <List <Charity> >(response.Charities);

            return(Json(charities));
        }