Beispiel #1
0
 def post(self, user_id=None):
     """
     Create medication and add it to a user’s list of medications
     POST  /api/med/{user id}
     """
     if not user_id:
         return {'reason': 'Invalid user'}, 404
     db = getDB()
     data = request.get_json(force=True)
     print data
     med_name = data['name']
     med_instr = data['instructions']
     schedule = data['schedule']
     adherence = {}
     medication = {
         'name': med_name,
         'instructions': med_instr,
         'schedule': schedule,
         'adherence': adherence,
     }
     response = db.medications.insert_one(medication)
     if response.acknowledged:
         user = db.users.find_one({'_id': ObjectId(user_id)})
         if not user:
             return {'reason': 'Invalid user'}, 404
         user_meds = user['medications']
         user_meds.append(medication['_id'])
         db.users.update_one({'_id': ObjectId(user_id)}, {'$set': {'medications': user_meds}})
         return _serialize(medication), 200
     else:
         return {'reason': 'Invalid data'}, 404
    def put(self, entry_id=None):
        # Update with partial or full post information.
        # Changes only the fields that differ between old and new post.
        db = getDB()
        if not entry_id:
            return {'reason': 'entry id required for updates'}, 404
        existing = db.entries.find_one({'_id': ObjectId(entry_id)})
        if not existing:
            return {'reason': 'entry does not exist for id ' + entry_id}, 404

        data = request.get_json(force=True)

        user = data['user'] if 'user' in data else existing['user']
        title = data['title'] if 'title' in data else existing['title']
        body = data['body'] if 'body' in data else existing['body']

        updated = {
            'user': user,
            'title': title,
            'body': body,
        }
        update_result = db.users.update_one({'_id': ObjectId(entry_id)},
                                            {'$set': updated})

        if update_result.acknowledged:
            updated['_id'] = entry_id
            ser = _serialize(updated)
            if self.cache:
                self.cache.set(entry_id, json.dumps(ser))
                print('cache set {}: {}'.format(entry_id, json.dumps(ser)))
            return ser, 200
        else:
            return {'reason': 'db failed to update entry object'}, 500
Beispiel #3
0
def editUserInformation(userId, email, phone, twitter, contactMethodFlags):
    db = database.getDB()
    cursor = db.cursor()
    sql = "UPDATE users set email = %s, phone = %s, twitter = %s, contactMethodFlags = %s WHERE userID = %s"
    cursor.execute(sql, (email, phone, twitter, contactMethodFlags, userId))
    db.commit()
    return True  
Beispiel #4
0
def _getCoachesPoll(teams):

    # get current week from Sportsdata API
    time = getTimeframe()

    # initialize dict of team rankings
    ranks = {team["id"]: [] for team in teams}

    db = getDB()
    votes = db.coaches_polls.find({
        "week": time["week"],
        "season": time["season"]
    })
    for vote in votes:
        for i, team in enumerate(vote["rankings"]):
            ranks[team].append(i + 1)

    teamsWithRank = [{
        "id": team["id"],
        "name": team["name"],
        "owner": team["owner"],
        "rank": floor(mean(ranks[team["id"]] or [1])),
        "topVotes": ranks[team["id"]].count(1),
    } for team in teams]

    return {
        "week": time["week"],
        "season": time["season"],
        "numVotes": votes.count(),
        "teams": sorted(teamsWithRank, key=lambda team: team["rank"]),
    }
Beispiel #5
0
def getOwner(user, pw):
    """Verifies user is an owner in the league."""
    client = SleeperGraphQLClient()
    query = gql("""
        query getUserID ($user: String! $pw: String!) {
            login(email_or_phone_or_username: $user password: $pw) {
                avatar
                display_name
                real_name
                email
                phone
                user_id
            }
        }
        """)
    try:
        data = client.request(query, {"user": user, "pw": pw})
    except TransportQueryError:
        return None
    userID = data["login"]["user_id"]
    season = getTimeframe()["season"]
    leagues = requests.get(
        f"https://api.sleeper.app/v1/user/{userID}/leagues/nfl/{season}").json(
        )
    leagueIDs = [league["league_id"] for league in leagues]
    if os.getenv("LEAGUE_ID") in leagueIDs:
        db = getDB()
        db.users.update({"user_id": data["login"]["user_id"]},
                        data["login"],
                        upsert=True)
        return userID
    return None
