public async Task <OperationDetailDTO <RepositoryDTO> > GetRepositoryByID(int id)
{
var detail = new OperationDetailDTO <RepositoryDTO>();
try
{
var repoEntity = await _context.RepositoryModels
.Include(r => r.Files)
.FirstOrDefaultAsync(r => r.Id == id);
if (repoEntity != null)
{
var dto = RepositoryDTO.Map(repoEntity);
detail.Data = dto;
detail.Succeeded = true;
}
else
{
detail.ErrorMessages.Add("Репозиторий не найден");
}
return(detail);
}
catch (Exception e)
{
detail.ErrorMessages.Add(_serverErrorMessage + e.Message);
return(detail);
}
}
// test
public async Task <OperationDetailDTO <List <RepositoryDTO> > > GetRepositoriesFromDBAsync(FilterDTO[] filters = null)
{
var detail = new OperationDetailDTO <List <RepositoryDTO> >();
var resultList = new List <RepositoryDTO>();
var currentUserEntity = await GetUserFromClaimsAsync();
var teacherEntity = await _context.Teachers
.Include(t => t.User)
.Where(t => t.UserId == currentUserEntity.Id)
.FirstOrDefaultAsync();
var repos = from r in _context.RepositoryModels
.Where(r => r.TeacherId == teacherEntity.Id)
.Include(r => r.Subject)
.Include(r => r.Files)
select r;
repos.OrderBy(r => r.Name);
if (filters != null)
{
foreach (var filter in filters)
{
switch (filter.Name)
{
case "subjectId":
{
var value = Convert.ToInt32(filter.Value);
if (value > 0)
{
repos = repos.Where(r => r.SubjectId == value);
}
break;
}
}
}
}
foreach (var entity in repos)
{
var repoDTO = RepositoryDTO.Map(entity);
resultList.Add(repoDTO);
}
detail.Data = resultList;
detail.Succeeded = true;
return(detail);
}
public async Task <OperationDetailDTO <List <RepositoryDTO> > > GetRepositoriesFromDBAsync(FilterDTO[] filters)
{
var detail = new OperationDetailDTO <List <RepositoryDTO> >();
try
{
var resultList = new List <RepositoryDTO>();
var repos = from r in _context.RepositoryModels
.Include(r => r.Subject)
.Include(r => r.Files)
.Include(r => r.Teacher)
select r;
repos.OrderBy(r => r.Teacher.Name);
if (filters != null)
{
foreach (var filter in filters)
{
switch (filter.Name)
{
case "subjectId":
{
var value = Convert.ToInt32(filter.Value);
if (value > 0)
{
repos = repos.Where(r => r.SubjectId == value);
}
break;
}
}
}
}
foreach (var entity in repos)
{
var repoDTO = RepositoryDTO.Map(entity);
resultList.Add(repoDTO);
}
detail.Data = resultList;
detail.Succeeded = true;
}
catch (Exception e)
{
detail.ErrorMessages.Add(_serverErrorMessage + e.Message);
}
return(detail);
}
private async Task AddSolutionsToRepositoryAsync(RepositoryDTO repositoryDTO)
{
string[] solutionsFilesPaths = fileService.GetFilesPaths(repositoryDTO.Path, SolutionSearchPattern);
foreach (string solutionDirectoryPath in fileService.GetFilesDirectoriesPaths(solutionsFilesPaths))
{
SolutionDTO solutionDTO = new SolutionDTO
{
Name = directoryService.GetName(solutionDirectoryPath),
Path = solutionDirectoryPath
};
await AddProjectsToSolutionAsync(solutionDTO);
repositoryDTO.Solutions.Add(solutionDTO);
}
}
public async Task <RepositoryDTO> GetParsedRepositoryAsync(string repositoryPath)
{
if (!directoryService.Exists(repositoryPath))
{
return(null);
}
RepositoryDTO repositoryDTO = new RepositoryDTO
{
Name = directoryService.GetName(repositoryPath),
Path = repositoryPath
};
await AddSolutionsToRepositoryAsync(repositoryDTO);
return(repositoryDTO);
}
public void OneTimeSetup()
{
accurateRepositoryDTO = new RepositoryDTO
{
Name = RepositoryName,
Solutions = new List <SolutionDTO>
{
new SolutionDTO
{
Name = SolutionName,
Projects = new List <ProjectDTO>
{
new ProjectDTO
{
Name = FirstProjectName,
Packages = new List <PackageDTO>
{
new PackageDTO
{
Name = FirstPackageName,
Version = VersionString
},
new PackageDTO
{
Name = SecondPackageName,
Version = VersionString
}
}
},
new ProjectDTO
{
Name = SecondProjectName,
Packages = new List <PackageDTO>
{
new PackageDTO
{
Name = FirstPackageName,
Version = VersionString
}
}
}
}
}
}
};
}
public async Task GetParsedRepositoryAsync_ShouldRepositoryNotNullAndPackagesCount5_WhenCoreAppType()
{
string[] filesPaths = testList.ToArray();
string repositoryPath = testList.First();
// Arrange
directoryServiceMock
.Setup(directoryService => directoryService.Exists(repositoryPath))
.Returns(true);
directoryServiceMock
.Setup(directoryService => directoryService.GetName(repositoryPath))
.Returns(repositoryPath);
fileServiceMock
.Setup(fileService => fileService.GetFilesPaths(repositoryPath, SolutionSearchPattern))
.Returns(filesPaths);
fileServiceMock
.Setup(fileService => fileService.GetFilesDirectoriesPaths(filesPaths))
.Returns(testList);
fileServiceMock
.Setup(fileService => fileService.GetFilesPaths(repositoryPath, CsProjSearchPattern))
.Returns(filesPaths);
fileServiceMock
.Setup(fileService => fileService.GetFilePath(repositoryPath, PackagesConfigSearchPattern))
.Returns((string)null);
fileServiceMock
.Setup(fileService => fileService.GetFilePath(repositoryPath, CsProjSearchPattern))
.Returns(repositoryPath);
fileServiceMock
.Setup(fileService => fileService.GetContentAsync(repositoryPath))
.ReturnsAsync(TestCsProjFileContent);
// Act
RepositoryDTO repotitory = await repositoryAnalyzerService.GetParsedRepositoryAsync(repositoryPath);
// Assert
Assert.IsNotNull(repotitory);
double packagesCount = repotitory.Solutions.First().Projects.First().Packages.Count;
Assert.AreEqual(5, packagesCount);
}
private async Task <Repository> ToDomainAsync(RepositoryDTO businessRepositoryDTO, int userId)
{
var dbRepository =
await DatabaseRepository.GetSingleOrDefaultAsync(repository =>
repository.Name == businessRepositoryDTO.Name);
if (dbRepository != null)
{
DatabaseRepository.Delete(dbRepository.Id);
}
var domainRepository = CreateRepository(businessRepositoryDTO.Name, userId);
foreach (var businessSolution in businessRepositoryDTO.Solutions)
{
domainRepository.Solutions.Add(CreateSolution(businessSolution.Name));
var domainSolution =
domainRepository.Solutions.FirstOrDefault(solution => solution.Name == businessSolution.Name);
foreach (var businessProject in businessSolution.Projects)
{
domainSolution.Projects.Add(CreateProject(businessProject.Name));
var domainProject =
domainSolution.Projects.FirstOrDefault(project => project.Name == businessProject.Name);
foreach (var businessPackage in businessProject.Packages)
{
domainProject.ProjectPackageVersions.Add(await CreatePackageAsync(businessPackage.Name,
businessPackage.Version,
domainProject, domainRepository));
}
}
}
return(domainRepository);
}
public async Task SaveAsync(RepositoryDTO repositoryDTO, int userId)
{
unitOfWork.GetRepository <Repository>().Add(await ToDomainAsync(repositoryDTO, userId));
await unitOfWork.SaveChangesAsync();
}
public Task <OperationDetailDTO> UpdateRepoAsync(RepositoryDTO dto)
{
throw new NotImplementedException();
}
