public string Dispatch(string input)
{
string result = string.Empty;
var inputArgs = input.Split(new[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
string command = inputArgs.Length > 0 ? inputArgs[0] : string.Empty;
string[] commandArgs = inputArgs.Skip(1).ToArray();
switch (command.ToLower())
{
case "registeruser": result = new RegisterUserCommand().Execute(commandArgs);
break;
case "login": result = new LoginCommand().Execute(commandArgs);
break;
case "logout": result = new LogoutCommand().Execute(commandArgs);
break;
case "deleteuser": result = new DeleteUserCommand().Execute(commandArgs);
break;
case "createevent": result = new CreateEventCommand().Execute(commandArgs);
break;
case "createteam": result = new CreateTeamCommand().Execute(commandArgs);
break;
case "invitetoteam": result = new InviteToTeamCommand().Execute(commandArgs);
break;
case "acceptinvite": result = new AcceptInviteCommand().Execute(commandArgs);
break;
case "declineinvite": result = new DeclineInviteCommand().Execute(commandArgs);
break;
case "kickmember": result = new KickMemberCommand().Execute(commandArgs);
break;
case "disband": result = new DisbandCommand().Execute(commandArgs);
break;
case "addteamto": result = new AddTeamToCommand().Execute(commandArgs);
break;
case "showevent": result = new ShowEventCommand().Execute(commandArgs);
break;
case "showteam": result = new ShowTeamCommand().Execute(commandArgs);
break;
case "exit":
var exit = new ExitCommand().Execute(commandArgs);
break;
default: throw new NotSupportedException($"Command {command} not supported!");
}
return(result);
}
public string Dispatch(string input)
{
string output = String.Empty;
string[] inputArgs = input.Split(new[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
string commandName = inputArgs.Length > 0 ? inputArgs[0] : String.Empty;
string[] commandArgs = inputArgs.Skip(1).ToArray();
ICommand command = null;
switch (commandName)
{
case "AcceptInvite":
command = new AcceptInviteCommand(serviceProvider);
break;
case "AddTeamTo":
command = new AddTeamToCommand(serviceProvider);
break;
case "CreateEvent":
command = new CreateEventCommand(serviceProvider);
break;
case "CreateTeam":
command = new CreateTeamCommand(serviceProvider);
break;
case "DeclineInvite":
command = new DeclineInviteCommand(serviceProvider);
break;
case "DeleteUser":
command = new DeleteUserCommand(serviceProvider);
break;
case "Disband":
command = new DisbandCommand(serviceProvider);
break;
case "Exit":
command = new ExitCommand();
break;
case "InviteToTeam":
command = new InviteToTeamCommand(serviceProvider);
break;
case "KickMember":
command = new KickMemberCommand(serviceProvider);
break;
case "Login":
command = new LoginCommand(serviceProvider);
break;
case "Logout":
command = new LogoutCommand(serviceProvider);
break;
case "RegisterUser":
command = new RegisterUserCommand(serviceProvider);
break;
case "ShowEvent":
command = new ShowEventCommand(serviceProvider);
break;
case "ShowTeam":
command = new ShowTeamCommand(serviceProvider);
break;
default:
throw new NotSupportedException(String.Format(Messages.CommandNotSupported, commandName));
}
output = command.Execute(commandArgs);
return(output);
}
public async Task NavigateFromMenu(int id)
{
if (!MenuPages.ContainsKey(id))
{
switch (id)
{
case (int)MenuItemType.PersonalCurrentMonthExpenses:
MenuPages.Add(id, new NavigationPage(new PersonalCurrentMonthExpensesPage()));
break;
case (int)MenuItemType.PersonalCurrentMonthResults:
MenuPages.Add(id, new NavigationPage(new PersonalCurrentMonthResultsPage()));
break;
case (int)MenuItemType.FamilyCurrentMonthPlanning:
MenuPages.Add(id, new NavigationPage(new FamilyCurrentMonthPlanningPage()));
break;
case (int)MenuItemType.FamilyNextMonthPlanning:
MenuPages.Add(id, new NavigationPage(new FamilyNextMonthPlanningPage()));
break;
case (int)MenuItemType.PersonalLastMonthResults:
MenuPages.Add(id, new NavigationPage(new PersonalLastMonthResultsPage()));
break;
case (int)MenuItemType.PersonalLastMonthExpenses:
MenuPages.Add(id, new NavigationPage(new PersonalLastMonthExpensesPage()));
break;
case (int)MenuItemType.FamilyCurrentMonthExpenses:
MenuPages.Add(id, new NavigationPage(new FamilyCurrentMonthExpensesPage()));
break;
case (int)MenuItemType.FamilyLastMonthExpenses:
MenuPages.Add(id, new NavigationPage(new FamilyLastMonthExpensesPage()));
break;
case (int)MenuItemType.FamilyCurrentMonthResults:
MenuPages.Add(id, new NavigationPage(new FamilyCurrentMonthResultsPage()));
break;
case (int)MenuItemType.FamilyLastMonthResults:
MenuPages.Add(id, new NavigationPage(new FamilyLastMonthResultsPage()));
break;
case (int)MenuItemType.FamilyAllExpenses:
MenuPages.Add(id, new NavigationPage(new FamilyAllExpensesPage()));
break;
case (int)MenuItemType.Settings:
MenuPages.Add(id, new NavigationPage(new SettingsPage()));
break;
case (int)MenuItemType.About:
MenuPages.Add(id, new NavigationPage(new AboutPage()));
break;
case (int)MenuItemType.Logout:
LogoutCommand.Execute(null);
//MenuPages.Add(id, new NavigationPage(new LoginPage()));
Application.Current.MainPage = new LoginPage();
return;
}
}
var newPage = MenuPages[id];
if (newPage != null && Detail != newPage)
{
Detail = newPage;
if (Device.RuntimePlatform == Device.Android)
{
await Task.Delay(100);
}
IsPresented = false;
}
}
public MainWindowViewModel(List <Task> tasks, UserGroup group)
{
GridWidth = false;
// Set the current user
CurrentUser = RunTimeContext.Context.CurrentUser;
#region Lists
// The list of scheduled tasks (bind to the Schedule list in UI)
ScheduledList = new ObservableCollection <Schedule>(ScheduleManager.GetScheduledTask(RunTimeContext.Context.CurrentUser,
RunTimeContext.Context.DatabaseContext));
// Result list (bind to the result panel in UI)
ResultList = new ObservableCollection <ResultTask>();
// Property list, to use with FileLib, /!\ not implemented now :(
Props = new ObservableCollection <Dictionary <string, string> >();
// Task list, with all the task, given by the loading screen as constructor parameter
TaskList = tasks == null ? new ObservableCollection <Task>() : new ObservableCollection <Task>(tasks);
// The list of queued tasks (bind to the queue panel in UI)
QueueList = new ObservableCollection <Task>();
// The list of markets (Bind to the combobox with the list of markets in UI)
MarketList = new ObservableCollection <Market>(MarketManager.GetAllMarkets(RunTimeContext.Context.DatabaseContext));
#endregion
#region Selected
// Set the market to the main market of the user
SelectedMarket = CurrentUser.MainMarket;
// Set the selected task to the first one of the list
SelectedTask = FilteredTasks.FirstOrDefault();
#endregion
#region User right
// Those three properties are used to be bind with some UI elements like menu
// If you bind the IsVisibility property of a control with one of those, only the group of person with the appropriate
// rights will be able to see it
// eg : Visibility="{Binding IsAdmin}" <-- only Admin level people will see
// Do the user have Admin Access ?
IsAdmin = (@group == UserGroup.Dev || @group == UserGroup.Admin) ? Visibility.Visible : Visibility.Collapsed;
// Manager ?
IsManager = @group == UserGroup.Manager ? Visibility.Visible : Visibility.Collapsed;
// Or maybe a Developer ?
IsDev = @group == UserGroup.Dev ? Visibility.Visible : Visibility.Collapsed;
#endregion
#region Commands
OpenConfigCommand = new OpenConfigCommand(this);
OpenScheduleCommand = new OpenScheduleCommand(this);
OpenFileCommand = new OpenFileCommand(this);
OpenFolderCommand = new OpenFolderCommand(this);
OpenLogCommand = new OpenLogCommand(this);
RunCommand = new RunTaskCommand(this);
QueueCommand = new QueueTaskCommand(this);
RemoveCommand = new RemoveTaskCommand(this);
CloseCommand = new CloseWindowCommand();
MinimizeCommand = new MinimizeWindowCommand();
MaximizeCommand = new MaximizeWindowCommand();
LogoutCommand = new LogoutCommand();
ClearQueueCommand = new ClearQueueCommand(this);
MoveDownQueueCommand = new MoveDownQueueCommand(this);
MoveUpQueueCommand = new MoveUpQueueCommand(this);
StartQueueCommand = new StartQueueCommand(this);
AddScheduleCommand = new AddScheduleCommand(this);
RemoveScheduleCommand = new RemoveScheduleCommand(this);
ChangeScheduleCommand = new ChangeScheduleCommand(this);
ShowAllTaskCommand = new ShowAllTaskCommand(this);
ShowMarketTaskCommand = new ShowMarketTaskCommand(this);
ShowInfoCommand = new ShowInfoCommand(this);
ShowQueueCommand = new ShowQueueCommand(this);
FilterResultCommand = new FilterResultCommand(this);
ReportDevCommand = new ReportDevCommand(this);
#endregion
// Number of time in a row a task failed
// if 3 the error window will appear automatically
FailedInARow = 0;
#region Hide other regions
GridWidth = true;
//CollapseQueue();
//CollapseGrid();
#endregion
// A simple bool to see if a task is running at the moment or not
TaskRunning = false;
// The result filter, chaging it will change automatically the task list
ResultFilter = "";
// The log List
Log = new ObservableCollection <Log>();
// The list of currently scheduled tasks, use for rerun if failed and keep track of current running status
CurrentlyScheduledTasks = new Dictionary <int, ScheduledTaskInfo>();
#region Timer
// Create new DispatcherTimer and attach event handler to it
var launchScheduleTimer = new DispatcherTimer();
launchScheduleTimer.Tick += LaunchScheduleTimer_Tick;
launchScheduleTimer.Interval = new TimeSpan(0, 1, 0);
launchScheduleTimer.Start();
#endregion
}
static async Task <int> Main(string[] args)
{
// We don't have access to a built host yet. Get configuration settings using a configuration builder.
// Required to set initial token credentials.
var configBuilder = new ConfigurationBuilder();
ConfigureAppConfiguration(configBuilder);
var config = configBuilder.Build();
var authSettings = config.GetSection(nameof(AuthenticationOptions)).Get <AuthenticationOptions>();
var authServiceFactory = new AuthenticationServiceFactory(new PathUtility());
var authStrategy = AuthenticationStrategy.DeviceCode;
var credential = await authServiceFactory.GetTokenCredentialAsync(authStrategy, authSettings?.TenantId, authSettings?.ClientId);
var authProvider = new AzureIdentityAuthenticationProvider(credential, new string[] { "graph.microsoft.com" });
var assemblyVersion = Assembly.GetExecutingAssembly().GetName().Version;
var options = new GraphClientOptions {
GraphProductPrefix = "graph-cli",
GraphServiceLibraryClientVersion = $"{assemblyVersion.Major}.{assemblyVersion.Minor}.{assemblyVersion.Build}",
GraphServiceTargetVersion = "1.0"
};
using var httpClient = GraphCliClientFactory.GetDefaultClient(options);
var core = new HttpClientRequestAdapter(authProvider, httpClient: httpClient);
var client = new GraphClient(core);
var commands = new List <Command>();
var loginCommand = new LoginCommand(authServiceFactory);
commands.Add(loginCommand.Build());
var logoutCommand = new LogoutCommand(new LogoutService());
commands.Add(logoutCommand.Build());
var builder = BuildCommandLine(client, commands).UseDefaults().UseHost(CreateHostBuilder);
builder.AddMiddleware((invocation) => {
var host = invocation.GetHost();
var outputFilter = host.Services.GetRequiredService <IOutputFilter>();
var outputFormatterFactory = host.Services.GetRequiredService <IOutputFormatterFactory>();
invocation.BindingContext.AddService <IOutputFilter>(_ => outputFilter);
invocation.BindingContext.AddService <IOutputFormatterFactory>(_ => outputFormatterFactory);
});
builder.UseExceptionHandler((ex, context) => {
if (ex is AuthenticationRequiredException)
{
Console.ResetColor();
Console.ForegroundColor = ConsoleColor.Red;
context.Console.Error.WriteLine("Token acquisition failed. Run mgc login command first to get an access token.");
Console.ResetColor();
}
else
{
Console.ResetColor();
Console.ForegroundColor = ConsoleColor.Red;
context.Console.Error.WriteLine(ex.Message);
context.Console.Error.WriteLine(ex.StackTrace);
Console.ResetColor();
}
});
var parser = builder.Build();
return(await parser.InvokeAsync(args));
}
public async Task <OperationResult> Handle(LogoutCommand command, CancellationToken cancellationToken)
{
await _signInManager.SignOutAsync();
return(new OperationResult(nameof(HttpStatusCode.OK), true));
}
internal static void Update()
{
if (State == ConnectionState.CONNECTED)
{
lock (userDatasLock)
{
// Check if user changed
string uuid = APIUser.CurrentUser == null ? "" : APIUser.CurrentUser.id ?? "";
string displayName = APIUser.CurrentUser == null ? "" : APIUser.CurrentUser.displayName ?? "";
string authToken = ApiCredentials.GetAuthToken() ?? "";
Credentials c = ApiCredentials.GetWebCredentials() as Credentials;
if (!uuid.Equals(userUuid))
{
VRCModLogger.Log("new UUID: " + uuid);
DiscordManager.UserChanged(displayName);
if (!uuid.Equals("") && "".Equals(authToken))
{
string password = typeof(ApiCredentials).GetField("password", BindingFlags.NonPublic | BindingFlags.Static).GetValue(null) as string;
authToken = Convert.ToBase64String(Encoding.UTF8.GetBytes(ApiCredentials.GetUsername() + ":" + password));
}
if (uuid.Equals(""))
{
userUuid = uuid;
VRCModLogger.Log("Resetting data");
ResetDatas();
VRCModLogger.Log("Logging out");
LogoutCommand logoutCommand = CommandManager.CreateInstance("LOGOUT", client) as LogoutCommand;
logoutCommand.LogOut();
VRCModLogger.Log("Done");
}
else
{
userUuid = uuid;
VRCModLogger.Log("Getting current instanceId");
if (RoomManager.currentRoom != null && RoomManager.currentRoom.id != null && RoomManager.currentRoom.currentInstanceIdOnly != null)
{
userInstanceId = RoomManager.currentRoom.id + ":" + RoomManager.currentRoom.currentInstanceIdOnly;
}
VRCModLogger.Log("Getting current modList");
modlist = ModDesc.GetAllMods();
VRCModLogger.Log("Getting current environment");
ApiServerEnvironment env = VRCApplicationSetup._instance.ServerEnvironment;
string stringEnv = "";
if (env == ApiServerEnvironment.Dev)
{
stringEnv = "dev";
}
if (env == ApiServerEnvironment.Beta)
{
stringEnv = "beta";
}
if (env == ApiServerEnvironment.Release)
{
stringEnv = "release";
}
VRCModLogger.Log("Env: " + env);
VRCModLogger.Log("Authenticating");
AuthCommand authCommand = CommandManager.CreateInstance("AUTH", client, false) as AuthCommand;
authCommand.Auth(authToken, stringEnv, userInstanceId, modlist);
VRCModLogger.Log("Done");
}
}
if (IsAuthenticated)
{
string roomId = "";
if (RoomManager.currentRoom != null && RoomManager.currentRoom.id != null && RoomManager.currentRoom.currentInstanceIdOnly != null)
{
roomId = RoomManager.currentRoom.id + ":" + RoomManager.currentRoom.currentInstanceIdOnly;
}
if (!userInstanceId.Equals(roomId))
{
VRCModLogger.Log("Updating instance id");
userInstanceId = roomId;
if (roomId != "")
{
DiscordManager.RoomChanged(RoomManager.currentRoom.name, roomId, RoomManager.currentRoom.currentInstanceAccess, RoomManager.currentRoom.capacity);
}
else
{
DiscordManager.RoomChanged("", roomId, ApiWorldInstance.AccessType.InviteOnly, 0);
}
((InstanceChangedCommand)CommandManager.CreateInstance("INSTANCECHANGED", client)).Send(userInstanceId);
VRCModLogger.Log("Done");
}
}
}
}
}
internal static void Update()
{
lock (sheduled)
{
foreach (Action a in sheduled)
{
try
{
a?.Invoke();
}
catch (Exception e)
{
VRCModLogger.LogError("[VRCModNetwork] An error occured while running sheduled action: " + e);
}
}
sheduled.Clear();
}
if (State == ConnectionState.CONNECTED)
{
lock (userDatasLock)
{
// Check if user changed
string uuid = APIUser.CurrentUser?.id ?? "";
if (!uuid.Equals(userUuid))
{
VRCModLogger.Log("[VRCModNetwork] new UUID: " + uuid);
string displayName = APIUser.CurrentUser?.displayName ?? "";
DiscordManager.UserChanged(displayName);
userUuid = uuid; // use it as a lock to avoid spamming
if (uuid.Equals(""))
{
VRCModLogger.Log("[VRCModNetwork] Resetting data");
ResetDatas();
VRCModLogger.Log("[VRCModNetwork] Logging out");
LogoutCommand logoutCommand = CommandManager.CreateInstance("LOGOUT", client) as LogoutCommand;
logoutCommand.LogOut();
VRCModLogger.Log("[VRCModNetwork] Done");
}
else
{
if (SecurePlayerPrefs.HasKey("vrcmnw_token_" + uuid))
{
TryAuthenticate("vrcmnw " + uuid + " " + SecurePlayerPrefs.GetString("vrcmnw_token_" + uuid, "vl9u1grTnvXA"));
}
else if (ApiCredentials.GetAuthTokenProvider() == "steam")
{
TryAuthenticate("st_" + SteamUtils.GetSteamTicket());
}
else if (ApiCredentials.GetAuthTokenProvider() == "oculus")
{
OculusUtils.GetAccessToken(
ticket => TryAuthenticate($"oculus {ticket} {OculusUtils.OculusId} {OculusUtils.OculusName}"),
error => VRCModLogger.LogError("[VRCModNetwork] Error while fetching oculus ticket: " + error));
}
else if (!string.IsNullOrEmpty(credentials))
{
TryAuthenticate("login " + Convert.ToBase64String(Encoding.UTF8.GetBytes(credentials)));
credentials = "";
VRCTools.ModPrefs.SetBool("vrctools", "hasvrcmnwtoken", true);
}
else
{
VRCModLogger.LogError("[VRCModNetwork] Unable to auth: Required auth datas are missing");
return;
}
}
}
if (IsAuthenticated)
{
string roomId = "";
if (RoomManagerBase.currentRoom?.currentInstanceIdOnly != null)
{
roomId = RoomManagerBase.currentRoom.id + ":" + RoomManagerBase.currentRoom.currentInstanceIdWithTags;
}
if (!userInstanceId.Equals(roomId))
{
VRCModLogger.Log("[VRCModNetwork] Updating instance id. Current room: " + roomId);
userInstanceId = roomId;
roomSecret = "";
if (roomId != "")
{
roomSecret = DiscordManager.RoomChanged(RoomManagerBase.currentRoom.name, RoomManagerBase.currentRoom.id + ":" + RoomManagerBase.currentRoom.currentInstanceIdOnly, RoomManagerBase.currentRoom.currentInstanceIdWithTags, RoomManager.currentRoom.currentInstanceAccess, RoomManager.currentRoom.capacity);
}
else
{
DiscordManager.RoomChanged("", "", "", ApiWorldInstance.AccessType.InviteOnly, 0);
}
((InstanceChangedCommand)CommandManager.CreateInstance("INSTANCECHANGED", client)).Send(roomId, roomSecret);
VRCModLogger.Log("[VRCModNetwork] Done");
}
}
}
}
}
internal static void Update()
{
lock (sheduled)
{
foreach (Action a in sheduled)
{
try
{
a?.Invoke();
}
catch (Exception e)
{
VRCModLogger.LogError("[VRCModNetwork] An error occured while running sheduled action: " + e);
}
}
sheduled.Clear();
}
if (State == ConnectionState.CONNECTED)
{
lock (userDatasLock)
{
// Check if user changed
string uuid = APIUser.CurrentUser?.id ?? "";
if (!uuid.Equals(userUuid))
{
VRCModLogger.Log("[VRCModNetwork] new UUID: " + uuid);
userUuid = uuid; // use it as a lock to avoid spamming
if (uuid.Equals(""))
{
VRCModLogger.Log("[VRCModNetwork] Resetting data");
ResetDatas();
VRCModLogger.Log("[VRCModNetwork] Logging out");
LogoutCommand logoutCommand = CommandManager.CreateInstance("LOGOUT", client) as LogoutCommand;
logoutCommand.LogOut();
VRCModLogger.Log("[VRCModNetwork] Done");
}
else
{
if (SecurePlayerPrefs.HasKey("vrcmnw_token_" + uuid))
{
TryAuthenticate("vrcmnw " + uuid + " " + SecurePlayerPrefs.GetString("vrcmnw_token_" + uuid, "vl9u1grTnvXA"));
}
else if (ApiCredentials.GetAuthTokenProvider() == "steam")
{
TryAuthenticate("st_" + SteamUtils.GetSteamTicket());
}
else if (!string.IsNullOrEmpty(credentials))
{
TryAuthenticate("login " + Convert.ToBase64String(Encoding.UTF8.GetBytes(credentials)));
credentials = "";
VRCTools.ModPrefs.SetBool("vrctools", "hasvrcmnwtoken", true);
}
else
{
/*
* VRCModLogger.LogError("[VRCModNetwork] Unable to auth: Required auth datas are missing");
* return;
*/
TryAuthenticate("ac " + uuid + " " + ApiCredentials.GetAuthToken()); // may broke at any time
}
}
}
if (IsAuthenticated)
{
string roomId = "";
if (RoomManagerBase.currentRoom?.currentInstanceIdOnly != null)
{
roomId = RoomManagerBase.currentRoom.id + ":" + RoomManagerBase.currentRoom.currentInstanceIdWithTags;
}
if (!userInstanceId.Equals(roomId))
{
VRCModLogger.Log("[VRCModNetwork] Updating instance id. Current room: " + roomId);
userInstanceId = roomId;
((InstanceChangedCommand)CommandManager.CreateInstance("INSTANCECHANGED", client)).Send(roomId);
VRCModLogger.Log("[VRCModNetwork] Done");
}
}
}
}
}
public void RaiseCanExecuteChanged()
{
LoginCommand.RaiseCanExecuteChanged();
LogoutCommand.RaiseCanExecuteChanged();
OpenRegisterCommand.RaiseCanExecuteChanged();
}
private void SetIsBusy(bool isBusy)
{
_isBusy = isBusy;
LogoutCommand.RaiseCanExecuteChanged();
LoginCommand.RaiseCanExecuteChanged();
}
public string Dispatch(string input)
{
string result = string.Empty;
string[] inputArgs = Regex.Split(input.Trim(), @"\s+");
//string[] args = input.Trim().Split(new[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
string commandName = inputArgs.Length > 0 ? inputArgs[0] : string.Empty;
inputArgs = inputArgs.Skip(1).ToArray();
switch (commandName)
{
// Basic Logic
case "RegisterUser":
RegisterUserCommand register = new RegisterUserCommand();
result = register.Execute(inputArgs);
break;
case "Login":
LoginCommand login = new LoginCommand();
result = login.Execute(inputArgs);
break;
case "Logout":
LogoutCommand logout = new LogoutCommand();
result = logout.Execute(inputArgs);
break;
case "DeleteUser":
DeleteUserCommand deleteUser = new DeleteUserCommand();
result = deleteUser.Execute(inputArgs);
break;
case "Exit":
ExitCommand exit = new ExitCommand();
result = exit.Execute(inputArgs);
break;
// Advanced Logic
case "CreateEvent":
CreateEventCommand createEvent = new CreateEventCommand();
result = createEvent.Execute(inputArgs);
break;
case "CreateTeam":
CreateTeamCommand createTeam = new CreateTeamCommand();
result = createTeam.Execute(inputArgs);
break;
case "InviteToTeam":
InviteToTeamCommand inviteToTeam = new InviteToTeamCommand();
result = inviteToTeam.Execute(inputArgs);
break;
case "AcceptInvite":
AcceptInviteCommand acceptInvite = new AcceptInviteCommand();
result = acceptInvite.Execute(inputArgs);
break;
case "DeclineInvite":
DeclineInviteCommand declineInvite = new DeclineInviteCommand();
result = declineInvite.Execute(inputArgs);
break;
case "KickMember":
KickMemberCommand kickMember = new KickMemberCommand();
result = kickMember.Execute(inputArgs);
break;
case "Disband":
DisbandTeamCommand disband = new DisbandTeamCommand();
result = disband.Execute(inputArgs);
break;
case "AddTeamTo":
AddTeamToCommand addTeamTo = new AddTeamToCommand();
result = addTeamTo.Execute(inputArgs);
break;
case "ShowEvent":
ShowEventCommand showEvent = new ShowEventCommand();
result = showEvent.Execute(inputArgs);
break;
case "ShowTeam":
ShowTeamCommand showTeam = new ShowTeamCommand();
result = showTeam.Execute(inputArgs);
break;
// Import Data
case "ImportUsers":
ImportUsersCommand importUsers = new ImportUsersCommand();
result = importUsers.Execute(inputArgs);
break;
case "ImportTeams":
ImportTeamsCommand importTeams = new ImportTeamsCommand();
result = importTeams.Execute(inputArgs);
break;
// Export Data
case "ExportTeam":
ExportTeamCommand exportTeam = new ExportTeamCommand();
result = exportTeam.Execute(inputArgs);
break;
// Basic Logic
default:
throw new NotSupportedException($"Command {commandName} not supported!");
}
return(result);
}
public async Task <ActionResult <bool> > LogoutAsync([FromBody] LogoutCommand command)
{
return(Ok(await _mediator.Send(command)));
}
public string Dispatch(string input)
{
string result = string.Empty;
string[] inputArgs = input.Split(new[] { ' ', '\t', '\'' }, StringSplitOptions.RemoveEmptyEntries);
string commandName = inputArgs.Length > 0 ? inputArgs[0] : string.Empty;
inputArgs = inputArgs.Skip(1).ToArray();
switch (commandName)
{
case "help":
HelpCommand help = new HelpCommand();
result = help.Execute(inputArgs);
break;
case "ExportToJson":
ExportToJsonCommand exportToJson = new ExportToJsonCommand();
result = exportToJson.Execute(inputArgs);
break;
case "ChangeRole":
ChangeRoleCommand changeRole = new ChangeRoleCommand();
result = changeRole.Execute(inputArgs);
break;
case "clear":
ClearCommand clear = new ClearCommand();
result = clear.Execute(inputArgs);
break;
case "ShowAllUsers":
ShowAllUserCommand showAllUsers = new ShowAllUserCommand();
result = showAllUsers.Execute(inputArgs);
break;
case "AddTown":
AddTownCommand addTown = new AddTownCommand();
result = addTown.Execute(inputArgs);
break;
case "ModifyUser":
ModifyUserCommand modifyUser = new ModifyUserCommand();
result = modifyUser.Execute(inputArgs);
break;
case "AddBook":
AddBookCommand addBook = new AddBookCommand();
result = addBook.Execute(inputArgs);
break;
case "DeleteUser":
DeleteUserCommand deleteUser = new DeleteUserCommand();
result = deleteUser.Execute(inputArgs);
break;
case "Logout":
LogoutCommand logout = new LogoutCommand();
result = logout.Execute(inputArgs);
break;
case "Login":
LoginCommand login = new LoginCommand();
result = login.Execute(inputArgs);
break;
case "RegisterUser":
RegisterUserCommand registerUser = new RegisterUserCommand();
result = registerUser.Execute(inputArgs);
break;
case "Exit":
ExitCommand exit = new ExitCommand();
exit.Execute(inputArgs);
break;
default:
throw new NotSupportedException($"Command {commandName} not supported!");
}
return(result);
}
public void LogoutCommand_InitiateLogout_NullcheckRequest()
{
Action a = () => LogoutCommand.InitiateLogout(null, null, null, false);
a.ShouldThrow <ArgumentNullException>().And.ParamName.Should().Be("request");
}
private void OnLogoutRequestedEventPublished()
{
LogoutCommand.Execute();
}
public string DispatchCommand(string[] commandParameters)
{
string commandName = commandParameters[0];
commandParameters = commandParameters.Skip(1).ToArray();
string result = string.Empty;
switch (commandName)
{
case "RegisterUser":
RegisterUserCommand registerUser = new RegisterUserCommand(new UserService());
result = registerUser.Execute(commandParameters);
break;
case "Login":
LoginCommand loginCommand = new LoginCommand(new UserService());
result = loginCommand.Execute(commandParameters);
break;
case "Logout":
LogoutCommand logoutCommand = new LogoutCommand(new UserService());
result = logoutCommand.Execute(commandParameters);
break;
case "DeleteUser":
DeleteUserCommand deleteUser = new DeleteUserCommand(new UserService());
result = deleteUser.Execute(commandParameters);
break;
case "CreateEvent":
CreateEventCommand createEvent = new CreateEventCommand(new EventService());
result = createEvent.Execute(commandParameters);
break;
case "CreateTeam":
CreateTeamCommand createTeam = new CreateTeamCommand(new TeamService());
result = createTeam.Execute(commandParameters);
break;
case "InviteToTeam":
InviteToTeamCommand invToTeam = new InviteToTeamCommand(new TeamService(), new UserService());
result = invToTeam.Execute(commandParameters);
break;
case "AcceptInvite":
AcceptInviteCommand acceptInvite = new AcceptInviteCommand(new TeamService(), new UserService());
result = acceptInvite.Execute(commandParameters);
break;
case "DeclineInvite":
DeclineInviteCommand declineInvite = new DeclineInviteCommand(new TeamService(), new UserService());
result = declineInvite.Execute(commandParameters);
break;
case "KickMember":
KickMemberCommand kickMember = new KickMemberCommand(new TeamService(), new UserService());
result = kickMember.Execute(commandParameters);
break;
case "Disband":
DisbandCommand disbandTeam = new DisbandCommand(new TeamService(), new UserService());
result = disbandTeam.Execute(commandParameters);
break;
case "AddTeamTo":
AddTeamToCommand addTeam = new AddTeamToCommand(new EventService(), new TeamService());
result = addTeam.Execute(commandParameters);
break;
case "ShowEvent":
ShowEventCommand showEvent = new ShowEventCommand(new EventService());
result = showEvent.Execute(commandParameters);
break;
case "ShowTeam":
ShowTeamCommand showTeam = new ShowTeamCommand(new TeamService());
result = showTeam.Execute(commandParameters);
break;
case "ImportUsers":
ImportUsersCommand importUsers = new ImportUsersCommand(new UserService());
result = importUsers.Execute(commandParameters);
break;
case "ImportTeams":
ImportTeamsCommand importTeams = new ImportTeamsCommand(new TeamService());
result = importTeams.Execute(commandParameters);
break;
case "ExportTeam":
ExportTeamCommand exportTeam = new ExportTeamCommand(new TeamService());
result = exportTeam.Execute(commandParameters);
break;
case "Exit":
ExitCommand exit = new ExitCommand();
exit.Execute(commandParameters);
break;
default:
throw new NotSupportedException($"Command {commandName} not valid!");
}
return(result);
}
public string Dispatch(string input)
{
string result = string.Empty;;
string[] inputArgs = input
.Split(new char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
string commandName = inputArgs.Length > 0 ? inputArgs[0].ToLower() : string.Empty;
inputArgs = inputArgs.Skip(1).ToArray();
switch (commandName)
{
case "exit":
result = ExitCommand.Execute(inputArgs);
break;
case "registeruser":
result = RegisterUserCommand.Execute(inputArgs);
break;
case "login":
result = LoginCommand.Execute(inputArgs);
break;
case "logout":
result = LogoutCommand.Execute(inputArgs);
break;
case "deleteuser":
result = DeleteUserCommand.Execute(inputArgs);
break;
case "createevent":
result = CreateEventInternalCommand.Execute(inputArgs);
break;
case "createteam":
result = CreateTeamCommand.Execute(inputArgs);
break;
case "invitetoteam":
result = InviteToTeamCommand.Execute(inputArgs);
break;
case "acceptinvite":
result = AcceptInviteCommand.Execute(inputArgs);
break;
case "declineinvite":
result = DeclineInvitartionCommand.Execute(inputArgs);
break;
case "kickmember":
result = KickMemberInternalCommand.Execute(inputArgs);
break;
case "disband":
result = DisbandCommand.Execute(inputArgs);
break;
case "addteamto":
result = AddTeamToCommand.Execute(inputArgs);
break;
case "showevent":
result = ShowEventCommand.Execute(inputArgs);
break;
case "showteam":
result = ShowTeamCommand.Execute(inputArgs);
break;
default:
throw new NotSupportedException($"Command {commandName} not supported!");
}
return(result);
}
public void Handle(ICommandContext context, LogoutCommand command)
{
context.Get <ConLog>(command.AggregateRootId).Logout(command.UpdateBy);
}
public string Dispatch(string input)
{
string result = string.Empty;
string[] inputArgs = input
.Split(new char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
string commandName = inputArgs.Length > 0 ? inputArgs[0] : string.Empty;
inputArgs = inputArgs.Skip(1).ToArray();
switch (commandName.ToLower())
{
case "exit":
ExitCommand exit = new ExitCommand();
exit.Execute(inputArgs);
break;
case "registeruser":
RegisterUserCommand registerUserCommand = new RegisterUserCommand();
result = registerUserCommand.Execute(inputArgs);
break;
case "login":
LoginCommand login = new LoginCommand();
result = login.Execute(inputArgs);
break;
case "logout":
LogoutCommand logoutCommand = new LogoutCommand();
result = logoutCommand.Execute(inputArgs);
break;
case "deleteuser":
DeleteUserCommand deleteUserCommand = new DeleteUserCommand();
result = deleteUserCommand.Execute(inputArgs);
break;
case "createevent":
CreateEventCommand createEvent = new CreateEventCommand();
result = createEvent.Execute(inputArgs);
break;
case "createteam":
CreateTeamCommand createTeam = new CreateTeamCommand();
result = createTeam.Execute(inputArgs);
break;
case "invitetoteam":
InviteToTeamCommand inviteToTeamCommand = new InviteToTeamCommand();
result = inviteToTeamCommand.Execute(inputArgs);
break;
case "acceptinvite":
AcceptInviteCommand acceptInviteCommand = new AcceptInviteCommand();
result = acceptInviteCommand.Execute(inputArgs);
break;
case "declineinvite":
DeclineInviteCommand declineInviteCommand = new DeclineInviteCommand();
result = declineInviteCommand.Execute(inputArgs);
break;
case "kickmember":
KickMemberCommand kickMemberCommand = new KickMemberCommand();
result = kickMemberCommand.Execute(inputArgs);
break;
case "disband":
DisbandCommand disbandCommand = new DisbandCommand();
result = disbandCommand.Execute(inputArgs);
break;
case "addteamto":
AddTeamToCommand addTeamToCommand = new AddTeamToCommand();
result = addTeamToCommand.Execute(inputArgs);
break;
case "showevent":
ShowEventCommand showEventCommand = new ShowEventCommand();
result = showEventCommand.Execute(inputArgs);
break;
case "showteam":
ShowTeamCommand showTeamCommand = new ShowTeamCommand();
result = showTeamCommand.Execute(inputArgs);
break;
default:
throw new NotSupportedException($"Command {commandName} not supported!");
}
return(result);
}
protected void LogoutCommandHandler(LogoutCommand cmd)
{
_backendService.Logout();
}
public virtual void ProcessLogoutCommand(LogoutCommand cmd)
{
this.Session.ChangeState(new LogoutState(this.Session));
this.Session.AppendResponse(new ServerStatusResponse(cmd.Tag, ServerStatusResponseType.OK, "LOGOUT completed"));
}
