public async Task<IActionResult> CreateOrganization(CreateOrganizationCommand command, ApiVersion version) { var organization = await Mediator.Send(command); return CreatedAtAction(nameof(GetOrganization), new { id = organization.Id, version = version.ToString() }, organization); }
public async Task <IHttpActionResult> CreateOrganization(string description, string details, OrganizationType organizationType, ReportingFrequency reportingFrequency, EntityReference parent) { try { if (!_userContext.CurrentUserIsSystemUser()) { return(Unauthorized()); } if (string.IsNullOrWhiteSpace(description)) { throw new ArgumentException("Value cannot be null or whitespace.", nameof(description)); } if (!_userContext.CurrentUserIsSystemAdmin()) { return(Unauthorized()); } var cmd = new CreateOrganizationCommand(description, details, organizationType, reportingFrequency, parent); await _endpointInstance().SendWithSignalRMetaData(cmd, Request); return(this.Accepted()); } catch (Exception ex) { _log.Error(ex); return(InternalServerError()); } }
public async Task <IActionResult> CreateOrganization([FromBody] CreateOrganizationCommand createOrganizationCommand, CancellationToken cancellationToken = default) { createOrganizationCommand.CreatedBy = User.ExtractIdentifier(); var result = await _mediator.Send(createOrganizationCommand, cancellationToken); return(Created($"{nameof(Organization)}/{result.Id}", result)); }
public void CreateOrganizationCommand_WithoutTitle_ShouldThrowValidationException() { var command = new CreateOrganizationCommand(); FluentActions.Invoking(() => SendAsync(command)).Should().Throw <ValidationException>(); }
public async Task <IActionResult> Create(CreateOrganizationCommand command) { logger.LogInformation("Creating organization"); var result = await service.Handle(command); return(FromResult(result)); }
public async Task <IActionResult> Create([FromBody] CreateOrganizationCommand request) { var response = await _mediator.Send(request); if (response.WithError) { return(BadRequest(response)); } return(Ok(response)); }
public void CreateOrganizationCommand_WithoutCurrentUserId_ShouldThrowDbUpdateException() { var command = new CreateOrganizationCommand { Title = "Test" }; FluentActions.Invoking(() => SendAsync(command)).Should().Throw <DbUpdateException>(); }
/** * Creates an organization */ public int CreateOrganization(CreateOrganizationCommand command) { var organization = mapper.Map <OrganizationEntity>(command); organization.CreatedAt = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(); this.context.Organizations.Add(organization); this.context.SaveChanges(); return(organization.OrganizationEntityId); }
public void CreateOrganizationCommand_WithTitleMoreThan200Characters_ShouldThrowValidationException() { var command = new CreateOrganizationCommand { Title = "This is a very long title for an organization so we could test Request validator. In this case we expect a validation exception because our title is more that 200 character. so let's test it and see our test result" }; FluentActions.Invoking(() => SendAsync(command)).Should().Throw <ValidationException>(); }
public IOrganization CreateOrganization(string name, string description) { userContext.CheckPermission(Permissions.UserMaintenance); Guid organizationId = Guid.NewGuid(); ICommand command = new CreateOrganizationCommand(organizationId, name, description); commandBus.Value.Send(Envelope.Create(command)); return(GetOrganization(organizationId)); }
public async Task <IActionResult> Create(CreateOrganizationCommand createOrganizationCommand) { var result = await Mediator.Send(createOrganizationCommand); if (result.Success == false) { return(result.ApiResult); } return(Created(Url.Link("GetOrganizationInfo", new { id = result.Data.Id }), result.Data)); }
/// <summary> /// Creates organization /// </summary> /// <param name="createOrganizationCommand">Model for all needed fields to create a tenant</param> /// <returns>ID of created Organization</returns> /// <exception cref="InvalidCreateOrganizationDataError">If create data is not valid</exception> /// <exception cref="OrganizationAlreadyExistsError">If organization already exists</exception> public Result <int> CreateOrganization(CreateOrganizationCommand createOrganizationCommand) { if (createOrganizationCommand?.Name == null || createOrganizationCommand.Name.Length == 0) { return(new Result <int>(OrganizationServiceErrors.InvalidCreateOrganizationDataError(nameof(createOrganizationCommand.Name)))); } if (this.organizationRepository.OrganizationExistsByName(createOrganizationCommand.Name)) { return(new Result <int>(OrganizationServiceErrors.OrganizationAlreadyExistsError())); } return(new Result <int>(this.organizationRepository.CreateOrganization(createOrganizationCommand))); }
public async Task <ActionResult> Create(OrganizationViewModel model, CancellationToken cancellationToken) { if (ModelState.IsValid) { var command = new CreateOrganizationCommand(model.Name, User.Identity.GetUserId()); Organization organization = await _createOrganization.Execute(command, cancellationToken); return(RedirectToAction("Details", new { id = organization.Id })); } return(View()); }
public HttpResponseMessage Post(CreateOrganizationCommand command) { if (command.Id == Guid.Empty) { command.Id = Guid.NewGuid(); } m_CreateHandler.Handle(command); var response = Request.CreateResponse(HttpStatusCode.Created, command.Id); return(response); }
public async Task<ActionResult> Create(OrganizationViewModel model, CancellationToken cancellationToken) { if (ModelState.IsValid) { var command = new CreateOrganizationCommand(model.Name, User.Identity.GetUserId()); Organization organization = await _createOrganization.Execute(command, cancellationToken); return RedirectToAction("Details", new {id = organization.Id}); } return View(); }
public async Task Handle_Success(CreateOrganizationCommand orgDto, Mock <ILogger <CreateOrganizationCommandHandler> > logger) { //Arrange var workerService = new Mock <IOrganizationWorkerService>(); workerService.Setup(x => x.AddOrganization(It.IsAny <OrganizationDto>())); var system = new CreateOrganizationCommandHandler(workerService.Object, logger.Object); //Act await system.Handle(orgDto); //Assert workerService.Verify(x => x.AddOrganization(It.IsAny <OrganizationDto>()), Times.Once); }
public async Task CreateOrganizationCommandValidationTests(CreateOrganizationCommand command, Action <CreateOrganizationCommand, CreateOrganizationCommandValidator> assertation) { var user = Fixture.Build <CreateUserCommand>().Create(); var handler = new CreateUserCommandHandler(Context, _mapper); var result = await handler.Handle(user); await Context.SaveChangesAsync(); var validator = new CreateOrganizationCommandValidator(Context); command.CreatedBy = result.Id; assertation(command, validator); }
public Task <Organization> AddOrganizationAsync(CreateOrganizationCommand command) { // Creates entity var person = new Organization { Id = OrganizationsDB.Items.Count + 1, Name = command.Name, Integrants = command.Integrants }; // Insert it OrganizationsDB.Items.Add(person); return(Task.FromResult(person)); }
public async Task CreateOrganization(OrganizationDto newOrganization) { var id = Guid.NewGuid(); var command = new CreateOrganizationCommand( id, newOrganization.Name, newOrganization.Street, newOrganization.StreetExtended, newOrganization.PostalCode, newOrganization.City, newOrganization.Country, newOrganization.VatNumber, newOrganization.Website, newOrganization.ChangeDate, newOrganization.ChangedBy); await _bus.Send(command); }
public void CreateNewOrganizationWithUserThenDelete() { var command = new CreateOrganizationCommand(); command.Name = "Test Org"; command.PrimaryEmailAddress = "*****@*****.**"; command.WebsiteUrl = "www.n-dexed.com"; IHashProvider hashProvider = new PublicPrivateKeyHasher(); string publicKey = ConfigurationManager.AppSettings["PublicKey"]; string privateKey = ConfigurationManager.AppSettings["PrivateKey"]; hashProvider.RegisterKeyPair(publicKey, privateKey); IRepository <UserInfo, UserInfo> userRepository = new MockUserRepository(); ISearchableRepository <UserInfo, UserInfo> searchRepository = new MockUserRepository(); var messager = new MockMailMessager(); IEncryptor encryptor = new RijndaelManagedEncryptor(); IAuthorizationTokenProvider tokenProvider = new HashAuthorizationTokenProvider(hashProvider, encryptor); ICommandHandler <CreateUserCommand> commandHandler = new UserCommandHandler(hashProvider, userRepository, messager, tokenProvider, searchRepository); var handler = new OrganizationCommandHandler(new MockOrganizationRepository(), searchRepository, commandHandler); try { handler.Handle(command); } finally { try { var searchCriteria = new UserInfo() { EmailAddress = command.PrimaryEmailAddress }; var user = searchRepository.Search(searchCriteria).First(); userRepository.Remove(user); } catch { } } }
public async Task CreateOrganizationCommand_WithTitle_ShouldInsertOrganizationAndReturnOrganizationId() { var defaultUserId = await RunAsDefaultUserAsync(); var command = new CreateOrganizationCommand { Title = "Test" }; var organizationId = await SendAsync(command); var organization = await FindAsync <Organization>(organizationId); organization.ShouldNotBeNull(); organization.Title.ShouldBe("Test"); organization.Id.ShouldBe(organizationId); }
public void Instansiate_NoStreetExtended_Success(Guid id, string name, string street, string postalCode, string city, string country, string vatNumber, string website, DateTime changeDate, string changedBy) { var command = new CreateOrganizationCommand( id, name, street, string.Empty, postalCode, city, country, vatNumber, website, changeDate, changedBy ); command.Should().BeOfType <CreateOrganizationCommand>(); }
public async Task <Guid> Handle(CreateOrganizationRequest request, CancellationToken cancellationToken) { var command = new CreateOrganizationCommand( new Guid(request.Id), request.Name, request.Street, request.StreetExtended, request.PostalCode, request.City, request.Country, request.VatNumber, request.Website, request.ChangeDate, request.ChangedBy); await _bus.Send(command); return(await Task.FromResult(Guid.Empty)); }
public async Task CreateOrganizationCommand_WithTitle_ShouldInsertCurrentUserAsAdminOfOrganizationAndReturnOrganizationId() { var defaultUserId = await RunAsDefaultUserAsync(); var command = new CreateOrganizationCommand { Title = "Test" }; var organizationId = await SendAsync(command); var organization = await FindAsync <Organization>(organizationId); organization.ShouldNotBeNull(); organization.Title.ShouldBe("Test"); organization.Id.ShouldBe(organizationId); var context = GetContext(); var orgnizationUser = await context.OrganizationUsers.SingleOrDefaultAsync(x => x.OrganizationId == organizationId && x.UserId == defaultUserId && x.Type == UserType.Admin); orgnizationUser.ShouldNotBeNull(); }
public async Task <Result <CommandResult> > Handle(CreateOrganizationCommand request, CancellationToken cancellationToken) { if (!request.IsValid()) { await PublishValidationErrorsAsync(request); return(Result.Failure <CommandResult>(ApplicationMessages.Create_Failed)); } var organization = _mapper.Map <Organization>(request); var exist = await _organizationRepository.ExistByNameAsync(organization.Id, organization.Name); if (exist) { await _mediator.Publish(new DomainNotification("", ApplicationMessages.Name_Already_Exist)); return(Result.Failure <CommandResult>(ApplicationMessages.Create_Failed)); } await _organizationRepository.CreateAsync(organization); return(Result.Success(new CommandResult(organization.Id, ApplicationMessages.Create_Success))); }
public async Task <Result <Guid> > CreateOrganization( [FromBody] CreateOrganizationCommand command, CancellationToken token) => await Mediator.Send(command, token);
public async Task <ActionResult <Guid> > Create(CreateOrganizationCommand command) { return(await Mediator.Send(command)); }
public async Task <ActionResult> CreateOrganization(CreateOrganizationCommand command) { command.UserId = User.GetUserId(); return(await this.SendCreateCommand(command, nameof(GetOrganization))); }
public Task <CommandResult <int> > CreateOrganization(CreateOrganizationCommand cmd) { throw new NotImplementedException(); }
public async Task <IActionResult> CreateOrganization([FromBody] CreateOrganizationCommand command) => await HandleCommandAsync(command, _commandService.CreateOrganization);