public async Task <IActionResult> SendQuickMessage([FromBody] QuickMessageViewModel model)
        {
            if (ModelState.IsValid)
            {
                //Cant be null coz user is logged in
                // ReSharper disable once PossibleInvalidOperationException
                model.UserId = CurrentUser.UserId.Value;

                var adminAccountResult = await _userService.GetAdminAccountIdAsync();

                if (!adminAccountResult.IsValid)
                {
                    return(BadRequest(SmartJsonResult.Failure(adminAccountResult.ValidationErrors)));
                }
                model.ReceiverUserId = adminAccountResult.Result;
                var serviceRequest = _mapper.Map <PortalMessageDto>(model);
                serviceRequest.Starter = true;
                var createResult = await _portalMessageService.CreateAsync(serviceRequest);

                if (createResult.IsValid)
                {
                    return(Ok(SmartJsonResult <QuickMessageViewModel> .Success(model, "Wiadomość wysłana, dziękujemy za wsparcie :)")));
                }
                return(BadRequest(SmartJsonResult.Failure(createResult.ValidationErrors)));
            }
            return(BadRequest(GetModelStateErrors(ModelState)));
        }
示例#2
0
        public async Task <IActionResult> DateRangeList([FromBody] SmartParkListDateRangeRequestViewModel model)
        {
            if (!ModelState.IsValid)
            {
                model = new SmartParkListDateRangeRequestViewModel
                {
                    DateFrom = DateTime.Today.AddDays(-6),
                    DateTo   = DateTime.Now
                };
            }

            var dateFrom = model.DateFrom;
            var dateTo   = model.DateTo;

            var serviceResult = await _entityService.GetAllAdminAsync(x => x.Date >= dateFrom && x.Date <= dateTo);

            if (serviceResult.IsValid)
            {
                return(Ok(SmartJsonResult <SmartParkListWithDateRangeViewModel <AdminOrderListItemViewModel> >
                          .Success(new SmartParkListWithDateRangeViewModel <AdminOrderListItemViewModel>
                {
                    ListItems = serviceResult.Result.Select(_mapper.Map <AdminOrderListItemViewModel>),
                    DateTo = model.DateTo,
                    DateFrom = model.DateFrom
                })));
            }
            return(BadRequest(SmartJsonResult <SmartParkListWithDateRangeViewModel <AdminOrderListItemViewModel> > .Failure(serviceResult.ValidationErrors)));
        }
        public async Task <IActionResult> OrderDateRangeList([FromBody] SmartParkListDateRangeRequestViewModel model)
        {
            if (!ModelState.IsValid)
            {
                model = new SmartParkListDateRangeRequestViewModel
                {
                    DateFrom = DateTime.Today.AddDays(-6),
                    DateTo   = DateTime.Now
                };
            }

            var dateFrom = model.DateFrom;
            var dateTo   = model.DateTo;

            // ReSharper disable once PossibleInvalidOperationException
            var userId = CurrentUser.UserId.Value;

            var serviceResult = await _orderService.GetAllAsync(x => x.Date >= dateFrom && x.Date <= dateTo && x.UserId == userId);

            if (serviceResult.IsValid)
            {
                return(Ok(SmartJsonResult <SmartParkListWithDateRangeViewModel <ShopOrderItemViewModel> >
                          .Success(new SmartParkListWithDateRangeViewModel <ShopOrderItemViewModel>
                {
                    ListItems = serviceResult.Result.OrderByDescending(x => x.Date).Select(_mapper.Map <ShopOrderItemViewModel>),
                    DateTo = model.DateTo,
                    DateFrom = model.DateFrom
                })));
            }
            return(BadRequest(SmartJsonResult <SmartParkListWithDateRangeViewModel <ShopOrderItemViewModel> > .Failure(serviceResult.ValidationErrors)));
        }
        public async Task <IActionResult> ReplyPortalMessage([FromBody] ReplyMessageViewModel model)
        {
            if (ModelState.IsValid)
            {
                // ReSharper disable once PossibleInvalidOperationException
                var validateMessageResult = await _portalMessageService.ValidateMessageRecipents(CurrentUser.UserId.Value, model.PreviousMessageId);

                if (!validateMessageResult.IsValid)
                {
                    return(BadRequest(SmartJsonResult.Failure(validateMessageResult.ValidationErrors)));
                }
                PrepareReplyMessageModel(model, validateMessageResult.Result);

                var serviceRequest = _mapper.Map <PortalMessageDto>(model);
                serviceRequest.Starter = false;

                var createResult = await _portalMessageService.CreateAsync(serviceRequest);

                if (createResult.IsValid)
                {
                    return(Ok(SmartJsonResult <PortalMessageItemViewModel> .Success(_mapper.Map <PortalMessageItemViewModel>(createResult.Result), "Wiadomość została wysłana")));
                }
                return(BadRequest(SmartJsonResult.Failure(createResult.ValidationErrors)));
            }
            return(BadRequest(SmartJsonResult.Failure(GetModelStateErrors(ModelState))));
        }
        public async Task <IActionResult> LoginWeb([FromBody] ApplicationUser applicationUser)
        {
            if (!ModelState.IsValid)
            {
                return(ReturnBadRequestWithModelErrors());
            }

            var userLoginResult = await _userService.LoginAsync(applicationUser.Email, applicationUser.Password);

            if (!userLoginResult.IsValid)
            {
                _logger.LogInformation($"Invalid username ({applicationUser.Email}) or password ({applicationUser.Password})");
                return(BadRequest(SmartJsonResult.Failure("Invalid credentials.")));
            }
            var identity = GetClaimsIdentity(userLoginResult);

            var encodedJwt = await CreateJwtToken(applicationUser.Email, identity);


            // Serialize and return the response
            var response = new
            {
                access_token = encodedJwt,
                expires_in   = (int)_jwtOptions.ValidFor.TotalSeconds
            };

            var json = JsonConvert.SerializeObject(SmartJsonResult <object> .Success(response), _serializerSettings);

            return(new OkObjectResult(json));
        }
        public IActionResult RefreshWebToken()
        {
            var token = HttpContext.Request.Headers["Authorization"].First().Replace("Bearer ", "");
            var jwtSecurityTokenHandler = new JwtSecurityTokenHandler();
            var decodedJwt = jwtSecurityTokenHandler.ReadJwtToken(token);
            // Create the JWT security token and encode it.
            var jwt = new JwtSecurityToken(
                issuer: _jwtOptions.Issuer,
                audience: _jwtOptions.Audience,
                claims: decodedJwt.Claims,
                notBefore: _jwtOptions.NotBefore,
                expires: _jwtOptions.Expiration,
                signingCredentials: _jwtOptions.SigningCredentials);

            var encodedJwt = jwtSecurityTokenHandler.WriteToken(jwt);

            // Serialize and return the response
            var response = new
            {
                access_token = encodedJwt,
                expires_in   = (int)_jwtOptions.ValidFor.TotalSeconds
            };

            var json = JsonConvert.SerializeObject(SmartJsonResult <object> .Success(response), _serializerSettings);

            return(new OkObjectResult(json));
        }
        public async Task <IActionResult> RefreshAppToken([FromForm] RefreshAppTokenModel model)
        {
            if (!ModelState.IsValid)
            {
                return(ReturnBadRequestWithModelErrors());
            }
            var validateMobileTokenResult = await _userDeviceService.ValidateMobileTokenAsync(model.Email, model.Token);

            if (validateMobileTokenResult.IsValid)
            {
                var identity   = GetClaimsIdentity(validateMobileTokenResult);
                var encodedJwt = await CreateJwtToken(model.Email, identity);

                // Serialize and return the response
                var response = new
                {
                    access_token = encodedJwt,
                    expires_in   = (int)_jwtOptions.ValidFor.TotalSeconds
                };

                var json = JsonConvert.SerializeObject(SmartJsonResult <object> .Success(response), _serializerSettings);
                return(new OkObjectResult(json));
            }
            return(BadRequest());
        }
