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)
});
}
}
