public void GetAllParticipants_ShouldThrow_IfUserIsNotCreator()
{
var coursesRepoBuilder = new CoursesRepositoryBuilder();
var courseRepo = coursesRepoBuilder
.WithAll()
.Build();
var coursesUsersRepoBuilder = new CoursesUsersRepositoryBuilder();
var coursUserRepo = coursesUsersRepoBuilder
.WithAll()
.Build();
var sut = new CoursesService(coursUserRepo, courseRepo, null, Mapper);
var user = new GoUser {
Id = "9"
};
var ex = Assert.Throws <ArgumentException>(() => sut.GetAllParticipants("1", user));
Assert.Equal("You can not add results!", ex.Message);
coursesRepoBuilder.CoursesRepoMock.Verify();
coursesUsersRepoBuilder.CoursesUsersRepoMock.Verify();
}
public async Task UserStartGame(string id, GoUser user)
{
var game = this.gamesRepository.All().FirstOrDefault(x => x.Id == id);
var levels = this.levelsRepository.All().Where(x => x.GameId == id).OrderBy(x => x.NumberInGame).ToList();
if (game == null)
{
throw new ArgumentException(GameDoNotExist);
}
else if (this.levelsParticipantRepository.All().FirstOrDefault(x => x.ParticipantId == user.Id && x.GameId == game.Id) == null)
{
var gamesLevelsUsers = levels.Select(x => new GameLevelParticipant
{
GameId = game.Id,
Game = game,
ParticipantId = user.Id,
LevelId = x.Id,
Level = x,
StatusLevel = (StatusLevel)2
}).ToList();
await this.levelsParticipantRepository.AddRangeAsync(gamesLevelsUsers);
await this.levelsParticipantRepository.SaveChangesAsync();
}
}
public async Task DeleteCourse_ShouldNotDeleteCourse_WhenCourseNotExist()
{
Course deletedCourse = null;
var courseRepoBuilder = new CoursesRepositoryBuilder();
courseRepoBuilder.CoursesRepoMock.Setup(r => r.Delete(It.IsAny <Course>()))
.Callback <Course>(c => deletedCourse = c);
var courseRepo = courseRepoBuilder
.WithAll()
.Build();
var sut = new CoursesService(null, courseRepo, null, Mapper);
var user = new GoUser {
Id = "9"
};
await sut.DeleteCourse("7", user);
Assert.Null(deletedCourse);
courseRepoBuilder.CoursesRepoMock.Verify();
courseRepoBuilder.CoursesRepoMock.Verify(d => d.Delete(It.IsAny <Course>()), Times.Exactly(0));
courseRepoBuilder.CoursesRepoMock.Verify(d => d.SaveChangesAsync(), Times.Exactly(0));
}
public async Task EditCourse_ShouldNotEditCourseIf_UserIsNotCreator()
{
var user = new GoUser {
Id = "2"
};
var coursesRepoBuilder = new CoursesRepositoryBuilder();
var courseRepo = coursesRepoBuilder
.WithAll()
.Build();
var sut = new CoursesService(null, courseRepo, null, Mapper);
var editCourseViewModel = new EditCourseViewModel
{
Id = "2",
Image = SetupFileMock().Object,
Title = "Edit",
Description = "Brr",
MaxCountParticipants = 7,
StartDate = DateTime.Now.AddDays(2),
DurationOfDays = 5,
Status = Status.Practically,
Category = Category.Other
};
await sut.EditCourse(editCourseViewModel, user);
coursesRepoBuilder.CoursesRepoMock.Verify(d => d.SaveChangesAsync(), Times.Exactly(0));
}
public async Task DeleteCourse_ShouldDeleteCourseCorrectly_IfCourseexist_AndUserIsCreator()
{
Course deletedCourse = null;
var courseRepoBuilder = new CoursesRepositoryBuilder();
courseRepoBuilder.CoursesRepoMock.Setup(r => r.Delete(It.IsAny <Course>()))
.Callback <Course>(c => deletedCourse = c);
var courseRepo = courseRepoBuilder
.WithAll()
.Build();
var sut = new CoursesService(null, courseRepo, null, Mapper);
var user = new GoUser {
Id = "9"
};
await sut.DeleteCourse("2", user);
Assert.Equal("2", deletedCourse.Id);
courseRepoBuilder.CoursesRepoMock.Verify();
courseRepoBuilder.CoursesRepoMock.Verify(d => d.Delete(It.IsAny <Course>()), Times.Once);
courseRepoBuilder.CoursesRepoMock.Verify(d => d.SaveChangesAsync(), Times.Once);
}
public async Task AddUserToCourse_ShouldNotAddNew_CourseUser_WhenMaxCountParticipantsIsFully()
{
var coursesRepoBuilder = new CoursesRepositoryBuilder();
var courseRepo = coursesRepoBuilder
.WithAll()
.Build();
var coursesUsersRepoBuilder = new CoursesUsersRepositoryBuilder();
var courseUserRepo = coursesUsersRepoBuilder
.WithAll()
.Build();
var sut = new CoursesService(courseUserRepo, courseRepo, null, Mapper);
var user = new GoUser {
Id = "7"
};
var user1 = new GoUser {
Id = "8"
};
await sut.AddUserToCourse("1", user);
await sut.AddUserToCourse("1", user1);
coursesUsersRepoBuilder.CoursesUsersRepoMock.Verify(r => r.AddAsync(It.IsAny <CoursesUsers>()), Times.Exactly(1));
coursesUsersRepoBuilder.CoursesUsersRepoMock.Verify(r => r.SaveChangesAsync(), Times.Exactly(1));
}
public async Task AddResultToUsersCourses(UsersResultsViewModel model, GoUser user)
{
var userCouse = this.coursesUsersRepository.All()
.FirstOrDefault(x => x.CourseId == model.CourseId && x.ParticipantId == model.ParticipantId);
var course = this.coursesRepository.All().FirstOrDefault(x => x.Id == model.CourseId);
if (userCouse == null)
{
throw new ArgumentException(UserCourseNotExistException);
}
if (course.CreatorId != user.Id)
{
throw new ArgumentException(YouCanNotAddResultsException);
}
userCouse.StatusUser = model.Result;
if (course.StartDate.AddDays(course.DurationOfDays) > DateTime.Now)
{
throw new ArgumentException(CourseIsNotFinished);
}
await this.coursesUsersRepository.SaveChangesAsync();
}
public async Task AddLevelResult(GameLevelParticipantViewModel model, GoUser user)
{
var gameLevelParticipant = this.levelsParticipantRepository.All()
.FirstOrDefault(x => x.GameId == model.GameId && x.LevelId == model.LevelId &&
x.ParticipantId == model.ParticipantId);
if (gameLevelParticipant == null)
{
throw new ArgumentException(ThisGameLevelParticipantNotExist);
}
gameLevelParticipant.StatusLevel = model.StatusLevel;
if (model.StatusLevel == StatusLevel.SuccessfullyPassed)
{
var participant = this.usersRepository.All().FirstOrDefault(x => x.Id == model.ParticipantId);
var level = this.levelsRepository.All().FirstOrDefault(l => l.Id == model.LevelId);
participant.Points += level.Points;
await this.usersRepository.SaveChangesAsync();
}
await this.levelsParticipantRepository.SaveChangesAsync();
}
public async Task AddCommentToThem_ShouldThrow_IfThemNotExist()
{
var themsRepoBuilder = new ThemsRepositoryBuilder();
var themsRepo = themsRepoBuilder
.WithAll()
.Build();
var themCommentRepoBuilder = new ThemCommentsRepositoryBuilder();
var themCommentsRepo = themCommentRepoBuilder
.WithAll()
.Build();
var sut = new ThemService(themsRepo, null, themCommentsRepo, Mapper);
var model = new CreateThemViewModel
{
Description = "TraLaLA"
};
var user = new GoUser {
Id = "7"
};
var ex = await Assert.ThrowsAsync <ArgumentException>(async() => await sut.AddCommentToThem("5", "New themComment", user));
Assert.Equal("Theme not exist!", ex.Message);
themCommentRepoBuilder.ThemCommentsRepoMock.Verify(r => r.AddAsync(It.IsAny <ThemComment>()), Times.Never);
themCommentRepoBuilder.ThemCommentsRepoMock.Verify(r => r.SaveChangesAsync(), Times.Never);
}
public async Task LikeStory(string id, GoUser user) //id(storyId)
{
var story = this.storiesRepository.All().FirstOrDefault(x => x.Id == id);
if (story == null)
{
throw new ArgumentException(StoryNotExist);
}
var userStory = new PeopleStories
{
Story = story,
StoryId = story.Id,
User = user,
UserId = user.Id
};
story.PeopleWhosLikeThis.Add(userStory);
if (peopleStoriesRepository.All().FirstOrDefault(x => x.StoryId == userStory.StoryId && x.UserId == userStory.UserId) == null)
{
await this.peopleStoriesRepository.AddAsync(userStory);
await this.peopleStoriesRepository.SaveChangesAsync();
await this.storiesRepository.SaveChangesAsync();
}
}
public async Task AddStory_ShouldThrow_IfDestinationNotExist()
{
var destRepoBuilder = new DestinationsRepositoryBuilder();
var destRepo = destRepoBuilder
.WithAll()
.Build();
var storiesRepoBuilder = new StoriesRepositoryBuilder();
var storiesRepo = storiesRepoBuilder
.WithAll()
.Build();
var sut = new StoriesService(storiesRepo, destRepo, null, null, Mapper);
var createStoryViewModel = new CreateStoryViewModel
{
Content = "Niki otiva na ski",
Title = "Niki",
DestinationId = "11",
};
var user = new GoUser {
Id = "7"
};
var ex = await Assert.ThrowsAsync <ArgumentException>(async() => await sut.AddStory(createStoryViewModel, "11", user));
Assert.Equal("Destination not exist!", ex.Message);
storiesRepoBuilder.StoriesRepoMock.Verify(r => r.AddAsync(It.IsAny <Story>()), Times.Never);
storiesRepoBuilder.StoriesRepoMock.Verify(r => r.SaveChangesAsync(), Times.Never);
}
public ThemDetailsViewModel GetDetails(string themId, GoUser user)
{
var them = this.themsRepository.All().FirstOrDefault(x => x.Id == themId);
if (them == null)
{
throw new ArgumentException(ThemeNotExist);
}
var themModel = mapper.Map <ThemDetailsViewModel>(them);
var author = this.usersRepository.All().FirstOrDefault(x => x.Id == them.AuthorId);
themModel.Author = author.FirstName + SpaceSeparetedUsersFirstAndLastName + author.LastName;
var themComments = this.themCommentsRepository.All().Where(x => x.ThemId == themId)
.Select(x => mapper.Map <ThemCommentViewModel>(x)).ToList();
themComments.ForEach(x => x.Author = this.usersRepository.All().FirstOrDefault(u => u.Id == x.AuthorId).FirstName +
SpaceSeparetedUsersFirstAndLastName + this.usersRepository.All()
.FirstOrDefault(u => u.Id == x.AuthorId).LastName);
themModel.Comments = themComments;
return(themModel);
}
public async Task LikeStory_ShouldThrow_IfStoryNotExist()
{
var storiesRepoBuilder = new StoriesRepositoryBuilder();
var storiesRepo = storiesRepoBuilder
.WithAll()
.Build();
var userStoriesRepoBuilder = new PeopleStoriesRepositoryBuilder();
var userStoriesRepo = userStoriesRepoBuilder
.WithAll()
.Build();
var sut = new StoriesService(storiesRepo, null, userStoriesRepo, null, Mapper);
var user = new GoUser {
Id = "7"
};
var ex = await Assert.ThrowsAsync <ArgumentException>(async() => await sut.LikeStory("17", user));
Assert.Equal("Story not exist!", ex.Message);
storiesRepoBuilder.StoriesRepoMock.Verify();
userStoriesRepoBuilder.PeopleStoriesRepoMock.Verify(d => d.AddAsync(It.IsAny <PeopleStories>()), Times.Never);
userStoriesRepoBuilder.PeopleStoriesRepoMock.Verify(d => d.SaveChangesAsync(), Times.Never);
}
public async Task LikeStory_ShouldNotAddUserStory_IfUserStoryAureadyExist()
{
var storiesRepoBuilder = new StoriesRepositoryBuilder();
var storiesRepo = storiesRepoBuilder
.WithAll()
.Build();
var userStoriesRepoBuilder = new PeopleStoriesRepositoryBuilder();
var userStoriesRepo = userStoriesRepoBuilder
.WithAll()
.Build();
var sut = new StoriesService(storiesRepo, null, userStoriesRepo, null, Mapper);
var user = new GoUser {
Id = "9"
};
await sut.LikeStory("7", user);
storiesRepoBuilder.StoriesRepoMock.Verify();
userStoriesRepoBuilder.PeopleStoriesRepoMock.Verify(d => d.AddAsync(It.IsAny <PeopleStories>()), Times.Never);
userStoriesRepoBuilder.PeopleStoriesRepoMock.Verify(d => d.SaveChangesAsync(), Times.Never);
}
public void GetDetails_ShouldReturnCorrect_ListFrom_StoriesViewModel()
{
var user = new GoUser {
Id = "1"
};
var sut = SetupGetDetailsSut();
var actual = sut.GetDetails("2", user);
var usersRepoBuilder = new GoUserRepositoryBuilder();
var usersRepo = usersRepoBuilder
.WithAll()
.Build();
var expected = new List <StoryViewModel>
{
new StoryViewModel
{
Id = "7", DestinationId = "2", AuthorId = "8", Author = "Niki", Title = "Mrun", PeopleWhosLikeThis = 2
},
new StoryViewModel
{
Id = "8", DestinationId = "2", AuthorId = "9", Author = "Pelin", Title = "Drun", PeopleWhosLikeThis = 0
},
new StoryViewModel
{
Id = "9", DestinationId = "2", AuthorId = "10", Author = "Saso", Title = "Brum", PeopleWhosLikeThis = 1
}
};
Assert.Equal(expected, actual.Stories, new StoriesViewModelComparer());
}
public async Task UserStartGame_ShouldThrowIfGameNotExist()
{
var gameRepoBuilder = new GameRepositoryBuilder();
var gameRepo = gameRepoBuilder
.WithAll()
.Build();
var levelsRepoBuilder = new LevelRepositoryBuilder();
var levelRepo = levelsRepoBuilder
.WithAll()
.Build();
var levelsParticipantsRepoBuilder = new GameLevelParticipantRepositoryBuilder();
var levelsParticipantsRepo = levelsParticipantsRepoBuilder
.WithAll()
.Build();
var sut = new GamesService(gameRepo, levelRepo, levelsParticipantsRepo, null, Mapper);
var user = new GoUser {
Id = "1"
};
var ex = await Assert.ThrowsAsync <ArgumentException>(async() => await sut.UserStartGame("11", user));
Assert.Equal("Game do not exist!", ex.Message);
levelsParticipantsRepoBuilder.LevelParticipantRepoMock.Verify(r => r.AddRangeAsync(It.IsAny <List <GameLevelParticipant> >()), Times.Never);
levelsParticipantsRepoBuilder.LevelParticipantRepoMock.Verify(r => r.SaveChangesAsync(), Times.Never);
gameRepoBuilder.GamesRepoMock.Verify();
levelsRepoBuilder.LevelsRepoMock.Verify();
}
public void GetDetails_ShouldReturnCorrect_ListFrom_UsersNotKnowAnyone()
{
var user = new GoUser {
Id = "1"
};
var sut = SetupGetDetailsSut();
var actual = sut.GetDetails("2", user);
var usersRepoBuilder = new GoUserRepositoryBuilder();
var usersRepo = usersRepoBuilder
.WithAll()
.Build();
var expected = new List <GoUserViewModel>
{
new GoUserViewModel {
Id = "9", FirstName = "Pelin", Image = usersRepo.All()
.FirstOrDefault(x => x.Id == "9").Image
},
new GoUserViewModel {
Id = "10", FirstName = "Saso", Image = usersRepo.All()
.FirstOrDefault(x => x.Id == "10").Image
},
new GoUserViewModel {
Id = "11", FirstName = "Koni", Image = usersRepo.All()
.FirstOrDefault(x => x.Id == "11").Image
},
};
Assert.Equal(expected, actual.ParticipantsNotKnowAnyone, new GoUserViewModelComparer());
}
public void GetDetails_ShouldReturnCorrect_ListFrom_ParticipantsKnowSomeone()
{
var user = new GoUser {
Id = "1"
};
var sut = SetupGetDetailsSut();
var actual = sut.GetDetails("2", user);
var usersRepoBuilder = new GoUserRepositoryBuilder();
var usersRepo = usersRepoBuilder
.WithAll()
.Build();
var expected = new List <GoUserViewModel>
{
new GoUserViewModel {
Id = "7", FirstName = "Slavqna", Image = ConvertImageToByteArray(SetupFileMock().Object)
}, //!!!! inage
new GoUserViewModel {
Id = "8", FirstName = "Niki", Image = ConvertImageToByteArray(SetupFileMock().Object)
}
};
Assert.Equal(expected, actual.ParticipantsKnowSomeone, new GoUserViewModelComparer());
}
public async Task EditCourse(EditCourseViewModel model, GoUser user)
{
byte[] file = null;
if (model.Image.Length > 0)
{
using (var ms = new MemoryStream())
{
model.Image.CopyTo(ms);
file = ms.ToArray();
}
}
var course = this.coursesRepository.All().FirstOrDefault(x => x.Id == model.Id);
if (course != null && course.CreatorId == user.Id)
{
course.Image = file;
course.Title = model.Title;
course.Description = model.Description;
course.StartDate = model.StartDate;
course.MaxCountParticipants = model.MaxCountParticipants;
course.DurationOfDays = model.DurationOfDays;
course.CountOfHours = model.CountOfHours;
course.Category = model.Category;
course.Status = model.Status;
await this.coursesRepository.SaveChangesAsync();
}
}
public void FindMyDestinations_ShouldReturn_CorrectCountOf_DestViewModels()
{
var user = new GoUser {
Id = "1"
};
var destUserRepoBuilder = new DestinationsUsersRepositoryBuilder();
var destUserRepo = destUserRepoBuilder
.WithAll()
.Build();
var sut = new DestinationService(null, destUserRepo, null, null, null, null, null, this.Mapper);
var actual = sut.FindMyDestinations(user);
var expected = new List <DestViewModel>
{
new DestViewModel {
Id = "1"
}
}.AsQueryable();
Assert.Equal(expected.Count(), actual.Count());
destUserRepoBuilder.DestUsersRepoMock.Verify();
destUserRepoBuilder.DestUsersRepoMock.Verify(d => d.AddAsync(It.IsAny <DestinationsUsers>()), Times.Never);
destUserRepoBuilder.DestUsersRepoMock.Verify(d => d.SaveChangesAsync(), Times.Never);
}
public async Task AddCommentToThem_ShouldAddNewThemComment_Correctly()
{
var themsRepoBuilder = new ThemsRepositoryBuilder();
var themsRepo = themsRepoBuilder
.WithAll()
.Build();
var themCommentRepoBuilder = new ThemCommentsRepositoryBuilder();
var themCommentsRepo = themCommentRepoBuilder
.WithAll()
.Build();
var sut = new ThemService(themsRepo, null, themCommentsRepo, Mapper);
var model = new CreateThemViewModel
{
Description = "TraLaLA"
};
var user = new GoUser {
Id = "7"
};
await sut.AddCommentToThem("3", "New themComment", user);
themCommentRepoBuilder.ThemCommentsRepoMock.Verify(r => r.AddAsync(It.IsAny <ThemComment>()), Times.Once);
themCommentRepoBuilder.ThemCommentsRepoMock.Verify(r => r.SaveChangesAsync(), Times.Once);
}
public void GetDetails_ShouldThrow_IfThemNotExist()
{
var themsRepoBuilder = new ThemsRepositoryBuilder();
var themsRepo = themsRepoBuilder
.WithAll()
.Build();
var themCommentRepoBuilder = new ThemCommentsRepositoryBuilder();
var themCommentsRepo = themCommentRepoBuilder
.WithAll()
.Build();
var usersRepoBuilder = new GoUserRepositoryBuilder();
var usersRepo = usersRepoBuilder
.WithAll()
.Build();
var sut = new ThemService(themsRepo, usersRepo, themCommentsRepo, Mapper);
var user = new GoUser {
Id = "7"
};
var ex = Assert.Throws <ArgumentException>(() => sut.GetDetails("7", user));
Assert.Equal("Theme not exist!", ex.Message);
themsRepoBuilder.ThemsRepoMock.Verify();
}
public async Task UserStartGame_ShouldDoNotAddUserToGame_IfUserAureadyExistInThisGame()
{
var gameRepoBuilder = new GameRepositoryBuilder();
var gameRepo = gameRepoBuilder
.WithAll()
.Build();
var levelsRepoBuilder = new LevelRepositoryBuilder();
var levelRepo = levelsRepoBuilder
.WithAll()
.Build();
var levelsParticipantsRepoBuilder = new GameLevelParticipantRepositoryBuilder();
var levelsParticipantsRepo = levelsParticipantsRepoBuilder
.WithAll()
.Build();
var sut = new GamesService(gameRepo, levelRepo, levelsParticipantsRepo, null, Mapper);
var user = new GoUser {
Id = "10"
};
await sut.UserStartGame("7", user);
levelsParticipantsRepoBuilder.LevelParticipantRepoMock.Verify(r => r.AddRangeAsync(It.IsAny <List <GameLevelParticipant> >()), Times.Never);
levelsParticipantsRepoBuilder.LevelParticipantRepoMock.Verify(r => r.SaveChangesAsync(), Times.Never);
gameRepoBuilder.GamesRepoMock.Verify();
levelsRepoBuilder.LevelsRepoMock.Verify();
levelsParticipantsRepoBuilder.LevelParticipantRepoMock.Verify();
}
public ICollection <DestViewModel> FindMyDestinations(GoUser user)
{
var destModels = this.destUsersRepository.All().Where(x => x.ParticipantId == user.Id)
.Select(d => mapper.Map <DestViewModel>(d.Destination)).ToList();
return(destModels);
}
public async Task AddStory_ShouldAddNewStoryCorrectly()
{
var destRepoBuilder = new DestinationsRepositoryBuilder();
var destRepo = destRepoBuilder
.WithAll()
.Build();
var storiesRepoBuilder = new StoriesRepositoryBuilder();
var storiesRepo = storiesRepoBuilder
.WithAll()
.Build();
var sut = new StoriesService(storiesRepo, destRepo, null, null, Mapper);
var createStoryViewModel = new CreateStoryViewModel
{
Content = "Niki otiva na ski",
Title = "Niki",
DestinationId = "2",
};
var user = new GoUser {
Id = "7"
};
await sut.AddStory(createStoryViewModel, "2", user);
storiesRepoBuilder.StoriesRepoMock.Verify(r => r.AddAsync(It.IsAny <Story>()), Times.Once);
storiesRepoBuilder.StoriesRepoMock.Verify(r => r.SaveChangesAsync(), Times.Once);
}
public async Task <string> AddGame(CreateGameViewModel model, GoUser user)
{
byte[] imageLevel1 = ImageAsBytes(model.Level1.Image);
byte[] imageLevel2 = ImageAsBytes(model.Level2.Image);
byte[] imageLevel3 = ImageAsBytes(model.Level3.Image);
var game = new Game
{
Name = model.Name,
Description = model.Description,
Image = imageLevel3,
CreatorId = user.Id
};
await this.gamesRepository.AddAsync(game);
await this.gamesRepository.SaveChangesAsync();
var level1 = new Level
{
Image = imageLevel1,
Description = model.Level1.Description,
NumberInGame = model.Level1.NumberInGame,
GameId = game.Id,
Game = game,
Points = model.Level1.Points
};
var level2 = new Level
{
Image = imageLevel2,
Description = model.Level2.Description,
NumberInGame = model.Level2.NumberInGame,
GameId = game.Id,
Game = game,
Points = model.Level2.Points
};
var level3 = new Level
{
Image = imageLevel3,
Description = model.Level3.Description,
NumberInGame = model.Level3.NumberInGame,
GameId = game.Id,
Game = game,
Points = model.Level3.Points
};
await this.levelsRepository.AddAsync(level1);
await this.levelsRepository.AddAsync(level2);
await this.levelsRepository.AddAsync(level3);
await this.levelsRepository.SaveChangesAsync();
return(game.Id);
}
public async Task DeleteCourse(string id, GoUser user)
{
var course = this.coursesRepository.All().FirstOrDefault(x => x.Id == id);
if (course != null && course.CreatorId == user.Id)
{
this.coursesRepository.Delete(course);
await this.coursesRepository.SaveChangesAsync();
}
}
public DestViewModel FindToDeleteDestination(string id, GoUser user)
{
var dest = this.destRepository.All().FirstOrDefault(x => x.Id == id);
if (dest.CreatorId != user.Id)
{
throw new ArgumentException(YoucanNotDeleteThisPage);
}
var destination = mapper.Map <DestViewModel>(dest);
return(destination);
}
public async Task AddSocialization(GoUser user, string id, string socialization)
{
var dest = this.destUsersRepository.All()
.FirstOrDefault(x => x.DestinationId == id && x.ParticipantId == user.Id);
if (dest == null)
{
throw new ArgumentException(YouAreNotInThisGroup);
}
dest.Socialization = Enum.Parse <Socialization>(socialization);
await this.destUsersRepository.SaveChangesAsync();
}
public async Task AddDestination(CreateDestinationViewModel model, GoUser user)
{
byte[] file = NewMethod(model.Image);
var dest = mapper.Map <Destination>(model);
dest.Image = file;
dest.Creator = user;
dest.CreatorId = user.Id;
await this.destRepository.AddAsync(dest);
await this.destRepository.SaveChangesAsync();
}
