from peewee import (
    AutoField,
    BigIntegerField,
    CharField,
    CompositeKey,
    DateTimeField,
    FloatField,
    ForeignKeyField,
    IntegerField,
    Model,
    TextField,
    SQL
)
from db.common import UnknownField
from db.dci6.databases import auth_database


class BaseModel(Model):
    class Meta:
        database = auth_database


class AlertSetting(BaseModel):
    channel = UnknownField(null=True)  # json
    enabled = IntegerField(constraints=[SQL("DEFAULT 1")])
    metric = UnknownField(null=True)  # json
    metric_id = CharField(null=True)
    name = CharField(null=True)

    class Meta:
        table_name = 'alert_setting'


class AuthAcl(BaseModel):
    ip_list = UnknownField()  # json
    name = CharField(constraints=[SQL("DEFAULT ''")], unique=True)

    class Meta:
        table_name = 'auth_acl'


class AuthUser(BaseModel):
    auth_source = CharField(constraints=[SQL("DEFAULT 'local'")])
    avatar = TextField(null=True)
    avatar_content_type = CharField(null=True)
    avatar_filename = CharField(null=True)
    created_date = DateTimeField(null=True)
    email = CharField(constraints=[SQL("DEFAULT ''")], unique=True)
    email_confirm = IntegerField(constraints=[SQL("DEFAULT 0")])
    full_name = CharField(null=True)
    ip_list = UnknownField(null=True)  # json
    lang = CharField(constraints=[SQL("DEFAULT 'en'")])
    password = CharField(null=True)
    phone_number = CharField(null=True)
    property = UnknownField(null=True)  # json
    reserve_codes = UnknownField(null=True)  # json
    roles = UnknownField()  # json
    ssh_priv_key = TextField(null=True)
    ssh_pub_key = TextField(null=True)
    state = CharField(constraints=[SQL("DEFAULT 'active'")])
    timezone = CharField(null=True)
    totp = CharField(null=True)
    uuid = CharField(null=True, unique=True)

    class Meta:
        table_name = 'auth_user'


class AuthConfirmToken(BaseModel):
    expires_at = DateTimeField(null=True)
    resend_token_after = DateTimeField(null=True)
    token = CharField(null=True, unique=True)
    user = ForeignKeyField(
        column_name='user',
        field='id',
        model=AuthUser,
        null=True,
        unique=True
    )

    class Meta:
        table_name = 'auth_confirm_token'


class AuthGdprDoc(BaseModel):
    change_date = DateTimeField(null=True)
    desc_condition = CharField(null=True)
    entry_date = DateTimeField(null=True)
    locale = CharField(null=True)
    name = CharField(unique=True)
    required = IntegerField(constraints=[SQL("DEFAULT 0")])
    state = CharField()
    url = CharField(null=True)

    class Meta:
        table_name = 'auth_gdpr_doc'


class AuthGdprJournal(BaseModel):
    action_date = DateTimeField(null=True)
    action_type = CharField()
    doc = ForeignKeyField(
        column_name='doc',
        field='id',
        model=AuthGdprDoc,
        null=True
    )
    ip = CharField(null=True)
    user_email = CharField()

    class Meta:
        table_name = 'auth_gdpr_journal'


class AuthGeneratedSshkey(BaseModel):
    generation_date = DateTimeField(null=True)
    privkey = TextField(null=True)
    pubkey = TextField(null=True)

    class Meta:
        table_name = 'auth_generated_sshkey'


class AuthProduct(BaseModel):
    docker_compose_file = TextField(null=True)
    name = CharField(null=True)
    script = TextField(null=True)
    version = CharField(null=True)

    class Meta:
        table_name = 'auth_product'
        indexes = (
            (('name', 'version'), True),
        )


class AuthInstance(BaseModel):
    conn_params = UnknownField(null=True)  # json
    dbkey = TextField(null=True)
    demo = IntegerField(constraints=[SQL("DEFAULT 0")])
    failure_reason = UnknownField(null=True)  # json
    limits = UnknownField(null=True)  # json
    name = CharField(null=True)
    owner = ForeignKeyField(
        column_name='owner',
        field='id',
        model=AuthUser,
        null=True
    )
    product = ForeignKeyField(
        column_name='product',
        field='id',
        model=AuthProduct,
        null=True
    )
    roles = UnknownField(null=True)  # json
    started = DateTimeField(null=True)
    status = CharField()

    class Meta:
        table_name = 'auth_instance'


