public async Task <IActionResult> Activate(string id, string elt, [FromBody] ActivateCommand activateCommand, CancellationToken token)
{
try
{
activateCommand.CasePlanInstanceId = id;
activateCommand.CasePlanElementInstanceId = elt;
await _mediator.Send(activateCommand, token);
return(new OkResult());
}
catch (UnknownCasePlanInstanceException)
{
return(new NotFoundResult());
}
catch (UnknownCasePlanElementInstanceException)
{
return(this.ToError(new Dictionary <string, string>
{
{ "bad_request", "case instance element doesn't exist" }
}, HttpStatusCode.NotFound, Request));
}
catch (AggregateValidationException ex)
{
return(this.ToError(ex.Errors, HttpStatusCode.BadRequest, Request));
}
catch (Exception ex)
{
return(this.ToError(new Dictionary <string, string>
{
{ "invalid_request", ex.Message }
}, HttpStatusCode.BadRequest, Request));
}
}
public async void Deactivate()
{
if (await casparCGService.SendCommandsAsync(placeholder.ReplacePlaceholders(configuration.LowerthirdsDeactivateCommands, currentlyActive)))
{
currentlyActive.IsActive = false;
currentlyActive = null;
DeactivateCommand.RaiseCanExecuteChanged();
ActivateCommand.RaiseCanExecuteChanged();
}
}
public void AccountActivate_Execute_ReturnsNotFoundMessage()
{
var command = new ActivateCommand(_console, LoggerMock.GetLogger <ActivateCommand>().Object, _accountService.Object)
{
User = "******"
};
var resultMessage = command.Execute();
Assert.Equal("User [email protected] was not found", resultMessage);
}
public void EngineActivate_Execute_ReturnsNotFoundMessage()
{
var command = new ActivateCommand(_console, LoggerMock.GetLogger <ActivateCommand>().Object, _engineService.Object)
{
Name = "Engine02"
};
var resultMessage = command.Execute();
Assert.Equal("Engine Engine02 was not found", resultMessage);
}
public void EngineActivate_Execute_ReturnsSuccessMessage()
{
var command = new ActivateCommand(_console, LoggerMock.GetLogger <ActivateCommand>().Object, _engineService.Object)
{
Name = "Engine01"
};
var resultMessage = command.Execute();
Assert.Equal("Engine Engine01 has been activated successfully", resultMessage);
}
public async void Activate(Lowerthird lowerthird)
{
bool worked;
if (currentlyActive != null)
{
if (worked = await casparCGService.SendCommandsAsync(placeholder.ReplacePlaceholders(configuration.LowerthirdsChangeCommands, lowerthird)))
{
currentlyActive.IsActive = false;
}
}
else
{
worked = await casparCGService.SendCommandsAsync(placeholder.ReplacePlaceholders(configuration.LowerthirdsActivateCommands, lowerthird));
}
if (worked)
{
currentlyActive = lowerthird;
lowerthird.IsActive = true;
DeactivateCommand.RaiseCanExecuteChanged();
ActivateCommand.RaiseCanExecuteChanged();
}
}
public MenuViewModel(ISessionService sessionService, IAccountsRepository accountsService)
{
_sessionService = sessionService;
this.WhenAnyValue(x => x.Account)
.Select(x => new GitHubAvatar(x.AvatarUrl))
.ToProperty(this, x => x.Avatar, out _avatar);
GoToNotificationsCommand = ReactiveCommand.Create().WithSubscription(_ => {
var vm = this.CreateViewModel <NotificationsViewModel>();
vm.NotificationCount.Subscribe(x => Notifications = x);
NavigateTo(vm);
});
GoToAccountsCommand = ReactiveCommand.Create().WithSubscription(_ =>
NavigateTo(this.CreateViewModel <AccountsViewModel>()));
GoToProfileCommand = ReactiveCommand.Create();
GoToProfileCommand
.Select(_ => this.CreateViewModel <UserViewModel>())
.Select(x => x.Init(Account.Username))
.Subscribe(NavigateTo);
GoToMyIssuesCommand = ReactiveCommand.Create().WithSubscription(_ =>
NavigateTo(this.CreateViewModel <MyIssuesViewModel>()));
GoToRepositoryCommand = ReactiveCommand.Create();
GoToRepositoryCommand.OfType <RepositoryIdentifier>()
.Select(x => this.CreateViewModel <RepositoryViewModel>().Init(x.Owner, x.Name))
.Subscribe(NavigateTo);
GoToSettingsCommand = ReactiveCommand.Create().WithSubscription(_ =>
NavigateTo(this.CreateViewModel <SettingsViewModel>()));
GoToNewsCommand = ReactiveCommand.Create().WithSubscription(_ =>
NavigateTo(this.CreateViewModel <NewsViewModel>()));
GoToOrganizationsCommand = ReactiveCommand.Create();
GoToOrganizationsCommand
.Select(_ => this.CreateViewModel <OrganizationsViewModel>())
.Select(x => x.Init(Account.Username))
.Subscribe(NavigateTo);
GoToTrendingRepositoriesCommand = ReactiveCommand.Create().WithSubscription(_ =>
NavigateTo(this.CreateViewModel <RepositoriesTrendingViewModel>()));
GoToExploreRepositoriesCommand = ReactiveCommand.Create().WithSubscription(_ =>
NavigateTo(this.CreateViewModel <ExploreViewModel>()));
GoToOrganizationEventsCommand = ReactiveCommand.Create();
GoToOrganizationEventsCommand
.OfType <Octokit.Organization>()
.Select(x => this.CreateViewModel <UserEventsViewModel>().Init(x.Login))
.Subscribe(NavigateTo);
GoToOrganizationCommand = ReactiveCommand.Create();
GoToOrganizationCommand
.OfType <Octokit.Organization>()
.Select(x => this.CreateViewModel <OrganizationViewModel>().Init(x.Login))
.Subscribe(NavigateTo);
GoToOwnedRepositoriesCommand = ReactiveCommand.Create();
GoToOwnedRepositoriesCommand
.Select(_ => this.CreateViewModel <UserRepositoriesViewModel>())
.Select(x => x.Init(Account.Username))
.Subscribe(NavigateTo);
GoToStarredRepositoriesCommand = ReactiveCommand.Create().WithSubscription(
_ => NavigateTo(this.CreateViewModel <RepositoriesStarredViewModel>()));
GoToWatchedRepositoriesCommand = ReactiveCommand.Create().WithSubscription(
_ => NavigateTo(this.CreateViewModel <RepositoriesWatchedViewModel>()));
GoToPublicGistsCommand = ReactiveCommand.Create().WithSubscription(
_ => NavigateTo(this.CreateViewModel <PublicGistsViewModel>()));
GoToStarredGistsCommand = ReactiveCommand.Create().WithSubscription(
_ => NavigateTo(this.CreateViewModel <StarredGistsViewModel>()));
GoToMyGistsCommand = ReactiveCommand.Create();
GoToMyGistsCommand
.Select(_ => this.CreateViewModel <UserGistsViewModel>())
.Select(x => x.Init(Account.Username))
.Subscribe(NavigateTo);
GoToMyEvents = ReactiveCommand.Create();
GoToMyEvents
.Select(_ => this.CreateViewModel <UserEventsViewModel>())
.Select(x => x.Init(Account.Username))
.Subscribe(NavigateTo);
GoToFeedbackCommand = ReactiveCommand.Create();
GoToFeedbackCommand.Subscribe(_ => {
var vm = sessionService.Account.IsEnterprise
? (IBaseViewModel)this.CreateViewModel <EnterpriseSupportViewModel>()
: this.CreateViewModel <SupportViewModel>();
NavigateTo(vm);
});
DeletePinnedRepositoryCommand = ReactiveCommand.Create();
DeletePinnedRepositoryCommand.OfType <PinnedRepository>()
.Subscribe(x => {
sessionService.Account.PinnnedRepositories.Remove(x);
accountsService.Update(sessionService.Account);
});
ActivateCommand = ReactiveCommand.Create();
ActivateCommand.Subscribe(x => {
var startupViewModel = sessionService.StartupViewModel;
sessionService.StartupViewModel = null;
if (startupViewModel != null)
{
NavigateTo(startupViewModel);
}
else
{
GoToDefaultTopView.ExecuteIfCan();
}
});
LoadCommand = ReactiveCommand.CreateAsyncTask(_ => {
// var notifications = sessionService.GitHubClient.Notification.GetAllForCurrent();
// notifications.ToBackground(x => Notifications = x.Count);
////
// var organizations = sessionService.GitHubClient.Organization.GetAllForCurrent();
// organizations.ToBackground(x => Organizations = x);
//
// return Task.WhenAll(notifications, organizations);
return(Task.FromResult(Unit.Default));
});
}
public Task PublishExternalEvt(string evt, string casePlanInstanceId, string casePlanElementInstanceId, Dictionary <string, string> parameters, CancellationToken token)
{
IBaseRequest request = null;
switch (evt)
{
case CMMNConstants.ExternalTransitionNames.AddChild:
request = new AddChildCommand(casePlanInstanceId, casePlanElementInstanceId)
{
Parameters = parameters
};
break;
case CMMNConstants.ExternalTransitionNames.Close:
request = new CloseCommand(casePlanInstanceId)
{
Parameters = parameters
};
break;
case CMMNConstants.ExternalTransitionNames.Complete:
request = new CompleteCommand(casePlanInstanceId, casePlanElementInstanceId)
{
Parameters = parameters
};
break;
case CMMNConstants.ExternalTransitionNames.Disable:
request = new DisableCommand(casePlanInstanceId, casePlanElementInstanceId)
{
Parameters = parameters
};
break;
case CMMNConstants.ExternalTransitionNames.Occur:
request = new OccurCommand(casePlanInstanceId, casePlanElementInstanceId)
{
Parameters = parameters
};
break;
case CMMNConstants.ExternalTransitionNames.Reactivate:
request = new ReactivateCommand(casePlanInstanceId, casePlanElementInstanceId)
{
Parameters = parameters
};
break;
case CMMNConstants.ExternalTransitionNames.Reenable:
request = new ReenableCommand(casePlanInstanceId, casePlanElementInstanceId)
{
Parameters = parameters
};
break;
case CMMNConstants.ExternalTransitionNames.Resume:
request = new ResumeCommand(casePlanInstanceId, casePlanElementInstanceId)
{
Parameters = parameters
};
break;
case CMMNConstants.ExternalTransitionNames.Suspend:
request = new SuspendCommand(casePlanInstanceId, casePlanElementInstanceId)
{
Parameters = parameters
};
break;
case CMMNConstants.ExternalTransitionNames.Terminate:
request = new TerminateCommand(casePlanInstanceId, casePlanElementInstanceId)
{
Parameters = parameters
};
break;
case CMMNConstants.ExternalTransitionNames.ManualStart:
request = new ActivateCommand(casePlanInstanceId, casePlanElementInstanceId)
{
Parameters = parameters
};
break;
}
return(_mediator.Send(request, token));
}
public override void Setup()
{
base.Setup();
Command = new ActivateCommand();
}
public async Task <IActionResult> Activate([FromBody] ActivateCommand command)
{
await _commandDispatcher.SendAsync(command);
return(Ok());
}
