Teaching_integration_platform_admin_template/generated/services/Service.ts

/* generated using openapi-typescript-codegen -- do not edit */
/* istanbul ignore file */
/* tslint:disable */
/* eslint-disable */
import type { BaseResponse } from '../models/BaseResponse';
import type { BaseResponse_CoursesDTO_ } from '../models/BaseResponse_CoursesDTO_';
import type { BaseResponse_List_CourseObjectivesTreeVO_ } from '../models/BaseResponse_List_CourseObjectivesTreeVO_';
import type { BaseResponse_List_ObjectivesType_ } from '../models/BaseResponse_List_ObjectivesType_';
import type { BaseResponse_Map_string_object_ } from '../models/BaseResponse_Map_string_object_';
import type { BaseResponse_ObjectiveContentKnowVO_ } from '../models/BaseResponse_ObjectiveContentKnowVO_';
import type { BaseResponse_ObjectiveContents_ } from '../models/BaseResponse_ObjectiveContents_';
import type { BaseResponse_PageDTO_CoursesVO_ } from '../models/BaseResponse_PageDTO_CoursesVO_';
import type { BaseResponse_string_ } from '../models/BaseResponse_string_';
import type { CourseObjectivesDTO } from '../models/CourseObjectivesDTO';
import type { CoursesDTO } from '../models/CoursesDTO';
import type { ObjectiveContentKnowDTO } from '../models/ObjectiveContentKnowDTO';
import type { ObjectiveContents_ } from '../models/ObjectiveContents_';
import type { ObjectivesType_ } from '../models/ObjectivesType_';
import type { StudentCoursesDTO } from '../models/StudentCoursesDTO';
import type { CancelablePromise } from '../core/CancelablePromise';
import { OpenAPI } from '../core/OpenAPI';
import { request as __request } from '../core/request';
export class Service {
    /**
     * 编辑分项目标
     * @param courseObjectivesDto courseObjectivesDTO
     * @returns BaseResponse_string_ OK
     * @returns any Created
     * @throws ApiError
     */
    public static updateCourseObjectivesUsingPut1(
        courseObjectivesDto: CourseObjectivesDTO,
    ): CancelablePromise<BaseResponse_string_ | any> {
        return __request(OpenAPI, {
            method: 'PUT',
            url: '/course_objectives',
            body: courseObjectivesDto,
            errors: {
                401: `Unauthorized`,
                403: `Forbidden`,
                404: `Not Found`,
            },
        });
    }
    /**
     * 新增分项目标-默认第一个必须添加思政目标
     * @param courseObjectivesDto courseObjectivesDTO
     * @returns BaseResponse_string_ OK
     * @returns any Created
     * @throws ApiError
     */
    public static saveCourseObjectivesUsingPost1(
        courseObjectivesDto: CourseObjectivesDTO,
    ): CancelablePromise<BaseResponse_string_ | any> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/course_objectives/addobjectives',
            body: courseObjectivesDto,
            errors: {
                401: `Unauthorized`,
                403: `Forbidden`,
                404: `Not Found`,
            },
        });
    }
    /**
     * 查询课程目标内容
     * @param id id
     * @returns BaseResponse_List_CourseObjectivesTreeVO_ OK
     * @throws ApiError
     */
    public static queryCourseObjectivesTreeUsingGet1(
        id: string,
    ): CancelablePromise<BaseResponse_List_CourseObjectivesTreeVO_> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/course_objectives/list/{id}',
            path: {
                'id': id,
            },
            errors: {
                401: `Unauthorized`,
                403: `Forbidden`,
                404: `Not Found`,
            },
        });
    }
    /**
     * 删除分项目标-只能最后一个删除思政目标-总目标只需删除关联的内容
     * @param id id
     * @returns BaseResponse_string_ OK
     * @throws ApiError
     */
    public static deleteCourseObjectivesByIdsUsingDelete1(
        id: string,
    ): CancelablePromise<BaseResponse_string_> {
        return __request(OpenAPI, {
            method: 'DELETE',
            url: '/course_objectives/{id}',
            path: {
                'id': id,
            },
            errors: {
                401: `Unauthorized`,
                403: `Forbidden`,
            },
        });
    }
    /**
     * 根据id修改课程
     * @param coursesDto coursesDTO
     * @returns BaseResponse_string_ OK
     * @returns any Created
     * @throws ApiError
     */
    public static editCourseUsingPut1(
        coursesDto: CoursesDTO,
    ): CancelablePromise<BaseResponse_string_ | any> {
        return __request(OpenAPI, {
            method: 'PUT',
            url: '/coursesteacher',
            body: coursesDto,
            errors: {
                401: `Unauthorized`,
                403: `Forbidden`,
                404: `Not Found`,
            },
        });
    }
    /**
     * 新增课程--同步新增课程的总体目标并同时添加所有的分项目标
     * @param coursesDto coursesDTO
     * @returns BaseResponse_string_ OK
     * @returns any Created
     * @throws ApiError
     */
    public static saveCourseUsingPost1(
        coursesDto: CoursesDTO,
    ): CancelablePromise<BaseResponse_string_ | any> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/coursesteacher/addcourse',
            body: coursesDto,
            errors: {
                401: `Unauthorized`,
                403: `Forbidden`,
                404: `Not Found`,
            },
        });
    }
    /**
     * 导出word
     * @returns any OK
     * @throws ApiError
     */
    public static testUsingGet1(): CancelablePromise<any> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/coursesteacher/down',
            errors: {
                401: `Unauthorized`,
                403: `Forbidden`,
                404: `Not Found`,
            },
        });
    }
    /**
     * 网站首页
     * @param page page
     * @param pageSize pageSize
     * @returns BaseResponse_Map_string_object_ OK
     * @throws ApiError
     */
    public static getDataUsingGet1(
        page: number,
        pageSize: number,
    ): CancelablePromise<BaseResponse_Map_string_object_> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/coursesteacher/index',
            query: {
                'page': page,
                'pageSize': pageSize,
            },
            errors: {
                401: `Unauthorized`,
                403: `Forbidden`,
                404: `Not Found`,
            },
        });
    }
    /**
     * 查询课程列表
     * @param username 用户的username
     * @param assessmenttype 课程考核类型
     * @param category 课程类别
     * @param isAsc 是否升序
     * @param name 课程名称关键字
     * @param nature 课程性质
     * @param pageNo 页码
     * @param pageSize 每页数量
     * @param sortBy 排序字段
     * @param teacher 课程任课教师
     * @returns BaseResponse_PageDTO_CoursesVO_ OK
     * @throws ApiError
     */
    public static getCoursesUsingGet1(
        username: string,
        assessmenttype?: string,
        category?: string,
        isAsc?: boolean,
        name?: string,
        nature?: string,
        pageNo?: number,
        pageSize?: number,
        sortBy?: string,
        teacher?: string,
    ): CancelablePromise<BaseResponse_PageDTO_CoursesVO_> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/coursesteacher/page',
            query: {
                'assessmenttype': assessmenttype,
                'category': category,
                'isAsc': isAsc,
                'name': name,
                'nature': nature,
                'pageNo': pageNo,
                'pageSize': pageSize,
                'sortBy': sortBy,
                'teacher': teacher,
                'username': username,
            },
            errors: {
                401: `Unauthorized`,
                403: `Forbidden`,
                404: `Not Found`,
            },
        });
    }
    /**
     * 根据id查询课程
     * @param id id
     * @returns BaseResponse_CoursesDTO_ OK
     * @throws ApiError
     */
    public static getByIdCourseUsingGet1(
        id: string,
    ): CancelablePromise<BaseResponse_CoursesDTO_> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/coursesteacher/{id}',
            path: {
                'id': id,
            },
            errors: {
                401: `Unauthorized`,
                403: `Forbidden`,
                404: `Not Found`,
            },
        });
    }
    /**
     * 根据id删除课程
     * @param id id
     * @returns BaseResponse OK
     * @throws ApiError
     */
    public static deleteCoursesUsingDelete1(
        id: string,
    ): CancelablePromise<BaseResponse> {
        return __request(OpenAPI, {
            method: 'DELETE',
            url: '/coursesteacher/{id}',
            path: {
                'id': id,
            },
            errors: {
                401: `Unauthorized`,
                403: `Forbidden`,
            },
        });
    }
    /**
     * 给分项目标或者是内容添加知识点
     * @param objectiveContentKnowDto objectiveContentKnowDTO
     * @returns BaseResponse_string_ OK
     * @returns any Created
     * @throws ApiError
     */
    public static saveKnowsWithObjectiveOrContentUsingPost1(
        objectiveContentKnowDto: ObjectiveContentKnowDTO,
    ): CancelablePromise<BaseResponse_string_ | any> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/objective_content_know/addknows',
            body: objectiveContentKnowDto,
            errors: {
                401: `Unauthorized`,
                403: `Forbidden`,
                404: `Not Found`,
            },
        });
    }
    /**
     * 针对分项目标统计，支撑分项目标知识点的个数、学时合计、占比
     * @param objectiveId objectiveId
     * @returns BaseResponse_ObjectiveContentKnowVO_ OK
     * @throws ApiError
     */
    public static getCountDataUsingGet1(
        objectiveId: string,
    ): CancelablePromise<BaseResponse_ObjectiveContentKnowVO_> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/objective_content_know/{objectiveId}',
            path: {
                'objectiveId': objectiveId,
            },
            errors: {
                401: `Unauthorized`,
                403: `Forbidden`,
                404: `Not Found`,
            },
        });
    }
    /**
     * 添加目标内容
     * @param objectiveContents objectiveContents
     * @returns BaseResponse_string_ OK
     * @returns any Created
     * @throws ApiError
     */
    public static saveContentUsingPost1(
        objectiveContents: ObjectiveContents_,
    ): CancelablePromise<BaseResponse_string_ | any> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/objective_contents/addcontent',
            body: objectiveContents,
            errors: {
                401: `Unauthorized`,
                403: `Forbidden`,
                404: `Not Found`,
            },
        });
    }
    /**
     * 修改目标内容
     * @param objectiveContents objectiveContents
     * @returns BaseResponse_string_ OK
     * @returns any Created
     * @throws ApiError
     */
    public static updateContentUsingPut1(
        objectiveContents: ObjectiveContents_,
    ): CancelablePromise<BaseResponse_string_ | any> {
        return __request(OpenAPI, {
            method: 'PUT',
            url: '/objective_contents/update',
            body: objectiveContents,
            errors: {
                401: `Unauthorized`,
                403: `Forbidden`,
                404: `Not Found`,
            },
        });
    }
    /**
     * 根据id查询目标内容
     * @param id id
     * @returns BaseResponse_ObjectiveContents_ OK
     * @throws ApiError
     */
    public static updateContentUsingGet1(
        id: string,
    ): CancelablePromise<BaseResponse_ObjectiveContents_> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/objective_contents/{id}',
            path: {
                'id': id,
            },
            errors: {
                401: `Unauthorized`,
                403: `Forbidden`,
                404: `Not Found`,
            },
        });
    }
    /**
     * 删除目标内容
     * @param id id
     * @returns BaseResponse_string_ OK
     * @throws ApiError
     */
    public static deleteContentUsingDelete1(
        id: string,
    ): CancelablePromise<BaseResponse_string_> {
        return __request(OpenAPI, {
            method: 'DELETE',
            url: '/objective_contents/{id}',
            path: {
                'id': id,
            },
            errors: {
                401: `Unauthorized`,
                403: `Forbidden`,
            },
        });
    }
    /**
     * 修改目标类型
     * @param objectivesType objectivesType
     * @returns BaseResponse_string_ OK
     * @returns any Created
     * @throws ApiError
     */
    public static updateObjectivesUsingPut1(
        objectivesType: ObjectivesType_,
    ): CancelablePromise<BaseResponse_string_ | any> {
        return __request(OpenAPI, {
            method: 'PUT',
            url: '/objectives_type',
            body: objectivesType,
            errors: {
                401: `Unauthorized`,
                403: `Forbidden`,
                404: `Not Found`,
            },
        });
    }
    /**
     * 新增目标类型
     * @param objectivesType objectivesType
     * @returns BaseResponse_string_ OK
     * @returns any Created
     * @throws ApiError
     */
    public static saveObjectivesUsingPost1(
        objectivesType: ObjectivesType_,
    ): CancelablePromise<BaseResponse_string_ | any> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/objectives_type/addobjectives',
            body: objectivesType,
            errors: {
                401: `Unauthorized`,
                403: `Forbidden`,
                404: `Not Found`,
            },
        });
    }
    /**
     * 删除目标类型
     * @param id id
     * @returns BaseResponse_string_ OK
     * @throws ApiError
     */
    public static deleteObjectivesUsingDelete1(
        id: string,
    ): CancelablePromise<BaseResponse_string_> {
        return __request(OpenAPI, {
            method: 'DELETE',
            url: '/objectives_type/deleteobjectives/{id}',
            path: {
                'id': id,
            },
            errors: {
                401: `Unauthorized`,
                403: `Forbidden`,
            },
        });
    }
    /**
     * 列表显示目标类型
     * @returns BaseResponse_List_ObjectivesType_ OK
     * @throws ApiError
     */
    public static objectivesListUsingGet1(): CancelablePromise<BaseResponse_List_ObjectivesType_> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/objectives_type/list',
            errors: {
                401: `Unauthorized`,
                403: `Forbidden`,
                404: `Not Found`,
            },
        });
    }
    /**
     * 给学生添加课程
     * @param studentCoursesDto studentCoursesDTO
     * @returns BaseResponse_string_ OK
     * @returns any Created
     * @throws ApiError
     */
    public static saveCoursesToStudentsUsingPost1(
        studentCoursesDto: StudentCoursesDTO,
    ): CancelablePromise<BaseResponse_string_ | any> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/student_courses/addcoursess',
            body: studentCoursesDto,
            errors: {
                401: `Unauthorized`,
                403: `Forbidden`,
                404: `Not Found`,
            },
        });
    }
}