devops/encoach_backend_v4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
6ec68160c83474358ca2bd27b98ac9b6dd4021b9
encoach_backend_v4/custom_addons/encoach_lms_api/controllers/academic.py
Yamen Ahmad 6ec68160c8 feat: institutional + support + training admin sections (backend + frontend) 
Ship three fully-wired admin areas end-to-end with APIs, seeds, tests and docs.

Backend (new `encoach_lms_api` addon + existing addons):
- Institutional: academic years/terms, departments, admission registers & admissions,
  courses/batches, lessons, fees (terms + student fees + invoicing with income-account
  auto-wiring), gradebook (assignments/grades), library, facilities (encoach.asset),
  student leave, result templates + marksheets (incl. delete-with-cascade).
- Support: `encoach.ticket` model + CRUD/assignee routes; payment records derived
  from `op.student.fees.details` and `account.move`; platform settings backed by
  `encoach.code` and `ir.config_parameter` (packages + grading config).
- Training: `encoach.vocab.item` + `encoach.grammar.rule` (plus progress models)
  with CRUD, pagination, search/level filters, and upsert-style progress endpoints.
  Odoo 19 compatibility: `_sql_constraints` replaced with `@api.constrains`;
  `ValidationError`/`UserError` mapped to HTTP 400.

Frontend:
- Rewire institutional admin pages (Academic Year Manager, Admissions, Courses,
  Lessons, Fees, Gradebook, Library, Facilities, Student Leave, Marksheets,
  Taxonomy, Resources) to real APIs with React Query invalidation and dialogs.
- New typed services: `payments.service.ts`, `platformSettings.service.ts`,
  `training.service.ts`. Updated `fees/gradebook/lms/courseware/taxonomy/
  resources/student-progress/generation` services + related types.
- Rewrite `VocabularyPage`, `GrammarPage`, `PaymentRecordPage`, `SettingsPage`,
  `TicketsPage` to consume live data with search/filter/progress/CRUD flows.
- New shared components: `TaxonomyCascade`, `MaterialViewer`, `teacher/TeacherLibrary`.
- Favicons/branding assets and misc. UX polish across teacher/student pages.

Tooling & QA:
- Seeders: `seed_demo.py`, `seed_demo_data.py`, `seed_institutional.py` (idempotent,
  covers institutional + support + training fixtures incl. income-account wiring).
- API write-flow test suites: `test_write_flows.py` (institutional),
  `test_support_flows.py` (support), `test_training_flows.py` (training),
  `test_ai_full.py`. All suites pass end-to-end.
- Docs: add `docs/PROJECT_SUMMARY.md` with per-section scope, artifacts and QA.
- `.gitignore`: ignore `pgdata_bak_*/`, `frontend/.vite/`, `frontend/dist/`,
  `frontend/node_modules/`.

Made-with: Cursor
2026-04-19 03:13:23 +04:00

