コード例 #1
0
        public async Task AddFileTest()
        {
            // Arrange
            var createDocumentCommand =
                new CreateDocumentCommand(DateTime.UtcNow.Ticks.ToString(), "Test document");
            var addFileCommand = new AddFileCommand("Test", "Test file");

            // Act
            var documentUri = await _client.CreateDocumentAsync(createDocumentCommand);

            var fileUri = await _client.AddFileAsync(documentUri, addFileCommand);

            var file = await _client.GetAsync <File>(fileUri);

            var files = await _client.GetFiles(documentUri);

            // Assert
            Assert.NotNull(file);
            Assert.Equal(addFileCommand.FileName, file.Name);
            Assert.Equal(addFileCommand.FileDescription, file.Description);

            Assert.NotNull(files);
            Assert.Single(files);
            Assert.Equal(file.Id, files.First().Id);
        }
コード例 #2
0
        public void File_add_throws_when_owner_now_found()
        {
            // Arrange
            FakeFileStorage         fileStorage         = new FakeFileStorage();
            FakeFileRepository      fileRepository      = new FakeFileRepository();
            FakeEventPublisher      eventPublisher      = new FakeEventPublisher();
            FakeCurrentUserSource   currentUserSource   = new FakeCurrentUserSource();
            FakePostCommitRegistrar postCommitRegistrar = new FakePostCommitRegistrar();

            currentUserSource.CurrentUser = null;

            var commandHandler = new AddFileCommandHandler(
                fileRepository, fileStorage, eventPublisher, postCommitRegistrar, currentUserSource);

            var contentBuffer = Encoding.UTF8.GetBytes("testContent");

            using (Stream fileContent = new MemoryStream(contentBuffer))
            {
                var command = new AddFileCommand("filename", "desc", "text/plain", fileContent);

                // Assert & Act
                Assert.Throws <NotFoundException>(() =>
                {
                    commandHandler.Handle(command);
                    postCommitRegistrar.ExecuteActions();
                });
            }
        }
コード例 #3
0
        public async Task <IActionResult> AddFile([FromForm] IFormFile file)
        {
            await using var content = new MemoryStream();
            file.CopyTo(content);

            var command = new AddFileCommand(file.FileName, content, Username);
            await Mediator.Send(command);

            return(CreatedAtRoute(nameof(GetFile), new { id = command.FileId }, null));
        }
コード例 #4
0
        public async Task <IActionResult> AddFile(Guid documentId, [FromBody] AddFileCommand command)
        {
            var outcome =
                from doc in GetDocumentFromEvents(documentId)
                from u in ValidateDocumentUser(doc.UserId.Value)
                from result in doc.AddFile(Guid.NewGuid(), command.FileName, command.FileDescription).AsTask()
                from _ in SaveAndPublishEventAsync(result.Event)
                select result.Event;

            return(await outcome.Map(val =>
                                     val.ToActionResult(evt => Created($"documents/{documentId}/files/{evt.FileId}", null))));
        }
コード例 #5
0
ファイル: Program.cs プロジェクト: syemi95/grpc-dotnet
        public static Task <int> Main(string[] args)
        {
            MSBuildLocator.RegisterDefaults();

            var parser = new CommandLineBuilder()
                         .AddCommand(AddFileCommand.Create())
                         .AddCommand(AddUrlCommand.Create())
                         .AddCommand(RefreshCommand.Create())
                         .AddCommand(RemoveCommand.Create())
                         .UseDefaults()
                         .Build();

            return(parser.InvokeAsync(args));
        }
        public void AddFileToDfsResponse_No_Response_Codes()
        {
            //Arrange
            var addFileToDfsResponse = new AddFileToDfsResponse();
            var commandContext       = TestCommandHelpers.GenerateCliResponseCommandContext(_testScheduler);
            var addFileToDfsCommand  = new AddFileCommand(null, commandContext, _logger);

            //Act
            TestCommandHelpers.GenerateResponse(commandContext, addFileToDfsResponse);

            _testScheduler.Start();

            //Assert
            commandContext.UserOutput.Received(1).WriteLine(AddFileCommand.ErrorNoResponseCodes);
        }
