@regulaforensics/face-sdk 6.3.3-beta

package/ios/RFSWMain.h

@@ -0,0 +1,23 @@
+#import "RFSWJSONConstructor.h"
+@import FaceSDK;
+
+typedef void (^RFSWCallback)(id _Nullable response);
+typedef void (^RFSWEventSender)(NSString* _Nonnull event, id _Nullable data);
+
+@interface RFSWMain: NSObject<RFSURLRequestInterceptingDelegate,
+                              RFSVideoUploadingDelegate,
+                              RFSCustomizationActionDelegate,
+                              RFSFaceCaptureDelegate,
+                              RFSLivenessDelegate>
+
++(void)methodCall:(NSString* _Nonnull)method
+                 :(NSArray* _Nonnull)args
+                 :(RFSWCallback _Nonnull)callback
+                 :(RFSWEventSender _Nonnull)eventSender;
+
+@end
+
+static NSString* _Nonnull RFSWCameraSwitchEvent = @"cameraSwitchEvent";
+static NSString* _Nonnull RFSWLivenessNotificationEvent = @"livenessNotificationEvent";
+static NSString* _Nonnull RFSWVideoEncoderCompletionEvent = @"video_encoder_completion";
+static NSString* _Nonnull RFSWOnCustomButtonTappedEvent = @"onCustomButtonTappedEvent";

package/ios/RFSWMain.m

