Initial commit

src/organisation/config.py

@@ -0,0 +1,7 @@
+"""
+Configurations for organisation module
+
+Configurations:
+ - List: Description
+ - Configs: Description
+"""

src/organisation/constants.py

@@ -0,0 +1,44 @@
+"""
+Constants and error codes for organisation module
+
+Classes:
+ - Status(StrEnum): PARTIAL, SUBMITTED, REMEDIATION, APPROVED, REJECTED, REMOVED
+ - ContactType(StrEnum): BILLING, SECURITY, OWNER
+"""
+from enum import StrEnum, auto
+
+
+class Status(StrEnum):
+	"""
+	Enumeration of organisation statuses.
+
+	Attributes:
+		PARTIAL(str): Organisation has been created but questionnaire hasn't been submitted.
+		SUBMITTED (str): Questionnaire submitted but not approved.
+		REMEDIATION (str): Questionnaire submitted but requires revisions.
+		APPROVED (str): Questionnaire has been approved by an admin.
+		REJECTED (str): Questionnaire has been rejected by an admin.
+		REMOVED (str): Organisation has been removed.
+	"""
+
+	PARTIAL = auto()
+	SUBMITTED = auto()
+	REMEDIATION = auto()
+	APPROVED = auto()
+	REJECTED = auto()
+	REMOVED = auto()
+
+
+class ContactType(StrEnum):
+	"""
+	Enumeration of organisation contact types.
+
+	Attributes:
+		BILLING(str): Billing contact.
+		SECURITY (str): Security contact.
+		OWNER (str): Owner contact.
+	"""
+
+	BILLING = auto()
+	SECURITY = auto()
+	OWNER = auto()

src/organisation/dependencies.py

@@ -0,0 +1,11 @@
+"""
+Router dependencies for organisation module
+
+Classes:
+ - List: Description
+ - Classes: Description
+
+Functions:
+ - List: Description
+ - Functions: Description
+"""

src/organisation/exceptions.py

@@ -0,0 +1,7 @@
+"""
+Module specific exceptions for organisation module
+
+Exceptions:
+ - List: Description
+ - Exceptions: Description
+"""

src/organisation/models.py

@@ -0,0 +1,34 @@
+"""
+Database models for organisation module
+
+Models:
+ - Organisation: id[pk], name, status, intake_questionnaire,
+                billing_contact_id[fk], security_contact_id[fk], owner_contact_id[fk]
+ - OrgUsers: org_id[fk][cpk], user_id[fk][cpk], is_admin
+"""
+from sqlalchemy import Column, Integer, String, Boolean, ForeignKey, JSON, false
+
+from src.database import Base
+from src.contact.models import Contact
+from src.user.models import User
+
+
+class Organisation(Base):
+	__tablename__ = "organisation"
+
+	id = Column(Integer, primary_key=True)
+	name = Column(String)
+	status = Column(String, default="partial")
+	intake_questionnaire = Column(JSON)
+
+	billing_contact_id = Column(Integer, ForeignKey("contact.id"))
+	security_contact_id = Column(Integer, ForeignKey("contact.id"))
+	owner_contact_id = Column(Integer, ForeignKey("contact.id"))
+
+
+class OrgUsers(Base):
+	__tablename__ = "orgusers"
+
+	org_id = Column(Integer, ForeignKey("organisation.id", ondelete="CASCADE"), primary_key=True)
+	user_id = Column(Integer, ForeignKey("user.id", ondelete="CASCADE"), primary_key=True)
+	is_admin = Column(Boolean, nullable=False, server_default=false())

src/organisation/router.py

