private void Apply(ProjectCreated @event)
{
_projects.Add(@event.ProjectId);
LastModified = @event.OccurredAt;
LastModifiedBy = @event.UserId;
LastModifiedVersion = CalculateLastModifiedVersion();
}
public void Process(ProjectCreated @event)
{
var project = _projects.GetById(@event.Id);
project.Name = @event.Name;
_projects.Save(project);
}
public async Task Handle_ProjectCreatedEvent_CreatesProject()
{
// arrange
var message = new ProjectCreated
{
Id = Guid.NewGuid(),
Version = 1,
TimeStamp = DateTimeOffset.Now,
Name = "New Project",
Description = "A new Project Scription"
};
var target = new ReadModelEventHandler(this.context.DbContext, this.context.Mapper);
// act
await target.Handle(message);
// assert
var project = this.context.DbContext.Projects.FirstOrDefault(p => p.Id == message.Id);
Assert.NotNull(project);
Assert.Equal(message.Version, project.Version);
Assert.Equal(message.TimeStamp, project.TimeStamp);
Assert.Equal(message.Name, project.Name);
Assert.Equal(message.Description, project.Description);
Assert.Null(project.Description);
}
public void Process(ProjectCreated projectCreated)
{
_projects.Save(new Project()
{
Id = projectCreated.Id,
Name = projectCreated.Name
});
}
private void OnProjectCreated(ProjectCreated studioProject)
{
if (studioProject != null)
{
_projectControllerService.OpenProjectInFilesView(studioProject.CreatedProject);
}
Close();
}
public void Apply(ProjectCreated e)
{
Id = e.Id;
Name = e.Name;
Description = e.Description;
ClientId = e.ClientId;
CreatedOn = e.CreatedOn;
}
void OnProjectCreated()
{
ProjectCreated?.Invoke(this, EventArgs.Empty);
if (IdeServices.DesktopService.AccessibilityInUse)
{
var announcement = GettextCatalog.GetString("{0} successfully created", SelectedTemplate.Name);
IdeServices.DesktopService.MakeAccessibilityAnnouncement(announcement);
}
}
public void Process(ProjectCreated @event)
{
var project = _projects.GetById(@event.Id);
project.NationalSociety = _nationalSocieties.GetById(@event.NationalSocietyId);
project.DataOwner = _users.GetById(@event.DataOwnerId);
project.Name = @event.Name;
project.SurveillanceContex = @event.SurveillanceContex;
_projects.Save(project);
}
public void Process(ProjectCreated @event)
{
var project = new Project
{
Id = @event.Id,
Name = @event.Name
};
_projects.Insert(project);
}
public Project(Guid id, string title)
{
if (string.IsNullOrWhiteSpace(title))
{
throw new ArgumentException(nameof(title));
}
State = new ProjectState(id, title);
var projectCreated = new ProjectCreated(id, title);
_events.Add(projectCreated);
}
public Project(Guid id, string name, string description)
{
this.Id = id;
this.Schema = new ModelDefinition(this.eventAggregator);
this.Configuration = new Configuration(this.eventAggregator, this.Schema);
var e = new ProjectCreated {
Id = id, Name = name, Description = description
};
this.ApplyChange(e);
}
protected override void Handle(Commands.CreateProject command)
{
var dateTime = DateTime.UtcNow;
var @event = new ProjectCreated(
command.ProjectId,
command.ProjectOwnerId,
command.Name,
dateTime);
_saveEventService.SaveEvent(@event, dateTime);
}
public void Process(ProjectCreated @event)
{
var project = new Project
{
Id = @event.Id,
NationalSociety = _nationalSocieties.GetById(@event.NationalSocietyId),
DataOwner = _users.GetById(@event.DataOwnerId),
Name = @event.Name,
SurveillanceContext = @event.SurveillanceContext
};
_projects.Save(project);
}
public void ApplyEvent(ProjectCreated @event)
{
var readModel = new ProjectReadModel
{
ProjectId = @event.ProjectId,
ProjectName = @event.ProjectName,
ProjectAbbreviation = @event.ProjectAbbreviation,
Description = @event.Description,
ProjectType = @event.ProjectType.ToProjectTypeString(),
IsCompleted = false
};
_projectRepository.Save(readModel, justCreated: true);
}
private void Apply(ProjectCreated e)
{
Id = e.Id;
Created = e.OccurredAt;
CreatedBy = e.UserId;
Name = e.Name;
_environments = new List <Environment>();
_toggles = new List <Toggle>();
_environmentStates = new List <EnvironmentState>();
LastModified = e.OccurredAt;
LastModifiedBy = e.UserId;
LastModifiedVersion = 0;
}
public async Task projectcreated_event_fails_when_project_with_id_already_exists()
{
var projectId = "projectKey";
var project = new Project(projectId);
await _projectsMongoDbFixture.InsertAsync(project.AsDocument());
var externalEvent = new ProjectCreated(projectId);
// Check if exception is thrown
_eventHandler
.Awaiting(c => c.HandleAsync(externalEvent))
.Should().Throw <ProjectAlreadyCreatedException>();
}
public void Process(ProjectCreated @event)
{
var project = new Project
{
Id = @event.Id,
NationalSociety = _nationalSocieties.GetById(@event.NationalSocietyId),
DataOwner = _users.GetById(@event.DataOwnerId),
Name = @event.Name,
SurveillanceContext = (ProjectSurveillanceContext)@event.SurveillanceContext,
HealthRisks = new ProjectHealthRisk[0],
DataVerifiers = new User[0],
SmsProxy = ""
};
_projects.Insert(project);
}
public async Task projectcreated_event_should_add_project_with_given_data_to_database()
{
var projectId = "projectKey";
var externalEvent = new ProjectCreated(projectId);
// Check if exception is thrown
_eventHandler
.Awaiting(c => c.HandleAsync(externalEvent))
.Should().NotThrow();
var project = await _projectsMongoDbFixture.GetAsync(externalEvent.ProjectId);
project.Should().NotBeNull();
project.Id.Should().Be(projectId);
}
/// <summary>
/// Creates the project.
/// </summary>
/// <param name="name">The name of the project.</param>
/// <param name="description">The description of the project.</param>
/// <param name="projectOrdered">The project ordered.</param>
/// <param name="receivingOrganization">The receiving organization of the project.</param>
/// <param name="mandatory">if set to <c>true</c> project is mandatory.</param>
/// <param name="startDate">The start date of the project.</param>
/// <param name="endDate">The end date of the project.</param>
/// <param name="department">The department of the project.</param>
/// <param name="classification">The classification of the project.</param>
/// <param name="owner">The owner of the project.</param>
/// <param name="manager">The manager of the project.</param>
public void CreateProject(string name, string description, string projectOrdered, string receivingOrganization, bool mandatory,
DateTime startDate, DateTime endDate, Department department, PpsClassification classification, UserId owner, UserId manager)
{
this.Name = name;
this.Description = description;
this.ProjectOrderer = projectOrdered;
this.RecievingOrganization = receivingOrganization;
this.Mandatory = mandatory;
this.StartDate = startDate;
this.EndDate = endDate;
this.Department = department;
this.Classification = classification;
this.Owner = owner;
this.Manager = manager;
this.IsNew = true;
this.IsDeleted = false;
this.TeamMembers = new List <TeamMember>();
var @event = new ProjectCreated(this.Id);
this.ApplyChange(@event);
}
public void Process(ProjectCreated @event)
{
_projects.SaveProject(@event.Id, @event.Name);
}
private void Apply(ProjectCreated e)
{
Name = e.Name;
}
protected void OnCreateProject(object sender, ProjectArgs e)
{
ProjectCreated.Invoke(sender, e);
}
public async Task Create()
{
projectCreated = new TaskCompletionSource <bool> ();
if (wizardProvider.HasWizard)
{
wizardProvider.BeforeProjectIsCreated();
}
if (!await CreateProject())
{
projectCreated.SetResult(false);
ProjectCreationFailed?.Invoke(this, EventArgs.Empty);
return;
}
Solution parentSolution = null;
if (ParentFolder == null)
{
//NOTE: we can only create one solution, so if the first item is a solution, it's the only item
parentSolution = processedTemplate.WorkspaceItems.FirstOrDefault() as Solution;
if (parentSolution != null)
{
if (parentSolution.RootFolder.Items.Count > 0)
{
currentEntries = new List <SolutionItem> (parentSolution.GetAllSolutionItems());
}
ParentFolder = parentSolution.RootFolder;
}
}
else
{
parentSolution = ParentFolder.ParentSolution;
currentEntries = processedTemplate.WorkspaceItems.OfType <SolutionItem> ().ToList();
}
// New combines (not added to parent combines) already have the project as child.
if (!projectConfiguration.CreateSolution)
{
// Make sure the new item is saved before adding. In this way the
// version control add-in will be able to put it under version control.
foreach (SolutionItem currentEntry in currentEntries)
{
var eitem = currentEntry as SolutionItem;
if (eitem != null)
{
// Inherit the file format from the solution
eitem.ConvertToFormat(ParentFolder.ParentSolution.FileFormat);
var project = eitem as Project;
if (project != null)
{
// Remove any references to other projects and add them back after the
// project is saved because a project reference cannot be resolved until
// the project has a parent solution.
List <ProjectReference> projectReferences = GetProjectReferences(project);
if (projectReferences.Any())
{
project.Items.RemoveRange(projectReferences);
}
await IdeApp.ProjectOperations.SaveAsync(eitem);
if (projectReferences.Any())
{
project.Items.AddRange(projectReferences);
}
}
}
ParentFolder.AddItem(currentEntry, true);
}
}
else
{
string solutionFileName = Path.Combine(projectConfiguration.SolutionLocation, finalConfigurationPage.SolutionFileName);
if (File.Exists(solutionFileName))
{
if (!MessageService.Confirm(GettextCatalog.GetString("File {0} already exists. Overwrite?", solutionFileName), AlertButton.OverwriteFile))
{
ParentFolder = null; //Reset process of creating solution
projectCreated.SetResult(false);
return;
}
File.Delete(solutionFileName);
}
}
dialog.CloseDialog();
try {
if (ParentFolder != null)
{
await IdeApp.ProjectOperations.SaveAsync(ParentFolder.ParentSolution);
}
else
{
await IdeApp.ProjectOperations.SaveAsync(processedTemplate.WorkspaceItems);
}
CreateVersionControlItems();
if (OpenSolution)
{
DisposeExistingNewItems();
TemplateWizard wizard = wizardProvider.CurrentWizard;
if (await OpenCreatedSolution(processedTemplate))
{
var sol = IdeApp.Workspace.GetAllSolutions().FirstOrDefault();
if (sol != null)
{
if (wizard != null)
{
wizard.ItemsCreated(new [] { sol });
}
InstallProjectTemplatePackages(sol);
}
}
}
else
{
// The item is not a solution being opened, so it is going to be added to
// an existing item. In this case, it must not be disposed by the dialog.
RunTemplateActions(processedTemplate);
if (wizardProvider.HasWizard)
{
wizardProvider.CurrentWizard.ItemsCreated(processedTemplate.WorkspaceItems);
}
if (ParentFolder != null)
{
InstallProjectTemplatePackages(ParentFolder.ParentSolution);
}
}
wizardProvider.Dispose();
IsNewItemCreated = true;
UpdateDefaultSettings();
projectCreated.SetResult(true);
await Runtime.RunInMainThread(() => ProjectCreated?.Invoke(this, EventArgs.Empty));
} catch (Exception ex) {
projectCreated.SetException(ex);
throw;
}
}
private void Apply(ProjectCreated @event)
{
}
protected virtual void OnProjectCreated(ProjectCreatedEventArgs e)
{
ProjectCreated?.Invoke(this, e);
}
private void Apply(ProjectCreated e)
{
this.Id = e.Id;
this.Name = e.Name;
}