class AuthInstanceHistory(BaseModel):
    create_time = DateTimeField(constraints=[SQL("DEFAULT CURRENT_TIMESTAMP")])
    event_info = UnknownField(null=True)  # json
    event_type = CharField(null=True)
    prev_time = DateTimeField(null=True)
    ref = ForeignKeyField(
        column_name='ref',
        field='id',
        model=AuthInstance,
        null=True
    )
    request_id = CharField(null=True)
    request_ip = CharField(null=True)
    request_owner = CharField(null=True)
    request_user = CharField(null=True)

    class Meta:
        table_name = 'auth_instance_history'


class AuthKey(BaseModel):
    expires_at = DateTimeField(null=True)
    name = CharField(constraints=[SQL("DEFAULT ''")], unique=True)
    user = ForeignKeyField(column_name='user', field='id', model=AuthUser)

    class Meta:
        table_name = 'auth_key'


class AuthLicense(BaseModel):
    instance = ForeignKeyField(
        column_name='instance',
        field='id',
        model=AuthInstance,
        null=True,
        unique=True
    )
    last_update = DateTimeField(null=True)
    lic_data = UnknownField(null=True)  # json
    lic_request = UnknownField(null=True)  # json
    product = CharField(null=True)
    signature_expire_date = DateTimeField(null=True)
    status = CharField()

    class Meta:
        table_name = 'auth_license'


class AuthPermission(BaseModel):
    data = UnknownField()  # json
    plugin = CharField(constraints=[SQL("DEFAULT ''")])
    service = CharField(constraints=[SQL("DEFAULT ''")])

    class Meta:
        table_name = 'auth_permission'
        indexes = (
            (('service', 'plugin'), True),
        )


class AuthPricelist(BaseModel):
    bill_id = IntegerField(null=True, unique=True)
    name = CharField(null=True)
    params = UnknownField(null=True)  # json

    class Meta:
        table_name = 'auth_pricelist'


class AuthRestrictions(BaseModel):
    attempts_counting_duration = BigIntegerField()
    attempts_max_count = IntegerField(null=True)
    role = CharField(constraints=[SQL("DEFAULT ''")], unique=True)
    time_between_attempts = BigIntegerField()
    time_to_unban = BigIntegerField()

    class Meta:
        table_name = 'auth_restrictions'


class AuthRestrictionsBans(BaseModel):
    banned_until = DateTimeField()
    user = ForeignKeyField(column_name='user', field='id', model=AuthUser)
    user_ip = CharField(null=True)

    class Meta:
        table_name = 'auth_restrictions_bans'
        indexes = (
            (('user', 'user_ip'), True),
        )


class AuthRole(BaseModel):
    data = UnknownField()  # json
    human_descr = CharField(null=True)
    human_name = CharField(null=True)
    name = CharField(constraints=[SQL("DEFAULT ''")], unique=True)

    class Meta:
        table_name = 'auth_role'


class AuthServer(BaseModel):
    demo = IntegerField(constraints=[SQL("DEFAULT 0")])
    host = CharField(null=True)
    instance = ForeignKeyField(
        column_name='instance',
        field='id',
        model=AuthInstance,
        null=True,
        unique=True
    )
    login = CharField(null=True)
    machine_id = CharField(null=True)
    password = CharField(null=True)
    port = IntegerField(null=True)

    class Meta:
        table_name = 'auth_server'
        indexes = (
            (('host', 'port'), True),
        )


class AuthService(BaseModel):
    bill_id = IntegerField(null=True, unique=True)
    info = UnknownField(null=True)  # json
    instance = ForeignKeyField(
        column_name='instance',
        field='id',
        model=AuthInstance,
        null=True,
        unique=True
    )
    params = UnknownField(null=True)  # json
    payment_form = TextField(null=True)
    status = CharField(null=True)

    class Meta:
        table_name = 'auth_service'
        indexes = (
            (('instance', 'bill_id'), True),
        )


class AuthServiceDbkey(BaseModel):
    dbkey = TextField(null=True)
    name = CharField(null=True, unique=True)

    class Meta:
        table_name = 'auth_service_dbkey'


class AuthSession(BaseModel):
    expires_at = DateTimeField(null=True)
    is_internal = IntegerField(constraints=[SQL("DEFAULT 0")])
    name = CharField(null=True, unique=True)
    owner = ForeignKeyField(
        column_name='owner',
        field='id',
        model=AuthUser,
        null=True
    )
    trustee = ForeignKeyField(
        backref='auth_user_trustee_set',
        column_name='trustee',
        field='id',
        model=AuthUser,
        null=True
    )
    updated_at = DateTimeField(null=True)
    xsrf_token = CharField(null=True)

    class Meta:
        table_name = 'auth_session'