コード例 #7
0
        public async Task <IActionResult> Add([FromBody] AddFileRequest content)
        {
            var command = new AddFileCommand(content);

            try
            {
                await _commandProcessor.SendAsync(command);
            }
            catch (Exception exception)
            {
                return(StatusCode(StatusCodes.Status500InternalServerError, $"Failed to add the content: {exception.Message}."));
            }

            return(Ok());
        }
コード例 #8
0
ファイル: Program.cs プロジェクト: rafsanulhasan/grpc-dotnet
        internal static Parser BuildParser(HttpClient client)
        {
            var root = new RootCommand();

            root.AddCommand(AddFileCommand.Create(client));
            root.AddCommand(AddUrlCommand.Create(client));
            root.AddCommand(RefreshCommand.Create(client));
            root.AddCommand(RemoveCommand.Create(client));
            root.AddCommand(ListCommand.Create(client));

            var parser = new CommandLineBuilder(root)
                         .UseDefaults()
                         .Build();

            return(parser);
        }
コード例 #9
0
        private void m_addFileToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Vault.Currency.Entities.Folder parent = m_model.Parent as Vault.Currency.Entities.Folder;
            if (parent != null)
            {
                OpenFileDialog openFileDialog = new OpenFileDialog();
                openFileDialog.Multiselect = true;

                if (openFileDialog.ShowDialog() == DialogResult.OK)
                {
                    string[] filePaths = openFileDialog.FileNames;
                    foreach (string filePath in filePaths)
                    {
                        AddFileCommand.Execute(filePath, parent, m_conn);
                    }
                    m_model.Reload();
                }
            }
        }
コード例 #10
0
        public async Task TestAddFileReadEventsErrorBadRequestResult()
        {
            //Arrange
            const string error      = "testError";
            var          documentId = Guid.NewGuid();
            var          command    = new AddFileCommand("test", "description");

            _documentFilesController = new DocumentFilesController(TestHelper.ReadEventsFuncWithError(error),
                                                                   TestHelper.SaveAndPublish, GetFile, GetFiles, TestHelper.GetCurrentUserId(), TestHelper.GetDocumentById());

            //Act
            var result = await _documentFilesController.AddFile(documentId, command);

            //Assert
            var badRequestResult = result as BadRequestObjectResult;

            Assert.NotNull(badRequestResult);
            Assert.NotNull(badRequestResult.Value);
        }
コード例 #11
0
        public async Task SendDocumentForApprovalTest()
        {
            // Arrange
            var createDocumentCommand = new CreateDocumentCommand(DateTime.UtcNow.Ticks.ToString(), "Test document");
            var addFileCommand        = new AddFileCommand("Test", "Test file");

            // Act
            var documentUri = await _client.CreateDocumentAsync(createDocumentCommand);

            await _client.AddFileAsync(documentUri, addFileCommand);

            await _client.SendDocumentForApprovalAsync(documentUri);

            var document = await _client.GetAsync <Document>(documentUri);

            // Assert
            Assert.NotNull(document);
            Assert.Equal(DocumentStatus.WaitingForApproval.ToString(), document.Status);
        }
