Example #1
0
    def add_defn(self, model, **kwargs):
        name = model.__name__
        self.swagger['definitions'][name] = {
            'type': 'object',
            'properties': {}
        }
        columns = get_columns(model).keys()
        for column_name, column in get_columns(model).items():
            if column_name in kwargs.get('exclude_columns', []):
                continue
            try:
                column_type = str(column.type)
                if '(' in column_type:
                    column_type = column_type.split('(')[0]
                column_defn = sqlalchemy_swagger_mapping[column_type]
            except AttributeError:
                schema = get_related_model(model, column_name)
                if column_name + '_id' in columns:
                    column_defn = {'schema': {'$ref': schema.__name__}}
                else:
                    column_defn = {
                        'schema': {
                            'type': 'array',
                            'items': {
                                '$ref': schema.__name__
                            }
                        }
                    }

            # if column.__doc__:
            #     column_defn['description'] = column.__doc__
            self.swagger['definitions'][name]['properties'][
                column_name] = column_defn
Example #2
0
def info(ctx, table, filter_):
    """ Print table summary information
    """
    import sqlalchemy_utils as sau
    from ..db import construct_filter

    db = _db_from_ctx(ctx)
    echoer = cliutils.Echoer(logging.getLogger("tilez"))

    echoer.info("Information about: {}".format(table))
    query = construct_filter(db.session.query(table), filter_)

    echoer.process("Number of entries: {}".format(query.count()))

    # Diagnostic info about table
    template = "{idx: <10} {name: <20}{type: <15}"

    echoer.process("Enumerating columns in table: {}".format(table))
    echoer.item(
        "{idx: <10} {name: <20}{type: <30}".format(idx="COLUMN #", name="NAME", type="TYPE"), bold=True, underline=True
    )
    for idx, col in enumerate(sau.get_columns(table).values()):
        echoer.item(
            template.format(
                **{
                    "idx": "Col {0:02d}".format(idx),
                    "name": '"{}"'.format(col.name),
                    "type": "{type} {pk}".format(type=col.type, pk="(PRIMARY KEY)" if col.primary_key else ""),
                }
            )
        )

    for idx, (name, col) in enumerate(six.iteritems(sau.get_hybrid_properties(table))):
        echoer.item(template.format(**{"idx": "HYBRID {0:02d}".format(idx), "name": '"{}"'.format(name), "type": "?"}))
Example #3
0
def search(ctx, quiet, group_by, distinct, filter_, select, table):
    """ Search a table according to some filters

    Example:

    \b
    1. Print list of all products with 8 bands, grouped by 'timeseries_id'
        > tilez db search -h --filter "n_bands = 8"
            --group_by timeseries_id product

    """
    # TODO: add conjunction argument -- or / and
    import sqlalchemy_utils as sau
    from ..db import construct_filter

    db = _db_from_ctx(ctx)
    table_columns = sau.get_columns(table)

    if "*" in select:
        select = table_columns.keys()

    if not quiet:
        click.secho('Searching table "{}" where:'.format(table.__tablename__), fg="blue", bold=True)
        for filter_item in filter_:
            click.echo("    {}".format(filter_item))

    query = construct_filter(db.session.query(table), filter_)

    if distinct:
        try:
            col = table_columns[distinct]
        except KeyError:
            raise click.BadParameter(
                'Cannot select distinct of "{}" in table "{}": no such column'.format(distinct, table),
                param_hint="distinct",
            )
        else:
            query = query.distinct(col)

    if group_by:
        try:
            col = table_columns[group_by]
        except KeyError:
            raise click.BadParameter(
                'Cannot group by "{}" in table "{}": no such column'.format(group_by, table), param_hint="group_by"
            )
        else:
            query = query.group_by(col)

    if not quiet:
        click.secho("Results:", fg="red", bold=True)
    for query_row in query:
        if select and not quiet:
            click.echo(", ".join("{}={}".format(_c, getattr(query_row, _c)) for _c in select))
        elif select and quiet:
            click.echo(" ".join(str(getattr(query_row, _c)) for _c in select))
        else:
            click.echo(query_row)
 def test_mapper(self, Building):
     assert isinstance(
         get_columns(Building.__mapper__),
         sa.util._collections.OrderedProperties
     )
Example #5
0
 def test_table_alias(self, Building, columns):
     alias = sa.orm.aliased(Building.__table__)
     assert [c.name for c in get_columns(alias).values()] == columns
 def test_declarative_class(self):
     assert isinstance(
         get_columns(self.Building),
         sa.util._collections.OrderedProperties
     )
 def test_column(self):
     assert get_columns(self.Building.__table__.c._id) == [
         self.Building.__table__.c._id
     ]
