analytica-frontend-lib/dist/chunk-BMJTQFRE.mjs

Repositório público dos componentes utilizados nas plataformas da Analytica Ensino

import {
  extractBreakdownFilterOptions,
  mergeFilterOptions
} from "./chunk-XRPLT7ML.mjs";
import {
  mapApiStatusToDisplay
} from "./chunk-DG76FRXG.mjs";

// src/hooks/useActivitiesHistory.ts
import { useState, useCallback } from "react";
import dayjs from "dayjs";
var DEFAULT_ACTIVITIES_PAGINATION = {
  total: 0,
  page: 1,
  limit: 10,
  totalPages: 0
};
var DEFAULT_ACTIVITY_FILTER_OPTIONS = {
  schools: [],
  classes: [],
  subjects: [],
  schoolYears: []
};
var transformActivityToTableItem = (activity) => {
  const firstBreakdown = activity.breakdown?.[0];
  return {
    id: activity.id,
    startDate: activity.startDate ? dayjs(activity.startDate).format("DD/MM") : "-",
    deadline: activity.finalDate ? dayjs(activity.finalDate).format("DD/MM") : "-",
    creator: activity.creator?.name?.trim() ? activity.creator.name : "-",
    creatorId: activity.creator?.id ?? null,
    title: activity.title,
    school: firstBreakdown?.school?.name ?? "-",
    year: firstBreakdown?.schoolYear?.name ?? "-",
    subject: activity.subject?.name ?? "-",
    class: firstBreakdown?.class?.name ?? "-",
    status: mapApiStatusToDisplay(activity.status),
    completionPercentage: activity.completionPercentage
  };
};
var extractActivityFilterOptions = (activities) => extractBreakdownFilterOptions(activities);
var toCsv = (value) => {
  if (Array.isArray(value) && value.length > 0) {
    return value.map(String).join(",");
  }
  return void 0;
};
var toSingle = (value) => {
  if (Array.isArray(value)) {
    return value.length > 0 ? String(value[0]) : void 0;
  }
  if (typeof value === "string" && value.length > 0) {
    return value;
  }
  return void 0;
};
var assignIf = (params, key, value) => {
  if (value) {
    params[key] = value;
  }
};
var PASSTHROUGH_KEYS = [
  "page",
  "limit",
  "search",
  "startDate",
  "finalDate",
  "sortBy",
  "sortOrder"
];
var buildActivityHistoryQueryParams = (filters, activityCategory) => {
  const params = {};
  assignIf(params, "type", activityCategory);
  if (!filters) {
    return params;
  }
  for (const key of PASSTHROUGH_KEYS) {
    const value = filters[key];
    if (value !== void 0 && value !== null && value !== "") {
      params[key] = value;
    }
  }
  assignIf(params, "schoolIds", toCsv(filters.school));
  assignIf(params, "classIds", toCsv(filters.class));
  assignIf(params, "schoolYearIds", toCsv(filters.schoolYear));
  if (!params.schoolIds) {
    assignIf(params, "schoolId", toSingle(filters.schoolId));
  }
  if (!params.classIds) {
    assignIf(params, "classId", toSingle(filters.classId));
  }
  assignIf(params, "status", toSingle(filters.status));
  assignIf(
    params,
    "subjectId",
    toSingle(filters.subject) ?? toSingle(filters.subjectId)
  );
  assignIf(params, "creatorType", toSingle(filters.creatorType));
  return params;
};
var useActivitiesHistoryImpl = (apiClient, options) => {
  const [state, setState] = useState({
    activities: [],
    loading: false,
    error: null,
    pagination: DEFAULT_ACTIVITIES_PAGINATION,
    apiFilterOptions: DEFAULT_ACTIVITY_FILTER_OPTIONS
  });
  const fetchActivities = useCallback(
    async (filters) => {
      setState((prev) => ({ ...prev, loading: true, error: null }));
      try {
        const params = buildActivityHistoryQueryParams(
          filters,
          options?.activityCategory
        );
        const response = await apiClient.get(
          "/activities/history",
          { params }
        );
        const { data } = response.data;
        const tableItems = data.activities.map(transformActivityToTableItem);
        const extracted = extractActivityFilterOptions(data.activities);
        setState((prev) => ({
          activities: tableItems,
          loading: false,
          error: null,
          pagination: data.pagination,
          apiFilterOptions: {
            schools: mergeFilterOptions(
              prev.apiFilterOptions.schools,
              extracted.schools
            ),
            classes: mergeFilterOptions(
              prev.apiFilterOptions.classes,
              extracted.classes
            ),
            subjects: mergeFilterOptions(
              prev.apiFilterOptions.subjects,
              extracted.subjects
            ),
            schoolYears: mergeFilterOptions(
              prev.apiFilterOptions.schoolYears,
              extracted.schoolYears
            )
          }
        }));
      } catch (error) {
        console.error("Erro ao carregar hist\xF3rico:", error);
        setState((prev) => ({
          ...prev,
          loading: false,
          error: "Erro ao carregar hist\xF3rico de atividades"
        }));
      }
    },
    [apiClient, options?.activityCategory]
  );
  return { ...state, fetchActivities };
};
var createUseActivitiesHistory = (apiClient, options) => {
  return () => useActivitiesHistoryImpl(apiClient, options);
};
var createActivitiesHistoryHook = createUseActivitiesHistory;

export {
  DEFAULT_ACTIVITIES_PAGINATION,
  DEFAULT_ACTIVITY_FILTER_OPTIONS,
  transformActivityToTableItem,
  extractActivityFilterOptions,
  buildActivityHistoryQueryParams,
  createUseActivitiesHistory,
  createActivitiesHistoryHook
};
//# sourceMappingURL=chunk-BMJTQFRE.mjs.map