Example #1
0
    def handleMessage(self, sessionToken, status):

        mentionIds = self.extractUsernames(status)

        if mentionIds == []:
            #this isn't a message
            return

        #get our object id
        myObjectId = whoAmI(sessionToken)
        entry = {
                    "from" : {
                            "__type":"Pointer",
                            "className":"_User",
                            "objectId": myObjectId
                          },
                    "message" : status,
                    "read" : False,
                    "to" : {
                            "__type":"Pointer",
                            "className":"_User",
                            "objectId": myObjectId
                          }
                }
        for toObjectId in mentionIds:
            #set the recipient
            entry["to"]["objectId"] = toObjectId
            #post them into the system
            headers = apiHeader()
            r = requests.post(url + "/classes/Messages", headers = headers,
                    json = entry)
Example #2
0
    def post(self):
        """
        they post us username/password
        we send that to parse
        which creates the user and gives us a session token
        return the sessiontoken
        """
        parser = reqparse.RequestParser()
        parser.add_argument("username", required=True)
        parser.add_argument("password", required=True)
        parser.add_argument("email")
        args = parser.parse_args()
        #extract require username/password

        #todo: add stuff for the geo location of the person, and display name
        headers = apiHeader()
        headers["X-Parse-Revocable-Session"] = 1
        payload = {"username": args["username"],
                   "password": args["password"],
                   "displayName": args["username"]
                   }

        if args["email"] != None:
            payload["email"] = args["email"]
            #email is optional

        r = requests.post(url + "/users", headers = headers, json = payload)
        #setup to send it the way parse wants

        response = json.loads(r.text)
        if "error" in response:
            return {"error": "unable to create user"}

        return {"sessionToken": response["sessionToken"]}
Example #3
0
    def post(self):
        parser = reqparse.RequestParser()
        parser.add_argument("sessionToken", required=True)
        args = parser.parse_args()

        sessionToken = args["sessionToken"]

        userObjectId = whoAmI(sessionToken)
        if userObjectId == None:
            #we don't use validateSessionToken
            #to avoid a duplicated call
            return {"error": "authentication error"}

        #query for the statuses that mention me
        header = apiHeader()
        query = {"to":
                    {
                        "__type": "Pointer",
                        "className": "_User",
                        "objectId": userObjectId
                    }
                } #change this
        data = {"where": json.dumps(query), "include":"from"}

        r = requests.get(url + "/classes/Messages", headers = header, params = data)
        response = json.loads(r.text)
        return [{"msg": item["message"], "readStatus": item["read"], "objectId": item["objectId"],
            "from": item["from"]["username"]} for item in response["results"]]
Example #4
0
    def handleMessage(self, sessionToken, status):

        mentionIds = self.extractUsernames(status)

        if mentionIds == []:
            #this isn't a message
            return

        #get our object id
        myObjectId = whoAmI(sessionToken)
        entry = {
            "from": {
                "__type": "Pointer",
                "className": "_User",
                "objectId": myObjectId
            },
            "message": status,
            "read": False,
            "to": {
                "__type": "Pointer",
                "className": "_User",
                "objectId": myObjectId
            }
        }
        for toObjectId in mentionIds:
            #set the recipient
            entry["to"]["objectId"] = toObjectId
            #post them into the system
            headers = apiHeader()
            r = requests.post(url + "/classes/Messages",
                              headers=headers,
                              json=entry)
Example #5
0
    def post(self):
        parser = reqparse.RequestParser()
        parser.add_argument("sessionToken", required=True)
        args = parser.parse_args()

        sessionToken = args["sessionToken"]

        userObjectId = whoAmI(sessionToken)
        if userObjectId == None:
            #we don't use validateSessionToken
            #to avoid a duplicated call
            return {"error": "authentication error"}

        #query for the statuses that mention me
        header = apiHeader()
        query = {
            "to": {
                "__type": "Pointer",
                "className": "_User",
                "objectId": userObjectId
            }
        }  #change this
        data = {"where": json.dumps(query), "include": "from"}

        r = requests.get(url + "/classes/Messages",
                         headers=header,
                         params=data)
        response = json.loads(r.text)
        return [{
            "msg": item["message"],
            "readStatus": item["read"],
            "objectId": item["objectId"],
            "from": item["from"]["username"]
        } for item in response["results"]]
Example #6
0
    def post(self):
        parser = reqparse.RequestParser()
        parser.add_argument("sessionToken", required=True)
        parser.add_argument("lat", required=True)
        parser.add_argument("lon", required=True)
        parser.add_argument("limit")

        args = parser.parse_args()
        sessionToken = args["sessionToken"]
        #we're going to verify this session token for security purposes
        if not validateSessionToken(args["sessionToken"]):
            return {"error": "authentication problem"}


        limit = 10 #default is 10
        if args["limit"] != None:
            limit = int(args["limit"])

        loc = {"geo": {
                    "$nearSphere": {
                        "__type": "GeoPoint",
                        "latitude": float(args["lat"]),
                        "longitude": float(args["lon"])
                        }
                    }
              }


        data = {"limit": limit,
                "where":json.dumps(loc)}
        header = apiHeader()
        r = requests.get(url + "/users", headers = header, params = data)
        response = json.loads(r.text)

        #filter the response so we don't leak a bunch of personal info
        filtered_response = {"results": []}
        for item in response["results"]:
            entry = {}
            entry["username"] = item["username"]
            if "displayName" not in item or item["displayName"] == None:
                entry["displayName"] = item["username"]
            else:
                entry["displayName"] = item["displayName"]

            if "status" not in item or item["status"] == None:
                entry["status"] = ""
            else:
                entry["status"] = item["status"]

            if "geo" not in item:
                entry["lat"] = 0
                entry["lon"] = 0
            else:
                entry["lat"] = item["geo"]["latitude"]
                entry["lon"] = item["geo"]["longitude"]

            filtered_response["results"].append(entry)
        return filtered_response
Example #7
0
    def getEntryForUsername(self, username):
        header = apiHeader()
        query = {"username": username}
        data = {"where": json.dumps(query), "include": "profileImage"}

        r = requests.get(url + "/users", headers = header, params = data)
        response = json.loads(r.text)
        if response["results"] == []:
            return {"error": "user not found"}
        return response["results"][0]
Example #8
0
    def getEntryForUsername(self, username):
        header = apiHeader()
        query = {"username": username}
        data = {"where": json.dumps(query), "include": "profileImage"}

        r = requests.get(url + "/users", headers=header, params=data)
        response = json.loads(r.text)
        if response["results"] == []:
            return {"error": "user not found"}
        return response["results"][0]
Example #9
0
    def post(self):
        """
        they post us username/password
        we send that to parse
        return the sessiontoken
        """
        parser = reqparse.RequestParser()
        parser.add_argument("username", required=True)
        parser.add_argument("password", required=True)
        args = parser.parse_args()
        #extract require username/password

        headers = apiHeader()
        headers["X-Parse-Revocable-Session"]  = 1
        params = {"username": args["username"],
                   "password": args["password"]}
        r = requests.get(url + "/login", headers = headers, params = params)
        #setup to send it the way parse wants

        response = json.loads(r.text)
        if "error" in response:
            return {"error": "unable to authenticate"}

        return {"sessionToken": response["sessionToken"]}