@@ -0,0 +1,352 @@
+#import "RFSWMain.h"
+
+@implementation RFSWMain
+
+RFSWMain* RFSWSelf;
+RFSWEventSender RFSWSendEvent;
+
+NSDictionary* RFSWheaders;
+
++(void)methodCall:(NSString*)method :(NSArray*)args :(RFSWCallback)callback :(RFSWEventSender)eventSender {
+    if(!RFSWSelf) RFSWSelf = [RFSWMain new];
+    RFSWSendEvent = eventSender;
+    NSDictionary* Switch = @{
+        @"getVersion": ^{ [self getVersion :callback]; },
+        @"getServiceUrl": ^{ [self getServiceUrl :callback]; },
+        @"setServiceUrl": ^{ [self setServiceUrl :args[0] :callback]; },
+        @"setLocalizationDictionary": ^{ [self setLocalizationDictionary :args[0]]; },
+        @"setRequestHeaders": ^{ [self setRequestHeaders :args[0]]; },
+        @"setCustomization": ^{ [self setCustomization :args[0]]; },
+        @"isInitialized": ^{ [self isInitialized :callback]; },
+        @"initialize": ^{ [self initialize :args[0] :callback]; },
+        @"deinitialize": ^{ [self deinitialize]; },
+        @"startFaceCapture": ^{ [self startFaceCapture :args[0] :callback]; },
+        @"stopFaceCapture": ^{ [self stopFaceCapture]; },
+        @"startLiveness": ^{ [self startLiveness :args[0] :callback]; },
+        @"stopLiveness": ^{ [self stopLiveness]; },
+        @"matchFaces": ^{ [self matchFaces :args[0] :args[1] :callback]; },
+        @"splitComparedFaces": ^{ [self splitComparedFaces :args[0] :args[1] :callback]; },
+        @"detectFaces": ^{ [self detectFaces :args[0] :callback]; },
+        @"createPerson": ^{ [self createPerson :args[0] :args[1] :args[2] :callback]; },
+        @"updatePerson": ^{ [self updatePerson :args[0] :callback]; },
+        @"deletePerson": ^{ [self deletePerson :args[0] :callback]; },
+        @"getPerson": ^{ [self getPerson :args[0] :callback]; },
+        @"addPersonImage": ^{ [self addPersonImage :args[0] :args[1] :callback]; },
+        @"deletePersonImage": ^{ [self deletePersonImage :args[0] :args[1] :callback]; },
+        @"getPersonImage": ^{ [self getPersonImage :args[0] :args[1] :callback]; },
+        @"getPersonImages": ^{ [self getPersonImages :args[0] :callback]; },
+        @"getPersonImagesForPage": ^{ [self getPersonImagesForPage :args[0] :args[1] :args[2] :callback]; },
+        @"createGroup": ^{ [self createGroup :args[0] :args[1] :callback]; },
+        @"updateGroup": ^{ [self updateGroup :args[0] :callback]; },
+        @"editPersonsInGroup": ^{ [self editPersonsInGroup :args[0] :args[1] :callback]; },
+        @"deleteGroup": ^{ [self deleteGroup :args[0] :callback]; },
+        @"getGroup": ^{ [self getGroup :args[0] :callback]; },
+        @"getGroups": ^{ [self getGroups :callback]; },
+        @"getGroupsForPage": ^{ [self getGroupsForPage :args[0] :args[1] :callback]; },
+        @"getPersonGroups": ^{ [self getPersonGroups :args[0] :callback]; },
+        @"getPersonGroupsForPage": ^{ [self getPersonGroupsForPage :args[0] :args[1] :args[2] :callback]; },
+        @"getPersonsInGroup": ^{ [self getPersonsInGroup :args[0] :callback]; },
+        @"getPersonsInGroupForPage": ^{ [self getPersonsInGroupForPage :args[0] :args[1] :args[2] :callback]; },
+        @"searchPerson": ^{ [self searchPerson :args[0] :callback]; },
+    };
+    ((void(^)(void))Switch[method])();
+}
+
++(void)getVersion:(RFSWCallback)callback {
+    callback([RFSWJSONConstructor generateFaceSDKVersion:RFSFaceSDK.service.version]);
+}
+
++(void)getServiceUrl:(RFSWCallback)callback {
+    callback([RFSFaceSDK.service serviceURL]);
+}
+
++(void)setServiceUrl:(NSString*)url :(RFSWCallback)callback {
+    [RFSFaceSDK.service setServiceURL:url];
+    callback(@"");
+}
+
++(void)setLocalizationDictionary:(NSDictionary*)dictionary {
+    RFSFaceSDK.service.localizationHandler = ^NSString* (NSString* localizationKey) {
+        if (dictionary[localizationKey]) return dictionary[localizationKey];
+        return nil;
+    };
+}
+
++(void)setRequestHeaders:(NSDictionary*)headersDict {
+    RFSWheaders = headersDict;
+    RFSFaceSDK.service.requestInterceptingDelegate = RFSWSelf;
+}
+
+-(NSURLRequest*)interceptorPrepareRequest:(NSURLRequest*)request {
+    NSMutableURLRequest *interceptedRequest = [request mutableCopy];
+    for (NSString* key in RFSWheaders.allKeys)
+        [interceptedRequest addValue:[RFSWheaders valueForKey:key] forHTTPHeaderField:key];
+    return interceptedRequest;
+}
+
++(void)setCustomization:(NSDictionary*)config {
+    [RFSWConfig setCustomization:config :RFSFaceSDK.service.customization];
+}
+
++(void)isInitialized:(RFSWCallback)callback {
+    callback(@([RFSFaceSDK.service isInitialized]));
+}
+
++(void)initialize:(NSDictionary*)config :(RFSWCallback)callback {
+    [RFSFaceSDK.service initializeWithConfiguration:[RFSWJSONConstructor initConfigFromJSON:config]
+                                         completion:[RFSWMain initCompletion:callback]];
+}
+
++(void)deinitialize {
+    [RFSFaceSDK.service deinitialize];
+}
+
++(void)startFaceCapture:(NSDictionary*)config :(RFSWCallback)callback {
+    dispatch_async(dispatch_get_main_queue(), ^{
+        [RFSFaceSDK.service presentFaceCaptureViewControllerFrom:[UIApplication sharedApplication].windows.lastObject.rootViewController
+                                                            animated:true
+                                                       configuration:[RFSWConfig faceCaptureConfigFromJSON:config]
+                                                           onCapture:[self faceCaptureCompletion:callback]
+                                                          completion:nil];
+    });
+}
+
++(void)stopFaceCapture {
+    [RFSFaceSDK.service stopFaceCaptureViewController];
+}
+
++(void)startLiveness:(NSDictionary*)config :(RFSWCallback)callback {
+    dispatch_async(dispatch_get_main_queue(), ^{
+        [RFSFaceSDK.service startLivenessFrom:[UIApplication sharedApplication].windows.lastObject.rootViewController
+                                                animated:true
+                                           configuration:[RFSWConfig livenessConfigFromJSON:config]
+                                              onLiveness:[self livenessCompletion:callback]
+                                              completion:nil];
+    });
+}
+
++(void)stopLiveness {
+    [RFSFaceSDK.service stopLivenessProcessing];
+}
+
++(void)matchFaces:(NSDictionary*)request :(NSDictionary*)config :(RFSWCallback)callback {
+    [RFSFaceSDK.service matchFaces:[RFSWJSONConstructor matchFacesRequestFromJSON:request]
+                     configuration:[RFSWConfig matchFacesConfigFromJSON:config]
+                        completion:[self matchFacesCompletion:callback]];
+}
+
++(void)splitComparedFaces:(NSArray*)faces :(NSNumber*)similarity :(RFSWCallback)callback {
+    NSArray* array = [RFSWJSONConstructor arrayFromJSON:faces :@selector(comparedFacesPairFromJSON:)];
+    RFSMatchFacesSimilarityThresholdSplit *split = [RFSMatchFacesSimilarityThresholdSplit splitPairs:array bySimilarityThreshold:similarity];
+    callback([RFSWJSONConstructor generateComparedFacesSplit:split]);
+}
+
++(void)detectFaces:(NSDictionary*)request :(RFSWCallback)callback {
+    [RFSFaceSDK.service detectFacesByRequest:[RFSWJSONConstructor detectFacesRequestFromJSON:request]
+                                  completion:[self detectFacesCompletion:callback]];
+}
+
++(void)createPerson:(NSString*)name :(NSDictionary*)metadata :(NSArray<NSString*>*)groupIds :(RFSWCallback)callback {
+    [RFSFaceSDK.service.personDatabase createPersonWithName:name
+                                                   metadata:metadata
+                                                   groupIds:groupIds
+                                                 completion:[self databaseItemCompletion :callback :@selector(generatePerson:)]];
+}
+
++(void)updatePerson:(NSDictionary*)person :(RFSWCallback)callback {
+    [RFSFaceSDK.service.personDatabase getPersonByPersonId:[RFSWJSONConstructor idFromJSON:person] completion:^(RFSItemResponse<RFSPerson *> * response) {
+        if (response.error) callback([RFSWJSONConstructor generatePersonDBResponse:nil :response.error]);
+        else [RFSFaceSDK.service.personDatabase updatePerson:[RFSWJSONConstructor updatePersonFromJSON:response.item :person]
+                                                 completion:[self databaseCompletion:callback]];
+    }];
+}
+
++(void)deletePerson:(NSString*)personId :(RFSWCallback)callback {
+    [RFSFaceSDK.service.personDatabase deletePersonByPersonId:personId
+                                                   completion:[self databaseCompletion:callback]];
+}
+
++(void)getPerson:(NSString*)personId :(RFSWCallback)callback {
+    [RFSFaceSDK.service.personDatabase getPersonByPersonId:personId
+                                                completion:[self databaseItemCompletion :callback :@selector(generatePerson:)]];
+}
+
++(void)addPersonImage:(NSString*)personId :(NSDictionary*)image :(RFSWCallback)callback {
+    [RFSFaceSDK.service.personDatabase addPersonImageByPersonId:personId
+                                                    imageUpload:[RFSWJSONConstructor imageUploadFromJSON:image]
+                                                     completion:[self databaseItemCompletion :callback :@selector(generatePersonImage:)]];
+}
+
++(void)deletePersonImage:(NSString*)personId :(NSString*)imageId :(RFSWCallback)callback {
+    [RFSFaceSDK.service.personDatabase deletePersonImageByPersonId:personId
+                                                           imageId: imageId
+                                                        completion:[self databaseCompletion:callback]];
+}
+
++(void)getPersonImage:(NSString*)personId :(NSString*)imageId :(RFSWCallback)callback {
+    [RFSFaceSDK.service.personDatabase getPersonImageByPersonId:personId imageId:imageId completion:^(RFSDataResponse* response) {
+        callback([RFSWJSONConstructor generatePersonDBResponse:[RFSWJSONConstructor base64Encode:response.data] :response.error]);
+    }];
+}
+
++(void)getPersonImages:(NSString*)personId :(RFSWCallback)callback {
+    [RFSFaceSDK.service.personDatabase getPersonImagesByPersonId:personId
+                                                      completion:[self databasePageCompletion :callback :@selector(generatePersonImage:)]];
+}
+
++(void)getPersonImagesForPage:(NSString*)personId :(NSNumber*)page :(NSNumber*)size :(RFSWCallback)callback {
+    [RFSFaceSDK.service.personDatabase getPersonImagesByPersonId:personId
+                                                            page:[page integerValue]
+                                                            size:[size integerValue]
+                                                      completion:[self databasePageCompletion :callback :@selector(generatePersonImage:)]];
+}
+
++(void)createGroup:(NSString*)name :(NSDictionary*)metadata :(RFSWCallback)callback {
+    [RFSFaceSDK.service.personDatabase createGroupWithName:name
+                                                  metadata:metadata
+                                                completion:[self databaseItemCompletion :callback :@selector(generatePersonGroup:)]];
+}
+
++(void)updateGroup:(NSDictionary*)group :(RFSWCallback)callback {
+    [RFSFaceSDK.service.personDatabase getGroupByGroupId:[RFSWJSONConstructor idFromJSON:group] completion:^(RFSItemResponse<RFSPersonGroup *> * response) {
+        if (response.error) callback([RFSWJSONConstructor generatePersonDBResponse:nil :response.error]);
+        else [RFSFaceSDK.service.personDatabase updateGroup:[RFSWJSONConstructor updatePersonGroupFromJSON:response.item :group]
+                                                 completion:[self databaseCompletion:callback]];
+    }];
+}
+
++(void)editPersonsInGroup:(NSString*)groupId :(NSDictionary*)editGroupPersonsRequest :(RFSWCallback)callback {
+    [RFSFaceSDK.service.personDatabase editGroupPersonsByGroupId:groupId
+                                                         request:[RFSWJSONConstructor editGroupPersonsRequestFromJSON:editGroupPersonsRequest]
+                                                      completion:[self databaseCompletion:callback]];
+}
+
++(void)deleteGroup:(NSString*)groupId :(RFSWCallback)callback {
+    [RFSFaceSDK.service.personDatabase deleteGroupByGroupId:groupId
+                                                 completion:[self databaseCompletion:callback]];
+}
+
++(void)getGroup:(NSString*)groupId :(RFSWCallback)callback {
+    [RFSFaceSDK.service.personDatabase getGroupByGroupId:groupId
+                                              completion:[self databaseItemCompletion :callback :@selector(generatePersonGroup:)]];
+}
+
++(void)getGroups:(RFSWCallback)callback {
+    [RFSFaceSDK.service.personDatabase getGroups:[self databasePageCompletion :callback :@selector(generatePersonGroup:)]];
+}
+
++(void)getGroupsForPage:(NSNumber*)page :(NSNumber*)size :(RFSWCallback)callback {
+    [RFSFaceSDK.service.personDatabase getGroupsForPage:[page integerValue]
+                                                   size:[size integerValue]
+                                             completion:[self databasePageCompletion :callback :@selector(generatePersonGroup:)]];
+}
+
++(void)getPersonGroups:(NSString*)personId :(RFSWCallback)callback {
+    [RFSFaceSDK.service.personDatabase getPersonGroupsByPersonId:personId
+                                                      completion:[self databasePageCompletion :callback :@selector(generatePersonGroup:)]];
+}
+
++(void)getPersonGroupsForPage:(NSString*)personId :(NSNumber*)page :(NSNumber*)size :(RFSWCallback)callback {
+    [RFSFaceSDK.service.personDatabase getPersonGroupsByPersonId:personId
+                                                            page:[page integerValue]
+                                                            size:[size integerValue]
+                                                      completion:[self databasePageCompletion :callback :@selector(generatePersonGroup:)]];
+}
+
++(void)getPersonsInGroup:(NSString*)groupId :(RFSWCallback)callback {
+    [RFSFaceSDK.service.personDatabase getGroupPersonsByGroupId:groupId
+                                                     completion:[self databasePageCompletion :callback :@selector(generatePerson:)]];
+}
+
++(void)getPersonsInGroupForPage:(NSString*)groupId :(NSNumber*)page :(NSNumber*)size :(RFSWCallback)callback {
+    [RFSFaceSDK.service.personDatabase getGroupPersonsByGroupId:groupId
+                                                           page:[page integerValue]
+                                                           size:[size integerValue]
+                                                     completion:[self databasePageCompletion :callback :@selector(generatePerson:)]];
+}
+
++(void)searchPerson:(NSDictionary*)searchPersonRequest :(RFSWCallback)callback {
+    [RFSFaceSDK.service.personDatabase searchPerson:[RFSWJSONConstructor searchPersonRequestFromJSON:searchPersonRequest]
+                                         completion:^(RFSSearchPersonResponse *response) {
+        callback([RFSWJSONConstructor generatePersonDBResponse:[RFSWJSONConstructor generateArray:response.results :@selector(generateSearchPerson:)] :response.error]);
+    }];
+}
+
++(RFSInitializationCompletion)initCompletion:(RFSWCallback)callback {
+    return ^(BOOL success, NSError* error) {
+        RFSFaceSDK.service.customization.configuration = [RFSUIConfiguration defaultConfiguration];
+        [RFSFaceSDK.service setVideoUploadingDelegate:RFSWSelf];
+        [RFSFaceSDK.service setFaceCaptureDelegate:RFSWSelf];
+        [RFSFaceSDK.service setLivenessDelegate:RFSWSelf];
+        RFSFaceSDK.service.customization.actionDelegate = RFSWSelf;
+        callback([RFSWJSONConstructor generateInitCompletion:success :error]);
+    };
+}
+
++(void (^)(RFSFaceCaptureResponse*)) faceCaptureCompletion:(RFSWCallback)callback {
+    return ^(RFSFaceCaptureResponse* response) {
+        callback([RFSWJSONConstructor generateFaceCaptureResponse:response]);
+    };
+}
+
++(void (^)(RFSLivenessResponse*)) livenessCompletion:(RFSWCallback)callback {
+    return ^(RFSLivenessResponse* response) {
+        callback([RFSWJSONConstructor generateLivenessResponse:response]);
+    };
+}
+
++(void (^)(RFSMatchFacesResponse*)) matchFacesCompletion:(RFSWCallback)callback {
+    return ^(RFSMatchFacesResponse* response) {
+        callback([RFSWJSONConstructor generateMatchFacesResponse:response]);
+    };
+}
+
++(void (^)(RFSDetectFacesResponse*)) detectFacesCompletion:(RFSWCallback)callback {
+    return ^(RFSDetectFacesResponse* response) {
+        callback([RFSWJSONConstructor generateDetectFacesResponse:response]);
+    };
+}
+
++(void (^)(RFSComfirmResponse *response))databaseCompletion:(RFSWCallback)callback {
+    return ^(RFSComfirmResponse *response) {
+        callback([RFSWJSONConstructor generatePersonDBResponse:@YES :response.error]);
+    };
+}
+
++(void (^)(RFSItemResponse<RFSDBBaseItem *> *response))databaseItemCompletion:(RFSWCallback)callback :(SEL)toJson {
+    return ^(RFSItemResponse<RFSDBBaseItem *> *response) {
+        callback([RFSWJSONConstructor generatePersonDBResponse:[RFSWJSONConstructor performSelector:toJson withObject:response.item] :response.error]);
+    };
+}
+
++(void (^)(RFSPageResponse<RFSDBBaseItem *> *response))databasePageCompletion:(RFSWCallback)callback :(SEL)toJson {
+    return ^(RFSPageResponse<RFSDBBaseItem *> *response) {
+        callback([RFSWJSONConstructor generatePersonDBResponse:@{
+            @"items": [RFSWJSONConstructor generateArray:response.items :toJson],
+            @"page": @(response.page),
+            @"totalPages": @(response.totalPages),
+        } :response.error]);
+    };
+}
+
+// RFSFaceCaptureDelegate & RFSLivenessDelegate
+-(void)cameraPositionChanged:(RFSCameraPosition)cameraPosition {
+    RFSWSendEvent(RFSWCameraSwitchEvent, @(cameraPosition));
+}
+
+// RFSLivenessDelegate
+-(void)processStatusChanged:(RFSLivenessProcessStatus)status result:(RFSLivenessResponse*)result {
+    RFSWSendEvent(RFSWLivenessNotificationEvent, [RFSWJSONConstructor generateLivenessNotification:status result:result]);
+}
+
+// RFSVideoUploadingDelegate
+-(void)videoUploadingForTransactionId:(NSString*)transactionId didFinishedWithSuccess:(BOOL)success {
+    RFSWSendEvent(RFSWVideoEncoderCompletionEvent, [RFSWJSONConstructor generateVideoEncoderCompletion:transactionId :success]);
+}
+
+// RFSCustomizationActionDelegate
+-(void)onFaceCustomButtonTappedWithTag:(NSInteger)tag {
+    RFSWSendEvent(RFSWOnCustomButtonTappedEvent, @(tag));
+}
+
+@end

