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)