fis_lib_jsonrpc/lib/services/education.dart

import 'dart:core';

import 'package:fis_jsonrpc/client_base.dart';
import 'package:fis_common/json_convert.dart';

import 'education.m.dart';

import 'liveConsultation.m.dart';
import 'notification.m.dart';


class EducationService extends JsonRpcClientBase {
	EducationService(
		String host, {
		String serviceName = "IEducationService",
		Map<String, String>? headers,
		int? timeout,
	}) : super(
						host,
						serviceName,
						headers: headers,
						timeout: timeout,
				) {
		/// 注册响应实体反序列化处理器
		FJsonConvert.setDecoder((map) => CourseLabelDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => PageResult<CourseInfoDetailDTO>.fromJson(map));
		FJsonConvert.setDecoder((map) => CourseInfoDetailDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => PageResult<CourseAlbumDTO>.fromJson(map));
		FJsonConvert.setDecoder((map) => CourseAlbumDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => PageResult<UserGroupDTO>.fromJson(map));
		FJsonConvert.setDecoder((map) => UserGroupDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => PageResult<VideoInfoDTO>.fromJson(map));
		FJsonConvert.setDecoder((map) => VideoInfoDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => BuyCourseResult.fromJson(map));
		FJsonConvert.setDecoder((map) => BaseCourseExaminationDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => CourseExaminationDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => PageResult<BaseStudentExaminationDTO>.fromJson(map));
		FJsonConvert.setDecoder((map) => BaseStudentExaminationDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => StudentExaminationDetailDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => InitiateLiveCourseResult.fromJson(map));
		FJsonConvert.setDecoder((map) => JoinLiveCourseResult.fromJson(map));
		FJsonConvert.setDecoder((map) => StudentLivePullUrlResult.fromJson(map));
		FJsonConvert.setDecoder((map) => LiveHeartRateResult.fromJson(map));
		FJsonConvert.setDecoder((map) => LiveCourseBaseResult.fromJson(map));
		FJsonConvert.setDecoder((map) => LiveCourseMember.fromJson(map));
		FJsonConvert.setDecoder((map) => RemoteExaminationPageDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => PageResult<CourseCommonInfoDTO>.fromJson(map));
		FJsonConvert.setDecoder((map) => CourseCommonInfoDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => CourseAlbumExtendDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => BaseCourseAlbumDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => UserGroupStudentsDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => PageResult<UserExtendDTO>.fromJson(map));
		FJsonConvert.setDecoder((map) => UserExtendDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => UserBaseDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => CourseBrowsedRecordDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => PageResult<CourseBrowsedRecordDTO>.fromJson(map));
		FJsonConvert.setDecoder((map) => CourseVisitorsStatisticResult.fromJson(map));
	}

	Future<List<CourseLabelDTO>> getCourseLabelsAsync(QueryCourseLabelListRequest request) async {
		var rpcRst = await call("GetCourseLabelsAsync", request);
		var result = (rpcRst as List).map((e)=>CourseLabelDTO.fromJson(e as Map<String, dynamic>)).toList();
		return result;
	}

	Future<bool> applyCourseAsync(ApplyCourseRequest request) async {
		var rpcRst = await call("ApplyCourseAsync", request);
		return rpcRst;
	}

