jknife 0.0.1__py2.py3-none-any.whl

jknife/db/models/mongo/personnel_info.py

@@ -0,0 +1,108 @@
+# import packages from default or pip library
+from datetime import date
+from typing_extensions import Annotated, Doc
+from mongoengine import Document, DateField, StringField, EmailField
+from fastapi.exceptions import RequestValidationError
+from pycountry import countries as pycountries
+
+# import packages from this framework
+
+
+# define Class for Common SQLModel
+class AddressMixin(Document):
+    meta = {'abstract': True}
+
+    address: Annotated[str,
+    Doc("Address.")] = StringField(null=False)
+
+
+class BirthdateMixin(Document):
+    meta = {'abstract': True}
+
+    birthdate: Annotated[date,
+    Doc("User's Birthdate.")] = DateField(null=False)
+
+
+class CPNumMixin(Document):
+    meta = {'abstract': True}
+
+    cp_num: Annotated[str,
+    Doc("cellphone number.")] = StringField(null=False)
+
+
+class EmailMixin(Document):
+    meta = {'abstract': True}
+
+    email: Annotated[str,
+    Doc("email address. this can replace username for signup and signin.")] = EmailField(null=False, unique=True)
+
+
+class FirstnameMixin(Document):
+    meta = {'abstract': True}
+
+    firstname: Annotated[str,
+    Doc("First name of application user.")] = StringField(null=False)
+
+
+class LastnameMixin(Document):
+    meta = {'abstract': True}
+
+    lastname: Annotated[str,
+    Doc("Last name of application user.")] = StringField(null=False)
+
+
+class NationMixin(Document):
+    meta = {'abstract': True}
+
+    nation: Annotated[str,
+    Doc("the nation that user came from.")] = StringField(null=False)
+
+
+class NicknameMixin(Document):
+    meta = {'abstract': True}
+
+    nickname: Annotated[str,
+    Doc("User's nickname that used in this application.")] = StringField(unique=True)
+
+
+class PostalCodeMixin(Document):
+    meta = {'abstract': True}
+
+    postal_code: Annotated[str,
+    Doc("postal number of address.")] = StringField(null=False)
+
+
+# define function to control MongoDB document event
+# please follow the procedure below
+# create event handler function with name starting with _.
+# event handler function must have 3 args: sender, document, **kwargs)
+# each db column can get from 'document'
+# import pre_init or pre_save from 'mongoengine.signals' in your model file.
+# pre_init.connect(EVNET_HANDLER_FUNC_NAME, sender=TABLE_CLASS_NAME)
+def _convert_country_to_alpha2(sender, document, **kwargs):
+    if document.nation and len(document.nation) != 2:
+        try:
+            document.nation = pycountries.get(name=document.nation).alpha_2
+        except AttributeError:
+            raise RequestValidationError(errors={"input": "nation", "msg": "please input official country name."})
+
+    return None
+
+def _convert_country_to_alpha3(sender, document, **kwargs):
+    if document.nation and len(document.nation) != 3:
+        try:
+            document.nation = pycountries.get(name=document.nation).alpha_3
+        except AttributeError:
+            raise RequestValidationError(errors={"input": "nation", "msg": "please input official country name."})
+
+    return None
+
+def _lower_firstname(sender, document, **kwargs) -> None:
+    if document.firstname:
+        document.firstname = document.firstname.lower()
+    return None
+
+def _lower_lastname(sender, document, **kwargs) -> None:
+    if document.lastname:
+        document.lastname = document.lastname.lower()
+    return None

jknife/db/models/mongo/settings.py

