def test_operation(self):
op = Operation(self.extractor, self.inspector, self.param_values)
op.execute(self.device_info, self.data_dir_path, simple_output=True)
self.assertTrue(
os.path.exists(
os.path.join(self.data_dir_path, EXTRACTED_DATA_DIR_NAME)))
self.assertTrue(
os.path.exists(
os.path.join(self.data_dir_path, INSPECTED_DATA_FILE_NAME)))
self.assertTrue(
os.path.exists(
os.path.join(self.data_dir_path, SOURCE_DATA_FILE_NAME)))
def get_operation(self, name):
"""
:param name: string
:rtype: Operation
"""
if not self.definitions_database.exists_operation(name):
raise ValueError("'{0}' is not a defined Operation.".format(name))
extractor_name, inspector_name, param_values = self.definitions_database.get_operation_exec_info(
name)
try:
extractor = self.repositories_manager.get_extractor_instance(
extractor_name)
except (ImportError, AttributeError, TypeError):
raise RuntimeError(
'Could not instantiate the operation\'s extractor class')
try:
inspector = self.repositories_manager.get_inspector_instance(
inspector_name)
except (ImportError, AttributeError, TypeError):
raise RuntimeError(
'Could not instantiate the operation\'s inspector class')
return Operation(extractor, inspector, param_values)
def p_BinaryArithExpr(self, p):
'''BinaryArithExpr : AnnidateArithExpr PLUS AnnidateArithExpr
| AnnidateArithExpr MINUS AnnidateArithExpr
| AnnidateArithExpr MUL AnnidateArithExpr
| AnnidateArithExpr DIVIDE AnnidateArithExpr
| MINUS AnnidateArithExpr
'''
if len(p) > 3:
oper = Operation(p[1].value, str(p[2]), p[3].value)
node = self.manager.createNode(oper, [p[1], p[3]])
p[0] = node
else:
tmpNode = self.manager.createNode(Number("0"), [])
oper = Operation(tmpNode.value, str(p[1]), p[2].value)
p[0] = self.manager.createNode(oper, [tmpNode, p[2]])
self.myPrint("BinaryArithExpr", p)
def update(self, obj: Operation) -> int:
return self.connection[DATABASE][COLLECTION_OPERATION].update_one(
filter={
'idx': obj.idx
},
update={
'$set': obj.convert_to_db_format()
}).modified_count
def p_AnnidateArithExpr(self, p):
'''AnnidateArithExpr : LPAREN AnnidateArithExpr PLUS AnnidateArithExpr RPAREN
| LPAREN AnnidateArithExpr MINUS AnnidateArithExpr RPAREN
| LPAREN AnnidateArithExpr MUL AnnidateArithExpr RPAREN
| LPAREN AnnidateArithExpr DIVIDE AnnidateArithExpr RPAREN
| LPAREN MINUS AnnidateArithExpr RPAREN
'''
if len(p) > 5:
oper = Operation(p[2].value, str(p[3]), p[4].value)
node = self.manager.createNode(oper, [p[2], p[4]])
p[0] = node
else:
tmpNode = self.manager.createNode(Number("0"), [])
oper = Operation(tmpNode.value, str(p[2]), p[3].value)
p[0] = self.manager.createNode(oper, [tmpNode, p[3]])
self.myPrint("AnnidateArithExpr", p)
def p_AnnidateArithExprNegativeSpecial(self, p):
'''AnnidateArithExpr : LPAREN AnnidateArithExpr NEGNUMBER RPAREN
'''
negative_string = str(p[3])
positive_string = remove_starting_minus_from_string(negative_string)
tmpNode = self.manager.createNode(Number(positive_string), [])
oper = Operation(p[2].value, "-", tmpNode.value)
p[0] = self.manager.createNode(oper, [p[2], tmpNode])
self.myPrint("AnnidateArithExprNegativeSpecial", p)
def get_operation(operation_key=None, handler_class=None):
if operation_key is None and handler_class is None:
raise CoreError("operation_key and handler_class can't be empty meantime.")
query = Operation.all()
if operation_key is not None:
query.filter("operation_key =", operation_key)
if handler_class is not None:
query.filter("handler_classes like ", "%%%s%%" % handler_class)
operation = query.get()
return operation
def update_operation_status(self, operation_id: int,
operation_status: str) -> str:
try:
logging.info(
"------------- update operation status executed -----------")
status, operation = self._validate_operation_id(
operation_id=operation_id)
if not status:
logging.error(
Error.ERROR_OPERATION_NOT_EXISTS.format(operation_id))
return Error.ERROR_OPERATION_NOT_EXISTS.format(operation_id)
operation = Operation(**operation)
operation.status = operation_status
operation.updated_timestamp = str(datetime.now())
operation_dao.update(obj=operation)
logging.info(Message.OPERATION_UPDATED.format(operation.idx))
return Message.OPERATION_UPDATED.format(operation.idx)
except Exception as e:
logging.error(Error.ERROR_OPERATION_UPDATE.format(str(e)))
return Error.ERROR_OPERATION_UPDATE.format(str(e))
def create_operation(operation_key, handler_classes, resource_oql, modifier_id):
if type(handler_classes) == str:
handler_classes = [handler_classes]
query = Operation.all()
for handler_class in handler_classes:
query.filter("handler_classes like ", "%%%s%%" % handler_class)
if query.count() > 0:
raise CoreError("One handler only can have one corresponding operation. The handler %s is corresponding to multiple operations." % handler_class)
query = Operation.all()
query.filter("operation_key =", operation_key)
operation = Operation(operation_key=operation_key)
operation.handler_classes = ",".join(handler_classes)
operation.resource_oql = resource_oql
operation.create(modifier_id)
return operation
def create_operation(self, operation: dict) -> (int, str):
try:
if not self._validate_user_id(user_id=operation['user_id']):
logging.error(
Error.ERROR_OPERATION_USER_NOT_EXISTS.format(
operation['user_id']))
return 409, Error.ERROR_OPERATION_USER_NOT_EXISTS.format(
operation['user_id'])
operation = Operation(**operation)
operation.idx = sequence_dao.increment_and_get_sequence(
SEQUENCE_COLLECTION_OPERATION)
operation.status = Status.CREATED.value
operation.created_timestamp = str(datetime.now())
operation_dao.create(obj=operation)
logging.info(Message.OPERATION_CREATED.format(operation.idx))
return 200, Message.OPERATION_CREATED.format(operation.idx)
except Exception as e:
logging.error(Error.ERROR_OPERATION_CREATE.format(str(e)))
return 500, Error.ERROR_OPERATION_CREATE.format(str(e))
def has_permission(user_id, operation_key, oqlparams=None):
b = False
cachekey = '%d:%s:%r' % (user_id, operation_key, oqlparams)
perm = cache.get(CACHESPACE_PERMISSION, cachekey)
if perm != None:
return perm
query = stdModel.all()
query.model(UserRole.get_modelname(), "a")
query.model(Role.get_modelname(), "b", join="inner", on="a.role_id=b.uid")
query.model(RoleOperation.get_modelname(), "c", join="inner", on="c.role_id=b.uid")
query.model(Operation.get_modelname(), "d", join="inner", on="c.operation_key=d.operation_key")
query.what("a.user_id", alias="user_id")
query.what("b.uid", alias="role_id")
query.what("d.operation_key", alias="operation_key")
query.what("d.handler_classes", alias="handler_classes")
query.what("d.resource_oql", alias="resource_oql")
query.what("a.user_id", alias="user_id")
query.filter("a.user_id =", user_id)
if operation_key is not None:
query.filter("d.operation_key =", operation_key)
std = query.get()
if std != None:
if std.resource_oql != None:
operation = get_operation(operation_key=operation_key)
params = operation.get_resource_oql_paramnames()
if len(params) != len(oqlparams):
raise UnauthorizedError()
query = stdModel.all()
if oqlparams != None and len(oqlparams) > 0 :
query = query.sql(std.resource_oql, sql_vars=oqlparams)
else:
query = query.sql(std.resource_oql)
if query.count() > 0:
b = True
else:
b = True
cache.put(CACHESPACE_PERMISSION, cachekey, b)
return b
def sync_operation(operation_dict: Dict, operation: model.Operation = None) -> model.Operation:
if not operation:
operation = model.Operation()
if operation_dict.get('position_id'):
operation.position_id = operation_dict['position_id']
operation.kind = operation_dict['kind']
operation.future = operation_dict['future_symbol']
operation.future_price = operation_dict['future_price']
operation.spot = operation_dict['spot_symbol']
operation.spot_price = operation_dict['spot_price']
operation.direct_ratio = operation_dict['direct_ratio']
operation.hours = operation_dict['hours']
operation.hour_ratio = operation_dict['hour_ratio']
operation.days = operation_dict['days']
operation.year_ratio = operation_dict['year_ratio']
operation.contract_size = operation_dict['contract_size']
operation.contract_qty = operation_dict['contract_qty']
operation.buy_per_contract = operation_dict['buy_per_contract']
operation.tick_size = operation_dict['tick_size']
operation.base_asset = operation_dict['base_asset']
operation.state = operation_dict['state']
operation.close_reason = operation_dict.get('close_reason')
return operation
def delete_operation(operation_key, modifier_id):
delete_roleoperations(operation_key=operation_key, modifier_id=modifier_id)
operation = Operation.get_by_key(operation_key)
if operation is not None:
operation.delete(modifier_id)
def fetch_operations(role_id):
query = Operation.all("a")
query.model(RoleOperation.get_modelname(), "b", join="inner", on="a.operation_key = b.operation_key")
query.filter("b.role_id =", role_id)
return query.fetch()
def create(self, obj: Operation) -> int:
return self.connection[DATABASE][COLLECTION_OPERATION].insert_one(
document=obj.convert_to_db_format()).inserted_id