Beispiel #6
0
def sendMessageViaEmail(content, sender, receiver):
    db = database.getDB()
    cursor = db.cursor()
    sql = "SELECT email from users where userID = %s"
    cursor.execute(sql, (receiver,))
    data = cursor.fetchone()
    if data:
        email = data[0]
        try:
            #login to smtp server to send email
            server = smtplib.SMTP('smtp.gmail.com', 587)
            server.ehlo()
            server.starttls()
            gmail_user='******'
            gmail_password = '******'
            server.login(gmail_user, gmail_password)
            #get username of sender so we know who is sending this message
            sql = "SELECT username from users where userID = %s"
            cursor.execute(sql, (sender,))
            sender = cursor.fetchone()[0]
            # Message = "!!!Urgent Message from john doe: " + 
            message = "Subject: !!!Urgent message from " + str(sender) + "  \n" +  str(content)
            print (message)
            server.sendmail(gmail_user, email, message)
            print(gmail_user, email, message)
            return True
        except:
            print("Email exceptioned out")
            return False

    else:
        print("No data")
        return False
Beispiel #7
0
 def post(self, user_id=None, med_id=None):
     db = getDB()
     data = request.get_json(force=True)
     event = data['event']
     date = event['date']
     delta = event['med_delta']
     if not user_id:
         return {'reason': 'No user id'}, 404
     user = db.users.find_one({'_id': ObjectId(user_id)})
     if not user:
         return {'reason': 'Invalid user id'}, 404
     if not med_id:
         return {'reason': 'No medication id'}, 404
     med = db.medications.find_one({'_id': ObjectId(med_id)})
     if not med:
         return {'reason': 'Invalid med id'}, 404
     adherence = med['adherence']
     taken = adherence[date][0]
     needed = adherence[date][1]
     taken += delta
     adherence[date] = (taken, needed)
     updated = db.medications.update_one({'_id': ObjectId(med_id)}, {'$set': {'adherence': adherence}})
     if updated:
         med = db.medications.find_one({'_id': ObjectId(med_id)})
         return _serialize(med)
     else:
         return {'reason': 'Unable to update adherence'}
Beispiel #8
0
    def delete(self, user_id=None):
        """
        Remove user from friend's network and friend from user's network
        DELETE /api/user/{user id}/friends - { friends: List<UserId> }
        """
        db = getDB()
        data = request.get_json(force=True)
        if user_id:
            user = db.users.find_one({'_id': ObjectId(user_id)})
            if user and 'friends' in data:
                # remove friends
                user_friends = set(user['friends'])
                deleted_friends = set([])
                for f in data['friends']:
                    find_friend = db.users.find_one({'_id': ObjectId(f)})
                    if find_friend and f != user_id:
                        # remove friend from user friend set
                        user_friends.remove(f)
                        deleted_friends.add(f)
                        # remove user from friend's friend set
                        f_friends = set(find_friend['friends']) - {user_id}
                        db.users.update_one({'_id': ObjectId(f)}, {'$set': {'friends': list(f_friends)}})
                db.users.update_one({'_id': ObjectId(user_id)}, {'$set': {'friends': list(user_friends)}})

                removed_friends = []
                for f_id in deleted_friends:
                    u = db.users.find_one({'_id': ObjectId(f_id)})
                    if u:
                        removed_friends.append(_serialize(u))
                return {'friends': removed_friends}
            else:
                return {'reason': 'user not found'}, 500
        else:
            return {'reason': 'user id required to add friends'}, 404
Beispiel #9
0
    def post(self, user_id=None):
        """
        Add one or more friends to a user's network, also add the user to each friend's network
        POST /api/user/{user id}/friends - { friends: List<UserId> }
        """
        db = getDB()
        data = request.get_json(force=True)
        if user_id:
            user = db.users.find_one({'_id': ObjectId(user_id)})
            if user and 'friends' in data:
                # add friends
                user_friends = set(user['friends'])
                for f in data['friends']:
                    find_friend = db.users.find_one({'_id': ObjectId(f)})
                    if find_friend and f != user_id:
                        # add friend to user friend set
                        user_friends.add(f)
                        # add user to friend's friend set
                        f_friends = set(find_friend['friends']) | {user_id}
                        db.users.update_one({'_id': ObjectId(f)}, {'$set': {'friends': list(f_friends)}})
                db.users.update_one({'_id': ObjectId(user_id)}, {'$set': {'friends': list(user_friends)}})

                added_friends = []
                for f_id in user_friends:
                    u = db.users.find_one({'_id': ObjectId(f_id)})
                    if u:
                        added_friends.append(_serialize(u))
                return {'friends': added_friends}
            else:
                return {'reason': 'user not found'}, 500
        else:
            return {'reason': 'user id required to add friends'}, 404
