class Disciplina(Base): __tablename__ = 'disciplinas' id = Column(Integer, primary_key=True) nome = Column(String(100), unique=True) creditos = Column(Integer, unique=False) codigo = Column(String(6), unique=True) vagas = Column(Integer, unique=False) horario = Column(Integer, unique=False) dias = Column(MutableList.as_mutable(PickleType), unique=False) requisito = Column(Integer, unique=False) inscritos = Column(MutableList.as_mutable(PickleType), unique=False) def __init__(self, id, nome, creditos, codigo, vagas, horario, dias, requisito, inscritos): self.id = id self.nome = nome self.creditos = creditos self.codigo = codigo self.vagas = vagas self.horario = horario self.dias = dias self.requisito = requisito self.inscritos = inscritos def __repr__(self): return '<Disciplina %r>' % (self.nome)
def __init__(self, parent, stypename, birthdate=None): # If it is an original sample then sample should be set to the species name try: stype = Sample.Type[stypename] except KeyError: raise KeyError('Sample type, {0}, is not valid'.format(stypename)) self.type = stype.value if (isinstance(parent, list) and isinstance(parent[0], Sample)): self.parent = parent self.species = parent[0].species elif isinstance(parent, str): self.parent = [] self.species = parent else: raise TypeError("Type of parent, {0}, is not valid".format( type(parent))) self.notes = MutableList() self.images = MutableList() if birthdate: if isinstance(birthdate, str): self.birthDate = datetime.datetime.strftime( datetime.datetime.strptime(birthdate, '%d-%m-%Y'), '%d-%m-%Y') elif isinstance(birthdate, datetime.datetime): self.birthDate = datetime.datetime.strftime( birthdate, '%d-%m-%Y') else: raise TypeError('birthdate is not of a valid type') else: self.birthDate = datetime.datetime.strftime( datetime.datetime.now(datetime.timezone.utc), '%d-%m-%Y')
class UserModel(db.Model, Model): __tablename__ = 'user' profile_id = db.Column(UUID(as_uuid=True), db.ForeignKey(ProfileModel.id), nullable=False) name = db.Column(db.VARCHAR(100), nullable=False) email = db.Column(db.VARCHAR(100), nullable=False) salt = db.Column(db.VARCHAR(32), nullable=False) password = db.Column(db.VARCHAR(32), nullable=False) password_recovery = db.Column(db.VARCHAR(32), nullable=True) password_history = db.Column(JSON, nullable=True) permission = db.Column(MutableList.as_mutable(ARRAY(db.String)), nullable=False) token = db.Column(MutableList.as_mutable(ARRAY(db.String)), nullable=True)
class Pclass(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(40)) hp = db.Column(db.Integer) sp = db.Column(db.Integer) key_ability = db.Column(db.Integer) gbab = db.Column(db.Boolean) gfort = db.Column(db.Boolean) gref = db.Column(db.Boolean) gwill = db.Column(db.Boolean) armor_prof = db.Column(MutableList.as_mutable(PickleType)) wp_prof = db.Column(MutableList.as_mutable(PickleType)) c_skills = db.Column(MutableList.as_mutable(PickleType))
class User(CustomBase, UserMixin): __tablename__ = 'User' id = Column(Integer, primary_key=True) type = Column(String, default='admin') email = Column(String) name = Column(String, unique=True) permissions = Column(MutableList.as_mutable(PickleType), default=[]) password = Column(String) tasks = relationship('Task', back_populates='user') def update(self, **kwargs): if app.config['USE_VAULT']: data = {'password': kwargs.pop('password')} vault_helper(app, f'user/{kwargs["name"]}', data) super().update(**kwargs) @property def is_admin(self): return 'Admin' in self.permissions def allowed(self, permission): return self.is_admin or permission in self.permissions def __repr__(self): return self.name
class LocalSampleMetrics(db2.Model): __bind_key__ = 'local' __tablename__ = "sample_metrics" id = db.Column(db.Integer, primary_key=True) sample_id = db.Column(db.String(5), db.ForeignKey("samples.id"), nullable=False, unique=True) created_at = db.Column(db.DateTime(timezone=True), default=utcnow_datetime_aware, nullable=False) last_updated_at = db.Column(db.DateTime(timezone=True), default=utcnow_datetime_aware, onupdate=utcnow_datetime_aware, nullable=False) wellness_score = db.Column(db.Float, nullable=False) diversity_index = db.Column(db.Float, nullable=False) evenness = db.Column(db.Float, nullable=False) richness = db.Column(db.Integer, nullable=False) total_species_count = db.Column(db.Integer, nullable=False) ecosystem = db.Column(MutableDict.as_mutable(postgresql.JSONB), nullable=False) growth = db.Column(MutableDict.as_mutable(postgresql.JSONB), nullable=False) probiotics = db.Column(MutableList.as_mutable(postgresql.JSONB), nullable=False) recommendations = db.Column(MutableDict.as_mutable(postgresql.JSONB), nullable=False) symptoms = db.Column(MutableDict.as_mutable(postgresql.JSONB), nullable=False) def __repr__(self): return f"<[LOCAL]SampleMetrics id:{self.id!r} sample_id={self.sample_id!r}>"
class AvailableOSUpdate(db.Model): """This table holds the results of `AvailableOSUpdates` commands.""" __tablename__ = 'available_os_updates' id = db.Column(db.Integer, primary_key=True) device_id = db.Column(db.ForeignKey('devices.id'), nullable=True) """(int): Device foreign key ID.""" device = db.relationship('Device', backref='available_os_updates') """(db.relationship): Device relationship""" # Common to all platforms allows_install_later = db.Column(db.Boolean) human_readable_name = db.Column(db.String) is_critical = db.Column(db.Boolean) product_key = db.Column(db.String) restart_required = db.Column(db.Boolean) version = db.Column(db.String) # macOS Only app_identifiers_to_close = db.Column( MutableList.as_mutable(JSONEncodedDict)) human_readable_name_locale = db.Column(db.String) is_config_data_update = db.Column(db.Boolean) """(bool): This update is a config data update eg. for XProtect or Gatekeeper. These arent normally shown""" is_firmware_update = db.Column(db.Boolean) metadata_url = db.Column(db.String) # iOS Only product_name = db.Column(db.String) build = db.Column(db.String) download_size = db.Column(db.BigInteger) install_size = db.Column(db.BigInteger)
class User(Base, UserMixin): __tablename__ = type = "User" id = Column(Integer, primary_key=True) email = Column(String(255), default="") jobs = relationship("Job", back_populates="creator") name = Column(String(255), unique=True) permissions = Column(MutableList.as_mutable(PickleType), default=[]) pools = relationship("Pool", secondary=pool_user_table, back_populates="users") password = Column(String(255), default="") def __init__(self, **kwargs: Any) -> None: super().__init__(**kwargs) def generate_row(self, table: str) -> List[str]: return [ f"""<button type="button" class="btn btn-primary btn-xs" onclick="showTypeModal('user', '{self.id}')">Edit</button>""", f"""<button type="button" class="btn btn-primary btn-xs" onclick="showTypeModal('user', '{self.id}', true)"> Duplicate</button>""", f"""<button type="button" class="btn btn-danger btn-xs" onclick="confirmDeletion('user', '{self.id}')">Delete</button>""", ] @property def is_admin(self) -> bool: return "Admin" in self.permissions def allowed(self, permission: str) -> bool: return self.is_admin or permission in self.permissions
class User(AbstractBase, UserMixin): __tablename__ = type = "User" id = Column(Integer, primary_key=True) email = Column(String(SMALL_STRING_LENGTH)) name = Column(String(SMALL_STRING_LENGTH)) permissions = Column(MutableList.as_mutable(PickleType), default=[]) pools = relationship("Pool", secondary=pool_user_table, back_populates="users") password = Column(String(SMALL_STRING_LENGTH)) def generate_row(self, table: str) -> List[str]: return [ f"""<button type="button" class="btn btn-primary btn-xs" onclick="showTypePanel('user', '{self.id}')">Edit</button>""", f"""<button type="button" class="btn btn-primary btn-xs" onclick="showTypePanel('user', '{self.id}', true)"> Duplicate</button>""", f"""<button type="button" class="btn btn-danger btn-xs" onclick="showDeletionPanel('user', '{self.id}', '{self.name}')"> Delete</button>""", ] @property def is_admin(self) -> bool: return "Admin" in self.permissions def allowed(self, permission: str) -> bool: return self.is_admin or permission in self.permissions
class User(db.Model): id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(80), unique=True, nullable=False) money = db.Column(db.Integer, default=True, nullable=False) field = db.Column(MutableList.as_mutable(db.PickleType)) def __init__(self, **kwargs): super().__init__(**kwargs) if 'field' not in kwargs: self.field = [Plant().info] * (TILE_NUM**2) def get_plant(self, col, row): if row >= TILE_NUM or col >= TILE_NUM: raise AttributeError("Plant {} {} doesn't exist".format(col, row)) return Plant(self.field[row * TILE_NUM + col]) def set_plant(self, col, row, plant: Plant): if row >= TILE_NUM or col >= TILE_NUM: raise AttributeError("Plant {} {} doesn't exist".format(col, row)) self.field[row * TILE_NUM + col] = plant.info def get_snapshot(self): return {'money': self.money, 'field': self.field} def __repr__(self): return "<User {} with field {} and money {}>".format( self.username, self.field, self.money)
class NapalmGettersScript(Script): __tablename__ = 'NapalmGettersScript' id = Column(Integer, ForeignKey('Script.id'), primary_key=True) getters = Column(MutableList.as_mutable(PickleType), default=[]) content_match = Column(String) content_match_regex = Column(Boolean) device_multiprocessing = True __mapper_args__ = { 'polymorphic_identity': 'napalm_getters', } @multiprocessing def job(self, task, device, results, payloads): result = {} results['expected'] = self.content_match try: napalm_driver = napalm_connection(device) napalm_driver.open() for getter in self.getters: try: result[getter] = getattr(napalm_driver, getter)() except Exception as e: result[getter] = f'{getter} failed because of {e}' if self.content_match_regex: success = bool(search(self.content_match, str_dict(result))) else: success = self.content_match in str_dict(result) napalm_driver.close() except Exception as e: result = f'script did not work:\n{e}' success = False return success, result, result
class InventoryEntry(Base): """ An inventory class """ __tablename__ = 'inventory_items' entry_id = Column(INTEGER, autoincrement=True, primary_key=True) owner = Column(BigInteger, ForeignKey('accounts.id')) item_type = Column(types.Enum(ItemType)) item_info = Column(MutableList.as_mutable(JSON), server_default='[]') owner_acc = relationship("Account") def _create_item(self, args): return item_class_map[self.item_type](**args) def get_items(self): return [self._create_item(i) for i in self.item_info] def add_item(self, item): logger.info(f"added {item} to <@{self.owner}>'s inventory") self.item_info.append(item.to_json()) def remove_item(self, index=0): logger.info( f"Removed {self._create_item(**self.item_info[index])} from <@{self.owner}>'s inventory" ) self.item_info.pop(index) def equip_item(self, index=0): logger.info(f"Equipped {self.item_info[index]} to <@{self.owner}>") self.owner_acc.equip(self._create_item(self.item_info[index])) def update_item(self, item): assert reversed_class_map[type(item)] == item_class_map[ self.item_type.value] self.item_info = item.to_json()
def configure_columns(self): class CustomPickleType(PickleType): if self.dialect == "mysql": impl = MSMediumBlob self.Dict = MutableDict.as_mutable(CustomPickleType) self.List = MutableList.as_mutable(CustomPickleType) if self.dialect == "postgresql": self.LargeString = Text else: self.LargeString = Text( self.columns["length"]["large_string_length"]) self.SmallString = String( self.columns["length"]["small_string_length"]) self.TinyString = String(self.columns["length"]["tiny_string_length"]) default_ctypes = { self.Dict: {}, self.List: [], self.LargeString: "", self.SmallString: "", self.TinyString: "", Text: "", } class CustomColumn(Column): def __init__(self, ctype, *args, **kwargs): if "default" not in kwargs and ctype in default_ctypes: kwargs["default"] = default_ctypes[ctype] super().__init__(ctype, *args, **kwargs) self.Column = CustomColumn
class User(db.Model, RoleFreeUserMixin): __tablename__ = "users" id = db.Column(db.Integer, primary_key=True) email = db.Column(db.String(255)) password = db.Column(db.String(255)) active = db.Column(db.Boolean(), default=False) confirmed_at = db.Column(db.DateTime()) user_type = db.Column(db.Enum(TypeOfUser, name="type_of_user_types"), nullable=False) capabilities = db.Column(MutableList.as_mutable(ARRAY(db.String)), default=[]) last_login_at = db.Column(db.DateTime()) current_login_at = db.Column(db.DateTime()) last_login_ip = db.Column(db.String(16)) current_login_ip = db.Column(db.String(16)) login_count = db.Column(db.Integer) failed_login_count = db.Column(db.Integer, default=0) # relationships measures = db.relationship( "Measure", lazy="subquery", secondary="user_measure", primaryjoin="User.id == user_measure.columns.user_id", secondaryjoin="Measure.id == user_measure.columns.measure_id", back_populates="shared_with", ) __table_args__ = (UniqueConstraint(email, name="uq_users_email"),) def user_name(self): return self.email.split("@")[0] def is_departmental_user(self): return self.user_type == TypeOfUser.DEPT_USER def is_rdu_user(self): return self.user_type == TypeOfUser.RDU_USER def is_admin_user(self): return self.user_type == TypeOfUser.ADMIN_USER def can(self, capability): return capability in self.capabilities def can_access_measure(self, measure): if self.user_type != TypeOfUser.DEPT_USER: return True else: return self in measure.shared_with # DEPRECATED: use `can_access_measure` method instead. def can_access(self, measure_slug): if self.user_type != TypeOfUser.DEPT_USER: return True else: if any(measure.slug == measure_slug for measure in self.measures): return True else: return False
class DiscordServer(db.Model): __tablename__ = "discordserver" id = db.Column(BIGINT, primary_key=True, autoincrement=False) server_group_id = db.Column(db.Integer, db.ForeignKey("servergroup.id")) name = db.Column(db.String, nullable=False) command_prefixes = db.Column(MutableList.as_mutable(ARRAY(db.String)), nullable=True) # a message prefix is a regex string that would be applied to the message # before being processed. The regex would just be the prefix to the message # so whatever is matched would be removed. # its undefined what regex would be applied # if two regexes match the same message message_prefixes = db.Column(MutableList.as_mutable(ARRAY(db.String)), nullable=True) admin_role = db.Column(BIGINT, nullable=True) server_group = db.relationship("ServerGroup")
class Ordinals(Base): """Class to represent a list of ordinals in some language or other.""" id = Column(Integer, primary_key=True, index=True) content = Column(MutableList.as_mutable(PickleType), default=[]) language = Column(String()) owner_id = Column(Integer, ForeignKey("user.id")) owner = relationship("User", back_populates="ordinals")
class Chat(Base): __tablename__ = 'chats' chat_id = Column(Integer(), primary_key=True) chat_type = Column(Enum(ChatType), nullable=False) description = Column(String(255)) tags = Column(MutableList.as_mutable(ARRAY(String(100)))) chat_status = Column(Enum(ChatStatus), nullable=False) aspiring_professionals = Column(MutableList.as_mutable(ARRAY(String(100)))) senior_executive = Column(String(100), nullable=False) fixed_date = Column(DateTime()) expiry_date = Column(DateTime()) created_on = Column(DateTime(), default=datetime.now) updated_on = Column(DateTime(), default=datetime.now, onupdate=datetime.now)
class NapalmGettersService(Service): __tablename__ = 'NapalmGettersService' id = Column(Integer, ForeignKey('Service.id'), primary_key=True) has_targets = True content_match = Column(String) content_match_textarea = True content_match_regex = Column(Boolean) negative_logic = Column(Boolean) delete_spaces_before_matching = Column(Boolean) driver = Column(String) driver_values = NAPALM_DRIVERS getters = Column(MutableList.as_mutable(PickleType), default=[]) getters_values = (('get_arp_table', 'ARP table'), ('get_interfaces_counters', 'Interfaces counters'), ('get_facts', 'Facts'), ('get_environment', 'Environment'), ('get_config', 'Configuration'), ('get_interfaces', 'Interfaces'), ('get_interfaces_ip', 'Interface IP'), ('get_lldp_neighbors', 'LLDP neighbors'), ('get_lldp_neighbors_detail', 'LLDP neighbors detail'), ('get_mac_address_table', 'MAC address'), ('get_ntp_servers', 'NTP servers'), ('get_ntp_stats', 'NTP statistics'), ('get_optics', 'Transceivers'), ('get_snmp_information', 'SNMP'), ('get_users', 'Users'), ('get_network_instances', 'Network instances (VRF)'), ('get_ntp_peers', 'NTP peers'), ('get_bgp_config', 'BGP configuration'), ('get_bgp_neighbors', 'BGP neighbors'), ('get_ipv6_neighbors_table', 'IPv6'), ('is_alive', 'Is alive')) optional_args = Column(MutableDict.as_mutable(PickleType), default={}) __mapper_args__ = { 'polymorphic_identity': 'NapalmGettersService', } def job(self, device, _): napalm_driver, result = napalm_connection(self, device), {} napalm_driver.open() for getter in self.getters: try: result[getter] = getattr(napalm_driver, getter)() except Exception as e: result[getter] = f'{getter} failed because of {e}' match = substitute(self.content_match, locals()) napalm_driver.close() return { 'expected': match, 'negative_logic': self.negative_logic, 'result': result, 'success': self.match_content(str(result), match) }
class ExampleService(Service): __tablename__ = "ExampleService" id = Column(Integer, ForeignKey("Service.id"), primary_key=True) # the "string1" property will be displayed as a drop-down list, because # there is an associated "string1_values" property in the class. string1 = Column(String(255), default="") # the "string2" property will be displayed as a text area. string2 = Column(String(255), default="") string2_name = "String 2 !" string2_length = 5 # Text area an_integer = Column(Integer, default=0) # Text area a_float = Column(Float, default=0.0) # the "a_list" property will be displayed as a multiple selection list # list, with the values contained in "a_list_values". a_list = Column(MutableList.as_mutable(PickleType)) # Text area where a python dictionnary is expected a_dict = Column(MutableDict.as_mutable(PickleType)) # "boolean1" and "boolean2" will be displayed as tick boxes in the GUI. boolean1 = Column(Boolean, default=False) boolean1_name = "Boolean N°1" boolean2 = Column(Boolean, default=False) # these values will be displayed in a single selection drop-down list, # for the property "a_list". string1_values = [("cisco", "Cisco"), ("juniper", "Juniper"), ("arista", "Arista")] # these values will be displayed in a multiple selection list, # for the property "a_list". a_list_values = [ ("value1", "Value 1"), ("value2", "Value 2"), ("value3", "Value 3"), ] __mapper_args__ = {"polymorphic_identity": "ExampleService"} # Some services will take action or interrogate a device. The job method # can also take device as a parameter for these types of services. # def job(self, device, payload): def job(self, payload: dict) -> dict: self.logs.append( f"Real-time logs displayed when the service is running.") # The "job" function is called when the service is executed. # The parameters of the service can be accessed with self (self.string1, # self.boolean1, etc) # You can look at how default services (netmiko, napalm, etc.) are # implemented in the /services subfolders (/netmiko, /napalm, etc). # "results" is a dictionnary that will be displayed in the logs. # It must contain at least a key "success" that indicates whether # the execution of the service was a success or a failure. # In a workflow, the "success" value will determine whether to move # forward with a "Success" edge or a "Failure" edge. return {"success": True, "result": "example"}
class ExampleService(Service): __tablename__ = 'ExampleService' id = Column(Integer, ForeignKey('Service.id'), primary_key=True) # see eNMS documentation section on Workflow devices for a description of # the multiprocessing property and its expected behavior multiprocessing = False # the "string1" property will be displayed as a drop-down list, because # there is an associated "string1_values" property in the class. string1 = Column(String) # the "string2" property will be displayed as a text area. string2 = Column(String) # Text area an_integer = Column(Integer) # Text area a_float = Column(Float) # the "a_list" property will be displayed as a multiple selection list # list, with the values contained in "a_list_values". a_list = Column(MutableList.as_mutable(PickleType)) # Text area where a python dictionnary is expected a_dict = Column(MutableDict.as_mutable(PickleType)) # "boolean1" and "boolean2" will be displayed as tick boxes in the GUI. boolean1 = Column(Boolean) boolean2 = Column(Boolean) # these values will be displayed in a single selection drop-down list, # for the property "a_list". string1_values = [ ('cisco', 'Cisco'), ('juniper', 'Juniper'), ('arista', 'Arista') ] # these values will be displayed in a multiple selection list, # for the property "a_list". a_list_values = [ ('value1', 'Value 1'), ('value2', 'Value 2'), ('value3', 'Value 3') ] __mapper_args__ = { 'polymorphic_identity': 'example_service', } def job(self, payload): # The "job" function is called when the service is executed. # The parameters of the service can be accessed with self (self.string1, # self.boolean1, etc) # You can look at how default services (netmiko, napalm, etc.) are # implemented in the /services subfolders (/netmiko, /napalm, etc). # "results" is a dictionnary that will be displayed in the logs. # It must contain at least a key "success" that indicates whether # the execution of the service was a success or a failure. # In a workflow, the "success" value will determine whether to move # forward with a "Success" edge or a "Failure" edge. return {'success': True, 'result': 'example'}
class Updates(db.Model): __tablename__ = "updates" id = db.Column(db.Integer, primary_key=True) client_id = db.Column(db.Integer) data = db.Column(MutableList.as_mutable(db.PickleType)) def __init__(self, client_id=None, data=None): self.client_id = client_id self.data = data
class Session(db.Model): __tablename__ = 'session' id = db.Column(db.Integer, primary_key=True) status = db.Column(db.String(25), nullable=False, default='initialised') app_id = db.Column(db.Integer, db.ForeignKey('application.id', use_alter=True, name='fk_app_id'), nullable=False) creation_date = db.Column(db.TIMESTAMP, server_default=db.func.current_timestamp(), nullable=False) expected_emotions = db.Column(db.JSON, nullable=False) questionnaire_id = db.Column(db.Integer, db.ForeignKey('questionnaire.id', use_alter=True, name='fk_questionnaire_id'), nullable=False) cssi_score = db.Column(db.Float, nullable=False, default=0) latency_scores = db.Column(MutableList.as_mutable(db.JSON), nullable=False, default=[]) total_latency_score = db.Column(db.Float, nullable=False, default=0) sentiment_scores = db.Column(MutableList.as_mutable(db.JSON), nullable=False, default=[]) plugin_scores = db.Column(MutableDict.as_mutable(db.JSON), nullable=False, default={}) total_plugin_scores = db.Column(MutableDict.as_mutable(db.JSON), nullable=False, default={}) total_sentiment_score = db.Column(db.Float, nullable=False, default=0) questionnaire_scores = db.Column(db.JSON, nullable=True, default={}) total_questionnaire_score = db.Column(db.Float, nullable=False, default=0) def __init__(self, app, expected_emotions, questionnaire): self.app = app self.expected_emotions = expected_emotions self.questionnaire = questionnaire def __repr__(self): return '<Session %r>' % self.id
class Game(db.Model): __tablename__ = 'games' __table_args__ = { 'mysql_engine': 'InnoDB', 'mysql_charset': 'utf8', 'mysql_collate': 'utf8_general_ci' } gid = db.Column(db.Integer, primary_key=True, autoincrement=True) host_uid = db.Column(db.Integer, nullable=False) status = db.Column(EnumType, nullable=False) victory_mode = db.Column(EnumType, nullable=False) captain_mode = db.Column(EnumType, nullable=False) witch_mode = db.Column(EnumType, nullable=False) wolf_mode = db.Column(EnumType, nullable=False) end_time = db.Column(db.DateTime, nullable=False) updated_on = db.Column(db.DateTime, nullable=False, default=datetime.utcnow, onupdate=datetime.utcnow) players = db.Column(MutableList.as_mutable(JSONEncodedType(225)), nullable=False) cards = db.Column(MutableList.as_mutable(JSONEncodedType(1023)), nullable=False) days = db.Column(db.Integer, nullable=False) now_index = db.Column(db.Integer, nullable=False) step_cnt = db.Column(db.Integer, nullable=False) steps = db.Column(MutableList.as_mutable(JSONEncodedType(1023)), nullable=False) history = db.Column(MutableDict.as_mutable(JSONEncodedType(1023)), nullable=False) captain_pos = db.Column(db.Integer, nullable=False) def __enter__(self): return self def __exit__(self, exc_type, exc_val, exc_tb): db.session.commit() return True if exc_type is None else False def get_seats_cnt(self): cnt = len(self.cards) if GameEnum.ROLE_TYPE_THIEF in self.cards: cnt -= 2 return cnt
class Quiz(db.Model): """ Create a Quiz table """ __tablename__ = "quizzes" id = db.Column(db.Integer, primary_key=True) questions = db.Column(MutableList.as_mutable(PickleType), default=[]) user_id = db.Column(db.Integer, db.ForeignKey("users.id"))
class Favorite(db.Model): __tablename__ = 'favorites' id = db.Column(db.Integer, primary_key=True) user_id = db.Column(db.Integer, db.ForeignKey('users.id')) url = db.Column(db.String(1000), nullable=False) categories = db.Column('categories', MutableList.as_mutable(ARRAY(db.String(100)))) def __init__(self, user_id, url): self.user_id = user_id self.url = url
class Task(db.Model, DomainObject): '''An individual Task which can be performed by a user. A Task is associated to a project. ''' __tablename__ = 'task' #: Task.ID id = Column(Integer, primary_key=True) #: UTC timestamp when the task was created. created = Column(Text, default=make_timestamp) #: Project.ID that this task is associated with. project_id = Column(Integer, ForeignKey('project.id', ondelete='CASCADE'), nullable=False) #: Task.state: ongoing or completed. state = Column(UnicodeText, default=u'ongoing') quorum = Column(Integer, default=0) #: If the task is a calibration task calibration = Column(Integer, default=0) #: Priority of the task from 0.0 to 1.0 priority_0 = Column(Float, default=0) #: Task.info field in JSONB with the data for the task. info = Column(JSONB) #: Number of answers to collect for this task. n_answers = Column(Integer, default=1) #: Array of User IDs that favorited this task fav_user_ids = Column(MutableList.as_mutable(ARRAY(Integer))) #: completed task can be marked as exported=True after its exported exported = Column(Boolean, default=False) #: Task.user_pref field in JSONB with user preference data for the task. user_pref = Column(JSONB) #: Task.worker_pref field in JSONB with worker preference data for the task. worker_pref = Column(JSONB) #: Task.worker_filter field in JSONB with worker filter data for the task. worker_filter = Column(JSONB) #: Task.gold_answers field in JSONB to record golden answers for fields under Task.info. gold_answers = Column(JSONB) #: Task.expiration field to determine when a task should no longer be scheduled. As UTC timestamp without timezone expiration = Column(DateTime, nullable=True) task_runs = relationship(TaskRun, cascade='all, delete, delete-orphan', backref='task') def pct_status(self): """Returns the percentage of Tasks that are completed""" if self.n_answers != 0 and self.n_answers is not None: return float(len(self.task_runs)) / self.n_answers else: # pragma: no cover return float(0) __table_args__ = (Index('task_info_idx', sqlalchemy.text('md5(info::text)')), ) __mapper_args__ = {"order_by": id}
class Chat(Base, Generic): __tablename__ = "chat" id = Column(BigInteger, primary_key=True) chat_type = Column(String) title = Column(String) timezone = Column(String, default="Europe/Amsterdam") days_off = Column(MutableList.as_mutable(ARRAY(String)), default=[]) main_hours = Column(MutableList.as_mutable(ARRAY(Integer)), default=MAIN_HOURS) games = relationship("Game", backref="chat") def add_game(self, game): self.games.append(game) self.save() def add_day_off(self, weekday): self.days_off.append(weekday) self.save() def rm_day_off(self, weekday): self.days_off.remove(weekday) self.save() def add_hour(self, hour): self.main_hours.append(hour) self.save() self.reorder_hours() def rm_hour(self, hour): self.main_hours.remove(hour) self.save() def reorder_hours(self): morning_hours = sorted(i for i in self.main_hours if i < 4) day_hours = sorted(i for i in self.main_hours if i > 4) self.main_hours = day_hours + morning_hours self.save() @property def timezone_pytz(self): return pytz.timezone(self.timezone)
def define_tables(cls, metadata): MutableList = cls._type_fixture() mutable_pickle = MutableList.as_mutable(PickleType) Table('foo', metadata, Column('id', Integer, primary_key=True, test_needs_autoincrement=True), Column('skip', mutable_pickle), Column('data', mutable_pickle), Column('non_mutable_data', PickleType), Column('unrelated_data', String(50)) )
def define_tables(cls, metadata): MutableList = cls._type_fixture() mutable_pickle = MutableList.as_mutable(PickleType) Table( "foo", metadata, Column( "id", Integer, primary_key=True, test_needs_autoincrement=True ), Column("data", mutable_pickle), )
class Podcast(Base): __tablename__ = "podcasts" id = Column(INTEGER, primary_key=True, unique=True, index=True) name = Column(String(100), nullable=False) duration = Column(INTEGER, nullable=False) uploaded_time = Column(DateTime(), default=datetime.now, onupdate=datetime.now) host = Column(String(100), nullable=False) participants = Column(MutableList.as_mutable(PickleType), default=[])
class UserSong(sqldb.Model): id = sqldb.Column(sqldb.Integer, primary_key=True) desc = sqldb.Column( sqldb.String(150)) #TODO: catch error if greater than 150 char saved = sqldb.Column(sqldb.Boolean) date = sqldb.Column(MutableList.as_mutable(sqldb.ARRAY(sqldb.String(60)))) plays = sqldb.Column(sqldb.Integer) period = sqldb.Column( sqldb.Enum('Spring', 'Summer', 'Fall', 'Winter', name='periodenum')) year = sqldb.Column(sqldb.Integer) song_id = sqldb.Column(sqldb.Integer, sqldb.ForeignKey('song.id')) user_id = sqldb.Column(sqldb.Integer, sqldb.ForeignKey('user.id'))
def define_tables(cls, metadata): MutableList = cls._type_fixture() mutable_pickle = MutableList.as_mutable(PickleType) Table( "foo", metadata, Column( "id", Integer, primary_key=True, test_needs_autoincrement=True ), Column("skip", mutable_pickle), Column("data", mutable_pickle), Column("non_mutable_data", PickleType), Column("unrelated_data", String(50)), )