def test_unicode_warnings_dialectlevel(self):
unicodedata = self.data
with testing.expect_deprecated(
"The create_engine.convert_unicode parameter and "
"corresponding dialect-level"
):
dialect = default.DefaultDialect(convert_unicode=True)
dialect.supports_unicode_binds = False
s = String()
uni = s.dialect_impl(dialect).bind_processor(dialect)
uni(util.b("x"))
assert isinstance(uni(unicodedata), util.binary_type)
eq_(uni(unicodedata), unicodedata.encode("utf-8"))
def test_ignoring_unicode_error(self):
"""checks String(unicode_error='ignore') is passed to
underlying codec."""
unicodedata = self.data
with testing.expect_deprecated(
"The String.convert_unicode parameter is deprecated and "
"will be removed in a future release.",
"The String.unicode_errors parameter is deprecated and "
"will be removed in a future release.",
):
type_ = String(
248, convert_unicode="force", unicode_error="ignore"
)
dialect = default.DefaultDialect(encoding="ascii")
proc = type_.result_processor(dialect, 10)
utfdata = unicodedata.encode("utf8")
eq_(proc(utfdata), unicodedata.encode("ascii", "ignore").decode())
class Privacy(Base):
__tablename__ = 'Privacies'
tabletype = TableTypes.REFERENCE
privacy_id = Column(UUID(), primary_key=True, default=uuid.uuid4)
name = Column(String(150), nullable=False)
)
from sqlalchemy.sql import func
DATABASE_URL = os.getenv("DATABASE_URL")
# SQLAlchemy
engine = create_engine(DATABASE_URL)
metadata = MetaData()
images = Table(
"cyanotypes",
metadata,
Column("id", Integer, primary_key=True),
Column("title", String(50)),
Column("description", String(250)),
Column("link_to_file", String(250)),
Column("created_date", DateTime, default=func.now(), nullable=False),
)
notes = Table(
"notes",
metadata,
Column("id", Integer, primary_key=True),
Column("title", String(50)),
Column("description", String(50)),
Column("created_date", DateTime, default=func.now(), nullable=False),
)
# databases query builder
database = Database(DATABASE_URL)
from sqlalchemy import (Table, Column, Date, Integer, Numeric,
String, MetaData, Enum)
from sqlalchemy.dialects import postgresql
meta = MetaData()
server_type = postgresql.ENUM('region', 'update', name='server_type',
metadata=meta)
image_state = postgresql.ENUM('deleted', 'deprecated', 'inactive',
'active', name='image_state', metadata=meta)
amazonimages = Table(
'amazonimages', meta,
Column('name', String(255), primary_key=True),
Column('state', image_state),
Column('replacementname', String(255)),
Column('publishedon', Date, primary_key=True),
Column('deprecatedon', Date),
Column('deletedon', Date),
Column('changeinfo', String(255)),
Column('id', String(100), primary_key=True),
Column('replacementid', String(100)),
Column('region', String(100), primary_key=True),
)
alibabaimages = Table(
'alibabaimages', meta,
Column('name', String(255), primary_key=True),
class Company(Base):
# 表名
__tablename__ = 'company'
id = Column(Integer, unique=True, primary_key=True)
detail_url = Column(String(64)) # 机构详情页
image = Column(String(256)) # 公司图片
web = Column(String(512)) # 机构官网
name = Column(String(512)) # 机构名称
become_time = Column(String(16)) # 成立时间
investment_case = Column(String(8)) # 投资案例
like = Column(String(512)) # 投资偏好
field = Column(String(512)) # 专注投资领域
information = Column(Text) # 机构简介
icon1_num = Column(String(8)) # 披露的投资事件数
icon2_num = Column(String(8)) # 走到下一轮公司数
icon3_num = Column(String(8)) # 连续投资公司数
add_time = Column(String(32)) # 数据添加时间
class Bet(Base):
__tablename__ = 'bets'
id = Column(Integer, primary_key=True)
player_id = Column(Integer)
match = Column(Integer)
bet = Column(String(50))
class BaseModel:
"""A base class for all hbnb models"""
id = Column(String(60), nullable=False, primary_key=True)
created_at = Column(DateTime, nullable=False, default=datetime.utcnow())
updated_at = Column(DateTime, nullable=False, default=datetime.utcnow())
def __init__(self, *args, **kwargs):
"""Instatntiates a new model"""
if not kwargs:
from models import storage
self.id = str(uuid.uuid4())
self.created_at = datetime.now()
self.updated_at = datetime.now()
else:
if "id" not in kwargs:
self.id = str(uuid.uuid4())
if "updated_at" not in kwargs:
self.updated_at = datetime.now()
else:
kwargs['updated_at'] = datetime.strptime(kwargs['updated_at'],
'%Y-%m-%dT%H:%M:%S.%f')
if "created_at" not in kwargs:
self.created_at = datetime.now()
else:
kwargs['created_at'] = datetime.strptime(kwargs['created_at'],
'%Y-%m-%dT%H:%M:%S.%f')
try:
del kwargs['__class__']
except:
pass
# print(self.__dict__)
self.__dict__.update(kwargs)
def __str__(self):
"""Returns a string representation of the instance"""
cls = (str(type(self)).split('.')[-1]).split('\'')[0]
new_dict = self.__dict__.copy()
return "[{}] ({}) {}".format(cls, self.id, new_dict)
def save(self):
"""Updates updated_at with current time when instance is changed"""
from models import storage
self.updated_at = datetime.now()
models.storage.new(self)
models.storage.save()
def to_dict(self):
"""Convert instance into dict format"""
dictionary = {}
dictionary.update(self.__dict__)
dictionary["__class__"] = str(type(self).__name__)
dictionary['created_at'] = self.created_at.isoformat()
dictionary['updated_at'] = self.updated_at.isoformat()
if "_sa_instance_state" in dictionary:
dictionary.pop("_sa_instance_state", None)
return dictionary
def delete(self):
""" Deletes the current instance from the storage """
models.storage.delete(self)
class Contact(Base):
__tablename__ = "contact"
user: str = Column(String(255), primary_key=True)
contact: str = Column(String(255), ForeignKey("puppet.gid"), primary_key=True)
in_community: bool = Column(Boolean, nullable=False, server_default=expression.false())
class RuleSet(Base):
__tablename__ = 'ruleset'
id = Column(Integer, primary_key=True)
context_label = Column(String(256))
context = Column(String(256))
context_details = Column(String(256))
priority = Column(Integer, nullable=False)
user_id = Column(Integer, ForeignKey("user.id"), nullable=False)
user = relationship("User", back_populates="rulesets", lazy="joined")
min_time_of_day = Column(Time)
max_time_of_day = Column(Time)
max_time_per_day = Column(Integer)
max_activity_duration = Column(Integer)
min_break = Column(Integer)
free_play = Column(Boolean)
def __init__(self):
self.context = None
self.context_details = None
self.context_label = None
self.min_time_of_day = None
self.max_time_of_day = None
self.max_time_per_day = None
self.max_activity_duration = None
self.min_break = None
self.free_play = False
self.priority = None
self.get_context_rule_handler = None
@property
def label(self):
if self.context_label:
return self.context_label
else:
return self.context
@property
def summary(self):
context_handler = self.get_context_rule_handler(
p_context_name=self.context)
texts = []
if context_handler is not None:
texts.extend(
context_handler.summary(p_context_detail=self.context_details))
if self.max_time_per_day is not None:
texts.append(constants.TEXT_SEPERATOR)
texts.append("Time per Day")
texts.append(": " + tools.get_duration_as_string(
p_seconds=self.max_time_per_day, p_include_seconds=False))
return texts
@property
def html_key(self):
return "ruleset_{id}".format(id=self.id)
@property
def delete_html_key(self):
return "delete_ruleset_{id}".format(id=self.id)
@property
def move_up_html_key(self):
return "move_up_ruleset_{id}".format(id=self.id)
@property
def move_down_html_key(self):
return "move_down_ruleset_{id}".format(id=self.id)
@staticmethod
def get_by_id(p_session, p_id):
query = p_session.query(RuleSet).filter(RuleSet.id == p_id)
if query.count() == 1:
return query.one()
else:
return None
@property
def can_move_up(self):
return 1 < self.priority < len(self.user.rulesets)
@property
def can_move_down(self):
return self.priority > 2
@property
def fixed_context(self):
return self.priority == 1
class Device(Base):
__tablename__ = 'device'
id = Column(Integer, primary_key=True)
device_name = Column(String(256), nullable=False)
hostname = Column(String(256))
min_activity_duration = Column(Integer)
max_active_ping_delay = Column(Integer)
sample_size = Column(Integer)
users = relationship("User2Device", back_populates="device", lazy="joined")
def __init__(self):
self.device_name = None
self.hostname = None
self.min_activity_duration = None
self.max_active_ping_delay = None
self.sample_size = None
@staticmethod
def get_by_device_name(p_session, p_device_name):
query = p_session.query(Device).filter(
Device.device_name == p_device_name)
if query.count() == 1:
return query.one()
else:
return None
@staticmethod
def get_by_id(p_session, p_id):
query = p_session.query(Device).filter(Device.id == p_id)
if query.count() == 1:
return query.one()
else:
return None
@property
def html_key(self):
return "device_{id}".format(id=self.id)
@property
def delete_html_key(self):
return "delete_device_{id}".format(id=self.id)
def list_of_users(self, p_exclude=None):
return ", ".join([
"{name} ({percent}%)".format(name=user2device.user.full_name,
percent=user2device.percent)
for user2device in self.users
if p_exclude is None or not user2device.user is p_exclude
])
@property
def summary(self):
texts = []
if len(self.users) > 0:
texts.extend([_("Assigned users"), ": ", self.list_of_users()])
texts.extend([
constants.TEXT_SEPERATOR,
_("Host Name"), ": ",
tools.value_or_not_set(self.hostname)
])
return texts
class Costumes(Base):
__tablename__ = "costumes"
category_id = Column(Integer, primary_key=True)
name = Column(String(50), nullable=False)
user_id = Column(Integer, ForeignKey("users.user_id"))
users = relationship(Users)
class Users(Base):
__tablename__ = "users"
user_id = Column(Integer, primary_key=True)
email = Column(String(100), nullable=False)
class Category(Base):
__tablename__ = "categories"
id = Column(Integer, primary_key=True, autoincrement=False)
name = Column(String(128), unique=True, nullable=False)
parent_id = Column(Integer, ForeignKey("categories.id"))
parent = relationship("Category", remote_side="categories.c.id")
books = relationship(
"Book",
secondary=categories_table,
back_populates="categories",
)
@staticmethod
def ancestors(session):
all_categories = session.query(Category).all()
names = {}
for category in all_categories:
names[category.id] = category.name
parents = {}
for category in all_categories:
if category.parent_id is not None:
parents[category.name] = names[category.parent_id]
else:
parents[category.name] = None
category_ancestors = {}
def calculate(name):
if name in category_ancestors:
return
ancestors = set()
ancestors.add(name)
parent = parents[name]
if parent:
if parent not in category_ancestors:
calculate(parent)
ancestors.update(category_ancestors[parent])
category_ancestors[name] = ancestors
for category in all_categories:
calculate(category.name)
return category_ancestors
@staticmethod
def children(session):
all_categories = session.query(Category).all()
names = {}
for category in all_categories:
names[category.id] = category.name
children = defaultdict(list)
for category in all_categories:
if category.parent_id is not None:
children[names[category.parent_id]].append(category.name)
else:
children["Books"].append(category.name)
return children
@staticmethod
def tree_names(session, name):
names = []
to_process = (session.query(Category).filter(
Category.name == name).all())
while to_process:
c = to_process.pop()
names.append(c.name)
to_process.extend(
session.query(Category).filter(
Category.parent_id == c.id).all())
return names
class BaseModel:
"""This class will defines all common attributes/methods
for other classes
"""
id = Column(String(60), nullable=False, primary_key=True)
created_at = Column(DateTime, nullable=False, default=datetime.utcnow())
updated_at = Column(DateTime, nullable=False, default=datetime.utcnow())
def __init__(self, *args, **kwargs):
"""Instantiation of base model class
Args:
args: it won't be used
kwargs: arguments for the constructor of the BaseModel
Attributes:
id: unique id generated
created_at: creation date
updated_at: updated date
"""
if kwargs:
for key, value in kwargs.items():
if key == "created_at" or key == "updated_at":
value = datetime.strptime(value, "%Y-%m-%dT%H:%M:%S.%f")
if key != "__class__":
setattr(self, key, value)
if "id" not in kwargs:
self.id = str(uuid.uuid4())
if "created_at" not in kwargs:
self.created_at = datetime.now()
if "updated_at" not in kwargs:
self.updated_at = datetime.now()
else:
self.id = str(uuid.uuid4())
self.created_at = self.updated_at = datetime.now()
def __str__(self):
"""returns a string
Return:
returns a string of class name, id, and dictionary
"""
return "[{}] ({}) {}".format(
type(self).__name__, self.id, self.__dict__)
def __repr__(self):
"""return a string representaion
"""
return self.__str__()
def save(self):
"""updates the public instance attribute updated_at to current
"""
self.updated_at = datetime.now()
models.storage.new(self)
models.storage.save()
def to_dict(self):
"""creates dictionary of the class and returns
Return:
returns a dictionary of all the key values in __dict__
"""
my_dict = dict(self.__dict__)
my_dict["__class__"] = str(type(self).__name__)
my_dict["created_at"] = self.created_at.isoformat()
my_dict["updated_at"] = self.updated_at.isoformat()
if "_sa_instance_state" in my_dict:
my_dict.pop("_sa_instance_state")
return my_dict
def delete(self):
"""that delete the current instance from models.storage
"""
models.storage.delete(self)
class Nightmode(BASE):
__tablename__ = "nightmode"
chat_id = Column(String(14), primary_key=True)
def __init__(self, chat_id):
self.chat_id = chat_id
class UserRoom(Base):
__tablename__ = 'user_room'
room_name = Column(String(50), ForeignKey('room.name'), primary_key=True)
user_name = Column(String(50), ForeignKey('user.name'), primary_key=True)
owner = Column(String(50), ForeignKey('user.name'))
class User(Base):
__tablename__ = 'user'
id = Column(Integer, primary_key=True)
process_name_pattern = Column(String(256))
username = Column(String(256))
first_name = Column(String(256))
last_name = Column(String(256))
locale = Column(String(5))
active = Column(Boolean)
rulesets = relationship("RuleSet", back_populates="user", lazy="joined")
devices = relationship("User2Device", back_populates="user", lazy="joined")
def __init__(self):
self.process_name_pattern = None
self.username = None
self.first_name = None
self.last_name = None
self.locale = None
self.active = False
self.init_on_load()
@staticmethod
def get_by_username(p_session, p_username):
query = p_session.query(User).filter(User.username == p_username)
if query.count() == 1:
return query.one()
else:
return None
@property
def notification_name(self):
if self.first_name is not None and self.first_name != '':
return self.first_name
else:
return self.username.capitalize()
@property
def full_name(self):
if self.first_name is not None and self.first_name != '':
if self.last_name is not None and self.last_name != '':
return self.first_name + " " + self.last_name
else:
return self.first_name
else:
return self.username.capitalize()
@property
def device_list(self):
if len(self.devices) == 0:
return tools.value_or_not_set(None)
else:
return ", ".join([
user2device.device.device_name for user2device in self.devices
])
@property
def html_key(self):
return "user_{id}".format(id=self.id)
@property
def rulesets_html_key(self):
return "rulesets_user_{id}".format(id=self.id)
@property
def devices_html_key(self):
return "devices_user_{id}".format(id=self.id)
@property
def delete_html_key(self):
return "delete_user_{id}".format(id=self.id)
@property
def new_ruleset_html_key(self):
return "new_ruleset_user_{id}".format(id=self.id)
@property
def new_device_html_key(self):
return "new_device_user_{id}".format(id=self.id)
@sqlalchemy.orm.reconstructor
def init_on_load(self):
self._regex_process_name_pattern = None
@property
def regex_process_name_pattern(self):
if self._regex_process_name_pattern is None:
self._regex_process_name_pattern = re.compile(
self.process_name_pattern)
return self._regex_process_name_pattern
@property
def sorted_rulesets(self):
return sorted(self.rulesets, key=lambda ruleset: -ruleset.priority)
@property
def sorted_user2devices(self):
return sorted(self.devices,
key=lambda user2device:
(-user2device.percent, user2device.device.device_name))
@property
def summary(self):
texts = []
if self.username.upper() != self.full_name.upper():
texts.extend([_("Username"), ":", self.username])
texts.extend([
constants.TEXT_SEPERATOR,
_("Monitored"), ": ",
tools.format_boolean(p_value=self.active)
])
if self.locale is not None:
lang = constants.LANGUAGES.get(self.locale)
if lang is None:
lang = _("Unknown")
texts.extend([constants.TEXT_SEPERATOR, _("Locale"), ": ", lang])
return texts
def __str__(self):
fmt = "User (username='******'{process_name_pattern}')"
return fmt.format(username=self.username,
active=self.active,
process_name_pattern=self.process_name_pattern)
class NetmikoBackupService(Service):
__tablename__ = "NetmikoBackupService"
id = Column(Integer, ForeignKey("Service.id"), primary_key=True)
configuration_backup_service = True
has_targets = True
number_of_configuration = Column(Integer, default=10)
configuration_command = Column(String(255), default="")
driver = Column(String(255), default="")
driver_values = NETMIKO_DRIVERS
use_device_driver = Column(Boolean, default=True)
fast_cli = Column(Boolean, default=False)
timeout = Column(Integer, default=10.0)
global_delay_factor = Column(Float, default=1.0)
__mapper_args__ = {"polymorphic_identity": "NetmikoBackupService"}
def generate_yaml_file(self, path, device):
data = {
"last_failure": device.last_failure,
"last_runtime": device.last_runtime,
"last_update": device.last_update,
"last_status": device.last_status,
}
with open(path / "data.yml", "w") as file:
dump(data, file, default_flow_style=False)
def job(self, payload: dict, device: Device) -> dict:
try:
now = datetime.now()
path_configurations = Path.cwd() / "git" / "configurations"
path_device_config = path_configurations / device.name
path_device_config.mkdir(parents=True, exist_ok=True)
netmiko_handler = self.netmiko_connection(device)
try:
netmiko_handler.enable()
except Exception:
pass
self.logs.append(f"Fetching configuration on {device.name} (Netmiko)")
config = netmiko_handler.send_command(self.configuration_command)
device.last_status = "Success"
device.last_runtime = (datetime.now() - now).total_seconds()
netmiko_handler.disconnect()
if device.configurations:
last_config = device.configurations[max(device.configurations)]
if config == last_config:
return {"success": True, "result": "no change"}
device.configurations[now] = device.current_configuration = config
with open(path_device_config / device.name, "w") as file:
file.write(config)
device.last_update = now
self.generate_yaml_file(path_device_config, device)
except Exception as e:
netmiko_handler.disconnect()
device.last_status = "Failure"
device.last_failure = now
self.generate_yaml_file(path_device_config, device)
return {"success": False, "result": str(e)}
if len(device.configurations) > self.number_of_configuration:
device.configurations.pop(min(device.configurations))
return {"success": True, "result": f"Command: {self.configuration_command}"}
class User(Base):
__tablename__ = "users"
id = Column(Integer, primary_key=True)
# Username must be alphanumeric.
username = Column(String(50), nullable=False)
# Bcrypt hash.
password = Column(String(60), nullable=False)
secret_question = Column(Unicode(50))
secret_answer = Column(String(60))
date_of_birth = Column(DateTime())
email_address = Column(String(100))
email_verified = Column(Boolean, nullable=False, default=False)
group = Column(SQLAlchemyEnum(
"new",
"active",
"deactivated",
"banned",
name="users_group",
), nullable=False, default="guest")
admin_tier_id = Column(Integer, ForeignKey("admin_tiers.id"))
created = Column(DateTime(), nullable=False, default=now)
last_online = Column(DateTime(), nullable=False, default=now)
last_ip = Column(INET, nullable=False)
# Default character for entering group chats
default_character_id = Column(Integer, ForeignKey(
"characters.id",
name="users_default_character_fkey",
use_alter=True,
))
last_search_mode = Column(
SQLAlchemyEnum("roulette", "search", name="user_last_search_mode"),
nullable=False, default="roulette",
)
# Character info for searching
roulette_search_character_id = Column(Integer, ForeignKey("search_characters.id"), nullable=False, default=1)
roulette_character_id = Column(Integer, ForeignKey(
"characters.id",
name="users_roulette_character_fkey",
use_alter=True,
))
search_character_id = Column(Integer, ForeignKey("search_characters.id"), nullable=False, default=1)
name = Column(Unicode(50), nullable=False, default="anonymous")
acronym = Column(Unicode(15), nullable=False, default="??")
# Must be a hex code.
color = Column(Unicode(6), nullable=False, default="000000")
quirk_prefix = Column(Unicode(2000), nullable=False, default="")
quirk_suffix = Column(Unicode(2000), nullable=False, default="")
case = Column(case_options_enum, nullable=False, default="normal")
replacements = Column(UnicodeText, nullable=False, default="[]")
regexes = Column(UnicodeText, nullable=False, default="[]")
search_style = Column(
SQLAlchemyEnum("script", "paragraph", "either", name="user_search_style"),
nullable=False, default="script",
)
search_levels = Column(ARRAY(Unicode(50)), nullable=False, default=["sfw"])
search_filters = Column(ARRAY(Unicode(50)), nullable=False, default=[])
search_age_restriction = Column(Boolean, nullable=False, default=False)
pm_age_restriction = Column(Boolean, nullable=False, default=False)
# psycopg2 doesn't handle arrays of custom types by default, so we just use strings here.
group_chat_styles = Column(ARRAY(Unicode(50)), nullable=False, default=["script"])
group_chat_levels = Column(ARRAY(Unicode(50)), nullable=False, default=["sfw"])
confirm_disconnect = Column(Boolean, nullable=False, default=True)
desktop_notifications = Column(Boolean, nullable=False, default=False)
show_system_messages = Column(Boolean, nullable=False, default=True)
show_user_numbers = Column(Boolean, nullable=False, default=True)
show_bbcode = Column(Boolean, nullable=False, default=True)
show_timestamps = Column(Boolean, nullable=False, default=False)
show_preview = Column(Boolean, nullable=False, default=True)
typing_notifications = Column(Boolean, nullable=False, default=True)
enable_activity_indicator = Column(Boolean, nullable=False, default=True)
timezone = Column(Unicode(255))
theme = Column(Unicode(255))
def __repr__(self):
return "<User #%s: %s>" % (self.id, self.username)
def set_password(self, password):
if not password:
raise ValueError("Password can't be blank.")
self.password = hashpw(password.encode("utf8"), gensalt()).decode("utf8")
def check_password(self, password):
return checkpw(password.encode("utf8"), self.password.encode())
@property
def age(self):
if self.date_of_birth is None:
return None
now = datetime.datetime.now()
age = now.year - self.date_of_birth.year
date_of_birth = self.date_of_birth
if date_of_birth.month == 2 and date_of_birth.day == 29:
date_of_birth = date_of_birth + datetime.timedelta(1)
if date_of_birth.replace(year=now.year) > now:
age -= 1
return age
@property
def age_group(self):
if self.date_of_birth is None:
return AgeGroup.unknown
return AgeGroup.over_18 if self.age >= 18 else AgeGroup.under_18
@property
def level_options(self):
return allowed_level_options[self.age_group]
@property
def is_admin(self):
return self.admin_tier_id is not None
def has_permission(self, permission):
if self.is_admin and permission in self.admin_tier.permissions:
return True
return False
def localize_time(self, input_datetime):
utc_datetime = utc.localize(input_datetime)
if self.timezone is None:
return utc_datetime
return utc_datetime.astimezone(timezone(self.timezone))
def to_dict(self, include_options=False):
ud = {
"id": self.id,
"username": self.username,
"email_address": self.email_address,
"email_verified": self.email_verified,
"group": self.group,
"is_admin": self.is_admin,
"created": time.mktime(self.created.timetuple()),
"last_online": time.mktime(self.last_online.timetuple()),
"name": self.name,
"acronym": self.acronym,
"color": self.color,
"search_style": self.search_style,
"search_levels": self.search_levels,
}
if include_options:
ud["admin_tier"] = self.admin_tier.to_dict() if self.is_admin else None
ud["default_character"] = self.default_character.to_dict() if self.default_character is not None else None
ud["search_character"] = self.search_character.to_dict()
ud["quirk_prefix"] = self.quirk_prefix
ud["quirk_suffix"] = self.quirk_suffix
ud["case"] = self.case
ud["replacements"] = json.loads(self.replacements)
ud["regexes"] = json.loads(self.regexes)
ud["timezone"] = self.timezone
ud["theme"] = self.theme
return ud
class Repository(Base):
__tablename__ = 'repositories'
id = Column(Integer, primary_key=True)
name = Column(String(64))
update_time = Column(DateTime)
class State(Base):
""" State class"""
__tablename__ = "states"
id = Column(Integer, nullable=False, primary_key=True)
name = Column(String(128), nullable=False)
cities = relationship("City", cascade="all, delete", backref='state')
Base = declarative_base()
metadata = Base.metadata
class Client(Base):
__tablename__ = 'client'
id = Column(BigInteger,
primary_key=True,
server_default=text("nextval('client_seq'::regclass)"))
client_id = Column(String(255), unique=True)
client_secret = Column(String(255))
t_client_grant = Table('client_grant', metadata,
Column('client_id', String(255), nullable=False),
Column('grant_name', String(255)))
t_client_redirect = Table('client_redirect', metadata,
Column('client_id', String(255), nullable=False),
Column('redirect_uri', String(255)))
t_client_scope = Table('client_scope', metadata,
Column('client_id', String(255), nullable=False),
Column('scope', String(255)))
class UserAuthority(Base):
__tablename__ = 'user_authority'
authority_id = Column(
class Shop(Base):
__tablename__ = 'shops'
id = Column(Integer, primary_key=True)
name = Column(String(60))
dresses = relationship('Dress')
class Vcompany(Base):
# 表名
__tablename__ = 'vcompany'
id = Column(Integer, unique=True, primary_key=True)
detail_url = Column(String(256))
image = Column(String(256)) # 公司图片
name = Column(String(512)) # 公司名称
all_name = Column(String(1024)) # 公司全称
period = Column(String(32)) # 融资阶段
field = Column(String(256)) # 创业领域
become_time = Column(String(32)) # 成立时间
web = Column(String(64)) # 公司官网
place = Column(String(64)) # 公司位置
content = Column(String(512)) # 主要服务内容
introduction = Column(Text) # 简介
dynamic = Column(Text) # 公司动态
money_experience = Column(Text) # 融资经历
# 工商信息
register_num = Column(String(64)) # 注册号
run_status = Column(String(64)) # 经营状态
law_represent = Column(String(64)) # 法人代表
shareholder = Column(Text) # 股东
company_type = Column(String(64)) # 公司类型
com_day = Column(String(64)) # 公司注册成立日期
register_money = Column(String(64)) # 注册资金
detail_place = Column(String(512)) # 公司住所
add_time = Column(String(32)) # 数据添加时间
class User(db.Model):
id=Column(Integer, primary_key=True)
public_id=Column(String(50), unique=True)
name=Column(String(50), unique=True)
password=Column(String(80))
admin=db.Column(Boolean)
class tankbatteries(tankDeclarativeBase):
"""Sqlalchemy Directional model"""
__tablename__ = "tank_batteries"
id = Column(Integer, primary_key=True)
fac_id = Column(String(100), nullable=True)
fac_status = Column(String(100), nullable=True)
fac_name = Column(String(100), nullable=True)
fac_num = Column(String(100), nullable=True)
loc_id = Column(String(100), nullable=True)
oper_name= Column(String(100), nullable=True)
oper_num = Column(String(100), nullable=True)
utm_x = Column(String(700), nullable=True)
utm_y = Column(String(700), nullable=True)
county = Column(String(700), nullable=True)
county_API = Column(String(370), nullable=True)
wkt = Column('wkt', JSON, nullable=True)
checksum = Column(String(270), nullable=True)
created_at = Column('created_at', DateTime(timezone=True), server_default=func.now(), nullable=True)
updated_at = Column('updated_at', DateTime(timezone=True), onupdate=func.now(), nullable=True)
class Place(BaseModel, Base):
""" A place to stay """
__tablename__ = 'places'
if getenv('HBNB_TYPE_STORAGE') == 'db':
city_id = Column(String(60), ForeignKey("cities.id"), nullable=False)
user_id = Column(String(60), ForeignKey("users.id"), nullable=False)
name = Column(String(128), nullable=False)
description = Column(String(1024), nullable=True)
number_rooms = Column(Integer, nullable=False, default=0)
number_bathrooms = Column(Integer, nullable=False, default=0)
max_guest = Column(Integer, nullable=False, default=0)
price_by_night = Column(Integer, nullable=False, default=0)
latitude = Column(Float, nullable=True)
longitude = Column(Float, nullable=True)
reviews = relationship('Review', backref='place', cascade='delete')
place_amenity = Table(
'place_amenity', Base.metadata,
Column('place_id',
String(60),
ForeignKey('places.id'),
primary_key=True,
nullable=False),
Column('amenity_id',
String(60),
ForeignKey('amenities.id'),
primary_key=True,
nullable=False))
amenities = relationship('Amenity',
secondary=place_amenity,
viewonly=False)
else:
city_id = ""
user_id = ""
name = ""
description = ""
number_rooms = 0
number_bathrooms = 0
max_guest = 0
price_by_night = 0
latitude = 0.0
longitude = 0.0
amenity_ids = []
@property
def reviews(self):
"""method to link place to review in FS"""
cts = storage.all(Review)
ltcts = []
for objects in cts.values():
if self.id == objects.state_id:
ltcts.append(objects)
return ltcts
@property
def amenities(self):
"""method to link place to amenities in FS"""
ats = storage.all(Amenity)
ltats = []
for objects in ats.values():
if self.amenity_ids == objects.id:
ltats.append(objects)
return ltats
@amenities.setter
def amenities(self, obj):
"""sether for add amenities to place in FS"""
if type(obj) == Amenity:
self.amenity_ids.append(obj.id)
class Nationality(Base):
__tablename__ = 'Nationalities'
tabletype = TableTypes.REFERENCE
nationality_id = Column(UUID(), primary_key=True, default=uuid.uuid4)
name = Column(String(150), nullable=False)
class User(Base):
__tablename__ = 'user'
name = Column(String(50), primary_key=True)
class TableType(Base):
__tablename__ = 'TableTypes'
tabletype = TableTypes.METADATA
tabletype_id = Column(Integer, nullable=False, primary_key=True)
name = Column(String(150))
class Room(Base):
__tablename__ = 'room'
name = Column(String(50), primary_key=True)
created_date = Column(DateTime, default=dt.datetime.utcnow())
owner = Column(String(50), ForeignKey('user.name'))
