Master

.gitignore

@@ -1,3 +1 @@
-__pycache__
-moodbase-env
-.DS_Store
+todo.txt

.vscode/launch.json

@@ -0,0 +1,52 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+    {
+        "name": "Chrome",
+        "type": "chrome",
+        "request": "launch",
+        "url": "http://localhost:8080",
+        "webRoot": "${workspaceFolder}/src",
+        "sourceMapPathOverrides": {
+            "webpack-internal:///./src/": "${webRoot}/*",
+            "webpack-internal:///src/*": "${webRoot}/*"
+        }
+    },
+    {
+            "type": "firefox",
+            "request": "launch",
+            "name": "vuejs: firefox",
+            "url": "http://localhost:8080",
+            "webRoot": "${workspaceFolder}/src",
+            "pathMappings": [{ "url": "webpack:///src/", "path": "${webRoot}/" }]
+        },
+    {
+        "name": "Launch via NPM",
+        "request": "launch",
+        "runtimeArgs": [
+            "run-script",
+            "debug"
+        ],
+        "runtimeExecutable": "npm",
+        "skipFiles": [
+            "<node_internals>/**"
+        ],
+        "type": "pwa-node"
+    },
+        {
+            "name": "Python: FastAPI",
+            "type": "python",
+            "request": "launch",
+            "module": "uvicorn",
+            "args": [
+                "main:app"
+            ],
+            "jinja": true,
+            "justMyCode":false,
+
+        }
+    ]
+}

.vscode/settings.json

@@ -0,0 +1,7 @@
+{
+    "python.linting.pylintEnabled": true,
+    "python.linting.enabled": true,
+    "python.linting.pylintArgs": [
+        "--disable=C0103"
+    ]
+}

backend/.gitignore

@@ -0,0 +1,4 @@
+__pycache__
+moodbase-env
+.DS_Store
+.env

backend/build/lib/models/groupModel.py

@@ -0,0 +1,10 @@
+from pydantic import BaseModel
+
+class GroupData(BaseModel):
+    name:str
+    memberDict:dict
+    colors:dict
+    weightButtons:dict
+    adminUser:str
+    timeInterval:int
+    password:str

backend/build/lib/models/plotModel.py

@@ -0,0 +1,44 @@
+from typing import ValuesView
+from pydantic import BaseModel, Field
+from datetime import datetime, timezone
+
+
+# remember x value is happiness y value is calm
+class PlotDataSubmission(BaseModel):
+    lineChart: dict
+    clickMap: dict
+    timestamp = datetime.now(timezone.utc)
+
+    def truncateCoordinates(self):
+        for key, value in self.lineChart.items():
+            self.lineChart[key] = round(value,1)
+        for key,value in self.clickMap.items():
+            self.clickMap[key]=int(value)
+        return True 
+
+    def returnList(self):
+        listOfValues = []
+        for value in self.clickMap.values():
+            listOfValues.append(value)
+        for value in self.lineChart.values():
+            listOfValues.append(value)
+        return listOfValues
+
+    def prepareForCommunityData(self,key):
+        communityEntry=getattr(self,key)
+        communityEntry['day']=datetime.today()
+        return communityEntry
+
+class UserPlotData(BaseModel):
+    user:str
+    dictWithLists:dict
+
+class UserColorChoices(BaseModel):
+    happyColor:dict
+    calmColor:dict
+    sadColor:dict
+    anxiousColor:dict
+
+class UserColorChange(BaseModel):
+    colorChange:dict
+    variable:str

backend/build/lib/models/userModel.py

@@ -0,0 +1,20 @@
+from typing import Optional
+from db import userData
+from pydantic import BaseModel, EmailStr, Field
+
+class TestModel(BaseModel):
+    testing:str
+
+class User(BaseModel):
+    username: str 
+    password: str
+    email: Optional[EmailStr]
+    active= False
+
+class ActivationModel(BaseModel):
+    token:str
+
+class ResetModel(BaseModel):
+    email:Optional[EmailStr]
+    token:Optional[str]
+    newPassword:Optional[str]

backend/build/lib/models/weightModel.py

@@ -0,0 +1,7 @@
+from pydantic import BaseModel
+from datetime import datetime,timezone
+
+class WeightData(BaseModel):
+    name:str
+    value:int
+    delta:int

