ntcri/app/api/classes.py

from fastapi import APIRouter, Form, Depends, HTTPException, File, UploadFile
from typing import List,Optional
from fastapi.responses import FileResponse
from random import randint
from fastapi.security import OAuth2PasswordRequestForm
from app.models.models import User,Favorite_course,Article_list,Class_date,Attend_record,One_day_class
from app.models.models import Class_list,Schools,Class_detail,Class_name,Registration,Group_name,Online_course
from app.api import deps
from sqlalchemy.orm import Session
from typing import Any, Dict
import secrets
from fastapi_login.exceptions import InvalidCredentialsException
from fastapi_login import LoginManager
from datetime import timedelta,datetime
from app.config import settings
from pathlib import Path
from jose import jwt
from emails.template import JinjaTemplate
from tortoise.queryset import Q
from fastapi.responses import HTMLResponse
import requests
import json
from itertools import chain
from tortoise import fields

classes = APIRouter()

async def check_token(access_token: str):

    result = await User.filter(token=access_token).first()
    
    if not result:
        print("no access")
        return None
    
    user_id = result.id

    return user_id

IMAGEDIR = "/var/www/ntcri/assets/"
IMAGEDIR_short = "assets/"

async def update_location_time(location_id: int):
    if location_id:
        school = await Schools.get(id=location_id)
        school.update_time = datetime.now()
        await school.save()
        return {"msg": "success", "code": 200}

@classes.post("/insert_school")
async def insert_school(
    location_name: str = Form(default=''),
    Lng: str = Form(default=''),
    Lat: str = Form(default=''),
    address : str = Form(default=''),
    introduction : str = Form(default=''),
    email : str = Form(default=''),
    phone : str = Form(default='')
):
    try:
        new_school = await Schools.create(
            name=location_name,
            longitude=Lng,
            latitude=Lat,
            address = address,
            update_time = datetime.now(),
            introduction = introduction ,
            email=  email,
            phone = phone
        )
        
        return {"msg": "success", "code": 200, "location_id": new_school.id}
    except Exception as e:
        return {"msg": str(e), "code": 500}

@classes.post("/insert_class_name")
async def insert_class_name(
    name: str = Form(default=''),
    location_id: int = Form(default=1),
    category: str = Form(default='詳細 請至觀看課程資訊 查看'),
    introduction: str = Form(default='詳細 請至觀看課程資訊 查看'),
    organizer: str = Form(default='詳細 請至觀看課程資訊 查看'),
    cover_img_file:UploadFile = File(default=''),
    group_id : int = Form(default=1),
    group_sort :str = Form(default='詳細 請至觀看課程資訊 查看'),
    recommend: int = Form(default=0),
    special_class_list_name : str = Form(default=None),
    is_inner : int = Form(default=1),
    is_check : int = Form(default=1)
):    
    try:
        cover_img = ''
        if cover_img_file != '':
            contents = await cover_img_file.read()

            #save the file
            with open(f"{IMAGEDIR}{cover_img_file.filename}", "wb") as f:
                f.write(contents)
        
            cover_img = f"{IMAGEDIR_short}{cover_img_file.filename}"        

        new_class_name = await Class_name.create(
            name=name,
            school_id=location_id,
            category=category,
            introduction=introduction,
            organizer=organizer,
            cover_img=cover_img,
            group_id=group_id,
            group_sort=group_sort,
            recommend = recommend,
            special_class_list_name = special_class_list_name,
            is_inner = is_inner,
            is_check = is_check
        )
        update_location_time(location_id= location_id)
        return {"msg": "success", "code": 200, "new_class_name_id": new_class_name.id}
    except Exception as e:
        return {"msg": str(e), "code": 500}

@classes.post("/insert_event")
async def insert_event(
    name_id: int = Form(default=0),
    event: str = Form(default='詳細 請至觀看課程資訊 查看'),
    start_time: datetime = Form(default=datetime.now()),
    end_time: datetime = Form(default=datetime.now()),
    contact: str = Form(default='詳細 請至觀看課程資訊 查看'),
    lecturer: str = Form(default='詳細 請至觀看課程資訊 查看'),
    location: str = Form(default='詳細 請至觀看課程資訊 查看'),
    content: str = Form(default='詳細 請至觀看課程資訊 查看'),
    URL: str = Form(default='詳細 請至觀看課程資訊 查看'), 
    people : str = Form(default='詳細 請至觀看課程資訊 查看'),
    fee_method: str = Form(default='詳細 請至觀看課程資訊 查看'),
    registration_way: str = Form(default='詳細 請至觀看課程資訊 查看'),
    registration_start:  datetime = Form(default=datetime.now()),
    registration_end:  datetime = Form(default=datetime.now()),
    number_limit: int = Form(default=0),
    remark : str = Form(default='詳細 請至觀看課程資訊 查看'),
    ATM_address: str = Form(default='')
):    
    try:

        # 檢查是否有該課程
        class_name_list = await Class_name.filter(id=name_id).all()
        if class_name_list == []:
            return {"msg": "沒有此課程", "code": 200}
        
        new_class = await Class_list.create(
            name_id=name_id,
            event =event,
            start_time=start_time,
            end_time=end_time,
            contact=contact,
            lecturer=lecturer,
            location=location,
            content=content,
            URL=URL,
            people=people,
            fee_method=fee_method,
            registration_way=registration_way,
            remark=remark,
            ATM_address=ATM_address
        )
        try:
            await Class_date.create(
                class_list_id = new_class.id,
                registration_start = registration_start,
                registration_end = registration_end,
                number_limit = number_limit,
                amount_left = number_limit
            )
        except:
            pass

        return {"msg": "success", "code": 200, "class_id": new_class.id}
    except Exception as e:
        return {"msg": str(e), "code": 500}

