def upgrade(migrate_engine):
    metadata.bind = migrate_engine
    print(__doc__)
    metadata.reflect()
    try:
        SampleDataset_table = Table( "sample_dataset", metadata, autoload=True )
    except NoSuchTableError:
        SampleDataset_table = None
        log.debug( "Failed loading table 'sample_dataset'" )

    if SampleDataset_table is not None:
        cmd = "SELECT id, file_path FROM sample_dataset"
        result = migrate_engine.execute( cmd )
        filepath_dict = {}
        for r in result:
            id = int(r[0])
            filepath_dict[id] = r[1]
        # remove the 'file_path' column
        try:
            SampleDataset_table.c.file_path.drop()
        except Exception:
            log.exception("Deleting column 'file_path' from the 'sample_dataset' table failed.")
        # create the column again
        try:
            col = Column( "file_path", TEXT )
            col.create( SampleDataset_table )
            assert col is SampleDataset_table.c.file_path
        except Exception:
            log.exception("Creating column 'file_path' in the 'sample_dataset' table failed.")

        for id, file_path in filepath_dict.items():
            cmd = "update sample_dataset set file_path='%s' where id=%i" % (file_path, id)
            migrate_engine.execute( cmd )
def upgrade(migrate_engine):
    meta.bind = migrate_engine

    records_table = Table('records', meta, autoload=True)

    disabled = Column('disabled', TINYINT(1), server_default='0')
    disabled.create(records_table)
def upgrade(migrate_engine):
    meta.bind = migrate_engine
    dialect = migrate_engine.url.get_dialect().name

    domains_table = Table('domains', meta, autoload=True)

    if dialect.startswith('sqlite'):
        # SQLite can't drop a constraint. Yay. This will be fun..

        # Create a new name column without the unique index
        name_tmp_column = Column('name_tmp', String(255))
        name_tmp_column.create(domains_table)

        # Copy the data over.
        query = update(domains_table).values(name_tmp=domains_table.c.name)
        migrate_engine.execute(query)

        # Delete the name column
        domains_table.c.name.drop()

        # Rename the name_tmp column to name
        domains_table.c.name_tmp.alter(name='name')
    elif dialect.startswith('postgresql'):
        constraint = UniqueConstraint('name', name='domains_name_key',
                                      table=domains_table)
        constraint.drop()
    else:
        constraint = UniqueConstraint('name', name='name', table=domains_table)
        constraint.drop()
def upgrade(migrate_engine):
    # Upgrade operations go here. Don't create your own engine; bind
    # migrate_engine to your metadata
    meta = MetaData(bind=migrate_engine)
    store = Table('store', meta, autoload=True)
    datecol = Column('timestamp', DateTime, default=datetime.datetime.utcnow)
    datecol.create(store)
def upgrade(migrate_engine):

    metadata.bind = migrate_engine

    # dummy definitions to satisfy foreign keys
    Table('instance', metadata, autoload=True)
    Table('group', metadata, autoload=True)

    # add the column for the polymorphic identity
    # we have to use 'nullable=True' cause the values are
    # null when the column is created
    type_col = Column('type', String(40), nullable=True)
    type_col.create(badge_table)

    # fill column with the right values
    select = badge_table.select().with_only_columns(
        ['id', 'title', 'badge_delegateable', 'badge_delegateable_category'])
    badges_query_result = migrate_engine.execute(select)
    for values in badges_query_result:
        (id_, title, delegateable, category) = values
        if category:
            type_ = CATEGORY_BADGE
        elif delegateable:
            type_ = DELEGATEABLE_BADGE
        else:
            type_ = USER_BADGE
        update = badge_table.update().values(type=type_).where(
            badge_table.c.id == id_)
        migrate_engine.execute(update)

    # drop the old columns
    badge_table.c.badge_delegateable.drop()
    badge_table.c.badge_delegateable_category.drop()

    type_col.alter(nullable=False)
def downgrade(migrate_engine):
    meta = MetaData()
    meta.bind = migrate_engine
    instances = Table('instances', meta, autoload=True)
    instance_types = Table('instance_types', meta, autoload=True)

    for table in (instances, instance_types):
        local_gb = Column('local_gb', Integer)
        local_gb.create(table)

    try:
        for table in (instances, instance_types):
            if FLAGS.connection_type == 'libvirt':
                column = table.c.ephemeral_gb
            else:
                column = table.c.root_gb
            table.update().values(local_gb=column).execute()
    except Exception:
        for table in (instances, instance_types):
            table.drop_column('local_gb')
        raise

    default_ephemeral_device = instances.c.default_ephemeral_device
    default_ephemeral_device.alter(name='default_local_device')

    for table in (instances, instance_types):
        table.drop_column('root_gb')
        table.drop_column('ephemeral_gb')
def upgrade(migrate_engine):
    metadata.bind = migrate_engine
    print(__doc__)
    metadata.reflect()
    try:
        LibraryDataset_table = Table("library_dataset", metadata, autoload=True)
        c = Column("purged", Boolean, index=True, default=False)
        c.create(LibraryDataset_table, index_name='ix_library_dataset_purged')
        assert c is LibraryDataset_table.c.purged
    except Exception:
        log.exception("Adding purged column to library_dataset table failed.")
    # Update the purged flag to the default False
    cmd = "UPDATE library_dataset SET purged = %s;" % engine_false(migrate_engine)
    try:
        migrate_engine.execute(cmd)
    except Exception:
        log.exception("Setting default data for library_dataset.purged column failed.")

    # Update the purged flag for those LibaryDatasets whose purged flag should be True.  This happens
    # when the LibraryDataset has no active LibraryDatasetDatasetAssociations.
    cmd = "SELECT * FROM library_dataset WHERE deleted = %s;" % engine_true(migrate_engine)
    deleted_lds = migrate_engine.execute(cmd).fetchall()
    for row in deleted_lds:
        cmd = "SELECT * FROM library_dataset_dataset_association WHERE library_dataset_id = %d AND library_dataset_dataset_association.deleted = %s;" % (int(row.id), engine_false(migrate_engine))
        active_lddas = migrate_engine.execute(cmd).fetchall()
        if not active_lddas:
            print("Updating purged column to True for LibraryDataset id : ", int(row.id))
            cmd = "UPDATE library_dataset SET purged = %s WHERE id = %d;" % (engine_true(migrate_engine), int(row.id))
            migrate_engine.execute(cmd)
def upgrade(migrate_engine):
    meta.bind = migrate_engine
    instance_table = Table('instance', meta,
        Column('id', Integer, primary_key=True),
        Column('key', Unicode(20), nullable=False, unique=True),
        Column('label', Unicode(255), nullable=False),
        Column('description', UnicodeText(), nullable=True),
        Column('required_majority', Float, nullable=False),
        Column('activation_delay', Integer, nullable=False),
        Column('create_time', DateTime, default=func.now()),
        Column('access_time', DateTime, default=func.now(), onupdate=func.now()),
        Column('delete_time', DateTime, nullable=True),
        Column('creator_id', Integer, ForeignKey('user.id'), nullable=False),
        Column('default_group_id', Integer, ForeignKey('group.id'), nullable=True),
        Column('allow_adopt', Boolean, default=True),       
        Column('allow_delegate', Boolean, default=True),
        Column('allow_index', Boolean, default=True),
        Column('hidden', Boolean, default=False),
        Column('locale', Unicode(7), nullable=True),
        Column('css', UnicodeText(), nullable=True),
        Column('use_norms', Boolean, nullable=True, default=True)
    )
    
    propose = Column('allow_propose', Boolean, default=True)
    propose.create(instance_table)
    u = instance_table.update(values={'allow_propose': True})
    migrate_engine.execute(u)
def upgrade(migrate_engine):
    meta.bind = migrate_engine

    records_table = Table('records', meta, autoload=True)

    # Create the new inherit_ttl column
    inherit_ttl = Column('inherit_ttl', Boolean(), default=True)
    inherit_ttl.create(records_table)

    # Semi-Populate the new inherit_ttl column. We'll need to do a cross-db
    # join from powerdns.records -> powerdns.domains -> designate.domains, so
    # we can't perform the second half here.
    query = records_table.update().values(inherit_ttl=False)
    query = query.where(records_table.c.ttl != None)
    query.execute()

    # If there are records without an explicity configured TTL, we'll need
    # a manual post-migration step.
    query = records_table.select()
    query = query.where(records_table.c.ttl == None)
    c = query.count()

    if c > 0:
        pmq = ('UPDATE powerdns.records JOIN powerdns.domains ON powerdns.reco'
               'rds.domain_id = powerdns.domains.id JOIN designate.domains ON '
               'powerdns.domains.designate_id = designate.domains.id SET power'
               'dns.records.ttl = designate.domains.ttl WHERE powerdns.records'
               '.inherit_ttl = 1;')

        LOG.warning(_LW('**** A manual post-migration step is required ****'))
        LOG.warning(_LW('Please issue this query: %s' % pmq))
def downgrade(migrate_engine):
    meta = MetaData()
    meta.bind = migrate_engine

    instances = Table('instances', meta, autoload=True)

    integer_column = instances.c.instance_type_id
    string_column = Column('instance_type_id_str',
                           String(length=255, convert_unicode=False,
                                  assert_unicode=None, unicode_error=None,
                                  _warn_on_bytestring=False),
                           nullable=True)

    types = {}
    for instance in migrate_engine.execute(instances.select()):
        if instance.instance_type_id is None:
            types[instance.id] = None
        else:
            types[instance.id] = str(instance.instance_type_id)

    string_column.create(instances)
    for instance_id, instance_type_id in types.iteritems():
        update = instances.update().\
                where(instances.c.id == instance_id).\
                values(instance_type_id_str=instance_type_id)
        migrate_engine.execute(update)

    integer_column.alter(name='instance_type_id_int')
    string_column.alter(name='instance_type_id')
    integer_column.drop()
