public void Constructor_ShouldSetProperties_WithNullAuthMethodInsight()
{
var requestingEntity = new EntityIdentifier(EntityType.Directory, Guid.NewGuid());
var serviceId = Guid.NewGuid();
var authorizationRequestId = Guid.NewGuid();
var devicePins = new[] { "1", "2" };
var o = new ServiceV3AuthsGetResponse(
requestingEntity,
serviceId,
"userhash",
"orghash",
"userpush",
authorizationRequestId,
true,
"deviceId",
devicePins,
null,
null,
null,
null,
null
);
Assert.AreSame(requestingEntity, o.RequestingEntity);
Assert.AreEqual(serviceId, o.ServiceId);
Assert.AreEqual("userhash", o.ServiceUserHash);
Assert.AreEqual("orghash", o.OrganizationUserHash);
Assert.AreEqual("userpush", o.UserPushId);
Assert.AreEqual(authorizationRequestId, o.AuthorizationRequestId);
Assert.AreEqual(true, o.Response);
Assert.AreEqual("deviceId", o.DeviceId);
Assert.AreSame(devicePins, o.DevicePins);
Assert.AreEqual(null, o.AuthPolicy);
Assert.AreEqual(null, o.AuthMethods);
}
public AdvancedAuthorizationResponse GetAdvancedAuthorizationResponse(string authorizationRequestId)
{
ServiceV3AuthsGetResponse response = _transport.ServiceV3AuthsGet(Guid.Parse(authorizationRequestId), _serviceId);
if (response != null)
{
return(ParseAuthsGetToAdvancedAuthorizationPackage(response));
}
else
{
return(null);
}
}
public void Constructor_ShouldSetProperties()
{
var requestingEntity = new EntityIdentifier(EntityType.Directory, Guid.NewGuid());
var serviceId = Guid.NewGuid();
var authorizationRequestId = Guid.NewGuid();
var devicePins = new[] { "1", "2" };
var authPolicy = new AuthPolicy.JWEAuthPolicy
{
Requirement = "types",
Amount = 3,
Types = new List <string> {
"inherence"
}
};
var authMethods = new AuthPolicy.AuthMethod[7]
{
CreateAuthTransportMethod("wearables", false, false, true, true, null, null, null),
CreateAuthTransportMethod("geofencing", null, true, true, true, null, null, null),
CreateAuthTransportMethod("locations", true, true, true, true, true, false, false),
CreateAuthTransportMethod("pin_code", true, true, true, true, true, null, null),
CreateAuthTransportMethod("circle_code", false, false, true, true, null, null, null),
CreateAuthTransportMethod("face", false, false, true, true, null, null, null),
CreateAuthTransportMethod("fingerprint", false, false, true, true, null, null, null)
};
var o = new ServiceV3AuthsGetResponse(
requestingEntity,
serviceId,
"userhash",
"orghash",
"userpush",
authorizationRequestId,
true,
"deviceId",
devicePins,
null,
null,
null,
authPolicy,
authMethods
);
Assert.AreSame(requestingEntity, o.RequestingEntity);
Assert.AreEqual(serviceId, o.ServiceId);
Assert.AreEqual("userhash", o.ServiceUserHash);
Assert.AreEqual("orghash", o.OrganizationUserHash);
Assert.AreEqual("userpush", o.UserPushId);
Assert.AreEqual(authorizationRequestId, o.AuthorizationRequestId);
Assert.AreEqual(true, o.Response);
Assert.AreEqual("deviceId", o.DeviceId);
Assert.AreSame(devicePins, o.DevicePins);
Assert.AreEqual("inherence", o.AuthPolicy.Types[0]);
Assert.AreEqual(3, o.AuthPolicy.Amount);
Assert.AreEqual("types", o.AuthPolicy.Requirement);
var authMethod = o.AuthMethods[2];
Assert.AreEqual("locations", authMethod.Method);
Assert.AreEqual(true, authMethod.Set);
Assert.AreEqual(true, authMethod.Active);
Assert.AreEqual(true, authMethod.Allowed);
Assert.AreEqual(true, authMethod.Supported);
Assert.AreEqual(true, authMethod.UserRequired);
Assert.AreEqual(false, authMethod.Passed);
Assert.AreEqual(false, authMethod.Error);
}
private List <AuthMethod> GetAuthMethods(ServiceV3AuthsGetResponse authResponse)
{
var authMethods = new List <AuthMethod>();
if (authResponse.AuthMethods != null)
{
foreach (var transportMethod in authResponse.AuthMethods)
{
string methodType = transportMethod.Method.ToUpper();
AuthMethodType authMethodType;
if (methodType == "PIN_CODE")
{
authMethodType = AuthMethodType.PIN_CODE;
}
else if (methodType == "CIRCLE_CODE")
{
authMethodType = AuthMethodType.CIRCLE_CODE;
}
else if (methodType == "GEOFENCING")
{
authMethodType = AuthMethodType.GEOFENCING;
}
else if (methodType == "LOCATIONS")
{
authMethodType = AuthMethodType.LOCATIONS;
}
else if (methodType == "WEARABLES")
{
authMethodType = AuthMethodType.WEARABLES;
}
else if (methodType == "FINGERPRINT")
{
authMethodType = AuthMethodType.FINGERPRINT;
}
else if (methodType == "FACE")
{
authMethodType = AuthMethodType.FACE;
}
else
{
authMethodType = AuthMethodType.OTHER;
}
authMethods.Add(
new AuthMethod
(
authMethodType,
transportMethod.Set,
transportMethod.Active,
transportMethod.Allowed,
transportMethod.Supported,
transportMethod.UserRequired,
transportMethod.Passed,
transportMethod.Error
)
);
}
}
else
{
authMethods = null;
}
return(authMethods);
}
private AdvancedAuthorizationResponse ParseAuthsGetToAdvancedAuthorizationPackage(ServiceV3AuthsGetResponse response)
{
AuthorizationResponseType?type;
switch (response.Type)
{
case null:
type = null;
break;
case "AUTHORIZED":
type = AuthorizationResponseType.AUTHORIZED;
break;
case "DENIED":
type = AuthorizationResponseType.DENIED;
break;
case "FAILED":
type = AuthorizationResponseType.FAILED;
break;
default:
type = AuthorizationResponseType.OTHER;
break;
}
AuthorizationResponseReason?reason;
switch (response.Reason)
{
case null:
reason = null;
break;
case "APPROVED":
reason = AuthorizationResponseReason.APPROVED;
break;
case "DISAPPROVED":
reason = AuthorizationResponseReason.DISAPPROVED;
break;
case "FRAUDULENT":
reason = AuthorizationResponseReason.FRAUDULENT;
break;
case "POLICY":
reason = AuthorizationResponseReason.POLICY;
break;
case "PERMISSION":
reason = AuthorizationResponseReason.PERMISSION;
break;
case "AUTHENTICATION":
reason = AuthorizationResponseReason.AUTHENTICATION;
break;
case "CONFIGURATION":
reason = AuthorizationResponseReason.CONFIGURATION;
break;
case "BUSY_LOCAL":
reason = AuthorizationResponseReason.BUSY_LOCAL;
break;
case "SENSOR":
reason = AuthorizationResponseReason.SENSOR;
break;
default:
reason = AuthorizationResponseReason.OTHER;
break;
}
AuthorizationResponsePolicy authResponse = null;
if (response.AuthPolicy != null)
{
List <DomainPolicy.IFence> fences = new List <DomainPolicy.IFence>();
if (response.AuthPolicy.Geofences != null)
{
foreach (IFence fence in response.AuthPolicy.Geofences)
{
fences.Add(fence.FromTransport());
}
}
bool?knowledgeRequired = null;
bool?possessionRequired = null;
bool?inherenceRequired = null;
if (response.AuthPolicy.Types != null && response.AuthPolicy.Types.Count > 0)
{
knowledgeRequired = response.AuthPolicy.Types.Contains("KNOWLEDGE", StringComparer.OrdinalIgnoreCase);
inherenceRequired = response.AuthPolicy.Types.Contains("INHERENCE", StringComparer.OrdinalIgnoreCase);
possessionRequired = response.AuthPolicy.Types.Contains("POSSESSION", StringComparer.OrdinalIgnoreCase);
}
Requirement?requirement = null;
if (response.AuthPolicy.Requirement != null)
{
Requirement parsedRequirement;
if (Enum.TryParse(response.AuthPolicy.Requirement, true, out parsedRequirement))
{
requirement = parsedRequirement;
}
else
{
requirement = Requirement.OTHER;
}
}
authResponse = new AuthorizationResponsePolicy(
requirement: requirement,
amount: response.AuthPolicy.Amount,
fences: fences,
knowledgeRequired: knowledgeRequired,
inherenceRequired: inherenceRequired,
possessionRequired: possessionRequired
);
}
List <AuthMethod> authMethods = GetAuthMethods(response);
return(new AdvancedAuthorizationResponse(
response.AuthorizationRequestId.ToString("D"),
response.Response,
response.ServiceUserHash,
response.OrganizationUserHash,
response.UserPushId,
response.DeviceId,
new List <string>(response.DevicePins),
type,
reason,
response.DenialReason,
reason == AuthorizationResponseReason.FRAUDULENT,
authResponse,
authMethods
));
}
