public async Task AddUserAsync(long telegramUserId, string lastFmUsername) { await context.Users.AddAsync(new User { TelegramUserId = telegramUserId, LastfmUsername = lastFmUsername, }); await context.SaveChangesAsync(); }
public async Task <SomeEntity> UpdateSomeEntity(SomeEntity updatedSomeEntity) { _myDbContext.UpdateGraph(updatedSomeEntity, map => map.OwnedCollection(p => p.SomeChildCollection)); await _myDbContext.SaveChangesAsync(); return(updatedSomeEntity); }
public async Task <IActionResult> InsertUser([FromBody] InsertUser user) { var entity = new User() { FirstName = user.FirstName, LastName = user.LastName, Email = user.Email, IsActive = user.IsActive, IsInternalUser = user.IsInternalUser, }; entity.InvitationUrl = !user.IsInternalUser ? _invitationUrl.CreateInvittionUrl(entity) : string.Empty; _context.User.Add(entity); await _context.SaveChangesAsync(new CancellationToken()); return(Ok()); }
public async Task <Artist> AddArtistAsync(string artistName) { var artist = await context.Artists.FirstOrDefaultAsync(a => a.Name.Equals(artistName)); if (artist != null) { return(artist); } artist = new Artist() { Name = artistName }; await context.Artists.AddAsync(artist); await context.SaveChangesAsync(); return(artist); }
public async Task AddSpotifyTrackAsync(Artist artist, string track, string url) { if (artist == null || string.IsNullOrEmpty(url) || string.IsNullOrEmpty(track)) { return; } string formattedTrack = track.Length > 255 ? track.Substring(0, 255) : track; var existingTrack = await context.SpotifyTracks.FirstOrDefaultAsync(t => t.Track == formattedTrack && t.Artist.Name == artist.Name); if (existingTrack != null) { return; } var spotifyTrack = new SpotifyTrack { Url = url, Artist = artist, Track = formattedTrack }; await context.SpotifyTracks.AddAsync(spotifyTrack); try { await context.SaveChangesAsync(); } catch (ArgumentException e) { Console.WriteLine(e); } }
public async Task <int> RemoveAsync(IBooks entity) { DbContext.Books.Remove(await DbContext.Books.FindAsync(entity.BookId)); return(await DbContext.SaveChangesAsync()); }
/// <summary> /// Add a new instrument /// </summary> /// <param name="instrument"></param> /// <param name="saveChanges">Set to true if saving to db should be done.</param> /// <returns>True if the insertion or update succeeded. False if it did not.</returns> /// <exception cref="ArgumentException"></exception> public async Task <Instrument> AddInstrument(Instrument instrument, bool saveChanges = true) { //Check if an instrument with these unique constraints already exists var existingInstrument = Context.Instruments.SingleOrDefault(x => (x.ID == instrument.ID) || (x.Symbol == instrument.Symbol && x.DatasourceID == instrument.DatasourceID && x.ExchangeID == instrument.ExchangeID && x.Expiration == instrument.Expiration && x.Type == instrument.Type)); if (existingInstrument != null) { //throw new ArgumentException("Unique constraint violation"); } ValidateInstrument(instrument); //All this stuff is detached, so we need to get the attached objects instrument.Datasource = Context.GetAttachedEntity(instrument.Datasource); instrument.Exchange = Context.GetAttachedEntity(instrument.Exchange); instrument.PrimaryExchange = Context.GetAttachedEntity(instrument.PrimaryExchange); instrument.Tags = instrument.Tags != null ? new List <Tag>(instrument.Tags.Select(Context.GetAttachedEntity).ToList()) : new List <Tag>(); //If necessary, load sessions from teplate or exchange if (instrument.SessionsSource == SessionsSource.Exchange && instrument.Exchange != null) { instrument.Sessions = instrument.Exchange.Sessions.Select(x => x.ToInstrumentSession()).ToList(); } else if (instrument.SessionsSource == SessionsSource.Exchange && instrument.Exchange == null) { instrument.SessionsSource = SessionsSource.Custom; instrument.Sessions = new List <InstrumentSession>(); } else if (instrument.SessionsSource == SessionsSource.Template) { instrument.Sessions = new List <InstrumentSession>(); var template = Context.SessionTemplates.Include(x => x.Sessions).FirstOrDefault(x => x.ID == instrument.SessionTemplateID); if (template != null) { foreach (TemplateSession s in template.Sessions) { instrument.Sessions.Add(s.ToInstrumentSession()); } } } //Continuous future requires a bit of a workaround ContinuousFuture tmpCf = null; if (instrument.IsContinuousFuture) { tmpCf = instrument.ContinuousFuture; //EF can't handle circular references, so we hack around it instrument.ContinuousFuture = null; instrument.ContinuousFutureID = null; } Context.Instruments.Add(instrument); if (saveChanges) { await Context.SaveChangesAsync().ConfigureAwait(false); } if (tmpCf != null) { tmpCf.UnderlyingSymbol = Context.GetAttachedEntity(tmpCf.UnderlyingSymbol); instrument.ContinuousFuture = tmpCf; instrument.ContinuousFuture.Instrument = instrument; instrument.ContinuousFuture.InstrumentID = instrument.ID.Value; if (saveChanges) { await Context.SaveChangesAsync().ConfigureAwait(false); } } _logger.Info($"Instrument Manager: successfully added instrument {instrument}"); return(instrument); }
public async Task <int> RemoveAsync(IElectronics entity) { DbContext.Electronics.Remove(await DbContext.Electronics.FindAsync(entity.ElectronicPartId)); return(await DbContext.SaveChangesAsync()); }
public async Task <int> RemoveAsync(ISport entity) { DbContext.Sports.Remove(await DbContext.Sports.FindAsync(entity.SportItemId)); return(await DbContext.SaveChangesAsync()); }
public async Task <int> AddAsync(TEntity entity) { Context.Set <TEntity>().Add(entity); return(await Context.SaveChangesAsync()); }
public async Task <int> RemoveAsync(IMusic entity) { DbContext.Musics.Remove(await DbContext.Musics.FindAsync(entity.MusicPartId)); return(await DbContext.SaveChangesAsync()); }