class Item(PoeDbBase):
"""
The db-table for API item data
"""
__tablename__ = 'item'
id = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True)
api_id = sqlalchemy.Column(sqlalchemy.String(255),
nullable=False,
index=True,
unique=True)
stash_id = sqlalchemy.Column(sqlalchemy.Integer,
sqlalchemy.ForeignKey("stash.id"),
nullable=False)
h = sqlalchemy.Column(sqlalchemy.Integer, nullable=False)
w = sqlalchemy.Column(sqlalchemy.Integer, nullable=False)
x = sqlalchemy.Column(sqlalchemy.Integer, nullable=False)
y = sqlalchemy.Column(sqlalchemy.Integer, nullable=False)
abyssJewel = sqlalchemy.Column(sqlalchemy.Boolean, default=False)
artFilename = sqlalchemy.Column(sqlalchemy.String(255))
# Note: API docs say this cannot be null, but we get null values
category = sqlalchemy.Column(SemiJSON)
corrupted = sqlalchemy.Column(sqlalchemy.Boolean, default=False)
cosmeticMods = sqlalchemy.Column(SemiJSON)
craftedMods = sqlalchemy.Column(SemiJSON)
descrText = sqlalchemy.Column(sqlalchemy.Unicode(255))
duplicated = sqlalchemy.Column(sqlalchemy.Boolean, default=False)
elder = sqlalchemy.Column(sqlalchemy.Boolean, default=False)
enchantMods = sqlalchemy.Column(SemiJSON)
explicitMods = sqlalchemy.Column(SemiJSON)
flavourText = sqlalchemy.Column(SemiJSON)
frameType = sqlalchemy.Column(sqlalchemy.Integer, nullable=False)
icon = sqlalchemy.Column(sqlalchemy.String(255), nullable=False)
identified = sqlalchemy.Column(sqlalchemy.Boolean, nullable=False)
ilvl = sqlalchemy.Column(sqlalchemy.Integer, nullable=False)
implicitMods = sqlalchemy.Column(SemiJSON)
inventoryId = sqlalchemy.Column(sqlalchemy.String(255))
isRelic = sqlalchemy.Column(sqlalchemy.Boolean, default=False)
league = sqlalchemy.Column(sqlalchemy.Unicode(64),
nullable=False,
index=True)
lockedToCharacter = sqlalchemy.Column(sqlalchemy.Boolean, default=False)
maxStackSize = sqlalchemy.Column(sqlalchemy.Integer)
name = sqlalchemy.Column(sqlalchemy.Unicode(255),
nullable=False,
index=True)
nextLevelRequirements = sqlalchemy.Column(SemiJSON)
note = sqlalchemy.Column(sqlalchemy.Unicode(255))
properties = sqlalchemy.Column(SemiJSON)
prophecyDiffText = sqlalchemy.Column(sqlalchemy.Unicode(255))
prophecyText = sqlalchemy.Column(sqlalchemy.Unicode(255))
requirements = sqlalchemy.Column(SemiJSON)
secDescrText = sqlalchemy.Column(sqlalchemy.Text)
shaper = sqlalchemy.Column(sqlalchemy.Boolean, default=False)
sockets = sqlalchemy.Column(SemiJSON)
stackSize = sqlalchemy.Column(sqlalchemy.Integer)
support = sqlalchemy.Column(sqlalchemy.Boolean, default=False)
talismanTier = sqlalchemy.Column(sqlalchemy.Integer)
typeLine = sqlalchemy.Column(sqlalchemy.String(255),
nullable=False,
index=True)
utilityMods = sqlalchemy.Column(SemiJSON)
verified = sqlalchemy.Column(sqlalchemy.Boolean, nullable=False)
# This is an internal field which we use to track stash updates.
# When a new version of the stash shows up, we mark all of the
# items in it inactive, then we re-activate the one's we see again.
active = sqlalchemy.Column(sqlalchemy.Boolean,
nullable=False,
default=True,
index=True)
created_at = sqlalchemy.Column(sqlalchemy.Integer,
nullable=False,
index=True)
updated_at = sqlalchemy.Column(sqlalchemy.Integer,
nullable=False,
index=True)
def __repr__(self):
return "<Item(name=%r, id=%s, api_id=%s, typeLine=%r)>" % (
self.name, self.id, self.api_id, self.typeLine)
"""
import json
from alembic import op
import sqlalchemy as sa
# revision identifiers, used by Alembic.
revision = 'd7a914dbc133'
down_revision = '93591ffbbc1b'
metadata = sa.MetaData()
question_type_groups = sa.Table(
'question_type_groups', metadata,
sa.Column('id', sa.Integer(), primary_key=True),
sa.Column('name', sa.Unicode(255)), sa.Column('parent_id', sa.Integer()))
question_types = sa.Table('question_types', metadata,
sa.Column('id', sa.Integer(), primary_key=True),
sa.Column('name', sa.Unicode(255)),
sa.Column('frontend', sa.UnicodeText()),
sa.Column('backend', sa.UnicodeText()),
sa.Column('group_id', sa.Integer()),
sa.Column('parent_id', sa.Integer()))
def upgrade():
parent = op.get_bind().execute(question_type_groups.select().where(
question_type_groups.c.name == 'ess:builtins')).first()
parent = op.get_bind().execute(question_type_groups.select().where(
sa.and_(question_type_groups.c.name == 'ess:core',
question_type_groups.c.parent_id == parent[0]))).first()
class Comment(Base):
__tablename__ = 'comment'
id = sa.Column(sa.Integer, primary_key=True)
content = sa.Column(sa.Unicode(255))
thread_id = sa.Column(sa.Integer, sa.ForeignKey('thread.id'))
rdb.Column(column_key, rdb.Integer, primary_key=True),
rdb.Column(column_name, rdb.Unicode(256), nullable=False, unique=True),
rdb.Column("language", rdb.String(5), nullable=False),
)
#######################
# Users
#######################
users = rdb.Table(
"users",
metadata,
rdb.Column("user_id", rdb.Integer, PrincipalSequence, primary_key=True),
# login is our principal id
rdb.Column("login", rdb.Unicode(80), unique=True, nullable=True),
rdb.Column("titles", rdb.Unicode(32)),
rdb.Column("first_name", rdb.Unicode(256), nullable=False),
rdb.Column("last_name", rdb.Unicode(256), nullable=False),
rdb.Column("middle_name", rdb.Unicode(256)),
rdb.Column("email", rdb.String(512), nullable=False),
rdb.Column(
"gender",
rdb.String(1),
rdb.CheckConstraint("""gender in ('M', 'F')""") # (M)ale (F)emale
),
rdb.Column("date_of_birth", rdb.Date),
rdb.Column("birth_country", rdb.String(2),
rdb.ForeignKey("countries.country_id")),
rdb.Column("birth_nationality", rdb.String(2),
rdb.ForeignKey("countries.country_id")),
from progressbar import ProgressBar
import progressbar.widgets
from coaster.utils import buid2uuid, uuid2buid
# revision identifiers, used by Alembic.
revision = '4e206c5ddabd'
down_revision = '83d3ede06c'
branch_labels = None
depends_on = None
user = table(
'user',
column('id', sa.Integer()),
column('created_at', sa.DateTime()),
column('userid', sa.Unicode(22)),
column('uuid', UUIDType(binary=False)),
)
organization = table(
'organization',
column('id', sa.Integer()),
column('created_at', sa.DateTime()),
column('userid', sa.Unicode(22)),
column('uuid', UUIDType(binary=False)),
)
team = table(
'team',
column('id', sa.Integer()),
column('created_at', sa.DateTime()),
column('userid', sa.Unicode(22)),
column('uuid', UUIDType(binary=False)),
class SlowCall(Base, BaseModel):
__tablename__ = 'slow_calls'
__table_args__ = {'implicit_returning': False}
resource_id = sa.Column(sa.Integer(), nullable=False, index=True)
id = sa.Column(sa.Integer, nullable=False, primary_key=True)
report_id = sa.Column(sa.BigInteger,
sa.ForeignKey('reports.id',
ondelete='cascade',
onupdate='cascade'),
primary_key=True)
duration = sa.Column(sa.Float(), default=0)
statement = sa.Column(sa.UnicodeText(), default='')
statement_hash = sa.Column(sa.Unicode(60), default='')
parameters = sa.Column(JSON(), nullable=False, default=dict)
type = sa.Column(sa.Unicode(16), default='')
subtype = sa.Column(sa.Unicode(16), default=None)
location = sa.Column(sa.Unicode(255), default='')
timestamp = sa.Column(sa.DateTime(),
default=datetime.utcnow,
server_default=sa.func.now())
report_group_time = sa.Column(sa.DateTime(),
default=datetime.utcnow,
server_default=sa.func.now())
def set_data(self,
data,
protocol_version=None,
resource_id=None,
report_group=None):
self.resource_id = resource_id
if data.get('start') and data.get('end'):
self.timestamp = data.get('start')
d = data.get('end') - data.get('start')
self.duration = d.total_seconds()
self.statement = data.get('statement', '')
self.type = data.get('type', 'unknown')[:16]
self.parameters = data.get('parameters', {})
self.location = data.get('location', '')[:255]
self.report_group_time = report_group.first_timestamp
if 'subtype' in data:
self.subtype = data.get('subtype', 'unknown')[:16]
if self.type == 'tmpl':
self.set_hash('{} {}'.format(self.statement, self.parameters))
else:
self.set_hash()
def set_hash(self, custom_statement=None):
statement = custom_statement or self.statement
self.statement_hash = hashlib.sha1(
statement.encode('utf8')).hexdigest()
@property
def end_time(self):
if self.duration and self.timestamp:
return self.timestamp + timedelta(seconds=self.duration)
return None
def get_dict(self):
instance_dict = super(SlowCall, self).get_dict()
instance_dict['children'] = []
instance_dict['end_time'] = self.end_time
return instance_dict
def es_doc(self):
doc = {
'resource_id':
self.resource_id,
'timestamp':
self.timestamp,
'pg_id':
str(self.id),
'permanent':
False,
'request_id':
None,
'log_level':
'UNKNOWN',
'message':
self.statement,
'namespace':
'appenlight.slow_call',
'tags': {
'report_id': {
'values': self.report_id,
'numeric_values': self.report_id
},
'duration': {
'values': None,
'numeric_values': self.duration
},
'statement_hash': {
'values': self.statement_hash,
'numeric_values': None
},
'type': {
'values': self.type,
'numeric_values': None
},
'subtype': {
'values': self.subtype,
'numeric_values': None
},
'location': {
'values': self.location,
'numeric_values': None
},
'parameters': {
'values': None,
'numeric_values': None
}
},
'tag_list': [
'report_id', 'duration', 'statement_hash', 'type', 'subtype',
'location'
]
}
if isinstance(self.parameters, str):
doc['tags']['parameters']['values'] = self.parameters[:255]
return doc
@property
def partition_id(self):
return 'rcae_sc_%s' % self.report_group_time.strftime('%Y_%m')
def upgrade():
op.add_column("role", sa.Column("locale", sa.Unicode(), nullable=True))