import Foundation
import AsyncDisplayKit
import Display
import TelegramCore
import Postbox
import SwiftSignalKit
private enum SecureIdDocumentFormTextField {
case identifier
case firstName
case lastName
case street1
case street2
case city
case state
case postcode
}
private enum SecureIdDocumentFormDateField {
case birthdate
case expiry
}
private enum SecureIdDocumentFormGenderField {
case gender
}
private enum SecureIdDocumentFormSelectionField {
case country
case residenceCountry
case date(Int32?, SecureIdDocumentFormDateField)
case gender
}
private enum AddFileTarget {
case scan
case selfie
case frontSide
case backSide
}
final class SecureIdDocumentFormParams {
fileprivate let account: Account
fileprivate let context: SecureIdAccessContext
fileprivate let addFile: (AddFileTarget) -> Void
fileprivate let openDocument: (SecureIdVerificationDocument) -> Void
fileprivate let updateText: (SecureIdDocumentFormTextField, String) -> Void
fileprivate let activateSelection: (SecureIdDocumentFormSelectionField) -> Void
fileprivate let deleteValue: () -> Void
fileprivate init(account: Account, context: SecureIdAccessContext, addFile: @escaping (AddFileTarget) -> Void, openDocument: @escaping (SecureIdVerificationDocument) -> Void, updateText: @escaping (SecureIdDocumentFormTextField, String) -> Void, activateSelection: @escaping (SecureIdDocumentFormSelectionField) -> Void, deleteValue: @escaping () -> Void) {
self.account = account
self.context = context
self.addFile = addFile
self.openDocument = openDocument
self.updateText = updateText
self.activateSelection = activateSelection
self.deleteValue = deleteValue
}
}
private struct SecureIdDocumentFormIdentityDetailsState: Equatable {
var firstName: String
var lastName: String
var countryCode: String
var residenceCountryCode: String
var birthdate: SecureIdDate?
var gender: SecureIdGender?
func isComplete() -> Bool {
if self.firstName.isEmpty {
return false
}
if self.lastName.isEmpty {
return false
}
if self.countryCode.isEmpty {
return false
}
if self.residenceCountryCode.isEmpty {
return false
}
if self.birthdate == nil {
return false
}
if self.gender == nil {
return false
}
return true
}
}
private struct SecureIdDocumentFormIdentityDocumentState: Equatable {
var type: SecureIdRequestedIdentityDocument
var identifier: String
var expiryDate: SecureIdDate?
func isComplete() -> Bool {
if self.identifier.isEmpty {
return false
}
return true
}
}
private struct SecureIdDocumentFormIdentityState {
var details: SecureIdDocumentFormIdentityDetailsState?
var document: SecureIdDocumentFormIdentityDocumentState?
func isEqual(to: SecureIdDocumentFormIdentityState) -> Bool {
if self.details != to.details {
return false
}
if self.document != to.document {
return false
}
return true
}
func isComplete() -> Bool {
if let details = self.details {
if !details.isComplete() {
return false
}
}
if let document = self.document {
if !document.isComplete() {
return false
}
}
return true
}
}
private struct SecureIdDocumentFormAddressDetailsState: Equatable {
var street1: String
var street2: String
var city: String
var state: String
var countryCode: String
var postcode: String
func isComplete() -> Bool {
if self.street1.isEmpty {
return false
}
if self.city.isEmpty {
return false
}
if self.countryCode.isEmpty {
return false
}
if self.postcode.isEmpty {
return false
}
return true
}
}
private struct SecureIdDocumentFormAddressState {
var details: SecureIdDocumentFormAddressDetailsState?
var document: SecureIdRequestedAddressDocument?
func isEqual(to: SecureIdDocumentFormAddressState) -> Bool {
if self.details != to.details {
return false
}
if self.document != to.document {
return false
}
return true
}
func isComplete() -> Bool {
if let details = self.details {
if !details.isComplete() {
return false
}
}
return true
}
}
private enum SecureIdDocumentFormDocumentState {
case identity(SecureIdDocumentFormIdentityState)
case address(SecureIdDocumentFormAddressState)
mutating func updateTextField(type: SecureIdDocumentFormTextField, value: String) {
switch self {
case var .identity(state):
switch type {
case .firstName:
state.details?.firstName = value
case .lastName:
state.details?.lastName = value
case .identifier:
state.document?.identifier = value
default:
break
}
self = .identity(state)
case var .address(state):
switch type {
case .street1:
state.details?.street1 = value
case .street2:
state.details?.street2 = value
case .city:
state.details?.city = value
case .state:
state.details?.state = value
case .postcode:
state.details?.postcode = value
default:
break
}
self = .address(state)
}
}
mutating func updateCountryCode(value: String) {
switch self {
case var .identity(state):
state.details?.countryCode = value
self = .identity(state)
case var .address(state):
state.details?.countryCode = value
self = .address(state)
}
}
mutating func updateResidenceCountryCode(value: String) {
switch self {
case var .identity(state):
state.details?.residenceCountryCode = value
self = .identity(state)
case .address:
break
}
}
mutating func updateDateField(type: SecureIdDocumentFormDateField, value: SecureIdDate?) {
switch self {
case var .identity(state):
switch type {
case .birthdate:
state.details?.birthdate = value
case .expiry:
state.document?.expiryDate = value
}
self = .identity(state)
case .address:
break
}
}
mutating func updateGenderField(type: SecureIdDocumentFormGenderField, value: SecureIdGender?) {
switch self {
case var .identity(state):
switch type {
case .gender:
state.details?.gender = value
}
self = .identity(state)
case .address:
break
}
}
func isEqual(to: SecureIdDocumentFormDocumentState) -> Bool {
switch self {
case let .identity(lhsValue):
if case let .identity(rhsValue) = to, lhsValue.isEqual(to: rhsValue) {
return true
} else {
return false
}
case let .address(lhsValue):
if case let .address(rhsValue) = to, lhsValue.isEqual(to: rhsValue) {
return true
} else {
return false
}
}
}
}
private enum SecureIdDocumentFormActionState {
case none
case saving
case deleting
}
enum SecureIdDocumentFormInputState {
case saveAvailable
case saveNotAvailable
case inProgress
}
struct SecureIdDocumentFormState: FormControllerInnerState {
fileprivate var previousValues: [SecureIdValueKey: SecureIdValueWithContext]
fileprivate var documentState: SecureIdDocumentFormDocumentState
fileprivate var documents: [SecureIdVerificationDocument]
fileprivate var selfieRequired: Bool
fileprivate var selfieDocument: SecureIdVerificationDocument?
fileprivate var frontSideRequired: Bool
fileprivate var frontSideDocument: SecureIdVerificationDocument?
fileprivate var backSideRequired: Bool
fileprivate var backSideDocument: SecureIdVerificationDocument?
fileprivate var actionState: SecureIdDocumentFormActionState
func isEqual(to: SecureIdDocumentFormState) -> Bool {
if !self.documentState.isEqual(to: to.documentState) {
return false
}
if self.actionState != to.actionState {
return false
}
if self.documents.count != to.documents.count {
return false
}
for i in 0 ..< self.documents.count {
if self.documents[i] != to.documents[i] {
return false
}
}
if self.selfieRequired != to.selfieRequired {
return false
}
if self.selfieDocument != to.selfieDocument {
return false
}
if self.frontSideDocument != to.frontSideDocument {
return false
}
if self.backSideDocument != to.backSideDocument {
return false
}
return true
}
func entries() -> [FormControllerItemEntry<SecureIdDocumentFormEntry>] {
switch self.documentState {
case let .identity(identity):
var result: [FormControllerItemEntry<SecureIdDocumentFormEntry>] = []
var errorIndex = 0
if let document = identity.document, false {
result.append(.entry(SecureIdDocumentFormEntry.scansHeader))
let filesType: SecureIdValueKey
switch document.type {
case .passport:
filesType = .passport
case .internalPassport:
filesType = .internalPassport
case .driversLicense:
filesType = .driversLicense
case .idCard:
filesType = .idCard
}
if let value = self.previousValues[filesType] {
var fileHashes: Set<Data>? = Set()
loop: for document in self.documents {
switch document {
case .local:
fileHashes = nil
break loop
case let .remote(file):
fileHashes?.insert(file.fileHash)
}
}
if let fileHashes = fileHashes, !fileHashes.isEmpty, let error = value.errors[.files(hashes: fileHashes)] {
//result.append(.spacer)
result.append(.entry(SecureIdDocumentFormEntry.error(errorIndex, error)))
errorIndex += 1
}
}
for i in 0 ..< self.documents.count {
var error: String?
switch self.documents[i] {
case .local:
break
case let .remote(file):
switch self.documentState {
case let .identity(identity):
if let document = identity.document {
switch document.type {
case .passport:
error = self.previousValues[.passport]?.errors[.file(hash: file.fileHash)]
case .internalPassport:
error = self.previousValues[.internalPassport]?.errors[.file(hash: file.fileHash)]
case .driversLicense:
error = self.previousValues[.driversLicense]?.errors[.file(hash: file.fileHash)]
case .idCard:
error = self.previousValues[.idCard]?.errors[.file(hash: file.fileHash)]
}
}
case let .address(address):
if let document = address.document {
switch document {
case .passportRegistration:
error = self.previousValues[.passportRegistration]?.errors[.file(hash: file.fileHash)]
case .temporaryRegistration:
error = self.previousValues[.temporaryRegistration]?.errors[.file(hash: file.fileHash)]
case .bankStatement:
error = self.previousValues[.bankStatement]?.errors[.file(hash: file.fileHash)]
case .utilityBill:
error = self.previousValues[.utilityBill]?.errors[.file(hash: file.fileHash)]
case .rentalAgreement:
error = self.previousValues[.rentalAgreement]?.errors[.file(hash: file.fileHash)]
}
}
}
}
result.append(.entry(SecureIdDocumentFormEntry.scan(i, self.documents[i], error)))
}
result.append(.entry(SecureIdDocumentFormEntry.addScan(!self.documents.isEmpty)))
result.append(.entry(SecureIdDocumentFormEntry.scansInfo(.identity)))
result.append(.spacer)
}
if let details = identity.details {
result.append(.entry(SecureIdDocumentFormEntry.infoHeader(.identity)))
result.append(.entry(SecureIdDocumentFormEntry.firstName(details.firstName, self.previousValues[.personalDetails]?.errors[.field(.personalDetails(.firstName))])))
result.append(.entry(SecureIdDocumentFormEntry.lastName(details.lastName, self.previousValues[.personalDetails]?.errors[.field(.personalDetails(.lastName))])))
result.append(.entry(SecureIdDocumentFormEntry.birthdate(details.birthdate, self.previousValues[.personalDetails]?.errors[.field(.personalDetails(.birthdate))])))
result.append(.entry(SecureIdDocumentFormEntry.gender(details.gender, self.previousValues[.personalDetails]?.errors[.field(.personalDetails(.gender))])))
result.append(.entry(SecureIdDocumentFormEntry.countryCode(details.countryCode, self.previousValues[.personalDetails]?.errors[.field(.personalDetails(.countryCode))])))
result.append(.entry(SecureIdDocumentFormEntry.residenceCountryCode(details.residenceCountryCode, self.previousValues[.personalDetails]?.errors[.field(.personalDetails(.residenceCountryCode))])))
}
if let document = identity.document {
if (identity.details == nil) {
result.append(.entry(SecureIdDocumentFormEntry.infoHeader(.identity)))
}
var identifierError: String?
var expiryDateError: String?
switch document.type {
case .passport:
identifierError = self.previousValues[.passport]?.errors[.field(.passport(.documentId))]
expiryDateError = self.previousValues[.passport]?.errors[.field(.passport(.expiryDate))]
case .internalPassport:
identifierError = self.previousValues[.internalPassport]?.errors[.field(.internalPassport(.documentId))]
expiryDateError = self.previousValues[.internalPassport]?.errors[.field(.internalPassport(.expiryDate))]
case .driversLicense:
identifierError = self.previousValues[.driversLicense]?.errors[.field(.driversLicense(.documentId))]
expiryDateError = self.previousValues[.driversLicense]?.errors[.field(.driversLicense(.expiryDate))]
case .idCard:
identifierError = self.previousValues[.idCard]?.errors[.field(.idCard(.documentId))]
expiryDateError = self.previousValues[.idCard]?.errors[.field(.idCard(.expiryDate))]
}
result.append(.entry(SecureIdDocumentFormEntry.identifier(document.identifier, identifierError)))
result.append(.entry(SecureIdDocumentFormEntry.expiryDate(document.expiryDate, expiryDateError)))
}
if self.selfieRequired || self.frontSideRequired || self.backSideRequired {
result.append(.spacer)
result.append(.entry(SecureIdDocumentFormEntry.requestedDocumentsHeader))
if self.frontSideRequired {
if let document = self.frontSideDocument {
var error: String?
if case let .remote(file) = document {
switch self.documentState {
case let .identity(identity):
if let document = identity.document {
switch document.type {
case .passport:
error = self.previousValues[.passport]?.errors[.frontSide(hash: file.fileHash)]
case .internalPassport:
error = self.previousValues[.internalPassport]?.errors[.frontSide(hash: file.fileHash)]
case .driversLicense:
error = self.previousValues[.driversLicense]?.errors[.frontSide(hash: file.fileHash)]
case .idCard:
error = self.previousValues[.idCard]?.errors[.frontSide(hash: file.fileHash)]
}
}
case .address:
break
}
}
result.append(.entry(SecureIdDocumentFormEntry.frontSide(1, document, error)))
} else {
result.append(.entry(SecureIdDocumentFormEntry.frontSide(1, nil, nil)))
}
}
if self.backSideRequired {
if let document = self.backSideDocument {
var error: String?
if case let .remote(file) = document {
switch self.documentState {
case let .identity(identity):
if let document = identity.document {
switch document.type {
case .passport:
error = self.previousValues[.passport]?.errors[.backSide(hash: file.fileHash)]
case .internalPassport:
error = self.previousValues[.internalPassport]?.errors[.backSide(hash: file.fileHash)]
case .driversLicense:
error = self.previousValues[.driversLicense]?.errors[.backSide(hash: file.fileHash)]
case .idCard:
error = self.previousValues[.idCard]?.errors[.backSide(hash: file.fileHash)]
}
}
case .address:
break
}
}
result.append(.entry(SecureIdDocumentFormEntry.backSide(2, document, error)))
} else {
result.append(.entry(SecureIdDocumentFormEntry.backSide(2, nil, nil)))
}
}
if self.selfieRequired {
if let document = self.selfieDocument {
var error: String?
if case let .remote(file) = document {
switch self.documentState {
case let .identity(identity):
if let document = identity.document {
switch document.type {
case .passport:
error = self.previousValues[.passport]?.errors[.selfie(hash: file.fileHash)]
case .internalPassport:
error = self.previousValues[.internalPassport]?.errors[.selfie(hash: file.fileHash)]
case .driversLicense:
error = self.previousValues[.driversLicense]?.errors[.selfie(hash: file.fileHash)]
case .idCard:
error = self.previousValues[.idCard]?.errors[.selfie(hash: file.fileHash)]
}
}
case .address:
break
}
}
result.append(.entry(SecureIdDocumentFormEntry.selfie(0, document, error)))
} else {
result.append(.entry(SecureIdDocumentFormEntry.selfie(0, nil, nil)))
}
}
}
if !self.previousValues.isEmpty {
result.append(.spacer)
result.append(.entry(SecureIdDocumentFormEntry.deleteDocument))
}
return result
case let .address(address):
var result: [FormControllerItemEntry<SecureIdDocumentFormEntry>] = []
var errorIndex = 0
if let document = address.document {
result.append(.entry(SecureIdDocumentFormEntry.scansHeader))
let filesType: SecureIdValueKey
switch document {
case .passportRegistration:
filesType = .passportRegistration
case .temporaryRegistration:
filesType = .temporaryRegistration
case .bankStatement:
filesType = .bankStatement
case .rentalAgreement:
filesType = .rentalAgreement
case .utilityBill:
filesType = .utilityBill
}
if let value = self.previousValues[filesType] {
var fileHashes: Set<Data>? = Set()
loop: for document in self.documents {
switch document {
case .local:
fileHashes = nil
break loop
case let .remote(file):
fileHashes?.insert(file.fileHash)
}
}
if let fileHashes = fileHashes, !fileHashes.isEmpty, let error = value.errors[.files(hashes: fileHashes)] {
result.append(.entry(SecureIdDocumentFormEntry.error(errorIndex, error)))
errorIndex += 1
}
}
for i in 0 ..< self.documents.count {
var error: String?
switch self.documents[i] {
case .local:
break
case let .remote(file):
switch self.documentState {
case let .identity(identity):
if let document = identity.document {
switch document.type {
case .passport:
error = self.previousValues[.passport]?.errors[.file(hash: file.fileHash)]
case .internalPassport:
error = self.previousValues[.internalPassport]?.errors[.file(hash: file.fileHash)]
case .driversLicense:
error = self.previousValues[.driversLicense]?.errors[.file(hash: file.fileHash)]
case .idCard:
error = self.previousValues[.idCard]?.errors[.file(hash: file.fileHash)]
}
}
case let .address(address):
if let document = address.document {
switch document {
case .passportRegistration:
error = self.previousValues[.passportRegistration]?.errors[.file(hash: file.fileHash)]
case .temporaryRegistration:
error = self.previousValues[.temporaryRegistration]?.errors[.file(hash: file.fileHash)]
case .bankStatement:
error = self.previousValues[.bankStatement]?.errors[.file(hash: file.fileHash)]
case .utilityBill:
error = self.previousValues[.utilityBill]?.errors[.file(hash: file.fileHash)]
case .rentalAgreement:
error = self.previousValues[.rentalAgreement]?.errors[.file(hash: file.fileHash)]
}
}
}
}
result.append(.entry(SecureIdDocumentFormEntry.scan(i, self.documents[i], error)))
}
result.append(.entry(SecureIdDocumentFormEntry.addScan(!self.documents.isEmpty)))
result.append(.entry(SecureIdDocumentFormEntry.scansInfo(.address)))
result.append(.spacer)
}
if let details = address.details {
result.append(.entry(SecureIdDocumentFormEntry.infoHeader(.address)))
result.append(.entry(SecureIdDocumentFormEntry.street1(details.street1, self.previousValues[.address]?.errors[.field(.address(.streetLine1))])))
result.append(.entry(SecureIdDocumentFormEntry.street2(details.street2, self.previousValues[.address]?.errors[.field(.address(.streetLine2))])))
result.append(.entry(SecureIdDocumentFormEntry.city(details.city, self.previousValues[.address]?.errors[.field(.address(.city))])))
result.append(.entry(SecureIdDocumentFormEntry.state(details.state, self.previousValues[.address]?.errors[.field(.address(.state))])))
result.append(.entry(SecureIdDocumentFormEntry.countryCode(details.countryCode, self.previousValues[.address]?.errors[.field(.address(.countryCode))])))
result.append(.entry(SecureIdDocumentFormEntry.postcode(details.postcode, self.previousValues[.address]?.errors[.field(.address(.postCode))])))
}
if !self.previousValues.isEmpty {
result.append(.spacer)
result.append(.entry(SecureIdDocumentFormEntry.deleteDocument))
}
return result
}
}
func actionInputState() -> SecureIdDocumentFormInputState {
switch self.actionState {
case .deleting, .saving:
return .inProgress
default:
break
}
switch self.documentState {
case let .identity(identity):
if !identity.isComplete() {
return .saveNotAvailable
}
case let .address(address):
if !address.isComplete() {
return .saveNotAvailable
}
}
if self.selfieRequired {
if let selfieDocument = self.selfieDocument {
switch selfieDocument {
case let .local(local):
switch local.state {
case .uploading:
return .saveNotAvailable
case .uploaded:
break
}
case .remote:
break
}
} else {
return .saveNotAvailable
}
}
for document in self.documents {
switch document {
case let .local(local):
switch local.state {
case .uploading:
return .saveNotAvailable
case .uploaded:
break
}
case .remote:
break
}
}
return .saveAvailable
}
}
extension SecureIdDocumentFormState {
init(requestedData: SecureIdDocumentFormRequestedData, values: [SecureIdValueKey: SecureIdValueWithContext]) {
switch requestedData {
case let .identity(details, document, selfie):
var previousValues: [SecureIdValueKey: SecureIdValueWithContext] = [:]
var detailsState: SecureIdDocumentFormIdentityDetailsState?
if details {
if let value = values[.personalDetails], case let .personalDetails(personalDetailsValue) = value.value {
previousValues[.personalDetails] = value
detailsState = SecureIdDocumentFormIdentityDetailsState(firstName: personalDetailsValue.firstName, lastName: personalDetailsValue.lastName, countryCode: personalDetailsValue.countryCode, residenceCountryCode: personalDetailsValue.residenceCountryCode, birthdate: personalDetailsValue.birthdate, gender: personalDetailsValue.gender)
} else {
detailsState = SecureIdDocumentFormIdentityDetailsState(firstName: "", lastName: "", countryCode: "", residenceCountryCode: "", birthdate: nil, gender: nil)
}
}
var documentState: SecureIdDocumentFormIdentityDocumentState?
var verificationDocuments: [SecureIdVerificationDocument] = []
var selfieDocument: SecureIdVerificationDocument?
var frontSideRequired: Bool = false
var backSideRequired: Bool = false
var frontSideDocument: SecureIdVerificationDocument?
var backSideDocument: SecureIdVerificationDocument?
if let document = document {
var identifier: String = ""
var expiryDate: SecureIdDate?
switch document {
case .passport:
if let value = values[.passport], case let .passport(passport) = value.value {
previousValues[value.value.key] = value
identifier = passport.identifier
expiryDate = passport.expiryDate
verificationDocuments = passport.verificationDocuments.compactMap(SecureIdVerificationDocument.init)
selfieDocument = passport.selfieDocument.flatMap(SecureIdVerificationDocument.init)
}
frontSideRequired = true
case .internalPassport:
if let value = values[.internalPassport], case let .internalPassport(internalPassport) = value.value {
previousValues[value.value.key] = value
identifier = internalPassport.identifier
expiryDate = internalPassport.expiryDate
verificationDocuments = internalPassport.verificationDocuments.compactMap(SecureIdVerificationDocument.init)
selfieDocument = internalPassport.selfieDocument.flatMap(SecureIdVerificationDocument.init)
frontSideDocument = internalPassport.frontSideDocument.flatMap(SecureIdVerificationDocument.init)
}
frontSideRequired = true
case .driversLicense:
if let value = values[.driversLicense], case let .driversLicense(driversLicense) = value.value {
previousValues[value.value.key] = value
identifier = driversLicense.identifier
expiryDate = driversLicense.expiryDate
verificationDocuments = driversLicense.verificationDocuments.compactMap(SecureIdVerificationDocument.init)
selfieDocument = driversLicense.selfieDocument.flatMap(SecureIdVerificationDocument.init)
frontSideDocument = driversLicense.frontSideDocument.flatMap(SecureIdVerificationDocument.init)
backSideDocument = driversLicense.backSideDocument.flatMap(SecureIdVerificationDocument.init)
}
frontSideRequired = true
backSideRequired = true
case .idCard:
if let value = values[.idCard], case let .idCard(idCard) = value.value {
previousValues[value.value.key] = value
identifier = idCard.identifier
expiryDate = idCard.expiryDate
verificationDocuments = idCard.verificationDocuments.compactMap(SecureIdVerificationDocument.init)
selfieDocument = idCard.selfieDocument.flatMap(SecureIdVerificationDocument.init)
frontSideDocument = idCard.frontSideDocument.flatMap(SecureIdVerificationDocument.init)
backSideDocument = idCard.backSideDocument.flatMap(SecureIdVerificationDocument.init)
}
frontSideRequired = true
backSideRequired = true
}
documentState = SecureIdDocumentFormIdentityDocumentState(type: document, identifier: identifier, expiryDate: expiryDate)
}
let formState = SecureIdDocumentFormIdentityState(details: detailsState, document: documentState)
self.init(previousValues: previousValues, documentState: .identity(formState), documents: verificationDocuments, selfieRequired: selfie, selfieDocument: selfieDocument, frontSideRequired: frontSideRequired, frontSideDocument: frontSideDocument, backSideRequired: backSideRequired, backSideDocument: backSideDocument, actionState: .none)
case let .address(details, document):
var previousValues: [SecureIdValueKey: SecureIdValueWithContext] = [:]
var detailsState: SecureIdDocumentFormAddressDetailsState?
var documentState: SecureIdRequestedAddressDocument?
var verificationDocuments: [SecureIdVerificationDocument] = []
if details {
if let value = values[.address], case let .address(address) = value.value {
previousValues[value.value.key] = value
detailsState = SecureIdDocumentFormAddressDetailsState(street1: address.street1, street2: address.street2, city: address.city, state: address.state, countryCode: address.countryCode, postcode: address.postcode)
} else {
detailsState = SecureIdDocumentFormAddressDetailsState(street1: "", street2: "", city: "", state: "", countryCode: "", postcode: "")
}
}
if let document = document {
switch document {
case .passportRegistration:
if let value = values[.passportRegistration], case let .passportRegistration(passportRegistration) = value.value {
previousValues[value.value.key] = value
verificationDocuments = passportRegistration.verificationDocuments.compactMap(SecureIdVerificationDocument.init)
}
case .temporaryRegistration:
if let value = values[.temporaryRegistration], case let .temporaryRegistration(temporaryRegistration) = value.value {
previousValues[value.value.key] = value
verificationDocuments = temporaryRegistration.verificationDocuments.compactMap(SecureIdVerificationDocument.init)
}
case .bankStatement:
if let value = values[.bankStatement], case let .bankStatement(bankStatement) = value.value {
previousValues[value.value.key] = value
verificationDocuments = bankStatement.verificationDocuments.compactMap(SecureIdVerificationDocument.init)
}
case .utilityBill:
if let value = values[.utilityBill], case let .utilityBill(utilityBill) = value.value {
previousValues[value.value.key] = value
verificationDocuments = utilityBill.verificationDocuments.compactMap(SecureIdVerificationDocument.init)
}
case .rentalAgreement:
if let value = values[.rentalAgreement], case let .rentalAgreement(rentalAgreement) = value.value {
previousValues[value.value.key] = value
verificationDocuments = rentalAgreement.verificationDocuments.compactMap(SecureIdVerificationDocument.init)
}
}
documentState = document
}
let formState = SecureIdDocumentFormAddressState(details: detailsState, document: documentState)
self.init(previousValues: previousValues, documentState: .address(formState), documents: verificationDocuments, selfieRequired: false, selfieDocument: nil, frontSideRequired: false, frontSideDocument: nil, backSideRequired: false, backSideDocument: nil, actionState: .none)
}
}
func makeValues() -> [SecureIdValueKey: SecureIdValue]? {
var verificationDocuments: [SecureIdVerificationDocumentReference] = []
for document in self.documents {
switch document {
case let .remote(file):
verificationDocuments.append(.remote(file))
case let .local(file):
switch file.state {
case let .uploaded(file):
verificationDocuments.append(.uploaded(file))
case .uploading:
return nil
}
}
}
var selfieDocument: SecureIdVerificationDocumentReference?
if let document = self.selfieDocument {
switch document {
case let .remote(file):
selfieDocument = .remote(file)
case let .local(file):
switch file.state {
case let .uploaded(file):
selfieDocument = .uploaded(file)
case .uploading:
return nil
}
}
}
var frontSideDocument: SecureIdVerificationDocumentReference?
if let document = self.frontSideDocument {
switch document {
case let .remote(file):
frontSideDocument = .remote(file)
case let .local(file):
switch file.state {
case let .uploaded(file):
frontSideDocument = .uploaded(file)
case .uploading:
return nil
}
}
}
var backSideDocument: SecureIdVerificationDocumentReference?
if let document = self.backSideDocument {
switch document {
case let .remote(file):
backSideDocument = .remote(file)
case let .local(file):
switch file.state {
case let .uploaded(file):
backSideDocument = .uploaded(file)
case .uploading:
return nil
}
}
}
switch self.documentState {
case let .identity(identity):
var values: [SecureIdValueKey: SecureIdValue] = [:]
if let details = identity.details {
guard !details.firstName.isEmpty else {
return nil
}
guard !details.lastName.isEmpty else {
return nil
}
guard !details.countryCode.isEmpty else {
return nil
}
guard !details.residenceCountryCode.isEmpty else {
return nil
}
guard let birthdate = details.birthdate else {
return nil
}
guard let gender = details.gender else {
return nil
}
values[.personalDetails] = .personalDetails(SecureIdPersonalDetailsValue(firstName: details.firstName, lastName: details.lastName, birthdate: birthdate, countryCode: details.countryCode, residenceCountryCode: details.residenceCountryCode, gender: gender))
}
if let document = identity.document {
guard !document.identifier.isEmpty else {
return nil
}
switch document.type {
case .passport:
values[.passport] = .passport(SecureIdPassportValue(identifier: document.identifier, expiryDate: document.expiryDate, verificationDocuments: verificationDocuments, selfieDocument: selfieDocument, frontSideDocument: frontSideDocument))
case .internalPassport:
values[.internalPassport] = .internalPassport(SecureIdInternalPassportValue(identifier: document.identifier, expiryDate: document.expiryDate, verificationDocuments: verificationDocuments, selfieDocument: selfieDocument, frontSideDocument: frontSideDocument))
case .driversLicense:
values[.driversLicense] = .driversLicense(SecureIdDriversLicenseValue(identifier: document.identifier, expiryDate: document.expiryDate, verificationDocuments: verificationDocuments, selfieDocument: selfieDocument, frontSideDocument: frontSideDocument, backSideDocument: backSideDocument))
case .idCard:
values[.idCard] = .idCard(SecureIdIDCardValue(identifier: document.identifier, expiryDate: document.expiryDate, verificationDocuments: verificationDocuments, selfieDocument: selfieDocument, frontSideDocument: frontSideDocument, backSideDocument: backSideDocument))
}
}
return values
case let .address(address):
var values: [SecureIdValueKey: SecureIdValue] = [:]
if let details = address.details {
guard !details.street1.isEmpty else {
return nil
}
guard !details.city.isEmpty else {
return nil
}
guard !details.countryCode.isEmpty else {
return nil
}
guard !details.postcode.isEmpty else {
return nil
}
values[.address] = .address(SecureIdAddressValue(street1: details.street1, street2: details.street2, city: details.city, state: details.state, countryCode: details.countryCode, postcode: details.postcode))
}
if let document = address.document {
switch document {
case .passportRegistration:
values[.passportRegistration] = .passportRegistration(SecureIdPassportRegistrationValue(verificationDocuments: verificationDocuments))
case .temporaryRegistration:
values[.temporaryRegistration] = .temporaryRegistration(SecureIdTemporaryRegistrationValue(verificationDocuments: verificationDocuments))
case .bankStatement:
values[.bankStatement] = .bankStatement(SecureIdBankStatementValue(verificationDocuments: verificationDocuments))
case .utilityBill:
values[.utilityBill] = .utilityBill(SecureIdUtilityBillValue(verificationDocuments: verificationDocuments))
case .rentalAgreement:
values[.rentalAgreement] = .rentalAgreement(SecureIdRentalAgreementValue(verificationDocuments: verificationDocuments))
}
}
return values
}
}
}
enum SecureIdDocumentFormEntryId: Hashable {
case scansHeader
case scan(SecureIdVerificationDocumentId)
case addScan
case scansInfo
case infoHeader
case identifier
case firstName
case lastName
case gender
case countryCode
case residenceCountryCode
case birthdate
case expiryDate
case deleteDocument
case requestedDocumentsHeader
case selfie
case frontSide
case backSide
case documentsInfo
case street1
case street2
case city
case state
case postcode
case error
}
enum SecureIdDocumentFormEntryCategory {
case identity
case address
}
enum SecureIdDocumentFormEntry: FormControllerEntry {
case scansHeader
case scan(Int, SecureIdVerificationDocument, String?)
case addScan(Bool)
case scansInfo(SecureIdDocumentFormEntryCategory)
case infoHeader(SecureIdDocumentFormEntryCategory)
case identifier(String, String?)
case firstName(String, String?)
case lastName(String, String?)
case gender(SecureIdGender?, String?)
case countryCode(String, String?)
case residenceCountryCode(String, String?)
case birthdate(SecureIdDate?, String?)
case expiryDate(SecureIdDate?, String?)
case deleteDocument
case requestedDocumentsHeader
case selfie(Int, SecureIdVerificationDocument?, String?)
case frontSide(Int, SecureIdVerificationDocument?, String?)
case backSide(Int, SecureIdVerificationDocument?, String?)
case documentsInfo
case error(Int, String)
case street1(String, String?)
case street2(String, String?)
case city(String, String?)
case state(String, String?)
case postcode(String, String?)
var stableId: SecureIdDocumentFormEntryId {
switch self {
case .scansHeader:
return .scansHeader
case let .scan(_, document, _):
return .scan(document.id)
case .addScan:
return .addScan
case .scansInfo:
return .scansInfo
case .infoHeader:
return .infoHeader
case .identifier:
return .identifier
case .firstName:
return .firstName
case .lastName:
return .lastName
case .countryCode:
return .countryCode
case .residenceCountryCode:
return .residenceCountryCode
case .birthdate:
return .birthdate
case .expiryDate:
return .expiryDate
case .deleteDocument:
return .deleteDocument
case .street1:
return .street1
case .street2:
return .street2
case .city:
return .city
case .state:
return .state
case .postcode:
return .postcode
case .gender:
return .gender
case .requestedDocumentsHeader:
return .requestedDocumentsHeader
case .selfie:
return .selfie
case .frontSide:
return .frontSide
case .backSide:
return .backSide
case .documentsInfo:
return .documentsInfo
case .error:
return .error
}
}
func isEqual(to: SecureIdDocumentFormEntry) -> Bool {
switch self {
case .scansHeader:
if case .scansHeader = to {
return true
} else {
return false
}
case let .scan(lhsId, lhsDocument, lhsError):
if case let .scan(rhsId, rhsDocument, rhsError) = to, lhsId == rhsId, lhsDocument == rhsDocument, lhsError == rhsError {
return true
} else {
return false
}
case let .addScan(hasAny):
if case .addScan(hasAny) = to {
return true
} else {
return false
}
case let .scansInfo(value):
if case .scansInfo(value) = to {
return true
} else {
return false
}
case let .infoHeader(value):
if case .infoHeader(value) = to {
return true
} else {
return false
}
case let .identifier(value, error):
if case .identifier(value, error) = to {
return true
} else {
return false
}
case let .firstName(value, error):
if case .firstName(value, error) = to {
return true
} else {
return false
}
case let .lastName(value, error):
if case .lastName(value, error) = to {
return true
} else {
return false
}
case let .gender(value, error):
if case .gender(value, error) = to {
return true
} else {
return false
}
case let .countryCode(value, error):
if case .countryCode(value, error) = to {
return true
} else {
return false
}
case let .residenceCountryCode(value, error):
if case .residenceCountryCode(value, error) = to {
return true
} else {
return false
}
case let .birthdate(lhsValue, lhsError):
if case let .birthdate(rhsValue, rhsError) = to, lhsValue == rhsValue, lhsError == rhsError {
return true
} else {
return false
}
case let .expiryDate(lhsValue, lhsError):
if case let .expiryDate(rhsValue, rhsError) = to, lhsValue == rhsValue, lhsError == rhsError {
return true
} else {
return false
}
case .deleteDocument:
if case .deleteDocument = to {
return true
} else {
return false
}
case let .street1(value, error):
if case .street1(value, error) = to {
return true
} else {
return false
}
case let .street2(value, error):
if case .street2(value, error) = to {
return true
} else {
return false
}
case let .city(value, error):
if case .city(value, error) = to {
return true
} else {
return false
}
case let .state(value, error):
if case .state(value, error) = to {
return true
} else {
return false
}
case let .postcode(value, error):
if case .postcode(value, error) = to {
return true
} else {
return false
}
case .requestedDocumentsHeader:
if case .requestedDocumentsHeader = to {
return true
} else {
return false
}
case let .selfie(index, document, error):
if case .selfie(index, document, error) = to {
return true
} else {
return false
}
case let .frontSide(index, document, error):
if case .frontSide(index, document, error) = to {
return true
} else {
return false
}
case let .backSide(index, document, error):
if case .backSide(index, document, error) = to {
return true
} else {
return false
}
case .documentsInfo:
if case .documentsInfo = to {
return true
} else {
return false
}
case let .error(index, text):
if case .error(index, text) = to {
return true
} else {
return false
}
}
}
func item(params: SecureIdDocumentFormParams, strings: PresentationStrings) -> FormControllerItem {
switch self {
case .scansHeader:
return FormControllerHeaderItem(text: "SCANS")
case let .scan(index, document, error):
return SecureIdValueFormFileItem(account: params.account, context: params.context, document: document, placeholder: nil, title: "Scan \(index + 1)", label: error.flatMap(SecureIdValueFormFileItemLabel.error) ?? .timestamp, activated: {
params.openDocument(document)
})
case let .addScan(hasAny):
return FormControllerActionItem(type: .accent, title: hasAny ? "Upload Additional Scan" : "Upload Scan", fullTopInset: true, activated: {
params.addFile(.scan)
})
case let .scansInfo(type):
let text: String
switch type {
case .identity:
text = "The document must contain your photograph, name, surname, date of birth, citizenship, document issue date and document number."
case .address:
text = "The document must contain your first and last name, your residential address, a stamp / barcode / QR code / logo, and issue date, no more that 3 months ago."
}
return FormControllerTextItem(text: text)
case let .infoHeader(type):
let text: String
switch type {
case .identity:
text = "DOCUMENT DETAILS"
case .address:
text = "ADDRESS"
}
return FormControllerHeaderItem(text: text)
case let .identifier(value, error):
return FormControllerTextInputItem(title: "Document #", text: value, placeholder: "Document Number", error: error, textUpdated: { text in
params.updateText(.identifier, text)
})
case let .firstName(value, error):
return FormControllerTextInputItem(title: "First Name", text: value, placeholder: "First Name", error: error, textUpdated: { text in
params.updateText(.firstName, text)
})
case let .lastName(value, error):
return FormControllerTextInputItem(title: "Last Name", text: value, placeholder: "Last Name", error: error, textUpdated: { text in
params.updateText(.lastName, text)
})
case let .gender(value, error):
var text = ""
if let value = value {
switch value {
case .male:
text = "Male"
case .female:
text = "Female"
}
}
return FormControllerDetailActionItem(title: "Gender", text: text, placeholder: "Gender", error: error, activated: {
params.activateSelection(.gender)
})
case let .countryCode(value, error):
return FormControllerDetailActionItem(title: "Country", text: AuthorizationSequenceCountrySelectionController.lookupCountryNameById(value.uppercased(), strings: strings) ?? "", placeholder: "Country", error: error, activated: {
params.activateSelection(.country)
})
case let .residenceCountryCode(value, error):
return FormControllerDetailActionItem(title: "Residence", text: AuthorizationSequenceCountrySelectionController.lookupCountryNameById(value.uppercased(), strings: strings) ?? "", placeholder: "Residence Country", error: error, activated: {
params.activateSelection(.residenceCountry)
})
case let .birthdate(value, error):
return FormControllerDetailActionItem(title: "Date of Birth", text: value.flatMap({ stringForDate(timestamp: $0.timestamp, strings: strings) }) ?? "", placeholder: "Date of Birth", error: error, activated: {
params.activateSelection(.date(value?.timestamp, .birthdate))
})
case let .expiryDate(value, error):
return FormControllerDetailActionItem(title: "Expiry Date", text: value.flatMap({ stringForDate(timestamp: $0.timestamp, strings: strings) }) ?? "", placeholder: "Expiry Date", error: error, activated: {
params.activateSelection(.date(value?.timestamp, .expiry))
})
case .deleteDocument:
return FormControllerActionItem(type: .destructive, title: "Delete Document", activated: {
params.deleteValue()
})
case let .street1(value, error):
return FormControllerTextInputItem(title: "Street", text: value, placeholder: "Street and number, P.O. box", error: error, textUpdated: { text in
params.updateText(.street1, text)
})
case let .street2(value, error):
return FormControllerTextInputItem(title: "", text: value, placeholder: "Apt., suite, unit, builting, block", error: error, textUpdated: { text in
params.updateText(.street2, text)
})
case let .city(value, error):
return FormControllerTextInputItem(title: "City", text: value, placeholder: "City", error: error, textUpdated: { text in
params.updateText(.city, text)
})
case let .state(value, error):
return FormControllerTextInputItem(title: "Region", text: value, placeholder: "State / Province / Region", error: error, textUpdated: { text in
params.updateText(.state, text)
})
case let .postcode(value, error):
return FormControllerTextInputItem(title: "Postcode", text: value, placeholder: "Postcode", error: error, textUpdated: { text in
params.updateText(.postcode, text)
})
case .requestedDocumentsHeader:
return FormControllerHeaderItem(text: "REQUESTED FILES")
case let .selfie(_, document, error):
let label: SecureIdValueFormFileItemLabel
if let error = error {
label = .error(error)
} else if document != nil {
label = .timestamp
} else {
label = .text("Upload a selfie of yourself holding document")
}
return SecureIdValueFormFileItem(account: params.account, context: params.context, document: document, placeholder: UIImage(bundleImageName: "Secure ID/DocumentInputSelfie"), title: "Selfie", label: label, activated: {
if let document = document {
params.openDocument(document)
} else {
params.addFile(.selfie)
}
})
case let .frontSide(_, document, error):
let label: SecureIdValueFormFileItemLabel
if let error = error {
label = .error(error)
} else if document != nil {
label = .timestamp
} else {
label = .text("Upload a front side photo of a document")
}
return SecureIdValueFormFileItem(account: params.account, context: params.context, document: document, placeholder: UIImage(bundleImageName: "Secure ID/PassportInputFrontSide"), title: "Front Side", label: label, activated: {
if let document = document {
params.openDocument(document)
} else {
params.addFile(.frontSide)
}
})
case let .backSide(_, document, error):
let label: SecureIdValueFormFileItemLabel
if let error = error {
label = .error(error)
} else if document != nil {
label = .timestamp
} else {
label = .text("Upload a reverse side photo of a document")
}
return SecureIdValueFormFileItem(account: params.account, context: params.context, document: document, placeholder: UIImage(bundleImageName: "Secure ID/DocumentInputBackSide"), title: "Reverse Side", label: label, activated: {
if let document = document {
params.openDocument(document)
} else {
params.addFile(.backSide)
}
})
case .documentsInfo:
return FormControllerTextItem(text: "")
case let .error(_, text):
return FormControllerTextItem(text: text, color: .error)
}
}
}
struct SecureIdDocumentFormControllerNodeInitParams {
let account: Account
let context: SecureIdAccessContext
}
final class SecureIdDocumentFormControllerNode: FormControllerNode<SecureIdDocumentFormControllerNodeInitParams, SecureIdDocumentFormState> {
private var _itemParams: SecureIdDocumentFormParams?
override var itemParams: SecureIdDocumentFormParams {
return self._itemParams!
}
private var theme: PresentationTheme
private var strings: PresentationStrings
private let account: Account
private let context: SecureIdAccessContext
private let uploadContext: SecureIdVerificationDocumentsContext
var actionInputStateUpdated: ((SecureIdDocumentFormInputState) -> Void)?
var completedWithValues: (([SecureIdValueWithContext]?) -> Void)?
var dismiss: (() -> Void)?
private let actionDisposable = MetaDisposable()
private let hiddenItemDisposable = MetaDisposable()
required init(initParams: SecureIdDocumentFormControllerNodeInitParams, theme: PresentationTheme, strings: PresentationStrings) {
self.theme = theme
self.strings = strings
self.account = initParams.account
self.context = initParams.context
var updateImpl: ((Int64, SecureIdVerificationLocalDocumentState) -> Void)?
self.uploadContext = SecureIdVerificationDocumentsContext(postbox: self.account.postbox, network: self.account.network, context: self.context, update: { id, state in
updateImpl?(id, state)
})
super.init(initParams: initParams, theme: theme, strings: strings)
self._itemParams = SecureIdDocumentFormParams(account: self.account, context: self.context, addFile: { [weak self] type in
if let strongSelf = self {
strongSelf.presentAssetPicker(type)
}
}, openDocument: { [weak self] document in
if let strongSelf = self {
strongSelf.presentGallery(document: document)
}
}, updateText: { [weak self] field, value in
if let strongSelf = self, var innerState = strongSelf.innerState {
innerState.documentState.updateTextField(type: field, value: value)
var valueKey: SecureIdValueKey?
var errorKey: SecureIdValueContentErrorKey?
switch innerState.documentState {
case let .identity(identity):
switch field {
case .firstName:
valueKey = .personalDetails
errorKey = .field(.personalDetails(.firstName))
case .lastName:
valueKey = .personalDetails
errorKey = .field(.personalDetails(.lastName))
case .identifier:
if let document = identity.document {
switch document.type {
case .passport:
valueKey = .passport
errorKey = .field(.passport(.documentId))
case .internalPassport:
valueKey = .internalPassport
errorKey = .field(.internalPassport(.documentId))
case .driversLicense:
valueKey = .driversLicense
errorKey = .field(.driversLicense(.documentId))
case .idCard:
valueKey = .idCard
errorKey = .field(.idCard(.documentId))
}
}
default:
break
}
case .address:
switch field {
case .street1:
valueKey = .address
errorKey = .field(.address(.streetLine1))
case .street2:
valueKey = .address
errorKey = .field(.address(.streetLine2))
case .state:
valueKey = .address
errorKey = .field(.address(.state))
case .postcode:
valueKey = .address
errorKey = .field(.address(.postCode))
default:
break
}
}
if let valueKey = valueKey, let errorKey = errorKey {
if let previousValue = innerState.previousValues[valueKey] {
innerState.previousValues[valueKey] = previousValue.withRemovedErrors([errorKey])
}
}
strongSelf.updateInnerState(transition: .immediate, with: innerState)
}
}, activateSelection: { [weak self] field in
if let strongSelf = self {
switch field {
case .country:
let controller = AuthorizationSequenceCountrySelectionController(strings: strings, theme: AuthorizationSequenceCountrySelectionTheme(presentationTheme: strongSelf.theme), displayCodes: false)
controller.completeWithCountryCode = { _, id in
if let strongSelf = self, var innerState = strongSelf.innerState {
innerState.documentState.updateCountryCode(value: id)
var valueKey: SecureIdValueKey?
var errorKey: SecureIdValueContentErrorKey?
switch innerState.documentState {
case .identity:
valueKey = .personalDetails
errorKey = .field(.personalDetails(.countryCode))
case .address:
valueKey = .address
errorKey = .field(.address(.countryCode))
}
if let valueKey = valueKey, let errorKey = errorKey {
if let previousValue = innerState.previousValues[valueKey] {
innerState.previousValues[valueKey] = previousValue.withRemovedErrors([errorKey])
}
}
strongSelf.updateInnerState(transition: .immediate, with: innerState)
}
}
strongSelf.view.endEditing(true)
strongSelf.present(controller, ViewControllerPresentationArguments(presentationAnimation: .modalSheet))
case .residenceCountry:
let controller = AuthorizationSequenceCountrySelectionController(strings: strings, theme: AuthorizationSequenceCountrySelectionTheme(presentationTheme: strongSelf.theme), displayCodes: false)
controller.completeWithCountryCode = { _, id in
if let strongSelf = self, var innerState = strongSelf.innerState {
innerState.documentState.updateResidenceCountryCode(value: id)
var valueKey: SecureIdValueKey?
var errorKey: SecureIdValueContentErrorKey?
switch innerState.documentState {
case .identity:
valueKey = .personalDetails
errorKey = .field(.personalDetails(.residenceCountryCode))
case .address:
break
}
if let valueKey = valueKey, let errorKey = errorKey {
if let previousValue = innerState.previousValues[valueKey] {
innerState.previousValues[valueKey] = previousValue.withRemovedErrors([errorKey])
}
}
strongSelf.updateInnerState(transition: .immediate, with: innerState)
}
}
strongSelf.view.endEditing(true)
strongSelf.present(controller, ViewControllerPresentationArguments(presentationAnimation: .modalSheet))
case let .date(current, field):
var emptyTitle: String?
if case .expiry = field {
emptyTitle = "Does not expire"
}
let controller = DateSelectionActionSheetController(theme: theme, strings: strings, currentValue: current ?? Int32(Date().timeIntervalSince1970), emptyTitle: emptyTitle, applyValue: { value in
if let strongSelf = self, var innerState = strongSelf.innerState {
innerState.documentState.updateDateField(type: field, value: value.flatMap(SecureIdDate.init))
var valueKey: SecureIdValueKey?
var errorKey: SecureIdValueContentErrorKey?
switch innerState.documentState {
case let .identity(identity):
switch field {
case .birthdate:
valueKey = .personalDetails
errorKey = .field(.personalDetails(.birthdate))
case .expiry:
if let document = identity.document {
switch document.type {
case .passport:
valueKey = .passport
errorKey = .field(.passport(.expiryDate))
case .internalPassport:
valueKey = .internalPassport
errorKey = .field(.internalPassport(.expiryDate))
case .driversLicense:
valueKey = .driversLicense
errorKey = .field(.driversLicense(.expiryDate))
case .idCard:
valueKey = .idCard
errorKey = .field(.idCard(.expiryDate))
}
}
}
case .address:
break
}
if let valueKey = valueKey, let errorKey = errorKey {
if let previousValue = innerState.previousValues[valueKey] {
innerState.previousValues[valueKey] = previousValue.withRemovedErrors([errorKey])
}
}
strongSelf.updateInnerState(transition: .immediate, with: innerState)
}
})
strongSelf.view.endEditing(true)
strongSelf.present(controller, nil)
case .gender:
let controller = ActionSheetController(presentationTheme: theme)
let dismissAction: () -> Void = { [weak controller] in
controller?.dismissAnimated()
}
let applyAction: (SecureIdGender) -> Void = { gender in
if let strongSelf = self, var innerState = strongSelf.innerState {
innerState.documentState.updateGenderField(type: .gender, value: gender)
var valueKey: SecureIdValueKey?
var errorKey: SecureIdValueContentErrorKey?
valueKey = .personalDetails
errorKey = .field(.personalDetails(.gender))
if let valueKey = valueKey, let errorKey = errorKey {
if let previousValue = innerState.previousValues[valueKey] {
innerState.previousValues[valueKey] = previousValue.withRemovedErrors([errorKey])
}
}
strongSelf.updateInnerState(transition: .immediate, with: innerState)
}
}
controller.setItemGroups([
ActionSheetItemGroup(items: [
ActionSheetButtonItem(title: "Male", action: {
dismissAction()
applyAction(.male)
}),
ActionSheetButtonItem(title: "Female", action: {
dismissAction()
applyAction(.female)
})
]),
ActionSheetItemGroup(items: [ActionSheetButtonItem(title: strongSelf.strings.Common_Cancel, action: { dismissAction() })])
])
strongSelf.view.endEditing(true)
strongSelf.present(controller, nil)
}
}
}, deleteValue: { [weak self] in
if let strongSelf = self {
strongSelf.deleteValue()
}
})
updateImpl = { [weak self] id, state in
if let strongSelf = self, var innerState = strongSelf.innerState {
outer: for i in 0 ..< innerState.documents.count {
switch innerState.documents[i] {
case var .local(local):
if local.id == id {
local.state = state
innerState.documents[i] = .local(local)
break outer
}
case .remote:
break
}
}
if let selfieDocument = innerState.selfieDocument {
switch selfieDocument {
case var .local(local):
if local.id == id {
local.state = state
innerState.selfieDocument = .local(local)
}
case .remote:
break
}
}
if let frontSideDocument = innerState.frontSideDocument {
switch frontSideDocument {
case var .local(local):
if local.id == id {
local.state = state
innerState.frontSideDocument = .local(local)
}
case .remote:
break
}
}
if let backSideDocument = innerState.backSideDocument {
switch backSideDocument {
case var .local(local):
if local.id == id {
local.state = state
innerState.backSideDocument = .local(local)
}
case .remote:
break
}
}
strongSelf.updateInnerState(transition: .immediate, with: innerState)
}
}
}
deinit {
self.actionDisposable.dispose()
}
private func presentAssetPicker(_ type: AddFileTarget) {
guard let validLayout = self.layoutState?.layout else {
return
}
let attachmentType: SecureIdAttachmentMenuType
switch type {
case .scan:
attachmentType = .multiple
case .backSide, .frontSide:
attachmentType = .generic
case .selfie:
attachmentType = .selfie
}
presentLegacySecureIdAttachmentMenu(account: self.account, present: { [weak self] c in
self?.present(c, nil)
}, validLayout: validLayout, type: attachmentType, completion: { [weak self] resources, recognizedData in
self?.addDocuments(type: type, resources: resources, recognizedData: recognizedData)
})
}
private func addDocuments(type: AddFileTarget, resources: [TelegramMediaResource], recognizedData: SecureIdRecognizedDocumentData?) {
guard var innerState = self.innerState else {
return
}
switch type {
case .scan:
for resource in resources {
let id = arc4random64()
innerState.documents.append(.local(SecureIdVerificationLocalDocument(id: id, resource: SecureIdLocalImageResource(localId: id, source: resource), timestamp: Int32(Date().timeIntervalSince1970), state: .uploading(0.0))))
}
case .selfie:
loop: for resource in resources {
let id = arc4random64()
innerState.selfieDocument = .local(SecureIdVerificationLocalDocument(id: id, resource: SecureIdLocalImageResource(localId: id, source: resource), timestamp: Int32(Date().timeIntervalSince1970), state: .uploading(0.0)))
break loop
}
case .frontSide:
loop: for resource in resources {
let id = arc4random64()
innerState.frontSideDocument = .local(SecureIdVerificationLocalDocument(id: id, resource: SecureIdLocalImageResource(localId: id, source: resource), timestamp: Int32(Date().timeIntervalSince1970), state: .uploading(0.0)))
break loop
}
case .backSide:
loop: for resource in resources {
let id = arc4random64()
innerState.backSideDocument = .local(SecureIdVerificationLocalDocument(id: id, resource: SecureIdLocalImageResource(localId: id, source: resource), timestamp: Int32(Date().timeIntervalSince1970), state: .uploading(0.0)))
break loop
}
}
if let recognizedData = recognizedData {
switch innerState.documentState {
case var .identity(identity):
if var document = identity.document {
switch document.type {
case .passport:
break
case .internalPassport:
break
case .driversLicense:
break
case .idCard:
break
}
if var details = identity.details {
if details.firstName.isEmpty {
details.firstName = recognizedData.firstName ?? ""
}
if details.lastName.isEmpty {
details.lastName = recognizedData.lastName ?? ""
}
if details.birthdate == nil, let birthdate = recognizedData.birthDate {
details.birthdate = SecureIdDate(timestamp: Int32(birthdate.timeIntervalSince1970))
}
if details.gender == nil, let gender = recognizedData.gender {
if gender == "M" {
details.gender = .male
} else {
details.gender = .female
}
}
if details.countryCode.isEmpty {
details.countryCode = recognizedData.issuingCountry ?? ""
}
identity.details = details
}
if document.identifier.isEmpty {
document.identifier = recognizedData.documentNumber ?? ""
}
if document.expiryDate == nil, let expiryDate = recognizedData.expiryDate {
document.expiryDate = SecureIdDate(timestamp: Int32(expiryDate.timeIntervalSince1970))
}
identity.document = document
innerState.documentState = .identity(identity)
}
default:
break
}
}
self.updateInnerState(transition: .immediate, with: innerState)
}
override func updateInnerState(transition: ContainedViewLayoutTransition, with innerState: SecureIdDocumentFormState) {
let previousActionInputState = self.innerState?.actionInputState()
super.updateInnerState(transition: transition, with: innerState)
var documents = innerState.documents
if let selfieDocument = innerState.selfieDocument {
documents.append(selfieDocument)
}
if let frontSideDocument = innerState.frontSideDocument {
documents.append(frontSideDocument)
}
if let backSideDocument = innerState.backSideDocument {
documents.append(backSideDocument)
}
self.uploadContext.stateUpdated(documents)
let actionInputState = innerState.actionInputState()
if previousActionInputState != actionInputState {
self.actionInputStateUpdated?(actionInputState)
}
}
func save() {
guard var innerState = self.innerState else {
return
}
guard case .none = innerState.actionState else {
return
}
guard case .saveAvailable = innerState.actionInputState() else {
return
}
guard let values = innerState.makeValues(), !values.isEmpty else {
return
}
if !innerState.previousValues.isEmpty, values == innerState.previousValues.mapValues({ $0.value }) {
self.dismiss?()
return
}
innerState.actionState = .saving
self.updateInnerState(transition: .immediate, with: innerState)
var saveValues: [Signal<SecureIdValueWithContext, SaveSecureIdValueError>] = []
for (_, value) in values {
saveValues.append(saveSecureIdValue(postbox: self.account.postbox, network: self.account.network, context: self.context, value: value, uploadedFiles: self.uploadContext.uploadedFiles))
}
self.actionDisposable.set((combineLatest(saveValues)
|> deliverOnMainQueue).start(next: { [weak self] result in
if let strongSelf = self {
strongSelf.completedWithValues?(result)
}
}, error: { [weak self] error in
if let strongSelf = self {
guard var innerState = strongSelf.innerState else {
return
}
guard case .saving = innerState.actionState else {
return
}
innerState.actionState = .none
strongSelf.updateInnerState(transition: .immediate, with: innerState)
}
}))
}
func deleteValue() {
guard var innerState = self.innerState, !innerState.previousValues.isEmpty else {
return
}
guard case .none = innerState.actionState else {
return
}
innerState.actionState = .deleting
self.updateInnerState(transition: .immediate, with: innerState)
self.actionDisposable.set((deleteSecureIdValues(network: self.account.network, keys: Set(innerState.previousValues.keys))
|> deliverOnMainQueue).start(error: { [weak self] error in
if let strongSelf = self {
guard var innerState = strongSelf.innerState else {
return
}
guard case .deleting = innerState.actionState else {
return
}
innerState.actionState = .none
strongSelf.updateInnerState(transition: .immediate, with: innerState)
}
}, completed: { [weak self] in
if let strongSelf = self {
strongSelf.completedWithValues?([])
}
}))
}
private func presentGallery(document: SecureIdVerificationDocument) {
guard let innerState = self.innerState else {
return
}
var entries: [SecureIdDocumentGalleryEntry] = []
var index = 0
var centralIndex = 0
if let selfieDocument = innerState.selfieDocument, selfieDocument.id == document.id {
entries.append(SecureIdDocumentGalleryEntry(index: Int32(index), resource: selfieDocument.resource, location: SecureIdDocumentGalleryEntryLocation(position: Int32(index), totalCount: 1), error: ""))
centralIndex = index
index += 1
} else {
for itemDocument in innerState.documents {
entries.append(SecureIdDocumentGalleryEntry(index: Int32(index), resource: itemDocument.resource, location: SecureIdDocumentGalleryEntryLocation(position: Int32(index), totalCount: Int32(innerState.documents.count)), error: ""))
if document.id == itemDocument.id {
centralIndex = index
}
index += 1
}
}
let galleryController = SecureIdDocumentGalleryController(account: self.account, context: self.context, entries: entries, centralIndex: centralIndex, replaceRootController: { _, _ in
})
galleryController.deleteResource = { [weak self] resource in
guard let strongSelf = self else {
return
}
guard var innerState = strongSelf.innerState else {
return
}
if let selfieDocument = innerState.selfieDocument, selfieDocument.resource.isEqual(to: resource) {
innerState.selfieDocument = nil
}
if let frontSideDocument = innerState.frontSideDocument, frontSideDocument.resource.isEqual(to: resource) {
innerState.frontSideDocument = nil
}
if let backSideDocument = innerState.backSideDocument, backSideDocument.resource.isEqual(to: resource) {
innerState.selfieDocument = nil
}
for i in 0 ..< innerState.documents.count {
if innerState.documents[i].resource.isEqual(to: resource) {
innerState.documents.remove(at: i)
break
}
}
strongSelf.updateInnerState(transition: .immediate, with: innerState)
}
self.hiddenItemDisposable.set((galleryController.hiddenMedia |> deliverOnMainQueue).start(next: { [weak self] entry in
guard let strongSelf = self else {
return
}
for itemNode in strongSelf.itemNodes {
if let itemNode = itemNode as? SecureIdValueFormFileItemNode, let item = itemNode.item {
if let entry = entry, let document = item.document, document.resource.isEqual(to: entry.resource) {
itemNode.imageNode.isHidden = true
} else {
itemNode.imageNode.isHidden = false
}
}
}
}))
self.present(galleryController, SecureIdDocumentGalleryControllerPresentationArguments(transitionArguments: { [weak self] entry in
guard let strongSelf = self else {
return nil
}
for itemNode in strongSelf.itemNodes {
if let itemNode = itemNode as? SecureIdValueFormFileItemNode, let item = itemNode.item, let document = item.document {
if document.resource.isEqual(to: entry.resource) {
return GalleryTransitionArguments(transitionNode: (itemNode.imageNode, {
return itemNode.imageNode.view.snapshotContentTree(unhide: true)
}), addToTransitionSurface: { view in
self?.view.addSubview(view)
})
}
}
}
return nil
}))
}
}