Ejemplo n.º 1
0
        public async Task <IActionResult> Edit(Guid id, [Bind("Id,FileSHA256,FirstUploaderId,DOUploading")] FunFileByte funFileByte)
        {
            if (id != funFileByte.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(funFileByte);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!FunFileByteExists(funFileByte.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(funFileByte));
        }
Ejemplo n.º 2
0
        public async Task <IActionResult> Create([Bind("Id,FileSHA256,FirstUploaderId,DOUploading")] FunFileByte funFileByte)
        {
            if (ModelState.IsValid)
            {
                funFileByte.Id = Guid.NewGuid();
                _context.Add(funFileByte);
                await _context.SaveChangesAsync();

                return(RedirectToAction(nameof(Index)));
            }
            return(View(funFileByte));
        }
Ejemplo n.º 3
0
        public async Task <IActionResult> FunUploadFiles([FromForm] FunUploadFile funUploadFile)
        {
            if (funUploadFile.FunFiles.Count() < 1)
            {
                return(NoContent());
            }

            var _InvalidPathChars = System.IO.Path.GetInvalidPathChars();

            if (
                funUploadFile.FunFiles
                .Select(p => p.FileName)
                .Any(p =>
                     _InvalidPathChars
                     .Any(i => p.Contains(i)))
                )
            {
                return(NoContent());
            }
            var UserId_ = _userManager.GetUserAsync(User).GetAwaiter().GetResult().Id;

            if (await IsLengthOfUserFilesExceeded(
                    funUploadFile.FunFiles.Select(p => p.Length).Sum(),
                    UserId_))
            {
                return(BadRequest());
            }


            var _FunFileBytes = new List <FunFileByte>();
            var _FunYourFiles = new List <FunYourFile>();

            funUploadFile.FunFiles.ForEach(p =>
            {
                var _FileBytes = _funFilesHelper.GetFormFileBytes(p);

                var _SHA256          = SHA256.Create().ComputeHash(_FileBytes);
                var _SHA256HexString = _funFilesHelper.SHA256BytesToHexString(_SHA256);

                if (
                    !new DirectoryInfo(_funFilesHelper.FunFilesRootPath(_webHostEnv)).GetFiles()
                    .Select(p => p.Name)
                    .Any(p => p == _SHA256HexString)
                    )
                {
                    System.IO.File.WriteAllBytesAsync(
                        _funFilesHelper.FunFilesRootPath(_webHostEnv) + "/" + _SHA256HexString, _FileBytes)
                    .GetAwaiter()
                    .GetResult();
                }


                var _FunFileByte = new FunFileByte
                {
                    DOUploading         = DateTimeOffset.Now,
                    FileSHA256HexString = _SHA256HexString,
                    FirstUploaderId     = UserId_,
                    Id = Guid.NewGuid()
                };

                _FunFileBytes.Add(_FunFileByte);

                _FunYourFiles.Add(

                    new FunYourFile
                {
                    DOUploading = DateTimeOffset.Now,
                    Id          = Guid.NewGuid(),
                    FileByteId  = _FunFileByte.Id,
                    Name        = System.IO.Path.GetFileName(p.FileName),
                    ParentDirId = funUploadFile.ParentDirId,
                    UserId      = UserId_
                }
                    );
            });

            await _context.FunFileByte.AddRangeAsync(_FunFileBytes);

            await _context.FunYourFile.AddRangeAsync(_FunYourFiles);

            await _context.SaveChangesAsync();

            return(Ok());
        }