public async Task <ResponseModel <SingleUploadResponse> > Handle(SingleFileUploadPhysicalCommand request, CancellationToken cancellationToken)
        {
            var swTotalEncrypt = new Stopwatch();

            swTotalEncrypt.Start();
            var errorModel = new FormFileErrorModel();

            var multiPartContentTypeValidation = MultiPartContentTypeValidation(_accessor.HttpContext.Request.ContentType)
                                                 .Select(x => x.ErrorMessage)
                                                 .ToArray();

            if (multiPartContentTypeValidation.Any())
            {
                return(ResponseProvider.BadRequest <SingleUploadResponse>(multiPartContentTypeValidation));
            }

            var boundary = MultipartRequestHelper.GetBoundary(
                MediaTypeHeaderValue.Parse(_accessor.HttpContext.Request.ContentType),
                _defaultFormOptions.MultipartBoundaryLengthLimit);
            var reader  = new MultipartReader(boundary, _accessor.HttpContext.Request.Body);
            var section = await reader.ReadNextSectionAsync(cancellationToken);

            while (section != null)
            {
                var hasContentDispositionHeader =
                    ContentDispositionHeaderValue.TryParse(
                        section.ContentDisposition, out var contentDisposition);

                if (hasContentDispositionHeader)
                {
                    var hasFileContentDispositionValidation = HasFileContentDispositionValidation(contentDisposition)
                                                              .Select(x => x.ErrorMessage)
                                                              .ToArray();
                    if (hasFileContentDispositionValidation.Any())
                    {
                        return(ResponseProvider.BadRequest <SingleUploadResponse>(hasFileContentDispositionValidation));
                    }
                    else
                    {
                        var streamedFileContent = await FileHelpers.ProcessStreamedFile(
                            section, contentDisposition, errorModel,
                            _permittedExtensions, _streamFileLimitSize, ValidateExtension.Encrypt);

                        if (errorModel.Errors.Any())
                        {
                            //return ResponseProvider.BadRequest<SingleUploadResponse>(errorModel.Errors);
                            return(ResponseProvider.Ok(new SingleUploadResponse()));
                        }
                        var fileNameWithEncryptExtension = UploadFileHelper.GetFileNameWithEncryptExtension(request.File.FileName, request.EncryptAlg);
                        var uploadFileAbsolutePath       = UploadFileHelper.GetUploadAbsolutePath(_contentRootPath, fileNameWithEncryptExtension, request.Archive);

                        await UploadFile(streamedFileContent, uploadFileAbsolutePath, request.EncryptAlg);
                    }
                }

                section = await reader.ReadNextSectionAsync(cancellationToken);
            }
            swTotalEncrypt.Stop();

            var requestScheme = _accessor.HttpContext.Request.Scheme;
            var domain        = _accessor.HttpContext.Request.Host.Value;
            var url           = Path.Combine(requestScheme, domain, "Archive", request.Archive.ToString(), request.File.FileName);

            Console.Write($"File length: {request.File.Length / 1024f / 1024f} MB");
            Console.WriteLine($"Encrypt time: {swTotalEncrypt.ElapsedMilliseconds}");

            return(ResponseProvider.Ok(new SingleUploadResponse {
                Url = url
            }));
        }