dlsx
/
Teaching_integration_platform_admin_template
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
166 Commits
3 Branches
0 Tags
106 MiB
 
 
 
 
 
Tag: Branch: Tree: 971304bb30
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '971304bb30'
${ noResults }
Teaching_integration_platfo.../generated/services/Service.ts

512 lines
16 KiB
Raw Blame History

/* 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: '/api/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: '/api/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: '/api/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: '/api/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: '/api/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: '/api/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: '/api/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: '/api/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: '/api/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: '/api/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: '/api/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: '/api/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: '/api/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: '/api/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: '/api/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: '/api/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: '/api/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: '/api/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: '/api/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: '/api/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: '/api/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: '/api/student_courses/addcoursess',
body: studentCoursesDto,
errors: {
401: `Unauthorized`,
403: `Forbidden`,
404: `Not Found`,
},
});
}
}