def downgrade(migrate_engine):
    meta = MetaData()
    meta.bind = migrate_engine

    instances = Table('instances', meta, autoload=True)
    volumes = Table('volumes', meta, autoload=True)
    instance_id_column = Column('instance_id', Integer)

    instance_id_column.create(volumes)
    try:
        volumes.update().values(
            instance_id=select(
                [instances.c.id],
                instances.c.uuid == volumes.c.instance_uuid)
                ).execute()
    except Exception:
        instance_id_column.drop()

    fkeys = list(volumes.c.instance_id.foreign_keys)
    if fkeys:
        try:
            fk_name = fkeys[0].constraint.name
            ForeignKeyConstraint(
                columns=[volumes.c.instance_id],
                refcolumns=[instances.c.id],
                name=fk_name).create()

        except Exception:
            LOG.error(_("foreign key could not be created"))
            raise

    volumes.c.instance_uuid.drop()
def upgrade(migrate_engine):
    meta = MetaData()
    meta.bind = migrate_engine
    instance_metadata = Table("instance_metadata", meta, autoload=True)
    instances = Table("instances", meta, autoload=True)
    uuid_column = Column("instance_uuid", String(36))
    uuid_column.create(instance_metadata)

    try:
        instance_metadata.update().values(
            instance_uuid=select([instances.c.uuid], instances.c.id == instance_metadata.c.instance_id)
        ).execute()
    except Exception:
        uuid_column.drop()
        raise

    fkeys = list(instance_metadata.c.instance_id.foreign_keys)
    if fkeys:
        try:
            fkey_name = fkeys[0].constraint.name
            ForeignKeyConstraint(
                columns=[instance_metadata.c.instance_id], refcolumns=[instances.c.id], name=fkey_name
            ).drop()
        except Exception:
            LOG.error(_("foreign key constraint couldn't be removed"))
            raise

    instance_metadata.c.instance_id.drop()
def upgrade(migrate_engine):
    metadata.bind = migrate_engine
    instance_table = Table(
        "instance",
        metadata,
        Column("id", Integer, primary_key=True),
        Column("key", Unicode(20), nullable=False, unique=True),
        Column("label", Unicode(255), nullable=False),
        Column("description", UnicodeText(), nullable=True),
        Column("required_majority", Float, nullable=False),
        Column("activation_delay", Integer, nullable=False),
        Column("create_time", DateTime, default=func.now()),
        Column("access_time", DateTime, default=func.now(), onupdate=func.now()),
        Column("delete_time", DateTime, nullable=True),
        Column("creator_id", Integer, ForeignKey("user.id"), nullable=False),
        Column("default_group_id", Integer, ForeignKey("group.id"), nullable=True),
        Column("allow_adopt", Boolean, default=True),
        Column("allow_delegate", Boolean, default=True),
        Column("allow_propose", Boolean, default=True),
        Column("allow_index", Boolean, default=True),
        Column("hidden", Boolean, default=False),
        Column("locale", Unicode(7), nullable=True),
        Column("css", UnicodeText(), nullable=True),
        Column("frozen", Boolean, default=False),
        Column("milestones", Boolean, default=False),
        Column("use_norms", Boolean, nullable=True, default=True),
        Column("require_selection", Boolean, nullable=True, default=False),
        Column("is_authenticated", Boolean, nullable=True, default=False),
    )

    hide_categories = Column("hide_global_categories", Boolean, nullable=True, default=False)
    hide_categories.create(instance_table)
    u = instance_table.update(values={"hide_global_categories": False})
    migrate_engine.execute(u)
def upgrade(migrate_engine):
    metadata.bind = migrate_engine
    print(__doc__)
    metadata.reflect()
    try:
        if migrate_engine.name == 'mysql':
            # Strip slug index prior to creation so we can do it manually.
            slug_index = None
            for ix in Page_table.indexes:
                if ix.name == 'ix_page_slug':
                    slug_index = ix
            Page_table.indexes.remove(slug_index)
        Page_table.create()
        if migrate_engine.name == 'mysql':
            # Create slug index manually afterward.
            i = Index("ix_page_slug", Page_table.c.slug, mysql_length=200)
            i.create()
    except Exception:
        log.exception("Could not create page table")
    try:
        PageRevision_table.create()
    except Exception:
        log.exception("Could not create page_revision table")

    # Add 1 column to the user table
    User_table = Table("galaxy_user", metadata, autoload=True)
    col = Column('username', String(255), index=True, unique=True, default=False)
    col.create(User_table, index_name='ix_user_username', unique_name='username')
    assert col is User_table.c.username
def upgrade(migrate_engine):
    meta = MetaData()
    meta.bind = migrate_engine

    instances = Table('instances', meta, autoload=True)

    types = {}
    for instance in migrate_engine.execute(instances.select()):
        if instance.instance_type_id is None:
            types[instance.id] = None
            continue
        try:
            types[instance.id] = int(instance.instance_type_id)
        except ValueError:
            LOG.warn("Instance %s did not have instance_type_id "
                         "converted to an integer because its value is %s" %
                          (instance.id, instance.instance_type_id))
            types[instance.id] = None

    integer_column = Column('instance_type_id_int', Integer(), nullable=True)
    string_column = instances.c.instance_type_id

    integer_column.create(instances)
    for instance_id, instance_type_id in types.iteritems():
        update = instances.update().\
                where(instances.c.id == instance_id).\
                values(instance_type_id_int=instance_type_id)
        migrate_engine.execute(update)

    string_column.alter(name='instance_type_id_str')
    integer_column.alter(name='instance_type_id')
    string_column.drop()
def upgrade(migrate_engine):
    meta = MetaData()
    meta.bind = migrate_engine
    dialect = migrate_engine.url.get_dialect().name
    instance_actions = Table('instance_actions', meta, autoload=True)
    instances = Table('instances', meta, autoload=True)
    uuid_column = Column('instance_uuid', String(36))
    uuid_column.create(instance_actions)

    try:
        instance_actions.update().values(
            instance_uuid=select(
                [instances.c.uuid],
                instances.c.id == instance_actions.c.instance_id)
        ).execute()
    except Exception:
        uuid_column.drop()
        raise

    if not dialect.startswith('sqlite'):
        fkeys = list(instance_actions.c.instance_id.foreign_keys)
        if fkeys:
            try:
                fkey_name = fkeys[0].constraint.name
                ForeignKeyConstraint(columns=[instance_actions.c.instance_id],
                                     refcolumns=[instances.c.id],
                                     name=fkey_name).drop()
            except Exception:
                LOG.error(_("foreign key constraint couldn't be removed"))
                raise

    instance_actions.c.instance_id.drop()
def upgrade(migrate_engine):
    meta.bind = migrate_engine

    records_table = Table('records', meta, autoload=True)

    recordset_id = Column('designate_recordset_id', UUID())
    recordset_id.create(records_table)
def upgrade(migrate_engine):
    meta = MetaData()
    meta.bind = migrate_engine
    dialect = migrate_engine.url.get_dialect().name
    block_device_mapping = Table('block_device_mapping', meta, autoload=True)
    instances = Table('instances', meta, autoload=True)
    uuid_column = Column('instance_uuid', String(36))
    uuid_column.create(block_device_mapping)

    try:
        block_device_mapping.update().values(
            instance_uuid=select(
                [instances.c.uuid],
                instances.c.id == block_device_mapping.c.instance_id)
        ).execute()
    except Exception:
        uuid_column.drop()
        raise

    fkeys = list(block_device_mapping.c.instance_id.foreign_keys)
    if fkeys:
        try:
            fkey_name = fkeys[0].constraint.name
            ForeignKeyConstraint(
                columns=[block_device_mapping.c.instance_id],
                refcolumns=[instances.c.id],
                name=fkey_name).drop()
        except Exception:
            LOG.error(_("foreign key constraint couldn't be removed"))
            raise

    block_device_mapping.c.instance_id.drop()
def downgrade(migrate_engine):
    metadata.bind = migrate_engine
    metadata.reflect()
    # Drop missing_test_components and tool_test_results from the repository_metadata table and add tool_test_errors to the repository_metadata table.
    RepositoryMetadata_table = Table("repository_metadata", metadata, autoload=True)

    # Drop the missing_test_components column.
    try:
        RepositoryMetadata_table.c.missing_test_components.drop()
    except Exception:
        log.exception("Dropping column missing_test_components from the repository_metadata table failed.")

    # Drop the tool_test_results column.
    try:
        RepositoryMetadata_table.c.tool_test_results.drop()
    except Exception:
        log.exception("Dropping column tool_test_results from the repository_metadata table failed.")

    # Create the tool_test_errors column.
    c = Column("tool_test_errors", JSONType, nullable=True)
    try:
        c.create(RepositoryMetadata_table)
        assert c is RepositoryMetadata_table.c.tool_test_errors
    except Exception:
        log.exception("Adding tool_test_errors column to the repository_metadata table failed.")
def downgrade(migrate_engine):
    meta = MetaData()
    meta.bind = migrate_engine

    volumes = Table('volumes', meta, autoload=True)
    attach_string = Column('attachtime_string', String(255))
    attach_string.create(volumes)

    old_attachtime = volumes.c.attach_time

    try:
        volumes_list = list(volumes.select().execute())
        for v in volumes_list:
            attach_time = select([volumes.c.attach_time],
                volumes.c.id == v['id'])
            volumes.update().\
                where(volumes.c.id == v['id']).\
                values(attach_string=attach_time).execute()
    except Exception:
        attach_datetime.drop()
        raise

    old_attachtime.alter(name='attach_time_old')
    attach_string.alter(name='attach_time')
    old_attachtime.drop()
def upgrade(migrate_engine):
    metadata.bind = migrate_engine

    show_norms_navigation = Column('show_norms_navigation',
                                   Boolean,
                                   default=True)
    show_norms_navigation.create(instance_table)