@classes.post("/auto_create_session")
async def auto_create_session(
    class_event_id : int = Form(default=0),
    week_day_str : str = Form(default="[]")
):
    try:
        week_day = eval(week_day_str)

        #print(week_day)
        
        class_obj = await Class_list.get(id = class_event_id)
        time_stemp = class_obj.start_time
        
        while time_stemp <= class_obj.end_time:
            if week_day[time_stemp.weekday()]:
                time_del =  class_obj.end_time.hour - time_stemp.hour
                time_del_minutes =  class_obj.end_time.minute - time_stemp.minute
                time_end =  time_stemp + timedelta(hours=time_del,minutes=time_del_minutes)
                #print(time_end,class_obj.end_time.hour)

                session_list = await Class_detail.filter(class_list_id=class_event_id).all()
                session = 0
                if session_list != []:
                    for session_obj in session_list:
                        if session < session_obj.sessions:
                            session = session_obj.sessions

                new_session = await Class_detail.create(
                    class_list_id=class_event_id,
                    start_time=time_stemp,
                    end_time=time_end,
                    sessions=session +1,
                    content = ""
                ) 

            time_stemp = time_stemp + timedelta(days=1) 

        return {"msg": "success", "code": 200}
    except Exception as e:
        return {"msg": str(e), "code": 500}

@classes.post("/insert_session")
async def insert_session(
    class_event_id : int = Form(default=0),
    start_time: datetime = Form(default=datetime.now()),
    end_time: datetime = Form(default=datetime.now()),
    content : str = Form(default='')
):
    try:
        session_list = await Class_detail.filter(class_list_id=class_event_id).all()
        session = 0
        if session_list != []:
            for session_obj in session_list:
                if session < session_obj.sessions:
                    session = session_obj.sessions

        new_session = await Class_detail.create(
            class_list_id=class_event_id,
            start_time=start_time,
            end_time=end_time,
            sessions=session +1,
            content = content
        )
        
        return {"msg": "success", "code": 200, "new_session_id": new_session.id}
    except Exception as e:
        return {"msg": str(e), "code": 500}

@classes.post("/update_school")
async def update_school(
    location_id: int = Form(default=0),
    location_name: str = Form(default=''),
    Lng: str = Form(default=''),
    Lat: str = Form(default=''),
    address : str = Form(default=''),
    introduction : str = Form(default=None),
    email : str = Form(default=None),
    phone : str = Form(default=None)
):
    try:
        school = await Schools.get(id=location_id)

        if location_name.strip() != '':
            school.name = location_name

        if Lng != '':
            school.longitude = Lng
        
        if  Lat.strip() != '':
            school.latitude =  Lat

        if  address.strip() != '':
            school.address =  address
        
        if introduction:
            school.introduction =  introduction

        if email:
            school.email =  email

        if phone:
            school.phone =  phone

        await school.save()

        update_location_time(location_id= location_id)
        return {"msg": "success", "code": 200}
    except Exception as e:
        return {"msg": str(e), "code": 500}

@classes.post("/update_class_name")
async def update_class_name(
    class_name_id: int = Form(default=0),
    name: str = Form(default=''),
    location_id: int = Form(default=0),
    category: str = Form(default=''),
    introduction: str = Form(default=''),
    organizer: str = Form(default=''),
    cover_img_file:UploadFile = File(default=''),
    group_id : int = Form(default=0),
    group_sort : str = Form(default=''),
    recommend: int = Form(default=None),
    special_class_list_name : str = Form(default=None),
    is_inner : int = Form(default=None),
    is_check : int = Form(default=None)
):
    try:
        class_name = await Class_name.get(id=class_name_id)

        if name.strip() != '':
            class_name.name = name

        if location_id != 0:
            class_name.school_id = location_id
            update_location_time(location_id= location_id)
        
        if category.strip() != '':
            class_name.category = category

        if introduction.strip() != '':
            class_name.introduction = introduction

        if organizer.strip() != '':
            class_name.organizer = organizer

        if group_id != 0 :
            class_name.group_id = group_id

        if is_inner :
            class_name.is_inner = is_inner

        if cover_img_file != '':
            contents = await cover_img_file.read()

            with open(f"{IMAGEDIR}{cover_img_file.filename}", "wb") as f:
                f.write(contents)
        
            class_name.cover_img = f"{IMAGEDIR_short}{cover_img_file.filename}"

        if group_sort != '':
            class_name.group_sort = group_sort

        if recommend:
            class_name.recommend = recommend

        if is_check:
            class_name.is_check = is_check

        if special_class_list_name:
            class_name.special_class_list_name = special_class_list_name

        await class_name.save()

        
        return {"msg": "success", "code": 200}
    except Exception as e:
        return {"msg": str(e), "code": 500}
    