backend/build/lib/modules/AuthenticationModule.py

@@ -0,0 +1,160 @@
+# database stuff
+from db import userData,bannedKeys,aggregateData, groupData
+from models.userModel import User
+from modules.UserAggregationUtilities import updateUserCountOnActivation
+
+# email stuff
+import modules.EmailModule as email
+
+# dependency injection stuff
+from fastapi import HTTPException, Depends,BackgroundTasks, Security, Header
+
+# jwt and password stuff
+from jose import JWTError, jwt
+from passlib.context import CryptContext
+from datetime import datetime,timedelta,timezone
+
+# environment variable and bearer stuff
+from config import Secret
+from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
+from dotenv import load_dotenv
+load_dotenv('.env')
+from decouple import config
+
+security = HTTPBearer()
+
+secret=config('secret')
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+def gate(refresh: str = Header(None), userAuth: HTTPAuthorizationCredentials = Security(security)):
+    try:
+        return getUserFromToken(userAuth.credentials)
+    except:
+        raise HTTPException(status_code=401,detail='invalid token')
+
+def verifyUserAtLogin(loginAttempt: User) -> User:
+    checkUsername={'username':loginAttempt['username']}
+    if userData.find(checkUsername).limit(1).count()<1:
+        return False
+    else:
+        userToCheck=userData.find_one(checkUsername)
+        if pwd_context.verify(loginAttempt['password'].encode('utf-8'), userToCheck['password']):
+            return userToCheck
+        else:
+            return False    
+
+def createAccessToken(subName: str,*args) -> dict():
+    payload = {
+        'exp' : datetime.now(timezone.utc) + timedelta(days=args[0], hours=args[1], minutes=args[2]),
+        'iat' : datetime.now(tz=timezone.utc),
+        'sub' : subName        }
+    return jwt.encode(
+        payload, 
+        secret,
+        algorithm='HS256'
+    )
+
+def getUserFromToken(tokenToUser:str)-> str:
+    decoded = jwt.decode(tokenToUser, secret, 'HS256')
+    userStr=decoded['sub']
+    return userStr
+
+def checkToken(tokenToCheck:str)->str:
+    try:
+         jwt.decode(tokenToCheck,secret,'HS256')
+         return tokenToCheck
+    except:
+        raise HTTPException(status_code=401,detail='invalid token')
+
+def addUserToDatabase(user:User) -> dict:
+    checkUsername={'username':user.username}
+    # checkEmail={'email':user.email}
+    if userData.find(checkUsername).limit(1).count()>0:
+        raise HTTPException(status_code=404,detail="User already exists with this ID or email address")
+    else: 
+        userToDB=user.dict()
+        userToDB['groupMemberships']={}
+        userToDB['password']=pwd_context.hash(user.password)
+        userData.insert_one(userToDB)
+        activationToken=createAccessToken(user.username,2,0,0)
+        url=createUrlForEmail("activate",activationToken)
+        activationSpecs={'urlDict':{'url':url},'subject':'Activation email',
+                        'recipient':user.email,'template':'ActivationEmail.html'}
+        return activationSpecs
+
+def createUrlForEmail(route: str,token:str) -> str:
+    url=f"http://localhost:8080/{route}/{token}"
+    return url
+
+def activateUser(tokenDict: dict) -> dict:
+    user=getUserFromToken(tokenDict.token)
+    userData.update_one({'username':user},{'$set':{'active':True}})
+    updateUserCountOnActivation()
+    activationToken=createAccessToken(user,0,0,30)
+    return activationToken
+
+def sendResetEmail(emailObj):
+    lookupEmail={'email':emailObj.email}
+    user=userData.find_one(lookupEmail)
+    forgotToken=createAccessToken(user,0,0,60)
+    url=createUrlForEmail("reset",forgotToken)
+    emailSpecifications={
+        'recipient':emailObj.email,
+        'urlDict': {'url':url},
+        'subject':"Reset password email",
+        'template':'ResetEmail.html'}
+    return emailSpecifications
+
+def resetPassword(newPassword):
+    resetToken=newPassword.token
+    user=getUserFromToken(resetToken)
+    if not user: raise HTTPException(status_code=404,detail='Did not work') 
+    userData.update_one({'username':user},
+            {'$set':{'password':pwd_context.hash(newPassword.newPassword)}})
+    return {'message':'password reset successfully'}
+
+def attemptRefresh(refreshToken):
+    user=getUserFromToken(refreshToken)
+    if user:
+        return {'access_token':createAccessToken(user,0,0,1),'token_type':'bearer'}
+    else:
+        raise HTTPException(status_code=401,detail='invalid token')
+
+def banKeyTTL(tokenToBan):
+    try:
+        expiry = createTTL(tokenToBan)
+        bannedKeys.insert_one({'expires':expiry,'tokenValue':tokenToBan})
+        return True
+    except:
+        raise HTTPException(status_code=418, detail="Something happened")
+
+def createTTL(token:str):
+    decoded = jwt.decode(token,secret,'HS256')
+    expDT = datetime.fromtimestamp(decoded['exp'],tz=timezone.utc)
+    return expDT
+    # timeToExpire = (expDT - datetime.now(timezone.utc)).total_seconds()
+    # return timeToExpire
+
+def sendGroupInvitations(groupName:str,membersToInvite:dict):
+    for member in membersToInvite.keys():
+        email.sendEmailBackground({
+            'recipient':userData.find_one({'user':member})['email'],
+            'urlDict':{
+                'url':createUrlForEmail("groups/"+groupName,createAccessToken(member)),
+                'groupName':groupName
+                },
+            'subject':'Your invitation to a moodgroup',
+            'template':'GroupInvitation.html'
+        })
+    return True
+
+def handleGroupLogin(userToken:str,groupName:str):
+    userToCheck= userData.find_one (
+        {'username': getUserFromToken(userToken)}
+    )
+    groupToCheck = groupData.find_one(
+        {'name':groupName})
+    if 'groupName' in userToCheck['groupMemberships'] and + userToCheck['username'] in groupToCheck['memberDict' ]:
+        return True
+    else:
+        raise HTTPException(status_code=404,detail='You are not currently a member of this group. Speak to the group administrator to regain access.')  

