@iblai/iblai-api 3.34.5-ai

package/src/services/PlatformService.ts

@@ -0,0 +1,181 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { Count } from '../models/Count';
+import type { PerlearnerCourseProgress } from '../models/PerlearnerCourseProgress';
+import type { VideosCount } from '../models/VideosCount';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class PlatformService {
+    /**
+     * Base class for API views that return a single count value.
+     *
+     * This class formats the response as {"data": {value_key: count}} where
+     * value_key is configurable (defaults to "count").
+     *
+     * Attributes:
+     * value_key: The key used in the response for the count value
+     * @param courseId
+     * @param org
+     * @param userId
+     * @returns any No response body
+     * @throws ApiError
+     */
+    public static platformOrgsCoursesUsersGradesPassedRetrieve(
+        courseId: string,
+        org: string,
+        userId: string,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/platform/orgs/{org}/courses/{course_id}/users/{user_id}/grades/passed',
+            path: {
+                'course_id': courseId,
+                'org': org,
+                'user_id': userId,
+            },
+        });
+    }
+    /**
+     * Gives Percentage of units completed in course for a specific learner
+     * @param courseId
+     * @param org
+     * @param userId
+     * @param departmentId When `department_mode=1` is passed, it allows to filter data for only user content groups for the specified department
+     * @param format Format
+     *
+     * * `json` - json
+     * @param includeMainPlatform Include main platform data
+     * @returns PerlearnerCourseProgress
+     * @throws ApiError
+     */
+    public static platformOrgsCoursesUsersProgressRetrieve(
+        courseId: string,
+        org: string,
+        userId: string,
+        departmentId?: number,
+        format: 'json' = 'json',
+        includeMainPlatform: boolean = true,
+    ): CancelablePromise<PerlearnerCourseProgress> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/platform/orgs/{org}/courses/{course_id}/users/{user_id}/progress',
+            path: {
+                'course_id': courseId,
+                'org': org,
+                'user_id': userId,
+            },
+            query: {
+                'department_id': departmentId,
+                'format': format,
+                'include_main_platform': includeMainPlatform,
+            },
+        });
+    }
+    /**
+     * Average days used to complete a course
+     *
+     * Query Params
+     * 1. course_id <optional> e.g course-v1:Org+Course4+Run
+     * @param courseId
+     * @param org
+     * @param userId
+     * @returns any No response body
+     * @throws ApiError
+     */
+    public static platformOrgsCoursesUsersProgressDaysToCompleteRetrieve(
+        courseId: string,
+        org: string,
+        userId: string,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/platform/orgs/{org}/courses/{course_id}/users/{user_id}/progress/days-to-complete',
+            path: {
+                'course_id': courseId,
+                'org': org,
+                'user_id': userId,
+            },
+        });
+    }
+    /**
+     * Time spent count in seconds within a course by a learner
+     * @param courseId
+     * @param org
+     * @param userId
+     * @param departmentId When `department_mode=1` is passed, it allows to filter data for only user content groups for the specified department
+     * @param endDate end date. ISO 8601
+     * @param format Format
+     *
+     * * `json` - json
+     * @param includeMainPlatform Include main platform data
+     * @param startDate start date. ISO 8601
+     * @returns Count
+     * @throws ApiError
+     */
+    public static platformOrgsCoursesUsersTimeCountRetrieve(
+        courseId: string,
+        org: string,
+        userId: string,
+        departmentId?: number,
+        endDate?: string,
+        format: 'json' = 'json',
+        includeMainPlatform: boolean = true,
+        startDate?: string,
+    ): CancelablePromise<Count> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/platform/orgs/{org}/courses/{course_id}/users/{user_id}/time/count',
+            path: {
+                'course_id': courseId,
+                'org': org,
+                'user_id': userId,
+            },
+            query: {
+                'department_id': departmentId,
+                'end_date': endDate,
+                'format': format,
+                'include_main_platform': includeMainPlatform,
+                'start_date': startDate,
+            },
+        });
+    }
+    /**
+     * (Total videos watched / Total Course Videos) or Total Videos watched in a course by a learner
+     * @param courseId
+     * @param org
+     * @param userId
+     * @param departmentId When `department_mode=1` is passed, it allows to filter data for only user content groups for the specified department
+     * @param format Format
+     *
+     * * `json` - json
+     * @param includeMainPlatform Include main platform data
+     * @returns VideosCount
+     * @throws ApiError
+     */
+    public static platformOrgsCoursesUsersVideosCountRetrieve(
+        courseId: string,
+        org: string,
+        userId: string,
+        departmentId?: number,
+        format: 'json' = 'json',
+        includeMainPlatform: boolean = true,
+    ): CancelablePromise<VideosCount> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/platform/orgs/{org}/courses/{course_id}/users/{user_id}/videos/count',
+            path: {
+                'course_id': courseId,
+                'org': org,
+                'user_id': userId,
+            },
+            query: {
+                'department_id': departmentId,
+                'format': format,
+                'include_main_platform': includeMainPlatform,
+            },
+        });
+    }
+}

