public async Task <bool> DeleteTrainingAsync(int trainingId)
{
using (ShapeAppDbContext ctx = new ShapeAppDbContext())
{
try {
Training training = await ctx.Training.FirstAsync(t => t.Id == trainingId);
List <Exercise> exercisesForTraining = ctx.TrainingExercises.Where(te => te.TrainingId == trainingId)
.Select(te => te.Exercise).ToList();
Console.WriteLine("Training " + trainingId + " has " + exercisesForTraining.Count + " exercises");
foreach (var exercise in exercisesForTraining)
{
if (GetNumberOfTrainingsForExercise(exercise.Id) == 1)
{
ctx.Exercise.Remove(exercise);
}
}
ctx.Training.Remove(training);
await ctx.SaveChangesAsync();
}
catch (Exception e) {
return(false);
}
return(true);
}
}
private int GetNumberOfCommonFriends(int firstUserId, int secondUserId)
{
using (ShapeAppDbContext ctx = new ShapeAppDbContext())
{
List <int> firstUserFriendIds = new List <int>();
List <int> temp = ctx.Friendships.Where(fr => fr.FirstUserId == firstUserId)
.Select(fr => fr.SecondUserId).ToList();
firstUserFriendIds.AddRange(temp);
temp = ctx.Friendships.Where(fr => fr.SecondUserId == firstUserId)
.Select(fr => fr.FirstUserId).ToList();
firstUserFriendIds.AddRange(temp);
List <int> secondUserFriendIds = new List <int>();
temp = ctx.Friendships.Where(fr => fr.FirstUserId == secondUserId)
.Select(fr => fr.SecondUserId).ToList();
secondUserFriendIds.AddRange(temp);
temp = ctx.Friendships.Where(fr => fr.SecondUserId == secondUserId)
.Select(fr => fr.FirstUserId).ToList();
secondUserFriendIds.AddRange(temp);
int numberOfCommonFriends = 0;
foreach (var friendId in firstUserFriendIds)
{
if (secondUserFriendIds.Contains(friendId))
{
numberOfCommonFriends++;
}
}
return(numberOfCommonFriends);
}
}
private bool UserFollowsGym(int userId, int gymId)
{
using (ShapeAppDbContext ctx = new ShapeAppDbContext())
{
return(ctx.UserActions.Any(ua => ua.SenderId == userId && ua.ReceiverId == gymId && ua.IsFollowPage));
}
}
private int GetTotalNumberOfFriendsForUser(int userId)
{
using (ShapeAppDbContext ctx = new ShapeAppDbContext())
{
return(ctx.Friendships.Count(fr => fr.FirstUserId == userId || fr.SecondUserId == userId));
}
}
private int GetTotalNumberOfFollowersForGym(int gymId)
{
using (ShapeAppDbContext ctx = new ShapeAppDbContext())
{
return(ctx.UserActions.Count(ua => ua.ReceiverId == gymId && ua.IsFollowPage));
}
}
public List <UserShortVersion> GetAllLikesForPost(int postId)
{
using (ShapeAppDbContext ctx = new ShapeAppDbContext())
{
try {
List <User> postLikeUsers = ctx.PostActions.Where(pa =>
pa.PostId == postId && pa.IsLike).Select(pa => pa.User).ToList();
if (!postLikeUsers.Any())
{
return(null);
}
List <UserShortVersion> users = new List <UserShortVersion>();
foreach (var user in postLikeUsers)
{
users.Add(new UserShortVersion {
UserId = user.Id,
UserFullName = user.Name
});
}
return(users);
}
catch (Exception e) {
return(null);
}
}
}
private List <User> GetCommonFollowersFriends(int userId, int gymId)
{
using (ShapeAppDbContext ctx = new ShapeAppDbContext())
{
List <User> userFriends = new List <User>();
userFriends.Add(ctx.Users.First(u => u.Id == userId));
List <User> temp = ctx.Friendships.Where(fr => fr.FirstUserId == userId)
.Select(fr => fr.SecondUser).ToList();
userFriends.AddRange(temp);
temp = ctx.Friendships.Where(fr => fr.SecondUserId == userId)
.Select(fr => fr.FirstUser).ToList();
userFriends.AddRange(temp);
List <User> gymFollowers = ctx.UserActions.Where(ua => ua.ReceiverId == gymId && ua.IsFollowPage)
.Select(ua => ua.Sender).ToList();
List <User> commonFollowersFriends = new List <User>();
foreach (var gymFollower in gymFollowers)
{
if (userFriends.Contains(gymFollower))
{
commonFollowersFriends.Add(gymFollower);
}
}
return(commonFollowersFriends);
}
}
public List <int> GetLatestPostsByUser(int userId, int offset)
{
using (ShapeAppDbContext ctx = new ShapeAppDbContext())
{
List <int> postsDb = ctx.Posts.Where(p => p.Owner.Id == userId)
.OrderByDescending(p => p.TimeStamp)
.Select(p => p.Id).ToList();
if (postsDb.Count <= offset)
{
return(null);
}
List <int> postIds = new List <int>();
for (int i = offset; i < offset + 5; i++)
{
if (i >= postsDb.Count)
{
break;
}
postIds.Add(postsDb[i]);
}
return(postIds);
}
}
public async Task <List <CommentSockets> > GetAllCommentsForPost(int postId)
{
using (ShapeAppDbContext ctx = new ShapeAppDbContext())
{
Post post = await ctx.Posts.Where(p => p.Id == postId)
.Include(p => p.Comments)
.ThenInclude(c => c.Owner)
.Include(p => p.Owner).FirstAsync();
List <Comment> orderedComments = post.Comments.OrderByDescending(c => c.TimeStamp).ToList();
if (orderedComments.Any())
{
List <CommentSockets> comments = new List <CommentSockets>();
foreach (var postComment in orderedComments)
{
UserShortVersion owner = new UserShortVersion {
UserId = postComment.Owner.Id,
UserFullName = postComment.Owner.Name
};
comments.Add(new CommentSockets
{
Id = postComment.Id,
Owner = owner,
Content = postComment.Content,
TimeStamp = postComment.TimeStamp
});
}
return(comments);
}
return(null);
}
}
public async Task <bool> EditPostAsync(PostShortVersion post)
{
using (ShapeAppDbContext ctx = new ShapeAppDbContext())
{
Post postDb = await ctx.Posts.FirstAsync(p => p.Id == post.Id);
if (post.Title != null)
{
postDb.Title = post.Title;
}
if (post.Content != null)
{
postDb.Content = post.Content;
}
try {
ctx.Posts.Update(postDb);
await ctx.SaveChangesAsync();
}
catch (Exception e) {
return(false);
}
return(true);
}
}
public async Task <int> AddPostAsync(PostShortVersion postShortVersion)
{
using (ShapeAppDbContext ctx = new ShapeAppDbContext())
{
User owner = await ctx.Users.FirstAsync(u => u.Id == postShortVersion.Owner.UserId);
Post post = new Post
{
Title = postShortVersion.Title,
Content = postShortVersion.Content,
Owner = owner,
TimeStamp = DateTime.Now,
HasImage = postShortVersion.HasImage
};
Console.WriteLine("adding post to db");
await ctx.Posts.AddAsync(post);
await ctx.SaveChangesAsync();
Console.WriteLine("post saved");
var newPost = await ctx.Posts.ToListAsync();
return(newPost.Last().Id);
}
}
public async Task <TrainingSocketsModelWithOwner> GetTrainingByIdAsync(int id)
{
using (ShapeAppDbContext ctx = new ShapeAppDbContext())
{
Training training;
try {
training = await ctx.Training.Where(t => t.Id == id)
.Include(t => t.Owner).FirstAsync();
}
catch (Exception e) {
return(null);
}
List <Exercise> exercises = ctx.TrainingExercises.Where(te => te.TrainingId == id)
.Select(te => te.Exercise).ToList();
SearchBarUser owner = new SearchBarUser
{
UserId = training.Owner.Id,
FullName = training.Owner.Name
};
return(new TrainingSocketsModelWithOwner
{
Duration = training.Duration,
Exercises = exercises,
Id = training.Id,
Completed = training.IsCompleted,
Global = training.IsPublic,
Owner = owner,
TimeStamp = training.TimeStamp,
Title = training.Title,
Type = training.Type
});
}
}
private int GetNumberOfTrainingsForExercise(int exerciseId)
{
using (ShapeAppDbContext ctx = new ShapeAppDbContext())
{
return(ctx.TrainingExercises.Count(te => te.ExerciseId == exerciseId));
}
}
public async Task <int> AddExerciseToTrainingAsync(ExerciseWithTraining exercise)
{
using (ShapeAppDbContext ctx = new ShapeAppDbContext())
{
bool exists = ctx.Exercise.Any(e => e.Id == exercise.Id);
int exerciseId;
if (exists)
{
exerciseId = exercise.Id;
}
else
{
await ctx.Exercise.AddAsync(new Exercise
{
Description = exercise.Description,
Title = exercise.Title
});
await ctx.SaveChangesAsync();
exerciseId = ctx.Exercise.ToList().Last().Id;
}
await ctx.TrainingExercises.AddAsync(new TrainingExercise
{
ExerciseId = exerciseId,
TrainingId = exercise.TrainingId
});
await ctx.SaveChangesAsync();
return(exerciseId);
}
}
public async Task <int> PostPageRatingAsync(ModelActionSockets modelActionSockets)
{
using (ShapeAppDbContext ctx = new ShapeAppDbContext())
{
PageRating pageRating = await ctx.PageRatings.FirstOrDefaultAsync(pr =>
pr.UserId == modelActionSockets.SenderId && pr.PageId == modelActionSockets.ReceiverId);
if (pageRating == null)
{
await ctx.PageRatings.AddAsync(new PageRating
{
UserId = modelActionSockets.SenderId,
PageId = modelActionSockets.ReceiverId,
Rating = int.Parse(modelActionSockets.Value.ToString())
});
}
else
{
pageRating.Rating = int.Parse(modelActionSockets.Value.ToString());
ctx.PageRatings.Update(pageRating);
}
await ctx.SaveChangesAsync();
return(0);
}
}
public async Task <int> AddUserAsync(UserSocketsModel user)
{
using (ShapeAppDbContext ctx = new ShapeAppDbContext())
{
try
{
await ctx.Users.AddAsync(new User
{
Address = user.Address,
City = user.City,
Description = user.Description,
Email = user.Email,
Name = user.Name,
Password = user.Password
});
await ctx.SaveChangesAsync();
}
catch (Exception e)
{
return(-1);
}
int userId = ctx.Users.First(u => u.Email.Equals(user.Email)).Id;
Console.WriteLine("Added user to database with id " + userId);
return(userId);
}
}
public async Task <List <UserShortVersion> > GetAdminUsersAsync(int limit, int offset)
{
using (ShapeAppDbContext ctx = new ShapeAppDbContext())
{
return(GetAdminUsersWithDbContextAsync(ctx, limit, offset));
}
}
public async Task <DietSocketsModelWithOwner> GetDietByIdAsync(int id)
{
using (ShapeAppDbContext ctx = new ShapeAppDbContext())
{
Diet diet;
try
{
diet = await ctx.Diet.Where(d => d.Id == id).Include(d => d.Owner).FirstAsync();
}
catch (Exception e)
{
return(null);
}
List <Meal> meals = ctx.DietMeals.Where(dm => dm.DietId == id).Select(dm => dm.Meal).ToList();
SearchBarUser owner = new SearchBarUser
{
UserId = diet.Owner.Id,
FullName = diet.Owner.Name
};
return(new DietSocketsModelWithOwner
{
Description = diet.Description,
Global = diet.IsPublic,
Id = diet.Id,
Meals = meals,
Owner = owner,
Title = diet.Title
});
}
}
public async Task <bool> DeleteDietAsync(int dietId)
{
using (ShapeAppDbContext ctx = new ShapeAppDbContext())
{
try
{
Diet diet = await ctx.Diet.FirstAsync(d => d.Id == dietId);
List <Meal> mealsForDiet = ctx.DietMeals.Where(dm => dm.DietId == dietId)
.Select(dm => dm.Meal).ToList();
foreach (var meal in mealsForDiet)
{
if (GetNumberOfDietsForMeal(meal.Id) == 1)
{
ctx.Meal.Remove(meal);
}
}
ctx.Diet.Remove(diet);
await ctx.SaveChangesAsync();
}
catch (Exception e)
{
return(false);
}
return(true);
}
}
private int GetNumberOfDietsForMeal(int mealId)
{
using (ShapeAppDbContext ctx = new ShapeAppDbContext())
{
return(ctx.DietMeals.Count(dm => dm.MealId == mealId));
}
}
public async Task <int> AddMealToDietAsync(MealWithDiet meal)
{
using (ShapeAppDbContext ctx = new ShapeAppDbContext())
{
bool exists = ctx.Meal.Any(m => m.Id == meal.Id);
int mealId;
if (exists)
{
mealId = meal.Id;
}
else
{
await ctx.Meal.AddAsync(new Meal
{
Title = meal.Title,
Description = meal.Description,
Calories = meal.Calories
});
await ctx.SaveChangesAsync();
mealId = ctx.Meal.ToList().Last().Id;
}
await ctx.DietMeals.AddAsync(new DietMeal
{
MealId = mealId,
DietId = meal.DietId
});
await ctx.SaveChangesAsync();
return(mealId);
}
}
public List <UserShortVersionWithMessage> GetLastMessagesForUser(int userId, int offset)
{
using (ShapeAppDbContext ctx = new ShapeAppDbContext())
{
return(GetLastMessagesForUserWithDbContext(ctx, userId, offset));
}
}
public async Task <bool> EditDietAsync(DietSocketsModel diet)
{
using (ShapeAppDbContext ctx = new ShapeAppDbContext())
{
Diet dietDb = await ctx.Diet.FirstAsync(d => d.Id == diet.Id);
if (!string.IsNullOrEmpty(diet.Title))
{
dietDb.Title = diet.Title;
}
if (!string.IsNullOrEmpty(diet.Description))
{
dietDb.Description = diet.Description;
}
dietDb.IsPublic = diet.Global;
try
{
ctx.Diet.Update(dietDb);
await ctx.SaveChangesAsync();
}
catch (Exception e)
{
return(false);
}
return(true);
}
}
public async Task <List <int> > AddMessageAsync(MessageSocketsModel message)
{
using (ShapeAppDbContext ctx = new ShapeAppDbContext())
{
List <int> ints = new List <int>();
if (message.HasImage && message.Content == null)
{
message.Content = "";
}
await ctx.Messages.AddAsync(new Message
{
Content = message.Content,
HasImage = message.HasImage,
ReceiverId = message.ReceiverId,
SenderId = message.SenderId,
TimeStamp = DateTime.Now
});
await ctx.SaveChangesAsync();
ints.Add(ctx.Messages.ToList().Last().Id);
await ctx.Notifications.AddAsync(new Notification {
SenderId = message.SenderId,
ReceiverId = message.ReceiverId,
NotificationType = ActionType.MESSAGE_CREATE.ToString()
});
await ctx.SaveChangesAsync();
ints.Add(ctx.Notifications.ToList().Last().Id);
return(ints);
}
}
/// <summary>
/// Method for seeding the user's user chat messages
/// </summary>
/// <param name="seededUserIds">the seeded users ids</param>
private static async Task SeedChat(int[] seededUserIds)
{
using (ShapeAppDbContext ctx = new ShapeAppDbContext())
{
for (int i = 0; i < seededUserIds.Length - 1; i++)
{
for (int j = i + 1; j < seededUserIds.Length; j++)
{
await ctx.Messages.AddAsync(new Message
{
SenderId = seededUserIds[i],
ReceiverId = seededUserIds[j],
Content = GetRandomString(),
HasImage = false,
TimeStamp = GetRandomDateTime(DateTime.Today.AddDays(-10))
});
await ctx.Messages.AddAsync(new Message
{
SenderId = seededUserIds[j],
ReceiverId = seededUserIds[i],
Content = GetRandomString(),
HasImage = false,
TimeStamp = GetRandomDateTime(DateTime.Today.AddDays(-10))
});
}
}
await ctx.SaveChangesAsync();
}
}
private List <User> GetCommonFriendsForUsers(int firstUserId, int secondUserId)
{
using (ShapeAppDbContext ctx = new ShapeAppDbContext())
{
List <User> firstUserFriends = new List <User>();
List <User> temp = ctx.Friendships.Where(fr => fr.FirstUserId == firstUserId)
.Select(fr => fr.SecondUser).ToList();
firstUserFriends.AddRange(temp);
temp = ctx.Friendships.Where(fr => fr.SecondUserId == firstUserId)
.Select(fr => fr.FirstUser).ToList();
firstUserFriends.AddRange(temp);
List <User> secondUserFriends = new List <User>();
temp = ctx.Friendships.Where(fr => fr.FirstUserId == secondUserId)
.Select(fr => fr.SecondUser).ToList();
secondUserFriends.AddRange(temp);
temp = ctx.Friendships.Where(fr => fr.SecondUserId == secondUserId)
.Select(fr => fr.FirstUser).ToList();
secondUserFriends.AddRange(temp);
List <User> commonFriends = new List <User>();
foreach (var friend in firstUserFriends)
{
if (secondUserFriends.Contains(friend))
{
commonFriends.Add(friend);
}
}
return(commonFriends);
}
}
public List <UserShortVersion> GetOnlineFriendsForUser(int userId)
{
using (ShapeAppDbContext ctx = new ShapeAppDbContext())
{
List <int> onlineFriendIds = new List <int>();
foreach (var onlineUserId in onlineUserIds)
{
if (UsersAreFriends(userId, onlineUserId))
{
onlineFriendIds.Add(onlineUserId);
}
}
if (!onlineFriendIds.Any())
{
return(null);
}
List <UserShortVersion> onlineFriends = new List <UserShortVersion>();
foreach (var onlineFriendId in onlineFriendIds)
{
string username = ctx.Users.First(u => u.Id == onlineFriendId).Name;
onlineFriends.Add(new UserShortVersion
{
UserId = onlineFriendId,
UserFullName = username
});
}
return(onlineFriends);
}
}
public async Task <int> AddTrainingAsync(TrainingSocketsModelWithOwner training)
{
using (ShapeAppDbContext ctx = new ShapeAppDbContext())
{
try
{
User owner = await ctx.Users.FirstAsync(u => u.Id == training.Owner.UserId);
Training trainingDb = new Training
{
Title = training.Title,
TimeStamp = training.TimeStamp,
Duration = training.Duration,
IsPublic = training.Global,
Type = training.Type,
Owner = owner
};
await ctx.Training.AddAsync(trainingDb);
await ctx.SaveChangesAsync();
int createdTrainingId = ctx.Training.ToList().Last().Id;
if (training.Exercises != null && training.Exercises.Any())
{
foreach (var exercise in training.Exercises)
{
int createdExerciseId;
if (exercise.Id > 0)
{
createdExerciseId = exercise.Id;
}
else
{
await ctx.Exercise.AddAsync(exercise);
await ctx.SaveChangesAsync();
createdExerciseId = ctx.Exercise.ToList().Last().Id;
}
await ctx.TrainingExercises.AddAsync(new TrainingExercise
{
ExerciseId = createdExerciseId,
TrainingId = createdTrainingId
});
await ctx.SaveChangesAsync();
}
}
return(createdTrainingId);
}
catch (Exception e)
{
return(-1);
}
}
}
public async Task <bool> EditMealInDiet(MealWithDiet meal)
{
using (ShapeAppDbContext ctx = new ShapeAppDbContext())
{
int mealFrequency = GetNumberOfDietsForMeal(meal.Id);
Meal mealDb = await ctx.Meal.FirstAsync(m => m.Id == meal.Id);
if (mealFrequency > 1)
{
await ctx.Meal.AddAsync(new Meal
{
Calories = mealDb.Calories,
Description = mealDb.Description,
Title = mealDb.Title
});
await ctx.SaveChangesAsync();
int mealId = ctx.Meal.ToList().Last().Id;
Console.WriteLine("New meal id is " + mealId);
var dietMeals = ctx.DietMeals.Where(dm => dm.MealId == meal.Id &&
dm.Diet.Id != meal.DietId).ToList();
foreach (var dietMeal in dietMeals)
{
ctx.DietMeals.Remove(dietMeal);
await ctx.DietMeals.AddAsync(new DietMeal
{
DietId = dietMeal.DietId,
MealId = mealId
});
}
}
if (meal.Calories >= 0)
{
mealDb.Calories = meal.Calories;
}
if (!string.IsNullOrEmpty(meal.Description))
{
mealDb.Description = meal.Description;
}
if (!string.IsNullOrEmpty(meal.Title))
{
mealDb.Title = meal.Title;
}
try
{
ctx.Meal.Update(mealDb);
await ctx.SaveChangesAsync();
}
catch (Exception e)
{
return(false);
}
return(true);
}
}
public List <int> GetPostIdsForUser(int userId)
{
using (ShapeAppDbContext ctx = new ShapeAppDbContext())
{
return(ctx.Posts.Where(p => p.Owner.Id == userId)
.Select(p => p.Id).ToList());
}
}
