Initial Commit

Author: PhilippMDoerner

LICENSE

@@ -0,0 +1,6 @@
+# StoryFontBackendNim
+A re-implementation of the storyfont backend in nim.
+The tech stack of this project is:
+- Application Server: prologue
+- ORM: norm
+- JWT-handling: jwt

README.md

@@ -0,0 +1 @@
+switch("path", "~/dev/nimstoryfont/../src")

config/config.nims

@@ -0,0 +1,13 @@
+# Package
+
+version       = "0.1.0"
+author        = "PhilippMDoerner"
+description   = "A new awesome nimble package"
+license       = "GPL-3.0-or-later"
+srcDir        = "src"
+bin           = @["nimstoryfont"]
+
+
+# Dependencies
+
+requires "nim >= 1.6.2"

nimstoryfont.nimble

@@ -0,0 +1,82 @@
+import prologue
+import times
+
+#Custom Settings
+const database* = "db.sqlite3"
+const DEBUG*: bool = true
+const ACCESS_TOKEN_LIFETIME*: TimeInterval = hours(1) # 1h in seconds
+const REFRESH_TOKEN_LIFETIME*: TimeInterval = days(100) # 100 days in seconds
+
+#Prologue Settings
+let coreSettings*: Settings = loadSettings("./settings.json")
+
+const SECRET_KEY*: string = "MyBeautifulSecretKey"
+const AUTHORIZATION_HEADER*: string = "Authorization"
+
+
+#Constants
+const PRIMARY_DB_TIME_FORMAT* = "yyyy-MM-dd HH:mm:ss'.'ffffff" #Datetime format as Django stores it in DB
+const SECONDARY_DB_TIME_FORMAT* = "yyyy-MM-dd HH:mm:ss" # Datetime format as Django sometimes stores it in DB
+const OUTPUT_TIME_FORMAT* = "yyyy-MM-dd'T'HH:mm:ss'.'ffffff'Z'"
+
+###TABLE NAMES
+#Auth
+const GROUP_TABLE* = "auth_group"
+const GROUP_PERMISSION_TABLE* = "auth_group_permission"
+const PERMISSION_TABLE* = "auth_permission"
+const USER_TABLE* = "auth_user"
+const USER_GROUP_TABLE* = "auth_user_groups"
+const USER_USERPERMISSIONS_TABLE* = "auth_user_user_permissions"
+
+const TOKEN_TABLE* = "authtoken_token"
+const TOKEN_BLACKLIST_TABLE* = "token_blacklist_blacklistedtoken"
+const TOKEN_OUTSTANDING_TABLE* = "token_blacklist_outstandingtoken"
+
+#Django
+const DJ_ADMIN_LOG_TABLE* = "django_admin_log"
+const DJ_CONTENT_TYPE_TABLE* = "django_content_type"
+const DJ_MIGRATION_TABLE* = "django_migrations"
+const DJ_SESSION_TABLE* = "django_session"
+
+const DJ_GROUPOBJECTPERMISSION* = "guardian_groupobjectpermission"
+const DJ_USEROBJECTPERMISSION* = "guardian_userobjectpermission"
+
+#Wikientries
+const CAMPAIGN_TABLE* = "wikientries_campaign"
+const CHARACTER_TABLE* = "wikientries_character"
+const CHARACTER_PLAYERCLASS_TABLE* = "wikientries_characterplayerclassconnection"
+const CREATURE_TABLE* = "wikientries_creature"
+const DIARYENTRY_TABLE* = "wikientries_diaryentry"
+const ENCOUNTER_TABLE* = "wikientries_encounter"
+const ENCOUNTER_CHARACTER_TABLE* = "wikientries_encounterconnection"
+const IMAGE_TABLE* = "wikientries_image"
+const ITEM_TABLE* = "wikientries_item"
+const LOCATION_TABLE* = "wikientries_location"
+const ORGANIZATION_TABLE* = "wikientries_organization"
+const PLAYERCLASS_TABLE* = "wikientries_playerclass"
+const QUEST_TABLE* = "wikientries_quest"
+const QUOTE_TABLE* = "wikientries_quote"
+const QUOTE_CHARACTER_TABLE* = "wikientries_quoteconnection"
+const RULES_TABLE* = "wikientries_rules"
+const SESSION_TABLE* = "wikientries_session"
+const SPELL_TABLE* = "wikientries_spell"
+const SPELL_PLAYERCLASS_TABLE* = "wikientries_spellclassconnection"
+
+#Fileserver
+const SESSIONAUDIO_TABLE* = "fileserver_sessionaudio"
+const TIMESTAMP_TABLE* = "fileserver_sessionaudiotimestamp"
+
+#Map
+const MAP_TABLE* = "map_map"
+const MARKER_TABLE* = "map_marker"
+const MARKERTYPE_TABLE* = "map_markertype"
+
+#Search
+const SEARCH_TABLE* = "search_article_content"
+const EMPTY_SEARCH_RESPONSE_TABLE* = "wikientries_emptysearchresponse"
+
+#Sqlite
+const SQLITE_SEQUENCE_TABLE* = "sqlite_sequence"
+
+#Views
+const V_ALL_ARTICLES_TABLE* = "v_all_articles"