class AuthToken(BaseModel):
    client_ip = CharField(null=True)
    description = CharField(constraints=[SQL("DEFAULT ''")])
    expires_at = DateTimeField(null=True)
    last_used = DateTimeField()
    name = CharField(constraints=[SQL("DEFAULT ''")], unique=True)
    need_2fa = IntegerField(constraints=[SQL("DEFAULT 0")])
    owner = ForeignKeyField(column_name='owner', field='id', model=AuthUser)
    trustee = ForeignKeyField(
        backref='auth_user_trustee_set',
        column_name='trustee',
        field='id',
        model=AuthUser
    )

    class Meta:
        table_name = 'auth_token'


class AuthTrusteeUser(BaseModel):
    instance = ForeignKeyField(
        column_name='instance',
        field='id',
        model=AuthInstance,
        null=True
    )
    role = CharField(null=True)
    trustee = ForeignKeyField(
        column_name='trustee',
        field='id',
        model=AuthUser,
        null=True
    )
    user = ForeignKeyField(
        backref='auth_user_user_set',
        column_name='user',
        field='id',
        model=AuthUser,
        null=True
    )

    class Meta:
        table_name = 'auth_trustee_user'
        indexes = (
            (('user', 'trustee', 'instance'), True),
        )


class AuthUser2Acl(BaseModel):
    acl = ForeignKeyField(column_name='acl', field='id', model=AuthAcl)
    user = ForeignKeyField(column_name='user', field='id', model=AuthUser)

    class Meta:
        table_name = 'auth_user2acl'
        indexes = (
            (('user', 'acl'), True),
        )


class AuthUserRole(BaseModel):
    instance = ForeignKeyField(
        column_name='instance',
        field='id',
        model=AuthInstance,
        null=True
    )
    roles = UnknownField()  # json
    state = CharField(constraints=[SQL("DEFAULT 'active'")])
    trustee = ForeignKeyField(
        column_name='trustee',
        field='id',
        model=AuthUser
    )
    user = ForeignKeyField(
        backref='auth_user_user_set',
        column_name='user',
        field='id',
        model=AuthUser
    )

    class Meta:
        table_name = 'auth_user_role'
        indexes = (
            (('user', 'trustee', 'instance'), True),
        )


class AuthUserSetting(BaseModel):
    data = UnknownField(null=True)  # json
    instance = ForeignKeyField(
        column_name='instance',
        field='id',
        model=AuthInstance,
        null=True
    )
    name = CharField(null=True)
    user = ForeignKeyField(
        column_name='user',
        field='id',
        model=AuthUser
    )

    class Meta:
        table_name = 'auth_user_setting'
        indexes = (
            (('user', 'name', 'instance'), True),
        )


class AuthUserSshkey(BaseModel):
    name = CharField(constraints=[SQL("DEFAULT ''")])
    owner = ForeignKeyField(
        column_name='owner',
        field='id',
        model=AuthUser,
        null=True
    )
    ssh_pub_key = TextField()

    class Meta:
        table_name = 'auth_user_sshkey'
        indexes = (
            (('name', 'owner'), True),
        )


class AuthUsersLocks(BaseModel):
    description = CharField(constraints=[SQL("DEFAULT ''")])
    service_name = CharField()
    user = ForeignKeyField(column_name='user', field='id', model=AuthUser)

    class Meta:
        table_name = 'auth_users_locks'
        indexes = (
            (('user', 'service_name'), True),
        )
        primary_key = CompositeKey('service_name', 'user')


class BackupAlembicVersion(BaseModel):
    version_num = CharField(primary_key=True)

    class Meta:
        table_name = 'backup_alembic_version'


class BackupTask(BaseModel):
    connection_params = TextField()
    cron_expression = CharField()
    enabled = IntegerField()
    limit_count = IntegerField()
    limit_size_mib = IntegerField(null=True)
    name = CharField()
    note = TextField()
    schedule_type = CharField()
    storage_type = CharField()

    class Meta:
        table_name = 'backup_task'