@classes.post("/update_event")
async def update_event(
    id: int = Form(default=0),
    name_id: int = Form(default=0),
    event: str = Form(default=''),
    start_time: datetime = Form(default=datetime.now()),
    end_time: datetime = Form(default=datetime.now()),
    contact: str = Form(default=''),
    lecturer: str = Form(default=''),
    location: str = Form(default=''),
    content: str = Form(default=''),
    URL:  str = Form(default=''), 
    people : str = Form(default=''),
    fee_method: str = Form(default=''),
    registration_way: str = Form(default=''),
    registration_start:  datetime = Form(default=datetime.now()),
    registration_end:  datetime = Form(default=datetime.now()),
    number_limit: int = Form(default=0),
    remark :  str = Form(default=''),
    ATM_address :str = Form(default='')
):
    try:
        class_obj = await Class_list.get(id=id)

        if name_id != 0:
            class_obj.name_id = name_id

        if event.strip() != '':
            class_obj.event = event

        if start_time:
            class_obj.start_time = start_time

        if end_time:
            class_obj.end_time = end_time

        if lecturer.strip() != '':
            class_obj.lecturer = lecturer

        if location.strip() != '':
            class_obj.location = location

        if contact.strip() != '':
            class_obj.contact = contact

        if content.strip() != '':
            class_obj.content = content

        if URL.strip() != '':
            class_obj.URL = URL
        
        if people.strip() != '':
            class_obj.people = people

        if fee_method.strip() != '':
            class_obj.fee_method = fee_method

        if registration_way.strip() != '':
            class_obj.registration_way = registration_way

        if remark.strip() != '':
            class_obj.remark = remark

        if ATM_address.strip() != '':
            class_obj.ATM_address = ATM_address

        try :
            class_date_obj = await Class_date.get(class_list_id=id)

            if registration_start != datetime.now():
                class_date_obj.registration_start = registration_start

            if registration_end != datetime.now():
                class_date_obj.registration_end = registration_end

            if number_limit != 0:
                class_date_obj.number_limit = number_limit

            await class_date_obj.save()
        
        except:
            await Class_date.create(
                class_list_id = id,
                registration_start = registration_start,
                registration_end = registration_end,
                number_limit = number_limit,
                amount_left = number_limit
            )

        
        await class_obj.save()
        

        return {"msg": "success", "code": 200}
    except Exception as e:
        return {"msg": str(e), "code": 500}

@classes.post("/update_session")
async def update_session(
    session_id : int = Form(default=0),
    class_event_id : int = Form(default=0),
    start_time: datetime = Form(default=datetime.now()),
    end_time: datetime = Form(default=datetime.now()),
    sessions: str = Form(default=0),
    content : str = Form(default='')
):
    try:
        class_session_obj = await Class_detail.get(id=session_id)
        
        if class_event_id != 0:
            class_session_obj.class_list_id = class_event_id

        if start_time != '':
            class_session_obj.start_time = start_time

        if end_time != '':
            class_session_obj.end_time = end_time
        
        if sessions.strip() != '':
            class_session_obj.sessions = sessions

        if content.strip() != '':
            class_session_obj.content = content
        
        await class_session_obj.save()
        return {"msg": "success", "code": 200}
    except Exception as e:
        return {"msg": str(e), "code": 500}

@classes.post("/delete_school")
async def delete_school(location_id: int):
    if location_id:
        await Schools.filter(id=location_id).delete()
        return {"msg": "success", "code": 200}

@classes.post("/delete_session")
async def delete_session(id: int):
    if id:
        await Class_detail.filter(id=id).delete()
        return {"msg": "success", "code": 200}

@classes.post("/delete_event")
async def delete(id: int):
    if id:
        await Class_detail.filter(class_list_id=id).delete()
        await Class_list.filter(id=id).delete()
        await Class_date.filter(class_list_id=id).delete()
        return {"msg": "success", "code": 200}
    
