public async Task CreateAsync_WithOldImageName_WhereRegionIsNullFormFileIsNull_ReturnCityDtoID()
{
// Arrange
CityService cityService = CreateCityService();
CityProfileDTO cityProfileDto = new CityProfileDTO
{
City = new CityDTO
{
ID = 0
},
};
_mapper.Setup(m => m.Map <CityDTO, DataAccessCity.City>(It.IsAny <CityDTO>()))
.Returns(GetTestNewCity());
_repoWrapper.Setup(r => r.Region.GetFirstOrDefaultAsync(It.IsAny <Expression <Func <Region, bool> > >(), null))
.ReturnsAsync((Region)null);
_repoWrapper.Setup(r => r.Region.CreateAsync(It.IsAny <Region>()));
// Act
var result = await cityService.CreateAsync(cityProfileDto, null);
// Assert
Assert.AreEqual(cityProfileDto.City.ID, result);
_repoWrapper.Verify(r => r.Region.CreateAsync(It.IsAny <Region>()), Times.Once);
}
/// <inheritdoc />
public async Task <CityProfileDTO> GetCityAdminsAsync(int cityId)
{
var city = await GetByIdAsync(cityId);
if (city == null)
{
return(null);
}
var cityHead = city.CityAdministration?
.FirstOrDefault(a => a.AdminType.AdminTypeName == "Голова Станиці" &&
(DateTime.Now < a.EndDate || a.EndDate == null));
var cityAdmins = city.CityAdministration
.Where(a => a.AdminType.AdminTypeName != "Голова Станиці" &&
(DateTime.Now < a.EndDate || a.EndDate == null))
.ToList();
var cityProfileDto = new CityProfileDTO
{
City = city,
Admins = cityAdmins,
Head = cityHead
};
return(cityProfileDto);
}
/// <inheritdoc />
public async Task <CityProfileDTO> EditAsync(int cityId)
{
var city = await GetByIdAsync(cityId);
if (city == null)
{
return(null);
}
var cityAdmins = city.CityAdministration
.ToList();
var members = city.CityMembers
.Where(p => cityAdmins.All(a => a.UserId != p.UserId))
.Where(m => m.IsApproved)
.ToList();
var followers = city.CityMembers
.Where(m => !m.IsApproved)
.ToList();
var cityProfileDto = new CityProfileDTO
{
City = city,
Admins = cityAdmins,
Members = members,
Followers = followers
};
return(cityProfileDto);
}
/// <inheritdoc />
public async Task EditAsync(CityProfileDTO model, IFormFile file)
{
await UploadPhotoAsync(model.City, file);
var city = await CreateCityAndRegionAsync(model);
_repoWrapper.City.Attach(city);
_repoWrapper.City.Update(city);
await _repoWrapper.SaveAsync();
}
/// <inheritdoc />
public async Task <int> CreateAsync(CityProfileDTO model, IFormFile file)
{
await UploadPhotoAsync(model.City, file);
var city = await CreateCityAndRegionAsync(model);
_repoWrapper.City.Attach(city);
await _repoWrapper.City.CreateAsync(city);
await _repoWrapper.SaveAsync();
return(city.ID);
}
/// <inheritdoc />
public async Task <CityProfileDTO> GetCityProfileAsync(int cityId)
{
var city = await GetByIdAsync(cityId);
if (city == null)
{
return(null);
}
var cityHead = city.CityAdministration?
.FirstOrDefault(a => a.AdminType.AdminTypeName == "Голова Станиці" &&
(DateTime.Now < a.EndDate || a.EndDate == null));
var cityAdmins = city.CityAdministration
.Where(a => a.AdminType.AdminTypeName != "Голова Станиці" &&
(DateTime.Now < a.EndDate || a.EndDate == null))
.Take(6)
.ToList();
city.AdministrationCount = city.CityAdministration
.Count(a => (DateTime.Now < a.EndDate || a.EndDate == null));
var members = city.CityMembers
.Where(m => m.IsApproved)
.Take(9)
.ToList();
city.MemberCount = city.CityMembers
.Count(m => m.IsApproved);
var followers = city.CityMembers
.Where(m => !m.IsApproved)
.Take(6)
.ToList();
city.FollowerCount = city.CityMembers
.Count(m => !m.IsApproved);
var cityDoc = city.CityDocuments.Take(6).ToList();
var cityProfileDto = new CityProfileDTO
{
City = city,
Head = cityHead,
Members = members,
Followers = followers,
Admins = cityAdmins,
Documents = cityDoc,
};
return(cityProfileDto);
}
public async Task CreateTest()
{
CityService cityService = CreateCityService();
CityProfileDTO cityProfileDto = new CityProfileDTO
{
City = new CityDTO
{
ID = 0
}
};
var result = await cityService.CreateAsync(cityProfileDto, null);
Assert.Equal(cityProfileDto.City.ID, result);
}
/// <inheritdoc />
public async Task <CityProfileDTO> GetCityProfileAsync(int cityId)
{
var city = await GetByIdAsync(cityId);
if (city == null)
{
return(null);
}
var cityHead = GetCityHead(city);
var cityHeadDeputy = GetCityHeadDeputy(city);
var cityAdmins = GetCityAdmins(city);
city.AdministrationCount = city.CityAdministration == null ? 0
:city.CityAdministration.Count(a => (DateTime.Now < a.EndDate || a.EndDate == null));
var members = city.CityMembers
.Where(m => m.IsApproved)
.Take(9)
.ToList();
city.MemberCount = city.CityMembers
.Count(m => m.IsApproved);
var followers = city.CityMembers
.Where(m => !m.IsApproved)
.Take(6)
.ToList();
city.FollowerCount = city.CityMembers
.Count(m => !m.IsApproved);
var cityDoc = city.CityDocuments.Take(6).ToList();
city.DocumentsCount = city.CityDocuments.Count();
var cityProfileDto = new CityProfileDTO
{
City = city,
Head = cityHead,
HeadDeputy = cityHeadDeputy,
Members = members,
Followers = followers,
Admins = cityAdmins,
Documents = cityDoc,
};
return(cityProfileDto);
}
public async Task CreateAsync_WhereFormFileIsNull_ReturnCityDtoID()
{
// Arrange
CityService cityService = CreateCityService();
CityProfileDTO cityProfileDto = new CityProfileDTO
{
City = new CityDTO
{
ID = 0
}
};
// Act
var result = await cityService.CreateAsync(cityProfileDto, null);
// Assert
Assert.AreEqual(cityProfileDto.City.ID, result);
}
/// <inheritdoc />
public async Task <CityProfileDTO> GetCityDocumentsAsync(int cityId)
{
var city = await GetByIdAsync(cityId);
if (city == null)
{
return(null);
}
var cityDoc = city.CityDocuments.ToList();
var cityProfileDto = new CityProfileDTO
{
City = city,
Documents = cityDoc
};
return(cityProfileDto);
}
public async Task <IActionResult> CityDocuments(int cityId)
{
try
{
CityProfileDTO cityProfileDto = await _cityService.GetCityDocumentsAsync(cityId);
if (cityProfileDto == null)
{
return(RedirectToAction("HandleError", "Error", new { code = StatusCodes.Status404NotFound }));
}
return(View(_mapper.Map <CityProfileDTO, CityProfileViewModel>(cityProfileDto)));
}
catch (Exception e)
{
_logger.LogError($"Exception :{e.Message}");
return(RedirectToAction("HandleError", "Error", new { code = StatusCodes.Status505HttpVersionNotsupported }));
}
}
public async Task CreateAsync_WithOldImageName_WhereFormFileIsNull_ReturnCityDtoID()
{
// Arrange
CityService cityService = CreateCityService();
CityProfileDTO cityProfileDto = new CityProfileDTO
{
City = new CityDTO
{
ID = 0
}
};
_repoWrapper.Setup(r => r.City.GetFirstOrDefaultAsync(It.IsAny <Expression <Func <DataAccessCity.City, bool> > >(), null))
.ReturnsAsync((DataAccessCity.City)null);
// Act
var result = await cityService.CreateAsync(cityProfileDto, null);
// Assert
Assert.AreEqual(cityProfileDto.City.ID, result);
}
/// <inheritdoc />
public async Task <CityProfileDTO> GetCityFollowersAsync(int cityId)
{
var city = await GetByIdAsync(cityId);
if (city == null)
{
return(null);
}
var followers = city.CityMembers
.Where(m => !m.IsApproved)
.ToList();
var cityProfileDto = new CityProfileDTO
{
City = city,
Followers = followers
};
return(cityProfileDto);
}
/// <inheritdoc />
public async Task <CityProfileDTO> GetCityAdminsAsync(int cityId)
{
var city = await GetByIdAsync(cityId);
if (city == null)
{
return(null);
}
var cityHead = GetCityHead(city);
var cityHeadDeputy = GetCityHeadDeputy(city);
var cityAdmins = GetCityAdmins(city);
var cityProfileDto = new CityProfileDTO
{
City = city,
Admins = cityAdmins,
Head = cityHead,
HeadDeputy = cityHeadDeputy
};
return(cityProfileDto);
}
public async Task EditAsync_WithModelAndFormFile_ReturnsCityEdited()
{
// Arrange
CityService cityService = CreateCityService();
CityProfileDTO cityProfileDto = new CityProfileDTO
{
City = new CityDTO
{
ID = 0
}
};
_repoWrapper.Setup(r => r.City.Attach(It.IsAny <DataAccessCity.City>()));
_repoWrapper.Setup(r => r.City.Update(It.IsAny <DataAccessCity.City>()));
_repoWrapper.Setup(r => r.SaveAsync());
// Act
await cityService.EditAsync(cityProfileDto, It.IsAny <IFormFile>());
// Assert
_repoWrapper.Verify(r => r.City.Attach(It.IsAny <DataAccessCity.City>()), Times.Once);
_repoWrapper.Verify(r => r.City.Update(It.IsAny <DataAccessCity.City>()), Times.Once);
_repoWrapper.Verify(r => r.SaveAsync(), Times.Once);
}
private async Task <DataAccessCity.City> CreateCityAndRegionAsync(CityProfileDTO model)
{
var cityDto = model.City;
var city = _mapper.Map <CityDTO, DataAccessCity.City>(cityDto);
var region = await _repoWrapper.Region.GetFirstOrDefaultAsync(r => r.RegionName == city.Region.RegionName);
if (region == null)
{
region = new DataAccessCity.Region
{
RegionName = city.Region.RegionName
};
await _repoWrapper.Region.CreateAsync(region);
await _repoWrapper.SaveAsync();
}
city.RegionId = region.ID;
city.Region = region;
return(city);
}
public async Task NotifyNewPlastMembersAndCityAdminsAsync_Valid_Test()
{
// Arrange
var users = new List <User>()
{
new User()
{
RegistredOn = DateTime.Now.Date.Subtract(new TimeSpan(366, 0, 0, 0))
}
};
var user = new UserDTO
{
UserProfile = new UserProfileDTO
{
Birthday = DateTime.Now
},
CityMembers = new[]
{
new CityMembers
{
City = new DataAccess.Entities.City
{
Name = "CityName"
}
}
}
};
var cityProfile = new CityProfileDTO
{
Admins = new List <CityAdministrationDTO>
{
new CityAdministrationDTO
{
User = new CityUserDTO()
}
},
Head = new CityAdministrationDTO
{
User = new CityUserDTO()
}
};
var roles = new List <string>()
{
Roles.Supporter,
Roles.FormerPlastMember
};
var confirmedUsers = new ConfirmedUser[]
{
new ConfirmedUser()
{
isClubAdmin = true
}
}.AsQueryable <ConfirmedUser>();
_mockRepoWrapper
.Setup(x => x.User.GetAllAsync(It.IsAny <Expression <Func <User, bool> > >(),
It.IsAny <Func <IQueryable <User>, IIncludableQueryable <User, object> > >()))
.ReturnsAsync(users);
_mockUserManager
.Setup((x) => x.IsInRoleAsync(It.IsAny <User>(),
It.IsAny <string>()))
.ReturnsAsync(false);
_mockUserManager
.Setup(x => x.GetRolesAsync(It.IsAny <User>()))
.ReturnsAsync(roles);
_mockRepoWrapper
.Setup(r => r.ConfirmedUser.FindByCondition(It.IsAny <Expression <Func <ConfirmedUser, bool> > >()))
.Returns(confirmedUsers);
_mockUserManager
.Setup(u => u.FindByIdAsync(It.IsAny <string>()))
.ReturnsAsync(new User());
_mockUserManager
.Setup(x => x.AddToRoleAsync(It.IsAny <User>(),
It.IsAny <string>()));
_mockUserService.Setup(x => x.GetUserAsync(It.IsAny <string>()))
.ReturnsAsync(user);
_mockCityService.Setup(x => x.GetCityAdminsAsync(It.IsAny <int>()))
.ReturnsAsync(cityProfile);
_mockEmailSendingService
.Setup(x => x.SendEmailAsync(It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>()))
.ReturnsAsync(true);
_mockEmailContentService.Setup(x => x.GetGreetingForNewPlastMemberEmailAsync(It.IsAny <string>()))
.ReturnsAsync(new EmailModel());
_mockEmailContentService
.Setup(x => x.GetCityAdminAboutNewPlastMemberEmail(It.IsAny <string>(), It.IsAny <string>(),
It.IsAny <DateTime>())).Returns(new EmailModel());
// Act
await _newPlastMemberEmailGreetingService.NotifyNewPlastMembersAndCityAdminsAsync();
// Assert
_mockRepoWrapper.Verify();
_mockUserManager.Verify();
_mockEmailSendingService.Verify();
}
