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 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 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()
def _load_user(self):
if self._user:
return
self._user = User.get(self.user_id)
