feat: Enhance chore management with new update endpoint and structured logging
This commit introduces a new endpoint for updating chores of any type, allowing conversions between personal and group chores while enforcing permission checks. Additionally, structured logging has been implemented through a new middleware, improving request tracing and logging details for better monitoring and debugging. These changes aim to enhance the functionality and maintainability of the chore management system.
This commit is contained in:
mohamad
parent
29e42b8d80
commit
0207c175ba
@ -18,6 +18,7 @@ from app.schemas.chore import (
|
||||
from app.schemas.time_entry import TimeEntryPublic
|
||||
from app.crud import chore as crud_chore
|
||||
from app.crud import history as crud_history
|
||||
from app.crud import group as crud_group
|
||||
from app.core.exceptions import ChoreNotFoundError, PermissionDeniedError, GroupNotFoundError, DatabaseIntegrityError
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
@ -122,6 +123,66 @@ async def update_personal_chore(
|
||||
logger.error(f"DatabaseIntegrityError updating personal chore {chore_id} for {current_user.email}: {e.detail}", exc_info=True)
|
||||
raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=e.detail)
|
||||
|
||||
@router.put(
|
||||
"/{chore_id}",
|
||||
response_model=ChorePublic,
|
||||
summary="Update Chore (Any Type)",
|
||||
tags=["Chores"]
|
||||
)
|
||||
async def update_chore_any_type(
|
||||
chore_id: int,
|
||||
chore_in: ChoreUpdate,
|
||||
db: AsyncSession = Depends(get_transactional_session),
|
||||
current_user: UserModel = Depends(current_active_user),
|
||||
):
|
||||
"""Updates a chore of any type, including conversions between personal and group chores."""
|
||||
logger.info(f"User {current_user.email} updating chore ID: {chore_id}")
|
||||
|
||||
# Get the current chore to determine its type and group
|
||||
current_chore = await crud_chore.get_chore_by_id(db, chore_id)
|
||||
if not current_chore:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Chore {chore_id} not found")
|
||||
|
||||
# Check permissions on the current chore
|
||||
if current_chore.type == ChoreTypeEnum.personal:
|
||||
if current_chore.created_by_id != current_user.id:
|
||||
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="You can only update your own personal chores")
|
||||
else: # group chore
|
||||
if not await crud_group.is_user_member(db, current_chore.group_id, current_user.id):
|
||||
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=f"You are not a member of group {current_chore.group_id}")
|
||||
|
||||
# If converting to group chore, validate the target group
|
||||
if chore_in.type == ChoreTypeEnum.group and chore_in.group_id:
|
||||
if not await crud_group.is_user_member(db, chore_in.group_id, current_user.id):
|
||||
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=f"You are not a member of target group {chore_in.group_id}")
|
||||
|
||||
try:
|
||||
# Use the current group_id for the update call if not changing groups
|
||||
group_id_for_update = current_chore.group_id if current_chore.type == ChoreTypeEnum.group else None
|
||||
|
||||
updated_chore = await crud_chore.update_chore(
|
||||
db=db,
|
||||
chore_id=chore_id,
|
||||
chore_in=chore_in,
|
||||
user_id=current_user.id,
|
||||
group_id=group_id_for_update
|
||||
)
|
||||
if not updated_chore:
|
||||
raise ChoreNotFoundError(chore_id=chore_id)
|
||||
return updated_chore
|
||||
except ChoreNotFoundError as e:
|
||||
logger.warning(f"Chore {e.chore_id} not found for user {current_user.email} during update.")
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=e.detail)
|
||||
except PermissionDeniedError as e:
|
||||
logger.warning(f"Permission denied for user {current_user.email} updating chore {chore_id}: {e.detail}")
|
||||
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=e.detail)
|
||||
except ValueError as e:
|
||||
logger.warning(f"ValueError updating chore {chore_id} for user {current_user.email}: {str(e)}")
|
||||
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
|
||||
except DatabaseIntegrityError as e:
|
||||
logger.error(f"DatabaseIntegrityError updating chore {chore_id} for {current_user.email}: {e.detail}", exc_info=True)
|
||||
raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=e.detail)
|
||||
|
||||
@router.delete(
|
||||
"/personal/{chore_id}",
|
||||
status_code=status.HTTP_204_NO_CONTENT,
|
||||
@ -226,17 +287,16 @@ async def update_group_chore(
|
||||
db: AsyncSession = Depends(get_transactional_session),
|
||||
current_user: UserModel = Depends(current_active_user),
|
||||
):
|
||||
"""Updates a chore's details within a specific group."""
|
||||
"""Updates a chore's details. The group_id in path is the current group of the chore."""
|
||||
logger.info(f"User {current_user.email} updating chore ID {chore_id} in group {group_id}")
|
||||
if chore_in.type is not None and chore_in.type != ChoreTypeEnum.group:
|
||||
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Cannot change chore type to personal via this endpoint.")
|
||||
if chore_in.group_id is not None and chore_in.group_id != group_id:
|
||||
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=f"Chore's group_id if provided must match path group_id ({group_id}).")
|
||||
|
||||
chore_payload = chore_in.model_copy(update={"type": ChoreTypeEnum.group, "group_id": group_id} if chore_in.type is None else {"group_id": group_id})
|
||||
# Validate that the chore is in the specified group
|
||||
chore_to_update = await crud_chore.get_chore_by_id_and_group(db, chore_id, group_id, current_user.id)
|
||||
if not chore_to_update:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Chore {chore_id} not found in group {group_id}")
|
||||
|
||||
try:
|
||||
updated_chore = await crud_chore.update_chore(db=db, chore_id=chore_id, chore_in=chore_payload, user_id=current_user.id, group_id=group_id)
|
||||
updated_chore = await crud_chore.update_chore(db=db, chore_id=chore_id, chore_in=chore_in, user_id=current_user.id, group_id=group_id)
|
||||
if not updated_chore:
|
||||
raise ChoreNotFoundError(chore_id=chore_id, group_id=group_id)
|
||||
return updated_chore
|
||||
|
||||
@ -33,7 +33,7 @@ from app.crud import list as crud_list
|
||||
from app.core.exceptions import (
|
||||
ListNotFoundError, GroupNotFoundError, UserNotFoundError,
|
||||
InvalidOperationError, GroupPermissionError, ListPermissionError,
|
||||
ItemNotFoundError, GroupMembershipError
|
||||
ItemNotFoundError, GroupMembershipError, OverpaymentError, FinancialConflictError
|
||||
)
|
||||
from app.services import financials_service
|
||||
|
||||
@ -171,8 +171,12 @@ async def list_expenses(
|
||||
expenses = await crud_expense.get_user_accessible_expenses(db, user_id=current_user.id, skip=skip, limit=limit)
|
||||
|
||||
# Apply recurring filter if specified
|
||||
# NOTE: the original code referenced a non-existent ``expense.recurrence_rule`` attribute.
|
||||
# The canonical way to know if an expense is recurring is the ``is_recurring`` flag
|
||||
# (and/or the presence of a ``recurrence_pattern``). We use ``is_recurring`` here
|
||||
# because it is explicit, indexed and does not require an extra JOIN.
|
||||
if isRecurring is not None:
|
||||
expenses = [expense for expense in expenses if bool(expense.recurrence_rule) == isRecurring]
|
||||
expenses = [expense for expense in expenses if expense.is_recurring == isRecurring]
|
||||
|
||||
return expenses
|
||||
|
||||
@ -417,6 +421,10 @@ async def record_settlement_for_expense_split(
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"User referenced in settlement activity not found: {str(e)}")
|
||||
except InvalidOperationError as e:
|
||||
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
|
||||
except OverpaymentError as e:
|
||||
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
|
||||
except FinancialConflictError as e:
|
||||
raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail=str(e))
|
||||
except Exception as e:
|
||||
logger.error(f"Unexpected error recording settlement activity for expense_split_id {expense_split_id}: {str(e)}", exc_info=True)
|
||||
raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="An unexpected error occurred while recording settlement activity.")
|
||||
|
||||
@ -265,13 +265,21 @@ class SettlementOperationError(HTTPException):
|
||||
)
|
||||
|
||||
class FinancialConflictError(HTTPException):
|
||||
"""Raised when a financial conflict occurs."""
|
||||
"""Raised when a financial operation conflicts with business logic."""
|
||||
def __init__(self, detail: str):
|
||||
super().__init__(
|
||||
status_code=status.HTTP_409_CONFLICT,
|
||||
detail=detail
|
||||
)
|
||||
|
||||
class OverpaymentError(HTTPException):
|
||||
"""Raised when a settlement activity would cause overpayment."""
|
||||
def __init__(self, detail: str):
|
||||
super().__init__(
|
||||
status_code=status.HTTP_400_BAD_REQUEST,
|
||||
detail=detail
|
||||
)
|
||||
|
||||
class ConflictError(HTTPException):
|
||||
"""Raised when a conflict occurs."""
|
||||
def __init__(self, detail: str):
|
||||
@ -351,6 +359,10 @@ class ChoreOperationError(HTTPException):
|
||||
class ChoreNotFoundError(HTTPException):
|
||||
"""Raised when a chore or assignment is not found."""
|
||||
def __init__(self, chore_id: int = None, assignment_id: int = None, group_id: Optional[int] = None, detail: Optional[str] = None):
|
||||
self.chore_id = chore_id
|
||||
self.assignment_id = assignment_id
|
||||
self.group_id = group_id
|
||||
|
||||
if detail:
|
||||
error_detail = detail
|
||||
elif group_id is not None:
|
||||
|
||||
43
be/app/core/middleware.py
Normal file
43
be/app/core/middleware.py
Normal file
@ -0,0 +1,43 @@
|
||||
from starlette.middleware.base import BaseHTTPMiddleware
|
||||
from starlette.requests import Request
|
||||
from starlette.responses import Response
|
||||
import time
|
||||
import logging
|
||||
import uuid
|
||||
|
||||
logger = logging.getLogger("structured")
|
||||
|
||||
class RequestContextMiddleware(BaseHTTPMiddleware):
|
||||
"""Adds a unique request ID and logs request / response details."""
|
||||
|
||||
async def dispatch(self, request: Request, call_next):
|
||||
request_id = str(uuid.uuid4())
|
||||
start_time = time.time()
|
||||
# Attach id to request state for downstream handlers
|
||||
request.state.request_id = request_id
|
||||
|
||||
logger.info(
|
||||
{
|
||||
"event": "request_start",
|
||||
"request_id": request_id,
|
||||
"method": request.method,
|
||||
"path": request.url.path,
|
||||
"client": request.client.host if request.client else None,
|
||||
}
|
||||
)
|
||||
|
||||
response: Response = await call_next(request)
|
||||
|
||||
process_time = (time.time() - start_time) * 1000
|
||||
logger.info(
|
||||
{
|
||||
"event": "request_end",
|
||||
"request_id": request_id,
|
||||
"status_code": response.status_code,
|
||||
"duration_ms": round(process_time, 2),
|
||||
}
|
||||
)
|
||||
|
||||
# Propagate request id header for tracing
|
||||
response.headers["X-Request-ID"] = request_id
|
||||
return response
|
||||
@ -1,15 +1,15 @@
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
from sqlalchemy.future import select
|
||||
from sqlalchemy.orm import selectinload
|
||||
from sqlalchemy import union_all
|
||||
from sqlalchemy.orm import selectinload, subqueryload
|
||||
from sqlalchemy import union_all, and_, or_, delete
|
||||
from typing import List, Optional
|
||||
import logging
|
||||
from datetime import date, datetime
|
||||
|
||||
from app.models import Chore, Group, User, ChoreAssignment, ChoreFrequencyEnum, ChoreTypeEnum, UserGroup, ChoreHistoryEventTypeEnum
|
||||
from app.models import Chore, Group, User, ChoreAssignment, ChoreFrequencyEnum, ChoreTypeEnum, UserGroup, ChoreHistoryEventTypeEnum, UserRoleEnum, ChoreHistory, ChoreAssignmentHistory
|
||||
from app.schemas.chore import ChoreCreate, ChoreUpdate, ChoreAssignmentCreate, ChoreAssignmentUpdate
|
||||
from app.core.chore_utils import calculate_next_due_date
|
||||
from app.crud.group import get_group_by_id, is_user_member
|
||||
from app.crud.group import get_group_by_id, is_user_member, get_user_role_in_group
|
||||
from app.crud.history import create_chore_history_entry, create_assignment_history_entry
|
||||
from app.core.exceptions import ChoreNotFoundError, GroupNotFoundError, PermissionDeniedError, DatabaseIntegrityError
|
||||
|
||||
@ -137,14 +137,7 @@ async def get_chore_by_id(db: AsyncSession, chore_id: int) -> Optional[Chore]:
|
||||
result = await db.execute(
|
||||
select(Chore)
|
||||
.where(Chore.id == chore_id)
|
||||
.options(
|
||||
selectinload(Chore.creator),
|
||||
selectinload(Chore.group),
|
||||
selectinload(Chore.assignments).selectinload(ChoreAssignment.assigned_user),
|
||||
selectinload(Chore.assignments).selectinload(ChoreAssignment.history),
|
||||
selectinload(Chore.history),
|
||||
selectinload(Chore.child_chores)
|
||||
)
|
||||
.options(*get_chore_loader_options())
|
||||
)
|
||||
return result.scalar_one_or_none()
|
||||
|
||||
@ -174,13 +167,7 @@ async def get_personal_chores(
|
||||
Chore.created_by_id == user_id,
|
||||
Chore.type == ChoreTypeEnum.personal
|
||||
)
|
||||
.options(
|
||||
selectinload(Chore.creator),
|
||||
selectinload(Chore.assignments).selectinload(ChoreAssignment.assigned_user),
|
||||
selectinload(Chore.assignments).selectinload(ChoreAssignment.history),
|
||||
selectinload(Chore.history),
|
||||
selectinload(Chore.child_chores)
|
||||
)
|
||||
.options(*get_chore_loader_options())
|
||||
.order_by(Chore.next_due_date, Chore.name)
|
||||
)
|
||||
return result.scalars().all()
|
||||
@ -200,13 +187,7 @@ async def get_chores_by_group_id(
|
||||
Chore.group_id == group_id,
|
||||
Chore.type == ChoreTypeEnum.group
|
||||
)
|
||||
.options(
|
||||
selectinload(Chore.creator),
|
||||
selectinload(Chore.assignments).selectinload(ChoreAssignment.assigned_user),
|
||||
selectinload(Chore.assignments).selectinload(ChoreAssignment.history),
|
||||
selectinload(Chore.history),
|
||||
selectinload(Chore.child_chores)
|
||||
)
|
||||
.options(*get_chore_loader_options())
|
||||
.order_by(Chore.next_due_date, Chore.name)
|
||||
)
|
||||
return result.scalars().all()
|
||||
@ -226,21 +207,37 @@ async def update_chore(
|
||||
|
||||
original_data = {field: getattr(db_chore, field) for field in chore_in.model_dump(exclude_unset=True)}
|
||||
|
||||
# Check permissions for current chore
|
||||
if db_chore.type == ChoreTypeEnum.group:
|
||||
if not group_id:
|
||||
raise ValueError("group_id is required for group chores")
|
||||
if not await is_user_member(db, group_id, user_id):
|
||||
raise PermissionDeniedError(detail=f"User {user_id} not a member of group {group_id}")
|
||||
if db_chore.group_id != group_id:
|
||||
raise ChoreNotFoundError(chore_id, group_id)
|
||||
if not await is_user_member(db, db_chore.group_id, user_id):
|
||||
raise PermissionDeniedError(detail=f"User {user_id} not a member of chore's current group {db_chore.group_id}")
|
||||
else:
|
||||
if group_id:
|
||||
raise ValueError("group_id must be None for personal chores")
|
||||
if db_chore.created_by_id != user_id:
|
||||
raise PermissionDeniedError(detail="Only the creator can update personal chores")
|
||||
|
||||
update_data = chore_in.model_dump(exclude_unset=True)
|
||||
|
||||
# Handle group changes
|
||||
if 'group_id' in update_data:
|
||||
new_group_id = update_data['group_id']
|
||||
if new_group_id != db_chore.group_id:
|
||||
# Validate user has permission for the new group
|
||||
if new_group_id is not None:
|
||||
if not await is_user_member(db, new_group_id, user_id):
|
||||
raise PermissionDeniedError(detail=f"User {user_id} not a member of target group {new_group_id}")
|
||||
|
||||
# Handle type changes
|
||||
if 'type' in update_data:
|
||||
new_type = update_data['type']
|
||||
# When changing to personal, always clear group_id regardless of what's in update_data
|
||||
if new_type == ChoreTypeEnum.personal:
|
||||
update_data['group_id'] = None
|
||||
else:
|
||||
# For group chores, use the provided group_id or keep the current one
|
||||
new_group_id = update_data.get('group_id', db_chore.group_id)
|
||||
if new_type == ChoreTypeEnum.group and new_group_id is None:
|
||||
raise ValueError("group_id is required for group chores")
|
||||
|
||||
if 'parent_chore_id' in update_data:
|
||||
if update_data['parent_chore_id']:
|
||||
parent_chore = await get_chore_by_id(db, update_data['parent_chore_id'])
|
||||
@ -249,13 +246,6 @@ async def update_chore(
|
||||
# Setting parent_chore_id to None is allowed
|
||||
setattr(db_chore, 'parent_chore_id', update_data['parent_chore_id'])
|
||||
|
||||
if 'type' in update_data:
|
||||
new_type = update_data['type']
|
||||
if new_type == ChoreTypeEnum.group and not group_id:
|
||||
raise ValueError("group_id is required for group chores")
|
||||
if new_type == ChoreTypeEnum.personal and group_id:
|
||||
raise ValueError("group_id must be None for personal chores")
|
||||
|
||||
# Recalculate next_due_date if needed
|
||||
recalculate = False
|
||||
if 'frequency' in update_data and update_data['frequency'] != db_chore.frequency:
|
||||
@ -304,14 +294,7 @@ async def update_chore(
|
||||
result = await db.execute(
|
||||
select(Chore)
|
||||
.where(Chore.id == db_chore.id)
|
||||
.options(
|
||||
selectinload(Chore.creator),
|
||||
selectinload(Chore.group),
|
||||
selectinload(Chore.assignments).selectinload(ChoreAssignment.assigned_user),
|
||||
selectinload(Chore.assignments).selectinload(ChoreAssignment.history),
|
||||
selectinload(Chore.history),
|
||||
selectinload(Chore.child_chores)
|
||||
)
|
||||
.options(*get_chore_loader_options())
|
||||
)
|
||||
return result.scalar_one()
|
||||
except Exception as e:
|
||||
@ -398,12 +381,7 @@ async def create_chore_assignment(
|
||||
result = await db.execute(
|
||||
select(ChoreAssignment)
|
||||
.where(ChoreAssignment.id == db_assignment.id)
|
||||
.options(
|
||||
selectinload(ChoreAssignment.chore).selectinload(Chore.creator),
|
||||
selectinload(ChoreAssignment.chore).selectinload(Chore.child_chores),
|
||||
selectinload(ChoreAssignment.assigned_user),
|
||||
selectinload(ChoreAssignment.history)
|
||||
)
|
||||
.options(*get_assignment_loader_options())
|
||||
)
|
||||
return result.scalar_one()
|
||||
except Exception as e:
|
||||
@ -415,12 +393,7 @@ async def get_chore_assignment_by_id(db: AsyncSession, assignment_id: int) -> Op
|
||||
result = await db.execute(
|
||||
select(ChoreAssignment)
|
||||
.where(ChoreAssignment.id == assignment_id)
|
||||
.options(
|
||||
selectinload(ChoreAssignment.chore).selectinload(Chore.creator),
|
||||
selectinload(ChoreAssignment.chore).selectinload(Chore.child_chores),
|
||||
selectinload(ChoreAssignment.assigned_user),
|
||||
selectinload(ChoreAssignment.history)
|
||||
)
|
||||
.options(*get_assignment_loader_options())
|
||||
)
|
||||
return result.scalar_one_or_none()
|
||||
|
||||
@ -435,12 +408,7 @@ async def get_user_assignments(
|
||||
if not include_completed:
|
||||
query = query.where(ChoreAssignment.is_complete == False)
|
||||
|
||||
query = query.options(
|
||||
selectinload(ChoreAssignment.chore).selectinload(Chore.creator),
|
||||
selectinload(ChoreAssignment.chore).selectinload(Chore.child_chores),
|
||||
selectinload(ChoreAssignment.assigned_user),
|
||||
selectinload(ChoreAssignment.history)
|
||||
).order_by(ChoreAssignment.due_date, ChoreAssignment.id)
|
||||
query = query.options(*get_assignment_loader_options()).order_by(ChoreAssignment.due_date, ChoreAssignment.id)
|
||||
|
||||
result = await db.execute(query)
|
||||
return result.scalars().all()
|
||||
@ -465,12 +433,7 @@ async def get_chore_assignments(
|
||||
result = await db.execute(
|
||||
select(ChoreAssignment)
|
||||
.where(ChoreAssignment.chore_id == chore_id)
|
||||
.options(
|
||||
selectinload(ChoreAssignment.chore).selectinload(Chore.creator),
|
||||
selectinload(ChoreAssignment.chore).selectinload(Chore.child_chores),
|
||||
selectinload(ChoreAssignment.assigned_user),
|
||||
selectinload(ChoreAssignment.history)
|
||||
)
|
||||
.options(*get_assignment_loader_options())
|
||||
.order_by(ChoreAssignment.due_date, ChoreAssignment.id)
|
||||
)
|
||||
return result.scalars().all()
|
||||
@ -510,12 +473,13 @@ async def update_chore_assignment(
|
||||
history_event = ChoreHistoryEventTypeEnum.COMPLETED
|
||||
|
||||
# Advance the next_due_date of the parent chore
|
||||
if db_assignment.chore:
|
||||
if db_assignment.chore and db_assignment.chore.frequency != ChoreFrequencyEnum.one_time:
|
||||
db_assignment.chore.last_completed_at = db_assignment.completed_at
|
||||
db_assignment.chore.next_due_date = calculate_next_due_date(
|
||||
db_assignment.chore.frequency,
|
||||
db_assignment.chore.last_completed_at.date() if db_assignment.chore.last_completed_at else date.today(),
|
||||
db_assignment.chore.custom_interval_days
|
||||
current_due_date=db_assignment.chore.next_due_date,
|
||||
frequency=db_assignment.chore.frequency,
|
||||
custom_interval_days=db_assignment.chore.custom_interval_days,
|
||||
last_completed_date=db_assignment.chore.last_completed_at.date() if db_assignment.chore.last_completed_at else None
|
||||
)
|
||||
elif not new_status and original_status:
|
||||
db_assignment.completed_at = None
|
||||
@ -537,10 +501,7 @@ async def update_chore_assignment(
|
||||
result = await db.execute(
|
||||
select(ChoreAssignment)
|
||||
.where(ChoreAssignment.id == assignment_id)
|
||||
.options(
|
||||
selectinload(ChoreAssignment.chore).selectinload(Chore.child_chores),
|
||||
selectinload(ChoreAssignment.assigned_user)
|
||||
)
|
||||
.options(*get_assignment_loader_options())
|
||||
)
|
||||
return result.scalar_one()
|
||||
except Exception as e:
|
||||
@ -585,3 +546,25 @@ async def delete_chore_assignment(
|
||||
except Exception as e:
|
||||
logger.error(f"Error deleting chore assignment {assignment_id}: {e}", exc_info=True)
|
||||
raise DatabaseIntegrityError(f"Could not delete chore assignment {assignment_id}. Error: {str(e)}")
|
||||
|
||||
def get_chore_loader_options():
|
||||
"""Returns a list of SQLAlchemy loader options for chore relationships."""
|
||||
return [
|
||||
selectinload(Chore.creator),
|
||||
selectinload(Chore.group),
|
||||
selectinload(Chore.assignments).selectinload(ChoreAssignment.assigned_user),
|
||||
selectinload(Chore.history).selectinload(ChoreHistory.changed_by_user),
|
||||
selectinload(Chore.child_chores).options(
|
||||
selectinload(Chore.assignments).selectinload(ChoreAssignment.assigned_user),
|
||||
selectinload(Chore.history).selectinload(ChoreHistory.changed_by_user),
|
||||
selectinload(Chore.creator),
|
||||
selectinload(Chore.child_chores) # Load grandchildren, adjust depth if needed
|
||||
)
|
||||
]
|
||||
|
||||
def get_assignment_loader_options():
|
||||
return [
|
||||
selectinload(ChoreAssignment.assigned_user),
|
||||
selectinload(ChoreAssignment.history).selectinload(ChoreAssignmentHistory.changed_by_user),
|
||||
selectinload(ChoreAssignment.chore).options(*get_chore_loader_options())
|
||||
]
|
||||
|
||||
@ -4,7 +4,7 @@ from sqlalchemy.ext.asyncio import AsyncSession
|
||||
from sqlalchemy.future import select
|
||||
from sqlalchemy.orm import selectinload, joinedload
|
||||
from sqlalchemy.exc import SQLAlchemyError, IntegrityError, OperationalError # Added import
|
||||
from decimal import Decimal, ROUND_HALF_UP, InvalidOperation as DecimalInvalidOperation
|
||||
from decimal import Decimal, ROUND_HALF_UP, ROUND_DOWN, InvalidOperation as DecimalInvalidOperation
|
||||
from typing import Callable, List as PyList, Optional, Sequence, Dict, defaultdict, Any
|
||||
from datetime import datetime, timezone # Added timezone
|
||||
import json
|
||||
@ -20,6 +20,7 @@ from app.models import (
|
||||
Item as ItemModel,
|
||||
ExpenseOverallStatusEnum, # Added
|
||||
ExpenseSplitStatusEnum, # Added
|
||||
RecurrenceTypeEnum,
|
||||
)
|
||||
from app.schemas.expense import ExpenseCreate, ExpenseSplitCreate, ExpenseUpdate # Removed unused ExpenseUpdate
|
||||
from app.core.exceptions import (
|
||||
@ -147,13 +148,26 @@ async def create_expense(db: AsyncSession, expense_in: ExpenseCreate, current_us
|
||||
# Re-resolve context if list_id was derived from item
|
||||
final_group_id = await _resolve_expense_context(db, expense_in)
|
||||
|
||||
# Create recurrence pattern if this is a recurring expense
|
||||
recurrence_pattern = None
|
||||
if expense_in.is_recurring and expense_in.recurrence_pattern:
|
||||
# Normalize recurrence type (accept both str and Enum)
|
||||
_rp_type_raw = expense_in.recurrence_pattern.type
|
||||
if isinstance(_rp_type_raw, str):
|
||||
try:
|
||||
_rp_type_enum = RecurrenceTypeEnum[_rp_type_raw.upper()]
|
||||
except KeyError:
|
||||
raise InvalidOperationError(f"Unsupported recurrence type: {_rp_type_raw}")
|
||||
else:
|
||||
_rp_type_enum = _rp_type_raw # assume already RecurrenceTypeEnum
|
||||
|
||||
recurrence_pattern = RecurrencePattern(
|
||||
type=expense_in.recurrence_pattern.type,
|
||||
type=_rp_type_enum,
|
||||
interval=expense_in.recurrence_pattern.interval,
|
||||
days_of_week=expense_in.recurrence_pattern.days_of_week,
|
||||
days_of_week=(
|
||||
','.join(str(d) for d in expense_in.recurrence_pattern.days_of_week)
|
||||
if isinstance(expense_in.recurrence_pattern.days_of_week, (list, tuple))
|
||||
else expense_in.recurrence_pattern.days_of_week
|
||||
),
|
||||
end_date=expense_in.recurrence_pattern.end_date,
|
||||
max_occurrences=expense_in.recurrence_pattern.max_occurrences,
|
||||
created_at=datetime.now(timezone.utc),
|
||||
@ -314,7 +328,7 @@ async def _generate_expense_splits(
|
||||
|
||||
|
||||
async def _create_equal_splits(db: AsyncSession, expense_model: ExpenseModel, expense_in: ExpenseCreate, round_money_func: Callable[[Decimal], Decimal], **kwargs: Any) -> PyList[ExpenseSplitModel]:
|
||||
"""Creates equal splits among users."""
|
||||
"""Creates equal splits among users, distributing any rounding remainder fairly."""
|
||||
|
||||
users_for_splitting = await get_users_for_splitting(
|
||||
db, expense_model.group_id, expense_model.list_id, expense_model.paid_by_user_id
|
||||
@ -323,21 +337,30 @@ async def _create_equal_splits(db: AsyncSession, expense_model: ExpenseModel, ex
|
||||
raise InvalidOperationError("No users found for EQUAL split.")
|
||||
|
||||
num_users = len(users_for_splitting)
|
||||
amount_per_user = round_money_func(expense_model.total_amount / Decimal(num_users))
|
||||
remainder = expense_model.total_amount - (amount_per_user * num_users)
|
||||
# Use floor rounding initially to prevent over-shooting the total
|
||||
amount_per_user_floor = (expense_model.total_amount / Decimal(num_users)).quantize(Decimal("0.01"), rounding=ROUND_DOWN)
|
||||
|
||||
splits = []
|
||||
for i, user in enumerate(users_for_splitting):
|
||||
split_amount = amount_per_user
|
||||
if i == 0 and remainder != Decimal('0'):
|
||||
split_amount = round_money_func(amount_per_user + remainder)
|
||||
# Sort users by ID to ensure deterministic remainder distribution
|
||||
users_for_splitting.sort(key=lambda u: u.id)
|
||||
|
||||
for user in users_for_splitting:
|
||||
splits.append(ExpenseSplitModel(
|
||||
user_id=user.id,
|
||||
owed_amount=split_amount,
|
||||
status=ExpenseSplitStatusEnum.unpaid # Explicitly set default status
|
||||
owed_amount=amount_per_user_floor,
|
||||
status=ExpenseSplitStatusEnum.unpaid
|
||||
))
|
||||
|
||||
# Calculate remainder and distribute pennies one by one
|
||||
current_total = amount_per_user_floor * num_users
|
||||
remainder = expense_model.total_amount - current_total
|
||||
|
||||
pennies_to_distribute = int(remainder * 100)
|
||||
|
||||
for i in range(pennies_to_distribute):
|
||||
# The modulo ensures that if pennies > num_users (should not happen with floor), it still works
|
||||
splits[i % len(splits)].owed_amount += Decimal("0.01")
|
||||
|
||||
return splits
|
||||
|
||||
|
||||
@ -375,7 +398,7 @@ async def _create_exact_amount_splits(db: AsyncSession, expense_model: ExpenseMo
|
||||
|
||||
|
||||
async def _create_percentage_splits(db: AsyncSession, expense_model: ExpenseModel, expense_in: ExpenseCreate, round_money_func: Callable[[Decimal], Decimal], **kwargs: Any) -> PyList[ExpenseSplitModel]:
|
||||
"""Creates splits based on percentages."""
|
||||
"""Creates splits based on percentages, distributing any rounding remainder fairly."""
|
||||
|
||||
if not expense_in.splits_in:
|
||||
raise InvalidOperationError("Splits data is required for PERCENTAGE split type.")
|
||||
@ -407,16 +430,24 @@ async def _create_percentage_splits(db: AsyncSession, expense_model: ExpenseMode
|
||||
if round_money_func(total_percentage) != Decimal("100.00"):
|
||||
raise InvalidOperationError(f"Sum of percentages ({total_percentage}%) is not 100%.")
|
||||
|
||||
# Adjust for rounding differences
|
||||
# Adjust for rounding differences by distributing remainder fairly
|
||||
if current_total != expense_model.total_amount and splits:
|
||||
diff = expense_model.total_amount - current_total
|
||||
splits[-1].owed_amount = round_money_func(splits[-1].owed_amount + diff)
|
||||
|
||||
# Sort by user ID to make distribution deterministic
|
||||
splits.sort(key=lambda s: s.user_id)
|
||||
|
||||
pennies = int(diff * 100)
|
||||
increment = Decimal("0.01") if pennies > 0 else Decimal("-0.01")
|
||||
|
||||
for i in range(abs(pennies)):
|
||||
splits[i % len(splits)].owed_amount += increment
|
||||
|
||||
return splits
|
||||
|
||||
|
||||
async def _create_shares_splits(db: AsyncSession, expense_model: ExpenseModel, expense_in: ExpenseCreate, round_money_func: Callable[[Decimal], Decimal], **kwargs: Any) -> PyList[ExpenseSplitModel]:
|
||||
"""Creates splits based on shares."""
|
||||
"""Creates splits based on shares, distributing any rounding remainder fairly."""
|
||||
|
||||
if not expense_in.splits_in:
|
||||
raise InvalidOperationError("Splits data is required for SHARES split type.")
|
||||
@ -447,10 +478,18 @@ async def _create_shares_splits(db: AsyncSession, expense_model: ExpenseModel, e
|
||||
status=ExpenseSplitStatusEnum.unpaid # Explicitly set default status
|
||||
))
|
||||
|
||||
# Adjust for rounding differences
|
||||
# Adjust for rounding differences by distributing remainder fairly
|
||||
if current_total != expense_model.total_amount and splits:
|
||||
diff = expense_model.total_amount - current_total
|
||||
splits[-1].owed_amount = round_money_func(splits[-1].owed_amount + diff)
|
||||
|
||||
# Sort by user ID to make distribution deterministic
|
||||
splits.sort(key=lambda s: s.user_id)
|
||||
|
||||
pennies = int(diff * 100)
|
||||
increment = Decimal("0.01") if pennies > 0 else Decimal("-0.01")
|
||||
|
||||
for i in range(abs(pennies)):
|
||||
splits[i % len(splits)].owed_amount += increment
|
||||
|
||||
return splits
|
||||
|
||||
|
||||
@ -17,7 +17,7 @@ from app.models import (
|
||||
from pydantic import BaseModel
|
||||
from app.crud.audit import create_financial_audit_log
|
||||
from app.schemas.settlement_activity import SettlementActivityCreate
|
||||
from app.core.exceptions import UserNotFoundError, InvalidOperationError, FinancialConflictError
|
||||
from app.core.exceptions import UserNotFoundError, InvalidOperationError, FinancialConflictError, OverpaymentError
|
||||
|
||||
|
||||
class SettlementActivityCreatePlaceholder(BaseModel):
|
||||
@ -140,6 +140,27 @@ async def create_settlement_activity(
|
||||
if expense_split.status == ExpenseSplitStatusEnum.paid:
|
||||
raise FinancialConflictError(f"Expense split {expense_split.id} is already fully paid.")
|
||||
|
||||
# Calculate current total paid to prevent overpayment
|
||||
current_total_paid = Decimal("0.00")
|
||||
if expense_split.settlement_activities:
|
||||
current_total_paid = sum(
|
||||
Decimal(str(activity.amount_paid)) for activity in expense_split.settlement_activities
|
||||
)
|
||||
current_total_paid = current_total_paid.quantize(Decimal("0.01"))
|
||||
|
||||
new_payment_amount = Decimal(str(settlement_activity_in.amount_paid)).quantize(Decimal("0.01"))
|
||||
projected_total = current_total_paid + new_payment_amount
|
||||
owed_amount = Decimal(str(expense_split.owed_amount)).quantize(Decimal("0.01"))
|
||||
|
||||
# Prevent overpayment (with small epsilon for floating point precision)
|
||||
epsilon = Decimal("0.01")
|
||||
if projected_total > (owed_amount + epsilon):
|
||||
remaining_amount = owed_amount - current_total_paid
|
||||
raise OverpaymentError(
|
||||
f"Payment amount {new_payment_amount} would exceed remaining owed amount. "
|
||||
f"Maximum payment allowed: {remaining_amount} (owed: {owed_amount}, already paid: {current_total_paid})"
|
||||
)
|
||||
|
||||
# Validate that the user paying exists
|
||||
user_result = await db.execute(select(User).where(User.id == settlement_activity_in.paid_by_user_id))
|
||||
if not user_result.scalar_one_or_none():
|
||||
|
||||
@ -7,6 +7,7 @@ from app.crud.expense import create_expense
|
||||
from app.schemas.expense import ExpenseCreate, ExpenseSplitCreate
|
||||
import logging
|
||||
from typing import Optional
|
||||
import enum
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
@ -41,12 +42,12 @@ async def generate_recurring_expenses(db: AsyncSession) -> None:
|
||||
try:
|
||||
await _generate_next_occurrence(db, expense)
|
||||
except Exception as e:
|
||||
logger.error(f"Error generating next occurrence for expense {expense.id}: {str(e)}")
|
||||
logger.error(f"Error generating next occurrence for expense {expense.id}: {str(e)}", exc_info=True)
|
||||
continue
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error in generate_recurring_expenses job: {str(e)}")
|
||||
raise
|
||||
logger.error(f"Error in generate_recurring_expenses job during expense fetch: {str(e)}", exc_info=True)
|
||||
# Do not re-raise, allow the job scheduler to run again later
|
||||
|
||||
async def _generate_next_occurrence(db: AsyncSession, expense: Expense) -> None:
|
||||
"""Generate the next occurrence of a recurring expense."""
|
||||
@ -113,49 +114,72 @@ async def _generate_next_occurrence(db: AsyncSession, expense: Expense) -> None:
|
||||
await db.flush()
|
||||
|
||||
def _calculate_next_occurrence(current_date: datetime, pattern: RecurrencePattern) -> Optional[datetime]:
|
||||
"""Calculate the next occurrence date based on the pattern."""
|
||||
"""Calculate the next occurrence date based on the recurrence pattern provided."""
|
||||
|
||||
if not current_date:
|
||||
return None
|
||||
|
||||
next_date = None
|
||||
if pattern.type == 'daily':
|
||||
# Extract a lowercase string of the recurrence type regardless of whether it is an Enum member or a str.
|
||||
if isinstance(pattern.type, enum.Enum):
|
||||
pattern_type = pattern.type.value.lower()
|
||||
else:
|
||||
pattern_type = str(pattern.type).lower()
|
||||
|
||||
next_date: Optional[datetime] = None
|
||||
|
||||
if pattern_type == 'daily':
|
||||
next_date = current_date + timedelta(days=pattern.interval)
|
||||
|
||||
elif pattern.type == 'weekly':
|
||||
elif pattern_type == 'weekly':
|
||||
if not pattern.days_of_week:
|
||||
next_date = current_date + timedelta(weeks=pattern.interval)
|
||||
else:
|
||||
current_weekday = current_date.weekday()
|
||||
# Find the next valid weekday
|
||||
next_days = sorted([d for d in pattern.days_of_week if d > current_weekday])
|
||||
# ``days_of_week`` can be stored either as a list[int] (Python-side) or as a
|
||||
# comma-separated string in the database. We normalise it to a list[int].
|
||||
days_of_week_iterable = []
|
||||
if pattern.days_of_week is None:
|
||||
days_of_week_iterable = []
|
||||
elif isinstance(pattern.days_of_week, (list, tuple)):
|
||||
days_of_week_iterable = list(pattern.days_of_week)
|
||||
else:
|
||||
# Assume comma-separated string like "1,3,5"
|
||||
try:
|
||||
days_of_week_iterable = [int(d.strip()) for d in str(pattern.days_of_week).split(',') if d.strip().isdigit()]
|
||||
except Exception:
|
||||
days_of_week_iterable = []
|
||||
|
||||
# Find the next valid weekday after the current one
|
||||
next_days = sorted([d for d in days_of_week_iterable if d > current_weekday])
|
||||
if next_days:
|
||||
# Next occurrence is in the same week
|
||||
days_ahead = next_days[0] - current_weekday
|
||||
next_date = current_date + timedelta(days=days_ahead)
|
||||
else:
|
||||
# Next occurrence is in the following week(s)
|
||||
days_ahead = (7 - current_weekday) + min(pattern.days_of_week)
|
||||
next_date = current_date + timedelta(days=days_ahead)
|
||||
if pattern.interval > 1:
|
||||
next_date += timedelta(weeks=pattern.interval - 1)
|
||||
# Jump to the first valid day in a future week respecting the interval
|
||||
if days_of_week_iterable:
|
||||
days_ahead = (7 - current_weekday) + min(days_of_week_iterable)
|
||||
next_date = current_date + timedelta(days=days_ahead)
|
||||
if pattern.interval > 1:
|
||||
next_date += timedelta(weeks=pattern.interval - 1)
|
||||
|
||||
elif pattern.type == 'monthly':
|
||||
elif pattern_type == 'monthly':
|
||||
# Move `interval` months forward while keeping the day component stable where possible.
|
||||
year = current_date.year + (current_date.month + pattern.interval - 1) // 12
|
||||
month = (current_date.month + pattern.interval - 1) % 12 + 1
|
||||
# Handle cases where the day is invalid for the new month (e.g., 31st)
|
||||
try:
|
||||
next_date = current_date.replace(year=year, month=month)
|
||||
except ValueError:
|
||||
# Go to the last day of the new month
|
||||
next_date = (current_date.replace(year=year, month=month, day=1) + timedelta(days=31)).replace(day=1) - timedelta(days=1)
|
||||
# Handle cases like Feb-31st by rolling back to the last valid day of the new month.
|
||||
next_date = (current_date.replace(day=1, year=year, month=month) + timedelta(days=31)).replace(day=1) - timedelta(days=1)
|
||||
|
||||
elif pattern.type == 'yearly':
|
||||
elif pattern_type == 'yearly':
|
||||
try:
|
||||
next_date = current_date.replace(year=current_date.year + pattern.interval)
|
||||
except ValueError: # Leap year case (Feb 29)
|
||||
except ValueError:
|
||||
# Leap-year edge-case; fallback to Feb-28 if Feb-29 does not exist in the target year.
|
||||
next_date = current_date.replace(year=current_date.year + pattern.interval, day=28)
|
||||
|
||||
# Check against end_date
|
||||
# Stop recurrence if beyond end_date
|
||||
if pattern.end_date and next_date and next_date > pattern.end_date:
|
||||
return None
|
||||
|
||||
|
||||
@ -12,6 +12,7 @@ from app.core.api_config import API_METADATA, API_TAGS
|
||||
from app.auth import fastapi_users, auth_backend
|
||||
from app.schemas.user import UserPublic, UserCreate, UserUpdate
|
||||
from app.core.scheduler import init_scheduler, shutdown_scheduler
|
||||
from app.core.middleware import RequestContextMiddleware
|
||||
|
||||
if settings.SENTRY_DSN:
|
||||
sentry_sdk.init(
|
||||
@ -48,6 +49,9 @@ app.add_middleware(
|
||||
secret_key=settings.SESSION_SECRET_KEY
|
||||
)
|
||||
|
||||
# Structured logging & request tracing
|
||||
app.add_middleware(RequestContextMiddleware)
|
||||
|
||||
app.add_middleware(
|
||||
CORSMiddleware,
|
||||
allow_origins=settings.cors_origins_list,
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
from __future__ import annotations
|
||||
from datetime import date, datetime
|
||||
from typing import Optional, List, Any
|
||||
from pydantic import BaseModel, ConfigDict, field_validator
|
||||
from pydantic import BaseModel, ConfigDict, field_validator, model_validator
|
||||
from ..models import ChoreFrequencyEnum, ChoreTypeEnum, ChoreHistoryEventTypeEnum
|
||||
from .user import UserPublic
|
||||
|
||||
@ -35,37 +35,25 @@ class ChoreBase(BaseModel):
|
||||
next_due_date: date # For creation, this will be the initial due date
|
||||
type: ChoreTypeEnum
|
||||
|
||||
@field_validator('custom_interval_days', mode='before')
|
||||
@classmethod
|
||||
def check_custom_interval_days(cls, value, values):
|
||||
# Pydantic v2 uses `values.data` to get all fields
|
||||
# For older Pydantic, it might just be `values`
|
||||
# This is a simplified check; actual access might differ slightly
|
||||
# based on Pydantic version context within the validator.
|
||||
# The goal is to ensure custom_interval_days is present if frequency is 'custom'.
|
||||
# This validator might be more complex in a real Pydantic v2 setup.
|
||||
|
||||
# A more direct way if 'frequency' is already parsed into values.data:
|
||||
# freq = values.data.get('frequency')
|
||||
# For this example, we'll assume 'frequency' might not be in 'values.data' yet
|
||||
# if 'custom_interval_days' is validated 'before' 'frequency'.
|
||||
# A truly robust validator might need to be on the whole model or run 'after'.
|
||||
# For now, this is a placeholder for the logic.
|
||||
# Consider if this validation is better handled at the service/CRUD layer for complex cases.
|
||||
return value
|
||||
@model_validator(mode='after')
|
||||
def validate_custom_frequency(self):
|
||||
if self.frequency == ChoreFrequencyEnum.custom:
|
||||
if self.custom_interval_days is None or self.custom_interval_days <= 0:
|
||||
raise ValueError("custom_interval_days must be a positive integer when frequency is 'custom'")
|
||||
return self
|
||||
|
||||
class ChoreCreate(ChoreBase):
|
||||
group_id: Optional[int] = None
|
||||
parent_chore_id: Optional[int] = None
|
||||
|
||||
@field_validator('group_id')
|
||||
@classmethod
|
||||
def validate_group_id(cls, v, values):
|
||||
if values.data.get('type') == ChoreTypeEnum.group and v is None:
|
||||
@model_validator(mode='after')
|
||||
def validate_group_id_with_type(self):
|
||||
if self.type == ChoreTypeEnum.group and self.group_id is None:
|
||||
raise ValueError("group_id is required for group chores")
|
||||
if values.data.get('type') == ChoreTypeEnum.personal and v is not None:
|
||||
raise ValueError("group_id must be None for personal chores")
|
||||
return v
|
||||
if self.type == ChoreTypeEnum.personal and self.group_id is not None:
|
||||
# Automatically clear group_id for personal chores instead of raising an error
|
||||
self.group_id = None
|
||||
return self
|
||||
|
||||
class ChoreUpdate(BaseModel):
|
||||
name: Optional[str] = None
|
||||
@ -75,16 +63,17 @@ class ChoreUpdate(BaseModel):
|
||||
next_due_date: Optional[date] = None # Allow updating next_due_date directly if needed
|
||||
type: Optional[ChoreTypeEnum] = None
|
||||
group_id: Optional[int] = None
|
||||
parent_chore_id: Optional[int] = None # Allow moving a chore under a parent or removing association
|
||||
# last_completed_at should generally not be updated directly by user
|
||||
|
||||
@field_validator('group_id')
|
||||
@classmethod
|
||||
def validate_group_id(cls, v, values):
|
||||
if values.data.get('type') == ChoreTypeEnum.group and v is None:
|
||||
@model_validator(mode='after')
|
||||
def validate_group_id_with_type(self):
|
||||
if self.type == ChoreTypeEnum.group and self.group_id is None:
|
||||
raise ValueError("group_id is required for group chores")
|
||||
if values.data.get('type') == ChoreTypeEnum.personal and v is not None:
|
||||
raise ValueError("group_id must be None for personal chores")
|
||||
return v
|
||||
if self.type == ChoreTypeEnum.personal and self.group_id is not None:
|
||||
# Automatically clear group_id for personal chores instead of raising an error
|
||||
self.group_id = None
|
||||
return self
|
||||
|
||||
class ChorePublic(ChoreBase):
|
||||
id: int
|
||||
|
||||
@ -24,6 +24,7 @@ from app.crud.settlement_activity import (
|
||||
update_expense_overall_status # For direct testing if needed
|
||||
)
|
||||
from app.schemas.settlement_activity import SettlementActivityCreate as SettlementActivityCreateSchema
|
||||
from app.core.exceptions import OverpaymentError
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
@ -356,6 +357,73 @@ async def test_create_settlement_activity_overall_status_becomes_partially_paid(
|
||||
# Since one split is paid and the other is unpaid, the overall expense status should be partially_paid
|
||||
assert test_expense.overall_settlement_status == ExpenseOverallStatusEnum.partially_paid
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_create_settlement_activity_overpayment_protection(
|
||||
db_session: AsyncSession, test_user2: User, test_expense_split_user2_owes: ExpenseSplit
|
||||
):
|
||||
"""Test that settlement activities prevent overpayment beyond owed amount."""
|
||||
# Test split owes 10.00, attempt to pay 15.00 directly
|
||||
activity_data = SettlementActivityCreateSchema(
|
||||
expense_split_id=test_expense_split_user2_owes.id,
|
||||
paid_by_user_id=test_user2.id,
|
||||
amount_paid=Decimal("15.00") # More than the 10.00 owed
|
||||
)
|
||||
|
||||
# Should raise OverpaymentError
|
||||
with pytest.raises(OverpaymentError):
|
||||
await create_settlement_activity(
|
||||
db=db_session,
|
||||
settlement_activity_in=activity_data,
|
||||
current_user_id=test_user2.id
|
||||
)
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_create_settlement_activity_overpayment_protection_partial(
|
||||
db_session: AsyncSession, test_user2: User, test_expense_split_user2_owes: ExpenseSplit
|
||||
):
|
||||
"""Test overpayment protection with multiple payments."""
|
||||
# First payment of 7.00
|
||||
activity1_data = SettlementActivityCreateSchema(
|
||||
expense_split_id=test_expense_split_user2_owes.id,
|
||||
paid_by_user_id=test_user2.id,
|
||||
amount_paid=Decimal("7.00")
|
||||
)
|
||||
|
||||
activity1 = await create_settlement_activity(
|
||||
db=db_session,
|
||||
settlement_activity_in=activity1_data,
|
||||
current_user_id=test_user2.id
|
||||
)
|
||||
assert activity1 is not None
|
||||
|
||||
# Second payment of 5.00 should be rejected (7 + 5 = 12 > 10 owed)
|
||||
activity2_data = SettlementActivityCreateSchema(
|
||||
expense_split_id=test_expense_split_user2_owes.id,
|
||||
paid_by_user_id=test_user2.id,
|
||||
amount_paid=Decimal("5.00")
|
||||
)
|
||||
|
||||
with pytest.raises(OverpaymentError):
|
||||
await create_settlement_activity(
|
||||
db=db_session,
|
||||
settlement_activity_in=activity2_data,
|
||||
current_user_id=test_user2.id
|
||||
)
|
||||
|
||||
# But a payment of 3.00 should work (7 + 3 = 10 = exact amount owed)
|
||||
activity3_data = SettlementActivityCreateSchema(
|
||||
expense_split_id=test_expense_split_user2_owes.id,
|
||||
paid_by_user_id=test_user2.id,
|
||||
amount_paid=Decimal("3.00")
|
||||
)
|
||||
|
||||
activity3 = await create_settlement_activity(
|
||||
db=db_session,
|
||||
settlement_activity_in=activity3_data,
|
||||
current_user_id=test_user2.id
|
||||
)
|
||||
assert activity3 is not None
|
||||
|
||||
# Example of a placeholder for db_session fixture if not provided by conftest.py
|
||||
# @pytest.fixture
|
||||
# async def db_session() -> AsyncGenerator[AsyncSession, None]:
|
||||
|
||||
107
docs/chore-system.md
Normal file
107
docs/chore-system.md
Normal file
@ -0,0 +1,107 @@
|
||||
# Chore System Documentation
|
||||
|
||||
## 1. Overview
|
||||
|
||||
The chore system is designed to help users manage tasks, both personal and within groups. It supports recurring chores, assignments, and a detailed history of all changes. This document provides a comprehensive overview of the system's architecture, data models, API endpoints, and frontend implementation.
|
||||
|
||||
## 2. Data Models
|
||||
|
||||
The chore system is built around three core data models: `Chore`, `ChoreAssignment`, and `ChoreHistory`.
|
||||
|
||||
### 2.1. Chore Model
|
||||
|
||||
The `Chore` model represents a task to be completed. It can be a personal chore or a group chore.
|
||||
|
||||
- **`id`**: The unique identifier for the chore.
|
||||
- **`name`**: The name of the chore.
|
||||
- **`description`**: A detailed description of the chore.
|
||||
- **`type`**: The type of chore, either `personal` or `group`.
|
||||
- **`group_id`**: The ID of the group the chore belongs to (if it's a group chore).
|
||||
- **`created_by_id`**: The ID of the user who created the chore.
|
||||
- **`frequency`**: The frequency of the chore, such as `daily`, `weekly`, or `monthly`.
|
||||
- **`custom_interval_days`**: The number of days between occurrences for custom frequency chores.
|
||||
- **`next_due_date`**: The next due date for the chore.
|
||||
- **`last_completed_at`**: The timestamp of when the chore was last completed.
|
||||
|
||||
### 2.2. ChoreAssignment Model
|
||||
|
||||
The `ChoreAssignment` model represents the assignment of a chore to a user.
|
||||
|
||||
- **`id`**: The unique identifier for the assignment.
|
||||
- **`chore_id`**: The ID of the chore being assigned.
|
||||
- **`assigned_to_user_id`**: The ID of the user the chore is assigned to.
|
||||
- **`due_date`**: The due date for the assignment.
|
||||
- **`is_complete`**: A boolean indicating whether the assignment is complete.
|
||||
- **`completed_at`**: The timestamp of when the assignment was completed.
|
||||
|
||||
### 2.3. ChoreHistory Model
|
||||
|
||||
The `ChoreHistory` model tracks all changes to a chore, such as creation, updates, and completion.
|
||||
|
||||
- **`id`**: The unique identifier for the history entry.
|
||||
- **`chore_id`**: The ID of the chore the history entry belongs to.
|
||||
- **`event_type`**: The type of event, such as `created`, `updated`, or `completed`.
|
||||
- **`event_data`**: A JSON object containing details about the event.
|
||||
- **`changed_by_user_id`**: The ID of the user who made the change.
|
||||
|
||||
## 3. API Endpoints
|
||||
|
||||
The chore system exposes a set of API endpoints for managing chores, assignments, and history.
|
||||
|
||||
### 3.1. Chores
|
||||
|
||||
- **`GET /api/v1/chores/all`**: Retrieves all chores for the current user.
|
||||
- **`POST /api/v1/chores/personal`**: Creates a new personal chore.
|
||||
- **`GET /api/v1/chores/personal`**: Retrieves all personal chores for the current user.
|
||||
- **`PUT /api/v1/chores/personal/{chore_id}`**: Updates a personal chore.
|
||||
- **`DELETE /api/v1/chores/personal/{chore_id}`**: Deletes a personal chore.
|
||||
- **`POST /api/v1/chores/groups/{group_id}/chores`**: Creates a new group chore.
|
||||
- **`GET /api/v1/chores/groups/{group_id}/chores`**: Retrieves all chores for a specific group.
|
||||
- **`PUT /api/v1/chores/groups/{group_id}/chores/{chore_id}`**: Updates a group chore.
|
||||
- **`DELETE /api/v1/chores/groups/{group_id}/chores/{chore_id}`**: Deletes a group chore.
|
||||
|
||||
### 3.2. Assignments
|
||||
|
||||
- **`POST /api/v1/chores/assignments`**: Creates a new chore assignment.
|
||||
- **`GET /api/v1/chores/assignments/my`**: Retrieves all chore assignments for the current user.
|
||||
- **`GET /api/v1/chores/chores/{chore_id}/assignments`**: Retrieves all assignments for a specific chore.
|
||||
- **`PUT /api/v1/chores/assignments/{assignment_id}`**: Updates a chore assignment.
|
||||
- **`DELETE /api/v1/chores/assignments/{assignment_id}`**: Deletes a chore assignment.
|
||||
- **`PATCH /api/v1/chores/assignments/{assignment_id}/complete`**: Marks a chore assignment as complete.
|
||||
|
||||
### 3.3. History
|
||||
|
||||
- **`GET /api/v1/chores/{chore_id}/history`**: Retrieves the history for a specific chore.
|
||||
- **`GET /api/v1/chores/assignments/{assignment_id}/history`**: Retrieves the history for a specific chore assignment.
|
||||
|
||||
## 4. Frontend Implementation
|
||||
|
||||
The frontend for the chore system is built using Vue.js and the Composition API. The main component is `ChoresPage.vue`, which is responsible for displaying the list of chores, handling user interactions, and communicating with the backend.
|
||||
|
||||
### 4.1. State Management
|
||||
|
||||
The `ChoresPage.vue` component uses Pinia for state management. The `useChoreStore` manages the state of the chores, including the list of chores, the current chore being edited, and the loading state.
|
||||
|
||||
### 4.2. User Experience
|
||||
|
||||
The user experience is designed to be intuitive and efficient. Users can easily view their chores, mark them as complete, and create new chores. The UI also provides feedback to the user, such as loading indicators and success messages.
|
||||
|
||||
## 5. Reliability and UX Recommendations
|
||||
|
||||
To improve the reliability and user experience of the chore system, the following recommendations are suggested:
|
||||
|
||||
### 5.1. Optimistic UI Updates
|
||||
|
||||
When a user marks a chore as complete, the UI should immediately reflect the change, even before the API call has completed. This will make the UI feel more responsive and reduce perceived latency.
|
||||
|
||||
### 5.2. More Robust Error Handling
|
||||
|
||||
The frontend should provide more specific and helpful error messages to the user. For example, if an API call fails, the UI should display a message that explains what went wrong and what the user can do to fix it.
|
||||
|
||||
### 5.3. Intuitive User Interface
|
||||
|
||||
The user interface could be improved to make it more intuitive and easier to use. For example, the chore creation form could be simplified, and the chore list could be made more scannable.
|
||||
|
||||
### 5.4. Improved Caching
|
||||
|
||||
The frontend should implement a more sophisticated caching strategy to reduce the number of API calls and improve performance. For example, the list of chores could be cached in local storage, and the cache could be invalidated when a new chore is created or an existing chore is updated.
|
||||
@ -1,368 +0,0 @@
|
||||
# Expense System Documentation
|
||||
|
||||
## Overview
|
||||
|
||||
The expense system is a core feature that allows users to track shared expenses, split them among group members, and manage settlements. The system supports various split types and integrates with lists, groups, and items.
|
||||
|
||||
## Core Components
|
||||
|
||||
### 1. Expenses
|
||||
|
||||
An expense represents a shared cost that needs to be split among multiple users.
|
||||
|
||||
#### Key Properties
|
||||
|
||||
- `id`: Unique identifier
|
||||
- `description`: Description of the expense
|
||||
- `total_amount`: Total cost of the expense (Decimal)
|
||||
- `currency`: Currency code (defaults to "USD")
|
||||
- `expense_date`: When the expense occurred
|
||||
- `split_type`: How the expense should be divided
|
||||
- `list_id`: Optional reference to a shopping list
|
||||
- `group_id`: Optional reference to a group
|
||||
- `item_id`: Optional reference to a specific item
|
||||
- `paid_by_user_id`: User who paid for the expense
|
||||
- `created_by_user_id`: User who created the expense record
|
||||
- `version`: For optimistic locking
|
||||
- `overall_settlement_status`: Overall payment status
|
||||
|
||||
#### Status Types
|
||||
|
||||
```typescript
|
||||
enum ExpenseOverallStatusEnum {
|
||||
UNPAID = "unpaid",
|
||||
PARTIALLY_PAID = "partially_paid",
|
||||
PAID = "paid",
|
||||
}
|
||||
```
|
||||
|
||||
### 2. Expense Splits
|
||||
|
||||
Splits represent how an expense is divided among users.
|
||||
|
||||
#### Key Properties
|
||||
|
||||
- `id`: Unique identifier
|
||||
- `expense_id`: Reference to parent expense
|
||||
- `user_id`: User who owes this portion
|
||||
- `owed_amount`: Amount owed by the user
|
||||
- `share_percentage`: Percentage share (for percentage-based splits)
|
||||
- `share_units`: Number of shares (for share-based splits)
|
||||
- `status`: Current payment status
|
||||
- `paid_at`: When the split was paid
|
||||
- `settlement_activities`: List of payment activities
|
||||
|
||||
#### Status Types
|
||||
|
||||
```typescript
|
||||
enum ExpenseSplitStatusEnum {
|
||||
UNPAID = "unpaid",
|
||||
PARTIALLY_PAID = "partially_paid",
|
||||
PAID = "paid",
|
||||
}
|
||||
```
|
||||
|
||||
### 3. Settlement Activities
|
||||
|
||||
Settlement activities track individual payments made towards expense splits.
|
||||
|
||||
#### Key Properties
|
||||
|
||||
- `id`: Unique identifier
|
||||
- `expense_split_id`: Reference to the split being paid
|
||||
- `paid_by_user_id`: User making the payment
|
||||
- `amount_paid`: Amount being paid
|
||||
- `paid_at`: When the payment was made
|
||||
- `created_by_user_id`: User who recorded the payment
|
||||
|
||||
## Split Types
|
||||
|
||||
The system supports multiple ways to split expenses:
|
||||
|
||||
### 1. Equal Split
|
||||
|
||||
- Divides the total amount equally among all participants
|
||||
- Handles rounding differences by adding remainder to first split
|
||||
- No additional data required
|
||||
|
||||
### 2. Exact Amounts
|
||||
|
||||
- Users specify exact amounts for each person
|
||||
- Sum of amounts must equal total expense
|
||||
- Requires `splits_in` data with exact amounts
|
||||
|
||||
### 3. Percentage Based
|
||||
|
||||
- Users specify percentage shares
|
||||
- Percentages must sum to 100%
|
||||
- Requires `splits_in` data with percentages
|
||||
|
||||
### 4. Share Based
|
||||
|
||||
- Users specify number of shares
|
||||
- Amount divided proportionally to shares
|
||||
- Requires `splits_in` data with share units
|
||||
|
||||
### 5. Item Based
|
||||
|
||||
- Splits based on items in a shopping list
|
||||
- Each item's cost is assigned to its adder
|
||||
- Requires `list_id` and optionally `item_id`
|
||||
|
||||
## Integration Points
|
||||
|
||||
### 1. Lists
|
||||
|
||||
- Expenses can be associated with shopping lists
|
||||
- Item-based splits use list items to determine splits
|
||||
- List's group context can determine split participants
|
||||
|
||||
### 2. Groups
|
||||
|
||||
- Expenses can be directly associated with groups
|
||||
- Group membership determines who can be included in splits
|
||||
- Group context is required if no list is specified
|
||||
|
||||
### 3. Items
|
||||
|
||||
- Expenses can be linked to specific items
|
||||
- Item prices are used for item-based splits
|
||||
- Items must belong to a list
|
||||
|
||||
### 4. Users
|
||||
|
||||
- Users can be payers, debtors, or payment recorders
|
||||
- User relationships are tracked in splits and settlements
|
||||
- User context is required for all financial operations
|
||||
|
||||
## Key Operations
|
||||
|
||||
### 1. Creating Expenses
|
||||
|
||||
1. Validate context (list/group)
|
||||
2. Create expense record
|
||||
3. Generate splits based on split type
|
||||
4. Validate total amounts match
|
||||
5. Save all records in transaction
|
||||
|
||||
### 2. Updating Expenses
|
||||
|
||||
- Limited to non-financial fields:
|
||||
- Description
|
||||
- Currency
|
||||
- Expense date
|
||||
- Uses optimistic locking via version field
|
||||
- Cannot modify splits after creation
|
||||
|
||||
### 3. Recording Payments
|
||||
|
||||
1. Create settlement activity
|
||||
2. Update split status
|
||||
3. Recalculate expense overall status
|
||||
4. All operations in single transaction
|
||||
|
||||
### 4. Deleting Expenses
|
||||
|
||||
- Requires version matching
|
||||
- Cascades to splits and settlements
|
||||
- All operations in single transaction
|
||||
|
||||
## Best Practices
|
||||
|
||||
1. **Data Integrity**
|
||||
|
||||
- Always use transactions for multi-step operations
|
||||
- Validate totals match before saving
|
||||
- Use optimistic locking for updates
|
||||
|
||||
2. **Error Handling**
|
||||
|
||||
- Handle database errors appropriately
|
||||
- Validate user permissions
|
||||
- Check for concurrent modifications
|
||||
|
||||
3. **Performance**
|
||||
|
||||
- Use appropriate indexes
|
||||
- Load relationships efficiently
|
||||
- Batch operations when possible
|
||||
|
||||
4. **Security**
|
||||
- Validate user permissions
|
||||
- Sanitize input data
|
||||
- Use proper access controls
|
||||
|
||||
## Common Use Cases
|
||||
|
||||
1. **Group Dinner**
|
||||
|
||||
- Create expense with total amount
|
||||
- Use equal split or exact amounts
|
||||
- Record payments as they occur
|
||||
|
||||
2. **Shopping List**
|
||||
|
||||
- Create item-based expense
|
||||
- System automatically splits based on items
|
||||
- Track payments per person
|
||||
|
||||
3. **Rent Sharing**
|
||||
|
||||
- Create expense with total rent
|
||||
- Use percentage or share-based split
|
||||
- Record monthly payments
|
||||
|
||||
4. **Trip Expenses**
|
||||
- Create multiple expenses
|
||||
- Mix different split types
|
||||
- Track overall balances
|
||||
|
||||
## Recurring Expenses
|
||||
|
||||
Recurring expenses are expenses that repeat at regular intervals. They are useful for regular payments like rent, utilities, or subscription services.
|
||||
|
||||
### Recurrence Types
|
||||
|
||||
1. **Daily**
|
||||
|
||||
- Repeats every X days
|
||||
- Example: Daily parking fee
|
||||
|
||||
2. **Weekly**
|
||||
|
||||
- Repeats every X weeks on specific days
|
||||
- Example: Weekly cleaning service
|
||||
|
||||
3. **Monthly**
|
||||
|
||||
- Repeats every X months on the same date
|
||||
- Example: Monthly rent payment
|
||||
|
||||
4. **Yearly**
|
||||
- Repeats every X years on the same date
|
||||
- Example: Annual insurance premium
|
||||
|
||||
### Implementation Details
|
||||
|
||||
1. **Recurrence Pattern**
|
||||
|
||||
```typescript
|
||||
interface RecurrencePattern {
|
||||
type: "daily" | "weekly" | "monthly" | "yearly";
|
||||
interval: number; // Every X days/weeks/months/years
|
||||
daysOfWeek?: number[]; // For weekly recurrence (0-6, Sunday-Saturday)
|
||||
endDate?: string; // Optional end date for the recurrence
|
||||
maxOccurrences?: number; // Optional maximum number of occurrences
|
||||
}
|
||||
```
|
||||
|
||||
2. **Recurring Expense Properties**
|
||||
|
||||
- All standard expense properties
|
||||
- `recurrence_pattern`: Defines how the expense repeats
|
||||
- `next_occurrence`: When the next expense will be created
|
||||
- `last_occurrence`: When the last expense was created
|
||||
- `is_recurring`: Boolean flag to identify recurring expenses
|
||||
|
||||
3. **Generation Process**
|
||||
|
||||
- System automatically creates new expenses based on the pattern
|
||||
- Each generated expense is a regular expense with its own splits
|
||||
- Original recurring expense serves as a template
|
||||
- Generated expenses can be modified individually
|
||||
|
||||
4. **Management Features**
|
||||
- Pause/resume recurrence
|
||||
- Modify future occurrences
|
||||
- Skip specific occurrences
|
||||
- End recurrence early
|
||||
- View all generated expenses
|
||||
|
||||
### Best Practices for Recurring Expenses
|
||||
|
||||
1. **Data Management**
|
||||
|
||||
- Keep original recurring expense as template
|
||||
- Generate new expenses in advance
|
||||
- Clean up old generated expenses periodically
|
||||
|
||||
2. **User Experience**
|
||||
|
||||
- Clear indication of recurring expenses
|
||||
- Easy way to modify future occurrences
|
||||
- Option to handle exceptions
|
||||
|
||||
3. **Performance**
|
||||
- Batch process expense generation
|
||||
- Index recurring expense queries
|
||||
- Cache frequently accessed patterns
|
||||
|
||||
### Example Use Cases
|
||||
|
||||
1. **Monthly Rent**
|
||||
|
||||
```json
|
||||
{
|
||||
"description": "Monthly Rent",
|
||||
"total_amount": "2000.00",
|
||||
"split_type": "PERCENTAGE",
|
||||
"recurrence_pattern": {
|
||||
"type": "monthly",
|
||||
"interval": 1,
|
||||
"endDate": "2024-12-31"
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
2. **Weekly Cleaning Service**
|
||||
```json
|
||||
{
|
||||
"description": "Weekly Cleaning",
|
||||
"total_amount": "150.00",
|
||||
"split_type": "EQUAL",
|
||||
"recurrence_pattern": {
|
||||
"type": "weekly",
|
||||
"interval": 1,
|
||||
"daysOfWeek": [1] // Every Monday
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## API Considerations
|
||||
|
||||
1. **Decimal Handling**
|
||||
|
||||
- Use string representation for decimals in API
|
||||
- Convert to Decimal for calculations
|
||||
- Round to 2 decimal places for money
|
||||
|
||||
2. **Date Handling**
|
||||
|
||||
- Use ISO format for dates
|
||||
- Store in UTC
|
||||
- Convert to local time for display
|
||||
|
||||
3. **Status Updates**
|
||||
- Update split status on payment
|
||||
- Recalculate overall status
|
||||
- Notify relevant users
|
||||
|
||||
## Future Considerations
|
||||
|
||||
1. **Potential Enhancements**
|
||||
|
||||
- Recurring expenses
|
||||
- Bulk operations
|
||||
- Advanced reporting
|
||||
- Currency conversion
|
||||
|
||||
2. **Scalability**
|
||||
|
||||
- Handle large groups
|
||||
- Optimize for frequent updates
|
||||
- Consider caching strategies
|
||||
|
||||
3. **Integration**
|
||||
- Payment providers
|
||||
- Accounting systems
|
||||
- Export capabilities
|
||||
270
docs/financial-system-overview.md
Normal file
270
docs/financial-system-overview.md
Normal file
@ -0,0 +1,270 @@
|
||||
# Financial System Overview
|
||||
|
||||
## Introduction
|
||||
|
||||
This document provides a comprehensive overview of the **Expense, Cost & Financial** domain of the project. It is intended for backend / frontend developers, QA engineers and DevOps personnel who need to understand **how money flows through the system**, what invariants are enforced and where to extend the platform.
|
||||
|
||||
> **TL;DR** The financial subsystem is a *Split-wise*-inspired engine with first-class support for: shared lists, item-derived expenses, multi-scheme splitting, settlements, recurring charges and complete auditability.
|
||||
|
||||
---
|
||||
|
||||
## Main Concepts & Entities
|
||||
|
||||
| Entity | Purpose | Key Relationships |
|
||||
|--------|---------|-------------------|
|
||||
| **User** | A registered account. Owns expenses, owes splits, records settlements. | `expenses_paid`, `expenses_created`, `expense_splits`, `settlements_made/received`, `settlements_created` |
|
||||
| **Group** | A collection of users with shared expenses / lists. | `member_associations (UserGroup)`, `lists`, `expenses`, `settlements` |
|
||||
| **List** | A shopping / to-do list. May belong to a `Group` or be personal. | `items`, `expenses` |
|
||||
| **Item** | A purchasable line inside a `List`. Price & author drive *item-based* expense splits. | `list`, `added_by_user` |
|
||||
| **Expense** | A monetary outflow. | `splits`, `list`, `group`, `item`, `recurrence_pattern` |
|
||||
| **ExpenseSplit** | A *who-owes-what* record for an `Expense`. | `user`, `settlement_activities` |
|
||||
| **Settlement** | A generic *cash transfer* between two users inside a group. | – |
|
||||
| **SettlementActivity** | A *payment* that reduces an individual `ExpenseSplit` (e.g. Alice pays Bob her part). | – |
|
||||
| **RecurrencePattern** | The schedule template that spawns future `Expense` occurrences. | `expenses` |
|
||||
| **FinancialAuditLog** | Append-only journal of *who did what* (create / update / delete) for all financial entities. | – |
|
||||
|
||||
---
|
||||
|
||||
## Expense Lifecyle
|
||||
|
||||
1. **Creation** (`POST /financials/expenses`)
|
||||
• Caller provides an `ExpenseCreate` DTO.<br />
|
||||
• Backend validates the *context* (list / group / item), the *payer*, and the chosen **split strategy**.
|
||||
• Supported `split_type` values (`SplitTypeEnum`):
|
||||
* `EQUAL` – evenly divided among computed participants.
|
||||
* `EXACT_AMOUNTS` – caller supplies absolute owed amounts.
|
||||
* `PERCENTAGE` – caller supplies percentages totalling 100 %.
|
||||
* `SHARES` – integer share units (e.g. 1 : 2 : 3).
|
||||
* `ITEM_BASED` – derived from priced `Item`s in a list.
|
||||
• A database transaction writes `Expense` + `ExpenseSplit` rows and a `FinancialAuditLog` entry.
|
||||
|
||||
2. **Reading**
|
||||
• `GET /financials/expenses/{id}` enforces *row-level* security: the requester must be payer, list member or group member.
|
||||
|
||||
3. **Update / Delete**
|
||||
• Optimistic-locking via the `version` field.
|
||||
• Only the **payer** or a **group owner** may mutate records.
|
||||
|
||||
4. **Settlement**
|
||||
• Generic settlements (`/financials/settlements`) clear balances between two users.<br />
|
||||
• Fine-grained settlements (`/financials/expense_splits/{id}/settle`) clear a single `ExpenseSplit`.
|
||||
|
||||
5. **Recurring Expenses**
|
||||
• An `Expense` can be flagged `is_recurring = true` and carry a `RecurrencePattern`.<br />
|
||||
• A background job (`app/jobs/recurring_expenses.py::generate_recurring_expenses`) wakes up daily and:
|
||||
1. Finds template expenses due (`next_occurrence <= now`).
|
||||
2. Spawns a *child* expense replicating the split logic.
|
||||
3. Updates `last_occurrence`, decrements `max_occurrences` and calculates the next date.
|
||||
|
||||
---
|
||||
|
||||
## Cost Summaries & Balance Sheets
|
||||
|
||||
### List Cost Summary
|
||||
Endpoint: `GET /costs/lists/{list_id}/cost-summary`
|
||||
|
||||
• If an `ITEM_BASED` expense already exists → returns a snapshot derived from the **expense**.<br />
|
||||
• Otherwise → computes an *on-the-fly* summary using `Item.price` values (read-only).
|
||||
|
||||
Key Figures:
|
||||
* `total_list_cost` – sum of item prices.
|
||||
* `equal_share_per_user` – what each participant *should* pay.
|
||||
* `balance` – (over / under) contribution for each user.
|
||||
|
||||
*Action:* `POST /costs/lists/{id}/cost-summary` finalises the list by persisting the derived `ITEM_BASED` expense.
|
||||
|
||||
### Group Balance Summary
|
||||
Endpoint: `GET /costs/groups/{group_id}/balance-summary`
|
||||
|
||||
Aggregates across **all** group expenses + settlements:
|
||||
* What each user paid (expenses + received settlements)
|
||||
* What each user owed
|
||||
* Suggested minimal settlement graph (creditors vs debtors)
|
||||
|
||||
---
|
||||
|
||||
## Data-Integrity Rules & Guards
|
||||
|
||||
1. `Expense` **must** reference *either* `list_id` **or** `group_id` (DB-level CHECK).
|
||||
2. Row uniqueness guards: `UniqueConstraint('expense_id', 'user_id')` on `ExpenseSplit`.
|
||||
3. `Settlement` payer ≠ payee (DB CHECK).
|
||||
4. All mutating endpoints perform **authorization** checks via `crud_group` / `crud_list` helpers.
|
||||
5. Monetary amounts are stored as `Numeric(10,2)` and rounded (`ROUND_HALF_UP`).
|
||||
|
||||
---
|
||||
|
||||
## Recent Fixes & Improvements (June 2025)
|
||||
|
||||
| Area | Issue | Resolution |
|
||||
|------|-------|------------|
|
||||
| **Recurring filter** | `GET /financials/expenses?isRecurring=true` referenced nonexistent `recurrence_rule`. | Switched to `is_recurring` flag. |
|
||||
| **Enum mismatches** | `RecurrencePattern.type` stored uppercase enum, while API took lowercase strings. | Robust mapper converts strings → `RecurrenceTypeEnum`; scheduler is now case-insensitive. |
|
||||
| **Scheduler** | `_calculate_next_occurrence` failed with Enum values & stringified `days_of_week`. | Added polymorphic handling + safe parsing of comma-separated strings. |
|
||||
|
||||
*All tests pass (`pytest -q`) and new unit tests cover the edge-cases above.*
|
||||
|
||||
---
|
||||
|
||||
## Extension Points
|
||||
|
||||
* **VAT / Tax logic** – attach a `tax_rate` column to `Expense` and resolve net vs gross amounts.
|
||||
* **Multi-currency** – normalize amounts to a base currency using FX rates; expose a `Currency` table.
|
||||
* **Budgeting / Limits** – per-group or per-list spending caps with alerting.
|
||||
* **Webhook notifications** – publish `FinancialAuditLog` entries to external services.
|
||||
|
||||
---
|
||||
|
||||
## Appendix – Key SQL Schema Snapshots
|
||||
|
||||
```sql
|
||||
-- Expense table (excerpt)
|
||||
CREATE TABLE expenses (
|
||||
id SERIAL PRIMARY KEY,
|
||||
total_amount NUMERIC(10,2) NOT NULL,
|
||||
split_type VARCHAR(20) NOT NULL,
|
||||
list_id INT NULL,
|
||||
group_id INT NULL,
|
||||
-- …
|
||||
CHECK (group_id IS NOT NULL OR list_id IS NOT NULL)
|
||||
);
|
||||
|
||||
CREATE UNIQUE INDEX uq_expense_user_split ON expense_splits(expense_id, user_id);
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## System Reliability Analysis & Improvements
|
||||
|
||||
### ✅ Implemented Reliability Features
|
||||
|
||||
#### 1. **Transaction Safety**
|
||||
- All financial operations use **transactional sessions** (`get_transactional_session`)
|
||||
- Atomic operations ensure data consistency across expense creation, splits, and settlements
|
||||
- Row-level locking (`WITH FOR UPDATE`) prevents race conditions in settlement activities
|
||||
|
||||
#### 2. **Overpayment Protection**
|
||||
- **NEW**: Settlement activities now validate against remaining owed amount
|
||||
- Prevents payments that exceed the split's owed amount
|
||||
- Provides clear error messages with remaining balance information
|
||||
- Handles multiple partial payments correctly
|
||||
|
||||
#### 3. **Data Validation & Constraints**
|
||||
- **Decimal precision**: All monetary amounts use `Numeric(10,2)` with proper rounding
|
||||
- **Positive amount validation**: Prevents negative payments and settlements
|
||||
- **User existence validation**: Ensures all referenced users exist before operations
|
||||
- **Split consistency**: Validates split totals match expense amounts (EXACT_AMOUNTS, PERCENTAGE)
|
||||
|
||||
#### 4. **Permission & Authorization**
|
||||
- Multi-layered permission checks for expense creation and settlement recording
|
||||
- Group owners can act on behalf of members with proper validation
|
||||
- List/group access controls prevent unauthorized financial operations
|
||||
|
||||
#### 5. **Status Management**
|
||||
- Automatic status updates for expense splits (unpaid → partially_paid → paid)
|
||||
- Cascading status updates for parent expenses based on split states
|
||||
- Pessimistic locking ensures consistent status transitions
|
||||
|
||||
#### 6. **Audit Trail**
|
||||
- All financial operations logged via `create_financial_audit_log`
|
||||
- Complete traceability of who created/modified financial records
|
||||
- Immutable settlement activity records (no updates, only creation)
|
||||
|
||||
#### 7. **Error Handling**
|
||||
- Comprehensive exception hierarchy for different error types
|
||||
- Specific `OverpaymentError` for payment validation failures
|
||||
- Database integrity and connection error handling
|
||||
- Graceful degradation with meaningful error messages
|
||||
|
||||
### 🔍 Potential Areas for Enhancement
|
||||
|
||||
#### 1. **Optimistic Locking for Expenses**
|
||||
Currently, expenses use basic versioning but could benefit from full optimistic locking:
|
||||
```python
|
||||
# Consider adding to ExpenseUpdate operations
|
||||
if expected_version != current_expense.version:
|
||||
raise ConflictError("Expense was modified by another user")
|
||||
```
|
||||
|
||||
#### 2. **Recurring Expense Reliability**
|
||||
- Add retry logic for failed recurring expense generation
|
||||
- Implement dead letter queue for failed recurring operations
|
||||
- Add monitoring for recurring expense job health
|
||||
|
||||
#### 3. **Currency Consistency**
|
||||
While currency is stored, there's no validation that all splits in an expense use the same currency:
|
||||
```python
|
||||
# Potential enhancement
|
||||
if expense.currency != "USD" and any(split.currency != expense.currency for split in splits):
|
||||
raise InvalidOperationError("All splits must use the same currency as the parent expense")
|
||||
```
|
||||
|
||||
#### 4. **Settlement Verification**
|
||||
Consider adding verification flags for settlements to distinguish between:
|
||||
- Automatic settlements (from expense splits)
|
||||
- Manual settlements (direct user payments)
|
||||
- Disputed settlements requiring verification
|
||||
|
||||
### 📊 System Health Metrics
|
||||
|
||||
The system provides comprehensive financial tracking through:
|
||||
|
||||
1. **Real-time balance calculations** via `costs_service.py`
|
||||
2. **Settlement suggestions** using optimal debt reduction algorithms
|
||||
3. **Expense categorization and filtering** with proper indexing
|
||||
4. **Multi-context support** (lists, groups, personal expenses)
|
||||
|
||||
### 🛡️ Security Considerations
|
||||
|
||||
- **Input sanitization**: All financial inputs validated through Pydantic schemas
|
||||
- **Authorization layers**: Multiple permission checks prevent unauthorized access
|
||||
- **Audit logging**: Complete financial operation history for compliance
|
||||
- **Data isolation**: Users only see expenses/settlements they have permission to access
|
||||
|
||||
### 🚀 Performance Optimizations
|
||||
|
||||
- **Database indexing** on critical foreign keys and search fields
|
||||
- **Eager loading** with `selectinload` to prevent N+1 queries
|
||||
- **Pagination** for large result sets
|
||||
- **Connection pooling** with health checks (`pool_pre_ping=True`)
|
||||
|
||||
---
|
||||
|
||||
## Testing & Quality Assurance
|
||||
|
||||
The financial system includes comprehensive test coverage:
|
||||
|
||||
1. **Unit tests** for CRUD operations and business logic
|
||||
2. **Integration tests** for API endpoints and workflows
|
||||
3. **Edge case testing** for overpayment protection and boundary conditions
|
||||
4. **Concurrency tests** for settlement race conditions
|
||||
5. **Data consistency tests** for split calculations and status updates
|
||||
|
||||
Example test scenarios:
|
||||
- Multiple users settling the same split simultaneously
|
||||
- Expense split totals validation across different split types
|
||||
- Currency precision and rounding accuracy
|
||||
- Permission boundary testing for cross-user operations
|
||||
|
||||
---
|
||||
|
||||
## Deployment & Monitoring Recommendations
|
||||
|
||||
### Database Considerations
|
||||
- Regular backup strategy for financial data
|
||||
- Monitor transaction isolation levels and deadlocks
|
||||
- Set up alerts for unusual financial activity patterns
|
||||
- Implement database connection monitoring
|
||||
|
||||
### Application Monitoring
|
||||
- Track settlement activity creation rates and failures
|
||||
- Monitor recurring expense job execution and errors
|
||||
- Set up alerts for permission denial patterns
|
||||
- Track API response times for financial endpoints
|
||||
|
||||
### Business Intelligence
|
||||
- Daily/weekly financial summaries per group
|
||||
- Settlement velocity tracking (time to pay debts)
|
||||
- Expense categorization analytics
|
||||
- User engagement with financial features
|
||||
|
||||
The financial system is now **production-ready** with robust reliability safeguards, comprehensive error handling, and strong data consistency guarantees.
|
||||
@ -15,6 +15,8 @@
|
||||
class="badge badge-overdue">Overdue</span>
|
||||
<span v-if="getDueDateStatus(chore) === 'due-today'" class="badge badge-due-today">Due
|
||||
Today</span>
|
||||
<span v-if="getDueDateStatus(chore) === 'upcoming'" class="badge badge-upcoming">{{
|
||||
dueInText }}</span>
|
||||
</div>
|
||||
</div>
|
||||
<div v-if="chore.description" class="chore-description">{{ chore.description }}</div>
|
||||
@ -55,6 +57,7 @@
|
||||
|
||||
<script setup lang="ts">
|
||||
import { defineProps, defineEmits, computed } from 'vue';
|
||||
import { formatDistanceToNow, parseISO, isToday, isPast } from 'date-fns';
|
||||
import type { ChoreWithCompletion } from '../types/chore';
|
||||
import type { TimeEntry } from '../stores/timeEntryStore';
|
||||
import { formatDuration } from '../utils/formatters';
|
||||
@ -83,6 +86,13 @@ const totalTime = computed(() => {
|
||||
return props.timeEntries.reduce((acc, entry) => acc + (entry.duration_seconds || 0), 0);
|
||||
});
|
||||
|
||||
const dueInText = computed(() => {
|
||||
if (!props.chore.next_due_date) return '';
|
||||
const dueDate = new Date(props.chore.next_due_date);
|
||||
if (isToday(dueDate)) return 'Today';
|
||||
return formatDistanceToNow(dueDate, { addSuffix: true });
|
||||
});
|
||||
|
||||
const toggleTimer = () => {
|
||||
if (isActiveTimer.value) {
|
||||
emit('stop-timer', props.chore, props.activeTimer!.id);
|
||||
@ -326,6 +336,11 @@ export default {
|
||||
color: white;
|
||||
}
|
||||
|
||||
.badge-upcoming {
|
||||
background-color: #3b82f6;
|
||||
color: white;
|
||||
}
|
||||
|
||||
.chore-description {
|
||||
font-size: 0.875rem;
|
||||
color: var(--dark);
|
||||
|
||||
@ -131,11 +131,29 @@ export const API_ENDPOINTS = {
|
||||
},
|
||||
|
||||
CHORES: {
|
||||
// Generic
|
||||
ALL: '/chores/all',
|
||||
BASE: '/chores',
|
||||
BY_ID: (id: number) => `/chores/${id}`,
|
||||
UPDATE_ANY_TYPE: (id: number) => `/chores/${id}`,
|
||||
HISTORY: (id: number) => `/chores/${id}/history`,
|
||||
ASSIGNMENTS: (choreId: number) => `/chores/${choreId}/assignments`,
|
||||
|
||||
// Personal chore shortcuts
|
||||
PERSONAL: '/chores/personal',
|
||||
PERSONAL_BY_ID: (id: number) => `/chores/personal/${id}`,
|
||||
|
||||
// Group chore shortcuts
|
||||
GROUP_CHORES: (groupId: number) => `/chores/groups/${groupId}/chores`,
|
||||
GROUP_CHORE_BY_ID: (groupId: number, choreId: number) => `/chores/groups/${groupId}/chores/${choreId}`,
|
||||
|
||||
// Assignment centric paths
|
||||
ASSIGNMENTS_BASE: '/chores/assignments',
|
||||
ASSIGNMENT_BY_ID: (id: number) => `/chores/assignments/${id}`,
|
||||
MY_ASSIGNMENTS: (includeCompleted: boolean) => `/chores/assignments/my?include_completed=${includeCompleted}`,
|
||||
ASSIGNMENT_COMPLETE: (id: number) => `/chores/assignments/${id}/complete`,
|
||||
|
||||
// Time tracking
|
||||
TIME_ENTRIES: (assignmentId: number) => `/chores/assignments/${assignmentId}/time-entries`,
|
||||
TIME_ENTRY: (id: number) => `/chores/time-entries/${id}`,
|
||||
},
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
<script setup lang="ts">
|
||||
import { ref, onMounted, computed } from 'vue'
|
||||
import { ref, onMounted, computed, watch } from 'vue'
|
||||
import { useI18n } from 'vue-i18n'
|
||||
import { format, startOfDay, isEqual, isToday as isTodayDate, formatDistanceToNow, parseISO } from 'date-fns'
|
||||
import { choreService } from '../services/choreService'
|
||||
@ -129,6 +129,13 @@ const loadTimeEntries = async () => {
|
||||
});
|
||||
};
|
||||
|
||||
// Watch for type changes to clear group_id when switching to personal
|
||||
watch(() => choreForm.value.type, (newType) => {
|
||||
if (newType === 'personal') {
|
||||
choreForm.value.group_id = undefined
|
||||
}
|
||||
})
|
||||
|
||||
onMounted(() => {
|
||||
loadChores().then(loadTimeEntries);
|
||||
loadGroups()
|
||||
@ -302,10 +309,18 @@ const handleFormSubmit = async () => {
|
||||
let createdChore;
|
||||
if (isEditing.value && selectedChore.value) {
|
||||
const updateData: ChoreUpdate = { ...choreForm.value };
|
||||
createdChore = await choreService.updateChore(selectedChore.value.id, updateData);
|
||||
// Ensure group_id is properly set based on type
|
||||
if (updateData.type === 'personal') {
|
||||
updateData.group_id = undefined;
|
||||
}
|
||||
createdChore = await choreService.updateChore(selectedChore.value.id, updateData, selectedChore.value);
|
||||
notificationStore.addNotification({ message: t('choresPage.notifications.updateSuccess', 'Chore updated successfully!'), type: 'success' });
|
||||
} else {
|
||||
const createData = { ...choreForm.value };
|
||||
// Ensure group_id is properly set based on type
|
||||
if (createData.type === 'personal') {
|
||||
createData.group_id = undefined;
|
||||
}
|
||||
createdChore = await choreService.createChore(createData as ChoreCreate);
|
||||
|
||||
// Create an assignment for the new chore
|
||||
@ -564,7 +579,7 @@ const stopTimer = async (chore: ChoreWithCompletion, timeEntryId: number) => {
|
||||
</div>
|
||||
<div v-if="choreForm.frequency === 'custom'" class="form-group">
|
||||
<label class="form-label" for="chore-interval">{{ t('choresPage.form.interval', 'Interval (days)')
|
||||
}}</label>
|
||||
}}</label>
|
||||
<input id="chore-interval" type="number" v-model.number="choreForm.custom_interval_days"
|
||||
class="form-input" :placeholder="t('choresPage.form.intervalPlaceholder')" min="1">
|
||||
</div>
|
||||
@ -585,14 +600,14 @@ const stopTimer = async (chore: ChoreWithCompletion, timeEntryId: number) => {
|
||||
</div>
|
||||
<div v-if="choreForm.type === 'group'" class="form-group">
|
||||
<label class="form-label" for="chore-group">{{ t('choresPage.form.assignGroup', 'Assign to Group')
|
||||
}}</label>
|
||||
}}</label>
|
||||
<select id="chore-group" v-model="choreForm.group_id" class="form-input">
|
||||
<option v-for="group in groups" :key="group.id" :value="group.id">{{ group.name }}</option>
|
||||
</select>
|
||||
</div>
|
||||
<div class="form-group">
|
||||
<label class="form-label" for="parent-chore">{{ t('choresPage.form.parentChore', 'Parent Chore')
|
||||
}}</label>
|
||||
}}</label>
|
||||
<select id="parent-chore" v-model="choreForm.parent_chore_id" class="form-input">
|
||||
<option :value="null">None</option>
|
||||
<option v-for="parent in availableParentChores" :key="parent.id" :value="parent.id">
|
||||
@ -604,7 +619,7 @@ const stopTimer = async (chore: ChoreWithCompletion, timeEntryId: number) => {
|
||||
<div class="modal-footer">
|
||||
<button type="button" class="btn btn-neutral" @click="showChoreModal = false">{{
|
||||
t('choresPage.form.cancel', 'Cancel')
|
||||
}}</button>
|
||||
}}</button>
|
||||
<button type="submit" class="btn btn-primary">{{ isEditing ? t('choresPage.form.save', 'Save Changes') :
|
||||
t('choresPage.form.create', 'Create') }}</button>
|
||||
</div>
|
||||
@ -629,7 +644,7 @@ const stopTimer = async (chore: ChoreWithCompletion, timeEntryId: number) => {
|
||||
t('choresPage.deleteConfirm.cancel', 'Cancel') }}</button>
|
||||
<button type="button" class="btn btn-danger" @click="deleteChore">{{
|
||||
t('choresPage.deleteConfirm.delete', 'Delete')
|
||||
}}</button>
|
||||
}}</button>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
@ -654,7 +669,7 @@ const stopTimer = async (chore: ChoreWithCompletion, timeEntryId: number) => {
|
||||
<div class="detail-item">
|
||||
<span class="label">Created by:</span>
|
||||
<span class="value">{{ selectedChore.creator?.name || selectedChore.creator?.email || 'Unknown'
|
||||
}}</span>
|
||||
}}</span>
|
||||
</div>
|
||||
<div class="detail-item">
|
||||
<span class="label">Due date:</span>
|
||||
@ -686,7 +701,7 @@ const stopTimer = async (chore: ChoreWithCompletion, timeEntryId: number) => {
|
||||
<div v-for="assignment in selectedChoreAssignments" :key="assignment.id" class="assignment-item">
|
||||
<div class="assignment-main">
|
||||
<span class="assigned-user">{{ assignment.assigned_user?.name || assignment.assigned_user?.email
|
||||
}}</span>
|
||||
}}</span>
|
||||
<span class="assignment-status" :class="{ completed: assignment.is_complete }">
|
||||
{{ assignment.is_complete ? '✅ Completed' : '⏳ Pending' }}
|
||||
</span>
|
||||
|
||||
@ -1,8 +1,12 @@
|
||||
import { choreService } from '../choreService'; // Adjust path
|
||||
import { api } from '../api'; // Actual axios instance from api.ts
|
||||
/// <reference types="vitest" />
|
||||
// @ts-nocheck
|
||||
import { choreService } from '../choreService';
|
||||
import { api } from '../api';
|
||||
import { groupService } from '../groupService';
|
||||
import type { Chore, ChoreCreate, ChoreUpdate, ChoreType } from '../../types/chore'; // Adjust path
|
||||
import type { Group } from '../groupService';
|
||||
import { API_ENDPOINTS } from '@/services/api';
|
||||
import type { Chore, ChoreCreate, ChoreUpdate, ChoreType } from '@/types/chore';
|
||||
import type { Group } from '@/types/group';
|
||||
import { describe, it, expect, beforeEach, vi } from 'vitest';
|
||||
|
||||
// Mock the api module (axios instance)
|
||||
vi.mock('../api', () => ({
|
||||
@ -36,7 +40,7 @@ describe('Chore Service', () => {
|
||||
it('should fetch personal chores successfully', async () => {
|
||||
mockApi.get.mockResolvedValue({ data: [mockPersonalChore] });
|
||||
const chores = await choreService.getPersonalChores();
|
||||
expect(mockApi.get).toHaveBeenCalledWith('/api/v1/chores/personal');
|
||||
expect(mockApi.get).toHaveBeenCalledWith(API_ENDPOINTS.CHORES.PERSONAL);
|
||||
expect(chores).toEqual([mockPersonalChore]);
|
||||
});
|
||||
|
||||
@ -52,7 +56,7 @@ describe('Chore Service', () => {
|
||||
it('should fetch chores for a specific group successfully', async () => {
|
||||
mockApi.get.mockResolvedValue({ data: [mockGroupChore] });
|
||||
const chores = await choreService.getChores(groupId);
|
||||
expect(mockApi.get).toHaveBeenCalledWith(`/api/v1/chores/groups/${groupId}/chores`);
|
||||
expect(mockApi.get).toHaveBeenCalledWith(API_ENDPOINTS.CHORES.GROUP_CHORES(groupId));
|
||||
expect(chores).toEqual([mockGroupChore]);
|
||||
});
|
||||
|
||||
@ -70,7 +74,7 @@ describe('Chore Service', () => {
|
||||
mockApi.post.mockResolvedValue({ data: createdChore });
|
||||
|
||||
const result = await choreService.createChore(newPersonalChore);
|
||||
expect(mockApi.post).toHaveBeenCalledWith('/api/v1/chores/personal', newPersonalChore);
|
||||
expect(mockApi.post).toHaveBeenCalledWith(API_ENDPOINTS.CHORES.PERSONAL, newPersonalChore);
|
||||
expect(result).toEqual(createdChore);
|
||||
});
|
||||
|
||||
@ -80,7 +84,7 @@ describe('Chore Service', () => {
|
||||
mockApi.post.mockResolvedValue({ data: createdChore });
|
||||
|
||||
const result = await choreService.createChore(newGroupChore);
|
||||
expect(mockApi.post).toHaveBeenCalledWith(`/api/v1/chores/groups/${newGroupChore.group_id}/chores`, newGroupChore);
|
||||
expect(mockApi.post).toHaveBeenCalledWith(API_ENDPOINTS.CHORES.GROUP_CHORES(newGroupChore.group_id), newGroupChore);
|
||||
expect(result).toEqual(createdChore);
|
||||
});
|
||||
|
||||
@ -109,28 +113,51 @@ describe('Chore Service', () => {
|
||||
mockApi.put.mockResolvedValue({ data: responseChore });
|
||||
|
||||
const result = await choreService.updateChore(choreId, updatedPersonalChoreData);
|
||||
expect(mockApi.put).toHaveBeenCalledWith(`/api/v1/chores/personal/${choreId}`, updatedPersonalChoreData);
|
||||
expect(mockApi.put).toHaveBeenCalledWith(API_ENDPOINTS.CHORES.PERSONAL_BY_ID(choreId), updatedPersonalChoreData);
|
||||
expect(result).toEqual(responseChore);
|
||||
});
|
||||
|
||||
it('should update a group chore', async () => {
|
||||
const updatedGroupChoreData: ChoreUpdate = { name: 'Updated Group', type: 'group', group_id: 10, description: 'new desc' };
|
||||
const originalChore: Chore = { id: choreId, type: 'group', group_id: 10, name: 'Original', created_by_id: 1, next_due_date: '2024-01-01', frequency: 'daily' } as Chore;
|
||||
const responseChore = { ...updatedGroupChoreData, id: choreId };
|
||||
mockApi.put.mockResolvedValue({ data: responseChore });
|
||||
|
||||
const result = await choreService.updateChore(choreId, updatedGroupChoreData);
|
||||
expect(mockApi.put).toHaveBeenCalledWith(`/api/v1/chores/groups/${updatedGroupChoreData.group_id}/chores/${choreId}`, updatedGroupChoreData);
|
||||
const result = await choreService.updateChore(choreId, updatedGroupChoreData, originalChore);
|
||||
expect(mockApi.put).toHaveBeenCalledWith(API_ENDPOINTS.CHORES.GROUP_CHORE_BY_ID(updatedGroupChoreData.group_id, choreId), updatedGroupChoreData);
|
||||
expect(result).toEqual(responseChore);
|
||||
});
|
||||
|
||||
it('should use general endpoint for type conversion from personal to group', async () => {
|
||||
const conversionData: ChoreUpdate = { name: 'Converted to Group', type: 'group', group_id: 10 };
|
||||
const originalChore: Chore = { id: choreId, type: 'personal', name: 'Original Personal', created_by_id: 1, next_due_date: '2024-01-01', frequency: 'daily' } as Chore;
|
||||
const responseChore = { ...conversionData, id: choreId };
|
||||
mockApi.put.mockResolvedValue({ data: responseChore });
|
||||
|
||||
const result = await choreService.updateChore(choreId, conversionData, originalChore);
|
||||
expect(mockApi.put).toHaveBeenCalledWith(API_ENDPOINTS.CHORES.UPDATE_ANY_TYPE(choreId), conversionData);
|
||||
expect(result).toEqual(responseChore);
|
||||
});
|
||||
|
||||
it('should use general endpoint for type conversion from group to personal', async () => {
|
||||
const conversionData: ChoreUpdate = { name: 'Converted to Personal', type: 'personal' };
|
||||
const originalChore: Chore = { id: choreId, type: 'group', group_id: 10, name: 'Original Group', created_by_id: 1, next_due_date: '2024-01-01', frequency: 'daily' } as Chore;
|
||||
const responseChore = { ...conversionData, id: choreId };
|
||||
mockApi.put.mockResolvedValue({ data: responseChore });
|
||||
|
||||
const result = await choreService.updateChore(choreId, conversionData, originalChore);
|
||||
expect(mockApi.put).toHaveBeenCalledWith(API_ENDPOINTS.CHORES.UPDATE_ANY_TYPE(choreId), conversionData);
|
||||
expect(result).toEqual(responseChore);
|
||||
});
|
||||
|
||||
it('should throw error for invalid type or missing group_id for group chore update', async () => {
|
||||
// @ts-expect-error testing invalid type
|
||||
const invalidTypeUpdate: ChoreUpdate = { name: 'Invalid', type: 'unknown' };
|
||||
await expect(choreService.updateChore(choreId, invalidTypeUpdate)).rejects.toThrow('Invalid chore type or missing group_id for group chore update');
|
||||
// @ts-expect-error testing invalid type
|
||||
const invalidTypeUpdate: ChoreUpdate = { name: 'Invalid', type: 'unknown' };
|
||||
await expect(choreService.updateChore(choreId, invalidTypeUpdate)).rejects.toThrow('Invalid chore type for chore update');
|
||||
|
||||
const missingGroupIdUpdate: ChoreUpdate = { name: 'Missing GroupId', type: 'group' };
|
||||
await expect(choreService.updateChore(choreId, missingGroupIdUpdate)).rejects.toThrow('Invalid chore type or missing group_id for group chore update');
|
||||
});
|
||||
const missingGroupIdUpdate: ChoreUpdate = { name: 'Missing GroupId', type: 'group' };
|
||||
await expect(choreService.updateChore(choreId, missingGroupIdUpdate)).rejects.toThrow('Missing group_id for group chore update');
|
||||
});
|
||||
|
||||
it('should propagate API error on failure', async () => {
|
||||
const updatedChoreData: ChoreUpdate = { name: 'Test Update', type: 'personal' };
|
||||
@ -145,22 +172,22 @@ describe('Chore Service', () => {
|
||||
it('should delete a personal chore', async () => {
|
||||
mockApi.delete.mockResolvedValue({ data: null }); // delete often returns no content
|
||||
await choreService.deleteChore(choreId, 'personal');
|
||||
expect(mockApi.delete).toHaveBeenCalledWith(`/api/v1/chores/personal/${choreId}`);
|
||||
expect(mockApi.delete).toHaveBeenCalledWith(API_ENDPOINTS.CHORES.PERSONAL_BY_ID(choreId));
|
||||
});
|
||||
|
||||
it('should delete a group chore', async () => {
|
||||
const groupId = 10;
|
||||
mockApi.delete.mockResolvedValue({ data: null });
|
||||
await choreService.deleteChore(choreId, 'group', groupId);
|
||||
expect(mockApi.delete).toHaveBeenCalledWith(`/api/v1/chores/groups/${groupId}/chores/${choreId}`);
|
||||
expect(mockApi.delete).toHaveBeenCalledWith(API_ENDPOINTS.CHORES.GROUP_CHORE_BY_ID(groupId, choreId));
|
||||
});
|
||||
|
||||
it('should throw error for invalid type or missing group_id for group chore deletion', async () => {
|
||||
// @ts-expect-error testing invalid type
|
||||
await expect(choreService.deleteChore(choreId, 'unknown')).rejects.toThrow('Invalid chore type or missing group_id for group chore deletion');
|
||||
// @ts-expect-error testing invalid type
|
||||
await expect(choreService.deleteChore(choreId, 'unknown')).rejects.toThrow('Invalid chore type or missing group_id for group chore deletion');
|
||||
|
||||
await expect(choreService.deleteChore(choreId, 'group')).rejects.toThrow('Invalid chore type or missing group_id for group chore deletion'); // Missing groupId
|
||||
});
|
||||
await expect(choreService.deleteChore(choreId, 'group')).rejects.toThrow('Invalid chore type or missing group_id for group chore deletion'); // Missing groupId
|
||||
});
|
||||
|
||||
it('should propagate API error on failure', async () => {
|
||||
const error = new Error('API Delete Failed');
|
||||
@ -174,16 +201,16 @@ describe('Chore Service', () => {
|
||||
{ id: 1, name: 'Family', members: [], owner_id: 1 },
|
||||
{ id: 2, name: 'Work', members: [], owner_id: 1 },
|
||||
];
|
||||
const mockPersonalChores: Chore[] = [{ id: 100, name: 'My Laundry', type: 'personal', description:'' }];
|
||||
const mockFamilyChores: Chore[] = [{ id: 101, name: 'Clean Kitchen', type: 'group', group_id: 1, description:'' }];
|
||||
const mockWorkChores: Chore[] = [{ id: 102, name: 'Team Meeting Prep', type: 'group', group_id: 2, description:'' }];
|
||||
const mockPersonalChores: Chore[] = [{ id: 100, name: 'My Laundry', type: 'personal', description: '' }];
|
||||
const mockFamilyChores: Chore[] = [{ id: 101, name: 'Clean Kitchen', type: 'group', group_id: 1, description: '' }];
|
||||
const mockWorkChores: Chore[] = [{ id: 102, name: 'Team Meeting Prep', type: 'group', group_id: 2, description: '' }];
|
||||
|
||||
beforeEach(() => {
|
||||
// Mock the direct API calls made by getPersonalChores and getChores
|
||||
// if we are not spying/mocking those specific choreService methods.
|
||||
// Here, we assume choreService.getPersonalChores and choreService.getChores are called,
|
||||
// so we can mock them or let them call the mocked api. For simplicity, let them call mocked api.
|
||||
});
|
||||
// Mock the direct API calls made by getPersonalChores and getChores
|
||||
// if we are not spying/mocking those specific choreService methods.
|
||||
// Here, we assume choreService.getPersonalChores and choreService.getChores are called,
|
||||
// so we can mock them or let them call the mocked api. For simplicity, let them call mocked api.
|
||||
});
|
||||
|
||||
it('should fetch all personal and group chores successfully', async () => {
|
||||
mockApi.get
|
||||
@ -194,45 +221,45 @@ describe('Chore Service', () => {
|
||||
|
||||
const allChores = await choreService.getAllChores();
|
||||
|
||||
expect(mockApi.get).toHaveBeenCalledWith('/api/v1/chores/personal');
|
||||
expect(mockApi.get).toHaveBeenCalledWith(API_ENDPOINTS.CHORES.PERSONAL);
|
||||
expect(mockGroupService.getUserGroups).toHaveBeenCalled();
|
||||
expect(mockApi.get).toHaveBeenCalledWith(`/api/v1/chores/groups/${mockUserGroups[0].id}/chores`);
|
||||
expect(mockApi.get).toHaveBeenCalledWith(`/api/v1/chores/groups/${mockUserGroups[1].id}/chores`);
|
||||
expect(mockApi.get).toHaveBeenCalledWith(API_ENDPOINTS.CHORES.GROUP_CHORES(mockUserGroups[0].id));
|
||||
expect(mockApi.get).toHaveBeenCalledWith(API_ENDPOINTS.CHORES.GROUP_CHORES(mockUserGroups[1].id));
|
||||
expect(allChores).toEqual([...mockPersonalChores, ...mockFamilyChores, ...mockWorkChores]);
|
||||
});
|
||||
|
||||
it('should return partial results if fetching chores for one group fails', async () => {
|
||||
const groupFetchError = new Error('Failed to fetch group 2 chores');
|
||||
mockApi.get
|
||||
.mockResolvedValueOnce({ data: mockPersonalChores }) // Personal chores
|
||||
.mockResolvedValueOnce({ data: mockFamilyChores }) // Group 1 chores
|
||||
.mockRejectedValueOnce(groupFetchError); // Group 2 chores fail
|
||||
mockGroupService.getUserGroups.mockResolvedValue(mockUserGroups);
|
||||
const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
|
||||
const groupFetchError = new Error('Failed to fetch group 2 chores');
|
||||
mockApi.get
|
||||
.mockResolvedValueOnce({ data: mockPersonalChores }) // Personal chores
|
||||
.mockResolvedValueOnce({ data: mockFamilyChores }) // Group 1 chores
|
||||
.mockRejectedValueOnce(groupFetchError); // Group 2 chores fail
|
||||
mockGroupService.getUserGroups.mockResolvedValue(mockUserGroups);
|
||||
const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
|
||||
|
||||
const allChores = await choreService.getAllChores();
|
||||
const allChores = await choreService.getAllChores();
|
||||
|
||||
expect(allChores).toEqual([...mockPersonalChores, ...mockFamilyChores]);
|
||||
expect(consoleErrorSpy).toHaveBeenCalledWith(`Failed to get chores for group ${mockUserGroups[1].id} (${mockUserGroups[1].name}):`, groupFetchError);
|
||||
consoleErrorSpy.mockRestore();
|
||||
});
|
||||
expect(allChores).toEqual([...mockPersonalChores, ...mockFamilyChores]);
|
||||
expect(consoleErrorSpy).toHaveBeenCalledWith(`Failed to get chores for group ${mockUserGroups[1].id} (${mockUserGroups[1].name}):`, groupFetchError);
|
||||
consoleErrorSpy.mockRestore();
|
||||
});
|
||||
|
||||
it('should propagate error if getPersonalChores fails', async () => {
|
||||
const personalFetchError = new Error('Failed to fetch personal chores');
|
||||
mockApi.get.mockRejectedValueOnce(personalFetchError); // getPersonalChores fails
|
||||
mockGroupService.getUserGroups.mockResolvedValue(mockUserGroups); // This might not even be called
|
||||
it('should propagate error if getPersonalChores fails', async () => {
|
||||
const personalFetchError = new Error('Failed to fetch personal chores');
|
||||
mockApi.get.mockRejectedValueOnce(personalFetchError); // getPersonalChores fails
|
||||
mockGroupService.getUserGroups.mockResolvedValue(mockUserGroups); // This might not even be called
|
||||
|
||||
await expect(choreService.getAllChores()).rejects.toThrow(personalFetchError);
|
||||
expect(mockGroupService.getUserGroups).not.toHaveBeenCalled(); // Or it might, depending on Promise.all behavior if not used
|
||||
});
|
||||
await expect(choreService.getAllChores()).rejects.toThrow(personalFetchError);
|
||||
expect(mockGroupService.getUserGroups).not.toHaveBeenCalled(); // Or it might, depending on Promise.all behavior if not used
|
||||
});
|
||||
|
||||
it('should propagate error if getUserGroups fails', async () => {
|
||||
const groupsFetchError = new Error('Failed to fetch groups');
|
||||
// getPersonalChores might succeed or fail, let's say it succeeds for this test
|
||||
mockApi.get.mockResolvedValueOnce({ data: mockPersonalChores });
|
||||
mockGroupService.getUserGroups.mockRejectedValue(groupsFetchError);
|
||||
it('should propagate error if getUserGroups fails', async () => {
|
||||
const groupsFetchError = new Error('Failed to fetch groups');
|
||||
// getPersonalChores might succeed or fail, let's say it succeeds for this test
|
||||
mockApi.get.mockResolvedValueOnce({ data: mockPersonalChores });
|
||||
mockGroupService.getUserGroups.mockRejectedValue(groupsFetchError);
|
||||
|
||||
await expect(choreService.getAllChores()).rejects.toThrow(groupsFetchError);
|
||||
});
|
||||
await expect(choreService.getAllChores()).rejects.toThrow(groupsFetchError);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
@ -1,13 +1,21 @@
|
||||
import { api } from './api'
|
||||
import type { Chore, ChoreCreate, ChoreUpdate, ChoreType, ChoreAssignment, ChoreAssignmentCreate, ChoreAssignmentUpdate, ChoreHistory } from '../types/chore'
|
||||
import { api, apiClient, API_ENDPOINTS } from '@/services/api'
|
||||
import type {
|
||||
Chore,
|
||||
ChoreCreate,
|
||||
ChoreUpdate,
|
||||
ChoreType,
|
||||
ChoreAssignment,
|
||||
ChoreAssignmentCreate,
|
||||
ChoreAssignmentUpdate,
|
||||
ChoreHistory,
|
||||
} from '@/types/chore'
|
||||
import { groupService } from './groupService'
|
||||
import { apiClient, API_ENDPOINTS } from '@/services/api'
|
||||
import type { Group } from '@/types/group'
|
||||
|
||||
export const choreService = {
|
||||
async getAllChores(): Promise<Chore[]> {
|
||||
try {
|
||||
const response = await api.get('/chores/all')
|
||||
const response = await api.get(API_ENDPOINTS.CHORES.ALL)
|
||||
return response.data
|
||||
} catch (error) {
|
||||
console.error('Failed to get all chores via optimized endpoint, falling back to individual calls:', error)
|
||||
@ -38,78 +46,93 @@ export const choreService = {
|
||||
},
|
||||
|
||||
async getChores(groupId: number): Promise<Chore[]> {
|
||||
const response = await api.get(`/api/v1/chores/groups/${groupId}/chores`)
|
||||
const response = await api.get(API_ENDPOINTS.CHORES.GROUP_CHORES(groupId))
|
||||
return response.data
|
||||
},
|
||||
|
||||
async createChore(chore: ChoreCreate): Promise<Chore> {
|
||||
if (chore.type === 'personal') {
|
||||
const response = await api.post('/api/v1/chores/personal', chore)
|
||||
const response = await api.post(API_ENDPOINTS.CHORES.PERSONAL, chore)
|
||||
return response.data
|
||||
} else if (chore.type === 'group' && chore.group_id) {
|
||||
const response = await api.post(`/api/v1/chores/groups/${chore.group_id}/chores`, chore)
|
||||
const response = await api.post(API_ENDPOINTS.CHORES.GROUP_CHORES(chore.group_id), chore)
|
||||
return response.data
|
||||
} else {
|
||||
throw new Error('Invalid chore type or missing group_id for group chore')
|
||||
}
|
||||
},
|
||||
|
||||
async updateChore(choreId: number, chore: ChoreUpdate): Promise<Chore> {
|
||||
if (chore.type === 'personal') {
|
||||
const response = await api.put(`/api/v1/chores/personal/${choreId}`, chore)
|
||||
async updateChore(choreId: number, chore: ChoreUpdate, originalChore?: Chore): Promise<Chore> {
|
||||
// Check if this is a type conversion (personal to group or group to personal)
|
||||
const isTypeConversion = originalChore && chore.type && originalChore.type !== chore.type;
|
||||
|
||||
if (isTypeConversion) {
|
||||
// Use the new general endpoint for type conversions
|
||||
const response = await api.put(API_ENDPOINTS.CHORES.UPDATE_ANY_TYPE(choreId), chore)
|
||||
return response.data
|
||||
} else if (chore.type === 'group' && chore.group_id) {
|
||||
}
|
||||
|
||||
if (chore.type === 'personal') {
|
||||
const response = await api.put(API_ENDPOINTS.CHORES.PERSONAL_BY_ID(choreId), chore)
|
||||
return response.data
|
||||
} else if (chore.type === 'group') {
|
||||
// For group chores, we need to use the original group_id for the endpoint path
|
||||
// but can send the new group_id in the payload for group changes
|
||||
const currentGroupId = originalChore?.group_id ?? chore.group_id;
|
||||
if (!currentGroupId) {
|
||||
throw new Error('Missing group_id for group chore update')
|
||||
}
|
||||
const response = await api.put(
|
||||
`/api/v1/chores/groups/${chore.group_id}/chores/${choreId}`,
|
||||
API_ENDPOINTS.CHORES.GROUP_CHORE_BY_ID(currentGroupId, choreId),
|
||||
chore,
|
||||
)
|
||||
return response.data
|
||||
} else {
|
||||
throw new Error('Invalid chore type or missing group_id for group chore update')
|
||||
throw new Error('Invalid chore type for chore update')
|
||||
}
|
||||
},
|
||||
|
||||
async deleteChore(choreId: number, choreType: ChoreType, groupId?: number): Promise<void> {
|
||||
if (choreType === 'personal') {
|
||||
await api.delete(`/api/v1/chores/personal/${choreId}`)
|
||||
await api.delete(API_ENDPOINTS.CHORES.PERSONAL_BY_ID(choreId))
|
||||
} else if (choreType === 'group' && groupId) {
|
||||
await api.delete(`/api/v1/chores/groups/${groupId}/chores/${choreId}`)
|
||||
await api.delete(API_ENDPOINTS.CHORES.GROUP_CHORE_BY_ID(groupId, choreId))
|
||||
} else {
|
||||
throw new Error('Invalid chore type or missing group_id for group chore deletion')
|
||||
}
|
||||
},
|
||||
|
||||
async getPersonalChores(): Promise<Chore[]> {
|
||||
const response = await api.get('/api/v1/chores/personal')
|
||||
const response = await api.get(API_ENDPOINTS.CHORES.PERSONAL)
|
||||
return response.data
|
||||
},
|
||||
|
||||
async createAssignment(assignment: ChoreAssignmentCreate): Promise<ChoreAssignment> {
|
||||
const response = await api.post('/api/v1/chores/assignments', assignment)
|
||||
const response = await api.post(API_ENDPOINTS.CHORES.ASSIGNMENTS_BASE, assignment)
|
||||
return response.data
|
||||
},
|
||||
|
||||
async getMyAssignments(includeCompleted: boolean = false): Promise<ChoreAssignment[]> {
|
||||
const response = await api.get(`/api/v1/chores/assignments/my?include_completed=${includeCompleted}`)
|
||||
const response = await api.get(API_ENDPOINTS.CHORES.MY_ASSIGNMENTS(includeCompleted))
|
||||
return response.data
|
||||
},
|
||||
|
||||
async getChoreAssignments(choreId: number): Promise<ChoreAssignment[]> {
|
||||
const response = await api.get(`/api/v1/chores/chores/${choreId}/assignments`)
|
||||
const response = await api.get(API_ENDPOINTS.CHORES.ASSIGNMENTS(choreId))
|
||||
return response.data
|
||||
},
|
||||
|
||||
async updateAssignment(assignmentId: number, update: ChoreAssignmentUpdate): Promise<ChoreAssignment> {
|
||||
const response = await apiClient.put(`/api/v1/chores/assignments/${assignmentId}`, update)
|
||||
const response = await apiClient.put(API_ENDPOINTS.CHORES.ASSIGNMENT_BY_ID(assignmentId), update)
|
||||
return response.data
|
||||
},
|
||||
|
||||
async deleteAssignment(assignmentId: number): Promise<void> {
|
||||
await api.delete(`/api/v1/chores/assignments/${assignmentId}`)
|
||||
await api.delete(API_ENDPOINTS.CHORES.ASSIGNMENT_BY_ID(assignmentId))
|
||||
},
|
||||
|
||||
async completeAssignment(assignmentId: number): Promise<ChoreAssignment> {
|
||||
const response = await api.patch(`/api/v1/chores/assignments/${assignmentId}/complete`)
|
||||
const response = await api.patch(API_ENDPOINTS.CHORES.ASSIGNMENT_COMPLETE(assignmentId))
|
||||
return response.data
|
||||
},
|
||||
|
||||
@ -118,21 +141,21 @@ export const choreService = {
|
||||
choreId: number,
|
||||
chore: ChoreUpdate,
|
||||
): Promise<Chore> {
|
||||
const response = await api.put(`/api/v1/chores/groups/${groupId}/chores/${choreId}`, chore)
|
||||
const response = await api.put(API_ENDPOINTS.CHORES.GROUP_CHORE_BY_ID(groupId, choreId), chore)
|
||||
return response.data
|
||||
},
|
||||
|
||||
async _original_deleteGroupChore(groupId: number, choreId: number): Promise<void> {
|
||||
await api.delete(`/api/v1/chores/groups/${groupId}/chores/${choreId}`)
|
||||
await api.delete(API_ENDPOINTS.CHORES.GROUP_CHORE_BY_ID(groupId, choreId))
|
||||
},
|
||||
|
||||
async _updatePersonalChore(choreId: number, chore: ChoreUpdate): Promise<Chore> {
|
||||
const response = await api.put(`/api/v1/chores/personal/${choreId}`, chore)
|
||||
const response = await api.put(API_ENDPOINTS.CHORES.PERSONAL_BY_ID(choreId), chore)
|
||||
return response.data
|
||||
},
|
||||
|
||||
async _deletePersonalChore(choreId: number): Promise<void> {
|
||||
await api.delete(`/api/v1/chores/personal/${choreId}`)
|
||||
await api.delete(API_ENDPOINTS.CHORES.PERSONAL_BY_ID(choreId))
|
||||
},
|
||||
|
||||
async getChoreHistory(choreId: number): Promise<ChoreHistory[]> {
|
||||
|
||||
@ -32,7 +32,23 @@ export interface UpdateExpenseData extends Partial<CreateExpenseData> {
|
||||
|
||||
export const expenseService = {
|
||||
async createExpense(data: CreateExpenseData): Promise<Expense> {
|
||||
const response = await api.post<Expense>(API_ENDPOINTS.FINANCIALS.EXPENSES, data)
|
||||
// Convert camelCase keys to snake_case expected by backend
|
||||
const payload: Record<string, any> = { ...data }
|
||||
payload.is_recurring = data.isRecurring
|
||||
delete payload.isRecurring
|
||||
|
||||
if (data.recurrencePattern) {
|
||||
payload.recurrence_pattern = {
|
||||
...data.recurrencePattern,
|
||||
// daysOfWeek -> days_of_week, endDate -> end_date, maxOccurrences -> max_occurrences
|
||||
days_of_week: data.recurrencePattern.daysOfWeek,
|
||||
end_date: data.recurrencePattern.endDate,
|
||||
max_occurrences: data.recurrencePattern.maxOccurrences,
|
||||
}
|
||||
delete payload.recurrencePattern
|
||||
}
|
||||
|
||||
const response = await api.post<Expense>(API_ENDPOINTS.FINANCIALS.EXPENSES, payload)
|
||||
return response.data
|
||||
},
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user