public async Task <GetOrCreateSubscriberOutput> GetOrCreate(GetOrCreateSubscriberInput input) { try { SubscriberDto subscriberDto = null; bool newSubscriber = false; string normalisedEmail = StringUtils.NormaliseEmailAddress(input.EmailAddress); subscriberDto = await _crudServices.ReadSingleAsync <SubscriberDto>(s => s.EmailAddress == normalisedEmail); if (subscriberDto == null) { string emailVerifyCode = !input.EmailAddressVerified ? Guid.NewGuid().ToString("N").ToLowerInvariant().Truncate(Subscriber.MAX_LENGTH_EMAIL_VERIFY_CODE) : null; subscriberDto = await _crudServices.CreateAndSaveAsync(new SubscriberDto { EmailAddress = normalisedEmail, EmailAddressVerified = input.EmailAddressVerified, EmailVerifyCode = emailVerifyCode }); if (!_crudServices.IsValid) { return(new GetOrCreateSubscriberOutput { ErrorMessage = _crudServices.GetAllErrors() }); } newSubscriber = true; } return(new GetOrCreateSubscriberOutput { Subscriber = subscriberDto, CreatedNewSubscriber = newSubscriber, ErrorMessage = subscriberDto == null ? $"Error creating subscriber with email '{normalisedEmail}' in database" : null }); } catch (Exception ex) { Logger.LogError(ex, "EmailAddress: " + input.EmailAddress); return(new GetOrCreateSubscriberOutput { ErrorMessage = ex.Message }); } }
protected override async Task SaveCategory() { if (string.IsNullOrEmpty(SelectedCategory.Name)) { await dialogService.ShowMessage(Strings.MandatoryFieldEmptyTitle, Strings.NameRequiredMessage) ; return; } if (await crudServices.ReadManyNoTracked <AccountViewModel>().AnyWithNameAsync(SelectedCategory.Name) ) { await dialogService.ShowMessage(Strings.DuplicatedNameTitle, Strings.DuplicateCategoryMessage) ; return; } await crudServices.CreateAndSaveAsync(SelectedCategory, "ctor(2)") ; if (!crudServices.IsValid) { await dialogService.ShowMessage(Strings.GeneralErrorTitle, crudServices.GetAllErrors()) ; } await NavigationService.Close(this) ; }
protected override async Task SaveAccount() { await crudServices.UpdateAndSaveAsync(SelectedAccount); if (!crudServices.IsValid) { await dialogService.ShowMessage(Strings.GeneralErrorTitle, crudServices.GetAllErrors()); } CancelCommand.Execute(null); }
protected override async Task SaveCategory() { await crudServices.UpdateAndSaveAsync(SelectedCategory) .ConfigureAwait(true); if (!crudServices.IsValid) { await dialogService.ShowMessage(Strings.GeneralErrorTitle, crudServices.GetAllErrors()) .ConfigureAwait(true); } await CancelCommand.ExecuteAsync().ConfigureAwait(true); }
protected override async Task SavePayment() { var result = await paymentService.UpdatePayment(SelectedPayment) .ConfigureAwait(true); if (!result.Success) { await dialogService.ShowMessage(Strings.GeneralErrorTitle, crudServices.GetAllErrors()) .ConfigureAwait(true); } await NavigationService.Close(this).ConfigureAwait(true); }
protected override async Task SaveAccount() { if (await crudService.ReadManyNoTracked <AccountViewModel>() .AnyWithNameAsync(SelectedAccount.Name)) { await dialogService.ShowMessage(Strings.MandatoryFieldEmptyTitle, Strings.NameRequiredMessage); return; } await crudService.CreateAndSaveAsync(SelectedAccount, "ctor(4)"); if (!crudService.IsValid) { await dialogService.ShowMessage(Strings.GeneralErrorTitle, crudService.GetAllErrors()); } NavigationService.GoBack(); }
/// <summary> /// When we notify a subscriber about an album, we want to store the album in our database so we know /// that we've handled the album and don't send more notifications for it in future. /// </summary> public async Task <CreateAlbumsOutput> CreateAlbums(CreateAlbumsInput input) { try { foreach (var inputAlbum in input.Albums) { //If the album is attributed to more than one artist, there's a chance the album already exists var existingAlbum = await _crudServices.ReadManyNoTracked <Album>() .Where(a => a.SpotifyId == inputAlbum.SpotifyId) .Include(a => a.Artists) .FirstOrDefaultAsync(); if (existingAlbum != null) { //Check if we need to add this artist to the list of artists for the album if (!existingAlbum.Artists.Any(a => a.ArtistId == input.Artist.Id)) { Logger.LogInformation("Adding SpotifyArtistId: {0} to existing SpotifyAlbumId: {1} in database", input.Artist.SpotifyId, inputAlbum.SpotifyId); var artistAlbum = new ArtistAlbum { ArtistId = input.Artist.Id, AlbumId = existingAlbum.Id }; await _crudServices.CreateAndSaveAsync(artistAlbum); } } else { Logger.LogInformation("Saving SpotifyAlbumId: {0} to database", inputAlbum.SpotifyId); var newAlbum = new Album { Name = inputAlbum.Name, SpotifyId = inputAlbum.SpotifyId, ReleaseDate = inputAlbum.ReleaseDate, Artists = new List <ArtistAlbum> { new ArtistAlbum { ArtistId = input.Artist.Id } } }; await _crudServices.CreateAndSaveAsync(newAlbum); } } return(new CreateAlbumsOutput { ErrorMessage = _crudServices.IsValid ? null : _crudServices.GetAllErrors() }); } catch (Exception ex) { Logger.LogError(ex, ""); return(new CreateAlbumsOutput { ErrorMessage = ex.Message }); } }
public async Task <SubscribeToArtistsOutput> SubscribeToArtists(SubscribeToArtistsInput input) { if (input.Subscriber == null) { throw new ArgumentException("Subscriber must not be null", "Subscriber"); } if (!input.Artists.Any()) { throw new ArgumentException("Artists must contain at least one artist", "Artists"); } try { //The subscriber may have existing subscriptions var existingSubscriptions = await _crudServices.ReadManyNoTracked <Subscription>() .Where(s => s.SubscriberId == input.Subscriber.Id) .ToListAsync(); int existingSubscriptionsCount = existingSubscriptions.Count; int subscriptionsCount = existingSubscriptionsCount; bool limitReached = subscriptionsCount >= Subscription.MaxPerSubscriber; if (subscriptionsCount < Subscription.MaxPerSubscriber) { foreach (var artist in input.Artists) { if (!existingSubscriptions.Any(s => s.ArtistId == artist.Id)) { //Don't use _crudServices.CreateAndSaveAsync, because we only want to call Save once for performance reasons _crudServices.Context.Add(new Subscription { ArtistId = artist.Id, SubscriberId = input.Subscriber.Id }); subscriptionsCount++; if (subscriptionsCount >= Subscription.MaxPerSubscriber) { //Reached the maximum limit, don't create any more subscriptions for this Subscriber limitReached = true; break; } } } await _crudServices.Context.SaveChangesAsync(); } var output = new SubscribeToArtistsOutput { ErrorMessage = _crudServices.IsValid ? null : _crudServices.GetAllErrors() }; output.SetStatusMessage(existingSubscriptionsCount, subscriptionsCount - existingSubscriptionsCount, limitReached); output.RequiresEmailVerification = !input.Subscriber.EmailAddressVerified; return(output); } catch (Exception ex) { Logger.LogError(ex, "SubscriberId: " + input.Subscriber); return(new SubscribeToArtistsOutput { ErrorMessage = ex.Message }); } }