@classes.post("/delete_class_name")
async def delete(id: int):
    if id:
        class_event_list = await Class_list.filter(name_id=id).all()
        for class_event_obj in class_event_list:
            await Class_detail.filter(class_list_id=class_event_obj.id).delete()
            await Class_date.filter(class_list_id=class_event_obj.id).delete()

        await Class_list.filter(name_id=id).delete()
        await Class_name.filter(id=id).delete()
        
        return {"msg": "success", "code": 200}

@classes.get("/get_class_state")
async def check_date_state(
    class_name_id : Optional[int] = None,
    class_event_id : Optional[int] = None,
    special_class_list_name : Optional[str] = None,
):
    if class_name_id: 
        Q_word = Q(name_id=class_name_id)
    elif class_event_id:
        Q_word = Q(id=class_event_id)
    else:
        return {"msg": 'please input ID', "code": 500}
    
    if special_class_list_name == "one_day_class":
        class_list = await One_day_class.filter(Q_word).all()
    else :
        class_list = await Class_list.filter(Q_word).all()
    
    result = {"state": "尚未開放報名"}
    try:
        for class_obj in class_list:
            try:
                if class_obj.start_time.replace(tzinfo=None) <= datetime.now() and class_obj.end_time.replace(tzinfo=None) >= datetime.now():
                    result["state"] = "開課中"
                    break
                elif class_obj.end_time.replace(tzinfo=None) < datetime.now():
                    result["state"] = "課程已結束"
                    break
                else:
                    pass
            except Exception as e:
                pass

            if special_class_list_name == "one_day_class":
                if class_obj.reg_deadline.replace(tzinfo=None) >= datetime.now() :
                    result["state"] = "報名中"
                    break
                elif class_obj.reg_deadline.replace(tzinfo=None) < datetime.now():
                    result["state"] = "報名截止(人數已滿)"
                    break
            else :
                try:
                    class_date_obj = await Class_date.get(class_list_id=class_obj.id)
                    if class_date_obj.registration_start.replace(tzinfo=None) <= datetime.now() and class_date_obj.registration_end.replace(tzinfo=None) >= datetime.now() :
                        if class_date_obj.amount_left == 0:
                            result["start_class"] = "報名截止(人數已滿)"
                            break
                        else:
                            result["start_class"] = "報名中"
                            break
                    elif class_date_obj.registration_end.replace(tzinfo=None) < datetime.now():
                        result["start_class"] = "報名截止(人數已滿)"
                        break
                except Exception as e:
                    pass
                    

        return {"msg": "success", "code": 200, "result": result}
    except Exception as e:
        return {"msg": str(e), "code": 500}

@classes.get("/get_event")
async def search_event(
    class_name_id: Optional[int] = None,
    event_id : Optional[int] = None
):
    try:
        try :
            class_name_obj = await Class_name.get(id=class_name_id)
        except:
            return {"msg": "no this class id", "code": 500}
        
        special_class_list_name = class_name_obj.special_class_list_name

        Q_word = Q()

        if class_name_id:
            Q_word = Q_word | Q(name_id = class_name_id)
        elif event_id:
            Q_word = Q_word | Q(id = event_id)
        else :
            return {"msg": "please input class_name_id or event_id", "code": 200}
        
        model_fields =[]
        state = {}

        if special_class_list_name==None:
            class_list = Class_list.filter(Q_word).all().order_by("-start_time")
            # 获取模型类中的所有字段
            model_fields = [attr for attr in dir(Class_list) if isinstance(getattr(Class_list, attr), fields.Field)]
            try:
                state = await check_date_state(class_event_id=class_name_id)
            except:
                state["result"] = {
                    "state" : "fail to get data"
                }
        elif  special_class_list_name=='one_day_class':
            class_list = One_day_class.filter(Q_word).all().order_by("-start_time")
            # model_fields = [attr for attr in dir(One_day_class) if isinstance(getattr(One_day_class, attr), fields.Field)]
            try:
                state = await check_date_state(class_name_id=class_name_id,special_class_list_name=special_class_list_name)
            except:
                state["result"] = {
                    "state" : "fail to get data"
                }
                
    
        class_list = await class_list.all()

        classes = []
        for class_obj in class_list:
            class_name_obj = await Class_name.get(id=class_obj.name_id)
            class_name = class_name_obj.name

            try : 
                class_data = class_obj.show_data()
                class_data["class_name"] = class_name
                class_data["state"] = state["result"]["state"]

                try:
                    class_date_obj = await Class_date.get(class_list_id=class_obj.id)
                    class_data["registration_start"] = class_date_obj.registration_start
                    class_data["registration_end"] = class_date_obj.registration_end
                    class_data["number_limit"] = class_date_obj.number_limit
                    class_data["amount_left"] = class_date_obj.amount_left
                    model_fields.append("registration_start","registration_end","number_limit","amount_left")
                
                except:
                    pass

            except:
                class_data = {
                    "msg" : "fail to get data"
                }
            
            classes.append(class_data)

        return {"msg": "success", "code": 200, "classes": classes}
    except Exception as e:
        return {"msg": str(e), "code": 500}
    
