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; }