public DataFile CreateFolder(int projectId, DirectoryDTO folder)
{
//if (Directory.Exists(newDir))
//return new DirectoryInfo(newDir);
//var di = Directory.CreateDirectory(newDir);
var project = _projectRepository.FindSingle(p => p.Id == projectId);
if (project == null || folder.Name == "" || folder.Name == null)
{
return(null);
}
var file = new DataFile();
file.FileName = folder.Name;
file.DateAdded = DateTime.Now.ToString("D");
file.IsDirectory = true;
file.ProjectId = project.Id;
if (folder.ParentFolderId != 0)
{
file.FolderId = folder.ParentFolderId;
}
_fileRepository.Insert(file);
return(_dataServiceUnit.Save().Equals("CREATED") ? file : null);
}
public List <string> CreateDirectory(int projectId, [FromBody] DirectoryDTO dir)
{
var fullpath = _fileService.GetFullPath(projectId.ToString(), dir.name);
var diInfo = _fileService.AddDirectory(projectId, fullpath);
return(diInfo?.GetDirectories().Select(d => d.Name).ToList());
}
private async Task <DirectoryDTO> FillDirectoryChildrenAsync(DirectoryDTO root)
{
var children = await _context.Set <Directory>()
.Where(x => x.ParentId == root.Id)
.ToListAsync();
var files = await _context.Set <File>()
.Where(x => x.DirectoryId == root.Id)
.ToListAsync();
var childrenDtos = children.Count > 0 ?
children.Select(x =>
{
var childDto = new DirectoryDTO()
{
Id = x.Id,
Name = x.Name
};
childDto = FillDirectoryChildrenAsync(childDto).Result;
return(childDto);
})
.ToList()
: new List <DirectoryDTO>();
root.SubDirectories = childrenDtos;
root.Files = files.Select(x => _mapper.Map <FileDTO>(x)).ToList();
return(root);
}
public DirectoryBuilder AddSubdirectoryAndEnter(string name)
{
ValidateDirectoryName(name);
_currentDirectory = _currentDirectory.AddSubdirectory(name);
return(this);
}
public DirectoryViewModel(
DirectoryDTO directory,
DirectoryViewModel parent,
bool lazyLoadChildren = true)
: base(
data: directory,
parent: parent,
lazyLoadChildren: lazyLoadChildren)
{
}
public async Task <ActualResult> CreateAsync(DirectoryDTO dto)
{
if (!await CheckNameAsync(dto.Name))
{
await _database.ActivitiesRepository.Create(_mapperService.Mapper.Map <Activities>(dto));
return(_mapperService.Mapper.Map <ActualResult>(await _database.SaveAsync()));
}
return(new ActualResult(Errors.DuplicateData));
}
public async Task <ActualResult> UpdateAsync(DirectoryDTO dto)
{
try
{
_context.Entry(_mapperService.Mapper.Map <Hobby>(dto)).State = EntityState.Modified;
await _context.SaveChangesAsync();
return(new ActualResult());
}
catch (Exception exception)
{
return(new ActualResult(DescriptionExceptionHelper.GetDescriptionError(exception)));
}
}
private static string GetFullPathRecursive(DirectoryDTO dto)
{
if (dto == null)
{
return(string.Empty);
}
if (dto.Parent == null)
{
return(dto.Name);
}
return(Path.Combine(GetFullPathRecursive(dto.Parent), dto.Name));
}
public async Task <ActualResult> CreateAsync(DirectoryDTO dto)
{
try
{
await _context.Hobby.AddAsync(_mapperService.Mapper.Map <Hobby>(dto));
await _context.SaveChangesAsync();
return(new ActualResult());
}
catch (Exception exception)
{
return(new ActualResult(DescriptionExceptionHelper.GetDescriptionError(exception)));
}
}
public DirectoryBuilder(string basePath, bool createBasePath = false)
{
if (!Directory.Exists(basePath))
{
if (!createBasePath)
{
throw new DirectoryNotFoundException(basePath);
}
}
var info = new DirectoryInfo(basePath);
_basePath = info.Parent.FullName;
_rootDirectory = new DirectoryDTO(info.Name, null);
_currentDirectory = _rootDirectory;
}
public async Task <ActualResult> UpdateAsync(DirectoryDTO dto)
{
var check = await _hashIdUtilities.CheckDecryptWithId(dto.HashId, Enums.Services.Activities);
if (check.IsValid)
{
if (!await CheckNameAsync(dto.Name))
{
await _database.ActivitiesRepository.Update(_mapperService.Mapper.Map <Activities>(dto));
return(_mapperService.Mapper.Map <ActualResult>(await _database.SaveAsync()));
}
return(new ActualResult(Errors.DuplicateData));
}
return(new ActualResult(check.ErrorsList));
}
public string DescribeRecursive(DirectoryDTO dto, StringBuilder strBuilder)
{
strBuilder.AppendLine(Path.Combine(_basePath, dto.GetFullPath()));
foreach (var file in dto.Files.OrderBy(x => x.Name))
{
strBuilder.AppendLine(Path.Combine(_basePath, file.GetFullPath()));
}
foreach (var subDirectory in dto.Subdirectories.OrderBy(x => x.Name))
{
DescribeRecursive(subDirectory, strBuilder);
}
return(strBuilder.ToString());
}
public async Task <ActualResult <string> > CreateAsync(DirectoryDTO dto)
{
try
{
var hobby = _mapper.Map <Hobby>(dto);
await _context.Hobby.AddAsync(hobby);
await _context.SaveChangesAsync();
var hashId = HashHelper.EncryptLong(hobby.Id);
return(new ActualResult <string> {
Result = hashId
});
}
catch (Exception exception)
{
return(new ActualResult <string>(DescriptionExceptionHelper.GetDescriptionError(exception)));
}
}
private void CreateRecursive(DirectoryDTO dto)
{
var fullPath = Path.Combine(_basePath, dto.GetFullPath());
if (!Directory.Exists(fullPath))
{
Directory.CreateDirectory(fullPath);
}
foreach (var file in dto.Files)
{
var fullFilePath = Path.Combine(_basePath, file.GetFullPath());
if (!File.Exists(fullFilePath))
{
File.Create(fullFilePath);
}
}
foreach (var subDirectory in dto.Subdirectories)
{
CreateRecursive(subDirectory);
}
}
public IActionResult CreateDirectory(int projectId, [FromBody] DirectoryDTO dir)
{
var folderInfo = _fileService.CreateFolder(projectId, dir);
return(new CreatedAtRouteResult("GetFileById", new { fileId = folderInfo.Id }, folderInfo));
}
public DTOBase GetDtoDir(string folder, string alias = null)
{
DirectoryDTO response = new DirectoryDTO();
return(response);
}
public DirectoryBuilder GoBack()
{
_currentDirectory = _currentDirectory.Parent;
return(this);
}
public static string GetFullPath(DirectoryDTO dto)
{
return(Path.Combine(GetFullPathRecursive(dto.Parent), dto.Name));
}
