def test_unknown_input_data_allowed(self): one = copy.deepcopy(_one_dict) one['foo'] = 'bar' addr = ToUEvent(data=one, raise_on_unknown=False) out = addr.to_dict() self.assertIn('foo', out) self.assertEqual(out['foo'], one['foo'])
def perform_step(self, action): if not request.get_json().get('accept', ''): raise self.ActionError('tou.must-accept') if action.old_format: userid = action.user_id central_user = current_app.central_userdb.get_user_by_id(userid) else: eppn = action.eppn central_user = current_app.central_userdb.get_user_by_eppn(eppn) version = action.params['version'] user = ToUUser.from_user(central_user, current_app.tou_db) current_app.logger.debug('Loaded ToUUser {} from db'.format(user)) current_app.logger.info('ToU version {} accepted by user {}'.format(version, user)) event_id = ObjectId() user.tou.add(ToUEvent( version = version, application = 'eduid_tou_plugin', created_ts = datetime.utcnow(), event_id = event_id )) current_app.tou_db.save(user, check_sync=False) current_app.logger.debug("Asking for sync of {} by Attribute Manager".format(user)) rtask = self._update_attributes.delay('tou', str(user.user_id)) try: result = rtask.get(timeout=10) current_app.logger.debug("Attribute Manager sync result: {!r}".format(result)) current_app.actions_db.remove_action_by_id(action.action_id) current_app.logger.info('Removed completed action {}'.format(action)) return {} except Exception as e: current_app.logger.error("Failed Attribute Manager sync request: " + str(e)) user.tou.remove(event_id) current_app.tou_db.save(user) raise self.ActionError('tou.sync-problem')
def perform_action(self, action, request): _ = self.get_ugettext(request) if not request.POST.get('accept', ''): msg = _(u'You must accept the new terms of use to continue logging in') raise self.ActionError(msg) userid = action.user_id version = action.params['version'] user = request.tou_db.get_user_by_id(userid, raise_on_missing=False) logger.debug('Loaded ToUUser {!s} from db'.format(user)) if not user: user = ToUUser(userid=userid, tou=[]) user.tou.add(ToUEvent( version = version, application = 'eduid_tou_plugin', created_ts = datetime.utcnow(), event_id = ObjectId() )) request.tou_db.save(user) logger.debug("Asking for sync of {!s} by Attribute Manager".format(user)) rtask = update_attributes_keep_result.delay('tou', str(user.user_id)) try: result = rtask.get(timeout=10) logger.debug("Attribute Manager sync result: {!r}".format(result)) except Exception, e: logger.exception("Failed Attribute Manager sync request: " + str(e)) message = _('There were problems with your submission. ' 'You may want to try again later, ' 'or contact the site administrators.') request.session.flash(message) raise HTTPInternalServerError()
def tou_accepted(self, version): event_id = ObjectId() self.user.tou.add( ToUEvent(version=version, application='eduid_tou_plugin', created_ts=datetime.utcnow(), event_id=event_id)) self.app.central_userdb.save(self.user, check_sync=False)
def test_no_actions_touevent_from_dict(self): # Register user acceptance for the ToU version in use tou = ToUEvent.from_dict( dict( version=self.config.tou_version, created_by='unit test', created_ts=datetime.utcnow(), event_id=bson.ObjectId(), )) self._test_no_actions(tou)
def test_created_ts_is_required(self): """ Test bad 'version'. """ with self.assertRaises(eduid_userdb.exceptions.BadEvent): ToUEvent( application='unit test', created_ts=True, version=False, event_id=bson.ObjectId(), )
def test_created_ts_is_required(self): """ Test that ToUEvent require created_ts, although Event does not. """ with self.assertRaises(eduid_userdb.exceptions.BadEvent): ToUEvent( application='unit test', created_ts=None, version='foo', event_id=bson.ObjectId(), )
def tou_accepted(self, user, version, created_ts=None, modified_ts=None): event_id = ObjectId() if created_ts is None: created_ts = datetime.utcnow() user.tou.add( ToUEvent.from_dict( dict( version=version, created_by='eduid_tou_plugin', created_ts=created_ts, modified_ts=modified_ts, event_id=event_id, ))) self.app.central_userdb.save(user, check_sync=False)
def event_from_dict(data, raise_on_unknown=True): """ Create an Event instance (probably really a subclass of Event) from a dict. :param data: Password parameters from database :param raise_on_unknown: Raise EventHasUnknownData if unrecognized data is encountered :type data: dict :type raise_on_unknown: bool :rtype: Event """ if not 'event_type' in data: raise UserDBValueError('No event type specified') if data['event_type'] == 'tou_event': from eduid_userdb.tou import ToUEvent # avoid cyclic dependency by importing this here return ToUEvent(data=data, raise_on_unknown=raise_on_unknown) raise BadEvent('Unknown event_type in data: {!s}'.format( data['event_type']))
def test_add_tou_action_already_accepted_other_version(self): event_id = bson.ObjectId() self.test_user.tou.add( ToUEvent.from_dict( dict( version='mock-version-2', created_by='test_tou_plugin', created_ts=datetime.utcnow(), event_id=event_id, ))) self.actions.remove_action_by_id(self.test_action.action_id) from eduid_idp.tou_action import add_actions mock_ticket = make_login_ticket(req_class_ref=SWAMID_AL2, context=self.idp_app.context, key='mock-session') add_actions(self.idp_app.context, self.test_user, mock_ticket) self.assertEqual( len(self.actions.get_actions(self.test_user.eppn, 'mock-session')), 1)
def record_tou(user, source): """ Record user acceptance of terms of use. :param user: the user that has accepted the ToU :type user: eduid_userdb.signup.SignupUser :param source: An identificator for the proccess during which the user has accepted the ToU (e.g., "signup") :type source: str :return: None """ event_id = ObjectId() created_ts = datetime.datetime.utcnow() tou_version = current_app.config['TOU_VERSION'] current_app.logger.info('Recording ToU acceptance {!r} (version {})' ' for user {} (source: {})'.format( event_id, tou_version, user, source)) user.tou.add( ToUEvent(version=tou_version, application=source, created_ts=created_ts, event_id=event_id))
def test_unknown_input_data(self): one = copy.deepcopy(_one_dict) one['foo'] = 'bar' with self.assertRaises(eduid_userdb.exceptions.EventHasUnknownData): ToUEvent(data=one)
def test_unknown_data_dont_raise(self): one = copy.deepcopy(_one_dict) tou = ToUEvent(data=one, raise_on_unknown=False) data = dict(_id=USERID, tou=[tou], foo='bar') user = ToUUser(data=data, raise_on_unknown=False) self.assertEquals(user.to_dict()['foo'], 'bar')
def test_unknown_data(self): one = copy.deepcopy(_one_dict) tou = ToUEvent(data=one, raise_on_unknown=False) data = dict(_id=USERID, tou=[tou], foo='bar') with self.assertRaises(UserHasUnknownData): user = ToUUser(data=data)
def test_missing_userid(self): one = copy.deepcopy(_one_dict) tou = ToUEvent(data=one, raise_on_unknown=False) with self.assertRaises(UserMissingData): user = ToUUser(tou=[tou])
def test_proper_user(self): one = copy.deepcopy(_one_dict) tou = ToUEvent(data=one, raise_on_unknown=False) user = ToUUser(userid=USERID, tou=[tou]) self.assertEquals(user.tou.to_list_of_dicts()[0]['version'], '1')
def test_no_actions_touevent_init(self): # Register user acceptance for the ToU version in use tou = ToUEvent(version=self.config.tou_version, created_by='unit test', event_id=bson.ObjectId()) self._test_no_actions(tou)