private static void FillRecursively(DirectoryDto parent, IList <FileEntry> children)
{
foreach (FileEntry child in children)
{
if (child.IsDirectory)
{
DirectoryDto directory = new DirectoryDto
{
Name = child.Name,
Path = child.FullPath
};
FillRecursively(directory, child.Children);
parent.ListOfDirectories.Add(directory);
}
else
{
parent.ListOfFiles.Add(new FileDto
{
Name = child.Name,
Path = child.FullPath
});
}
}
}
public bool EditDirectory(DirectoryDto directoryDetail)
{
var editService = _iocContext.Resolve <IDirectoryService>();
var directoyExistOrNot = editService.EditDirectory(directoryDetail);
return(directoyExistOrNot);
}
//Add Directory
public bool AddDirectory(DirectoryDto directoryDetail)
{
var directoryDataService = _iocContext.Resolve <IDirectoryDataService>();
var directory = _iocContext.Resolve <IDirectory>();
directory.Name = directoryDetail.Name;
var directoryExist = directoryDataService.AddDirectory(directory);
return(directoryExist);
}
public async Task <int> AddDirectory(DirectoryDto dirDto, CancellationToken cancellationToken)
{
var model = _mapper.Map <Directory>(dirDto);
model.CreatedBy = dirDto.CreatedBy;
model.ModifiedBy = dirDto.CreatedBy;
model.Thumbnail = dirDto.Parent_id == 0 ? Configuration["Thumbnail:RootFolder"] : Configuration["Thumbnail:SubFolder"];
await _repo.AddDirectory(model, cancellationToken).ConfigureAwait(false);
return(1);
}
public static IDirectory Convert(List <FileEntry> entries)
{
DirectoryDto root = new DirectoryDto
{
Name = "data",
Path = "/"
};
FillRecursively(root, entries);
return(root);
}
public async Task <Guid> PutFileAsync(DirectoryDto directory, string fileName, Stream file)
{
var args = new MethodArgs
{
{ "FileName", fileName },
{ "DirectoryId", directory.Id.ToString() }
};
return(await PostRequestAsync <Guid>(
MethodNames.Files.PutFile,
args,
new Dictionary <string, IEnumerable <Stream> > {
{ "File", new[] { file } }
}
));
}
protected async Task <Directory> ViewModelToEntityAsync(DirectoryDto viewModel, ActionType actionType)
{
Directory directory;
if (actionType == ActionType.Create)
{
directory = new Directory();
Mapper.Map(viewModel, directory);
}
else
{
directory = await Repository.FirstOrDefaultAsync(u => u.Id == viewModel.Id);
Mapper.Map(viewModel, directory);
}
return(directory);
}
public IActionResult CreateDirectory([FromBody] DirectoryDto directoryDto)
{
var lang = Request.Headers["language"].ToString();
var errorMessages = new List <string>();
try
{
var webRootPath = _webHostEnvironment.WebRootPath;
var dirPath = $"{webRootPath}\\appData\\{directoryDto.Path}\\{directoryDto.Name.Replace(" ", "_").Replace(".", "_").Replace("+","_")}";
if (!Directory.Exists(dirPath))
{
DirectoryInfo createDir = Directory.CreateDirectory(dirPath);
if (createDir != null)
{
var dir = new E_Learning.Models.Directory()
{
Name = directoryDto.Name.Replace(" ", "_"),
Path = dirPath.Replace($"{webRootPath}\\appData\\", "").Replace(" ", "_"),
CreatedAt = DateTime.Now
};
var createdDir = _directoryRepository.Create(dir);
return(Ok(new { directory = createdDir }));
}
else
{
errorMessages.Add(_translator.GetTranslation("ERROR", lang));
return(BadRequest(new { errors = errorMessages }));
}
}
else
{
errorMessages.Add(_translator.GetTranslation("DIRECTORIES.DIRECTORY_EXISTS", lang));
return(BadRequest(new { errors = errorMessages }));
}
}
catch
{
errorMessages.Add(_translator.GetTranslation("ERROR", lang));
return(BadRequest(new { errors = errorMessages }));
}
}
public async Task <int> UpdateDirectory(int id, DirectoryDto dirDto, CancellationToken cancellationToken)
{
int ReturnId = 0;
var model = await _repo.GetDirectoryById(id, cancellationToken);
if (model != null)
{
int tempParentID = model.Parent_id;
_mapper.Map(dirDto, model);
model.ModifiedBy = dirDto.CreatedBy;
model.ModifiedDate = DateTime.Now;
model.Parent_id = tempParentID;
model.Thumbnail = dirDto.Parent_id == 0 ? Configuration["Thumbnail:RootFolder"] : Configuration["Thumbnail:SubFolder"];
await _repo.UpdateDirectory(model, cancellationToken).ConfigureAwait(false);
ReturnId = 1;
}
return(ReturnId);
}
private void CreateTreeViewItemsRecursive(DirectoryDto directory, FolderEntryViewModel parentVm, bool isTopLevel)
{
var directoryVm = CreateFromDirectory(directory, isTopLevel);
// Add the Files as SubEntries
var fileViewModels = directory
.Files
.Select(CreateFromFile)
.OrderBy(f => f.Name)
.ToList();
directoryVm.SubEntries.AddRange(fileViewModels);
// Add the Directory as SubEntry
parentVm.SubEntries.Add(directoryVm);
foreach (var subDirectory in directory.SubDirectories)
{
CreateTreeViewItemsRecursive(subDirectory, directoryVm, false);
}
}
public async Task <IActionResult> AddDirectory(DirectoryDto dir, CancellationToken cancellationToken)
{
try
{
int result = await _dirService.AddDirectory(dir, cancellationToken).ConfigureAwait(false);
if (result == 0)
{
return(BadRequest("No data found!"));
}
else
{
return(Ok("Category added successfully"));
}
}
catch (Exception ex)
{
await _errorlogService.InsertError(Request.GetDisplayUrl(), ControllerContext.ActionDescriptor.ActionName.ToString(), ex.Message, ex.ToString()).ConfigureAwait(false);
return(StatusCode(500, ex.InnerException));
}
}
public IActionResult CreateDirectory([FromRoute] string username, [FromBody] DirectoryDto directoryDto)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
// TODO: Check for what is 'Path' used and introduce new property 'Url'
string physicalPath;
if (String.IsNullOrWhiteSpace(directoryDto.Path))
{
physicalPath = Path.Combine(appEnv.WebRootPath,
String.Format(@"dataspace/{0}/{1}", username, directoryDto.Name)); // TODO FIX THIS AND ADD URL FIELD TO DTO MODEL
directoryDto.Url = $"{Request.Scheme}://{Request.Host}/dataspace/{username}/directories/{directoryDto.Name}";
directoryDto.Path = "";
}
else
{
physicalPath = Path.Combine(appEnv.WebRootPath,
String.Format(@"dataspace/{0}/{1}/{2}", username, directoryDto.Path, directoryDto.Name));
directoryDto.Url = $"{Request.Scheme}://{Request.Host}/dataspace/{username}/directories/{directoryDto.Path}/{directoryDto.Name}";
directoryDto.Path = directoryDto.Path;
}
var appId = Request.Headers["AppId"];
var phonenumber = Request.Headers["OwnerPhoneNumber"]; // Remove this and use Authentication and User obj.
if (System.IO.Directory.Exists(directoryDto.Path + '/' + directoryDto.Name))
{
return(BadRequest());
}
System.IO.Directory.CreateDirectory(physicalPath);
dataSpaceSignalRClient.SaveDirectoryMetadata(phonenumber, directoryDto);
return(Ok());
}
// Check how we'll create new dirs based on path not on parentDirName
public async Task <NodeDto> NewDirectory(string ownerPhoneNumber, DirectoryDto directoryDto)
{
var ownerAccount = await dbContext.Accounts
.Where(a => a.PhoneNumber == ownerPhoneNumber)
.SingleOrDefaultAsync();
if (ownerAccount == null)
{
return(null);
}
DSDirectory dsDirectory = await dbContext.DSDirectories
.Where(d => d.Node.Name == directoryDto.Name &&
d.Node.Path == directoryDto.Path &&
d.Node.OwnerId == ownerAccount.Id)
.SingleOrDefaultAsync();
if (dsDirectory == null)
{
DSNode dsNode = new DSNode();
dsDirectory = new DSDirectory();
await dbContext.DSNodes.AddAsync(dsNode);
dsDirectory.Node = dsNode;
await dbContext.DSDirectories.AddAsync(dsDirectory);
}
// Fetch parent directory by both path and name
int lastSegmentPos = directoryDto.Path.LastIndexOf('/'); // Get the positon of the last slash
string parentDirectoryName = directoryDto.Path;
string pathToParentDirectory = "";
if (lastSegmentPos > -1)
{
parentDirectoryName = directoryDto.Path.Substring(lastSegmentPos + 1); // Extract last segment (dir name)
pathToParentDirectory = directoryDto.Path.Remove(lastSegmentPos); // Extract the path up to the last segment
}
if (!String.IsNullOrEmpty(parentDirectoryName))
{
DSDirectory parentDir = await dbContext.DSDirectories
.Where(d => d.Node.Name == parentDirectoryName &&
d.Node.Path == pathToParentDirectory)
.SingleOrDefaultAsync();
dsDirectory.ParentDirectoryId = parentDir.Id;
}
dsDirectory.Node.Name = directoryDto.Name;
dsDirectory.Node.Path = directoryDto.Path;
dsDirectory.Node.Url = directoryDto.Url;
dsDirectory.Node.Private = directoryDto.Private;
dsDirectory.Node.NodeType = NodeType.Directory;
dsDirectory.Node.Owner = ownerAccount;
await dbContext.SaveChangesAsync();
return(autoMapper.Map <NodeDto>(dsDirectory));
}
public Task SaveDirectoryMetadata(string phonenumber, DirectoryDto directoryDto)
{
return(Clients.User(MicroserviceHandlerIdentifier)
.SendAsync("SaveDirectoryMetadata", phonenumber, directoryDto));
}
public List <DirectoryDto> GetDirectoryTree(IEnumerable <DirectoryDto> directoryTree, DirectoryDto currentDirectory = null)
{
if (currentDirectory != null)
{
foreach (var item in directoryTree)
{
item.DirectoryChildren = GetChildernRecursive(directoryTree, item);
}
return(directoryTree.Where(b => b.ParentId == currentDirectory.Id).ToList());
}
else
{
foreach (var item in directoryTree)
{
item.DirectoryChildren = GetChildernRecursive(directoryTree, item);
}
return(directoryTree.Where(b => b.ParentId == null).ToList());
}
}
public void SaveDirectoryMetadata(string phonenumber, DirectoryDto directoryDto)
{
hubConnection.SendAsync("SaveDirectoryMetadata", phonenumber, directoryDto);
}
public Task <ApiResponse <Guid> > CreateAsync([FromBody] DirectoryDto viewModel)
{
return(ExecuteSafely(() => _crudServiceMethods.CreateAsync(viewModel, ViewModelToEntityAsync)));
}
public Directory(DirectoryDto directoryDto, IFileMetadata[] fileChilds, IMinimalDirectoryMetadata[] directoryChilds) : base(directoryDto, (uint)(fileChilds.Length + directoryChilds.Length))
{
this.directoryDto = directoryDto;
FileChilds = fileChilds;
DirectoryChilds = directoryChilds;
}
/// <inheritdoc />
public async Task <bool> InsertDirectory(string requestingUserId, string parentDirectoryId, string directoryName, string newDirectoryId)
{
using var session = await client.StartSessionAsync();
try
{
session.StartTransaction();
var parentDirectory = await directoryCollection.AsQueryable()
.Where(x =>
x.Id == parentDirectoryId &&
x.Permissions.Any(y =>
y.Permission.HasFlag(Permission.ReadWrite) &&
y.UserId == requestingUserId
))
.Select(x => new
{
Owner = x.OwnerId,
Permissions = x.Permissions,
Path = x.PathIds
})
.FirstOrDefaultAsync();
if (parentDirectory == null)
{
throw new ObjectNotResolvableException(
$"Parent directory {parentDirectoryId} could not be found or accessed by user {requestingUserId} during directory insertion");
}
var newPath = parentDirectory.Path.ToList();
newPath.Add(newDirectoryId);
var newDirectory = new DirectoryDto
{
Id = newDirectoryId,
IsRootDirectory = false,
OwnerId = parentDirectory.Owner,
ObjectName = directoryName,
DirectoryIds = new List <string>(),
FileIds = new List <string>(),
Permissions = parentDirectory.Permissions,
PathIds = newPath.ToArray(),
ParentDirectoryId = parentDirectoryId
};
var insertDirectoryTask = directoryCollection.InsertOneAsync(session, newDirectory);
var update = Builders <DirectoryDto> .Update.Push(e => e.DirectoryIds, newDirectoryId);
var updateResultTask = directoryCollection.UpdateOneAsync(session, x => x.Id == parentDirectoryId, update);
await Task.WhenAll(insertDirectoryTask, updateResultTask);
if (updateResultTask.Result.ModifiedCount != 1)
{
throw new UnexpectedBehaviourException(
$"Insertion of new directory {newDirectoryId} to {parentDirectoryId} changed {updateResultTask.Result.ModifiedCount} parent directories but must exactly change 1");
}
await session.CommitTransactionAsync();
return(true);
}
catch (ObjectNotResolvableException)
{
await session.AbortTransactionAsync();
throw;
}
catch (InvalidParameterException)
{
await session.AbortTransactionAsync();
throw;
}
catch (UnexpectedBehaviourException)
{
await session.AbortTransactionAsync();
throw;
}
catch (MongoException e)
{
await session.AbortTransactionAsync();
throw new DatabaseException("Database error during file inserting. See inner exception.", e);
}
catch (Exception e)
{
await session.AbortTransactionAsync();
throw new Exception("Unknown error during file inserting. See inner exception.", e);
}
}
public Task <ApiResponse <Guid> > UpdateAsync(DirectoryDto viewModel)
{
throw new NotImplementedException();
}
private IEnumerable <DirectoryDto> GetChildernRecursive(IEnumerable <DirectoryDto> allDirectories, DirectoryDto directory)
{
if (allDirectories.All(b => b.ParentId != directory.Id))
{
return(null);
}
directory.DirectoryChildren = allDirectories
.Where(b => b.ParentId == directory.Id)
.ToList();
foreach (var item in directory.DirectoryChildren)
{
item.DirectoryChildren = GetChildernRecursive(allDirectories, item);
}
return(directory.DirectoryChildren);
}
private FolderEntryViewModel CreateFromDirectory(DirectoryDto directory, bool isTopLevel) => new FolderEntryViewModel(
FolderEntryViewModelType.Directory,
isTopLevel ? directory.Path : directory.DirectoryName,
directory.Path,
_structureEntryIconFactory.CreateIconPathForDirectory(),
string.Empty);
/// <inheritdoc />
public async Task <bool> InsertUser(string userId, string rootDirectoryId, string email, string hashedPassword, string salt,
string publicKey, string encryptedPrivateKey)
{
using (var session = await client.StartSessionAsync())
{
// Begin transaction
session.StartTransaction();
try
{
var newRootDirectory = new DirectoryDto
{
Id = rootDirectoryId,
IsRootDirectory = true,
OwnerId = userId,
ObjectName = "__root_dir__",
DirectoryIds = new List <string>(),
FileIds = new List <string>(),
PathIds = new[] { rootDirectoryId },
Permissions = new[]
{
new BasicPermissionDto
{
UserId = userId,
Permission = Permission.Read | Permission.ReadWrite | Permission.ReadPermissions | Permission.ReadWritePermissions
}
},
};
var insertRootDirectoryTask = directoryCollection.InsertOneAsync(session, newRootDirectory);
var newUser = new UserDto
{
Id = userId,
RootDirectory = newRootDirectory.Id,
Email = email,
PasswordHash = hashedPassword,
Salt = salt,
PublicKey = publicKey,
EncryptedPrivateKey = encryptedPrivateKey
};
var insertUserTask = userCollection.InsertOneAsync(session, newUser);
await Task.WhenAll(insertRootDirectoryTask, insertUserTask);
await session.CommitTransactionAsync();
}
catch (MongoException e)
{
await session.AbortTransactionAsync();
throw new DatabaseException("Database error during user creating. See inner exception.", e);
}
catch (Exception e)
{
await session.AbortTransactionAsync();
throw new Exception("Unknown error during file inserting. See inner exception.", e);
}
}
return(true);
}