class BackupFile(BaseModel):
    date = DateTimeField()
    downloadable = IntegerField()
    name = CharField()
    size = FloatField()
    storage_type = CharField()
    task = ForeignKeyField(
        column_name='task',
        field='id',
        model=BackupTask,
        null=True
    )

    class Meta:
        table_name = 'backup_file'


class CsDocuments(BaseModel):
    lang = CharField(constraints=[SQL("DEFAULT ''")])
    name = CharField(constraints=[SQL("DEFAULT ''")])
    product = CharField(constraints=[SQL("DEFAULT ''")])
    required = IntegerField(constraints=[SQL("DEFAULT 0")])
    url = CharField(constraints=[SQL("DEFAULT ''")])

    class Meta:
        table_name = 'cs_documents'
        indexes = (
            (('product', 'lang', 'name'), True),
        )


class CsSettings(BaseModel):
    lang = CharField(constraints=[SQL("DEFAULT ''")])
    product = CharField(constraints=[SQL("DEFAULT ''")])
    prop_key = CharField(constraints=[SQL("DEFAULT ''")])
    prop_value = CharField(constraints=[SQL("DEFAULT ''")])

    class Meta:
        table_name = 'cs_settings'
        indexes = (
            (('product', 'lang', 'prop_key'), True),
        )


class EserviceAlembicVersion(BaseModel):
    version_num = CharField(primary_key=True)

    class Meta:
        table_name = 'eservice_alembic_version'


class EserviceCustomEquipment(BaseModel):
    data = TextField(null=True)
    device_type = CharField()
    features = UnknownField(null=True)  # json
    handler = CharField(unique=True)
    handler_import = CharField(null=True)
    name = CharField(unique=True)
    protocol = UnknownField(null=True)  # json
    update_time = DateTimeField()
    version = CharField()

    class Meta:
        table_name = 'eservice_custom_equipment'


class EserviceIpmiFru(BaseModel):
    fru_info = UnknownField(null=True)  # json
    ipmi_id = AutoField()
    update_time = DateTimeField()

    class Meta:
        table_name = 'eservice_ipmi_fru'


class EserviceIpmiInfo(BaseModel):
    ipmi_id = AutoField()
    model = CharField()

    class Meta:
        table_name = 'eservice_ipmi_info'


class EserviceIpmiSensors(BaseModel):
    ipmi_id = AutoField()
    sensors_info = UnknownField(null=True)  # json
    update_time = DateTimeField()

    class Meta:
        table_name = 'eservice_ipmi_sensors'


class IpmiProxyLocation(BaseModel):
    docker_compose = TextField(null=True)
    instance = IntegerField(null=True)
    location = IntegerField(null=True)
    status = CharField(constraints=[SQL("DEFAULT 'setting_up'")])
    status_info = UnknownField(null=True)  # json
    supported_ipmi_consoles = UnknownField(null=True)  # json

    class Meta:
        table_name = 'ipmi_proxy_location'
        indexes = (
            (('instance', 'location'), True),
        )


class IpmiProxyConnection(BaseModel):
    close_time = DateTimeField(null=True)
    connection_data = UnknownField(null=True)  # json
    device_data = UnknownField(null=True)  # json
    intel_amt = IntegerField(null=True)
    ipmi = IntegerField(null=True)
    listen_web_port = IntegerField(null=True, unique=True)
    location = ForeignKeyField(
        column_name='location_id',
        field='id',
        model=IpmiProxyLocation
    )
    type = CharField(constraints=[SQL("DEFAULT 'web'")])
    user = IntegerField(null=True)
    vnc_port = IntegerField(null=True)

    class Meta:
        table_name = 'ipmi_proxy_connection'


class IpmiProxyJavaAgreement(BaseModel):
    instance = IntegerField(null=True, unique=True)
    java_agree = IntegerField(constraints=[SQL("DEFAULT 1")])

    class Meta:
        table_name = 'ipmi_proxy_java_agreement'


class IpmiProxyPlugin(BaseModel):
    instance = IntegerField(null=True, unique=True)

    class Meta:
        table_name = 'ipmi_proxy_plugin'


class IspSettings(BaseModel):
    name = CharField(primary_key=True)
    value = TextField()

    class Meta:
        table_name = 'isp_settings'


class JournalAlembicVersion(BaseModel):
    version_num = CharField(primary_key=True)

    class Meta:
        table_name = 'journal_alembic_version'


