from sqlalchemy.orm import Session
from typing import Optional

from mooc.models.account import (
    AccountWechats, 
    AccountAliapp, 
    AccountBaiduapp, 
    AccountPhoneapp, 
    AccountToutiaoapp, 
    AccountWebapp, 
    Account,
    AccountWxapp,
    AccountXzapp
    )
from mooc.schemas.account import (
    AccountWechatsCreate, 
    AccountWechatsUpdate, 
    AccountAliappCreate, 
    AccountAliappUpdate, 
    AccountBaiduappCreate, 
    AccountBaiduappUpdate, 
    AccountPhoneappCreate, 
    AccountPhoneappUpdate, 
    AccountToutiaoappCreate, 
    AccountToutiaoappUpdate, 
    AccountWebappCreate, 
    AccountWebappUpdate, 
    AccountXzappCreate,
    AccountXzappUpdate,
    AccountWxappCreate,
    AccountWxappUpdate

)

class CRUDAccountWechats:
    def create(self, db: Session, obj_in: AccountWechatsCreate) -> AccountWechats:
        db_obj = AccountWechats(**obj_in.dict())
        db.add(db_obj)
        db.commit()
        db.refresh(db_obj)
        return db_obj

    def get(self, db: Session, acid: int) -> Optional[AccountWechats]:
        return db.query(AccountWechats).filter(AccountWechats.acid == acid).first()

    def update(
        self, db: Session, *, db_obj: AccountWechats, obj_in: AccountWechatsUpdate
    ) -> AccountWechats:
        for field, value in obj_in.dict(exclude_unset=True).items():
            setattr(db_obj, field, value)
        db.add(db_obj)
        db.commit()
        db.refresh(db_obj)
        return db_obj

    def delete(self, db: Session, acid: int) -> None:
        obj = db.query(AccountWechats).filter(AccountWechats.acid == acid).first()
        if obj:
            db.delete(obj)
            db.commit()


class CRUDAccountAliapp:
    def create(self, db: Session, obj_in: AccountAliappCreate) -> AccountAliapp:
        db_obj = AccountAliapp(**obj_in.dict())
        db.add(db_obj)
        db.commit()
        db.refresh(db_obj)
        return db_obj

    def get(self, db: Session, acid: int) -> Optional[AccountAliapp]:
        return db.query(AccountAliapp).filter(AccountAliapp.acid == acid).first()

    def update(
        self, db: Session, *, db_obj: AccountAliapp, obj_in: AccountAliappUpdate
    ) -> AccountAliapp:
        for field, value in obj_in.dict(exclude_unset=True).items():
            setattr(db_obj, field, value)
        db.add(db_obj)
        db.commit()
        db.refresh(db_obj)
        return db_obj

    def delete(self, db: Session, acid: int) -> None:
        obj = db.query(AccountAliapp).filter(AccountAliapp.acid == acid).first()
        if obj:
            db.delete(obj)
            db.commit()
class CRUDAccountBaiduapp:
    def create(self, db: Session, obj_in: AccountBaiduappCreate) -> AccountBaiduapp:
        db_obj = AccountBaiduapp(**obj_in.dict())
        db.add(db_obj)
        db.commit()
        db.refresh(db_obj)
        return db_obj

    def get(self, db: Session, acid: int) -> Optional[AccountBaiduapp]:
        return db.query(AccountBaiduapp).filter(AccountBaiduapp.acid == acid).first()

    def update(
        self, db: Session, *, db_obj: AccountBaiduapp, obj_in: AccountBaiduappUpdate
    ) -> AccountBaiduapp:
        for field, value in obj_in.dict(exclude_unset=True).items():
            setattr(db_obj, field, value)
        db.add(db_obj)
        db.commit()
        db.refresh(db_obj)
        return db_obj

    def delete(self, db: Session, acid: int) -> None:
        obj = db.query(AccountBaiduapp).filter(AccountBaiduapp.acid == acid).first()
        if obj:
            db.delete(obj)
            db.commit()
class CRUDAccountPhoneapp:
    def create(self, db: Session, obj_in: AccountPhoneappCreate) -> AccountPhoneapp:
        db_obj = AccountPhoneapp(**obj_in.dict())
        db.add(db_obj)
        db.commit()
        db.refresh(db_obj)
        return db_obj

    def get(self, db: Session, acid: int) -> Optional[AccountPhoneapp]:
        return db.query(AccountPhoneapp).filter(AccountPhoneapp.acid == acid).first()

    def update(
        self, db: Session, *, db_obj: AccountPhoneapp, obj_in: AccountPhoneappUpdate
    ) -> AccountPhoneapp:
        for field, value in obj_in.dict(exclude_unset=True).items():
            setattr(db_obj, field, value)
        db.add(db_obj)
        db.commit()
        db.refresh(db_obj)
        return db_obj

    def delete(self, db: Session, acid: int) -> None:
        obj = db.query(AccountPhoneapp).filter(AccountPhoneapp.acid == acid).first()
        if obj:
            db.delete(obj)
            db.commit()