def upgrade(migrate_engine):
    metadata.bind = migrate_engine
    print(__doc__)
    metadata.reflect()
    ToolShedRepository_table = Table("tool_shed_repository", metadata, autoload=True)
    col = Column("installed_changeset_revision", TrimmedString(255))
    try:
        col.create(ToolShedRepository_table)
        assert col is ToolShedRepository_table.c.installed_changeset_revision
    except Exception:
        log.exception("Adding installed_changeset_revision column to the tool_shed_repository table failed.")
    # Update each row by setting the value of installed_changeset_revison to be the value of changeset_revision.
    # This will be problematic if the value of changeset_revision was updated to something other than the value
    # that it was when the repository was installed (because the install path determined in real time will attempt to
    # find the repository using the updated changeset_revison instead of the required installed_changeset_revision),
    # but at the time this script was written, this scenario is extremely unlikely.
    cmd = "SELECT id AS id, " \
        + "installed_changeset_revision AS installed_changeset_revision, " \
        + "changeset_revision AS changeset_revision " \
        + "FROM tool_shed_repository;"
    tool_shed_repositories = migrate_engine.execute(cmd).fetchall()
    update_count = 0
    for row in tool_shed_repositories:
        cmd = "UPDATE tool_shed_repository " \
            + "SET installed_changeset_revision = '%s' " % row.changeset_revision \
            + "WHERE changeset_revision = '%s';" % row.changeset_revision
        migrate_engine.execute(cmd)
        update_count += 1
    print("Updated the installed_changeset_revision column for ", update_count, " rows in the tool_shed_repository table.  ")
Exemple #23
0
def wants_notifications(db):
    """Add a wants_notifications field to User model"""
    metadata = MetaData(bind=db.bind)
    user_table = inspect_table(metadata, "core__users")
    col = Column('wants_notifications', Boolean, default=True)
    col.create(user_table)
    db.commit()
Exemple #24
0
def upgrade(migrate_engine):
    metadata.bind = migrate_engine
    message_table.create()
    message_recipient_table.create()

    email_messages = Column('email_messages', Boolean, default=True)
    email_messages.create(user_table)
 def check_create_fk(self, from_table_id, to_table_id, ignoreexisting=False):
     from_type = setobject_type_registry.lookup_by_table(from_table_id)        
     to_type = setobject_type_registry.lookup_by_table(to_table_id)        
     pk = to_type.get_primary_key_attr_name()
     # Now add foreign key if not existant yet
     if not field_exists(from_table_id, self.foreignkeycol):
         col = Column(
             self.foreignkeycol,
             getattr(to_type.get_table_class().c, pk).type,
             ForeignKey(to_table_id + "." + pk),
         )
         col.create(from_type.get_table_class())
        
         # The foreign key column has been newly created
         Session().flush()
         # deferred import
         from p2.datashackle.core.models.mapping import map_tables
         map_tables(exclude_sys_tables=True)
     else:
         # it exists, check whether it is what we want or something else
         fkset = getattr(from_type.get_table_class().c, self.foreignkeycol).foreign_keys
         if len(fkset) > 0:
             for fk in fkset:
                 if str(fk.column) == to_table_id + "." + pk \
                         and ignoreexisting == True:
                     return # this is what we want! fine.
             raise UserException("A relation with a similar Data Field Name but targetting the table '" + \
                 str(fk.column).split('.',1)[0] + "' already exists. Please use another Data Field Name.")
         raise UserException("The column '" + self.foreignkeycol + "' in the table '" + to_table_id + \
             "' does already exist. Please choose a unique Data Field Name that doesn't collide with existing data columns.")
Exemple #26
0
def upgrade(migrate_engine):
    metadata.bind = migrate_engine
    display_migration_details()
    # Load existing tables
    metadata.reflect()
    try:
        User_table = Table( "galaxy_user", metadata, autoload=True )
    except NoSuchTableError:
        User_table = None
        log.debug( "Failed loading table galaxy_user" )
    if User_table is not None:
        try:
            col = Column( "form_values_id", Integer, index=True )
            col.create( User_table, index_name='ix_user_form_values_id')
            assert col is User_table.c.form_values_id
        except Exception, e:
            log.debug( "Adding column 'form_values_id' to galaxy_user table failed: %s" % ( str( e ) ) )
        try:
            FormValues_table = Table( "form_values", metadata, autoload=True )
        except NoSuchTableError:
            FormValues_table = None
            log.debug( "Failed loading table form_values" )
        if migrate_engine.name != 'sqlite':
            # Add 1 foreign key constraint to the form_values table
            if User_table is not None and FormValues_table is not None:
                try:
                    cons = ForeignKeyConstraint( [User_table.c.form_values_id],
                                                 [FormValues_table.c.id],
                                                 name='user_form_values_id_fk' )
                    # Create the constraint
                    cons.create()
                except Exception, e:
                    log.debug( "Adding foreign key constraint 'user_form_values_id_fk' to table 'galaxy_user' failed: %s" % ( str( e ) ) )
def upgrade(migrate_engine):
    print(__doc__)
    metadata.bind = migrate_engine
    metadata.reflect()
    # Initialize.
    if migrate_engine.name == 'mysql' or migrate_engine.name == 'sqlite':
        default_false = "0"
    elif migrate_engine.name in ['postgresql', 'postgres']:
        default_false = "false"

    try:
        RepositoryMetadata_table = Table("repository_metadata", metadata, autoload=True)
    except NoSuchTableError:
        RepositoryMetadata_table = None
        log.debug("Failed loading table repository_metadata.")

    if RepositoryMetadata_table is not None:
        # Create the test_install_error column.
        c = Column("test_install_error", Boolean, default=False, index=True)
        try:
            c.create(RepositoryMetadata_table, index_name="ix_repository_metadata_ttie")
            assert c is RepositoryMetadata_table.c.test_install_error
            migrate_engine.execute("UPDATE repository_metadata SET test_install_error=%s" % default_false)
        except Exception:
            log.exception("Adding test_install_error column to the repository_metadata table failed.")

    # Create skip_tool_test table.
    try:
        SkipToolTest_table.create()
    except Exception:
        log.exception("Creating the skip_tool_test table failed.")
def upgrade(migrate_engine):
    print __doc__
    metadata.bind = migrate_engine
    metadata.reflect()
    # Initialize.
    if migrate_engine.name == 'mysql' or migrate_engine.name == 'sqlite':
        default_false = "0"
    elif migrate_engine.name in ['postgresql', 'postgres']:
        default_false = "false"

    try:
        RepositoryMetadata_table = Table( "repository_metadata", metadata, autoload=True )
    except NoSuchTableError:
        RepositoryMetadata_table = None
        log.debug( "Failed loading table repository_metadata." )

    if RepositoryMetadata_table is not None:
        # Drop the tool_test_errors column from the repository_metadata table as it is poorly named.  It will be replaced with the new
        # tool_test_results column.
        try:
            col = RepositoryMetadata_table.c.tool_test_errors
            col.drop()
        except Exception, e:
            log.debug( "Dropping column 'tool_test_errors' from repository_metadata table failed: %s" % ( str( e ) ) )

        # Create the tool_test_results column to replace the ill-named tool_test_errors column just dropped above.
        c = Column( "tool_test_results", JSONType, nullable=True )
        try:
            c.create( RepositoryMetadata_table )
            assert c is RepositoryMetadata_table.c.tool_test_results
        except Exception, e:
            print "Adding tool_test_results column to the repository_metadata table failed: %s" % str( e )
def upgrade(migrate_engine):
    metadata.bind = migrate_engine
    print(__doc__)
    metadata.reflect()
    try:
        Request_table = Table("request", metadata, autoload=True)
    except NoSuchTableError:
        Request_table = None
        log.debug("Failed loading table 'request'")

    if Request_table is not None:
        # create the column again as JSONType
        try:
            col = Column("notification", JSONType())
            col.create(Request_table)
            assert col is Request_table.c.notification
        except Exception:
            log.exception("Creating column 'notification' in the 'request' table failed.")

        cmd = "SELECT id, user_id, notify FROM request"
        result = migrate_engine.execute(cmd)
        for r in result:
            id = int(r[0])
            notify_new = dict(email=[], sample_states=[], body='', subject='')
            cmd = "UPDATE request SET notification='%s' WHERE id=%i" % (dumps(notify_new), id)
            migrate_engine.execute(cmd)

        # remove the 'notify' column for non-sqlite databases.
        if migrate_engine.name != 'sqlite':
            try:
                Request_table.c.notify.drop()
            except Exception:
                log.exception("Deleting column 'notify' from the 'request' table failed.")
def upgrade(migrate_engine):
    meta = MetaData(bind=migrate_engine)

    table = Table('user', meta, autoload=True)
    col = Column('optional_attributes',
                 MutationDict.as_mutable(JSONEncodedDict))
    col.create(table)
class Post(Base):
    __tablename__ = 'post'

    id = Column(Integer, primary_key=True, autoincrement=True)
    tags = Column(ARRAY(String(10)))
Exemple #32
0
class Artist(BaseModel):
    __tablename__ = 'artist'
    name = Column(String(256))
    description = Column(String(256))
    albums = relationship('Album', backref='artist')
    genre_id = Column(Integer, ForeignKey('genre.id'))
Exemple #33
0
class DummyModel2(Entity):
    list_attr = Column(JSONList())
    dict_attr = Column(JSONDict())
    uuid = Column(UUID())
Exemple #34
0
from sqlalchemy import Integer, Column, Table, ForeignKey, Boolean, DateTime, Text, String, Enum
from sqlalchemy.orm import relationship, backref

app = AppFactory(DevelopmentConfig).get_app(__name__)

root = DevelopmentConfig.ROOT_PATH


class Super(super):
    def __getattr__(self, attr):
        return self.__self__.__getattr__(attr)


pages_macros = Table('pages_macros',
                     BaseMixin.metadata,
                     Column('page_id', Integer, ForeignKey('pages.id')),
                     Column('macro_id', Integer, ForeignKey('macros.id')),
                     extend_existing=True)

