def create_one(author_id, content, title) -> ArticleModel:
article = ArticleModel(author_id=author_id,
content=content,
title=title)
DBSession().add(article)
DBSession().flush()
return article
def _login_to_tracker(self, engine=None):
with DBSession() as db:
cred = db.query(LostFilmTVCredentials).first()
if not cred:
return False
username = cred.username
password = cred.password
if not username or not password:
return False
self.tracker.setup(cred.c_uid, cred.c_pass, cred.c_usess)
if self.tracker.verify():
if engine:
engine.log.info('Cookies are valid')
return True
if engine:
engine.log.info('Login to <b>lostfilm.tv</b>')
try:
self.tracker.login(username, password)
with DBSession() as db:
cred = db.query(LostFilmTVCredentials).first()
cred.c_uid = self.tracker.c_uid
cred.c_pass = self.tracker.c_pass
cred.c_usess = self.tracker.c_usess
except Exception as e:
if engine:
engine.log.failed(
'Login to <b>lostfilm.tv</b> failed: {0}'.format(
e.message))
return self.tracker.verify()
def post_menus(restaurant_id: int):
session = DBSession()
new_item = MenuItem(
name=request.json["name"],
description=request.json["description"],
price=request.json["price"],
course=request.json["course"],
restaurant_id=restaurant_id,
)
session.add(new_item)
session.commit()
return (
jsonify(
{
"name": new_item.name,
"description": new_item.description,
"id": new_item.id,
"price": new_item.price,
"course": new_item.course,
}, ),
201,
{
"Location":
url_for("api.get_menus", restaurant_id=restaurant_id) +
f"/{new_item.id}",
},
)
def main(argv):
# Load env variables
load_dotenv()
# Parse arguments
parser = argparse.ArgumentParser(description='Overlord Discord Bot')
parser.add_argument('-c', '--config', nargs='?', type=str, default='config.json', help='config path')
args = parser.parse_args(argv[1:])
# Load config
config = ConfigView(path=args.config, schema_name="config_schema")
# Apply logging config
if config['logger']:
logging.config.dictConfig(config['logger'])
# Init database
url = os.getenv('DATABASE_ACCESS_URL')
if 'sqlite' in url:
import db.queries as q
q.MODE = q.MODE_SQLITE
session = DBSession(url, autocommit=False)
session.sync_table(EventType, 'name', EVENT_TYPES)
session.sync_table(UserStatType, 'name', USER_STAT_TYPES)
# Init bot
discord_bot = Overlord(config.bot, session)
discord_bot.run()
return 0
def get_one(**args) -> CommentModel:
query = DBSession().query(CommentModel)
if "id" in args:
query = query.filter(CommentModel.id == args["id"])
return query.first()
def GetInstances(self, request: GetInstancesRequest,
context: ServicerContext,
claims: TokenClaims) -> GetInstancesResponse:
session = DBSession()
user = get_user_from_claims(session, claims)
instances = user.instances
session.close()
# find the instances
client = create_client()
resp = GetInstancesResponse()
for db_server in instances:
server = client.connection.get_server_by_id(db_server.id)
flavor = client.connection.get_flavor_by_id(server.flavor["id"])
i = Instance()
i.id = server.id
i.name = server.name
i.imageName = db_server.image_name
i.flavor.name = flavor.name
i.flavor.cpu = flavor.vcpus
i.flavor.memory = flavor.ram
i.flavor.rootDisk = flavor.disk
i.status = server.status
i.vmState = server.vm_state
i.powerState = str(server.power_state)
if server.task_state is not None:
i.taskState = server.task_state
i.ip = server.public_v4
i.createTime = server.created_at
resp.instances.append(i)
return resp
def get_list(_fields: list = None, _paginated: bool = False, **kwargs):
page = 1 if "page" not in kwargs else int(kwargs["page"])
limit = 20 if "limit" not in kwargs else int(kwargs["limit"])
query = DBSession().query(ArticleModel)
if "created_at_ge" in kwargs:
query = query.filter(
ArticleModel.created_at >= kwargs["created_at_ge"])
if "created_at_le" in kwargs:
query = query.filter(
ArticleModel.created_at <= kwargs["created_at_le"])
if _fields is not None:
query = query.with_entities(
*[getattr(ArticleModel, _field) for _field in _fields])
if limit != 0:
datas = (query.order_by(desc(
ArticleModel.created_at)).limit(limit).offset(
(page - 1) * limit))
else:
datas = query.order_by(desc(ArticleModel.created_at))
if _paginated:
total = query.count()
return datas, schemas.PageInfoSchema.paginate(total, page, limit)
else:
return datas
def delete_menu(restaurant_id: int, menu_id: int):
session = DBSession()
restaurant = session.query(Restaurant).filter_by(
id=restaurant_id).one_or_none()
item = (session.query(MenuItem).filter_by(
id=menu_id, restaurant_id=restaurant_id).one_or_none())
if restaurant is None:
return (
jsonify({"details": f"Restaurant {restaurant_id} does not exist"}),
404,
{},
)
if item is None:
return (
jsonify(
{
"details":
f"Menu item {menu_id} does not exist in restaurant {restaurant.name}",
}, ),
404,
{},
)
session.delete(item)
session.commit()
return (
None,
204,
{},
)
def AddUser(self, req: AddUserRequest, context) -> AddUserResponse:
session = DBSession()
user = ProjectUser(id=req.userProjectAssignmentId,
user_id=req.userId,
project_id=req.projectId)
session.add(user)
session.commit()
return AddUserResponse()
def get_next_timestamp_by_path(path):
with DBSession() as session:
storage_file = session.query(Storage).filter(
Storage.path == path).one()
sql_map = session.query(Map).get(storage_file.map_id)
sql_file = found_next_map_in_storage(
session, sql_map, storage_file.timestamp + timedelta(seconds=1))
return sql_file.timestamp if sql_file else None
def remove_watch(self, url):
with DBSession() as db:
topic = db.query(RutorOrgTopic).filter(
RutorOrgTopic.url == url).first()
if topic is None:
return False
db.delete(topic)
return True
def manageSession(request):
session = DBSession()
def closeSession(request):
session.close()
request.add_finished_callback(closeSession)
return session
def remove_watch(self, url):
with DBSession() as db:
topic = db.query(LostFilmTVSeries).filter(
LostFilmTVSeries.url == url).first()
if topic is None:
return False
db.delete(topic)
return True
def __init__(self, session=None, autoinit=True):
if not autoinit:
self._session = None
elif session is None or not isinstance(session, Union[Session, scoped_session].__args__):
self._session: scoped_session = DBSession()
else:
self._session = session
self._session.expire_on_commit = False
def set_settings(self, settings):
with DBSession() as db:
cred = db.query(LostFilmTVCredentials).first()
if not cred:
cred = LostFilmTVCredentials()
db.add(cred)
cred.username = settings['username']
cred.password = settings['password']
def DeleteProject(self, request, context):
client = create_client()
session = DBSession()
for user in session.query(ProjectUser).filter_by(
project_id=request.projectId):
delete_db_user(user, client)
session.delete(user)
session.commit()
return DeleteProjectResponse()
def get_fees(symbol, side, start, end):
with DBSession() as session:
query = session.query(func.sum(Order.fill_fees)). \
filter(Order.symbol == symbol). \
filter(Order.side == side)
if start and end:
query = query.filter(Order.created_at >= start,
Order.created_at < end)
return float(query.scalar())
def _get_settings_execute():
with DBSession() as db:
if db.query(Execute).count() == 0:
settings_execute = Execute(interval=7200, last_execute=None)
db.add(settings_execute)
db.commit()
settings_execute = db.query(Execute).first()
db.expunge(settings_execute)
return settings_execute
def update_one(article_id, **args) -> ArticleModel:
article = ArticleManager.get_one(article_id=article_id)
if "content" in args:
article.content = args["content"]
if "title" in args:
article.title = args["title"]
DBSession().flush()
return article
def get_one(**args) -> AuthorModel:
query = DBSession().query(AuthorModel)
if "id" in args:
query = query.filter(AuthorModel.id == args["id"])
if "name" in args:
pass
return query.first()
def get_one(**args) -> ArticleModel:
query = DBSession().query(ArticleModel)
if "id" in args:
query = query.filter(ArticleModel.id == args["id"])
if "title" in args:
pass
return query.first()
def init_async_executor(app, loop):
executor = AsyncioExecutor(loop)
app.add_route(
GraphQLView.as_view(schema=schema,
executor=executor,
context=dict({"session": DBSession()},
**get_dataloaders()),
**kwargs),
path,
)
def init_web_route(app, loop):
print("初始化web路由")
app.add_route(
GraphQLView.as_view(schema=schema,
context=dict({"session": DBSession()},
**get_dataloaders()),
graphiql_template=TEMPLATE,
**kwargs),
"/web",
)
def get_one(**args) -> OrdinaryWriterModel:
query = DBSession().query(OrdinaryWriterModel)
if "id" in args:
query = query.filter(OrdinaryWriterModel.id == args["id"])
if "author_id" in args:
query = query.filter(
OrdinaryWriterModel.author_id == args["author_id"])
return query.first()
def interval(self, value):
settings_execute = self._get_settings_execute()
with DBSession() as db:
db.add(settings_execute)
settings_execute.interval = value
db.commit()
self.timer.cancel()
with self._timer_lock:
self.timer = threading.Timer(value, self._run)
self.timer.start()
def DeleteUser(self, request: DeleteUserRequest,
context) -> DeleteUserResponse:
client = create_client()
session = DBSession()
for user in session.query(ProjectUser).filter_by(
user_id=request.userId):
delete_db_user(user, client)
session.delete(user)
session.commit()
return DeleteUserResponse()
def get_settings(self):
with DBSession() as db:
cred = db.query(TransmissionCredentials).first()
if not cred:
return None
return {
'host': cred.host,
'port': cred.port,
'username': cred.username
}
def set_settings(self, settings):
with DBSession() as db:
cred = db.query(TransmissionCredentials).first()
if not cred:
cred = TransmissionCredentials()
db.add(cred)
cred.host = settings['host']
cred.port = settings['port']
cred.username = settings.get('username', None)
cred.password = settings.get('password', None)
def spider_closed(self, spider):
session = DBSession()
task = session.query(SpiderTask).filter(
SpiderTask.spider_rule_id == self.rule_id,
SpiderTask.end_time == None).first()
if task:
task.end_time = datetime.now()
task.status = "closed"
session.commit()
session.close()
def save_order(order_data):
order = Order(order_id=order_data.get("id"),
side=order_data.get("side"),
state=order_data.get("state"),
price=float(order_data.get("price")),
symbol=order_data.get("symbol"),
amount=float(order_data.get("amount")),
filled_amount=float(order_data.get("filled_amount")),
fill_fees=float(order_data.get("fill_fees")))
with DBSession() as session:
session.add(order)
