class CoMagicCall(db.Model):
__tablename__ = 'comagic_calls'
__humanname__ = 'Параметры звонков'
__order__ = 3
id = db.Column(db.Integer, primary_key=True, info={'verbose_name': 'Идентификатор звонка'})
account_id = db.Column(db.Integer, nullable=False, info={'verbose_name': 'Идентификатор подключенного аккаунта'})
call_id = db.Column(db.Integer, nullable=False, info={'verbose_name': 'Внутренний идентификатор звонка'})
finish_reason = db.Column(db.Unicode(128), nullable=False, info={'verbose_name': 'Причина окончания звонка'})
direction = db.Column(db.Unicode(16), nullable=False, info={'verbose_name': 'Направление звонка'})
call_source = db.Column(db.Unicode(32), nullable=False, info={'verbose_name': 'Источник звонка'})
is_lost = db.Column(db.Boolean, nullable=False, info={'verbose_name': 'Потерянный звонок'})
contact_phone_number = db.Column(db.Unicode(32), info={'verbose_name': 'Номер контакта'})
virtual_phone_number = db.Column(db.Unicode(16), info={'verbose_name': 'Виртуальный номер'})
visitor_id = db.Column(db.Unicode(16), info={'verbose_name': 'Идентификатор посетителя'})
visitor_session_id = db.Column(db.Unicode(16), info={'verbose_name': 'Идентификатор сессии посетителя'})
visitor_device = db.Column(db.Unicode(8), nullable=False, info={'verbose_name': 'Устройство пользователя'})
channel = db.Column(db.Unicode(16), info={'verbose_name': 'Канал'})
referrer = db.Column(db.Unicode(256), info={'verbose_name': 'Источник перехода'})
__table_args__ = (
db.Index('comagic_calls_idx_1', account_id),
db.Index('comagic_calls_idx_2', call_id),
)
def __repr__(self):
return '<CoMagicCall %r>' % self.id
class AnalyticsReport(db.Model):
__tablename__ = 'analytics_reports'
__humanname__ = 'Выгруженные отчеты'
id = db.Column(db.Integer,
primary_key=True,
info={'verbose_name': 'Идентификатор записи'})
account_id = db.Column(
db.Integer,
nullable=False,
info={'verbose_name': 'Идентификатор подключенного аккаунта'})
processor_id = db.Column(db.Integer,
nullable=False,
info={'verbose_name': 'Идентификатор отчета'})
simple_date = db.Column(db.Date,
nullable=False,
info={'verbose_name': 'Дата отчета'})
row_id = db.Column(db.Integer,
nullable=False,
info={'verbose_name': 'Идентификатор строки'})
row_data = db.Column(db.UnicodeText,
nullable=False,
info={'verbose_name': 'Содержимое строки'})
__table_args__ = (
db.Index('analytics_reports_idx_1', account_id),
db.Index('analytics_reports_idx_2', processor_id),
db.Index('analytics_reports_idx_3', simple_date),
)
def __repr__(self):
return '<AnalyticsReport %r>' % self.id
class AnalyticsTransaction(db.Model):
__tablename__ = 'analytics_transactions'
__humanname__ = 'Параметры заказов'
id = db.Column(db.Integer,
primary_key=True,
info={'verbose_name': 'Идентификатор транзакции'})
account_id = db.Column(
db.Integer,
nullable=False,
info={'verbose_name': 'Идентификатор подключенного аккаунта'})
transaction_id = db.Column(
db.Unicode(128),
nullable=False,
info={'verbose_name': 'Внутренний идентификатор транзакции'})
unique_id = db.Column(db.Unicode(64),
info={'verbose_name': 'Уникальный идентификатор'})
__table_args__ = (
db.Index('analytics_transactions_idx_1', account_id),
db.Index('analytics_transactions_idx_2', transaction_id),
)
def __repr__(self):
return '<AnalyticsTransaction %r>' % self.transaction_id
def create_index(cls, engine):
""" Method to create Indexes for pairing table. """
devices_msisdn = db.Index('devices_msisdn_index',
cls.msisdn,
postgresql_concurrently=False)
devices_msisdn.create(bind=engine)
devices_imsi = db.Index('devices_imsi_index',
cls.imsi,
postgresql_concurrently=False)
devices_imsi.create(bind=engine)
devices_creation_date = db.Index('devices_creation_date_index',
cls.creation_date,
postgresql_concurrently=False)
devices_creation_date.create(bind=engine)
devices_end_date = db.Index('devices_end_date_index',
cls.end_date,
postgresql_concurrently=False)
devices_end_date.create(bind=engine)
devices_operator_name = db.Index('devices_operator_index',
cls.operator_name,
postgresql_concurrently=False)
devices_operator_name.create(bind=engine)
class LayerDiffFeatureversion(db.Model):
__tablename__ = 'layer_diff_featureversion'
__table_args__ = (
db.UniqueConstraint('layer_id', 'featureversion_id'),
db.Index('layer_diff_featureversion_layer_id_modification_idx',
'layer_id', 'modification'),
db.Index('layer_diff_featureversion_featureversion_id_layer_id_idx',
'featureversion_id', 'layer_id'))
id = db.Column(db.Integer,
primary_key=True,
server_default=db.FetchedValue())
layer_id = db.Column(db.ForeignKey(u'layer.id', ondelete=u'CASCADE'),
nullable=False,
index=True)
featureversion_id = db.Column(db.ForeignKey(u'featureversion.id'),
nullable=False,
index=True)
modification = db.Column(ENUM(u'add', u'del', name='modification'),
nullable=False)
featureversion = db.relationship(
u'Featureversion',
primaryjoin=
'LayerDiffFeatureversion.featureversion_id == Featureversion.id',
backref=u'layer_diff_featureversions')
layer = db.relationship(
u'Layer',
primaryjoin='LayerDiffFeatureversion.layer_id == Layer.id',
backref=u'layer_diff_featureversions')
def __repr__(self):
return '<Layer_id {} featureversion_id {} >'.format(
self.featureversion_id, self.layer_id)
class AnalyticsGoal(db.Model):
__tablename__ = 'analytics_goals'
__humanname__ = 'Параметры целей'
id = db.Column(db.Integer,
primary_key=True,
info={'verbose_name': 'Идентификатор цели'})
account_id = db.Column(
db.Integer,
nullable=False,
info={'verbose_name': 'Идентификатор подключенного аккаунта'})
goal_id = db.Column(db.Integer,
nullable=False,
info={'verbose_name': 'Внутренний идентификатор цели'})
name = db.Column(db.Unicode(256),
info={'verbose_name': 'Наименование цели'})
active = db.Column(db.Boolean, info={'verbose_name': 'Активность'})
__table_args__ = (
db.Index('analytics_goals_idx_1', account_id),
db.Index('analytics_goals_idx_2', goal_id),
)
def __repr__(self):
return '<AnalyticsGoal %r>' % self.goal_id
class AnalyticsProduct(db.Model):
__tablename__ = 'analytics_products'
__humanname__ = 'Параметры товаров'
id = db.Column(db.Integer,
primary_key=True,
info={'verbose_name': 'Идентификатор товара'})
account_id = db.Column(
db.Integer,
nullable=False,
info={'verbose_name': 'Идентификатор подключенного аккаунта'})
product_id = db.Column(
db.Unicode(64),
nullable=False,
info={'verbose_name': 'Внутренний идентификатор товара'})
category = db.Column(db.Unicode(256),
info={'verbose_name': 'Категория товара'})
brand = db.Column(db.Unicode(256), info={'verbose_name': 'Бренд товара'})
name = db.Column(db.Unicode(256),
info={'verbose_name': 'Наименование товара'})
__table_args__ = (
db.Index('analytics_products_idx_1', account_id),
db.Index('analytics_products_idx_2', product_id),
)
def __repr__(self):
return '<AnalyticsProduct %r>' % self.product_id
def create_index(cls, engine):
""" Create Indexes for Registration imeidevice table. """
reg_imei = db.Index('reg_imei_index', cls.imei, postgresql_concurrently=True)
reg_imei.create(bind=engine)
reg_normalized_imei = db.Index('reg_normalized_imei_index', cls.normalized_imei, postgresql_concurrently=True)
reg_normalized_imei.create(bind=engine)
class GeneralDate(db.Model):
__tablename__ = 'general_dates'
__humanname__ = 'Параметры дат'
id = db.Column(db.Integer,
primary_key=True,
info={'verbose_name': 'Идентификатор даты'})
full_date = db.Column(db.DateTime,
nullable=False,
info={'verbose_name': 'Дата и время'})
year = db.Column(db.Integer, nullable=False, info={'verbose_name': 'Год'})
quarter = db.Column(db.Integer,
nullable=False,
info={'verbose_name': 'Номер квартала'})
quarter_label = db.Column(db.Unicode(3),
nullable=False,
info={'verbose_name': 'Квартал'})
month = db.Column(db.Integer,
nullable=False,
info={'verbose_name': 'Номер месяца'})
month_label = db.Column(db.Unicode(10),
nullable=False,
info={'verbose_name': 'Месяц'})
week = db.Column(db.Integer,
nullable=False,
info={'verbose_name': 'Номер недели'})
weekday = db.Column(db.Integer,
nullable=False,
info={'verbose_name': 'Номер дня недели'})
weekday_label = db.Column(db.Unicode(11),
nullable=False,
info={'verbose_name': 'День недели'})
day = db.Column(db.Integer, nullable=False, info={'verbose_name': 'День'})
hour = db.Column(db.Integer, nullable=False, info={'verbose_name': 'Час'})
minute = db.Column(db.Integer,
nullable=False,
info={'verbose_name': 'Минута'})
date_hash = db.Column(db.Unicode(32),
nullable=False,
info={'verbose_name': 'Хеш-сумма записи'})
simple_date = db.Column(db.Date,
nullable=False,
info={'verbose_name': 'Дата'})
__table_args__ = (
db.Index('general_dates_idx_1', date_hash),
db.Index('general_dates_idx_2', full_date),
db.Index('general_dates_idx_3', simple_date),
)
def __repr__(self):
return '<GeneralDate %r>' % self.id
class GeneralCostFact(db.Model):
__tablename__ = 'general_costs_facts'
__humanname__ = 'Статистика по расходам'
id = db.Column(db.Integer,
primary_key=True,
info={'verbose_name': 'Идентификатор записи'})
account_id = db.Column(
db.Integer,
nullable=False,
info={'verbose_name': 'Идентификатор подключенного аккаунта'})
dates_id = db.Column(db.Integer,
db.ForeignKey(
'general_dates.id',
name='general_costs_facts_general_dates'),
nullable=False,
info={'verbose_name': 'Идентификатор даты'})
sites_id = db.Column(db.Integer,
db.ForeignKey(
'general_sites.id',
name='general_costs_facts_general_sites'),
nullable=False,
info={'verbose_name': 'Идентификатор сайта'})
traffic_id = db.Column(
db.Integer,
db.ForeignKey('general_traffic.id',
name='general_costs_facts_general_traffic'),
nullable=False,
info={'verbose_name': 'Идентификатор источника трафика'})
impressions = db.Column(db.Integer,
nullable=False,
info={'verbose_name': 'Показы'})
clicks = db.Column(db.Integer,
nullable=False,
info={'verbose_name': 'Клики'})
cost = db.Column(db.Numeric(18, 2),
nullable=False,
info={'verbose_name': 'Расходы'})
general_dates = db.relationship('GeneralDate', foreign_keys=dates_id)
general_traffic = db.relationship('GeneralTraffic',
foreign_keys=traffic_id)
general_sites = db.relationship('GeneralSite', foreign_keys=sites_id)
__table_args__ = (
db.Index('general_costs_facts_idx_1', account_id),
db.Index('general_costs_facts_idx_2', dates_id),
db.Index('general_costs_facts_idx_3', traffic_id),
)
def __repr__(self):
return '<GeneralCostFact %r>' % self.id
def create_index(cls, engine):
""" Method to create Indexes for devices table. """
devices_serialno = db.Index('devices_serialno_index', cls.serial_no, postgresql_concurrently=False)
devices_serialno.create(bind=engine)
devices_mac = db.Index('devices_mac_index', cls.mac, postgresql_concurrently=False)
devices_mac.create(bind=engine)
devices_model = db.Index('devices_model_index', cls.model, postgresql_concurrently=False)
devices_model.create(bind=engine)
devices_brand = db.Index('devices_brand_index', cls.brand, postgresql_concurrently=False)
devices_brand.create(bind=engine)
class FundNetValue(db.Model):
__tablename__ = 'fundsnetvalue'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
annualizedRate = db.Column(db.DECIMAL(precision=22, scale=18))
unitNav = db.Column(db.DECIMAL(precision=14, scale=10))
navDate = db.Column(db.DateTime())
createTime = db.Column(db.DateTime()) # 抓取时间
fundId = db.Column(db.Integer, db.ForeignKey('funds.id')) # 基金表id外键
fund = db.relationship('Fund', backref=db.backref('fundnetvalues', cascade="all, delete,delete-orphan"))
__table_args__ = (
# Funds表索引
db.Index('ix_navDate', 'navDate'), # 索引
db.Index('ix_id_navDate', 'id', 'navDate'), # 索引
)
class AnalyticsDevice(db.Model):
__tablename__ = 'analytics_devices'
__humanname__ = 'Параметры устройств'
id = db.Column(db.Integer,
primary_key=True,
info={'verbose_name': 'Идентификатор типа устройства'})
account_id = db.Column(
db.Integer,
nullable=False,
info={'verbose_name': 'Идентификатор подключенного аккаунта'})
category = db.Column(db.Unicode(16),
nullable=False,
info={'verbose_name': 'Тип устройства'})
browser = db.Column(db.Unicode(128), info={'verbose_name': 'Браузер'})
browser_version = db.Column(db.Unicode(128),
info={'verbose_name': 'Версия браузера'})
os = db.Column(db.Unicode(128),
info={'verbose_name': 'Операционная система'})
os_version = db.Column(
db.Unicode(128), info={'verbose_name': 'Версия операционной системы'})
__table_args__ = (db.Index('analytics_devices_idx_1', account_id), )
def __repr__(self):
return '<AnalyticsDevice %r>' % self.id
class CostStatic(db.Model):
__tablename__ = 'cost_static'
_local_id = db.Column('local_id', db.BigInteger, db.Sequence('cost_static_local_id_seq'), primary_key=True,
unique=True, autoincrement=True)
id = db.Column('id', db.BigInteger, db.ForeignKey('way_types.id'), nullable=False)
profile = db.Column('profile', db.BigInteger, db.ForeignKey('profiles.id'), nullable=False)
cost_forward = db.Column(db.Numeric(16, 8))
cost_reverse = db.Column(db.Numeric(16, 8))
# unique constraint: (id, profile)-tupel
__table_args__ = (db.Index('cost_static_uniq_idx', id, profile, unique=True), )
def __init__(self, id, profile, cost_forward, cost_reverse):
self.id = id # way_type id
self.profile = profile
self.cost_forward = cost_forward
self.cost_reverse = cost_reverse
def __repr__(self):
return '<cost_static %i, profile=%i>' % self.id, self.profile
def get_dict(self):
return {
'way_type': self.id,
'cost_forward': float(self.cost_forward),
'cost_reverse': float(self.cost_reverse),
}
def create_certificate_indexes():
"""
Create db indexes (7) for table 'certificate'.
This should be run *after* table population.
Existing indexes will not be recreated.
"""
from sqlalchemy.engine import reflection
insp = reflection.Inspector.from_engine(db.engine)
Index = namedtuple("Index", ["name_suffix", "attributes"])
indexes = (
Index("type_county_year", (Cert.type, Cert.county, Cert.year)),
Index("type_year", (Cert.type, Cert.year)),
Index("year", (Cert.year, )),
Index("county", (Cert.county, )),
Index("firstname", (Cert.first_name, )),
Index("lastname", (Cert.last_name, )),
Index("number", (Cert.number, )),
Index("soundex", (Cert.soundex, ))
)
for i, index in enumerate(indexes):
index_name = "idx_{}".format(index.name_suffix)
if set(attr.key for attr in index.attributes) in (
set(index["column_names"]) for index in insp.get_indexes(Cert.__tablename__)
):
print("{}\tAlready Created, Skipping\t{}".format(i, index_name))
continue
print("{}\t{}".format(i, index_name))
db.Index(index_name, *index.attributes).create(db.engine)
class Vulnerability(db.Model):
__tablename__ = 'vulnerability'
__table_args__ = (db.Index('vulnerability_namespace_id_name_idx',
'namespace_id', 'name'), )
id = db.Column(db.Integer,
primary_key=True,
server_default=db.FetchedValue())
namespace_id = db.Column(db.ForeignKey(u'namespace.id'), nullable=False)
name = db.Column(db.String(128), nullable=False, index=True)
description = db.Column(db.Text)
link = db.Column(db.String(128))
severity = db.Column(ENUM(u'Unknown',
u'Negligible',
u'Low',
u'Medium',
u'High',
u'Critical',
u'Defcon1',
name='severity'),
nullable=False)
metadata2 = db.Column(db.Text, name="metadata")
created_at = db.Column(db.DateTime(True))
deleted_at = db.Column(db.DateTime(True))
namespace = db.relationship(
u'Namespace',
primaryjoin='Vulnerability.namespace_id == Namespace.id',
backref=u'vulnerabilities')
class VulnerabilityFixedinFeature(db.Model):
__tablename__ = 'vulnerability_fixedin_feature'
__table_args__ = (
db.UniqueConstraint('vulnerability_id', 'feature_id'),
db.Index(
'vulnerability_fixedin_feature_feature_id_vulnerability_id_idx',
'feature_id', 'vulnerability_id'))
id = db.Column(db.Integer,
primary_key=True,
server_default=db.FetchedValue())
vulnerability_id = db.Column(db.ForeignKey(u'vulnerability.id',
ondelete=u'CASCADE'),
nullable=False)
feature_id = db.Column(db.ForeignKey(u'feature.id'), nullable=False)
version = db.Column(db.String(128), nullable=False)
feature = db.relationship(
u'Feature',
primaryjoin='VulnerabilityFixedinFeature.feature_id == Feature.id',
backref=u'vulnerability_fixedin_features')
vulnerability = db.relationship(
u'Vulnerability',
primaryjoin=
'VulnerabilityFixedinFeature.vulnerability_id == Vulnerability.id',
backref=u'vulnerability_fixedin_features')
class DirectionStatistic(db.Model):
__tablename__ = "direction_statistics"
id = db.Column(db.Integer, primary_key=True)
directions_count = db.Column(db.Integer)
messages_count = db.Column(db.Integer)
direction_data = db.Column(db.JSON)
# Relations
sender_id = db.Column(db.Integer,
db.ForeignKey("senders.id", ondelete="CASCADE"),
index=True)
sender = db.relationship("Sender",
foreign_keys=[sender_id],
backref=db.backref(
"direction_stats",
order_by=directions_count.desc()))
receiver_id = db.Column(db.Integer,
db.ForeignKey("receivers.id", ondelete="CASCADE"),
index=True)
receiver = db.relationship("Receiver",
foreign_keys=[receiver_id],
backref=db.backref(
"direction_stats",
order_by=directions_count.desc()))
__table_args__ = (db.Index('idx_direction_statistics_uc',
'sender_id',
'receiver_id',
unique=True), )
class TakeoffLanding(db.Model):
__tablename__ = "takeoff_landings"
id = db.Column(db.Integer, primary_key=True)
timestamp = db.Column(db.DateTime)
is_takeoff = db.Column(db.Boolean)
track = db.Column(db.SmallInteger)
# Relations
sender_id = db.Column(db.Integer,
db.ForeignKey("senders.id", ondelete="CASCADE"))
sender = db.relationship("Sender",
foreign_keys=[sender_id],
backref="takeoff_landings")
airport_id = db.Column(db.Integer,
db.ForeignKey("airports.id", ondelete="SET NULL"))
airport = db.relationship("Airport",
foreign_keys=[airport_id],
backref="takeoff_landings")
country_id = db.Column(db.Integer,
db.ForeignKey("countries.gid", ondelete="CASCADE"),
index=True)
country = db.relationship("Country",
foreign_keys=[country_id],
backref="takeoff_landings")
__table_args__ = (db.Index('idx_takeoff_landings_uc',
'timestamp',
'sender_id',
'airport_id',
unique=True), )
class CVEGroupEntry(db.Model):
id = db.Column(db.Integer(),
index=True,
unique=True,
primary_key=True,
autoincrement=True)
group_id = db.Column(db.Integer(),
db.ForeignKey('cve_group.id', ondelete="CASCADE"),
nullable=False)
cve_id = db.Column(db.String(15),
db.ForeignKey('cve.id', ondelete="CASCADE"),
nullable=False)
group = db.relationship("CVEGroup", back_populates="issues")
cve = db.relationship("CVE")
__tablename__ = 'cve_group_entry'
__table_args__ = (db.Index('cve_group_entry__group_cve_idx',
group_id,
cve_id,
unique=True), )
def __repr__(self):
return '<CVEGroupEntry %r from %r referencing %r>' % (
self.id, self.group_id, self.cve_id)
class SelfSelectedStock(db.Model):
__tablename__ = 'self_selected_stock'
__table_args__ = (
db.UniqueConstraint('email', 'code', name='uix_email_code'),
db.Index('ix_email_code', 'email', 'code'),
)
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(128), nullable=False)
code = db.Column(db.String(8), nullable=False)
labels = db.Column(db.String(128))
deleted = db.Column(db.Boolean, default=False, nullable=False)
update_time = db.Column(db.DateTime, nullable=False)
def __init__(self, email, code, labels, deleted=False):
self.code = code
self.email = email
self.labels = labels
self.deleted = deleted
self.update_time = datetime.datetime.now()
def to_json(self):
result = {}
result['email'] = self.email
result['code'] = self.code
result['labels'] = self.labels
result['deleted'] = self.deleted
return result
class GeneralAccounts(db.Model):
__tablename__ = 'general_accounts'
__humanname__ = 'Параметры источников данных'
id = db.Column(db.Integer,
primary_key=True,
info={'verbose_name': 'Идентификатор записи'})
account_id = db.Column(
db.Integer,
nullable=False,
info={'verbose_name': 'Идентификатор подключенного аккаунта'})
caption = db.Column(db.Unicode(128),
nullable=False,
info={'verbose_name': 'Название источника'})
service = db.Column(db.Unicode(64),
nullable=False,
info={'verbose_name': 'Сервис'})
enabled = db.Column(db.Boolean,
nullable=False,
info={'verbose_name': 'Включен'})
status = db.Column(db.Unicode(32),
info={'verbose_name': 'Статус загрузки'})
interval_start = db.Column(db.Date,
info={'verbose_name': 'Дата начала интервала'})
interval_end = db.Column(db.Date,
info={'verbose_name': 'Дата окончания интервала'})
__table_args__ = (db.Index('general_accounts_idx_1', account_id), )
def __repr__(self):
return '<GeneralAccounts %r>' % self.id
def create_index(cls, engine):
""" Create Indexes for pairing_codes table. """
devices_paircodes = db.Index('devices_paircodes_index',
cls.pair_code,
postgresql_concurrently=False)
devices_paircodes.create(bind=engine)
def create_index(cls, engine):
""" Method to create Indexes for Owner table. """
owner_contact = db.Index('owner_contact_index',
cls.contact,
postgresql_concurrently=False)
owner_contact.create(bind=engine)
class AnalyticsHit(db.Model):
__tablename__ = 'analytics_hits'
__humanname__ = 'Полученные хиты'
id = db.Column(db.Integer,
primary_key=True,
info={'verbose_name': 'Идентификатор записи'})
account_id = db.Column(
db.Integer,
nullable=False,
info={'verbose_name': 'Идентификатор подключенного аккаунта'})
full_date = db.Column(db.DateTime,
nullable=False,
info={'verbose_name': 'Дата и время хита'})
clientid = db.Column(
db.Unicode(64),
nullable=False,
info={'verbose_name': 'Идентификатор посетителя сайта'})
hit = db.Column(db.UnicodeText,
nullable=False,
info={'verbose_name': 'Параметры хита'})
__table_args__ = (db.Index('analytics_hits_idx_1', account_id), )
def __repr__(self):
return '<AnalyticsHit %r>' % self.id
class ProfileDescriptions(db.Model):
__tablename__ = 'profile_descriptions'
_local_id = db.Column('local_id',
db.BigInteger,
db.Sequence('profile_descriptions_local_id_seq'),
primary_key=True,
unique=True,
autoincrement=True)
id = db.Column('id',
db.BigInteger,
db.ForeignKey('profiles.id'),
nullable=False)
language = db.Column(db.Text, nullable=False)
description = db.Column(db.Text, nullable=False)
# Unique constraint: (id, language must be unique)
__table_args__ = (db.Index('profile_desc_uniq_idx',
id,
language,
unique=True), )
default_language = 'en-US'
def __init__(self, id, language, description):
# 'id' auto increment
self.id = id
self.language = language
self.description = description
def __repr__(self):
return '<profile_description %i %s>' % self.id, self.name
class Record(db.Model):
__tablename__ = 'records'
__table_args__ = (db.Index('nametype_index', 'name', 'type'), )
id = db.Column(db.Integer, primary_key=True)
domain_id = db.Column(db.ForeignKey('domains.id',
ondelete='CASCADE',
onupdate='CASCADE'),
index=True,
server_default=db.FetchedValue())
name = db.Column(db.String(255),
index=True,
server_default=db.FetchedValue())
type = db.Column(db.String(10), server_default=db.FetchedValue())
content = db.Column(db.String(65535), server_default=db.FetchedValue())
ttl = db.Column(db.Integer, server_default=db.FetchedValue())
prio = db.Column(db.Integer, server_default=db.FetchedValue())
disabled = db.Column(db.Boolean, server_default=db.FetchedValue())
ordername = db.Column(db.String(255), index=True)
auth = db.Column(db.Boolean, server_default=db.FetchedValue())
domain = db.relationship(
'Domain',
primaryjoin='Record.domain_id == Domain.id',
backref='records',
)
class ReceiverCoverageStatistic(db.Model):
__tablename__ = "receiver_coverage_statistics"
id = db.Column(db.Integer, primary_key=True)
date = db.Column(db.Date)
location_mgrs_short = db.Column(db.String(9))
is_trustworthy = db.Column(db.Boolean)
messages_count = db.Column(db.Integer)
max_distance = db.Column(db.Float(precision=2))
max_normalized_quality = db.Column(db.Float(precision=2))
max_signal_quality = db.Column(db.Float(precision=2))
min_altitude = db.Column(db.Float(precision=2))
max_altitude = db.Column(db.Float(precision=2))
senders_count = db.Column(db.Integer)
# Relations
receiver_id = db.Column(db.Integer,
db.ForeignKey("receivers.id", ondelete="CASCADE"),
index=True)
receiver = db.relationship("Receiver",
foreign_keys=[receiver_id],
backref=db.backref("receiver_coverage_stats",
order_by=date))
__table_args__ = (db.Index('idx_receiver_coverage_statistics_uc',
'date',
'receiver_id',
'location_mgrs_short',
'is_trustworthy',
unique=True), )
def create_index(cls, engine):
""" Create Indexes for imei table. """
devices_imei = db.Index('devices_imei_index',
cls.imei,
postgresql_concurrently=False)
devices_imei.create(bind=engine)
class Friend(db.Model):
id = db.Column(db.Integer, primary_key=True)
first_username = db.Column(db.String(64), db.ForeignKey(User.username))
second_username = db.Column(db.String(64), db.ForeignKey(User.username))
status = db.Column(db.String(64))
timestamp = db.Column(db.DateTime)
action_username = db.Column(db.String(64), db.ForeignKey(User.username))
__table_args__ = (db.Index('myIndex',
'first_username',
'second_username',
unique=True), {})
def __repr__(self):
return '<%s and %s have friendship status %s >' % (
self.first_username, self.second_username, self.status)
@staticmethod
def are_friends(user1, user2):
if Friend.query.filter_by(first_username=user1,second_username=user2,status='Accepted').first() \
or Friend.query.filter_by(first_username=user2, second_username=user1, status='Accepted').first():
return True
return False
@staticmethod
def count_friends(user1):
frndlist1 = Friend.query.filter_by(first_username=user1,
status='Accepted')
frndlist2 = Friend.query.filter_by(second_username=user1,
status='Accepted')
frndlist = frndlist1.union(frndlist2)
count = 0
for f in frndlist:
count += 1
return count
