private AuthPolicy GetAuthPolicyFromAuthResponsePolicy(AuthorizationResponsePolicy authResponsePolicy)
{
AuthPolicy authPolicy = new AuthPolicy();
List <Location> authPolicyLocations = new List <Location>();
if (authResponsePolicy != null)
{
if (authResponsePolicy.Fences != null && authResponsePolicy.Fences.Any())
{
foreach (DomainPolicy.IFence fence in authResponsePolicy.Fences)
{
if (fence.GetType() == typeof(DomainPolicy.GeoCircleFence))
{
authPolicyLocations.Add(
new Location(
(fence as DomainPolicy.GeoCircleFence).Radius,
(fence as DomainPolicy.GeoCircleFence).Latitude,
(fence as DomainPolicy.GeoCircleFence).Longitude,
(fence as DomainPolicy.GeoCircleFence)?.Name
)
);
}
else
{
Trace.TraceWarning($"A Fence besides GeoCircleFence was present while using legacy functionality. This fence has been skipped from being processed.");
}
}
}
if (authResponsePolicy.Requirement == Requirement.AMOUNT)
{
authPolicy = new AuthPolicy(
authResponsePolicy.Amount,
null,
null,
null,
null,
authPolicyLocations
);
}
else if (authResponsePolicy.Requirement == Requirement.TYPES)
{
bool?requiredKnowledge = authResponsePolicy.KnowledgeRequired;
bool?requiredInherence = authResponsePolicy.InherenceRequired;
bool?requiredPosession = authResponsePolicy.PossessionRequired;
authPolicy = new AuthPolicy(
null,
requiredKnowledge,
requiredInherence,
requiredPosession,
null,
authPolicyLocations
);
}
else if (authResponsePolicy.Requirement == Requirement.COND_GEO)
{
Trace.TraceWarning($"Conditional Geofence cannot be converted to the legacy policy. To utilize new policies please use HandleAdvancedWebhook");
return(null);
}
else
{
authPolicy = new AuthPolicy(
null,
null,
null,
null,
null,
authPolicyLocations
);
}
}
else
{
authPolicy = null;
}
return(authPolicy);
}
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
));
}
