diff --git a/mooc/crud/crud_coupon_location.py b/mooc/crud/crud_coupon_location.py
new file mode 100644
index 0000000..2e28f36
--- /dev/null
+++ b/mooc/crud/crud_coupon_location.py
@@ -0,0 +1,32 @@
+from sqlalchemy.orm import Session
+from . import models, schemas
+
+def get_coupon_location(db: Session, coupon_location_id: int):
+    return db.query(models.CouponLocation).filter(models.CouponLocation.id == coupon_location_id).first()
+
+def get_coupon_locations(db: Session, skip: int = 0, limit: int = 100):
+    return db.query(models.CouponLocation).offset(skip).limit(limit).all()
+
+def create_coupon_location(db: Session, coupon_location: schemas.CouponLocationCreate):
+    db_coupon_location = models.CouponLocation(**coupon_location.dict())
+    db.add(db_coupon_location)
+    db.commit()
+    db.refresh(db_coupon_location)
+    return db_coupon_location
+
+def update_coupon_location(db: Session, coupon_location_id: int, coupon_location: schemas.CouponLocationUpdate):
+    db_coupon_location = db.query(models.CouponLocation).filter(models.CouponLocation.id == coupon_location_id).first()
+    if db_coupon_location:
+        for var, value in vars(coupon_location).items():
+            setattr(db_coupon_location, var, value) if value else None
+        db.add(db_coupon_location)
+        db.commit()
+        db.refresh(db_coupon_location)
+    return db_coupon_location
+
+def delete_coupon_location(db: Session, coupon_location_id: int):
+    db_coupon_location = db.query(models.CouponLocation).filter(models.CouponLocation.id == coupon_location_id).first()
+    if db_coupon_location:
+        db.delete(db_coupon_location)
+        db.commit()
+    return db_coupon_location
\ No newline at end of file
diff --git a/mooc/crud/crud_cover_reply.py b/mooc/crud/crud_cover_reply.py
new file mode 100644
index 0000000..84819cb
--- /dev/null
+++ b/mooc/crud/crud_cover_reply.py
@@ -0,0 +1,32 @@
+from sqlalchemy.orm import Session
+from . import models, schemas
+
+def get_cover_reply(db: Session, cover_reply_id: int):
+    return db.query(models.CoverReply).filter(models.CoverReply.id == cover_reply_id).first()
+
+def get_cover_replies(db: Session, skip: int = 0, limit: int = 100):
+    return db.query(models.CoverReply).offset(skip).limit(limit).all()
+
+def create_cover_reply(db: Session, cover_reply: schemas.CoverReplyCreate):
+    db_cover_reply = models.CoverReply(**cover_reply.dict())
+    db.add(db_cover_reply)
+    db.commit()
+    db.refresh(db_cover_reply)
+    return db_cover_reply
+
+def update_cover_reply(db: Session, cover_reply_id: int, cover_reply: schemas.CoverReplyUpdate):
+    db_cover_reply = db.query(models.CoverReply).filter(models.CoverReply.id == cover_reply_id).first()
+    if db_cover_reply:
+        for var, value in vars(cover_reply).items():
+            setattr(db_cover_reply, var, value) if value else None
+        db.add(db_cover_reply)
+        db.commit()
+        db.refresh(db_cover_reply)
+    return db_cover_reply
+
+def delete_cover_reply(db: Session, cover_reply_id: int):
+    db_cover_reply = db.query(models.CoverReply).filter(models.CoverReply.id == cover_reply_id).first()
+    if db_cover_reply:
+        db.delete(db_cover_reply)
+        db.commit()
+    return db_cover_reply
\ No newline at end of file
diff --git a/mooc/crud/crud_custom_reply.py b/mooc/crud/crud_custom_reply.py
new file mode 100644
index 0000000..8c11860
--- /dev/null
+++ b/mooc/crud/crud_custom_reply.py
@@ -0,0 +1,32 @@
+from sqlalchemy.orm import Session
+from . import models, schemas
+
+def get_custom_reply(db: Session, custom_reply_id: int):
+    return db.query(models.CustomReply).filter(models.CustomReply.id == custom_reply_id).first()
+
+def get_custom_replies(db: Session, skip: int = 0, limit: int = 100):
+    return db.query(models.CustomReply).offset(skip).limit(limit).all()
+
+def create_custom_reply(db: Session, custom_reply: schemas.CustomReplyCreate):
+    db_custom_reply = models.CustomReply(**custom_reply.dict())
+    db.add(db_custom_reply)
+    db.commit()
+    db.refresh(db_custom_reply)
+    return db_custom_reply
+
+def update_custom_reply(db: Session, custom_reply_id: int, custom_reply: schemas.CustomReplyUpdate):
+    db_custom_reply = db.query(models.CustomReply).filter(models.CustomReply.id == custom_reply_id).first()
+    if db_custom_reply:
+        for var, value in vars(custom_reply).items():
+            setattr(db_custom_reply, var, value) if value else None
+        db.add(db_custom_reply)
+        db.commit()
+        db.refresh(db_custom_reply)
+    return db_custom_reply
+
+def delete_custom_reply(db: Session, custom_reply_id: int):
+    db_custom_reply = db.query(models.CustomReply).filter(models.CustomReply.id == custom_reply_id).first()
+    if db_custom_reply:
+        db.delete(db_custom_reply)
+        db.commit()
+    return db_custom_reply
\ No newline at end of file
diff --git a/mooc/crud/crud_images_reply.py b/mooc/crud/crud_images_reply.py
new file mode 100644
index 0000000..d551e3a
--- /dev/null
+++ b/mooc/crud/crud_images_reply.py
@@ -0,0 +1,32 @@
+from sqlalchemy.orm import Session
+from . import models, schemas
+
+def get_images_reply(db: Session, images_reply_id: int):
+    return db.query(models.ImagesReply).filter(models.ImagesReply.id == images_reply_id).first()
+
+def get_images_replies(db: Session, skip: int = 0, limit: int = 100):
+    return db.query(models.ImagesReply).offset(skip).limit(limit).all()
+
+def create_images_reply(db: Session, images_reply: schemas.ImagesReplyCreate):
+    db_images_reply = models.ImagesReply(**images_reply.dict())
+    db.add(db_images_reply)
+    db.commit()
+    db.refresh(db_images_reply)
+    return db_images_reply
+
+def update_images_reply(db: Session, images_reply_id: int, images_reply: schemas.ImagesReplyUpdate):
+    db_images_reply = db.query(models.ImagesReply).filter(models.ImagesReply.id == images_reply_id).first()
+    if db_images_reply:
+        for var, value in vars(images_reply).items():
+            setattr(db_images_reply, var, value) if value else None
+        db.add(db_images_reply)
+        db.commit()
+        db.refresh(db_images_reply)
+    return db_images_reply
+
+def delete_images_reply(db: Session, images_reply_id: int):
+    db_images_reply = db.query(models.ImagesReply).filter(models.ImagesReply.id == images_reply_id).first()
+    if db_images_reply:
+        db.delete(db_images_reply)
+        db.commit()
+    return db_images_reply
\ No newline at end of file
diff --git a/mooc/crud/crud_mc.py b/mooc/crud/crud_mc.py
new file mode 100644
index 0000000..c4afd83
--- /dev/null
+++ b/mooc/crud/crud_mc.py
@@ -0,0 +1,494 @@
+from sqlalchemy.orm import Session
+from . import models, schemas
+
+def get_mc_cash_record(db: Session, mc_cash_record_id: int):
+    return db.query(models.McCashRecord).filter(models.McCashRecord.id == mc_cash_record_id).first()
+
+def get_mc_cash_records(db: Session, skip: int = 0, limit: int = 100):
+    return db.query(models.McCashRecord).offset(skip).limit(limit).all()
+
+def create_mc_cash_record(db: Session, mc_cash_record: schemas.McCashRecordCreate):
+    db_mc_cash_record = models.McCashRecord(**mc_cash_record.dict())
+    db.add(db_mc_cash_record)
+    db.commit()
+    db.refresh(db_mc_cash_record)
+    return db_mc_cash_record
+
+def get_mc_chats_record(db: Session, mc_chats_record_id: int):
+    return db.query(models.McChatsRecord).filter(models.McChatsRecord.id == mc_chats_record_id).first()
+
+def get_mc_chats_records(db: Session, skip: int = 0, limit: int = 100):
+    return db.query(models.McChatsRecord).offset(skip).limit(limit).all()
+
+def create_mc_chats_record(db: Session, mc_chats_record: schemas.McChatsRecordCreate):
+    db_mc_chats_record = models.McChatsRecord(**mc_chats_record.dict())
+    db.add(db_mc_chats_record)
+    db.commit()
+    db.refresh(db_mc_chats_record)
+    return db_mc_chats_record
+
+def update_mc_chats_record(db: Session, mc_chats_record_id: int, mc_chats_record: schemas.McChatsRecordUpdate):
+    db_mc_chats_record = db.query(models.McChatsRecord).filter(models.McChatsRecord.id == mc_chats_record_id).first()
+    if db_mc_chats_record:
+        for var, value in vars(mc_chats_record).items():
+            setattr(db_mc_chats_record, var, value) if value else None
+        db.add(db_mc_chats_record)
+        db.commit()
+        db.refresh(db_mc_chats_record)
+    return db_mc_chats_record
+
+def delete_mc_chats_record(db: Session, mc_chats_record_id: int):
+    db_mc_chats_record = db.query(models.McChatsRecord).filter(models.McChatsRecord.id == mc_chats_record_id).first()
+    if db_mc_chats_record:
+        db.delete(db_mc_chats_record)
+        db.commit()
+    return db_mc_chats_record
+def update_mc_cash_record(db: Session, mc_cash_record_id: int, mc_cash_record: schemas.McCashRecordUpdate):
+    db_mc_cash_record = db.query(models.McCashRecord).filter(models.McCashRecord.id == mc_cash_record_id).first()
+    if db_mc_cash_record:
+        for var, value in vars(mc_cash_record).items():
+            setattr(db_mc_cash_record, var, value) if value else None
+        db.add(db_mc_cash_record)
+        db.commit()
+        db.refresh(db_mc_cash_record)
+    return db_mc_cash_record
+
+def delete_mc_cash_record(db: Session, mc_cash_record_id: int):
+    db_mc_cash_record = db.query(models.McCashRecord).filter(models.McCashRecord.id == mc_cash_record_id).first()
+    if db_mc_cash_record:
+        db.delete(db_mc_cash_record)
+        db.commit()
+    return db_mc_cash_record
+# McMappingFans CRUD
+def get_mc_mapping_fans(db: Session, fanid: int):
+    return db.query(models.McMappingFans).filter(models.McMappingFans.fanid == fanid).first()
+
+def get_mc_mapping_fanss(db: Session, skip: int = 0, limit: int = 100):
+    return db.query(models.McMappingFans).offset(skip).limit(limit).all()
+
+def create_mc_mapping_fans(db: Session, mc_mapping_fans: schemas.McMappingFansCreate):
+    db_mc_mapping_fans = models.McMappingFans(**mc_mapping_fans.dict())
+    db.add(db_mc_mapping_fans)
+    db.commit()
+    db.refresh(db_mc_mapping_fans)
+    return db_mc_mapping_fans
+
+def update_mc_mapping_fans(db: Session, fanid: int, mc_mapping_fans: schemas.McMappingFansUpdate):
+    db_mc_mapping_fans = db.query(models.McMappingFans).filter(models.McMappingFans.fanid == fanid).first()
+    if db_mc_mapping_fans:
+        for var, value in vars(mc_mapping_fans).items():
+            setattr(db_mc_mapping_fans, var, value) if value else None
+        db.add(db_mc_mapping_fans)
+        db.commit()
+        db.refresh(db_mc_mapping_fans)
+    return db_mc_mapping_fans
+
+def delete_mc_mapping_fans(db: Session, fanid: int):
+    db_mc_mapping_fans = db.query(models.McMappingFans).filter(models.McMappingFans.fanid == fanid).first()
+    if db_mc_mapping_fans:
+        db.delete(db_mc_mapping_fans)
+        db.commit()
+    return db_mc_mapping_fans
+
+# McMassRecord CRUD
+def get_mc_mass_record(db: Session, id: int):
+    return db.query(models.McMassRecord).filter(models.McMassRecord.id == id).first()
+
+def get_mc_mass_records(db: Session, skip: int = 0, limit: int = 100):
+    return db.query(models.McMassRecord).offset(skip).limit(limit).all()
+
+def create_mc_mass_record(db: Session, mc_mass_record: schemas.McMassRecordCreate):
+    db_mc_mass_record = models.McMassRecord(**mc_mass_record.dict())
+    db.add(db_mc_mass_record)
+    db.commit()
+    db.refresh(db_mc_mass_record)
+    return db_mc_mass_record
+
+def update_mc_mass_record(db: Session, id: int, mc_mass_record: schemas.McMassRecordUpdate):
+    db_mc_mass_record = db.query(models.McMassRecord).filter(models.McMassRecord.id == id).first()
+    if db_mc_mass_record:
+        for var, value in vars(mc_mass_record).items():
+            setattr(db_mc_mass_record, var, value) if value else None
+        db.add(db_mc_mass_record)
+        db.commit()
+        db.refresh(db_mc_mass_record)
+    return db_mc_mass_record
+
+def delete_mc_mass_record(db: Session, id: int):
+    db_mc_mass_record = db.query(models.McMassRecord).filter(models.McMassRecord.id == id).first()
+    if db_mc_mass_record:
+        db.delete(db_mc_mass_record)
+        db.commit()
+    return db_mc_mass_record
+
+# McCreditsRecharge CRUD
+def get_mc_credits_recharge(db: Session, mc_credits_recharge_id: int):
+    return db.query(models.McCreditsRecharge).filter(models.McCreditsRecharge.id == mc_credits_recharge_id).first()
+
+def get_mc_credits_recharges(db: Session, skip: int = 0, limit: int = 100):
+    return db.query(models.McCreditsRecharge).offset(skip).limit(limit).all()
+
+def create_mc_credits_recharge(db: Session, mc_credits_recharge: schemas.McCreditsRechargeCreate):
+    db_mc_credits_recharge = models.McCreditsRecharge(**mc_credits_recharge.dict())
+    db.add(db_mc_credits_recharge)
+    db.commit()
+    db.refresh(db_mc_credits_recharge)
+    return db_mc_credits_recharge
+
+def update_mc_credits_recharge(db: Session, mc_credits_recharge_id: int, mc_credits_recharge: schemas.McCreditsRechargeUpdate):
+    db_mc_credits_recharge = db.query(models.McCreditsRecharge).filter(models.McCreditsRecharge.id == mc_credits_recharge_id).first()
+    if db_mc_credits_recharge:
+        for var, value in vars(mc_credits_recharge).items():
+            setattr(db_mc_credits_recharge, var, value) if value else None
+        db.add(db_mc_credits_recharge)
+        db.commit()
+        db.refresh(db_mc_credits_recharge)
+    return db_mc_credits_recharge
+
+def delete_mc_credits_recharge(db: Session, mc_credits_recharge_id: int):
+    db_mc_credits_recharge = db.query(models.McCreditsRecharge).filter(models.McCreditsRecharge.id == mc_credits_recharge_id).first()
+    if db_mc_credits_recharge:
+        db.delete(db_mc_credits_recharge)
+        db.commit()
+    return db_mc_credits_recharge
+
+# McCreditsRecord CRUD
+def get_mc_credits_record(db: Session, mc_credits_record_id: int):
+    return db.query(models.McCreditsRecord).filter(models.McCreditsRecord.id == mc_credits_record_id).first()
+
+def get_mc_credits_records(db: Session, skip: int = 0, limit: int = 100):
+    return db.query(models.McCreditsRecord).offset(skip).limit(limit).all()
+
+def create_mc_credits_record(db: Session, mc_credits_record: schemas.McCreditsRecordCreate):
+    db_mc_credits_record = models.McCreditsRecord(**mc_credits_record.dict())
+    db.add(db_mc_credits_record)
+    db.commit()
+    db.refresh(db_mc_credits_record)
+    return db_mc_credits_record
+
+def update_mc_credits_record(db: Session, mc_credits_record_id: int, mc_credits_record: schemas.McCreditsRecordUpdate):
+    db_mc_credits_record = db.query(models.McCreditsRecord).filter(models.McCreditsRecord.id == mc_credits_record_id).first()
+    if db_mc_credits_record:
+        for var, value in vars(mc_credits_record).items():
+            setattr(db_mc_credits_record, var, value) if value else None
+        db.add(db_mc_credits_record)
+        db.commit()
+        db.refresh(db_mc_credits_record)
+    return db_mc_credits_record
+
+def delete_mc_credits_record(db: Session, mc_credits_record_id: int):
+    db_mc_credits_record = db.query(models.McCreditsRecord).filter(models.McCreditsRecord.id == mc_credits_record_id).first()
+    if db_mc_credits_record:
+        db.delete(db_mc_credits_record)
+        db.commit()
+    return db_mc_credits_record
+
+# MCFansGroups CRUD
+def get_mc_fans_group(db: Session, mc_fans_group_id: int):
+    return db.query(models.MCFansGroups).filter(models.MCFansGroups.id == mc_fans_group_id).first()
+
+def get_mc_fans_groups(db: Session, skip: int = 0, limit: int = 100):
+    return db.query(models.MCFansGroups).offset(skip).limit(limit).all()
+
+def create_mc_fans_group(db: Session, mc_fans_group: schemas.MCFansGroupsCreate):
+    db_mc_fans_group = models.MCFansGroups(**mc_fans_group.dict())
+    db.add(db_mc_fans_group)
+    db.commit()
+    db.refresh(db_mc_fans_group)
+    return db_mc_fans_group
+
+def update_mc_fans_group(db: Session, mc_fans_group_id: int, mc_fans_group: schemas.MCFansGroupsUpdate):
+    db_mc_fans_group = db.query(models.MCFansGroups).filter(models.MCFansGroups.id == mc_fans_group_id).first()
+    if db_mc_fans_group:
+        for var, value in vars(mc_fans_group).items():
+            setattr(db_mc_fans_group, var, value) if value else None
+        db.add(db_mc_fans_group)
+        db.commit()
+        db.refresh(db_mc_fans_group)
+    return db_mc_fans_group
+
+def delete_mc_fans_group(db: Session, mc_fans_group_id: int):
+    db_mc_fans_group = db.query(models.MCFansGroups).filter(models.MCFansGroups.id == mc_fans_group_id).first()
+    if db_mc_fans_group:
+        db.delete(db_mc_fans_group)
+        db.commit()
+    return db_mc_fans_group
+
+# MCFansTag CRUD
+def get_mc_fans_tag(db: Session, mc_fans_tag_id: int):
+    return db.query(models.MCFansTag).filter(models.MCFansTag.id == mc_fans_tag_id).first()
+
+def get_mc_fans_tags(db: Session, skip: int = 0, limit: int = 100):
+    return db.query(models.MCFansTag).offset(skip).limit(limit).all()
+
+def create_mc_fans_tag(db: Session, mc_fans_tag: schemas.MCFansTagCreate):
+    db_mc_fans_tag = models.MCFansTag(**mc_fans_tag.dict())
+    db.add(db_mc_fans_tag)
+    db.commit()
+    db.refresh(db_mc_fans_tag)
+    return db_mc_fans_tag
+
+def update_mc_fans_tag(db: Session, mc_fans_tag_id: int, mc_fans_tag: schemas.MCFansTagUpdate):
+    db_mc_fans_tag = db.query(models.MCFansTag).filter(models.MCFansTag.id == mc_fans_tag_id).first()
+    if db_mc_fans_tag:
+        for var, value in vars(mc_fans_tag).items():
+            setattr(db_mc_fans_tag, var, value) if value else None
+        db.add(db_mc_fans_tag)
+        db.commit()
+        db.refresh(db_mc_fans_tag)
+    return db_mc_fans_tag
+
+def delete_mc_fans_tag(db: Session, mc_fans_tag_id: int):
+    db_mc_fans_tag = db.query(models.MCFansTag).filter(models.MCFansTag.id == mc_fans_tag_id).first()
+    if db_mc_fans_tag:
+        db.delete(db_mc_fans_tag)
+        db.commit()
+    return db_mc_fans_tag
+
+# MCFansTagMapping CRUD
+def get_mc_fans_tag_mapping(db: Session, mc_fans_tag_mapping_id: int):
+    return db.query(models.MCFansTagMapping).filter(models.MCFansTagMapping.id == mc_fans_tag_mapping_id).first()
+
+def get_mc_fans_tag_mappings(db: Session, skip: int = 0, limit: int = 100):
+    return db.query(models.MCFansTagMapping).offset(skip).limit(limit).all()
+
+def create_mc_fans_tag_mapping(db: Session, mc_fans_tag_mapping: schemas.MCFansTagMappingCreate):
+    db_mc_fans_tag_mapping = models.MCFansTagMapping(**mc_fans_tag_mapping.dict())
+    db.add(db_mc_fans_tag_mapping)
+    db.commit()
+    db.refresh(db_mc_fans_tag_mapping)
+    return db_mc_fans_tag_mapping
+
+def update_mc_fans_tag_mapping(db: Session, mc_fans_tag_mapping_id: int, mc_fans_tag_mapping: schemas.MCFansTagMappingUpdate):
+    db_mc_fans_tag_mapping = db.query(models.MCFansTagMapping).filter(models.MCFansTagMapping.id == mc_fans_tag_mapping_id).first()
+    if db_mc_fans_tag_mapping:
+        for var, value in vars(mc_fans_tag_mapping).items():
+            setattr(db_mc_fans_tag_mapping, var, value) if value else None
+        db.add(db_mc_fans_tag_mapping)
+        db.commit()
+        db.refresh(db_mc_fans_tag_mapping)
+    return db_mc_fans_tag_mapping
+
+def delete_mc_fans_tag_mapping(db: Session, mc_fans_tag_mapping_id: int):
+    db_mc_fans_tag_mapping = db.query(models.MCFansTagMapping).filter(models.MCFansTagMapping.id == mc_fans_tag_mapping_id).first()
+    if db_mc_fans_tag_mapping:
+        db.delete(db_mc_fans_tag_mapping)
+        db.commit()
+    return db_mc_fans_tag_mapping
+
+# MCGroups CRUD
+def get_mc_group(db: Session, mc_group_id: int):
+    return db.query(models.MCGroups).filter(models.MCGroups.groupid == mc_group_id).first()
+
+def get_mc_groups(db: Session, skip: int = 0, limit: int = 100):
+    return db.query(models.MCGroups).offset(skip).limit(limit).all()
+
+def create_mc_group(db: Session, mc_group: schemas.MCGroupsCreate):
+    db_mc_group = models.MCGroups(**mc_group.dict())
+    db.add(db_mc_group)
+    db.commit()
+    db.refresh(db_mc_group)
+    return db_mc_group
+
+def update_mc_group(db: Session, mc_group_id: int, mc_group: schemas.MCGroupsUpdate):
+    db_mc_group = db.query(models.MCGroups).filter(models.MCGroups.groupid == mc_group_id).first()
+    if db_mc_group:
+        for var, value in vars(mc_group).items():
+            setattr(db_mc_group, var, value) if value else None
+        db.add(db_mc_group)
+        db.commit()
+        db.refresh(db_mc_group)
+    return db_mc_group
+
+def delete_mc_group(db: Session, mc_group_id: int):
+    db_mc_group = db.query(models.MCGroups).filter(models.MCGroups.groupid == mc_group_id).first()
+    if db_mc_group:
+        db.delete(db_mc_group)
+        db.commit()
+    return db_mc_group
+
+# MCHandsel CRUD
+def get_mc_handsel(db: Session, mc_handsel_id: int):
+    return db.query(models.MCHandsel).filter(models.MCHandsel.id == mc_handsel_id).first()
+
+def get_mc_handsels(db: Session, skip: int = 0, limit: int = 100):
+    return db.query(models.MCHandsel).offset(skip).limit(limit).all()
+
+def create_mc_handsel(db: Session, mc_handsel: schemas.MCHandselCreate):
+    db_mc_handsel = models.MCHandsel(**mc_handsel.dict())
+    db.add(db_mc_handsel)
+    db.commit()
+    db.refresh(db_mc_handsel)
+    return db_mc_handsel
+
+def update_mc_handsel(db: Session, mc_handsel_id: int, mc_handsel: schemas.MCHandselUpdate):
+    db_mc_handsel = db.query(models.MCHandsel).filter(models.MCHandsel.id == mc_handsel_id).first()
+    if db_mc_handsel:
+        for var, value in vars(mc_handsel).items():
+            setattr(db_mc_handsel, var, value) if value else None
+        db.add(db_mc_handsel)
+        db.commit()
+        db.refresh(db_mc_handsel)
+    return db_mc_handsel
+
+def delete_mc_handsel(db: Session, mc_handsel_id: int):
+    db_mc_handsel = db.query(models.MCHandsel).filter(models.MCHandsel.id == mc_handsel_id).first()
+    if db_mc_handsel:
+        db.delete(db_mc_handsel)
+        db.commit()
+    return db_mc_handsel
+
+# McMembers CRUD
+def get_mc_member(db: Session, uid: int):
+    return db.query(models.McMembers).filter(models.McMembers.uid == uid).first()
+
+def get_mc_members(db: Session, skip: int = 0, limit: int = 100):
+    return db.query(models.McMembers).offset(skip).limit(limit).all()
+
+def create_mc_member(db: Session, mc_member: schemas.McMembersCreate):
+    db_mc_member = models.McMembers(**mc_member.dict())
+    db.add(db_mc_member)
+    db.commit()
+    db.refresh(db_mc_member)
+    return db_mc_member
+
+def update_mc_member(db: Session, uid: int, mc_member: schemas.McMembersUpdate):
+    db_mc_member = db.query(models.McMembers).filter(models.McMembers.uid == uid).first()
+    if db_mc_member:
+        for var, value in vars(mc_member).items():
+            setattr(db_mc_member, var, value) if value else None
+        db.add(db_mc_member)
+        db.commit()
+        db.refresh(db_mc_member)
+    return db_mc_member
+
+def delete_mc_member(db: Session, uid: int):
+    db_mc_member = db.query(models.McMembers).filter(models.McMembers.uid == uid).first()
+    if db_mc_member:
+        db.delete(db_mc_member)
+        db.commit()
+    return db_mc_member
+
+# McMemberAddress CRUD
+def get_mc_member_address(db: Session, id: int):
+    return db.query(models.McMemberAddress).filter(models.McMemberAddress.id == id).first()
+
+def get_mc_member_addresses(db: Session, skip: int = 0, limit: int = 100):
+    return db.query(models.McMemberAddress).offset(skip).limit(limit).all()
+
+def create_mc_member_address(db: Session, mc_member_address: schemas.McMemberAddressCreate):
+    db_mc_member_address = models.McMemberAddress(**mc_member_address.dict())
+    db.add(db_mc_member_address)
+    db.commit()
+    db.refresh(db_mc_member_address)
+    return db_mc_member_address
+
+def update_mc_member_address(db: Session, id: int, mc_member_address: schemas.McMemberAddressUpdate):
+    db_mc_member_address = db.query(models.McMemberAddress).filter(models.McMemberAddress.id == id).first()
+    if db_mc_member_address:
+        for var, value in vars(mc_member_address).items():
+            setattr(db_mc_member_address, var, value) if value else None
+        db.add(db_mc_member_address)
+        db.commit()
+        db.refresh(db_mc_member_address)
+    return db_mc_member_address
+
+def delete_mc_member_address(db: Session, id: int):
+    db_mc_member_address = db.query(models.McMemberAddress).filter(models.McMemberAddress.id == id).first()
+    if db_mc_member_address:
+        db.delete(db_mc_member_address)
+        db.commit()
+    return db_mc_member_address
+
+# McMemberFields CRUD
+def get_mc_member_fields(db: Session, id: int):
+    return db.query(models.McMemberFields).filter(models.McMemberFields.id == id).first()
+
+def get_mc_member_fieldss(db: Session, skip: int = 0, limit: int = 100):
+    return db.query(models.McMemberFields).offset(skip).limit(limit).all()
+
+def create_mc_member_fields(db: Session, mc_member_fields: schemas.McMemberFieldsCreate):
+    db_mc_member_fields = models.McMemberFields(**mc_member_fields.dict())
+    db.add(db_mc_member_fields)
+    db.commit()
+    db.refresh(db_mc_member_fields)
+    return db_mc_member_fields
+
+def update_mc_member_fields(db: Session, id: int, mc_member_fields: schemas.McMemberFieldsUpdate):
+    db_mc_member_fields = db.query(models.McMemberFields).filter(models.McMemberFields.id == id).first()
+    if db_mc_member_fields:
+        for var, value in vars(mc_member_fields).items():
+            setattr(db_mc_member_fields, var, value) if value else None
+        db.add(db_mc_member_fields)
+        db.commit()
+        db.refresh(db_mc_member_fields)
+    return db_mc_member_fields
+
+def delete_mc_member_fields(db: Session, id: int):
+    db_mc_member_fields = db.query(models.McMemberFields).filter(models.McMemberFields.id == id).first()
+    if db_mc_member_fields:
+        db.delete(db_mc_member_fields)
+        db.commit()
+    return db_mc_member_fields
+
+# McMemberProperty CRUD
+def get_mc_member_property(db: Session, id: int):
+    return db.query(models.McMemberProperty).filter(models.McMemberProperty.id == id).first()
+
+def get_mc_member_properties(db: Session, skip: int = 0, limit: int = 100):
+    return db.query(models.McMemberProperty).offset(skip).limit(limit).all()
+
+def create_mc_member_property(db: Session, mc_member_property: schemas.McMemberPropertyCreate):
+    db_mc_member_property = models.McMemberProperty(**mc_member_property.dict())
+    db.add(db_mc_member_property)
+    db.commit()
+    db.refresh(db_mc_member_property)
+    return db_mc_member_property
+
+def update_mc_member_property(db: Session, id: int, mc_member_property: schemas.McMemberPropertyUpdate):
+    db_mc_member_property = db.query(models.McMemberProperty).filter(models.McMemberProperty.id == id).first()
+    if db_mc_member_property:
+        for var, value in vars(mc_member_property).items():
+            setattr(db_mc_member_property, var, value) if value else None
+        db.add(db_mc_member_property)
+        db.commit()
+        db.refresh(db_mc_member_property)
+    return db_mc_member_property
+
+def delete_mc_member_property(db: Session, id: int):
+    db_mc_member_property = db.query(models.McMemberProperty).filter(models.McMemberProperty.id == id).first()
+    if db_mc_member_property:
+        db.delete(db_mc_member_property)
+        db.commit()
+    return db_mc_member_property
+
+# McOauthFans CRUD
+def get_mc_oauth_fans(db: Session, id: int):
+    return db.query(models.McOauthFans).filter(models.McOauthFans.id == id).first()
+
+def get_mc_oauth_fanss(db: Session, skip: int = 0, limit: int = 100):
+    return db.query(models.McOauthFans).offset(skip).limit(limit).all()
+
+def create_mc_oauth_fans(db: Session, mc_oauth_fans: schemas.McOauthFansCreate):
+    db_mc_oauth_fans = models.McOauthFans(**mc_oauth_fans.dict())
+    db.add(db_mc_oauth_fans)
+    db.commit()
+    db.refresh(db_mc_oauth_fans)
+    return db_mc_oauth_fans
+
+def update_mc_oauth_fans(db: Session, id: int, mc_oauth_fans: schemas.McOauthFansUpdate):
+    db_mc_oauth_fans = db.query(models.McOauthFans).filter(models.McOauthFans.id == id).first()
+    if db_mc_oauth_fans:
+        for var, value in vars(mc_oauth_fans).items():
+            setattr(db_mc_oauth_fans, var, value) if value else None
+        db.add(db_mc_oauth_fans)
+        db.commit()
+        db.refresh(db_mc_oauth_fans)
+    return db_mc_oauth_fans
+
+def delete_mc_oauth_fans(db: Session, id: int):
+    db_mc_oauth_fans = db.query(models.McOauthFans).filter(models.McOauthFans.id == id).first()
+    if db_mc_oauth_fans:
+        db.delete(db_mc_oauth_fans)
+        db.commit()
+    return db_mc_oauth_fans
diff --git a/mooc/crud/crud_menu_event.py b/mooc/crud/crud_menu_event.py
new file mode 100644
index 0000000..1f2c1f6
--- /dev/null
+++ b/mooc/crud/crud_menu_event.py
@@ -0,0 +1,32 @@
+from sqlalchemy.orm import Session
+from . import models, schemas
+
+def get_menu_event(db: Session, menu_event_id: int):
+    return db.query(models.MenuEvent).filter(models.MenuEvent.id == menu_event_id).first()
+
+def get_menu_events(db: Session, skip: int = 0, limit: int = 100):
+    return db.query(models.MenuEvent).offset(skip).limit(limit).all()
+
+def create_menu_event(db: Session, menu_event: schemas.MenuEventCreate):
+    db_menu_event = models.MenuEvent(**menu_event.dict())
+    db.add(db_menu_event)
+    db.commit()
+    db.refresh(db_menu_event)
+    return db_menu_event
+
+def update_menu_event(db: Session, menu_event_id: int, menu_event: schemas.MenuEventUpdate):
+    db_menu_event = db.query(models.MenuEvent).filter(models.MenuEvent.id == menu_event_id).first()
+    if db_menu_event:
+        for var, value in vars(menu_event).items():
+            setattr(db_menu_event, var, value) if value else None
+        db.add(db_menu_event)
+        db.commit()
+        db.refresh(db_menu_event)
+    return db_menu_event
+
+def delete_menu_event(db: Session, menu_event_id: int):
+    db_menu_event = db.query(models.MenuEvent).filter(models.MenuEvent.id == menu_event_id).first()
+    if db_menu_event:
+        db.delete(db_menu_event)
+        db.commit()
+    return db_menu_event
\ No newline at end of file
diff --git a/mooc/crud/crud_message_notice_log.py b/mooc/crud/crud_message_notice_log.py
new file mode 100644
index 0000000..1ff183e
--- /dev/null
+++ b/mooc/crud/crud_message_notice_log.py
@@ -0,0 +1,32 @@
+from sqlalchemy.orm import Session
+from . import models, schemas
+
+def get_message_notice_log(db: Session, message_notice_log_id: int):
+    return db.query(models.MessageNoticeLog).filter(models.MessageNoticeLog.id == message_notice_log_id).first()
+
+def get_message_notice_logs(db: Session, skip: int = 0, limit: int = 100):
+    return db.query(models.MessageNoticeLog).offset(skip).limit(limit).all()
+
+def create_message_notice_log(db: Session, message_notice_log: schemas.MessageNoticeLogCreate):
+    db_message_notice_log = models.MessageNoticeLog(**message_notice_log.dict())
+    db.add(db_message_notice_log)
+    db.commit()
+    db.refresh(db_message_notice_log)
+    return db_message_notice_log
+
+def update_message_notice_log(db: Session, message_notice_log_id: int, message_notice_log: schemas.MessageNoticeLogUpdate):
+    db_message_notice_log = db.query(models.MessageNoticeLog).filter(models.MessageNoticeLog.id == message_notice_log_id).first()
+    if db_message_notice_log:
+        for var, value in vars(message_notice_log).items():
+            setattr(db_message_notice_log, var, value) if value else None
+        db.add(db_message_notice_log)
+        db.commit()
+        db.refresh(db_message_notice_log)
+    return db_message_notice_log
+
+def delete_message_notice_log(db: Session, message_notice_log_id: int):
+    db_message_notice_log = db.query(models.MessageNoticeLog).filter(models.MessageNoticeLog.id == message_notice_log_id).first()
+    if db_message_notice_log:
+        db.delete(db_message_notice_log)
+        db.commit()
+    return db_message_notice_log
\ No newline at end of file
diff --git a/mooc/crud/crud_mobilenumber.py b/mooc/crud/crud_mobilenumber.py
new file mode 100644
index 0000000..da45d4a
--- /dev/null
+++ b/mooc/crud/crud_mobilenumber.py
@@ -0,0 +1,32 @@
+from sqlalchemy.orm import Session
+from . import models, schemas
+
+def get_mobilenumber(db: Session, mobilenumber_id: int):
+    return db.query(models.Mobilenumber).filter(models.Mobilenumber.id == mobilenumber_id).first()
+
+def get_mobilenumbers(db: Session, skip: int = 0, limit: int = 100):
+    return db.query(models.Mobilenumber).offset(skip).limit(limit).all()
+
+def create_mobilenumber(db: Session, mobilenumber: schemas.MobilenumberCreate):
+    db_mobilenumber = models.Mobilenumber(**mobilenumber.dict())
+    db.add(db_mobilenumber)
+    db.commit()
+    db.refresh(db_mobilenumber)
+    return db_mobilenumber
+
+def update_mobilenumber(db: Session, mobilenumber_id: int, mobilenumber: schemas.MobilenumberUpdate):
+    db_mobilenumber = db.query(models.Mobilenumber).filter(models.Mobilenumber.id == mobilenumber_id).first()
+    if db_mobilenumber:
+        for var, value in vars(mobilenumber).items():
+            setattr(db_mobilenumber, var, value) if value is not None else None
+        db.add(db_mobilenumber)
+        db.commit()
+        db.refresh(db_mobilenumber)
+    return db_mobilenumber
+
+def delete_mobilenumber(db: Session, mobilenumber_id: int):
+    db_mobilenumber = db.query(models.Mobilenumber).filter(models.Mobilenumber.id == mobilenumber_id).first()
+    if db_mobilenumber:
+        db.delete(db_mobilenumber)
+        db.commit()
+    return db_mobilenumber
\ No newline at end of file
diff --git a/mooc/crud/crud_modules.py b/mooc/crud/crud_modules.py
new file mode 100644
index 0000000..909176b
--- /dev/null
+++ b/mooc/crud/crud_modules.py
@@ -0,0 +1,248 @@
+from sqlalchemy.orm import Session
+from . import models, schemas
+
+def get_ims_modules_bindings(db: Session, eid: int):
+    return db.query(models.IMSModulesBindings).filter(models.IMSModulesBindings.eid == eid).first()
+
+def get_ims_modules_bindings_all(db: Session, skip: int = 0, limit: int = 100):
+    return db.query(models.IMSModulesBindings).offset(skip).limit(limit).all()
+
+def create_ims_modules_bindings(db: Session, ims_modules_bindings: schemas.IMSModulesBindingsCreate):
+    db_ims_modules_bindings = models.IMSModulesBindings(**ims_modules_bindings.dict())
+    db.add(db_ims_modules_bindings)
+    db.commit()
+    db.refresh(db_ims_modules_bindings)
+    return db_ims_modules_bindings
+
+def update_ims_modules_bindings(db: Session, eid: int, ims_modules_bindings: schemas.IMSModulesBindingsCreate):
+    db_ims_modules_bindings = db.query(models.IMSModulesBindings).filter(models.IMSModulesBindings.eid == eid).first()
+    if db_ims_modules_bindings:
+        for var, value in vars(ims_modules_bindings).items():
+            setattr(db_ims_modules_bindings, var, value) if value else None
+        db.add(db_ims_modules_bindings)
+        db.commit()
+        db.refresh(db_ims_modules_bindings)
+    return db_ims_modules_bindings
+
+def delete_ims_modules_bindings(db: Session, eid: int):
+    db_ims_modules_bindings = db.query(models.IMSModulesBindings).filter(models.IMSModulesBindings.eid == eid).first()
+    if db_ims_modules_bindings:
+        db.delete(db_ims_modules_bindings)
+        db.commit()
+    return db_ims_modules_bindings
+
+def get_ims_modules_cloud(db: Session, id: int):
+    return db.query(models.IMSModulesCloud).filter(models.IMSModulesCloud.id == id).first()
+
+def get_ims_modules_cloud_all(db: Session, skip: int = 0, limit: int = 100):
+    return db.query(models.IMSModulesCloud).offset(skip).limit(limit).all()
+
+def create_ims_modules_cloud(db: Session, ims_modules_cloud: schemas.IMSModulesCloudCreate):
+    db_ims_modules_cloud = models.IMSModulesCloud(**ims_modules_cloud.dict())
+    db.add(db_ims_modules_cloud)
+    db.commit()
+    db.refresh(db_ims_modules_cloud)
+    return db_ims_modules_cloud
+
+def update_ims_modules_cloud(db: Session, id: int, ims_modules_cloud: schemas.IMSModulesCloudCreate):
+    db_ims_modules_cloud = db.query(models.IMSModulesCloud).filter(models.IMSModulesCloud.id == id).first()
+    if db_ims_modules_cloud:
+        for var, value in vars(ims_modules_cloud).items():
+            setattr(db_ims_modules_cloud, var, value) if value else None
+        db.add(db_ims_modules_cloud)
+        db.commit()
+        db.refresh(db_ims_modules_cloud)
+    return db_ims_modules_cloud
+
+def delete_ims_modules_cloud(db: Session, id: int):
+    db_ims_modules_cloud = db.query(models.IMSModulesCloud).filter(models.IMSModulesCloud.id == id).first()
+    if db_ims_modules_cloud:
+        db.delete(db_ims_modules_cloud)
+        db.commit()
+    return db_ims_modules_cloud
+
+def get_ims_modules_ignore(db: Session, id: int):
+    return db.query(models.IMSModulesIgnore).filter(models.IMSModulesIgnore.id == id).first()
+
+def get_ims_modules_ignore_all(db: Session, skip: int = 0, limit: int = 100):
+    return db.query(models.IMSModulesIgnore).offset(skip).limit(limit).all()
+
+def create_ims_modules_ignore(db: Session, ims_modules_ignore: schemas.IMSModulesIgnoreCreate):
+    db_ims_modules_ignore = models.IMSModulesIgnore(**ims_modules_ignore.dict())
+    db.add(db_ims_modules_ignore)
+    db.commit()
+    db.refresh(db_ims_modules_ignore)
+    return db_ims_modules_ignore
+
+def update_ims_modules_ignore(db: Session, id: int, ims_modules_ignore: schemas.IMSModulesIgnoreCreate):
+    db_ims_modules_ignore = db.query(models.IMSModulesIgnore).filter(models.IMSModulesIgnore.id == id).first()
+    if db_ims_modules_ignore:
+        for var, value in vars(ims_modules_ignore).items():
+            setattr(db_ims_modules_ignore, var, value) if value is not None else None
+        db.add(db_ims_modules_ignore)
+        db.commit()
+        db.refresh(db_ims_modules_ignore)
+    return db_ims_modules_ignore
+
+def delete_ims_modules_ignore(db: Session, id: int):
+    db_ims_modules_ignore = db.query(models.IMSModulesIgnore).filter(models.IMSModulesIgnore.id == id).first()
+    if db_ims_modules_ignore:
+        db.delete(db_ims_modules_ignore)
+        db.commit()
+    return db_ims_modules_ignore
+
+
+def get_ims_modules_plugin(db: Session, id: int):
+    return db.query(models.IMSModulesPlugin).filter(models.IMSModulesPlugin.id == id).first()
+
+def get_ims_modules_plugin_all(db: Session, skip: int = 0, limit: int = 100):
+    return db.query(models.IMSModulesPlugin).offset(skip).limit(limit).all()
+
+def create_ims_modules_plugin(db: Session, ims_modules_plugin: schemas.IMSModulesPluginCreate):
+    db_ims_modules_plugin = models.IMSModulesPlugin(**ims_modules_plugin.dict())
+    db.add(db_ims_modules_plugin)
+    db.commit()
+    db.refresh(db_ims_modules_plugin)
+    return db_ims_modules_plugin
+
+def update_ims_modules_plugin(db: Session, id: int, ims_modules_plugin: schemas.IMSModulesPluginCreate):
+    db_ims_modules_plugin = db.query(models.IMSModulesPlugin).filter(models.IMSModulesPlugin.id == id).first()
+    if db_ims_modules_plugin:
+        for var, value in vars(ims_modules_plugin).items():
+            setattr(db_ims_modules_plugin, var, value) if value is not None else None
+        db.add(db_ims_modules_plugin)
+        db.commit()
+        db.refresh(db_ims_modules_plugin)
+    return db_ims_modules_plugin
+
+def delete_ims_modules_plugin(db: Session, id: int):
+    db_ims_modules_plugin = db.query(models.IMSModulesPlugin).filter(models.IMSModulesPlugin.id == id).first()
+    if db_ims_modules_plugin:
+        db.delete(db_ims_modules_plugin)
+        db.commit()
+    return db_ims_modules_plugin
+
+
+def get_ims_modules_plugin_rank(db: Session, id: int):
+    return db.query(models.IMSModulesPluginRank).filter(models.IMSModulesPluginRank.id == id).first()
+
+def get_ims_modules_plugin_rank_all(db: Session, skip: int = 0, limit: int = 100):
+    return db.query(models.IMSModulesPluginRank).offset(skip).limit(limit).all()
+
+def create_ims_modules_plugin_rank(db: Session, ims_modules_plugin_rank: schemas.IMSModulesPluginRankCreate):
+    db_ims_modules_plugin_rank = models.IMSModulesPluginRank(**ims_modules_plugin_rank.dict())
+    db.add(db_ims_modules_plugin_rank)
+    db.commit()
+    db.refresh(db_ims_modules_plugin_rank)
+    return db_ims_modules_plugin_rank
+
+def update_ims_modules_plugin_rank(db: Session, id: int, ims_modules_plugin_rank: schemas.IMSModulesPluginRankCreate):
+    db_ims_modules_plugin_rank = db.query(models.IMSModulesPluginRank).filter(models.IMSModulesPluginRank.id == id).first()
+    if db_ims_modules_plugin_rank:
+        for var, value in vars(ims_modules_plugin_rank).items():
+            setattr(db_ims_modules_plugin_rank, var, value) if value is not None else None
+        db.add(db_ims_modules_plugin_rank)
+        db.commit()
+        db.refresh(db_ims_modules_plugin_rank)
+    return db_ims_modules_plugin_rank
+
+def delete_ims_modules_plugin_rank(db: Session, id: int):
+    db_ims_modules_plugin_rank = db.query(models.IMSModulesPluginRank).filter(models.IMSModulesPluginRank.id == id).first()
+    if db_ims_modules_plugin_rank:
+        db.delete(db_ims_modules_plugin_rank)
+        db.commit()
+    return db_ims_modules_plugin_rank
+
+
+def get_ims_modules_rank(db: Session, id: int):
+    return db.query(models.IMSModulesRank).filter(models.IMSModulesRank.id == id).first()
+
+def get_ims_modules_rank_all(db: Session, skip: int = 0, limit: int = 100):
+    return db.query(models.IMSModulesRank).offset(skip).limit(limit).all()
+
+def create_ims_modules_rank(db: Session, ims_modules_rank: schemas.IMSModulesRankCreate):
+    db_ims_modules_rank = models.IMSModulesRank(**ims_modules_rank.dict())
+    db.add(db_ims_modules_rank)
+    db.commit()
+    db.refresh(db_ims_modules_rank)
+    return db_ims_modules_rank
+
+def update_ims_modules_rank(db: Session, id: int, ims_modules_rank: schemas.IMSModulesRankCreate):
+    db_ims_modules_rank = db.query(models.IMSModulesRank).filter(models.IMSModulesRank.id == id).first()
+    if db_ims_modules_rank:
+        for var, value in vars(ims_modules_rank).items():
+            setattr(db_ims_modules_rank, var, value) if value is not None else None
+        db.add(db_ims_modules_rank)
+        db.commit()
+        db.refresh(db_ims_modules_rank)
+    return db_ims_modules_rank
+
+def delete_ims_modules_rank(db: Session, id: int):
+    db_ims_modules_rank = db.query(models.IMSModulesRank).filter(models.IMSModulesRank.id == id).first()
+    if db_ims_modules_rank:
+        db.delete(db_ims_modules_rank)
+        db.commit()
+    return db_ims_modules_rank
+
+
+def get_ims_modules_recycle(db: Session, id: int):
+    return db.query(models.IMSModulesRecycle).filter(models.IMSModulesRecycle.id == id).first()
+
+def get_ims_modules_recycle_all(db: Session, skip: int = 0, limit: int = 100):
+    return db.query(models.IMSModulesRecycle).offset(skip).limit(limit).all()
+
+def create_ims_modules_recycle(db: Session, ims_modules_recycle: schemas.IMSModulesRecycleCreate):
+    db_ims_modules_recycle = models.IMSModulesRecycle(**ims_modules_recycle.dict())
+    db.add(db_ims_modules_recycle)
+    db.commit()
+    db.refresh(db_ims_modules_recycle)
+    return db_ims_modules_recycle
+
+def update_ims_modules_recycle(db: Session, id: int, ims_modules_recycle: schemas.IMSModulesRecycleCreate):
+    db_ims_modules_recycle = db.query(models.IMSModulesRecycle).filter(models.IMSModulesRecycle.id == id).first()
+    if db_ims_modules_recycle:
+        for var, value in vars(ims_modules_recycle).items():
+            setattr(db_ims_modules_recycle, var, value) if value is not None else None
+        db.add(db_ims_modules_recycle)
+        db.commit()
+        db.refresh(db_ims_modules_recycle)
+    return db_ims_modules_recycle
+
+def delete_ims_modules_recycle(db: Session, id: int):
+    db_ims_modules_recycle = db.query(models.IMSModulesRecycle).filter(models.IMSModulesRecycle.id == id).first()
+    if db_ims_modules_recycle:
+        db.delete(db_ims_modules_recycle)
+        db.commit()
+    return db_ims_modules_recycle
+
+
+# Modules CRUD
+def get_module(db: Session, mid: int):
+    return db.query(models.Modules).filter(models.Modules.mid == mid).first()
+
+def get_modules(db: Session, skip: int = 0, limit: int = 100):
+    return db.query(models.Modules).offset(skip).limit(limit).all()
+
+def create_module(db: Session, module: schemas.ModulesCreate):
+    db_module = models.Modules(**module.dict())
+    db.add(db_module)
+    db.commit()
+    db.refresh(db_module)
+    return db_module
+
+def update_module(db: Session, mid: int, module: schemas.ModulesUpdate):
+    db_module = db.query(models.Modules).filter(models.Modules.mid == mid).first()
+    if db_module:
+        for var, value in vars(module).items():
+            setattr(db_module, var, value) if value is not None else None
+        db.add(db_module)
+        db.commit()
+        db.refresh(db_module)
+    return db_module
+
+def delete_module(db: Session, mid: int):
+    db_module = db.query(models.Modules).filter(models.Modules.mid == mid).first()
+    if db_module:
+        db.delete(db_module)
+        db.commit()
+    return db_module
\ No newline at end of file
diff --git a/mooc/crud/crud_music_reply.py b/mooc/crud/crud_music_reply.py
new file mode 100644
index 0000000..b6755c2
--- /dev/null
+++ b/mooc/crud/crud_music_reply.py
@@ -0,0 +1,31 @@
+from sqlalchemy.orm import Session
+from . import models, schemas
+
+def get_music_reply(db: Session, music_reply_id: int):
+    return db.query(models.MusicReply).filter(models.MusicReply.Id == music_reply_id).first()
+
+def get_music_replies(db: Session, skip: int = 0, limit: int = 100):
+    return db.query(models.MusicReply).offset(skip).limit(limit).all()
+
+def create_music_reply(db: Session, music_reply: schemas.MusicReplyCreate):
+    db_music_reply = models.MusicReply(**music_reply.dict())
+    db.add(db_music_reply)
+    db.commit()
+    db.refresh(db_music_reply)
+    return db_music_reply
+
+def update_music_reply(db: Session, music_reply_id: int, music_reply: schemas.MusicReplyCreate):
+    db_music_reply = db.query(models.MusicReply).filter(models.MusicReply.Id == music_reply_id).first()
+    if db_music_reply:
+        for key, value in music_reply.dict().items():
+            setattr(db_music_reply, key, value)
+        db.commit()
+        db.refresh(db_music_reply)
+    return db_music_reply
+
+def delete_music_reply(db: Session, music_reply_id: int):
+    db_music_reply = db.query(models.MusicReply).filter(models.MusicReply.Id == music_reply_id).first()
+    if db_music_reply:
+        db.delete(db_music_reply)
+        db.commit()
+    return db_music_reply
\ No newline at end of file
diff --git a/mooc/crud/crud_news_reply.py b/mooc/crud/crud_news_reply.py
new file mode 100644
index 0000000..ea38e89
--- /dev/null
+++ b/mooc/crud/crud_news_reply.py
@@ -0,0 +1,31 @@
+from sqlalchemy.orm import Session
+from . import models, schemas
+
+def get_news_reply(db: Session, news_reply_id: int):
+    return db.query(models.NewsReply).filter(models.NewsReply.Id == news_reply_id).first()
+
+def get_news_replies(db: Session, skip: int = 0, limit: int = 100):
+    return db.query(models.NewsReply).offset(skip).limit(limit).all()
+
+def create_news_reply(db: Session, news_reply: schemas.NewsReplyCreate):
+    db_news_reply = models.NewsReply(**news_reply.dict())
+    db.add(db_news_reply)
+    db.commit()
+    db.refresh(db_news_reply)
+    return db_news_reply
+
+def update_news_reply(db: Session, news_reply_id: int, news_reply: schemas.NewsReplyCreate):
+    db_news_reply = db.query(models.NewsReply).filter(models.NewsReply.Id == news_reply_id).first()
+    if db_news_reply:
+        for key, value in news_reply.dict().items():
+            setattr(db_news_reply, key, value)
+        db.commit()
+        db.refresh(db_news_reply)
+    return db_news_reply
+
+def delete_news_reply(db: Session, news_reply_id: int):
+    db_news_reply = db.query(models.NewsReply).filter(models.NewsReply.Id == news_reply_id).first()
+    if db_news_reply:
+        db.delete(db_news_reply)
+        db.commit()
+    return db_news_reply
\ No newline at end of file
diff --git a/mooc/crud/crud_phoneapp_versions.py b/mooc/crud/crud_phoneapp_versions.py
new file mode 100644
index 0000000..576c9e9
--- /dev/null
+++ b/mooc/crud/crud_phoneapp_versions.py
@@ -0,0 +1,31 @@
+from sqlalchemy.orm import Session
+from . import models, schemas
+
+def get_phoneapp_version(db: Session, phoneapp_version_id: int):
+    return db.query(models.PhoneappVersions).filter(models.PhoneappVersions.Id == phoneapp_version_id).first()
+
+def get_phoneapp_versions(db: Session, skip: int = 0, limit: int = 100):
+    return db.query(models.PhoneappVersions).offset(skip).limit(limit).all()
+
+def create_phoneapp_version(db: Session, phoneapp_version: schemas.PhoneappVersionsCreate):
+    db_phoneapp_version = models.PhoneappVersions(**phoneapp_version.dict())
+    db.add(db_phoneapp_version)
+    db.commit()
+    db.refresh(db_phoneapp_version)
+    return db_phoneapp_version
+
+def update_phoneapp_version(db: Session, phoneapp_version_id: int, phoneapp_version: schemas.PhoneappVersionsCreate):
+    db_phoneapp_version = db.query(models.PhoneappVersions).filter(models.PhoneappVersions.Id == phoneapp_version_id).first()
+    if db_phoneapp_version:
+        for key, value in phoneapp_version.dict().items():
+            setattr(db_phoneapp_version, key, value)
+        db.commit()
+        db.refresh(db_phoneapp_version)
+    return db_phoneapp_version
+
+def delete_phoneapp_version(db: Session, phoneapp_version_id: int):
+    db_phoneapp_version = db.query(models.PhoneappVersions).filter(models.PhoneappVersions.Id == phoneapp_version_id).first()
+    if db_phoneapp_version:
+        db.delete(db_phoneapp_version)
+        db.commit()
+    return db_phoneapp_version
\ No newline at end of file
diff --git a/mooc/crud/crud_profile_fields.py b/mooc/crud/crud_profile_fields.py
new file mode 100644
index 0000000..acc5454
--- /dev/null
+++ b/mooc/crud/crud_profile_fields.py
@@ -0,0 +1,31 @@
+from sqlalchemy.orm import Session
+from . import models, schemas
+
+def get_profile_field(db: Session, profile_field_id: int):
+    return db.query(models.ProfileFields).filter(models.ProfileFields.Id == profile_field_id).first()
+
+def get_profile_fields(db: Session, skip: int = 0, limit: int = 100):
+    return db.query(models.ProfileFields).offset(skip).limit(limit).all()
+
+def create_profile_field(db: Session, profile_field: schemas.ProfileFieldsCreate):
+    db_profile_field = models.ProfileFields(**profile_field.dict())
+    db.add(db_profile_field)
+    db.commit()
+    db.refresh(db_profile_field)
+    return db_profile_field
+
+def update_profile_field(db: Session, profile_field_id: int, profile_field: schemas.ProfileFieldsCreate):
+    db_profile_field = db.query(models.ProfileFields).filter(models.ProfileFields.Id == profile_field_id).first()
+    if db_profile_field:
+        for key, value in profile_field.dict().items():
+            setattr(db_profile_field, key, value)
+        db.commit()
+        db.refresh(db_profile_field)
+    return db_profile_field
+
+def delete_profile_field(db: Session, profile_field_id: int):
+    db_profile_field = db.query(models.ProfileFields).filter(models.ProfileFields.Id == profile_field_id).first()
+    if db_profile_field:
+        db.delete(db_profile_field)
+        db.commit()
+    return db_profile_field
\ No newline at end of file
diff --git a/mooc/crud/crud_qrcode.py b/mooc/crud/crud_qrcode.py
new file mode 100644
index 0000000..bd19bbd
--- /dev/null
+++ b/mooc/crud/crud_qrcode.py
@@ -0,0 +1,31 @@
+from sqlalchemy.orm import Session
+from . import models, schemas
+
+def get_qrcode(db: Session, qrcode_id: int):
+    return db.query(models.Qrcode).filter(models.Qrcode.Id == qrcode_id).first()
+
+def get_qrcodes(db: Session, skip: int = 0, limit: int = 100):
+    return db.query(models.Qrcode).offset(skip).limit(limit).all()
+
+def create_qrcode(db: Session, qrcode: schemas.QrcodeCreate):
+    db_qrcode = models.Qrcode(**qrcode.dict())
+    db.add(db_qrcode)
+    db.commit()
+    db.refresh(db_qrcode)
+    return db_qrcode
+
+def update_qrcode(db: Session, qrcode_id: int, qrcode: schemas.QrcodeCreate):
+    db_qrcode = db.query(models.Qrcode).filter(models.Qrcode.Id == qrcode_id).first()
+    if db_qrcode:
+        for key, value in qrcode.dict().items():
+            setattr(db_qrcode, key, value)
+        db.commit()
+        db.refresh(db_qrcode)
+    return db_qrcode
+
+def delete_qrcode(db: Session, qrcode_id: int):
+    db_qrcode = db.query(models.Qrcode).filter(models.Qrcode.Id == qrcode_id).first()
+    if db_qrcode:
+        db.delete(db_qrcode)
+        db.commit()
+    return db_qrcode
\ No newline at end of file
diff --git a/mooc/crud/crud_qrcode_stat.py b/mooc/crud/crud_qrcode_stat.py
new file mode 100644
index 0000000..c36b0c2
--- /dev/null
+++ b/mooc/crud/crud_qrcode_stat.py
@@ -0,0 +1,31 @@
+from sqlalchemy.orm import Session
+from . import models, schemas
+
+def get_qrcode_stat(db: Session, qrcode_stat_id: int):
+    return db.query(models.QrcodeStat).filter(models.QrcodeStat.Id == qrcode_stat_id).first()
+
+def get_qrcode_stats(db: Session, skip: int = 0, limit: int = 100):
+    return db.query(models.QrcodeStat).offset(skip).limit(limit).all()
+
+def create_qrcode_stat(db: Session, qrcode_stat: schemas.QrcodeStatCreate):
+    db_qrcode_stat = models.QrcodeStat(**qrcode_stat.dict())
+    db.add(db_qrcode_stat)
+    db.commit()
+    db.refresh(db_qrcode_stat)
+    return db_qrcode_stat
+
+def update_qrcode_stat(db: Session, qrcode_stat_id: int, qrcode_stat: schemas.QrcodeStatCreate):
+    db_qrcode_stat = db.query(models.QrcodeStat).filter(models.QrcodeStat.Id == qrcode_stat_id).first()
+    if db_qrcode_stat:
+        for key, value in qrcode_stat.dict().items():
+            setattr(db_qrcode_stat, key, value)
+        db.commit()
+        db.refresh(db_qrcode_stat)
+    return db_qrcode_stat
+
+def delete_qrcode_stat(db: Session, qrcode_stat_id: int):
+    db_qrcode_stat = db.query(models.QrcodeStat).filter(models.QrcodeStat.Id == qrcode_stat_id).first()
+    if db_qrcode_stat:
+        db.delete(db_qrcode_stat)
+        db.commit()
+    return db_qrcode_stat
\ No newline at end of file
diff --git a/mooc/crud/crud_rule.py b/mooc/crud/crud_rule.py
new file mode 100644
index 0000000..34ed596
--- /dev/null
+++ b/mooc/crud/crud_rule.py
@@ -0,0 +1,31 @@
+from sqlalchemy.orm import Session
+from . import models, schemas
+
+def get_rule(db: Session, rule_id: int):
+    return db.query(models.Rule).filter(models.Rule.Id == rule_id).first()
+
+def get_rules(db: Session, skip: int = 0, limit: int = 100):
+    return db.query(models.Rule).offset(skip).limit(limit).all()
+
+def create_rule(db: Session, rule: schemas.RuleCreate):
+    db_rule = models.Rule(**rule.dict())
+    db.add(db_rule)
+    db.commit()
+    db.refresh(db_rule)
+    return db_rule
+
+def update_rule(db: Session, rule_id: int, rule: schemas.RuleCreate):
+    db_rule = db.query(models.Rule).filter(models.Rule.Id == rule_id).first()
+    if db_rule:
+        for key, value in rule.dict().items():
+            setattr(db_rule, key, value)
+        db.commit()
+        db.refresh(db_rule)
+    return db_rule
+
+def delete_rule(db: Session, rule_id: int):
+    db_rule = db.query(models.Rule).filter(models.Rule.Id == rule_id).first()
+    if db_rule:
+        db.delete(db_rule)
+        db.commit()
+    return db_rule
\ No newline at end of file
diff --git a/mooc/crud/crud_rule_keyword.py b/mooc/crud/crud_rule_keyword.py
new file mode 100644
index 0000000..4f8a02b
--- /dev/null
+++ b/mooc/crud/crud_rule_keyword.py
@@ -0,0 +1,31 @@
+from sqlalchemy.orm import Session
+from . import models, schemas
+
+def get_rule_keyword(db: Session, rule_keyword_id: int):
+    return db.query(models.RuleKeyword).filter(models.RuleKeyword.Id == rule_keyword_id).first()
+
+def get_rule_keywords(db: Session, skip: int = 0, limit: int = 100):
+    return db.query(models.RuleKeyword).offset(skip).limit(limit).all()
+
+def create_rule_keyword(db: Session, rule_keyword: schemas.RuleKeywordCreate):
+    db_rule_keyword = models.RuleKeyword(**rule_keyword.dict())
+    db.add(db_rule_keyword)
+    db.commit()
+    db.refresh(db_rule_keyword)
+    return db_rule_keyword
+
+def update_rule_keyword(db: Session, rule_keyword_id: int, rule_keyword: schemas.RuleKeywordCreate):
+    db_rule_keyword = db.query(models.RuleKeyword).filter(models.RuleKeyword.Id == rule_keyword_id).first()
+    if db_rule_keyword:
+        for key, value in rule_keyword.dict().items():
+            setattr(db_rule_keyword, key, value)
+        db.commit()
+        db.refresh(db_rule_keyword)
+    return db_rule_keyword
+
+def delete_rule_keyword(db: Session, rule_keyword_id: int):
+    db_rule_keyword = db.query(models.RuleKeyword).filter(models.RuleKeyword.Id == rule_keyword_id).first()
+    if db_rule_keyword:
+        db.delete(db_rule_keyword)
+        db.commit()
+    return db_rule_keyword
\ No newline at end of file