class JournalEvents(BaseModel):
    data = UnknownField(null=True)  # json
    date_time = DateTimeField(
        constraints=[SQL("DEFAULT CURRENT_TIMESTAMP(3)")]
    )
    entity_id = IntegerField()
    entity_name = CharField()
    entity_owner = IntegerField()
    entity_type = CharField()
    ip = CharField()
    roles = UnknownField(null=True)  # json
    trustee_email = CharField(index=True)
    trustee_id = IntegerField()
    type = CharField()
    user_email = CharField(index=True)
    user_id = IntegerField()

    class Meta:
        table_name = 'journal_events'


class MsgsChannel(BaseModel):
    comment = TextField(null=True)
    creation_date = DateTimeField(null=True)
    delivery_method = CharField()
    enabled = IntegerField(constraints=[SQL("DEFAULT 1")])
    language = CharField()
    name = CharField()
    params = UnknownField(null=True)  # json
    state = CharField(null=True)

    class Meta:
        table_name = 'msgs_channel'


class MsgsDeliveryMethod(BaseModel):
    delivery_method = CharField(primary_key=True)
    dm_params = UnknownField(null=True)  # json

    class Meta:
        table_name = 'msgs_delivery_method'


class MsgsMessageDesign(BaseModel):
    design = CharField(primary_key=True)

    class Meta:
        table_name = 'msgs_message_design'


class MsgsMessageDesignVariant(BaseModel):
    delivery_method = CharField()
    design = CharField()
    design_content = TextField(null=True)
    language = CharField()

    class Meta:
        table_name = 'msgs_message_design_variant'
        indexes = (
            (('design', 'delivery_method', 'language'), True),
            (('design', 'delivery_method', 'language'), True),
        )
        primary_key = CompositeKey('delivery_method', 'design', 'language')


class MsgsNoticeReceiver(BaseModel):
    delivery_method = CharField()
    receivers = UnknownField(null=True)  # json
    user = IntegerField(null=True)

    class Meta:
        table_name = 'msgs_notice_receiver'
        indexes = (
            (('user', 'delivery_method'), True),
        )


class MsgsTemplate(BaseModel):
    priority = CharField()
    template = CharField(primary_key=True)

    class Meta:
        table_name = 'msgs_template'


class MsgsTemplate2Category(BaseModel):
    category = CharField()
    template = CharField()

    class Meta:
        table_name = 'msgs_template2category'
        indexes = (
            (('template', 'category'), True),
            (('template', 'category'), True),
        )
        primary_key = CompositeKey('category', 'template')


class MsgsTemplateVariant(BaseModel):
    delivery_method = CharField()
    language = CharField()
    template = CharField()
    tv_params = UnknownField(null=True)  # json

    class Meta:
        table_name = 'msgs_template_variant'
        indexes = (
            (('template', 'delivery_method', 'language'), True),
            (('template', 'delivery_method', 'language'), True),
        )
        primary_key = CompositeKey('delivery_method', 'language', 'template')


class MsgsUser(BaseModel):
    language = CharField()
    user = AutoField()

    class Meta:
        table_name = 'msgs_user'


class MsgsUser2DeliveryMethod(BaseModel):
    delivery_method = CharField()
    u2dm_params = UnknownField(null=True)  # json
    user = IntegerField()

    class Meta:
        table_name = 'msgs_user2delivery_method'
        indexes = (
            (('user', 'delivery_method'), True),
            (('user', 'delivery_method'), True),
        )
        primary_key = CompositeKey('delivery_method', 'user')


class MsgsUserSubscription(BaseModel):
    category = CharField()
    delivery_method = CharField()
    user = IntegerField()

    class Meta:
        table_name = 'msgs_user_subscription'
        indexes = (
            (('user', 'delivery_method', 'category'), True),
        )
        primary_key = CompositeKey('category', 'delivery_method', 'user')


class NcNotice(BaseModel):
    create_timestamp = IntegerField(null=True)
    entity = UnknownField(null=True)  # json
    params = UnknownField(null=True)  # json
    status = CharField(constraints=[SQL("DEFAULT 'sended'")])
    timestamp = IntegerField(null=True)
    type = CharField(null=True)

    class Meta:
        table_name = 'nc_notice'


class NcUser(BaseModel):
    last_notice_timestamp = IntegerField(constraints=[SQL("DEFAULT 0")])
    read_timestamp = IntegerField(constraints=[SQL("DEFAULT 0")])

    class Meta:
        table_name = 'nc_user'


