jens/TimeTrack
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Squashed commit of the following:

Browse Source 
commit 1eeea9f83ad9230a5c1f7a75662770eaab0df837
Author: Jens Luedicke <jens@luedicke.me>
Date:   Mon Jul 7 21:15:41 2025 +0200

    Disable resuming of old time entries.

commit 3e3ec2f01cb7943622b819a19179388078ae1315
Author: Jens Luedicke <jens@luedicke.me>
Date:   Mon Jul 7 20:59:19 2025 +0200

    Refactor db migrations.

commit 15a51a569da36c6b7c9e01ab17b6fdbdee6ad994
Author: Jens Luedicke <jens@luedicke.me>
Date:   Mon Jul 7 19:58:04 2025 +0200

    Apply new style for Time Tracking view.

commit 77e5278b303e060d2b03853b06277f8aa567ae68
Author: Jens Luedicke <jens@luedicke.me>
Date:   Mon Jul 7 18:06:04 2025 +0200

    Allow direct registrations as a Company.

commit 188a8772757cbef374243d3a5f29e4440ddecabe
Author: Jens Luedicke <jens@luedicke.me>
Date:   Mon Jul 7 18:04:45 2025 +0200

    Add email invitation feature.

commit d9ebaa02aa01b518960a20dccdd5a327d82f30c6
Author: Jens Luedicke <jens@luedicke.me>
Date:   Mon Jul 7 17:12:32 2025 +0200

    Apply common style for Company, User, Team management pages.

commit 81149caf4d8fc6317e2ab1b4f022b32fc5aa6d22
Author: Jens Luedicke <jens@luedicke.me>
Date:   Mon Jul 7 16:44:32 2025 +0200

    Move export functions to own module.

commit 1a26e19338e73f8849c671471dd15cc3c1b1fe82
Author: Jens Luedicke <jens@luedicke.me>
Date:   Mon Jul 7 15:51:15 2025 +0200

    Split up models.py.

commit 61f1ccd10f721b0ff4dc1eccf30c7a1ee13f204d
Author: Jens Luedicke <jens@luedicke.me>
Date:   Mon Jul 7 12:05:28 2025 +0200

    Move utility function into own modules.

commit 84b341ed35e2c5387819a8b9f9d41eca900ae79f
Author: Jens Luedicke <jens@luedicke.me>
Date:   Mon Jul 7 11:44:24 2025 +0200

    Refactor auth functions use.

commit 923e311e3da5b26d85845c2832b73b7b17c48adb
Author: Jens Luedicke <jens@luedicke.me>
Date:   Mon Jul 7 11:35:52 2025 +0200

    Refactor route nameing and fix bugs along the way.

commit f0a5c4419c340e62a2615c60b2a9de28204d2995
Author: Jens Luedicke <jens@luedicke.me>
Date:   Mon Jul 7 10:34:33 2025 +0200

    Fix URL endpoints in announcement template.

commit b74d74542a1c8dc350749e4788a9464d067a88b5
Author: Jens Luedicke <jens@luedicke.me>
Date:   Mon Jul 7 09:25:53 2025 +0200

    Move announcements to own module.

commit 9563a28021ac46c82c04fe4649b394dbf96f92c7
Author: Jens Luedicke <jens@luedicke.me>
Date:   Mon Jul 7 09:16:30 2025 +0200

    Combine Company view and edit templates.

commit 6687c373e681d54e4deab6b2582fed5cea9aadf6
Author: Jens Luedicke <jens@luedicke.me>
Date:   Mon Jul 7 08:17:42 2025 +0200

    Move Users, Company and System Administration to own modules.

commit 8b7894a2e3eb84bb059f546648b6b9536fea724e
Author: Jens Luedicke <jens@luedicke.me>
Date:   Mon Jul 7 07:40:57 2025 +0200

    Move Teams and Projects to own modules.

commit d11bf059d99839ecf1f5d7020b8c8c8a2454c00b
Author: Jens Luedicke <jens@luedicke.me>
Date:   Mon Jul 7 07:09:33 2025 +0200

    Move Tasks and Sprints to own modules.
This commit is contained in:
Jens Luedicke
2025-07-07 21:16:36 +02:00
parent 4214e88d18
commit 9a79778ad6
116 changed files with 21063 additions and 5653 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
utils/__init__.py Normal file
View File

@@ -0,0 +1 @@
# Utils package

18
utils/auth.py Normal file
View File

