def resolve(self, capture_data: Optional[dict]=None):

        if now() > self.deadline_at:
            raise ManualConfirmationError("Cannot confirm after deadline.")

        self.action_taken_at = now()
        self.state = ManualConfirmationState.resolved

        self.update_capture_data(capture_data)

    def mark_performed(self):
        """
        Incoming: This operation has been registered to database. It may need more confirmations.

        Outgoing: This operation has been broadcasted to network. It's completion and confirmation might require further network confirmations."""
        self.performed_at = now()
        self.state = CryptoOperationState.pending

def main(argv=sys.argv):

    if len(argv) < 3:
        usage(argv)

    config_uri = argv[1]
    request = init_websauna(config_uri)

    User = get_user_class(request.registry)
    dbsession = request.dbsession

    if len(argv) == 4:
        password = argv[3]
    else:
        password = getpass.getpass("Password:")
        password2 = getpass.getpass("Password (again):")

        if password != password2:
            sys.exit("Password did not match")

    with transaction.manager:
        u = User(email=argv[2], username=argv[2])
        u.password = password
        u.registration_source = "command_line"
        u.activated_at = now()
        dbsession.add(u)
        dbsession.flush()

        request.registry.notify(UserCreated(request, u))

        print("Created user #{}: {}, admin: {}".format(u.id, u.email, u.is_admin()))

def create_user(dbsession:Session, registry:Registry, email:str=EMAIL, password:str=PASSWORD, admin:bool=False) -> User:
    """A helper function to create normal and admin users for tests.

    :param admin: If True run :py:class:`websauna.system.user.usermixin.SiteCreator` login and set the user to admin group.
    """

    user = User(email=email)

    if password:
        hasher = registry.getUtility(IPasswordHasher)
        user.hashed_password = hasher.hash_password(password)

    user.user_registration_source = "dummy"
    dbsession.add(user)
    dbsession.flush()
    user.username = user.generate_username()
    user.activated_at = now()

    assert user.can_login()

    # First user, make it admin
    if admin:
        site_creator = get_site_creator(registry)
        site_creator.init_empty_site(dbsession, user)

    return user

def create(request, username, email, password=None, source="command_line", admin=False):
    """Create a new site user from command line.

    :param request:
    :param username:
    :param email:
    :param password:
    :param source:
    :param admin: Set this user to admin. The first user is always implicitly admin.
    :return:
    """
    User = get_user_class(request.registry)
    dbsession = request.dbsession
    u = dbsession.query(User).filter_by(email=email).first()
    if u is not None:
        return u

    u = User(email=email, username=username)

    if password:
        user_registry = get_user_registry(request)
        user_registry.set_password(u, password)

    u.registration_source = source
    u.activated_at = now()
    dbsession.add(u)
    dbsession.flush()

    request.registry.notify(UserCreated(request, u))

    if admin:
        group = dbsession.query(Group).filter_by(name="admin").one_or_none()
        group.users.append(u)

    return u

    def add_object(self, obj):
        """Flush newly created object to persist storage."""

        # Users created through admin are useable right away
        obj.activated_at = now()

        super(UserAdd, self).add_object(obj)

    def reset_password(self, user: UserMixin, password: str):
        """Reset user password and clear all pending activation issues."""

        self.set_password(user, password)

        if not user.activated_at:
            user.activated_at = now()
        self.dbsession.delete(user.activation)

    def initialize_object(self, form, appstruct, obj: User):
        password = appstruct.pop("password")
        form.schema.objectify(appstruct, obj)
        hasher = self.request.registry.getUtility(IPasswordHasher)
        obj.hashed_password = hasher.hash_password(password)

        # Users created through admin are useable right away, so activate the user
        obj.activated_at = now()

 def create_blank_user(self, user_model, dbsession, email) -> IUserModel:
     """Create a new blank user instance as we could not find matching user with the existing details."""
     user = user_model(email=email)
     dbsession.add(user)
     dbsession.flush()
     user.username = user.generate_username()
     user.registration_source = self.provider_id
     user.activated_at = now()
     return user

    def mark_cancelled(self, error: Optional[str]=None):
        """This operation cannot be completed.

        Calling this implies automatic :meth:`reverse` of the operation.
        """
        self.failed_at = now()
        self.state = CryptoOperationState.cancelled
        self.other_data["error"] = error
        self.reverse()

    def update_login_data(self, user):
        request = self.request
        if not user.last_login_at:
            e = events.FirstLogin(request, user)
            request.registry.notify(e)

        # Update user security details
        user.last_login_at = now()
        user.last_login_ip = request.client_addr

    def activate_user(request, dbsession, user):
        """Checks to perform when the user becomes a valid user for the first time.

        If this user has already started sign up process through email we need to cancel that.
        """
        user.activated_at = now()

        # Cancel any pending email activations if the user chooses the option to use social media login
        if user.activation:
            dbsession.delete(user.activation)

    def require_confirmation(cls, user: User, phone_number, timeout=4*3600):
        assert cls.get_pending_confirmation(user) == None
        dbsession = Session.object_session(user)

        confirmation = UserNewPhoneNumberConfirmation()
        confirmation.user = user
        confirmation.deadline_at = now() + datetime.timedelta(seconds=timeout)
        confirmation.require_sms(phone_number)
        dbsession.add(confirmation)
        dbsession.flush()
        return confirmation

