Vl 6035

VCL/VCL/api/entities/VCLServiceTypeDynamic.swift

@@ -0,0 +1,30 @@
+//
+//  VCLServiceTypeDynamic.swift
+//  VCL
+//
+//  Created by Michael Avoyan on 26/10/2023.
+//
+//  Copyright 2022 Velocity Career Labs inc.
+//  SPDX-License-Identifier: Apache-2.0
+
+import Foundation
+
+public struct VCLServiceTypeDynamic {
+    public let payload: [String: Any]
+
+    public init(payload: [String : Any]) {
+        self.payload = payload
+    }
+
+    public var serviceType: String { get { payload[CodingKeys.KeyServiceType] as? String ?? "" } }
+    public var serviceCategory: String { get { payload[CodingKeys.KeyServiceCategory] as? String ?? "" } }
+    public var notary: Bool { get { payload[CodingKeys.KeyNotary] as? Bool ?? false } }
+    public var credentialGroup: String { get { payload[CodingKeys.KeyCredentialGroup] as? String ?? "" } }
+
+    public struct CodingKeys {
+        public static let KeyServiceType = "serviceType"
+        public static let KeyServiceCategory = "serviceCategory"
+        public static let KeyNotary = "notary"
+        public static let KeyCredentialGroup = "credentialGroup"
+    }
+}

VCL/VCL/api/entities/VCLServiceTypesDynamic.swift

@@ -0,0 +1,22 @@
+//
+//  VCLServiceTypesDynamic.swift
+//  VCL
+//
+//  Created by Michael Avoyan on 26/10/2023.
+//
+//  Copyright 2022 Velocity Career Labs inc.
+//  SPDX-License-Identifier: Apache-2.0
+
+import Foundation
+
+public struct VCLServiceTypesDynamic {
+    public let all: [VCLServiceTypeDynamic]
+
+    public init(all: [VCLServiceTypeDynamic]) {
+        self.all = all
+    }
+
+    public struct CodingKeys {
+        public static let KeyServiceTypes = "serviceTypes"
+    }
+}

VCL/VCL/impl/VCLImpl.swift

