Child Management

Child Management provides comprehensive child profile management, therapist assignment, and subscription-based organization. This system handles child lifecycle management with critical business logic for plan-based filtering, assessment assignment, and therapist-child relationships.

Core Concepts

• Plan-Based Organization: Children organized by subscription plans with dedicated tabs
• Therapist Assignment: Assign and manage therapist-child relationships
• Assessment Management: Assign and track assessments for children
• Child Profiles: Complete child information with parent associations
• Status Management: Active/Inactive status tracking with filtering capabilities

Web/Admin Capabilities

1) List & Filter by Subscription Plans

Business Rules:

• Plan-Based Tabs: Children organized by active subscription plans
• All Children Tab: View all children regardless of subscription plan
• Search Capabilities: Search by name, unique code, parent name, or child ID
• Filter Options: Filter by gender, status, and other criteria
• Sorting: Sort by name, last active date, country, and other fields

Implementation:

// Plan-based tab organization
const availableTabValues = ['all'].concat(
  plansList?.subscription_plans.map((ele) => formatForURL(ele.name)) || [],
);

const tabsList =
  plansList?.subscription_plans?.slice()?.map((item) => {
    return {
      tabId: formatForURL(item.name),
      tabName: item.name,
      tabNode: (
        <PlanBasedChildrenTab
          planId={item.id}
          setTotalRows={setTotalRows}
          pageSize={pageSize}
          searchObj={searchStr ? searchObj : undefined}
          filters={filters}
          deleteSingleChild={deleteSingleChild}
          deleteMultipleChildren={deleteMultipleChildren}
          sortBy={sortBy}
          updateSort={updateSort}
          getSortState={getSortState}
        />
      ),
    };
  }) || [];

// Search implementation with UUID detection
const searchObj: Child_Bool_Exp = isUUID(searchStr)
  ? {
      _or: [
        { name: { _ilike: `%${searchStr}%` } },
        { unique_code: { _ilike: `%${searchStr}%` } },
        { parent: { user: { name: { _ilike: `%${searchStr}%` } } } },
        { id: { _eq: searchStr } },
      ],
    }
  : {
      _or: [
        { name: { _ilike: `%${searchStr}%` } },
        { unique_code: { _ilike: `%${searchStr}%` } },
        { parent: { user: { name: { _ilike: `%${searchStr}%` } } } },
      ],
    };

2) Child Profile Management

Child Management Business Rules:

• Profile Creation: Create new child profiles with parent associations
• Profile Editing: Edit existing child information and details
• Status Management: Activate/deactivate child accounts
• Parent Association: Link children to parent accounts
• Unique Identification: Generate and manage unique child codes

Child Profile Logic:

// Child profile validation and management
const validateChildProfile = (child: ChildInput) => {
  const errors: string[] = [];

  if (!child.name?.trim()) {
    errors.push('Child name is required');
  }

  if (!child.parent_id) {
    errors.push('Parent association is required');
  }

  if (!child.gender) {
    errors.push('Gender is required');
  }

  if (!child.date_of_birth) {
    errors.push('Date of birth is required');
  }

  return errors;
};

// Child status management
const updateChildStatus = (
  childId: string,
  status: Activity_Status_Enum_Enum,
) => {
  return updateChildMutation({
    variables: {
      child_id: childId,
      status: status,
    },
  });
};

GraphQL Implementation:

import { gql, ApolloClient } from '@apollo/client';

const GET_CHILD_LIST = gql`
  query GetChildList(
    $limit: Int
    $offset: Int
    $where: child_bool_exp
    $order_by: [child_order_by!]
  ) {
    children(
      limit: $limit
      offset: $offset
      where: $where
      order_by: $order_by
    ) {
      id
      name
      unique_code
      gender
      date_of_birth
      status
      created_at
      parent {
        id
        user {
          name
          email
          phone
          last_active
          current_country
        }
      }
      child_subscriptions {
        subscription_plan {
          id
          name
        }
      }
    }
    children_aggregate(where: $where) {
      aggregate {
        count
      }
    }
  }
`;

const DELETE_CHILDREN = gql`
  mutation DeleteChilds($child_ids: [uuid!]!) {
    deleteChilds(child_ids: $child_ids) {
      success
      message
    }
  }
`;

const UPDATE_CHILD_STATUS = gql`
  mutation UpdateChildStatus(
    $child_id: uuid!
    $status: activity_status_enum_enum!
  ) {
    update_child(where: { id: { _eq: $child_id } }, _set: { status: $status }) {
      affected_rows
    }
  }
`;

async function getChildList(
  client: ApolloClient<unknown>,
  variables: {
    limit: number;
    offset: number;
    where?: Child_Bool_Exp;
    order_by?: Child_Order_By[];
  },
) {
  const { data } = await client.query({
    query: GET_CHILD_LIST,
    variables,
    fetchPolicy: 'cache-and-network',
  });

  return {
    children: data.children,
    totalCount: data.children_aggregate.aggregate?.count || 0,
  };
}

async function deleteChildren(
  client: ApolloClient<unknown>,
  childIds: string[],
) {
  const { data } = await client.mutate({
    mutation: DELETE_CHILDREN,
    variables: { child_ids: childIds },
  });

  return data.deleteChilds;
}

3) Therapist Assignment

