Merge remote-tracking branch 'origin/master'

# Conflicts:
#	app/models/models.py

app/api/article.py

@@ -18,7 +18,7 @@ from fastapi.responses import HTMLResponse
 
 article = APIRouter()
 
-IMAGEDIR = "/var/www/ntcri/ntcri/assets/article_files/"
+IMAGEDIR = "/var/www/ntcri/assets/article_files/"
 IMAGEDIR_short = "assets/article_files/"
 
 async def create_upload_files(files:Optional[List[UploadFile]] = File(None)):
@@ -67,37 +67,39 @@ async def get_article(
         if group_id :
             article_list = article_list.filter(group_id = group_id).all()
 
-        article_list = await article_list.all()
+        count = await article_list.all().count()
+
+        if page_num and page_amount:
+            article_list = article_list.offset((page_num-1)*page_amount).limit(page_amount)
+
+        article_list = await article_list.all().order_by("-create_time")
 
         article_objs = []
-        count = 0
+        
         for article_obj in article_list:
-            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,
-            "url" : article_obj.url
-            }
-            if page_num and page_amount:
-                if count < page_num*page_amount and count >= (page_num-1)*page_amount :
-                    article_objs.append(article_tmp)
-                    count += 1
-                elif  count >= page_num*page_amount: count += 1
-                else : count += 1
-            else :
-                article_objs.append(article_tmp)
-                count += 1
+            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,
+                    "video_url" : article_obj.vedio_url,
+                    "tags" : article_obj.tags,
+                    "cover_img": article_obj.cover_img,
+                    "url" : article_obj.url
+                }
+            except:
+                article_tmp = {"msg":"data wrong"}
+            
+            article_objs.append(article_tmp)
+                
 
         return {"msg": "success", "code": 200, "total_num":count,"articles": article_objs}
     except Exception as e:
@@ -213,7 +215,7 @@ async def update_article(
         if tags != '[]':
             article_obj.tags = tags
 
-        if url != '[]':
+        if url != '':
             article_obj.url = url
 
         
@@ -235,7 +237,11 @@ async def update_article(
 @article.post("/delete_article")
 async def delete_article(id: int = 0):
     if id != 0:
-        await Article_list.filter(id=id).delete()
+        article_obj = await Article_list.get(id=id)
+
+        article_obj.is_del = 1
+
+        await article_obj.save()
         return {"msg": "success", "code": 200}
     else :
         return {"msg": "please input ID", "code": 200}
@@ -244,7 +250,7 @@ async def delete_article(id: int = 0):
 async def search_article_like(keyword: str,page_num : Optional[int] = None,
     page_amount : Optional[int] = None):
     try:
-        article_list = await Article_list.filter(
+        article_list = Article_list.filter(
             Q(title__icontains=keyword)|
             Q(category__icontains=keyword)|
             Q(content__icontains=keyword)|
@@ -252,35 +258,38 @@ async def search_article_like(keyword: str,page_num : Optional[int] = None,
             Q(tags__icontains=keyword)
                 ).all()
         
+        count = await article_list.all().count()
+
+        if page_num and page_amount:
+            article_list = article_list.offset((page_num-1)*page_amount).limit(page_amount)
+
+        article_list = await article_list.all().order_by("-create_time")
+        
         article_objs = []
-        count = 0
+        
         for article_obj in article_list:
-            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,
-            "url" : article_obj.url
-        }
-            if page_num and page_amount:
-                if count < page_num*page_amount and count >= (page_num-1)*page_amount :
-                    article_objs.append(article_tmp)
-                    count += 1
-                elif  count >= page_num*page_amount: count += 1
-                else : count += 1
-            else :
-                article_objs.append(article_tmp)
-                count += 1
+            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,
+                    "video_url" : article_obj.vedio_url,
+                    "tags" : article_obj.tags,
+                    "cover_img": article_obj.cover_img,
+                    "url" : article_obj.url
+                }
+            except:
+                article_tmp = {"msg":"data wrong"}
+            
+            article_objs.append(article_tmp)
 
         return {"msg": "success", "code": 200, "total_num":count,"article": article_objs}
     except Exception as e:

app/api/classes.py

@@ -3,7 +3,7 @@ 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
+from app.models.models import User,Favorite_course,Article_list,Class_date,Attend_record
 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
@@ -20,6 +20,7 @@ from tortoise.queryset import Q
 from fastapi.responses import HTMLResponse
 import requests
 import json
+from itertools import chain
 
 classes = APIRouter()
 
@@ -35,7 +36,7 @@ async def check_token(access_token: str):
 
     return user_id
 
-IMAGEDIR = "/var/www/ntcri/ntcri/assets/"
+IMAGEDIR = "/var/www/ntcri/assets/"
 IMAGEDIR_short = "assets/"
 
 async def update_location_time(location_id: int):
@@ -50,8 +51,7 @@ async def insert_school(
     location_name: str = Form(default=''),
     Lng: str = Form(default=''),
     Lat: str = Form(default=''),
-    address : str = Form(default=''),
-    update_time : datetime = Form(default=datetime.now())
+    address : str = Form(default='')
 ):
     try:
         new_school = await Schools.create(
@@ -59,7 +59,7 @@ async def insert_school(
             longitude=Lng,
             latitude=Lat,
             address = address,
-            update_time = update_time
+            update_time = datetime.now()
         )
         
         return {"msg": "success", "code": 200, "location_id": new_school.id}
@@ -82,7 +82,7 @@ async def insert_class_name(
         if cover_img_file != '':
             contents = await cover_img_file.read()
 
-        #save the file
+            #save the file
             with open(f"{IMAGEDIR}{cover_img_file.filename}", "wb") as f:
                 f.write(contents)
         
@@ -117,7 +117,9 @@ async def insert_event(
     people : str = Form(default=''),
     fee_method: str = Form(default=''),
     registration_way: str = Form(default=''),
-    registration_day: 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='')
 ):    
     try:
@@ -140,14 +142,63 @@ async def insert_event(
             people=people,
             fee_method=fee_method,
             registration_way=registration_way,
-            registration_day=registration_day,
             remark=remark
         )
 
+        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
+        )
+
         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),
@@ -272,7 +323,9 @@ async def update_event(
     people : str = Form(default=''),
     fee_method: str = Form(default=''),
     registration_way: str = Form(default=''),
-    registration_day:  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='')
 ):
     try:
