def post(self):
"""Sign up View
"""
email = request.form.get('email', None)
password = request.form.get('password', None)
name = request.form.get('name', None)
age = request.form.get('age', None)
gender = request.form.get('gender', None)
image = request.form.get('image', None)
if not email or not password:
message = "Invalid request"
return api_response(message= message, status_code = BAD_REQUEST_STATUS_CODE)
exists_user = User.query.filter_by(email=email).first()
if not exists_user:
user = User(email, password, name, age, gender, image)
user.save()
data = {
"id": user.id,
"email": email
}
message = "Sign up successfully"
return api_response(data=data, message=message)
else :
message = "User already exists."
return api_response(message=message, status_code=BAD_REQUEST_STATUS_CODE)
def post(self):
"""Request forgot password code
"""
try:
email = request.form.get('email', None)
if not email :
message = "Invalid request"
return api_response(message= message, status_code = BAD_REQUEST_STATUS_CODE)
else:
user_id = None
code = code_generator()
user = User.query.filter_by(email=email).first()
if user:
user_id = user.id
reset_password = ResetPassword(code, user_id)
reset_password.save()
# Send email
# Should not return anything in this request but, should send via email
# But this for testing only
data = {
"code": code
}
return api_response(data=data)
except Exception as e:
print(e)
message = "Internal Server Error"
return api_response(message=message, status_code=500)
def user(request, username):
try:
profile = Profile.objects.annotate(
num_trips = Count('user__created_trip_set')
).select_related('user').get(user__username = username)
except Profile.DoesNotExist:
return api_response(request, 404, {
'username': username
}, ok = False)
info = {
'username': username,
'first_name': profile.user.first_name,
'last_name': profile.user.first_name,
'url': profile.url,
'biography': profile.biography,
'num_trips': profile.num_trips,
'trips_api': 'http://www.wildlifenearyou.com/api/%s/trips/' % (
username
),
'species_seen_api': 'http://www.wildlifenearyou.com/api/%s/species/'%(
username
),
}
return api_response(request, 200, info)
def post(self):
try:
email = request.form.get('email', None)
password = request.form.get('password', None)
if not email or not password:
message = "Invalid request"
return api_response(message= message, status_code = BAD_REQUEST_STATUS_CODE)
user = User.query.filter_by(email=email).first()
if not user:
message = "User not exist"
return api_response(message=message, status_code=400)
elif not user.check_password(password):
message = "Wrong email or password"
return api_response(message=message, status_code=400)
else:
access_token = user.get_access_token()
print(access_token)
data = {
"access_token": access_token
}
message = "Login successfully"
return api_response(data=data, message=message, status_code=BAD_REQUEST_STATUS_CODE)
except Exception as e:
print(e)
message = "Internal Server Error"
return api_response(message=message, status_code=500)
def delete(self):
mongoHelper = MongodbHelper(self.collection_name, self.db_dsn, self.db_name)
deleted_count = mongoHelper.remove_all()
if deleted_count == 0:
return api_response(400, "Cannot delete all sensors")
return api_response(200, "Delete all payloads succesfully")
def user_species(request, username):
try:
user = User.objects.get(username = username)
except User.DoesNotExist:
return api_response(request, 404, {
'username': username
}, ok = False)
species_seen = Species.objects.filter(
sightings__created_by = user
).annotate(
times_seen = Count('sightings')
).values('common_name', 'latin_name', 'slug', 'times_seen', 'pk')
return api_response(request, 200, {
'username': username,
'species': [{
'api_url': 'http://www.wildlifenearyou.com/api/species/%s/' % (
species['slug']
),
'common_name': species['common_name'],
'latin_name': species['latin_name'],
'code': 's' + converter.from_int(species['pk']),
'short_url': 'http://wlny.eu/s'+converter.from_int(species['pk']),
'times_seen': species['times_seen'],
} for species in species_seen]
})
def post(self):
"""Rest password
"""
try:
code = request.form.get('code', None)
password = request.form.get('password', None)
if not code or not password :
message = "Invalid request"
return api_response(message= message, status_code = BAD_REQUEST_STATUS_CODE)
else:
user_id = ResetPassword.check_code(code)
if user_id:
user = User.query.filter_by(id=user_id).first()
user.change_password(password)
user.save()
return api_response()
message = "Invalid code"
return api_response(message=message, status_code=BAD_REQUEST_STATUS_CODE)
except Exception as e:
print(e)
message = "Internal Server Error"
return api_response(message=message, status_code=500)
def get(self, object_id):
mongoHelper = MongodbHelper(self.collection_name, self.db_dsn, self.db_name)
query_object = {'_id': ObjectId(object_id)}
response = list(mongoHelper.list(query_object))
if not response:
return api_response(404, "Sensor not found which has '{}' object_id".format(object_id))
return api_response(200, response)
def delete(self, object_id):
mongoHelper = MongodbHelper(self.collection_name, self.db_dsn, self.db_name)
query_object = {'_id': ObjectId(object_id)}
deleted_count = mongoHelper.remove(query_object)
if deleted_count == 0:
return api_response(400, "Cannot delete sensor because there is no sensor which has '{}' object_id".format(object_id))
return api_response(200, "Delete sensor succesfully which has '{}' object_id".format(object_id))
def put(self, object_id):
mongoHelper = MongodbHelper(self.collection_name, self.db_dsn, self.db_name)
query_object = {'_id': ObjectId(object_id)}
json_data = request.get_json(force=True)
json_data['last_connection_datetime'] = datetime.datetime.now()
response = {"modified_count": mongoHelper.edit(query_object, json_data)}
if response == 0:
return api_response(400, "Cannot be edit")
return api_response(200, response)
def trip(request, username, pk):
try:
trip = Trip.objects.get(pk = pk, created_by__username = username)
except Trip.DoesNotExist:
return api_response(request, 404, {
'username': username,
'trip_id': pk,
}, ok = False)
return api_response(request, 200, {
'name': trip.name,
'todo': 'finish me',
})
def get(self):
"""Get user profile
"""
user_id = is_authorized(request)
if user_id:
user = User.query.filter_by(id=user_id).first()
data = user.to_json()
return api_response(data=data)
else:
message = "Invalid token"
return api_response(message=message, status_code=UNAUTHORIZED_STATUS_CODE)
def metadata(request, ids):
ids = ids.replace('/', '')
ids = [id.strip() for id in ids.split(',') if id.strip()]
if len(set(ids)) > MAX_METADATA:
return api_response(request, 500, {
'ok': False,
'reason': 'Max %s ids allowed' % MAX_METADATA
})
results = dict(zip(ids, [{'ok': False} for id in ids]))
from shorturl.views import PREFIXES
to_process = {}
for shortcode in ids:
if shortcode[0] in PREFIXES:
try:
pk = converter.to_int(shortcode[1:])
except ValueError:
continue
to_process.setdefault(
PREFIXES[shortcode[0]], {}
)[pk] = shortcode
for model, codes in to_process.items():
pks = codes.keys()
found = model.objects.in_bulk(pks)
for pk, obj in found.items():
results[codes[pk]] = {
'ok': True,
'shortcode': codes[pk],
'shorturl': 'http://wlny.eu/%s' % codes[pk],
'title': str(obj),
'url': 'http://www.wildlifenearyou.com%s' % \
obj.get_absolute_url(),
'type': model._meta.verbose_name,
}
return api_response(request, 200, {'results': results, 'ok': True})
def user_trips(request, username):
try:
user = User.objects.get(username = username)
except User.DoesNotExist:
return api_response(request, 404, {
'username': username
}, ok = False)
return api_response(request, 200, {
'username': username,
'trips': [{
'api_url': 'http://www.wildlifenearyou.com/api/%s/trips/%s/' % (
username, trip['pk']
),
'url': 'http://www.wildlifenearyou.com/%s/trips/%s/' % (
username, trip['pk']
),
'name': trip['name'],
'code': 't' + converter.from_int(trip['pk']),
'short_url': 'http://wlny.eu/t' + converter.from_int(trip['pk']),
'date': api_date(trip['start']),
'date_accuracy': trip['start_accuracy'],
'created': api_datetime(trip['created_at']),
'num_sightings': trip['num_sightings'],
'place': {
'known_as': trip['place__known_as'],
'api_url': 'http://www.wildlifenearyou.com/api/%s/%s/' % (
trip['place__country__country_code'], trip['place__slug']
),
'code': 'p' + converter.from_int(trip['place__pk']),
'short_url': 'http://wlny.eu/p' + \
converter.from_int(trip['place__pk']),
'url': 'http://www.wildlifenearyou.com/%s/%s/' % (
trip['place__country__country_code'], trip['place__slug']
)
},
} for trip in trip_qs.filter(created_by = user)]
})
def wrapper(request, *args, **kwargs):
if 'api_key' in request.GET:
limiter = KeyRateLimiter()
key = request.GET['api_key']
else:
limiter = IPRateLimiter()
key = request.META['REMOTE_ADDR']
try:
limiter.check(key)
except RateFail, e:
code, description = e.code_and_description()
detail = e.message
return api_response(request, 403, {
'ok': False,
'error': {
'code': code,
'description': description,
'detail': detail,
},
'key': key,
})
def species_identifiers(request):
all = Species.objects.all().order_by('slug')
allowed_args = ('namespace', 'source', 'key', 'code', 'slug', 'after')
external_identifier_args = ('namespace', 'source', 'key')
provided_args = [
(arg, request.GET.get(arg, None))
for arg in allowed_args
]
for arg, value in provided_args:
if value is None:
continue
if arg in external_identifier_args:
all = all.filter(**{
'external_identifiers__%s' % arg: value
})
elif arg == 'code':
all = all.filter(pk = converter.to_int(value[1:]))
elif arg == 'slug':
all = all.filter(slug = value)
elif arg == 'after': # Deal with pagination
all = all.filter(slug__gte = value)
# We only serve up 50 at a time
all = list(all[:51])
next_after = None
if len(all) == 51:
next_after = all[-1].slug
all = all[:-1]
# Now fetch the external identifiers in one big go
identifiers = ExternalIdentifier.objects.filter(**dict([
(k, v) for k, v in provided_args
if k in external_identifier_args and v is not None
])).filter(
species__in = [s.pk for s in all]
).values('species_id', 'source', 'namespace', 'key', 'uri')
species_identifiers = defaultdict(list)
for identifier in identifiers:
species_identifiers[identifier['species_id']].append(identifier)
species = []
for s in all:
species.append({
'url': 'http://www.wildlifenearyou.com%s' % (
s.get_absolute_url()
),
'code': s.short_code(),
'short_url': s.short_url(),
'common_name': s.common_name,
'latin_name': s.latin_name,
'slug': s.slug,
'external_identifiers': [{
'source': d['source'],
'namespace': d['namespace'],
'key': d['key'],
'uri': d['uri'],
} for d in species_identifiers.get(s.pk, [])]
})
result = {
'ok': True,
'species': species,
'args': {}
}
for arg, value in provided_args:
if value is not None:
result['args'][arg] = value
if next_after:
result['next'] = 'http://www.wildlifenearyou.com%s?%s' % (
request.path, urllib.urlencode(dict([
(key, value) for key, value in provided_args if (
key != 'after' and value is not None
)
] + [('after', next_after)]))
)
return api_response(request, 200, result)
def post(self):
mongoHelper = MongodbHelper(self.collection_name, self.db_dsn, self.db_name)
json_data = request.get_json(force=True)
json_data['last_connection_datetime'] = datetime.datetime.now()
result = mongoHelper.add(json_data)
return api_response(201, {"object_id":result})
def get(self):
mongoHelper = MongodbHelper(self.collection_name, self.db_dsn, self.db_name)
response = list(mongoHelper.list({}))
return api_response(200, response)
def handler():
return api_response({'message': 'a response message', 'data': None})