@@ -0,0 +1,18 @@
"""
Authentication utility functions
"""
from flask import g
from models import Role
def is_system_admin(user=None):
"""Helper function to check if user is system admin"""
if user is None:
user = g.user
return user and user.role == Role.SYSTEM_ADMIN
def can_access_system_settings(user=None):
"""Helper function to check if user can access system-wide settings"""
return is_system_admin(user)

197
utils/repository.py Normal file
View File

@@ -0,0 +1,197 @@
"""
Repository pattern for common database operations
"""
from flask import g
from models import db
class BaseRepository:
"""Base repository with common database operations"""
def __init__(self, model):
self.model = model
def get_by_id(self, id):
"""Get entity by ID"""
return self.model.query.get(id)
def get_by_company(self, company_id=None):
"""Get all entities for a company"""
if company_id is None and hasattr(g, 'user') and g.user:
company_id = g.user.company_id
if company_id is None:
return []
return self.model.query.filter_by(company_id=company_id).all()
def get_by_company_ordered(self, company_id=None, order_by=None):
"""Get all entities for a company with ordering"""
if company_id is None and hasattr(g, 'user') and g.user:
company_id = g.user.company_id
if company_id is None:
return []
query = self.model.query.filter_by(company_id=company_id)
if order_by is not None:
query = query.order_by(order_by)
return query.all()
def exists_by_name_in_company(self, name, company_id=None, exclude_id=None):
"""Check if entity with name exists in company"""
if company_id is None and hasattr(g, 'user') and g.user:
company_id = g.user.company_id
query = self.model.query.filter_by(name=name, company_id=company_id)
if exclude_id is not None:
query = query.filter(self.model.id != exclude_id)
return query.first() is not None
def create(self, **kwargs):
"""Create new entity"""
entity = self.model(**kwargs)
db.session.add(entity)
return entity
def update(self, entity, **kwargs):
"""Update entity with given attributes"""
for key, value in kwargs.items():
if hasattr(entity, key):
setattr(entity, key, value)
return entity
def delete(self, entity):
"""Delete entity"""
db.session.delete(entity)
def save(self):
"""Commit changes to database"""
db.session.commit()
def rollback(self):
"""Rollback database changes"""
db.session.rollback()
class CompanyScopedRepository(BaseRepository):
"""Repository for entities scoped to a company"""
def get_by_id_and_company(self, id, company_id=None):
"""Get entity by ID, ensuring it belongs to the company"""
if company_id is None and hasattr(g, 'user') and g.user:
company_id = g.user.company_id
if company_id is None:
return None
return self.model.query.filter_by(id=id, company_id=company_id).first()
def get_active_by_company(self, company_id=None):
"""Get active entities for a company"""
if company_id is None and hasattr(g, 'user') and g.user:
company_id = g.user.company_id
if company_id is None:
return []
# Assumes model has is_active field
if hasattr(self.model, 'is_active'):
return self.model.query.filter_by(
company_id=company_id,
is_active=True
).all()
return self.get_by_company(company_id)
def count_by_company(self, company_id=None):
"""Count entities for a company"""
if company_id is None and hasattr(g, 'user') and g.user:
company_id = g.user.company_id
if company_id is None:
return 0
return self.model.query.filter_by(company_id=company_id).count()
# Specific repositories for common entities
class UserRepository(CompanyScopedRepository):
"""Repository for User operations"""
def __init__(self):
from models import User
super().__init__(User)
def get_by_username_and_company(self, username, company_id):
"""Get user by username within a company"""
return self.model.query.filter_by(
username=username,
company_id=company_id
).first()
def get_by_email(self, email):
"""Get user by email (globally unique)"""
return self.model.query.filter_by(email=email).first()
class TeamRepository(CompanyScopedRepository):
"""Repository for Team operations"""
def __init__(self):
from models import Team
super().__init__(Team)
def get_with_member_count(self, company_id=None):
"""Get teams with member count"""
if company_id is None and hasattr(g, 'user') and g.user:
company_id = g.user.company_id
if company_id is None:
return []
# This would need a more complex query with joins
teams = self.get_by_company(company_id)
for team in teams:
team.member_count = len(team.users)
return teams
class ProjectRepository(CompanyScopedRepository):
"""Repository for Project operations"""
def __init__(self):
from models import Project
super().__init__(Project)
def get_by_code_and_company(self, code, company_id):
"""Get project by code within a company"""
return self.model.query.filter_by(
code=code,
company_id=company_id
).first()
def get_accessible_by_user(self, user):
"""Get projects accessible by a user"""
if not user:
return []
# Admin/Supervisor can see all company projects
if user.role.value in ['Administrator', 'Supervisor', 'System Administrator']:
return self.get_by_company(user.company_id)
# Team members see team projects + unassigned projects
from models import Project
return Project.query.filter(
Project.company_id == user.company_id,
db.or_(
Project.team_id == user.team_id,
Project.team_id.is_(None)
)
).all()