@classes.get("/get_school")
async def get_school(
    location_id : Optional[int] = None,
    keyword : Optional[str] = None, 
    location_keyword : Optional[str] = None, 
    page_num : Optional[int] = None,
    page_amount : Optional[int] = None,
    category :  Optional[str] = None
):
    try:
        school_list = Schools.all()

        if location_id :
            school_list = school_list.filter(id = location_id).all()
        
        if keyword :
            school_list = school_list.filter(Q(name__icontains=keyword)).all()

        if location_keyword :
            school_list = school_list.filter(Q(address__icontains=location_keyword)).all()

        Q_word = Q()
        if category:
            for tmp_word in category.split(",") :
                Q_word = Q_word | Q(category__icontains=tmp_word)

        school_list_tmp = await school_list.all()

        for school_obj in school_list_tmp:
            class_list = await Class_name.filter(Q(school_id = school_obj.id) & Q_word)
            if class_list == []:
                school_list = school_list.exclude(id = school_obj.id)
        
        count = await school_list.all().count()

        if page_num and page_amount:
            school_list = school_list.offset((page_num-1)*page_amount).limit(page_amount)
        
        school_list = await school_list.all().order_by("-update_time")
        
        schools = []

        for school_obj in school_list:
            try :
                
                school_data = school_obj.show_data()
                
                schools.append(school_data)
                

            except:
                schools.append({"msg : data wrong"})
            

        return {"msg": "success", "code": 200, "total_num" : count,"schools": schools}
    except Exception as e:
        return {"msg": str(e), "code": 500}
    
@classes.get("/get_group_name")
async def get_school_group():
    try:
        school_group_list = await Group_name.all()
        school_groups = []
        for school_obj in school_group_list:
            school_data = {
                "group_id": school_obj.id,
                "group_name": school_obj.group_name
            }
            school_groups.append(school_data)

        return {"msg": "success", "code": 200, "school_groups": school_groups}
    except Exception as e:
        return {"msg": str(e), "code": 500}

@classes.get("/get_class_name")
async def get_class_name(
    location_id : Optional[int] = None ,
    class_name_id : Optional[int] = None,
    group_id : Optional[int] = None,
    group_sort :Optional[str] = None,
    exclude_word: Optional[str] = None,
    category :Optional[str] = None,
    page_num : Optional[int] = None,
    page_amount : Optional[int] = None,
    recommend : Optional[int] = None,
    is_inner : Optional[int] = None,
    is_check : Optional[int] = None
):
    try:
        class_name_list = Class_name.all()
        Q_word = Q()

        if group_id:
            Q_word = Q_word & Q(group_id = group_id)

        if group_sort:
            Q_word = Q_word & Q(group_sort = group_sort)
        
        if category:
            for tmp_word in category.split(",") :
                Q_word = Q_word | Q(category__icontains=tmp_word) 

        if location_id :
            Q_word = Q_word & Q(school_id = location_id)

        if class_name_id :
            Q_word = Q_word & Q(id = class_name_id)

        if recommend :
            Q_word = Q_word & Q(recommend = recommend)

        if is_inner!=None:
            Q_word = Q_word & Q(is_inner = is_inner)

        if is_check!=None:
            Q_word = Q_word & Q(is_check = is_check)

        class_name_list = class_name_list.filter(Q_word).all()

        if exclude_word:        
            for tmp_word in exclude_word.split(",") :
                # print(tmp_word)
                class_name_list = class_name_list.exclude(Q(category__icontains=tmp_word)|Q(group_sort__icontains=tmp_word)).all()
        

        count = await class_name_list.all().count()

        if page_num and page_amount:
            class_name_list = class_name_list.offset((page_num-1)*page_amount).limit(page_amount)

        class_name_list = await class_name_list.all().order_by("-id")
        classes_name = []
        state = {}
        special_class_list_name = None
        
        for class_name_obj in class_name_list:
            school_obj = await Schools.filter(id=class_name_obj.school_id).all()
            school_name = ""
            if school_obj == []:
                school_name = "未設定該據點"
            else :
                school_obj = await Schools.get(id=class_name_obj.school_id)
                school_name = school_obj.name
            
            try:
        
                special_class_list_name = class_name_obj.special_class_list_name

                if special_class_list_name:
                    state = await check_date_state(class_name_id=class_name_obj.id,special_class_list_name=special_class_list_name)
                else:
                    state = await check_date_state(class_name_id=class_name_obj.id)
                
                class_data = class_name_obj.show_data()
                class_data["school"]=school_name  
                class_data["state"]=state["result"]["state"]
            except Exception as e:
                class_data = {
                    "msg" : str(e)
                } 
                
            classes_name.append(class_data)
                    

        return {"msg": "success", "code": 200,"total_num" : count,"classes": classes_name}
    
    except Exception as e:
        return {"msg": str(e), "code": 500}    
    
