public FubuContinuation Login(LoginCommand command)
{
var account = _session.Query<UserAccount>().First(x => x.Username == command.Username);
_service.Login(account);
return FubuContinuation.RedirectTo<HomeRequest>();
}
public void SuccessfulValidation()
{
var validator = new LoginCommandValidator(Session);
var command = new LoginCommand { Username = DefaultUser.Username, Password = DefaultUser.Password };
validator.Validate(command).IsValid.ShouldBeTrue();
}
public void ValidatesPasswordCorrect()
{
var validator = new LoginCommandValidator(Session);
var command = new LoginCommand { Username = DefaultUser.Username, Password = "******" };
validator.ShouldHaveValidationErrorFor(x => x.Password, command);
}
public void ValidatesUserExists()
{
var validator = new LoginCommandValidator(Session);
var command = new LoginCommand { Username = "******", Password = DefaultUser.Password };
validator.ShouldHaveValidationErrorFor(x => x.Username, command);
}
public async Task Login(string token)
{
await Connect().ConfigureAwait(false);
LoginCommand msg = new LoginCommand();
msg.Payload.Token = token;
msg.Payload.Properties["$device"] = "Discord.Net";
QueueMessage(msg);
}
private LoginCommand CreateStubbedCommand(IExtendedAuthenticationService service, IElmsSessionRequestService elmsSessionRequestService)
{
var command = new LoginCommand(service, elmsSessionRequestService);
command.Request = MockRepository.GenerateStub<IHttpRequest>();
command.Response = MockRepository.GenerateStub<IHttpResponse>();
command.Session = MockRepository.GenerateStub<IHttpSession>();
command.TemplateProvider = MockRepository.GenerateStub<ITemplateProvider>();
command.FileExtensionProvider = MockRepository.GenerateStub<IFileExtensionProvider>();
return command;
}
public void LogsInAndRedirects()
{
var endpoint = TestableLoginEndpoint.Build(Session);
var command = new LoginCommand { Username = DefaultUser.Username, Cookies = endpoint.CookieStorage.Object, HttpContext = endpoint.HttpContext };
var redirect = endpoint.Login(command);
endpoint.Service.Verify(x => x.Login(DefaultUser));
redirect.AssertWasRedirectedTo<HomeRequest>(x => x != null);
}
public static ICommand Parse( byte[] data )
{
ICommand response = null;
var pid = data[0];
switch (pid)
{
case (int)PacketID.Login:
response = new LoginCommand();
break;
case (int)PacketID.AcceptCharacter:
response = new UnknownCommand();
break;
case (int)PacketID.ArenaResult:
response = new UnknownCommand();
break;
case (int)PacketID.CharacterReturn:
response = new UnknownCommand();
break;
case (int)PacketID.CharacterUpdate:
response = new UnknownCommand();
break;
case (int)PacketID.GetCharacter:
response = new UnknownCommand();
break;
case (int)PacketID.GetServerData:
response = new UnknownCommand();
break;
case (int)PacketID.IdentServer:
response = new UnknownCommand();
break;
case (int)PacketID.NewCharacter:
response = new NewCharacterCommand();
break;
case (int)PacketID.NicknameCheck:
response = new UnknownCommand();
break;
case (int)PacketID.RejectCharacter:
response = new UnknownCommand();
break;
case (int)PacketID.ServerList:
response = new UnknownCommand();
break;
case (int)PacketID.ServerReconnect:
response = new UnknownCommand();
break;
default:
response = new UnknownCommand();
break;
}
return response;
}
public Server(CreateCommand createCommand, LoginCommand loginCommand, UseCommand useCommand,
ShowCommand showCommand, CommitCommand commitCommand, PullCommand pullCommand, ILocalService localService)
{
this.createCommand = createCommand;
this.loginCommand = loginCommand;
this.useCommand = useCommand;
this.showCommand = showCommand;
this.commitCommand = commitCommand;
this.pullCommand = pullCommand;
this.localService = localService;
}
public async void Execute_Works() {
var connectionInfo = new DbConnectionInfo() {
Uri = new Uri(BaseUri),
Host = "",
DatabaseName = "",
UserName = "",
Password = ""
};
var loginCommand = new LoginCommand(connectionInfo);
var httpClient = new HttpClient();
await loginCommand.Execute(httpClient);
}
public async Task Login(string token)
{
await BeginConnect().ConfigureAwait(false);
await Start().ConfigureAwait(false);
LoginCommand msg = new LoginCommand();
msg.Payload.Token = token;
msg.Payload.Properties["$device"] = "Discord.Net";
if (_client.Config.UseLargeThreshold)
msg.Payload.LargeThreshold = 100;
msg.Payload.Compress = true;
QueueMessage(msg);
}
public void FileExtensionIsCorrectlySetInLoginView()
{
var command = new LoginCommand();
var responseMock = MockRepository.GenerateMock<IHttpResponse>();
command.Response = responseMock;
var templateProvider = MockRepository.GenerateStub<ITemplateProvider>();
templateProvider.Stub(p => p.GetTemplate(null)).IgnoreArguments().Return("$EXTENSION$");
command.TemplateProvider = templateProvider;
command.FileExtensionProvider = new FileExtensionProvider() { Extension = "EXT"};
command.Request = MockRepository.GenerateStub<IHttpRequest>();
command.Session = MockRepository.GenerateStub<IHttpSession>();
command.Execute();
responseMock.AssertWasCalled(p => p.Write("EXT"));
}
public async void Execute_Works() {
var connectionInfo = new DbConnectionInfo() {
Uri = new Uri(BaseUri),
Host = "",
DatabaseName = "",
UserName = "",
Password = ""
};
var loginCommand = new LoginCommand(connectionInfo);
var httpClient = new HttpClient();
await loginCommand.Execute(httpClient);
using (var fileStream = File.Create("c:\\backup\\12345.bak")) {
var backupCommand = new BackupCommand(connectionInfo);
await backupCommand.Execute(httpClient, fileStream);
}
}
public dynamic LoginUser(LoginCommand loginCommand)
{
if (!ModelValidationResult.IsValid)
{
return View["LoginPage", new[] { "请正确输入Email和密码" }];
}
var commandResult = _commandInvoker.Handle<LoginCommand, LoginCommandResult>(loginCommand);
if (commandResult.Success)
{
var cookie = FormsAuthentication.CreateAuthCookie(commandResult.Author.Id);
var response = Context.GetRedirect(loginCommand.ReturnUrl ?? "/mz-admin");
response.WithCookie(cookie);
return response;
}
return View["LoginPage", commandResult.GetErrors()];
}
private LoginCommand CreateStubbedCommand()
{
var command = new LoginCommand();
command.Request = MockRepository.GenerateStub<IHttpRequest>();
command.Response = MockRepository.GenerateStub<IHttpResponse>();
command.Session = MockRepository.GenerateStub<IHttpSession>();
command.TemplateProvider = MockRepository.GenerateStub<ITemplateProvider>();
command.FileExtensionProvider = MockRepository.GenerateStub<IFileExtensionProvider>();
return command;
}
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 async Task <ActionResult <UserViewModel> > LoginAsync(LoginCommand query)
{
return(await Mediator.Send(query));
}
public LoginVM()
{
User = new Users();
LoginCommand = new LoginCommand(this);
}
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);
}
private void InitializeCommands()
{
LoginCommand = new LoginCommand(this);
}
public LoginVM()
{
User = new User();
RegisterCommand = new RegisterCommand(this);
LoginCommand = new LoginCommand(this);
}
public LoginPageVM()
{
authService = App.Data.AuthService;
LoginCommand = new LoginCommand(this);
user = new User();
}
public async Task <AuthDto> AuthenticateUser(LoginCommand loginCommand, CancellationToken cancellationToken)
{
return(await _mediator.Send(loginCommand, cancellationToken));
}
private void OnIsLoadingChanged()
{
LoginCommand.RaiseCanExecuteChanged();
}
private void OnPasswordChanged()
{
LoginCommand.RaiseCanExecuteChanged();
}
private void OnEmailChanged()
{
LoginCommand.RaiseCanExecuteChanged();
}
public menuViewModel()
{
this.RegisterCommand = new RegisterCommand(this);
this.LoginCommand = new LoginCommand(this);
soundPlayer.mainMenu();
}
public async Task <ResultData <string> > Login(LoginCommand param)
{
return(await _mediator.Send(param));
}
private LoginCommand CreateLoginCommand(string[] commandComponenets)
{
if (commandComponenets.Length != LoginCommandParametersCount)
{
throw new InvalidOperationException(LoginCommandParametersCountErrorMessage);
}
var username = commandComponenets[1];
if (username.Length < UsernameMinLength)
{
throw new ArgumentOutOfRangeException(UsernameLengthErrorMessage);
}
var password = commandComponenets[2];
var command = new LoginCommand(username, password);
return command;
}
public virtual void LoginHandler(LoginCommand command)
{
this.Login(command.Sender as LoginScreenViewModel);
}
private void ChangeIsBusy(bool isBusy)
{
IsBusy = isBusy;
LoginCommand.ChangeCanExecute();
}
private async Task <Result <LoginCommandResult, ErrorData> > Process(
LoginCommand request, CancellationToken cancellationToken)
{
var whenHappened = this._clock.GetCurrentInstant().ToDateTimeUtc();
var userMaybe = await this._userRepository.FindByEmailAddress(request.EmailAddress, cancellationToken);
if (userMaybe.HasNoValue)
{
return(Result.Fail <LoginCommandResult, ErrorData>(new ErrorData(ErrorCodes.UserNotFound)));
}
var user = userMaybe.Value;
if (user.IsLockable && user.IsLocked)
{
return(Result.Fail <LoginCommandResult, ErrorData>(new ErrorData(
ErrorCodes.AccountIsLocked, "Account Lock")));
}
if (!this._passwordHasher.ValidatePassword(request.Password, user.PasswordHash))
{
user.AddFailedLoginAttempt(whenHappened);
if (user.CheckAndApplyAccountLock(this._identitySettings.FailedLoginAttemptsThreshold, whenHappened))
{
user.RandomizePassword(
this._passwordHasher.HashPassword(this._passwordGenerator.Generate()),
whenHappened);
}
this._userRepository.Update(user);
return(Result.Fail <LoginCommandResult, ErrorData>(new ErrorData(
ErrorCodes.PasswordNotCorrect, "Password not valid")));
}
LoginCommandResult.LoginResultStatus loginResultStatus = 0;
if (this._identitySettings.AccountsMustBeVerified && !user.IsVerified)
{
loginResultStatus |= LoginCommandResult.LoginResultStatus.Unconfirmed;
return(Result.Ok <LoginCommandResult, ErrorData>(
new LoginCommandResult(user.Id, loginResultStatus)));
}
user.UpdateValidLoginProperties(whenHappened);
this._userRepository.Update(user);
if (user.AuthenticatorApps.Any(x => x.WhenRevoked == null))
{
loginResultStatus |= LoginCommandResult.LoginResultStatus.AuthAppEnabled;
}
if (user.AuthenticatorDevices.Any(x => x.WhenRevoked == null))
{
loginResultStatus |= LoginCommandResult.LoginResultStatus.AuthDeviceEnabled;
}
if (!this._identitySettings.PasswordsCanExpire)
{
loginResultStatus |= LoginCommandResult.LoginResultStatus.Valid;
return(Result.Ok <LoginCommandResult, ErrorData>(
new LoginCommandResult(user.Id, loginResultStatus)));
}
var passwordAge = (int)(whenHappened - (user.WhenPasswordChanged ?? user.WhenCreated).ToUniversalTime()).TotalDays;
if (passwordAge >= this._identitySettings.MaxPasswordAgeDays)
{
loginResultStatus |= LoginCommandResult.LoginResultStatus.PasswordExpired;
return(Result.Ok <LoginCommandResult, ErrorData>(new LoginCommandResult(user.Id,
loginResultStatus)));
}
loginResultStatus |= LoginCommandResult.LoginResultStatus.Valid;
return(Result.Ok <LoginCommandResult, ErrorData>(new LoginCommandResult(
user.Id, loginResultStatus)));
}
public virtual void LoginHandler(LoginCommand command)
{
this.Login(command.Sender as LoginScreenViewModel);
}
public HttpRequestMessage GetRequestMessage <T>(LoginCommand <T> command)
{
return(this.GetRequestMessage <T>(this.GetRequestUri(), this.GetHttpContent(command), HttpMethod));
}
private async Task<string> ExecuteLoginCommand(LoginCommand loginCommand)
{
var loginContent = new FormUrlEncodedContent(new[]
{
new KeyValuePair<string, string>("username", loginCommand.Username),
new KeyValuePair<string, string>("password", loginCommand.Password),
new KeyValuePair<string, string>("grant_type", "password")
});
var response = await this.Requester.HttpClient.PostAsync(LoginEndpoint, loginContent);
if (!response.IsSuccessStatusCode)
{
throw ApiException.Create(response);
}
this.Requester.LoggedUserData = response.Content.ReadAsAsync<LoginUserData>().Result;
this.Requester.SetClientHeaders();
return SuccessfullLoginMessage;
}
public LoginViewModel()
{
Login = new LoginCommand(this);
LoginModel = new LoginModel();
}
/// <summary>
/// Initalize a new instance of LoginViewModel class
/// </summary>
public LoginViewModel(User model)
{
User = model;
LoginCommand = new LoginCommand(this);
Controller = new AccountController();
}
private static bool RealizarAutoLogin(string arg)
{
const string methodName = "RealizarAutoLogin";
string login = null;
string password = null;
// login Jefe grupo
if (arg == "aljg")
{
login = "******";
password = "******";
}
if (arg == "alsrh")
{
login = "******";
password = "******";
}
if (arg == "aladm")
{
login = "******";
password = "******";
}
var loginCmd = new LoginCommand
{
UserName = login,
Password = password,
};
var status = _proxy.Handle(loginCmd);
bool Success = status.GetType() == typeof(Success);
if (Success)
{
Log.WriteEntry(ClassName, methodName, TraceEventType.Information, string.Format("Login exitoso para usuario: {0}", loginCmd.UserName));
_userName = loginCmd.UserName;
// continuar inicio
bool ret;
ret = ConsultarRol();
if (!ret)
{
return(false);
}
ret = ConfigurarMainForm();
if (!ret)
{
return(false);
}
ret = LeerDatosInicio();
if (!ret)
{
return(false);
}
return(true);
}
return(false);
}
public MainVM()
{
User = new User();
LoginCommand = new LoginCommand(this);
RegisterNavigationCommand = new RegisterNavigationCommand(this);
}
public LoginVM()
{
RegisterCommand = new RegisterCommand(this);
LoginCommand = new LoginCommand(this);
}
public void LoginCommandFailTest()
{
var loginCommand = new LoginCommand("deviceid");
Assert.IsFalse(loginCommand.IsValid);
}
public void SignIn(LoginCommand loginCommand)
{
Client.SignIn(loginCommand);
}
public void LoginCommandNullTest()
{
var loginCommand = new LoginCommand(null);
Assert.IsFalse(loginCommand.IsValid);
}
public void LoginCommandMoreParamsTest()
{
var loginCommand = new LoginCommand("a b c");
Assert.IsFalse(loginCommand.IsValid);
}
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();
result = registerUser.Execute(commandParameters);
break;
case "AddTown":
AddTownCommand addTown = new AddTownCommand();
result = addTown.Execute(commandParameters);
break;
case "ModifyUser":
ModifyUserCommand modifyUser = new ModifyUserCommand();
result = modifyUser.Execute(commandParameters);
break;
case "DeleteUser":
DeleteUserCommand deleteUser = new DeleteUserCommand();
result = deleteUser.Execute(commandParameters);
break;
case "AddTag":
AddTagCommand addTag = new AddTagCommand();
result = addTag.Execute(commandParameters);
break;
case "CreateAlbum":
CreateAlbumCommand createAlbum = new CreateAlbumCommand();
result = createAlbum.Execute(commandParameters);
break;
case "AddTagTo":
AddTagToCommand addTagTo = new AddTagToCommand();
result = addTagTo.Execute(commandParameters);
break;
case "MakeFriends":
MakeFriendsCommand makeFriend = new MakeFriendsCommand();
result = makeFriend.Execute(commandParameters);
break;
case "ListFriends":
PrintFriendsListCommand listFriends = new PrintFriendsListCommand();
result = listFriends.Execute(commandParameters);
break;
case "UploadPicture":
UploadPictureCommand uploadPicture = new UploadPictureCommand();
result = uploadPicture.Execute(commandParameters);
break;
case "ShareAlbum":
ShareAlbumCommand shareAlbum = new ShareAlbumCommand();
result = shareAlbum.Execute(commandParameters);
break;
case "Login":
LoginCommand login = new LoginCommand();
result = login.Execute(commandParameters);
break;
case "Logout":
LogoutCommand logout = new LogoutCommand();
result = logout.Execute(commandParameters);
break;
case "Exit":
ExitCommand exit = new ExitCommand();
exit.Execute();
break;
default:
Console.WriteLine($"Command {commandName} not valid!");
break;
}
return(result);
}
protected override IEnumerable<Task> GetTasks()
{
_isClearing = false;
_udp = new UdpClient(new IPEndPoint(IPAddress.Any, 0));
#if !DNX451 && !__MonoCS__
_udp.AllowNatTraversal(true);
#endif
LoginCommand msg = new LoginCommand();
msg.Payload.ServerId = _serverId;
msg.Payload.SessionId = _sessionId;
msg.Payload.Token = _token;
msg.Payload.UserId = _userId;
QueueMessage(msg);
List<Task> tasks = new List<Task>();
if ((_client.Config.VoiceMode & DiscordVoiceMode.Outgoing) != 0)
{
#if USE_THREAD
_sendThread = new Thread(new ThreadStart(() => SendVoiceAsync(_cancelToken)));
_sendThread.IsBackground = true;
_sendThread.Start();
#else
tasks.Add(SendVoiceAsync());
#endif
}
#if USE_THREAD
//This thread is required to establish a connection even if we're outgoing only
if ((_client.Config.VoiceMode & DiscordVoiceMode.Incoming) != 0)
{
_receiveThread = new Thread(new ThreadStart(() => ReceiveVoiceAsync(_cancelToken)));
_receiveThread.IsBackground = true;
_receiveThread.Start();
}
else //Dont make an OS thread if we only want to capture one packet...
tasks.Add(Task.Run(() => ReceiveVoiceAsync(_cancelToken)));
#else
tasks.Add(ReceiveVoiceAsync());
#endif
#if !DNXCORE50
tasks.Add(WatcherAsync());
#endif
if (tasks.Count > 0)
{
// We need to combine tasks into one because receiveThread is
// supposed to exit early if it's an outgoing-only client
// and we dont want the main thread to think we errored
var task = Task.WhenAll(tasks);
tasks.Clear();
tasks.Add(task);
}
tasks.AddRange(base.GetTasks());
return new Task[] { Task.WhenAll(tasks.ToArray()) };
}
public async Task <Option <Token> > Handle(LoginCommand request, CancellationToken cancellationToken)
{
return(await _repository.Login(request.UserName, request.Password));
}
public static DbQuery <User> ToDbQuery(this LoginCommand command)
{
return(DbQuery.For <User>().FilterBy(x => x.UserName == command.Login));
}
LoginAsync([FromBody] LoginCommand login)
{
var result = await Mediator.Send(login);
return(result != null?Created("", result) : (IActionResult)BadRequest(result));
}
public virtual void ExecuteLogin(LoginCommand command)
{
command.Sender = LoginScreen;
LoginScreen.Login.OnNext(command);
}
public async void Post([FromBody] LoginCommand command)
{
await HttpContext.SignOutAsync("DatScheme");
}