@@ -0,0 +1,58 @@
+# import packages from default or pip library
+from pycountry import languages as pylanguage
+from typing_extensions import Annotated, Doc
+from mongoengine import Document, BooleanField, IntField, StringField
+from fastapi.exceptions import RequestValidationError
+
+# import packages from this framework
+
+
+# define Class for Common SQLModel
+class AllowMaxAccessSettingMixin(Document):
+    meta = {'abstract': True}
+
+    allow_max_access: Annotated[int,
+    Doc("user setting for max access during trying sign in.")] = IntField(null=False, default=5, min_value=3, max_value=5)
+
+
+class LanguageSettingMixin(Document):
+    meta = {'abstract': True}
+
+    language: Annotated[str,
+    Doc("language setting for application user.")] = StringField(null=False)
+
+    _alpha_code_type: Annotated[str,
+    Doc("assign 'alpha_2' or 'alpha_3'. default is 'alpha_2'")] = "alpha_2"
+
+
+class DarkModeSettingMixin(Document):
+    meta = {'abstract': True}
+
+    is_dark_mode: Annotated[bool,
+    Doc("light or dark mode for application user.")] = BooleanField(null=False, default=False)
+
+
+# define function to control MongoDB document event
+# please follow the procedure below
+# create event handler function with name starting with _.
+# event handler function must have 3 args: sender, document, **kwargs)
+# each db column can get from 'document'
+# import pre_init or pre_save from 'mongoengine.signals' in your model file.
+# pre_init.connect(EVNET_HANDLER_FUNC_NAME, sender=TABLE_CLASS_NAME)
+def _convert_language_to_alpha2(sender, document, **kwargs):
+    if document.language and len(document.language) != 2:
+        try:
+            document.language = pylanguage.get(name=document.language).alpha_2
+        except AttributeError:
+            raise RequestValidationError(errors={"input": "nation", "msg": "please input official country name."})
+
+    return None
+
+def _convert_language_to_alpha3(sender, document, **kwargs):
+    if document.language and len(document.language) != 3:
+        try:
+            document.language = pylanguage.get(name=document.language).alpha_3
+        except AttributeError:
+            raise RequestValidationError(errors={"input": "nation", "msg": "please input official country name."})
+
+    return None

jknife/db/models/mongo/token.py

@@ -0,0 +1,62 @@
+# import packages from default or pip library
+from datetime import datetime, timedelta, timezone
+from typing_extensions import Annotated, Doc
+from mongoengine import Document, DateTimeField, StringField, pre_init
+
+# import packages from this framework
+from settings import AUTHENTICATION
+
+# settings
+TOKEN_VALID_TIME: int = AUTHENTICATION.get("token").get("token_valid_time")
+
+
+# define classes
+class AccessTokenMixin(Document):
+    meta = {'abstract': True}
+
+    access_token: Annotated[str,
+    Doc("This is a access token that will be stored in DB or somewhere")] = StringField(primary_key=True,
+                                                                                        null=False,
+                                                                                        unique=True)
+
+
+class TokenValidDateTime(Document):
+    meta = {'abstract': True}
+
+    issued_dt: Annotated[datetime,
+    Doc("datetime when the token issued.")] = DateTimeField(null=False)
+    expiration_dt: Annotated[datetime,
+    Doc("datetime when the token will be expired.")] = DateTimeField(null=False)
+
+
+class RefreshTokenMixin(Document):
+    meta = {'abstract': True}
+
+    refresh_token: Annotated[str,
+    Doc("This is a refresh token that will be used for issuing access token again.")] = StringField(null=False,
+                                                                                                    unique=True)
+
+
+class JWTTokens(RefreshTokenMixin, AccessTokenMixin):
+    meta = {'abstract': True}
+
+    token_type: Annotated[str,
+    Doc("Token type that used in this class.")] = StringField(null=False,
+                                                              default="Bearer")
+
+
+# define function to control MongoDB document event
+# please follow the procedure below
+# create event handler function with name starting with _.
+# event handler function must have 3 args: sender, document, **kwargs)
+# each db column can get from 'document'
+# import pre_init or pre_save from 'mongoengine.signals' in your model file.
+# pre_init.connect(EVNET_HANDLER_FUNC_NAME, sender=TABLE_CLASS_NAME)
+def _fill_token_datetime_field(sender, document, **kwargs) -> None:
+    if document.issued_dt is None:
+        document.issued_dt = datetime.now(tz=timezone.utc)
+
+    if document.expiration_dt is None:
+        document.expiration_dt = document.issued_dt + timedelta(minutes=TOKEN_VALID_TIME)
+
+    return None

jknife/db/models/mongo/users.py