@classes.get("/get_session")
async def get_session(
    event_id : Optional[int] = None
):
    try:
        if not event_id:
            return {"msg": "please input event_id", "code": 500}
        
        class_session_list = await Class_detail.filter(class_list_id=event_id).all().order_by("start_time")
        
        classe_sessions = []
        for class_session_obj in class_session_list:
            class_session_data = {
            "session_id": class_session_obj.id,
            "class_event_id": class_session_obj.class_list_id,
            "start_time": class_session_obj.start_time,
            "end_time": class_session_obj.end_time,
            "sessions": class_session_obj.sessions,
            "content": class_session_obj.content
        }
            classe_sessions.append(class_session_data)

        return {"msg": "success", "code": 200, "classe_sessions": classe_sessions}
    except Exception as e:
        return {"msg": str(e), "code": 500}

@classes.get("/search_class_like")
async def search_class_like(keyword: str):
    try:
        class_list = await Class_list.filter(Q(lecturer__icontains=keyword)).all()

        classes = []
        for class_obj in class_list:
            class_name = await Class_name.get(id=class_obj.name_id)
            school_obj = await Schools.get(id=class_name.school_id)
            
            class_data = {
                "class_id": class_obj.id,
                "name": class_name.name,
                "school":school_obj.name,
                "category": class_name.category,
                "introduction": class_name.introduction,
                "organizer": class_name.organizer,
                "cover_img": class_name.cover_img,
                "event": class_obj.event,
                "start_time": class_obj.start_time,
                "end_time": class_obj.end_time,
                "location": class_obj.location,
                "lecturer": class_obj.lecturer,
                "contact": class_obj.contact,
                "content": class_obj.content,
                "URL": class_obj.URL,
                "people": class_obj.people,
                "fee_method": class_obj.fee_method,
                "registration_way": class_obj.registration_way,
                "remark": class_obj.remark
            }
            classes.append(class_data)

        class_name_list = await Class_name.filter(
            Q(name__icontains=keyword)|
            Q(group_sort__icontains=keyword)|
            Q(category__icontains=keyword)|
            Q(organizer__icontains=keyword)).all()

        for class_name in class_name_list:
            class_list = await Class_list.filter(name_id=class_name.id).all()
            for class_obj in class_list:
                school_obj = await Schools.get(id=class_name.school_id)
                class_data = {
                    "class_id": class_obj.id,
                    "name": class_name.name,
                    "school":school_obj.name,
                    "category": class_name.category,
                    "introduction": class_name.introduction,
                    "organizer": class_name.organizer,
                    "cover_img": class_name.cover_img,
                    "event": class_obj.event,
                    "start_time": class_obj.start_time,
                    "end_time": class_obj.end_time,
                    "location": class_obj.location,
                    "lecturer": class_obj.lecturer,
                    "contact": class_obj.contact,
                    "content": class_obj.content,
                    "URL": class_obj.URL,
                    "people": class_obj.people,
                    "fee_method": class_obj.fee_method,
                    "registration_way": class_obj.registration_way,
                    "remark": class_obj.remark

                }
                if class_data not in classes:
                    classes.append(class_data)

        return {"msg": "success", "code": 200, "classes": classes}
    except Exception as e:
        return {"msg": str(e), "code": 500}

@classes.post("/add_favorite_class")
async def add_favorite_class(
        class_name_id: int, 
        user_id = Depends(check_token),
        time_stemp: datetime = datetime.now()
):
    try:
        if not user_id:
            return {"msg": "no access", "code": 500}
        new_favorite_class = await Favorite_course.get_or_create(
            class_name_id=class_name_id,
            user_id=user_id,
            defaults={'time_stemp': time_stemp}
        )
        return {"msg": "success", "code": 200,"is exist": not new_favorite_class[1],"id":new_favorite_class[0].id}
    except Exception as e:
        return {"msg": str(e), "code": 500}

@classes.get("/get_favorite_class")
async def get_favorite_class( 
        user_id = Depends(check_token),
        no_details : Optional[int] = None
):
    try:
        class_list = await Favorite_course.filter(user_id = user_id).all()
        favorite_courses = []
        for class_obj in class_list:
            if no_details:
                class_data = {
                    "id": class_obj.id,
                    "user_id": class_obj.user_id,
                    "class_name_id" : class_obj.class_name_id,
                    "time_stemp":class_obj.time_stemp
                }
                favorite_courses.append(class_data)
            else:
                class_data = {
                    "id": class_obj.id,
                    "user_id": class_obj.user_id,
                    "class_name_id" : class_obj.class_name_id,
                    "time_stemp":class_obj.time_stemp

                }

                result = await get_class_name(class_name_id = class_obj.class_name_id)
                class_detail = result["classes"][0]
                for class_tmp in class_detail.items():
                    class_data[class_tmp[0]] = class_tmp[1]
                favorite_courses.append(class_data)        

        return {"msg": "success", "code": 200, "favorite_courses": favorite_courses}
    except Exception as e:
        return {"msg": str(e), "code": 500}

