encoach_backend_v4/custom_addons/encoach_lms_api/controllers/lessons.py

import logging
from odoo import http
from odoo.http import request
from odoo.addons.encoach_api.controllers.base import (
    jwt_required, _json_response, _error_response, _get_json_body, _paginate,
)

_logger = logging.getLogger(__name__)


def _ser_lesson(r):
    return {
        'id': r.id,
        'name': r.name or '',
        'lesson_topic': r.lesson_topic or '',
        'subject_id': r.subject_id.id if r.subject_id else 0,
        'subject_name': r.subject_id.name if r.subject_id else '',
        'session_id': r.session_id.id if r.session_id else 0,
        'session_name': r.session_id.display_name if r.session_id else '',
        'course_id': r.course_id.id if r.course_id else 0,
        'batch_id': r.batch_id.id if r.batch_id else 0,
        'faculty_id': r.faculty_id.id if r.faculty_id else 0,
        'start_datetime': str(r.start_datetime) if r.start_datetime else '',
        'end_datetime': str(r.end_datetime) if r.end_datetime else '',
        'status': r.status or 'draft',
    }


class LessonsController(http.Controller):

    @http.route('/api/lessons', type='http', auth='public', methods=['GET'], csrf=False)
    @jwt_required
    def list_lessons(self, **kw):
        try:
            M = request.env['encoach.lesson'].sudo()
            offset, limit, page = _paginate(kw)
            total = M.search_count([])
            recs = M.search([], offset=offset, limit=limit, order='start_datetime desc, id desc')
            items = [_ser_lesson(r) for r in recs]
            return _json_response({'items': items, 'data': items, 'total': total, 'page': page, 'size': limit})
        except Exception as e:
            return _error_response(str(e), 500)

    @http.route('/api/lessons', type='http', auth='public', methods=['POST'], csrf=False)
    @jwt_required
    def create_lesson(self, **kw):
        try:
            body = _get_json_body()
            vals = {}
            if body.get('name'):
                vals['name'] = body['name']
            if body.get('lesson_topic'):
                vals['lesson_topic'] = body['lesson_topic']
            for fk in ('course_id', 'batch_id', 'subject_id', 'session_id', 'faculty_id'):
                if body.get(fk):
                    vals[fk] = int(body[fk])
            for dt in ('start_datetime', 'end_datetime'):
                if body.get(dt):
                    vals[dt] = body[dt]
            rec = request.env['encoach.lesson'].sudo().create(vals)
            return _json_response(_ser_lesson(rec))
        except Exception as e:
            return _error_response(str(e), 500)

    @http.route('/api/lessons/<int:lid>', type='http', auth='public', methods=['GET'], csrf=False)
    @jwt_required
    def get_lesson(self, lid, **kw):
        try:
            rec = request.env['encoach.lesson'].sudo().browse(lid)
            if not rec.exists():
                return _error_response('Not found', 404)
            return _json_response(_ser_lesson(rec))
        except Exception as e:
            return _error_response(str(e), 500)

    @http.route('/api/lessons/<int:lid>', type='http', auth='public', methods=['PATCH', 'PUT'], csrf=False)
    @jwt_required
    def update_lesson(self, lid, **kw):
        try:
            rec = request.env['encoach.lesson'].sudo().browse(lid)
            if not rec.exists():
                return _error_response('Not found', 404)
            body = _get_json_body()
            vals = {}
            for k in ('name', 'lesson_topic', 'start_datetime', 'end_datetime', 'status'):
                if k in body:
                    vals[k] = body[k]
            for fk in ('course_id', 'batch_id', 'subject_id', 'session_id', 'faculty_id'):
                if fk in body:
                    vals[fk] = int(body[fk]) if body[fk] else False
            if vals:
                rec.write(vals)
            return _json_response(_ser_lesson(rec))
        except Exception as e:
            return _error_response(str(e), 500)

    @http.route('/api/lessons/<int:lid>', type='http', auth='public', methods=['DELETE'], csrf=False)
    @jwt_required
    def delete_lesson(self, lid, **kw):
        try:
            rec = request.env['encoach.lesson'].sudo().browse(lid)
            if rec.exists():
                rec.unlink()
            return _json_response({'success': True})
        except Exception as e:
            return _error_response(str(e), 500)