pages_template_blocks = Table('pages_template_blocks',
                              BaseMixin.metadata,
                              Column('page_id', Integer,
                                     ForeignKey('pages.id')),
                              Column('template_block_id', Integer,
                                     ForeignKey('template_blocks.id')),
                              extend_existing=True)


class Template(BaseMixin):

    _filename = None
Exemple #35
0
class TrackerModel(Base):
    __tablename__ = 'tracker'
    id = Column(Integer, primary_key=True)
    track = Column(Boolean, default=True, server_default=expression.true())
Exemple #36
0
class Patient(Base):
    """
    SQLAlchemy ORM class for fictional patients.
    """
    __tablename__ = 'patient'
    __table_args__ = TABLE_KWARGS

    patient_id = Column(Integer, primary_key=True, autoincrement=False)
    forename = Column(String(50))
    surname = Column(String(50))
    dob = Column(Date)
    nullfield = Column(Integer)
    nhsnum = Column(BigInteger)
    phone = Column(String(50))
    postcode = Column(String(50))
    optout = Column(Boolean, default=False)
    related_patient_id = Column(Integer)
    colour = Column(Enum(EnumColours), nullable=True)  # new in v0.18.41
Exemple #37
0
class Page(BaseMixin):
    _use_base_template = None

    name = Column(String(255))
    description = Column(Text)
    template_id = Column(Integer, ForeignKey('templates.id'))
    template = relationship(Template)
    slug = Column(String(255))
    title = Column(String(255))
    add_to_nav = Column(Boolean, default=False)
    add_left_sidebar = Column(Boolean, default=False)
    add_right_sidebar = Column(Boolean, default=False)
    date_added = Column(DateTime, default=datetime.datetime)
    visible = Column(Boolean, default=False)
    meta_title = Column(String(255))
    added_by = relationship('flask_cms.auth.models.User')
    user_id = Column(Integer, ForeignKey('users.id'))
    short_url = Column(String(255))
    macros = relationship(Macro, secondary='pages_macros', lazy='dynamic')
    _blocks = relationship(TemplateBlock,
                           secondary='pages_template_blocks',
                           lazy='dynamic')
    content = Column(Text)

    def __repr__(self):
        if self.name is None:
            rtn = '<Page: Unnamed | {}'.format(self.line_count)
        else:
            rtn = '<Page: {} | {} lines'.format(self.name, self.line_count)
        return rtn

    @property
    def use_base_template(self):
        return bool(
            self.template
        ) if self._use_base_template is None else self._use_base_template

    @use_base_template.setter
    def use_base_template(self, val):
        self._use_base_template = val

    def _get_page_url(self):
        return url_for('page.pages', slug=self.slug)

    @staticmethod
    def _get_create_url():
        return url_for('admin.add_page')

    @classmethod
    def get_by_slug(cls, slug):
        return cls.query.filter(cls.slug == slug).first()

    def _get_absolute_url(self):
        return url_for('admin.page_view', slug=self.slug)

    def _get_edit_url(self):
        return url_for('admin.edit_page', item_id=int(self.id))

    def _get_edit_content_url(self):
        return url_for('admin.edit_page_content', item_id=int(self.id))

    @property
    def line_count(self):
        try:
            rtn = len(self.content.split('\n'))
        except:
            rtn = 0
        return rtn

    @property
    def template_name(self):
        return self.template.name or ''

    @property
    def block_count(self):
        return self._template.blocks.count()

    @property
    def blocks(self):
        return self._template.blocks.keys()

    def get_block(self, block):
        return self._template.blocks[block]
        return str(self._blocks.get_by_name(block))

    @property
    def _template(self):
        class template(object):
            def __init__(self):
                self.blocks = {
                    'blocka': '',
                    'blockb': '',
                    'blockc': 'x',
                    'blockd': ''
                }

        return template()
Exemple #38
0
class Template(BaseMixin):

    _filename = None

    name = Column(String(255), nullable=False, unique=True)
    description = Column(Text)
    body = Column(Text)
    base_template = Column(String(255))

    def __init__(self, *args, **kwargs):
        self._raw_template = ''
        self._head = ''
        base = kwargs.pop('base_template', None)
        super(Template, self).__init__(*args, **kwargs)
        if base is None:
            self.is_base_template = True
        else:
            self.is_base_template = False
            self._add_to_head(self._create_extend(base))
        if self.body:
            self._set_template()

    def _add_to_head(self, itm):
        self._head = self._head + '\n' + itm

    def _create_extend(self, parent):
        return '{% extends "%s" %}' % parent

    def _set_template(self):
        from jinja2 import Template
        self._raw_template = Template(self._head + self.body[:])

    @property
    def filename(self):
        return self._filename if self._filename is not None else "{}.html".format(
            self.name)

    @property
    def block_count(self):
        return len(Template(self._head + self.body[:]).blocks)

    @property
    def blocks(self):
        return self._raw_template.blocks.keys()

    def set_body(self, data):
        self.body = data
        self._set_template()

    @property
    def body_body(self):
        return self.body

    @property
    def content(self):
        return self.body[:] if self.body is not None else ""

    def _get_edit_url(self):
        return url_for('admin.edit_template', item_id=int(self.id))

    def _get_absolute_url(self):
        return url_for('admin.template_view', name=self.name)

    def __repr_(self):
        if self.name is None:
            rtn = '<Template: Unnamed | {} lines'.format(self.line_count)
        else:
            rtn = '<Template: {} | {} lines'.format(self.name, self.line_count)
        return rtn

    def __str__(self):
        return self.body or ''

    @staticmethod
    def _get_create_url():
        return url_for('admin.add_template')

    @property
    def line_count(self):
        try:
            rtn = len(self.body.split('\n'))
        except:
            rtn = 0
        return rtn

    def get_block_count(self):
        return len(self._raw_template.blocks.keys())

    @staticmethod
    def get_base_templates():
        return []

    @property
    def filename(self):
        return "{}.html".format(self.name if self.name else self.id)
Exemple #39
0
class Macro(BaseMixin):
    MACRO_FILE = os.path.join(os.path.abspath(root), 'macros.html')

    name = Column(String(255), nullable=False)
    content = Column(Text)
    _args = Column(Text)

    def __init__(self, name='', content='', arguments=''):
        self.name = name
        self.content = content
        self.args = arguments

    @hybrid_property
    def args(self):
        return pickle.loads(self._args)

    @args.setter
    def args(self, args):
        if args:
            self._args = pickle.dumps(args)

    @property
    def head(self):
        start = '{% macro '
        mid = '%s' % self.name
        end = '('
        if self._args:
            arg_amount = len(self.args)
            for k, v in self.args:
                end += '%s=%s' % (k, v)
                if k != self.args[-1][0]:
                    end += ','
        end += ') %}'
        return start + mid + end

    @property
    def foot(self):
        return '{% endmacro %}'

    def __str__(self):
        return self.head +'\n'+\
               self.content +'\n'+\
               self.foot + '\n'

    @property
    def import_statement(self):
        return self._generate_import()

    def _generate_import(self):
        start = '{% from "'
        end = ' %}'
        mid = '%s" import %s' % (self.MACRO_FILE, self.name)
        return start + mid + end

    @staticmethod
    def _generate_macro_file(names=None):
        res = ''
        if names is None:
            macros = Macro.query.all()
        else:
            macros = [
                Macro.query.filter(Macro.name == x).all()[0] for x in names
            ]
        for macro in macros:
            res += str(macro)
            res += '\n'
        try:
            with open(Macro.MACRO_FILE, 'w') as fp:
                fp.write(res)
        except IOError, e:
            return False
        return True
Exemple #40
0
class Block(BaseMixin):

    name = Column(String(255))
    content = Column(Text)

    def __init__(self, name='', content=''):
        self.name = name
        self.content = content

    @property
    def head(self):
        start = '{% block '
        mid = self.name
        end = ' %}'
        return start + mid + end

    @property
    def foot(self):
        start = '{% endblock '
        mid = self.name
        end = ' %}'
        return start + mid + end

    def set_content(self, data):
        self.content = data

    def __call__(self):
        return self.render()

    def __str__(self):
        return self.head + '\n' + self.content + '\n' + self.foot

    def render(self):
        s = self.content.split('\n')
        return self.head + '<br />'.join(map(str, s)) + self.foot

    def __repr__(self):
        if self.name is None:
            rtn = '<Block: Unnamed | {} lines'.format(self.line_count)
        else:
            rtn = '<block: {} | {} lines'.format(self.name, self.line_count)
        return rtn

    @staticmethod
    def _get_create_url():
        return url_for('admin.add_block')

    def _get_edit_content_url(self):
        return url_for('admin.edit_block_content', item_id=int(self.id))

    def _get_edit_url(self):
        return url_for('admin.edit_block', item_id=int(self.id))

    def _get_absolute_url(self):
        return url_for('admin.block_view', name=self.name)

    @property
    def line_count(self):
        try:
            rtn = len(self.content.split('\n'))
        except:
            rtn = 0
        return rtn
