Esempio n. 1
0
        public async Task <IActionResult> ChangeProfilePicture([FromBody] PostFilesModel postModel)
        {
            var model = new FileBase64Model {
                Files = new List <FileDetails> {
                    new FileDetails {
                        Name   = postModel.File.Name,
                        Base64 = postModel.File.Base64
                    }
                },
                Email  = UserEmail,
                FileId = postModel.FileId,
                Type   = 3
            };

            #region Validate Model

            if (model.Files == null)
            {
                _infos.Add(_badRequest.ShowError(ResponseBadRequest.ErrFileEmpty).Message);

                return(BadRequest(new CustomResponse <string> {
                    Message = _infos
                }));
            }

            #endregion

            var savedFiles = await _myFiles.SaveFiles(model);

            return(Ok(savedFiles));
        }
Esempio n. 2
0
        public async Task <CustomResponse <GetFilesResponse> > SaveFiles(FileBase64Model model)
        {
            var user = await _userManager.FindByEmailAsync(model.Email);

            #region Validate User

            if (user == null)
            {
                _infos.Add("Username/email not exist.");

                return(new CustomResponse <GetFilesResponse> {
                    Message = _infos
                });
            }
            #endregion

            var fileData = _context.Files.FirstOrDefault(f => f.Id == model.FileId);

            #region Add Files

            if (fileData == null)
            {
                var addedFiles = await AddFiles();

                return(new CustomResponse <GetFilesResponse> {
                    Succeed = true,
                    Data = new GetFilesResponse {
                        Files = addedFiles
                    }
                });
            }
            #endregion

            var modifiedFiles = ModifyFiles();

            return(new CustomResponse <GetFilesResponse> {
                Succeed = true,
                Data = new GetFilesResponse {
                    Files = modifiedFiles
                }
            });

            #region Local Methods

            async Task <List <GetFilesListResponse> > AddFiles()
            {
                var files = new List <GetFilesListResponse>();

                foreach (var file in model.Files)
                {
                    var fileCode = Guid.NewGuid();

                    var extension = Path.GetExtension(file.Name);

                    var newFileName = fileCode + extension;

                    var bytes = Convert.FromBase64String(file.Base64);

                    File.WriteAllBytes(Path.Combine(_options.Value.DirectoryPath,
                                                    newFileName), bytes);

                    var mappedFiles = new Files {
                        UserId    = user.Id,
                        FeedId    = model.FeedId,
                        Name      = file.Name,
                        CodeName  = fileCode + extension,
                        Extension = extension,
                        FilePath  =
                            _options.Value.Protocol + _options.Value.Uri + _options.Value.Files + newFileName,
                        Type      = model.Type,
                        CreatedAt = DateTime.UtcNow,
                        IsActive  = true
                    };

                    var savedFile = _context.Files.AddAsync(mappedFiles);

                    await _context.SaveChangesAsync();

                    files.Add(_mapper.Map <GetFilesListResponse>(savedFile.Result.Entity));
                }

                return(files);
            }

            List <GetFilesListResponse> ModifyFiles()
            {
                var updatedFiles = new List <GetFilesListResponse>();

                var updateFile = model.Files.FirstOrDefault();

                var fileCode = fileData.CodeName;

                var extension = Path.GetExtension(updateFile?.Name);

                var updateFileName = fileCode + extension;

                File.Delete(Path.Combine(_options.Value.DirectoryPath,
                                         fileCode + fileData.Extension));

                var bytes = Convert.FromBase64String(updateFile?.Base64);

                File.WriteAllBytes(Path.Combine(_options.Value.DirectoryPath,
                                                updateFileName), bytes);

                fileData.Name     = updateFile?.Name;
                fileData.FilePath = _options.Value.Protocol + _options.Value.Uri +
                                    _options.Value.Files + updateFileName;
                fileData.Extension = extension;
                fileData.UpdatedAt = DateTime.UtcNow;

                _context.Update(fileData);

                _context.SaveChanges();

                updatedFiles.Add(_mapper.Map <GetFilesListResponse>(fileData));

                return(updatedFiles);
            }

            #endregion
        }