Tutorial: Pre-create inquiries for iOS

1
from flask import Flask, request, jsonify
2
from flask_cors import CORS
3
import requests
4
import os
5
6
app = Flask(__name__)
7
CORS(app)
8
9
PERSONA_API_KEY = os.environ.get('PERSONA_API_KEY')
10
PERSONA_API_URL = 'https://withpersona.com/api/v1'
11
PERSONA_VERSION = '2025-10-27'
12
INQUIRY_TEMPLATE_ID = 'itmpl_XXXXXXXXXXXXX'  # Replace with your template ID
13
14
def _get_persona_req_headers():
15
    return {
16
        'Authorization': f'Bearer {PERSONA_API_KEY}',
17
        'Content-Type': 'application/json',
18
        'Persona-Version': PERSONA_VERSION
19
    }
20
21
@app.route('/api/inquiries/get-or-create', methods=['POST'])
22
def get_or_create_inquiry():
23
    # In production, get user ID from your auth system
24
    user_id = 'usr_ABC123'
25
26
    # In production, fetch user data from your database
27
    user_data = {
28
        'name_first': 'Alexander',
29
        'name_last': 'Sample',
30
        'birthdate': '1977-08-31'
31
    }
32
33
    # Check for existing incomplete inquiry
34
    existing = find_incomplete_inquiry(user_id)
35
36
    if existing:
37
        inquiry_id = existing['id']
38
        status = existing['attributes']['status']
39
40
        print(f"Found existing inquiry {inquiry_id} with status: {status}")
41
42
        if status == 'pending':
43
            print("Inquiry is pending, generating session token to resume")
44
            session_token = create_session_token(inquiry_id)
45
            return jsonify({
46
                'inquiry_id': inquiry_id,
47
                'session_token': session_token
48
            })
49
        else:
50
            print("Inquiry is created, resuming without session token")
51
            return jsonify({
52
                'inquiry_id': inquiry_id,
53
                'session_token': None
54
            })
55
    else:
56
        print("No incomplete inquiry found, creating new one")
57
        inquiry_id = create_inquiry(user_id, user_data)
58
        return jsonify({
59
            'inquiry_id': inquiry_id,
60
            'session_token': None
61
        })
62
63
def find_incomplete_inquiry(user_id):
64
    """Find existing inquiry with status 'created' or 'pending'"""
65
    try:
66
        response = requests.get(
67
            f"{PERSONA_API_URL}/inquiries",
68
            params={
69
                'filter[reference-id]': user_id,
70
                'filter[status]': 'created,pending',
71
                'page[size]': 1
72
            },
73
            headers=_get_persona_req_headers()
74
        )
75
        response.raise_for_status()
76
        inquiries = response.json().get('data', [])
77
        return inquiries[0] if inquiries else None
78
    except Exception as e:
79
        print(f"Error finding inquiry: {e}")
80
        return None
81
82
def create_inquiry(user_id, user_data):
83
    """Create new inquiry via Persona API"""
84
    payload = {
85
        'data': {
86
            'attributes': {
87
                'inquiry-template-id': INQUIRY_TEMPLATE_ID,
88
                'reference-id': user_id,
89
                'fields': user_data
90
            }
91
        }
92
    }
93
94
    response = requests.post(
95
        f"{PERSONA_API_URL}/inquiries",
96
        json=payload,
97
        headers=_get_persona_req_headers()
98
    )
99
    response.raise_for_status()
100
    return response.json()['data']['id']
101
102
def create_session_token(inquiry_id):
103
    """Generate session token for resuming pending inquiry"""
104
    try:
105
        response = requests.post(
106
            f"{PERSONA_API_URL}/inquiries/{inquiry_id}/resume",
107
            json={'meta': {}},
108
            headers=_get_persona_req_headers()
109
        )
110
        response.raise_for_status()
111
        meta = response.json().get('meta', {})
112
        return meta.get('session-token')
113
    except Exception as e:
114
        print(f"Error creating session token: {e}")
115
        return None
116
117
if __name__ == '__main__':
118
    app.run(port=8000, debug=True)

flask
flask-cors
requests