class NcNotice2User(BaseModel):
    notice = ForeignKeyField(
        column_name='notice',
        field='id',
        model=NcNotice,
        null=True
    )
    read_timestamp = IntegerField(constraints=[SQL("DEFAULT 0")])
    user = ForeignKeyField(
        column_name='user',
        field='id',
        model=NcUser,
        null=True
    )

    class Meta:
        table_name = 'nc_notice2user'
        indexes = (
            (('user', 'notice'), True),
        )


class NotifierNotify(BaseModel):
    additional_info = UnknownField()  # json
    description = UnknownField()  # json
    instance_id = IntegerField(null=True)
    modify_index = BigIntegerField()
    name = CharField(null=True)
    notify_type = CharField()
    owner = IntegerField(null=True)
    request_id = CharField(null=True)
    request_ip = CharField(null=True)
    time = DateTimeField(
        constraints=[SQL("DEFAULT CURRENT_TIMESTAMP")],
        index=True
    )
    trustee = IntegerField(null=True)

    class Meta:
        table_name = 'notifier_notify'


class PsPlugin(BaseModel):
    content = TextField()
    current_version = CharField(null=True)
    deprecated = IntegerField(constraints=[SQL("DEFAULT 0")])
    filename = CharField(null=True)
    intname = CharField(null=True, unique=True)
    metadata = UnknownField()  # json
    name = CharField(null=True, unique=True)
    obsoletes = UnknownField(null=True)  # json
    plugin_requirement = UnknownField(null=True)  # json
    product = CharField()
    remote = IntegerField(constraints=[SQL("DEFAULT 0")])
    status = CharField(constraints=[SQL("DEFAULT 'disabled'")])
    version = CharField(null=True)

    class Meta:
        table_name = 'ps_plugin'


class PsPluginLicense(BaseModel):
    instance = IntegerField(null=True)
    license = UnknownField(null=True)  # json
    plugin = IntegerField(null=True)

    class Meta:
        table_name = 'ps_plugin_license'
        indexes = (
            (('instance', 'plugin'), True),
        )


class ReportAlembicVersion(BaseModel):
    version_num = CharField(primary_key=True)

    class Meta:
        table_name = 'report_alembic_version'


class ReportFile(BaseModel):
    additional_info = UnknownField(null=True)  # json
    content = TextField(null=True)
    create_datetime = DateTimeField()
    entity = CharField()
    entity_ids = UnknownField()  # json
    filename = CharField(null=True)
    is_read = IntegerField()
    status = CharField()
    status_info = UnknownField(null=True)  # json
    type = CharField()

    class Meta:
        table_name = 'report_file'


class TaskmgrTask(BaseModel):
    before_execute = UnknownField(null=True)  # json
    bin_args = UnknownField(null=True)  # json
    bin_path = CharField(constraints=[SQL("DEFAULT ''")])
    callback_params = UnknownField(null=True)  # json
    defer_resolve = UnknownField(null=True)  # json
    defer_wait = UnknownField(null=True)  # json
    depends_on = UnknownField(null=True)  # json
    env = UnknownField(null=True)  # json
    instance_id = CharField(null=True)
    lock_tag = UnknownField(null=True)  # json
    name = CharField(constraints=[SQL("DEFAULT ''")])
    notify = UnknownField(null=True)  # json
    on_start = UnknownField(null=True)  # json
    output = TextField()
    queue = UnknownField(null=True)  # json
    registration_time = DateTimeField(
        constraints=[SQL("DEFAULT CURRENT_TIMESTAMP")]
    )
    request_info = UnknownField(null=True)  # json
    return_code = IntegerField()
    service = CharField(constraints=[SQL("DEFAULT ''")])
    status = CharField(constraints=[SQL("DEFAULT 'created'")], index=True)
    stdin = UnknownField(null=True)  # json
    ttl = IntegerField()
    work_dir = CharField(constraints=[SQL("DEFAULT ''")])
    worker_id = CharField(null=True)

    class Meta:
        table_name = 'taskmgr_task'


class Vault(BaseModel):
    key = CharField(unique=True)
    value = TextField()

    class Meta:
        table_name = 'vault'


class VaultAlembicVersion(BaseModel):
    version_num = CharField(primary_key=True)

    class Meta:
        table_name = 'vault_alembic_version'


class VaultQueryLog(BaseModel):
    date = DateTimeField()
    owner_email = CharField()
    owner_id = IntegerField()
    request_id = CharField()
    request_ip = CharField()
    service = CharField()
    trustee_id = IntegerField()

    class Meta:
        table_name = 'vault_query_log'