	Future<PageResult<CourseInfoDetailDTO>> findCoursePagesAsync(FindCoursePagesRequest request) async {
		var rpcRst = await call("FindCoursePagesAsync", request);
		var result = PageResult<CourseInfoDetailDTO>.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> deleteCourseByCodeAsync(DeleteCourseByCodeRequest request) async {
		var rpcRst = await call("DeleteCourseByCodeAsync", request);
		return rpcRst;
	}

	Future<bool> updateCourseAsync(UpdateCourseRequest request) async {
		var rpcRst = await call("UpdateCourseAsync", request);
		return rpcRst;
	}

	Future<CourseInfoDetailDTO> findCourseByCodeAsync(FindCourseByCodeRequest request) async {
		var rpcRst = await call("FindCourseByCodeAsync", request);
		var result = CourseInfoDetailDTO.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<PageResult<CourseInfoDetailDTO>> findMyCoursePagesAsync(FindMyCoursePagesRequest request) async {
		var rpcRst = await call("FindMyCoursePagesAsync", request);
		var result = PageResult<CourseInfoDetailDTO>.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<PageResult<CourseAlbumDTO>> findMyAlbumPagesAsync(FindMyCoursePagesRequest request) async {
		var rpcRst = await call("FindMyAlbumPagesAsync", request);
		var result = PageResult<CourseAlbumDTO>.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<PageResult<UserGroupDTO>> getUserGroupListsByCreatorCodeAsync(QueryUserGroupPageRequest request) async {
		var rpcRst = await call("GetUserGroupListsByCreatorCodeAsync", request);
		var result = PageResult<UserGroupDTO>.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> addUserGroupAsync(UserGroupRequest request) async {
		var rpcRst = await call("AddUserGroupAsync", request);
		return rpcRst;
	}

	Future<bool> removeStudentsByGroupCodeAsync(UserGroupFilterRequest request) async {
		var rpcRst = await call("RemoveStudentsByGroupCodeAsync", request);
		return rpcRst;
	}

	Future<bool> createVideoAsync(SaveVideoRequest request) async {
		var rpcRst = await call("CreateVideoAsync", request);
		return rpcRst;
	}

	Future<PageResult<VideoInfoDTO>> findVideosPagesAsync(FindVideoPagesRequest request) async {
		var rpcRst = await call("FindVideosPagesAsync", request);
		var result = PageResult<VideoInfoDTO>.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> deleteVideoByCodeAsync(DeleteVideoRequest request) async {
		var rpcRst = await call("DeleteVideoByCodeAsync", request);
		return rpcRst;
	}

	Future<BuyCourseResult> buyCourseAsync(BuyCourseRequest request) async {
		var rpcRst = await call("BuyCourseAsync", request);
		var result = BuyCourseResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> paymentCallbackAsync(PaymentCallbackRequest request) async {
		var rpcRst = await call("PaymentCallbackAsync", request);
		return rpcRst;
	}

	Future<bool> signUpCourseAsync(SignUpCourseRequest request) async {
		var rpcRst = await call("SignUpCourseAsync", request);
		return rpcRst;
	}

	Future<bool> cancelSignUpCourseAsync(CancelSignUpCourseRequest request) async {
		var rpcRst = await call("CancelSignUpCourseAsync", request);
		return rpcRst;
	}

	Future<PageResult<VideoInfoDTO>> findVideoFilesCourseTypeByPageAsync(FindVideoFilesCourseTypeByPageRequest request) async {
		var rpcRst = await call("FindVideoFilesCourseTypeByPageAsync", request);
		var result = PageResult<VideoInfoDTO>.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> publishCourseExaminationPaperAsync(PublishCourseExaminationPaperRequest request) async {
		var rpcRst = await call("PublishCourseExaminationPaperAsync", request);
		return rpcRst;
	}

	Future<List<BaseCourseExaminationDTO>> findCourseExaminationPapersAsync(FindCourseExaminationPapersRequest request) async {
		var rpcRst = await call("FindCourseExaminationPapersAsync", request);
		var result = (rpcRst as List).map((e)=>BaseCourseExaminationDTO.fromJson(e as Map<String, dynamic>)).toList();
		return result;
	}

	Future<CourseExaminationDTO> findCourseExaminationPaperByCodeAsync(FindCourseExaminationPaperByCodeRequest request) async {
		var rpcRst = await call("FindCourseExaminationPaperByCodeAsync", request);
		var result = CourseExaminationDTO.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> submitCourseExaminationPaperAsync(SubmitCourseExaminationPaperRequest request) async {
		var rpcRst = await call("SubmitCourseExaminationPaperAsync", request);
		return rpcRst;
	}

	Future<PageResult<BaseStudentExaminationDTO>> findCourseStudentExaminationPagesAsync(FindCourseStudentExaminationPagesRequest request) async {
		var rpcRst = await call("FindCourseStudentExaminationPagesAsync", request);
		var result = PageResult<BaseStudentExaminationDTO>.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<StudentExaminationDetailDTO> findStudentExaminationByCodeAsync(FindStudentExaminationByCodeRequest request) async {
		var rpcRst = await call("FindStudentExaminationByCodeAsync", request);
		var result = StudentExaminationDetailDTO.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> submitReviewStudentExaminationAsync(SubmitReviewStudentExaminationRequest request) async {
		var rpcRst = await call("SubmitReviewStudentExaminationAsync", request);
		return rpcRst;
	}

	Future<PageResult<BaseStudentExaminationDTO>> findMyCourseStudentExaminationResultsAsync(FindMyCourseStudentExaminationResultPagesRequest request) async {
		var rpcRst = await call("FindMyCourseStudentExaminationResultsAsync", request);
		var result = PageResult<BaseStudentExaminationDTO>.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<StudentExaminationDetailDTO> findMyCourseStudentExaminationResultAsync(FindMyCourseStudentExaminationResultRequest request) async {
		var rpcRst = await call("FindMyCourseStudentExaminationResultAsync", request);
		var result = StudentExaminationDetailDTO.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<InitiateLiveCourseResult> initiateLiveCourseAsync(InitiateLiveCourseRequest request) async {
		var rpcRst = await call("InitiateLiveCourseAsync", request);
		var result = InitiateLiveCourseResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<JoinLiveCourseResult> joinLiveCourseAsync(JoinLiveCourseRequest request) async {
		var rpcRst = await call("JoinLiveCourseAsync", request);
		var result = JoinLiveCourseResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<StudentLivePullUrlResult> getCoursePullUrlAsync(InitiateLiveCourseRequest request) async {
		var rpcRst = await call("GetCoursePullUrlAsync", request);
		var result = StudentLivePullUrlResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<LiveHeartRateResult> heartRateAsync(LiveHeartRateRequest request) async {
		var rpcRst = await call("HeartRateAsync", request);
		var result = LiveHeartRateResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<LiveCourseBaseResult> leaveLiveCourseAsync(LeaveLiveCourseRequest request) async {
		var rpcRst = await call("LeaveLiveCourseAsync", request);
		var result = LiveCourseBaseResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<LiveCourseBaseResult> completedLiveCourseAsync(LeaveLiveCourseRequest request) async {
		var rpcRst = await call("CompletedLiveCourseAsync", request);
		var result = LiveCourseBaseResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<LiveCourseBaseResult> setMuteLiveCourseAsync(SetMuteLiveCourseRequest request) async {
		var rpcRst = await call("SetMuteLiveCourseAsync", request);
		var result = LiveCourseBaseResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<LiveCourseBaseResult> setVideoLiveCourseAsync(SetVideoLiveCourseRequest request) async {
		var rpcRst = await call("SetVideoLiveCourseAsync", request);
		var result = LiveCourseBaseResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> setControlParameterLiveCourseAsync(ControlParameterInCourseRequest request) async {
		var rpcRst = await call("SetControlParameterLiveCourseAsync", request);
		return rpcRst;
	}

	Future<LiveCourseMember> deviceJoinInLiveCourseAsync(JoinLiveCourseRequest request) async {
		var rpcRst = await call("DeviceJoinInLiveCourseAsync", request);
		var result = LiveCourseMember.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> uploadRemoteExaminationDataAsync(UploadRemoteExamRequest request) async {
		var rpcRst = await call("UploadRemoteExaminationDataAsync", request);
		return rpcRst;
	}

	Future<List<RemoteExaminationPageDTO>> getRemoteExaminationList(TokenRequest request) async {
		var rpcRst = await call("GetRemoteExaminationList", request);
		var result = (rpcRst as List).map((e)=>RemoteExaminationPageDTO.fromJson(e as Map<String, dynamic>)).toList();
		return result;
	}

	Future<bool> addStudentInCourseUserGroupAsync(AddStudentInCourseUserGroupRequest request) async {
		var rpcRst = await call("AddStudentInCourseUserGroupAsync", request);
		return rpcRst;
	}

	Future<bool> studentLeaveCourseUserGroupAsync(StudentLeaveCourseUserGroupRequest request) async {
		var rpcRst = await call("StudentLeaveCourseUserGroupAsync", request);
		return rpcRst;
	}

	Future<PageResult<UserGroupDTO>> findUserGroupByStudentAsync(QueryUserGroupPageRequest request) async {
		var rpcRst = await call("FindUserGroupByStudentAsync", request);
		var result = PageResult<UserGroupDTO>.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> studyCompletedAsync(StudyCompletedRequest request) async {
		var rpcRst = await call("StudyCompletedAsync", request);
		return rpcRst;
	}

	Future<String> addCourseAlbumAsync(AddCourseAlbumRequest request) async {
		var rpcRst = await call("AddCourseAlbumAsync", request);
		return rpcRst;
	}

	Future<bool> deleteCourseAlbumAsync(DeleteCourseAlbumRequest request) async {
		var rpcRst = await call("DeleteCourseAlbumAsync", request);
		return rpcRst;
	}

	Future<PageResult<CourseCommonInfoDTO>> findCourseAlbumPageAsync(FindCoursePagesRequest request) async {
		var rpcRst = await call("FindCourseAlbumPageAsync", request);
		var result = PageResult<CourseCommonInfoDTO>.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<CourseAlbumExtendDTO> findCourseAlbumByCodeAsync(FindCourseAlbumByCodeRequest request) async {
		var rpcRst = await call("FindCourseAlbumByCodeAsync", request);
		var result = CourseAlbumExtendDTO.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<List<BaseCourseAlbumDTO>> findCourseAlbumListAsync(TokenRequest request) async {
		var rpcRst = await call("FindCourseAlbumListAsync", request);
		var result = (rpcRst as List).map((e)=>BaseCourseAlbumDTO.fromJson(e as Map<String, dynamic>)).toList();
		return result;
	}

	Future<bool> addUserGroupsStudentByTeacherAsync(TeacherAddStudentsInUserGroupsRequest request) async {
		var rpcRst = await call("AddUserGroupsStudentByTeacherAsync", request);
		return rpcRst;
	}

	Future<bool> joinClassApprovedAsync(JoinClassApprovedRequest request) async {
		var rpcRst = await call("JoinClassApprovedAsync", request);
		return rpcRst;
	}

	Future<bool> joinClassRejectedAsync(JoinClassRejectedRequest request) async {
		var rpcRst = await call("JoinClassRejectedAsync", request);
		return rpcRst;
	}

	Future<List<UserGroupStudentsDTO>> findStudentListAsync(FindStudentListRequest request) async {
		var rpcRst = await call("FindStudentListAsync", request);
		var result = (rpcRst as List).map((e)=>UserGroupStudentsDTO.fromJson(e as Map<String, dynamic>)).toList();
		return result;
	}

	Future<bool> createVideosAsync(CreateVideosRequest request) async {
		var rpcRst = await call("CreateVideosAsync", request);
		return rpcRst;
	}

	Future<PageResult<UserExtendDTO>> getAllStudentsAsync(GetUserPagesRequest request) async {
		var rpcRst = await call("GetAllStudentsAsync", request);
		var result = PageResult<UserExtendDTO>.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> setShareInLiveCourseAsync(SetShareInLiveCourseRequest request) async {
		var rpcRst = await call("SetShareInLiveCourseAsync", request);
		return rpcRst;
	}

	Future<List<UserBaseDTO>> findMyOrganizationExpertsAsync(FindMyOrganizationExpertsRequest request) async {
		var rpcRst = await call("FindMyOrganizationExpertsAsync", request);
		var result = (rpcRst as List).map((e)=>UserBaseDTO.fromJson(e as Map<String, dynamic>)).toList();
		return result;
	}

	Future<bool> sendCourseInteractiveBoardDataAsync(SendLiveInteractiveBoardDataRequest request) async {
		var rpcRst = await call("SendCourseInteractiveBoardDataAsync", request);
		return rpcRst;
	}

	Future<bool> sendCourseEntryNoticeAsync(SendCourseEntryNoticeRequest request) async {
		var rpcRst = await call("SendCourseEntryNoticeAsync", request);
		return rpcRst;
	}

	Future<LiveCourseBaseResult> deviceLeaveLiveCourseAsync(DeviceLeaveLiveCourseRequest request) async {
		var rpcRst = await call("DeviceLeaveLiveCourseAsync", request);
		var result = LiveCourseBaseResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> updateCourseAlbumAsync(UpdateCourseAlbumRequest request) async {
		var rpcRst = await call("UpdateCourseAlbumAsync", request);
		return rpcRst;
	}

	Future<bool> changeVideoNameAsync(ChangeVideoNameRequest request) async {
		var rpcRst = await call("ChangeVideoNameAsync", request);
		return rpcRst;
	}

	Future<bool> addCoursePlayCountAsync(AddCoursePlayCountRequest request) async {
		var rpcRst = await call("AddCoursePlayCountAsync", request);
		return rpcRst;
	}

	Future<CourseBrowsedRecordDTO> saveCourseBrowsedRecordAsync(CourseBrowsedRecordRequest request) async {
		var rpcRst = await call("SaveCourseBrowsedRecordAsync", request);
		var result = CourseBrowsedRecordDTO.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<PageResult<CourseBrowsedRecordDTO>> queryCourseBrowsedRecordsAsync(QueryBrowsedRecordPageRequest request) async {
		var rpcRst = await call("QueryCourseBrowsedRecordsAsync", request);
		var result = PageResult<CourseBrowsedRecordDTO>.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> visitorHeartRateAsync(QueryBrowsedRecordRequest request) async {
		var rpcRst = await call("VisitorHeartRateAsync", request);
		return rpcRst;
	}

	Future<bool> visitorLeaveLiveCourseAsync(QueryBrowsedRecordRequest request) async {
		var rpcRst = await call("VisitorLeaveLiveCourseAsync", request);
		return rpcRst;
	}

	Future<bool> setCourseLiveProhibitionAsync(CourseLiveProhibitionRequest request) async {
		var rpcRst = await call("SetCourseLiveProhibitionAsync", request);
		return rpcRst;
	}

	Future<CourseVisitorsStatisticResult> queryCourseBrowsedCountAsync(QueryBrowsedRecordRequest request) async {
		var rpcRst = await call("QueryCourseBrowsedCountAsync", request);
		var result = CourseVisitorsStatisticResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<CourseBrowsedRecordDTO> getCourseBrowsedRecordByRelevanceCodeAsync(QueryBrowsedRecordRequest request) async {
		var rpcRst = await call("GetCourseBrowsedRecordByRelevanceCodeAsync", request);
		var result = CourseBrowsedRecordDTO.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

}