def collection_post(self): """ Api for user authentication. Store generated tokens in a cache entry related to user_id and return a structure with this tokens for client usage. """ params = self.request.json_body user = User.authenticate(params['username'], params['password']) if not user: self._raise() log.info('Authenticate user {username}'.format(username=user.name)) access_token = create_token() refresh_token = create_token(80) ttl = self.request.cache.client.ttl expires_at = (datetime.datetime.utcnow() + datetime.timedelta(seconds=ttl)) tokens = {'access_token': access_token, 'refresh_token': refresh_token, 'expires_in': ttl, # TODO : remove this value 'expires_at': expires_at.isoformat()} self.request.cache.set(user.user_id, tokens) return {'user_id': user.user_id, 'username': user.name, 'tokens': tokens}
def collection_post(self): """ Api for user authentication. Store generated tokens in a cache entry related to user_id and return a structure with this tokens for client usage. """ params = self.request.params user = User.authenticate(params['username'], params['password']) if not user: self._raise() log.info('Authenticate user {username}'.format(username=user.name)) access_token = create_token() refresh_token = create_token(80) ttl = self.request.cache.client.ttl expires_at = (datetime.datetime.utcnow() + datetime.timedelta(seconds=ttl)) tokens = {'access_token': access_token, 'refresh_token': refresh_token, 'expires_in': ttl, # TODO : remove this value 'expires_at': expires_at.utcformat()} self.request.cache.set(user.user_id, tokens) return {'user_id': user.user_id, 'username': user.name, 'tokens': tokens}
def get(self): """Get information about logged user.""" user_id = self.request.validated['user_id'] if user_id != self.request.authenticated_userid.user_id: raise AuthenticationError() user = User.get(user_id) return ReturnUser.build(user).serialize()
def no_such_user(request): """Validator that an user does not exist.""" try: user = User.by_name(request.validated['username']) if user: raise AuthenticationError('User already exist') except NotFound: pass
def _validate_authentication_credentials(params): """ Check the user credentials and returns the associated user object. @param dict params the sanitized parameters for authentication @return user """ try: user = User.authenticate(params['username'], params['password']) user = ReturnUser.build(user).serialize() except ValidationError, e: raise ValidationError(e.messages)
def collection_post(self): """Create a new user.""" param = NewUser({'name': self.request.validated['username'], 'password': self.request.validated['password']}) try: user = User.create(param) except Exception as exc: raise AuthenticationError(exc.message) log.info('Created user {} with name {}'. format(user.user_id, user.name)) user_url = self.request.route_path('User', user_id=user.user_id) self.request.response.location = user_url.encode('utf-8') return {'location': user_url}
def create_user(**kwargs): from caliopen.base.user.core import User from caliopen.base.user.parameters import NewUser from caliopen.base.user.parameters import NewContact param = NewUser() param.name = kwargs['email'] param.password = kwargs['password'] contact = NewContact() contact.given_name = kwargs.get('given_name') contact.family_name = kwargs.get('family_name') param.contact = contact user = User.create(param) user.save() log.info('User %s (%s) created' % (user.user_id, user.user_name))
def validate_signup_params(username, email, password, password_repeat, given_name='', family_name=''): """Retrieve matching username and password. If no match is found, then return errors. @param string username @param string password @return Authentication """ creation = namedtuple('Creation', ['success', 'user', 'errors']) errors = { 'globals': [], 'given_name': [], 'family_name': [], 'username': [], 'password': [], 'password_repeat': [] } # validate user input has_error = False; if not password == password_repeat: errors['password_repeat'].append(messages['password_missmatch']) has_error = True # if an error occurred, then return the failed attempt if has_error: return creation(success=False, errors=errors, user=None) # create the user from parameters try: param = NewUser() param.name = email param.password = password contact = NewContact() contact.given_name = given_name contact.family_name = family_name param.contact = contact user = User.create(param) user.save() user = user.to_api() return creation(success=True, user=user, errors=None) except (KeyError, Exception), exc: # prepare errors errors['globals'].append(str(exc)) return creation(success=False, errors=errors, user=None)
def process(self, user_id, message_id): """Process a message for an user.""" user = User.get(user_id) msg = RawMessage.get(user, message_id) # XXX should use raw message type to use correct message formatter mail = MailMessage(msg.data) message = mail.to_parameter() message.recipients = self._get_recipients(user, mail) # compute tags message.tags = self._get_tags(user, mail) # lookup by external references lookup_sequence = mail.lookup_sequence() lookup = self.lookup(user, lookup_sequence) # Create or update existing thread thread if lookup: log.debug('Found thread %r' % lookup.thread_id) thread = Thread.get(user, lookup.thread_id) thread.update_from_message(message) else: log.debug('Creating new thread') thread = Thread.create_from_message(user, message) msg = Message.create(user, message, thread, lookup) # XXX Init lookup if not lookup: self.__init_lookups(lookup_sequence, msg) else: if msg.external_message_id: params = { 'user_id': msg.user_id, 'external_message_id': msg.external_message_id, 'thread_id': msg.thread_id, 'message_id': msg.message_id, } new_lookup = ThreadMessageLookup.create(**params) log.debug('Created message lookup %r' % new_lookup) return msg
def get(self): user_id = self.request.matchdict.get('user_id') if user_id != self.request.authenticated_userid.user_id: raise HTTPUnauthorized() user = User.get(user_id) return ReturnUser.build(user).serialize()
def _load_user(self): if self._user: return self._user = User.get(self.user_id)
def import_email(email, import_path, format, **kwargs): from caliopen.base.user.core import User from caliopen.base.user.core import Contact, ContactLookup from caliopen.base.message.format.mail import MailMessage from caliopen.base.user.parameters import NewContact, NewEmail from caliopen.smtp.agent import DeliveryAgent AVATAR_DIR = "../../../caliopen.ng/src/assets/images/avatars" if format == "maildir": emails = Maildir(import_path, factory=message_from_file) mode = "maildir" else: if os.path.isdir(import_path): mode = "mbox_directory" emails = {} files = [f for f in listdir(import_path) if os.path.isfile(os.path.join(import_path, f))] for f in files: with open("%s/%s" % (import_path, f)) as fh: emails[f] = message_from_file(fh) else: mode = "mbox" emails = mbox(import_path) user = User.by_name(email) agent = DeliveryAgent() mailfrom = "" rcpts = [email] log.info("Processing mode %s" % mode) msgs = [] for key, mail in emails.iteritems(): # Create contact for user log.info("Processing mail %s" % key) msgs.append(MailMessage(mail)) msgs = sorted(msgs, key=lambda msg: msg.date) for msg in msgs: for type, addresses in msg.recipients.iteritems(): if not addresses: continue for alias, _address in addresses: try: ContactLookup.get(user, alias) except NotFound: log.info("Creating contact %s" % alias) infos = {"mail": alias} name, domain = alias.split("@") if os.path.isfile("%s/%s.png" % (AVATAR_DIR, name)): infos.update({"avatar": "%s.png" % name}) contact = NewContact() contact.family_name = name email = NewEmail() email.address = alias Contact.create(user, contact, emails=[email]) res = agent.process(mailfrom, rcpts, msg.mail.as_string()) log.info("Process result %r" % res)
def resolve_users(self, rpcts): users = [] for rcpt in rpcts: user = User.by_name(rcpt) users.append(user) return users
def get(self): """Get information about logged user.""" user_id = self.request.authenticated_userid.user_id user = User.get(user_id) return ReturnUser.build(user).serialize()