@@ -0,0 +1,91 @@
+# import packages from default or pip library
+from datetime import datetime, timezone
+from typing_extensions import Annotated, Doc
+from mongoengine import Document, BooleanField, DateTimeField, IntField, StringField
+
+# import packages from this framework
+from src.jknife.db.models.rdbms.users import encrypt_password
+
+
+# define Class for Common SQLModel
+class LastSigninDateTimeMixin(Document):
+    meta = {'abstract': True}
+
+    last_signin_dt: Annotated[datetime,
+    Doc("User's last signin datetime.")] = DateTimeField(null=True, default=None)
+
+    def update_signin_dt(self) -> None:
+        self.last_signin_dt = datetime.now(tz=timezone.utc)
+        return None
+
+
+class SigninFailMixin(Document):
+    meta = {'abstract': True}
+
+    is_active: Annotated[bool,
+    Doc("show whether the user is activated or not.")] = BooleanField(null=False, default=False)
+    signin_fail: Annotated[int,
+    Doc("If the user fail to login, this value will be incremented.")] = IntField(null=False, default=0, ge=0, le=5)
+
+    def init_signin_fail_count(self) -> None:
+        self.signin_fail = 0
+        return None
+
+    def activate_user(self) -> None:
+        self.is_active = True
+        self.init_signin_fail_count()
+        return None
+
+    def deactivate_user(self) -> None:
+        self.is_active = False
+        return None
+
+    def add_signin_fail_count(self, limit: int) -> None:
+        if self.signin_fail < limit:
+            self.signin_fail += 1
+
+            if self.signin_fail == limit:
+                self.deactivate_user()
+
+        return None
+
+
+class IsAdminMixin(Document):
+    meta = {'abstract': True}
+
+    is_admin: Annotated[bool,
+    Doc("show whether the user is admin or not.")] = BooleanField(null=False, default=False)
+
+    def grant_admin(self) -> None:
+        self.is_admin = True
+        return None
+
+    def revoke_admin(self) -> None:
+        self.is_admin = False
+        return None
+
+
+class PasswordMixin(Document):
+    meta = {'abstract': True}
+
+    password: Annotated[str,
+    Doc("password for application user. it is recommended to store password after encrypting.")] = StringField(null=False, unique=False, min_length=32)
+
+    def encrypt_password(self, enc_type:str="sha256"):
+        self.password = encrypt_password(password=self.password, enc_type=enc_type)
+
+
+class UsernameMixin(Document):
+    meta = {'abstract': True}
+
+    username: Annotated[str,
+    Doc("username for application user. if you want to replace it to email, refer to 'contact' module.")] = StringField(null=False)
+
+
+# define function to control MongoDB document event
+# please follow the procedure below
+# create event handler function with name starting with _.
+# event handler function must have 3 args: sender, document, **kwargs)
+# each db column can get from 'document'
+# import pre_init or pre_save from 'mongoengine.signals' in your model file.
+# pre_init.connect(EVNET_HANDLER_FUNC_NAME, sender=TABLE_CLASS_NAME)

jknife/db/models/rdbms/__init__.py

@@ -0,0 +1,53 @@
+# import packages from default or pip library
+from datetime import datetime, timezone
+from typing_extensions import (Annotated,
+                               Doc,
+                               Optional)
+from uuid import UUID, uuid4
+from sqlmodel import (SQLModel,
+                      Field)
+
+# import packages from this framework
+
+
+# define Class for Common SQLModel
+class IdMixin(SQLModel):
+    id: Annotated[int,
+    Doc("Default integer id for each table row.")] = Field(primary_key=True, default=None)
+
+
+class UUIDMixin(SQLModel):
+    id: Annotated[UUID,
+    Doc("UUID format id for each table row.")] = Field(primary_key=True, default=None)
+
+
+class RegisterDateTimeMixin(SQLModel):
+    register_dt: Annotated[datetime,
+    Doc("Datetime that the row was added at.")] = Field(nullable=False, default=None)
+
+
+class UpdateDateTimeMixin(SQLModel):
+    update_dt: Annotated[Optional[datetime],
+    Doc("Datetime that the row was updated at.")] = Field(nullable=True, default=None)
+
+
+# define function to control SQL event
+# please follow the procedure below
+# use decorator 'event.listens_for()' for event handling function
+# event handler function must have 3 args: mapper, connection and target)
+# in your model file, import listens_for from 'sqlalchemy.event'
+# event.listens_for(target=TARGET_TABLE_CLASS_NAME, identifier=['before_insert', 'before_update',...])
+def _assign_register_datetime(mapper, connection, target) -> None:
+    if target.register_dt is None:
+        target.register_dt = datetime.now(tz=timezone.utc)
+    return None
+
+def _assign_update_datetime(mapper, connection, target) -> None:
+    if target.update_dt is not None:
+        target.update_dt = datetime.now(tz=timezone.utc)
+    return None
+
+def _assign_uuid(mapper, connection, target) -> None:
+    if target.id is None:
+        target.id = uuid4()
+    return None