示例#8
0
        public async Task <IActionResult> ProcessPayment([FromBody] PaymentRequestViewModel model)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(SmartJsonResult <PaymentResponseViewModel> .Failure(GetModelStateErrors(ModelState))));
            }

            // ReSharper disable once PossibleInvalidOperationException
            model.UserId = CurrentUser.UserId.Value;

            //var connection = HttpContext.Features.Get<IHttpConnectionFeature>();
            //model.CustomerIP = connection?.RemoteIpAddress?.ToString();ca

            model.CustomerIP   = HttpContext.Connection.RemoteIpAddress?.ToString() ?? "127.0.0.1";
            model.UserEmail    = CurrentUser.Email;
            model.UserName     = CurrentUser.Name;
            model.UserLastName = CurrentUser.LastName;

            var request = _mapper.Map <PaymentRequest>(model);

            request.notifyUrl   = Url.Action("Notify", "Payment", new { area = "Portal" }, "http");
            request.continueUrl = Url.Action("ShopContinue", "Home", new { area = "Portal" }, "http");
            var payuServiceResult = await _payuService.ProcessPaymentAsync(request, model.UserId, OrderPlace.Website);

            if (payuServiceResult.IsValid)
            {
                return(Ok(SmartJsonResult <PaymentResponseViewModel> .Success(_mapper.Map <PaymentResponseViewModel>(payuServiceResult.Result))));
            }
            return(BadRequest(SmartJsonResult <PaymentResponseViewModel> .Failure(payuServiceResult.ValidationErrors)));
        }
