def members(self):
_model = get_user_model()
if not self.contract_address:
return _model.objects.none()
oracle = OracleHandler()
members = oracle.get_company_members(self.contract_address)
return _model.objects.filter(contract_address__in=members)
def facts(context, member):
date_fields = ['date_from', 'date_up_to', 'date_of_receiving']
args = {}
if member.contract_address:
oracle = OracleHandler()
fact_keys = oracle.facts_keys(member.contract_address)
facts_dict = []
for item in fact_keys:
fact = oracle.fact(member.contract_address, item)
f = json.loads(fact[2])
for date_item in date_fields:
if date_item in f:
f[date_item] = date_converter.string_to_date(
f[date_item], current_format='%Y-%m-%dT%H:%M:%S')
facts_dict.append({
'id':
item,
'from':
fact[0],
'date':
datetime.datetime.fromtimestamp(int(fact[1])),
'fact':
f
})
args['facts'] = facts_dict
args['member'] = member
context.update(args)
return context
def new_member_instance(user_id):
try:
Member.objects.get(pk=user_id)
except Member.DoesNotExist:
logger.error('Member with id {} not found, contract will not be deployed.'.format(user_id))
else:
oracle = OracleHandler()
w3 = utils.get_w3()
contract_file = 'dapp/contracts/Member.sol'
compile_sol = compile_files([contract_file, ],
output_values=("abi", "ast", "bin", "bin-runtime",))
create_abi(compile_sol[contract_file + ':Member']['abi'], 'Member')
obj = w3.eth.contract(
abi=compile_sol[contract_file + ':Member']['abi'],
bytecode=compile_sol[contract_file + ':Member']['bin'],
bytecode_runtime=compile_sol[contract_file + ':Member']['bin-runtime'],
)
args = [settings.VERA_ORACLE_CONTRACT_ADDRESS, ]
logger.info('Try to unlock account: {}.'.format(oracle.unlockAccount()))
try:
txn_hash = obj.deploy(transaction={'from': oracle.account}, args=args)
except Exception as e:
logger.warning('Error while deploy new member contract. User {}: {}'.format(user_id, e))
return False
else:
logger.info('Lock account: {}'.format(oracle.lockAccount()))
save_txn.delay(txn_hash.hex(), 'NewMember', user_id, user_id)
save_txn_to_history.delay(user_id, txn_hash.hex(),
'Creation of a new Member contract')
def candidate_level_up(vacancy_id, candidate_id):
try:
vacancy = Vacancy.objects.get(pk=vacancy_id)
candidate = Member.objects.get(pk=candidate_id)
except Vacancy.DoesNotExist:
logger.warning(
'Vacancy {} not found, candidate will not be leveled up.'.format(
vacancy_id))
return False
except Member.DoesNotExist:
logger.warning(
'Member {} not found and will not be leveled up.'.format(
candidate_id))
return False
else:
oracle = OracleHandler()
try:
txn_hash = oracle.level_up(vacancy.company.contract_address,
vacancy.uuid,
candidate.contract_address)
except Exception as e:
logger.error(
'Error auto level up member {} on vacancy {}: {}'.format(
candidate_id, vacancy_id, e))
return False
else:
save_txn_to_history.delay(
candidate_id, txn_hash.hex(),
'Level up on vacancy {}'.format(vacancy.title))
return True
def post(self, request, *args, **kwargs):
oracle = OracleHandler()
old_status = oracle.member_status(request.user.contract_address,
only_index=True)
new_status = int(request.POST.get('status'))
if new_status != old_status:
change_member_status.delay(request.user.id, new_status)
return super().get(request, *args, **kwargs)
def change_status(vacancy_id, member_id):
try:
sender = Member.objects.get(pk=member_id)
except Member.DoesNotExist:
logger.warning(
'Member {} not found, vacancy status will not be changed'.format(
member_id))
else:
try:
vacancy = Vacancy.objects.get(pk=vacancy_id)
except Vacancy.DoesNotExist:
logger.warning('Vacancy {} does not exist'.format(vacancy_id))
else:
oracle = OracleHandler()
allowed_for_vacancies = 0
company = vacancy.company
for vacancy_item in company.vacancies.all():
allowed_for_vacancies += oracle.vacancy(
company.contract_address,
vacancy_item.uuid)['allowed_amount']
mi = MemberInterface(contract_address=sender.contract_address)
try:
mi.approve_company_tokens(company.contract_address, 0)
txn_hash = mi.approve_company_tokens(company.contract_address,
allowed_for_vacancies)
except Exception as e:
logger.warning('Cannot approve company tokens: {}'.format(e))
else:
save_txn_to_history.delay(
member_id, txn_hash.hex(),
'Approving {} tokens for platform'.format(
allowed_for_vacancies / 10**18))
bch_vacancy = oracle.vacancy(vacancy.company.contract_address,
vacancy.uuid)
if bch_vacancy['enabled']:
method = getattr(mi, 'disable_vac')
else:
method = getattr(mi, 'enable_vac')
try:
txn_hash = method(company.contract_address, vacancy.uuid)
except Exception as e:
logger.warning('Cant change vacancy {} status: {}'.format(
vacancy.id, e))
else:
save_txn_to_history.apply_async(
args=(member_id, txn_hash.hex(),
'Vacancy status changed: {}'.format(
vacancy.title)),
countdown=0.1)
save_txn.apply_async(args=(txn_hash.hex(), 'VacancyChange',
member_id, vacancy.id),
countdown=0.1)
return True
def may_apply_vacancy(member, vacancy):
if not member.contract_address:
return False
oracle = OracleHandler()
current_action_index = oracle.get_member_current_action_index(
vacancy.company.contract_address, vacancy.uuid,
member.contract_address)
already_subscribed = MemberOnVacancy.objects.filter(
member=member, vacancy=vacancy).exists()
return current_action_index == -1 and not already_subscribed
def dispatch(self, request, *args, **kwargs):
self.action = get_object_or_404(Action, pk=kwargs.get('pk', None))
vacancy = self.action.pipeline.vacancy
oracle = OracleHandler()
mci = oracle.get_member_current_action_index(
vacancy.company.contract_address, vacancy.uuid,
request.user.contract_address)
if mci != self.action.index:
raise Http404
return super().dispatch(request, *args, **kwargs)
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context['action'] = self.action_exam.action
context['candidate'] = self.candidate
oracle = OracleHandler()
vacancy = self.action_exam.action.pipeline.vacancy
mci = oracle.get_member_current_action_index(
vacancy.company.contract_address, vacancy.uuid,
self.candidate.contract_address)
mci == self.action_exam.action.index and context.update(
{'not_yet': True})
return context
def deploy_new_company(company_id):
"""
Deploy new company contract
:param company_id: Company off chain id for deploy
:return: True in case of successful, false otherwise
"""
try:
instance = Company.objects.get(pk=company_id)
except Company.DoesNotExist:
logger.error(
'Company with id {} not found, contract will bot be deployed.'.
format(company_id))
return False
else:
oracle = OracleHandler()
w3 = utils.get_w3()
contract_file = 'dapp/contracts/Company.sol'
compile_sol = compile_files([
contract_file,
],
output_values=(
"abi",
"ast",
"bin",
"bin-runtime",
))
create_abi(compile_sol[contract_file + ':Company']['abi'], 'Company')
obj = w3.eth.contract(
abi=compile_sol[contract_file + ':Company']['abi'],
bytecode=compile_sol[contract_file + ':Company']['bin'],
bytecode_runtime=compile_sol[contract_file +
':Company']['bin-runtime'],
)
args = [
settings.VERA_COIN_CONTRACT_ADDRESS,
settings.VERA_ORACLE_CONTRACT_ADDRESS,
]
logger.info('Try to unlock account: {}.'.format(
oracle.unlockAccount()))
try:
txn_hash = obj.deploy(transaction={'from': oracle.account},
args=args)
except Exception as e:
logger.warning(
'Error while deploy new company contract. Company {}: {}'.
format(company_id, e))
else:
logger.info('Lock account: {}'.format(oracle.lockAccount()))
save_txn.delay(txn_hash.hex(), 'NewCompany',
instance.created_by.id, company_id)
save_txn_to_history.delay(instance.created_by.id, txn_hash.hex(),
'Creation of a new Company contract')
def member_status(context, member, for_change=False):
oracle = OracleHandler()
status = oracle.member_status(member.contract_address)
return {
'statuses': [{
'id': i,
'status': v
} for i, v in enumerate(oracle.statuses)],
'status': status,
'for_change': for_change,
'now_pending':
context['txns'].filter(txn_type='ChangeStatus').exists()
}
def candidate_pass_exam(sender, instance, created, **kwargs):
if created or not instance.processed:
pr = ProcessExam()
pr.delay(instance.id)
else:
if instance.processed and instance.points >= instance.exam.passing_grade:
oracle = OracleHandler()
vacancy = instance.exam.action.pipeline.vacancy
cci = oracle.get_member_current_action_index(
vacancy.company.contract_address, vacancy.uuid,
instance.candidate.contract_address)
if cci == instance.exam.action.index:
if not instance.exam.action.chain.approvable:
candidate_level_up.delay(vacancy.id, instance.candidate.id)
def verify(self):
"""
Verify user
:return: txn_hash in hex object
"""
return self.contract_address and OracleHandler().verify_member(
self.contract_address)
def verified(self):
"""
Is member verified in system
:return: bool
"""
return self.contract_address and OracleHandler().member_verified(
self.contract_address)
def is_member_verify_fact(sender_address, member_address, fact_id, txns):
transact_now = False
for item in txns:
if item.obj_id == fact_id:
transact_now = True
return transact_now or OracleHandler().member_fact_confirmations(
sender_address, member_address, fact_id)
def vacancies(self):
"""
Filter for vacancies member subscribed to
:return: Vacancies QuerySet
"""
_model = ContentType.objects.get(model='vacancy')
if not self.contract_address:
return _model.model_class().objects.none()
vac_set = set()
oracle = OracleHandler()
vac_length = oracle.member_vacancies_length(self.contract_address)
for i in range(vac_length):
vac_uuid = oracle.member_vacancy_by_index(self.contract_address, i)
vac_set.add(vac_uuid)
vacancies = _model.model_class().objects.filter(uuid__in=vac_set)
return vacancies
def candidates(self):
"""
Filter for members subscribed to vacancy
:return: Members QuerySet
"""
members = OracleHandler().get_members_on_vacancy(self.company.contract_address, self.uuid)
return get_user_model().objects.filter(contract_address__in=[i['contract_address'] for i in members])
def is_already_verify_fact(self, member_address, fact_id):
"""
Returns true if current user already verify member fact
:param member_address: Member fact verified for
:param fact_id: fact id
:return: bool
"""
return OracleHandler().member_fact_confirmations(
self.contract_address, member_address, fact_id)
def current_action_index(self, vacancy):
"""
Get member current action number for given vacancy
:param vacancy: vacancy to find action number
:return: int (action number) or -1 (not subscribed to vacancy)
"""
return OracleHandler().get_member_current_action_index(
vacancy.company.contract_address, vacancy.uuid,
self.contract_address)
def chain(self):
if not self.published:
return None
if self.pipeline:
if self.pipeline.vacancy:
vacancy = self.pipeline.vacancy
return OracleHandler().get_action(
vacancy.company.contract_address, vacancy.uuid, self.index)
return None
def companies(self):
"""
Filter for companies member is in.
:return: Companies QuerySet
"""
_model = ContentType.objects.get(model='company')
if not self.contract_address:
return _model.model_class().objects.none()
companies = OracleHandler().get_member_companies(self.contract_address)
return _model.model_class().objects.filter(
contract_address__in=companies)
class CompaniesView(ListView):
model = Company
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.request = None
self.oracle = OracleHandler()
@method_decorator(login_required)
def dispatch(self, request, *args, **kwargs):
return super(CompaniesView, self).dispatch(request, *args, **kwargs)
def get_queryset(self):
qs = super().get_queryset()
companies = self.oracle.get_member_companies(
self.request.user.contract_address)
return qs.filter(contract_address__in=companies)
def change_member_status(member_id, status):
try:
member = Member.objects.get(pk=member_id)
except Member.DoesNotExist:
logger.warning('Member {} not found. Status will not be changed.')
return False
else:
mi = MemberInterface(contract_address=member.contract_address)
try:
txn_hash = mi.change_status(status)
except Exception as e:
logger.error('Error while change member {} status: {}'.format(
member_id, e))
return False
else:
save_txn.delay(txn_hash.hex(), 'ChangeStatus', member_id,
member_id)
save_txn_to_history.delay(
member_id, txn_hash.hex(), 'Status changed to {}'.format(
OracleHandler().statuses[int(status)]))
return True
def chain(self):
return OracleHandler().vacancy(self.company.contract_address, self.uuid)
def chain_allowed_amount(self):
return OracleHandler().vacancy(self.company.contract_address, self.uuid)['allowed_amount'] / 10 ** 18
def members_length(address):
oracle = OracleHandler()
return oracle.get_company_members_length(address)
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.request = None
self.oracle = OracleHandler()
class CheckTransaction(Task):
name = 'CheckTransaction'
soft_time_limit = 10 * 60
def __init__(self):
self.w3 = Web3(HTTPProvider(settings.NODE_URL))
self.oracle = OracleHandler()
self.txn_set = None
def run(self, *args, **kwargs):
self.txn_set = Transaction.objects.all()
if len(self.txn_set):
self.process_txns()
return True
def process_txns(self):
for txn in self.txn_set:
txn_info = self.w3.eth.getTransaction(txn.txn_hash)
if txn_info is not None and txn_info['blockNumber'] is not None:
self.handle_txn(txn)
def check_txn_status(self, txn):
receipt = self.w3.eth.getTransactionReceipt(txn.txn_hash)
return receipt['status']
def handle_txn(self, txn):
if txn.txn_type.lower() in DELETE_ONLY_TXN:
self.delete_txn(txn)
return True
if hasattr(self, txn.txn_type.lower()):
method = getattr(self, txn.txn_type.lower())
method(txn)
def get_receipt(self, txn_hash):
return self.w3.eth.getTransactionReceipt(txn_hash)
def delete_txn(self, txn):
try:
txn.delete()
except AssertionError:
pass
def newmember(self, txn):
try:
member = Member.objects.get(id=txn.obj_id)
except Member.DoesNotExist:
txn.delete()
else:
tnx_receipt = self.get_receipt(txn.txn_hash)
member.contract_address = tnx_receipt['contractAddress']
member.save()
self.delete_txn(txn)
print("New Member contract: {} {}".format(member.full_name, tnx_receipt['contractAddress']))
def newcompany(self, txn):
try:
company = Company.objects.get(id=txn.obj_id)
except Company.DoesNotExist:
logger.warning('Company with id {} not found. Member will not be added as company owner'.format(txn.obj_id))
txn.delete()
else:
tnx_receipt = self.get_receipt(txn.txn_hash)
company.contract_address = tnx_receipt['contractAddress']
company.save()
oi = CompanyInterface(contract_address=tnx_receipt['contractAddress'])
txn_hash = oi.new_owner_member(company.created_by.contract_address)
save_txn_to_history.delay(company.created_by.id, txn_hash.hex(),
'Setting your member address as company owner')
self.delete_txn(txn)
print("New Company contract: {} {}".format(company.name, tnx_receipt['contractAddress']))
def newvacancy(self, txn):
try:
vac_o = Vacancy.objects.get(id=txn.obj_id)
except Vacancy.DoesNotExist:
pass
else:
vac_o.published = True
vac_o.save()
self.delete_txn(txn)
print("NewVacancy: " + vac_o.title + ' ' + vac_o.uuid)
def newaction(self, txn):
try:
act_o = Action.objects.get(pk=txn.obj_id)
except Action.DoesNotExist:
pass
else:
act_o.published = True
act_o.save()
self.delete_txn(txn)
print("New action added: {}".format(act_o.id))
def vacancychange(self, txn):
try:
vac_o = Vacancy.objects.get(pk=txn.obj_id)
except Vacancy.DoesNotExist:
pass
else:
vac_o.enabled = self.oracle.vacancy(vac_o.company.contract_address, vac_o.uuid)['enabled']
vac_o.save()
txn.delete()
def actiondeleted(self, txn):
try:
act_o = Action.objects.get(pk=txn.obj_id)
except Action.DoesNotExist:
pass
else:
Action.objects.filter(pipeline=act_o.pipeline, index__gt=act_o.index).update(index=F('index') - 1)
act_o.delete()
self.delete_txn(txn)
def __init__(self):
self.w3 = Web3(HTTPProvider(settings.NODE_URL))
self.oracle = OracleHandler()
self.txn_set = None
def job_status(self):
return OracleHandler().member_status(self.contract_address,
only_index=True)