1
import Foundation
2
import Combine
3
import Persona2
4
5
@MainActor
6
class OnboardingViewModel: ObservableObject {
7
    @Published var isLoading = false
8
    @Published var errorMessage: String?
9
    @Published var showPersonaFlow = false
10
    @Published var showSuccess = false
11
    @Published var inquiryId: String?
12
    @Published var sessionToken: String?
13
    @Published var completedInquiryId: String?
14
    @Published var completedInquiryStatus: String?
15
16
    // Replace with your backend URL
17
    // For iOS Simulator: use http://localhost:8000
18
    // For physical device: use your computer's IP address (e.g., http://192.168.1.100:8000)
19
    private let backendURL = "http://localhost:8000/api/inquiries/get-or-create"
20
21
    func startVerification() async {
22
        isLoading = true
23
        errorMessage = nil
24
25
        guard let url = URL(string: backendURL) else {
26
            errorMessage = "Invalid server URL"
27
            isLoading = false
28
            return
29
        }
30
31
        var request = URLRequest(url: url)
32
        request.httpMethod = "POST"
33
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
34
35
        do {
36
            let (data, _) = try await URLSession.shared.data(for: request)
37
            let response = try JSONDecoder().decode(InquiryResponse.self, from: data)
38
39
            inquiryId = response.inquiryId
40
            sessionToken = response.sessionToken
41
            showPersonaFlow = true
42
        } catch {
43
            errorMessage = "Failed to verify: \(error.localizedDescription)"
44
        }
45
46
        isLoading = false
47
    }
48
49
    func handleCompletion(inquiryId: String, status: String) {
50
        print("Verification completed. Inquiry ID: \(inquiryId), Status: \(status)")
51
        completedInquiryId = inquiryId
52
        completedInquiryStatus = status
53
        showPersonaFlow = false
54
        showSuccess = true
55
    }
56
57
    func handleCancellation() {
58
        print("User cancelled verification")
59
        showPersonaFlow = false
60
    }
61
62
    func handleEvent(_ event: InquiryEvent) {
63
        switch event {
64
        case .start(let startEvent):
65
            print("Inquiry started: \(startEvent.inquiryId) with session token: \(startEvent.sessionToken)")
66
        case .pageChange(let pageChangeEvent):
67
            print("Page changed to: \(pageChangeEvent.name)")
68
        default:
69
            print("Inquiry event: \(event)")
70
        }
71
    }
72
73
    func handleError(_ error: Error) {
74
        print("Verification error: \(error.localizedDescription)")
75
        showPersonaFlow = false
76
        errorMessage = "Verification failed. Please try again."
77
    }
78
}
79
80
struct InquiryResponse: Codable {
81
    let inquiryId: String
82
    let sessionToken: String?
83
84
    enum CodingKeys: String, CodingKey {
85
        case inquiryId = "inquiry_id"
86
        case sessionToken = "session_token"
87
    }
88
}

1
func startVerification() {
2
    …
3
    // Call backend API
4
    var request = URLRequest(url: url)
5
    request.httpMethod = "POST"
6
    …
7
8
    // Parse response
9
    if let inquiryId = json["inquiry_id"] as? String {
10
        self.inquiryId = inquiryId
11
        self.sessionToken = json["session_token"] as? String
12
        self.showPersonaFlow = true
13
    }
14
}

1
    @Published var isLoading = false
2
    @Published var errorMessage: String?
3
    @Published var showPersonaFlow = false
4
    @Published var showSuccess = false
5
    @Published var inquiryId: String?
6
    @Published var sessionToken: String?
7
    @Published var completedInquiryId: String?
8
    @Published var completedInquiryStatus: String?

1
import SwiftUI
2
import Persona2
3
4
struct ContentView: View {
5
    @StateObject private var viewModel = OnboardingViewModel()
6
7
    var body: some View {
8
        if viewModel.showSuccess {
9
            FinishedView(
10
                inquiryId: viewModel.completedInquiryId ?? "",
11
                status: viewModel.completedInquiryStatus ?? ""
12
            )
13
        } else {
14
            OnboardingView(viewModel: viewModel)
15
        }
16
    }
17
}
18
19
struct ContentView_Previews: PreviewProvider {
20
    static var previews: some View {
21
        ContentView()
22
    }
23
}