def deleteToken(token):
    db = database.getDB()
    cursor = db.cursor()
    sql = "UPDATE token set expiration = 0 where token = %s"
    cursor.execute(sql, (token, ))
    db.commit()
    return True
Beispiel #11
0
def sendMessageViaText(content, sender, receiver):
    db = database.getDB()
    cursor.db.cursor()
    sql = "SELECT phone from users where userID = %s"
    cursor.execute(sql, (receiver,))
    data = cursor.fetchone()
    if data:
        email = data[0]
Beispiel #12
0
def _getRosterPlayers(rosters):

    # flatten player list
    simpleRosters = [roster["players"] for roster in rosters]
    allIds = [player for roster in simpleRosters for player in roster]

    # get players from DB
    db = getDB()
    return getPlayerData(db, allIds)
Beispiel #13
0
def deleteTradeVotes(transaction_id, user_id):
    """Delete Trade Votes per user."""

    db = getDB()
    db.trade_votes.delete_many(
        {
            "transaction_id": transaction_id,
            "user_id": user_id,
        }, )
def checkLogin(username, password):
    db = database.getDB()
    cursor = db.cursor()
    sql = "SELECT userID FROM users WHERE username = %s AND password = %s"
    cursor.execute(sql, (username, password))
    returnData = cursor.fetchone()
    if returnData:
        return returnData[0]
    else:
        return False
Beispiel #15
0
def updatePlayers():
    """Gets players from Sleepers database and uploads to Mongo."""
    players = requests.get("https://api.sleeper.app/v1/players/nfl").json()

    # update players in database
    db = getDB()
    db.drop_collection("players")
    db.create_collection("players")
    db.players.insert_many(players.values())
    db.players.create_index("player_id")
def generateAndSaveToken(userID):
    letters = string.ascii_uppercase
    token = ''.join(random.choice(letters) for i in range(69))
    db = database.getDB()
    cursor = db.cursor()
    sql = "INSERT INTO token(token, userID, expiration) VALUES (%s, %s, %s)"
    expiration = time.time() + 60 * 60 * 24 * 7
    print("this will expire", expiration)
    cursor.execute(sql, (token, userID, expiration))
    db.commit()
    return token
Beispiel #17
0
def getSentMessages(userID):
    db = database.getDB()
    cursor = db.cursor()
    sql = "SELECT * FROM messages WHERE sender = %s"
    cursor.execute(sql, (userID,))
    returnData = cursor.fetchall()
    if returnData:
        items = [dict(zip([key[0] for key in cursor.description], row)) for row in returnData]
        return {"getSentMessages":items}
    else:
        return {"Error":"no users available"}
Beispiel #18
0
def getUsers():
    db = database.getDB()
    cursor = db.cursor()
    sql = "SELECT userID, username, email  FROM users"
    cursor.execute(sql)
    returnData = cursor.fetchall()
    if returnData:
        items = [dict(zip([key[0] for key in cursor.description], row)) for row in returnData]
        return {"getUsers":items}
    else:
        return {"Error":"no users available"}
Beispiel #19
0
def getUserSendMethods(userID):
    db = database.getDB()
    cursor = db.cursor()
    sql = "SELECT a.id, a.contactMethodName, a.contactMethodFlagValue from contactMethodFlags a inner join users b on a.contactMethodFlagValue & b.contactMethodFlags and b.userID = %s"
    cursor.execute(sql, (userID,))
    returnData = cursor.fetchall()
    if returnData:
        items = [dict(zip([key[0] for key in cursor.description], row)) for row in returnData]
        return {"getUserSendMethods":items}
    else:
        return {"Error":"no send methods available"}
Beispiel #20
0
def getAllSendMethods():
    db = database.getDB()
    cursor = db.cursor()
    sql = "SELECT id, contactMethodName, contactMethodFlagValue from contactMethodFlags"
    cursor.execute(sql)
    returnData = cursor.fetchall()
    if returnData:
        items = [dict(zip([key[0] for key in cursor.description], row)) for row in returnData]
        return {"getAllSendMethods":items}
    else:
        return {"Error":"no send methods available"}
def verifyTokenValid(token):
    db = database.getDB()
    cursor = db.cursor()
    sql = "SELECT expiration, userId from token where token = %s"
    cursor.execute(sql, (token, ))
    data = cursor.fetchone()
    if data:
        if data[0] < time.time():
            return False
        else:
            return data[1]
Beispiel #22
0
def rules():
    db = getDB()
    proposal = db.proposals.find_one({"open": True})
    with open("docs/rules.md") as f:
        text = f.read()
        html = markdown.markdown(text)
        return render_template(
            "rules.html",
            proposal=proposal,
            html=html,
        )
