class t_host_cpu(db.Model):
"""定义数据模型"""
__tablename__ = "t_host_cpu"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
ctime = db.Column(db.DateTime, nullable=False, comment="采集时间", index=True)
itime = db.Column(db.DateTime,
nullable=False,
default=datetime.datetime.now,
comment="入库时间")
ip = db.Column(db.String(20), nullable=False, comment="服务器IP")
cpu = db.Column(db.Float(5, 2), nullable=False, comment="使用率")
cpu_user_rate = db.Column(db.Float(5, 2), nullable=False, comment="用户态")
cpu_nice_rate = db.Column(db.Float(5, 2), nullable=False, comment="权限调整")
cpu_system_rate = db.Column(db.Float(5, 2), nullable=False, comment="内核态")
cpu_idle_rate = db.Column(db.Float(5, 2), nullable=False, comment="空闲")
cpu_iowait_rate = db.Column(db.Float(5, 2), nullable=False, comment="IO阻塞")
cpu_irq_rate = db.Column(db.Float(5, 2), nullable=False, comment="硬中断")
cpu_softirq_rate = db.Column(db.Float(5, 2), nullable=False, comment="软中断")
ld_1 = db.Column(db.Float(5, 2), nullable=False, comment="1分钟负载")
ld_2 = db.Column(db.Float(5, 2), nullable=False, comment="5分钟负载")
ld_3 = db.Column(db.Float(5, 2), nullable=False, comment="15分钟负载")
proc_run = db.Column(db.SmallInteger(), nullable=False, comment="当前运行pid")
proc_sub = db.Column(db.SmallInteger(), nullable=False, comment="合计PID数")
class t_host_ram(db.Model):
"""定义数据模型"""
__tablename__ = "t_host_ram"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
ctime = db.Column(db.DateTime, nullable=False, comment="采集时间", index=True)
itime = db.Column(db.DateTime,
default=datetime.datetime.now,
comment="入库时间")
ip = db.Column(db.String(20), nullable=False, comment="服务器IP")
mem = db.Column(db.SmallInteger(), nullable=False, comment="内存使用率")
swap = db.Column(db.SmallInteger(), nullable=False, comment="swap使用率")
class Submission(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(150), nullable=False)
subtitles = db.Column(ARRAY(db.String(150)), nullable=True)
# agency_ein = db.Column(db.String(4), db.ForeignKey('agency.ein'), nullable=False)
additional_creators = db.Column(ARRAY(db.String(150)), nullable=True)
subjects = db.Column(ARRAY(db.String), nullable=False)
description = db.Column(db.String(300), nullable=False)
date_published = db.Column(db.Date, nullable=False)
report_type = db.Column(db.Enum(ReportTypeEnum), nullable=False)
languages = db.Column(ARRAY(db.String()), nullable=False)
fiscal_years = db.Column(ARRAY(db.SmallInteger()), nullable=True)
calendar_years = db.Column(ARRAY(db.SmallInteger()), nullable=True)
boroughs = db.Column(ARRAY(db.Enum(BoroughEnum)), nullable=True)
school_districts = db.Column(ARRAY(db.Enum(SchoolDistrictEnum)),
nullable=True)
community_board_districts = db.Column(ARRAY(
db.Enum(CommunityBoardDistrictEnum)),
nullable=True)
def __init__(
self,
title,
# agency_ein,
subjects,
description,
date_published,
report_type,
languages,
subtitles=None,
additional_creators=None,
fiscal_years=None,
calendar_years=None,
boroughs=None,
school_districts=None,
community_board_districts=None):
self.title = title
# self.agency_ein = agency_ein
self.subjects = subjects
self.description = description
self.date_published = date_published
self.report_type = report_type
self.languages = languages
self.additional_creators = additional_creators
self.fiscal_years = fiscal_years
self.calendar_years = calendar_years
self.boroughs = boroughs
self.school_districts = school_districts
self.community_board_districts = community_board_districts
self.subtitles = subtitles
class PartCast(db.Model):
time = db.Column(db.DateTime(timezone=True),
primary_key=True,
default=func.now())
pn = db.Column(db.String())
lot = db.Column(db.String())
hanger = db.Column(db.SmallInteger())
class ShellActivity(db.Model):
ts = db.Column(db.DateTime(timezone=True),
primary_key=True,
default=func.now())
room = db.Column(db.String())
action = db.Column(db.String())
pn = db.Column(db.String())
lot = db.Column(db.String())
hanger = db.Column(db.SmallInteger())
class Records(db.Model):
"""Model for the records database table."""
__bind_key__ = 'powerdnsadmin'
__tablename__ = 'records'
id = db.Column(db.INTEGER(), primary_key=True, nullable=False)
domain_id = db.Column(db.INTEGER())
name = db.Column(db.VARCHAR(length=255))
type = db.Column(db.VARCHAR(length=10))
content = db.Column(db.VARCHAR(length=64000))
ttl = db.Column(db.INTEGER())
prio = db.Column(db.INTEGER())
change_date = db.Column(db.INTEGER())
disabled = db.Column(db.SmallInteger())
ordername = db.Column(db.VARCHAR(length=255))
auth = db.Column(db.SmallInteger())
def __repr__(self):
"""Represent an instance of the class."""
return '%s %s %s %s %s' % (self.id, self.domain_id, self.type,
self.name, self.content)
class HostsAllow(db.Model):
# список хостов, которые получают настройки по dhcp сервера
id = db.Column(db.SmallInteger(), primary_key=True, autoincrement=True)
hostname = db.Column(db.VARCHAR(32), nullable=False)
mac_addr = db.Column(db.VARCHAR(18), nullable=False, unique=True)
def __init__(self, *args, **kwargs):
super(HostsAllow, self).__init__(*args, **kwargs)
def __repr__(self):
return'<HostsAllow id: {}, hostname: {}, mac_addr: {}>' \
.format(self.id, self.hostname, self.mac_addr)
class ReservedIpv4(db.Model):
# список хостов, для которых зарезервированы ip адреса
id = db.Column(db.SmallInteger(), primary_key=True, autoincrement=True)
hostname = db.Column(db.VARCHAR(32), nullable=False)
mac_addr = db.Column(db.VARCHAR(18), nullable=False)
res_ipv4 = db.Column(db.VARCHAR(15), nullable=False, unique=True)
def __init__(self, *args, **kwargs):
super(ReservedIpv4, self).__init__(*args, **kwargs)
def __repr__(self):
return'<ReservedIpv4 id: {}, hostname: {}, mac_addr: {} res_ipv4: {}>' \
.format(self.id, self.hostname, self.mac_addr, self.res_ipv4)
class User(UserMixin, db.Model):
'''Таблица с пользователями и их паролями'''
id = db.Column(db.SmallInteger(), primary_key=True, autoincrement=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password_hash = db.Column(db.String(128))
def __repr__(self):
return '<User {}>'.format(self.username)
def set_password(self, password):
'''Генерируем хэш пароля'''
self.password_hash = generate_password_hash(password)
def check_password(self, password):
'''Проверка пароля'''
return check_password_hash(self.password_hash, password)
class Result(Base):
__tablename__ = 'result'
password = db.Column(db.String(256), nullable=True)
length = db.Column(db.SmallInteger(), nullable=True)
letters = db.Column(db.SmallInteger(), nullable=True)
digits = db.Column(db.SmallInteger(), nullable=True)
uppercase = db.Column(db.SmallInteger(), nullable=True)
lowercase = db.Column(db.SmallInteger(), nullable=True)
symbols = db.Column(db.SmallInteger(), nullable=True)
position = db.Column(db.Integer(), nullable=True)
guesses = db.Column(db.String(256), nullable=True)
score = db.Column(db.SmallInteger(), nullable=True)
online_time_1 = db.Column(db.String(256), nullable=True)
online_time_2 = db.Column(db.String(256), nullable=True)
offline_time_1 = db.Column(db.String(256), nullable=True)
offline_time_2 = db.Column(db.String(256), nullable=True)
class Location(db.Model):
"""
Model representing the location of an item, which might be a stash page
or a character
"""
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), nullable=False)
page_no = db.Column(db.SmallInteger())
is_premium = db.Column(db.Boolean, nullable=False, default=False)
is_character = db.Column(db.Boolean, nullable=False, default=False)
items = db.relationship("Item", backref="location")
def __str__(self):
if self.is_character:
return self.name
return "Stash: %s" % self.name
def __repr__(self):
return self.__str__()
class ProductModel(db.Model):
__tablename__ = 'product'
id = db.Column(db.BigInteger, primary_key=True)
name = db.Column(db.String())
description = db.Column(db.String())
price = db.Column(db.Integer())
pieces_left = db.Column(db.Integer())
category = db.Column(db.String())
specifications = db.Column(db.String())
box_dimensions = db.Column(db.String())
weight = db.Column(db.SmallInteger())
img_paths = db.Column(db.String())
def __init__(self, **kwargs):
super(ProductModel).__init__(**kwargs)
def __repr__(self):
return f"<Product {self.name}>"
class Service(Base):
__tablename__ = 'services'
name = db.Column(db.String(120))
# FIXME: This should be an enum or limited
category = db.Column(db.String())
description = db.Column(db.Text())
lat = db.Column(db.Float())
lng = db.Column(db.Float())
address = db.Column(db.String())
city = db.Column(db.String())
state_abbreviation = db.Column(db.String(2))
postal_code = db.Column(db.SmallInteger())
operating_hours = db.Column(db.JSON())
active = db.Column(db.Boolean())
def __init__(
self,
name: str,
category: str,
description: str,
lat: float,
lng: float,
address: str,
city: str,
state_abbreviation: str,
postal_code: int,
operating_hours: dict,
active: bool = True,
):
self.name = name
self.category = category
self.description = description
self.lat = lat
self.lng = lng
self.address = address
self.city = city
self.state_abbreviation = state_abbreviation
self.postal_code = postal_code
self.operating_hours = operating_hours
self.active = active
class User(db.Model):
"""
每一个属性定义过一个字段
"""
id = db.Column(db.Integer, primary_key=True)
nickname = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
role = db.Column(db.SmallInteger(), default=ROLE_USER)
password = db.Column(db.String(10), index=True, unique=True)
posts = db.relationship('Post', backref='author', lazy='dynamic')
def is_authenticated(self):
return True
def is_active(self):
return True
def is_anonymous(self):
return True
def get_id(self):
return unicode(self.id)
@classmethod
def login_check(cls, user_name, passwd):
print "-==========================="
print user_name
user = cls.query.filter(
db.or_(User.nickname == user_name,
User.email == user_name)).first()
if not user or passwd != user.password:
return None
return user
def __repr__(self):
return '<User %r>' % (self.nickname)
class Proposal(db.Model):
__tablename__ = 'proposals'
id = db.Column(db.String(), primary_key=True)
user1_id = db.Column(db.String(), nullable=False)
user2_id = db.Column(db.String(), nullable=False)
location = db.Column(db.String(), nullable=False)
delay = db.Column(db.SmallInteger(), nullable=False)
user1_accepted = db.Column(db.Boolean())
user2_accpeted = db.Column(db.Boolean())
created = db.Column(db.DateTime(), default=db.func.current_timestamp())
def __init__(self, user1_id, user2_id, location, delay):
self.id = str(uuid.uuid1())
self.user1_id = user1_id
self.user2_id = user2_id
self.location = location
self.delay = delay
self.user1_accepted = None
self.user2_accepted = None
def update_accepted(accepted):
self.accepted = accepted
def as_json(self):
location = Location.query.filter(Location.id == self.location).first()
return {
'id': self.id,
'user1_id': self.user1_id,
'user2_id': self.user2_id,
'location': location.as_json(),
'delay': self.delay,
'user1_accepted': self.user1_accepted,
'user2_accepted': self.user1_accepted,
'created': self.created
}
class Book(db.Model):
formats = ['hardcover', 'softcover']
ISBN = db.Column(db.String(13), primary_key=True)
title = db.Column(db.String(), nullable=False)
authors = db.Column(ARRAY(db.String()), nullable=False)
publisher = db.Column(db.String(), nullable=False)
year_of_publication = db.Column(db.SmallInteger(), nullable=False)
stock = db.Column(db.Integer(), nullable=False)
price = db.Column(db.Numeric(), nullable=False)
format = db.Column(db.Enum('hardcover', 'softcover', name='formats'),
nullable=False)
subject = db.Column(db.String(), nullable=False)
keywords = db.Column(ARRAY(db.String()), nullable=False)
reviews = db.relationship('Review',
backref=db.backref('book', lazy='joined'),
lazy='dynamic')
def __init__(self, **kwargs):
self.ISBN = kwargs['ISBN']
self.title = kwargs['title']
self.authors = kwargs['authors']
self.publisher = kwargs['publisher']
self.year_of_publication = kwargs['year_of_publication']
self.stock = kwargs['stock']
self.price = kwargs['price']
self.format = kwargs['format']
self.subject = kwargs['subject']
self.keywords = kwargs['keywords']
def __repr__(self):
return '{} ISBN: {}'.format(self.title, self.ISBN)
def customers(self):
orders_with_book = Order.query.filter(
Order.books_orders.any(book=self)).all()
customer_usernames = {
order.customer_username
for order in orders_with_book
}
return {
Customer.query.get(username)
for username in customer_usernames
}
def total_sales_to_similar_customers(self, book):
similar_customers = self.customers() & book.customers()
sales = 0
for customer in similar_customers:
for order in customer.orders.all():
for books_orders in order.books_orders.all():
sales += books_orders.quantity
return sales
def total_sales_in_month(self, month, year):
num_days = calendar.monthrange(year, month)[1]
start_date = datetime.date(year, month, 1)
end_date = datetime.date(year, month, num_days)
orders_in_month = Order.query.filter(
Order.books_orders.any(book=self)).filter(
Order.date >= start_date).filter(Order.date <= end_date).all()
sales = 0
for order in orders_in_month:
for books_orders in order.books_orders.filter_by(book=self):
sales += books_orders.quantity
return sales
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password_hash = db.Column(db.String(128))
about_me = db.Column(db.String(140))
age = db.Column(db.SmallInteger())
last_seen = db.Column(db.DateTime, default=datetime.utcnow)
posts = db.relationship('Post', backref='author', lazy='dynamic')
followed = db.relationship(
argument='User', #The right side of the relationship
secondary=followers, #Which table holds this relationship
primaryjoin=(followers.c.follower_id == id
), #The join condition for the left side
secondaryjoin=(followers.c.followed_id == id
), #The join condition for the right side
backref=db.backref(
'followers', lazy='dynamic'
), #How the relationship will be accesed from the right side
lazy='dynamic' #
)
def __repr__(self):
return '<User {}>'.format(self.username)
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
def forgot_password_generate(self, length=None):
new_password = ""
possibleValues = "abcdefghijklmnopqrstuvwxyz"
if length is None:
length = 4
for i in range(length):
new_password = new_password + possibleValues[random.randint(
0, len(possibleValues))]
return new_password
def follow(self, user):
if not self.is_following(user):
self.followed.append(user)
def unfollow(self, user):
if self.is_following(user):
self.followed.remove(user)
def is_following(self, user):
return self.followed.filter(
followers.c.followed_id == user.id).count() > 0
def get_followed(self):
return self.followed
def get_followers(self):
return self.followers
def followed_posts(self):
followed = Post.query.join(
followers, (followers.c.followed_id == Post.user_id)).filter(
followers.c.follower_id == self.id)
own = Post.query.filter_by(user_id=self.id)
return followed.union(own).order_by(Post.timestamp.desc())
def avatar(self, size):
digest = md5(self.email.lower().encode('utf-8')).hexdigest()
return 'https://www.gravatar.com/avatar/{}?d=identicon&s={}'.format(
digest, size)
class Replay(db.Model):
__tablename__ = "replays"
#################
# Table columns #
#################
id = db.Column(db.Integer,
primary_key=True) # optional uint32 match_id = 6;
local_uri = db.Column(db.String(128), index=True)
state = db.Column(db.Enum("WAITING_GC", "WAITING_DOWNLOAD",
"DOWNLOAD_IN_PROGRESS", "ARCHIVED", "GC_ERROR",
"DOWNLOAD_ERROR"),
default="WAITING_GC",
index=True)
gc_fails = db.Column(db.Integer, default=0)
dl_fails = db.Column(db.Integer, default=0)
# Timestamps for progress tracker
added_to_site_time = db.Column(db.DateTime,
default=datetime.datetime.utcnow,
index=True)
gc_done_time = db.Column(db.DateTime, index=True)
dl_done_time = db.Column(db.DateTime, index=True)
# Match data
replay_state = db.Column(
db.Enum("REPLAY_AVAILABLE", "REPLAY_NOT_RECORDED", "REPLAY_EXPIRED",
"UNKNOWN"),
default="UNKNOWN",
index=True
) # optional .CMsgDOTAMatch.ReplayState replay_state = 34 [default = REPLAY_AVAILABLE];
replay_cluster = db.Column(db.Integer()) # optional uint32 cluster = 10;
replay_salt = db.Column(db.Integer()) # optional fixed32 replay_salt = 13;
game_mode = db.Column(
db.SmallInteger(), index=True
) # optional .DOTA_GameMode game_mode = 31 [default = DOTA_GAMEMODE_NONE];
match_seq_num = db.Column(
db.Integer()) # optional uint64 match_seq_num = 33;
lobby_type = db.Column(
db.SmallInteger()) # optional uint32 lobby_type = 16;
league_id = db.Column(db.Integer(),
db.ForeignKey("leagues.id"),
nullable=True) # optional uint32 leagueid = 22;
series_id = db.Column(db.Integer()) # optional uint32 series_id = 39;
series_type = db.Column(db.Integer()) # optional uint32 series_type = 40;
good_guys_win = db.Column(db.Boolean()) # optional bool good_guys_win = 2;
duration = db.Column(db.Integer()) # optional uint32 duration = 3;
start_time = db.Column(db.Integer()) # optional fixed32 startTime = 4;
first_blood_time = db.Column(
db.Integer()) # optional uint32 first_blood_time = 12;
human_players = db.Column(
db.Integer()) # optional uint32 human_players = 17;
radiant_tower_status = db.Column(
db.Integer()) # repeated uint32 tower_status = 8;
dire_tower_status = db.Column(db.Integer())
radiant_barracks_status = db.Column(
db.Integer()) # repeated uint32 barracks_status = 9;
dire_barracks_status = db.Column(db.Integer())
radiant_team_id = db.Column(
db.Integer(), index=True) # optional uint32 radiant_team_id = 20;
radiant_team_name = db.Column(
db.String(80), index=True) # optional string radiant_team_name = 23;
radiant_team_logo = db.Column(
db.BigInteger()) # optional uint64 radiant_team_logo = 25;
radiant_team_tag = db.Column(
db.String(80)) # optional string radiant_team_tag = 37;
radiant_team_complete = db.Column(
db.Boolean()) # optional uint32 radiant_team_complete = 27;
dire_team_id = db.Column(db.Integer(),
index=True) # optional uint32 dire_team_id = 21;
dire_team_name = db.Column(
db.String(80), index=True) # optional string dire_team_name = 24;
dire_team_logo = db.Column(
db.BigInteger()) # optional uint64 dire_team_logo = 26;
dire_team_tag = db.Column(
db.String(80)) # optional string dire_team_tag = 38;
dire_team_complete = db.Column(
db.Boolean()) # optional uint32 dire_team_complete = 28;
radiant_guild_id = db.Column(
db.Integer()) # optional uint32 radiant_guild_id = 35;
dire_guild_id = db.Column(
db.Integer()) # optional uint32 dire_guild_id = 36;
# Not implementing
# optional fixed32 server_ip = 14; # Not exposed to client
# optional uint32 server_port = 15; # Not exposed to client
# optional uint32 average_skill = 18; # Not exposed to client
# optional float game_balance = 19; # Not exposed to client
# optional uint32 positive_votes = 29; # Variable, not worth serializing to DB. Perhaps memcached with websockets GC reqs
# optional uint32 negative_votes = 30; # Variable, not worth serializing to DB.
#################
# Relationships #
#################
# GC relationships
players = db.relationship('ReplayPlayer',
backref="replay",
lazy="join",
cascade="all, delete-orphan"
) # repeated .CMsgDOTAMatch.Player players = 5;
# repeated .CMatchHeroSelectEvent picks_bans = 32; # TODO
# Site relationships
ratings = db.relationship('ReplayRating',
backref='replay',
lazy='joined',
cascade="all, delete-orphan")
favourites = db.relationship('ReplayFavourite',
backref='replay',
lazy='joined',
cascade="all, delete-orphan")
downloads = db.relationship('ReplayDownload',
backref="replay",
lazy="dynamic",
cascade="all, delete-orphan")
aliases = db.relationship('ReplayAlias',
backref="replay",
lazy="dynamic",
cascade="all, delete-orphan")
###############
# Static data #
###############
# Game mode data interpreted from the game's protobufs:
# https://github.com/SteamRE/SteamKit/blob/master/Resources/Protobufs/dota/dota_gcmessages_common.proto#L407
game_mode_strings = [
"Invalid (0)", # DOTA_GAMEMODE_NONE = 0;
"All Pick", # DOTA_GAMEMODE_AP = 1;
"Captain's Mode", # DOTA_GAMEMODE_CM = 2;
"Random Draft", # DOTA_GAMEMODE_RD = 3;
"Standard Draft", # DOTA_GAMEMODE_SD = 4;
"All Random", # DOTA_GAMEM ODE_AR = 5;
"Invalid (6)", # DOTA_GAMEMODE_INTRO = 6;
"Diretide", # DOTA_GAMEMODE_HW = 7;
"Reverse Captains Mode", # DOTA_GAMEMODE_REVERSE_CM = 8;
"The Greeviling", # DOTA_GAMEMODE_XMAS = 9;
"Tutorial", # DOTA_GAMEMODE_TUTORIAL = 10;
"Mid Only", # DOTA_GAMEMODE_MO = 11;
"Least Played", # DOTA_GAMEMODE_LP = 12;
"Limited Heroes", # DOTA_GAMEMODE_POOL1 = 13;
"Compendium", # DOTA_GAMEMODE_FH = 14;
"Invalid (15)", # DOTA_GAMEMODE_CUSTOM = 15;
"Captains Draft", # DOTA_GAMEMODE_CD = 16;
"Balanced Draft", # DOTA_GAMEMODE_BD = 17;
"Ability Draft", # DOTA_GAMEMODE_ABILITY_DRAFT = 18;
"Invalid (19)" # DOTA_GAMEMODE_EVENT = 19;
]
# Lobby data interpreted from the game's protobufs:
# https://github.com/SteamRE/SteamKit/blob/master/Resources/Protobufs/dota/dota_gcmessages_common.proto#L824
lobby_type_strings = [
"Public Matchmaking", "Practice Game", "Tournament Game",
"Invalid (3)", "Co-op Bot", "Team Matchmaking", "Solo Matchmaking",
"Ranked Match"
]
# Set default order by
__mapper_args__ = {"order_by": [db.desc(added_to_site_time)]}
# Object cache
_team_players = None # Object cache for team_players so if it's poked before being cached we dont need to call the database for this info.
def __init__(self,
id=None,
replay_state="UNKNOWN",
state="WAITING_GC",
skip_webapi=False):
self.id = id
self.replay_state = replay_state
self.state = state
if not skip_webapi:
self._populate_from_webapi()
def __repr__(self):
return "<Replay {}>".format(self.id)
def _populate_from_webapi(self, match_data=None):
""" Populates a new replay object with data from WebAPI.
"""
try:
if not match_data:
match_data = steam.api.interface(
"IDOTA2Match_570").GetMatchDetails(
match_id=self.id).get("result")
if match_data:
self.good_guys_win = match_data.get('radiant_win')
self.duration = match_data.get('duration')
self.start_time = match_data.get('start_time')
self.match_seq_num = match_data.get('match_seq_num')
self.radiant_tower_status = match_data.get(
'tower_status_radiant')
self.dire_tower_status = match_data.get('tower_status_dire')
self.radiant_barracks_status = match_data.get(
'barracks_status_radiant')
self.dire_barracks_status = match_data.get(
'barracks_status_dire')
self.replay_cluster = match_data.get('cluster')
self.first_blood_time = match_data.get('first_blood_time')
self.lobby_type = match_data.get('lobby_type')
self.human_players = match_data.get('human_players')
self.league_id = match_data.get('leagueid')
self.game_mode = match_data.get('game_mode')
# Team info
self.radiant_team_id = match_data.get('radiant_team_id')
self.radiant_team_name = match_data.get('radiant_name')
self.radiant_team_logo = match_data.get('radiant_logo')
self.radiant_team_complete = match_data.get(
'radiant_team_complete')
self.dire_team_id = match_data.get('dire_team_id')
self.dire_team_name = match_data.get('dire_name')
self.dire_team_logo = match_data.get('dire_logo')
self.dire_team_complete = match_data.get('dire_team_complete')
except steam.api.HTTPError:
pass
@property
def url(self):
return "http://replay{}.valve.net/570/{}_{}.dem.bz2".format(
self.replay_cluster, self.id, self.replay_salt)
@property
def lobby_type_string(self):
""" Returns a human-friendly string for the replay's lobby type. """
try:
return Replay.lobby_type_strings[self.lobby_type]
except (IndexError, TypeError):
if self.lobby_type:
return "Invalid ({})".format(self.lobby_type)
else:
return "No lobby type specificed"
@property
def game_mode_string(self):
""" Returns a human-friendly string for the replay's game mode. """
try:
return Replay.game_mode_strings[self.game_mode]
except (IndexError, TypeError):
if self.game_mode:
return "Invalid ({})".format(self.game_mode)
else:
return "No game mode specified"
@property
def team_players(self):
""" Returns a tuple (radiant, dire) after splitting the replays players into teams. """
# Sort players by their in-game slot
# If we have this cached in the object then serve it. This means we can cache replays and poke
# team_players without requiring extra DB calls, as long as team_players was poked pre-cache.
if self._team_players:
return self._team_players
players = sorted(self.players, key=lambda x: x.player_slot)
# Split players into teams
radiant = [p for p in players if p.team == "Radiant"] # 8th bit false
dire = [p for p in players if p.team == "Dire"] # 8th bit true
self._team_players = (radiant, dire)
return self._team_players
@property
def region(self):
return Region.get_by_cluster(self.replay_cluster)
def get_s3_file(self):
key = None
if self.local_uri:
key = dotabank_bucket.get_key(self.local_uri)
return key
def get_alias(self, formatted=True):
if current_user.is_anonymous() is True:
return None
replay_alias = current_user.replay_aliases_dict.get(self.id)
if replay_alias is not None:
if formatted:
return "\u201C{}\u201D".decode('unicode-escape').format(
replay_alias.alias) # Wrap in curly quotes
else:
return replay_alias.alias
return None
def get_state(self):
"""
Returns a descriptive and human-friendly representation of the replay's state.
:return: String
"""
# TODO: Store this in a centralised string table
if self.state == "ARCHIVED":
return "Archived"
elif self.state == "WAITING_GC":
return "Waiting for GC"
elif self.state == "WAITING_DOWNLOAD":
return "Waiting to be archived"
elif self.state == "DOWNLOAD_IN_PROGRESS":
return "Archiving in progress"
elif self.state == "GC_ERROR":
return "Private"
elif self.state == "DOWNLOAD_ERROR":
if self.replay_state == "REPLAY_AVAILABLE":
return "Download error"
else:
return "Expired"
# TODO: What is this?
def user_rating(self):
if current_user.is_authenticated():
return next((rating for rating in self.ratings
if rating.user_id == current_user.id), None)
else:
return None
# TODO: What is this?
def user_favourite(self):
if current_user.is_authenticated():
return next((favourite for favourite in self.favourites
if favourite.user_id == current_user.id), False)
else:
return False
@classmethod
def get_or_create(cls, **kwargs):
# Get instance, filter skip_webapi from kwargs as that's the only non-database argument __init__ can take.
instance = cls.query.filter_by(
**{k: v
for k, v in kwargs.iteritems()
if k is not "skip_webapi"}).first()
if instance:
return instance, False
else:
instance = cls(**kwargs)
return instance, True
@staticmethod
def add_gc_job(_replay, skip_commit=False):
# Reset gc fails
_replay.gc_fails = 0
_replay.gc_done_time = None
db.session.add(_replay)
if not skip_commit:
db.session.commit()
# Write to SQS
msg = sqsMessage()
msg.set_body(str(_replay.id))
return sqs_gc_queue.write(msg)
@staticmethod
def add_dl_job(_replay, skip_commit=False):
# Reset dl fails
_replay.dl_fails = 0
_replay.dl_done_time = None
db.session.add(_replay)
if not skip_commit:
db.session.commit()
# Write to SQS
msg = sqsMessage()
msg.set_body(str(_replay.id))
return sqs_dl_queue.write(msg)
class Item(db.Model):
"""
Model representing an item
"""
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255))
type = db.Column(db.String(255), nullable=False)
# x, y can be null for equipped or socketed items
x = db.Column(db.SmallInteger())
y = db.Column(db.SmallInteger())
w = db.Column(db.SmallInteger(), nullable=False, default=1)
h = db.Column(db.SmallInteger(), nullable=False, default=1)
rarity = db.Column(
db.Enum('normal', 'magic', 'rare', 'unique', name='rarities'))
icon = db.Column(db.String(500))
num_sockets = db.Column(db.SmallInteger(), nullable=False, default=0)
socket_str = db.Column(db.String(20), nullable=False, default="")
is_identified = db.Column(db.Boolean, nullable=False, default=True)
char_location = db.Column(db.String(20))
full_text = db.Column(tsvector, nullable=False)
is_corrupted = db.Column(db.Boolean, nullable=False, default=False)
# or marking the item as deleted
is_deleted = db.Column(db.Boolean, nullable=False, default=False)
league = db.Column(db.String(20), default="Standard")
# funky stuff for item properties, mods etc
mods = db.relationship("Modifier", backref="item", lazy="dynamic")
requirements = db.relationship("Requirement",
backref="item",
lazy="dynamic")
properties = db.relationship("Property", backref="item", lazy="dynamic")
location_id = db.Column(db.Integer, db.ForeignKey('location.id'))
# socketed items use these for the parent item
parent_id = db.Column(db.Integer, db.ForeignKey('item.id'))
parent_item = db.relationship('Item',
remote_side=[id],
backref="socketed_items")
def __repr__(self):
if self.name:
return "%s %s" % (self.name, self.type)
else:
return self.type
@property
def image_url(self):
_, _, query = self.icon.rpartition("?")
sha = hashlib.sha1(self.icon).hexdigest()
return "images/full/%s.png?%s" % (sha, query)
@property
def implicit_mods(self):
return self.mods.filter(Modifier.is_implicit == true()).all()
@property
def explicit_mods(self):
return self.mods.filter(Modifier.is_implicit == false()).all()
@property
def numeric_mods(self):
return self.mods.filter(Modifier.original != Modifier.normalized).all()
@db.validates('num_sockets')
def validate_num_sockets(self, key, num_sockets):
assert 0 <= num_sockets <= 6
return num_sockets
@db.validates('x')
def validate_x(self, key, x):
assert x is None or x >= 0
return x
@db.validates('y')
def validate_y(self, key, y):
assert y is None or y >= 0
return y
@db.validates('w')
def validate_w(self, key, w):
assert 1 <= w <= 2
return w
@db.validates('h')
def validate_h(self, key, h):
assert 1 <= h <= 4, h
return h
# various helpers for the model
def is_gem(self):
for p in self.properties:
if p.name == "Experience":
return True
return False
def is_quest_item(self):
return norm(self.type).startswith(constants.QUEST_ITEMS)
@property
def identified(self):
return self.query.filter(self.is_identified)
def location_str(self):
"""Outputs a nicely formatted location string"""
ret = "%s: " % str(self.location)
if self.char_location:
ret += self.char_location
elif self.x is not None:
ret += "(%s, %s)" % (self.x, self.y)
if self.parent_item:
ret += " [Socketed]"
return ret
def gem_color(self):
"""
returns the letter for the color of the gem, if the item is not a gem,
raises ValueError
"""
for p in self.properties:
if p.name == "Experience":
break
else:
raise ValueError("Item is not a gem.")
return normfind(GEMS, self.type)["color"]
def item_group(self):
"""returns the major item grouping for an item, e.g. mace, armor etc"""
own_type = self.type.lower()
for g in ("axes", "bows", "claws", "daggers", "maces", "staves",
"swords", "wands", "helms", "armors", "gloves", "boots",
"shields", "belts", "quivers"):
for k, v in get_constant(g.upper(), as_dict=True).items():
if k.lower() in own_type:
# see if there is a subtype
if isinstance(v, str):
return g.title()
else:
return v.get("subtype", g.title())
raise ValueError("%s is not a recognized item type." % self.type)
@property
def required_level(self):
"""
convenience property that returns the required level for the item,
None otherwise
"""
for req in self.requirements:
if req.name == "Level":
return int(req.value)
return None
class Requirement(db.Model):
"""Model representing a single requirement of an item"""
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), nullable=False)
value = db.Column(db.SmallInteger(), nullable=False)
item_id = db.Column(db.Integer, db.ForeignKey('item.id'))
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
nickname = db.Column(db.String(64), default=username)
phone = db.Column(db.String(11), index=True)
email = db.Column(db.String(120))
password_hash = db.Column(db.String(128))
lastseen = db.Column(db.DateTime, default=datetime.utcnow())
create_time = db.Column(db.DateTime, default=datetime.utcnow())
sex = db.Column(db.Enum('F', 'M', 'Na'), default='M')
birthday = db.Column(db.DateTime)
address = db.Column(db.String(120))
hometown = db.Column(db.String(120))
school = db.Column(db.String(120))
company = db.Column(db.String(120))
signature = db.Column(db.Text(), default="等我下完这把自走棋再写个签！") # 个签
status = db.Column(db.SmallInteger(),
default=1) # 用户状态 1：正常 2：禁用 3：在线 4：离线 5：忙碌
# region methods
def __repr__(self):
return '<User username:{},user id :{} >'.format(self.username, self.id)
def avatar(self):
avatar = Img.query.filter_by(owner_id=self.id, owner_type=1).first()
if avatar:
return avatar.url
else:
return "https://huyaimg.msstatic.com/avatar/1094/9c/9bd826292dbe3a174fc81b5a6e781f_180_135.jpg?1559034850"
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
def follow(self, followed_id):
follower = Follower(followed_id=followed_id, follower_id=self.id)
db.session.add(follower)
db.session.commit()
def unfollow(self, followed_id):
follower = Follower.query.filter_by(followed_id=followed_id,
follower_id=self.id).first()
if follower:
db.session.delecte(follower)
db.session.commit()
def followers(self, limit=50, offset=0):
followers = Follower.query.filter_by(
followed_id=self.id).limit(limit).offset(offset).all()
if followers:
return followers
else:
return []
def followed(self, limit=50, offset=0):
followers = Follower.query.filter_by(
follower_id=self.id).limit(limit).offset(offset).all()
if followers:
return followers
else:
return []
def followed_count(self):
count = Follower.query.filter_by(follower_id=self.id).count()
return count
def follower_count(self):
count = Follower.query.filter_by(followed_id=self.id).count()
return count
def to_dict(self):
data = {
'id': self.id,
'name': self.username,
'nickname': self.nickname,
'sex': self.sex,
'signature': self.signature,
'lastseen': self.lastseen.isoformat() + 'Z',
'followed': self.followed_count(),
'followers': self.follower_count(),
'avatar': self.avatar()
}
return data
def card(self):
return {
'name': self.username,
'nickname': self.nickname,
'sex': self.sex,
'followed': self.followed_count(),
'followers': self.follower_count(),
'signature': self.signature,
'avatar': self.avatar()
}
class Ref(Base):
__tablename__ = 'ref'
ref_uri = db.Column(db.String(32), nullable=True)
status = db.Column(db.SmallInteger(), nullable=True)
class NetIpv4(db.Model):
'''класс котоый отвечает за хранение инф. о настройках конфигурации
dhcpd сервера. Он наследует свойства от класса Model SQLAlchemy
'''
id = db.Column(db.SmallInteger(), primary_key=True, autoincrement=True)
interface = db.Column(db.VARCHAR(15), nullable=False)
subnet_ipv4 = db.Column(db.VARCHAR(15), nullable=False)
netmask = db.Column(db.VARCHAR(15), nullable=False)
default_gw = db.Column(db.VARCHAR(15), nullable=False)
broadcast = db.Column(db.VARCHAR(15), nullable=False)
ip_range_start = db.Column(db.VARCHAR(15), nullable=False)
ip_range_end = db.Column(db.VARCHAR(15), nullable=False)
dns_suffix = db.Column(db.VARCHAR(20),
nullable=False,
server_default='nr.local')
dns_srv_01 = db.Column(db.VARCHAR(15),
nullable=False,
server_default='192.168.156.93')
dns_srv_02 = db.Column(db.VARCHAR(15),
nullable=False,
server_default='192.168.156.94')
failover_peer = db.Column(db.VARCHAR(20), nullable=False, \
server_default='nr-dhcpd-failover')
opt_242 = db.Column(db.VARCHAR(150), nullable=True)
#vlan_num = db.Column(db.VARCHAR(150), nullable=False)
# мы определили свойства класса (свойства таблицы) выше, теперь определим
# конструктор класса
# def __init__(self, interface, subnet_ipv4, netmask, default_gw, broadcast, ip_range_start, ip_range_end, failover_peer, opt_242):
def __init__(self, *args, **kwargs):
# * позиционные аргументы в любом количестве (список)
# ** именованные аргументы в любом количестве(словарь)
# вызвали конструктор класса Model, это предок класса NetIpv4
super(NetIpv4, self).__init__(*args, **kwargs)
'''
self.interface = interface
self.subnet_ipv4 = subnet_ipv4
self.netmask = netmask
self.default_gw = default_gw
self.broadcast = broadcast
self.ip_range_start = ip_range_start
self.ip_range_end = ip_range_end
self.failover_peer = failover_peer
self.opt_242 = opt_242
'''
# вызывается встроенной функцией repr; возвращает "сырые" данные,
# использующиеся для внутреннего представления в python.
# метод формат подставляет в {} данные
def __repr__(self):
return '<NetIpv4 id: {}, interface: {}, subnet_ipv4: {}, netmask: {}, \
default_gw: {}, broadcast: {}, ip_range_start: {}, \
ip_range_end: {}, dns_suffix: {}, dns_srv_01: {}, \
dns_srv_02: {}, failover_peer: {}, opt_242: {} >' \
.format(self.id, self.interface, self.subnet_ipv4, \
self.netmask, self.default_gw, \
self.broadcast, self.ip_range_start, \
self.ip_range_end, self.dns_suffix, \
self.dns_srv_01, self.dns_srv_02, \
self.failover_peer, self.opt_242)