Therapist Assignment Business Rules:

• Assignment Modal: Dedicated modal for assigning therapists to children
• Therapist Selection: Select from available therapists with appropriate specializations
• Bulk Assignment: Assign multiple children to therapists simultaneously
• Assignment Validation: Ensure therapist specialization matches child needs
• Assignment History: Track therapist assignment history and changes

Assignment Logic:

// Therapist assignment validation
const validateTherapistAssignment = (childId: string, therapistId: string) => {
  const errors: string[] = [];

  if (!childId) {
    errors.push('Child ID is required');
  }

  if (!therapistId) {
    errors.push('Therapist ID is required');
  }

  // Check if therapist is available
  // Check if therapist specialization matches child needs
  // Check if assignment already exists

  return errors;
};

// Bulk therapist assignment
const assignMultipleChildren = (childIds: string[], therapistId: string) => {
  return Promise.all(
    childIds.map((childId) =>
      assignTherapistMutation({
        variables: {
          child_id: childId,
          therapist_id: therapistId,
        },
      }),
    ),
  );
};

4) Assessment Assignment

Assessment Assignment Business Rules:

• Assessment Selection: Choose from available assessments
• Age Validation: Ensure assessments are age-appropriate for children
• Subscription Validation: Verify child has appropriate subscription for assessment
• Assignment Tracking: Track assigned assessments and completion status
• Bulk Assignment: Assign assessments to multiple children

Assessment Assignment Logic:

// Assessment assignment validation
const validateAssessmentAssignment = (
  childId: string,
  assessmentId: string,
) => {
  const errors: string[] = [];

  if (!childId) {
    errors.push('Child ID is required');
  }

  if (!assessmentId) {
    errors.push('Assessment ID is required');
  }

  // Check child age against assessment age range
  // Check child subscription against assessment requirements
  // Check if assessment is already assigned

  return errors;
};

// Get available assessments for child
const getAvailableAssessments = (child: Child) => {
  return (
    allAssessments?.filter((assessment) => {
      // Check age appropriateness
      const childAge = calculateAge(child.date_of_birth);
      const isAgeAppropriate =
        childAge >= assessment.min_age && childAge <= assessment.max_age;

      // Check subscription compatibility
      const hasValidSubscription = child.child_subscriptions.some((sub) =>
        assessment.assessment_subscriptions.includes(sub.subscription_plan.id),
      );

      return isAgeAppropriate && hasValidSubscription;
    }) || []
  );
};

5) Child Details & Management

Child Details Business Rules:

• Comprehensive View: Display complete child information and associated data
• Appointment History: Show scheduled and completed appointments
• Assessment Progress: Track assessment completion and scores
• Lesson Plans: Display assigned lesson plans and progress
• Therapist Information: Show assigned therapist details and history

Child Details Implementation:

// Child details data structure
interface ChildDetails {
  id: string;
  name: string;
  unique_code: string;
  gender: Gender_Enum_Enum;
  date_of_birth: string;
  status: Activity_Status_Enum_Enum;
  parent: ParentInfo;
  child_subscriptions: SubscriptionInfo[];
  assigned_therapist?: TherapistInfo;
  appointments: AppointmentInfo[];
  assessments: AssessmentInfo[];
  lesson_plans: LessonPlanInfo[];
  reports: ReportInfo[];
}

// Child details aggregation
const aggregateChildData = (child: Child) => {
  return {
    ...child,
    total_appointments: child.appointments?.length || 0,
    completed_assessments:
      child.assessments?.filter((a) => a.status === 'COMPLETED').length || 0,
    active_lesson_plans:
      child.lesson_plans?.filter((lp) => lp.status === 'ACTIVE').length || 0,
    last_activity: getLastActivityDate(child),
  };
};

Data Flow (Web ↔ Backend)

Critical Business Logic Flow:

1. Child Listing: Load children → Apply plan-based filtering → Search → Sort → Paginate
2. Child Management: Create/Edit child → Validate data → Update parent association → Manage status
3. Therapist Assignment: Select children → Choose therapist → Validate compatibility → Assign relationship
4. Assessment Assignment: Select children → Choose assessments → Validate requirements → Assign assessments

GraphQL Operations with Business Rules:

Action	Operation	Business Rules
List Children	getChildList(where, order_by)	Plan-based filtering, search across multiple fields
Create Child	createChild(input)	Parent association, unique code generation
Update Child	updateChild(child_id, input)	Data validation, status management
Delete Children	deleteChilds(child_ids)	Bulk deletion with confirmation
Assign Therapist	assignTherapist(child_id, therapist_id)	Compatibility validation
Assign Assessment	assignAssessment(child_id, assessment_id)	Age and subscription validation

Error Handling & Validation:

• Child Not Found: "Child not found or access denied"
• Invalid Parent: "Parent association is required"
• Age Validation: "Assessment not suitable for child's age"
• Subscription Mismatch: "Child does not have required subscription plan"
• Therapist Assignment: "Therapist specialization does not match child needs"

Security & Access Control

• Admin-Only Access: Only admins can manage child profiles and assignments
• Parent Association: Children must be associated with valid parent accounts
• Data Privacy: Child data protected by role-based permissions
• Audit Trail: All child management actions are logged with timestamps
• Assignment Controls: Therapist and assessment assignments require proper validation