public async Task <IndexedResult <IEnumerable <UserVM> > > SearchUsersAsync(
Guid userId,
IndexedResult <UserSearchVM> searchArgumentsVM,
int takeAmount = Constants.DEFAULT_DB_TAKE_VALUE)
{
var searchResultTask = _userRepository.GetUsersByQueryAsync(
searchArgumentsVM.Result.Query,
searchArgumentsVM.Index,
takeAmount);
var friendsIdsTask = _friendRepository.GetFriendsIdsAsync(userId);
await Task.WhenAll(searchResultTask, friendsIdsTask);
var searchResultVM = _mapper.Map <ICollection <UserVM> >(searchResultTask.Result);
SetIsFriendField(friendsIdsTask.Result, searchResultVM);
return(new IndexedResult <IEnumerable <UserVM> >
{
Result = searchResultVM,
Index = searchArgumentsVM.Index + searchResultVM.Count,
IsLast = searchResultVM.Count != takeAmount
});
}
public async Task <IndexedResult <IEnumerable <UserVM> > > GetFriendsAsync(
Guid userId,
IndexedResult <UserVM> lastReturned,
int takeAmount = Constants.DEFAULT_DB_TAKE_VALUE)
{
if (lastReturned != null && lastReturned.IsLast)
{
return(null);
}
var usersVM = _mapper.Map <ICollection <UserVM> >(
await _friendRepository.GetFriendsAsync(userId, lastReturned?.Index ?? 0, takeAmount));
foreach (var user in usersVM)
{
user.IsFriend = true;
}
return(new IndexedResult <IEnumerable <UserVM> >()
{
Result = usersVM,
Index = lastReturned?.Index ?? 0 + usersVM.Count,
IsLast = usersVM.Count != takeAmount
});
}
public async Task <IActionResult> SearchMealIngredients([FromBody] IndexedResult <MealIngredientSearchVM> lastReturned)
{
if (lastReturned != null && lastReturned.IsLast)
{
return(NotFound("Invalid arguments"));
}
var result = await _searchService.SearchMealIngredientsAsync(lastReturned);
return(Ok(result));
}
public async Task <IActionResult> GetUsersActivities([FromBody] IndexedResult <UserActivityVM> lastReturned)
{
if (lastReturned != null && lastReturned.IsLast)
{
return(NotFound("Invalid arguments"));
}
var activities = await _adminService.GetUsersActivitiesAsync(lastReturned);
return(Ok(activities));
}
public async Task <IActionResult> SearchUsers([FromBody] IndexedResult <UserSearchVM> lastReturned)
{
if (lastReturned != null && lastReturned.IsLast)
{
return(BadRequest("Invalid arguments"));
}
var loggedUserId = new Guid(User.Identity.Name);
var result = await _searchService.SearchUsersAsync(loggedUserId, lastReturned);
return(Ok(result));
}
public async Task <IActionResult> GetNewsFeed([FromBody] IndexedResult <UserActivityVM> lastReturned)
{
if (lastReturned != null && lastReturned.IsLast)
{
return(NotFound("Invalid arguments"));
}
var userId = new Guid(User.Identity.Name);
var newsFeed = await _friendService.GetFriendsActivitiesFeedAsync(userId, lastReturned);
return(Ok(newsFeed));
}
public async Task <IActionResult> SearchMeals([FromBody] IndexedResult <MealSearchVM> lastReturned)
{
if (lastReturned != null && lastReturned.IsLast)
{
return(NotFound("Invalid arguments"));
}
var userId = new Guid(User.Identity.Name);
var result = await _searchService.SearchMealsAsync(userId, lastReturned);
return(Ok(result));
}
public async Task <IActionResult> GetMealPreviewsForUser([FromBody] IndexedResult <MealPreviewVM> lastReturned)
{
if (lastReturned != null && lastReturned.IsLast)
{
return(NotFound("Invalid arguments"));
}
var userId = new Guid(User.Identity.Name);
var result = await _mealService.GetUsersMealsPreviewsAsync(userId, lastReturned);
return(Ok(result));
}
public async Task <IndexedResult <IEnumerable <UserActivityVM> > > GetFriendsActivitiesFeedAsync(
Guid userId,
IndexedResult <UserActivityVM> lastReturned,
int takeAmount = Constants.DEFAULT_DB_TAKE_VALUE)
{
var indexedFriendsActivities = await _activityRepository.GetUsersFriendsActivitiesAsync(userId, lastReturned?.Index ?? 0, takeAmount);
return(new IndexedResult <IEnumerable <UserActivityVM> >()
{
Result = _mapper.Map <IEnumerable <UserActivityVM> >(indexedFriendsActivities),
Index = lastReturned?.Index ?? 0 + indexedFriendsActivities.Count,
IsLast = indexedFriendsActivities.Count != takeAmount
});
}
public async Task <IndexedResult <ICollection <UserActivityVM> > > GetUserActivitiesAsync(
Guid userId,
IndexedResult <UserActivityVM> lastReturned,
int takeAmount = Constants.DEFAULT_DB_TAKE_VALUE)
{
var usersActivities = await _activityRepository.GetUserActivitiesAsync(userId, lastReturned?.Index ?? 0, takeAmount);
return(new IndexedResult <ICollection <UserActivityVM> >()
{
Result = _mapper.Map <ICollection <UserActivityVM> >(usersActivities),
Index = lastReturned?.Index ?? 0 + usersActivities.Count,
IsLast = usersActivities.Count != takeAmount
});
}
public async Task <IndexedResult <IEnumerable <MealPreviewVM> > > GetFavouriteMealsAsync(
Guid userId,
IndexedResult <MealPreviewVM> lastReturned,
int takeAmount = Constants.DEFAULT_DB_TAKE_VALUE
)
{
var usersFavourites = await _favouriteRepository.GetUserFavouritesAsync(userId, lastReturned?.Index ?? 0, takeAmount);
return(new IndexedResult <IEnumerable <MealPreviewVM> >()
{
Result = _mapper.Map <IEnumerable <MealPreviewVM> >(usersFavourites),
Index = lastReturned?.Index ?? 0 + usersFavourites.Count,
IsLast = usersFavourites.Count != takeAmount
});
}
public async Task <IActionResult> GetFavouriteMeals(IndexedResult <MealPreviewVM> lastReturned)
{
if (lastReturned != null && lastReturned.IsLast)
{
return(NotFound("Invalid arguments"));
}
var userId = new Guid(User.Identity.Name);
var favourites = await _favouritesService.GetFavouriteMealsAsync(userId, lastReturned);
if (favourites == null)
{
return(NotFound());
}
return(Ok(favourites));
}
public async Task <IndexedResult <IEnumerable <MealIngredientVM> > > SearchMealIngredientsAsync(
IndexedResult <MealIngredientSearchVM> searchArgumentsVM,
int takeAmount = Constants.DEFAULT_DB_TAKE_VALUE)
{
var searchResult = _mapper.Map <ICollection <MealIngredientVM> >(
await _mealIngredientRepository.GetMealIngredientsByQueryAsync(
searchArgumentsVM.Result.Query,
searchArgumentsVM.Index,
takeAmount)
);
return(new IndexedResult <IEnumerable <MealIngredientVM> >
{
Result = searchResult,
Index = searchArgumentsVM.Index + searchResult.Count,
IsLast = searchResult.Count != takeAmount
});
}
public async Task <IActionResult> GetInvitations([FromBody] IndexedResult <AwaitingFriendInvitationVM> lastReturned)
{
if (lastReturned != null && lastReturned.IsLast)
{
return(NotFound("Invalid arguments"));
}
var userId = new Guid(User.Identity.Name);
var friendInvitations = await _friendService.GetFriendInvitationsAsync(userId, lastReturned);
if (friendInvitations == null)
{
return(NotFound());
}
return(Ok(friendInvitations));
}
public async Task <IndexedResult <IEnumerable <AwaitingFriendInvitationVM> > > GetFriendInvitationsAsync(
Guid userId,
IndexedResult <AwaitingFriendInvitationVM> lastReturned,
int takeAmount = Constants.DEFAULT_DB_TAKE_VALUE)
{
if (lastReturned != null && lastReturned.IsLast)
{
return(null);
}
var friends = await _friendRepository.GetFriendsAsync(userId, lastReturned?.Index ?? 0, takeAmount, Models.Enums.FriendInvitationStatus.Awaiting);
return(new IndexedResult <IEnumerable <AwaitingFriendInvitationVM> >()
{
Result = _mapper.Map <IEnumerable <AwaitingFriendInvitationVM> >(friends),
Index = lastReturned?.Index ?? 0 + friends.Count,
IsLast = friends.Count != takeAmount
});
}
public async Task <IndexedResult <IEnumerable <MealPreviewVM> > > SearchMealsAsync(
Guid userId,
IndexedResult <MealSearchVM> searchArgumentsVM,
int takeAmount = Constants.DEFAULT_DB_TAKE_VALUE)
{
var searchTask = _mealRepository.GetMealPreviewsByQueryAsync(
searchArgumentsVM.Result.Query,
searchArgumentsVM.Index,
takeAmount
);
var favouritesTask = _favouritesRepository.GetUserFavouritesAsync(
userId,
0,
int.MaxValue,
searchArgumentsVM.Result.Query);
await Task.WhenAll(searchTask, favouritesTask);
if (!searchTask.Result.Any())
{
return(new IndexedResult <IEnumerable <MealPreviewVM> >
{
Result = Enumerable.Empty <MealPreviewVM>(),
Index = 0,
IsLast = true
});
}
var searchResultVM = _mapper.Map <IEnumerable <MealPreviewVM> >(searchTask.Result);
SetIsFavouriteField(userId, favouritesTask.Result, searchResultVM);
return(new IndexedResult <IEnumerable <MealPreviewVM> >
{
Result = searchResultVM,
Index = searchArgumentsVM.Index + searchTask.Result.Count,
IsLast = searchTask.Result.Count != takeAmount
});
}
public async Task <IndexedResult <IEnumerable <MealPreviewVM> > > GetUsersMealsPreviewsAsync(
Guid userId,
IndexedResult <MealPreviewVM> lastReturned,
int takeAmount = Constants.DEFAULT_DB_TAKE_VALUE
)
{
var userMealPreviews = await _mealRepository.GetMealPreviewsAsync(userId, lastReturned?.Index ?? 0, takeAmount);
var userFavourites = await _favouritesRepository.GetUserFavouritesAsync(
userId,
0,
int.MaxValue);
var mealPreviewsVM = _mapper.Map <IEnumerable <MealPreviewVM> >(userMealPreviews);
SetIsFavourite(userFavourites, mealPreviewsVM);
return(new IndexedResult <IEnumerable <MealPreviewVM> >()
{
Result = mealPreviewsVM,
Index = (lastReturned?.Index ?? 0) + userMealPreviews.Count,
IsLast = userMealPreviews.Count != takeAmount
});
}