365 lines
16 KiB
Python
Raw Blame History

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_year(r):
terms = []
if hasattr(r, 'academic_term_ids'):
for t in r.academic_term_ids:
terms.append(_ser_term(t))
return {
'id': r.id,
'name': r.name or '',
'start_date': str(r.start_date) if r.start_date else '',
'end_date': str(r.end_date) if r.end_date else '',
'term_structure': getattr(r, 'term_structure', 'others') or 'others',
'terms': terms,
}
def _ser_term(t):
return {
'id': t.id,
'name': t.name or '',
'term_start_date': str(t.term_start_date) if hasattr(t, 'term_start_date') and t.term_start_date else str(t.start_date) if hasattr(t, 'start_date') and t.start_date else '',
'term_end_date': str(t.term_end_date) if hasattr(t, 'term_end_date') and t.term_end_date else str(t.end_date) if hasattr(t, 'end_date') and t.end_date else '',
'academic_year_id': t.academic_year_id.id if hasattr(t, 'academic_year_id') and t.academic_year_id else 0,
'academic_year_name': t.academic_year_id.name if hasattr(t, 'academic_year_id') and t.academic_year_id else '',
'parent_term_id': t.parent_id.id if hasattr(t, 'parent_id') and t.parent_id else None,
'parent_term_name': t.parent_id.name if hasattr(t, 'parent_id') and t.parent_id else None,
}
def _ser_dept(d):
env = d.env
course_count = 0
faculty_count = 0
try:
if 'op.course' in env:
Course = env['op.course'].sudo()
if 'department_id' in Course._fields:
course_count = Course.search_count([('department_id', '=', d.id)])
if 'op.faculty' in env:
Faculty = env['op.faculty'].sudo()
if 'department_id' in Faculty._fields:
faculty_count = Faculty.search_count([('department_id', '=', d.id)])
elif 'main_department_id' in Faculty._fields:
faculty_count = Faculty.search_count([('main_department_id', '=', d.id)])
except Exception:
pass
return {
'id': d.id,
'name': d.name or '',
'code': d.code or '' if hasattr(d, 'code') else '',
'parent_id': d.parent_id.id if hasattr(d, 'parent_id') and d.parent_id else None,
'parent_name': d.parent_id.name if hasattr(d, 'parent_id') and d.parent_id else None,
'course_count': course_count,
'faculty_count': faculty_count,
}
class AcademicController(http.Controller):
# ── Academic Years ───────────────────────────────────────────────
@http.route('/api/academic-years', type='http', auth='public', methods=['GET'], csrf=False)
@jwt_required
def list_years(self, **kw):
try:
M = request.env['op.academic.year'].sudo()
offset, limit, page = _paginate(kw)
total = M.search_count([])
recs = M.search([], offset=offset, limit=limit, order='id desc')
return _json_response({'items': [_ser_year(r) for r in recs], 'data': [_ser_year(r) for r in recs], 'total': total, 'page': page, 'size': limit})
except Exception as e:
_logger.exception('list_years')
return _error_response(str(e), 500)
@http.route('/api/academic-years/<int:yid>', type='http', auth='public', methods=['GET'], csrf=False)
@jwt_required
def get_year(self, yid, **kw):
try:
rec = request.env['op.academic.year'].sudo().browse(yid)
if not rec.exists():
return _error_response('Not found', 404)
return _json_response(_ser_year(rec))
except Exception as e:
return _error_response(str(e), 500)
@http.route('/api/academic-years', type='http', auth='public', methods=['POST'], csrf=False)
@jwt_required
def create_year(self, **kw):
try:
body = _get_json_body()
Year = request.env['op.academic.year'].sudo()
vals = {
'name': body.get('name', ''),
'start_date': body.get('start_date'),
'end_date': body.get('end_date'),
}
if body.get('term_structure') and 'term_structure' in Year._fields:
vals['term_structure'] = body['term_structure']
rec = Year.create(vals)
return _json_response(_ser_year(rec))
except Exception as e:
return _error_response(str(e), 500)
@http.route('/api/academic-years/<int:yid>', type='http', auth='public', methods=['PATCH', 'PUT'], csrf=False)
@jwt_required
def update_year(self, yid, **kw):
try:
rec = request.env['op.academic.year'].sudo().browse(yid)
if not rec.exists():
return _error_response('Not found', 404)
body = _get_json_body()
vals = {}
for k in ('name', 'start_date', 'end_date'):
if k in body:
vals[k] = body[k]
if 'term_structure' in body and 'term_structure' in rec._fields:
vals['term_structure'] = body['term_structure']
if vals:
rec.write(vals)
return _json_response(_ser_year(rec))
except Exception as e:
return _error_response(str(e), 500)
@http.route('/api/academic-years/<int:yid>', type='http', auth='public', methods=['DELETE'], csrf=False)
@jwt_required
def delete_year(self, yid, **kw):
try:
rec = request.env['op.academic.year'].sudo().browse(yid)
if rec.exists():
# Unlink dependent terms first to avoid RESTRICT FK violation.
if hasattr(rec, 'academic_term_ids') and rec.academic_term_ids:
rec.academic_term_ids.unlink()
rec.unlink()
return _json_response({'success': True})
except Exception as e:
_logger.exception('delete_year')
return _error_response(str(e), 500)
@http.route('/api/academic-years/<int:yid>/generate-terms', type='http', auth='public', methods=['POST'], csrf=False)
@jwt_required
def generate_terms(self, yid, **kw):
"""Create a set of op.academic.term records spanning the year.
The number of terms is dictated by the year's `term_structure`:
two_sem → 2 semesters
two_sem_qua → 2 semesters + 4 quarters (nested under each sem)
three_sem → 3 semesters
four_Quarter → 4 quarters
final_year → 1 single term
others → 2 semesters (default fallback)
"""
try:
from datetime import timedelta
year = request.env['op.academic.year'].sudo().browse(yid)
if not year.exists():
return _error_response('Not found', 404)
start = year.start_date
end = year.end_date
if not start or not end:
return _error_response('Year has no dates', 400)
total_days = max(1, (end - start).days)
structure = getattr(year, 'term_structure', 'two_sem') or 'two_sem'
body = _get_json_body() or {}
if body.get('replace'):
for existing in year.academic_term_ids:
existing.sudo().unlink()
Term = request.env['op.academic.term'].sudo()
def _split(n, label):
chunk = total_days // n
out = []
for i in range(n):
s = start + timedelta(days=i * chunk)
e = end if i == n - 1 else start + timedelta(days=(i + 1) * chunk - 1)
out.append(Term.create({
'name': f'{year.name} - {label} {i + 1}',
'term_start_date': str(s),
'term_end_date': str(e),
'academic_year_id': year.id,
}))
return out
created = []
if structure == 'two_sem':
created = _split(2, 'Semester')
elif structure == 'three_sem':
created = _split(3, 'Semester')
elif structure == 'four_Quarter':
created = _split(4, 'Quarter')
elif structure == 'final_year':
created = [Term.create({
'name': f'{year.name} - Final Year',
'term_start_date': str(start),
'term_end_date': str(end),
'academic_year_id': year.id,
})]
elif structure == 'two_sem_qua':
sems = _split(2, 'Semester')
quarters = []
for parent_idx, parent in enumerate(sems):
s = parent.term_start_date
e = parent.term_end_date
span = max(1, (e - s).days)
half = span // 2
q1 = Term.create({
'name': f'{year.name} - Q{parent_idx * 2 + 1}',
'term_start_date': str(s),
'term_end_date': str(s + timedelta(days=half)),
'academic_year_id': year.id,
})
q2 = Term.create({
'name': f'{year.name} - Q{parent_idx * 2 + 2}',
'term_start_date': str(s + timedelta(days=half + 1)),
'term_end_date': str(e),
'academic_year_id': year.id,
})
if 'parent_id' in Term._fields:
q1.write({'parent_id': parent.id})
q2.write({'parent_id': parent.id})
quarters += [q1, q2]
created = sems + quarters
else:
created = _split(2, 'Semester')
year.invalidate_recordset()
return _json_response([_ser_term(t) for t in created])
except Exception as e:
_logger.exception('generate_terms')
return _error_response(str(e), 500)
# ── Academic Terms ───────────────────────────────────────────────
@http.route('/api/academic-terms', type='http', auth='public', methods=['GET'], csrf=False)
@jwt_required
def list_terms(self, **kw):
try:
M = request.env['op.academic.term'].sudo()
domain = []
if kw.get('year_id'):
domain.append(('academic_year_id', '=', int(kw['year_id'])))
offset, limit, page = _paginate(kw)
total = M.search_count(domain)
recs = M.search(domain, offset=offset, limit=limit, order='id desc')
return _json_response({'items': [_ser_term(r) for r in recs], 'data': [_ser_term(r) for r in recs], 'total': total, 'page': page, 'size': limit})
except Exception as e:
return _error_response(str(e), 500)
@http.route('/api/academic-terms', type='http', auth='public', methods=['POST'], csrf=False)
@jwt_required
def create_term(self, **kw):
try:
body = _get_json_body()
vals = {
'name': body.get('name', ''),
'term_start_date': body.get('term_start_date'),
'term_end_date': body.get('term_end_date'),
}
if body.get('academic_year_id'):
vals['academic_year_id'] = int(body['academic_year_id'])
rec = request.env['op.academic.term'].sudo().create(vals)
return _json_response(_ser_term(rec))
except Exception as e:
return _error_response(str(e), 500)
@http.route('/api/academic-terms/<int:tid>', type='http', auth='public', methods=['PATCH', 'PUT'], csrf=False)
@jwt_required
def update_term(self, tid, **kw):
try:
rec = request.env['op.academic.term'].sudo().browse(tid)
if not rec.exists():
return _error_response('Not found', 404)
body = _get_json_body()
vals = {}
for k in ('name', 'term_start_date', 'term_end_date'):
if k in body:
vals[k] = body[k]
if 'academic_year_id' in body:
vals['academic_year_id'] = int(body['academic_year_id'])
if vals:
rec.write(vals)
return _json_response(_ser_term(rec))
except Exception as e:
return _error_response(str(e), 500)
@http.route('/api/academic-terms/<int:tid>', type='http', auth='public', methods=['DELETE'], csrf=False)
@jwt_required
def delete_term(self, tid, **kw):
try:
rec = request.env['op.academic.term'].sudo().browse(tid)
if rec.exists():
rec.unlink()
return _json_response({'success': True})
except Exception as e:
return _error_response(str(e), 500)
# ── Departments ──────────────────────────────────────────────────
@http.route('/api/departments', type='http', auth='public', methods=['GET'], csrf=False)
@jwt_required
def list_depts(self, **kw):
try:
M = request.env['op.department'].sudo()
offset, limit, page = _paginate(kw)
total = M.search_count([])
recs = M.search([], offset=offset, limit=limit, order='id desc')
return _json_response({'items': [_ser_dept(r) for r in recs], 'data': [_ser_dept(r) for r in recs], 'total': total, 'page': page, 'size': limit})
except Exception as e:
return _error_response(str(e), 500)
@http.route('/api/departments', type='http', auth='public', methods=['POST'], csrf=False)
@jwt_required
def create_dept(self, **kw):
try:
body = _get_json_body()
vals = {'name': body.get('name', '')}
if body.get('code'):
vals['code'] = body['code']
if body.get('parent_id'):
vals['parent_id'] = int(body['parent_id'])
rec = request.env['op.department'].sudo().create(vals)
return _json_response(_ser_dept(rec))
except Exception as e:
return _error_response(str(e), 500)
@http.route('/api/departments/<int:did>', type='http', auth='public', methods=['PATCH', 'PUT'], csrf=False)
@jwt_required
def update_dept(self, did, **kw):
try:
rec = request.env['op.department'].sudo().browse(did)
if not rec.exists():
return _error_response('Not found', 404)
body = _get_json_body()
vals = {}
for k in ('name', 'code'):
if k in body:
vals[k] = body[k]
if 'parent_id' in body:
vals['parent_id'] = int(body['parent_id']) if body['parent_id'] else False
if vals:
rec.write(vals)
return _json_response(_ser_dept(rec))
except Exception as e:
return _error_response(str(e), 500)
@http.route('/api/departments/<int:did>', type='http', auth='public', methods=['DELETE'], csrf=False)
@jwt_required
def delete_dept(self, did, **kw):
try:
rec = request.env['op.department'].sudo().browse(did)
if rec.exists():
rec.unlink()
return _json_response({'success': True})
except Exception as e:
return _error_response(str(e), 500)
Reference in New Issue View Git Blame Copy Permalink