Beispiel #1
0
def new_vacancy(vacancy_id):
    try:
        vacancy = Vacancy.objects.get(pk=vacancy_id)
    except Vacancy.DoesNotExist:
        logger.warning('Vacancy {} not found and will not be published'.format(
            vacancy_id))
    else:
        mi = MemberInterface(
            contract_address=vacancy.created_by.contract_address)
        try:
            txn_hash = mi.new_vacancy(vacancy.company.contract_address,
                                      vacancy.uuid,
                                      int(vacancy.allowed_amount) * 10**18)
        except Exception as e:
            logger.error(
                'Error deploy new vacancy: {}, vacancy deleted'.format(e))
            vacancy.delete()
            return False
        else:
            save_txn_to_history.apply_async(
                args=(vacancy.created_by.id, txn_hash.hex(),
                      'Creation of a new vacancy: {}'.format(vacancy.title)),
                countdown=0.2)
            save_txn.apply_async(args=(txn_hash.hex(), 'NewVacancy',
                                       vacancy.created_by.id, vacancy.id),
                                 countdown=0.2)
    return True
Beispiel #2
0
def new_subscribe(member_id, vacancy_id):
    try:
        vacancy = Vacancy.objects.get(pk=vacancy_id)
    except Vacancy.DoesNotExist:
        logger.warning(
            'Vacancy {} not found, user {} will not be subscribed'.format(
                vacancy_id, member_id))
        return False
    else:
        try:
            member = Member.objects.get(pk=member_id)
        except Member.DoesNotExist:
            logger.warning(
                'Member {} not found, and will not be subscribed'.format(
                    member_id))
            return False
        else:
            mi = MemberInterface(contract_address=member.contract_address)
            try:
                txn_hash = mi.subscribe(vacancy.company.contract_address,
                                        vacancy.uuid)
            except Exception as e:
                logger.error(
                    'Error while subscribe: member {}, vacancy {}, e: {}'.
                    format(member_id, vacancy_id, e))
            else:
                save_txn_to_history.apply_async(
                    args=(member_id, txn_hash.hex(),
                          'Subscribe to vacancy: {}'.format(vacancy.title)),
                    countdown=0.1)
                save_txn.apply_async(args=(txn_hash.hex(), 'MemberSubscribe',
                                           member_id, vacancy.id),
                                     countdown=0.1)
                return True
Beispiel #3
0
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
Beispiel #4
0
def changed_action(action):
    try:
        sender = Member.objects.get(pk=action['sender_id'])
    except Member.DoesNotExist:
        logger.warning(
            'Sender {} not found, action will not be changed'.format(
                action['sender_id']))
        return False
    else:
        try:
            vacancy = Vacancy.objects.get(pk=action['vacancy_id'])
        except Vacancy.DoesNotExist:
            logger.warning(
                'Vacancy {} not found, action will not be changed'.format(
                    action['vacancy_id']))
            return False
        else:
            mi = MemberInterface(contract_address=sender.contract_address)
            try:
                txn_hash = mi.change_action(
                    company_address=vacancy.company.contract_address,
                    vac_uuid=vacancy.uuid,
                    index=action['index'],
                    title=action['title'],
                    fee=action['fee'],
                    appr=action['approvable'])
            except Exception as e:
                logger.error('Error while change pipline action {}: {}'.format(
                    action['index'], e))
                return False
            else:
                save_txn_to_history.apply_async(
                    args=(action['sender_id'], txn_hash.hex(),
                          'Changed action {} on vacancy: {}'.format(
                              action['index'], vacancy.title)),
                    countdown=0.1)
                save_txn.apply_async(args=(txn_hash.hex(), 'ActionChanged',
                                           action['sender_id'], action['id']),
                                     countdown=0.1)
                return True
Beispiel #5
0
def change_vacancy_allowed_amount(vacancy_id, sender_id):
    try:
        sender = Member.objects.get(pk=sender_id)
    except Member.DoesNotExist:
        logger.warning(
            'Member {} not found, vacancy allowed amount will not be changed'.
            format(sender_id))
        return False
    else:
        try:
            vacancy = Vacancy.objects.get(pk=vacancy_id)
        except Vacancy.DoesNotExist:
            logger.warning(
                'Vacancy {} not found, allowed will not be changed'.format(
                    vacancy_id))
            return False
        else:
            mi = MemberInterface(contract_address=sender.contract_address)

            if vacancy.chain['allowed_amount'] != int(
                    vacancy.allowed_amount) * 10**18:
                try:
                    txn_hash = mi.change_vacancy_allowance_amount(
                        vacancy.company.contract_address, vacancy.uuid,
                        int(vacancy.allowed_amount) * 10**18)
                except Exception as e:
                    logger.error(
                        'Error changing vacancy allowed amount: {}'.format(e))
                    return False
                else:
                    save_txn_to_history.apply_async(
                        args=(sender_id, txn_hash.hex(),
                              'Vacancy allowed amount changed: {}'.format(
                                  vacancy.title)),
                        countdown=0.1)
                    save_txn.apply_async(args=(txn_hash.hex(),
                                               'VacancyAllowedChanged',
                                               sender_id, vacancy.id),
                                         countdown=0.1)
                    return True
Beispiel #6
0
def new_action(action):
    mi = MemberInterface(contract_address=action['member_address'])
    try:
        txn_hash = mi.new_action(company_address=action['company_address'],
                                 vac_uuid=action['vacancy_uuid'],
                                 title=action['title'],
                                 fee=action['fee'],
                                 appr=action['approvable'])
    except Exception as e:
        logger.warning('Cant create new action, {} {}'.format(action['id'], e))
        return False
    else:
        vacancy = Vacancy.objects.get(uuid=action['vacancy_uuid'])
        save_txn_to_history.apply_async(
            args=(action['created_by'], txn_hash.hex(),
                  'Creation of a new action for vacancy: {}'.format(
                      vacancy.title)),
            countdown=0.1)
        save_txn.apply_async(args=(txn_hash.hex(), 'NewAction',
                                   action['created_by'], action['id'],
                                   vacancy.id),
                             countdown=0.1)
        return True
Beispiel #7
0
def delete_action(action):
    try:
        sender = Member.objects.get(pk=action['sender_id'])
    except Member.DoesNotExist:
        logger.warning(
            'Sender {} not found. Action will not be deleted'.format(
                action['sender_id']))
        return False
    else:
        try:
            vacancy = Vacancy.objects.get(id=action['vacancy_id'])
        except Vacancy.DoesNotExist:
            logger.warning(
                'Action vacancy {} not found, action will not be deleted'.
                format(action['vacancy_id']))
            return False
        else:
            mi = MemberInterface(contract_address=sender.contract_address)
            try:
                txn_hash = mi.delete_action(vacancy.company.contract_address,
                                            vacancy.uuid, action['index'])
            except Exception as e:
                logger.error('Error while deleting action {}: {}'.format(
                    action['id'], e))
                return False
            else:
                save_txn_to_history.apply_async(
                    args=(action['sender_id'], txn_hash.hex(),
                          'Deleted action {} on vacancy: {}'.format(
                              action['index'], vacancy.title)),
                    countdown=0.1)
                save_txn.apply_async(args=(txn_hash.hex(), 'ActionDeleted',
                                           action['sender_id'], action['id'],
                                           vacancy.id),
                                     countdown=0.1)
                return True