Exemple #41
0
class Pet(Base):
    __tablename__ = 'pet'
    id = Column(Integer, primary_key=True)
    _kind = Column(String(50), nullable=False)
    _place = Column(String(100))
    _history = Column(String(1000))
    _owner_id = Column(Integer, ForeignKey('owner.id'), nullable=False)
    _owner = relationship('Owner', backref=backref('pets', lazy=True))
    _cuteness_level = Column(Integer)
    _hungry_level = Column(Integer)
    _color = Column(String(100))
    _gender = Column(String(40))
    _breed = Column(String(100))
    _weight = Column(Integer)
    _height = Column(Integer)
    _name = Column(String(100))

    def __init__(self,
                 kind="unknown",
                 place="unknown",
                 cuteness_level=10,
                 hungry_level=10,
                 # owner="unknown",
                 color="unknown",
                 gender="unknown",
                 breed="unknown",
                 weight=1,
                 height=1,
                 name="unknown"):
        """Constructor for Pet class for default arguments

        :_kind: TODO
        :_gender: TODO
        :_cuteness_level: TODO
        :_hungry_level: TODO
        :_owner: TODO
        :_color: TODO
        :_gender: TODO
        :_breed: TODO
        :_weight: TODO
        :_height: TODO
        :_name: TODO

        """
        self._kind = kind
        self._cuteness_level = cuteness_level
        self._hungry_level = hungry_level
        # self._owner = owner
        self._color = color
        self._gender = gender
        self._breed = breed
        self._weight = weight
        self._height = height
        self._name = name
        self.update_place(place)

    def update_place(self, place):
        self._place = place
        try:
            places = defaultdict(list, loads(self._history))
        except TypeError:
            places = defaultdict(list)
        places[place].append(datetime.utcnow().timestamp())
        self._history = dumps(places)

    def __repr__(self):
        return "Pet({0._kind!r}, {0._place!r}, {0._cuteness_level!r}, {0._hungry_level!r}, {0._color!r}, {0._gender!r}, {0._breed!r}, {0._weight!r}, {0._height!r}, {0._name!r})".format(
            self)
Exemple #42
0
class Classification(db.Model):
    __tablename__ = 'Classification'

    id = Column(Integer, primary_key=True)
    UNCLASSIFIED = Column(String)
Exemple #43
0
class Domains(db.Model):
    __tablename__ = 'domains'

    id = Column(Integer, primary_key=True)
    domain = Column(String)
    last_run = Column(DateTime)
    scan_spf = Column(Boolean)
    scan_dmarc = Column(Boolean)
    scan_dmarc_psl = Column(Boolean)
    scan_mx = Column(Boolean)
    scan_dkim = Column(Boolean)
    scan_https = Column(Boolean)
    scan_ssl = Column(Boolean)
    dmarc_phase = Column(Integer)
    organization_id = Column(Integer, ForeignKey('organizations.id'))
    organization = relationship("Organizations", back_populates="domains", cascade="all, delete")
    scans = relationship("Scans", back_populates="domain", cascade="all, delete")
Exemple #44
0
class IncidentType(Base):
    id = Column(Integer, primary_key=True)
    name = Column(String, unique=True)
    slug = Column(String)
    description = Column(String)
    exclude_from_metrics = Column(Boolean, default=False)
    default = Column(Boolean, default=False)
    visibility = Column(String, default=Visibility.open.value)
    plugin_metadata = Column(JSON, default=[])

    template_document_id = Column(Integer, ForeignKey("document.id"))
    template_document = relationship("Document")

    commander_service_id = Column(Integer, ForeignKey("service.id"))
    commander_service = relationship("Service", foreign_keys=[commander_service_id])

    liaison_service_id = Column(Integer, ForeignKey("service.id"))
    liaison_service = relationship("Service", foreign_keys=[liaison_service_id])

    search_vector = Column(TSVectorType("name", "description"))

    @hybrid_method
    def get_meta(self, slug):
        if not self.plugin_metadata:
            return

        for m in self.plugin_metadata:
            if m["slug"] == slug:
                return m
Exemple #45
0
class Ssl_scans(db.Model):
    __tablename__ = 'ssl_scans'

    id = Column(Integer, ForeignKey('scans.id'), primary_key=True)
    ssl_scan = Column(JSONB)
    ssl_flagged_scan = relationship("Scans", back_populates="ssl", cascade="all, delete")
Exemple #46
0
class Store(Base):
	__tablename__ = 'store'
	id = Column(Integer, primary_key=True)
	name = Column(String(150), nullable=False)
	user_id = Column(Integer, ForeignKey('user.id'))
Exemple #47
0
class Flat(BASE):
    """
    SQLAlchemy ORM model to store a flat.
    """
    __tablename__ = "flats"
    __searchable__ = ["title", "text", "station", "location", "details"]

    # Weboob data
    id = Column(String, primary_key=True)
    area = Column(Float)
    bedrooms = Column(Float)
    cost = Column(Float)
    currency = Column(String)
    utilities = Column(Enum(FlatUtilities), default=FlatUtilities.unknown)
    date = Column(DateTime)
    details = Column(MagicJSON)
    location = Column(String)
    phone = Column(String)
    photos = Column(MagicJSON)
    rooms = Column(Float)
    station = Column(String)
    text = Column(Text)
    title = Column(String)
    urls = Column(MagicJSON)
    merged_ids = Column(MagicJSON)
    notes = Column(Text)
    notation = Column(SmallInteger, default=0)

    # Flatisfy data
    # TODO: Should be in another table with relationships
    flatisfy_stations = Column(MagicJSON)
    flatisfy_postal_code = Column(String)
    flatisfy_time_to = Column(MagicJSON)
    flatisfy_constraint = Column(String)

    # Status
    status = Column(Enum(FlatStatus), default=FlatStatus.new)

    @staticmethod
    def from_dict(flat_dict):
        """
        Create a Flat object from a flat dict as manipulated by the filtering
        pass.
        """
        # Handle flatisfy metadata
        flat_dict = flat_dict.copy()
        if "flatisfy" in flat_dict:
            flat_dict["flatisfy_stations"] = (flat_dict["flatisfy"].get(
                "matched_stations", []))
            flat_dict["flatisfy_postal_code"] = (flat_dict["flatisfy"].get(
                "postal_code", None))
            flat_dict["flatisfy_time_to"] = (flat_dict["flatisfy"].get(
                "time_to", {}))
            flat_dict["flatisfy_constraint"] = (flat_dict["flatisfy"].get(
                "constraint", "default"))
            del flat_dict["flatisfy"]

        # Handle utilities field
        if not isinstance(flat_dict["utilities"], FlatUtilities):
            if flat_dict["utilities"] == "C.C.":
                flat_dict["utilities"] = FlatUtilities.included
            elif flat_dict["utilities"] == "H.C.":
                flat_dict["utilities"] = FlatUtilities.excluded
            else:
                flat_dict["utilities"] = FlatUtilities.unknown

        # Handle status field
        flat_status = flat_dict.get("status", "new")
        if not isinstance(flat_status, FlatStatus):
            try:
                flat_dict["status"] = getattr(FlatStatus, flat_status)
            except AttributeError:
                if "status" in flat_dict:
                    del flat_dict["status"]
                LOGGER.warn("Unkown flat status %s, ignoring it.", flat_status)

        # Handle date field
        flat_dict["date"] = arrow.get(flat_dict["date"]).naive

        flat_object = Flat()
        flat_object.__dict__.update(flat_dict)
        return flat_object

    def __repr__(self):
        return "<Flat(id=%s, urls=%s)>" % (self.id, self.urls)

    def json_api_repr(self):
        """
        Return a dict representation of this flat object that is JSON
        serializable.
        """
        flat_repr = {
            k: v
            for k, v in self.__dict__.items() if not k.startswith("_")
        }
        if isinstance(flat_repr["status"], FlatStatus):
            flat_repr["status"] = flat_repr["status"].name
        if isinstance(flat_repr["utilities"], FlatUtilities):
            flat_repr["utilities"] = flat_repr["utilities"].name

        return flat_repr
Exemple #48
0
class Ciphers(db.Model):
    __tablename__ = 'ciphers'

    id = Column(Integer, primary_key=True)
    cipher_type = Column(String)
Exemple #49
0
from datetime import datetime

from sqlalchemy.orm import relationship, backref
from sqlalchemy import Column, Integer, String, Table, ForeignKey, Boolean

from modules.core.source import Base

# what groups does user belongs to
user_group_association = Table(
    'schedule_user_group_association', Base.metadata,
    Column('user', Integer, ForeignKey('schedule_users.id')),
    Column('group', Integer, ForeignKey('schedule_groups.name')))


class User(Base):
    __tablename__ = "schedule_users"

    id = Column(Integer, primary_key=True)
    alias = Column(String)
    is_configured = Column(Boolean)  # chosen groups are saved
    groups = relationship("Group", secondary=user_group_association)

    def __init__(self, id_, alias_):
        self.id = id_
        self.alias = alias_

    def __repr__(self):
        return f"User({self.id}, {self.alias})"


