public WorkflowDefinitionVersion Build()
{
// Generate deterministic activity ids.
var id = 1;
foreach (var activityBuilder in activityBuilders)
{
if (activityBuilder.Id == null)
{
activityBuilder.Id = $"activity-{id++}";
}
}
var activities = activityBuilders.Select(x => x.BuildActivity()).ToList();
var connections = connectionBuilders.Select(x => x.BuildConnection()).ToList();
var versionId = idGenerator.Generate();
var definitionId = !string.IsNullOrWhiteSpace(Id) ? Id : idGenerator.Generate();
return(new WorkflowDefinitionVersion(
versionId,
definitionId,
Version,
Name,
Description,
activities,
connections,
IsSingleton,
IsDisabled,
Variables.Empty)
{
IsPublished = true,
IsLatest = true
});
}
public async Task <Article> AddAsync(Article article, CancellationToken cancellationToken)
{
article.Id = _idGenerator.Generate();
var ret = await _repository.GetByTitleAsync(article.Title, cancellationToken);
if (ret != null && !string.IsNullOrEmpty(ret.Title))
{
return(await _repository.AddAsync(article, cancellationToken));
}
return(null);
}
public WorkflowDefinition New()
{
var definition = new WorkflowDefinition
{
Id = _idGenerator.Generate(),
DefinitionId = _idGenerator.Generate(),
Name = "New Workflow",
Version = 1,
IsLatest = true,
IsPublished = false,
IsSingleton = false
};
return(definition);
}
/// <summary>
/// Создать лог организации
/// </summary>
/// <param name="stateRegistrationId">Идентификатор государственной регистрации</param>
/// <param name="name">Наименование</param>
/// <param name="shortName">Короткое наименование</param>
/// <param name="legalAddress">Юридический адрес</param>
/// <param name="scientificActivity">Научная деятельность</param>
/// <param name="revisionNumber">Номер ревизии</param>
/// <returns>Идентификатор лога организации</returns>
public Guid Create(
Guid stateRegistrationId,
string name,
string shortName,
string legalAddress,
string scientificActivity,
long revisionNumber)
{
Contract.Argument.IsNotEmptyGuid(stateRegistrationId, nameof(stateRegistrationId));
Contract.Argument.IsNotNullOrEmptyOrWhiteSpace(name, nameof(name));
Contract.Argument.IsNotNullOrEmptyOrWhiteSpace(shortName, nameof(shortName));
Contract.Argument.IsNotNullOrEmptyOrWhiteSpace(scientificActivity, nameof(scientificActivity));
Contract.Argument.IsNotNullOrEmptyOrWhiteSpace(legalAddress, nameof(legalAddress));
Contract.Argument.IsValidIf(revisionNumber > 0, $"{nameof(revisionNumber)} > 0");
var createdOrganizationLog = _context.Set <OrganizationLog>().Create();
var id = _idGenerator.Generate();
createdOrganizationLog.Initialize(
id: id,
stateRegistrationId: stateRegistrationId,
name: name,
shortName: shortName,
scientificActivity: scientificActivity,
legalAddress: legalAddress,
revisionNumber: revisionNumber);
var newOrganizationLog = _context.Set <OrganizationLog>().Add(createdOrganizationLog);
return(newOrganizationLog.Id);
}
public async Task AddEntryAsync(string workflowInstanceId, string activityId, string activityType, string eventName, string?message, string?tenantId, string?source, JObject?data, CancellationToken cancellationToken = default)
{
var id = _idGenerator.Generate();
var timeStamp = _clock.GetCurrentInstant();
var record = new WorkflowExecutionLogRecord(id, tenantId, workflowInstanceId, activityId, activityType, timeStamp, eventName, message, source, data);
await _store.SaveAsync(record, cancellationToken);
}
public EntityTypeDataComponent(
EntityType entityType,
IIdGenerator idGenerator)
{
EntityType = entityType;
Id = idGenerator.Generate();
}
/// <summary>
/// Создать приглашение
/// </summary>
/// <param name="alienId">Иностранец</param>
/// <param name="employeeId">Сотрудник</param>
/// <param name="visitDetailId">Детали визита</param>
/// <param name="foreignParticipants">Сопровождение</param>
/// <param name="createdDate">Дата создания</param>
/// <param name="updateDate">Дата изменения</param>
/// <param name="invitationStatus">Статус приглашения</param>
/// <returns>Идентификатор приглашения</returns>
public Invitation Create(
Guid alienId,
Guid employeeId,
Guid visitDetailId,
ICollection <ForeignParticipant> foreignParticipants,
DateTimeOffset createdDate,
DateTimeOffset updateDate,
InvitationStatus invitationStatus)
{
Contract.Argument.IsNotEmptyGuid(alienId, nameof(alienId));
Contract.Argument.IsNotEmptyGuid(employeeId, nameof(employeeId));
Contract.Argument.IsNotEmptyGuid(visitDetailId, nameof(visitDetailId));
Contract.Argument.IsNotNull(foreignParticipants, nameof(foreignParticipants));
Contract.Argument.IsValidIf(createdDate <= updateDate, $"{nameof(createdDate)}:{createdDate} < {nameof(updateDate)}:{updateDate}");
var createdInvitation = _context.Set <Invitation>().Create();
var id = _idGenerator.Generate();
createdInvitation.Initialize(
id: id,
alienId: alienId,
employeeId: employeeId,
visitDetailId: visitDetailId,
foreignParticipants: foreignParticipants,
createdDate: createdDate,
updateDate: updateDate,
invitationStatus: invitationStatus);
var newInvitation = _context.Set <Invitation>().Add(createdInvitation);
return(newInvitation);
}
/// <summary>
/// Создать лог приглашения
/// </summary>
/// <param name="alienId">Идентификатор иностранца</param>
/// <param name="employeeId">Идентификатор сотрудника</param>
/// <param name="visitDetailId">Идентификатор деталей визита</param>
/// <param name="createdDate">Дата создания</param>
/// <param name="updateDate">Дата изменения</param>
/// <param name="invitationStatus">Статус приглашения</param>
/// <param name="revisionNumber">Номер ревизии</param>
/// <returns>Идентификатор лога приглашения</returns>
public Guid Create(
Guid alienId,
Guid employeeId,
Guid visitDetailId,
DateTime createdDate,
DateTime updateDate,
InvitationStatus invitationStatus,
long revisionNumber)
{
Contract.Argument.IsNotEmptyGuid(alienId, nameof(alienId));
Contract.Argument.IsNotEmptyGuid(employeeId, nameof(employeeId));
Contract.Argument.IsNotEmptyGuid(visitDetailId, nameof(visitDetailId));
Contract.Argument.IsValidIf(createdDate <= updateDate, $"{nameof(createdDate)}:{createdDate} < {nameof(updateDate)}:{updateDate}");
Contract.Argument.IsValidIf(revisionNumber > 0, $"{nameof(revisionNumber)} > 0");
var createdInvitationLog = _context.Set <InvitationLog>().Create();
var id = _idGenerator.Generate();
createdInvitationLog.Initialize(
id: id,
alienId: alienId,
employeeId: employeeId,
visitDetailId: visitDetailId,
createdDate: createdDate,
updateDate: updateDate,
status: invitationStatus,
revisionNumber: revisionNumber);
var newInvitationLog = _context.Set <InvitationLog>().Add(createdInvitationLog);
return(newInvitationLog.Id);
}
/// <summary>
/// 创建工作流
/// </summary>
/// <param name="definition"></param>
/// <param name="input"></param>
/// <param name="workflowInstance"></param>
/// <param name="correlationId"></param>
/// <returns></returns>
public Workflow CreateWorkflow(
WorkflowDefinitionVersion definition,
Variables input = default,
WorkflowInstance workflowInstance = default,
string correlationId = default)
{
if (definition.IsDisabled)//工作流定义已经禁用
{
throw new InvalidOperationException("Cannot instantiate disabled workflow definitions.");
}
var activities = CreateActivities(definition.Activities).ToList(); //创建节点
var connections = CreateConnections(definition.Connections, activities); //创建连线
var id = idGenerator.Generate(); //生成Id
var workflow = new Workflow(
id,
definition,
clock.GetCurrentInstant(),
activities,
connections,
input,
correlationId);
if (workflowInstance != default)
{
workflow.Initialize(workflowInstance);
}
return(workflow);
}
/// <summary>
/// Создать организацию
/// </summary>
/// <param name="stateRegistration">Государственная регистрация</param>
/// <param name="name">Наименование</param>
/// <param name="shortName">Короткое наименование</param>
/// <param name="legalAddress">Юридический адрес</param>
/// <param name="scientificActivity">Научная деятельность</param>
/// <returns>Идентификатор организации</returns>
public Organization Create(
Guid stateRegistrationId,
string name,
string shortName,
string legalAddress,
string scientificActivity)
{
/*
* Contract.Argument.IsNotEmptyGuid(stateRegistrationId, nameof(stateRegistrationId));
* Contract.Argument.IsNotNullOrEmptyOrWhiteSpace(name, nameof(name));
* Contract.Argument.IsNotNullOrEmptyOrWhiteSpace(shortName, nameof(shortName));
* Contract.Argument.IsNotNullOrEmptyOrWhiteSpace(scientificActivity, nameof(scientificActivity));
* Contract.Argument.IsNotNullOrEmptyOrWhiteSpace(legalAddress, nameof(legalAddress));
*/
var createdOrganization = _domainContext.Set <Organization>().Create();
var id = _idGenerator.Generate();
createdOrganization.Initialize(
id: id,
stateRegistrationId: stateRegistrationId,
name: name,
shortName: shortName,
scientificActivity: scientificActivity,
legalAddress: legalAddress);
var newOrganization = _domainContext.Set <Organization>().Add(createdOrganization);
return(newOrganization);
}
public async Task HandleAsync(SendStory command)
{
var user = await _userRepository.GetAsync(command.UserId);
if (user is null)
{
throw new UserNotFoundException(command.UserId);
}
if (!_storyAuthorPolicy.CanCreate(user))
{
throw new CannotCreateStoryException(user.Id);
}
var author = Author.Create(user);
var text = _storyTextFactory.Create(command.Text);
var now = _clock.Current();
var visibility = command.VisibleFrom.HasValue && command.VisibleTo.HasValue
? new Visibility(command.VisibleFrom.Value, command.VisibleTo.Value, command.Highlighted)
: Visibility.Default(now);
var storyId = command.StoryId <= 0 ? _idGenerator.Generate() : command.StoryId;
var story = Story.Create(storyId, author, command.Title, text, command.Tags, now, visibility);
await _storyRepository.AddAsync(story);
var domainEvents = story.Events.ToArray();
await _domainEventDispatcher.DispatchAsync(domainEvents);
var integrationEvents = _eventMapper.Map(domainEvents).ToArray();
_storyRequestStorage.SetStoryId(command.Id, story.Id);
await _messageBroker.PublishAsync(integrationEvents);
}
/// <summary>
/// Создать лог контакта
/// </summary>
/// <param name="email">Электронный адрес</param>
/// <param name="postcode">Почтовый индекс</param>
/// <param name="homePhoneNumber">Домашний номер телефона</param>
/// <param name="workPhoneNumber">Рабочий номер телефона</param>
/// <param name="mobilePhoneNumber">Мобильный номер телефона</param>
/// <returns>Идентификатор лога контакта</returns>
public Guid Create(
string email,
string postcode,
string homePhoneNumber,
string workPhoneNumber,
string mobilePhoneNumber,
long revisionNumber)
{
Contract.Argument.IsNotNullOrEmptyOrWhiteSpace(email, nameof(email));
Contract.Argument.IsNotNullOrEmptyOrWhiteSpace(postcode, nameof(postcode));
Contract.Argument.IsNotNullOrEmptyOrWhiteSpace(homePhoneNumber, nameof(homePhoneNumber));
Contract.Argument.IsNotNullOrEmptyOrWhiteSpace(workPhoneNumber, nameof(workPhoneNumber));
Contract.Argument.IsNotNullOrEmptyOrWhiteSpace(mobilePhoneNumber, nameof(mobilePhoneNumber));
Contract.Argument.IsValidIf(revisionNumber > 0, $"{nameof(revisionNumber)} > 0");
var createdContactLog = _context.Set <ContactLog>().Create();
var id = _idGenerator.Generate();
createdContactLog.Initialize(
id: id,
email: email,
postcode: postcode,
homePhoneNumber: homePhoneNumber,
workPhoneNumber: workPhoneNumber,
mobilePhoneNumber: mobilePhoneNumber,
revisionNumber: revisionNumber);
var newContactLog = _context.Set <ContactLog>().Add(createdContactLog);
return(newContactLog.Id);
}
/// <summary>
/// Создать документ
/// </summary>
/// <param name="invitationId">Идентификатор приглашения</param>
/// <param name="name">Название</param>
/// <param name="content">Содержимое</param>
/// <param name="createdDate">Дата создания</param>
/// <param name="updateDate">Дата изменения</param>
/// <param name="documentType">Тип документа</param>
/// <returns>Идентификатор документа</returns>
public Guid Create(
Guid invitationId,
string name,
byte[] content,
DateTime createdDate,
DateTime updateDate,
DocumentType documentType)
{
Contract.Argument.IsNotEmptyGuid(invitationId, nameof(invitationId));
Contract.Argument.IsNotNullOrEmptyOrWhiteSpace(name, nameof(name));
Contract.Argument.IsNotNull(content, nameof(content));
Contract.Argument.IsValidIf(createdDate <= updateDate, $"{nameof(createdDate)}:{createdDate} < {nameof(updateDate)}:{updateDate}");
var createdDocument = _context.Set <Document>().Create();
var id = _idGenerator.Generate();
createdDocument.Initialize(
id: id,
invitationId: invitationId,
name: name,
content: content,
createdDate: createdDate,
updateDate: updateDate,
documentType: documentType);
var newDocument = _context.Set <Document>().Add(createdDocument);
return(newDocument.Id);
}
public WorkflowDefinition New()
{
var definition = new WorkflowDefinition
{
Id = _idGenerator.Generate(),
DefinitionId = _idGenerator.Generate(),
Name = "New Workflow",
Version = 1,
IsLatest = true,
IsPublished = false,
IsSingleton = false,
CreatedAt = _clock.GetCurrentInstant()
};
return(definition);
}
public async Task HandleAsync(SendStory command)
{
var user = await _userRepository.GetAsync(command.UserId);
if (user is null)
{
throw new UserNotFoundException(command.UserId);
}
if (user.Locked)
{
throw new UserLockedException(command.UserId);
}
var author = Author.Create(user);
var storyText = new StoryText(command.Text);
_storyTextPolicy.Verify(storyText);
var now = _dateTimeProvider.Get();
var visibility = command.VisibleFrom.HasValue && command.VisibleTo.HasValue
? new Visibility(command.VisibleFrom.Value, command.VisibleTo.Value, command.Highlighted)
: Visibility.Default(now);
var storyId = command.StoryId == default ? _idGenerator.Generate() : command.StoryId;
var story = new Story(storyId, author, command.Title, storyText, command.Tags, now, visibility);
await _storyRepository.AddAsync(story);
_storyRequestStorage.SetStoryId(command.Id, story.Id);
await _messageBroker.PublishAsync(new StorySent(story.Id,
new StorySent.AuthorModel(author.Id, author.Name), story.Title, story.Tags, story.CreatedAt,
new StorySent.VisibilityModel(story.Visibility.From, story.Visibility.To,
story.Visibility.Highlighted)));
}
public async Task <ActionResult <WebhookDefinition> > Handle([FromBody] SaveWebhookDefinitionRequest request, [FromRoute] ApiVersion apiVersion, CancellationToken cancellationToken)
{
var webhookId = request.Id;
var webhookDefinition = !string.IsNullOrWhiteSpace(webhookId) ? await _store.FindAsync(new EntityIdSpecification <WebhookDefinition>(webhookId), cancellationToken) : default;
if (webhookDefinition == null)
{
webhookDefinition = new WebhookDefinition
{
Id = !string.IsNullOrWhiteSpace(webhookId) ? webhookId : _idGenerator.Generate(),
}
}
;
webhookDefinition.Name = request.Name.Trim();
webhookDefinition.Path = request.Path.Trim();
webhookDefinition.Description = request.Description?.Trim();
webhookDefinition.PayloadTypeName = request.PayloadTypeName?.Trim();
webhookDefinition.IsEnabled = request.IsEnabled;
await _store.SaveAsync(webhookDefinition, cancellationToken);
return(CreatedAtAction("Handle", "Get", new { id = webhookDefinition.Id, apiVersion = apiVersion.ToString() }, webhookDefinition));
}
}
/// <summary>
/// Создать контакт
/// </summary>
/// <param name="email">Электронный адрес</param>
/// <param name="postcode">Почтовый индекс</param>
/// <param name="homePhoneNumber">Домашний номер телефона</param>
/// <param name="workPhoneNumber">Рабочий номер телефона</param>
/// <param name="mobilePhoneNumber">Мобильный номер телефона</param>
/// <returns></returns>
public Contact Create(
string email,
string postcode,
string homePhoneNumber,
string workPhoneNumber,
string mobilePhoneNumber)
{
/*
* Contract.Argument.IsNotNullOrEmptyOrWhiteSpace(email, nameof(email));
* Contract.Argument.IsNotNullOrEmptyOrWhiteSpace(postcode, nameof(postcode));
* Contract.Argument.IsNotNullOrEmptyOrWhiteSpace(homePhoneNumber, nameof(homePhoneNumber));
* Contract.Argument.IsNotNullOrEmptyOrWhiteSpace(workPhoneNumber, nameof(workPhoneNumber));
* Contract.Argument.IsNotNullOrEmptyOrWhiteSpace(mobilePhoneNumber, nameof(mobilePhoneNumber));
*/
var createdContact = _domainContext.Set <Contact>().Create();
var id = _idGenerator.Generate();
createdContact.Initialize(
id: id,
email: email,
postcode: postcode,
homePhoneNumber: homePhoneNumber,
workPhoneNumber: workPhoneNumber,
mobilePhoneNumber: mobilePhoneNumber);
var newContact = _domainContext.Set <Contact>().Add(createdContact);
return(newContact);
}
public override void Add(User user)
{
userValidator.Validate(user);
user.Id = idGenerator.Generate();
UserRepository.Set(user);
OnUserAdded(user);
}
public Task AddAsync(Workflow value, CancellationToken cancellationToken)
{
value.Metadata.Id = idGenerator.Generate();
value.CreatedAt = clock.GetCurrentInstant();
Workflows.Add(value);
return(Task.CompletedTask);
}
public void AddEntry(string workflowInstanceId, string activityId, string activityType, string eventName, string?message, string?tenantId, string?source, JObject?data)
{
var id = _idGenerator.Generate();
var timeStamp = _clock.GetCurrentInstant();
var record = new WorkflowExecutionLogRecord(id, tenantId, workflowInstanceId, activityId, activityType, timeStamp, eventName, message, source, data);
_records.Add(record);
}
public async Task <Workflow> DeriveAsync(Workflow parent, CancellationToken cancellationToken)
{
var child = await CloneAsync(parent, cancellationToken);
child.Metadata.ParentId = parent.Metadata.Id;
child.Metadata.Id = idGenerator.Generate();
return(child);
}
private WebhookDefinition Initialize(WebhookDefinition webhookDefinition)
{
if (string.IsNullOrWhiteSpace(webhookDefinition.Id))
{
webhookDefinition.Id = _idGenerator.Generate();
}
return(webhookDefinition);
}
public async Task StartMonitoring(StartMonitoringModel startMonitoringModel)
{
var newId = _idGenerator.Generate();
await _siteStorage.AddSiteInfo(newId, startMonitoringModel.Uri, startMonitoringModel.RefreshTimeInSeconds);
await _trackingTimer.Start(newId, startMonitoringModel.Uri, startMonitoringModel.RefreshTimeInSeconds);
await _clientNotifier.UpdateSitesInfo();
}
private static Dictionary <string, Country> LoadCountries(IIdGenerator idGenerator)
{
var scotland = new Country {
Id = idGenerator.Generate(), Name = "Scotland"
};
return(new Dictionary <string, Country>
{
{ DobihCodeForScotland, new Country {
Id = idGenerator.Generate(), Name = "Scotland"
} },
//{ DobihCodeForEngland, new Country {Id = idGenerator.Generate(), Name = "England"} },
//{ DobihCodeForWales, new Country {Id = idGenerator.Generate(), Name = "Wales"} },
//{ DobihCodeForIreland, new Country {Id = idGenerator.Generate(), Name = "Ireland"} },
//{ DobihCodeForChannelIslands, new Country {Id = idGenerator.Generate(), Name = "Channel Islands"} },
//{ DobihCodeForIsleOfMan, new Country {Id = idGenerator.Generate(), Name = "Isle of Man"} }
});
}
private WorkflowSetting Initialize(WorkflowSetting workflowSetting)
{
if (string.IsNullOrWhiteSpace(workflowSetting.Id))
{
workflowSetting.Id = _idGenerator.Generate();
}
return(workflowSetting);
}
public async Task AddAsync(Workflow value, CancellationToken cancellationToken)
{
var fileExtension = $".{Format.ToLower()}";
var id = $"{idGenerator.Generate()}{fileExtension}";
value.Metadata.Id = id;
await UpdateAsync(value, cancellationToken);
}
private WorkflowDefinition Initialize(WorkflowDefinition workflowDefinition)
{
if (string.IsNullOrWhiteSpace(workflowDefinition.Id))
{
workflowDefinition.Id = _idGenerator.Generate();
}
if (workflowDefinition.Version == 0)
{
workflowDefinition.Version = 1;
}
if (string.IsNullOrWhiteSpace(workflowDefinition.DefinitionId))
{
workflowDefinition.DefinitionId = _idGenerator.Generate();
}
return(workflowDefinition);
}
public async Task <Result <Image, Error> > UploadAsync(Name galleryName, byte[] data, Option <byte[]> meta)
{
var imageId = await _imageIdGenerator.Generate().ConfigureAwait(false);
return(await CreateImageWithThumbnails(galleryName, imageId, 1u, meta, data)
.AndThenAsync(async imageAndThumbnails =>
{
var result = await _thumbnailRepository.Insert(galleryName, imageAndThumbnails.Thumbnails)
.AndThenAsync(_ => _imageRepository.Insert(galleryName, new[] { imageAndThumbnails.Image }));
return result.MapSuccess(_ => imageAndThumbnails.Image);
}));
}
private static Maps LoadMaps(IIdGenerator idGenerator, IOsFile osFile)
{
return(new Maps
{
Landranger = osFile
.Landranger
.Select(x => Build(x, idGenerator.Generate(), MapConstants.Landranger, MapConstants.OneTo50K))
.ToList(),
LandrangerActive = osFile
.LandrangerActive
.Select(x => Build(x, idGenerator.Generate(), MapConstants.LandrangerActive, MapConstants.OneTo50K))
.ToList(),
Explorer = osFile
.Explorer
.Select(x => Build(x, idGenerator.Generate(), MapConstants.Explorer, MapConstants.OneTo25K))
.ToList(),
ExplorerActive = osFile
.ExplorerActive
.Select(x => Build(x, idGenerator.Generate(), MapConstants.ExplorerActive, MapConstants.OneTo25K))
.ToList(),
Discoverer = osFile
.Discoverer
.Select(x => Build(x, idGenerator.Generate(), MapConstants.Discoverer, MapConstants.OneTo50K))
.ToList(),
Discovery = osFile
.Discovery
.Select(x => Build(x, idGenerator.Generate(), MapConstants.Discovery, MapConstants.OneTo50K))
.ToList()
});
}
public async Task <IEnumerable <StartableWorkflow> > FindStartableWorkflowsAsync(WorkflowsQuery query, CancellationToken cancellationToken = default)
{
var correlationId = query.CorrelationId ?? _idGenerator.Generate();
var updatedContext = query with {
CorrelationId = correlationId
};
await using var lockHandle = await AcquireLockAsync(correlationId, cancellationToken);
var startableWorkflowDefinitions = await CollectStartableWorkflowsInternalAsync(updatedContext, cancellationToken);
return(await InstantiateStartableWorkflows(startableWorkflowDefinitions, cancellationToken).ToList());
}