11
utils/settings.py Normal file
View File

@@ -0,0 +1,11 @@
"""
System settings utility functions
"""
from models import SystemSettings
def get_system_setting(key, default='false'):
"""Helper function to get system setting value"""
setting = SystemSettings.query.filter_by(key=key).first()
return setting.value if setting else default

151
utils/validation.py Normal file
View File

@@ -0,0 +1,151 @@
"""
Form validation utility functions
"""
from datetime import datetime
from flask import flash
class ValidationError:
"""Container for validation errors"""
def __init__(self):
self.errors = []
def add(self, message):
"""Add an error message"""
self.errors.append(message)
def has_errors(self):
"""Check if there are any errors"""
return len(self.errors) > 0
def get_first(self):
"""Get the first error message"""
return self.errors[0] if self.errors else None
def flash_first(self, category='error'):
"""Flash the first error message"""
if self.errors:
flash(self.errors[0], category)
def validate_required(value, field_name):
"""Validate that a field is not empty"""
if not value or (isinstance(value, str) and not value.strip()):
return f"{field_name} is required"
return None
def validate_unique(model, field_name, value, company_id=None, exclude_id=None):
"""Validate that a value is unique in the database
Args:
model: The SQLAlchemy model class
field_name: The field to check for uniqueness
value: The value to check
company_id: Optional company ID for company-scoped uniqueness
exclude_id: Optional ID to exclude (for updates)
Returns:
Error message if not unique, None otherwise
"""
query = model.query.filter_by(**{field_name: value})
if company_id is not None:
query = query.filter_by(company_id=company_id)
if exclude_id is not None:
query = query.filter(model.id != exclude_id)
if query.first():
return f"{field_name.replace('_', ' ').title()} already exists"
return None
def validate_date_range(start_date, end_date, start_name="Start date", end_name="End date"):
"""Validate that start date is before or equal to end date"""
if start_date and end_date and start_date > end_date:
return f"{start_name} cannot be after {end_name}"
return None
def parse_date(date_string, format='%Y-%m-%d'):
"""Parse a date string and return date object or None
Returns:
tuple: (date_object, error_message)
"""
if not date_string:
return None, None
try:
return datetime.strptime(date_string, format).date(), None
except ValueError:
return None, f"Invalid date format (expected {format})"
def parse_datetime(datetime_string, format='%Y-%m-%dT%H:%M'):
"""Parse a datetime string and return datetime object or None
Returns:
tuple: (datetime_object, error_message)
"""
if not datetime_string:
return None, None
try:
return datetime.strptime(datetime_string, format), None
except ValueError:
return None, f"Invalid datetime format (expected {format})"
class FormValidator:
"""Helper class for form validation"""
def __init__(self):
self.errors = ValidationError()
def validate_required(self, value, field_name):
"""Validate required field and add error if invalid"""
error = validate_required(value, field_name)
if error:
self.errors.add(error)
return error is None
def validate_unique(self, model, field_name, value, **kwargs):
"""Validate unique field and add error if invalid"""
error = validate_unique(model, field_name, value, **kwargs)
if error:
self.errors.add(error)
return error is None
def validate_date_range(self, start_date, end_date, **kwargs):
"""Validate date range and add error if invalid"""
error = validate_date_range(start_date, end_date, **kwargs)
if error:
self.errors.add(error)
return error is None
def parse_date(self, date_string, field_name="Date", **kwargs):
"""Parse date and add error if invalid"""
date_obj, error = parse_date(date_string, **kwargs)
if error:
self.errors.add(f"{field_name}: {error}")
return date_obj
def parse_datetime(self, datetime_string, field_name="Date/Time", **kwargs):
"""Parse datetime and add error if invalid"""
datetime_obj, error = parse_datetime(datetime_string, **kwargs)
if error:
self.errors.add(f"{field_name}: {error}")
return datetime_obj
def is_valid(self):
"""Check if form is valid (no errors)"""
return not self.errors.has_errors()
def flash_errors(self, category='error'):
"""Flash all error messages"""
for error in self.errors.errors:
flash(error, category)