849 lines
30 KiB
Python
849 lines
30 KiB
Python
"""
|
|
Commands for schedule-related operations.
|
|
"""
|
|
from typing import Any, Dict, List, Optional
|
|
from datetime import datetime
|
|
|
|
from backend.core.models.schedules.schedules import Schedule
|
|
from backend.core.models.services.services import Service
|
|
from backend.core.repositories.schedules.schedules import ScheduleRepository
|
|
from backend.core.repositories.accounts.accounts import AccountRepository
|
|
from backend.core.utils.validators import (
|
|
is_valid_uuid, is_valid_date, validate_required_fields, validate_model_exists
|
|
)
|
|
from backend.core.utils.helpers import generate_uuid, parse_date
|
|
from backend.core.commands.base import Command, CommandResult
|
|
|
|
|
|
class CreateScheduleCommand(Command):
|
|
"""
|
|
Command to create a new schedule.
|
|
"""
|
|
|
|
def __init__(
|
|
self,
|
|
schedule_repo: ScheduleRepository,
|
|
account_repo: AccountRepository,
|
|
account_id: str,
|
|
start_date: str,
|
|
monday_service: bool = False,
|
|
tuesday_service: bool = False,
|
|
wednesday_service: bool = False,
|
|
thursday_service: bool = False,
|
|
friday_service: bool = False,
|
|
saturday_service: bool = False,
|
|
sunday_service: bool = False,
|
|
weekend_service: bool = False,
|
|
schedule_exception: Optional[str] = None,
|
|
end_date: Optional[str] = None
|
|
):
|
|
"""
|
|
Initialize the create schedule command.
|
|
|
|
Args:
|
|
schedule_repo: Repository for schedule operations.
|
|
account_repo: Repository for account operations.
|
|
account_id: ID of the account this schedule belongs to.
|
|
start_date: Start date of the schedule (YYYY-MM-DD).
|
|
monday_service: Whether service is scheduled for Monday.
|
|
tuesday_service: Whether service is scheduled for Tuesday.
|
|
wednesday_service: Whether service is scheduled for Wednesday.
|
|
thursday_service: Whether service is scheduled for Thursday.
|
|
friday_service: Whether service is scheduled for Friday.
|
|
saturday_service: Whether service is scheduled for Saturday.
|
|
sunday_service: Whether service is scheduled for Sunday.
|
|
weekend_service: Whether weekend service is enabled.
|
|
schedule_exception: Any exceptions to the schedule.
|
|
end_date: End date of the schedule (YYYY-MM-DD, optional).
|
|
"""
|
|
self.schedule_repo = schedule_repo
|
|
self.account_repo = account_repo
|
|
self.account_id = account_id
|
|
self.start_date = start_date
|
|
self.monday_service = monday_service
|
|
self.tuesday_service = tuesday_service
|
|
self.wednesday_service = wednesday_service
|
|
self.thursday_service = thursday_service
|
|
self.friday_service = friday_service
|
|
self.saturday_service = saturday_service
|
|
self.sunday_service = sunday_service
|
|
self.weekend_service = weekend_service
|
|
self.schedule_exception = schedule_exception
|
|
self.end_date = end_date
|
|
|
|
def validate(self) -> Dict[str, Any]:
|
|
"""
|
|
Validate the schedule creation data.
|
|
|
|
Returns:
|
|
Dict[str, Any]: Validation result with 'is_valid' and optional 'errors'.
|
|
"""
|
|
errors = []
|
|
|
|
# Check required fields
|
|
required_fields = ['account_id', 'start_date']
|
|
|
|
field_values = {
|
|
'account_id': self.account_id,
|
|
'start_date': self.start_date
|
|
}
|
|
|
|
missing_fields = validate_required_fields(field_values, required_fields)
|
|
|
|
if missing_fields:
|
|
errors.append(f"Required fields missing: {', '.join(missing_fields)}")
|
|
|
|
# Validate account exists
|
|
if not errors and self.account_id:
|
|
account_validation = validate_model_exists(
|
|
self.account_id, 'account', self.account_repo.get_by_id
|
|
)
|
|
if not account_validation['valid']:
|
|
errors.append(account_validation['error'])
|
|
|
|
# Validate date formats
|
|
if not errors and self.start_date and not is_valid_date(self.start_date):
|
|
errors.append("Invalid start date format. Use YYYY-MM-DD.")
|
|
|
|
if not errors and self.end_date and not is_valid_date(self.end_date):
|
|
errors.append("Invalid end date format. Use YYYY-MM-DD.")
|
|
|
|
# Validate start date is before end date if both provided
|
|
if not errors and self.start_date and self.end_date:
|
|
start = parse_date(self.start_date)
|
|
end = parse_date(self.end_date)
|
|
if start and end and start > end:
|
|
errors.append("Start date must be before end date.")
|
|
|
|
# Check if there's an active schedule for this account
|
|
if not errors:
|
|
active_schedule = self.schedule_repo.get_active_by_account(self.account_id)
|
|
if active_schedule:
|
|
errors.append(
|
|
f"Account already has an active schedule. End the current schedule before creating a new one.")
|
|
|
|
# Validate at least one service day is selected
|
|
if not errors and not any([
|
|
self.monday_service, self.tuesday_service, self.wednesday_service,
|
|
self.thursday_service, self.friday_service, self.saturday_service,
|
|
self.sunday_service, self.weekend_service
|
|
]):
|
|
errors.append("At least one service day must be selected.")
|
|
|
|
return {
|
|
'is_valid': len(errors) == 0,
|
|
'errors': errors
|
|
}
|
|
|
|
def execute(self) -> CommandResult[Schedule]:
|
|
"""
|
|
Execute the schedule creation command.
|
|
|
|
Returns:
|
|
CommandResult[Schedule]: Result of the command execution.
|
|
"""
|
|
# Validate command data
|
|
validation = self.validate()
|
|
if not validation['is_valid']:
|
|
return CommandResult.failure_result(validation['errors'])
|
|
|
|
try:
|
|
# Create schedule data
|
|
schedule_id = generate_uuid()
|
|
|
|
# Create schedule data dictionary
|
|
schedule_data = {
|
|
'id': schedule_id,
|
|
'account_id': self.account_id,
|
|
'monday_service': self.monday_service,
|
|
'tuesday_service': self.tuesday_service,
|
|
'wednesday_service': self.wednesday_service,
|
|
'thursday_service': self.thursday_service,
|
|
'friday_service': self.friday_service,
|
|
'saturday_service': self.saturday_service,
|
|
'sunday_service': self.sunday_service,
|
|
'weekend_service': self.weekend_service,
|
|
'schedule_exception': self.schedule_exception,
|
|
'start_date': self.start_date,
|
|
'end_date': self.end_date
|
|
}
|
|
|
|
# Save to repository
|
|
created_schedule = self.schedule_repo.create(schedule_data)
|
|
|
|
return CommandResult.success_result(
|
|
created_schedule,
|
|
f"Schedule created successfully for account {self.account_id}"
|
|
)
|
|
|
|
except Exception as e:
|
|
return CommandResult.failure_result(
|
|
str(e),
|
|
"Failed to create schedule"
|
|
)
|
|
|
|
|
|
class UpdateScheduleCommand(Command):
|
|
"""
|
|
Command to update an existing schedule.
|
|
"""
|
|
|
|
def __init__(
|
|
self,
|
|
schedule_repo: ScheduleRepository,
|
|
account_repo: AccountRepository,
|
|
schedule_id: str,
|
|
monday_service: Optional[bool] = None,
|
|
tuesday_service: Optional[bool] = None,
|
|
wednesday_service: Optional[bool] = None,
|
|
thursday_service: Optional[bool] = None,
|
|
friday_service: Optional[bool] = None,
|
|
saturday_service: Optional[bool] = None,
|
|
sunday_service: Optional[bool] = None,
|
|
weekend_service: Optional[bool] = None,
|
|
schedule_exception: Optional[str] = None,
|
|
start_date: Optional[str] = None,
|
|
end_date: Optional[str] = None
|
|
):
|
|
"""
|
|
Initialize the update schedule command.
|
|
|
|
Args:
|
|
schedule_repo: Repository for schedule operations.
|
|
account_repo: Repository for account operations.
|
|
schedule_id: ID of the schedule to update.
|
|
monday_service: Whether service is scheduled for Monday.
|
|
tuesday_service: Whether service is scheduled for Tuesday.
|
|
wednesday_service: Whether service is scheduled for Wednesday.
|
|
thursday_service: Whether service is scheduled for Thursday.
|
|
friday_service: Whether service is scheduled for Friday.
|
|
saturday_service: Whether service is scheduled for Saturday.
|
|
sunday_service: Whether service is scheduled for Sunday.
|
|
weekend_service: Whether weekend service is enabled.
|
|
schedule_exception: Any exceptions to the schedule.
|
|
start_date: Start date of the schedule.
|
|
end_date: End date of the schedule.
|
|
"""
|
|
self.schedule_repo = schedule_repo
|
|
self.account_repo = account_repo
|
|
self.schedule_id = schedule_id
|
|
self.monday_service = monday_service
|
|
self.tuesday_service = tuesday_service
|
|
self.wednesday_service = wednesday_service
|
|
self.thursday_service = thursday_service
|
|
self.friday_service = friday_service
|
|
self.saturday_service = saturday_service
|
|
self.sunday_service = sunday_service
|
|
self.weekend_service = weekend_service
|
|
self.schedule_exception = schedule_exception
|
|
self.start_date = start_date
|
|
self.end_date = end_date
|
|
|
|
def validate(self) -> Dict[str, Any]:
|
|
"""
|
|
Validate the schedule update data.
|
|
|
|
Returns:
|
|
Dict[str, Any]: Validation result with 'is_valid' and optional 'errors'.
|
|
"""
|
|
errors = []
|
|
|
|
# Validate schedule exists
|
|
if not is_valid_uuid(self.schedule_id):
|
|
errors.append("Invalid schedule ID format")
|
|
else:
|
|
schedule = self.schedule_repo.get_by_id(self.schedule_id)
|
|
if not schedule:
|
|
errors.append(f"Schedule with ID {self.schedule_id} not found")
|
|
|
|
# Validate date formats if provided
|
|
if not errors and self.start_date is not None and not is_valid_date(self.start_date):
|
|
errors.append("Invalid start date format. Use YYYY-MM-DD.")
|
|
|
|
if not errors and self.end_date is not None and not is_valid_date(self.end_date):
|
|
errors.append("Invalid end date format. Use YYYY-MM-DD.")
|
|
|
|
# Validate start date is before end date if both provided
|
|
if not errors and self.start_date and self.end_date:
|
|
start = parse_date(self.start_date)
|
|
end = parse_date(self.end_date)
|
|
if start and end and start > end:
|
|
errors.append("Start date must be before end date.")
|
|
|
|
# If only updating end_date, validate it's after the existing start_date
|
|
if not errors and self.end_date and not self.start_date:
|
|
schedule = self.schedule_repo.get_by_id(self.schedule_id)
|
|
if schedule:
|
|
end = parse_date(self.end_date)
|
|
start = parse_date(schedule.start_date)
|
|
if end and start and start > end:
|
|
errors.append("End date must be after the existing start date.")
|
|
|
|
# Check if at least one service day will be selected after update
|
|
if not errors:
|
|
schedule = self.schedule_repo.get_by_id(self.schedule_id)
|
|
if schedule:
|
|
monday = self.monday_service if self.monday_service is not None else schedule.monday_service
|
|
tuesday = self.tuesday_service if self.tuesday_service is not None else schedule.tuesday_service
|
|
wednesday = self.wednesday_service if self.wednesday_service is not None else schedule.wednesday_service
|
|
thursday = self.thursday_service if self.thursday_service is not None else schedule.thursday_service
|
|
friday = self.friday_service if self.friday_service is not None else schedule.friday_service
|
|
saturday = self.saturday_service if self.saturday_service is not None else schedule.saturday_service
|
|
sunday = self.sunday_service if self.sunday_service is not None else schedule.sunday_service
|
|
weekend = self.weekend_service if self.weekend_service is not None else schedule.weekend_service
|
|
|
|
if not any([monday, tuesday, wednesday, thursday, friday, saturday, sunday, weekend]):
|
|
errors.append("At least one service day must be selected.")
|
|
|
|
return {
|
|
'is_valid': len(errors) == 0,
|
|
'errors': errors
|
|
}
|
|
|
|
def execute(self) -> CommandResult[Schedule]:
|
|
"""
|
|
Execute the schedule update command.
|
|
|
|
Returns:
|
|
CommandResult[Schedule]: Result of the command execution.
|
|
"""
|
|
# Validate command data
|
|
validation = self.validate()
|
|
if not validation['is_valid']:
|
|
return CommandResult.failure_result(validation['errors'])
|
|
|
|
try:
|
|
# Create a dictionary of fields to update
|
|
update_data = {}
|
|
|
|
# Add fields to update_data if they were provided
|
|
if self.monday_service is not None:
|
|
update_data['monday_service'] = self.monday_service
|
|
|
|
if self.tuesday_service is not None:
|
|
update_data['tuesday_service'] = self.tuesday_service
|
|
|
|
if self.wednesday_service is not None:
|
|
update_data['wednesday_service'] = self.wednesday_service
|
|
|
|
if self.thursday_service is not None:
|
|
update_data['thursday_service'] = self.thursday_service
|
|
|
|
if self.friday_service is not None:
|
|
update_data['friday_service'] = self.friday_service
|
|
|
|
if self.saturday_service is not None:
|
|
update_data['saturday_service'] = self.saturday_service
|
|
|
|
if self.sunday_service is not None:
|
|
update_data['sunday_service'] = self.sunday_service
|
|
|
|
if self.weekend_service is not None:
|
|
update_data['weekend_service'] = self.weekend_service
|
|
|
|
if self.schedule_exception is not None:
|
|
update_data['schedule_exception'] = self.schedule_exception
|
|
|
|
if self.start_date is not None:
|
|
update_data['start_date'] = self.start_date
|
|
|
|
if self.end_date is not None:
|
|
update_data['end_date'] = self.end_date
|
|
|
|
# Update the schedule with the data dictionary
|
|
updated_schedule = self.schedule_repo.update(self.schedule_id, update_data)
|
|
|
|
return CommandResult.success_result(
|
|
updated_schedule,
|
|
f"Schedule {self.schedule_id} updated successfully"
|
|
)
|
|
|
|
except Exception as e:
|
|
return CommandResult.failure_result(
|
|
str(e),
|
|
"Failed to update schedule"
|
|
)
|
|
|
|
|
|
class DeleteScheduleCommand(Command):
|
|
"""
|
|
Command to delete a schedule.
|
|
"""
|
|
|
|
def __init__(
|
|
self,
|
|
schedule_repo: ScheduleRepository,
|
|
schedule_id: str
|
|
):
|
|
"""
|
|
Initialize the delete schedule command.
|
|
|
|
Args:
|
|
schedule_repo: Repository for schedule operations.
|
|
schedule_id: ID of the schedule to delete.
|
|
"""
|
|
self.schedule_repo = schedule_repo
|
|
self.schedule_id = schedule_id
|
|
|
|
def validate(self) -> Dict[str, Any]:
|
|
"""
|
|
Validate the schedule deletion request.
|
|
|
|
Returns:
|
|
Dict[str, Any]: Validation result with 'is_valid' and optional 'errors'.
|
|
"""
|
|
errors = []
|
|
|
|
# Validate schedule exists
|
|
if not is_valid_uuid(self.schedule_id):
|
|
errors.append("Invalid schedule ID format")
|
|
else:
|
|
schedule = self.schedule_repo.get_by_id(self.schedule_id)
|
|
if not schedule:
|
|
errors.append(f"Schedule with ID {self.schedule_id} not found")
|
|
|
|
return {
|
|
'is_valid': len(errors) == 0,
|
|
'errors': errors
|
|
}
|
|
|
|
def execute(self) -> CommandResult[bool]:
|
|
"""
|
|
Execute the schedule deletion command.
|
|
|
|
Returns:
|
|
CommandResult[bool]: Result of the command execution.
|
|
"""
|
|
# Validate command data
|
|
validation = self.validate()
|
|
if not validation['is_valid']:
|
|
return CommandResult.failure_result(validation['errors'])
|
|
|
|
try:
|
|
# Delete the schedule
|
|
success = self.schedule_repo.delete(self.schedule_id)
|
|
|
|
if success:
|
|
return CommandResult.success_result(
|
|
True,
|
|
f"Schedule {self.schedule_id} deleted successfully"
|
|
)
|
|
else:
|
|
return CommandResult.failure_result(
|
|
"Failed to delete schedule",
|
|
f"Schedule {self.schedule_id} could not be deleted"
|
|
)
|
|
|
|
except Exception as e:
|
|
return CommandResult.failure_result(
|
|
str(e),
|
|
"Failed to delete schedule"
|
|
)
|
|
|
|
|
|
class EndScheduleCommand(Command):
|
|
"""
|
|
Command to end a schedule by setting its end date.
|
|
"""
|
|
|
|
def __init__(
|
|
self,
|
|
schedule_repo: ScheduleRepository,
|
|
schedule_id: str,
|
|
end_date: Optional[str] = None
|
|
):
|
|
"""
|
|
Initialize the end schedule command.
|
|
|
|
Args:
|
|
schedule_repo: Repository for schedule operations.
|
|
schedule_id: ID of the schedule to end.
|
|
end_date: End date for the schedule (defaults to today if not provided).
|
|
"""
|
|
self.schedule_repo = schedule_repo
|
|
self.schedule_id = schedule_id
|
|
self.end_date = end_date
|
|
|
|
def validate(self) -> Dict[str, Any]:
|
|
"""
|
|
Validate the end schedule request.
|
|
|
|
Returns:
|
|
Dict[str, Any]: Validation result with 'is_valid' and optional 'errors'.
|
|
"""
|
|
errors = []
|
|
|
|
# Validate schedule exists
|
|
if not is_valid_uuid(self.schedule_id):
|
|
errors.append("Invalid schedule ID format")
|
|
else:
|
|
schedule = self.schedule_repo.get_by_id(self.schedule_id)
|
|
if not schedule:
|
|
errors.append(f"Schedule with ID {self.schedule_id} not found")
|
|
elif schedule.end_date is not None:
|
|
errors.append(f"Schedule is already ended")
|
|
|
|
# Validate end date format if provided
|
|
if not errors and self.end_date and not is_valid_date(self.end_date):
|
|
errors.append("Invalid end date format. Use YYYY-MM-DD.")
|
|
|
|
# Validate end date is after start date if provided
|
|
if not errors and self.end_date:
|
|
schedule = self.schedule_repo.get_by_id(self.schedule_id)
|
|
if schedule:
|
|
end = parse_date(self.end_date)
|
|
start = parse_date(schedule.start_date)
|
|
if end and start and start > end:
|
|
errors.append("End date must be after the start date.")
|
|
|
|
return {
|
|
'is_valid': len(errors) == 0,
|
|
'errors': errors
|
|
}
|
|
|
|
def execute(self) -> CommandResult[Schedule]:
|
|
"""
|
|
Execute the end schedule command.
|
|
|
|
Returns:
|
|
CommandResult[Schedule]: Result of the command execution.
|
|
"""
|
|
# Validate command data
|
|
validation = self.validate()
|
|
if not validation['is_valid']:
|
|
return CommandResult.failure_result(validation['errors'])
|
|
|
|
try:
|
|
# End the schedule
|
|
end_date = self.end_date or datetime.now().strftime('%Y-%m-%d')
|
|
updated_schedule = self.schedule_repo.update(
|
|
self.schedule_id,
|
|
{'end_date': end_date}
|
|
)
|
|
|
|
if updated_schedule:
|
|
return CommandResult.success_result(
|
|
updated_schedule,
|
|
f"Schedule {self.schedule_id} ended successfully"
|
|
)
|
|
else:
|
|
return CommandResult.failure_result(
|
|
"Failed to end schedule",
|
|
f"Schedule {self.schedule_id} could not be ended"
|
|
)
|
|
|
|
except Exception as e:
|
|
return CommandResult.failure_result(
|
|
str(e),
|
|
"Failed to end schedule"
|
|
)
|
|
|
|
|
|
class GetActiveSchedulesCommand(Command):
|
|
"""
|
|
Command to get all active schedules.py.
|
|
"""
|
|
|
|
def __init__(
|
|
self,
|
|
schedule_repo: ScheduleRepository,
|
|
account_id: Optional[str] = None
|
|
):
|
|
"""
|
|
Initialize the get active schedules.py command.
|
|
|
|
Args:
|
|
schedule_repo: Repository for schedule operations.
|
|
account_id: Optional account ID to filter by.
|
|
"""
|
|
self.schedule_repo = schedule_repo
|
|
self.account_id = account_id
|
|
|
|
def validate(self) -> Dict[str, Any]:
|
|
"""
|
|
Validate the get active schedules.py request.
|
|
|
|
Returns:
|
|
Dict[str, Any]: Validation result with 'is_valid' and optional 'errors'.
|
|
"""
|
|
errors = []
|
|
|
|
# Validate account ID if provided
|
|
if self.account_id and not is_valid_uuid(self.account_id):
|
|
errors.append("Invalid account ID format")
|
|
|
|
return {
|
|
'is_valid': len(errors) == 0,
|
|
'errors': errors
|
|
}
|
|
|
|
def execute(self) -> CommandResult[List[Schedule]]:
|
|
"""
|
|
Execute the get active schedules.py command.
|
|
|
|
Returns:
|
|
CommandResult[List[Schedule]]: Result of the command execution with active schedules.py.
|
|
"""
|
|
# Validate command data
|
|
validation = self.validate()
|
|
if not validation['is_valid']:
|
|
return CommandResult.failure_result(validation['errors'])
|
|
|
|
try:
|
|
# Get active schedules.py
|
|
if self.account_id:
|
|
active_schedule = self.schedule_repo.get_active_by_account(self.account_id)
|
|
schedules = [active_schedule] if active_schedule else []
|
|
else:
|
|
schedules = list(self.schedule_repo.get_active())
|
|
|
|
return CommandResult.success_result(
|
|
schedules,
|
|
f"Retrieved active schedule records"
|
|
)
|
|
|
|
except Exception as e:
|
|
return CommandResult.failure_result(
|
|
str(e),
|
|
"Failed to retrieve active schedule records"
|
|
)
|
|
|
|
|
|
class GenerateServicesCommand(Command):
|
|
"""
|
|
Command to generate services based on a schedule.
|
|
"""
|
|
|
|
def __init__(
|
|
self,
|
|
schedule_repo: ScheduleRepository,
|
|
schedule_id: str,
|
|
start_date: str,
|
|
end_date: str
|
|
):
|
|
"""
|
|
Initialize the generate services command.
|
|
|
|
Args:
|
|
schedule_repo: Repository for schedule operations.
|
|
schedule_id: ID of the schedule to generate services from.
|
|
start_date: Start date for service generation (YYYY-MM-DD).
|
|
end_date: End date for service generation (YYYY-MM-DD).
|
|
"""
|
|
self.schedule_repo = schedule_repo
|
|
self.schedule_id = schedule_id
|
|
self.start_date = start_date
|
|
self.end_date = end_date
|
|
|
|
def validate(self) -> Dict[str, Any]:
|
|
"""
|
|
Validate the generate services request.
|
|
|
|
Returns:
|
|
Dict[str, Any]: Validation result with 'is_valid' and optional 'errors'.
|
|
"""
|
|
errors = []
|
|
|
|
# Validate schedule exists
|
|
if not is_valid_uuid(self.schedule_id):
|
|
errors.append("Invalid schedule ID format")
|
|
else:
|
|
schedule = self.schedule_repo.get_by_id(self.schedule_id)
|
|
if not schedule:
|
|
errors.append(f"Schedule with ID {self.schedule_id} not found")
|
|
|
|
# Validate date formats
|
|
if not errors and not is_valid_date(self.start_date):
|
|
errors.append("Invalid start date format. Use YYYY-MM-DD.")
|
|
|
|
if not errors and not is_valid_date(self.end_date):
|
|
errors.append("Invalid end date format. Use YYYY-MM-DD.")
|
|
|
|
# Validate start date is before end date
|
|
if not errors:
|
|
start = parse_date(self.start_date)
|
|
end = parse_date(self.end_date)
|
|
if start and end and start > end:
|
|
errors.append("Start date must be before end date.")
|
|
|
|
# Validate date range is not too large (e.g., limit to 3 months)
|
|
if not errors:
|
|
start = parse_date(self.start_date)
|
|
end = parse_date(self.end_date)
|
|
if start and end:
|
|
date_diff = (end - start).days
|
|
if date_diff > 90: # 3 months
|
|
errors.append("Date range too large. Maximum range is 90 days.")
|
|
|
|
return {
|
|
'is_valid': len(errors) == 0,
|
|
'errors': errors
|
|
}
|
|
|
|
def execute(self) -> CommandResult[List[Service]]:
|
|
"""
|
|
Execute the generate services command.
|
|
|
|
Returns:
|
|
CommandResult[List[Service]]: Result of the command execution with generated services.
|
|
"""
|
|
# Validate command data
|
|
validation = self.validate()
|
|
if not validation['is_valid']:
|
|
return CommandResult.failure_result(validation['errors'])
|
|
|
|
try:
|
|
# Parse dates
|
|
start_date_obj = parse_date(self.start_date)
|
|
end_date_obj = parse_date(self.end_date)
|
|
|
|
# Generate services
|
|
services = self.schedule_repo.generate_services(
|
|
self.schedule_id,
|
|
start_date_obj,
|
|
end_date_obj
|
|
)
|
|
|
|
return CommandResult.success_result(
|
|
services,
|
|
f"Generated {len(services)} services from schedule {self.schedule_id}"
|
|
)
|
|
|
|
except Exception as e:
|
|
return CommandResult.failure_result(
|
|
str(e),
|
|
"Failed to generate services from schedule"
|
|
)
|
|
|
|
|
|
class GetScheduleByAccountCommand(Command):
|
|
"""
|
|
Command to get schedules.py for a specific account.
|
|
"""
|
|
|
|
def __init__(
|
|
self,
|
|
schedule_repo: ScheduleRepository,
|
|
account_id: str
|
|
):
|
|
"""
|
|
Initialize the get schedule by account command.
|
|
|
|
Args:
|
|
schedule_repo: Repository for schedule operations.
|
|
account_id: ID of the account to get schedules.py for.
|
|
"""
|
|
self.schedule_repo = schedule_repo
|
|
self.account_id = account_id
|
|
|
|
def validate(self) -> Dict[str, Any]:
|
|
"""
|
|
Validate the get schedule by account request.
|
|
|
|
Returns:
|
|
Dict[str, Any]: Validation result with 'is_valid' and optional 'errors'.
|
|
"""
|
|
errors = []
|
|
|
|
# Validate account ID
|
|
if not is_valid_uuid(self.account_id):
|
|
errors.append("Invalid account ID format")
|
|
|
|
return {
|
|
'is_valid': len(errors) == 0,
|
|
'errors': errors
|
|
}
|
|
|
|
def execute(self) -> CommandResult[List[Schedule]]:
|
|
"""
|
|
Execute the get schedule by account command.
|
|
|
|
Returns:
|
|
CommandResult[List[Schedule]]: Result of the command execution with account schedules.py.
|
|
"""
|
|
# Validate command data
|
|
validation = self.validate()
|
|
if not validation['is_valid']:
|
|
return CommandResult.failure_result(validation['errors'])
|
|
|
|
try:
|
|
# Get schedules.py for the account
|
|
schedules = list(self.schedule_repo.get_by_account(self.account_id))
|
|
|
|
return CommandResult.success_result(
|
|
schedules,
|
|
f"Retrieved {len(schedules)} schedules.py for account {self.account_id}"
|
|
)
|
|
|
|
except Exception as e:
|
|
return CommandResult.failure_result(
|
|
str(e),
|
|
"Failed to retrieve schedules.py for account"
|
|
)
|
|
|
|
|
|
class SearchSchedulesCommand(Command):
|
|
"""
|
|
Command to search for schedules.py.
|
|
"""
|
|
|
|
def __init__(
|
|
self,
|
|
schedule_repo: ScheduleRepository,
|
|
search_term: str
|
|
):
|
|
"""
|
|
Initialize the search schedules.py command.
|
|
|
|
Args:
|
|
schedule_repo: Repository for schedule operations.
|
|
search_term: Term to search for.
|
|
"""
|
|
self.schedule_repo = schedule_repo
|
|
self.search_term = search_term
|
|
|
|
def validate(self) -> Dict[str, Any]:
|
|
"""
|
|
Validate the search schedules.py request.
|
|
|
|
Returns:
|
|
Dict[str, Any]: Validation result with 'is_valid' and optional 'errors'.
|
|
"""
|
|
errors = []
|
|
|
|
# Validate search term
|
|
if not self.search_term or len(self.search_term.strip()) < 2:
|
|
errors.append("Search term must be at least 2 characters long")
|
|
|
|
return {
|
|
'is_valid': len(errors) == 0,
|
|
'errors': errors
|
|
}
|
|
|
|
def execute(self) -> CommandResult[List[Schedule]]:
|
|
"""
|
|
Execute the search schedules.py command.
|
|
|
|
Returns:
|
|
CommandResult[List[Schedule]]: Result of the command execution with matching schedules.py.
|
|
"""
|
|
# Validate command data
|
|
validation = self.validate()
|
|
if not validation['is_valid']:
|
|
return CommandResult.failure_result(validation['errors'])
|
|
|
|
try:
|
|
# Search for schedules.py
|
|
schedules = list(self.schedule_repo.search(self.search_term))
|
|
|
|
return CommandResult.success_result(
|
|
schedules,
|
|
f"Found {len(schedules)} schedules.py matching '{self.search_term}'"
|
|
)
|
|
|
|
except Exception as e:
|
|
return CommandResult.failure_result(
|
|
str(e),
|
|
"Failed to search for schedules.py"
|
|
)
|