@classes.post("/delete_favorite_class")
async def delete_favorite_class(
        class_name_id: int, 
        user_id = Depends(check_token)
):
    try:
        await Favorite_course.filter(class_name_id=class_name_id,user_id=user_id).delete()
        return {"msg": "success", "code": 200}
    except Exception as e:
        return {"msg": str(e), "code": 500}

@classes.post("/insert_online_course")
async def insert_online_course(
    title : str = Form(default=''),
    category : str = Form(default=''),
    create_time :str = Form(default=datetime.now()),
    content : str = Form(default=''),
    video_url :str = Form(default='')
):
    try:
        new_online_course = await Online_course.create(
            title=title,
            create_time=create_time,
            category=category,
            content=content,
            video_url=video_url,
            group_id = 8
        )
        
        return {"msg": "success", "code": 200, "online_course_obj": new_online_course.id}
    except Exception as e:
        return {"msg": str(e), "code": 500}
    
@classes.post("/update_online_course")
async def update_online_course(
    id : int = Form(default=0),
    title : str = Form(default=''),
    category : str = Form(default=''),
    create_time :str = Form(default=datetime.now()),
    content : str = Form(default=''),
    video_url :str = Form(default='')
):
    try:
        online_course_obj = await Online_course.get(id=id)

        if title.strip() != '':
            online_course_obj.title = title
        
        if category.strip() != '':
            online_course_obj.category = category

        if create_time.strip() != '':
            online_course_obj.create_time = create_time

        if content.strip() != '':
            online_course_obj.content = content

        if video_url.strip() != '':
            online_course_obj.video_url = video_url
        
        await online_course_obj.save()
        
        return {"msg": "success", "code": 200}
    except Exception as e:
        return {"msg": str(e), "code": 500}

@classes.get("/get_online_courese")
async def get_online_courese(
    online_courese_id : Optional[int] = None,
    category:Optional[int] = None,
    group_id : Optional[int] = None,
    page_num : Optional[int] = None,
    page_amount : Optional[int] = None
    
):
    try:
        online_courese_list = Online_course.all()
        Q_word = Q()

        if group_id:
            Q_word = Q_word & Q(group_id = group_id)

        if category:
            for tmp_word in category.split(",") :
                Q_word = Q_word | Q(category__icontains=tmp_word) 

        if online_courese_id :
            Q_word = Q_word & Q(id = online_courese_id)

        count = await online_courese_list.all().count()

        if page_num and page_amount:
            online_courese_list = online_courese_list.offset((page_num-1)*page_amount).limit(page_amount)

        online_courese_list = await online_courese_list.all().order_by("-id")
        
        online_coureses = []
        for online_coures_obj in online_courese_list:
            online_coures_data = {
                "id": online_coures_obj.id,
                "title": online_coures_obj.title,
                "category":online_coures_obj.category,
                "create_time": online_coures_obj.create_time,
                "click_time": online_coures_obj.click_time,
                "content": online_coures_obj.content,
                "video_url":online_coures_obj.video_url
            }
            online_coureses.append(online_coures_data)

        return {"msg": "success", "code": 200, "total_num" : count,"online_coures": online_coureses}
    except Exception as e:
        return {"msg": str(e), "code": 500}

@classes.post("/delete_online_course")
async def delete_online_course(
    online_course_id : int 
):
    try:
        await Online_course.filter(id=online_course_id).delete()
        return {"msg": "success", "code": 200}
    except Exception as e:
        return {"msg": str(e), "code": 500}