package/ios/RNFaceSDK.h

@@ -0,0 +1,8 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+#import "RFSWMain.h"
+@import UIKit;
+
+@interface RNFaceSDK : RCTEventEmitter <RCTBridgeModule>
+
+@end

package/ios/RNFaceSDK.m

@@ -0,0 +1,42 @@
+#import "RNFaceSDK.h"
+
+RNFaceSDK* RFSWPlugin;
+@implementation RNFaceSDK
+RCT_EXPORT_MODULE();
+
+NSMutableArray<RCTResponseSenderBlock>* _firedCallbacks = nil;
+- (NSMutableArray<RCTResponseSenderBlock>*)firedCallbacks {
+    if (_firedCallbacks == nil) _firedCallbacks = @[].mutableCopy;
+    return _firedCallbacks;
+}
+
+- (NSArray<NSString*>*)supportedEvents {
+    return @[RFSWCameraSwitchEvent,
+             RFSWLivenessNotificationEvent,
+             RFSWVideoEncoderCompletionEvent,
+             RFSWOnCustomButtonTappedEvent];
+}
+
+bool hasListeners;
+- (void)startObserving { hasListeners = YES; }
+- (void)stopObserving { hasListeners = NO; }
+
+RCT_EXPORT_METHOD(exec:(NSString*)method:(NSArray*)args:(RCTPromiseResolveBlock)resolve:(RCTPromiseRejectBlock)reject) {
+    RFSWPlugin = self;
+    
+    RFSWCallback callback = ^(id _Nullable data) {
+        if ([self.firedCallbacks containsObject:resolve]) return;
+        [self.firedCallbacks addObject:resolve];
+        resolve([RFSWJSONConstructor toSendable:data]);
+    };
+    
+    RFSWEventSender sendEvent = ^(NSString* event, id data) {
+        dispatch_async(dispatch_get_main_queue(), ^{
+            if (hasListeners) [RFSWPlugin sendEventWithName:event body:[RFSWJSONConstructor toSendable:data]];
+        });
+    };
+    
+    [RFSWMain methodCall:method :args :callback :sendEvent];
+}
+
+@end