def user_auth_details_changes(event:UserAuthSensitiveOperation):
    """Default logic how to invalidate sessions on user auth detail changes.

    If you are using different session management model you can install a custom handle.

    :param event: Incoming event instance
    """

    user = event.user

    # Update the timestamp which session validation checks on every request
    user.last_auth_sensitive_operation_at = now()

def check_wallet_creation(request) -> bool:
    """Check if we have notified this user about wallet creation yet.

    :return: True if this was a wallet creation event
    """
    user = request.user

    if not "wallet_creation_notified_at" in request.user.user_data:
        request.user.user_data["wallet_creation_notified_at"] = now().isoformat()
        request.registry.notify(WalletCreated(request, user))
        return True
    else:
        return False

    def create_email_activation_token(self, user) -> Tuple[str, int]:
        """Create activation token for the user to be used in the email

        :return: Tuple (email activation code, expiration in seconds)
        """
        activation = self.Activation()
        activation_token_expiry_seconds = int(self.registry.settings.get("websauna.activation_token_expiry_seconds", 24*3600))
        activation.expires_at = now() + timedelta(seconds=activation_token_expiry_seconds)

        self.dbsession.add(activation)
        self.dbsession.flush()
        user.activation = activation
        return [activation.code, activation_token_expiry_seconds]

    def send_confirmation(self):

        phone_number = self.get_target_phone_number()
        if not phone_number:
            messages.add(self.request, type="error", msg="You do not have phone number set. Please set a phone number before proceeding.")
            return

        context = {
            "sms_code": self.manual_confirmation.other_data["sms_code"],
        }

        sms_text = self.render_sms(context)

        send_sms(self.request, phone_number, sms_text)
        self.manual_confirmation.other_data["sms_sent_at"] = now()

    def require_confirmation(cls, uco: UserCryptoOperation, timeout=4*3600):
        """Make a crypto operatation to require a SMS confirmation before it can proceed."""
        assert uco.id
        assert uco.crypto_operation.operation_type == CryptoOperationType.withdraw

        dbsession = Session.object_session(uco)
        uco.crypto_operation.state = CryptoOperationState.confirmation_required

        user = uco.user
        uwc = UserWithdrawConfirmation()
        uwc.user = user
        uwc.user_crypto_operation = uco
        uwc.deadline_at = now() + datetime.timedelta(seconds=timeout)
        uwc.require_sms(user.user_data["phone_number"])
        dbsession.add(uwc)
        dbsession.flush()
        return uwc

def test_confirm_user_withdraw_timeout(dbsession, eth_network_id, eth_asset_id, user_id, topped_up_user):
    """User did not reply to withdraw confirmation within the timeout."""
    with transaction.manager:
        uca = dbsession.query(UserCryptoAddress).first()
        asset = dbsession.query(Asset).get(eth_asset_id)
        withdraw_op = uca.withdraw(asset, Decimal(5), eth_address_to_bin(TEST_ADDRESS), "Foobar", 1)
        UserWithdrawConfirmation.require_confirmation(withdraw_op)

    with transaction.manager:
        ManualConfirmation.run_timeout_checks(dbsession, now() + timedelta(hours=12))

    with transaction.manager:
        confirmation = dbsession.query(UserWithdrawConfirmation).first()
        assert confirmation.action_taken_at
        assert confirmation.state == ManualConfirmationState.timed_out
        assert confirmation.user_crypto_operation.crypto_operation.state == CryptoOperationState.cancelled
        assert "error" in confirmation.user_crypto_operation.crypto_operation.other_data

def create_user(dbsession: Session, registry: Registry, email: str=EMAIL, password: str=PASSWORD, admin: bool=False) -> User:
    """A helper function to create normal and admin users for tests.

    Example:

    .. code-block:: python

        import transaction
        from websauna.tests.utils import create_user


        def test_some_stuff(dbsession, registry):

            with transaction.manager:
                u = create_user(registry)
                # Do stuff with new user



    :param email: User's email address. If inot given use unit testing default.

    :param password: Password as plain text. If not given use unit testing default.

    :param admin: If True run :py:class:`websauna.system.user.usermixin.SiteCreator` login and set the user to admin group.
    """

    user = User(email=email)

    if password:
        hasher = registry.getUtility(IPasswordHasher)
        user.hashed_password = hasher.hash_password(password)

    user.user_registration_source = "dummy"
    dbsession.add(user)
    dbsession.flush()
    user.username = user.generate_username()
    user.activated_at = now()

    assert user.can_login()

    # First user, make it admin
    if admin:
        site_creator = get_site_creator(registry)
        site_creator.init_empty_site(dbsession, user)

    return user