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)));
}
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());
}
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)));
}
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));
}
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))));
}
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))));
}
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))));
}
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))));
}
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))));
}