コード例 #12
0
        public void File_add_adds_file_and_publishes_event()
        {
            // Arrange
            FakeFileStorage         fileStorage         = new FakeFileStorage();
            FakeFileRepository      fileRepository      = new FakeFileRepository();
            FakeEventPublisher      eventPublisher      = new FakeEventPublisher();
            FakeCurrentUserSource   currentUserSource   = new FakeCurrentUserSource();
            FakePostCommitRegistrar postCommitRegistrar = new FakePostCommitRegistrar();

            currentUserSource.CurrentUser = new User("userId", "username");

            var commandHandler = new AddFileCommandHandler(
                fileRepository, fileStorage, eventPublisher, postCommitRegistrar, currentUserSource);

            var contentBuffer = Encoding.UTF8.GetBytes("testContent");

            using (Stream fileContent = new MemoryStream(contentBuffer))
            {
                var command = new AddFileCommand("filename", "desc", "text/plain", fileContent);

                // Act
                commandHandler.Handle(command);
                postCommitRegistrar.ExecuteActions();

                // Assert
                File addedFile = fileRepository.GetByName("filename");

                Assert.IsNotNull(addedFile);
                Assert.AreEqual("filename", addedFile.FileName);
                Assert.AreEqual("desc", addedFile.Description);
                Assert.AreEqual("userId", addedFile.Owner.Id);

                Stream fileStream = fileStorage.ReadFile(addedFile).Result;
                Assert.IsNotNull(fileStream);

                using (var reader = new StreamReader(fileStream))
                    Assert.AreEqual("testContent", reader.ReadToEnd());

                File publishedEvent = eventPublisher.VerifyPublishedOnce <File>();
                Assert.AreEqual(addedFile, publishedEvent);
            }
        }
        public void AddFileToDfsResponse_Finished_Can_Get_Output()
        {
            //Arrange
            var addFileToDfsResponse = new AddFileToDfsResponse
            {
                ResponseCode = ByteString.CopyFrom((byte)FileTransferResponseCodeTypes.Finished.Id)
            };

            var commandContext      = TestCommandHelpers.GenerateCliResponseCommandContext(_testScheduler);
            var addFileToDfsCommand = new AddFileCommand(null, commandContext, _logger);

            //Act
            TestCommandHelpers.GenerateResponse(commandContext, addFileToDfsResponse);

            _testScheduler.Start();

            //Assert
            commandContext.UserOutput.Received(1).WriteLine("File transfer completed, Response: " +
                                                            FileTransferResponseCodeTypes.Finished.Name +
                                                            " Dfs Hash: " + addFileToDfsResponse.DfsHash);
        }
コード例 #14
0
        public async Task TestAddFileInvalidCommandBadRequestResult()
        {
            //Arrange
            var documentId         = Guid.NewGuid();
            var command            = new AddFileCommand(string.Empty, "test");
            var documentCreatedDto =
                new DocumentCreatedEventDto(Guid.Empty, DateTime.UtcNow, Guid.Empty, "1234", string.Empty);
            var readEventsFunc = TestHelper.ValidReadEventsFunc(documentCreatedDto.ToEvent());

            _documentFilesController = new DocumentFilesController(readEventsFunc, TestHelper.SaveAndPublish, GetFile,
                                                                   GetFiles, TestHelper.GetCurrentUserId(), TestHelper.GetDocumentById());

            //Act
            var result = await _documentFilesController.AddFile(documentId, command);

            //Assert
            var badRequestResult = result as BadRequestObjectResult;

            Assert.NotNull(badRequestResult);
            Assert.NotNull(badRequestResult.Value);
        }
コード例 #15
0
        public void AddFileCommand_AddsPackagesAndReferences()
        {
            // Arrange
            var currentDir = Directory.GetCurrentDirectory();
            var tempDir    = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());

            new DirectoryInfo(Path.Combine(currentDir, "TestAssets", "EmptyProject")).CopyTo(tempDir);

            // Act
            Directory.SetCurrentDirectory(tempDir);
            var command = new AddFileCommand(new TestConsole(), null);

            command.AddFile(Services.Server, Access.Internal, "ImportDir", new[] { Path.Combine("Proto", "*.proto") });
            command.Project.ReevaluateIfNecessary();

            // Assert
            var packageRefs = command.Project.GetItems(CommandBase.PackageReferenceElement);

            Assert.AreEqual(1, packageRefs.Count);
            Assert.NotNull(packageRefs.SingleOrDefault(r => r.UnevaluatedInclude == "Grpc.AspNetCore" && !r.HasMetadata(CommandBase.PrivateAssetsElement)));


            var protoRefs = command.Project.GetItems(CommandBase.ProtobufElement);

            Assert.AreEqual(2, protoRefs.Count);
            Assert.NotNull(protoRefs.SingleOrDefault(r => r.UnevaluatedInclude == Path.Combine("Proto", "a.proto")));
            Assert.NotNull(protoRefs.SingleOrDefault(r => r.UnevaluatedInclude == Path.Combine("Proto", "b.proto")));
            foreach (var protoRef in protoRefs)
            {
                Assert.AreEqual("Server", protoRef.GetMetadataValue(CommandBase.GrpcServicesElement));
                Assert.AreEqual("ImportDir", protoRef.GetMetadataValue(CommandBase.AdditionalImportDirsElement));
                Assert.AreEqual("Internal", protoRef.GetMetadataValue(CommandBase.AccessElement));
            }

            // Cleanup
            Directory.SetCurrentDirectory(currentDir);
            Directory.Delete(tempDir, true);
        }