src/applicationSettings.nim

@@ -0,0 +1,65 @@
+import prologue
+import json
+import ../../utils/errorResponses
+import myJwt
+import ../../utils/database
+import authenticationRepository
+import authenticationModels
+import ../../applicationSettings
+import jwt
+import nimSHA2
+
+#proc createToken*(ctx: Context) {.async.} =
+
+proc getRefreshToken(ctx: Context): Option[JWT] =
+    let requestBody: string = ctx.request.body()
+    let parsedRequestBody: JsonNode = parseJson(requestBody)
+    let refreshTokenString: string = parsedRequestBody.fields["refresh"].getStr()
+
+    result = parseJWT(refreshTokenString)
+
+
+proc createNextToken(user: User, tokenType: JWTType): JWT =
+    var newToken: JWT = user.createToken(JWTType.REFRESH)
+    newToken.sign(applicationSettings.SECRET_KEY)
+    result = newToken
+
+
+proc refreshTokens*(ctx: Context) {.async.} =
+    let refreshTokenOption: Option[JWT] = getRefreshToken(ctx)
+    if refreshTokenOption.isNone():
+        resp get401UnauthorizedResponse(ctx)
+        return
+
+    let refreshToken: JWT = refreshTokenOption.get()
+    if not myJwt.isValidRefreshToken(refreshToken):
+        resp get401UnauthorizedResponse(ctx)
+        return
+
+    let tokenData: TokenData = extractTokenData(refreshToken)
+    let user: User = getUserById(tokenData.userId)
+    
+    let newAccessToken: JWT = createNextToken(user, JWTType.ACCESS)
+    let newRefreshToken: JWT = createNextToken(user, JWTType.REFRESH)
+
+    resp jsonResponse(%*{"refresh": newRefreshToken, "access": newAccessToken})
+
+
+proc hasMatchingPassword(user: User, password: string): bool=
+    let hashedPassword = computeSHA256(password, 18000).toHex()
+    return true
+
+
+proc login*(ctx: Context) {.async.} =
+    let requestBody: JsonNode = parseJson(ctx.request.body())
+    let userName: string = requestBody.fields["username"].getStr()
+    let user: User = getUserByName(userName)
+
+    let plainPassword: string = requestBody.fields["password"].getStr()
+    if not user.hasMatchingPassword(plainPassword):
+        resp get401UnauthorizedResponse(ctx)
+    
+    let newAccessToken: JWT = createNextToken(user, JWTType.ACCESS)
+    let newRefreshToken: JWT = createNextToken(user, JWTType.REFRESH)
+
+    resp jsonResponse(%*{"refresh": newRefreshToken, "access": newAccessToken})

src/applications/authentication/authenticationControllers.nim