class Group(Base):
Exemple #50
0
class Permission(Base):
    """A class to hold permissions.

    Permissions in Stalker defines what one can do or do not. A Permission
    instance is composed by three attributes; access, action and class_name.

    Permissions for all the classes in SOM are generally created by Stalker
    when initializing the database.

    If you created any custom classes to extend SOM you are also responsible to
    create the Permissions for it by calling :meth:`stalker.db.register` and
    passing your class to it. See the :mod:`stalker.db` documentation for
    details.

    :param str access: An Enum value which can have the one of the values of
      ``Allow`` or ``Deny``.

    :param str action: An Enum value from the list ['Create', 'Read', 'Update',
      'Delete', 'List']. Can not be None. The list can be changed from
      stalker.config.Config.default_actions.

    :param str class_name: The name of the class that this action is applied
      to. Can not be None or an empty string.

    Example: Let say that you want to create a Permission specifying a Group of
    Users are allowed to create Projects::

      from stalker import db
      from stalker import db
      from stalker.models.auth import User, Group, Permission

      # first setup the db with the default database
      #
      # stalker.db.init() will create all the Actions possible with the
      # SOM classes automatically
      #
      # What is left to you is to create the permissions
      db.setup()

      user1 = User(
          name='Test User',
          login='******',
          password='******',
          email='*****@*****.**'
      )
      user2 = User(
          name='Test User',
          login='******',
          password='******',
          email='*****@*****.**'
      )

      group1 = Group(name='users')
      group1.users = [user1, user2]

      # get the permissions for the Project class
      project_permissions = Permission.query\
          .filter(Permission.access='Allow')\
          .filter(Permission.action='Create')\
          .filter(Permission.class_name='Project')\
          .first()

      # now we have the permission specifying the allowance of creating a
      # Project

      # to make group1 users able to create a Project we simply add this
      # Permission to the groups permission attribute
      group1.permissions.append(permission)

      # and persist this information in the database
      DBSession.add(group)
      DBSession.commit()
    """
    __tablename__ = 'Permissions'
    __table_args__ = (
        UniqueConstraint('access', 'action', 'class_name'),
        {"extend_existing": True}
    )

    id = Column(Integer, primary_key=True)
    _access = Column('access', Enum('Allow', 'Deny', name='AccessNames'))
    _action = Column('action',
                     Enum(*defaults.actions, name='AuthenticationActions'))
    _class_name = Column('class_name', String(32))

    def __init__(self, access, action, class_name):
        self._access = self._validate_access(access)
        self._action = self._validate_action(action)
        self._class_name = self._validate_class_name(class_name)

    def _validate_access(self, access):
        """validates the given access value
        """
        from stalker import __string_types__
        if not isinstance(access, __string_types__):
            raise TypeError(
                '%s.access should be an instance of str not %s' % (
                    self.__class__.__name__,
                    access.__class__.__name__
                )
            )

        if access not in ['Allow', 'Deny']:
            raise ValueError(
                '%s.access should be "Allow" or "Deny" not %s' %
                (self.__class__.__name__, access)
            )

        return access

    def _access_getter(self):
        """returns the _access value
        """
        return self._access

    access = synonym('_access', descriptor=property(_access_getter))

    def _validate_class_name(self, class_name):
        """validates the given class_name value
        """
        from stalker import __string_types__
        if not isinstance(class_name, __string_types__):
            raise TypeError(
                '%s.class_name should be an instance of str not %s' %
                (self.__class__.__name__, class_name.__class__.__name__)
            )

        return class_name

    def _class_name_getter(self):
        """returns the _class_name attribute value
        """
        return self._class_name

    class_name = synonym(
        '_class_name',
        descriptor=property(_class_name_getter)
    )

    def _validate_action(self, action):
        """validates the given action value
        """
        from stalker import __string_types__
        if not isinstance(action, __string_types__):
            raise TypeError(
                '%s.action should be an instance of str not %s' %
                (self.__class__.__name__, action.__class__.__name__)
            )

        if action not in defaults.actions:
            raise ValueError(
                "%s.action should be one of the values of %s not '%s'" %
                (self.__class__.__name__, defaults.actions, action)
            )

        return action

    def _action_getter(self):
        """returns the _action value
        """
        return self._action

    action = synonym('_action', descriptor=property(_action_getter))

    def __eq__(self, other):
        """the equality of two Permissions
        """
        return isinstance(other, Permission) \
            and other.access == self.access \
            and other.action == self.action \
            and other.class_name == self.class_name
Exemple #51
0
from dataclasses import dataclass

from sqlalchemy import Table, Column, Integer, String, ForeignKey, DateTime
from sqlalchemy.orm import relationship
from typing import List

from . import Base

association_table = Table('works_cvs', Base.metadata,
                          Column('work_uid', String(10),
                                 ForeignKey('works.uid')),
                          Column('cv_id', Integer, ForeignKey('cvs.id'))
                          )


@dataclass
class Record(Base):
    __tablename__ = "records"
    id = Column(Integer, primary_key=True)
    uid = Column(String(10), ForeignKey('works.uid'))
    work = relationship("Work", back_populates="records")
    timestamp:DateTime = Column(DateTime)
    dl_count:int = Column(Integer)
    wishlist_count:int = Column(Integer)


@dataclass
class CV(Base):
    __tablename__ = 'cvs'
    id = Column(Integer, primary_key=True)
    name:str = Column(String(50))
Exemple #52
0
class Lesson(Base):
    __tablename__ = "schedule_lessons"

    id = Column(Integer, primary_key=True)
    group = Column(String, ForeignKey('schedule_groups.name'))
    subject = Column(String)
    teacher = Column(String)
    day = Column(Integer)
    start = Column(String)
    end = Column(String)
    room = Column(Integer)

    def __init__(self, group, subject, teacher, day, start, end, room):
        self.group = group
        self.subject = subject
        self.teacher = teacher
        self.day = day
        self.start = start
        self.end = end
        self.room = room

    def __repr__(self):
        return f"Lesson({self.subject}, {self.start})"

    @property
    def start_struct(self):
        """
        Converts start time from string to time object
        :return: datetime
        """
        return datetime.now().replace(hour=int(self.start[:2]),
                                      minute=int(self.start[3:]))

    @property
    def end_struct(self):
        """
        Converts end time from string to time object
        :return: datetime
        """
        return datetime.now().replace(hour=int(self.end[:2]),
                                      minute=int(self.end[3:]))

    @property
    def minutes_until_start(self):
        """
        Total number of minutes until lesson begins

        :return: int
        """
        seconds_left = (self.start_struct - datetime.now()).total_seconds()
        return round(seconds_left / 60)

    @property
    def minutes_until_end(self):
        """
        Total number of minutes until lesson ends

        :return: int
        """
        seconds_left = (self.end_struct - datetime.now()).total_seconds()
        return round(seconds_left / 60)

    def __lt__(self, other):
        """
        Compares this lesson with given. Used in lesson sort

        :param other: Lesson
        :return: boolean
        """
        return self.start_struct < other.start_struct

    def __str__(self):
        """
        Converts current lesson to string for easy output

        :return: String
        """
        return f"{self.subject}\n"\
               f"👨‍🏫 {self.teacher}\n"\
               f"🕐 {self.start} 	— {self.end}\n" \
               f"🚪 {self.room if self.room != -1 else '?'}\n"

    def get_str_current(self):
        """
        Returns string, which indicates how many time left until current lesson will be finished.
        Used when NOW button is pressed and current lesson is going

        :return: String
        """
        hours_until_end = self.minutes_until_end // 60
        return f"{self}⏸️ {str(hours_until_end)+'h ' if hours_until_end > 0 else ''}" \
               f"{self.minutes_until_end % 60}m\n"

    def get_str_future(self):
        """
        Returns string, which indicates how many time left until current lesson will be started.
        Used when NOW button is pressed and current lesson will start next

        :return: String
        """
        hours_until_start = self.minutes_until_start // 60
        return f"{self}▶ ️{str(hours_until_start)+'h ' if hours_until_start > 0 else ''}" \
               f"{self.minutes_until_start % 60}m\n"
Exemple #53
0
class Group(Entity, ACLMixin):
    """Creates groups for users to be used in authorization system.

    A Group instance is nothing more than a list of :class:`.User`\ s created
    to be able to assign permissions in a group level.

    The Group class, as with the :class:`.User` class, is mixed with the
    :class:`.ACLMixin` which adds ability to hold :class:`.Permission`
    instances and serve ACLs to Pyramid.

    :param str name: The name of this group.
    :param list users: A list of :class:`.User` instances, holding the desired
      users in this group.
    """

    __auto_name__ = False
    __tablename__ = 'Groups'
    __mapper_args__ = {'polymorphic_identity': 'Group'}

    gid = Column("id", Integer, ForeignKey("Entities.id"),
                 primary_key=True)

    users = relationship(
        "User",
        secondary="Group_Users",
        back_populates="groups",
        doc="""Users in this group.

        Accepts:class:`.User` instance.
        """
    )

    def __init__(self, name='', users=None, permissions=None, **kwargs):
        if users is None:
            users = []

        if permissions is None:
            permissions = []

        kwargs.update({'name': name})
        super(Group, self).__init__(**kwargs)

        self.users = users
        self.permissions = permissions

    @validates('users')
    def _validate_users(self, key, user):
        """validates the given user instance
        """
        if not isinstance(user, User):
            raise TypeError(
                '%s.users attribute must all be stalker.models.auth.User '
                'instances not %s' %
                (self.__class__.__name__, user.__class__.__name__)
            )

        return user

    def __hash__(self):
        """the overridden __hash__ method
        """
        return super(Group, self).__hash__()
