#author:        4N
#createtime:    2021/1/27
#email:         nheweijun@sina.com

from ..models import *
import json
from sqlalchemy.orm import Session
import datetime
from app.util.component.ApiTemplate import ApiTemplate
from app.util.component.PGUtil import PGUtil
from authlib.integrations.flask_oauth2 import current_token
from app.util.component.UserCheck import UserCheck

class Api(ApiTemplate):
    api_name = "修改表信息"
    def process(self):

        res = {}
        try:
        
            table_guid = self.para.get("guid")
            table_alias = self.para.get("alias")
            catalog_guid = self.para.get("catalog_guid")
            description = self.para.get("description")
            name = self.para.get("name")
            columns_edit = self.para.get("columns_edit")
            is_for_partition = self.para.get("is_for_partition")
    
            table = Table.query.filter_by(guid=table_guid)
            if not table.one_or_none():
                res["result"]=False
                res["msg"]= "数据不存在！"
                return res

            #验证权限
            UserCheck.verify(table.one_or_none().relate_database.creator)
    
            if self.para.__contains__("catalog_guid"):
                if catalog_guid is None:
                    table.update({"catalog_guid": None})
    
                else:
                    # 检测目录的有效性
    
                    if not Catalog.query.filter_by(guid=catalog_guid).one_or_none():
                        raise Exception("目录不存在！")
    
                    if not table.one_or_none().database_guid.__eq__(
                        Catalog.query.filter_by(guid=catalog_guid).one_or_none().database_guid
                    ):
                        raise Exception("该目录不属于表所在的数据库！")
                    table.update({"catalog_guid": catalog_guid})
    
    
            if self.para.__contains__("alias"):
                table.update({"alias":table_alias})
            if is_for_partition is not None:
                table.update({"is_for_partition": int(is_for_partition)})
    
            if self.para.__contains__("description"):
                table.update({"description":description})
    
            if columns_edit:
                columns_edit_list = json.loads(columns_edit)
                for ce in columns_edit_list:
                    columns_update_dict = {}
                    if ce.get("alias"):
                        columns_update_dict["alias"] = ce.get("alias")
                    if ce.get("is_for_partition") is not None:
                        columns_update_dict["is_for_partition"] = int(ce.get("is_for_partition"))
                    if columns_update_dict:
                        Columns.query.filter_by(guid=ce["guid"]).update(columns_update_dict)
    
            if name:
                sys_session=None
                try:
                    this_table = table.one_or_none()
                    database:Database= this_table.relate_database
                    sys_session: Session = PGUtil.get_db_session(DES.decode(database.sqlalchemy_uri))
                    rename_sql = 'alter table "{}" rename to "{}"'.format(this_table.name,name)
                    sys_session.execute(rename_sql)
                    sys_session.commit()

                    # 更新所有相关业务表
                    same_databases = Database.query.filter_by(sqlalchemy_uri=this_table.relate_database.sqlalchemy_uri).all()
                    same_databases_database_guid = [d.guid for d in same_databases]
                    re_tables = Table.query.filter(Table.name==this_table.name).filter(Table.database_guid.in_(same_databases_database_guid))
                    re_tables.update({"name": name},synchronize_session=False)
                except:
                    raise Exception("表名更新失败，表名已存在!")
                finally:
                    if sys_session:
                        sys_session.close()
            db.session.commit()

            if catalog_guid or table_alias or name or columns_edit:
                Table.query.filter_by(guid=table_guid).update({"update_time":datetime.datetime.now()})
                db.session.commit()
            res["result"] = True
            res["msg"] = "更新成功！"
        except Exception as e:
            db.session.rollback()
            raise e
        return res
    
    api_doc={
    "tags":["管理接口"],
    "parameters":[
        {"name": "guid",
         "in": "formData",
         "type": "string",
         "description": "表guid","required":"true"},
        {"name": "alias",
         "in": "formData",
         "type": "string",
         "description": "表别名"},
        {"name": "name",
         "in": "formData",
         "type": "string",
         "description": "表名"},
        {"name": "is_for_partition",
         "in": "formData",
         "type": "int",
         "description": "是否用于分层分级", "enum": [0, 1]},
        {"name": "description",
         "in": "formData",
         "type": "string",
         "description": "表描述"},
        {"name": "catalog_guid",
         "in": "formData",
         "type": "string",
         "description": "目录guid,如果要撤销挂载目录，传None"},
        {"name": "columns_edit",
         "in": "formData",
         "type": "string",
         "description": '需要修改的属性的列表，如 [{"guid":"1fda","alias":"测试"}]'},
    
    ],
    "responses":{
        200:{
            "schema":{
                "properties":{
                }
            }
            }
        }
    }