jknife/db/models/rdbms/network.py

@@ -0,0 +1,24 @@
+# import packages from default or pip library
+from typing_extensions import Annotated, Doc
+from sqlmodel import SQLModel, Field
+
+# import packages from this framework
+
+
+# define Class for Common SQLModel
+class AllowIPsMixin(SQLModel):
+    allow_ips: Annotated[list[str],
+    Doc("Set IPv4 or IPv6 addresses or networks to allow user to access")] = Field(nullable=False,
+                                                                                   default=["127.0.0.1"])
+
+
+# define function to control SQL event
+# please follow the procedure below
+# use decorator 'event.listens_for()' for event handling function
+# event handler function must have 3 args: mapper, connection and target)
+# in your model file, import listens_for from 'sqlalchemy.event'
+# event.listens_for(target=TARGET_TABLE_CLASS_NAME, identifier=['before_insert', 'before_update',...])
+def _convert_ips_to_str(mapper, connection, target) -> None:
+    if target.allow_ips is not None:
+        target.allow_ips = [ str(ip) for ip in target.allow_ips ]
+    return None

jknife/db/models/rdbms/personnel_info.py

@@ -0,0 +1,88 @@
+# import packages from default or pip library
+from datetime import date
+from typing_extensions import Annotated, Doc
+from sqlmodel import SQLModel, Field
+from fastapi.exceptions import RequestValidationError
+from pycountry import countries as pycountries
+
+# import packages from this framework
+
+
+# define Class for Common SQLModel
+class AddressMixin(SQLModel):
+    address: Annotated[str,
+    Doc("Address.")] = Field(nullable=False)
+
+
+class BirthdateMixin(SQLModel):
+    birthdate: Annotated[date,
+    Doc("User's Birthdate.")] = Field(nullable=False)
+
+
+class CPNumMixin(SQLModel):
+    cp_num: Annotated[str,
+    Doc("cellphone number.")] = Field(nullable=False)
+
+
+class EmailMixin(SQLModel):
+    email: Annotated[str,
+    Doc("email address. this can replace username for signup and signin.")] = Field(nullable=False, unique=True)
+
+
+class FirstnameMixin(SQLModel):
+    firstname: Annotated[str,
+    Doc("First name of application user.")] = Field(nullable=False, index=True)
+
+
+class LastnameMixin(SQLModel):
+    lastname: Annotated[str,
+    Doc("Last name of application user.")] = Field(nullable=False, index=True)
+
+
+class NationMixin(SQLModel):
+    nation: Annotated[str,
+    Doc("the nation that user came from.")] = Field(nullable=False)
+
+
+class NicknameMixin(SQLModel):
+    nickname: Annotated[str,
+    Doc("User's nickname that used in this application.")] = Field(unique=True, index=True)
+
+
+class PostalCodeMixin(SQLModel):
+    postal_code: Annotated[str,
+    Doc("postal number of address.")] = Field(nullable=False)
+
+
+# define function to control SQL event
+# please follow the procedure below
+# use decorator 'event.listens_for()' for event handling function
+# event handler function must have 3 args: mapper, connection and target)
+# in your model file, import listens_for from 'sqlalchemy.event'
+# event.listens_for(target=TARGET_TABLE_CLASS_NAME, identifier=['before_insert', 'before_update',...])
+def _convert_country_to_alpha2(mapper, connection, target):
+    if target.nation is not None and len(target.nation) != 2:
+        try:
+            target.nation = pycountries.get(name=target.nation).alpha_2
+        except AttributeError:
+            raise RequestValidationError(errors={"input": "nation", "msg": "please input official country name."})
+    return None
+
+def _convert_country_to_alpha3(mapper, connection, target):
+    if target.nation is not None and len(target.nation) != 3:
+        try:
+            target.nation = pycountries.get(name=target.nation).alpha_3
+        except AttributeError:
+            raise RequestValidationError(errors={"input": "nation", "msg": "please input official country name."})
+    return None
+
+def _lower_firstname(mapper, connection, target) -> None:
+    if target.firstname is not None:
+        target.firstname = target.firstname.lower()
+    return None
+
+def _lower_lastname(mapper, connection, target) -> None:
+    if target.lastname is not None:
+        target.lastname = target.lastname.lower()
+    return None
+

