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);