Beispiel #23
0
def getUserInformation(userID):
    db = database.getDB()
    cursor = db.cursor()
    sql = "SELECT email, phone, twitter, contactMethodFlags from users where userID = %s"
    cursor.execute(sql, (userID,))
    print (sql, userID)
    returnData = cursor.fetchall()
    if returnData:
        items = [dict(zip([key[0] for key in cursor.description], row)) for row in returnData]
        return {"userInformation":items}
    else:
        return {"Error":"no data available"}
Beispiel #24
0
def sendMessage(message, sender, receiver):
    # try:
    db = database.getDB()
    cursor = db.cursor()
    sql = "INSERT INTO messages (content, sender, receiver) VALUES (%s, %s, %s)"
    cursor.execute(sql, (message, sender, receiver))
    db.commit()
    messageSent = sendViaPreferredMethod(message, sender, receiver)
    if messageSent:
        return {"Send Message":"Success"}
    else:
        return {"Error":"Message send failed"}
Beispiel #25
0
 def get(self, med_id=None):
     """
     Get medication and usage information
     GET  /api/med/{med id}
     """
     if not med_id:
         return {'reason': 'Med_id not provided'}, 404
     db = getDB()
     medication = db.medications.find_one({'_id': ObjectId(med_id)})
     if not medication:
         return {'reason': 'Invalid med id'}, 400
     return _serialize(medication), 200
Beispiel #26
0
 def get(self, user_id=None):
     db = getDB()
     if user_id:
         result = []
         user = db.users.find_one({'_id': ObjectId(user_id)})
         if user:
             user_friends = user['friends']
             for f_id in user_friends:
                 u = db.users.find_one({'_id': ObjectId(f_id)})
                 if u:
                     result.append(_serialize(u))
         return {'friends': result}
     else:
         return {'reason': 'user id required to add friends'}, 404
Beispiel #27
0
def addProposalVote(user_id, rc_id, vote):
    """Adds rule change proposal to the DB."""

    db = getDB()
    proposal = db.proposals.find_one({"rc_id": rc_id})
    db.proposal_votes.update(
        {
            "user_id": user_id,
            "proposal_id": proposal["_id"]
        },
        {
            "user_id": user_id,
            "yes_vote": vote == "yes",
            "proposal_id": proposal["_id"]
        },
        upsert=True,
    )
Beispiel #28
0
def getProposal(rc_id):
    """This gets yes and no votes for a given proposal from the DB."""

    db = getDB()
    proposal = db.proposals.find_one({"rc_id": rc_id})
    if not proposal:
        return None
    votes = db.proposal_votes.find({"proposal_id": proposal["_id"]})
    yes, no = 0, 0
    for vote in votes:
        if vote["yes_vote"]:
            yes += 1
        else:
            no += 1
    proposal["yes"] = yes
    proposal["no"] = no
    return proposal
Beispiel #29
0
def addTradeVote(transaction_id, user_id, roster_id):
    """Adds Trade Vote to DB."""

    db = getDB()
    db.trade_votes.update(
        {
            "transaction_id": transaction_id,
            "user_id": user_id,
            "roster_id": roster_id,
        },
        {
            "transaction_id": transaction_id,
            "user_id": user_id,
            "roster_id": roster_id,
        },
        upsert=True,
    )
Beispiel #30
0
 def get(self, user_id=None):
     """
     With user id, return full user object
     GET /api/user/<userid> - specific user
     GET /api/user - all users
     """
     db = getDB()
     if user_id:
         # return user information
         user = db.users.find_one({'_id': ObjectId(user_id)}, {'password': 0, 'salt': 0})
         if not user:
             return {'reason': 'User not found'}, 404
         return _serialize(user)
     else:
         # return all users
         user_list = [_serialize(u) for u in db.users.find()]
         return user_list
Beispiel #31
0
import database

col = database.getDB("auditserver", "pcaip");


def findbyid(id):
    return col.find_one({"_id": id})


def findbypca(id):
    return findbyid(id)


def insert(insertdoc):
    return col.insert_one(insertdoc).inserted_id


def update(id, updatedoc):
    res = col.update_one({"_id": id}, {"$set": updatedoc})
    if res.modified_count > 0:
        return True
    else:
        return False


def delete(id):
    res = col.delete_one({"_id": id})
    if res.deleted_count > 0:
        return True
    else:
        return False
Beispiel #32
0
def	retriveFromDB(owner, repo):
	c = database.getDB().cursor()
	results = c.execute('''select * from orphans where project_name = ?, owner = ?''', (repo, owner))
	return results.fetchone()