def blocks_post_query_process(self, **kwargs):
logger.debug("blocks_post_query_process kwargs: %s" % kwargs)
hash_ids = self.prepare_col_ids(col_ids=kwargs.get('hash_ids'))
if not hash_ids:
logger.warning("hash_ids isn't set")
logger.debug("blocks_post_query_process hash_ids: %s" % hash_ids)
time_ids = self.prepare_col_ids(col_ids=kwargs.get('time_ids'))
if not time_ids:
logger.warning("time_ids isn't set")
logger.debug("blocks_post_query_process time_ids: %s" % time_ids)
data_ids = self.prepare_col_ids(col_ids=kwargs.get('data_ids'))
if not data_ids:
logger.warning("data_ids isn't set")
logger.debug("blocks_post_query_process data_ids: %s" % data_ids)
eco_ids = self.prepare_col_ids(col_ids=kwargs.get('eco_ids'))
if not eco_ids:
logger.warning("eco_ids isn't set")
logger.debug("blocks_post_query_process eco_ids: %s" % eco_ids)
if self.results:
if kwargs.get('debug_mode', False) == True:
results = []
for row in self.results:
#logger.debug("type(row): %s, row: %s" % (type(row), row))
new_cols = set()
p_data = dict()
for col_id, val in row.items():
if col_id in hash_ids:
val = val.hex()
if col_id in time_ids:
val = ts_to_fmt_time(val, utc=False)
if col_id in data_ids:
parse_error = False
try:
logger.error("val: %s" % val)
p = parse_block(val)
except ExtraData as e:
parse_error = True
except UnpackValueError as e:
parse_error = True
except BlockParseError as e:
parse_error = True
except Exception as e:
msg = "Parse Block Error, row: %s; error: %s" \
% (row, e)
logger.error(msg)
raise e
if parse_error:
p_data['key_id'] = ''
else:
if hasattr(p, 'block_data'):
if 'key_id' in p.block_data:
p_data['key_id'] = \
p.block_data['key_id']
if 'ecosystem_id' in p.block_data:
p_data['ecosystem_id'] = \
p.block_data['ecosystem_id']
if hasattr(p, 'ecosystem_id'):
p_data['ecosystem_id'] = \
p.ecosystem_id
if hasattr(p, 'tx_smart') \
and p.tx_smart \
and 'ecosystem_id' in p.tx_smart:
p_data['ecosystem_id'] = \
p.tx_smart['ecosystem_id']
if hasattr(p, 'key_id'):
p_data['key_id'] = \
p['key_id']
new_cols.add((col_id, val))
new_cols2 = set()
for col_id, val in new_cols:
if col_id in eco_ids and 'ecosystem_id' in p_data:
val = p_data['ecosystem_id']
if col_id in data_ids and 'key_id' in p_data:
val = p_data['key_id']
new_cols2.add((col_id, val))
results.append(dict(new_cols2))
self.results = results
else:
raise Exception("Not implemented yet")
def update_from_block_chain(cls, **kwargs):
db_id = kwargs.get('db_id', 1)
block_id = kwargs.get('block_id', 1)
show_raw_data = kwargs.get('show_raw_data', False)
block = BlockChain.query.with_session(
sm.get(db_id)).filter_by(id=block_id).one()
d_names_titles = {
'hash': 'Hash',
'rollbacks_hash': 'Rollbacks Hash',
'data': 'Raw Block Data',
'ecosystem_id': 'Ecosystem ID',
'node_position': 'Node Position',
'time': 'Time'
}
r = BlockRows(db_id=db_id, block_id=block_id)
p_data = None
for col_name, col_title in d_names_titles.items():
val = getattr(block, col_name)
if col_name in ['hash', 'rollbacks_hash']:
r.add(BlockItem(col_name, val.hex(), a="d 0 str", t=col_title))
elif col_name in ['ecosystem_id', 'node_position', 'tx']:
r.add(BlockItem(col_name, val, a="d 0 int", t=col_title))
elif col_name in ['time']:
[
r.add(t) for t in create_time_items(
BlockItem, col_name, val, a_s="d", t=col_title)
]
elif col_name in ['data']:
p_data = val
else:
r.add(BlockItem(col_name, str(val), a="d 1 str", t=col_title))
if p_data:
b_names_titles = {
# block data
'block_id': 'Block ID',
'block_version': 'Block Version',
'block_time': 'Block Time',
'ecosystem_id': 'Ecosystem ID',
'node_position': 'Node Position',
'sign': 'Sign',
# tx
'tx_type': 'Transaction Type ID',
'tx_type_str': 'Transaction Type',
'tx_hash': 'Transaction Hash',
'tx_user_cost': 'Transaction User Cost',
'tx_ecosystem_id': 'Transaction Ecosystem ID',
'tx_contract': 'Transaction Contract',
'tx_data': 'Transaction Data',
'public_key': 'Public Key',
'bin_signatures': 'Binary Signatures',
'token_ecosystem': 'Token Ecosystem',
'signed_by': 'Signed By',
'max_sum': 'Max Sum',
'pay_over': 'Pay Over',
'request_id': 'Request ID',
# tx extra
'tx_size': 'Transaction Size',
'tx_size_offset': 'Transaction Size Offset',
}
try:
p = parse_block(p_data)
except Exception as e:
logger.error("Block Parse Error: %s" % e)
p = Parser()
else:
b_names_titles = {}
# common part for blocks of all kinds tx
for col_name, col_title in b_names_titles.items():
if col_name in [
'block_id', 'block_version', 'ecosystem_id',
'node_position'
]:
r.add(PBDKey(col_name, p, a="b 0 int", t=col_title))
elif col_name in ['sign']:
r.add(PBDKey(col_name, p, a="b 0 str", t=col_title))
elif col_name in ['tx_hash', 'tx_type_str', 'public_key']:
r.add(PAttr(col_name, p, a="b 0 str", t=col_title))
elif col_name in ['block_time']:
[
r.add(t) for t in create_time_items(
PBDKey, col_name, p, a_s="b", t=col_title)
]
elif col_name in ['tx_data']:
r.add(PAttr(col_name, p, a="b 0 str", t=col_title))
#elif col_name in ['tx_ecosystem_id', 'tx_type']:
elif col_name in ['tx_type']:
r.add(PAttr(col_name, p, a="b 0 int", t=col_title))
elif col_name in ['tx_size', 'tx_size_offset']:
r.add(PTxExtraKey(col_name, p, a="b 0 int", t=col_title))
# tx specific part
if hasattr(p, 'tx_type_str'):
logger.debug("block tx type: %s" % p.tx_type_str)
if p.tx_type_str == 'contract':
for col_name, col_title in b_names_titles.items():
if col_name in ['tx_contract']:
r.add(PAttr(col_name, p, a="b 0 str", t=col_title))
elif col_name in [
'bin_signatures',
'token_ecosystem',
'pay_over',
'max_sum',
'request_id',
]:
r.add(
PTxSmartKey(col_name, p, a="b 0 str", t=col_title))
elif col_name in ['signed_by', 'token_ecosystem']:
r.add(
PTxSmartKey(col_name, p, a="b 0 int", t=col_title))
#elif col_name in ['tx_user_cost']:
# r.add(PAttr(col_name, p, a="b 0 dec", t=col_title))
elif col_name in ['tx_ecosystem_id', 'tx_type']:
r.add(PAttr(col_name, p, a="b 0 int", t=col_title))
if col_name in ['ecosystem_id']:
r.add(
PTxSmartKey(col_name, p, a="b 0 int", t=col_title))
elif p.tx_type_str == 'structure':
pass
else:
pass
else:
logger.warning("block tx type str not found")
r.consolidate()
list_of_dicts = r.to_list_of_dicts()
cls.query.filter_by(db_id=db_id, block_id=block_id)
i = insert(cls.__table__)
i = i.values(list_of_dicts)
db.session.execute(i)
return list_of_dicts