def new_graph(request): if request.method == "GET": if not request.user.is_authenticated() or is_lazy_user(request.user): return HttpResponseRedirect(reverse("user:login")) concepts = get_user_data(request) used = True while used: gid = ''.join([ random.choice(string.lowercase + string.digits) for i in range(8) ]) used = len(Graph.objects.filter(id=gid)) > 0 return render( request, "graph-creator.html", { "user_data": json.dumps(concepts), "graph_id": gid, "graph_init_data": { "id": gid } }) else: return HttpResponse(status=405)
def user_main(request): if not request.user.is_authenticated() or is_lazy_user(request.user): return redirect('/user/login?next=%s' % request.path) uprof, created = Profile.objects.get_or_create(pk=request.user.pk) # list roadmaps where the user is listed as an owner roadmaps = [rs.roadmap for rs in uprof.roadmap_owners.all()] # obtain an array of learned concept ids for the user lids = [l.id for l in uprof.learned.all()] sids = [s.id for s in uprof.starred.all()] # TODO refactor if len(lids) > 0: concepts_dict = get_id_to_concept_dict() lconcepts = [concepts_dict[idval] for idval in lids if concepts_dict.has_key(idval)] else: lconcepts = [] if len(sids) > 0: concepts_dict = get_id_to_concept_dict() sconcepts = [concepts_dict[idval] for idval in sids if concepts_dict.has_key(idval)] else: sconcepts = [] return render_to_response('user.html', {"lconcepts": lconcepts, "sconcepts": sconcepts, "roadmaps": roadmaps}, context_instance=RequestContext(request))
def user_main(request): if not request.user.is_authenticated() or is_lazy_user(request.user): return redirect('/user/login?next=%s' % request.path) # obtain an array of learned concept ids for the user uprof, created = Profile.objects.get_or_create(pk=request.user.pk) lids = [l.id for l in uprof.learned.all()] sids = [s.id for s in uprof.starred.all()] # TODO refactor if len(lids) > 0: concepts_dict = get_id_to_concept_dict() lconcepts = [ concepts_dict[idval] for idval in lids if concepts_dict.has_key(idval) ] else: lconcepts = [] if len(sids) > 0: concepts_dict = get_id_to_concept_dict() sconcepts = [ concepts_dict[idval] for idval in sids if concepts_dict.has_key(idval) ] else: sconcepts = [] return render_to_response('user.html', { "lconcepts": lconcepts, "sconcepts": sconcepts }, context_instance=RequestContext(request))
def __call__(self, request): if request.user.is_anonymous() and not is_lazy_user(request.user): new_lazy_user = self.get_or_create_guest_account( request.user, request) login(request, new_lazy_user.user, 'django.contrib.auth.backends.ModelBackend') response = self.get_response(request) return response
def register(request, redirect_addr="/user"): # don't allow logged-in users to register a new account if request.user.is_authenticated and not is_lazy_user(request.user): return HttpResponseRedirect(redirect_addr) if request.method == 'POST': form = UserCreateForm(request.POST, instance=request.user) if form.is_valid(): # save lazy or non-lazy acct if is_lazy_user(form.instance): user = LazyUser.objects.convert(form) else: user = form.save() # create and save corresponding profile prof = Profile(user=user) prof.save() # send basic info email uname = form.cleaned_data['username'] subject, from_email, to = 'Metacademy account successfully created', '*****@*****.**', form.cleaned_data[ 'email'] text_content = TXT_ACCT_EMAIL % uname html_content = HTML_ACCT_EMAIL % uname msg = EmailMultiAlternatives(subject, text_content, from_email, [to]) msg.attach_alternative(html_content, "text/html") try: msg.send() except: # TODO handle incorrect emails better print "Unable to send confirmation message to " + to login(request, authenticate(**form.get_credentials())) return HttpResponseRedirect(redirect_addr) else: form = UserCreateForm() return render(request, "user_management/register.html", { 'form': form, })
def register(request, redirect_addr="/user"): # don't allow logged-in users to register a new account if request.user.is_authenticated and not is_lazy_user(request.user): return HttpResponseRedirect(redirect_addr) if request.method == 'POST': form = UserCreateForm(request.POST, instance=request.user) if form.is_valid(): # save lazy or non-lazy acct if is_lazy_user(form.instance): user = LazyUser.objects.convert(form) else: user = form.save() # create and save corresponding profile prof = Profile(user=user) prof.save() # send basic info email uname = form.cleaned_data['username'] subject, from_email, to = 'Metacademy account successfully created', '*****@*****.**', form.cleaned_data['email'] text_content = TXT_ACCT_EMAIL % uname html_content = HTML_ACCT_EMAIL % uname msg = EmailMultiAlternatives(subject, text_content, from_email, [to]) msg.attach_alternative(html_content, "text/html") try: msg.send() except: # TODO handle incorrect emails better print "Unable to send confirmation message to " + to login(request, authenticate(**form.get_credentials())) return HttpResponseRedirect(redirect_addr) else: form = UserCreateForm() return render(request, "user_management/register.html", { 'form': form, })
def new(request): if not request.user.is_authenticated() or is_lazy_user(request.user): return HttpResponseRedirect(reverse("user:login")) if request.method == 'POST': form = RoadmapForm(request.POST) settings_form = RoadmapSettingsForm(request.POST) is_publish = request.POST["submitbutton"] == "Publish" if form.is_valid() and settings_form.is_valid(): with reversion.create_revision(): roadmap = form.save(commit=False) roadmap.save() reversion.set_user(request.user) rms = settings_form.save(commit=False) if not request.user.is_superuser: rms.sudo_listed_in_main = models.RoadmapSettings._meta.get_field_by_name( 'sudo_listed_in_main')[0].default # TODO hack if is_publish: rms.published = True rms.roadmap = roadmap prof = request.user.profile rms.creator = prof rms.save() rms.owners.add(prof) rms.save() return HttpResponseRedirect( '/roadmaps/%s/%s' % (request.user.username, settings_form.cleaned_data['url_tag'])) else: try: initial_txt = open( os.path.join(os.path.dirname(os.path.realpath(__file__)), "templates/roadmap-instructions.txt")).read() except: sys.stderr.write("unable to open roadmap instructions txt\n") initial_txt = "" form = RoadmapForm(initial={'body': initial_txt}) settings_form = RoadmapSettingsForm() return render(request, 'roadmap-new.html', { 'form': form, 'settings_form': settings_form, 'can_edit': True })
def new(request): if not request.user.is_authenticated() or is_lazy_user(request.user): return HttpResponseRedirect(reverse("user:login")) if request.method == 'POST': form = RoadmapForm(request.POST) settings_form = RoadmapSettingsForm(request.POST) is_publish = request.POST["submitbutton"] == "Publish" if form.is_valid() and settings_form.is_valid(): with reversion.create_revision(): roadmap = form.save(commit=False) roadmap.save() reversion.set_user(request.user) rms = settings_form.save(commit=False) if not request.user.is_superuser: rms.sudo_listed_in_main = models.RoadmapSettings._meta.get_field_by_name('sudo_listed_in_main')[0].default # TODO hack if is_publish: rms.published = True rms.roadmap = roadmap prof = request.user.profile rms.creator = prof rms.save() rms.owners.add(prof) rms.save() return HttpResponseRedirect('/roadmaps/%s/%s' % (request.user.username, settings_form.cleaned_data['url_tag'])) else: try: initial_txt = open(os.path.join(os.path.dirname(os.path.realpath(__file__)), "templates/roadmap-instructions.txt")).read() except: sys.stderr.write("unable to open roadmap instructions txt\n") initial_txt = "" form = RoadmapForm(initial={'body': initial_txt}) settings_form = RoadmapSettingsForm() return render(request, 'roadmap-new.html', { 'form': form, 'settings_form': settings_form, 'can_edit': True })
def new_graph(request): if request.method == "GET": if not request.user.is_authenticated() or is_lazy_user(request.user): return HttpResponseRedirect(reverse("user:login")) concepts = get_user_data(request) used = True while used: gid = ''.join([random.choice(string.lowercase + string.digits) for i in range(8)]) used = len(Graph.objects.filter(id=gid)) > 0 return render(request, "graph-creator.html", {"user_data": json.dumps(concepts), "graph_id": gid, "graph_init_data": {"id": gid}}) else: return HttpResponse(status=405)
def user_main(request): if not request.user.is_authenticated() or is_lazy_user(request.user): return redirect('/user/login?next=%s' % request.path) uprof, created = Profile.objects.get_or_create(pk=request.user.pk) # list graphs they've edited graphs = [gs.graph for gs in uprof.edited_graph.all()] # list concepts they've edited concepts = [cs.concept for cs in uprof.edited_concept.all()] # list roadmaps where the user is listed as an owner roadmaps = [rs.roadmap for rs in uprof.roadmap_owners.all()] # obtain an array of learned concept ids for the user lids = [l.id for l in uprof.learned.all()] sids = [s.id for s in uprof.starred.all()] # FIXME TODO refactor and use the new database if len(lids) > 0: lconcepts = [ Concept.objects.get(id=idval) for idval in lids if Concept.objects.filter(id=idval).exists() ] else: lconcepts = [] if len(sids) > 0: sconcepts = [ Concept.objects.get(id=idval) for idval in sids if Concept.objects.filter(id=idval).exists() ] else: sconcepts = [] return render_to_response('user_management/user.html', { "lconcepts": lconcepts, "sconcepts": sconcepts, "roadmaps": roadmaps, "graphs": graphs, "concepts": concepts }, context_instance=RequestContext(request))
def settings(request, in_username, tag): # check that the user is logged in if not request.user.is_authenticated() or is_lazy_user(request.user): return HttpResponseRedirect(reverse("user:login")) # get the roadmap and settings try: rm_dict = get_roadmap_objs(in_username, tag) except: return HttpResponse(status=404) roadmap = rm_dict["roadmap"] roadmap_settings = rm_dict["settings"] # make sure the user is capable of changing the settings if (not roadmap_settings.can_change_settings(request.user)): return HttpResponse(status=401) if request.method == 'POST': form = RoadmapSettingsForm(request.POST, instance=roadmap_settings) rms_sudo_listed_in_main = roadmap_settings.sudo_listed_in_main if form.is_valid(): rs = form.save(commit=False) if not request.user.is_superuser: rs.sudo_listed_in_main = rms_sudo_listed_in_main rs.save() return HttpResponseRedirect('/roadmaps/%s/%s' % (in_username, form.data['url_tag'])) elif request.method == 'GET': form = RoadmapSettingsForm(instance=roadmap_settings) else: return HttpResponse(status=403) common_rm_dict = get_common_roadmap_dict(roadmap, roadmap_settings, request.user, in_username, tag) return render( request, 'roadmap-settings.html', dict({ 'settings_form': form, 'page_class': "settings", }, **common_rm_dict))
def user_main(request): if not request.user.is_authenticated() or is_lazy_user(request.user): return redirect('/user/login?next=%s' % request.path) uprof, created = Profile.objects.get_or_create(pk=request.user.pk) # list graphs they've edited graphs = [gs.graph for gs in uprof.edited_graph.all()] # list concepts they've edited concepts = [cs.concept for cs in uprof.edited_concept.all()] # list roadmaps where the user is listed as an owner roadmaps = [rs.roadmap for rs in uprof.roadmap_owners.all()] # obtain an array of learned concept ids for the user lids = [l.id for l in uprof.learned.all()] sids = [s.id for s in uprof.starred.all()] # FIXME TODO refactor and use the new database if len(lids) > 0: lconcepts = [Concept.objects.get(id=idval) for idval in lids if Concept.objects.filter(id=idval).exists()] else: lconcepts = [] if len(sids) > 0: sconcepts = [Concept.objects.get(id=idval) for idval in sids if Concept.objects.filter(id=idval).exists()] else: sconcepts = [] return render_to_response('user_management/user.html', { "lconcepts": lconcepts, "sconcepts": sconcepts, "roadmaps": roadmaps, "graphs": graphs, "concepts": concepts }, context_instance=RequestContext(request))
def settings(request, in_username, tag): # check that the user is logged in if not request.user.is_authenticated() or is_lazy_user(request.user): return HttpResponseRedirect(reverse("user:login")) # get the roadmap and settings try: rm_dict = get_roadmap_objs(in_username, tag) except: return HttpResponse(status=404) roadmap = rm_dict["roadmap"] roadmap_settings = rm_dict["settings"] # make sure the user is capable of changing the settings if (not roadmap_settings.can_change_settings(request.user)): return HttpResponse(status=401) if request.method == 'POST': form = RoadmapSettingsForm(request.POST, instance=roadmap_settings) rms_sudo_listed_in_main = roadmap_settings.sudo_listed_in_main if form.is_valid(): rs = form.save(commit=False) if not request.user.is_superuser: rs.sudo_listed_in_main = rms_sudo_listed_in_main rs.save() return HttpResponseRedirect('/roadmaps/%s/%s' % (in_username, form.data['url_tag'])) elif request.method == 'GET': form = RoadmapSettingsForm(instance=roadmap_settings) else: return HttpResponse(status=403) common_rm_dict = get_common_roadmap_dict(roadmap, roadmap_settings, request.user, in_username, tag) return render(request, 'roadmap-settings.html', dict({ 'settings_form': form, 'page_class': "settings", }, **common_rm_dict))
def edit_existing_graph(request, gid): if not request.user.is_authenticated() or is_lazy_user(request.user): return HttpResponseRedirect(reverse("user:login")) return render_graph_view(request, gid, "graph-creator.html")
def test_is_not_lazy(self): is_lazy = is_lazy_user(self.user) self.assertFalse(is_lazy)
def edit_existing_graph(request, gid): if not request.user.is_authenticated() or is_lazy_user(request.user): return HttpResponseRedirect(reverse("user:login")) return render_graph_view(request, gid, "graph-creator.html")
def test_is_lazy(self): is_lazy = is_lazy_user(self.lazy_user) self.assertTrue(is_lazy)