package/src/services/RecommendationsService.ts

@@ -0,0 +1,31 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { RecommendationSearchAPI } from '../models/RecommendationSearchAPI';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class RecommendationsService {
+    /**
+     * API endpoint that returns a search api url prepopulated with context data
+     * See http://localhost:8000/api/schema/swagger-ui/#/recommendations
+     * @param org
+     * @param userId
+     * @returns RecommendationSearchAPI
+     * @throws ApiError
+     */
+    public static recommendationsOrgsUsersRetrieve(
+        org: string,
+        userId: string,
+    ): CancelablePromise<RecommendationSearchAPI> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/recommendations/orgs/{org}/users/{user_id}/',
+            path: {
+                'org': org,
+                'user_id': userId,
+            },
+        });
+    }
+}

package/src/services/ReportsService.ts

@@ -0,0 +1,218 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { ReportCreate } from '../models/ReportCreate';
+import type { ReportDetail } from '../models/ReportDetail';
+import type { ReportList } from '../models/ReportList';
+import type { ReportRequest } from '../models/ReportRequest';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class ReportsService {
+    /**
+     * Lists all available reports in the system.
+     *
+     * This endpoint returns a list of all reports available to the user, including:
+     * - Report metadata (name, description, icon)
+     * - Available query parameters for each report
+     * - Result columns that will be returned
+     * - Current status of any previously requested reports
+     *
+     * If a report has been previously requested by the user, its status will be included
+     * in the response. Expired reports are automatically cleaned up.
+     *
+     * Returns:
+     * A list of report objects with their metadata and status information.
+     * @param org
+     * @returns ReportList
+     * @throws ApiError
+     */
+    public static reportsOrgsRetrieve(
+        org: string,
+    ): CancelablePromise<ReportList> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/reports/orgs/{org}/',
+            path: {
+                'org': org,
+            },
+        });
+    }
+    /**
+     * Retrieves detailed information about a specific report type.
+     *
+     * This endpoint provides:
+     * - Metadata about the report (name, description, icon)
+     * - Available query parameters for the report
+     * - Result columns that will be returned
+     * - Current status of the most recent report of this type requested by the user
+     *
+     * Path Parameters:
+     * report_name (str): The identifier of the report to retrieve details for
+     *
+     * Returns:
+     * Detailed information about the report type and its current status if previously requested.
+     *
+     * Error Responses:
+     * 404 Not Found: If the specified report type doesn't exist
+     * @param org
+     * @param reportName
+     * @returns ReportDetail
+     * @throws ApiError
+     */
+    public static reportsOrgsRetrieve2(
+        org: string,
+        reportName: string,
+    ): CancelablePromise<ReportDetail> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/reports/orgs/{org}/{report_name}',
+            path: {
+                'org': org,
+                'report_name': reportName,
+            },
+        });
+    }
+    /**
+     * Creates and manages report generation requests.
+     *
+     * This endpoint allows users to:
+     * 1. Request a new report generation
+     * 2. Check the status of a previously requested report
+     * 3. Force regeneration of an existing report
+     *
+     * Reports expire after a configured time period (default is typically 24-48 hours).
+     *
+     * Request Parameters:
+     * report_name (str): The identifier of the report to generate
+     * owner (str): The username of the report owner (usually the current user)
+     * learner_id (str, optional): Filter by specific learner
+     * course_id (str, optional): Filter by specific course
+     * start_date (str, optional): Start date for report data (ISO format)
+     * end_date (str, optional): End date for report data (ISO format)
+     * filters (dict, optional): Additional filters specific to the report type
+     * force (bool, optional): Force regeneration even if a valid report exists
+     *
+     * Returns:
+     * For new reports:
+     * - report_id: The unique identifier for the report task
+     * - state: The current state of the report (PENDING, RUNNING, etc.)
+     *
+     * For completed reports:
+     * - report_id: The unique identifier for the report task
+     * - report_name: The name of the report
+     * - url: Download URL for the report
+     * - state: COMPLETED
+     * - expires: Expiration timestamp for the report
+     *
+     * For in-progress reports:
+     * - report_id: The unique identifier for the report task
+     * - state: Current state (PENDING, RUNNING)
+     * - started_on: When the report generation started
+     * - owner: Username of the report owner
+     *
+     * Error Responses:
+     * 400 Bad Request: Invalid parameters or report configuration
+     * 404 Not Found: Report type not found
+     * 403 Forbidden: User doesn't have permission for the requested report
+     * @param org
+     * @param requestBody
+     * @returns ReportCreate
+     * @throws ApiError
+     */
+    public static reportsOrgsNewCreate(
+        org: string,
+        requestBody?: ReportRequest,
+    ): CancelablePromise<ReportCreate> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/reports/orgs/{org}/new',
+            path: {
+                'org': org,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Returns a list of reports available in the system.
+     *
+     * For each report, it includes:
+     * - display_name: Human-readable name of the report
+     * - description: Description of what the report contains
+     * - icon: URL to an icon representing the report
+     * - report_name: Unique identifier for the report
+     * - extra_query_params: Additional parameters that can be passed when creating the report
+     * - result_columns: Columns that will be included in the report results
+     * - status: Current status of the report if it has been previously requested
+     *
+     * The status will include details like the report ID, state, and download URL if completed.
+     * @param key
+     * @returns ReportList
+     * @throws ApiError
+     */
+    public static reportsPlatformsRetrieve(
+        key: string,
+    ): CancelablePromise<ReportList> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/reports/platforms/{key}/',
+            path: {
+                'key': key,
+            },
+        });
+    }
+    /**
+     * Returns details of a specific report type including its status if previously requested.
+     * @param key
+     * @param reportName
+     * @returns ReportDetail
+     * @throws ApiError
+     */
+    public static reportsPlatformsRetrieve2(
+        key: string,
+        reportName: string,
+    ): CancelablePromise<ReportDetail> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/reports/platforms/{key}/{report_name}',
+            path: {
+                'key': key,
+                'report_name': reportName,
+            },
+        });
+    }
+    /**
+     * Triggers a new report generation.
+     *
+     * If the report has been previously requested, it returns the status of the report.
+     * Reports expire after a configured duration.
+     *
+     * The request body should include:
+     * - report_name: Name of the report to generate
+     * - learner_id: (optional) ID of the learner to filter by
+     * - course_id: (optional) ID of the course to filter by
+     * - force: (optional) Force generation of a new report even if one exists
+     * - filters: (optional) Additional filters for the report
+     * - departments: (optional) Department IDs to filter by
+     * @param key
+     * @param requestBody
+     * @returns ReportCreate
+     * @throws ApiError
+     */
+    public static reportsPlatformsNewCreate(
+        key: string,
+        requestBody?: ReportRequest,
+    ): CancelablePromise<ReportCreate> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/reports/platforms/{key}/new',
+            path: {
+                'key': key,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+}