public async Task <ActionResult <object> > Get(string idsString)
{
var ids = idsString.Split(",").Select(s => s.Trim());
var idsToFetch = new List <string>();
var movies = new List <Movie>();
foreach (var id in ids)
{
var movie = await context.Movies.FindAsync(id);
if (movie == null)
{
idsToFetch.Add(id);
}
else
{
movie.FromLocalDatabase = true;
movies.Add(movie);
}
}
var tasks = idsToFetch.Select(id => fetchMovie(id)).ToArray();
Task.WaitAll(tasks);
//Get the valid fetched movies, that returned an ID.
var fetchedMovies = tasks.Where(t => t.Result.ID != null).Select(t => t.Result);
await context.AddRangeAsync(fetchedMovies);
await context.SaveChangesAsync();
movies.AddRange(fetchedMovies);
return(movies);
}
public async Task UpdateGuardianMatchEfficiency(IEnumerable <GuardianMatchResult> guardianMatchResults)
{
var efficiencyUpdates = new List <GuardianEfficiency>();
foreach (var result in guardianMatchResults)
{
var currentEfficiencies = GetGuardianEfficiencies(result.GuardianId);
var newEfficiency = (currentEfficiencies.Sum() + result.Efficiency) / (currentEfficiencies.Count() + 1);
var newGuardianEff = new GuardianEfficiency()
{
Id = $"eff_{Guid.NewGuid():N}",
GuardianId = result.GuardianId,
MatchId = result.MatchId,
NewEfficiency = newEfficiency,
PreviousEfficiency = currentEfficiencies.Any() ? currentEfficiencies.Average() : 0
};
efficiencyUpdates.Add(newGuardianEff);
}
await _databaseContext.AddRangeAsync(efficiencyUpdates);
await _databaseContext.SaveChangesAsync();
}
public async Task <IEnumerable <string> > SaveGuardianResults(IEnumerable <GuardianMatchResult> matchResults)
{
await _databaseContext.AddRangeAsync(matchResults);
await _databaseContext.SaveChangesAsync();
return(matchResults.Select(results => results.Id));
}
public async Task <IEnumerable <string> > WriteMatchTeams(IEnumerable <MatchTeam> matchTeams)
{
await _databaseContext.AddRangeAsync(matchTeams);
await _databaseContext.SaveChangesAsync();
return(matchTeams.Select(team => team.Id));
}
/// <summary>
/// Сохранение данных из JSON
/// </summary>
/// <param name="json">Содержимое JSON</param>
/// <returns></returns>
public async Task SaveFromJson(string json)
{
var books = JsonConvert.DeserializeObject <List <Book> >(json) ?? new List <Book>();
books.ForEach(a => a.Id = Guid.NewGuid());
await _context.AddRangeAsync(books);
await _context.SaveChangesAsync();
}
public async Task <Unit> Handle(Command message, CancellationToken cancellationToken)
{
var questionsToAdd = PrepareQuestions(message.UserId, message.Questions);
await _db.AddRangeAsync(questionsToAdd);
await _db.SaveChangesAsync();
return(Unit.Value);
}
public async Task <Unit> Handle(Command message, CancellationToken cancellationToken)
{
var parsedMetadata = ParseMetadata(message.Metadata.Metadatas, message.UserId);
var metadataToAdd = await DistinctMetadata(message.UserId, parsedMetadata);
await _db.AddRangeAsync(metadataToAdd);
await _db.SaveChangesAsync(cancellationToken);
return(Unit.Value);
}
/// <summary>
/// Insert normalny
/// </summary>
/// <param name="entities"></param>
/// <returns></returns>
public async Task Insert(IEnumerable <object> entities)
{
try
{
await _databaseContext.AddRangeAsync(entities);
await _databaseContext.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException ex)
{
throw new DbUpdateConcurrencyException("Dane nie zostały zapisane. Ktoś w międzyczasie wykonał ich zmianę. Odśwież i spróbuj ponownie", ex);
}
finally
{
Parallel.ForEach(entities, p =>
{
_databaseContext.Entry(p).State = EntityState.Detached;
});
}
}
protected override async Task Handle(AddNotificationCommand request, CancellationToken cancellationToken)
{
var auction = dbContext.Auctions
.Include(x => x.Categories)
.SingleOrDefault(x => x.Id == request.AuctionId);
if (auction == null)
{
throw new BusinessLogicException("Auction doesn't exist");
}
var subscriptions = await subscriptionRepository.GetSubscriptionsByAuction(auction, request.Type);
await dbContext.AddRangeAsync(
subscriptions.Select(s => new Notification
{
Status = NotificationStatus.ReadyToSend,
Auction = auction,
Subscription = s
}));
await dbContext.SaveChangesAsync();
}
static async Task Main(string[] args)
{
var connectionStrings = args[0];
var options = new DbContextOptionsBuilder <DatabaseContext>()
.UseSqlServer(connectionStrings)
.Options;
using (var context = new DatabaseContext(options))
{
await context.Database.EnsureCreatedAsync();
using (var tx = await context.Database.BeginTransactionAsync())
{
var enumerable = Enumerable.Range(0, 20)
.Select(_ => new User
{
Id = Guid.NewGuid(),
Email = "*****@*****.**",
Name = "hogehoge",
LastLogin = DateTimeOffset.UtcNow,
Roles = new List <Role>
{
new Role
{
Id = Guid.NewGuid(),
Name = "role0",
Deleted = R.Next(2) == 0
},
new Role
{
Id = Guid.NewGuid(),
Name = "role1",
Deleted = R.Next(2) == 0
}
},
Departments = new List <Department>
{
new Department
{
Id = Guid.NewGuid(),
Name = "department0",
Deleted = R.Next(2) == 0
},
new Department
{
Id = Guid.NewGuid(),
Name = "department1",
Deleted = R.Next(2) == 0
},
new Department
{
Id = Guid.NewGuid(),
Name = "department2",
Deleted = R.Next(2) == 0
}
}
});
await context.Database.ExecuteSqlCommandAsync("DELETE FROM Roles");
await context.Database.ExecuteSqlCommandAsync("DELETE FROM Departments");
await context.Database.ExecuteSqlCommandAsync("DELETE FROM Users");
await context.AddRangeAsync(enumerable);
await context.SaveChangesAsync();
tx.Commit();
}
}
Console.WriteLine("Done");
Console.ReadLine();
}
