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)
