Teaching_integration_platform_admin_template/generated/services/UmsAdminControllerService.ts

/* generated using openapi-typescript-codegen -- do not edit */
/* istanbul ignore file */
/* tslint:disable */
/* eslint-disable */
import type { BaseResponse_List_TeacherInfVO_ } from '../models/BaseResponse_List_TeacherInfVO_';
import type { CommonResult } from '../models/CommonResult';
import type { CommonResult_string_ } from '../models/CommonResult_string_';
import type { CommonResult_UmsAdmin_ } from '../models/CommonResult_UmsAdmin_';
import type { UmsAdmin } from '../models/UmsAdmin';
import type { UmsAdminParam } from '../models/UmsAdminParam';
import type { UmsStudentAndTeacherDTO } from '../models/UmsStudentAndTeacherDTO';
import type { UpdateAdminPasswordParam } from '../models/UpdateAdminPasswordParam';
import type { CancelablePromise } from '../core/CancelablePromise';
import { OpenAPI } from '../core/OpenAPI';
import { request as __request } from '../core/request';
export class UmsAdminControllerService {
    /**
     * 发送短信返回验证码
     * @param phone phone
     * @returns CommonResult_string_ OK
     * @returns any Created
     * @throws ApiError
     */
    public static sendVerifyCodeUsingPost1(
        phone: string,
    ): CancelablePromise<CommonResult_string_ | any> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/api/user/code',
            query: {
                'phone': phone,
            },
            errors: {
                401: `Unauthorized`,
                403: `Forbidden`,
                404: `Not Found`,
            },
        });
    }
    /**
     * 获取教师信息列表，关联教师的username和name
     * @returns BaseResponse_List_TeacherInfVO_ OK
     * @throws ApiError
     */
    public static getTeacherInfListUsingGet1(): CancelablePromise<BaseResponse_List_TeacherInfVO_> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/api/user/get_teacherinf_list',
            errors: {
                401: `Unauthorized`,
                403: `Forbidden`,
                404: `Not Found`,
            },
        });
    }
    /**
     * 获取当前登录用户信息
     * @param name
     * @returns CommonResult OK
     * @throws ApiError
     */
    public static getAdminInfoUsingGet1(
        name?: string,
    ): CancelablePromise<CommonResult> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/api/user/info',
            query: {
                'name': name,
            },
            errors: {
                401: `Unauthorized`,
                403: `Forbidden`,
                404: `Not Found`,
            },
        });
    }
    /**
     * 用户名登录以后返回token
     * @param umsAdmin umsAdmin
     * @returns CommonResult OK
     * @returns any Created
     * @throws ApiError
     */
    public static loginUsingPost1(
        umsAdmin: UmsAdmin,
    ): CancelablePromise<CommonResult | any> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/api/user/login',
            body: umsAdmin,
            errors: {
                401: `Unauthorized`,
                403: `Forbidden`,
                404: `Not Found`,
            },
        });
    }
    /**
     * 获取指定个人信息
     * @param id id
     * @returns CommonResult OK
     * @returns any Created
     * @throws ApiError
     */
    public static getByIdPersonalInfoUsingPost1(
        id: string,
    ): CancelablePromise<CommonResult | any> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/api/user/personal/info',
            query: {
                'id': id,
            },
            errors: {
                401: `Unauthorized`,
                403: `Forbidden`,
                404: `Not Found`,
            },
        });
    }
    /**
     * 手机号登录以后返回token
     * @param phone phone
     * @returns CommonResult OK
     * @returns any Created
     * @throws ApiError
     */
    public static phoneLoginUsingPost1(
        phone: string,
    ): CancelablePromise<CommonResult | any> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/api/user/phone/login',
            query: {
                'phone': phone,
            },
            errors: {
                401: `Unauthorized`,
                403: `Forbidden`,
                404: `Not Found`,
            },
        });
    }
    /**
     * 手机号注册
     * @param umsAdminParam umsAdminParam
     * @returns CommonResult_UmsAdmin_ OK
     * @returns any Created
     * @throws ApiError
     */
    public static phoneRegisterUsingPost1(
        umsAdminParam: UmsAdminParam,
    ): CancelablePromise<CommonResult_UmsAdmin_ | any> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/api/user/phone/register',
            body: umsAdminParam,
            errors: {
                401: `Unauthorized`,
                403: `Forbidden`,
                404: `Not Found`,
            },
        });
    }
    /**
     * 刷新token
     * @returns CommonResult OK
     * @throws ApiError
     */
    public static refreshTokenUsingGet1(): CancelablePromise<CommonResult> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/api/user/refreshToken',
            errors: {
                401: `Unauthorized`,
                403: `Forbidden`,
                404: `Not Found`,
            },
        });
    }
    /**
     * 用户注册
     * @param umsAdminParam umsAdminParam
     * @returns CommonResult_UmsAdmin_ OK
     * @returns any Created
     * @throws ApiError
     */
    public static registerUsingPost1(
        umsAdminParam: UmsAdminParam,
    ): CancelablePromise<CommonResult_UmsAdmin_ | any> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/api/user/register',
            body: umsAdminParam,
            errors: {
                401: `Unauthorized`,
                403: `Forbidden`,
                404: `Not Found`,
            },
        });
    }
    /**
     * 修改指定用户信息
     * @param umsadmin umsadmin
     * @returns CommonResult OK
     * @returns any Created
     * @throws ApiError
     */
    public static updateUmsUsingPost1(
        umsadmin: UmsAdmin,
    ): CancelablePromise<CommonResult | any> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/api/user/update',
            body: umsadmin,
            errors: {
                401: `Unauthorized`,
                403: `Forbidden`,
                404: `Not Found`,
            },
        });
    }
    /**
     * 修改指定个人信息
     * @param umsStudentAndTeacherDto umsStudentAndTeacherDTO
     * @returns CommonResult OK
     * @returns any Created
     * @throws ApiError
     */
    public static updatePersonalInfoUsingPost1(
        umsStudentAndTeacherDto: UmsStudentAndTeacherDTO,
    ): CancelablePromise<CommonResult | any> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/api/user/update/PersonalInfo',
            body: umsStudentAndTeacherDto,
            errors: {
                401: `Unauthorized`,
                403: `Forbidden`,
                404: `Not Found`,
            },
        });
    }
    /**
     * 修改指定用户密码
     * @param updatePasswordParam updatePasswordParam
     * @returns CommonResult OK
     * @returns any Created
     * @throws ApiError
     */
    public static updatePasswordUsingPost1(
        updatePasswordParam: UpdateAdminPasswordParam,
    ): CancelablePromise<CommonResult | any> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/api/user/updatePassword',
            body: updatePasswordParam,
            errors: {
                401: `Unauthorized`,
                403: `Forbidden`,
                404: `Not Found`,
            },
        });
    }
}