@@ -314,13 +367,36 @@ async def update_event(
         if registration_way.strip() != '':
             class_obj.registration_way = registration_way
 
-        if registration_day.strip() != '':
-            class_obj.registration_day = registration_day
-
         if remark.strip() != '':
             class_obj.remark = remark
+
+        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}
@@ -374,6 +450,7 @@ 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")
@@ -382,11 +459,59 @@ async def delete(id: int):
         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
+):
+    if class_name_id: 
+        class_list = await Class_list.filter(name_id=class_name_id).all()
+    elif class_event_id:
+        class_list = await Class_list.filter(id=class_event_id).all()
+    else:
+        return {"msg": 'please input ID', "code": 500}
+    
+    result = {"reg": "尚未開放報名", "start_class":"課程尚未開始"}
+    class_check = True
+    reg_check = True
+    try:
+        for class_obj in class_list:
+            if class_check:
+                try:
+                    if class_obj.start_time.replace(tzinfo=None) <= datetime.now() and class_obj.end_time.replace(tzinfo=None) >= datetime.now():
+                        result["start_class"] = "開課中"
+                        class_check = False
+                    elif class_obj.end_time.replace(tzinfo=None) < datetime.now():
+                        result["start_class"] = "課程已結束"
+                except Exception as e:
+                    result["start_class"] = "尚未確認開課時間"
+            
+            if reg_check:
+                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["reg"] = "報名已額滿"
+                        else:
+                            result["reg"] = "開放報名中"
+
+                        reg_check = False
+                    elif class_date_obj.registration_end.replace(tzinfo=None) < datetime.now():
+                        result["reg"] = "報名已結束"
+                except Exception as e:
+                    result["reg"] = "尚未確認報名時間"
+
+        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,
@@ -394,9 +519,9 @@ async def search_event(
 ):
     try:
         if event_id :