示例#9
0
        public override async Task <IActionResult> ListAsync()
        {
            var serviceResult = await _entityService.GetAllAdminAsync();

            if (serviceResult.IsValid)
            {
                return(Ok(SmartJsonResult <IEnumerable <AdminOrderListItemViewModel> > .Success(serviceResult.Result.Select(_mapper.Map <AdminOrderListItemViewModel>))));
            }
            return(BadRequest(SmartJsonResult <IEnumerable <AdminOrderListItemViewModel> > .Failure(serviceResult.ValidationErrors)));
        }
        public virtual async Task <IActionResult> ListAsync()
        {
            var serviceResult = await GetAllAsync();

            if (serviceResult.IsValid)
            {
                return(Ok(SmartJsonResult <IEnumerable <TListViewModel> > .Success(serviceResult.Result.Select(_mapper.Map <TListViewModel>))));
            }
            return(BadRequest(SmartJsonResult <IEnumerable <TListViewModel> > .Failure(serviceResult.ValidationErrors)));
        }
        public virtual IActionResult List()
        {
            var serviceResult = _entityService.GetAll();

            if (serviceResult.IsValid)
            {
                return(Ok(SmartJsonResult <IEnumerable <TListViewModel> > .Success(serviceResult.Result.Select(_mapper.Map <TListViewModel>))));
            }
            return(BadRequest(SmartJsonResult <IEnumerable <TListViewModel> > .Failure(serviceResult.ValidationErrors)));
        }
        public async Task <IActionResult> GetUnreadClustersCount()
        {
            // ReSharper disable once PossibleInvalidOperationException
            var messagesGetResult = await _portalMessageService.GetPortalMessageClusterForCurrentUserAsync(CurrentUser.UserId.Value);

            if (messagesGetResult.IsValid)
            {
                var jsonResult = _mapper.Map <PortalMessageClustersViewModel>(messagesGetResult.Result);
                return(Ok(SmartJsonResult <PortalMessageClustersViewModel> .Success(jsonResult)));
            }
            return(BadRequest(SmartJsonResult.Failure(messagesGetResult.ValidationErrors)));
        }
        public async Task <SmartJsonResult <GetUserApiModel> > CheckAccount([FromBody] CheckAccountApiModel model)
        {
            if (!ModelState.IsValid)
            {
                return(SmartJsonResult <GetUserApiModel> .Failure(GetModelStateErrors(ModelState)));
            }

            var checkAccountExistResult = await _userService.GetByEmailAsync(model.Email);

            return(checkAccountExistResult.IsValid
                ? SmartJsonResult <GetUserApiModel> .Success(_mapper.Map <GetUserApiModel>(checkAccountExistResult.Result))
                : SmartJsonResult <GetUserApiModel> .Failure(checkAccountExistResult.ValidationErrors));
        }