@classes.get("/get_group_classes_and_articles")
async def get_group_classes_and_articles(
    group_id : int,
    page_num : Optional[int] = None,
    page_amount : Optional[int] = None
):
    try:
        class_name_list = Class_name.filter(group_id = group_id).all().order_by("-id")
        article_list = Article_list.filter(group_id = group_id).all().order_by("-id")

        class_count = await class_name_list.all().count()
        article_count = await article_list.all().count()

        if page_num and page_amount:
            class_name_list = class_name_list.offset((page_num-1)*page_amount).limit(page_amount)
            article_list = article_list.offset((page_num-1)*page_amount).limit(page_amount)
        
        
        class_name_list = await class_name_list.all()
        article_list = await article_list.all()

        article_objs = []
        
        for article_obj in article_list:
            try :
                article_tmp = {
                    "article_id": article_obj.id,
                    "title": article_obj.title,
                    "school_id" :article_obj.school_id,
                    "group_sort" :article_obj.group_sort,
                    "group_id" :article_obj.group_id,
                    "category": article_obj.category,
                    "create_time" : article_obj.create_time,
                    "click_time" : article_obj.click_time,
                    "depiction" : article_obj.depiction,
                    "content" : article_obj.content,
                    "files" : article_obj.files,
                    "vedio_url" : article_obj.vedio_url,
                    "tags" : article_obj.tags,
                    "cover_img": article_obj.cover_img
                }
            except:
                article_tmp = {
                    "msg" : "fail to get data"
                } 
                
            article_objs.append(article_tmp)
            

        classes_name = []

        
        for class_name_obj in class_name_list:
            school_obj = await Schools.filter(id=class_name_obj.school_id).all()
            school_name = ""
            if school_obj == []:
                school_name = "未設定該據點"
            else :
                school_obj = await Schools.get(id=class_name_obj.school_id)
                school_name = school_obj.name
            try:
                class_data = {
                    "class_name_id": class_name_obj.id,
                    "name": class_name_obj.name,
                    "school":school_name,
                    "category": class_name_obj.category,
                    "introduction": class_name_obj.introduction,
                    "organizer": class_name_obj.organizer,
                    "group_id": class_name_obj.group_id,
                    "cover_img": class_name_obj.cover_img,
                    "group_sort":class_name_obj.group_sort
                    }
                
            except:
                class_data ={
                    "msg" : "fail to get data"
                } 
            
            classes_name.append(class_data)
                    

        return {"msg": "success", "code": 200,"class_num" : class_count,"classes": classes_name,"article_num":article_count,"articles": article_objs}
    
    except Exception as e:
        return {"msg": str(e), "code": 500}    
    
@classes.post("/add_attend_record")
async def add_attend_record(
    class_detail_id : int = Form(default=0),
    user_id : int =  Form(default=0),
    is_attend : int = Form(default=0)
):
    try:
        if not class_detail_id or not user_id:
            return {"msg": "Please input right ","code":500}
        
        try:
            class_detail_obj = await Class_detail.filter(id = class_detail_id).all()
            if not class_detail_obj:
                return {"msg": "no this class_detail_id","code":500}
        except:
            return {"msg": "get class_detail_id error","code":500}
        
        new_record = await Attend_record.get_or_create(
            class_detail_id = class_detail_id,
            user_id = user_id,
            defaults = {
                "is_attend" : is_attend
            }
        )

        return {"msg": "success", "code": 200,"new_record_id":new_record[0].id}

    except Exception as e:
        return {"msg": str(e), "code": 500} 
    
@classes.post("/delete_attend_record")
async def delete_attend_record(
    id : int = 0
):
    try :
        await Attend_record.filter(id=id).delete()
        return {"msg": "success", "code": 200}
    except Exception as e:
        return {"msg": str(e), "code": 500} 
    
@classes.get("/update_attend_record")
async def update_attend_record(
    id : int = 0,
    class_detail_id : Optional[int] = None,
    user_id : Optional[int] = None,
    is_attend : Optional[int] = None
):
    if not id :
        return {"msg":"please input id"}
    
    try :
        tmp = await Attend_record.get(id=id)

        if class_detail_id!=None:
            tmp.class_detail_id = class_detail_id

        if user_id!=None:
            tmp.user_id = user_id

        if is_attend!=None:
            tmp.is_attend = is_attend

        await tmp.save()

        return {"msg": "success", "code": 200}
    except Exception as e:
        return {"msg": str(e), "code": 500}   
    
@classes.get("/get_attend_record")
async def get_attend_record(
    class_event_id : Optional[int] = None,
    class_detail_id : Optional[int] = None,
    user_id : Optional[int] = None,
    is_attend : Optional[int] = None
):
    try:
        attend_record_list = Attend_record.all()

        if class_event_id:
            id_list = []
            class_detail_list = await Class_detail.filter(class_list_id = class_event_id)
            for tmp in class_detail_list :
                id_list.append(tmp.id)
            attend_record_list = Attend_record.filter(class_detail_id__in=id_list)
                

        if class_detail_id:
            attend_record_list = attend_record_list.filter(class_detail_id = class_detail_id)

        if user_id :
            attend_record_list = attend_record_list.filter(user_id = user_id)

        if is_attend :
            attend_record_list = attend_record_list.filter(is_attend = is_attend)

        attend_record_list = await attend_record_list.all()
        attend_records = []

        for obj in attend_record_list:
            data = {
                "id" :obj.id,
                "class_detail_id" :obj.class_detail_id,
                "user_id" :obj.user_id,
                "is_attend" :obj.is_attend
            }
            attend_records.append(data)

        return {"msg": "success", "code": 200,"attend_record_list":attend_records}
    except Exception as e:
        return {"msg": str(e), "code": 500}