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