Merge branch 'master' into release/1.0.5

Author: phillwiggins

.idea/workspace.xml

@@ -1,276 +1,92 @@
 part of flutter_parse_sdk;
 
-class ParseUser extends ParseBase implements ParseCloneable {
+class ParseResponse {
+  bool success = false;
+  int statusCode = -1;
+  dynamic result;
+  ParseError error;
 
-  ParseUser.clone(Map map): this(map[keyVarUsername],map[keyVarPassword],map[keyVarEmail]);
-
-  @override
-  clone(Map map) => ParseUser.clone(map)..fromJson(map);
-
-  static final String path = "$keyEndPointClasses$keyClassUser";
-
-  bool _debug;
-  ParseHTTPClient _client;
-
-  Map get acl => super.get<Map>(keyVarAcl);
-  set acl(Map acl) => set<Map>(keyVarAcl, acl);
-
-  String get username => super.get<String>(keyVarUsername);
-  set username(String username) => set<String>(keyVarUsername, username);
-
-  String get password => super.get<String>(keyVarPassword);
-  set password(String password) => set<String>(keyVarPassword, password);
-
-  String get emailAddress => super.get<String>(keyVarEmail);
-  set emailAddress(String emailAddress) => set<String>(keyVarEmail, emailAddress);
-
-  /// Creates an instance of ParseUser
-  ///
-  /// Users can set whether debug should be set on this class with a [bool],
-  /// they can also create thier own custom version of [ParseHttpClient]
+  /// Handles all the ParseObject responses
   ///
-  /// Creates a new user locally
-  ///
-  /// Requires [String] username, [String] password. [String] email address
-  /// is required as well to create a full new user object on ParseServer. Only
-  /// username and password is required to login
-  ParseUser(String username, String password, String emailAddress, {bool debug, ParseHTTPClient client}) : super() {
-    client == null ? _client = ParseHTTPClient() : _client = client;
-    _debug = isDebugEnabled(objectLevelDebug: debug);
-
-    this.username = username;
-    this.password = password;
-    this.emailAddress = emailAddress;
-
-    setClassName(keyClassUser);
-  }
-
-  create(String username, String password, [String emailAddress]) {
-    return ParseUser(username, password, emailAddress);
-  }
-
-  /// Gets the current user from the server
-  ///
-  /// Current user is stored locally, but in case of a server update [bool]
-  /// fromServer can be called and an updated version of the [User] object will be
-  /// returned
-  getCurrentUserFromServer() async {
-    // We can't get the current user and session without a sessionId
-    if (_client.data.sessionId == null) return null;
-
-    try {
-      Uri tempUri = Uri.parse(_client.data.serverUrl);
-
-      Uri uri = Uri(
-          scheme: tempUri.scheme,
-          host: tempUri.host,
-          path: "${tempUri.path}$keyEndPointUserName");
-
-      final response = await _client
-          .get(uri, headers: {keyHeaderSessionToken: _client.data.sessionId});
-      return _handleResponse(response, ParseApiRQ.currentUser);
-    } on Exception catch (e) {
-      return _handleException(e, ParseApiRQ.currentUser);
+  /// There are 4 probable outcomes from a Parse API call,
+  /// 1. Fail - [ParseResponse()] will be returned with further details
+  /// 2. Success but no results. [ParseResponse()] is returned.
+  /// 3. Success with simple OK.
+  /// 4. Success with results. Again [ParseResponse()] is returned
+  static handleResponse(dynamic object, Response apiResponse) {
+    var parseResponse = ParseResponse();
+
+    if (apiResponse != null) {
+      parseResponse.statusCode = apiResponse.statusCode;
+
+      if (apiResponse.statusCode != 200 && apiResponse.statusCode != 201) {
+        return _handleError(parseResponse, apiResponse);
+      } else if (apiResponse.body == "{\"results\":[]}"){
+        return _handleSuccessWithNoResults(parseResponse, 1, "Successful request, but no results found");
+      } else if (apiResponse.body == "OK"){
+        return _handleSuccessWithNoResults(parseResponse, 2, "Successful request");
+      } else {
+        return _handleSuccess(parseResponse, object, apiResponse.body);
+      }
+    } else {
+      parseResponse.error = ParseError(message: "Error reaching server, or server response was null");
+      return apiResponse;
     }
   }
-  /// Gets the current user from storage
-  ///
-  /// Current user is stored locally, but in case of a server update [bool]
-  /// fromServer can be called and an updated version of the [User] object will be
-  /// returned
-  static currentUser() {
-    return _getUserFromLocalStore();
-  }
-
-  /// Registers a user on Parse Server
-  ///
-  /// After creating a new user via [Parse.create] call this method to register
-  /// that user on Parse
-  signUp() async {
-    try {
-      if (emailAddress == null) return null;
-
-      Map<String, dynamic> bodyData = {};
-      bodyData[keyVarEmail] = emailAddress;
-      bodyData[keyVarPassword] = password;
-      bodyData[keyVarUsername] = username;
 
-      Uri tempUri = Uri.parse(_client.data.serverUrl);
-
-      Uri url = Uri(
-          scheme: tempUri.scheme,
-          host: tempUri.host,
-          path: "${tempUri.path}$path");
-
-      final response = await _client.post(url,
-          headers: {
-            keyHeaderRevocableSession: "1",
-          },
-          body: json.encode(bodyData));
-
-      _handleResponse(response, ParseApiRQ.signUp);
-      return this;
-    } on Exception catch (e) {
-      return _handleException(e, ParseApiRQ.signUp);
-    }
+  /// Handles exception instead of throwing an exception
+  static ParseResponse handleException(Exception exception) {
+    var response = ParseResponse();
+    response.error = ParseError(message: exception.toString(), isTypeOfException: true);
+    return response;
   }
 
-  /// Logs a user in via Parse
-  ///
-  /// Once a user is created using [Parse.create] and a username and password is
-  /// provided, call this method to login.
-  login() async {
-    try {
-      Uri tempUri = Uri.parse(_client.data.serverUrl);
-
-      Uri url = Uri(
-          scheme: tempUri.scheme,
-          host: tempUri.host,
-          path: "${tempUri.path}$keyEndPointLogin",
-          queryParameters: {keyVarUsername: username, keyVarPassword: password});
-
-      final response = await _client.post(url, headers: {
-        keyHeaderRevocableSession: "1",
-      });
-
-      _handleResponse(response, ParseApiRQ.login);
-      return this;
-    } on Exception catch (e) {
-      return _handleException(e, ParseApiRQ.login);
-    }
+  /// Handles any errors returned in response
+  static ParseResponse _handleError(ParseResponse response, Response apiResponse) {
+    Map<String, dynamic> responseData = JsonDecoder().convert(apiResponse.body);
+    response.error = ParseError(code: responseData['code'], message: responseData['error']);
+    response.statusCode = responseData['code'];
+    return response;
   }
 
-  /// Removes the current user from the session data
-  logout() {
-    _client.data.sessionId = null;
-    setObjectData(null);
+  /// Handles successful responses with no results
+  static ParseResponse _handleSuccessWithNoResults(ParseResponse response, int code, String value) {
+    response.success = true;
+    response.statusCode = 200;
+    response.error = ParseError(code: code, message: value);
+    return response;
   }
 
-  /// Sends a verification email to the users email address
-  verificationEmailRequest() async {
-    try {
-      final response = await _client.post(
-          "${_client.data.serverUrl}$keyEndPointVerificationEmail",
-          body: json.encode({keyVarEmail: emailAddress}));
-      return _handleResponse(response, ParseApiRQ.verificationEmailRequest);
-    } on Exception catch (e) {
-      return _handleException(e, ParseApiRQ.verificationEmailRequest);
-    }
-  }
+  /// Handles successful response with results
+  static ParseResponse _handleSuccess(ParseResponse response, dynamic object, String responseBody) {
+    response.success = true;
 
-  /// Sends a password reset email to the users email address
-  requestPasswordReset() async {
-    try {
-      final response = await _client.post(
-          "${_client.data.serverUrl}$keyEndPointRequestPasswordReset",
-          body: json.encode({keyVarEmail: emailAddress}));
-      return _handleResponse(response, ParseApiRQ.requestPasswordReset);
-    } on Exception catch (e) {
-      return _handleException(e, ParseApiRQ.requestPasswordReset);
-    }
-  }
+    var map = JsonDecoder().convert(responseBody) as Map;
 
-  /// Saves the current user
-  ///
-  /// If changes are made to the current user, call save to sync them with
-  /// Parse Server
-  save() async {
-    if (objectId == null) {
-      return signUp();
+    if (map != null && map.length == 1 && map.containsKey('results')) {
+      response.result = _handleMultipleResults(object, map.entries.first.value);
     } else {
-      try {
-        var uri = _client.data.serverUrl + "$path/$objectId";
-        var body = json.encode(toJson(forApiRQ: true), toEncodable: dateTimeEncoder);
-        final response = await _client.put(uri, body: body);
-        return _handleResponse(response, ParseApiRQ.save);
-      } on Exception catch (e) {
-        return _handleException(e, ParseApiRQ.save);
-      }
-    }
-  }
-
-  /// Removes a user from Parse Server locally and online
-  Future<ParseResponse> destroy() async {
-    if (objectId != null) {
-      try {
-        final response = await _client.delete(
-            _client.data.serverUrl + "$path/$objectId",
-            headers: {keyHeaderSessionToken: _client.data.sessionId});
-        return _handleResponse(response, ParseApiRQ.destroy);
-      } on Exception catch (e) {
-        return _handleException(e, ParseApiRQ.destroy);
-      }
-    }
-
-    return null;
-  }
-
-  /// Gets a list of all users (limited return)
-  static Future<ParseResponse> all() async {
-
-    var emptyUser = ParseUser(null, null, null);
-
-    try {
-      final response = await ParseHTTPClient().get(
-          "${ParseCoreData().serverUrl}/$path");
-
-      ParseResponse parseResponse = ParseResponse.handleResponse(emptyUser, response);
-
-      if (ParseCoreData().debug) {
-        logger(ParseCoreData().appName, keyClassUser, ParseApiRQ.getAll.toString(), parseResponse);
-      }
-
-      return parseResponse;
-    } on Exception catch (e) {
-      return ParseResponse.handleException(e);
-    }
-  }
-
-  static ParseUser _getUserFromLocalStore() {
-    var userJson = ParseCoreData().getStore().getString(keyParseStoreUser);
-
-    if (userJson != null) {
-      var userMap = JsonDecoder().convert(userJson);
-
-      if (userMap != null) {
-        ParseCoreData().sessionId = userMap[keyParamSessionToken];
-        return ParseUser.clone(userMap);
-      }
+      response.result = _handleSingleResult(object, map);
     }
 
-    return null;
+    return response;
   }
 
-  /// Handles an API response and logs data if [bool] debug is enabled
-  ParseResponse _handleException(Exception exception, ParseApiRQ type) {
-    ParseResponse parseResponse = ParseResponse.handleException(exception);
+  /// Handles a response with a multiple result object
+  static _handleMultipleResults(dynamic object, dynamic map) {
+    var resultsList = List();
 
-    if (_debug) {
-      logger(ParseCoreData().appName, className, type.toString(), parseResponse);
+    for (var value in map) {
+      resultsList.add(_handleSingleResult(object, value));
     }
 
-    return parseResponse;
+    return resultsList;
   }
 
-  /// Handles all the response data for this class
-  _handleResponse(Response response, ParseApiRQ type) {
-
-    ParseResponse parseResponse = ParseResponse.handleResponse(this, response);
-    if (_debug) {
-      logger(ParseCoreData().appName, className, type.toString(), parseResponse);
-    }
-
-    Map<String, dynamic> responseData = JsonDecoder().convert(response.body);
-    if (responseData.containsKey(keyVarObjectId)) {
-      fromJson(responseData);
-      _client.data.sessionId = responseData[keyParamSessionToken];
-    }
-
-    if (type == ParseApiRQ.getAll || type == ParseApiRQ.destroy) {
-      return parseResponse;
-    } else {
-      saveInStorage(keyParseStoreUser);
-      return this;
-    }
+  /// Handles a response with a single result object
+  static _handleSingleResult(dynamic object, map) {
+    if (object is Parse) return map;
+    if (object is ParseCloneable) return object.clone(map);
+    return null;
   }
 }