protected async Task HandleValidSubmit()
{
Mapper.Map(InvoiceViewModel, Invoice);
InvoiceServiceResponse response = null;
if (Invoice.InvoiceNumber != new Guid())
{
Invoice result = null;
result = await InvoiceService.UpdateInvoice(Invoice);
ToastService.ShowSuccess(Invoice.Description + " was updated successfully");
NavigationManager.NavigateTo("/");
}
else
{
response = await InvoiceService.CreateInvoice(Invoice);
if (response.ResponseCode == StatusCodes.Status422UnprocessableEntity || response.ResponseCode == StatusCodes.Status409Conflict)
{
ToastService.ShowError(response.ResponseMessage);
}
if (response.ResponseCode == StatusCodes.Status201Created)
{
ToastService.ShowSuccess(response.ResponseMessage);
NavigationManager.NavigateTo("/");
}
}
}
public async Task AddPortfolioCoin(Coin c)
{
var result = await _http.PostAsJsonAsync <Coin>("api/portfoliocoin", c);
if (result.StatusCode != System.Net.HttpStatusCode.OK)
{
_toastService.ShowError(await result.Content.ReadAsStringAsync());
}
else
{
_toastService.ShowSuccess($"{c.name} was added to your portfolio!", "Coin added!");
}
}
public async Task AddPortfolioTransaction(Transaction transaction)
{
var result = await _http.PostAsJsonAsync <Transaction>("api/portfoliotransaction/", transaction);
if (result.StatusCode != System.Net.HttpStatusCode.OK)
{
_toastService.ShowError(await result.Content.ReadAsStringAsync());
}
else
{
_toastService.ShowSuccess("The transaction was added to your account!", "Transaction added!");
}
}
public async Task UpdatePortfolio(UserPortfolio portfolio)
{
var result = await _http.PostAsJsonAsync <UserPortfolio>("api/userportfolio/updateportfolio", portfolio);
if (result.StatusCode != System.Net.HttpStatusCode.OK)
{
_toastService.ShowError(await result.Content.ReadAsStringAsync());
}
else
{
_toastService.ShowSuccess($"{portfolio.Name} was updated successfully.", "Update successful");
}
}
public override async Task Save(ProductDto saveDto)
{
try
{
await base.Save(saveDto);
_toastService.ShowSuccess("Successfully saved " + saveDto.Name);
}
catch (Exception e)
{
Console.WriteLine("Error while saving " + saveDto.Id + ", " + saveDto.Name);
Console.WriteLine(e);
_toastService.ShowError("Error while saving " + saveDto.Name);
}
}
public async Task Submit()
{
Error = string.Empty;
if (!Guid.TryParse(Code, out var code))
{
Error = "The code entered is invalid.";
return;
}
if (Password != PasswordMatch)
{
Error = "The passwords entered do not match";
return;
}
var result = await _accountService.CompleteAdmin(Email, code, Password, PasswordMatch);
if (result is null)
{
_toastService.ShowSuccess("Your account has been created.");
_navigationService.NavigateTo("login");
return;
}
Error = result.Reason;
}
public async Task AddToCart(CartItem item)
{
var cart = await _localStorage.GetItemAsync <List <CartItem> >("cart");
if (cart == null)
{
cart = new List <CartItem>();
}
var sameItem = cart.Find(x => x.ProductId == item.ProductId && x.PurchaseOptionId == item.PurchaseOptionId);
if (sameItem == null)
{
cart.Add(item);
}
else
{
sameItem.Quantity += item.Quantity;
}
await _localStorage.SetItemAsync("cart", cart);
var product = await _productService.GetProduct(item.ProductId);
_toastService.ShowSuccess(product.Title, "Added to your shopping cart:");
OnChange.Invoke();
}
public async Task SubmitAsync()
{
HttpResponseMessage response = null;
try
{
response = await _client.IdentityClient.PostAsync("admin/create-business-admin", JsonMessage.CreateJsonMessage(new { BusinessId = Id, Email }));
}
catch (HttpRequestException)
{
_toastService.ShowError(ServiceError.Standard.Reason);
return;
}
if (response.IsSuccessStatusCode)
{
_modalService.Close(ModalResult.Cancel());
_toastService.ShowSuccess($"Email sent to user {Email} to confirm their account");
Email = string.Empty;
Id = Guid.Empty;
return;
}
else if (response.StatusCode == System.Net.HttpStatusCode.BadRequest)
{
var error = await ServiceError.Deserialize(response);
_toastService.ShowError(error.Reason);
}
}
public async Task <bool> DeleteAccount(Guid accountId, Guid businessId)
{
HttpResponseMessage response = null;
try
{
response = await _client.IdentityClient.PostAsync("admin/remove", JsonMessage.CreateJsonMessage(new { BusinessId = businessId, Id = accountId }));;
}
catch (HttpRequestException)
{
_toastService.ShowError(ServiceError.Standard.Reason);
return(false);
}
if (response.IsSuccessStatusCode)
{
_toastService.ShowSuccess($"admin removed successfully.");
return(true);
}
else if (response.StatusCode == System.Net.HttpStatusCode.BadRequest)
{
var error = await ServiceError.Deserialize(response);
_toastService.ShowError(error.Reason);
return(false);
}
return(false);
}
public async Task AddUnit(int unitId)
{
Unit unit = Units.First(unit => unit.Id == unitId);
var result = await _http.PostAsJsonAsync <int>("api/UserUnit", unitId);
if (result.StatusCode != System.Net.HttpStatusCode.OK)
{
_toastService.ShowError(await result.Content.ReadAsStringAsync());
}
else
{
await _bananaService.GetBananas();
_toastService.ShowSuccess($"Your {unit.Title} has been built!", "Unit built!");
}
}
public async Task BookWorkTask(int workTaskId)
{
var result = await _httpClient.PutAsJsonAsync("api/WorkTask", workTaskId);
var response = await result.Content.ReadFromJsonAsync <ServiceResponse <string> >();
if (response.Success)
{
_toastService.ShowSuccess(response.Message, "Succès");
}
else
{
_toastService.ShowError(response.Message, "Erreur.");
}
await GetWorkTaskAsync();
await GetNumberOfRemainingWorkTasks();
}
public void AddUnit(int unitId)
{
Unit unit = Units.First(unit => unit.Id == unitId);
UserUnits.Add(new UserUnit {
UnitId = unit.Id, HitPoints = unit.HitPoints
});
_toast.ShowSuccess($"A {unit.Title} has joined your army!", "Unit recruited!");
}
public void AddUnit(int unitId)
{
Unit unit = Units.First(u => u.Id == unitId);
MyUnits.Add(new UserUnit {
UnitId = unit.Id, HitPoints = unit.HitPoints
});
_toastService.ShowSuccess($"Your {unit.Title} has been built!", "Unit built!");
}
public static void ShowSuccessOrFailure(this IToastService me, IStringLocalizer localizer, int count, string message)
{
if (count > 0)
me.ShowSuccess(localizer[message], localizer["Success"].ToString());
else if (count < 0)
me.ShowInfo(localizer[message], localizer["Info"].ToString());
else
me.ShowError(localizer[message], localizer["Fault"].ToString());
}
public void AddUnit(int unitId)
{
Unit unit = Units.First(unit => unit.Id == unitId);
Console.WriteLine($"## UnitService unit: " + unit.ToString());
MyUnits.Add(new UserUnit {
UnitId = unit.Id, HitPoints = unit.HitPoints
});
_toastService.ShowSuccess($"Your {unit.Title} has been successfully built");
}
public void AddUnit(int unitId)
{
Unit unit = Units.First(unit => unit.Id == unitId);
MyUnits.Add(new UserUnit {
UnitId = unit.Id, HitPoints = unit.HitPoints
});
_toastService.ShowSuccess($"Your {unit.Title} has been built!", "Unit built!");
//Console.WriteLine($"{unit.Title} was built!");
//Console.WriteLine($"Your army size: {MyUnits.Count}");
}
public async Task AddUnit(int unitId)
{
var unit = Units.FirstOrDefault(x => x.Id == unitId);
if (unit == null)
{
return;
}
var res = await _http.PostAsJsonAsync <int>("api/UserUnit", unitId);
if (res.StatusCode != HttpStatusCode.OK)
{
_toastService.ShowError(await res.Content.ReadAsStringAsync());
}
else
{
await _bananaService.GetBananas();
_toastService.ShowSuccess($"Your {unit.Title} has been built!", "Unit built!");
}
}
public async Task ClaimEpisode(int episodeID)
{
HttpResponseMessage response = null;
try
{
using (var requestMessage =
new HttpRequestMessage(HttpMethod.Post,
$"{_httpClient.BaseAddress}claim/{episodeID.ToString()}"))
{
requestMessage.Headers.Authorization =
new AuthenticationHeaderValue("Bearer", (await _userSession.GetToken()).AccessToken);
response = await _httpClient.SendAsync(requestMessage);
}
if (response.IsSuccessStatusCode)
{
_toastService.ShowSuccess("Claimed episode.");
}
else
{
if (response.StatusCode == HttpStatusCode.BadRequest)
{
_toastService.ShowError(response.Content.ReadAsStringAsync().Result);
}
}
}
catch (Exception e)
{
SentrySdk.CaptureException(e);
}
}
public void Toast(Bread bread)
{
switch (bread.Level)
{
case Bread.Hawtness.Success:
toaster.ShowSuccess(bread.Banner, bread.Message);
return;
case Bread.Hawtness.Error:
toaster.ShowError(bread.Banner, bread.Message);
return;
}
}
public async Task Submit()
{
var result = await _accountService.CreateAdmin(Email);
if (result is null)
{
_navigationManager.NavigateTo("counter");
_toastService.ShowSuccess($"Email sent to {Email} to setup their account.");
Email = string.Empty;
Error = string.Empty;
return;
}
Error = result.Reason;
}
public async Task SaveAsync()
{
try {
var siteDb = SiteViewDto.ToSite();
if (siteDb.Id == 0)
{
Site newSiteDb = await _sitesRepository.AddAsync(siteDb);
SiteViewDto.Id = newSiteDb.Id;
_toastService.ShowSuccess("New site added");
}
else
{
await _sitesRepository.SaveSiteAsync(siteDb);
_toastService.ShowSuccess("Site was saved");
}
}
catch (Exception ex) {
_toastService.ShowError(ex.Message);
}
}
public async Task Sync()
{
var unsynced = await _dexie.GetDeckUnsynced();
var r = await _appender.Sync(unsynced).ToTask();
if (r.IsOk)
{
_toastService.ShowSuccess("Sync successful!");
}
else
{
_toastService.ShowError(r.ErrorValue);
}
}
public async Task AddToCart(ProductVariant productVariant)
{
var cart = await _localStorage.GetItemAsync <List <ProductVariant> >("cart");
if (cart == null)
{
cart = new List <ProductVariant>();
}
cart.Add(productVariant);
await _localStorage.SetItemAsync("cart", cart);
var product = await _productService.GetProduct(productVariant.ProductId);
_toastService.ShowSuccess(product.Title, "Added to cart:");
OnChange.Invoke();
}
public static void ShowSuccessOrFailure(this IToastService me, IStringLocalizer localizer, int count, string?message)
{
if (string.IsNullOrWhiteSpace(message))
{
message = string.Empty;
}
if (count > 0)
{
me.ShowSuccess(localizer[message], localizer["Success"].ToString());
}
else if (count < 0)
{
me.ShowInfo(localizer[message], localizer["Info"].ToString());
}
else
{
me.ShowError(localizer[message], localizer["Fault"].ToString());
}
}
public bool OperacaoValida(EnumTipoSendService tipoService)
{
AddNotificaoPeloTipoServico(tipoService);
if (_notificador.Value.ContemMensagens())
{
var mensagem = _notificador.Value.Mensagens().FirstOrDefault();
switch (mensagem.Tipo)
{
case EnumTipoMensagem.Erro:
_toastService.ShowError(mensagem?.Mensagem, "Ocorreu um erro!"); break;
case EnumTipoMensagem.Warning:
_toastService.ShowWarning(mensagem?.Mensagem, "Atenção!"); break;
case EnumTipoMensagem.Sucesso:
_toastService.ShowSuccess(mensagem?.Mensagem, "Sucesso!"); break;
default:
break;
}
}
_notificador.Value.Limpar();
return(_notificador.Value.IsValido());
}
public void Web_CopyToClipboardCallback()
{
_toastService.ShowSuccess("Copied to clipboard");
}
public async Task <bool> SendRequestAsync(Func <Task <HttpResponseMessage> > call, string successMessage, Func <Task> onFailure = null, Func <Task> onSuccess = null)
{
HttpResponseMessage response = null;
try
{
response = await call();
if (response.StatusCode == System.Net.HttpStatusCode.ServiceUnavailable)
{
_toastService.ShowError("Something went wrong please try again shortly.");
_logger.LogInformation("Request failed due to service being down.");
return(false);
}
}
catch (HttpRequestException e)
{
_logger.LogError("A request failed with the reason: " + e.Message);
_toastService.ShowError(ServiceError.Standard.Reason);
return(false);
}
if (response.IsSuccessStatusCode)
{
var status = await _operationsManager.GetOperationStatusAsync(response.GetOperationId());
if (status is null)
{
_toastService.ShowError("Something went wrong your operation may have completed please verify before trying again");
return(false);
}
if (status.Status == OperationStatus.Complete)
{
if (onSuccess is null)
{
_toastService.ShowSuccess(successMessage);
await CheckConnection();
return(true);
}
await CheckConnection();
await onSuccess.Invoke();
return(true);
}
else if (status is OperationMessageFailed failed)
{
if (onFailure is null)
{
await CheckConnection();
_toastService.ShowError(failed.Reason);
return(false);
}
await CheckConnection();
await onFailure?.Invoke();
return(false);
}
}
else if (response.StatusCode == System.Net.HttpStatusCode.Unauthorized)
{
await CheckConnection();
// TODO Re apply for token using refresh token and then recurse on this function.
_toastService.ShowError("Request failed as you are not authenticated");
return(false);
}
await CheckConnection();
_toastService.ShowError("Something went wrong :(");
return(false);
}
public void ShowMessage()
{
_toastService.ShowSuccess("I'm a SUCCESS message with a custom title", "Congratulations!");
}
public static void Success(this IToastService toast)
{
toast.ShowSuccess(ToastMessages.Success, ToastMessages.SuccessHeader);
}
