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)