-            class_list = await Class_list.filter(id=event_id).all()
+            class_list = await Class_list.filter(id=event_id).all().order_by("-start_time")
         elif class_name_id:
-            class_list = await Class_list.filter(name_id=class_name_id).all()
+            class_list = await Class_list.filter(name_id=class_name_id).all().order_by("-start_time")
         else :
             return {"msg": "please input class_name_id or event_id", "code": 200}
 
@@ -405,24 +530,42 @@ async def search_event(
             class_name_obj = await Class_name.get(id=class_obj.name_id)
             class_name = class_name_obj.name
 
-            class_data = {
-            "class_name" : class_name,
-            "event_id": class_obj.id,
-            "name_id": class_obj.name_id,
-            "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,
-            "registration_day": class_obj.registration_day,
-            "remark": class_obj.remark
-        }
+            try : 
+                state = await check_date_state(class_event_id=class_obj.id)
+                class_data = {
+                    "class_name" : class_name,
+                    "event_id": class_obj.id,
+                    "name_id": class_obj.name_id,
+                    "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,
+                    "state": state["result"]
+                }
+
+                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
+                
+                except:
+                    pass
+
+            except:
+                class_data = {
+                    "msg" : "fail to get data"
+                }
+            
             classes.append(class_data)
 
         return {"msg": "success", "code": 200, "classes": classes}
@@ -431,27 +574,51 @@ async def search_event(
     
 @classes.get("/get_school")
 async def get_school(
-    location_id : Optional[int] = None
+    location_id : Optional[int] = None,
+    keyword : Optional[str] = None, 
+    location_keyword : Optional[str] = None, 
+    page_num : Optional[int] = None,
+    page_amount : Optional[int] = None
 ):
     try:
+        school_list = Schools.all()
+
         if location_id :
-            school_list = await Schools.filter(id = location_id).all()
-        else :
-            school_list = await Schools.all()
+            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()
+        
+        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:
-            school_data = {
-                "location_id": school_obj.id,
-                "location_name": school_obj.name,
-                "Lng": school_obj.longitude,
-                "Lat": school_obj.latitude,
-                "address": school_obj.address,
-                "update_time":school_obj.update_time
-            }
-            schools.append(school_data)
+            try :
+                school_data = {
+                    "location_id": school_obj.id,
+                    "location_name": school_obj.name,
+                    "Lng": school_obj.longitude,
+                    "Lat": school_obj.latitude,
+                    "address": school_obj.address,
+                    "update_time":school_obj.update_time
+                }
+            
+                schools.append(school_data)
+
+            except:
+                schools.append({"msg : data wrong"})
+            
 
-        return {"msg": "success", "code": 200, "schools": schools}
+        return {"msg": "success", "code": 200, "total_num" : count,"schools": schools}
     except Exception as e:
         return {"msg": str(e), "code": 500}
     
@@ -484,6 +651,9 @@ async def get_class_name(
     try:
         class_name_list = Class_name.all()
 
+        if group_id:
+            class_name_list = class_name_list.filter(group_id = group_id).all()
+
         if group_sort:
             class_name_list = class_name_list.filter(group_sort = group_sort).all()
         
@@ -496,10 +666,15 @@ async def get_class_name(
         if class_name_id :
             class_name_list = class_name_list.filter(id = class_name_id).all()
 
-        class_name_list = await class_name_list.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 = []
 
-        count = 0
+        
         for class_name_obj in class_name_list:
             school_obj = await Schools.filter(id=class_name_obj.school_id).all()
             school_name = ""
@@ -508,27 +683,28 @@ async def get_class_name(
             else :
                 school_obj = await Schools.get(id=class_name_obj.school_id)
                 school_name = school_obj.name
-            if not group_id or class_name_obj.group_id==group_id:
+            
+            try:
+                state = await check_date_state(class_name_id=class_name_obj.id)
                 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
-                    }
-                if page_num and page_amount:
-                    if count < page_num*page_amount and count >= (page_num-1)*page_amount :
-                        classes_name.append(class_data)
-                        count += 1
-                    elif  count >= page_num*page_amount: count += 1
-                    else : count += 1
-                else :
-                    classes_name.append(class_data)
-                    count += 1
+                        "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,
+                        "state": state["result"]
+                        }
+            except:
+                class_data = {
+                    "msg" : "fail to get data"
+                } 
+                
+            classes_name.append(class_data)
+                    
 
         return {"msg": "success", "code": 200,"total_num" : count,"classes": classes_name}
     
@@ -540,7 +716,10 @@ async def get_session(
     event_id : Optional[int] = None
 ):
     try:
-        class_session_list = await Class_detail.filter(class_list_id=event_id).all()
+        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:
@@ -567,63 +746,64 @@ async def search_class_like(keyword: str):
         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 = {
-                "msg": "success",
-            "code": 200,
-            "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
-
+                "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)).all()
+        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 = {
-                "msg": "success",
-            "code": 200,
-            "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
+                    "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)
+                }
+                if class_data not in classes:
+                    classes.append(class_data)
 
         return {"msg": "success", "code": 200, "classes": classes}
     except Exception as e:
@@ -793,41 +973,51 @@ async def get_group_classes_and_articles(
     page_amount : Optional[int] = None
 ):
     try:
-        class_name_list = await Class_name.filter(group_id = group_id).all()
-        article_list = await Article_list.filter(group_id = group_id).all()
+        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 = []
-        article_count = 0
+        
         for article_obj in article_list:
-            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
-            }
-            if page_num and page_amount:
-                if article_count < page_num*page_amount and article_count >= (page_num-1)*page_amount :
-                    article_objs.append(article_tmp)
-                    article_count += 1
-                elif  article_count >= page_num*page_amount: article_count += 1
-                else : article_count += 1
-            else :
-                article_objs.append(article_tmp)
-                article_count += 1
+            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 = []
 
-        class_count = 0
+        
         for class_name_obj in class_name_list:
             school_obj = await Schools.filter(id=class_name_obj.school_id).all()
             school_name = ""
@@ -836,7 +1026,7 @@ async def get_group_classes_and_articles(
             else :
                 school_obj = await Schools.get(id=class_name_obj.school_id)
                 school_name = school_obj.name
-            if not group_id or class_name_obj.group_id==group_id:
+            try:
                 class_data = {
                     "class_name_id": class_name_obj.id,
                     "name": class_name_obj.name,
@@ -848,17 +1038,128 @@ async def get_group_classes_and_articles(
                     "cover_img": class_name_obj.cover_img,
                     "group_sort":class_name_obj.group_sort
                     }
-                if page_num and page_amount:
-                    if class_count < page_num*page_amount and class_count >= (page_num-1)*page_amount :
-                        classes_name.append(class_data)
-                        class_count += 1
-                    elif  class_count >= page_num*page_amount: class_count += 1
-                    else : class_count += 1
-                else :
-                    classes_name.append(class_data)
-                    class_count += 1
+                
+            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}    
+        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} 

app/api/news.py

@@ -18,36 +18,52 @@ from fastapi.responses import HTMLResponse
 
 news = APIRouter()
 
-IMAGEDIR = "/var/www/ntcri/ntcri/assets/news_files/"
+IMAGEDIR = "/var/www/ntcri/assets/news_files/"
 IMAGEDIR_short = "assets/news_files/"
 
 @news.get("/get_news")
 async def search_news(
-    news_id : int = None
+    news_id : int = None,
+    category :Optional[str] = None,
+    page_num : Optional[int] = None,
+    page_amount : Optional[int] = None
 ):
     try:
+        news_list = News.all()
         if news_id :
-            news_list = await News.filter(id=news_id).all()
-        else:    
-            news_list = await News.all()
+            news_list = news_list.filter(id=news_id).all()
+        
+        if category:
+            news_list = news_list.filter(category=category).all()
+
+        count = await news_list.all().count()
+
+        if page_num and page_amount:
+            news_list = news_list.offset((page_num-1)*page_amount).limit(page_amount)
+        
+        news_list = await news_list.all().order_by("-create_time")
 
         news_objs = []
         for news_obj in news_list:
-            news_tmp = {
-            "news_id": news_obj.id,
-            "title": news_obj.title,
-            "category": news_obj.category,
-            "create_time" : news_obj.create_time,
-            "click_time" : news_obj.click_time,
-            "content" : news_obj.content,
-            "files" : news_obj.files,
-            "URL" : news_obj.URL,
-            "tags" : news_obj.tags,
-            "cover_img": news_obj.cover_img
-        }
+            try:
+                news_tmp = {
+                    "news_id": news_obj.id,
+                    "title": news_obj.title,
+                    "category": news_obj.category,
+                    "create_time" : news_obj.create_time,
+                    "click_time" : news_obj.click_time,
+                    "content" : news_obj.content,
+                    "files" : news_obj.files,
+                    "URL" : news_obj.URL,
+                    "tags" : news_obj.tags,
+                    "cover_img": news_obj.cover_img
+                }
+            except:
+                news_tmp = {"msg":"data wrong"}
+                
             news_objs.append(news_tmp)
 
-        return {"msg": "success", "code": 200, "news": news_objs}
+        return {"msg": "success", "code": 200, "total_num" : count,"news": news_objs}
     except Exception as e:
         return {"msg": str(e), "code": 500}
     

app/api/registration.py

@@ -4,14 +4,14 @@ from typing import List,Optional,Union
 from fastapi.responses import FileResponse
 from random import randint
 from fastapi.security import OAuth2PasswordRequestForm
-from app.models.models import Registration,User,User_information,Class_list
+from app.models.models import Registration,User,User_information,Class_list,Class_name,Schools,Class_date
 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 datetime import timedelta,datetime,date
 from jose import jwt
 from emails.template import JinjaTemplate
 from tortoise.queryset import Q
@@ -33,16 +33,6 @@ async def check_token(access_token: str):
 
     return user_id
 
-async def check_if_id_exeit(
-    table_name : str,
-    id : int      
-):
-    exec('check_list = await {}.filter(id=id).all()'.format(table_name))
-    if check_list == []:
-        return True
-    else:
-        False
-
 async def check_permissions(user_id):
     user = await User.get(id=user_id)
     if user.is_superuser:
@@ -70,39 +60,65 @@ async def get_registration(
             return  {"msg": "please log in", "code": 200}
         
         if get_all:
-            inform_list = await User_information.all()
+            inform_list = Registration.all()
+        else:
+            inform_list = Registration.filter(user_id=user_id).all()
+
+        if event_id:
+            inform_list = inform_list.filter(event_id=event_id)
+
+        if is_check != None:
+            inform_list = inform_list.filter(reg_confirm=is_check)
+
+        if registration_id:
+            reg_list_tmp = await inform_list.filter(id=registration_id,is_del=0).all().order_by("-event_id","create_time")
         else:
-            inform_list = await User_information.filter(user_id=user_id).all()
+            reg_list_tmp = await inform_list.filter(is_del=0).all().order_by("-event_id","create_time")
+        
 
         reg_list = []
 
-        for infor in inform_list:
-            if registration_id:
-                reg_list_tmp = await Registration.filter(id=registration_id,user_inform_id=infor.id,is_del=0).all()
-            else:
-                reg_list_tmp = await Registration.filter(user_inform_id=infor.id,is_del=0).all()
+        for infor in reg_list_tmp:
 
-            for reg_obj in reg_list_tmp:
+            try : 
+                
+                reg_data = {
+                    "Registration_id" : infor.id,
+                    "event_id" : infor.event_id,
+                    "user_id" : infor.user_id,
+                    "reg_confirm" : infor.reg_confirm,
+                    "create_time" : infor.create_time
+                }
+            except:
                 reg_data = {
-                    "Registration_id" : reg_obj.id,
-                    "event_id" : reg_obj.event_id,
-                    "user_inform_id" : reg_obj.user_inform_id,
-                    "reg_confirm" : reg_obj.reg_confirm,
-                    "create_time" : reg_obj.create_time
+                    "msg" : "fail to get data"
                 }
-                if event_id and reg_data["event_id"] == event_id :
-                    if is_check != None :
-                        if reg_obj.reg_confirm == is_check :
-                            reg_list.append(reg_data)
-                    else :
-                        reg_list.append(reg_data)
-                elif not event_id:
-                    if is_check != None :
-                        if reg_obj.reg_confirm == is_check :
-                            reg_list.append(reg_data)
-                    else :
-                        reg_list.append(reg_data)
 
+            try :
+                class_obj = await Class_list.get(id = infor.event_id)
+                class_name_obj = await Class_name.get(id = class_obj.name_id)
+                school_obj = await Schools.get(id = class_name_obj.school_id)
+                reg_data["school_name"] = school_obj.name
+                reg_data["class_name"] = class_name_obj.name
+                reg_data["class_event"] = class_obj.event
+                reg_data["start_time"] = str(class_obj.start_time) 
+                reg_data["end_time"] =str(class_obj.end_time)
+
+            except Exception as e:
+                reg_data["class_data"] = str(e)
+            
+            try:
+                user = await User.get(id=infor.user_id)
+                inform = await User_information.get(user_id=infor.user_id)
+                reg_data["real_name"] = inform.name
+                reg_data["phone"] = inform.phone
+                reg_data["email"] = user.email
+
+            except Exception as e:
+                reg_data["user_data"] = str(e)
+
+            reg_list.append(reg_data)
+                
         
         return {"msg": "success", "code": 200,"registrations":reg_list}
     except Exception as e:
@@ -110,68 +126,200 @@ async def get_registration(
 
 @registration.post("/input_information")
 async def input_information(
-    user_id = Depends(check_token),
     name : str = Form(default=''),
+    user_name : str = Form(default=''),
+    birthday : date = Form(default=datetime.now().date()),
     gender : str = Form(default=''),
     phone : str = Form(default=''),
-    email : str = Form(default=''),
-    is_default : int = Form(default=0)
+    address : str = Form(default=''),
+    user_id = Depends(check_token)
 ):
     try :
         if not user_id :
             return  {"msg": "no access", "code": 200}
         
-        if is_default:
-            inform = await User_information.get_or_create(
-                user_id=user_id,
-                is_default = is_default,
-                defaults={
-                    'name': name,
-                    'gender': gender,
-                    'phone': phone,
-                    'email': email
+        
+        inform = await User_information.get_or_create(
+        user_id=user_id,
+            defaults={
+                'name': name,
+                'birthday' :birthday,
+                'gender': gender,
+                'phone': phone,
+                'address': address
+            }
+        )
+
+        if user_name != '':
+            user = await User.get(id = user_id)
+            user.username = user_name 
+            await user.save()
+            
+        
+
+        return {"msg": "success", "code": 200, "user_inform_id": inform[0].id,"is_exist":not inform[1]}
+    except Exception as e:
+        return {"msg": str(e), "code": 500}
+    
+@registration.post("/update_information")
+async def update_information(
+    user_name : str = Form(default=''),
+    name : str = Form(default=''),
+    birthday : date = Form(default=datetime.now().date()),
+    gender : str = Form(default=''),
+    phone : str = Form(default=''),
+    address : str = Form(default=''),
+    user_id = Depends(check_token)
+):
+    try :
+        if not user_id :
+            return  {"msg": "no access", "code": 200}
+        
+        infor = await User_information.get(user_id = user_id)
+        user = await User.get(id = user_id)
+
+        if name != '':
+            infor.name = name
+
+        if birthday != datetime.now().date():
+            infor.birthday = birthday
+
+        if gender != '':
+            infor.gender = gender
+
+        if phone != '':
+            infor.phone = phone
+
+        if address != '':
+            infor.address = address
+
+        if user_name != '':
+            user.username = user_name
+        
+        await infor.save()
+        await user.save()
+
+        return {"msg": "success", "code": 200, "user_inform_id": infor.id}
+    except Exception as e:
+        return {"msg": str(e), "code": 500}
+    
+@registration.get("/get_user_information")
+async def get_user_information(
+    user_id = Depends(check_token),
+    get_all : int = 0,
+    get_detail_information : int = 1
+):
+    try: 
+        if not user_id :
+            return  {"msg": "no access", "code": 200}
+        
+        try:
+            if get_all:
+                user_list = await User.all()
+            else:
+                user_list = await User.filter(id = user_id)
+        except:
+            return  {"msg": "user table run fail", "code": 500}
+
+        user_inform_list = []
+        for user_obj in user_list:
+            user_inform = {
+                    "user_id" : user_obj.id,
+                    "user_name" : user_obj.username,
+                    "email" : user_obj.email
                 }
-            )
-            new_inform = inform[0]
-        else :
-            new_inform = await User_information.create(
-                user_id = user_id,
-                name = name ,
-                gender = gender,
-                phone = phone,
-                email = email,
-                is_default = is_default
-            )
-
-        return {"msg": "success", "code": 200, "user_inform_id": new_inform.id}
+
+            if get_detail_information:
+                try :
+                    inform = await User_information.get(user_id=user_obj.id)
+                    user_inform["name"]  = inform.name
+                    user_inform["birthday"]  = inform.birthday
+                    user_inform["gender"]  = inform.gender
+                    user_inform["phone"]  = inform.phone
+                    user_inform["address"]  = inform.address
+                    user_inform["msg"] = "user information exist"
+                    user_inform["exist"] = True
+                    
+                except:
+                    user_inform["msg"] = "no user information"
+                    user_inform["exist"] = False
+
+            user_inform_list.append(user_inform)
+
+
+        return {"msg":"success","code":200,"user_inform": user_inform_list}
+    except Exception as e:
+        return {"msg": str(e), "code": 500}
+
+@registration.get("/change_class_reg_number")
+async def change_class_reg_number(
+    event_id: int = 0,
+    reduce_number : int = 1
+):
+    try:
+        if event_id:
+            try:
+                await Class_list.get(id = event_id)
+            except Exception as e:
+                return {"msg": "no this event", "code": 200}
+            try:
+                class_date = await Class_date.get(class_list_id = event_id)
+            except Exception as e:
+                return {"msg": "no this class' number limit", "code": 200}
+            
+            if class_date.amount_left ==0 and reduce_number>0:
+                return {"msg": "class is full", "code": 200,"amount_left":-1}
+            elif class_date.amount_left == class_date.number_limit and reduce_number<0:
+                return {"msg": "class is empty", "code": 200,"amount_left":class_date.amount_left }
+            else:
+                class_date.amount_left = class_date.amount_left-reduce_number
+                await class_date.save()
+    
+        return {"msg": "success", "code": 200,"amount_left":class_date.amount_left}
     except Exception as e:
         return {"msg": str(e), "code": 500}
 
 @registration.post("/input_registration")
 async def input_registration(
-    user_id = Depends(check_token),
-    user_inform_id : int= Form(default=0),
-    event_id : int = Form(default=0)
+    event_id : int = Form(default=0),
+    user_id = Depends(check_token)
 ): 
     try :
         if not user_id :
             return  {"msg": "please log in", "code": 200}
+        
+        try:
+            await Class_list.get(id = event_id)
+        except Exception as e:
+            return {"msg": "no this event", "code": 200}
 
         # if check_if_id_exeit(User_information,user_inform_id):
         #     return {"msg": "no user information", "code": 200}
         
         # if check_if_id_exeit(Class_list,event_id):
         #     return {"msg": "no class list", "code": 200}
+        try:
+            await User_information.get(user_id=user_id)
+        except:
+            return  {"msg": "no user information", "code": 200}
         
-        new_registration = await Registration.create(
+        new_registration = await Registration.get_or_create(
             event_id = event_id,
-            user_inform_id = user_inform_id,
-            reg_confirm = 0,
-            is_del = 0 ,
-            create_time = datetime.now()
+            user_id = user_id,
+            defaults = {
+                "reg_confirm" : 0,
+                "is_del" : 0 ,
+                "create_time" : datetime.now()
+            }
         )
 
-        return {"msg": "success", "code": 200,"new_registration_id":new_registration.id}
+        if new_registration[1]:
+            amount_left_obj = await change_class_reg_number(event_id=event_id)
+            msg = amount_left_obj["msg"]
+        else:
+            msg = "already registrate"
+
+        return {"msg": msg, "code": 200,"new_registration_id":new_registration[0].id,"is_already_exist":not new_registration[1]}
     except Exception as e:
         return {"msg": str(e), "code": 500}
     
@@ -191,17 +339,55 @@ async def confirm_reg(
     except Exception as e:
         return {"msg": str(e), "code": 500}
 
+@registration.post("/recover_registration")
+async def delete_registration(
+    user_id = Depends(check_token),
+    event_id : int = 0
+):
+    try:
+
+        if not user_id :
+            return  {"msg": "please log in", "code": 200}
+        
+        registration_obj = await Registration.get(event_id=event_id,user_id=user_id)
+
+        amount_left_obj = await change_class_reg_number(event_id=registration_obj.event_id)
+        msg = amount_left_obj["msg"]
+
+        if msg == "class is full":
+            return {"msg": msg+" cannot recover registration", "code": 200}
+
+        registration_obj.is_del = 0
+
+        await registration_obj.save()
+
+        return {"msg": msg, "code": 200}
+    except Exception as e:
+        return {"msg": str(e), "code": 500}
+
 @registration.post("/delete_registration")
 async def delete_registration(
-    registration_id : int 
+    user_id = Depends(check_token),
+    super_ad_input_user_id : int = 0,
+    event_id : int = 0
 ):
     try:
-        registration_obj = await Registration.get(id=registration_id)
+
+        if not user_id :
+            return  {"msg": "please log in", "code": 200}
+        
+        if super_ad_input_user_id:
+            registration_obj = await Registration.get(event_id=event_id,user_id=super_ad_input_user_id)
+        else:
+            registration_obj = await Registration.get(event_id=event_id,user_id=user_id)
 
         registration_obj.is_del = 1
 
+        amount_left_obj = await change_class_reg_number(event_id=registration_obj.event_id,reduce_number=-1)
+        msg = amount_left_obj["msg"]
+
         await registration_obj.save()
 
-        return {"msg": "success", "code": 200}
+        return {"msg": msg , "code": 200}
     except Exception as e:
         return {"msg": str(e), "code": 500}

app/models/models.py

@@ -68,7 +68,6 @@ class Class_list(Model):
     fee_method = fields.CharField(max_length=255, description="收費方式")
     registration_way = fields.CharField(max_length=255, description="報名方式")
     remark = fields.TextField(description="備註")
-    registration_day = fields.CharField(max_length=255, description="報名時間")
 
 
 class Class_detail(Model):
@@ -82,7 +81,7 @@ class Class_detail(Model):
 class Registration(Model):
     id = fields.IntField(pk=True)
     event_id = fields.IntField(description="課程ID")
-    user_inform_id = fields.IntField(description="使用者ID")
+    user_id = fields.IntField(description="使用者ID")
     reg_confirm = fields.IntField(description="報名確認(1:報名成功 0:單純報名)")
     is_del = fields.IntField(description="是否取消(1:yes ,0:no)")
     create_time = fields.DatetimeField(description="創建時間")
@@ -155,7 +154,22 @@ class User_information(Model):
     id = fields.IntField(pk=True)
     user_id = fields.IntField(description="使用者ID")
     name = fields.CharField(max_length=45, description="姓名")
+    birthday = fields.DateField(description="生日")
     gender = fields.CharField(max_length=45, description="性別")
     phone = fields.CharField(max_length=45, description="電話")
-    email = fields.CharField(max_length=45, description="信箱")
+    address = fields.TextField(description="地址")
     is_default = fields.IntField(description="是否為預設")
+
+class Class_date(Model):
+    id = fields.IntField(pk=True)
+    class_list_id = fields.IntField(description="場次ID")
+    registration_start = fields.DatetimeField(description="報名時間開始")
+    registration_end = fields.DatetimeField(description="報名時間結束")
+    number_limit = fields.IntField(description="名額")
+    amount_left = fields.IntField(description="剩餘名額")
+
+class Attend_record(Model):
+    id = fields.IntField(pk=True)
+    class_detail_id = fields.IntField(description="課堂ID")
+    user_id = fields.IntField(description="使用者ID")
+    is_attend = fields.IntField(description="是否已出席(1:是、0:否)")