Exemple #54
0
    """
    from stalker.models.client import ClientUser
    return ClientUser(client=client)


def create_project_user(project):
    """helper function to create ProjectUser instance on association proxy
    """
    from stalker.models.project import ProjectUser
    return ProjectUser(project=project)


# Group_Users
Group_Users = Table(
    "Group_Users", Base.metadata,
    Column("uid", Integer, ForeignKey("Users.id"), primary_key=True),
    Column("gid", Integer, ForeignKey("Groups.id"), primary_key=True)
)


class AuthenticationLog(SimpleEntity):
    """Keeps track of login/logout dates and the action (login or logout).
    """

    __auto_name__ = True
    __tablename__ = "AuthenticationLogs"
    __mapper_args__ = {"polymorphic_identity": "AuthenticationLog"}

    log_id = Column(
        'id',
        Integer,
Exemple #55
0
class AuthenticationLog(SimpleEntity):
    """Keeps track of login/logout dates and the action (login or logout).
    """

    __auto_name__ = True
    __tablename__ = "AuthenticationLogs"
    __mapper_args__ = {"polymorphic_identity": "AuthenticationLog"}

    log_id = Column(
        'id',
        Integer,
        ForeignKey('SimpleEntities.id'),
        primary_key=True
    )

    user_id = Column(
        'uid',
        Integer,
        ForeignKey('Users.id'),
        nullable=False
    )

    user = relationship(
        'User',
        primaryjoin='AuthenticationLogs.c.uid==Users.c.id',
        uselist=False,
        back_populates='authentication_logs',
        doc="The :class:`.User` instance that this AuthenticationLog is "
        "created for"
    )

    action = Column(
        'action',
        Enum(LOGIN, LOGOUT, name='ActionNames'),
        nullable=False
    )

    date = Column(
        DateTime(timezone=True),
        nullable=False
    )

    def __init__(self, user=None, date=None, action=LOGIN, **kwargs):
        super(AuthenticationLog, self).__init__(**kwargs)
        self.user = user
        self.date = date
        self.action = action

    @validates('user')
    def __validate_user__(self, key, user):
        """validates the given user argument value
        """
        if not isinstance(user, User):
            raise TypeError(
                '%s.user should be a User instance, not %s' % (
                    self.__class__.__name__,
                    user.__class__.__name__
                )
            )

        return user

    @validates('action')
    def __validate_action__(self, key, action):
        """validates the given action argument value
        """
        if action is None:
            import copy
            action = copy.copy(LOGIN)

        if action not in [LOGIN, LOGOUT]:
            raise ValueError(
                '%s.action should be one of "login" or "logout", not "%s"' % (
                    self.__class__.__name__,
                    action
                )
            )

        return action

    @validates('date')
    def __validate_date__(self, key, date):
        """validates the given date value
        """
        if date is None:
            date = datetime.datetime.now(pytz.utc)

        if not isinstance(date, datetime.datetime):
            raise TypeError(
                '%s.date should be a "datetime.datetime" instance, not %s' % (
                    self.__class__.__name__,
                    date.__class__.__name__
                )
            )

        return date
Exemple #56
0
class User(Entity, ACLMixin):
    """The user class is designed to hold data about a User in the system.

    .. note::
       .. versionadded 0.2.0: Task Watchers

       New to version 0.2.0 users can be assigned to a :class:`.Task` as a
       **Watcher**. Which can be used to inform the users in watchers list
       about the updates of certain Tasks.

    .. note::
       .. versionadded 0.2.0: Vacations

       It is now possible to define Vacations per user.

    .. note::
       .. versionadded 0.2.7: Resource Efficiency

    .. note::
       .. versionadded 0.2.11:

          Users not have a :attr:`.rate` attribute.

    :param rate:
       For future usage a rate attribute is added to the User to record the
       daily cost of this user as a resource. It should be either 0 or a
       positive integer or float value. Default is 0.

    :param efficiency:

      The efficiency is a multiplier for a user as a resource to a task and
      defines how much of the time spent for that particular task is counted as
      an actual effort. The default value is 1.0, lowest possible value is 0.0
      and there is no upper limit.

      The efficiency of a resource can be used for three purposes. First you
      can use it as a crude way to model a team. A team of 5 people should have
      an efficiency of 5.0. Keep in mind that you cannot track the members of
      the team individually if you use this feature. They always act as a
      group.

      Another use is to model performance variations between your resources.
      Again, this is a fairly crude mechanism and should be used with care. A
      resource that isn't every good at some task might be pretty good at
      another. This can't be taken into account as the resource efficiency can
      only set globally for all tasks.

      One another and interesting use is to model the availability of passive
      resources like a meeting room or a workstation or something that needs to
      be free for a task to take place but does not contribute to a task as an
      active resource.

      All resources that do not contribute effort to the task, that is a
      passive resource, should have an efficiency of 0.0. Again a typical
      example would be a conference room. It's necessary for a meeting, but it
      does not contribute any work.

    :param email: holds the e-mail of the user, should be in [part1]@[part2]
      format

    :type email: str

    :param login: This is the login name of the user, it should be all lower
      case. Giving a string that has uppercase letters, it will be converted to
      lower case. It can not be an empty string or None and it can not contain
      any white space inside.

    :type login: str

    :param departments: It is the departments that the user is a part of. It
      should be a list of Department objects. One user can be listed in
      multiple departments.

    :type departments: list of :class:`.Department`\ s

    :param password: it is the password of the user, can contain any character.
      Stalker doesn't store the raw passwords of the users. To check a stored
      password with a raw password use :meth:`.check_password` and to set the
      password you can use the :attr:`.password` property directly.

    :type password: str

    :param groups: It is a list of :class:`.Group` instances that this user
      belongs to.

    :type groups: list of :class:`.Group`

    :param tasks: it is a list of Task objects which holds the tasks that this
      user has been assigned to

    :type tasks: list of :class:`.Task`\ s

    :param last_login: it is a datetime.datetime object holds the last login
      date of the user (not implemented yet)

    :type last_login: datetime.datetime
    """
    __auto_name__ = False
    __tablename__ = "Users"
    __mapper_args__ = {"polymorphic_identity": "User"}

    user_id = Column(
        "id",
        Integer,
        ForeignKey("Entities.id"),
        primary_key=True
    )

    departments = association_proxy(
        'department_role',
        'department',
        creator=lambda d: create_department_user(d)
    )

    department_role = relationship(
        'DepartmentUser',
        back_populates='user',
        cascade='all, delete-orphan',
        primaryjoin='Users.c.id==Department_Users.c.uid',
        doc="""A list of :class:`.Department`\ s that
        this user is a part of"""
    )

    companies = association_proxy(
        'company_role',
        'client',
        creator=lambda n: create_client_user(n)
    )

    company_role = relationship(
        "ClientUser",
        back_populates="user",
        cascade='all, delete-orphan',
        primaryjoin="Users.c.id==Client_Users.c.uid",
        doc="""A list of :class:`.Client`\ s that this user is a part of."""
    )

    email = Column(
        String(256),
        unique=True,
        nullable=False,
        doc="email of the user, accepts string"
    )

    password = Column(
        String(256),
        nullable=False,
        doc="""The password of the user.

        It is scrambled before it is stored.
        """
    )

    login = Column(
        String(256),
        nullable=False,
        unique=True,
        doc="""The login name of the user.

        Can not be empty.
        """
    )

    authentication_logs = relationship(
        "AuthenticationLog",
        primaryjoin="AuthenticationLogs.c.uid==Users.c.id",
        back_populates="user",
        cascade='all, delete-orphan',
        doc="""A list of :class:`.AuthenticationLog` instances which holds the
        login/logout info for this :class:`.User`.
        """
    )

    groups = relationship(
        'Group',
        secondary='Group_Users',
        back_populates='users',
        doc="""Permission groups that this users is a member of.

        Accepts :class:`.Group` object.
        """
    )

    projects = association_proxy(
        'project_role',
        'project',
        creator=lambda p: create_project_user(p)
    )

    project_role = relationship(
        'ProjectUser',
        back_populates='user',
        cascade='all, delete-orphan',
        primaryjoin='Users.c.id==Project_Users.c.user_id'
    )

    tasks = relationship(
        "Task",
        secondary="Task_Resources",
        back_populates="resources",
        doc=""":class:`.Task`\ s assigned to this user.

        It is a list of :class:`.Task` instances.
        """
    )

    watching = relationship(
        'Task',
        secondary='Task_Watchers',
        back_populates='watchers',
        doc=''':class:`.Tasks`\ s that this user is
        assigned as a watcher.

        It is a list of :class:`.Task` instances.
        '''
    )

    responsible_of = relationship(
        'Task',
        secondary='Task_Responsible',
        primaryjoin='Users.c.id==Task_Responsible.c.responsible_id',
        secondaryjoin='Task_Responsible.c.task_id==Tasks.c.id',
        back_populates='_responsible',
        uselist=True,
        doc="""A list of :class:`.Task` instances that this user is responsible
        of."""
    )

    time_logs = relationship(
        "TimeLog",
        primaryjoin="TimeLogs.c.resource_id==Users.c.id",
        back_populates="resource",
        cascade='all, delete-orphan',
        doc="""A list of :class:`.TimeLog` instances which
        holds the time logs created for this :class:`.User`.
        """
    )

    vacations = relationship(
        'Vacation',
        primaryjoin='Vacations.c.user_id==Users.c.id',
        back_populates='user',
        cascade='all, delete-orphan',
        doc="""A list of :class:`.Vacation` instances
        which holds the vacations created for this :class:`.User`
        """
    )

    efficiency = Column(Float, default=1.0)

    rate = Column(Float, default=0.0)

    def __init__(
            self,
            name=None,
            login=None,
            email=None,
            password=None,
            departments=None,
            companies=None,
            groups=None,
            efficiency=1.0,
            rate=0.0,
            **kwargs):
        kwargs['name'] = name

        super(User, self).__init__(**kwargs)

        self.login = login

        if departments is None:
            departments = []

        # from stalker import DepartmentUser
        # for department in departments:
        #     self.department_role.append(
        #         DepartmentUser(user=self, department=department)
        #     )
        self.departments = departments

        if companies is None:
            companies = []
        self.companies = companies

        self.email = email

        # to be able to mangle the password do it like this
        self.password = password

        if groups is None:
            groups = []
        self.groups = groups

        self.tasks = []

        self.last_login = None
        self.efficiency = efficiency
        self.rate = rate

    def __repr__(self):
        """return the representation of the current User
        """
        return "<%s ('%s') (User)>" % (self.name, self.login)

    def __eq__(self, other):
        """the equality operator
        """
        return super(User, self).__eq__(other) and \
            isinstance(other, User) and \
            self.email == other.email and \
            self.login == other.login and \
            self.name == other.name

    def __hash__(self):
        """the overridden __hash__ method
        """
        return super(User, self).__hash__()

    @validates("login")
    def _validate_login(self, key, login):
        """validates the given login value
        """
        if login is None:
            raise TypeError(
                '%s.login can not be None' % self.__class__.__name__
            )

        login = self._format_login(login)

        # raise a ValueError if the login is an empty string after formatting
        if login == '':
            raise ValueError(
                '%s.login can not be an empty string' %
                self.__class__.__name__
            )

        logger.debug("name out: %s" % login)

        return login

    @validates("email")
    def _validate_email(self, key, email_in):
        """validates the given email value
        """
        # check if email_in is an instance of string
        from stalker import __string_types__
        if not isinstance(email_in, __string_types__):
            raise TypeError(
                "%s.email should be an instance of str not %s" %
                (self.__class__.__name__, email_in.__class__.__name__)
            )
        return self._validate_email_format(email_in)

    def _validate_email_format(self, email_in):
        """formats the email
        """
        # split the mail from @ sign
        splits = email_in.split("@")
        len_splits = len(splits)

        # there should be one and only one @ sign
        if len_splits > 2:
            raise ValueError(
                "check the formatting of %s.email, there are more than one @ "
                "sign" % self.__class__.__name__
            )

        if len_splits < 2:
            raise ValueError(
                "check the formatting of %s.email, there is no @ sign" %
                self.__class__.__name__
            )

        if splits[0] == "":
            raise ValueError(
                "check the formatting of %s.email, the name part is missing" %
                self.__class__.__name__
            )

        if splits[1] == "":
            raise ValueError(
                "check the formatting %s.email, the domain part is missing" %
                self.__class__.__name__
            )

        return email_in

    @validates("last_login")
    def _validate_last_login(self, key, last_login_in):
        """validates the given last_login argument
        """
        if not isinstance(last_login_in, datetime.datetime) \
           and last_login_in is not None:
            raise TypeError(
                "%s.last_login should be an instance of datetime.datetime or "
                "None not %s" %
                (self.__class__.__name__, last_login_in.__class__.__name__)
            )
        return last_login_in

    @classmethod
    def _format_login(cls, login):
        """formats the given login value
        """
        # strip white spaces from start and end
        login = login.strip()

        # remove all the spaces
        login = login.replace(" ", "")

        # make it lowercase
        login = login.lower()

        # remove any illegal characters
        login = re.sub("[^\\(a-zA-Z0-9)]+", "", login)

        # remove any number at the beginning
        login = re.sub("^[0-9]+", "", login)

        return login

    @validates("password")
    def _validate_password(self, key, password_in):
        """validates the given password

        Note:
            This function was updated to support both Python 2.7 and 3.5.
            It will now explicitly convert the base64 bytes object into
            a string object.
        """
        if password_in is None:
            raise TypeError(
                "%s.password cannot be None" % self.__class__.__name__
            )

        if password_in == "":
            raise ValueError(
                "%s.password can not be an empty string" %
                self.__class__.__name__
            )

        # mangle the password
        mangled_password_bytes = base64.b64encode(password_in.encode('utf-8'))

        if sys.version_info.major == 2:
            mangled_password_str = str(mangled_password_bytes)
        else:
            # Assuming Python >= 3.5
            mangled_password_str = \
                str(mangled_password_bytes.decode('utf-8'))

        return mangled_password_str

    def check_password(self, raw_password):
        """Checks the given raw_password.

        Checks the given raw_password with the current User object's mangled
        password. Handles the encryption process behind the scene.

        Note:
            This function was updated to support both Python 2.7 and 3.5.
            It will now compare the string (str) versions of the given
            raw_password and the current Users object encrypted password.
        """
        mangled_password_str = str(self.password)
        raw_password_bytes = base64.b64encode(
            bytes(raw_password.encode('utf-8')))

        if sys.version_info.major == 2:
            raw_password_encrypted_str = str(raw_password_bytes)
        else:
            # Assuming Python >= 3.5
            raw_password_encrypted_str = \
                str(raw_password_bytes.decode('utf-8'))

        return mangled_password_str == raw_password_encrypted_str

    @validates("groups")
    def _validate_groups(self, key, group):
        """check the given group
        """
        if not isinstance(group, Group):
            raise TypeError(
                "Any group in %s.groups should be an instance of "
                "stalker.models.auth.Group not %s" %
                (self.__class__.__name__, group.__class__.__name__)
            )

        return group

    @validates("tasks")
    def _validate_tasks(self, key, task):
        """validates the given tasks attribute
        """
        from stalker.models.task import Task

        if not isinstance(task, Task):
            raise TypeError(
                "Any element in %s.tasks should be an instance of "
                "stalker.models.task.Task not %s" %
                (self.__class__.__name__, task.__class__.__name__)
            )
        return task

    @validates("watching")
    def _validate_watching(self, key, task):
        """validates the given watching attribute
        """
        from stalker.models.task import Task

        if not isinstance(task, Task):
            raise TypeError(
                "Any element in %s.watching should be an instance of "
                "stalker.models.task.Task not %s" %
                (self.__class__.__name__, task.__class__.__name__)
            )
        return task

    @validates('vacations')
    def _validate_vacations(self, key, vacation):
        """validates the given vacation value
        """
        from stalker.models.studio import Vacation

        if not isinstance(vacation, Vacation):
            raise TypeError(
                "All of the elements in %s.vacations should be a "
                "stalker.models.studio.Vacation instance, not %s" %
                (self.__class__.__name__, vacation.__class__.__name__)
            )
        return vacation

    @validates('efficiency')
    def _validate_efficiency(self, key, efficiency):
        """validates the given efficiency value
        """
        if efficiency is None:
            efficiency = 1.0

        if not isinstance(efficiency, (int, float)):
            raise TypeError(
                '%(class)s.efficiency should be a float number greater or '
                'equal to 0.0, not %(efficiency_class)s' % {
                    'class': self.__class__.__name__,
                    'efficiency_class': efficiency.__class__.__name__
                }
            )

        if efficiency < 0:
            raise ValueError(
                '%(class)s.efficiency should be a float number greater or '
                'equal to 0.0, not %(efficiency)s' % {
                    'class': self.__class__.__name__,
                    'efficiency': efficiency
                }
            )

        return efficiency

    @validates('rate')
    def _validate_rate(self, key, rate):
        """validates the given rate value
        """
        if rate is None:
            rate = 0.0

        if not isinstance(rate, (int, float)):
            raise TypeError(
                '%(class)s.rate should be a float number greater or '
                'equal to 0.0, not %(rate_class)s' % {
                    'class': self.__class__.__name__,
                    'rate_class': rate.__class__.__name__
                }
            )

        if rate < 0:
            raise ValueError(
                '%(class)s.rate should be a float number greater or '
                'equal to 0.0, not %(rate)s' % {
                    'class': self.__class__.__name__,
                    'rate': rate
                }
            )

        return rate

    @property
    def tickets(self):
        """The list of :class:`.Ticket`\ s that this user has.

        returns a list of :class:`.Ticket` instances
        which this user is the owner of.
        """
        # do it with sqlalchemy
        from stalker import Ticket

        return Ticket.query \
            .filter(Ticket.owner == self) \
            .all()

    @property
    def open_tickets(self):
        """The list of open :class:`.Ticket`\ s that this user has.

        returns a list of :class:`.Ticket` instances which has a status of
        `Open` that this user is assigned as the owner.
        """
        from stalker import Ticket, Status
        return Ticket.query \
            .join(Status, Ticket.status) \
            .filter(Ticket.owner == self) \
            .filter(Status.code != 'CLS') \
            .all()

    @property
    def to_tjp(self):
        """outputs a TaskJuggler formatted string
        """
        from jinja2 import Template

        temp = Template(defaults.tjp_user_template, trim_blocks=True)
        return temp.render({'user': self})
Exemple #57
0
class Hoa_don(Base):
    __tablename__ = 'hoa_don'
    ma_hoa_don = Column(Integer, nullable = False, primary_key = True)
    ngay_tao_hoa_don = Column(DateTime, nullable = False)
    ma_khach_hang = Column(Integer, ForeignKey('khach_hang.ma_khach_hang'))
    tong_tien = Column(Float, nullable = False)
    ma_hoa_don_sendo = Column(String(50))
    nha_van_chuyen = Column(String(255))
    ma_van_don = Column(String(100))
    trang_thai = Column(Integer)
    ghi_chu = Column(Text)
    da_in_hd = Column(Integer, default = 0)
    da_cap_nhat_kho = Column(Integer, default = 0)
    
    khach_hang = relationship(Khach_hang, backref = 'hoa_don')
    def __repr__(self):
        return "<Ma_hoa_don = %d>" % self.ma_hoa_don

    def get_id(self):
        return self.ma_hoa_don
Exemple #58
0
class Genre(BaseModel):
    __tablename__ = 'genre'
    name = Column(String(256))
    description = Column(String(256))
Exemple #59
0
class Loai_nguoi_dung(Base):
    __tablename__ = 'loai_nguoi_dung'
    ma_loai_nguoi_dung = Column(Integer, nullable = False, primary_key = True)
    ten_loai_nguoi_dung = Column(String(100), nullable = False)
    def __str__(self):
        return self.ten_loai_nguoi_dung
class SiteDB(Base):
    """
        Databse model for site table
    """
    __tablename__ = 'sites'
    __table_args__ = {'extend_existing': True}
    id = Column(Integer, primary_key=True)
    sitename = Column(String, unique=True)

    site_type = Column(String)
    cache_type = Column(String)
    site_path = Column(String)

    # Use default=func.now() to set the default created time
    # of a site to be the current time when a
    # Site record was created

    created_on = Column(DateTime, default=func.now())
    is_enabled = Column(Boolean, unique=False, default=True, nullable=False)
    is_ssl = Column(Boolean, unique=False, default=False)
    storage_fs = Column(String)
    storage_db = Column(String)
    db_name = Column(String)
    db_user = Column(String)
    db_password = Column(String)
    db_host = Column(String)
    is_hhvm = Column(Boolean, unique=False, default=False)
    is_pagespeed = Column(Boolean, unique=False, default=False)

    def __init__(self, sitename=None, site_type=None, cache_type=None,
                 site_path=None, site_enabled=None,
                 is_ssl=None, storage_fs=None, storage_db=None, db_name=None,
                 db_user=None, db_password=None, db_host='localhost',
                 hhvm=None, pagespeed=None):
        self.sitename = sitename
        self.site_type = site_type
        self.cache_type = cache_type
        self.site_path = site_path
        self.is_enabled = site_enabled
        self.is_ssl = is_ssl
        self.storage_fs = storage_fs
        self.storage_db = storage_db
        self.db_name = db_name
        self.db_user = db_user
        self.db_password = db_password
        self.db_host = db_host
        self.is_hhvm = hhvm
        self.is_pagespeed = pagespeed
    # def __repr__(self):
    #     return '<Site %r>' % (self.site_type)
    #
    # def getType(self):
    #     return '%r>' % (self.site_type)