1
import SwiftUI
2
3
struct OnboardingView: View {
4
    @ObservedObject var viewModel: OnboardingViewModel
5
6
    var body: some View {
7
        VStack(spacing: 0) {
8
            VStack(spacing: 20) {
9
                Text("Pawsona")
10
                    .font(Font.title2)
11
12
                Spacer()
13
14
                Text("Welcome, Alexander! 🐕")
15
                    .font(.title)
16
                    .fontWeight(.bold)
17
                    .foregroundColor(.primary)
18
19
                Text("Before you can start walking dogs, we need to verify your identity. This helps ensure the safety of pet owners and walkers like you.")
20
                    .font(.body)
21
                    .foregroundColor(.secondary)
22
                    .multilineTextAlignment(.center)
23
                    .fixedSize(horizontal: false, vertical: true)
24
25
                VStack(alignment: .leading, spacing: 12) {
26
                    Text("Your Information")
27
                        .font(.headline)
28
                        .foregroundColor(.primary)
29
30
                    InfoRow(label: "Name:", value: "Alexander Sample")
31
                    InfoRow(label: "Birthdate:", value: "August 31, 1977")
32
                }
33
                .frame(maxWidth: .infinity, alignment: .leading)
34
                .padding()
35
                .background(Color(UIColor.systemBackground))
36
                .cornerRadius(8)
37
                .overlay(
38
                    RoundedRectangle(cornerRadius: 8)
39
                        .stroke(Color(UIColor.separator), lineWidth: 1)
40
                )
41
42
                if let errorMessage = viewModel.errorMessage {
43
                    Text(errorMessage)
44
                        .font(.subheadline)
45
                        .foregroundColor(.white)
46
                        .padding()
47
                        .frame(maxWidth: .infinity)
48
                        .background(Color.red.opacity(0.8))
49
                        .cornerRadius(8)
50
                }
51
52
                Spacer()
53
54
                Button(action: {
55
                    Task {
56
                        await viewModel.startVerification()
57
                    }
58
                }) {
59
                    if viewModel.isLoading {
60
                        ProgressView()
61
                            .progressViewStyle(CircularProgressViewStyle(tint: .white))
62
                            .frame(maxWidth: .infinity)
63
                    } else {
64
                        Text("Start Verifying")
65
                            .fontWeight(.semibold)
66
                            .frame(maxWidth: .infinity)
67
                    }
68
                }
69
                .frame(height: 50)
70
                .background(viewModel.isLoading ? Color.gray : Color.blue)
71
                .foregroundColor(.white)
72
                .cornerRadius(8)
73
                .disabled(viewModel.isLoading)
74
            }
75
            .padding(20)
76
            .frame(maxWidth: .infinity, maxHeight: .infinity)
77
        }
78
        .background(
79
            PersonaFlowPresenter(
80
                isPresented: $viewModel.showPersonaFlow,
81
                inquiryId: viewModel.inquiryId ?? "",
82
                sessionToken: viewModel.sessionToken,
83
                onComplete: { inquiryId, status in
84
                    viewModel.handleCompletion(inquiryId: inquiryId, status: status)
85
                },
86
                onCancel: {
87
                    viewModel.handleCancellation()
88
                },
89
                onEvent: { event in
90
                    viewModel.handleEvent(event)
91
                },
92
                onError: { error in
93
                    viewModel.handleError(error)
94
                }
95
            )
96
        )
97
    }
98
}
99
100
struct InfoRow: View {
101
    let label: String
102
    let value: String
103
104
    var body: some View {
105
        HStack {
106
            Text(label)
107
                .fontWeight(.semibold)
108
                .foregroundColor(.primary)
109
            Text(value)
110
                .foregroundColor(.secondary)
111
        }
112
    }
113
}

1
Button(action: { viewModel.startVerification() }) {
2
    if viewModel.isLoading {
3
        ProgressView()
4
    } else {
5
        Text("Start Verifying")
6
    }
7
}

