public ViewResult Edit(int id)
{
FolderDto instance = GetFolder(id);
InstanceEditViewModel model = new InstanceEditViewModel(InstanceTypes.Folder, instance);
model.FolderTree = GetCurrentFolderTree(id);
model.CurrentLanguage = CurrentLanguage;
return(View(model));
}
public static void ValidateModel(FolderDto folder, int folderId)
{
ValidateModel(folder);
if (folderId == folder.ParentFolderId.Value)
{
throw new ConflictException(ErrorMessages.FolderReferenceToItself, ErrorCodes.Conflict);
}
}
public IFacadeUpdateResult <FolderData> SaveFolder(FolderDto instance)
{
using (IUnitOfWork uow = UnitOfWorkFactory.Instance.Start(DataStoreResolver.CMSDataStoreKey))
{
FolderFacade facade = new FolderFacade(uow);
IFacadeUpdateResult <FolderData> result = facade.SaveFolder(FolderConverter.ConvertToData(instance));
return(result);
}
}
private void LoadChilds(FolderDto folder, List <FolderDto> allFolders)
{
folder.ChildFolders = allFolders.Where(fi => fi.ParentId == folder.FolderId)
.OrderBy(f => f.Order).ThenBy(f => f.Name).ToList();
foreach (FolderDto f in folder.ChildFolders)
{
LoadChilds(f, allFolders);
}
}
public void CreateOrEditFolder(FolderDto fold)
{
if (fold.id != 0)
{
Update(fold);
}
else
{
Create(fold);
}
}
public static Folder MappingFolder(this FolderDto FolderDto)
{
return(new Folder
{
ID = FolderDto.ID,
IDuser = FolderDto.IDuser,
name = FolderDto.name,
describe = FolderDto.describe,
link = FolderDto.link
});
}
public void FolderDto_Extension_AsEntity_Null()
{
// Arrange
FolderDto folder = null;
// Act
var result = folder.AsEntity();
// Assert
Assert.IsNull(result);
Assert.AreEqual(null, result);
}
public void AddFolder(UserCache cache, FolderDto parentFolder, FolderDto folder)
{
Project p = null;
cache.CurrentProject.CopyTo(p);
p.Folders.Add(new Folder() {Name = folder.Name, Path = folder.Path});
Directory.CreateDirectory(folder.Path+"\\"+folder.Name);
SaveContext();
var log = new Userlog() { Date = DateTime.Now, Message = "Создание папки " + folder.Name };
cache.Client.Userlogs.Add(log);
cache.LogMessages.Add(log.AsDto());
cache.StructureChanges.Add(new StructureChange(Action.Added, folder));
}
private void Update(FolderDto folder)
{
var folderEntity = _context.Folders.Where(x => !x.isDeleted).SingleOrDefault(x => x.id == folder.id);
if (folderEntity != null)
{
_mapper.Map <FolderDto, Folder>(folder, folderEntity);
//_context.Set<Folder>().Update(folderEntity);
//folderEntity.folderName = "antran";
_context.SaveChanges();
}
}
public async Task <Result <FolderDto> > UpdateAsync(FolderDto entity)
{
var result = new Result <FolderDto>();
try
{
var db = GetOpenConnection();
entity.ModificationDateTime = DateTime.Now;
var sql = @"UPDATE Folders SET
FolderNumber = @FolderNumber,
CreationDateTime = @CreationDateTime,
ModificationDateTime = @ModificationDateTime,
[Name] = @Name,
Tags = @Tags,
PathFolder = @PathFolder,
[Order] = @Order,
OrderNotes = @OrderNotes,
Script = @Script,
ParentId = @ParentId
WHERE FolderId = @FolderId";
var r = await db.ExecuteAsync(sql.ToString(),
new {
entity.FolderId,
entity.FolderNumber,
entity.CreationDateTime,
entity.ModificationDateTime,
entity.Name,
entity.Tags,
entity.PathFolder,
entity.Order,
entity.OrderNotes,
entity.Script,
entity.ParentId
});
if (r == 0)
{
result.ErrorList.Add("Entity not updated");
}
result.Entity = entity;
await CloseIsTempConnection(db);
}
catch (Exception ex)
{
AddExecptionsMessagesToErrorsList(ex, result.ErrorList);
}
return(ResultDomainAction(result));
}
public async Task <Guid> CreateFolderAsync(Guid userId, string slug, Folder folder, CancellationToken cancellationToken)
{
if (Guid.Empty == userId)
{
throw new ArgumentOutOfRangeException(nameof(userId));
}
if (string.IsNullOrEmpty(slug))
{
throw new ArgumentOutOfRangeException(nameof(slug));
}
var now = _systemClock.UtcNow.UtcDateTime;
var groupId = await _groupCommand.GetGroupIdForSlugAsync(slug, cancellationToken);
if (!groupId.HasValue)
{
_logger.LogError($"Error: CreateFolderAsync - Group not found for slug:{0}", slug);
throw new KeyNotFoundException("Error: Group not found for slug");
}
var userCanPerformAction = await _permissionsService.UserCanPerformActionAsync(userId, groupId.Value, AddFolderRole, cancellationToken);
if (!userCanPerformAction)
{
_logger.LogError($"Error: CreateFolderAsync - User:{0} does not have access to group:{1}", userId, slug);
throw new SecurityException($"Error: User does not have access");
}
var folderDto = new FolderDto()
{
Name = folder.Name,
Description = folder.Description,
CreatedAtUTC = now,
CreatedBy = userId,
ModifiedBy = null,
ModifiedAtUTC = null,
ParentFolder = null,
GroupId = groupId.Value,
IsDeleted = false
};
var validator = new FolderValidator(_folderCommand);
var validationResult = await validator.ValidateAsync(folderDto, cancellationToken);
if (validationResult.Errors.Count > 0)
{
throw new ValidationException(validationResult);
}
return(await _folderCommand.CreateFolderAsync(userId, groupId.Value, folderDto, cancellationToken));
}
public void AddFile(UserCache cache, FolderDto parentFolder ,FileDto file)
{
Project p = null;
cache.CurrentProject.CopyTo(p);
var folder = p.Folders.Where(x => x.Path == parentFolder.Path && x.Name == parentFolder.Name).First();
folder.Files.Add(new File() {Name = file.Name, Path = file.Path});
System.IO.File.Create(file.Path + "\\" + file.Name);
SaveContext();
var log = new Userlog() { Date = DateTime.Now, Message = "Создание файла " + file.Name };
cache.Client.Userlogs.Add(log);
cache.LogMessages.Add(log.AsDto());
cache.StructureChanges.Add(new StructureChange(Action.Added, file));
}
public static Folder FromDto(FolderDto dto)
{
return(new Folder
{
Id = dto.Id.Value,
DisplayName = dto.DisplayName,
FullyQualifiedName = dto.FullyQualifiedName,
Description = dto.Description,
ProvisionType = dto.ProvisionType,
PermissionModel = dto.PermissionModel,
ParentId = dto.ParentId,
});
}
public OperationResultWithData <FolderDto> CreateFolder(FolderDto dto)
{
if (dto == null)
{
throw new ArgumentNullException(nameof(dto));
}
try
{
// TODO: validation!! via FluentValidation
//if (string.IsNullOrWhiteSpace(dto.FolderId))
// throw new ArgumentException("folderScoId can't be empty");
ScoInfoResult updatedSco =
_acProxy.CreateSco(
new FolderUpdateItem
{
Name = dto.Name,
Description = dto.Description,
FolderId = dto.FolderId,
Type = ScoType.folder,
});
if (!updatedSco.Success)
{
if (updatedSco.Status.Code == StatusCodes.no_access &&
updatedSco.Status.SubCode == StatusSubCodes.denied)
{
return(OperationResultWithData <FolderDto> .Error(Resources.Messages.AccessDenied));
}
if (updatedSco.Status.Code == StatusCodes.invalid &&
updatedSco.Status.SubCode == StatusSubCodes.duplicate &&
updatedSco.Status.InvalidField == "name")
{
return(OperationResultWithData <FolderDto> .Error(Resources.Messages.NameNotUnique));
}
_logger.Error(updatedSco.Status.GetErrorInfo());
return(OperationResultWithData <FolderDto> .Error(updatedSco.Status.GetErrorInfo()));
}
dto.ScoId = updatedSco.ScoInfo.ScoId;
return(dto.ToSuccessResult());
}
catch (Exception ex)
{
string errorMessage = GetOutputErrorMessage("CreateFolder", ex);
return(OperationResultWithData <FolderDto> .Error(errorMessage));
}
}
public void FolderDto_Property_CreatedBy()
{
// Arrange
var folder = new FolderDto();
var value = TestHelper.UserDto();
// Act
folder.CreatedBy = value;
// Assert
Assert.IsNotNull(folder.CreatedBy);
Assert.IsInstanceOfType(folder.CreatedBy, typeof(UserDto));
Assert.AreEqual(value, folder.CreatedBy);
}
private FolderDto GetFolder(int id)
{
FolderDto folder = null;
if (CurrentLanguage.Id == WebContext.Current.DefaultLanguage.Id)
{
folder = Service.GetFolder(id, null);
}
else
{
folder = Service.GetFolder(id, CurrentLanguage.Id);
}
return(folder);
}
public void FolderDto_Property_IsDeleted()
{
// Arrange
var folder = new FolderDto();
var value = false;
// Act
folder.IsDeleted = value;
// Assert
Assert.IsNotNull(folder.IsDeleted);
Assert.IsInstanceOfType(folder.IsDeleted, typeof(bool));
Assert.AreEqual(value, folder.IsDeleted);
}
public void FolderDto_Property_Name()
{
// Arrange
var folder = new FolderDto();
var value = "Test Folder";
// Act
folder.Name = value;
// Assert
Assert.IsNotNull(folder.Name);
Assert.IsInstanceOfType(folder.Name, typeof(string));
Assert.AreEqual(value, folder.Name);
}
public void FolderDto_Property_Modified()
{
// Arrange
var folder = new FolderDto();
var value = DateTime.Now;
// Act
folder.Modified = value;
// Assert
Assert.IsNotNull(folder.Modified);
Assert.IsInstanceOfType(folder.Modified, typeof(DateTime));
Assert.AreEqual(value, folder.Modified);
}
public void FolderDto_Property_ParentFolderID()
{
// Arrange
var folder = new FolderDto();
var value = 99;
// Act
folder.ParentFolderID = value;
// Assert
Assert.IsNotNull(folder.ParentFolderID);
Assert.IsInstanceOfType(folder.ParentFolderID, typeof(int));
Assert.AreEqual(value, folder.ParentFolderID);
}
public FolderDto CreateFolderInFolder(string folderName, string folderId)
{
FolderDto response = null;
try
{
var service = _googleDriveOperation.GetDriveService();
response = _googleDriveOperation.CreateFolderInFolder(service, folderName, folderId);
}
catch (Exception ex)
{
Logger.Error(ex.StackTrace);
}
return(response);
}
public async Task <HttpResponseMessage> UpdateInstanceFolder(int folderId, [FromBody] FolderDto folderDto)
{
if (folderDto == null)
{
throw new BadRequestException(ErrorMessages.ModelIsEmpty, ErrorCodes.BadRequest);
}
await _privilegesManager.Demand(Session.UserId, InstanceAdminPrivileges.ManageProjects);
FolderValidator.ValidateModel(folderDto, folderId);
await _instanceRepository.UpdateFolderAsync(folderId, folderDto);
return(Request.CreateResponse(HttpStatusCode.NoContent));
}
public async Task <HttpResponseMessage> CreateFolder(FolderDto folder)
{
if (folder == null)
{
throw new BadRequestException(ErrorMessages.ModelIsEmpty, ErrorCodes.BadRequest);
}
await _privilegesManager.Demand(Session.UserId, InstanceAdminPrivileges.ManageProjects);
FolderValidator.ValidateModel(folder);
var folderId = await _instanceRepository.CreateFolderAsync(folder);
return(Request.CreateResponse(HttpStatusCode.Created, folderId));
}
protected override void ProcessRecord()
{
var postDto = new FolderDto
{
DisplayName = DisplayName,
Description = Description,
ProvisionType = (FolderDtoProvisionType)Enum.Parse(typeof(FolderDtoProvisionType), ProvisionType),
PermissionModel = (FolderDtoPermissionModel)Enum.Parse(typeof(FolderDtoPermissionModel), PermissionModel),
ParentId = ParentId,
};
var response = HandleHttpOperationException(() => Api_19_10.Folders.Post(postDto));
WriteObject(Folder.FromDto(response));
}
public OperationResultWithData <FolderDto> CreateFolder(FolderDto dto)
{
if (dto == null)
{
throw new ArgumentNullException(nameof(dto));
}
try
{
// TODO: validation!! via FluentValidation
//if (string.IsNullOrWhiteSpace(dto.FolderId))
// throw new ArgumentException("folderScoId can't be empty");
ScoInfoResult updatedSco =
_acProxy.CreateSco(
new FolderUpdateItem
{
Name = dto.Name,
Description = dto.Description,
FolderId = dto.FolderId,
Type = ScoType.folder,
});
if (!updatedSco.Success)
{
_logger.Error(updatedSco.Status.GetErrorInfo());
return(OperationResultWithData <FolderDto> .Error(updatedSco.Status.GetErrorInfo()));
}
dto.ScoId = updatedSco.ScoInfo.ScoId;
return(OperationResultWithData <FolderDto> .Success(dto));
}
catch (AdobeConnectException ex)
{
if (ex.Status.Code == StatusCodes.no_access && ex.Status.SubCode == StatusSubCodes.denied)
{
return(OperationResultWithData <FolderDto> .Error("You do not have permission to access this item."));
}
string errorMessage = GetOutputErrorMessage("CreateFolder", ex);
return(OperationResultWithData <FolderDto> .Error(errorMessage));
}
catch (Exception ex)
{
string errorMessage = GetOutputErrorMessage("CreateFolder", ex);
return(OperationResultWithData <FolderDto> .Error(errorMessage));
}
}
public async Task <Result <FolderDto> > SaveAsync(FolderDto entity)
{
if (entity.FolderId == Guid.Empty)
{
entity.FolderId = Guid.NewGuid();
var res = await _repository.Folders.AddAsync(entity);
return(res);
}
else
{
var res = await _repository.Folders.UpdateAsync(entity);
return(res);
}
}
public async Task <Result <FolderDto> > AddAsync(FolderDto entity)
{
var result = new Result <FolderDto>();
try
{
var db = GetOpenConnection();
entity.CreationDateTime = DateTime.Now;
entity.ModificationDateTime = DateTime.Now;
entity.FolderNumber = GetNextFolderNumber(db);
var sql = @"INSERT INTO Folders (FolderId, FolderNumber, CreationDateTime, ModificationDateTime, [Name], Tags,
PathFolder, [Order], OrderNotes, Script, ParentId )
VALUES (@FolderId, @FolderNumber, @CreationDateTime, @ModificationDateTime, @Name, @Tags,
@PathFolder, @Order, @OrderNotes, @Script, @ParentId)";
var r = await db.ExecuteAsync(sql.ToString(),
new {
entity.FolderId,
entity.FolderNumber,
entity.CreationDateTime,
entity.ModificationDateTime,
entity.Name,
entity.Tags,
entity.PathFolder,
entity.Order,
entity.OrderNotes,
entity.Script,
entity.ParentId
});
if (r == 0)
{
result.ErrorList.Add("Entity not inserted");
}
result.Entity = entity;
await CloseIsTempConnection(db);
}
catch (Exception ex)
{
AddExecptionsMessagesToErrorsList(ex, result.ErrorList);
}
return(ResultDomainAction(result));
}
public async Task <Result <FolderDto> > SaveAsync(FolderDto folder)
{
HttpResponseMessage httpRes;
if (folder.FolderId == Guid.Empty)
{
httpRes = await _httpClient.PostAsJsonAsync <FolderDto>($"api/folders", folder);
}
else
{
httpRes = await _httpClient.PutAsJsonAsync <FolderDto>($"api/folders", folder);
}
var res = await httpRes.Content.ReadFromJsonAsync <Result <FolderDto> >();
return(res);
}
public void Update(string securityToken, FolderDto folder)
{
try
{
var session = CheckSession(securityToken);
var folderDom = _dao.ReadFullFolder(folder.Id);
if (folderDom == null)
{
throw new FileSharingException(FileSharingException.FOLDER_NOT_FOUND,
"Folder with id " + folder.Id + " does not exist");
}
if (folderDom.IdUser != session.IdUser)
{
throw new FileSharingException(FileSharingException.UNAUTHORIZED,
"You do not have permissions to update this folder");
}
var similarName = _dao.GetByNameAndFolderRoot(folder.Name, folder.IdFolderRoot);
if (similarName != null)
{
throw new FileSharingException(FileSharingException.FOLDER_ALREADY_EXISTS,
"You already have a folder with this name in this directory");
}
string previousPath = GetFullPath(folderDom);
string action = "Update:\r\n" + "-Previous: " + folderDom + "\r\n";
Mapper.Map(folder, folderDom);
action += "-Updated: " + folderDom;
Directory.Move(previousPath, GetFullPath(folderDom));
Directory.Delete(previousPath);
_dao.Update(folderDom);
Audit(session.IdUser, folderDom.Id.ToString(), typeof(Folder).Name, ActionDto.Update, action);
}
catch (FileSharingException)
{
throw;
}
catch (Exception e)
{
throw new FileSharingException(FileSharingException.ERROR_FILESHARING_SERVER, e.Message, e);
}
}
public static Folder AsEntity(this FolderDto folderDto)
{
if (folderDto == null)
{
return(null);
}
return(new Folder
{
ID = folderDto.Id,
Name = folderDto.Name,
ParentFolderID = folderDto.ParentFolderID,
Created = folderDto.Created,
CreatedBy = folderDto.CreatedBy.AsEntity(),
Modified = folderDto.Modified,
ModifiedBy = folderDto.ModifiedBy.AsEntity(),
IsDeleted = folderDto.IsDeleted
});
}
public static void ValidateModel(FolderDto folder)
{
if (string.IsNullOrWhiteSpace(folder.Name))
{
throw new BadRequestException(ErrorMessages.FolderNameLimitation, ErrorCodes.BadRequest);
}
folder.Name = folder.Name.Trim();
if (folder.Name.Length > MinNameLength)
{
throw new BadRequestException(ErrorMessages.FolderNameLimitation, ErrorCodes.BadRequest);
}
if (!folder.ParentFolderId.HasValue)
{
throw new BadRequestException(ErrorMessages.LocationIsRequired, ErrorCodes.BadRequest);
}
}
private async Task <FolderDto> ConvertChildFolders(FolderDto folderDto, IEnumerable <Folder> folders)
{
var children = folders.Where(f => f.ParentFolderId == folderDto.Id).Select(f => new FolderDto
{
Id = f.Id,
Name = f.Name,
Children = new List <FolderDto>(),
Order = f.Order,
ParentFolderId = f.ParentFolderId
})
.OrderBy(f => f.Order).ToList();
foreach (var child in children)
{
folderDto.Children = folderDto.Children.Concat(new[] { await ConvertChildFolders(child, folders) });
}
return(folderDto);
}
public void RemoveFolder(UserCache cache, FolderDto folder)
{
Project p = null;
cache.CurrentProject.CopyTo(p);
var f = p.Folders.Where(x => x.Path == folder.Path && x.Name == folder.Name).First();
p.Folders.Remove(f);
Directory.Delete(f.Path + "\\" + f.Name, true);
SaveContext();
var log = new Userlog() { Date = DateTime.Now, Message = "Удаление папки " + folder.Name };
cache.Client.Userlogs.Add(log);
cache.LogMessages.Add(log.AsDto());
cache.StructureChanges.Add(new StructureChange(Action.Removed, folder));
}
private static List<Elem> GetFoldersFromFolder(ref ProjectStructure structure, FolderDto folder)
{
var result = new List<Elem>();
for (int i = 0; i < structure.Folders.Count; ++i)
{
if ((structure.Folders[i].Path == folder.Path + "\\" + folder.Name)&&(structure.Folders[i] != folder))
{
var newFolder = structure.Folders[i];
structure.Folders.RemoveAt(i);
result.Add(new Elem(newFolder.Name, newFolder, ElemType.Folder, ref structure));
--i;
}
}
return result;
}
private static List<Elem> GetFilesFromFolder(ref ProjectStructure structure, FolderDto folder)
{
var result = new List<Elem>();
for(int i =0; i< structure.Files.Count; ++i)
{
if(structure.Files[i].Path == folder.Path+"\\"+folder.Name)
{
var file = structure.Files[i];
structure.Files.RemoveAt(i);
result.Add(new Elem(file.Name, file, ElemType.File,ref structure));
--i;
}
}
return result;
}
