public async Task <EntityResponse <Report> > Handle(CreateReportCommand request, CancellationToken cancellationToken) { var response = new EntityResponse <Report> () { ReponseName = nameof(CreateReportCommand), Content = new List <Report> () { } }; var entity = _mapper.Map <Report> (request); var newentity = await _reportRepository.AddAsync(entity); if (newentity == null) { response.Status = ResponseType.Warning; response.Message = $"{nameof(Report)} could not be created."; response.Content = null; } else { response.Status = ResponseType.Success; response.Message = $"{nameof(Report)} created successfully."; response.Content.Add(newentity); } return(response); }
/// <summary> /// Occurs if any test result data in <see cref="ISyncServiceModel"/> was changed. /// </summary> /// <param name="sender">Sender of the event.</param> /// <param name="e">Empty event data.</param> private void HandleTestReportDataChangedEvent(object sender, SyncServiceEventArgs e) { if (e.DocumentName != Document.Name || e.DocumentFullName != Document.FullName) { return; } ViewDispatcher.Invoke(() => CreateReportCommand.CallEventCanExecuteChanged()); OperationActive = SyncServiceDocumentModel.TestReportRunning; }
public void CanBeSerialized() { //Arrange var sut = new CreateReportCommand(new List <CostItem>()); //Act var json = JsonSerializer.Serialize(sut); //Assert Assert.False(string.IsNullOrEmpty(json)); }
public async Task CanProcessCommand() { //Arrange var sut = _serviceProviderFixture.Provider.GetService <IApplicationFacade>(); var testCommand = new CreateReportCommand(new List <CostItem>()); //Act var result = await sut.Execute(testCommand); //Assert Assert.NotNull(result); }
void IReportService.CreateReport(CreateReportCommand command) { try { reportRepository.CreateReport(command.ToReportModel()); reportRepository.Save(); } catch (DbUpdateException) { throw; } }
public void CanBeConstructed() { //Arrange var sut = new CreateReportCommand(new List <CostItem>()); //Act var hashCode = sut.GetHashCode(); //Assert Assert.NotNull(sut); Assert.Equal(hashCode, sut.GetHashCode()); Assert.Empty(sut.CostItems); }
public AdminWindowViewModel() { RunList = new ObservableCollection <Run>(); IsTaskReadOnly = true; IsUserReadOnly = true; IsMarketReadOnly = true; SaveTaskCommand = new SaveTaskCommand(this); SaveMarketCommand = new SaveMarketCommand(this); ChangeTaskCommand = new ChangeTaskCommand(this); CancelSaveTaskCommand = new CancelSaveTaskCommand(this); ContactDeveloperCommand = new ContactDeveloperCommand(this); ResetTaskCommand = new ResetTaskCommand(this); CreateReportCommand = new CreateReportCommand(this); CloseCommand = new CloseWindowCommand(); MaximizeCommand = new MaximizeWindowCommand(); MinimizeCommand = new MinimizeWindowCommand(); CreateUserCommand = new CreateUserCommand(this); ChangeUserCommand = new ChangeUserCommand(this); SaveUserCommand = new SaveUserCommand(this); CancelUserCommand = new CancelUserCommand(this); RemoveUserCommand = new RemoveUserCommand(this); TaskIndex = 0; UserIndex = 0; MarketIndex = 0; DevList = new List <User>(UserManager.GetUserByGroup(UserGroup.Dev, RunTimeContext.Context.DatabaseContext)); MarketList = new ObservableCollection <Market>(MarketManager.GetAllMarkets(RunTimeContext.Context.DatabaseContext)); TaskList = new ObservableCollection <Task>(TaskManager.GetAllTasks(RunTimeContext.Context.DatabaseContext)); SetUserList(); SelectedTask = TaskList.FirstOrDefault(); SelectedUser = UserList.FirstOrDefault(); SelectedMarket = MarketList.FirstOrDefault(); StartDate = DateTime.Now.AddMonths(-1); EndDate = DateTime.Now; TaskFilter = TaskList.FirstOrDefault(); MarketFilter = MarketList.FirstOrDefault(); DevFilter = DevList.FirstOrDefault(); }
public static Report ToReportModel(this CreateReportCommand command) { if (command == null) { return(null); } return(new Report() { Title = command.Title, ReporterId = command.ReporterId, Description = command.Description, ReproduceSteps = command.ReproduceSteps, BuildId = command.BuildId }); }
public async Task <ActionResult <EntityResponse <Report> > > CreateReport(CreateReportCommand command) { try { var result = await _mediator.Send(command); return(Ok(result)); } catch (ValidationException ex) { var err = new EntityResponse <Report> (); err.ReponseName = nameof(CreateReport); err.Status = ResponseType.Error; err.Message = ex.Message; err.Content = null; return(Ok(err)); } }
private async Task CreateReport(string forUser, string forCompany) { var color = _generator.GetContrastedColor(_contrastColor, 1.8); var users = await GetUserIds(forUser); var companies = await GetCompanyIds(forCompany); var request = new CreateReportCommand( _faker.Lorem.Sentence(), _faker.Lorem.Sentence(10, 20), _generator.GetContrastRatio(_contrastColor, color).ToString("F2"), new ColorDto(color.Red, color.Green, color.Blue), users.Select(uid => uid.Value).ToArray(), companies.Select(uid => uid.Value).ToArray()); await _mediator.Send(request); }
private async void ReceivedEvent(object sender, BasicDeliverEventArgs e) { if (e.RoutingKey == EventBusConstants.PrepareReportQueue) { var message = Encoding.UTF8.GetString(e.Body.Span); var prepareReportEvent = JsonConvert.DeserializeObject <PrepareReportEvent>(message); //create a new report var createCommand = new CreateReportCommand { Location = prepareReportEvent.Location }; var createCommandResponse = await _mediator.Send(createCommand); //update the report var prepareReportCommand = new PrepareReportCommand { Location = prepareReportEvent.Location, Persons = prepareReportEvent.Persons.Select(i => new Application.Models.PersonModel { Id = i.Id, Company = i.Company, FirstName = i.FirstName, LastName = i.LastName, Addresses = i.Addresses.Select(x => new Application.Models.AddressModel { Id = x.Id, AddressType = x.AddressType, Email = x.Email, Location = x.Location, Phone = x.Phone }).ToList() }).ToList(), ReportId = createCommandResponse.Id, RequestId = prepareReportEvent.RequestId }; await _mediator.Send(prepareReportCommand); } }
public ICommand <IAggregateRoot> Convert(IAggregateRoot source, ICommand <IAggregateRoot> destination = default, ResolutionContext context = default) { switch (source) { case ReportRoot report: if (report.Id == Guid.Empty) { destination = new CreateReportCommand(report.CostItems); } else { destination = new UpdateReportCommand(report); } break; case null: default: break; } return(destination); }
/// <summary> /// The method creates report for selected test suite. /// </summary> public void CreateReport() { SyncServiceTrace.D("Creating report..."); SyncServiceDocumentModel.TestReportRunning = true; try { ProcessPreOperations(); // Common part if (IncludeTestConfigurations && SelectedConfigurationPositionType == Contracts.Enums.Model.ConfigurationPositionType.AboveTestPlan) { CreateConfigurationPart(); } if (CreateDocumentStructure) { switch (SelectedDocumentStructureType) { case DocumentStructureType.AreaPath: CreateReportByAreaPath(SelectedTestSuite); break; case DocumentStructureType.IterationPath: CreateReportByIterationPath(SelectedTestSuite); break; case DocumentStructureType.TestPlanHierarchy: CreateReportByTestPlanHierarchy(SelectedTestSuite); break; } } else { CreateReportUnstructured(SelectedTestSuite); } if (!CancellationPending()) { // Set the 'Report generated' only if the report was not canceled SyncServiceDocumentModel.TestReportGenerated = true; if (ViewDispatcher != null) { ViewDispatcher.Invoke(() => CreateReportCommand.CallEventCanExecuteChanged()); } StoreReportData(); } var config = SyncServiceFactory.GetService <IConfigurationService>().GetConfiguration(Document); var testReport = SyncServiceFactory.CreateWord2007TestReportAdapter(Document, config); var testReportHelper = new TestReportHelper(TestAdapter, testReport, config, CancellationPending); if (TestReportingProgressCancellationService.CheckIfContinue()) { testReportHelper.CreateSummaryPage(WordDocument, SelectedTestPlan); ProcessPostOperations(); } else { SyncServiceTrace.I("Skipped creation of summary page and processing post operations because of error or cancellation."); } } catch (Exception ex) { var infoStorageService = SyncServiceFactory.GetService <IInfoStorageService>(); if (infoStorageService == null) { throw; } IUserInformation info = new UserInformation { Text = Resources.TestSpecification_Error, Explanation = ex is OperationCanceledException ? ex.Message : ex.ToString(), Type = UserInformationType.Error }; infoStorageService.AddItem(info); } finally { SyncServiceDocumentModel.TestReportRunning = false; } }
public async Task <ActionResult <ReportDto> > CreateReport([FromHybrid] CreateReportCommand command) { var result = await _mediator.Send(command); return(Ok(result)); }
public async Task <ReportRoot> Create(CreateReportCommand command) { return(await _applicationFacade.Execute(command)); }
public async Task <ActionResult <CreateReportOutputModel> > Create( CreateReportCommand command) => await this.Send(command);