@@ -0,0 +1,194 @@
+"""
+Router endpoints for organisation module
+
+Endpoints:
+ - [get]/id/{org_id} - Retrieves an organisation by its ID
+ - [post]/ - Creates a new organisation
+ - [patch]/{org_id}/questionnaire - Updates the questionnaire data for an organisation (can be partial or final submission)
+ - [patch]/{org_id}/status - Updates the status of an organisation
+ - [patch]/{org_id}/contact - Assigns a contact to an organisation (as billing, security, or owner)
+ - [get]/{org_id}/users - Retrieves all users associated with an organisation
+ - [get]/{org_id}/users/admins - Retrieves only the admin users of an organisation
+ - [post]/{org_id}/users - Adds a new user to an organisation
+ - [patch]/{org_id}/users - Updates details of an existing organisation user (e.g., admin status)
+ - [delete]/{org_id} - Deletes an organisation by ID
+ - [get]/{org_id}/contact/{contact_type} - Retrieves the contact of a specific type (owner, billing, security) for an organisation
+"""
+from fastapi import APIRouter, HTTPException
+from fastapi.params import Path
+
+from sqlalchemy.sql import exists
+
+from src.auth.service import super_admin_dependency
+from src.database import db_dependency
+from src.contact.models import Contact
+
+from src.organisation.constants import ContactType
+from src.organisation.models import Organisation as Org, OrgUsers
+from src.organisation.schemas import OrgOrgPostRequest, OrgQuestionnairePatchRequest, OrgStatusPatchRequest, \
+	OrgContactPatchRequest, \
+	OrgUserPostRequest, OrgUserGetResponse, OrgContactGetResponse, OrgOrgGetResponse
+
+router = APIRouter(
+	prefix="/org",
+	tags=["org"],
+)
+
+
+@router.get("/id/{org_id}", response_model=OrgOrgGetResponse)
+async def get_org_by_id(db: db_dependency, org_id: int = Path(gt=0)):
+	org_model = (db.query(Org).filter(Org.id == org_id).first())
+	if org_model is None:
+		raise HTTPException(status_code=404, detail="Organisation not found")
+
+	response = {
+		"name": org_model.name,
+		"status": org_model.status,
+		"owner_contact": (db.query(Contact).filter(Contact.id == org_model.owner_contact_id).first()),
+		"billing_contact": (db.query(Contact).filter(Contact.id == org_model.billing_contact_id).first()),
+		"security_contact": (db.query(Contact).filter(Contact.id == org_model.security_contact_id).first()),
+	}
+
+	return response
+
+
+@router.post("/")
+async def create_org(db: db_dependency, org_request: OrgOrgPostRequest):
+	org_model = Org(**org_request.model_dump())
+
+	org_model.status = "partial"  # Status is always set to partial at first, see update_questionnaire() doc
+
+	db.add(org_model)
+	db.commit()
+
+
+@router.patch("/{org_id}/questionnaire")
+async def update_questionnaire(db: db_dependency, q_request: OrgQuestionnairePatchRequest, org_id: int = Path(gt=0)):
+	"""
+	Route for updating questionnaire.
+	The partial bool allows for submission of partially completed questionnaire and/or
+	final "are you sure" check before setting the org to be in "submitted" status, awaiting admin approval.
+	"""
+	org_model = db.query(Org).filter(Org.id == org_id).first()
+	if org_model is None:
+		raise HTTPException(status_code=404, detail="Organisation not found")
+
+	org_model.intake_questionnaire = q_request.intake_questionnaire
+
+	# Allows for partially completed questionnaires to be saved without being submitted for review
+	if not q_request.partial:
+		org_model.status = "submitted"
+
+	db.add(org_model)
+	db.commit()
+
+
+@router.patch("/{org_id}/status")
+async def update_status(db: db_dependency, status_request: OrgStatusPatchRequest, org_id: int = Path(gt=0)):
+	org_model = db.query(Org).filter(Org.id == org_id).first()
+	if org_model is None:
+		raise HTTPException(status_code=404, detail="Organisation not found")
+
+	org_model.status = status_request.status
+
+	db.add(org_model)
+	db.commit()
+
+
+@router.patch("/{org_id}/contact")
+async def update_contact(db: db_dependency, contact_request: OrgContactPatchRequest, org_id: int = Path(gt=0)):
+	org_model = db.query(Org).filter(Org.id == org_id).first()
+	if org_model is None:
+		raise HTTPException(status_code=404, detail="Organisation not found")
+
+	match contact_request.contact_type:
+		case "billing":
+			org_model.billing_contact_id = contact_request.contact_id
+		case "security":
+			org_model.security_contact_id = contact_request.contact_id
+		case "owner":
+			org_model.owner_contact_id = contact_request.contact_id
+		case _:
+			raise HTTPException(status_code=422, detail="Invalid contact type")
+
+	db.add(org_model)
+	db.commit()
+
+
+@router.get("/{org_id}/users", response_model=list[OrgUserGetResponse])
+async def get_users(db: db_dependency, org_id: int = Path(gt=0)):
+	org_exists = db.query(exists().where(Org.id == org_id)).scalar()
+	if not org_exists:
+		raise HTTPException(status_code=404, detail="Organisation not found")
+
+	org_user_models = db.query(OrgUsers).filter(OrgUsers.org_id == org_id).all()
+
+	return org_user_models
+
+
+@router.get("/{org_id}/users/admins", response_model=list[OrgUserGetResponse])
+async def get_admin_users(db: db_dependency, org_id: int = Path(gt=0)):
+	org_exists = db.query(exists().where(Org.id == org_id)).scalar()
+	if not org_exists:
+		raise HTTPException(status_code=404, detail="Organisation not found")
+
+	org_user_models = db.query(OrgUsers).filter(OrgUsers.org_id == org_id).filter(OrgUsers.is_admin == True).all()
+
+	return org_user_models
+
+
+@router.post("/{org_id}/users")
+async def add_user_to_org(db: db_dependency, user_request: OrgUserPostRequest, org_id: int = Path(gt=0)):
+	org_user_model = OrgUsers(**user_request.model_dump(), org_id=org_id)
+
+	db.add(org_user_model)
+	db.commit()
+
+
+@router.patch("/{org_id}/users")
+async def update_user_details(db: db_dependency, user_request: OrgUserPostRequest, org_id: int = Path(gt=0)):
+	"""
+	Currently used only to update user admin status for organisation.
+	"""
+	# TODO: Check if org exists
+	org_user_model = db.query(OrgUsers).filter(OrgUsers.org_id == org_id).filter(OrgUsers.user_id == user_request.user_id).first()
+
+	if org_user_model is None:
+		raise HTTPException(status_code=404, detail="Organisation user not found")
+
+	if user_request.is_admin is not None:
+		org_user_model.is_admin = user_request.is_admin
+
+	db.add(org_user_model)
+	db.commit()
+
+
+@router.delete("/{org_id}")
+async def delete_organisation_by_id(db: db_dependency, org_id: int = Path(gt=0)):
+	org_model = (db.query(Org).filter(Org.id == org_id).first())
+	if org_model is None:
+		raise HTTPException(status_code=404, detail="Organisation not found")
+	db.delete(org_model)
+	db.commit()
+
+
+@router.get("/{org_id}/contact/{contact_type}", response_model=OrgContactGetResponse)
+async def get_contact(db: db_dependency, contact_type: ContactType, org_id: int = Path(gt=0)):
+	org_model = db.query(Org).filter(Org.id == org_id).first()
+	if org_model is None:
+		raise HTTPException(status_code=404, detail="Organisation not found")
+	match contact_type:
+		case "billing":
+			contact_id = org_model.billing_contact_id
+		case "security":
+			contact_id = org_model.security_contact_id
+		case "owner":
+			contact_id = org_model.owner_contact_id
+		case _:
+			raise HTTPException(status_code=422, detail="Invalid contact type")
+
+	contact_model = (db.query(Contact).filter(Contact.id == contact_id).first())
+	if contact_model is None:
+		raise HTTPException(status_code=404, detail="Contact not found")
+
+	return contact_model