Example #8
0
 def test_class_alias(self, Building, columns):
     assert [
         c.name for c in get_columns(sa.orm.aliased(Building)).values()
     ] == columns
 def test_declarative_object(self):
     assert isinstance(get_columns(self.Building()),
                       sa.util._collections.OrderedProperties)
 def test_class_alias(self):
     assert isinstance(get_columns(sa.orm.aliased(self.Building)),
                       sa.util._collections.OrderedProperties)
 def test_table(self):
     assert isinstance(get_columns(self.Building.__table__),
                       sa.sql.base.ImmutableColumnCollection)
 def test_column_property(self):
     assert get_columns(
         self.Building.id.property) == [self.Building.__table__.c._id]
 def test_declarative_object(self, Building):
     assert isinstance(
         get_columns(Building()),
         sa.util._collections.OrderedProperties
     )
Example #14
0
 def get_file_columns(target):
     return filter(lambda c: isinstance(c.type, FileType),
                   get_columns(target))
 def test_declarative_class(self, Building):
     assert isinstance(
         get_columns(Building),
         sa.util._collections.OrderedProperties
     )
 def test_column(self, Building):
     assert get_columns(Building.__table__.c._id) == [
         Building.__table__.c._id
     ]
 def test_column_property(self, Building):
     assert get_columns(Building.id.property) == [
         Building.__table__.c._id
     ]
 def test_instrumented_attribute(self, Building):
     assert get_columns(Building.id) == [Building.__table__.c._id]
 def test_table(self, Building):
     assert isinstance(
         get_columns(Building.__table__),
         sa.sql.base.ImmutableColumnCollection
     )
 def test_class_alias(self, Building):
     assert isinstance(
         get_columns(sa.orm.aliased(Building)),
         sa.util._collections.OrderedProperties
     )
 def test_table_alias(self, Building):
     alias = sa.orm.aliased(Building.__table__)
     assert isinstance(
         get_columns(alias),
         sa.sql.base.ImmutableColumnCollection
     )
 def test_instrumented_attribute(self):
     assert get_columns(self.Building.id) == [self.Building.__table__.c._id]
Example #23
0
 def test_column(self, Building):
     assert get_columns(
         Building.__table__.c._id) == [Building.__table__.c._id]
 def test_column(self):
     assert get_columns(
         self.Building.__table__.c._id) == [self.Building.__table__.c._id]
Example #25
0
 def test_declarative_object(self, Building, columns):
     assert [c.name for c in get_columns(Building()).values()] == columns
 def test_mapper(self):
     assert isinstance(get_columns(self.Building.__mapper__),
                       sa.util._collections.OrderedProperties)
Example #27
0
 def test_mapper(self, Building, columns):
     assert [c.name
             for c in get_columns(Building.__mapper__).values()] == columns
 def test_table_alias(self):
     alias = sa.orm.aliased(self.Building.__table__)
     assert isinstance(get_columns(alias),
                       sa.sql.base.ImmutableColumnCollection)
Example #29
0
def update_user(request_data, user_id=''):

    if len(request_data) == 0:

        response = {'status_code': 400, 'status_message': 'Bad request'}

        return response

    user = session.query(User).filter_by(id=user_id).first()

    # This columns can't be changed in this method
    deprecated_columns_to_change = [
        'id', 'user_pass_hash', 'access_token', 'token_expired_date'
    ]

    # Get columns names
    existing_columns = get_columns(user.__table__)
    existing_columns_names = list(
        map(lambda x: str(x).replace('users_.', ''), existing_columns))

    for key, value in request_data.items():
        if (key in existing_columns_names) and (
                key not in deprecated_columns_to_change) and value:

            if key == 'user_name':
                user.user_name = value

            if key == 'user_surname':
                user.user_surname = value

            if key == 'user_middle_name':
                user.user_middle_name = value

            if key == 'user_date_of_birth':

                if type(value) == int and datetime.fromtimestamp(
                        value) < datetime.now():

                    user.user_date_of_birth = datetime.fromtimestamp(value)

                else:
                    print('user_date_of_birth is not correct', key, value)

            if key == 'eye_color_id':
                if len(value) == 36:
                    eye_color = session.query(EyeColor).filter_by(
                        id=value).first()

                    if eye_color:
                        user.eye_color_id = eye_color.id
                    else:
                        print('wrong eye_color_id', key, value)

                else:
                    print('wrong uuid eye_color_id', key, value)

            if key == 'country_id':
                if len(value) == 36:
                    country = session.query(Country).filter_by(
                        id=value).first()

                    if country:
                        user.country_id = country.id
                    else:
                        print('wrong country_id', key, value)
                else:
                    print('wrong uuid country_id', key, value)
        else:
            print('wrong key', key, value)

    try:
        session.commit()

        response = {
            'status_code': 200,
            'status_message': 'OK',
            'user_id': user_id
        }

        return JsonResponse(response)

    except:

        response = {
            'status_code': 500,
            'status_message': 'Internal Server Error'
        }

        return JsonResponse(response)