public async Task <ServiceResult <CatFeedingModel> > FeedAsync(CatFeedingCreateModel info)
{
CatInDbModel cat = await catDatabase.GetAsync(info.CatId);
if (cat == null)
{
return(new ServiceResult <CatFeedingModel>(ServiceResultStatus.ItemNotFound, "Cat is not found"));
}
UserInDbModel user = await userDatabase.GetAsync(info.UserId);
if (user == null)
{
return(new ServiceResult <CatFeedingModel>(ServiceResultStatus.ItemNotFound, "User is not found"));
}
if (!await catSharingDatabase.IsCatSharedWithUserAsync(info.UserId, info.CatId))
{
return(new ServiceResult <CatFeedingModel>(ServiceResultStatus.ActionNotAllowed, "You cannot feed this cat"));
}
await catFeedingdatabase.CreateAsync(mapper.Map <CatFeedingCreateInDbModel, CatFeedingCreateModel>(info));
return(new ServiceResult <CatFeedingModel>(ServiceResultStatus.NoContent));
}
public async Task <ServiceResult <CatServiceModel> > CreateAsync(CatCreateServiceModel info, IEnumerable <Claim> userClaims)
{
int userId = Convert.ToInt32(userClaims.FirstOrDefault(claim => claim.Type == ClaimTypes.NameIdentifier).Value);
Roles userRole = (Roles)Convert.ToInt32(userClaims.FirstOrDefault(claim => claim.Type == ClaimTypes.Role).Value);
if (userId != info.OwnerId)
{
if (userRole != Roles.Admin)
{
return(new ServiceResult <CatServiceModel>(ServiceResultStatus.ActionNotAllowed, "You cannot create cat for this user"));
}
}
UserInDbModel user = await userDatabase.GetAsync(info.OwnerId);
if (user == null)
{
return(new ServiceResult <CatServiceModel>(ServiceResultStatus.ItemNotFound, "User is not found"));
}
int catId = await catDatabase.CreateAsync(mapper.Map <CatCreateInDbModel, CatCreateServiceModel>(info));
CatServiceModel cat = new CatServiceModel(catId, info.Name, info.OwnerId);
await catSharingDatabase.CreateAsync(new CatSharingCreateInDbModel(cat.Id, info.OwnerId));
return(new ServiceResult <CatServiceModel>(ServiceResultStatus.ItemCreated, cat));
}
public async Task <ServiceResult <List <DateTime> > > GetFeedingForPeriodAsync(int userId, int catId, DateTime start, DateTime finish)
{
UserInDbModel user = await userDatabase.GetAsync(userId);
if (user == null)
{
return(new ServiceResult <List <DateTime> >(ServiceResultStatus.ItemNotFound, "User is not found"));
}
CatInDbModel cat = await catDatabase.GetAsync(catId);
if (cat == null)
{
return(new ServiceResult <List <DateTime> >(ServiceResultStatus.ItemNotFound, "Cat is not found"));
}
List <DateTime> info = new List <DateTime>();
List <CatFeedingInDbModel> feedings = await catFeedingdatabase.GetFeedingsForPeriodAsync(userId, catId, start, finish);
for (int i = 0; i < feedings.Count; i++)
{
info.Add(feedings[i].FeedingTime);
}
return(new ServiceResult <List <DateTime> >(ServiceResultStatus.ItemRecieved, info));
}
public async Task <ServiceResult <CatSharingModel> > ShareAsync(CatSharingCreateModel info, int ownerId)
{
UserInDbModel userInDb = await userDatabase.GetAsync(info.UserId);
if (userInDb == null)
{
return(new ServiceResult <CatSharingModel>(ServiceResultStatus.ItemNotFound, "User to share cannot be found"));
}
CatInDbModel cat = await catDatabase.GetAsync(info.CatId);
if (cat == null)
{
return(new ServiceResult <CatSharingModel>(ServiceResultStatus.ItemNotFound, "Cat is not found"));
}
if (cat.OwnerId != ownerId)
{
return(new ServiceResult <CatSharingModel>(ServiceResultStatus.CantShareWithUser, "This user cannot share the cat"));
}
if (!await IsCatSharedWithUser(info.UserId, info.CatId))
{
await catSharingDatabase.CreateAsync(mapper.Map <CatSharingCreateInDbModel, CatSharingCreateModel>(info));
}
return(new ServiceResult <CatSharingModel>(ServiceResultStatus.CatIsShared));
}
private void SetUpMockRepositories(
int CatDatabaseCreateResult,
UserInDbModel userRepositoryGetResult,
CatCreateInDbModel mapperResult)
{
mockCatDatabase.Setup(repository => repository.CreateAsync(It.IsAny <CatCreateInDbModel>())).Returns(Task.FromResult(CatDatabaseCreateResult));
mockUserDatabase.Setup(repository => repository.GetAsync(1)).Returns(Task.FromResult(userRepositoryGetResult));
mockMapper.Setup(mapper => mapper.Map <CatCreateInDbModel, CatCreateServiceModel>(catCreateServiceModel)).Returns(mapperResult);
}
public async Task <ServiceResult <UserServiceModel> > CreateAsync(UserCreateModel info)
{
HashedPasswordWithSalt hashSalt = protector.ProtectPassword(info.Password);
UserInDbModel userInDB = new UserInDbModel(0, info.Login, info.Nickname, (int)info.Role, hashSalt.Salt, hashSalt.Password);
int userId = await database.CreateAsync(userInDB);
return(new ServiceResult <UserServiceModel>(ServiceResultStatus.ItemCreated, new UserServiceModel(userId, info.Login, info.Password, info.Nickname, info.Role)));
}
public async Task <ServiceResult <UserGetModel> > GetAsync(int id)
{
UserInDbModel userInDb = await database.GetAsync(id);
if (userInDb == null)
{
return(new ServiceResult <UserGetModel>(ServiceResultStatus.ItemNotFound, "User cannot be found"));
}
return(new ServiceResult <UserGetModel>(ServiceResultStatus.ItemRecieved, mapper.Map <UserGetModel, UserInDbModel>(userInDb)));
}
private void SetUpMockRepositories(
int catSharingCreateResult,
bool isCatShared,
CatInDbModel catGetResult,
UserInDbModel userGetResult,
CatSharingCreateInDbModel mapperResult)
{
mockCatSharingDatabase.Setup(repository => repository.CreateAsync(catSharingCreateInDb)).Returns(Task.FromResult(catSharingCreateResult));
mockCatSharingDatabase.Setup(repository => repository.IsCatSharedWithUserAsync(1, 1)).Returns(Task.FromResult(isCatShared));
mockCatDatabase.Setup(repository => repository.GetAsync(1)).Returns(Task.FromResult(catGetResult));
mockUserDatabase.Setup(repository => repository.GetAsync(1)).Returns(Task.FromResult(userGetResult));
mockMapper.Setup(mapper => mapper.Map <CatSharingCreateInDbModel, CatSharingCreateModel>(catSharingCreate)).Returns(mapperResult);
}
public async Task <ServiceResult <UserServiceModel> > UpdateAsync(int id, UserUpdateModel info, IEnumerable <Claim> userClaims)
{
int userId = Convert.ToInt32(userClaims.FirstOrDefault(claim => claim.Type == ClaimTypes.NameIdentifier)?.Value);
Roles userRole = (Roles)Convert.ToInt32(userClaims.FirstOrDefault(claim => claim.Type == ClaimTypes.Role)?.Value);
if (userId != id)
{
if (userRole != Roles.Admin)
{
return(new ServiceResult <UserServiceModel>(ServiceResultStatus.ActionNotAllowed, "You cannot update this user"));
}
}
UserInDbModel user = await database.GetAsync(id);
if (user == null)
{
return(new ServiceResult <UserServiceModel>(ServiceResultStatus.ItemNotFound, "User cannot be found"));
}
bool IsPasswordSame = protector.VerifyPassword(new HashedPasswordWithSalt {
Password = user.HashedPassword, Salt = user.Salt
}, info.Password ?? "");
HashedPasswordWithSalt hashSalt = protector.ProtectPassword(info.Password ?? "");
UserInDbModel newUser = new UserInDbModel(
id,
info.Login ?? user.Login,
info.Nickname ?? user.Nickname,
info.Role == default ? user.Role : (int)info.Role,
IsPasswordSame ? user.Salt : hashSalt.Salt,
IsPasswordSame ? user.HashedPassword : hashSalt.Password
);
await database.UpdateAsync(id, newUser);
return(new ServiceResult <UserServiceModel>(ServiceResultStatus.ItemChanged));
}
public async Task <ServiceResult <TokenJwt> > LogInAsync(string login, string password)
{
UserInDbModel user = await database.GetUserByLoginAsync(login);
if (user == null)
{
return(new ServiceResult <TokenJwt>(ServiceResultStatus.IncorrectLoginPassword));
}
if (!protection.VerifyPassword(new HashedPasswordWithSalt {
Salt = user.Salt, Password = user.HashedPassword
}, password))
{
return(new ServiceResult <TokenJwt>(ServiceResultStatus.IncorrectLoginPassword));
}
return(new ServiceResult <TokenJwt>(ServiceResultStatus.ItemRecieved,
new TokenJwt(
GetIdentity(mapper.Map <UserClaimsModel, UserInDbModel>(user)),
365,
"UNBELIEVABLEsecretKEEEEEYYYYYY!!!!!=)",
"http://localhost:44338/",
"TaskServer")));
}
public async Task <ServiceResult <UserServiceModel> > DeleteAsync(int id, IEnumerable <Claim> userClaims)
{
int userId = Convert.ToInt32(userClaims.FirstOrDefault(claim => claim.Type == ClaimTypes.NameIdentifier).Value);
Roles userRole = (Roles)Convert.ToInt32(userClaims.FirstOrDefault(claim => claim.Type == ClaimTypes.Role).Value);
if (userId != id)
{
if (userRole != Roles.Admin)
{
return(new ServiceResult <UserServiceModel>(ServiceResultStatus.ActionNotAllowed, "You cannot delete this user"));
}
}
UserInDbModel user = await database.GetAsync(id);
if (user == null)
{
return(new ServiceResult <UserServiceModel>(ServiceResultStatus.ItemNotFound, "User cannot be found"));
}
await database.DeleteAsync(id);
return(new ServiceResult <UserServiceModel>(ServiceResultStatus.ItemDeleted));
}