@@ -0,0 +1,106 @@
+import norm/[model, pragmas]
+import ../../utils/djangoDateTime/djangoDateTimeType
+import ../../applicationSettings
+import std/options
+
+
+type User* {.tableName: USER_TABLE.} = ref object of Model
+    ##[TableModel of the table of creatures ]##
+    password*: string
+    last_login*: Option[DjangoDateTime]
+    is_superuser*: bool
+    username*: string
+    last_name*: string
+    email*: string
+    is_staff*: bool
+    is_active*: bool
+    date_joined*: DjangoDateTime
+    first_name*: string
+
+
+type Group* {.tableName: GROUP_TABLE.} = ref object of Model
+    name*: string
+
+
+type Permission* {.tableName: PERMISSION_TABLE.} = ref object of Model
+    content_type_id*: int64
+    codename*: string
+    name*: string
+
+
+type GroupPermission* {.tableName: GROUP_PERMISSION_TABLE.} = ref object of Model
+    group_id*: int64
+    permission_id*: int64
+
+
+type UserGroup* {.tableName: USER_GROUP_TABLE.} = ref object of Model
+    user_id*: int64
+    group_id*: int64
+
+
+type UserPermission* {.tableName: USER_USERPERMISSIONS_TABLE.} = ref object of Model
+    user_id*: int64
+    permission_id*: int64
+
+
+proc newUser(
+    password = "",
+    lastLogin = none(DjangoDateTime),
+    isSuperuser = false,
+    username = "",
+    firstName = "",
+    lastName = "",
+    email = "",
+    isStaff = false,
+    isActive = true,
+    dateJoined = djangoDateTimeType.now()
+): User = 
+    result = User(
+        password: password,
+        last_login: lastLogin,
+        is_superuser: isSuperuser,
+        username: username,
+        last_name: lastName,
+        email: email,
+        is_staff: isStaff,
+        is_active: isActive,
+        date_joined: dateJoined,
+        first_name: firstName
+    )
+
+
+proc newPermission(
+    contentTypeId = -1,
+    codename = "",
+    name = ""
+): Permission =
+    result = Permission(
+        content_type_id: contentTypeId,
+        codename: codename,
+        name: name
+    )
+
+
+proc newGroup(name = ""): Group =
+    result = Group(name: name)
+
+
+proc newGroupPermission(groupId = -1, permissionId = -1): GroupPermission =
+    result = GroupPermission(group_id: groupId, permission_id: permissionId)
+
+
+proc newUserGroup(userId = -1, groupId = -1): UserGroup =
+    result = UserGroup(user_id: userId, group_id: groupId)
+
+
+proc newUserPermission(userId = -1, permissionId = -1): UserPermission =
+    result = UserPermission(user_id: userId, permission_id: permissionId)
+
+proc newTableModel*(T: typedesc[User]): User = newUser()
+
+proc newModel*(T: typedesc[GroupPermission]): GroupPermission = newGroupPermission()
+proc newModel*(T: typedesc[UserPermission]): UserPermission = newUserPermission()
+proc newModel*(T: typedesc[User]): User = newUser()
+proc newModel*(T: typedesc[Group]): Group = newGroup()
+proc newModel*(T: typedesc[Permission]): Permission = newPermission()
+proc newModel*(T: typedesc[UserGroup]): UserGroup = newUserGroup()

src/applications/authentication/authenticationModels.nim

@@ -0,0 +1,10 @@
+import ../base_generics/genericArticleRepository
+import authenticationModels
+
+
+proc getUserById*(userId: int64): User =
+    result = getEntryById[User](userId)
+
+
+proc getUserByName*(userName: string): User =
+    result = getEntryByField[User, string]("username", userName)

src/applications/authentication/authenticationRepository.nim

@@ -0,0 +1,9 @@
+import prologue
+import authenticationControllers
+
+proc addAuthenticationRoutes*(app: Prologue) =
+    app.addRoute(
+        re"/token/refresh", 
+        authenticationControllers.refreshTokens, 
+        httpMethod = HttpPost,
+    )