コード例 #16
0
        public void Upload(AddFileCommand command)
        {
            AssertConcern.AssertArgumentNotEmpty(command.FileName, "Nome do arquivo não pode ser nulo");

            var fileAlreadyExist = FileRepository.GetFilesByQuery(command.FileName);

            var file = new File(command.FileName, command.ContentType)
            {
                Size        = command.File.Length,
                CreatedAt   = DateTime.UtcNow,
                CreateBy    = command.CreateUser,
                UpdatedAt   = DateTime.UtcNow,
                UpdateBy    = command.CreateUser,
                ReferenceId = command.ReferenceId.Value
            };

            file.GenerateNewId();

            FileRepository.Save(file, command.CreateUser);
            AzureContainer.AddFile($"{file.Id}_{file.Name}", command.File);

            Uow.Commit();
        }
コード例 #17
0
 public async Task <IActionResult> Post([FromForm] AddFileCommand command)
 {
     return(await HandleAsync(command));
 }
コード例 #18
0
        public static async Task <Uri> AddFileAsync(this HttpClient httpClient, Uri documentUri, AddFileCommand command)
        {
            var content    = GetStringContent(command);
            var requestUri = CombineUri(documentUri, "files");

            var response = await httpClient.PostAsync(requestUri, content);

            response.EnsureSuccessStatusCode();
            Assert.NotNull(response.Headers.Location);

            return(response.Headers.Location);
        }
コード例 #19
0
        protected override string BuildPackage()
        {
            var commands = new List <ICommand>();

            foreach (var item in Items)
            {
                var syncItem = ItemSynchronization.BuildSyncItem(item);

                var contentDataItem = new ContentDataItem(string.Empty, item.Paths.ParentPath, item.Name, syncItem);

                var command = new AddItemCommand(contentDataItem);

                commands.Add(command);
            }

            var rootPath = FileUtil.MapPath("/");

            foreach (var fileName in Files)
            {
                if (FileUtil.IsFolder(fileName))
                {
                    foreach (var file in Directory.GetFiles(FileUtil.MapPath(fileName), "*", SearchOption.AllDirectories))
                    {
                        var fileInfo = new FileInfo(file);
                        if ((fileInfo.Attributes & FileAttributes.Hidden) == FileAttributes.Hidden)
                        {
                            continue;
                        }

                        if ((fileInfo.Attributes & FileAttributes.System) == FileAttributes.System)
                        {
                            continue;
                        }

                        var fileItem = new FileSystemDataItem(rootPath, Path.GetDirectoryName(file), Path.GetFileName(file));
                        var command  = new AddFileCommand(fileItem);
                        commands.Add(command);
                    }
                }
                else
                {
                    var fileItem = new FileSystemDataItem(rootPath, Path.GetDirectoryName(fileName), Path.GetFileName(fileName));
                    var command  = new AddFileCommand(fileItem);
                    commands.Add(command);
                }
            }

            var diff = new DiffInfo(commands)
            {
                Author    = Author,
                PostStep  = PostStep,
                Publisher = Publisher,
                Readme    = Readme,
                Version   = Version,
                Title     = PackageName
            };

            var directoryName = Path.GetDirectoryName(FileName) ?? string.Empty;

            directoryName = directoryName.Replace("\\", "/");
            var folderPath = FileUtil.MapPath(directoryName);

            diff.Serialize(folderPath);

            var packageFileName = FileUtil.UnmapPath(folderPath, false) + "/" + DiffInfo.OutputFileName;

            PackageGenerator.GeneratePackage(diff, packageFileName);

            return(packageFileName);
        }