示例#14
0
        public async Task <SmartJsonResult <bool> > ChangeEmail([FromBody] ChangeEmailApiModel model)
        {
            if (!ModelState.IsValid)
            {
                return(SmartJsonResult <bool> .Failure(GetModelStateErrors(ModelState)));
            }

            var changeEmailResult = await _userService.ChangeEmailAsync(model.Email, model.NewEmail, model.Password);

            return(changeEmailResult.IsValid
                ? SmartJsonResult <bool> .Success(true)
                : SmartJsonResult <bool> .Failure(changeEmailResult.ValidationErrors));
        }
        public virtual async Task <IActionResult> Create([FromBody] TCreateViewModel model)
        {
            if (ModelState.IsValid)
            {
                var serviceResult = await _entityService.CreateAsync(_mapper.Map <TDto>(model));

                if (serviceResult.IsValid)
                {
                    return(Ok(SmartJsonResult <TListViewModel> .Success(_mapper.Map <TListViewModel>(serviceResult.Result))));
                }
                return(BadRequest(SmartJsonResult.Failure(serviceResult.ValidationErrors)));
            }
            return(BadRequest(SmartJsonResult.Failure(GetModelStateErrors(ModelState))));
        }
示例#16
0
        public override async Task <IActionResult> Create([FromBody] AdminPriceTresholdCreateViewModel model)
        {
            if (ModelState.IsValid)
            {
                var serviceResult = await _entityService.CreateAsync(_mapper.Map <PriceTresholdBaseDto>(model));


                return(Json(serviceResult.IsValid
                    ? SmartJsonResult <AdminPriceTresholdListItemViewModel, PrcAdminCreateInfo>
                            .Success(_mapper.Map <AdminPriceTresholdListItemViewModel>(serviceResult.Result), serviceResult.SecondResult, GetSuccessNotificationForCreate(serviceResult.SecondResult))
                    : SmartJsonResult.Failure(serviceResult.ValidationErrors)));
            }
            return(Json(SmartJsonResult.Failure(GetModelStateErrors(ModelState))));
        }
示例#17
0
        public async Task <IActionResult> RecoverPrc([FromBody] AdminPriceTresholdDeleteViewModel model)
        {
            if (ModelState.IsValid)
            {
                var recoverUserResult = await _entityService.RecoverPriceTresholdAsync(model.Id);

                if (recoverUserResult.IsValid)
                {
                    return(Ok(SmartJsonResult.Success(recoverUserResult.SuccessNotifications.First())));
                }
                return(BadRequest(SmartJsonResult.Failure(recoverUserResult.ValidationErrors)));
            }
            return(BadRequest(SmartJsonResult.Failure(GetModelStateErrors(ModelState))));
        }
示例#18
0
        public async Task <IActionResult> GetSettingsIndexData()
        {
            var serviceResult = await _userService.GetUserDataWithLastGateUsage(CurrentUser.UserId.Value);

            if (serviceResult.IsValid)
            {
                var viewModel = _mapper.Map <UserBaseViewModel>(serviceResult.Result);
                viewModel.LastGateOpenDate = serviceResult.SecondResult != null
                    ? $"{serviceResult.SecondResult.DateOfUse.ToLongDateString()} - {serviceResult.SecondResult.DateOfUse.ToShortTimeString()}"
                    : "Brak wyjazdów";
                return(Ok(SmartJsonResult <UserBaseViewModel> .Success(viewModel)));
            }
            return(BadRequest(SmartJsonResult <UserBaseViewModel> .Failure(serviceResult.ValidationErrors)));
        }
        public virtual async Task <IActionResult> Delete([FromBody] TDeleteViewModel model)
        {
            if (ModelState.IsValid)
            {
                var serviceResult = await _entityService.DeleteAsync(model.Id);

                if (serviceResult.IsValid)
                {
                    return(Ok(SmartJsonResult.Success("Operacja usunięcia zakończona pomyślnie.")));
                }
                return(BadRequest(SmartJsonResult.Failure(serviceResult.ValidationErrors)));
            }
            return(BadRequest(SmartJsonResult.Failure(GetModelStateErrors(ModelState))));
        }
