public static void Initialize(TestContext testContext)
{
Task <AuthorizationToken> tokenTask = AuthorizationController.GetAuthorizationToken(ConfigurationHelper.PortalUrl, ConfigurationHelper.UserName, ConfigurationHelper.Password, ConfigurationHelper.Domain);
tokenTask.Wait();
_authToken = tokenTask.Result;
}
public ApplicationController()
{
AuthController = new AuthorizationController(new AuthorizationView(), new AuthorizationModel());
AuthController.ControllerClosed += this.AuthController_ControllerClosed;
MainController = new MainController(new MainView(), new MainModel());
MainController.ControllerClosed += this.MainController_ControllerClosed;
}
public async Task ResetPassword_Should_change_password_and_reset_pemisiontoken()
{
// arrange
var user = UserBuilder.Create()
.WithEmail(HealthyJuicesConstants.DEFAULT_USER_LOGIN)
.WithPassword(RandomString)
.WithPermissionsToken(RandomString, DateTime.Today.AddDays(1))
.Active()
.Build(ArrangeRepositoryContext);
var controller = new AuthorizationController(Mediator);
var newPass = "******";
var dto = new ResetPassword.Command(HealthyJuicesConstants.DEFAULT_USER_LOGIN, user.PermissionsToken.Token, newPass);
// act
await controller.ResetPasswordAsync(dto);
// assert
var subject = AssertRepositoryContext.Users.FirstOrDefault();
subject.Should().NotBeNull();
subject.Password.Salt.Should().NotBe(user.Password.Salt);
subject.Password.Salt.Should().NotBe(user.Password.Text);
subject.Password.CheckValidity(newPass).Should().BeTrue();
subject.IsActive.Should().BeTrue();
subject.PermissionsToken.Should().BeNull();
MailerMock.VerifyNoOtherCalls();
}
public async Task Post_ReturnsNewlyCreatedToken()
{
Mock <IRepository> mockRepo = new Mock <IRepository>();
AuthorizationController controller = new AuthorizationController(mockRepo.Object);
// arrange
var newLoginModel = new LoginModel
{
UserName = "******",
Password = "******",
Cust_ID_Main = 19139
};
int y = 0;
// Result
var result = await controller.Post(newLoginModel);
int x = 0;
// Assert
var okResult = Assert.IsType <OkObjectResult>(result);
var returnResponse = Assert.IsType <LoginSuccessModel>(okResult.Value);
_mockRepo.Verify();
Assert.Equal("41607", returnResponse.UserId);
Assert.Equal("customer", returnResponse.Role);
Assert.Equal("*****@*****.**", returnResponse.UserName);
Assert.NotEmpty(returnResponse.AccessToken);
}
public async Task Can_Login_as_Customer()
{
// arrange
var user = UserBuilder.Create()
.WithRole(UserRole.Customer)
.WithEmail(HealthyJuicesConstants.DEFAULT_USER_LOGIN)
.Active()
.WithPassword(HealthyJuicesConstants.DEFAULT_USER_PASSWORD)
.Build(ArrangeRepositoryContext);
var dto = new Login.Query(HealthyJuicesConstants.DEFAULT_USER_LOGIN, HealthyJuicesConstants.DEFAULT_USER_PASSWORD);
var controller = new AuthorizationController(Mediator);
// act
var result = await controller.LoginAsync(dto);
// assert
result.AccessToken.Should().NotBeNullOrEmpty();
result.User.Should().NotBeNull();
result.User.Email.Should().Be(dto.Email);
var subject = AssertRepositoryContext.Users.FirstOrDefault();
subject.Should().NotBeNull();
subject.Roles.Should().Be(UserRole.Customer);
subject.Email.Should().Be(dto.Email);
subject.Password.Text.Should().NotBeNullOrWhiteSpace();
subject.Password.Salt.Should().NotBeNullOrWhiteSpace();
subject.IsActive.Should().BeTrue();
subject.IsRemoved.Should().BeFalse();
}
public async Task CreateEnquiries(int userid, string userType, List <cServiceProvider> serProviders)
{
AuthorizationController ac = new AuthorizationController();
MessageController mc = new MessageController();
int smsCnt = 0;
//System.Net.WebUtility.UrlEncode(serProviders[0].cSvcDesc);
//HttpUtility.UrlEncode("search");
foreach (cPartialSender snd in serProviders[0].providers)
{
ctblEnquiry cEnquiry = new ctblEnquiry();
cEnquiry.FromUserID = userid;
cEnquiry.FromUserType = userType;
cEnquiry.ToUserID = snd.SenderID;
cEnquiry.ToUserType = "S";
/* THIS SENTENCE SHOULD NOT BE CHANGED, IT USED IN SP sp_addEnquiryAnswer */
cEnquiry.EnquiryMessage = "Found your reference on searching '" + serProviders[0].cSvcDesc.Replace(",", " ").ToString() + "'. Distance: " + snd.postcode;
cEnquiry.EnquiryID = 0;
mc.PostEnquiry(cEnquiry);
if (smsCnt < 10 /*&& snd.isFCMActive.Equals("Y") */)
{
ac.SendSearchEnquirySMS(snd.SenderContactNo_2, System.Net.WebUtility.UrlEncode(serProviders[0].cSvcDesc.Replace(",", " ").ToString()), snd.postcode);
smsCnt++;
}
}
}
public AuthorizationControllerTests()
{
var userManagerLogger = new NullLogger <UserManager <RoadkillIdentityUser> >();
var userStoreMock = Substitute.For <IUserStore <RoadkillIdentityUser> >();
_userManagerMock = Substitute.For <UserManager <RoadkillIdentityUser> >(
userStoreMock,
null,
null,
null,
null,
null,
null,
null,
userManagerLogger);
var signinManagerLogger = new NullLogger <SignInManager <RoadkillIdentityUser> >();
var contextAccessorMock = Substitute.For <IHttpContextAccessor>();
var claimFactoryMock = Substitute.For <IUserClaimsPrincipalFactory <RoadkillIdentityUser> >();
_signinManagerMock = Substitute.For <SignInManager <RoadkillIdentityUser> >(
_userManagerMock,
contextAccessorMock,
claimFactoryMock,
null,
signinManagerLogger,
null);
_jwtTokenProvider = Substitute.For <IJwtTokenProvider>();
_authorizationController = new AuthorizationController(_userManagerMock, _signinManagerMock, _jwtTokenProvider);
}
public void Register()
{
// Arrange
var controller = new AuthorizationController();
// Act
var result = controller.Register(new RegisterViewModel.Request
{
email = "*****@*****.**",
hash = Hashing.GetMD5("password")
});
// Assert
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result.Data, typeof(JsonResultViewModel));
var jsonResult = (JsonResultViewModel)result.Data;
Assert.IsNotNull(jsonResult);
Assert.IsTrue(jsonResult.is_successful);
Assert.IsInstanceOfType(jsonResult.data, typeof(RegisterViewModel.Response));
var data = (RegisterViewModel.Response)jsonResult.data;
Assert.IsNotNull(data);
Assert.IsNotNull(data.access_token);
}
protected async Task GetCurrecntUserGrantedPermissions(IDictionary <string, string> userClaims)
{
IdentityInfo identityInfo;
try
{
identityInfo = (await AuthorizationController.ParseIdentityInfoFromIdentityClaimsAsync(userClaims));
}
catch (ArgumentException)
{
identityInfo = null;
}
if (identityInfo != null)
{
UserId = identityInfo.UserId;
Username = identityInfo.Username;
GrantedPermissions = new HashSet <string>(identityInfo.GrantedPermissions);
}
else
{
UserId = null;
Username = null;
GrantedPermissions = new HashSet <string>();
}
}
public async Task Can_register_as_Customer_and_send_email()
{
// arrange
var company = CompanyBuilder.Create().WithName("test company").Build(ArrangeRepositoryContext);
var dto = new Register.Command("*****@*****.**", "test pass", "", "", company.Id);
var controller = new AuthorizationController(Mediator);
// act
var result = await controller.RegisterAsync(dto);
// assert
result.Should().NotBeNullOrWhiteSpace();
var subject = AssertRepositoryContext.Users.FirstOrDefault();
subject.Should().NotBeNull();
subject.Roles.Should().Be(UserRole.Customer);
subject.Email.Should().Be(dto.Email);
subject.Password.Text.Should().NotBeNullOrWhiteSpace();
subject.Password.Salt.Should().NotBeNullOrWhiteSpace();
subject.IsActive.Should().BeFalse();
subject.IsRemoved.Should().BeFalse();
subject.PermissionsToken.Token.Should().NotBeNullOrEmpty();
subject.PermissionsToken.Expiration.Should().BeAfter(DateTime.Now);
subject.PermissionsToken.Expiration.Should().BeBefore(DateTime.Now.AddDays(2));
MailerMock.Verify(mock => mock.SendAsync(It.Is <string>(x => x == dto.Email), It.IsAny <string>(), It.Is <string>(x => x.Contains(subject.PermissionsToken.Token)), false), Times.Once);
MailerMock.VerifyNoOtherCalls();
}
public void TestFailAuthorization()
{
var authorizationController = new AuthorizationController(_mock.Object);
var result = authorizationController.AuthorizeUser("Name");
Assert.False(result);
}
static void Main(string[] args)
{
View.SendMessage("Hello, please enter your name: ");
string name = Console.ReadLine();
ManagerRepository managerRepository = new ManagerRepository(new JsonRepository());
AuthorizationRepository authorizationRepository = new AuthorizationRepository(managerRepository);
AuthorizationController authorizationController = new AuthorizationController(name, authorizationRepository);
}
public static void Initialize(TestContext testContext)
{
_objectsToCleanup = new List <PurchaseOrder>();
Task <AuthorizationToken> tokenTask = AuthorizationController.GetAuthorizationToken(ConfigurationHelper.PortalUrl, ConfigurationHelper.UserName, ConfigurationHelper.Password, ConfigurationHelper.Domain);
tokenTask.Wait();
_authToken = tokenTask.Result;
}
public static string GetStoreAddress()
{
if (authParams == null)
{
authParams = AuthorizationController.GetAuthParams();
}
return(authParams.StoreAddress);
}
public void Init()
{
_logger = new Mock <ILogger>();
_controller = new AuthorizationController(
AccessKey,
_logger.Object,
Mock.Of <IRepository>(),
Mock.Of <IMapper>(),
Mock.Of <IUserSpecificationProvider>()
);
}
private AuthorizationController GetMockRepositoryController()
{
var userRepository = new TestUserRepository();
var rolesRepository = new TestRolesRepository();
var userService = new UserService(userRepository);
var rolesService = new RolesService(userRepository, rolesRepository);
var controller = new AuthorizationController(userService, rolesService);
return(controller);
}
public async Task ValidateClient()
{
//TODO: This needs a mocked IConfiguration to pass
var authorizationController = new AuthorizationController(null, new ClientRepository(context));
var result = await authorizationController.GetToken(new Dto.CredentialDto()
{
ClientName = "client1", Key = "password"
});
Assert.IsNotNull(result.Value);
}
public static void Initialize(TestContext testContext)
{
Task <AuthorizationToken> tokenTask = AuthorizationController.GetAuthorizationToken(ConfigurationHelper.PortalUrl, ConfigurationHelper.UserName, ConfigurationHelper.Password, ConfigurationHelper.Domain);
tokenTask.Wait();
_authToken = tokenTask.Result;
if (!_authToken.User.CanCreateIncident)
{
Assert.Fail("Must run Incident tests with an account that can create Incidents.");
}
}
public async Task AUTH02_GetUserRightsTest()
{
// Arrange
ConsoleUser userRights;
// Act
userRights = await AuthorizationController.GetUserRights(_authToken);
// Assert
Assert.IsNotNull(userRights);
Assert.AreEqual(ConfigurationHelper.UserName, userRights.UserName);
Assert.AreEqual(ConfigurationHelper.Domain, userRights.Domain);
Assert.IsFalse(string.IsNullOrWhiteSpace(userRights.PrincipalName));
}
public async Task AUTH01_GetAuthorizationTokenTest()
{
// Arrange
// Act
_authToken = await AuthorizationController.GetAuthorizationToken(ConfigurationHelper.PortalUrl, ConfigurationHelper.UserName, ConfigurationHelper.Password, ConfigurationHelper.Domain);
// Assert
Assert.IsNotNull(_authToken);
Assert.AreEqual(ConfigurationHelper.UserName, _authToken.User.UserName);
Assert.AreEqual(ConfigurationHelper.Domain, _authToken.User.Domain);
Assert.AreEqual(ConfigurationHelper.PortalUrl, _authToken.PortalUrl);
Assert.IsTrue(_authToken.IsValid);
}
static void Main(string[] args)
{
LogManager.Configuration ??= new NLog.Config.LoggingConfiguration();
var tcpProvider = new TcpProvider(NetworkSocket.Create);
var udpProvider = new UdpProvider(NetworkSocket.Create);
var watcher = new ActivityWatcher(tcpProvider)
{
Interval = 15000,
};
// TODO Impl udp transport layer.
var provider = new AudioProvider(udpProvider);
var calls = new CallController(new KeyContainer(), () => new BridgeRouter(provider));
var authorization = new AuthorizationController();
var core = new CoreApi(tcpProvider, new MessageFactory(true));
new AuthApi(core, authorization);
new TextApi(core, authorization);
new CallApi(core, authorization, calls);
// TODO Impl ping message.
//watcher.Start();
// TODO Add network interfaces.
_ = tcpProvider.StartAsync(new IPEndPoint(IPAddress.Any, 30010));
_ = udpProvider.StartAsync(new IPEndPoint(IPAddress.Any, 30010));
Console.WriteLine("Press key:\r\n S - stop\r\n Q - exit");
while (true)
{
var key = Console.ReadKey();
switch (key.Key)
{
case ConsoleKey.Q:
return;
case ConsoleKey.S:
tcpProvider.Stop();
udpProvider.Stop();
break;
default:
break;
}
}
}
public void LoginAsync_ShouldContainsValidateModelAttribute()
{
//arrange
var authService = new Mock <IAuthService>();
var controller = new AuthorizationController(authService.Object);
//act
var method = controller.GetType()
.GetMethods()
.Where(m => m.Name == nameof(controller.LoginAsync))
.Where(m => m.CustomAttributes.Any(a => a.AttributeType == typeof(ValidateModelAttribute)))
.FirstOrDefault();
//assert
Assert.IsNotNull(method);
}
public void BeforeEach()
{
IServiceCollection serviceCollection = ServiceConfiguration.InitServiceCollection();
IServiceProvider serviceProvider = ServiceConfiguration.BuildServiceProvider();
Configuration = serviceProvider.GetRequiredService <IConfiguration>();
controller = serviceProvider.GetRequiredService <AuthorizationController>();
connectionController = serviceProvider.GetRequiredService <ConnectionController>();
accountController = serviceProvider.GetRequiredService <AccountController>();
connectionRepository = serviceProvider.GetRequiredService <IRepository <Connection, long> >();
authorizationRepository = serviceProvider.GetRequiredService <IRepository <Authorization, long> >();
clientRepository = serviceProvider.GetRequiredService <IRepository <Client, string> >();
account = accountController.Create(new AddAccountModel
{
Name = "Chendjou",
Surname = "Caleb",
Email = "*****@*****.**",
Password = "******",
});
connection = connectionController.Create(new LoginModel
{
Email = account.Email,
Password = "******"
});
client = clientRepository.Save(new Client
{
Name = "Identity Client",
SecretCode = Guid.NewGuid().ToString()
});
model = new AuthorizeModel
{
ClientId = client.Id,
SecretCode = client.SecretCode,
ConnectionId = connection.Id
};
}
public void BeforeEach()
{
serviceCollection = ServiceConfiguration.InitServiceCollection();
provider = ServiceConfiguration.BuildServiceProvider();
configuration = provider.GetRequiredService <IConfiguration>();
clientRepository = provider.GetRequiredService <IRepository <Client, string> >();
authorizationRepository = provider.GetRequiredService <IRepository <Authorization, long> >();
connectionRepository = provider.GetRequiredService <IRepository <Connection, long> >();
accountRepository = provider.GetRequiredService <IRepository <Account, string> >();
validator = provider.GetRequiredService <AccessTokenValidator>();
controller = provider.GetRequiredService <AuthorizationController>();
client = clientRepository.Save(new Client {
Name = "clientApp", Id = "d8g1fn"
});
}
public async Task ConfirmEmailRegister_Should_activate_user_and_reset_pemisiontoken()
{
// arrange
var user = UserBuilder.Create()
.WithEmail(HealthyJuicesConstants.DEFAULT_USER_LOGIN)
.WithPermissionsToken(RandomString, DateTime.Today.AddDays(1))
.Build(ArrangeRepositoryContext);
var controller = new AuthorizationController(Mediator);
// act
await controller.ConfirmRegisterAsync(HealthyJuicesConstants.DEFAULT_USER_LOGIN, user.PermissionsToken.Token);
// assert
var subject = AssertRepositoryContext.Users.FirstOrDefault();
subject.Should().NotBeNull();
subject.IsActive.Should().BeTrue();
subject.PermissionsToken.Should().BeNull();
}
public void RegisterInvalidEmail()
{
// Arrange
var controller = new AuthorizationController();
// Act
var result = controller.Register(new RegisterViewModel.Request
{
email = "test",
hash = Hashing.GetMD5("password")
});
// Assert
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result.Data, typeof(JsonResultViewModel));
var jsonResult = (JsonResultViewModel)result.Data;
Assert.IsNotNull(jsonResult);
Assert.IsFalse(jsonResult.is_successful);
}
public void RegisterWeakPassword()
{
// Arrange
var controller = new AuthorizationController();
// Act
var result = controller.Register(new RegisterViewModel.Request
{
email = "*****@*****.**",
hash = "pass"
});
// Assert
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result.Data, typeof(JsonResultViewModel));
var jsonResult = (JsonResultViewModel)result.Data;
Assert.IsNotNull(jsonResult);
Assert.IsFalse(jsonResult.is_successful);
}
public async Task ForgotPassword_Should_save_new_token_and_send_email()
{
// arrange
var user = UserBuilder.Create().WithRole(UserRole.Customer).WithEmail(HealthyJuicesConstants.DEFAULT_USER_LOGIN).WithPassword(HealthyJuicesConstants.DEFAULT_USER_PASSWORD).Build(ArrangeRepositoryContext);
var controller = new AuthorizationController(Mediator);
var dto = new ForgotPassword.Command(HealthyJuicesConstants.DEFAULT_USER_LOGIN);
// act
await controller.ForgotPasswordAsync(dto);
// assert
var subject = AssertRepositoryContext.Users.FirstOrDefault();
subject.Should().NotBeNull();
subject.PermissionsToken.Token.Should().NotBeNullOrEmpty();
subject.PermissionsToken.Expiration.Should().BeAfter(DateTime.Now);
subject.PermissionsToken.Expiration.Should().BeBefore(DateTime.Now.AddDays(2));
MailerMock.Verify(mock => mock.SendAsync(It.Is <string>(x => x == HealthyJuicesConstants.DEFAULT_USER_LOGIN), It.IsAny <string>(), It.Is <string>(x => x.Contains(subject.PermissionsToken.Token)), false), Times.Once);
MailerMock.VerifyNoOtherCalls();
}
private static string Signature()
{
if (authParams == null)
{
authParams = AuthorizationController.GetAuthParams();
}
if (String.IsNullOrWhiteSpace(authParams.SecretToken) || String.IsNullOrWhiteSpace(authParams.PublicToken))
{
return("");
}
string signature;
var secretBytes = Encoding.UTF8.GetBytes(authParams.SecretToken);
var valueBytes = Encoding.UTF8.GetBytes(authParams.PublicToken);
using (var hmac = new HMACSHA256(secretBytes))
{
var hash = hmac.ComputeHash(valueBytes);
signature = Convert.ToBase64String(hash);
}
return(signature);
}
private void Form1_Load(object sender, EventArgs e)
{
OptionsMercator repMerc = new OptionsMercator();
OptionsMercator journal = new OptionsMercator();
string repMercValue = repMerc.GetOptionValue("NOP_REP_M")?.ToString();
string journalValue = journal.GetOptionValue("NOP_JOURN")?.ToString();
txtRepMercator.Text = repMercValue?.ToString()?.TrimEnd() ?? "";
txtJournal.Text = journalValue?.ToString()?.TrimEnd() ?? "";
if (DatabaseManager.CheckTableExistence("WEB_API_CREDENTIALS"))
{
AuthParameters ap = AuthorizationController.GetAuthParams();
if (ap != null)
{
txtPublicToken.Text = ap.PublicToken;
txtSecretToken.Text = ap.SecretToken;
txtStoreAddress.Text = ap.StoreAddress;
txtUser.Text = ap.ClientName;
}
}
}