package/ios-ci/.gitlab-ci.yml

@@ -0,0 +1,41 @@
+# Official language image. Look for the different tagged releases at:
+# https://hub.docker.com/r/library/python/tags/
+image: python:latest
+
+# Change pip's cache directory to be inside the project directory since we can
+# only cache local items.
+variables:
+  PIP_CACHE_DIR: "$CI_PROJECT_DIR/.cache/pip"
+
+# Pip's cache doesn't store the python packages
+# https://pip.pypa.io/en/stable/reference/pip_install/#caching
+#
+# If you want to also cache the installed packages, you have to install
+# them in a virtualenv and cache it as well.
+cache:
+  paths:
+    - .cache/pip
+    - venv/
+
+before_script:
+  - python -V  # Print out python version for debugging
+  - pip install virtualenv
+  - virtualenv venv
+  - source venv/bin/activate
+  - pip install poetry
+  - poetry install
+
+stages:
+  - build
+  - test
+
+build-job:
+  stage: build
+  script:
+    - poetry build
+
+unit-test-job:
+  stage: test
+  script:
+    - poetry run pytest
+    

package/ios-ci/.sample-env

@@ -0,0 +1,22 @@
+# This is a sample .env file for use in local development.
+# Duplicate this file as .env in the root of the project
+# and update the environment variables to match your needs.
+
+# Overrides FTP host for Temp uploads.
+# This is usefull when you are under a VPN and the FTP host is different.
+LOCAL_FTP_RENAME=
+
+# Credentials for public github repositories access. Needed for updating SPM manifests.
+GITHUB_USERNAME=
+GITHUB_PASSWORD=
+
+# Credentials for public pods FTP.
+PUBLIC_UPLOAD_FTP_USERNAME=
+PUBLIC_UPLOAD_FTP_PASSWORD=
+
+# Credentials for private pods FTP.
+PRIVATE_UPLOAD_FTP_USERNAME=
+PRIVATE_UPLOAD_FTP_PASSWORD=
+
+# Sets how many times inject-dependency will retry to redownload a dependency when unzip fails.
+IOS_CI_DEPENDENCY_DOWNLOAD_ATTEMPTS=

