Exemple #1
0
        public async Task <IHttpActionResult> CreateAsync(FolderUnitDto folder)
        {
            var dto = await _service?.CreateAsync(folder);

            if (dto == null)
            {
                return(BadRequest());
            }
            return(Ok(dto));
        }
Exemple #2
0
        public async Task <IHttpActionResult> UpdateAsync(int id, FolderUnitDto folder)
        {
            var dto = await _service?.UpdateAsync(id, folder);

            if (id != folder?.Id)
            {
                return(BadRequest());
            }

            return(Ok(dto));
        }
Exemple #3
0
        public async Task <IHttpActionResult> CreateCopyAsync(int id, FolderUnitDto folder)
        {
            await _service?.CreateCopyAsync(id, folder);

            //if (id != folder?.Id)
            //{
            //    return BadRequest();
            //}

            return(Ok());
        }
Exemple #4
0
        public async Task <FolderUnitDto> CreateAsync(FolderUnitDto dto)
        {
            var user = await _usersService?.GetCurrentUser();

            var localUser = await _unitOfWork?.Users?.Query.FirstOrDefaultAsync(x => x.GlobalId == user.id);

            var space = await _unitOfWork?.Spaces?.GetByIdAsync(dto.SpaceId);

            var parentFolder = await _unitOfWork?.Folders?.GetByIdAsync(dto.ParentId);

            List <User> ReadPermittedUsers = new List <User>();

            ReadPermittedUsers.Add(localUser);

            List <User> ModifyPermittedUsers = new List <User>();

            ModifyPermittedUsers.Add(localUser);


            if (space != null)
            {
                var folder = new FolderUnit
                {
                    Description = dto.Description,
                    Name        = dto.Name,

                    CreatedAt            = DateTime.Now,
                    LastModified         = DateTime.Now,
                    IsDeleted            = false,
                    Space                = space,
                    FolderUnit           = parentFolder,
                    Owner                = await _unitOfWork.Users.Query.FirstOrDefaultAsync(u => u.GlobalId == user.id),
                    ModifyPermittedUsers = ModifyPermittedUsers,
                    ReadPermittedUsers   = ReadPermittedUsers
                };

                _unitOfWork?.Folders?.Create(folder);
                await _unitOfWork?.SaveChangesAsync();

                dto.Id           = folder.Id;
                dto.CreatedAt    = folder.CreatedAt;
                dto.LastModified = folder.LastModified;
                dto.Author       = new AuthorDto()
                {
                    Id = folder.Owner.Id, Name = user.name + ' ' + user.surname
                };

                return(dto);
            }
            return(null);
        }
Exemple #5
0
        public async Task CreateCopyAsync(int id, FolderUnitDto dto)
        {
            var space = await _unitOfWork.Spaces.GetByIdAsync(dto.SpaceId);

            var user  = _usersService.CurrentUserId;
            var owner = await _unitOfWork.Users.Query.FirstOrDefaultAsync(u => u.GlobalId == user);

            var folder = await _unitOfWork.Folders.GetByIdAsync(id);

            string name = folder.Name;

            if (await _unitOfWork.Folders.Query.FirstOrDefaultAsync(f => f.Name == folder.Name &&
                                                                    (f.FolderUnit.Id == dto.ParentId || (dto.ParentId == 0 && f.Space.Id == dto.SpaceId))) != null)
            {
                name = name + "-copy";
            }

            var destinationFolder = await _unitOfWork.Folders.GetByIdAsync(dto.ParentId);

            await CopyFolder(id, name, owner, space, destinationFolder);
        }
Exemple #6
0
        public async Task <FolderUnitDto> UpdateAsync(int id, FolderUnitDto dto)
        {
            var folder = await _unitOfWork?.Folders?.GetByIdAsync(id);

            if (folder == null)
            {
                return(null);
            }

            folder.Description  = dto.Description;
            folder.IsDeleted    = dto.IsDeleted;
            folder.Name         = dto.Name;
            folder.LastModified = DateTime.Now;
            if (dto.ParentId != 0)
            {
                folder.FolderUnit = await _unitOfWork.Folders.GetByIdAsync(dto.ParentId);
            }

            await _unitOfWork?.SaveChangesAsync();

            dto.LastModified = DateTime.Now;

            return(dto);
        }
Exemple #7
0
        public async Task <FolderUnitDto> UpdateDeletedAsync(int id, int?oldParentId, FolderUnitDto dto)
        {
            var folder = await _unitOfWork?.Folders?.Deleted.Include(f => f.DataUnits).SingleOrDefaultAsync(f => f.Id == id);

            if (folder == null)
            {
                return(null);
            }

            folder.IsDeleted = false;

            folder.Name         = dto.Name;
            folder.Description  = dto.Description;
            folder.IsDeleted    = dto.IsDeleted;
            folder.LastModified = DateTime.Now;

            var space = await _unitOfWork.Spaces.GetByIdAsync(dto.SpaceId);

            if (oldParentId != null)
            {
                var oldParentFolder = await _unitOfWork.Folders.Query.Include(f => f.DataUnits).SingleOrDefaultAsync(f => f.Id == oldParentId);

                var list = new List <DataUnit>();
                foreach (var item in oldParentFolder.DataUnits)
                {
                    if (item.Id != folder.Id)
                    {
                        list.Add(item);
                    }
                }

                oldParentFolder.DataUnits = list;
            }

            var parentFolder = await _unitOfWork.Folders.GetByIdAsync(dto.ParentId);

            folder.Space      = space;
            folder.FolderUnit = parentFolder ?? null;

            foreach (var item in folder.DataUnits)
            {
                item.IsDeleted = false;

                item.Space = await _unitOfWork.Spaces.GetByIdAsync(folder.Space.Id);

                if (item is FolderUnit)
                {
                    await ChangeSpaceId(item.Id, folder.Space.Id);
                }
            }

            await _unitOfWork?.SaveChangesAsync();

            return(dto);
        }