def post(self, request):
post_schema = {
"email": schema.email(required=True),
"password": schema.text(required=True),
}
data = json.loads(request.body)
data, errors = schema.validate(post_schema, data)
if errors != {}:
return json_response(request, {"status": "error", "errors": errors})
username = data.get('email').lower()
password = data.get('password')
user = authenticate(request, username=username, password=password)
if user is None:
return json_response(request, {
"status": "error",
"errors": AuthenticationForm.error_messages.get('invalid_login') % { "username" : "email" }
})
if not user.is_active:
return json_response(request, {
"status": "error",
"errors": AuthenticationForm.error_messages.get('inactive')
})
login(request, user)
return json_response(request, { "status": "success", "user": user.username });
def post(self, request):
def _user_check():
def _validate(value):
error = _('A user with that email address already exists.')
if User.objects.filter(username__iexact=value).exists():
return None, error
return value, None
return _validate
post_schema = {
"email": schema.chain([
schema.email(required=True),
_user_check(),
]),
"first_name": schema.text(required=True),
"last_name": schema.text(required=True),
"password": schema.text(required=True),
"newsletter": schema.boolean(),
}
data = json.loads(request.body)
data, errors = schema.validate(post_schema, data)
if errors != {}:
return json_response(request, {"status": "error", "errors": errors})
user = create_user(data['email'], data['first_name'], data['last_name'], data['password'], data.get('newsletter', False))
login(request, user)
return json_response(request, { "status": "created", "user": user.username });
def post(self, request, *args, **kwargs):
study_group = self.get_object()
post_schema = _make_learning_circle_schema(request)
data = json.loads(request.body)
data, errors = schema.validate(post_schema, data)
if errors != {}:
return json_response(request, {
"status": "error",
"errors": errors
})
# update learning circle
end_date = data.get('start_date') + datetime.timedelta(
weeks=data.get('weeks') - 1)
published = False
# only publish a learning circle for a user with a verified email address
draft = data.get('draft', True)
if draft == False and request.user.profile.email_confirmed_at != None:
published = study_group.draft == True
study_group.draft = False
study_group.course = data.get('course')
study_group.description = data.get('description')
study_group.venue_name = data.get('venue_name')
study_group.venue_address = data.get('venue_address')
study_group.venue_details = data.get('venue_details')
study_group.venue_website = data.get('venue_website', '')
study_group.city = data.get('city')
study_group.region = data.get('region')
study_group.country = data.get('country')
study_group.latitude = data.get('latitude')
study_group.longitude = data.get('longitude')
study_group.place_id = data.get('place_id', '')
study_group.start_date = data.get('start_date')
study_group.end_date = end_date
study_group.meeting_time = data.get('meeting_time')
study_group.duration = data.get('duration')
study_group.timezone = data.get('timezone')
study_group.image = data.get('image')
study_group.signup_question = data.get('signup_question', '')
study_group.facilitator_goal = data.get('facilitator_goal', '')
study_group.facilitator_concerns = data.get('facilitator_concerns', '')
study_group.save()
# generate all meetings if the learning circle has been published
if published:
generate_all_meetings(study_group)
study_group_url = settings.DOMAIN + reverse(
'studygroups_signup',
args=(
slugify(study_group.venue_name, allow_unicode=True),
study_group.id,
))
return json_response(request, {
"status": "updated",
"url": study_group_url
})
def post(self, request):
post_schema = _make_learning_circle_schema(request)
data = json.loads(request.body)
data, errors = schema.validate(post_schema, data)
if errors != {}:
return json_response(request, {
"status": "error",
"errors": errors
})
# create learning circle
end_date = data.get('start_date') + datetime.timedelta(
weeks=data.get('weeks') - 1)
study_group = StudyGroup(
course=data.get('course'),
facilitator=request.user,
description=data.get('description'),
venue_name=data.get('venue_name'),
venue_address=data.get('venue_address'),
venue_details=data.get('venue_details'),
venue_website=data.get('venue_website', ''),
city=data.get('city'),
region=data.get('region'),
country=data.get('country'),
latitude=data.get('latitude'),
longitude=data.get('longitude'),
place_id=data.get('place_id', ''),
start_date=data.get('start_date'),
end_date=end_date,
meeting_time=data.get('meeting_time'),
duration=data.get('duration'),
timezone=data.get('timezone'),
image=data.get('image'),
signup_question=data.get('signup_question', ''),
facilitator_goal=data.get('facilitator_goal', ''),
facilitator_concerns=data.get('facilitator_concerns', ''))
# only update value for draft if the use verified their email address
if request.user.profile.email_confirmed_at != None:
study_group.draft = data.get('draft', True)
study_group.save()
# generate all meetings if the learning circle has been published
if study_group.draft == False:
generate_all_meetings(study_group)
study_group_url = settings.DOMAIN + reverse(
'studygroups_signup',
args=(
slugify(study_group.venue_name, allow_unicode=True),
study_group.id,
))
return json_response(request, {
"status": "created",
"url": study_group_url
})
def post(self, request):
form = ImageForm(request.POST, request.FILES)
if form.is_valid():
image = form.cleaned_data['image']
storage = get_storage_class()()
filename = storage.save(image.name, image)
# TODO - get full URL
image_url = ''.join([settings.MEDIA_URL, filename])
return json_response(request, {"image_url": image_url})
else:
return json_response(request, {'error': 'not a valid image'})
def post(self, request):
def _user_check():
def _validate(value):
error = _('A user with that email address already exists.')
if User.objects.filter(username__iexact=value).exists():
return None, error
return value, None
return _validate
post_schema = {
"email": schema.chain([
schema.email(required=True),
_user_check(),
]),
"first_name": schema.text(required=True),
"last_name": schema.text(required=True),
"password": schema.text(required=True),
"communication_opt_in": schema.boolean(required=True),
"g-recaptcha-response": schema.text(required=True),
}
data = json.loads(request.body)
data, errors = schema.validate(post_schema, data)
recaptcha_response = data.get('g-recaptcha-response')
recaptcha_data = {
'secret': settings.RECAPTCHA_SECRET_KEY,
'response': recaptcha_response
}
r = requests.post('https://www.google.com/recaptcha/api/siteverify',
data=recaptcha_data)
captcha_result = r.json()
if not captcha_result.get('success'):
# TODO track metric somewhere?
return json_response(request, {
"status": "error",
"errors": '1011010010010010111'
})
if errors != {}:
return json_response(request, {
"status": "error",
"errors": errors
})
user = create_user(data['email'], data['first_name'],
data['last_name'], data['password'],
data.get('communication_opt_in', False))
login(request, user)
return json_response(request, {
"status": "created",
"user": user.username
})
def post(self, request):
signup_questions = {
"goals": schema.text(required=True),
"support": schema.text(required=True),
"computer_access": schema.text(required=True),
"use_internet": schema.text(required=True)
}
post_schema = {
"study_group":
schema.chain([
schema.integer(),
lambda x: (None, 'No matching learning circle exists')
if not StudyGroup.objects.filter(pk=int(x)).exists() else
(StudyGroup.objects.get(pk=int(x)), None),
],
required=True),
"name":
schema.text(required=True),
"email":
schema.email(required=True),
"mobile":
schema.mobile(),
"signup_questions":
schema.schema(signup_questions, required=True)
}
data = json.loads(request.body)
clean_data, errors = schema.validate(post_schema, data)
if errors != {}:
return json_response(request, {
"status": "error",
"errors": errors
})
study_group = StudyGroup.objects.get(pk=data.get('study_group'))
if Application.objects.active().filter(
email__iexact=data.get('email'),
study_group=study_group).exists():
application = Application.objects.active().get(
email__iexact=data.get('email'), study_group=study_group)
else:
application = Application(study_group=study_group,
name=data.get('name'),
email=data.get('email'),
signup_questions=json.dumps(
data.get('signup_questions')),
accepted_at=timezone.now())
application.name = data.get('name')
application.signup_questions = json.dumps(data.get('signup_questions'))
if data.get('mobile'):
application.mobile = data.get('mobile')
application.save()
return json_response(request, {"status": "created"})
def get(self, request):
user_data = {
"user": "******",
}
if request.user.is_authenticated():
user_data["user"] = request.user.first_name
user_data["links"] = [
{
"text": "My learning circles",
"url": reverse('studygroups_facilitator')
},
{
"text": "Log out",
"url": reverse('logout')
},
]
if request.user.is_staff or TeamMembership.objects.filter(
user=request.user, role=TeamMembership.ORGANIZER):
user_data["links"][:0] = [
{
"text": "My Team",
"url": reverse('studygroups_organize')
},
]
if request.user.is_staff:
user_data["links"][:0] = [
{
"text": "Staff dash",
"url": reverse('studygroups_staff_dash')
},
]
return json_response(request, user_data)
def post(self, request):
try:
json_data = json.loads(request.body)
level = json_data['level']
logger.log(LEVELS[level], json_data['message'])
except (ValueError, KeyError):
logger.warning('Malformed client log received')
return json_response(request, {'status': 200})
def get(self, request):
topics = Course.objects.active()\
.filter(unlisted=False)\
.exclude(topics='')\
.values_list('topics')
topics = [
item.strip().lower() for sublist in topics for item in sublist[0].split(',')
]
from collections import Counter
data = {}
#data['items'] = list(set(topics))
data['topics'] = { k:v for k,v in list(Counter(topics).items()) }
return json_response(request, data)
def studygroups(request):
#TODO only accept GET requests
# TODO remove this API endpoint, where is it currently being used??
study_groups = StudyGroup.objects.published()
if 'course_id' in request.GET:
study_groups = study_groups.filter(
course_id=request.GET.get('course_id'))
def to_json(sg):
data = {
"course_title":
sg.course.title,
"facilitator":
sg.facilitator.first_name + " " + sg.facilitator.last_name,
"venue":
sg.venue_name,
"venue_address":
sg.venue_address + ", " + sg.city,
"city":
sg.city,
"day":
sg.day(),
"start_date":
sg.start_date,
"meeting_time":
sg.meeting_time,
"time_zone":
sg.timezone_display(),
"end_time":
sg.end_time(),
"weeks":
sg.meeting_set.active().count(),
"url":
"https://learningcircles.p2pu.org" + reverse(
'studygroups_signup', args=(
slugify(sg.venue_name),
sg.id,
)),
}
if sg.image:
data[
"image_url"] = "https://learningcircles.p2pu.org" + sg.image.url
#TODO else set default image URL
return data
data = [to_json(sg) for sg in study_groups]
return json_response(request, data)
def get(self, request):
user_data = {
"user": "******",
}
if request.user.is_authenticated:
user_data["user"] = request.user.first_name
user_data["links"] = [
{
"text": "Dashboard",
"url": reverse('studygroups_facilitator')
},
{
"text": "Start a learning circle",
"url": reverse('studygroups_facilitator_studygroup_create')
},
{
"text": "Account settings",
"url": reverse('account_settings')
},
{
"text": "Log out",
"url": reverse('logout')
},
]
if request.user.is_staff or TeamMembership.objects.active().filter(
user=request.user, role=TeamMembership.ORGANIZER):
user_data["links"][:0] = [
{
"text": "My team",
"url": reverse('studygroups_organize')
},
]
if request.user.is_staff or TeamMembership.objects.active().filter(
user=request.user):
user_data['team'] = True
if request.user.is_staff:
user_data["links"][:0] = [
{
"text": "Staff dash",
"url": reverse('studygroups_staff_dash')
},
]
return json_response(request, user_data)
def get(self, request):
# get learning circles with image & upcoming meetings
study_groups = StudyGroup.objects.published().filter(
meeting__meeting_date__gte=timezone.now(), ).annotate(
next_meeting_date=Min('meeting__meeting_date')).order_by(
'next_meeting_date')[:3]
# if there are less than 3 with upcoming meetings and an image
if study_groups.count() < 3:
#pad with learning circles with the most recent meetings
past_study_groups = StudyGroup.objects.published().filter(
meeting__meeting_date__lt=timezone.now(), ).annotate(
next_meeting_date=Max('meeting__meeting_date')).order_by(
'-next_meeting_date')
study_groups = list(study_groups) + list(
past_study_groups[:3 - study_groups.count()])
data = {'items': [_map_to_json(sg) for sg in study_groups]}
return json_response(request, data)
def get(self, request):
study_group_ids = Meeting.objects.active().filter(
meeting_date__gte=timezone.now()
).values('study_group')
course_ids = None
course_ids = StudyGroup.objects.published().filter(id__in=study_group_ids).values('course')
topics = Course.objects.active()\
.filter(unlisted=False)\
.filter(id__in=course_ids)\
.exclude(topics='')\
.values_list('topics')
topics = [
item.strip().lower() for sublist in topics for item in sublist[0].split(',')
]
from collections import Counter
data = {}
#data['items'] = list(set(topics))
data['topics'] = { k:v for k,v in list(Counter(topics).items()) }
return json_response(request, data)
def get(self, request):
study_groups = StudyGroup.objects.published().filter(
meeting__meeting_date__gte=timezone.now()).annotate(
next_meeting_date=Min('meeting__meeting_date'))
cities = StudyGroup.objects.published().filter(
latitude__isnull=False,
longitude__isnull=False,
).distinct('city').values('city')
learning_circle_count = StudyGroup.objects.published().count()
facilitators = StudyGroup.objects.active().distinct(
'facilitator').values('facilitator')
cities_s = list(set([c['city'].split(',')[0].strip() for c in cities]))
data = {
"active_learning_circles": study_groups.count(),
#"city_list": [v['city'] for v in cities],
"cities": len(cities_s),
"facilitators": facilitators.count(),
"learning_circle_count": learning_circle_count
}
return json_response(request, data)
def form_valid(self, form):
recaptcha_response = self.request.POST.get('g-recaptcha-response')
data = {
'secret': settings.RECAPTCHA_SECRET_KEY,
'response': recaptcha_response
}
r = requests.post('https://www.google.com/recaptcha/api/siteverify',
data=data)
captcha_result = r.json()
if not captcha_result.get('success'):
# TODO track metric somewhere?
return json_response(self.request, {
"status": "error",
"errors": '1011010010010010111'
})
user = form.save(commit=False)
user = create_user(user.email, user.first_name, user.last_name,
form.cleaned_data['password1'],
form.cleaned_data['communication_opt_in'])
login(self.request, user)
return http.HttpResponseRedirect(self.get_success_url())
def get(self, request):
query_schema = {
"offset": schema.integer(),
"limit": schema.integer(),
"order": lambda v: (v, None) if v in ['title', 'usage', None] else (None, "must be 'title' or 'usage'")
}
data = schema.django_get_to_dict(request.GET)
clean_data, errors = schema.validate(query_schema, data)
if errors != {}:
return json_response(request, {"status": "error", "errors": errors})
courses = Course.objects.active().filter(unlisted=False).annotate(
num_learning_circles=Sum(
Case(
When(
studygroup__deleted_at__isnull=True, then=Value(1),
studygroup__course__id=F('id')
),
default=Value(0), output_field=models.IntegerField()
)
)
)
if 'course_id' in request.GET:
course_id = request.GET.get('course_id')
courses = courses.filter(pk=int(course_id))
if request.GET.get('order', None) in ['title', None]:
courses = courses.order_by('title')
else:
courses = courses.order_by('-num_learning_circles')
query = request.GET.get('q', None)
if query:
tsquery = CustomSearchQuery(query, config='simple')
courses = courses.annotate(
search=SearchVector('topics', 'title', 'caption', 'provider', config='simple')
).filter(search=tsquery)
if 'topics' in request.GET:
topics = request.GET.get('topics').split(',')
query = Q(topics__icontains=topics[0])
for topic in topics[1:]:
query = Q(topics__icontains=topic) | query
courses = courses.filter(query)
if 'active' in request.GET:
active = request.GET.get('active') == 'true'
study_group_ids = Meeting.objects.active().filter(
meeting_date__gte=timezone.now()
).values('study_group')
course_ids = None
if active:
course_ids = StudyGroup.objects.published().filter(id__in=study_group_ids).values('course')
else:
course_ids = StudyGroup.objects.published().exclude(id__in=study_group_ids).values('course')
courses = courses.filter(id__in=course_ids)
data = {
'count': courses.count()
}
if 'offset' in request.GET or 'limit' in request.GET:
limit, offset = _limit_offset(request)
data['offset'] = offset
data['limit'] = limit
courses = courses[offset:offset+limit]
data['items'] = [ _course_to_json(course) for course in courses ]
return json_response(request, data)
def get(self, request):
query_schema = {
"latitude": schema.floating_point(),
"longitude": schema.floating_point(),
"distance": schema.floating_point(),
"offset": schema.integer(),
"limit": schema.integer(),
"weekdays": _intCommaList,
}
data = schema.django_get_to_dict(request.GET)
clean_data, errors = schema.validate(query_schema, data)
if errors != {}:
return json_response(request, {"status": "error", "errors": errors})
study_groups = StudyGroup.objects.published().order_by('id')
if 'id' in request.GET:
id = request.GET.get('id')
study_groups = StudyGroup.objects.filter(pk=int(id))
if 'q' in request.GET:
q = request.GET.get('q')
study_groups = study_groups.annotate(
search =
SearchVector('city')
+ SearchVector('course__title')
+ SearchVector('course__provider')
+ SearchVector('course__topics')
+ SearchVector('venue_name')
+ SearchVector('venue_address')
+ SearchVector('venue_details')
+ SearchVector('facilitator__first_name')
+ SearchVector('facilitator__last_name')
).filter(search=q)
if 'course_id' in request.GET:
study_groups = study_groups.filter(
course_id=request.GET.get('course_id')
)
city = request.GET.get('city')
if city is not None:
study_groups = study_groups.filter(city=city)
team_id = request.GET.get('team_id')
if team_id is not None:
team = Team.objects.get(pk=team_id)
members = team.teammembership_set.values('user')
team_users = User.objects.filter(pk__in=members)
study_groups = study_groups.filter(facilitator__in=team_users)
if 'signup' in request.GET:
signup_open = request.GET.get('signup') == 'open'
study_groups = study_groups.filter(signup_open=signup_open)
if 'active' in request.GET:
active = request.GET.get('active') == 'true'
study_group_ids = Meeting.objects.active().filter(
meeting_date__gte=timezone.now()
).values('study_group')
if active:
study_groups = study_groups.filter(id__in=study_group_ids)
else:
study_groups = study_groups.exclude(id__in=study_group_ids)
if 'latitude' in request.GET and 'longitude' in request.GET:
# work with floats for ease
latitude = float(request.GET.get('latitude'))
longitude = float(request.GET.get('longitude'))
distance = float(request.GET.get('distance', False) or 50)
lat_delta, lon_delta = getLatLonDelta(latitude, longitude, distance)
lat_min = max(-90, latitude - lat_delta)
lat_max = min(90, latitude + lat_delta)
lon_min = max(-180, longitude - lon_delta)
lon_max = min(180, longitude + lon_delta)
# NOTE doesn't wrap around,
# iow, something at lat=45, lon=-189 and distance=1000 won't match
# lat=45, lon=189 even though they are only 222 km apart.
study_groups = study_groups.filter(
latitude__gte=lat_min,
latitude__lte=lat_max,
longitude__gte=lon_min,
longitude__lte=lon_max
)
# NOTE could use haversine approximation to filter more accurately
if 'topics' in request.GET:
topics = request.GET.get('topics').split(',')
query = Q(course__topics__icontains=topics[0])
for topic in topics[1:]:
query = Q(course__topics__icontains=topic) | query
study_groups = study_groups.filter(query)
if 'weekdays' in request.GET:
weekdays = request.GET.get('weekdays').split(',')
query = None
for weekday in weekdays:
# __week_day differs from datetime.weekday()
# Monday should be 0
weekday = int(weekday) + 2 % 7
query = query | Q(start_date__week_day=weekday) if query else Q(start_date__week_day=weekday)
study_groups = study_groups.filter(query)
data = {
'count': len(study_groups)
}
if 'offset' in request.GET or 'limit' in request.GET:
limit, offset = _limit_offset(request)
data['offset'] = offset
data['limit'] = limit
study_groups = study_groups[offset:offset+limit]
data['items'] = [ _map_to_json(sg) for sg in study_groups ]
return json_response(request, data)