jknife/db/models/rdbms/settings.py

@@ -0,0 +1,39 @@
+# import packages from default or pip library
+from pycountry import languages as pylanguage
+from typing_extensions import Annotated, Doc
+from sqlmodel import SQLModel, Field
+
+# import packages from this framework
+
+
+# define Class for Common SQLModel
+class AllowMaxAccessSettingMixin(SQLModel):
+    allow_max_access: Annotated[int,
+    Doc("user setting for max access during trying sign in.")] = Field(nullable=False, default=5, ge=3, le=5)
+
+
+class LanguageSettingMixin(SQLModel):
+    language: Annotated[str,
+    Doc("language setting for application user.")] = Field(nullable=False)
+
+
+class DarkModeSettingMixin(SQLModel):
+    is_dark_mode: Annotated[bool,
+    Doc("light or dark mode for application user.")] = Field(nullable=False, default=False)
+
+
+# define function to control SQL event
+# please follow the procedure below
+# use decorator 'event.listens_for()' for event handling function
+# event handler function must have 3 args: mapper, connection and target)
+# in your model file, import listens_for from 'sqlalchemy.event'
+# event.listens_for(target=TARGET_TABLE_CLASS_NAME, identifier=['before_insert', 'before_update',...])
+def _convert_language_to_alpha2(mapper, connection, target) -> None:
+    if target.language is not None:
+        target.language = pylanguage.get(name=target.language).alpha_2
+    return None
+
+def _convert_language_to_alpha3(mapper, connection, target) -> None:
+    if target.language is not None:
+        target.language = pylanguage.get(name=target.language).alpha_3
+    return None

jknife/db/models/rdbms/token.py

@@ -0,0 +1,53 @@
+# import packages from default or pip library
+from datetime import datetime, timedelta, timezone
+from typing_extensions import Annotated, Doc
+from sqlmodel import SQLModel, Field
+
+# import packages from this framework
+from settings import AUTHENTICATION
+
+# settings
+TOKEN_VALID_TIME: int = AUTHENTICATION.get("token").get("token_valid_time")
+
+
+# define classes
+class AccessTokenMixin(SQLModel):
+    access_token: Annotated[str,
+    Doc("This is a access token that will be stored in DB or somewhere")] = Field(primary_key=True,
+                                                                                  nullable=False,
+                                                                                  unique=True)
+
+
+class RefreshTokenMixin(SQLModel):
+    refresh_token: Annotated[str,
+    Doc("This is a refresh token that will be used for issuing access token again.")] = Field(nullable=False,
+                                                                                              unique=True)
+
+
+class TokenValidDateTimeMixin(SQLModel):
+    issued_dt: Annotated[datetime,
+    Doc("datetime when the token issued.")] = Field(nullable=False)
+    expiration_dt: Annotated[datetime,
+    Doc("datetime when the token will be expired.")] = Field(nullable=False)
+
+
+class JWTTokens(RefreshTokenMixin, AccessTokenMixin):
+    token_type: Annotated[str,
+    Doc("Token type that used in this class.")] = Field(nullable=False,
+                                                        default="Bearer")
+
+
+# define function to control SQL event
+# please follow the procedure below
+# use decorator 'event.listens_for()' for event handling function
+# event handler function must have 3 args: mapper, connection and target)
+# in your model file, import listens_for from 'sqlalchemy.event'
+# event.listens_for(target=TARGET_TABLE_CLASS_NAME, identifier=['before_insert', 'before_update',...])
+def _fill_token_datetime_field(mapper, connection, target) -> None:
+    if target.issued_dt is None:
+        target.issued_dt = datetime.now(tz=timezone.utc)
+
+    if target.expired is None:
+        target.expired_dt = target.issued_dt + timedelta(minutes=TOKEN_VALID_TIME)
+
+    return None

