public async Task <IEnumerable <UserDailyTrackingValue> > Handle(UpdateUserDailyTrackingValues request, CancellationToken cancellationToken)
{
var results = new List <UserDailyTrackingValue>();
using var transaction = _dbContext.Database.BeginTransaction();
foreach (var value in request.Values)
{
var data = await _dbContext.UserDailyTrackingValues
.AsNoTracking()
.Where(u => u.Day.Equals(request.Day))
.Where(u => u.UserId.Equals(request.UserId))
.Where(u => u.UserTrackingValueId.Equals(value.UserTrackingValueId))
.Where(u => u.Occurrence.Equals(value.Occurance))
.SingleOrDefaultAsync(cancellationToken);
if (data == null)
{
var result = _dbContext.UserDailyTrackingValues
.Add(new UserDailyTrackingValue
{
Day = request.Day,
UserId = request.UserId,
UserTrackingValueId = value.UserTrackingValueId,
Occurrence = value.Occurance,
Value = value.Value,
When = value.When,
});
await _dbContext.SaveChangesAsync(cancellationToken);
results.Add(result.Entity);
}
else
{
var result = _dbContext.UserDailyTrackingValues
.Update(data with
{
Value = value.Value,
When = value.When,
});
await _dbContext.SaveChangesAsync(cancellationToken);
results.Add(result.Entity);
}
}
await transaction.CommitAsync(cancellationToken);
return(results);
}
public async Task <UserTracking> Handle(AddUserTracking request, CancellationToken cancellationToken)
{
var order = await _dbContext.UserTrackings
.Where(t => t.UserId.Equals(request.UserId))
.OrderByDescending(t => t.Order)
.Select(t => t.Order)
.FirstOrDefaultAsync(cancellationToken);
var result = _dbContext.UserTrackings
.Add(new UserTracking
{
UserId = request.UserId,
Title = request.Title,
Description = request.Description,
Disabled = false,
Occurrences = request.Occurrences,
Order = order + 1,
UseTime = request.UseTime,
Values = request.Values.ToList(),
});
await _dbContext.SaveChangesAsync(cancellationToken);
return(await _mediator.Send(new GetUserTracking(request.UserId, result.Entity.UserTrackingId)));
}
public async Task <bool> Handle(UpdateUserTrackingValue request, CancellationToken cancellationToken)
{
var data = await _dbContext.UserTrackingValues
.AsNoTracking()
.Where(p => p.UserTrackingValueId == request.UserTrackingValueId)
.Where(p => p.Tracking.UserId == request.UserId)
.FirstOrDefaultAsync(cancellationToken);
if (data == null)
{
throw new ArgumentException($"User Tracking Value Id ({request.UserTrackingValueId}) for User Id ({request.UserId}) not found.");
}
_dbContext.Update(data with {
Name = request.Name,
Description = request.Description,
Order = request.Order,
Type = request.Type,
Disabled = request.Disabled,
Metadata = request.Metadata.ToArray(),
});
return(await _dbContext.SaveChangesAsync(cancellationToken) == 1);
}
public async Task <Unit> Handle(UpdateDay request, CancellationToken cancellationToken)
{
var data = await _dbContext.UserDays
.Where(userDay => userDay.UserId == request.UserId && userDay.Day == request.Day.Date)
.AsNoTracking()
.FirstOrDefaultAsync(cancellationToken);
if (data == null)
{
_dbContext.UserDays
.Add(new UserDay
{
Day = request.Day.Date,
UserId = request.UserId,
Water = request.UserDay.Water,
Weight = request.UserDay.Weight,
Notes = (request.UserDay.Notes == null || request.UserDay.Notes.Trim().Length == 0) ? null : request.UserDay.Notes.Trim(),
});
}
else
{
_dbContext.UserDays.Update(data with
{
Water = request.UserDay.Water,
Weight = request.UserDay.Weight,
Notes = request.UserDay.Notes == null || request.UserDay.Notes.Trim().Length == 0 ? null : request.UserDay.Notes.Trim(),
});
}
await _dbContext.SaveChangesAsync(cancellationToken);
return(Unit.Value);
}
public async Task <Fueling> Handle(AddFueling request, CancellationToken cancellationToken)
{
var data = _dbContext.Fuelings
.Add(new Fueling
{
Name = request.Name
});
await _dbContext.SaveChangesAsync(cancellationToken);
return(data.Entity);
}
public async Task <int> Handle(Plans.ChangeUserPlan request, CancellationToken cancellationToken)
{
ctx.UserPlans.Add(new UserPlan
{
UserId = request.UserId,
PlanId = request.PlanId,
Start = DateTime.Now,
});
await ctx.SaveChangesAsync(cancellationToken);
return(request.PlanId);
}
public async Task <int> Handle(AddPlan request, CancellationToken cancellationToken)
{
var result = _dbContext.Plans
.Add(new Plan
{
Name = request.Name,
MealCount = request.MealCount,
FuelingCount = request.FuelingCount,
});
await _dbContext.SaveChangesAsync(cancellationToken);
return(result.Entity.PlanId);
}
public async Task <Victory> Handle(AddVictory request, CancellationToken cancellationToken)
{
var data = ctx.Add(new Victory
{
UserId = request.UserId,
Name = request.Name,
When = request.When,
Type = request.Type,
});
await ctx.SaveChangesAsync(cancellationToken);
return(data.Entity);
}
public async Task <bool> Handle(DeleteFueling request, CancellationToken cancellationToken)
{
var data = await _dbContext.Fuelings
.AsNoTracking()
.SingleOrDefaultAsync(fueling => fueling.FuelingId == request.FuelingId, cancellationToken);
if (data == null)
{
throw new ArgumentException($"Fueling Id ({request.FuelingId}) not found.");
}
_dbContext.Fuelings.Remove(data);
return(await _dbContext.SaveChangesAsync(cancellationToken) == 1);
}
public async Task <bool> Handle(AddUserDailyTracking request, CancellationToken cancellationToken)
{
var result = _dbContext.UserDailyTrackingValues
.Add(new UserDailyTrackingValue
{
Day = request.Day,
UserId = request.UserId,
UserTrackingValueId = request.UserTrackingValueId,
Occurrence = request.Occurance,
Value = request.Value,
When = request.When,
});
return(await _dbContext.SaveChangesAsync(cancellationToken) == 1);
}
public async Task <User> Handle(CreateNewUser request, CancellationToken cancellationToken)
{
var result = _dbContext
.Users
.Add(new User
{
UserId = request.UserId,
FirstName = request.FirstName,
LastName = request.LastName,
EmailAddress = request.EmailAddress,
Created = DateTime.Now
});
await _dbContext.SaveChangesAsync(cancellationToken);
return(result.Entity);
}
public async Task <bool> Handle(DeleteUserTrackingValue request, CancellationToken cancellationToken)
{
var data = await _dbContext.UserTrackingValues
.AsNoTracking()
.Where(p => p.UserTrackingValueId == request.UserTrackingValueId)
.Where(p => p.Tracking.UserId == request.UserId)
.FirstOrDefaultAsync(cancellationToken);
if (data == null)
{
throw new ArgumentException($"User Tracking Value Id ({request.UserTrackingValueId}) for User Id ({request.UserId}) not found.");
}
_dbContext.Remove(data);
return(await _dbContext.SaveChangesAsync(cancellationToken) == 1);
}
public async Task <bool> Handle(DeleteVictory request, CancellationToken cancellationToken)
{
var data = await ctx.Victories
.AsNoTracking()
.FirstOrDefaultAsync(v => v.VictoryId == request.VictoryId, cancellationToken);
if (data == null)
{
return(false);
}
ctx.Victories.Remove(data);
await ctx.SaveChangesAsync(cancellationToken);
return(true);
}
public async Task <int> Handle(AddUserTrackingValue request, CancellationToken cancellationToken)
{
var data = _dbContext.UserTrackingValues
.Add(new UserTrackingValue
{
UserTrackingId = request.UserTrackingId,
Name = request.Name,
Description = request.Description,
Order = request.Order,
Type = request.Type,
Disabled = request.Disabled,
Metadata = request.Metadata.ToArray(),
});
await _dbContext.SaveChangesAsync(cancellationToken);
return(data.Entity.UserTrackingValueId);
}
public async Task <string> Handle(AddNewUser request, CancellationToken cancellationToken)
{
var userPlans = new UserPlan[] { new UserPlan {
PlanId = request.PlanId, Start = DateTime.Now
} };
var result = _dbContext.Users.Add(new User
{
UserId = request.UserId,
FirstName = request.FirstName,
LastName = request.LastName,
EmailAddress = request.EmailAddress,
Created = DateTime.Now,
UserPlans = userPlans,
});
await _dbContext.SaveChangesAsync(cancellationToken);
return(result.Entity.UserId);
}
public async Task <bool> Handle(UpdateVictory request, CancellationToken cancellationToken)
{
var data = await ctx.Victories
.AsNoTracking()
.FirstOrDefaultAsync(v => v.VictoryId == request.VictoryId, cancellationToken);
if (data == null)
{
return(false);
}
ctx.Victories.Update(data with
{
Name = request.Name,
When = request.When,
});
await ctx.SaveChangesAsync(cancellationToken);
return(true);
}
public async Task <Plan> Handle(UpdatePlan request, CancellationToken cancellationToken)
{
var data = await _dbContext.Plans
.AsNoTracking()
.SingleOrDefaultAsync(plan => plan.PlanId == request.PlanId);
if (data == null)
{
throw new ArgumentException($"Plan Id ({request.PlanId}) not found.");
}
_dbContext.Plans.Update(data with
{
Name = request.Name,
FuelingCount = request.FuelingCount,
MealCount = request.MealCount,
});
await _dbContext.SaveChangesAsync(cancellationToken);
return(data);
}
public async Task <bool> Handle(DeleteUserTracking request, CancellationToken cancellationToken)
{
var data = await _dbContext.UserTrackings
.AsNoTracking()
.Include(u => u.Values)
.Where(u => u.UserTrackingId.Equals(request.UserTrackingId))
.Where(u => u.UserId.Equals(request.UserId))
.SingleOrDefaultAsync(cancellationToken);
if (data == null)
{
throw new ArgumentException($"User Tracking Id ({request.UserTrackingId}) for User Id ({request.UserId}) not found.");
}
var values = data.Values.ToList();
var userValues = await _dbContext.UserDailyTrackingValues
.AsNoTracking()
.Where(v => v.TrackingValue.UserTrackingId.Equals(request.UserTrackingId))
.ToListAsync();
using var transaction = _dbContext.Database.BeginTransaction();
_dbContext.UserDailyTrackingValues
.RemoveRange(userValues);
_dbContext.UserTrackingValues
.RemoveRange(values);
_dbContext.UserTrackings
.Remove(data);
var result = await _dbContext.SaveChangesAsync(cancellationToken) > 0;
await transaction.CommitAsync(cancellationToken);
return(result);
}
public async Task <bool> Handle(UpdateUser request, CancellationToken cancellationToken)
{
var user = _dbContext.Users
.AsNoTracking()
.FirstOrDefault(user => user.UserId.Equals(request.userId));
if (user != null)
{
_dbContext.Users
.Update(user with
{
FirstName = request.FirstName,
LastName = request.LastName,
WaterSize = request.WaterSize,
WaterTarget = request.WaterTarget,
Autosave = request.Autosave,
});
return(await _dbContext.SaveChangesAsync(cancellationToken) == 1);
}
return(false);
}
public async Task <UserTracking> Handle(UpdateUserTracking request, CancellationToken cancellationToken)
{
var data = await _dbContext.UserTrackings
.AsNoTracking()
.Where(u => u.UserTrackingId.Equals(request.UserTrackingId))
.Where(u => u.UserId.Equals(request.UserId))
.SingleOrDefaultAsync(cancellationToken);
if (data == null)
{
throw new ArgumentException($"UserTrackingId ({request.UserTrackingId}) not found.");
}
using var transaction = _dbContext.Database.BeginTransaction();
_dbContext.UserTrackings
.Update(data with
{
Title = request.Title,
Description = request.Description,
Occurrences = request.Occurrences,
Disabled = request.Disabled,
UseTime = request.UseTime,
});
await _dbContext.SaveChangesAsync(cancellationToken);
_dbContext.UserTrackingValues
.AddRange(request.Values
.Where(userTrackingValue => userTrackingValue.UserTrackingValueId == 0)
.Select(userTrackingValue => new UserTrackingValue
{
UserTrackingId = data.UserTrackingId,
Name = userTrackingValue.Name,
Description = userTrackingValue.Description,
Disabled = userTrackingValue.Disabled,
Order = userTrackingValue.Order,
Type = userTrackingValue.Type,
Metadata = userTrackingValue.Metadata,
})
);
var values = await _dbContext.UserTrackingValues
.AsNoTracking()
.Where(u => u.Tracking.UserTrackingId.Equals(request.UserTrackingId))
.Where(u => u.Tracking.UserId.Equals(request.UserId))
.ToListAsync(cancellationToken);
foreach (var userTrackingValue in request.Values.Where(v => v.UserTrackingValueId != 0))
{
var value = await _dbContext.UserTrackingValues
.AsNoTracking()
.Where(p => p.UserTrackingValueId == userTrackingValue.UserTrackingValueId)
.Where(p => p.Tracking.UserId == request.UserId)
.FirstOrDefaultAsync(cancellationToken);
_dbContext.Update(value with
{
Name = userTrackingValue.Name,
Description = userTrackingValue.Description,
Order = userTrackingValue.Order,
Type = userTrackingValue.Type,
Disabled = userTrackingValue.Disabled,
});
var metadata = await _dbContext.UserTrackingValueMetadata
.AsNoTracking()
.Where(p => p.UserTrackingValueId == userTrackingValue.UserTrackingValueId)
.ToListAsync(cancellationToken);
_dbContext.UserTrackingValueMetadata
.RemoveRange(metadata);
_dbContext.UserTrackingValueMetadata
.AddRange(userTrackingValue.Metadata
.Select(m => new UserTrackingValueMetadata
{
Key = m.Key,
Value = m.Value,
UserTrackingValueId = userTrackingValue.UserTrackingValueId
}));
}
var removeTrackingValueIds = request.Values.Where(value => value.UserTrackingValueId != 0).Select(value => value.UserTrackingValueId);
var removeTrackingValues = _dbContext.UserTrackingValues
.Where(userTrackingValue => userTrackingValue.Tracking.UserId == request.UserId)
.Where(userTrackingValue => userTrackingValue.UserTrackingId == request.UserTrackingId)
.Where(userTrackingValue => !removeTrackingValueIds.Contains(userTrackingValue.UserTrackingValueId))
.AsEnumerable();
_dbContext.UserTrackingValues
.RemoveRange(removeTrackingValues);
await _dbContext.SaveChangesAsync(cancellationToken);
await transaction.CommitAsync(cancellationToken);
return(data);
}
