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`,
      },
    })
  }
}