-
-
+
+
-
Date
{{ formatDate(session.createdAt) }}
+
-
+
+
+
Email
+
+
+
![]()
+
+
+
+
+
+
+
+
+
+
+
+ Approve
+
+
+
+ Reject
+
+
+
+ This verification will be approved and the user can proceed.
+
+
+ This verification will be rejected and the user will not be able to proceed.
+
+
+
+
+
+
+
+
+ Cancel
+
+
+ {{ isSubmittingReviewDecision ? "Submitting..." : "Submit" }}
+
+
+
@@ -885,7 +1382,12 @@ const FaicalAuthenticationError = {
4: "Failed to perform face check due to the pose of the face",
5: "Failed due to problems in the extraction of the facial pattern",
6: "Duplicate document was used",
- 7: 'Failed, because the date of birth could not be read correctly from the document'
+ 7: 'Failed, because the date of birth could not be read correctly from the document',
+ 8: "Failed, because document issuing country is restricted",
+ 9: "Failed, because nationality is restricted",
+ 10: "Failed, because document issuing country is not allowed",
+ 11: "Failed, because nationality is not allowed",
+ 12: "Failed, because jurisdiction restriction requires manual review",
};
const ZkpVerificationResultEnum = {
@@ -1138,6 +1640,41 @@ export default {
(a, b) => new Date(a.createdAt) - new Date(b.createdAt)
);
},
+ normalizedRiskFlags() {
+ const flags = this.session?.riskFlags || [];
+ if (!Array.isArray(flags)) return [];
+
+ return flags.map((flag, index) => this.normalizeRiskFlag(flag, index));
+ },
+ hasRiskFlags() {
+ return this.normalizedRiskFlags.length > 0;
+ },
+ riskFlagCount() {
+ return this.normalizedRiskFlags.length;
+ },
+ normalizedManualDecisions() {
+ const decisions = this.session?.manualDecisions || [];
+ if (!Array.isArray(decisions)) return [];
+
+ return decisions
+ .map((decision, index) => ({
+ ...decision,
+ key: `${decision.action || "DECISION"}-${decision.decidedAt || index}`,
+ action: decision.action || "",
+ reasonCode: decision.reasonCode || "",
+ comments: decision.comments || "",
+ decidedBy: decision.decidedBy || "",
+ decidedAt: decision.decidedAt || "",
+ }))
+ .sort((a, b) => {
+ const aTime = Date.parse(a.decidedAt) || 0;
+ const bTime = Date.parse(b.decidedAt) || 0;
+ return bTime - aTime;
+ });
+ },
+ hasManualDecisions() {
+ return this.normalizedManualDecisions.length > 0;
+ },
},
data() {
return {
@@ -1153,6 +1690,19 @@ export default {
sessionId: "",
env: "prod",
session: {},
+ showManualReviewModal: false,
+ isSubmittingReviewDecision: false,
+ reviewDecision: "REJECTED",
+ reviewReasonCode: "",
+ reviewComments: "",
+ reviewReasonOptions: [
+ { label: "Suspicious document", value: "SUSPICIOUS_DOCUMENT" },
+ { label: "Identity could not be verified", value: "IDENTITY_NOT_VERIFIED" },
+ { label: "Biometric mismatch", value: "BIOMETRIC_MISMATCH" },
+ { label: "Restricted jurisdiction", value: "RESTRICTED_JURISDICTION" },
+ { label: "Fraud / duplicate identity", value: "FRAUD_DUPLICATE_IDENTITY" },
+ { label: "Other", value: "OTHER" },
+ ],
popupHeader: "",
popupImage: "",
deviceDetails: {
@@ -1278,12 +1828,187 @@ export default {
});
},
methods: {
- ...mapActions("mainStore", ["fetchSessionsDetailsById"]),
+ ...mapActions("mainStore", ["fetchSessionsDetailsById", "submitManualReviewDecision"]),
formatDate(date) {
if (!date) return "-";
const d = new Date(date);
return d.toLocaleString(); // Customize formatting if needed
},
+ openManualReviewModal() {
+ this.showManualReviewModal = true;
+ },
+ closeManualReviewModal() {
+ this.showManualReviewModal = false;
+ },
+ async submitReviewDecision() {
+ if (this.reviewDecision === "REJECTED" && !this.reviewReasonCode) {
+ this.notifyErr("Please select a reason for rejection.");
+ return;
+ }
+
+ const decisionSessionId = this.session?.latestSessionId || this.session?.sessionId || this.sessionId;
+ const reasonCode = this.reviewDecision === "REJECTED"
+ ? this.reviewReasonCode
+ : "MANUAL_REVIEW_CLEARED";
+
+ try {
+ this.isSubmittingReviewDecision = true;
+ await this.submitManualReviewDecision({
+ sessionId: decisionSessionId,
+ action: this.reviewDecision,
+ reasonCode,
+ comments: this.reviewComments,
+ });
+
+ this.session = await this.fetchSessionsDetailsById({
+ sessionId: this.sessionId,
+ env: this.env,
+ businessId: this.isValidBusinessID ? this.companyId : undefined,
+ }) || {};
+
+ this.notifySuccess("Manual review decision submitted successfully.");
+ this.closeManualReviewModal();
+ } catch (e) {
+ this.notifyErr(e.message || "Unable to submit manual review decision.");
+ } finally {
+ this.isSubmittingReviewDecision = false;
+ }
+ },
+ normalizeRiskFlag(flag, index) {
+ const code = flag?.code || flag?.reason || "RISK_FLAG";
+ const severity = flag?.severity || "MEDIUM";
+ const metadata = flag?.metadata || {};
+ const metaLine = this.getRiskMetaLine(code, metadata);
+
+ return {
+ ...flag,
+ key: `${code}-${index}`,
+ code,
+ severity,
+ source: flag?.source || flag?.associatedStep || flag?.step || "",
+ associatedStep: flag?.associatedStep || flag?.step || "",
+ title: this.formatRiskCode(code),
+ description: flag?.message || this.getRiskFlagDescription(code),
+ metadata,
+ metaLine,
+ };
+ },
+ formatRiskCode(code) {
+ const labels = {
+ JURISDICTION_RESTRICTION_MATCH: "Jurisdiction restriction",
+ RESTRICTED_NATIONALITY: "Jurisdiction restriction",
+ RESTRICTED_ISSUING_COUNTRY: "Jurisdiction restriction",
+ LOW_OCR_CONFIDENCE: "Low OCR confidence",
+ BIOMETRIC_MATCH_BELOW_THRESHOLD: "Biometric match below threshold",
+ BORDERLINE_LIVENESS: "Borderline liveness",
+ FACIAL_SPOOF_SUSPECTED: "Facial spoof suspected",
+ DUPLICATE_FACE_DETECTED: "Duplicate face detected",
+ DOCUMENT_EXPIRING_SOON: "Document expiring soon",
+ NATIONALITY_MISMATCH: "Nationality mismatch",
+ ZKP_PROOF_WARNING: "Age verification warning",
+ };
+
+ if (labels[code]) return labels[code];
+ return String(code)
+ .toLowerCase()
+ .split("_")
+ .filter(Boolean)
+ .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+ .join(" ");
+ },
+ getRiskFlagDescription(code) {
+ const descriptions = {
+ JURISDICTION_RESTRICTION_MATCH:
+ "Document issuing country or nationality matches a configured manual review policy.",
+ RESTRICTED_NATIONALITY:
+ "Document nationality matches a configured manual review policy.",
+ RESTRICTED_ISSUING_COUNTRY:
+ "Document issuing country matches a configured manual review policy.",
+ LOW_OCR_CONFIDENCE:
+ "Document field confidence is below the configured threshold.",
+ BIOMETRIC_MATCH_BELOW_THRESHOLD:
+ "Face similarity score is below the auto-approval threshold.",
+ BORDERLINE_LIVENESS:
+ "Liveness confidence is inconclusive and requires manual inspection.",
+ FACIAL_SPOOF_SUSPECTED:
+ "Potential presentation attack was detected with soft certainty.",
+ DUPLICATE_FACE_DETECTED:
+ "A matching face or document may already exist for another user.",
+ DOCUMENT_EXPIRING_SOON:
+ "The identity document is valid but close to expiry.",
+ NATIONALITY_MISMATCH:
+ "Document issuing country differs from declared nationality.",
+ ZKP_PROOF_WARNING:
+ "Age verification produced a non-fatal warning.",
+ };
+
+ return descriptions[code] || "This verification triggered a risk flag that requires review.";
+ },
+ getRiskMetaLine(code, metadata) {
+ const country = metadata.matchedCountry || metadata.evaluatedNationality || metadata.evaluatedIssuingCountry;
+ const field = metadata.matchedField;
+ const score = metadata.score || metadata.faceSimilarity || metadata.faceSimilarityScore;
+
+ if (score) {
+ const numericScore = Number(String(score).replace("%", ""));
+ if (!Number.isNaN(numericScore)) {
+ return `Face similarity: ${numericScore > 1 ? numericScore : Math.round(numericScore * 1000) / 10}%`;
+ }
+ return `Face similarity: ${score}`;
+ }
+ if (country && field) return `${this.formatRiskCode(field)}: ${country}`;
+ if (country) return `Matched country: ${country}`;
+ if (metadata.threshold) return `Threshold: ${metadata.threshold}`;
+ return "";
+ },
+ formatSeverity(severity) {
+ return String(severity || "MEDIUM").toLowerCase().replace(/^./, (char) => char.toUpperCase());
+ },
+ riskSeverityClass(severity) {
+ const value = String(severity || "MEDIUM").toLowerCase();
+ return {
+ "badge-outline-danger": value === "high",
+ "badge-outline-warning": value === "medium",
+ "badge-outline-secondary": value === "low",
+ };
+ },
+ riskFlagCardClass(severity) {
+ const value = String(severity || "MEDIUM").toLowerCase();
+ return {
+ "border-danger": value === "high",
+ "border-warning": value === "medium",
+ "border-secondary": value === "low",
+ };
+ },
+ riskFlagIconClass(severity) {
+ const value = String(severity || "MEDIUM").toLowerCase();
+ return value === "high" ? "fa fa-exclamation-circle" : "fa fa-exclamation-triangle";
+ },
+ decisionStatusLabel(action) {
+ const labels = {
+ MANUAL_REVIEW: "Manual Review",
+ APPROVED: "Approved",
+ Success: "Approved",
+ REJECTED: "Rejected",
+ };
+
+ if (labels[action]) return labels[action];
+ return this.formatRiskCode(action || "Decision");
+ },
+ decisionStatusClass(action) {
+ if (action === "REJECTED") return "badge-outline-danger";
+ if (action === "APPROVED" || action === "Success") return "badge-outline-success";
+ return "badge-outline-warning";
+ },
+ formatDecisionReason(reasonCode) {
+ const reason = this.reviewReasonOptions.find((item) => item.value === reasonCode);
+ if (reason) return reason.label;
+
+ return this.formatRiskCode(reasonCode);
+ },
+ isManualReviewCleared(decision) {
+ return decision?.reasonCode === "MANUAL_REVIEW_CLEARED";
+ },
applySessionFailureToTimeline() {
if (this.session?.status !== "Failed") return;
diff --git a/src/views/playground/WidgetConfig/Index.vue b/src/views/playground/WidgetConfig/Index.vue
index b62b509..01cc544 100644
--- a/src/views/playground/WidgetConfig/Index.vue
+++ b/src/views/playground/WidgetConfig/Index.vue
@@ -131,6 +131,216 @@ ul {
padding: 6px 8px;
}
+.jurisdiction-panel {
+ background: #fff;
+ min-width: 0;
+}
+
+.jurisdiction-description {
+ color: #6c757d;
+ font-size: 80%;
+ line-height: 1.45;
+ margin: 4px 0 22px;
+}
+
+.jurisdiction-label {
+ color: #374151;
+ font-weight: 700;
+ margin-bottom: 10px;
+}
+
+.jurisdiction-config-grid {
+ display: grid;
+ gap: 24px;
+ grid-template-columns: minmax(300px, 5fr) minmax(0, 7fr);
+}
+
+.jurisdiction-column {
+ min-width: 0;
+}
+
+.strategy-options {
+ display: grid;
+ gap: 12px;
+ grid-template-columns: repeat(2, minmax(0, 1fr));
+}
+
+.strategy-card {
+ align-items: flex-start;
+ border: 1px solid #e5e7eb;
+ border-radius: 8px;
+ cursor: pointer;
+ display: flex;
+ margin: 0;
+ min-height: 120px;
+ padding: 16px;
+ transition: border-color 0.15s ease, box-shadow 0.15s ease;
+ width: 100%;
+}
+
+.strategy-card.active {
+ border-color: #8ab9ff;
+ box-shadow: 0 0 0 1px #8ab9ff;
+}
+
+.strategy-radio {
+ flex: 0 0 auto;
+ margin-right: 14px;
+ margin-top: 2px;
+}
+
+.strategy-title {
+ color: #374151;
+ font-weight: 700;
+ margin-bottom: 18px;
+}
+
+.strategy-help {
+ color: #6b7280;
+ font-size: 0.92rem;
+ line-height: 1.35;
+}
+
+.country-chip-row {
+ display: flex;
+ flex-wrap: nowrap;
+ gap: 12px;
+ margin-bottom: 12px;
+ min-height: 58px;
+ overflow-x: auto;
+ padding: 1px 0 8px;
+ scrollbar-width: thin;
+ width: 100%;
+}
+
+.country-chip {
+ align-items: center;
+ border: 1px solid #e5e7eb;
+ border-radius: 8px;
+ color: #374151;
+ display: inline-flex;
+ flex: 0 0 auto;
+ font-weight: 600;
+ min-height: 44px;
+ padding: 10px 12px;
+}
+
+.country-chip-flag {
+ font-size: 1.45rem;
+ line-height: 1;
+ margin-right: 10px;
+}
+
+.country-chip-remove {
+ color: #374151;
+ cursor: pointer;
+ font-size: 1.2rem;
+ line-height: 1;
+ margin-left: 18px;
+}
+
+.country-dropdown-item {
+ align-items: center;
+ display: flex;
+ justify-content: space-between;
+ width: 100%;
+}
+
+.jurisdiction-country-search-wrap {
+ position: relative;
+}
+
+.jurisdiction-country-search-hint {
+ color: #7c8798;
+ font-size: 10px;
+ left: 44px;
+ line-height: 1;
+ pointer-events: none;
+ position: absolute;
+ top: 7px;
+ z-index: 2;
+}
+
+::v-deep(.jurisdiction-country-select.v-text-field--outlined > .v-input__control > .v-input__slot) {
+ background: #f8fafc;
+ border-radius: 8px;
+ min-height: 44px;
+ transition: background-color 0.15s ease, box-shadow 0.15s ease;
+}
+
+::v-deep(.jurisdiction-country-select.v-text-field--outlined:not(.v-input--is-focused) fieldset) {
+ border-color: #e2e8f0;
+}
+
+::v-deep(.jurisdiction-country-select.v-text-field--outlined.v-input--is-focused fieldset) {
+ border-color: #94a3b8;
+ border-width: 1px;
+}
+
+::v-deep(.jurisdiction-country-select.v-input--is-focused > .v-input__control > .v-input__slot) {
+ background: #fff;
+ box-shadow: 0 0 0 3px rgba(148, 163, 184, 0.14);
+}
+
+::v-deep(.jurisdiction-country-select:not(.v-input--is-focused):hover fieldset) {
+ border-color: #cbd5e1;
+}
+
+::v-deep(.jurisdiction-country-select .v-input__prepend-inner),
+::v-deep(.jurisdiction-country-select .v-input__append-inner) {
+ align-self: center;
+ margin-top: 0;
+}
+
+::v-deep(.jurisdiction-country-select .v-input__prepend-inner) {
+ padding-left: 2px;
+ padding-right: 10px;
+}
+
+::v-deep(.jurisdiction-country-select input) {
+ color: #374151;
+ font-size: 13px;
+ line-height: 20px;
+ margin-top: 11px;
+ max-height: 32px;
+}
+
+::v-deep(.jurisdiction-country-select .v-icon) {
+ color: #7c8798 !important;
+}
+
+.jurisdiction-action-column {
+ grid-column: 1 / -1;
+ max-width: 440px;
+}
+
+.jurisdiction-action-help {
+ color: #6b7280;
+ font-size: 0.86rem;
+ line-height: 1.4;
+ margin-top: 8px;
+}
+
+@media (max-width: 991.98px) {
+ .jurisdiction-config-grid {
+ grid-template-columns: 1fr;
+ }
+
+ .jurisdiction-action-column {
+ grid-column: auto;
+ }
+}
+
+@media (max-width: 575.98px) {
+ .strategy-options {
+ grid-template-columns: 1fr;
+ }
+
+ .strategy-card {
+ min-height: auto;
+ }
+}
+
/* .zkbadge {
background-color: lightblue;
margin-left: 3px;
@@ -372,6 +582,119 @@ ul {
Attempts
{{ session ? session.retryAttempts : "-" }}
-
+
+
@@ -508,6 +787,81 @@
+
+
+
+
+ Decision History
+
+
+
+
+
+
+
+
+
+
+ Status
+
+ {{ decisionStatusLabel(decision.action) }}
+
+
+
+ Decided By
+
+ {{ decision.decidedBy || "-" }}
+
+
+ Time
+
+ {{ formatDate(decision.decidedAt) }}
+
+
+
+
+ {{ isManualReviewCleared(decision) ? "Review Result" : "Reason" }}
+
+
+
+ {{ formatDecisionReason(decision.reasonCode) }}
+
+
+
+
+ Comment
+
+ {{ decision.comments }}
+
+
+
+ + Review the risk flags below and decide to approve or reject this verification. +
+ +
+
+
+ Review Required
+
+
+ {{ riskFlagCount }} risk {{ riskFlagCount === 1 ? "flag" : "flags" }}
+
+
+
+ + This verification passed automated checks but requires manual review before it can be approved. +
+ +
+
+
+
+
+ {{ flag.title }}
+
+ {{ formatSeverity(flag.severity) }}
+
+
+ {{ flag.description }}
+
+ {{ flag.metaLine }}
+
+ Take decision
+
+
+
+
+ {{ reason.label }}
+
+
+
+ Common reasons
+
+
+
+
+ {{ reviewComments.length }} / 300
+
+
+
+ {{ widgetConfigUI.jurisdictionRules.label }}
+
+
+ {{ widgetConfigUI.jurisdictionRules.description }}
+
+ {{ widgetConfigUI.jurisdictionRules.secondaryDescription }}
+
+
+
+
+
+ Enforcement Strategy
+
+
+
+
+
+ Target Countries ({{ selectedJurisdictionCountries.length }})
+
+
+
+ {{ country.flag }}
+ {{ country.text }} ({{ country.value }})
+
+ ×
+
+
+
+
+
+ Select or search country...
+
+
+
+ mdi-magnify
+
+
+
+
+
+
+
+ {{ item.flag }}
+ {{ item.text }} ({{ item.value }})
+
+
+ mdi-check
+
+
+
+
+
+ Action on Match
+
+ {{ selectedJurisdictionActionDescription }}
+
+
@@ -421,6 +744,10 @@ import { isAccessDeniedError } from '../../../utils/accessDenied';
import MarketplaceList from '../../../components/MarketplaceList.vue';
import HFBeta from '../../../components/element/HFBeta.vue';
import config from '../../../config';
+import countries from 'i18n-iso-countries';
+import enLocale from 'i18n-iso-countries/langs/en.json';
+
+countries.registerLocale(enLocale);
export default {
name: "WidgetConfig",
@@ -495,7 +822,7 @@ export default {
},
immediate: true
- }
+ },
},
computed: {
...mapState({
@@ -523,6 +850,39 @@ export default {
});
return options
},
+ countryOptions() {
+ return Object.entries(countries.getNames('en', { select: 'alias' }))
+ .map(([alpha2, name]) => {
+ const alpha3 = countries.alpha2ToAlpha3(alpha2)
+ const displayName = alpha2 === 'AE' ? 'United Arab Emirates' : name
+
+ return {
+ value: alpha3,
+ text: displayName,
+ displayText: `${displayName} (${alpha3})`,
+ flag: this.countryFlagFromAlpha2(alpha2),
+ }
+ })
+ .filter(country => !!country.value)
+ .sort((a, b) => a.text.localeCompare(b.text))
+ },
+ selectedJurisdictionCountries() {
+ const selected = this.widgetConfigTemp.jurisdictionRules?.countries || []
+ return selected.map(code => {
+ const option = this.countryOptions.find(country => country.value === code)
+ return option || {
+ value: code,
+ text: code,
+ displayText: code,
+ flag: this.countryFlagFromAlpha3(code),
+ }
+ })
+ },
+ selectedJurisdictionActionDescription() {
+ const action = this.widgetConfigTemp.jurisdictionRules?.actionOnRestriction
+ const option = this.jurisdictionActionOptions.find(option => option.value === action)
+ return option?.description || ''
+ },
},
async mounted() {
@@ -550,6 +910,7 @@ export default {
if (typeof this.widgetConfigTemp.isMobileAssistedVerification !== 'boolean') {
this.$set(this.widgetConfigTemp, 'isMobileAssistedVerification', true)
}
+ this.ensureJurisdictionRules()
this.trustedIssuersList = [...this.getMarketPlaceApps];
this.appId = this.$route.params.appId;
@@ -659,6 +1020,11 @@ export default {
label: "Mobile-Assisted Verification",
description: "When enabled, users who start verification on a desktop will continue ID verification on their mobile device by scanning a QR code. This improves verification success rates, provides a better user experience, and strengthens proof of possession. Disable to allow the entire verification process to be completed on the desktop."
},
+ jurisdictionRules: {
+ label: "Enable Jurisdictional Restrictions",
+ description: "Enforce compliance policies by restricting access based on document issuing country and nationality.",
+ secondaryDescription: "Choose to either block high-risk regions (Blocklist) or restrict onboarding to specific permitted territories (Allowlist)."
+ },
},
fullPage: true,
isLoading: false,
@@ -698,6 +1064,12 @@ export default {
isVaultEnabled: true,
isEmailNotificationEnabled: true,
isMobileAssistedVerification: true,
+ jurisdictionRules: {
+ enabled: false,
+ strategy: 'BLOCKLIST',
+ countries: [],
+ actionOnRestriction: 'HARD_REJECT',
+ },
issuerDID: "",
issuerVerificationMethodId: "",
},
@@ -726,6 +1098,30 @@ export default {
text: "Government ID"
},
],
+ jurisdictionStrategyOptions: [
+ {
+ value: 'BLOCKLIST',
+ text: 'Blocklist',
+ description: 'Block selected countries',
+ },
+ {
+ value: 'ALLOWLIST',
+ text: 'Allowlist',
+ description: 'Only permit selected countries',
+ },
+ ],
+ jurisdictionActionOptions: [
+ {
+ value: 'HARD_REJECT',
+ text: 'Hard Reject (Stop Onboarding)',
+ description: 'Rejects the session immediately if the user matches the configured jurisdiction rule.',
+ },
+ {
+ value: 'MANUAL_REVIEW',
+ text: 'Manual Review',
+ description: 'Allows the user to complete verification, then sends the session to the manual review queue.',
+ },
+ ],
}
},
@@ -742,6 +1138,84 @@ export default {
this.notifyErr(message)
},
+ defaultJurisdictionRules() {
+ return {
+ enabled: false,
+ strategy: 'BLOCKLIST',
+ countries: [],
+ actionOnRestriction: 'HARD_REJECT',
+ }
+ },
+ ensureJurisdictionRules() {
+ const defaults = this.defaultJurisdictionRules()
+
+ if (!this.widgetConfigTemp.jurisdictionRules) {
+ this.$set(this.widgetConfigTemp, 'jurisdictionRules', defaults)
+ return
+ }
+
+ const existingRules = this.widgetConfigTemp.jurisdictionRules
+ Object.keys(defaults).forEach(key => {
+ if (!Object.prototype.hasOwnProperty.call(existingRules, key)) {
+ this.$set(existingRules, key, defaults[key])
+ }
+ })
+
+ existingRules.enabled = existingRules.enabled === true
+ existingRules.strategy = ['BLOCKLIST', 'ALLOWLIST'].includes(existingRules.strategy)
+ ? existingRules.strategy
+ : defaults.strategy
+ existingRules.countries = Array.isArray(existingRules.countries)
+ ? existingRules.countries.map(country => String(country).toUpperCase()).filter(country => !!country)
+ : []
+ existingRules.actionOnRestriction = ['HARD_REJECT', 'MANUAL_REVIEW'].includes(existingRules.actionOnRestriction)
+ ? existingRules.actionOnRestriction
+ : defaults.actionOnRestriction
+ },
+ countryFlagFromAlpha2(alpha2) {
+ if (!alpha2 || alpha2.length !== 2) return ''
+ return alpha2
+ .toUpperCase()
+ .replace(/./g, char => String.fromCodePoint(127397 + char.charCodeAt()))
+ },
+ countryFlagFromAlpha3(alpha3) {
+ const alpha2 = countries.alpha3ToAlpha2(alpha3)
+ return this.countryFlagFromAlpha2(alpha2)
+ },
+ removeJurisdictionCountry(countryCode) {
+ const selectedCountries = this.widgetConfigTemp.jurisdictionRules.countries || []
+ this.widgetConfigTemp.jurisdictionRules.countries = selectedCountries.filter(country => country !== countryCode)
+ },
+ isJurisdictionCountrySelected(countryCode) {
+ return (this.widgetConfigTemp.jurisdictionRules.countries || []).includes(countryCode)
+ },
+ validateJurisdictionRules() {
+ this.ensureJurisdictionRules()
+ const rules = this.widgetConfigTemp.jurisdictionRules
+
+ if (!rules.enabled) {
+ rules.countries = []
+ rules.actionOnRestriction = rules.actionOnRestriction || 'HARD_REJECT'
+ return
+ }
+
+ if (!['BLOCKLIST', 'ALLOWLIST'].includes(rules.strategy)) {
+ throw new Error('Kindly select a jurisdiction enforcement strategy')
+ }
+
+ if (!Array.isArray(rules.countries) || rules.countries.length === 0) {
+ throw new Error('Kindly select at least one target country for jurisdiction restrictions')
+ }
+
+ const invalidCountries = rules.countries.filter(country => !/^[A-Z]{3}$/.test(country) || !countries.alpha3ToAlpha2(country))
+ if (invalidCountries.length > 0) {
+ throw new Error(`Invalid country code(s): ${invalidCountries.join(', ')}`)
+ }
+
+ if (!['HARD_REJECT', 'MANUAL_REVIEW'].includes(rules.actionOnRestriction)) {
+ throw new Error('Kindly select a jurisdiction action on match')
+ }
+ },
selectedServiceEventHandler(event) {
// Guard: ignore entries with no issuerDid
@@ -865,6 +1339,7 @@ export default {
this.widgetConfigTemp.isWidgetLogin = this.widgetConfigTemp.isWidgetLogin !== false
this.widgetConfigTemp.isMobileAssistedVerification = this.widgetConfigTemp.isMobileAssistedVerification !== false
this.migratedocumentUploadMode()
+ this.validateJurisdictionRules()
if (!this.widgetConfigTemp.issuerDID) {
throw new Error('Issuer DID is required')
}
@@ -924,6 +1399,7 @@ export default {
await this.createAppsWidgetConfig()
if (this.widgetConfig) {
this.widgetConfigTemp = JSON.parse(JSON.stringify(this.widgetConfig))
+ this.ensureJurisdictionRules()
}
this.isLoading = false
@@ -947,6 +1423,7 @@ export default {
if (this.widgetConfig) {
// this.widgetConfigTemp = { ...this.widgetConfig }
this.widgetConfigTemp.trustedIssuer = this.widgetConfigTemp.issuerDID ? true : false;
+ this.ensureJurisdictionRules()
}
this.isLoading = false
} catch (e) {