jknife/db/models/rdbms/users.py

@@ -0,0 +1,94 @@
+# import packages from default or pip library
+import hashlib
+from datetime import datetime, timezone
+from typing_extensions import Annotated, Doc
+from sqlmodel import SQLModel, Field
+
+# import packages from this framework
+from settings import PASSWORD_POLICIES
+
+
+# password encryption algorithm
+ENCRYPT_TYPE: str = PASSWORD_POLICIES.get("encrypt_type")
+
+
+# define Class for Common SQLModel
+class LastSigninDateTimeMixin(SQLModel):
+    last_signin_dt: Annotated[datetime,
+    Doc("User's last signin datetime.")] = Field(nullable=True, default=None)
+
+    def update_signin_dt(self) -> None:
+        self.last_signin_dt = datetime.now(tz=timezone.utc)
+        return None
+
+
+class SigninFailMixin(SQLModel):
+    is_active: Annotated[bool,
+    Doc("show whether the user is activated or not.")] = Field(nullable=False, default=False)
+    signin_fail: Annotated[int,
+    Doc("If the user fail to login, this value will be incremented.")] = Field(nullable=False, default=0, ge=0, le=5)
+
+    def activate_user(self) -> None:
+        self.is_active = True
+        self.__init_signin_fail_count()
+        return None
+
+    def deactivate_user(self) -> None:
+        self.is_active = False
+        return None
+
+    def add_signin_fail_count(self, limit: int) -> None:
+        if self.signin_fail < limit:
+            self.signin_fail += 1
+
+            if self.signin_fail == limit:
+                self.deactivate_user()
+
+        return None
+
+    def __init_signin_fail_count(self) -> None:
+        self.signin_fail = 0
+        return None
+
+
+class IsAdminMixin(SQLModel):
+    is_admin: Annotated[bool,
+    Doc("show whether the user is admin or not.")] = Field(nullable=False, default=False)
+
+    def grant_admin(self) -> None:
+        self.is_admin = True
+        return None
+
+    def revoke_admin(self) -> None:
+        self.is_admin = False
+        return None
+
+
+class PasswordMixin(SQLModel):
+    password: Annotated[str,
+    Doc("password for application user. it is recommended to store password after encrypting.")] = Field(nullable=False, unique=False, min_length=32)
+
+    def encrypt_password(self, enc_type:str=ENCRYPT_TYPE):
+        self.password = encrypt_password(password=self.password, enc_type=enc_type)
+
+
+class UsernameMixin(SQLModel):
+    username: Annotated[str,
+    Doc("username for application user. if you want to replace it to email, refer to 'contact' module.")] = Field(nullable=False, unique=True, min_length=8)
+
+
+# define function for users
+def encrypt_password(password:str, enc_type:str=ENCRYPT_TYPE) -> str:
+    if enc_type not in hashlib.algorithms_available:
+        raise ValueError(f"'{enc_type}' is not supported hash method in this application. Password will be encrypted with default hash.")
+
+    return getattr(hashlib, enc_type)(string=password.encode("utf-8")).hexdigest()
+
+
+# define function to control SQL event
+# please follow the procedure below
+# use decorator 'event.listens_for()' for event handling function
+# event handler function must have 3 args: mapper, connection and target)
+# in your model file, import listens_for from 'sqlalchemy.event'
+# event.listens_for(target=TARGET_TABLE_CLASS_NAME, identifier=['before_insert', 'before_update',...])
+