@@ -9,13 +9,14 @@
 
 public class VCLImpl: VCL {
 
-    private static let ModelsToInitializeAmount = 3
+    private static let ModelsToInitializeAmount = 4
 
     private var initializationDescriptor: VCLInitializationDescriptor!
 
     private var credentialTypesModel: CredentialTypesModel!
     private var credentialTypeSchemasModel: CredentialTypeSchemasModel!
     private var countriesModel: CountriesModel!
+    private var serviceTypesModel: ServiceTypesModel!
 
     private var presentationRequestUseCase: PresentationRequestUseCase!
     private var presentationSubmissionUseCase: PresentationSubmissionUseCase!
@@ -115,6 +116,8 @@ public class VCLImpl: VCL {
 
         countriesModel = VclBlocksProvider.provideCountriesModel()
 
+        serviceTypesModel = VclBlocksProvider.provideServiceTypesModel()
+
         countriesModel.initialize(cacheSequence: cacheSequence) { [weak self] result in
             do {
                 _ = try result.get()
@@ -158,6 +161,19 @@ public class VCLImpl: VCL {
                 }
             }
         }
+
+        serviceTypesModel.initialize(cacheSequence: cacheSequence) { [weak self] result in
+            do {
+                _ = try result.get()
+                if self?.initializationWatcher.onInitializedModel(error: nil) == true {
+                    self?.completionHandler(successHandler, errorHandler)
+                }
+            } catch {
+                if self?.initializationWatcher.onInitializedModel(error: error as? VCLError) == true {
+                    self?.completionHandler(successHandler, errorHandler)
+                }
+            }
+        }
     }
 
     private func initGlobalConfigurations() {

VCL/VCL/impl/VclBlocksProvider.swift

@@ -134,6 +134,18 @@ class VclBlocksProvider {
         )
     }
 
+    static func provideServiceTypesModel() -> ServiceTypesModel {
+        return ServiceTypesModelImpl(
+            ServiceTypesUseCaseImpl(
+                ServiceTypesRepositoryImpl(
+                    NetworkServiceImpl(),
+                    CacheServiceImpl()
+                ),
+                ExecutorImpl()
+            )
+        )
+    }
+
     static func providePresentationRequestUseCase(
         _ cryptoServicesDescriptor: VCLCryptoServicesDescriptor
     ) throws -> PresentationRequestUseCase {

VCL/VCL/impl/data/infrastructure/db/CacheServiceImpl.swift

@@ -14,6 +14,7 @@ class CacheServiceImpl: CacheService {
     private static let KEY_CACHE_SEQUENCE_COUNTRIES = "KEY_CACHE_SEQUENCE_COUNTRIES"
     private static let KEY_CACHE_SEQUENCE_CREDENTIAL_TYPES = "KEY_CACHE_SEQUENCE_CREDENTIAL_TYPES"
     private static let KEY_CACHE_SEQUENCE_CREDENTIAL_TYPE_SCHEMA = "KEY_CACHE_SEQUENCE_CREDENTIAL_TYPE_SCHEMA"
+    private static let KEY_CACHE_SEQUENCE_SERVICE_TYPES = "KEY_CACHE_SEQUENCE_SERVICE_TYPES"
 
     private var defaults: UserDefaults = UserDefaults()
 
@@ -63,4 +64,16 @@ class CacheServiceImpl: CacheService {
     func isResetCacheCredentialTypeSchema(cacheSequence: Int) -> Bool {
         return getInt(key: CacheServiceImpl.KEY_CACHE_SEQUENCE_CREDENTIAL_TYPE_SCHEMA) < cacheSequence
     }
+
+    func getServiceTypes(key: String) -> Data? {
+        return getData(key: key)
+    }
+    func setServiceTypes(key: String, value: Data, cacheSequence: Int) {
+        setData(key: key, value: value)
+        setInt(key: CacheServiceImpl.KEY_CACHE_SEQUENCE_SERVICE_TYPES, value: cacheSequence)
+    }
+    func isResetCacheServiceTypes(cacheSequence: Int) -> Bool {
+        return getInt(key: CacheServiceImpl.KEY_CACHE_SEQUENCE_SERVICE_TYPES) < cacheSequence
+    }
+
 }

VCL/VCL/impl/data/models/CountriesModelImpl.swift

@@ -10,7 +10,7 @@
 import Foundation
 
 class CountriesModelImpl: CountriesModel {
-
+    
     private(set) var data: VCLCountries? = nil
     let countriesUseCase: CountriesUseCase
 
@@ -23,9 +23,9 @@ class CountriesModelImpl: CountriesModel {
         completionBlock: @escaping (VCLResult<VCLCountries>) -> Void
     ) {
         countriesUseCase.getCountries(cacheSequence: cacheSequence) { [weak self] result in
-                do {
-                    self?.data = try result.get()
-                } catch {}
+            do {
+                self?.data = try result.get()
+            } catch {}
             completionBlock(result)
         }
     }

VCL/VCL/impl/data/models/IdentificationModelImpl.swift

@@ -4,8 +4,8 @@
 //
 //  Created by Michael Avoyan on 18/07/2021.
 //
-// Copyright 2022 Velocity Career Labs inc.
-// SPDX-License-Identifier: Apache-2.0
+//  Copyright 2022 Velocity Career Labs inc.
+//  SPDX-License-Identifier: Apache-2.0
 
 import Foundation
 

VCL/VCL/impl/data/models/ServiceTypesModelImpl.swift

@@ -0,0 +1,32 @@
+//
+//  ServiceTypesModelImpl.swift
+//  VCL
+//
+//  Created by Michael Avoyan on 29/10/2023.
+//
+//  Copyright 2022 Velocity Career Labs inc.
+//  SPDX-License-Identifier: Apache-2.0
+
+import Foundation
+
+class ServiceTypesModelImpl: ServiceTypesModel {
+    var data: VCLServiceTypesDynamic?
+
+    private let serviceTypesUseCase: ServiceTypesUseCase
+
+    init(_ serviceTypesUseCase: ServiceTypesUseCase) {
+        self.serviceTypesUseCase = serviceTypesUseCase
+    }
+
+    func initialize(
+        cacheSequence: Int,
+        completionBlock: @escaping (VCLResult<VCLServiceTypesDynamic>) -> Void
+    ) {
+        serviceTypesUseCase.getServiceTypes(cacheSequence: cacheSequence) { [weak self] result in
+            do {
+                self?.data = try result.get()
+            } catch {}
+            completionBlock(result)
+        }
+    }
+}

VCL/VCL/impl/data/repositories/ServiceTypesRepositoryImpl.swift

@@ -0,0 +1,86 @@
+//
+//  ServiceTypesRepositoryImpl.swift
+//  VCL
+//
+//  Created by Michael Avoyan on 26/10/2023.
+//
+
+import Foundation
+
+class ServiceTypesRepositoryImpl: ServiceTypesRepository {
+
+    private let networkService: NetworkService
+    private let cacheService: CacheService
+
+    init(
+        _ networkService: NetworkService, 
+        _ cacheService: CacheService) {
+        self.networkService = networkService
+        self.cacheService = cacheService
+    }
+
+    func getServiceTypes(
+        cacheSequence: Int,
+        completionBlock: @escaping (VCLResult<VCLServiceTypesDynamic>) -> Void
+    ) {
+        let endpoint = Urls.ServiceTypes
+        if (cacheService.isResetCacheServiceTypes(cacheSequence: cacheSequence)) {
+            fetchServiceTypes(endpoint, cacheSequence, completionBlock)
+        } else {
+            if let serviceTypesData = cacheService.getServiceTypes(key: endpoint) {
+                if let serviceTypes =  parse(serviceTypesData.toDictionary()) {
+                    completionBlock(.success(serviceTypes))
+                } else {
+                    completionBlock(.failure(VCLError(message: "Failed to parse \(String(data: serviceTypesData, encoding: .utf8) ?? "")")))
+                }
+            } else {
+                fetchServiceTypes(endpoint, cacheSequence, completionBlock)
+            }
+        }
+    }
+
+    private func fetchServiceTypes(
+        _ endpoint: String,
+        _ cacheSequence: Int,
+        _ completionBlock: @escaping (VCLResult<VCLServiceTypesDynamic>) -> Void
+    ) {
+        networkService.sendRequest(
+            endpoint: endpoint,
+            contentType: Request.ContentType.ApplicationJson,
+            method: Request.HttpMethod.GET,
+            headers: [(HeaderKeys.XVnfProtocolVersion, HeaderValues.XVnfProtocolVersion)],
+            completionBlock: { [weak self] result in
+                do {
+                    let serviceTypesData = try result.get().payload
+                    self?.cacheService.setServiceTypes(
+                        key: endpoint,
+                        value: serviceTypesData,
+                        cacheSequence: cacheSequence
+                    )
+                    if let serviceTypes =  self?.parse(serviceTypesData.toDictionary()) {
+                        completionBlock(.success(serviceTypes))
+                    } else {
+                        completionBlock(.failure(VCLError(message: "Failed to parse \(String(data: serviceTypesData, encoding: .utf8) ?? "")")))
+                    }
+                } catch {
+                    completionBlock(.failure(error as? VCLError ?? VCLError(error: error)))
+                }
+            }
+        )
+    }
+
+    private func parse(_ serviceTypesJsonObj: [String: Any]?) -> VCLServiceTypesDynamic? {
+        if let serviceTypesJsonArr = 
+            serviceTypesJsonObj?[VCLServiceTypesDynamic.CodingKeys.KeyServiceTypes] as? [Any] {
+            var serviceTypesArr = [VCLServiceTypeDynamic]()
+            serviceTypesJsonArr.forEach {
+                if let payload = $0 as? [String: Any] {
+                    serviceTypesArr.append(VCLServiceTypeDynamic(payload: payload))
+                }
+            }
+            return VCLServiceTypesDynamic(all: serviceTypesArr)
+        } else {
+            return nil
+        }
+    }
+}

VCL/VCL/impl/data/repositories/Urls.swift

@@ -24,6 +24,7 @@ struct Urls {
     private static var BaseUrlRegistrar: String { get { "https://\(EnvironmentPrefix)registrar.velocitynetwork.foundation" } }
 //    private static var BaseUrlWalletApi: String { get { "https://\(EnvironmentPrefix)walletapi.velocitycareerlabs.io" } }
 
+    static var ServiceTypes: String { get { "\(BaseUrlRegistrar)/api/v0.6/service-types" } }
     static var CredentialTypes: String { get { "\(BaseUrlRegistrar)/api/v0.6/credential-types" } }
     static var CredentialTypeSchemas: String { get { "\(BaseUrlRegistrar)/schemas/" } }
     static var Countries: String { get { "\(BaseUrlRegistrar)/reference/countries" } }

VCL/VCL/impl/data/usecases/ServiceTypesUseCaseImpl.swift

@@ -0,0 +1,34 @@
+//
+//  ServiceTypesUseCaseImpl.swift
+//  VCL
+//
+//  Created by Michael Avoyan on 29/10/2023.
+//
+//  Copyright 2022 Velocity Career Labs inc.
+//  SPDX-License-Identifier: Apache-2.0
+
+import Foundation
+
+class ServiceTypesUseCaseImpl: ServiceTypesUseCase {
+    private let serviceTypesRepository: ServiceTypesRepository
+    private let executor: Executor
+
+    init(
+        _ serviceTypesRepository: ServiceTypesRepository,
+        _ executor: Executor
+    ) {
+        self.serviceTypesRepository = serviceTypesRepository
+        self.executor = executor
+    }
+
+    func getServiceTypes(
+        cacheSequence: Int,
+        completionBlock: @escaping (VCLResult<VCLServiceTypesDynamic>) -> Void
+    ) {
+        executor.runOnBackground  { [weak self] in
+            self?.serviceTypesRepository.getServiceTypes(cacheSequence: cacheSequence) { serviceTypes in
+                self?.executor.runOnMain { completionBlock(serviceTypes) }
+            }
+        }
+    }
+}

VCL/VCL/impl/domain/infrastructure/db/CacheService.swift

@@ -21,4 +21,8 @@ protocol CacheService {
     func getCredentialTypeSchema(key: String) -> Data?
     func setCredentialTypeSchema(key: String, value: Data, cacheSequence: Int)
     func isResetCacheCredentialTypeSchema(cacheSequence: Int) -> Bool
+
+    func getServiceTypes(key: String) -> Data?
+    func setServiceTypes(key: String, value: Data, cacheSequence: Int)
+    func isResetCacheServiceTypes(cacheSequence: Int) -> Bool
 }

VCL/VCL/impl/domain/models/Model.swift

@@ -4,8 +4,8 @@
 //
 //  Created by Michael Avoyan on 17/03/2021.
 //
-// Copyright 2022 Velocity Career Labs inc.
-// SPDX-License-Identifier: Apache-2.0
+//  Copyright 2022 Velocity Career Labs inc.
+//  SPDX-License-Identifier: Apache-2.0
 
 import Foundation
 

VCL/VCL/impl/domain/models/ServiceTypesModel.swift

@@ -0,0 +1,19 @@
+//
+//  ServiceTypesModel.swift
+//  VCL
+//
+//  Created by Michael Avoyan on 29/10/2023.
+//
+//  Copyright 2022 Velocity Career Labs inc.
+//  SPDX-License-Identifier: Apache-2.0
+
+import Foundation
+
+protocol ServiceTypesModel: Model {
+    var data: VCLServiceTypesDynamic? { get }
+
+    func initialize(
+        cacheSequence: Int,
+        completionBlock: @escaping (VCLResult<VCLServiceTypesDynamic>) -> Void
+    )
+}

VCL/VCL/impl/domain/repositories/ServiceTypesRepository.swift

@@ -0,0 +1,17 @@
+//
+//  ServiceTypesRepository.swift
+//  VCL
+//
+//  Created by Michael Avoyan on 26/10/2023.
+//
+// Copyright 2022 Velocity Career Labs inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import Foundation
+
+protocol ServiceTypesRepository {
+    func getServiceTypes(
+        cacheSequence: Int,
+        completionBlock: @escaping (VCLResult<VCLServiceTypesDynamic>) -> Void
+    )
+}