public static async Task DeleteAsync(Guid id)
{
using (var repository = RepoUnitOfWork.CreateTrackingRepository <TRepo>())
{
await repository.DeleteAsync(id).ConfigureAwait(false);
}
}
public static void Delete(Guid id)
{
using (var repository = RepoUnitOfWork.CreateTrackingRepository <TRepo>())
{
repository.Delete(id);
}
}
public static async Task <bool> DeleteAsync(TDataAccessModel model)
{
using (var repository = RepoUnitOfWork.CreateTrackingRepository <TRepo>())
{
return(await repository.DeleteAsync(model).ConfigureAwait(false));
}
}
public static async Task <UserViewModel> GetUserData(string aspNetUserId)
{
if (string.IsNullOrWhiteSpace(aspNetUserId) || aspNetUserId == Guid.Empty.ToString())
{
return(null);
}
var userRepo = RepoUnitOfWork.CreateTrackingRepository <UserRepository>();
var user = await userRepo.GetSingleAsync(usr => usr.AspNetUserId == aspNetUserId, new[] {
nameof(User.AspNetUser)
}).ConfigureAwait(false);
var model = new UserViewModel()
{
AspNetUserId = user.AspNetUserId,
UserId = user.Id,
ProfilePictureUrl = user.ProfilePictureUrl,
BodyWeight = 0,
CaloriesBurned = 0,
GoalsAchived = 0,
Achivements = 0,
DailyGoal = 0,
Email = user.AspNetUser.Email,
FullName = user.FullName,
BirthDay = user.BirthDay ?? user.BirthDay.Value,
DailyMin = 0,
WeeklyMin = 0,
MonthlyMin = 0,
};
return(model);
}
public static async Task <bool> DeleteAsync(IList <TEntity> modelCollection)
{
using (var repository = RepoUnitOfWork.CreateTrackingRepository <TRepo>())
{
return(await repository.DeleteAsync(modelCollection).ConfigureAwait(false));
}
}
public static TDataAccessModel Update(TDataAccessModel entity, bool refreshFromDb = false, IList <string> navigationProperties = null)
{
using (var repository = RepoUnitOfWork.CreateTrackingRepository <TRepo>())
{
entity = repository.Update(entity, refreshFromDb, navigationProperties);
return(entity);
}
}
public static TEntity Update(TEntity model, bool refreshFromDb = false, IList <string> navigationProperties = null)
{
using (var repository = RepoUnitOfWork.CreateTrackingRepository <TRepo>())
{
var entity = repository.Update(model, refreshFromDb, navigationProperties);
return(entity);
}
}
public static void Delete(Guid id, TRepo repo = null)
{
if (repo == null)
{
repo = RepoUnitOfWork.CreateTrackingRepository <TRepo>();
}
repo.Delete(id);
}
public static async Task <TModel> UpdateAsync(TDataAccessModel entity, bool refreshFromDb = false, IList <string> navigationProperties = null)
{
using (var repository = RepoUnitOfWork.CreateTrackingRepository <TRepo>())
{
entity = await repository.UpdateAsync(entity, refreshFromDb, navigationProperties).ConfigureAwait(false);
return(entity.CopyTo <TModel>());
}
}
public static async Task <bool> DeleteAsync(IList <TModel> modelCollection)
{
using (var repository = RepoUnitOfWork.CreateTrackingRepository <TRepo>())
{
var entityCollection = modelCollection.CopyTo <TDataAccessModel>();
return(await repository.DeleteAsync(entityCollection).ConfigureAwait(false));
}
}
public static async Task <bool> DeleteAsync(TModel model)
{
using (var repository = RepoUnitOfWork.CreateTrackingRepository <TRepo>())
{
var entity = model.CopyTo <TEntity>();
return(await repository.DeleteAsync(entity).ConfigureAwait(false));
}
}
public static async Task <Response> DeleteAsync(Guid id)
{
using (var repository = RepoUnitOfWork.CreateTrackingRepository <TRepo>())
{
var result = await repository.DeleteAsync(id).ConfigureAwait(false);
return(ResponseFactory.CreateResponse(result, result ? ResponseCode.Success : ResponseCode.ErrorAnErrorOccurred));
}
}
public static async Task <IList <TEntity> > UpdateAsync(IList <TEntity> modelCollection, bool refreshFromDb = false, IList <string> navigationProperties = null)
{
using (var repository = RepoUnitOfWork.CreateTrackingRepository <TRepo>())
{
var entityCollection = await repository.UpdateAsync(modelCollection, refreshFromDb, navigationProperties).ConfigureAwait(false);
return(entityCollection);
}
}
public static IList <TEntity> Create(IList <TEntity> modelCollection, bool refreshFromDb = false, IList <string> navigationProperties = null)
{
using (var repository = RepoUnitOfWork.CreateTrackingRepository <TRepo>())
{
var entityCollection = repository.Create(modelCollection, refreshFromDb, navigationProperties);
return(entityCollection);
}
}
public static bool Delete(TDataAccessModel entity, TRepo repo = null)
{
if (repo == null)
{
repo = RepoUnitOfWork.CreateTrackingRepository <TRepo>();
}
return(repo.Delete(entity));
}
public static Response <TDataAccessModel> RestoreState(TDataAccessModel entityFromDb, TDataAccessModel entityToRestore)
{
using (var repository = RepoUnitOfWork.CreateTrackingRepository <TRepo>())
{
entityToRestore = entityFromDb;
var result = repository.Update(entityToRestore, true);
return(ResponseFactory.CreateResponse(result != null, result != null ? ResponseCode.Success : ResponseCode.ErrorAnErrorOccurred, result));
}
}
public static TEntity Create(TEntity model, bool refreshFromDb = false, TRepo Trepository = null, IList <string> navigationProperties = null)
{
if (Trepository == null)
{
Trepository = RepoUnitOfWork.CreateTrackingRepository <TRepo>();
}
var entity = Trepository.Create(model, refreshFromDb, navigationProperties);
return(entity);
}
public static async Task <TEntity> CreateAsync(TEntity model, bool refreshFromDb = false, TRepo Trepository = null, IList <string> navigationProperties = null)
{
if (Trepository == null)
{
Trepository = RepoUnitOfWork.CreateTrackingRepository <TRepo>();
}
var entity = await Trepository.CreateAsync(model, refreshFromDb, navigationProperties).ConfigureAwait(false);
return(entity);
}
public static TDataAccessModel Create(TDataAccessModel model, bool refreshFromDb = false, TRepo Trepository = null, IList <string> navigationProperties = null)
{
if (Trepository == null)
{
Trepository = RepoUnitOfWork.CreateTrackingRepository <TRepo>();
}
model = Trepository.Create(model, refreshFromDb, navigationProperties);
return(model);
}
public static Response UpdateMeal(CreateMealViewModel model)
{
using (var mealRepo = RepoUnitOfWork.CreateTrackingRepository <MealRepository>())
using (var foodRepo = RepoUnitOfWork.CreateTrackingRepository <FoodRepository>())
{
var currentMeal = mealRepo.Get(model.Id);
currentMeal.Name = model.Name;
currentMeal.PictureUrl = model.PictureUrl;
currentMeal.Description = model.Description;
double?caloriValue = 0;
var listOfFoodsAssignments = new List <RecipeFoodAssignment>();
if (model.SelectedFoods != null)
{
foreach (var item in model.SelectedFoods)
{
var food = foodRepo.Get(item.Id);
if (food == null)
{
return(ResponseFactory.ErrorReponse);
}
caloriValue = caloriValue + (item.Quantity * food.Calories) / food.Grams;
var foodItems = new RecipeFoodAssignment
{
FoodId = item.Id,
RecipeId = currentMeal.Id,
Quantity = item.Quantity
};
listOfFoodsAssignments.Add(foodItems);
}
}
currentMeal.RecipeFoodAssignments = listOfFoodsAssignments;
currentMeal.Calories = caloriValue ?? caloriValue.Value;
var updatedMeal = mealRepo.Update(currentMeal);
if (updatedMeal == null)
{
return(ResponseFactory.ErrorReponse);
}
return(ResponseFactory.SuccessResponse);
}
}
public static async Task <Response> DeleteAsync(Guid id)
{
using (var repository = RepoUnitOfWork.CreateTrackingRepository <TRepo>())
{
var response = ResponseFactory.ErrorReponse;
var result = await repository.DeleteAsync(id).ConfigureAwait(false);
if (result)
{
response = ResponseFactory.SuccessResponse;
}
return(response);
}
}
public static async Task <Response> DeleteAllAsync()
{
using (var repository = RepoUnitOfWork.CreateTrackingRepository <TRepo>())
{
var entities = await repository.GetAllAsync().ConfigureAwait(false);
await repository.DeleteAsync(entities).ConfigureAwait(false);
entities = await repository.GetAllAsync().ConfigureAwait(false);
if (entities != null && entities.Any())
{
return(ResponseFactory.ErrorReponse);
}
return(ResponseFactory.SuccessResponse);
}
}
public static async Task <Response> DeleteAllAsync()
{
using (var repository = RepoUnitOfWork.CreateTrackingRepository <TRepo>())
{
var entities = await repository.GetAllAsync().ConfigureAwait(false);
await repository.DeleteAsync(entities).ConfigureAwait(false);
entities = await repository.GetAllAsync().ConfigureAwait(false);
if (entities != null && entities.Any())
{
//TODO: Add a ResponseCode Enum
//return ResponseFactory.CreateResponse(false, ResponseCode.ErrorAnErrorOccurred);
return(ResponseFactory.CreateResponse(true, -1));
}
//return ResponseFactory.CreateResponse(true, ResponseCode.Success);
return(ResponseFactory.CreateResponse(true, 0));
}
}
public TRepo CreateTrackingRepository <TRepo, TDataAccessModel>()
where TRepo : BaseRepository <TDataAccessModel>, new()
where TDataAccessModel : class, IDataAccessObject, new()
{
return(RepoUnitOfWork.CreateTrackingRepository <TRepo>());
}