src/organisation/schemas.py

@@ -0,0 +1,54 @@
+"""
+Pydantic models for organisation module
+
+Models:
+ - List: Description
+ - Models: Description
+"""
+from typing import Optional
+from pydantic import Json
+
+from src.schemas import CustomBaseModel
+from src.organisation.constants import Status, ContactType
+
+
+class OrgOrgPostRequest(CustomBaseModel):
+	name: str
+	intake_questionnaire: Optional[Json] = None
+
+	billing_contact_id: Optional[int] = None
+	security_contact_id: Optional[int] = None
+	owner_contact_id: Optional[int] = None
+
+class OrgQuestionnairePatchRequest(CustomBaseModel):
+	intake_questionnaire: Json
+	partial: bool
+
+class OrgStatusPatchRequest(CustomBaseModel):
+	status: Status
+
+class OrgContactPatchRequest(CustomBaseModel):
+	contact_id: int
+	contact_type: ContactType
+
+class OrgUserPostRequest(CustomBaseModel):
+	user_id: int
+	is_admin: Optional[bool] = False
+
+class OrgUserGetResponse(CustomBaseModel):
+	user_id: int
+	is_admin: bool
+
+class OrgContactGetResponse(CustomBaseModel):
+	email: str
+	first_name: str
+	last_name: str
+	phonenumber: str
+	vat_number: Optional[str] = None
+
+class OrgOrgGetResponse(CustomBaseModel):
+	name: str
+	status: Status
+	owner_contact: OrgContactGetResponse
+	billing_contact: OrgContactGetResponse
+	security_contact: OrgContactGetResponse

src/organisation/service.py

@@ -0,0 +1,11 @@
+"""
+Module specific business logic for organisation module
+
+Classes:
+ - List: Description
+ - Classes: Description
+
+Functions:
+ - List: Description
+ - Functions: Description
+"""

src/organisation/utils.py

@@ -0,0 +1,11 @@
+"""
+Non-business logic reusable functions and classes for organisation module
+
+Classes:
+ - List: Description
+ - Classes: Description
+
+Functions:
+ - List: Description
+ - Functions: Description
+"""