def test_main_service_db_connection(self):
with transaction_context() as session:
entry = Action(time=1,
name="test1",
action_type=ActionType.FIXED_ACTION.value)
session.add(entry)
entry = Action(time=2,
name="test2",
action_type=ActionType.FIXED_ACTION.value)
session.add(entry)
entry = Action(time=0,
name="test3",
action_type=ActionType.REPETITIVE_ACTION.value)
session.add(entry)
service = MainService()
service.run()
lst = service.get_action_from_queue()
self.assertEqual(len(lst), 0)
time.sleep(3)
lst = service.get_action_from_queue()
self.assertEqual(len(lst), 3)
with transaction_context() as session:
lst = session.query(Action).all()
for i in lst:
print(i)
session.delete(i)
def test_db(self):
with transaction_context() as session:
entry = Action(time=1,
name="test",
action_type=ActionType.REPETITIVE_ACTION.value)
session.add(entry)
with transaction_context() as session:
lst = session.query(Action).all()
for i in lst:
print(i)
session.delete(i)
def is_cron(self, message: str) -> bool:
with transaction_context() as session:
r = session.query(Cron).filter_by(message=message).all()
if len(r) == 0:
return False
else:
return True
def tearDown(self):
print('END TestParamService')
with transaction_context() as session:
lst = session.query(ParamDb).all()
for elem in lst:
session.delete(elem)
print(f'{elem} removed from db')
def setUp(self):
print('BEGIN TestParamService')
with transaction_context() as session:
entry = ParamDb(name=ParamName.BEGIN_TIME_REPETITIVE_ACTION,
value=2)
print(f'{entry} added to db')
session.add(entry)
def put(self, message: str, cron: str) -> Cron:
with transaction_context() as session:
entry = Cron(message=message, cron=cron)
session.add(entry)
session.commit()
logger.info('Cron added {}'.format(entry))
return entry
def alert_is_in_db(self, message: str, time: str) -> bool:
with transaction_context() as session:
r = session.query(DbAlert).filter_by(message=message).filter_by(
time=time).all()
if len(r) == 0:
return False
else:
return True
def put(self, alert: Alert) -> Alert:
with transaction_context() as session:
entry = DbAlert(**asdict(alert))
session.add(entry)
session.commit()
alert = Alert(**entry.serialize)
logger.info('Alert added in DB : {}'.format(alert))
return alert
def client_id_present_in_db(client_id: str) -> bool:
with transaction_context() as session:
ids = session.query(DbClientId).all()
ids = set(map(lambda x: x.client_id, ids))
if client_id in ids:
return True
else:
return False
def get_param(self, param_name: ParamName) -> Param:
with transaction_context() as session:
entry = session.query(ParamDb).filter_by(
name=param_name.value).first()
if entry is None:
logger.error(f'{param_name} not in db')
raise Exception(f'{param_name} not in db')
param = Param(name=param_name, value=entry.value)
return param
def add_param(self, name: str, value):
param_name = ParamName(name)
if param_name is ParamName.OTHER:
logger.error(f'{name} not in ParamName enum')
raise Exception(
f'{name} not in ParamName enum. Accepted value : ' +
';'.join([i for i in ParamName]))
with transaction_context() as session:
entry = ParamDb(name=param_name, value=value)
session.add(entry)
def update_scope(name: str, scopes: List[str]) -> User:
logger.info(f'Updating scope of user {name} with {scopes}')
with transaction_context() as session:
user = session.query(DbUser).filter_by(nickname=name).first()
if user is None:
raise Exception(f'No user named {name}')
user.scopes = ' '.join(scopes)
session.commit()
ret = User(**user.serialize)
return ret
def create_user(name: str, pwd: str, scopes: List[str] = None) -> User:
logger.info(f'Creating user {name}')
user = DbUser(nickname=name,
password=pwd,
scopes=' '.join(scopes) if scopes else '')
with transaction_context() as session:
session.add(user)
session.commit()
ret = User(**user.serialize)
return ret
def emit(self, record):
trace = None
exc = record.__dict__['exc_info']
if exc:
trace = traceback.format_exc()
with transaction_context() as session:
log = Log(logger=record.__dict__['name'],
level=record.__dict__['levelname'],
trace=trace,
message=record.__dict__['message'])
session.add(log)
def create_new_build_order():
name = request.form['name']
with transaction_context() as session:
session.expire_on_commit = False
lst = session.query(BuildOrder).filter_by(name=name).all()
if len(lst) == 0:
entry = BuildOrder(name=name)
session.add(entry)
else:
entry = lst[0]
j = entry.serialize
return jsonify(j)
def actions(build_order=None, _id=None):
if _id:
if request.method == 'DELETE':
with transaction_context() as session:
to_del = session.query(Action).filter_by(id=_id).first()
logger.info(f'Deleting {to_del}')
session.delete(to_del)
return '', 204
elif request.method == 'GET':
with transaction_context() as session:
to_ret = session.query(Action).filter_by(id=_id).first()
j = to_ret.serialize
return jsonify(j)
elif request.method == 'PUT':
with transaction_context() as session:
session.expire_on_commit = False
to_update = session.query(Action).filter_by(id=_id).first()
logger.info(f'Updating {to_update} with : {request.json}')
# to_update.__dict__.update(**request.json)
for k, v in request.json.items():
setattr(to_update, k, v)
session.add(to_update)
else:
if request.method == 'GET':
with transaction_context() as session:
lst = session.query(BuildOrder).filter_by(
name=build_order).first().actions
lst = sorted(lst, key=lambda x: x.time)
lst = [i.serialize for i in lst]
return jsonify(lst)
elif request.method == 'POST':
with transaction_context() as session:
session.expire_on_commit = False
new_action = Action(**request.json)
session.add(new_action)
session.commit()
logger.info(f'Creating {new_action}')
j = new_action.serialize
return jsonify(j), 201
return '', 200
def get_action_list(self) -> List[Action]:
lst_to_return = []
with transaction_context() as session:
if self.build_order_name is None:
lst = session.query(ActionDb).all()
else:
lst = session.query(BuildOrder).filter_by(
name=self.build_order_name).first().actions
lst = list(
filter(lambda x: x.action_type == ActionType.FIXED_ACTION,
lst))
lst_to_return = [Action(i.time, i.name) for i in lst]
return lst_to_return
def get_user_by_name(name: str) -> DbUser:
with transaction_context() as session:
user: DbUser = session.query(DbUser).filter_by(nickname=name).first()
if user is None:
raise UserNotFoundException(f'User not found : {name}')
return user
def add_one(client_id: str):
with transaction_context() as session:
entry = DbClientId(client_id=client_id)
session.add(entry)
def get_all(self) -> List[Param]:
with transaction_context() as session:
lst = session.query(ParamDb).all()
lst = [Param(name=i.name, value=i.value) for i in lst]
return lst
def get_all_users() -> List[User]:
with transaction_context() as session:
users_from_db: List[DbUser] = session.query(DbUser).all()
users = list(map(lambda x: User(**x.serialize), users_from_db))
return users
def get_all(self) -> List[Alert]:
with transaction_context() as session:
r = session.query(DbAlert).all()
r = list(map(lambda x: Alert(**x.serialize), r))
return r
def delete_param(self, param_name: ParamName):
with transaction_context() as session:
entry = session.query(ParamDb).filter_by(
name=param_name.value).first()
if entry is not None:
session.delete(entry)
def remove_one(self, _id: int):
with transaction_context() as session:
r = session.query(DbAlert).filter_by(id=_id).first()
logger.info('Removing alert {}'.format(r.serialize))
session.delete(r)
def setUp(self) -> None:
Base.metadata.create_all(bind=engine)
self.password = '******'
user = DbClientId(client_id='aaa')
with transaction_context() as session:
session.add(user)
def setUp(self):
Base.metadata.create_all(bind=engine)
self.password = '******'
user = DbUser(nickname='Robin', password=self.password, scopes="a b c")
with transaction_context() as session:
session.add(user)
def get_all_build_orders_name():
with transaction_context() as session:
lst = session.query(BuildOrder).all()
lst = [i.name for i in lst]
return jsonify(lst)
def persist_entry(self, action: Action):
with transaction_context() as session:
entry = ActionDb(time=action.time,
name=action.name,
action_type=ActionType.FIXED_ACTION.value)
session.add(entry)
def delete_entry(self, action: Action):
with transaction_context() as session:
entry = session.query(ActionDb).filter_by(
time=action.time, name=action.name).first()
session.delete(entry)
def get_all() -> List[str]:
with transaction_context() as session:
ids = session.query(DbClientId).all()
ids = list(map(lambda x: x.client_id, ids))
return ids
