http://git-wip-us.apache.org/repos/asf/usergrid/blob/7442c881/sdks/swift/Samples/ActivityFeed/Pods/UsergridSDK/sdks/swift/Source/Usergrid.swift ---------------------------------------------------------------------- diff --git a/sdks/swift/Samples/ActivityFeed/Pods/UsergridSDK/sdks/swift/Source/Usergrid.swift b/sdks/swift/Samples/ActivityFeed/Pods/UsergridSDK/sdks/swift/Source/Usergrid.swift new file mode 100644 index 0000000..78769ae --- /dev/null +++ b/sdks/swift/Samples/ActivityFeed/Pods/UsergridSDK/sdks/swift/Source/Usergrid.swift @@ -0,0 +1,610 @@ +// +// Usergrid.swift +// UsergridSDK +// +// Created by Robert Walsh on 7/21/15. +// +/* + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. The ASF licenses this file to You + * under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. For additional information regarding + * copyright in this work, please see the NOTICE file in the top level + * directory of this distribution. + * + */ + +import Foundation + +/// The version number for the Usergrid Swift SDK. +public let UsergridSDKVersion = "2.1.0" + +/** + The `Usergrid` class acts as a static shared instance manager for the `UsergridClient` class. + + The methods and variables in this class are all static and therefore you will never need or want to initialize an instance of the `Usergrid` class. + + Use of this class depends on initialization of the shared instance of the `UsergridClient` object. Because of this, before using any of the static methods + provided you will need to call one of the shared instance initialization methods. Failure to do so will result in failure from all methods. + */ +public class Usergrid: NSObject { + + // MARK: - Static Variables - + + internal static var _sharedClient : UsergridClient! + + /// Used to determine if the shared instance of the `UsergridClient` has been initialized. + public static var isInitialized : Bool { return Usergrid._sharedClient != nil } + + /** + A shared instance of `UsergridClient`, used by the `Usergrid` static methods and acts as the default `UsergridClient` + within the UsergridSDK library. + + - Warning: You must call one of the `Usergrid.initSharedInstance` methods before this or any other `Usergrid` static methods are valid. + */ + public static var sharedInstance : UsergridClient { + assert(Usergrid.isInitialized, "Usergrid shared instance is not initalized!") + return Usergrid._sharedClient + } + + /// The application identifier the shared instance of `UsergridClient`. + public static var appId : String { return Usergrid.sharedInstance.appId } + + /// The organization identifier of the shared instance of `UsergridClient`. + public static var orgId : String { return Usergrid.sharedInstance.orgId } + + /// The base URL that all calls will be made with of the shared instance of `UsergridClient`. + public static var baseUrl : String { return Usergrid.sharedInstance.baseUrl } + + /// The constructed URL string based on the `UsergridClient`'s baseUrl, orgId, and appId of the shared instance of `UsergridClient`. + public static var clientAppURL : String { return Usergrid.sharedInstance.clientAppURL } + + /// The currently logged in `UsergridUser` of the shared instance of `UsergridClient`. + public static var currentUser: UsergridUser? { return Usergrid.sharedInstance.currentUser } + + /// The `UsergridUserAuth` which consists of the token information from the `currentUser` property of the shared instance of `UsergridClient`. + public static var userAuth: UsergridUserAuth? { return Usergrid.sharedInstance.userAuth } + + /// The application level `UsergridAppAuth` object of the shared instance of `UsergridClient`. + public static var appAuth: UsergridAppAuth? { + get{ return Usergrid.sharedInstance.appAuth } + set{ Usergrid.sharedInstance.appAuth = newValue } + } + + // MARK: - Initialization - + + /** + Initializes the `Usergrid.sharedInstance` of `UsergridClient`. + + - parameter orgId: The organization identifier. + - parameter appId: The application identifier. + + - returns: The shared instance of `UsergridClient`. + */ + public static func initSharedInstance(orgId orgId : String, appId: String) -> UsergridClient { + if !Usergrid.isInitialized { + Usergrid._sharedClient = UsergridClient(orgId: orgId, appId: appId) + } else { + print("The Usergrid shared instance was already initialized. All subsequent initialization attempts (including this) will be ignored.") + } + return Usergrid._sharedClient + } + + /** + Initializes the `Usergrid.sharedInstance` of `UsergridClient`. + + - parameter orgId: The organization identifier. + - parameter appId: The application identifier. + - parameter baseUrl: The base URL that all calls will be made with. + + - returns: The shared instance of `UsergridClient`. + */ + public static func initSharedInstance(orgId orgId : String, appId: String, baseUrl: String) -> UsergridClient { + if !Usergrid.isInitialized { + Usergrid._sharedClient = UsergridClient(orgId: orgId, appId: appId, baseUrl: baseUrl) + } else { + print("The Usergrid shared instance was already initialized. All subsequent initialization attempts (including this) will be ignored.") + } + return Usergrid._sharedClient + } + + /** + Initializes the `Usergrid.sharedInstance` of `UsergridClient`. + + - parameter configuration: The configuration for the client to be set up with. + + - returns: The shared instance of `UsergridClient`. + */ + public static func initSharedInstance(configuration configuration: UsergridClientConfig) -> UsergridClient { + if !Usergrid.isInitialized { + Usergrid._sharedClient = UsergridClient(configuration: configuration) + } else { + print("The Usergrid shared instance was already initialized. All subsequent initialization attempts (including this) will be ignored.") + } + return Usergrid._sharedClient + } + + // MARK: - Push Notifications - + + /** + Sets the push token for the given notifier ID and performs a PUT request to update the shared `UsergridDevice` instance using the shared instance of `UsergridCient`. + + - parameter pushToken: The push token from Apple. + - parameter notifierID: The Usergrid notifier ID. + - parameter completion: The completion block. + */ + public static func applyPushToken(pushToken: NSData, notifierID: String, completion: UsergridResponseCompletion? = nil) { + Usergrid.sharedInstance.applyPushToken(pushToken, notifierID: notifierID, completion: completion) + } + + /** + Sets the push token for the given notifier ID and performs a PUT request to update the given `UsergridDevice` instance using the shared instance of `UsergridCient`. + + - parameter device: The `UsergridDevice` object. + - parameter pushToken: The push token from Apple. + - parameter notifierID: The Usergrid notifier ID. + - parameter completion: The completion block. + */ + public static func applyPushToken(device: UsergridDevice, pushToken: NSData, notifierID: String, completion: UsergridResponseCompletion? = nil) { + Usergrid.sharedInstance.applyPushToken(device, pushToken: pushToken, notifierID: notifierID, completion: completion) + } + + + // MARK: - Authorization - + + /// The `UsergridAuthFallback` value used to determine what type of token will be sent of the shared instance of `UsergridClient`, if any. + public static var authFallback: UsergridAuthFallback { + get{ return Usergrid.sharedInstance.authFallback } + set { Usergrid.sharedInstance.authFallback = newValue } + } + + /** + Sets the shared `UsergridClient`'s `tempAuth` property using the passed in `UsergridAuth`. + + This will cause the next CRUD method performed by the client to use the `tempAuth` property once and will then reset. + + - parameter auth: The `UsergridAuth` object to temporarily use for authentication. + + - returns: The shared instance of `UsergridClient` + */ + public static func usingAuth(auth:UsergridAuth) -> UsergridClient { + return Usergrid.sharedInstance.usingAuth(auth) + } + + /** + Sets the shared `UsergridClient`'s `tempAuth` property using the passed in token. + + This will cause the next CRUD method performed by the client to use the `tempAuth` property once and will then reset. + + - parameter auth: The access token to temporarily use for authentication. + + - returns: The shared instance of `UsergridClient` + */ + public static func usingToken(token:String) -> UsergridClient { + return Usergrid.sharedInstance.usingToken(token) + } + + + /** + Determines the `UsergridAuth` object that will be used for all outgoing requests made by the shared instance of `UsergridClient`. + + If there is a `UsergridUser` logged in and the token of that user is valid then it will return that. + + Otherwise, if the `authFallback` is `.App`, and the `UsergridAppAuth` of the client is set and the token is valid it will return that. + + - returns: The `UsergridAuth` if one is found or nil if not. + */ + public static func authForRequests() -> UsergridAuth? { + return Usergrid.sharedInstance.authForRequests() + } + + /** + Authenticates with the `UsergridAppAuth` that is contained within the shared instance of `UsergridCient`. + + - parameter completion: The completion block that will be called after authentication has completed. + */ + public static func authenticateApp(completion: UsergridAppAuthCompletionBlock? = nil) { + Usergrid.sharedInstance.authenticateApp(completion) + } + + /** + Authenticates with the `UsergridAppAuth` that is passed in using the shared instance of `UsergridCient`. + + - parameter auth: The `UsergridAppAuth` that will be authenticated. + - parameter completion: The completion block that will be called after authentication has completed. + */ + public static func authenticateApp(auth: UsergridAppAuth, completion: UsergridAppAuthCompletionBlock? = nil) { + Usergrid.sharedInstance.authenticateApp(auth, completion: completion) + } + + /** + Authenticates with the `UsergridUserAuth` that is passed in using the shared instance of `UsergridCient`. + + - parameter auth: The `UsergridUserAuth` that will be authenticated. + - parameter completion: The completion block that will be called after authentication has completed. + */ + public static func authenticateUser(auth: UsergridUserAuth, completion: UsergridUserAuthCompletionBlock? = nil) { + Usergrid.sharedInstance.authenticateUser(auth, completion: completion) + } + + /** + Authenticates with the `UsergridUserAuth` that is passed in using the shared instance of `UsergridCient`. + + - parameter auth: The `UsergridUserAuth` that will be authenticated. + - parameter setAsCurrentUser: If the authenticated user should be set as the `UsergridClient.currentUser`. + - parameter completion: The completion block that will be called after authentication has completed. + */ + public static func authenticateUser(userAuth: UsergridUserAuth, setAsCurrentUser:Bool, completion: UsergridUserAuthCompletionBlock? = nil) { + Usergrid.sharedInstance.authenticateUser(userAuth, setAsCurrentUser: setAsCurrentUser, completion: completion) + } + + /** + Logs out the current user of the shared instance locally and remotely. + + - parameter completion: The completion block that will be called after logout has completed. + */ + public static func logoutCurrentUser(completion:UsergridResponseCompletion? = nil) { + Usergrid.sharedInstance.logoutCurrentUser(completion) + } + + /** + Logs out the user remotely with the given tokens using the shared instance of `UsergridCient`. + + - parameter completion: The completion block that will be called after logout has completed. + */ + public static func logoutUserAllTokens(uuidOrUsername:String, completion:UsergridResponseCompletion? = nil) { + Usergrid.sharedInstance.logoutUserAllTokens(uuidOrUsername, completion: completion) + } + + /** + Logs out a user with the give UUID or username using the shared instance of `UsergridCient`. + + Passing in a token will log out the user for just that token. Passing in nil for the token will logout the user for all tokens. + + - parameter completion: The completion block that will be called after logout has completed. + */ + public static func logoutUser(uuidOrUsername:String, token:String?, completion:UsergridResponseCompletion? = nil) { + Usergrid.sharedInstance.logoutUser(uuidOrUsername, token: token, completion: completion) + } + + // MARK: - Generic Request Methods - + + /** + Starts the `UsergridRequest` sending process using the shared instance of `UsergridCient`. + + - Note: This method should only be used when you construct your own `UsergridRequest objects. + + - parameter request: The `UsergridRequest` object to send. + - parameter completion: The optional completion block that will be called once the request has completed. + */ + public static func sendRequest(request:UsergridRequest, completion:UsergridResponseCompletion? = nil) { + Usergrid.sharedInstance.sendRequest(request, completion: completion) + } + + // MARK: - GET - + + /** + Gets a single `UsergridEntity` of a given type with a specific UUID/name using the shared instance of `UsergridCient`. + + - parameter type: The `UsergridEntity` type. + - parameter uuidOrName: The UUID or name of the `UsergridEntity`. + - parameter completion: The completion block that will be called once the request has completed. + */ + public static func GET(type: String, uuidOrName: String, completion: UsergridResponseCompletion? = nil) { + Usergrid.sharedInstance.GET(type,uuidOrName:uuidOrName,completion:completion) + } + + /** + Gets a group of `UsergridEntity` objects of a given type with an optional query using the shared instance of `UsergridCient`. + + - parameter type: The `UsergridEntity` type. + - parameter query: The optional query to use when gathering `UsergridEntity` objects. + - parameter completion: The completion block that will be called once the request has completed. + */ + public static func GET(type: String, query: UsergridQuery? = nil, completion: UsergridResponseCompletion? = nil) { + Usergrid.sharedInstance.GET(type,query:query,completion:completion) + } + + // MARK: - PUT - + + /** + Updates an `UsergridEntity` with the given type and UUID/name specified using the passed in jsonBody using the shared instance of `UsergridCient`. + + - parameter type: The `UsergridEntity` type. + - parameter uuidOrName: The UUID or name of the `UsergridEntity`. + - parameter jsonBody: The valid JSON body dictionary to update the `UsergridEntity` with. + - parameter completion: The completion block that will be called once the request has completed. + */ + public static func PUT(type: String, uuidOrName: String, jsonBody:[String:AnyObject], completion: UsergridResponseCompletion? = nil) { + Usergrid.sharedInstance.PUT(type, uuidOrName: uuidOrName, jsonBody: jsonBody, completion: completion) + } + + /** + Updates an `UsergridEntity` with the given type using the jsonBody where the UUID/name is specified inside of the jsonBody using the shared instance of `UsergridCient`. + + - Note: The `jsonBody` must contain a valid value for either `uuid` or `name`. + + - parameter type: The `UsergridEntity` type. + - parameter jsonBody: The valid JSON body dictionary to update the `UsergridEntity` with. + - parameter completion: The completion block that will be called once the request has completed. + */ + public static func PUT(type: String, jsonBody:[String:AnyObject], completion: UsergridResponseCompletion? = nil) { + Usergrid.sharedInstance.PUT(type, jsonBody: jsonBody, completion: completion) + } + + /** + Updates the passed in `UsergridEntity` using the shared instance of `UsergridCient`. + + - parameter entity: The `UsergridEntity` to update. + - parameter completion: The completion block that will be called once the request has completed. + */ + public static func PUT(entity: UsergridEntity, completion: UsergridResponseCompletion? = nil) { + Usergrid.sharedInstance.PUT(entity, completion: completion) + } + + /** + Updates the entities that fit the given query using the passed in jsonBody using the shared instance of `UsergridCient`. + + - Note: The query parameter must have a valid `collectionName` before calling this method. + + - parameter query: The query to use when filtering what entities to update. + - parameter jsonBody: The valid JSON body dictionary to update with. + - parameter queryCompletion: The completion block that will be called once the request has completed. + */ + public static func PUT(query: UsergridQuery, jsonBody:[String:AnyObject], queryCompletion: UsergridResponseCompletion? = nil) { + Usergrid.sharedInstance.PUT(query, jsonBody: jsonBody, queryCompletion: queryCompletion) + } + + // MARK: - POST - + + /** + Creates and posts an `UsergridEntity` of the given type with a given name and the given jsonBody using the shared instance of `UsergridCient`. + + - parameter type: The `UsergridEntity` type. + - parameter name: The name of the `UsergridEntity`. + - parameter jsonBody: The valid JSON body dictionary to use when creating the `UsergridEntity`. + - parameter completion: The completion block that will be called once the request has completed. + */ + public static func POST(type: String, name: String, jsonBody:[String:AnyObject], completion: UsergridResponseCompletion? = nil) { + Usergrid.sharedInstance.POST(type, name: name, jsonBody: jsonBody, completion: completion) + } + + /** + Creates and posts an `UsergridEntity` of the given type with the given jsonBody using the shared instance of `UsergridCient`. + + - parameter type: The `UsergridEntity` type. + - parameter jsonBody: The valid JSON body dictionary to use when creating the `UsergridEntity`. + - parameter completion: The completion block that will be called once the request has completed. + */ + public static func POST(type: String, jsonBody:[String:AnyObject], completion: UsergridResponseCompletion? = nil) { + Usergrid.sharedInstance.POST(type, jsonBody: jsonBody, completion: completion) + } + + /** + Creates and posts an array of `Entity` objects while assinging the given type to them using the shared instance of `UsergridCient`. + + - parameter type: The `UsergridEntity` type. + - parameter jsonBody: The valid JSON body dictionaries to use when creating the `UsergridEntity` objects. + - parameter completion: The completion block that will be called once the request has completed. + */ + public static func POST(type: String, jsonBodies:[[String:AnyObject]], completion: UsergridResponseCompletion? = nil) { + Usergrid.sharedInstance.POST(type, jsonBodies: jsonBodies, completion: completion) + } + + /** + Creates and posts creates an `UsergridEntity` using the shared instance of `UsergridCient`. + + - parameter entity: The `UsergridEntity` to create. + - parameter completion: The completion block that will be called once the request has completed. + */ + public static func POST(entity:UsergridEntity, completion: UsergridResponseCompletion? = nil) { + Usergrid.sharedInstance.POST(entity, completion: completion) + } + + /** + Creates and posts an array of `UsergridEntity` objects using the shared instance of `UsergridCient`. + + - Note: Each `UsergridEntity` in the array much already have a type assigned and must be the same. + + - parameter entities: The `UsergridEntity` objects to create. + - parameter entitiesCompletion: The completion block that will be called once the request has completed. + */ + public static func POST(entities:[UsergridEntity], entitiesCompletion: UsergridResponseCompletion? = nil) { + Usergrid.sharedInstance.POST(entities, entitiesCompletion: entitiesCompletion) + } + + // MARK: - DELETE - + + /** + Destroys the `UsergridEntity` of a given type with a specific UUID/name using the shared instance of `UsergridCient`. + + - parameter type: The `UsergridEntity` type. + - parameter uuidOrName: The UUID or name of the `UsergridEntity`. + - parameter completion: The completion block that will be called once the request has completed. + */ + public static func DELETE(type:String, uuidOrName: String, completion: UsergridResponseCompletion? = nil) { + Usergrid.sharedInstance.DELETE(type, uuidOrName: uuidOrName, completion: completion) + } + + /** + Destroys the passed `UsergridEntity` using the shared instance of `UsergridCient`. + + - Note: The entity object must have a `uuid` or `name` assigned. + + - parameter entity: The `UsergridEntity` to delete. + - parameter completion: The completion block that will be called once the request has completed. + */ + public static func DELETE(entity:UsergridEntity, completion: UsergridResponseCompletion? = nil) { + Usergrid.sharedInstance.DELETE(entity, completion:completion) + } + + /** + Destroys the `UsergridEntity` objects that fit the given `UsergridQuery` using the shared instance of `UsergridCient`. + + - Note: The query parameter must have a valid `collectionName` before calling this method. + + - parameter query: The query to use when filtering what entities to delete. + - parameter queryCompletion: The completion block that will be called once the request has completed. + */ + public static func DELETE(query:UsergridQuery, queryCompletion: UsergridResponseCompletion? = nil) { + Usergrid.sharedInstance.DELETE(query, queryCompletion:queryCompletion) + } + + // MARK: - Connection Management - + + /** + Connects the `UsergridEntity` objects via the relationship using the shared instance of `UsergridCient`. + + - parameter entity: The entity that will contain the connection. + - parameter relationship: The relationship of the two entities. + - parameter to: The entity which is connected. + - parameter completion: The completion block that will be called once the request has completed. + */ + public static func connect(entity:UsergridEntity, relationship:String, to:UsergridEntity, completion: UsergridResponseCompletion? = nil) { + Usergrid.sharedInstance.connect(entity, relationship: relationship, to: to, completion: completion) + } + + /** + Connects the entity objects via the relationship using the shared instance of `UsergridCient`. + + - parameter entityType: The entity type. + - parameter entityID: The entity UUID or name. + - parameter relationship: The relationship of the connection. + - parameter toType: The optional type of the entity you are connecting to. + - parameter toID: The UUID of the entity you are connecting to. + - parameter completion: The completion block that will be called once the request has completed. + */ + public static func connect(entityType:String, entityID:String, relationship:String, toType:String?, toID: String, completion: UsergridResponseCompletion? = nil) { + Usergrid.sharedInstance.connect(entityType, entityID: entityID, relationship: relationship, toType: toType, toID: toID, completion: completion) + } + + /** + Connects the entity objects via the relationship using the shared instance of `UsergridCient`. + + - parameter entityType: The entity type. + - parameter entityID: The entity UUID or name. + - parameter relationship: The relationship of the connection. + - parameter toType: The type of the entity you are connecting to. + - parameter toName: The name of the entity you are connecting to. + - parameter completion: The completion block that will be called once the request has completed. + */ + public static func connect(entityType:String, entityID:String, relationship:String, toType:String, toName: String, completion: UsergridResponseCompletion? = nil) { + Usergrid.sharedInstance.connect(entityType, entityID: entityID, relationship: relationship, toType: toType, toName: toName, completion: completion) + } + + + /** + Disconnects the `UsergridEntity` objects via the relationship using the shared instance of `UsergridCient`. + + - parameter entity: The entity that contains the connection. + - parameter relationship: The relationship of the two entities. + - parameter connectingEntity: The entity which is connected. + - parameter completion: The completion block that will be called once the request has completed. + */ + public static func disconnect(entity:UsergridEntity, relationship:String, from:UsergridEntity, completion: UsergridResponseCompletion? = nil) { + Usergrid.sharedInstance.disconnect(entity, relationship: relationship, from: from, completion: completion) + } + + /** + Disconnects the entity objects via the relationship using the shared instance of `UsergridCient`. + + - parameter entityType: The entity type. + - parameter entityID: The entity UUID or name. + - parameter relationship: The relationship of the connection. + - parameter fromType: The optional type of the entity you are disconnecting from. + - parameter toID: The UUID of the entity you are disconnecting from. + - parameter completion: The completion block that will be called once the request has completed. + */ + public static func disconnect(entityType:String, entityID:String, relationship:String, fromType:String?, fromID: String, completion: UsergridResponseCompletion? = nil) { + Usergrid.sharedInstance.disconnect(entityType, entityID: entityID, relationship: relationship, fromType: fromType, fromID: fromID, completion: completion) + } + + /** + Disconnects the entity objects via the relationship using the shared instance of `UsergridCient`. + + - parameter entityType: The entity type. + - parameter entityID: The entity UUID or name. + - parameter relationship: The relationship of the connection. + - parameter fromType: The type of the entity you are disconnecting from. + - parameter fromName: The name of the entity you are disconnecting from. + - parameter completion: The completion block that will be called once the request has completed. + */ + public static func disconnect(entityType:String, entityID:String, relationship:String, fromType:String, fromName: String, completion: UsergridResponseCompletion? = nil) { + Usergrid.sharedInstance.disconnect(entityType, entityID: entityID, relationship: relationship, fromType: fromType, fromName: fromName, completion: completion) + } + + /** + Gets the connected entities for the given relationship using the shared instance of `UsergridCient`. + + - parameter direction: The direction of the connection. + - parameter entity: The entity that contains the connection. + - parameter relationship: The relationship. + - parameter completion: The completion block that will be called once the request has completed. + */ + public static func getConnections(direction:UsergridDirection, entity:UsergridEntity, relationship:String, query:UsergridQuery?, completion:UsergridResponseCompletion? = nil) { + Usergrid.sharedInstance.getConnections(direction, entity: entity, relationship: relationship, query:query, completion: completion) + } + + /** + Gets the connected entities for the given relationship using the shared instance of `UsergridCient`. + + - parameter direction: The direction of the connection. + - parameter type: The entity type. + - parameter uuidOrName: The entity UUID or name. + - parameter relationship: The relationship of the connection. + - parameter query: The optional query. + - parameter completion: The completion block that will be called once the request has completed. + */ + public static func getConnections(direction:UsergridDirection, type:String, uuidOrName:String, relationship:String, query:UsergridQuery?, completion:UsergridResponseCompletion? = nil) { + Usergrid.sharedInstance.getConnections(direction, type: type, uuidOrName: uuidOrName, relationship: relationship, query:query, completion: completion) + } + + /** + Gets the connected entities for the given relationship using the shared instance of `UsergridCient`. + + - parameter direction: The direction of the connection. + - parameter uuid: The entity UUID. + - parameter relationship: The relationship of the connection. + - parameter query: The optional query. + - parameter completion: The optional completion block that will be called once the request has completed. + */ + public static func getConnections(direction:UsergridDirection, uuid:String, relationship:String, query:UsergridQuery?, completion:UsergridResponseCompletion? = nil) { + Usergrid.sharedInstance.getConnections(direction, uuid: uuid, relationship: relationship, query: query, completion: completion) + } + + // MARK: - Asset Management - + + /** + Uploads the asset and connects the data to the given `UsergridEntity` using the shared instance of `UsergridCient`. + + - parameter entity: The entity to connect the asset to. + - parameter asset: The asset to upload. + - parameter progress: The progress block that will be called to update the progress of the upload. + - parameter completion: The completion block that will be called once the request has completed. + */ + public static func uploadAsset(entity:UsergridEntity, asset:UsergridAsset, progress:UsergridAssetRequestProgress? = nil, completion:UsergridAssetUploadCompletion? = nil) { + Usergrid.sharedInstance.uploadAsset(entity, asset: asset, progress: progress, completion: completion) + } + + /** + Downloads the asset from the given `UsergridEntity` using the shared instance of `UsergridCient`. + + - parameter entity: The entity to which the asset to. + - parameter contentType: The content type of the asset's data. + - parameter progress: The progress block that will be called to update the progress of the download. + - parameter completion: The completion block that will be called once the request has completed. + */ + public static func downloadAsset(entity:UsergridEntity, contentType:String, progress:UsergridAssetRequestProgress? = nil, completion:UsergridAssetDownloadCompletion? = nil) { + Usergrid.sharedInstance.downloadAsset(entity, contentType: contentType, progress: progress, completion: completion) + } +}
http://git-wip-us.apache.org/repos/asf/usergrid/blob/7442c881/sdks/swift/Samples/ActivityFeed/Pods/UsergridSDK/sdks/swift/Source/UsergridAsset.swift ---------------------------------------------------------------------- diff --git a/sdks/swift/Samples/ActivityFeed/Pods/UsergridSDK/sdks/swift/Source/UsergridAsset.swift b/sdks/swift/Samples/ActivityFeed/Pods/UsergridSDK/sdks/swift/Source/UsergridAsset.swift new file mode 100644 index 0000000..3f74796 --- /dev/null +++ b/sdks/swift/Samples/ActivityFeed/Pods/UsergridSDK/sdks/swift/Source/UsergridAsset.swift @@ -0,0 +1,198 @@ +// +// UsergridAsset.swift +// UsergridSDK +// +// Created by Robert Walsh on 9/21/15. +// +/* + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. The ASF licenses this file to You + * under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. For additional information regarding + * copyright in this work, please see the NOTICE file in the top level + * directory of this distribution. + * + */ + +import Foundation + +#if os(iOS) || os(watchOS) || os(tvOS) +import UIKit +import MobileCoreServices +#endif + +/// The progress block used in `UsergridAsset` are being uploaded or downloaded. +public typealias UsergridAssetRequestProgress = (bytesFinished:Int64, bytesExpected: Int64) -> Void + +/// The completion block used in `UsergridAsset` are finished uploading. +public typealias UsergridAssetUploadCompletion = (response:UsergridResponse,asset:UsergridAsset?, error: String?) -> Void + +/// The completion block used in `UsergridAsset` are finished downloading. +public typealias UsergridAssetDownloadCompletion = (asset:UsergridAsset?, error: String?) -> Void + +/** +As Usergrid supports storing binary assets, the SDKs are designed to make uploading assets easier and more robust. Attaching, uploading, and downloading assets is handled by the `UsergridEntity` class. + +Unless defined, whenever possible, the content-type will be inferred from the data provided, and the attached file (if not already a byte-array representation) will be binary-encoded. +*/ +public class UsergridAsset: NSObject, NSCoding { + + private static let DEFAULT_FILE_NAME = "file" + + // MARK: - Instance Properties - + + /// The filename to be used in the multipart/form-data request. + public let filename: String + + /// Binary representation of the asset's data. + public let data: NSData + + /// A representation of the folder location the asset was loaded from, if it was provided in the initialization. + public let originalLocation: String? + + /// The Content-type of the asset to be used when defining content-type inside the multipart/form-data request. + public var contentType: String + + /// The content length of the assets data. + public var contentLength: Int { return self.data.length } + + // MARK: - Initialization - + + /** + Designated initializer for `UsergridAsset` objects. + + - parameter fileName: The file name associated with the file data. + - parameter data: The data of the file. + - parameter originalLocation: An optional original location of the file. + - parameter contentType: The content type of the file. + + - returns: A new instance of `UsergridAsset`. + */ + public init(filename:String? = UsergridAsset.DEFAULT_FILE_NAME, data:NSData, originalLocation:String? = nil, contentType:String) { + self.filename = filename ?? UsergridAsset.DEFAULT_FILE_NAME + self.data = data + self.originalLocation = originalLocation + self.contentType = contentType + } + + #if os(iOS) || os(watchOS) || os(tvOS) + /** + Convenience initializer for `UsergridAsset` objects dealing with image data. + + - parameter fileName: The file name associated with the file data. + - parameter image: The `UIImage` object to upload. + - parameter imageContentType: The content type of the `UIImage` + + - returns: A new instance of `UsergridAsset` if the data can be gathered from the passed in `UIImage`, otherwise nil. + */ + public convenience init?(fileName:String? = UsergridAsset.DEFAULT_FILE_NAME, image:UIImage, imageContentType:UsergridImageContentType = .Png) { + var imageData: NSData? + switch(imageContentType) { + case .Png : + imageData = UIImagePNGRepresentation(image) + case .Jpeg : + imageData = UIImageJPEGRepresentation(image, 1.0) + } + if let assetData = imageData { + self.init(filename:fileName,data:assetData,contentType:imageContentType.stringValue) + } else { + self.init(filename:"",data:NSData(),contentType:"") + return nil + } + } + #endif + + /** + Convenience initializer for `UsergridAsset` objects dealing directly with files on disk. + + - parameter fileName: The file name associated with the file data. + - parameter fileURL: The `NSURL` object associated with the file. + - parameter contentType: The content type of the `UIImage`. If not specified it will try to figure out the type and if it can't initialization will fail. + + - returns: A new instance of `UsergridAsset` if the data can be gathered from the passed in `NSURL`, otherwise nil. + */ + public convenience init?(fileName:String? = UsergridAsset.DEFAULT_FILE_NAME, fileURL:NSURL, contentType:String? = nil) { + if fileURL.isFileReferenceURL(), let assetData = NSData(contentsOfURL: fileURL) { + var fileNameToUse = fileName + if fileNameToUse != UsergridAsset.DEFAULT_FILE_NAME, let inferredFileName = fileURL.lastPathComponent { + fileNameToUse = inferredFileName + } + if let fileContentType = contentType ?? UsergridAsset.MIMEType(fileURL) { + self.init(filename:fileNameToUse,data:assetData,originalLocation:fileURL.absoluteString,contentType:fileContentType) + } else { + print("Usergrid Error: Failed to imply content type of the asset.") + self.init(filename:"",data:NSData(),contentType:"") + return nil + } + } else { + print("Usergrid Error: fileURL parameter must be a file reference URL.") + self.init(filename:"",data:NSData(),contentType:"") + return nil + } + } + + // MARK: - NSCoding - + + /** + NSCoding protocol initializer. + + - parameter aDecoder: The decoder. + + - returns: A decoded `UsergridUser` object. + */ + required public init?(coder aDecoder: NSCoder) { + guard let filename = aDecoder.decodeObjectForKey("filename") as? String, + let assetData = aDecoder.decodeObjectForKey("data") as? NSData, + let contentType = aDecoder.decodeObjectForKey("contentType") as? String + else { + self.filename = "" + self.contentType = "" + self.originalLocation = nil + self.data = NSData() + super.init() + return nil + } + self.filename = filename + self.data = assetData + self.contentType = contentType + self.originalLocation = aDecoder.decodeObjectForKey("originalLocation") as? String + super.init() + } + + /** + NSCoding protocol encoder. + + - parameter aCoder: The encoder. + */ + public func encodeWithCoder(aCoder: NSCoder) { + aCoder.encodeObject(self.filename, forKey: "filename") + aCoder.encodeObject(self.data, forKey: "data") + aCoder.encodeObject(self.contentType, forKey: "contentType") + aCoder.encodeObject(self.originalLocation, forKey: "originalLocation") + } + + private static func MIMEType(fileURL: NSURL) -> String? { + if let pathExtension = fileURL.pathExtension { + if let UTIRef = UTTypeCreatePreferredIdentifierForTag(kUTTagClassFilenameExtension, pathExtension, nil) { + let UTI = UTIRef.takeUnretainedValue() + UTIRef.release() + if let MIMETypeRef = UTTypeCopyPreferredTagWithClass(UTI, kUTTagClassMIMEType) { + let MIMEType = MIMETypeRef.takeUnretainedValue() + MIMETypeRef.release() + return MIMEType as String + } + } + } + return nil + } +} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/usergrid/blob/7442c881/sdks/swift/Samples/ActivityFeed/Pods/UsergridSDK/sdks/swift/Source/UsergridAssetRequestWrapper.swift ---------------------------------------------------------------------- diff --git a/sdks/swift/Samples/ActivityFeed/Pods/UsergridSDK/sdks/swift/Source/UsergridAssetRequestWrapper.swift b/sdks/swift/Samples/ActivityFeed/Pods/UsergridSDK/sdks/swift/Source/UsergridAssetRequestWrapper.swift new file mode 100644 index 0000000..d715652 --- /dev/null +++ b/sdks/swift/Samples/ActivityFeed/Pods/UsergridSDK/sdks/swift/Source/UsergridAssetRequestWrapper.swift @@ -0,0 +1,48 @@ +// +// UsergridAssetRequestWrapper.swift +// UsergridSDK +// +// Created by Robert Walsh on 10/1/15. +// +/* + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. The ASF licenses this file to You + * under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. For additional information regarding + * copyright in this work, please see the NOTICE file in the top level + * directory of this distribution. + * + */ + +import Foundation + +typealias UsergridAssetRequestWrapperCompletionBlock = (requestWrapper:UsergridAssetRequestWrapper) -> Void + +final class UsergridAssetRequestWrapper { + weak var session: NSURLSession? + let sessionTask: NSURLSessionTask + + var response: NSURLResponse? + var responseData: NSData? + var error: NSError? + + var progress: UsergridAssetRequestProgress? + let completion: UsergridAssetRequestWrapperCompletionBlock + + init(session:NSURLSession?, sessionTask:NSURLSessionTask, progress:UsergridAssetRequestProgress?, completion:UsergridAssetRequestWrapperCompletionBlock) { + self.session = session + self.sessionTask = sessionTask + self.progress = progress + self.completion = completion + } +} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/usergrid/blob/7442c881/sdks/swift/Samples/ActivityFeed/Pods/UsergridSDK/sdks/swift/Source/UsergridAuth.swift ---------------------------------------------------------------------- diff --git a/sdks/swift/Samples/ActivityFeed/Pods/UsergridSDK/sdks/swift/Source/UsergridAuth.swift b/sdks/swift/Samples/ActivityFeed/Pods/UsergridSDK/sdks/swift/Source/UsergridAuth.swift new file mode 100644 index 0000000..a8879b2 --- /dev/null +++ b/sdks/swift/Samples/ActivityFeed/Pods/UsergridSDK/sdks/swift/Source/UsergridAuth.swift @@ -0,0 +1,276 @@ +// +// UsergridAuth.swift +// UsergridSDK +// +// Created by Robert Walsh on 9/11/15. +// +/* + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. The ASF licenses this file to You + * under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. For additional information regarding + * copyright in this work, please see the NOTICE file in the top level + * directory of this distribution. + * + */ + +import Foundation + +/// The completion block used in `UsergridAppAuth` authentication methods. +public typealias UsergridAppAuthCompletionBlock = (auth:UsergridAppAuth?, error: UsergridResponseError?) -> Void + +/// The completion block used in `UsergridUserAuth` authentication methods. +public typealias UsergridUserAuthCompletionBlock = (auth:UsergridUserAuth?, user:UsergridUser?, error: UsergridResponseError?) -> Void + +/** + The `UsergridAuth` class functions to create and store authentication information used by Usergrid. + + The `UsergridAuth` sub classes, `UsergridAppAuth` and `UsergridUserAuth`, provide different ways for authentication to be used in creating requests for access tokens through the SDK. +*/ +public class UsergridAuth : NSObject, NSCoding { + + // MARK: - Instance Properties - + + /// The access token, if this `UsergridAuth` was authorized successfully. + public var accessToken : String? + + /// The expires at date, if this `UsergridAuth` was authorized successfully and their was a expires in time stamp within the token response. + public var expiry : NSDate? + + /// Determines if an access token exists. + public var hasToken: Bool { return self.accessToken != nil } + + /// Determines if the token was set explicitly within the init method or not. + private var usingToken: Bool = false + + /// Determines if an access token exists and if the token is not expired. + public var isValid : Bool { return self.hasToken && !self.isExpired } + + /// Determines if the access token, if one exists, is expired. + public var isExpired: Bool { + var isExpired = false + if let expires = self.expiry { + isExpired = expires.timeIntervalSinceNow < 0.0 + } else { + isExpired = !self.usingToken + } + return isExpired + } + + /// The credentials dictionary. Subclasses must override this method and provide an actual dictionary containing the credentials to send with requests. + var credentialsJSONDict: [String:AnyObject] { + return [:] + } + + // MARK: - Initialization - + + /** + Internal initialization method. Note this should never be used outside of internal methods. + + - returns: A new instance of `UsergridAuth`. + */ + override private init() { + super.init() + } + + /** + Initializer for a base `UsergridAuth` object that just contains an `accessToken` and an optional `expiry` date. + + - parameter accessToken: The access token. + - parameter expiry: The optional expiry date. + + - returns: A new instance of `UsergridAuth` + */ + public init(accessToken:String, expiry:NSDate? = nil) { + self.usingToken = true + self.accessToken = accessToken + self.expiry = expiry + } + + // MARK: - NSCoding - + + /** + NSCoding protocol initializer. + + - parameter aDecoder: The decoder. + + - returns: A decoded `UsergridUser` object. + */ + required public init?(coder aDecoder: NSCoder) { + self.accessToken = aDecoder.decodeObjectForKey("accessToken") as? String + self.expiry = aDecoder.decodeObjectForKey("expiry") as? NSDate + } + + /** + NSCoding protocol encoder. + + - parameter aCoder: The encoder. + */ + public func encodeWithCoder(aCoder: NSCoder) { + if let accessToken = self.accessToken { + aCoder.encodeObject(accessToken, forKey: "accessToken") + } + if let expiresAt = self.expiry { + aCoder.encodeObject(expiresAt, forKey: "expiry") + } + } + + // MARK: - Instance Methods - + + /** + Destroys/removes the access token and expiry. + */ + public func destroy() { + self.accessToken = nil + self.expiry = nil + } +} + +/// The `UsergridAuth` subclass used for user level authorization. +public class UsergridUserAuth : UsergridAuth { + + // MARK: - Instance Properties - + + /// The username associated with the User. + public let username: String + + /// The password associated with the User. + private let password: String + + /// The credentials dictionary constructed with the `UsergridUserAuth`'s `username` and `password`. + override var credentialsJSONDict: [String:AnyObject] { + return ["grant_type":"password", + "username":self.username, + "password":self.password] + } + + // MARK: - Initialization - + + /** + Designated initializer for `UsergridUserAuth` objects. + + - parameter username: The username associated with the User. + - parameter password: The password associated with the User. + + - returns: A new instance of `UsergridUserAuth`. + */ + public init(username:String, password: String){ + self.username = username + self.password = password + super.init() + } + + // MARK: - NSCoding - + + /** + NSCoding protocol initializer. + + - parameter aDecoder: The decoder. + + - returns: A decoded `UsergridUser` object. + */ + required public init?(coder aDecoder: NSCoder) { + guard let username = aDecoder.decodeObjectForKey("username") as? String, + password = aDecoder.decodeObjectForKey("password") as? String + else { + self.username = "" + self.password = "" + super.init(coder: aDecoder) + return nil + } + + self.username = username + self.password = password + super.init(coder: aDecoder) + } + + /** + NSCoding protocol encoder. + + - parameter aCoder: The encoder. + */ + override public func encodeWithCoder(aCoder: NSCoder) { + aCoder.encodeObject(self.username, forKey: "username") + aCoder.encodeObject(self.password, forKey: "password") + super.encodeWithCoder(aCoder) + } +} + +/// The `UsergridAuth` subclass used for application level authorization. +public class UsergridAppAuth : UsergridAuth { + + // MARK: - Instance Properties - + + /// The client identifier associated with the application. + public let clientId: String + + /// The client secret associated with the application. + private let clientSecret: String + + /// The credentials dictionary constructed with the `UsergridAppAuth`'s `clientId` and `clientSecret`. + override var credentialsJSONDict: [String:AnyObject] { + return ["grant_type":"client_credentials", + "client_id":self.clientId, + "client_secret":self.clientSecret] + } + + // MARK: - Initialization - + + /** + Designated initializer for `UsergridAppAuth` objects. + + - parameter clientId: The client identifier associated with the application. + - parameter clientSecret: The client secret associated with the application. + + - returns: A new instance of `UsergridAppAuth`. + */ + public init(clientId:String,clientSecret:String){ + self.clientId = clientId + self.clientSecret = clientSecret + super.init() + } + + // MARK: - NSCoding - + + /** + NSCoding protocol initializer. + + - parameter aDecoder: The decoder. + + - returns: A decoded `UsergridUser` object. + */ + required public init?(coder aDecoder: NSCoder) { + guard let clientId = aDecoder.decodeObjectForKey("clientId") as? String, + let clientSecret = aDecoder.decodeObjectForKey("clientSecret") as? String + else { + self.clientId = "" + self.clientSecret = "" + super.init(coder: aDecoder) + return nil + } + self.clientId = clientId + self.clientSecret = clientSecret + super.init(coder: aDecoder) + } + + /** + NSCoding protocol encoder. + + - parameter aCoder: The encoder. + */ + override public func encodeWithCoder(aCoder: NSCoder) { + aCoder.encodeObject(self.clientId, forKey: "clientId") + aCoder.encodeObject(self.clientSecret, forKey: "clientSecret") + super.encodeWithCoder(aCoder) + } +} \ No newline at end of file
