public async Task Check_Access_Level_Sufficient_3() { var assertDatabase = await RfidDatabaseAssert.CreateAsync(); var userRM = Examples.Administrator(); var tagRM = Examples.Tag("test", (int)AccessLevel.Mid, "test"); var accessPoint = Examples.AccessPoint("test", "test", AccessLevel.Low); await RfidHttpClient.RegisterUserAsync(userRM); using (var tokenResponse = await RfidHttpClient.GenerateAuthTokenAsync(userRM)) { var authToken = await AuthTokenHelper.FromHttpResponseMessageAsync(tokenResponse); var token = await authToken.GetTokenAsync(); using (var registerTagResponse = await RfidHttpClient.RegisterTagAsync(tagRM, token)) using (var registerAccessPointResponse = await RfidHttpClient.RegisterAccessPointAsync(accessPoint, token)) using (var checkAccessResponse = await RfidHttpClient.CheckAccessAsync(tagRM.Number, accessPoint.SerialNumber)) { RfidAssert.AssertHttpResponse(checkAccessResponse, System.Net.HttpStatusCode.OK); } } await assertDatabase.AssertCntAsync(userRM, tagRM, accessPoint); }
public async Task Change_Access_Level_When_Not_Authorized() { var assertDatabase = await RfidDatabaseAssert.CreateAsync(); var userRM = Examples.Administrator(); var tagRM = Examples.Tag(); var tagId = 0; await RfidHttpClient.RegisterUserAsync(userRM); using (var authHttpResponse = await RfidHttpClient.GenerateAuthTokenAsync(userRM)) { var authToken = await AuthTokenHelper.FromHttpResponseMessageAsync(authHttpResponse); var token = await authToken.GetTokenAsync(); using (var registerTagHttpResponse = await RfidHttpClient.RegisterTagAsync(tagRM, token)) { RfidAssert.AssertHttpResponse(registerTagHttpResponse, System.Net.HttpStatusCode.OK); tagId = await RfidDatabase.GetTagIdByNumberAsync(tagRM.Number); using (var activateHttpResponse = await RfidHttpClient.ChangeTagAccessLevelAsync(new ChangeTagAccessLevelRequestModel { Id = tagId, AccessLevel = AccessLevel.High }, null)) { RfidAssert.AssertHttpResponse(activateHttpResponse, System.Net.HttpStatusCode.Unauthorized); } } } await assertDatabase.AssertCntAsync(userRM, tagRM); await assertDatabase.AssertStateAsync("[access_control].[Tags]", tagId, new { Id = tagId, IsActive = true, LevelId = (int)AccessLevel.Mid }); }
public async Task Register_When_UnKnown_Access_Point() { var assertDatabase = await RfidDatabaseAssert.CreateAsync(); var userRM = Examples.Administrator(); var accessPointRM = Examples.AccessPoint(); await RfidHttpClient.RegisterUserAsync(userRM); using (var authTokenResponseMessage = await RfidHttpClient.GenerateAuthTokenAsync(userRM)) { var authToken = await AuthTokenHelper.FromHttpResponseMessageAsync(authTokenResponseMessage); var token = await authToken.GetTokenAsync(); using (var httpResponse = await RfidHttpClient.CheckAccessAsync("unknown", accessPointRM.SerialNumber)) { RfidAssert.AssertHttpResponse(httpResponse, System.Net.HttpStatusCode.NotFound); } using (var httpResponse = await RfidHttpClient.RegisterAccessPointAsync(accessPointRM, token)) { RfidAssert.AssertHttpResponse(httpResponse, System.Net.HttpStatusCode.OK); } } await assertDatabase.AssertCntAsync(userRM, accessPointRM, new UnKnownTagMock { Number = "unknown" }); }
public async Task ChangeAccessLevel_When_Not_Authorized() { var assertDatabase = await RfidDatabaseAssert.CreateAsync(); var userRM = Examples.Administrator(); var accessPointRM = Examples.AccessPoint("test", "test", AccessLevel.Low); var accessPointId = 0; await RfidHttpClient.RegisterUserAsync(userRM); using (var authTokenResponse = await RfidHttpClient.GenerateAuthTokenAsync(userRM)) { var authToken = await AuthTokenHelper.FromHttpResponseMessageAsync(authTokenResponse); var token = await authToken.GetTokenAsync(); using (var registerAccessPointResponse = await RfidHttpClient.RegisterAccessPointAsync(accessPointRM, token)) { accessPointId = await RfidDatabase.GetAccessPointIdBySerialNumberAsync(accessPointRM.SerialNumber); using (var activateAccessPointResponse = await RfidHttpClient.ChangeAccessPointAccessLevelAsync(accessPointRM.SerialNumber, AccessLevel.High, "unknown")) { RfidAssert.AssertHttpResponse(activateAccessPointResponse, System.Net.HttpStatusCode.Unauthorized); } } } await assertDatabase.AssertCntAsync(userRM, accessPointRM); await assertDatabase.AssertStateAsync("access_control.AccessPoints", accessPointId, new { Id = accessPointId, LevelId = (int)AccessLevel.Low }); }
public async Task DeActivate_When_Does_Not_Exists() { var assertDatabase = await RfidDatabaseAssert.CreateAsync(); var userRM = Examples.Administrator(); var accessPointRM = Examples.AccessPoint(); var accessPointId = 0; await RfidHttpClient.RegisterUserAsync(userRM); using (var authTokenResponse = await RfidHttpClient.GenerateAuthTokenAsync(userRM)) { var authToken = await AuthTokenHelper.FromHttpResponseMessageAsync(authTokenResponse); var token = await authToken.GetTokenAsync(); using (var registerAccessPointResponse = await RfidHttpClient.RegisterAccessPointAsync(accessPointRM, token)) { accessPointId = await RfidDatabase.GetAccessPointIdBySerialNumberAsync(accessPointRM.SerialNumber); using (var activateAccessPointResponse = await RfidHttpClient.DeActivateAccessPointAsync("unknown", token)) { RfidAssert.AssertHttpResponse(activateAccessPointResponse, System.Net.HttpStatusCode.NotFound); } } } await assertDatabase.AssertCntAsync(userRM, accessPointRM); await assertDatabase.AssertStateAsync("access_control.AccessPoints", accessPointId, new { Id = accessPointId, IsActive = true }); }
public async Task Register_When_User_Already_Exists() { var assertDatabase = await RfidDatabaseAssert.CreateAsync(); var userRM = Examples.Administrator(); var ftagRM = Examples.Tag(); var stagRM = Examples.Tag(Guid.NewGuid(), "test"); await RfidHttpClient.RegisterUserAsync(userRM); using (var httpResponse = await RfidHttpClient.GenerateAuthTokenAsync(userRM)) { var authToken = await AuthTokenHelper.FromHttpResponseMessageAsync(httpResponse); var token = await authToken.GetTokenAsync(); using (var fhttpResponse = await RfidHttpClient.RegisterTagAsync(ftagRM, token)) using (var shttpResponse = await RfidHttpClient.RegisterTagAsync(stagRM, token)) { RfidAssert.AssertHttpResponse(fhttpResponse, System.Net.HttpStatusCode.OK); RfidAssert.AssertHttpResponse(shttpResponse, System.Net.HttpStatusCode.OK); } } await assertDatabase.AssertCntAsync(userRM, ftagRM, stagRM); }
public async Task Delete_When_Not_Authorized() { var assertDatabase = await RfidDatabaseAssert.CreateAsync(); var userRM = Examples.Administrator(); var tagRM = Examples.Tag(); await RfidHttpClient.RegisterUserAsync(userRM); using (var authHttpResponse = await RfidHttpClient.GenerateAuthTokenAsync(userRM)) { var authToken = await AuthTokenHelper.FromHttpResponseMessageAsync(authHttpResponse); var token = await authToken.GetTokenAsync(); using (var registerTagHttpResponse = await RfidHttpClient.RegisterTagAsync(tagRM, token)) { RfidAssert.AssertHttpResponse(registerTagHttpResponse, System.Net.HttpStatusCode.OK); using (var activateHttpResponse = await RfidHttpClient.DeleteTagAsync(tagRM.Number, null)) { RfidAssert.AssertHttpResponse(activateHttpResponse, System.Net.HttpStatusCode.Unauthorized); } } } var tagId = await RfidDatabase.GetTagIdByNumberAsync(tagRM.Number); await assertDatabase.AssertCntAsync(userRM, tagRM); await assertDatabase.AssertStateAsync("[access_control].[Tags]", tagId, new { Id = tagId, IsActive = true, IsDeleted = false }); }
public async Task Get_All_Active_When_When_Several_In_Database() { var assertDatabase = await RfidDatabaseAssert.CreateAsync(); var userRM = Examples.Administrator(); var accessPointRM = Examples.AccessPoint(); await RfidHttpClient.RegisterUserAsync(userRM); using (var authTokenResponseMessage = await RfidHttpClient.GenerateAuthTokenAsync(userRM)) { var authToken = await AuthTokenHelper.FromHttpResponseMessageAsync(authTokenResponseMessage); var token = await authToken.GetTokenAsync(); using (await RfidHttpClient.RegisterAccessPointAsync(Examples.AccessPoint("1"), token)) using (await RfidHttpClient.RegisterAccessPointAsync(Examples.AccessPoint("2"), token)) using (await RfidHttpClient.RegisterAccessPointAsync(Examples.AccessPoint("3"), token)) using (await RfidHttpClient.RegisterAccessPointAsync(Examples.AccessPoint("4"), token)) { var actual = await RfidHttpClient.GetAllActiveAccessPointsAsync(token); Assert.Equal(expected: 4, actual: actual.Count); } } }
public async Task Register_When_Access_Point_Already_Exists() { var assertDatabase = await RfidDatabaseAssert.CreateAsync(); var userRM = Examples.Administrator(); var accessPointRM = Examples.AccessPoint("test1"); await RfidHttpClient.RegisterUserAsync(userRM); using (var authTokenResponseMessage = await RfidHttpClient.GenerateAuthTokenAsync(userRM)) { var authToken = await AuthTokenHelper.FromHttpResponseMessageAsync(authTokenResponseMessage); var token = await authToken.GetTokenAsync(); using (var fhttpResponse = await RfidHttpClient.RegisterAccessPointAsync(accessPointRM, token)) using (var shttpResponse = await RfidHttpClient.RegisterAccessPointAsync(accessPointRM, token)) { RfidAssert.AssertHttpResponse(fhttpResponse, System.Net.HttpStatusCode.OK); await RfidAssert.AssertHttpResponseAsync(shttpResponse, System.Net.HttpStatusCode.BadRequest, (false, CommandStatus.Dublicate)); } } await assertDatabase.AssertCntAsync(userRM, accessPointRM); }
public async Task Delete_When_Does_Not_Exists() { var assertDatabase = await RfidDatabaseAssert.CreateAsync(); var userRM = Examples.Administrator(); var accessPointRM = Examples.AccessPoint(); await RfidHttpClient.RegisterUserAsync(userRM); using (var authTokenResponseMessage = await RfidHttpClient.GenerateAuthTokenAsync(userRM)) { var authToken = await AuthTokenHelper.FromHttpResponseMessageAsync(authTokenResponseMessage); var token = await authToken.GetTokenAsync(); using (var httpResponse = await RfidHttpClient.RegisterAccessPointAsync(accessPointRM, token)) { RfidAssert.AssertHttpResponse(httpResponse, System.Net.HttpStatusCode.OK); } using (var httpResponse = await RfidHttpClient.DeleteAccessPointAsync("unknown", token)) { RfidAssert.AssertHttpResponse(httpResponse, System.Net.HttpStatusCode.NotFound); } } await assertDatabase.AssertCntAsync(userRM, accessPointRM); }
public async Task Check_Access_Level_When_Access_Point_Serial_Number_Does_Not_Exists() { var assertDatabase = await RfidDatabaseAssert.CreateAsync(); var userRM = Examples.Administrator(); var tagRM = Examples.Tag("test", (int)AccessLevel.Mid, "test"); var accessPoint = Examples.AccessPoint("test", "test", AccessLevel.Mid); await RfidHttpClient.RegisterUserAsync(userRM); using (var tokenResponse = await RfidHttpClient.GenerateAuthTokenAsync(userRM)) { var authToken = await AuthTokenHelper.FromHttpResponseMessageAsync(tokenResponse); var token = await authToken.GetTokenAsync(); using (var registerTagResponse = await RfidHttpClient.RegisterTagAsync(tagRM, token)) using (var registerAccessPointResponse = await RfidHttpClient.RegisterAccessPointAsync(accessPoint, token)) using (var checkAccessResponse = await RfidHttpClient.CheckAccessAsync(tagRM.Number, "unknown")) { RfidAssert.AssertHttpResponse(checkAccessResponse, System.Net.HttpStatusCode.NotFound); } } await assertDatabase.AssertCntAsync(userRM, tagRM, accessPoint, Examples.UnKnownAccessPoint("unknown")); }
private void HandleAuthTokenKey(IDBService dbProxy, IEncryption encryption) { if (AuthTokenHelper.IsAuthTokenExits(_httpProxy)) { var userId = AuthTokenHelper.GetUserId(_httpProxy, dbProxy, encryption); var userTempData = _httpProxy.GetTempValue <UserModel>(CommonConst.CommonValue.SESSION_USER_KEY); if (userTempData == null) { ISessionProvider session = new SessionProvider(_httpProxy, dbProxy, _logger); var userData = session.GetValue <UserModel>(CommonConst.CommonValue.SESSION_USER_KEY); if (userData != null && userData.user_id != userId) { throw new Exception("Session user conflict with authtoken"); } if (userData == null) { userData = dbProxy.FirstOrDefault <UserModel>(CommonConst.Collection.USERS, CommonConst.CommonField.USER_ID, userId); if (userData == null) { throw new Exception("User not found for authtoken"); } } _httpProxy.SetTempValue <UserModel>(CommonConst.CommonValue.SESSION_USER_KEY, userData); } } }
protected override Task <HttpResponseMessage> SendAsync ( HttpRequestMessage request, CancellationToken cancellationToken ) { IEnumerable <string> authorizationValue; var hasAutorization = request.Headers.TryGetValues("X-PATRONS-AUTH-TOKEN", out authorizationValue); if (hasAutorization) { var token = authorizationValue.First(); /*----------------------------------------------------------------------------------------- * INSPECT TOKEN TO SEE IF USER EXISTS AND TOKEN HAS NOT EXPIRED * -----------------------------------------------------------------------------------------*/ DateTime timeStampTokenCreated; DateTime timeStampTokenExpires; IWinstarDataModel winstarDataModel = AuthTokenHelper.UnPackAuthToken(token, out timeStampTokenCreated, out timeStampTokenExpires); //IF TOKEN EXPIRES TIMESTAMP IS LESS THAN NOW, ABORT if (timeStampTokenExpires < DateTime.Now) { return(CreateUnauthorizedResponse("Authorization has expired. Please login again.")); } //GET USER IUserModel currentUser = SecurityHelper.GetWinstarPatron(winstarDataModel); //IF USER IS UNKNOWN, THEN ABORT if (currentUser == null) { return(CreateUnauthorizedResponse("User is unknown.")); } //CAPTURE DATA FOR USE IN CONTROLLERS (SEE SecureApiController) ObjectFactory.Configure(x => x.For <IWinstarDataModel>().Singleton().Use(winstarDataModel)); ObjectFactory.Configure(x => x.For <IUserModel>().Singleton().Use(currentUser)); //CONVERT CURRENT USER TO AN AUTHENTICATED USER Thread.CurrentPrincipal = currentUser.ToClaimsPrincipal(); //SET HTTP CONTEXT CURRENT USER TO AUTHENTICATED USER if (HttpContext.Current != null) { HttpContext.Current.User = Thread.CurrentPrincipal; } } return(base.SendAsync(request, cancellationToken) .ContinueWith(task => { return task.Result; })); }
public void Init() { signOutButton.SetActive(true); var btnComponent = signOutButton.GetComponent <SimpleTextButton>(); btnComponent.onClick = () => { AuthTokenHelper.DeleteToken(Constants.LAST_SUCCESS_AUTH_TOKEN); SceneManager.LoadScene("Login"); }; }
private void Start() { if (AuthTokenHelper.LoadToken(Constants.LAST_SUCCESS_AUTH_TOKEN, out var token)) { OnSuccess?.Invoke(token); } else { OnFailed?.Invoke(); } Destroy(this, 0.1F); }
/// <summary> /// CONVERTS USER MODEL TO AUTHENTICATED USER (EXTENDS IUserModel) /// </summary> /// <param name="currentUser"></param> /// <param name="winstarDataModel"></param> /// <returns></returns> public static IAuthenticatedUser ToAuthenticatedUser(this IUserModel currentUser, IWinstarDataModel winstarDataModel) { var token = AuthTokenHelper.GenerateAuthToken(winstarDataModel); var autehnticatedUser = new AuthenticatedUser { CurrentUser = currentUser, Token = token }; return(autehnticatedUser); }
public async Task Update_When_All_Properties_Provided() { var assertDatabase = await RfidDatabaseAssert.CreateAsync(); var userRM = Examples.Administrator(); var accessPointRM = Examples.AccessPoint(); var accessPointId = 0; var updatedDescription = $"{Guid.NewGuid()}"; await RfidHttpClient.RegisterUserAsync(userRM); using (var authTokenResponseMessage = await RfidHttpClient.GenerateAuthTokenAsync(userRM)) { var authToken = await AuthTokenHelper.FromHttpResponseMessageAsync(authTokenResponseMessage); var token = await authToken.GetTokenAsync(); using (var httpResponse = await RfidHttpClient.RegisterAccessPointAsync(accessPointRM, token)) { RfidAssert.AssertHttpResponse(httpResponse, System.Net.HttpStatusCode.OK); } accessPointId = await RfidDatabase.GetAccessPointIdBySerialNumberAsync(accessPointRM.SerialNumber); var updateRm = new UpdateAccessPointRequestModel { Id = accessPointId, AccessLevel = AccessLevel.High, Description = updatedDescription, Direction = AccessPointDirectionType.Exit, }; using (var httpResponse = await RfidHttpClient.UpdateAccessPointAsync(updateRm, token)) { RfidAssert.AssertHttpResponse(httpResponse, System.Net.HttpStatusCode.OK); } } await assertDatabase.AssertCntAsync(userRM, accessPointRM); await assertDatabase.AssertStateAsync("access_control.AccessPoints", accessPointId, new { Id = accessPointId, LevelId = (int)AccessLevel.High, DirectionId = (int)AccessPointDirectionType.Exit, SerialNumber = accessPointRM.SerialNumber, Description = updatedDescription }); }
private void SuccessAuthorization(AuthToken token, Action <AuthToken> success = null) { Debug.Log($"SUCCESS Token = {token}"); if (rememberMeChkBox.isOn) { AuthTokenHelper.SaveToken(Constants.LAST_SUCCESS_AUTH_TOKEN, token); } else { AuthTokenHelper.DeleteToken(Constants.LAST_SUCCESS_AUTH_TOKEN); } success?.Invoke(token); OnSuccessfulLogin?.Invoke(token); }
private void HandleSession(HttpContext context) { if (AuthTokenHelper.IsAuthTokenExits(_httpProxy)) { // if there is auth token no cookies set in the response. return; } if (context.Request.Cookies[CommonConst.CommonValue.SESSION_COOKIE] == null) { CreateUpdateSessionCookie(context); } else { CreateUpdateSessionCookie(context, context.Request.Cookies[CommonConst.CommonValue.SESSION_COOKIE]); } }
public async Task Activate_When_One_Active_And_One_Not_Active_Tag() { var assertDatabase = await RfidDatabaseAssert.CreateAsync(); var userRM = Examples.Administrator(); var ftagRM = Examples.Tag(); var stagRM = Examples.Tag(Guid.NewGuid(), "test"); await RfidHttpClient.RegisterUserAsync(userRM); using (var authHttpResponse = await RfidHttpClient.GenerateAuthTokenAsync(userRM)) { var authToken = await AuthTokenHelper.FromHttpResponseMessageAsync(authHttpResponse); var token = await authToken.GetTokenAsync(); using (var fregisterTagHttpResponse = await RfidHttpClient.RegisterTagAsync(ftagRM, token)) using (var sregisterTagHttpResponse = await RfidHttpClient.RegisterTagAsync(stagRM, token)) { RfidAssert.AssertHttpResponse(fregisterTagHttpResponse, System.Net.HttpStatusCode.OK); RfidAssert.AssertHttpResponse(sregisterTagHttpResponse, System.Net.HttpStatusCode.OK); await RfidDatabase.DeActivateTagAsync(ftagRM.Number); using (var factivateHttpResponse = await RfidHttpClient.ActivateTagAsync(ftagRM.Number, token)) using (var sactivateHttpResponse = await RfidHttpClient.ActivateTagAsync(stagRM.Number, token)) { RfidAssert.AssertHttpResponse(factivateHttpResponse, System.Net.HttpStatusCode.OK); RfidAssert.AssertHttpResponse(sactivateHttpResponse, System.Net.HttpStatusCode.OK); } } } var ftagId = await RfidDatabase.GetTagIdByNumberAsync(ftagRM.Number); var stagId = await RfidDatabase.GetTagIdByNumberAsync(stagRM.Number); await assertDatabase.AssertCntAsync(userRM, ftagRM, stagRM); await assertDatabase.AssertStateAsync("access_control.Tags", ftagId, new { Id = ftagId, IsActive = true }); await assertDatabase.AssertStateAsync("access_control.Tags", stagId, new { Id = stagId, IsActive = true }); }
public async Task Activate_When_Several() { var assertDatabase = await RfidDatabaseAssert.CreateAsync(); var userRM = Examples.Administrator(); var faccessPointRM = Examples.AccessPoint("test1"); var saccessPointRM = Examples.AccessPoint("test2"); var faccessPointId = 0; var saccessPointId = 0; await RfidHttpClient.RegisterUserAsync(userRM); using (var authTokenResponse = await RfidHttpClient.GenerateAuthTokenAsync(userRM)) { var authToken = await AuthTokenHelper.FromHttpResponseMessageAsync(authTokenResponse); var token = await authToken.GetTokenAsync(); using (var fregisterAccessPointResponse = await RfidHttpClient.RegisterAccessPointAsync(faccessPointRM, token)) using (var sregisterAccessPointResponse = await RfidHttpClient.RegisterAccessPointAsync(saccessPointRM, token)) { faccessPointId = await RfidDatabase.GetAccessPointIdBySerialNumberAsync(faccessPointRM.SerialNumber); saccessPointId = await RfidDatabase.GetAccessPointIdBySerialNumberAsync(saccessPointRM.SerialNumber); await RfidDatabase.DeActivateAccessPointAsync(faccessPointId); await RfidDatabase.DeActivateAccessPointAsync(saccessPointId); using (var activateAccessPointResponse = await RfidHttpClient.ActivateAccessPointAsync(faccessPointRM.SerialNumber, token)) { RfidAssert.AssertHttpResponse(activateAccessPointResponse, System.Net.HttpStatusCode.OK); } } } await assertDatabase.AssertCntAsync(userRM, faccessPointRM, saccessPointRM); await assertDatabase.AssertStateAsync("access_control.AccessPoints", faccessPointId, new { Id = faccessPointId, IsActive = true }); await assertDatabase.AssertStateAsync("access_control.AccessPoints", saccessPointId, new { Id = saccessPointId, IsActive = false }); }
public static ActionContext GetActionContext(params Claim[] claims) { var authData = new AuthTokenHelper(); var groups = claims.Where(c => c.Type == ClaimTypes.Groups).Select(c => c.Value).ToArray(); var headerDictionary = new HeaderDictionary { { "Authorization", $"Bearer {authData.GetUserToken(null, groups)}" } }; var response = new Mock <HttpResponse>(); response.SetupGet(r => r.Headers).Returns(headerDictionary); var claimsPrincipal = new ClaimsPrincipal(new ClaimsIdentity(authData.GetUserClaims(groups))); var httpContext = new Mock <HttpContext>(); httpContext.SetupGet(a => a.Response).Returns(response.Object); httpContext.Setup(a => a.User).Returns(claimsPrincipal); var serviceCollectionMock = new Mock <IServiceCollection>(); var services = new ServiceCollection().AddOptions() .AddAuthenticationCore(o => { o.DefaultScheme = "simple"; o.AddScheme("simple", s => s.HandlerType = typeof(FakeAuthenticationHandler)); }); httpContext.SetupGet(a => a.RequestServices).Returns(services.BuildServiceProvider()); var actionContext = new ActionContext { HttpContext = httpContext.Object, RouteData = new RouteData(), ActionDescriptor = new ControllerActionDescriptor() }; return(actionContext); }
public async Task Change_Access_Level_When_Tag_Already_Has_The_Same_Access_level() { var assertDatabase = await RfidDatabaseAssert.CreateAsync(); var userRM = Examples.Administrator(); var tagRM = Examples.Tag(); var tagId = 0; await RfidHttpClient.RegisterUserAsync(userRM); using (var authHttpResponse = await RfidHttpClient.GenerateAuthTokenAsync(userRM)) { var authToken = await AuthTokenHelper.FromHttpResponseMessageAsync(authHttpResponse); var token = await authToken.GetTokenAsync(); using (var registerTagHttpResponse = await RfidHttpClient.RegisterTagAsync(tagRM, token)) { RfidAssert.AssertHttpResponse(registerTagHttpResponse, System.Net.HttpStatusCode.OK); tagId = await RfidDatabase.GetTagIdByNumberAsync(tagRM.Number); using (var factivateHttpResponse = await RfidHttpClient.ChangeTagAccessLevelAsync(new ChangeTagAccessLevelRequestModel { Id = tagId, AccessLevel = AccessLevel.Low }, token)) using (var sactivateHttpResponse = await RfidHttpClient.ChangeTagAccessLevelAsync(new ChangeTagAccessLevelRequestModel { Id = tagId, AccessLevel = AccessLevel.Low }, token)) { RfidAssert.AssertHttpResponse(factivateHttpResponse, System.Net.HttpStatusCode.OK); RfidAssert.AssertHttpResponse(sactivateHttpResponse, System.Net.HttpStatusCode.OK); } } } tagId = await RfidDatabase.GetTagIdByNumberAsync(tagRM.Number); await assertDatabase.AssertCntAsync(userRM, tagRM); await assertDatabase.AssertStateAsync("access_control.Tags", tagId, new { Id = tagId, IsActive = true, LevelId = (int)AccessLevel.Low }); }
public async Task Update_When_User_Changed() { var assertDatabase = await RfidDatabaseAssert.CreateAsync(); var userRM = Examples.Administrator(); var tagRM = Examples.Tag(); var tagId = 0; var tagNewUsername = "******"; var tagUpdateRM = (UpdateTagRequestModel)null; await RfidHttpClient.RegisterUserAsync(userRM); using (var httpResponse = await RfidHttpClient.GenerateAuthTokenAsync(userRM)) { var authToken = await AuthTokenHelper.FromHttpResponseMessageAsync(httpResponse); var token = await authToken.GetTokenAsync(); using (var tagHttpResponse = await RfidHttpClient.RegisterTagAsync(tagRM, token)) { RfidAssert.AssertHttpResponse(tagHttpResponse, System.Net.HttpStatusCode.OK); } tagId = await RfidDatabase.GetTagIdByNumberAsync(tagRM.Number); tagUpdateRM = Examples.TagUpdate(tagId, tagNewUsername); using (var tagHttpResponse = await RfidHttpClient.UpdateTagAsync(tagUpdateRM, token)) { RfidAssert.AssertHttpResponse(tagHttpResponse, System.Net.HttpStatusCode.OK); } } await assertDatabase.AssertCntAsync(userRM, tagRM, tagUpdateRM); var expectedUserId = await RfidDatabase.GetTagUserIdByUserNameAsync(tagNewUsername); await assertDatabase.AssertStateAsync("access_control.Tags", tagId, new { UserId = expectedUserId }); }
public async Task Register_When_Invalid(String number, int accessLevel, String userName) { var assertDatabase = await RfidDatabaseAssert.CreateAsync(); var userRM = Examples.Administrator(); var tagRM = Examples.Tag(number, accessLevel, userName); await RfidHttpClient.RegisterUserAsync(userRM); using (var httpResponse = await RfidHttpClient.GenerateAuthTokenAsync(userRM)) { var authToken = await AuthTokenHelper.FromHttpResponseMessageAsync(httpResponse); var token = await authToken.GetTokenAsync(); using (var tagHttpResponse = await RfidHttpClient.RegisterTagAsync(tagRM, token)) { RfidAssert.AssertHttpResponse(tagHttpResponse, System.Net.HttpStatusCode.BadRequest); } } await assertDatabase.AssertCntAsync(userRM); }
public async Task Register_When_New_Tag() { var assertDatabase = await RfidDatabaseAssert.CreateAsync(); var userRM = Examples.Administrator(); var tagRM = Examples.Tag(); await RfidHttpClient.RegisterUserAsync(userRM); using (var httpResponse = await RfidHttpClient.GenerateAuthTokenAsync(userRM)) { var authToken = await AuthTokenHelper.FromHttpResponseMessageAsync(httpResponse); var token = await authToken.GetTokenAsync(); using (var tagHttpResponse = await RfidHttpClient.RegisterTagAsync(tagRM, token)) { RfidAssert.AssertHttpResponse(tagHttpResponse, System.Net.HttpStatusCode.OK); } } await assertDatabase.AssertCntAsync(userRM, tagRM); }
public async Task Register_When_Invalid_Data(String serialNumber, String description, int accessLevel) { var assertDatabase = await RfidDatabaseAssert.CreateAsync(); var userRM = Examples.Administrator(); var accessPointRM = Examples.AccessPoint(serialNumber, description, (AccessLevel)accessLevel); await RfidHttpClient.RegisterUserAsync(userRM); using (var authTokenResponseMessage = await RfidHttpClient.GenerateAuthTokenAsync(userRM)) { var authToken = await AuthTokenHelper.FromHttpResponseMessageAsync(authTokenResponseMessage); var token = await authToken.GetTokenAsync(); using (var httpResponse = await RfidHttpClient.RegisterAccessPointAsync(accessPointRM, token)) { RfidAssert.AssertHttpResponse(httpResponse, System.Net.HttpStatusCode.BadRequest); } } await assertDatabase.AssertCntAsync(userRM); }
public async Task Change_Access_Level_When_Tag_Does_Not_Exists() { var assertDatabase = await RfidDatabaseAssert.CreateAsync(); var userRM = Examples.Administrator(); await RfidHttpClient.RegisterUserAsync(userRM); using (var authHttpResponse = await RfidHttpClient.GenerateAuthTokenAsync(userRM)) { var authToken = await AuthTokenHelper.FromHttpResponseMessageAsync(authHttpResponse); var token = await authToken.GetTokenAsync(); using (var activateHttpResponse = await RfidHttpClient.ChangeTagAccessLevelAsync(new ChangeTagAccessLevelRequestModel { Id = 0, AccessLevel = AccessLevel.High }, token)) { RfidAssert.AssertHttpResponse(activateHttpResponse, System.Net.HttpStatusCode.NotFound); } } await assertDatabase.AssertCntAsync(userRM); }
/// <summary> /// GetDataFromAzure_AuthAAD function to get data from azure sql using AzureAD Authentication /// </summary> public static async Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequestMessage httpRequestMessage, ILogger log) { log.LogInformation($"GetDataFromAzure_AuthAAD Function:HTTP trigger function processed request at : { DateTime.Now}"); DataSet publishMetadta = new DataSet(); string errormessage = string.Empty; try { //get the content from httpRequestMessage var jsonContent = await httpRequestMessage.Content.ReadAsStringAsync(); //Get the service bus message values from httpRequestMessage MessageModel messageModel = JsonConvert.DeserializeObject <MessageModel>(jsonContent); //Get the Configuration values from Function app Configuration ConfigurationModel configurationModel = new ConfigurationModel(); //Validating message values from httprequestMessage if (ModelValidation.ValidateMessageModel(messageModel, ref errormessage)) { log.LogInformation($"Service bus Message values returned from the HttpRequestMessage body: {messageModel}"); log.LogInformation($"r_object_id:{messageModel.r_object_id}"); log.LogInformation($"lifecyclestage:{messageModel.lifecyclestage}"); var configurationJSON = ConfigurationManager.AppSettings[Constants.CONFIGURATION_SETTINGS]; configurationModel = JsonConvert.DeserializeObject <ConfigurationModel>(configurationJSON); //Get the Azure SQL connection string value based on the lifecyclestage if (messageModel.lifecyclestage == Constants.WIP) { configurationModel.connStrAzure = ConfigurationManager.ConnectionStrings[Constants.WIP_SQLCONNECTIONSTRING].ConnectionString; } else if (messageModel.lifecyclestage == Constants.STAGING) { configurationModel.connStrAzure = ConfigurationManager.ConnectionStrings[Constants.STAGING_SQLCONNECTIONSTRING].ConnectionString; } else if (messageModel.lifecyclestage == Constants.ACTIVE) { configurationModel.connStrAzure = ConfigurationManager.ConnectionStrings[Constants.ACTIVE_SQLCONNECTIONSTRING].ConnectionString; } else { log.LogError($"Please provide valid lifecyclestage name: {messageModel.lifecyclestage}"); return(new HttpResponseMessage(HttpStatusCode.BadRequest) { Content = new StringContent($"Please provide valid lifecyclestage name : {messageModel.lifecyclestage}", Encoding.UTF8, Constants.JSON) }); } //Validating configuration values if (ModelValidation.ValidateConfigurationModel(configurationModel, ref errormessage)) { log.LogInformation($"Configuration values returned from,function app configuration app settings: {configurationModel}"); //Get access token for Azure SQL var accessToken = await AuthTokenHelper.GetSqlTokenAsync(configurationModel.TenantId, configurationModel.SqlEndPointURI); publishMetadta = GetDataFromAzureSql(configurationModel, messageModel, accessToken, log); if (publishMetadta != null) { log.LogInformation($"Table count: { publishMetadta.Tables.Count}"); string publishMetadtaJSON = JsonConvert.SerializeObject(publishMetadta, Formatting.Indented); //return dataset in the response log.LogInformation($"GetDataFromAzure_AuthAAD Function successfully processed."); return(new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent(publishMetadtaJSON, Encoding.UTF8, Constants.JSON) }); } else { log.LogError($"Content not available in azure sql for the given r_object_id : {messageModel.r_object_id}"); return(new HttpResponseMessage(HttpStatusCode.InternalServerError) { Content = new StringContent($"Content not available in azure sql for the given r_object_id : {messageModel.r_object_id}", Encoding.UTF8, Constants.JSON) }); } } else { //configuration values has empty or null return badrequest response log.LogError($"{errormessage}"); return(new HttpResponseMessage(HttpStatusCode.BadRequest) { Content = new StringContent($"{errormessage}", Encoding.UTF8, Constants.JSON) }); } } else { //Message model values has empty or null return badrequest response log.LogError($"{errormessage}"); return(new HttpResponseMessage(HttpStatusCode.BadRequest) { Content = new StringContent($"{errormessage}", Encoding.UTF8, Constants.JSON) }); } } catch (Exception ex) { log.LogError($"Exception occurred in GetDataFromAzure_Function,Error : {ex.Message}, Details:{ex.InnerException}"); publishMetadta = null; return(new HttpResponseMessage(HttpStatusCode.InternalServerError) { Content = new StringContent(ex.Message, Encoding.UTF8, Constants.JSON) }); } }