def save(self):
if not self.instance or not self.user:
return
content_type = ContentType.objects.get_for_model(self.instance)
object_id = self.instance.id
text = self.cleaned_data["text"].strip()
if not text:
# Delete note
self.instance.notes.filter(user=self.user).delete()
else:
note, created = Note.objects.get_or_create(
content_type=content_type,
object_id=object_id,
user=self.user)
note.text = text
note.save()
if self.cleaned_data["save_item"]:
SavedItem.objects.get_or_create(content_type=content_type,
object_id=object_id,
user=self.user)
else:
self.instance.saved_items.filter(user=self.user).delete()
reindex(self.instance)
def align(request, app_label, model, object_id):
if request.method != "POST":
raise Http404()
content_type = get_object_or_404(ContentType, app_label=app_label,
model=model)
model = content_type.model_class()
object_id = int(object_id)
item = get_object_or_404(model, id=object_id)
user = request.user
form = TagResourceForm(request.POST, instance=item, user=user)
if form.is_valid():
tagged = form.save()
tag = form.cleaned_data["tag"]
reindex(item)
return dict(status="success",
tag=dict(id=tagged.id, code=tag.full_code,
url=reverse("materials:alignment_index",
kwargs=dict(alignment=tag.full_code))))
else:
return dict(status="error")
def unsave(request, slug=None, model=None):
if not slug or not model:
raise Http404()
item = get_object_or_404(model, slug=slug)
content_type = ContentType.objects.get_for_model(item)
object_id = item.id
try:
SavedItem.objects.get(content_type=content_type,
object_id=object_id,
user=request.user).delete()
reindex(item)
if request.is_ajax():
return JsonResponse(dict(status="success",
message=u"Item was removed from your collection."))
messages.success(request, u"Item was removed from your collection.")
except SavedItem.DoesNotExist:
pass
return redirect_to_next_url(request, item.get_absolute_url())
def post(self, request, *args, **kwargs):
evaluation = get_object_or_None(
Evaluation,
content_type=self.content_type,
object_id=self.object.id,
user=self.request.user,
)
if not evaluation:
return redirect("rubrics:evaluate_rubrics",
kwargs=dict(
content_type_id=self.content_type.id,
object_id=self.object.id,
))
evaluation.confirmed = True
evaluation.save()
reindex(self.object)
return redirect("rubrics:evaluate_results",
content_type_id=self.content_type.id,
object_id=self.object.id,
)
def add(request, app_label, model, object_id):
content_type = get_object_or_404(ContentType, app_label=app_label,
model=model)
model = content_type.model_class()
object_id = int(object_id)
item = get_object_or_404(model, id=object_id)
user = request.user
new_tags = []
if request.method == "POST":
tags = [t.strip() for t in request.POST.get("tags", u"").split(u",")]
for tag in tags:
if not item.tags.filter(user=user, slug=slugify(tag)).count():
tag = Tag(content_type=content_type, object_id=object_id,
user=user, name=tag)
tag.save()
new_tags.append(tag)
reindex(item)
response = {"tags": []}
for tag in new_tags:
response["tags"].append(dict(name=tag.name,
id=tag.id,
url=reverse("materials:keyword_index",
kwargs={"keywords": tag.slug}),
))
return response
def save(self):
if not self.instance or not self.user:
return
content_type = ContentType.objects.get_for_model(self.instance)
object_id = self.instance.id
rating = self.cleaned_data["number"].strip()
if rating == "delete":
# Delete rating
self.instance.ratings.filter(user=self.user).delete()
else:
try:
rating_obj = Rating.objects.get(
content_type=content_type,
object_id=object_id,
user=self.user
)
rating_obj.value = int(rating)
rating_obj.save()
except Rating.DoesNotExist:
rating_obj = Rating(content_type=content_type,
object_id=object_id,
user=self.user,
value=int(rating))
rating_obj.save()
reindex(self.instance)
def save(request):
content_type_id, object_id = request.POST["identifier"].split(".")
content_type = get_object_or_404(ContentType, id=content_type_id)
item = get_object_or_404(content_type.model_class(), id=object_id)
SavedItem.objects.get_or_create(content_type=content_type,
object_id=object_id,
user=request.user)
reindex(item)
return dict(status="success",
message=u"Item was saved in your collection.")
def save(self):
if not self.instance or not self.user:
return
content_type = ContentType.objects.get_for_model(self.instance)
object_id = self.instance.id
existing_tags = Tag.objects.filter(user=self.user, content_type=content_type, object_id=object_id)
existing_tag_names = existing_tags.values_list("name", flat=True)
for tag in self.cleaned_data["tags"]:
if tag not in existing_tag_names:
Tag(content_type=content_type, object_id=object_id, user=self.user, name=tag).save()
reindex(self.instance)
def post(self, request, *args, **kwargs):
try:
folder = Folder.objects.get(
user=request.user,
id=request.REQUEST["id"]
)
except Folder.DoesNotExist:
pass
else:
items = set(x.content_object for x in folder.folderitem_set.all())
folder.delete()
for item in items:
reindex(item)
return { "status": "success" }
def unsave(request):
content_type_id, object_id = request.POST["identifier"].split(".")
content_type = get_object_or_404(ContentType, id=content_type_id)
item = get_object_or_404(content_type.model_class(), id=object_id)
try:
SavedItem.objects.get(content_type=content_type,
object_id=object_id,
user=request.user).delete()
reindex(item)
except SavedItem.DoesNotExist:
pass
return dict(status="success",
message=u"Item was removed from your collection.")
def post(self, request, *args, **kwargs):
try:
folder_id = request.REQUEST["folder_id"]
item_id = request.REQUEST["item_id"]
except KeyError:
return { "status": "error" }
folder = Folder.objects.get(
user=request.user,
id=folder_id
)
material = get_material_object_or_404(*item_id.split('.'))
material.folders.filter(folder=folder).delete()
reindex(material)
to_return = { "status": "success" }
return to_return
def forwards(self, orm):
# Remove duplicated ratings, keep the most recent rating.
prev = None
for rating in orm.Rating.objects.all().select_related().order_by(
"content_type", "object_id", "user", "-timestamp"):
k = (rating.content_type, rating.object_id, rating.user)
if k == prev:
content_type = orm["contenttypes.ContentType"].objects.get(id=rating.content_type_id)
model = models.get_model(content_type.app_label, content_type.model)
item = model.objects.get(id=rating.object_id)
reindex(item)
print "Removing rating for ", unicode(item)
rating.delete()
prev = k
# Adding unique constraint on 'Rating', fields ['object_id', 'content_type', 'user']
db.create_unique('rating_rating', ['object_id', 'content_type_id', 'user_id'])
def post(self, request, *args, **kwargs):
result = dict(status="error")
try:
id = int(request.POST["id"])
except (KeyError, ValueError, TypeError):
return result
evaluation = get_object_or_None(Evaluation, id=id)
if not evaluation:
return result
object = evaluation.content_object
evaluation.delete()
reindex(object)
result["status"] = "success"
return result
def post(self, request, *args, **kwargs):
try:
folder_name = request.REQUEST["folder_name"]
item_id = request.REQUEST["item_id"]
except KeyError:
return { "status": "error"}
content_type, object_id = item_id.split('.')
material = get_material_object_or_404(content_type, object_id)
folder, created = Folder.objects.get_or_create(
user=request.user,
name=folder_name
)
if isinstance(material, Material):
creator = material.creator
elif isinstance(material, AuthoredMaterial):
creator = material.author
elif isinstance(material, AuthoredMaterialDraft):
creator = material.material.author
else:
assert False, type(material)
content_type = ContentType.objects.get_for_id(content_type)
if creator != request.user:
SavedItem.objects.get_or_create(
user=request.user,
content_type=content_type,
object_id=object_id
)
_, created_fi = FolderItem.objects.get_or_create(
folder=folder,
content_type=content_type,
object_id=object_id
)
reindex(material)
if not created_fi:
return { "status": "error" }
to_return = { "status": "success" }
if created:
to_return["id"] = folder.id
to_return["slug"] = folder.slug
return to_return
def delete(request):
response = {}
if request.method == "POST":
try:
id = int(request.POST.get("id"))
except:
id = None
if id:
try:
tag = Tag.objects.get(id=id, user=request.user)
item = tag.content_object
tag.delete()
reindex(item)
except Tag.DoesNotExist:
pass
return response
def reindex_microsite_topic(topic):
from haystack.query import SearchQuerySet
objects = set()
# get all objects from this topic and all objects with this topic's keywords
query = "indexed_topics:%s" % topic.id
for result in SearchQuerySet().narrow(query).load_all():
objects.add(result.object)
topic_keywords = topic.keywords.values_list("slug", flat=True)
microsite_keywords = topic.microsite.keywords.values_list("slug", flat=True)
if topic_keywords and microsite_keywords:
query = SearchQuerySet()
query = query.narrow("keywords(%s)" % " OR ".join(["%s" % kw for kw in topic_keywords]))
query = query.narrow("keywords(%s)" % " OR ".join(["%s" % kw for kw in microsite_keywords]))
for result in query.load_all():
objects.add(result.object)
for instance in objects:
reindex(instance)
def save(request, slug=None, model=None):
""" Save item if it isn't saved.
Unsave item if it's saved. """
if not slug or not model:
raise Http404()
item = get_object_or_404(model, slug=slug)
content_type = ContentType.objects.get_for_model(item)
object_id = item.id
SavedItem.objects.get_or_create(content_type=content_type,
object_id=object_id,
user=request.user)
reindex(item)
if request.is_ajax():
return JsonResponse(dict(status="success",
message=u"Item was saved in your collection."))
messages.success(request, u"Item was saved in your collection.")
return redirect_to_next_url(request, item.get_absolute_url())
def post(self, request, *args, **kwargs):
try:
item_id = request.REQUEST["item_id"]
except KeyError:
return { "status": "error"}
material = get_material_object_or_404(*item_id.split('.'))
if isinstance(material, Material):
creator = material.creator
elif isinstance(material, AuthoredMaterial):
creator = material.author
elif isinstance(material, AuthoredMaterialDraft):
creator = material.material.author
else:
assert False, type(material)
if creator == request.user:
material.delete()
else:
material.saved_items.filter(user=request.user).delete()
reindex(material)
to_return = { "status": "success" }
return to_return
def reindex(cls):
search.reindex(cls)
def post(self, request, *args, **kwargs):
self.form = ValidateCSVForm(request.POST, request.FILES)
if not self.form.is_valid():
messages.error(request, u"Data is not valid, see below.")
return self.get(request, *args, **kwargs)
if self.form.validation_errors:
self.validation_errors = self.form.validation_errors
messages.error(request, u"Data is not valid, see below.")
return self.get(request, *args, **kwargs)
if "validate" in request.REQUEST:
messages.success(request, u"Data appears to be valid.")
return self.get(request, *args, **kwargs)
model = self.form.model
if model == Course:
field_name_prefix = "CR_"
simple_fields = SIMPLE_FIELDS + COURSE_SIMPLE_FIELDS
m2m_fields = M2M_FIELDS + COURSE_M2M_FIELDS
elif model == Library:
field_name_prefix = "LIB_"
simple_fields = SIMPLE_FIELDS + LIBRARY_SIMPLE_FIELDS
m2m_fields = M2M_FIELDS + LIBRARY_M2M_FIELDS
authors_field = None
keywords_field = None
for field in model._meta.many_to_many:
if field.name == "authors":
authors_field = field
elif field.name == "keywords":
keywords_field = field
institution_field = None
collection_field = None
license_field = None
prerequisite_1_field = None
prerequisite_2_field = None
postrequisite_1_field = None
postrequisite_2_field = None
derived_from_field = None
for field in model._meta.fields:
if field.name == "institution":
institution_field = field
elif field.name == "collection":
collection_field = field
elif field.name == "license":
license_field = field
elif field.name == "prerequisite_1":
prerequisite_1_field = field
elif field.name == "prerequisite_2":
prerequisite_2_field = field
elif field.name == "postrequisite_1":
postrequisite_1_field = field
elif field.name == "postrequisite_2":
postrequisite_2_field = field
elif field.name == "derived_from":
derived_from_field = field
imported_objects = []
for row_index, row in enumerate(self.form.csv_data):
data = {}
for field_index, value in enumerate(row):
field_name = self.form.header[field_index][len(field_name_prefix):]
data[field_name] = value
try:
check_for_unique_url = True
try:
obj = model.objects.get(url=data["URL"])
new_url = data.get("NEW_URL")
if new_url:
obj.url = new_url
else:
check_for_unique_url = False
except MultipleObjectsReturned:
self.validation_errors.append(
(row_index + 1, u"", u"URL '%s' is registered multiple times, can't find an object to update." % data["URL"])
)
continue
except model.DoesNotExist:
obj = model(creator=request.user)
obj.url = data["URL"]
obj.workflow_state = IMPORTED_STATE
# Do not re-index the object until the transaction is finished
obj.skip_indexing = True
if check_for_unique_url and model.objects.filter(url=obj.url).exists():
self.validation_errors.append(
(row_index + 1, u"", u"URL '%s' is registered in database already." % obj.url)
)
continue
for csv_field_name, obj_field_name in simple_fields:
if csv_field_name in data:
setattr(obj, obj_field_name, data[csv_field_name])
if institution_field and "INSTITUTION" in data:
institution_field.save_form_data(obj, dict(name=data["INSTITUTION"]))
if collection_field and "COLLECTION" in data:
collection_field.save_form_data(obj, dict(name=data["COLLECTION"]))
if license_field and ("COU_TITLE" in data or "COU_URL" in data):
url = data.get("COU_URL", u"")
name = data.get("COU_TITLE", u"")
if url:
if CC_LICENSE_URL_RE.match(url):
name = License.objects.get_cc_license_name_from_url(url)
elif PUBLIC_DOMAIN_URL_RE.match(url):
name = PUBLIC_DOMAIN_NAME
elif GNU_FDL_URL_RE.match(url):
name = GNU_FDL_NAME
description = data.get("COU_DESCRIPTION", u"")
copyright_holder = data.get("COU_COPYRIGHT_HOLDER", u"")
license_field.save_form_data(obj,
dict(url=url, name=name, description=description,
copyright_holder=copyright_holder)
)
if prerequisite_1_field and "PREREQ_TITLE1" in data:
title = data["PREREQ_TITLE1"]
if title:
url = data.get("PREREQ_URL1", u"")
prerequisite_1_field.save_form_data(obj,
dict(title=title, url=url)
)
else:
obj.prerequisite_1 = None
if prerequisite_2_field and "PREREQ_TITLE2" in data:
title = data["PREREQ_TITLE2"]
if title:
url = data.get("PREREQ_URL2", u"")
prerequisite_2_field.save_form_data(obj,
dict(title=title, url=url)
)
else:
obj.prerequisite_2 = None
if postrequisite_1_field and "POSTREQ_TITLE1" in data:
title = data["POSTREQ_TITLE1"]
if title:
url = data.get("POSTREQ_URL1", u"")
postrequisite_1_field.save_form_data(obj,
dict(title=title, url=url)
)
else:
obj.postrequisite_1 = None
if postrequisite_2_field and "POSTREQ_TITLE2" in data:
title = data["POSTREQ_TITLE2"]
if title:
url = data.get("POSTREQ_URL2", u"")
postrequisite_2_field.save_form_data(obj,
dict(title=title, url=url)
)
else:
obj.postrequisite_2 = None
if derived_from_field:
if data.get("PARENT_MODIFIED") == False:
obj.derived_from = None
else:
title = data.get("PARENT_TITLE", u"")
if not title:
obj.derived_from = None
else:
url = data.get("PARENT_URL", u"")
description = data.get("PARENT_CHANGES", u"")
derived_from_field.save_form_data(obj,
dict(title=title, url=url, description=description)
)
obj.save()
for csv_field_name, obj_field_name, field_model, field_model_key in m2m_fields:
if csv_field_name in data:
field = getattr(obj, obj_field_name)
field.clear()
for value in data[csv_field_name]:
field.add(field_model.objects.get(**{field_model_key: value}))
if authors_field and "AUTHOR_NAME" in data:
author_names = data["AUTHOR_NAME"]
author_emails = data.get("AUTHOR_EMAIL", [])
author_countries = data.get("AUTHOR_COUNTRY", [])
obj.authors.clear()
authors_data = []
for i, name in enumerate(author_names):
try:
email = author_emails[i]
except IndexError:
email = u""
try:
country = Country.objects.get(slug=author_countries[i])
except IndexError:
country = None
authors_data.append(dict(name=name, email=email,
country=country))
authors_field.save_form_data(obj, authors_data)
if keywords_field and "KEYWORDS" in data:
obj.keywords.clear()
keywords_data = []
for name in data["KEYWORDS"]:
keywords_data.append(dict(name=name))
keywords_field.save_form_data(obj, keywords_data)
imported_objects.append(obj)
except:
transaction.rollback()
if settings.DEBUG:
raise
self.validation_errors.append(
(row_index + 1, u"", unicode(sys.exc_info()[1]))
)
if self.validation_errors:
transaction.rollback()
self.is_valid = False
messages.error(request, u"There were some errors, see below.")
else:
if "dry_run" in request.REQUEST:
transaction.rollback()
messages.success(request, u"Data appears to be valid. "
"It is not imported because 'Dry run' option is selected.")
else:
transaction.commit()
for object in imported_objects:
object.skip_indexing = False
reindex(object)
transaction.commit()
messages.success(request, u"Data was imported successfully.")
return self.get(request, *args, **kwargs)
def review_post_delete(sender, **kwargs):
instance = kwargs["instance"]
content_object = instance.content_object
reindex(content_object)
def check_url_status(item):
status_code = get_url_status_code(item.url)
if item.http_status != status_code:
update_item(item, http_status=status_code)
reindex(item)
def post(self, request, *args, **kwargs):
evaluation = get_object_or_None(
Evaluation,
content_type=self.content_type,
object_id=self.object.id,
user=request.user,
)
if not evaluation:
return HttpResponseBadRequest()
delete = "delete" in request.POST
score_value_id = None
if not delete:
score_value_id = request.POST.get("score_id")
try:
score_value_id = int(score_value_id)
except (TypeError, ValueError):
return HttpResponseBadRequest()
tag_id = request.POST.get("tag_id")
rubric_id = request.POST.get("rubric_id")
comment = request.POST.get("comment", u"").strip()
if self.enable_alignment_scores and tag_id:
try:
tag_id = int(tag_id)
except (TypeError, ValueError):
return HttpResponseBadRequest()
tag = get_object_or_None(AlignmentTag, id=tag_id)
if not tag:
return HttpResponseBadRequest()
if delete:
StandardAlignmentScore.objects.filter(
evaluation=evaluation,
alignment_tag=tag,
).delete()
else:
score_value = get_object_or_None(StandardAlignmentScoreValue,
id=score_value_id)
if not score_value:
return HttpResponseBadRequest()
score, created = StandardAlignmentScore.objects.get_or_create(
evaluation=evaluation,
alignment_tag=tag,
defaults=dict(score=score_value, comment=comment)
)
if not created:
score.score = score_value
score.comment = comment
score.save()
if rubric_id:
try:
rubric_id = int(rubric_id)
except (TypeError, ValueError):
return HttpResponseBadRequest()
rubric = get_object_or_None(Rubric, id=rubric_id)
if not rubric:
return HttpResponseBadRequest()
if delete:
RubricScore.objects.filter(
evaluation=evaluation,
rubric=rubric
).delete()
else:
score_value = get_object_or_None(RubricScoreValue,
id=score_value_id)
if not score_value:
return HttpResponseBadRequest()
score, created = RubricScore.objects.get_or_create(
evaluation=evaluation,
rubric=rubric,
defaults=dict(score=score_value, comment=comment)
)
if not created:
score.score = score_value
score.comment = comment
score.save()
evaluation.confirmed = False
evaluation.save()
reindex(self.object)
return dict(status="success")
def post(self, request, *args, **kwargs):
result = dict(status="error")
try:
id = int(request.POST["id"])
except (KeyError, ValueError, TypeError):
return result
evaluation = get_object_or_None(Evaluation, id=id)
if not evaluation:
return result
data = []
for rubric in Rubric.objects.all():
#noinspection PyTypeChecker
k = "r%i" % (rubric.id + 1)
if k in request.POST:
value = request.POST[k].strip() or None
if value is not None:
try:
value = int(value)
except (TypeError, ValueError):
continue
value = get_object_or_None(
RubricScoreValue,
rubric=rubric,
value=value
)
if not value:
continue
data.append((rubric, value))
if not data:
return result
object = evaluation.content_object
for rubric, value in data:
score = get_object_or_None(
RubricScore,
evaluation=evaluation,
rubric=rubric
)
if score:
score.score = value
score.save()
else:
RubricScore.objects.create(
evaluation=evaluation,
rubric=rubric,
score=value,
)
reindex(object)
result["status"] = "success"
return result
