def post(self):
"""
Creating new user
"""
data = request.json
# check existence of user by email
if User.is_exists_by_email(data['email']):
raise ErrorResource(409, message="Email is already in use.")
# create user
user = User(**data)
db.session.add(user)
db.session.commit()
# scheduling registration email
MailTask.send(to=user.email,
template="mail/welcome",
params={
'first_name': user.firstName,
'last_name': user.lastName,
'host_name': app.config['SERVER_NAME']
})
return response(user.to_dict(), status_code=201)
def login(self):
"""
"""
# TODO(vojta) save success login, improve token stuff
data = request.json
# find user by email and if is not existing or passwd
# is incorect will raise error 403
user = User.query.filter_by(email=data['email']).first()
if user is None or user.compare_password(data['password']) is False:
raise ErrorResource(403, message="Invalid password or email.")
# non active users are not allowed
if user.isActive is False:
raise ErrorResource(403, message="Account is not active.")
# create user token for user
token = None
agent = request.headers.get('User-Agent')
if agent is not None:
token = UserToken.query \
.filter_by(userId=user.id) \
.filter_by(agent=agent) \
.first()
if token is None:
token = UserToken(userId=user.id, agent=agent)
db.session.add(token)
db.session.commit()
# create payload response
return response({
'uuid': user.uuid,
'token': token.token
},
status_code=200)
def on_validation_error(error):
payload = None
message, errors = get_validation_data(error)
if errors is not None:
payload = {'errors': errors}
return response(payload, status_code=400, message=message)
def on_validation_error(error):
payload = None
message, errors = get_validation_data(error)
if errors is not None:
payload = { 'errors': errors }
return response(payload, status_code=400, message=message)
def index(self, **kwargs):
"""
Getting list of all users, only with admin privileges
"""
users = User.query.order_by(User.lastName.asc()).all()
return response([user.to_dict() for user in users])
def post(self):
"""
Creating new user
"""
data = request.json
# check existence of user by email
if User.is_exists_by_email(data['email']):
raise ErrorResource(409, message="Email is already in use.")
# create user
user = User(**data)
db.session.add(user)
db.session.commit()
# scheduling registration email
MailTask.send(to=user.email,
template="mail/welcome",
params={
'first_name': user.firstName,
'last_name': user.lastName,
'host_name': app.config['SERVER_NAME']
})
return response(user.to_dict(), status_code=201)
def index(self, **kwargs):
"""
Getting list of all users, only with admin privileges
"""
users = User.query.order_by(User.lastName.asc()).all()
return response([user.to_dict() for user in users])
def index(self, **kwargs):
"""
Getting list of user's templates
"""
user = kwargs.get('user')
templates = user.templates.order_by(Template.label.asc())
return response([template.to_dict() for template in templates])
def on_sql_alchemy_error(error):
""" Error handler for sqlalchemy IntegrityError exception """
# do rollback
db.session.rollback()
# log it
current_app.logger.error(traceback.format_exc())
return response(None, status_code=500)
def delete(self, user, **kwargs):
"""
Delete user
"""
db.session.delete(user)
db.session.commit()
return response(user.to_dict())
def index(self, **kwargs):
"""
Getting list of user's templates
"""
user = kwargs.get('user')
templates = user.templates.order_by(Template.label.asc())
return response([template.to_dict() for template in templates])
def on_sql_alchemy_error(error):
""" Error handler for sqlalchemy IntegrityError exception """
# do rollback
db.session.rollback()
# log it
current_app.logger.error(traceback.format_exc())
return response(None, status_code=500)
def index(self, **kwargs):
"""
Returning list of applications for specific user
"""
user = kwargs.get('user')
applications = user.applications.order_by(Application.label.asc()).all()
return response([app.to_dict() for app in applications])
def delete(self, user, **kwargs):
"""
Delete user
"""
db.session.delete(user)
db.session.commit()
return response(user.to_dict())
def put(self, **kwargs):
"""
Updateing existing template
"""
template = kwargs.get('template')
template.update(request.json)
db.session.commit()
return response(template.to_dict())
def regenerate(self, **kwargs):
"""
Regenerate API token
"""
application = kwargs.get('application')
application.regenerate_token()
db.session.commit()
return response(application.to_dict(['uuid', 'token']))
def put(self, **kwargs):
"""
Updateing existing template
"""
template = kwargs.get('template')
template.update(request.json)
db.session.commit()
return response(template.to_dict())
def index(self, **kwargs):
"""
Getting list of outbox messages
"""
user = kwargs.get('user')
app = kwargs.get('application')
groups = Outbox.get_all(user_id=user.id,
application_id=app.id if app else None)
return response(groups)
def delete(self, **kwargs):
"""
Delete template
"""
# delete template
template = kwargs.get('template')
db.session.delete(template)
db.session.commit()
return response(template.to_dict())
def index(self, **kwargs):
"""
Returning list of sent items
"""
user = kwargs.get('user')
app = kwargs.get('application')
messages = SentItem.get(user_id=user.id,
application_id=app.id if app else None)
return response(messages)
def index(self, **kwargs):
"""
Returning list of sent items
"""
user = kwargs.get('user')
app = kwargs.get('application')
messages = SentItem.get(user_id=user.id,
application_id=app.id if app else None)
return response(messages)
def delete(self, **kwargs):
"""
Delete template
"""
# delete template
template = kwargs.get('template')
db.session.delete(template)
db.session.commit()
return response(template.to_dict())
def index(self, **kwargs):
"""
Getting list of outbox messages
"""
user = kwargs.get('user')
app = kwargs.get('application')
groups = Outbox.get_all(user_id=user.id,
application_id=app.id if app else None)
return response(groups)
def delete(self, **kwargs):
"""
Delete user contact
"""
contact = kwargs.get('contact')
# delete template
db.session.delete(contact)
db.session.commit()
return response(contact.to_dict())
def delete(self, **kwargs):
"""
Delete user contact
"""
tag = kwargs.get('tag')
# delete template
db.session.delete(tag)
db.session.commit()
return response(tag.to_dict())
def delete(self, **kwargs):
"""
Delete user application
"""
application = kwargs.get('application')
# delete template
db.session.delete(application)
db.session.commit()
return response(application.to_dict())
def put(self, **kwargs):
"""
Updating user contact
"""
contact = kwargs.get('contact')
# save to db
contact.update(request.json)
db.session.commit()
return response(contact.to_dict())
def delete(self, **kwargs):
"""
Delete user contact
"""
contact = kwargs.get('contact')
# delete template
db.session.delete(contact)
db.session.commit()
return response(contact.to_dict())
def put(self, **kwargs):
"""
Updating user contact
"""
contact = kwargs.get('contact')
# save to db
contact.update(request.json)
db.session.commit()
return response(contact.to_dict())
def post(self, **kwargs):
"""
Creating new user template
"""
user = kwargs.get('user')
# create and save template
template = Template(**request.json)
template.userId = user.id
db.session.add(template)
db.session.commit()
return response(template.to_dict(), status_code=201)
def post(self, **kwargs):
"""
Creating new user template
"""
user = kwargs.get('user')
# create and save template
template = Template(**request.json)
template.userId = user.id
db.session.add(template)
db.session.commit()
return response(template.to_dict(), status_code=201)
class TagsResource(FlaskView):
""" Tags endpoints """
route_base = '/users/<uuid:user_uuid>/tags/'
@decorators.auth()
def index(self, **kwargs):
"""
Returning list of tags for specific user
"""
user = kwargs.get('user')
# search or not
search = request.args.get('search')
tags = user.tags
if search is not None:
like = "%{0}%".format(search)
tags = tags.filter(Tag._label.like(like))
tags = tags.order_by(Tag._label.asc())
return response([tag.to_dict() for tag in tags.all()])
@route('/<uuid:tag_uuid>/')
@decorators.auth()
def get(self, **kwargs):
"""
Get user tag
"""
tag = kwargs.get('tag')
return response(tag.to_dict())
@decorators.auth()
@decorators.jsonschema_validate(post.schema)
def post(self, **kwargs):
"""
Creating user tag
"""
try:
# save tag
user = kwargs.get('user')
tag = Tag(userId=user.id, **request.json)
db.session.add(tag)
db.session.commit()
except IntegrityError, e:
db.session.rollback()
raise ErrorResource(409, message="Tag is already exists.")
return response(tag.to_dict(), status_code=201)
def get(self, group, **kwargs):
"""
Getting outbox group
"""
user = kwargs.get('user')
app = kwargs.get('application')
group = Outbox.get(group=group,
user_id=user.id,
application_id=app.id if app else None)
if group is None:
raise ErrorResource(message='Outbox group not found.',
status_code=404)
return response(group)
def delete(self, sentitem, **kwargs):
"""
Delete sent message
"""
user = kwargs.get('user')
app = kwargs.get('application')
SentItem.remove(uuid=sentitem,
user_id=user.id,
application_id=app.id if app else None)
db.session.commit()
return response({'uuid': sentitem})
def get(self, group, **kwargs):
"""
Getting outbox group
"""
user = kwargs.get('user')
app = kwargs.get('application')
group = Outbox.get(group=group,
user_id=user.id,
application_id=app.id if app else None)
if group is None:
raise ErrorResource(message='Outbox group not found.',
status_code=404)
return response(group)
def post(self, **kwargs):
"""
Creating user contact
"""
user = kwargs.get('user')
# create and save contact
# TODO(vojta) handling unique contacts ?
contact = Contact(userId=user.id, **request.json)
contact.tags = request.json.get('tags')
db.session.add(contact)
db.session.commit()
return response(contact.to_dict(), status_code=201)
def post(self, **kwargs):
"""
Creating user contact
"""
user = kwargs.get('user')
# create and save contact
# TODO(vojta) handling unique contacts ?
contact = Contact(userId=user.id, **request.json)
contact.tags = request.json.get('tags')
db.session.add(contact)
db.session.commit()
return response(contact.to_dict(), status_code=201)
def delete(self, group, **kwargs):
"""
Delete outbox message
"""
app = kwargs.get('application')
app_id = app.id if app else None
Outbox.query \
.filter(Outbox.group == group) \
.filter(Outbox.applicationId == app_id) \
.delete()
db.session.commit()
return response({'id': group})
def delete(self, **kwargs):
"""
Delete user contact
"""
user = kwargs.get('user', request.user)
inbox = kwargs.get('inbox')
# admin check, to be sure that non admin users can delete inboxes
if inbox.userId != user.id and not user.is_admin():
raise ErrorResource(message='Not have permissions.', status_code=403)
db.session.delete(inbox)
db.session.commit()
return response(inbox.to_dict())
def messages(self, **kwargs):
"""
GET stats count for inbox, sent and outbox
"""
user = kwargs.get('user')
app = kwargs.get('application')
payload = {}
elements = {'sent': SentItem, 'inbox': Inbox, 'outbox': Outbox}
for key, model in elements.iteritems():
query = model.query.filter_by(userId=user.id)
if app:
query = query.filter_by(applicationId=app.id)
payload[key] = query.count()
return response(payload)
def delete(self, sentitem, **kwargs):
"""
Delete sent message
"""
user = kwargs.get('user')
app = kwargs.get('application')
SentItem.remove(uuid=sentitem,
user_id=user.id,
application_id=app.id if app else None)
db.session.commit()
return response({
'uuid': sentitem
})
def delete(self, group, **kwargs):
"""
Delete outbox message
"""
app = kwargs.get('application')
app_id = app.id if app else None
Outbox.query \
.filter(Outbox.group == group) \
.filter(Outbox.applicationId == app_id) \
.delete()
db.session.commit()
return response({
'id': group
})
def delete(self, **kwargs):
"""
Delete user contact
"""
user = kwargs.get('user', request.user)
inbox = kwargs.get('inbox')
# admin check, to be sure that non admin users can delete inboxes
if inbox.userId != user.id and not user.is_admin():
raise ErrorResource(message='Not have permissions.',
status_code=403)
db.session.delete(inbox)
db.session.commit()
return response(inbox.to_dict())
def index(self, **kwargs):
"""
Returning list of tags for specific user
"""
user = kwargs.get('user')
# search or not
search = request.args.get('search')
tags = user.tags
if search is not None:
like = "%{0}%".format(search)
tags = tags.filter(Tag._label.like(like))
tags = tags.order_by(Tag._label.asc())
return response([tag.to_dict() for tag in tags.all()])
def external(self, application):
"""
Creating new message in outbox via application token key
"""
data = request.json
send_at = str_to_datetime(data.get('send')) if data.get('send') \
else datetime.utcnow()
# put message to queue
outbox = Outbox.send(user=application.user,
application_id=application.id,
group=random_string(8),
destination_number=data.get('phoneNumber'),
message=data.get('message'),
send=send_at)
return response(outbox.to_dict(), status_code=201)
def index(self, **kwargs):
"""
Returning list of contacts for specific user
"""
user = kwargs.get('user')
# search or not
search = request.args.get('search')
contacts = user.contacts
if search is not None:
like = "%{0}%".format(search)
contacts = contacts.filter(or_(Contact.firstName.ilike(like),
Contact.lastName.ilike(like)))
contacts = contacts.order_by(Contact.lastName.asc()).all()
return response([contact.to_dict() for contact in contacts])
def index(self, **kwargs):
"""
Returning list of contacts for specific user
"""
user = kwargs.get('user')
# search or not
search = request.args.get('search')
contacts = user.contacts
if search is not None:
like = "%{0}%".format(search)
contacts = contacts.filter(
or_(Contact.firstName.ilike(like),
Contact.lastName.ilike(like)))
contacts = contacts.order_by(Contact.lastName.asc()).all()
return response([contact.to_dict() for contact in contacts])
class ApplicationsResource(FlaskView):
""" Applications endpoints """
route_base = '/users/<uuid:user_uuid>/applications/'
@decorators.auth()
def index(self, **kwargs):
"""
Returning list of applications for specific user
"""
user = kwargs.get('user')
applications = user.applications.order_by(Application.label.asc()).all()
return response([app.to_dict() for app in applications])
@route('/<uuid:application_uuid>/')
@decorators.auth()
def get(self, **kwargs):
"""
Get user application
"""
application = kwargs.get('application')
return response(application.to_dict())
@decorators.auth()
@decorators.jsonschema_validate(post.schema)
def post(self, **kwargs):
"""
Creating new user application
"""
try:
# create and save application
user = kwargs.get('user')
application = Application(**request.json)
application.userId = user.id
db.session.add(application)
db.session.commit()
except IntegrityError, e:
db.session.rollback()
raise ErrorResource(409, message="Prefix is already exists.")
return response(application.to_dict(), status_code=201)
def messages_range(self, interval, **kwargs):
"""
GET stats count for inbox, sent and outbox per time intervals
"""
user = kwargs.get('user')
app = kwargs.get('application')
utcnow = datetime.utcnow()
payload = {}
elements = {
'sent': SentItem,
'inbox': Inbox,
'outbox': Outbox
}
intervals = {
'lastweek': 7,
'lastmonth': 31
}
# looking for each date stats
for x in range(0, intervals[interval]):
date = utcnow.date() - timedelta(days=x)
# constructing query to get stats for 3 tables at query
queries = []
for key, model in elements.iteritems():
query = db.session \
.query(func.count()) \
.filter(getattr(model, 'userId') == user.id) \
.filter(cast(getattr(model, 'created'), Date) == date)
if app:
query = query.filter(getattr(model, 'applicationId') == app.id)
query = query.limit(1).label(key)
queries.append(query)
counts = db.session.query(*tuple(queries)).one()
payload[date.isoformat()] = {
'sent': counts.sent,
'inbox': counts.inbox,
'outbox': counts.outbox,
}
return response(payload)
def index(self, **kwargs):
"""
Returning list items in inbox
"""
user = kwargs.get('user')
app = kwargs.get('application')
query = None
if user is None:
query = Inbox.query
if not request.user.is_admin():
raise ErrorResource(message='Not have permissions.',
status_code=403)
else:
query = app.inbox if app else user.inbox
messages = query.order_by(Inbox.received.desc()).all()
return response([message.to_dict() for message in messages])
def external(self, application):
"""
Creating new message in outbox via application token key
"""
data = request.json
send_at = str_to_datetime(data.get('send')) if data.get('send') \
else datetime.utcnow()
# put message to queue
outbox = Outbox.send(
user=application.user,
application_id=application.id,
group=random_string(8),
destination_number=data.get('phoneNumber'),
message=data.get('message'),
send=send_at
)
return response(outbox.to_dict(), status_code=201)
def messages(self, **kwargs):
"""
GET stats count for inbox, sent and outbox
"""
user = kwargs.get('user')
app = kwargs.get('application')
payload = {}
elements = {
'sent': SentItem,
'inbox': Inbox,
'outbox': Outbox
}
for key, model in elements.iteritems():
query = model.query.filter_by(userId=user.id)
if app:
query = query.filter_by(applicationId=app.id)
payload[key] = query.count()
return response(payload)
def index(self, **kwargs):
"""
Returning list items in inbox
"""
user = kwargs.get('user')
app = kwargs.get('application')
query = None
if user is None:
query = Inbox.query
if not request.user.is_admin():
raise ErrorResource(
message='Not have permissions.',
status_code=403
)
else:
query = app.inbox if app else user.inbox
messages = query.order_by(Inbox.received.desc()).all()
return response([message.to_dict() for message in messages])
def login(self):
"""
"""
# TODO(vojta) save success login, improve token stuff
data = request.json
# find user by email and if is not existing or passwd
# is incorect will raise error 403
user = User.query.filter_by(email=data['email']).first()
if user is None or user.compare_password(data['password']) is False:
raise ErrorResource(
403,
message="Invalid password or email."
)
# non active users are not allowed
if user.isActive is False:
raise ErrorResource(403, message="Account is not active.")
# create user token for user
token = None
agent = request.headers.get('User-Agent')
if agent is not None:
token = UserToken.query \
.filter_by(userId=user.id) \
.filter_by(agent=agent) \
.first()
if token is None:
token = UserToken(userId=user.id, agent=agent)
db.session.add(token)
db.session.commit()
# create payload response
return response({
'uuid': user.uuid,
'token': token.token
}, status_code=200)
def resetPassword(self, token=None, **kwargs):
"""
Reseting user password
"""
# get data from payload
data = request.json
email = data.get('email')
password = data.get('password')
# user
payload = None
message = None
user = None
if email is not None:
# find user
user = User.get_one(email=email)
if user is None:
raise ErrorResource(404, message="Invalid email address.")
# delete all existing tokens
UserForgotPassword.query.filter_by(userId=user.id).delete()
# create new token
expired = datetime.utcnow() + timedelta(minutes=30)
forgot_password = UserForgotPassword(userId=user.id,
expired=expired)
db.session.add(forgot_password)
db.session.commit()
# send email
from smsgw.tasks.mail import MailTask
MailTask().apply_async(**{
'kwargs': {
'to': [user.email],
'template': 'mail/forgotten_password',
'params': {
'first_name': user.firstName,
'last_name': user.lastName,
'token': forgot_password.token
}
}
})
# set up payload
message = "On your email has been sent link for change passowrd."
elif token is not None and password is not None:
# find request for user password
forgot_password = UserForgotPassword.get_one(token=token)
if forgot_password is None:
raise ErrorResource(404, message="Invalid token.")
# update password
user = forgot_password.user
user.password = password
# delete token
db.session.remove(forgot_password)
db.session.commit()
# set up payload
message = "Your passsword has been successfuly changed."
else:
# we dont have email, token or password, so we are not
# able to reset password
raise ErrorResource(400, message="Not able to reset password.")
return response(payload, message=message)