package/ios-ci/README.md

@@ -0,0 +1,97 @@
+# iOS CI
+Collection of tools related to Continuous Integration for iOS Platform
+
+## Dependencies
+We manage our dependencies with [Poetry](!https://python-poetry.org/docs/#osx--linux--bashonwindows-install-instructions). 
+
+Make sure to install `poetry` and dependencies before using `ios-ci`.
+```bash
+poetry install
+```
+
+## Configuration  
+
+The app supports `.env` configuration.  
+Please see `.sample-env` for more information on the environment variables.  
+
+## Installation
+
+You can install the package globally as an executable and run `ci [command]` instead of `poetry run ci [command]`.  
+This may be usefull when you dont want to have this project as a working directory for calling the commands.  
+
+The script will build the project and install it using pip3.
+```bash
+bash install.sh
+```
+
+## Commands
+The CLI supports help description of the options.  
+Run the command with `-h` or `--help` to get more information.  
+```bash
+poetry run ci --help
+```
+
+### Inject dependency
+Downloads and unzips specified dependency.  
+
+Supports exact version and `+`.  
+Finds the most appropriate location for the framework to store if the directory is not specified explicitly.  
+If there is a Pods directory - the dependency will be injected there.  
+Otherwise the location is the root of the host project.  
+
+```bash
+poetry run ci inject-dependency --help
+poetry run ci inject-dependency -n FaceSDK -v + -t Release -d ./Dependency 
+poetry run ci inject-dependency -n RegulaCommon -v + -t Release
+poetry run ci inject-dependency -n fullrfid -v + -t Temp -b develop                                            
+```
+
+
+### FTP Upload
+Determines the ftp location (private or public FTP server) by the name and the version of a package.  
+Creates `.zip` archive and upload the build to the server.  
+
+Prompts the user with credentials for the FTP server.  
+To skip the interaction please specify environment variables:  
+```
+PUBLIC_UPLOAD_FTP_USERNAME
+PUBLIC_UPLOAD_FTP_PASSWORD
+PRIVATE_UPLOAD_FTP_USERNAME
+PRIVATE_UPLOAD_FTP_PASSWORD
+```
+
+```bash
+poetry run ci ftp-upload --help
+poetry run ci ftp-upload -n BTDevice -v 0.1.0 -t Temp -p ./temp/BTDevice.framework
+poetry run ci ftp-upload -n FaceSDK -v 0.1.0 -t Beta -p ../Build/FaceSDK.xcframework
+```
+
+### Depdendency Version
+Fetches the version of a dependency by the name and the type.
+
+```bash
+poetry run ci dependency-version --help
+poetry run ci dependency-version -n fullrfid -t Beta
+poetry run ci dependency-version -n FaceSDK -t Beta
+poetry run ci dependency-version -n RegulaCommon -t Temp -b develop
+```
+
+
+### Publish SwiftPackage Manifest
+Updates the `SPM` repository manifest with provided version and `.zip` archived build.  
+
+```bash
+poetry run ci update-spm --help
+poetry run ci update-spm -v 3.0.799 -f ../Build/FaceSDK.xcframework.zip -r https://github.com/regulaforensics/FaceSDK-Swift-Package
+```
+
+### Create .podspec file
+Creates a `.podspec` file for a package at a given location with a dependency.
+Packages such as `FaceSDK`, `DocumentReader` and `IRS` require specifying a dependency.
+
+```bash
+
+poetry run ci create-podspec --help
+poetry run ci create-podspec -n FaceSDK -v "1.0.3" -t Release --d RegulaCommon Temp 1.1.1
+poetry run ci create-podspec -n FaceSDK -v "1.0.3" -t Release --d RegulaCommon 1.1.1 Release -d ../
+```

package/ios-ci/RegulaDanger/Package.swift

@@ -0,0 +1,34 @@
+// swift-tools-version:5.3
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+let package = Package(
+    name: "RegulaDanger",
+    products: [
+        // Products define the executables and libraries a package produces, and make them visible to other packages.
+        .library(
+            name: "RegulaDanger",
+            targets: ["RegulaDanger"]
+        ),
+    ],
+    dependencies: [
+        // Dependencies declare other packages that this package depends on.
+        // .package(url: /* package url */, from: "1.0.0"),
+        .package(name: "danger-swift", url: "https://github.com/danger/swift", .upToNextMinor(from: "3.12.0"))
+    ],
+    targets: [
+        // Targets are the basic building blocks of a package. A target can define a module or a test suite.
+        // Targets can depend on other targets in this package, and on products in packages this package depends on.
+        .target(
+            name: "RegulaDanger",
+            dependencies: [
+                .product(name: "Danger", package: "danger-swift")
+            ]
+        ),
+        .testTarget(
+            name: "RegulaDangerTests",
+            dependencies: ["RegulaDanger"]
+        ),
+    ]
+)

package/ios-ci/RegulaDanger/Sources/RegulaDanger/RegulaDanger.swift

@@ -0,0 +1,44 @@
+import Danger
+import Foundation
+
+public enum RegulaDanger {
+    public static func lint(using danger: DangerDSL = Danger(), rootSourceFolderName: String = "Sources") {
+        validateFiles(using: danger, rootSourceFolderName: rootSourceFolderName)
+        validateMegeRequest(using: danger)
+
+        if danger.hasReports {
+            danger.message("Reported by [Regula's iOS-CI](http://gitlab.regula.local/mobile-sdk/ios-ci).")
+        }
+    }
+
+    static func validateFiles(using danger: DangerDSL, rootSourceFolderName: String) {
+        let allFiles = Set(danger.git.createdFiles).union(danger.git.modifiedFiles)
+
+        let changelogChanged = allFiles.contains("CHANGELOG.md")
+        let sourceChanges = allFiles.first(where: { $0.hasPrefix(rootSourceFolderName) })
+        if !changelogChanged && sourceChanges != nil {
+            warn("No CHANGELOG entry added.")
+        }
+    }
+
+    static func validateMegeRequest(using danger: DangerDSL) {
+        guard let mr = danger.gitLab?.mergeRequest else {
+            print("There is no gitlab.")
+            return
+        }
+
+        if !mr.description.contains("app.clickup.com") {
+            danger.warn("Missing a link to the task from the [clickup](https://app.clickup.com/4535044/home) in the Merge Request description.")
+        }
+
+        if mr.title.range(of: #"SP-\d+:"#, options: .regularExpression) == nil {
+            danger.warn("Missing a task prefix in the Merge Request title. Expected format `SP-X: \(mr.title)` where `X` is a task number from the [clickup](https://app.clickup.com/4535044/home).")
+        }
+    }
+}
+
+extension DangerDSL {
+    var hasReports: Bool {
+        return !self.fails.isEmpty || !self.warnings.isEmpty || !self.messages.isEmpty || !self.markdowns.isEmpty
+    }
+}

package/ios-ci/RegulaDanger/Tests/LinuxMain.swift

@@ -0,0 +1,7 @@
+import XCTest
+
+import RegulaDangerTests
+
+var tests = [XCTestCaseEntry]()
+tests += RegulaDangerTests.allTests()
+XCTMain(tests)