class CRUDAccountToutiaoapp:
    def create(self, db: Session, obj_in: AccountToutiaoappCreate) -> AccountToutiaoapp:
        db_obj = AccountToutiaoapp(**obj_in.dict())
        db.add(db_obj)
        db.commit()
        db.refresh(db_obj)
        return db_obj

    def get(self, db: Session, acid: int) -> Optional[AccountToutiaoapp]:
        return db.query(AccountToutiaoapp).filter(AccountToutiaoapp.acid == acid).first()

    def update(
        self, db: Session, *, db_obj: AccountToutiaoapp, obj_in: AccountToutiaoappUpdate
    ) -> AccountToutiaoapp:
        for field, value in obj_in.dict(exclude_unset=True).items():
            setattr(db_obj, field, value)
        db.add(db_obj)
        db.commit()
        db.refresh(db_obj)
        return db_obj

    def delete(self, db: Session, acid: int) -> None:
        obj = db.query(AccountToutiaoapp).filter(AccountToutiaoapp.acid == acid).first()
        if obj:
            db.delete(obj)
            db.commit()


class CRUDAccount:
    def get_by_uniacid(self, db: Session, *, uniacid: int) -> Optional[Account]:
        return db.query(Account).filter(Account.uniacid == uniacid).first()

account = CRUDAccount()




class CRUDAccountWebapp:
    def create(self, db: Session, *, obj_in: AccountWebappCreate) -> AccountWebapp:
        db_obj = AccountWebapp(**obj_in.dict())
        db.add(db_obj)
        db.commit()
        db.refresh(db_obj)
        return db_obj

    def get(self, db: Session, acid: int) -> Optional[AccountWebapp]:
        return db.query(AccountWebapp).filter(AccountWebapp.acid == acid).first()

    def update(
        self,
        db: Session,
        *,
        db_obj: AccountWebapp,
        obj_in: AccountWebappUpdate
    ) -> AccountWebapp:
        data = obj_in.dict(exclude_unset=True)
        for field, value in data.items():
            setattr(db_obj, field, value)
        db.add(db_obj)
        db.commit()
        db.refresh(db_obj)
        return db_obj

    def delete(self, db: Session, acid: int) -> None:
        obj = db.query(AccountWebapp).filter(AccountWebapp.acid == acid).first()
        if obj:
            db.delete(obj)
            db.commit()



class CRUDAccountWxapp:
    def create(self, db: Session, obj_in: AccountWxappCreate) -> AccountWxapp:
        db_obj = AccountWxapp(**obj_in.dict())
        db.add(db_obj)
        db.commit()
        db.refresh(db_obj)
        return db_obj

    def get(self, db: Session, acid: int) -> Optional[AccountWxapp]:
        return db.query(AccountWxapp).filter(AccountWxapp.acid == acid).first()

    def update(
        self, db: Session, *, db_obj: AccountWxapp, obj_in: AccountWxappUpdate
    ) -> AccountWxapp:
        for field, value in obj_in.dict(exclude_unset=True).items():
            setattr(db_obj, field, value)
        db.add(db_obj)
        db.commit()
        db.refresh(db_obj)
        return db_obj

    def delete(self, db: Session, acid: int) -> None:
        obj = db.query(AccountWxapp).filter(AccountWxapp.acid == acid).first()
        if obj:
            db.delete(obj)
            db.commit()

class CRUDAccountXzapp:
    def create(self, db: Session, obj_in: AccountXzappCreate) -> AccountXzapp:
        db_obj = AccountXzapp(**obj_in.dict())
        db.add(db_obj)
        db.commit()
        db.refresh(db_obj)
        return db_obj

    def get(self, db: Session, acid: int) -> Optional[AccountXzapp]:
        return db.query(AccountXzapp).filter(AccountXzapp.acid == acid).first()

    def update(
        self, db: Session, *, db_obj: AccountXzapp, obj_in: AccountXzappUpdate
    ) -> AccountXzapp:
        for field, value in obj_in.dict(exclude_unset=True).items():
            setattr(db_obj, field, value)
        db.add(db_obj)
        db.commit()
        db.refresh(db_obj)
        return db_obj

    def delete(self, db: Session, acid: int) -> None:
        obj = db.query(AccountXzapp).filter(AccountXzapp.acid == acid).first()
        if obj:
            db.delete(obj)
            db.commit()

# 在文件末尾添加实例
account_wxapp = CRUDAccountWxapp()
account_xzapp = CRUDAccountXzapp()
account_webapp = CRUDAccountWebapp()

account_wechats = CRUDAccountWechats()
ims_account_aliapp = CRUDAccountAliapp()
ims_account_baiduapp = CRUDAccountBaiduapp()
ims_account_phoneapp = CRUDAccountPhoneapp()
ims_account_toutiaoapp = CRUDAccountToutiaoapp()