1
        .background(
2
            PersonaFlowPresenter(
3
                isPresented: $viewModel.showPersonaFlow,
4
                ...

1
// UIKit bridge for the Persona iOS SDK
2
import SwiftUI
3
import Persona2
4
5
struct PersonaFlowPresenter: UIViewControllerRepresentable {
6
    @Binding var isPresented: Bool
7
    let inquiryId: String
8
    let sessionToken: String?
9
    let onComplete: (String, String) -> Void
10
    let onCancel: () -> Void
11
    let onEvent: (InquiryEvent) -> Void
12
    let onError: (Error) -> Void
13
14
    func makeCoordinator() -> Coordinator {
15
        Coordinator(
16
            onComplete: onComplete,
17
            onCancel: onCancel,
18
            onEvent: onEvent,
19
            onError: onError
20
        )
21
    }
22
23
    func makeUIViewController(context: Context) -> UIViewController {
24
        let viewController = UIViewController()
25
        viewController.view.backgroundColor = .clear
26
        return viewController
27
    }
28
29
    func updateUIViewController(_ uiViewController: UIViewController, context: Context) {
30
        // Only present once - prevent re-presenting if SwiftUI re-renders
31
        guard isPresented && uiViewController.presentedViewController == nil else { return }
32
33
        let config = InquiryConfiguration(
34
            inquiryId: inquiryId,
35
            sessionToken: sessionToken
36
        )
37
38
        let inquiry = Inquiry(config: config, delegate: context.coordinator)
39
        DispatchQueue.main.async {
40
            inquiry.start(from: uiViewController)
41
        }
42
    }
43
44
    // MARK: - Coordinator (InquiryDelegate)
45
46
    @MainActor
47
    class Coordinator: NSObject, InquiryDelegate {
48
        let onComplete: (String, String) -> Void
49
        let onCancel: () -> Void
50
        let onEvent: (InquiryEvent) -> Void
51
        let onError: (Error) -> Void
52
53
        init(onComplete: @escaping (String, String) -> Void,
54
             onCancel: @escaping () -> Void,
55
             onEvent: @escaping (InquiryEvent) -> Void,
56
             onError: @escaping (Error) -> Void) {
57
            self.onComplete = onComplete
58
            self.onCancel = onCancel
59
            self.onEvent = onEvent
60
            self.onError = onError
61
        }
62
63
        func inquiryComplete(inquiryId: String, status: String, fields: [String : InquiryField]) {
64
            onComplete(inquiryId, status)
65
        }
66
67
        func inquiryCanceled(inquiryId: String?, sessionToken: String?) {
68
            onCancel()
69
        }
70
71
        func inquiryEventOccurred(event: InquiryEvent) {
72
            onEvent(event)
73
        }
74
75
        func inquiryError(_ error: Error) {
76
            onError(error)
77
        }
78
    }
79
}

1
        let config = InquiryConfiguration(
2
            inquiryId: inquiryId,
3
            sessionToken: sessionToken
4
        )
5
6
        let inquiry = Inquiry(config: config, delegate: context.coordinator)
7
8
        DispatchQueue.main.async {
9
            inquiry.start(from: uiViewController)
10
        }

1
class Coordinator: NSObject, InquiryDelegate {
2
        …
3
        func inquiryComplete(inquiryId: String, status: String, fields: [String : InquiryField]) {
4
            onComplete(inquiryId, status)
5
        }
6
7
        func inquiryCanceled(inquiryId: String?, sessionToken: String?) {
8
            onCancel()
9
        }
10
11
        func inquiryEventOccurred(event: InquiryEvent) {
12
            onEvent(event)
13
        }
14
15
        func inquiryError(_ error: Error) {
16
            onError(error)
17
        }
18
}

1
import SwiftUI
2
3
struct FinishedView: View {
4
    let inquiryId: String
5
    let status: String
6
7
    var body: some View {
8
        VStack(spacing: 20) {
9
            Text("Pawsona")
10
                .font(Font.title2)
11
12
            Spacer()
13
14
            Text("✔️")
15
                .font(.system(size: 60))
16
17
            Text("Verification Submitted")
18
                .font(.title)
19
                .fontWeight(.bold)
20
                .foregroundColor(.primary)
21
                .multilineTextAlignment(.center)
22
23
            Text("Your verification is being processed.")
24
                .font(.body)
25
                .foregroundColor(.secondary)
26
                .multilineTextAlignment(.center)
27
28
            Spacer()
29
30
            // Debug info
31
            VStack(alignment: .leading, spacing: 8) {
32
                HStack {
33
                    Text("Status:")
34
                        .fontWeight(.semibold)
35
                    Text(status)
36
                        .foregroundColor(.secondary)
37
                }
38
39
                HStack(alignment: .top) {
40
                    Text("Inquiry ID:")
41
                        .fontWeight(.semibold)
42
                    Text(inquiryId)
43
                        .foregroundColor(.secondary)
44
                        .lineLimit(nil)
45
                        .fixedSize(horizontal: false, vertical: true)
46
                }
47
            }
48
            .frame(maxWidth: .infinity, alignment: .leading)
49
            .padding()
50
            .background(Color(UIColor.secondarySystemBackground))
51
            .cornerRadius(8)
52
53
            Button(action: {
54
                // In production: navigate to home
55
                print("Navigate to home")
56
            }) {
57
                Text("Return to Home")
58
                    .fontWeight(.semibold)
59
                    .frame(maxWidth: .infinity)
60
            }
61
            .frame(height: 50)
62
            .background(Color.blue)
63
            .foregroundColor(.white)
64
            .cornerRadius(8)
65
        }
66
        .padding(20)
67
        .frame(maxWidth: .infinity, maxHeight: .infinity)
68
    }
69
}
70
71
struct FinishedView_Previews: PreviewProvider {
72
    static var previews: some View {
73
        FinishedView(inquiryId: "inq_12345", status: "completed")
74
    }
75
}