示例#20
0
        public async Task <IActionResult> GetUserOrders()
        {
            // ReSharper disable once PossibleInvalidOperationException
            var userId = CurrentUser.UserId.Value;

            var userOrdersResult = await _orderService.GetAllAsync(x => x.UserId == userId);

            if (userOrdersResult.IsValid)
            {
                var viewModel = userOrdersResult.Result.Take(5).Select(_mapper.Map <ShopOrderItemViewModel>);
                return(Ok(SmartJsonResult <IEnumerable <ShopOrderItemViewModel> > .Success(viewModel)));
            }
            return(BadRequest(SmartJsonResult <IEnumerable <ShopOrderItemViewModel> > .Failure(userOrdersResult.ValidationErrors)));
        }
        public virtual async Task <IActionResult> Edit([FromBody] TEditViewModel model)
        {
            if (ModelState.IsValid)
            {
                var serviceResult = await _entityService.EditAsync(_mapper.Map <TDto>(model));

                if (serviceResult.IsValid)
                {
                    return(Ok(SmartJsonResult <TListViewModel> .Success(_mapper.Map <TListViewModel>(serviceResult.Result), "Edycja zakończona pomyślnie")));
                }
                return(BadRequest(SmartJsonResult.Failure(serviceResult.ValidationErrors)));
            }
            return(BadRequest(SmartJsonResult.Failure(GetModelStateErrors(ModelState))));
        }
        public async Task <IActionResult> RecoverUser([FromBody] AdminUserDeleteViewModel model)
        {
            if (ModelState.IsValid)
            {
                var recoverUserResult = await _entityService.RecoverUserAsync(model.Id);

                if (recoverUserResult.IsValid)
                {
                    return(Ok(SmartJsonResult.Success("Operacja przywrócenia użytkownika zakończona pomyślnie.")));
                }
                return(BadRequest(SmartJsonResult.Failure(recoverUserResult.ValidationErrors)));
            }
            return(BadRequest(SmartJsonResult.Failure(GetModelStateErrors(ModelState))));
        }
        public override async Task <IActionResult> Edit([FromBody] AdminUserEditViewModel model)
        {
            if (ModelState.IsValid)
            {
                var serviceResult = await _entityService.AdminEditAsync(_mapper.Map <UserBaseDto>(model), model.OldEmail);

                if (serviceResult.IsValid)
                {
                    return(Ok(SmartJsonResult.Success("Edycja użytkownika zakończona pomyślnie")));
                }
                return(BadRequest(SmartJsonResult.Failure(serviceResult.ValidationErrors)));
            }
            return(BadRequest(SmartJsonResult.Failure(GetModelStateErrors(ModelState))));
        }
        public async Task <IActionResult> FakeDeleteCluster([FromBody] FakeDeleteClusterViewModel model)
        {
            if (ModelState.IsValid)
            {
                // ReSharper disable once PossibleInvalidOperationException
                var fakeDeleteClusterResult = await _portalMessageService.FakeDeleteCluster(CurrentUser.UserId.Value, model.StarterMessageId);

                if (!fakeDeleteClusterResult.IsValid)
                {
                    return(BadRequest(SmartJsonResult.Failure(fakeDeleteClusterResult.ValidationErrors)));
                }
                return(Ok(SmartJsonResult <bool> .Success(true, "Konwersacja została poprawnie usunięta.")));
            }
            return(BadRequest(SmartJsonResult.Failure(GetModelStateErrors(ModelState))));
        }
        public async Task <IActionResult> Register([FromBody] RegisterViewModel model)
        {
            if (ModelState.IsValid)
            {
                var userCreateResult = await _userService.CreateAsync(_mapper.Map <UserBaseDto>(model), model.Password);

                if (userCreateResult.IsValid)
                {
                    await _messageService.SendMessageAsync(EmailType.Register, userCreateResult.Result, GetAppBaseUrl());

                    return(Ok(SmartJsonResult.Success("Twoje konto zostało utworzone pomyślnie, czas się zalogować! :)")));
                }
                return(BadRequest(SmartJsonResult.Failure(userCreateResult.ValidationErrors)));
            }
            return(BadRequest(SmartJsonResult.Failure(GetModelStateErrors(ModelState))));
        }
        public async Task <IActionResult> SetDisplayed([FromBody] SetDisplayedMessageViewModel model)
        {
            if (ModelState.IsValid)
            {
                var message = await _portalMessageService.GetAsync(model.MessageId);

                if (message != null)
                {
                    message.Result.IsDisplayed = true;
                    await _portalMessageService.EditAsync(message.Result);

                    return(Ok(SmartJsonResult.Success()));
                }
            }
            return(BadRequest(SmartJsonResult.Failure()));
        }
        public async Task <SmartJsonResult <bool> > ForgotPassword([FromBody] ForgotApiModel model)
        {
            if (!ModelState.IsValid)
            {
                return(SmartJsonResult <bool> .Failure(GetModelStateErrors(ModelState)));
            }

            var changePasswordTokenResult = await _userService.GetPasswordChangeTokenAsync(model.Email);

            var changePasswordUrl = $"{Url.Action("RedirectFromToken", "Token", null, "http")}?id={changePasswordTokenResult.SecondResult}";
            await _messageService.SendMessageAsync(EmailType.ResetPassword, changePasswordTokenResult.Result, GetAppBaseUrl(),
                                                   new Dictionary <string, string> {
                { "ChangePasswordLink", changePasswordUrl }
            });

            return(changePasswordTokenResult.IsValid
                ? SmartJsonResult <bool> .Success(true)
                : SmartJsonResult <bool> .Failure(changePasswordTokenResult.ValidationErrors));
        }
        public async Task <SmartJsonResult <PaymentCardResponse> > ProcessCardPayment([FromBody] PaymentRequestApiModel model)
        {
            if (ModelState.IsValid)
            {
                model.CustomerIP = HttpContext.Connection.RemoteIpAddress?.ToString() ?? "127.0.0.1";

                var request = _mapper.Map <PaymentCardRequest>(model);
                request.notifyUrl = Url.Action("Notify", "Payment", new { area = "Portal" }, "http");
                var payuServiceResult = await _payuService.ProcessCardPaymentAsync(request, model.UserId, OrderPlace.Panel);

                if (payuServiceResult.IsValid)
                {
                    return
                        (SmartJsonResult <PaymentCardResponse> .Success(payuServiceResult.Result));
                }
                return(SmartJsonResult <PaymentCardResponse> .Failure(payuServiceResult.ValidationErrors));
            }
            return(SmartJsonResult <PaymentCardResponse> .Failure(GetModelStateErrors(ModelState)));
        }
        public async Task <IActionResult> GetPrices()
        {
            var currentPricesResult = await _priceTresholdService.GetAllAsync();

            if (currentPricesResult.IsValid)
            {
                var pricesViewModels = currentPricesResult.Result.Select(_mapper.Map <PriceTresholdShopItemViewModel>).ToList();
                var defaultPrice     = pricesViewModels.First();
                defaultPrice.IsDeafult = true;

                for (var i = 1; i < pricesViewModels.Count; i++)
                {
                    var price = pricesViewModels[i];
                    price.PercentDiscount = 100 - Convert.ToInt32((price.PricePerCharge * 100) / defaultPrice.PricePerCharge);
                }

                return(Json(SmartJsonResult <IEnumerable <PriceTresholdShopItemViewModel> > .Success(pricesViewModels)));
            }
            return(Json(SmartJsonResult <IEnumerable <PriceTresholdShopItemViewModel> > .Failure(currentPricesResult.ValidationErrors)));
        }
        public async Task <IActionResult> GetChartData([FromBody] ChartDataRequest model)
        {
            if (ModelState.IsValid)
            {
                var serviceRequest = _mapper.Map <ChartRequestDto>(model);

                // ReSharper disable once PossibleInvalidOperationException
                serviceRequest.UserId = CurrentUser.UserId.Value;

                var chartDataResult = await _chartService.GetDataAsync(serviceRequest);

                if (chartDataResult.IsValid)
                {
                    return(Ok(SmartJsonResult <ChartDataReturnModel> .Success(_mapper.Map <ChartDataReturnModel>(chartDataResult.Result))));
                }

                return(BadRequest(SmartJsonResult.Failure(chartDataResult.ValidationErrors)));
            }
            return(BadRequest(SmartJsonResult.Failure(GetModelStateErrors(ModelState))));
        }