backend/build/lib/modules/EmailModule.py

@@ -0,0 +1,59 @@
+from fastapi import BackgroundTasks
+from fastapi_mail import FastMail, MessageSchema, ConnectionConfig
+from pathlib import Path
+from dotenv import load_dotenv
+load_dotenv('.env')
+from decouple import config
+
+# environment variables
+class Envs:
+    MAIL_USERNAME = config('MAIL_USERNAME')
+    MAIL_PASSWORD = config('MAIL_PASSWORD')
+    MAIL_FROM = config('MAIL_FROM')
+    MAIL_PORT = int(config('MAIL_PORT'))
+    MAIL_SERVER = config('MAIL_SERVER')
+    MAIL_FROM_NAME = config('MAIL_FROM_NAME')
+
+# mail config
+
+mailer = ConnectionConfig(
+    MAIL_USERNAME=Envs.MAIL_USERNAME,
+    MAIL_PASSWORD=Envs.MAIL_PASSWORD,
+    MAIL_FROM=Envs.MAIL_FROM,
+    MAIL_PORT=Envs.MAIL_PORT,
+    MAIL_SERVER=Envs.MAIL_SERVER,
+    MAIL_FROM_NAME=Envs.MAIL_FROM_NAME,
+    MAIL_TLS=True,
+    MAIL_SSL=False,
+    USE_CREDENTIALS=True,
+    # TEMPLATE_FOLDER=Path(__file__).parent.parent / "templates"
+)
+
+# mail functions
+
+async def send_email_async(emailSpecs):
+    recipient="danbidikov@gmail.com"
+    # template_body={'url':url}
+    message = MessageSchema(
+        subject=emailSpecs['subject'],
+        recipients=[recipient],
+        template_body=emailSpecs['urlDict'],
+        subtype='html',
+    )
+
+    fm = FastMail(mailer)
+    await fm.send_message(message,template_name=emailSpecs['template'])
+
+async def sendEmailBackground(emailSpecs:dict):
+    recipient="danbidikov@gmail.com"
+    message = MessageSchema(
+        subject=emailSpecs['subject'],
+        recipients=[recipient],
+        template_body=emailSpecs['urlDict'],
+        subtype='html',
+    )
+    # background_task=BackgroundTasks
+    fm = FastMail(mailer)
+    await fm.send_message( message, template_name=emailSpecs['template'])
+
+    # return {'message':'email has been sent'}