Exemplo n.º 1
0
def validate_role_task(header, confirm, txn_signer_rel_address, state):

    proposal_address = addresser.make_proposal_address(
        object_id=confirm.role_id, related_id=confirm.task_id)

    state_entries = get_state(state,
                              [txn_signer_rel_address, proposal_address])

    if not proposal_exists_and_open(state_entries, proposal_address,
                                    confirm.proposal_id):
        raise InvalidTransaction("The proposal {} does not exist or "
                                 "is not open".format(confirm.proposal_id))
    try:
        entry = get_state_entry(state_entries, txn_signer_rel_address)
        task_owners_container = return_task_rel_container(entry)
    except KeyError:
        raise InvalidTransaction(
            "Signer {} is not a task owner for task {}".format(
                header.signer_public_key, confirm.task_id))

    if not is_in_task_rel_container(task_owners_container, confirm.task_id,
                                    header.signer_public_key):
        raise InvalidTransaction(
            "Signer {} is not a task owner for task {} no bytes in "
            "state".format(header.signer_public_key, confirm.task_id))
    return state_entries
Exemplo n.º 2
0
def apply_user_reject(header, payload, state):
    reject_payload = user_transaction_pb2.RejectUpdateUserManager()
    reject_payload.ParseFromString(payload.content)

    proposal_address = addresser.make_proposal_address(
        object_id=reject_payload.user_id, related_id=reject_payload.manager_id)

    state_entries = get_state(state, [proposal_address])

    if not proposal_exists_and_open(state_entries=state_entries,
                                    proposal_address=proposal_address,
                                    proposal_id=reject_payload.proposal_id):
        raise InvalidTransaction("Proposal {} is not open or does not "
                                 "exist".format(reject_payload.proposal_id))

    entry = get_state_entry(state_entries, proposal_address)

    proposal_container = return_prop_container(entry)

    if not reject_payload.manager_id == header.signer_pubkey:
        raise InvalidTransaction("Proposal expected closer to be {} while txn "
                                 "signer was {}".format(
                                     reject_payload.manager_id,
                                     header.signer_pubkey))

    proposal = get_prop_from_container(proposal_container,
                                       reject_payload.proposal_id)

    handle_reject_state_set(container=proposal_container,
                            proposal=proposal,
                            closer=header.signer_pubkey,
                            reason=reject_payload.reason,
                            address=proposal_address,
                            state=state)
Exemplo n.º 3
0
def validate_task_admin_or_owner(header, confirm, txn_signer_rel_address,
                                 task_rel_address, state, is_remove):
    """Validate a [ Confirm | Reject }_____Task[ Admin | Owner } transaction.

    Args:
        header (TransactionHeader): The transaction header protobuf class.:
        confirm: ConfirmAddTaskAdmin, RejectAddTaskAdmin, ...
        txn_signer_rel_address (str): The transaction signer address.
        task_rel_address (str): The task relationship address.
        state (Context): The class responsible for gets and sets of state.
        is_remove (boolean): Determines if task owner is being added or removed.

    Returns:
        (dict of addresses)

    Raises:
        InvalidTransaction
            - The transaction is invalid.
    """

    proposal_address = addresser.make_proposal_address(
        object_id=confirm.task_id, related_id=confirm.user_id)

    if not is_remove:
        state_entries = get_state(state,
                                  [txn_signer_rel_address, proposal_address])
    else:
        state_entries = get_state(
            state,
            [txn_signer_rel_address, task_rel_address, proposal_address])

    if not proposal_exists_and_open(state_entries, proposal_address,
                                    confirm.proposal_id):
        raise InvalidTransaction("The proposal {} does not exist or "
                                 "is not open".format(confirm.proposal_id))
    try:
        entry = get_state_entry(state_entries, txn_signer_rel_address)
        task_rel_container = return_task_rel_container(entry)
    except KeyError:
        raise InvalidTransaction(
            "Signer {} does not have the Task permissions "
            "to close the proposal".format(header.signer_public_key))
    if not is_in_task_rel_container(task_rel_container,
                                    task_id=confirm.task_id,
                                    identifier=header.signer_public_key):
        raise InvalidTransaction("Signer {} does not have the Task "
                                 "permissions to close the "
                                 "proposal".format(header.signer_public_key))

    return state_entries
Exemplo n.º 4
0
def validate_role_admin_or_owner(header,
                                 confirm,
                                 txn_signer_rel_address,
                                 state):
    """Validate a [ Confirm | Reject }_____Role[ Admin | Owner } transaction.

    Args:
        header (TransactionHeader): The transaction header protobuf class.:
        confirm: ConfirmAddRoleAdmin, RejectAddRoleAdmin, ...
        state (Context): The class responsible for gets and sets of state.

    Returns:
        (dict of addresses)
    """

    proposal_address = addresser.make_proposal_address(
        object_id=confirm.role_id,
        related_id=confirm.user_id)

    state_entries = get_state(
        state,
        [txn_signer_rel_address, proposal_address])

    if not proposal_exists_and_open(
            state_entries,
            proposal_address,
            confirm.proposal_id):
        raise InvalidTransaction("The proposal {} does not exist or "
                                 "is not open".format(confirm.proposal_id))
    try:
        entry = get_state_entry(state_entries, txn_signer_rel_address)
        role_rel_container = return_role_rel_container(entry)
    except KeyError:
        raise InvalidTransaction(
            "Signer {} does not have the Role permissions "
            "to close the proposal".format(header.signer_public_key))
    if not is_in_role_rel_container(
            role_rel_container,
            role_id=confirm.role_id,
            identifier=header.signer_public_key):
        raise InvalidTransaction("Signer {} does not have the Role "
                                 "permissions to close the "
                                 "proposal".format(header.signer_public_key))

    return state_entries
Exemplo n.º 5
0
def apply_user_confirm(header, payload, state):
    confirm_payload = user_transaction_pb2.ConfirmUpdateUserManager()
    confirm_payload.ParseFromString(payload.content)

    proposal_address = addresser.make_proposal_address(
        object_id=confirm_payload.user_id,
        related_id=confirm_payload.manager_id)

    proposal_entries = get_state(state, [proposal_address])

    if not proposal_exists_and_open(
            state_entries=proposal_entries,
            proposal_address=proposal_address,
            proposal_id=confirm_payload.proposal_id):
        raise InvalidTransaction(
            "Proposal id {} does not exist or is not open.".format(
                confirm_payload.proposal_id))

    entry = get_state_entry(proposal_entries, proposal_address)
    proposal_container = return_prop_container(entry)
    proposal = get_prop_from_container(
        container=proposal_container,
        proposal_id=confirm_payload.proposal_id)

    if not proposal.target_id == header.signer_public_key:
        raise InvalidTransaction(
            "Confirm update manager txn signed by {} while "
            "proposal expecting {}".format(
                header.signer_public_key,
                proposal.target_id))

    handle_confirm_state_set(
        container=proposal_container,
        proposal=proposal,
        closer=header.signer_public_key,
        reason=confirm_payload.reason,
        address=proposal_address,
        user_id=confirm_payload.user_id,
        new_manager_id=confirm_payload.manager_id,
        state=state)