def edit_mpa(request, pk): mpa = get_object_or_404(Mpa, pk=pk) if (request.POST): # Got a form submission editform = MpaForm(request.POST, instance=mpa) if editform.is_valid(): mpasaved = editform.save() try: reversion.set_comment(editform.cleaned_data.get("edit_comment")) except: pass try: reversion.set_user(request.user) except: pass try: reversion.add_meta(VersionMetadata, comment=editform.cleaned_data.get("edit_comment"), reference=editform.cleaned_data.get("edit_reference")) except: pass return HttpResponseRedirect(reverse('mpa-siteinfo', kwargs={'pk': pk})) else: editform = MpaForm(instance=mpa) return render_to_response('mpa/Mpa_editform.html', { 'form': editform, 'mpa': mpa, 'respond_url': reverse('mpa-editsite', kwargs={'pk': pk}), }, context_instance=RequestContext(request))
def obj_create(self, bundle, **kwargs): ''' created objects should automatically have a status of Human Created ''' status_update = StatusUpdate.objects.get(status_en='Human Created') username = bundle.request.GET['username'] user = User.objects.filter(username=username)[0] status_id = status_update.id if can_assign_users(user) is False and 'assigned_user' in bundle.data: del(bundle.data['assigned_user']) comment_uri = self.create_comment( bundle.data['comment'], status_id, user ) bundle.data['actor_comments'] = [ comment_uri ] with reversion.create_revision(): bundle = super(ActorResource, self)\ .obj_create(bundle, **kwargs) reversion.add_meta( VersionStatus, status='created', user=user ) reversion.set_user(user) reversion.set_comment(bundle.data['comment']) update_object.delay(username) return bundle
def make_profile(backend, user, response, is_new=False, *args, **kwargs): if is_new: if not hasattr(user, "profile"): profile = Profile(user=user) profile.language = Language.get_python2() if backend.name == "google-oauth2": profile.name = response["displayName"] elif backend.name in ("github", "facebook") and "name" in response: profile.name = response["name"] else: logger.info("Info from %s: %s", backend.name, response) profile.save() form = ProfileForm(instance=profile, user=user) else: data = backend.strategy.request_data() logger.info(data) form = ProfileForm(data, instance=user.profile, user=user) if form.is_valid(): with transaction.atomic(), revisions.create_revision(): form.save() revisions.set_user(user) revisions.set_comment("Updated on registration") return return render( backend.strategy.request, "registration/profile_creation.jade", {"title": "Create your profile", "form": form}, )
def editInclusionOrder(request, dss_id, inc_type): if inc_type not in ['cluster', 'data_element']: raise Http404 item = get_object_or_404(aristotle_dse.models.DataSetSpecification, pk=dss_id) if not user_can_edit(request.user, item): if request.user.is_anonymous(): return redirect(reverse('friendly_login') + '?next=%s' % request.path) else: raise PermissionDenied item_type, field_name = { 'cluster': (aristotle_dse.models.DSSClusterInclusion, 'child'), 'data_element': (aristotle_dse.models.DSSDEInclusion, 'data_element'), }.get(inc_type) num_values = item_type.objects.filter(dss=item.id).count() if num_values > 0: extra = 0 else: extra = 1 ValuesFormSet = modelformset_factory( item_type, formset=HiddenOrderModelFormSet, can_order=True, fields=('id',), extra=extra ) if request.method == 'POST': formset = ValuesFormSet(request.POST, request.FILES) if formset.is_valid(): with transaction.atomic(), reversion.create_revision(): item.save() # do this to ensure we are saving reversion records for the DSS, not just the values formset.save(commit=False) for form in formset.forms: if form['id'].value() not in [deleted_record['id'].value() for deleted_record in formset.deleted_forms]: inc = item_type.objects.get(pk=form['id'].value()) if inc.dss != item: raise PermissionDenied inc.order = form['ORDER'].value() # inc.maximum_occurances = form['maximum_occurances'].value() # value = form.save(commit=False) #Don't immediately save, we need to attach the value domain # value.dss = item inc.save() for obj in formset.deleted_objects: obj.delete() reversion.set_user(request.user) reversion.set_comment(construct_change_message(request, None, [formset, ])) return redirect(reverse("aristotle_mdr:item", args=[item.id])) else: formset = ValuesFormSet( queryset=item_type.objects.filter(dss=item.id), ) return render( request, "aristotle_dse/actions/edit_inclusion_order.html", {'item': item, 'formset': formset, 'include_type': inc_type, 'value_model': item_type, } )
def update_entities(model_dict, model_objects, appendable_keys): ''' model_dict is the key value store of updated elements model_objects are the models, these can be of type Actor, Bulletin or Incident delegates actual updating of fields to update_entity where the field is to be replaced and to update_entity_appendable where the field is to be added to ''' appendable_dict, remainder_dict = separate_field_types( model_dict, appendable_keys) for model in model_objects: model_dict_copy = remainder_dict.copy() model_dict_copy = update_related_actors(model_dict_copy, model) model = update_entity_appendable(appendable_dict, model) model = update_entity_status(model_dict, model) model = update_entity(model_dict_copy, model) user = model_dict['user'] with reversion.create_revision(): model.save() reversion.add_meta( VersionStatus, status='edited', user=user ) reversion.set_user(user) comment_text = model_dict['comment'] reversion.set_comment(comment_text)
def change_mark(request, slug): if request.method == "POST": data = json.loads(request.body.decode("utf-8")) grade_system = data.get("grade_system") pk = data.get("pk") new_comment = data.get("comment") new_mark = data.get("mark") if grade_system is not None and pk is not None and new_mark is not None: with reversion.create_revision(): mark, old_mark = MarkAPI.set_mark(grade_system, pk, new_mark) if mark.problem: assignment_hierarchy = "{0:s}/{1:s}/{2:s}".format( mark.problem.task.assignment.name, mark.problem.task.name, mark.problem.name ) elif mark.task: assignment_hierarchy = "{0:s}/{1:s}".format(mark.task.assignment.name, mark.task.name) else: assignment_hierarchy = "{0:s}".format(mark.assignment.name) reversion.set_user(request.user) reversion.set_comment( """Mark for '{0:s}' student, for '{1:s}' assignment was changed from '{2:d}' to '{3:d}' by '{4:s}' user """.format( mark.student.username, assignment_hierarchy, old_mark, mark.mark, request.user.username ) ) if grade_system is not None and pk is not None and new_comment is not None: MarkAPI.set_comment(grade_system, pk, new_comment) return HttpResponse()
def post(self, request, *args, **kwargs): if not request.user.is_authenticated(): raise Exception("Not logged in! Only staff have access to this function") if not request.user.is_staff and not request.user.is_superuser: raise Exception("Only staff have access to this function") keys = [('location', Location), ('time_block', TimeBlock), ('time_slot', TimeSlot)] key_text = 0 key_db_object = 1 game_id = request.POST.get('id') game = Game.objects.get(id=game_id) changed = [] for key in keys: incoming_id = request.POST.get(key[key_text]) old = getattr(game, key[key_text]) new = key[key_db_object].objects.get(id=incoming_id) if incoming_id else None setattr(game, key[key_text], new) if old != new: changed.append(key[key_text]) changed.sort() game.last_scheduled = timezone.now() with reversion.create_revision(): reversion.set_user(request.user) reversion.set_comment("AJAX Schedule Submission - %s Changed" % ", ".join(changed)) game.save()
def post(self, request, *args, **kwargs): if "room" in request.POST: if request.POST["room"] != "" and request.POST["room"] != 0: roomid = request.POST["room"][0] room = get_object_or_404(Room, pk=roomid) else: room = None else: room = None response = super(DeviceApiLend, self).post(request) if request.POST["device"] != "" and response.status_code == 201: device = Device.objects.get(pk=request.POST["device"]) device.currentlending = self.object if room: device.room = room reversion.set_user(request.user) reversion.set_comment("Device marked as lend") try: template = MailTemplate.objects.get(usage="room") except: template = None if not template == None: recipients = [] for recipient in template.default_recipients.all(): recipient = recipient.content_object if isinstance(recipient, Group): recipients += recipient.lageruser_set.all().values_list("email")[0] else: recipients.append(recipient.email) template.send(self.request, recipients, {"device": device, "user": self.request.user}) reversion.set_ignore_duplicates(True) device.save() return response
def create(self, validated_data): request = self.context['request'] venue_id = validated_data['venue'] slots = validated_data['slots'] talk = validated_data.get('talk') page = validated_data.get('page') try: existing_schedule_item = ScheduleItem.objects.get( venue_id=venue_id, slots__in=slots) except ScheduleItem.DoesNotExist: revisions.set_user(request.user) revisions.set_comment("Created using Schedule Editor") else: existing_schedule_item.talk = talk existing_schedule_item.page = page existing_schedule_item.slots = slots # Clear any existing details that aren't editable by the # schedule edit view existing_schedule_item.details = '' existing_schedule_item.notes = '' existing_schedule_item.css_class = '' existing_schedule_item.expand = False existing_schedule_item.save() revisions.set_user(request.user) revisions.set_comment("Updated using Schedule Editor") return existing_schedule_item return super(ScheduleItemSerializer, self).create(validated_data)
def get(self, request, attendance_id): a = get_object_or_404(Attendance, pk=attendance_id) with transaction.atomic(), reversion.create_revision(): a.rotate() reversion.set_user(request.user) reversion.set_comment("Rotating by %s" % request.user) return HttpResponseRedirect(reverse('training:course', args=[a.clazz.course.id]))
def set_denied(self, actor): if not self.can_deny(actor): raise PermissionDenied with DoAction() as action, reversion.create_revision(): self.state = STATE_DENIED self.save() revisions.set_user(actor) action.set(actor=actor, verb='denied trip request', target=self, state=STATE_DENIED, style='trip-denied')
def set_completed(self, actor): if not self.can_complete(actor): raise PermissionDenied with DoAction() as action, reversion.create_revision(): self.state = STATE_COMPLETED self.save() revisions.set_user(actor) action.set(actor=actor, verb='completed trip', target=self, state=STATE_CLOSED, style='trip-completed')
def set_open(self, actor): if not self.can_open(actor): raise PermissionDenied with DoAction() as action, reversion.create_revision(): self.state = STATE_OPEN self.save() revisions.set_user(actor) action.set(actor=actor, verb='opened trip', target=self, state=STATE_OPEN, style='trip-opened')
def set_cancelled(self, actor): if not self.can_cancel(actor): raise PermissionDenied with DoAction() as action, reversion.create_revision(): self.state = STATE_CANCELLED self.save() revisions.set_user(actor) action.set(actor=actor, verb='cancelled trip', target=self, state=STATE_CANCELLED, style='trip-cancelled')
def get(self, request, course_id, clazz_id, attendance_status): c1 = get_object_or_404(Course, pk=course_id) c2 = get_object_or_404(Class, pk=clazz_id) with transaction.atomic(), reversion.create_revision(): Attendance.attendance_all_set_status(c1, c2, attendance_status) reversion.set_user(request.user) reversion.set_comment("Setting to %s by %s" % (attendance_status, request.user)) return HttpResponseRedirect(reverse('training:course', args=[course_id]))
def done(self, form_list, **kwargs): reversion.set_user(self.request.user) reversion.set_comment("Added via concept wizard") item = None for form in form_list: item = form.save() return HttpResponseRedirect(url_slugify_concept(item))
def setUp(self): self.user = mommy.make(UserProfile, is_superuser=True) document = mommy.prepare(InformationDocument, text="text") with transaction.atomic(), revisions.create_revision(): document.save() revisions.set_user(self.user) revisions.set_comment('test version')
def save(self, **kwargs): if kwargs.pop('no_revision', False): super(RevisionedMixin, self).save(**kwargs) else: with revisions.create_revision(): revisions.set_user(kwargs.pop('version_user', None)) revisions.set_comment(kwargs.pop('version_comment', '')) super(RevisionedMixin, self).save(**kwargs)
def create_revision(self, bundle, user, status_update): with reversion.create_revision(): reversion.set_user(user) reversion.set_comment(bundle.data['comment']) reversion.add_meta( VersionStatus, status=status_update, user=user )
def wrapped(self, request, *args, **kwargs): with reversion.create_revision(): ret = fn(self, request, *args, **kwargs) reversion.set_user(request.user) reversion.add_meta(RevisionProject, project=request.project) if getattr(self, 'log_obj', None): reversion.add_meta(RevisionLogActivity, log_activity=self.log_obj) return ret
def setUp(self): self.user = mommy.make(UserProfile, is_superuser=True) self.document = mommy.prepare(InformationDocument) with transaction.atomic(), revisions.create_revision(): self.document.save() revisions.set_user(self.user) revisions.set_comment('test version') self.document.set_all_permissions(mommy.make(Group))
def handle_edit(request, document, formset=None, initial=None): if request.method == 'POST': creation = document.is_in_creation form = document.Form(request.POST, instance=document, initial=initial, user=request.user, creation=creation) if form.is_valid() and (formset is None or formset.is_valid()): cleaned_data = form.cleaned_data document.url_title = cleaned_data['url_title'] # save the document and also save the user and the comment the user added with transaction.atomic(), revisions.create_revision(): document.handle_edit(cleaned_data) document.save() document.save_formset(formset) revisions.set_user(request.user) revisions.set_comment(cleaned_data['comment']) if not document.has_perms() or creation: document.set_all_permissions(cleaned_data['group']) # delete Autosave try: autosave = TemporaryDocumentText.objects.get(document=document) autosave.delete() except TemporaryDocumentText.DoesNotExist: pass return True, form else: # load Autosave autosave = None try: autosave = TemporaryDocumentText.objects.get(document=document) autosaved = True except TemporaryDocumentText.DoesNotExist: autosaved = False if 'restore' in request.GET: autosaved = False if 'restore' in request.GET and autosave is not None: form_data = { 'text': autosave.text, 'url_title': document.url_title, } if initial is None: initial = {} initial.update(form_data) form = document.Form(initial=initial, instance=document, user=request.user, creation=document.is_in_creation) form.autosave = autosaved if autosaved: form.autosave_date = autosave.created return False, form
def obj_update(self, bundle, **kwargs): username = bundle.request.GET['username'] user = User.objects.filter(username=username)[0] bundle.data['id'] = kwargs['pk'] if self.can_edit(user, bundle, Actor) is False: raise ImmediateHttpResponse( HttpForbidden('You do not have permission to edit this entity') ) if self.is_finalized( Actor, kwargs['pk'], 'most_recent_status_actor' ) and can_finalize(user) is False: raise ImmediateHttpResponse( HttpForbidden('This item has been finalized') ) if can_assign_users(user) is False and 'assigned_user' in bundle.data: del(bundle.data['assigned_user']) status_id = self.id_from_url(bundle.data) status_update = StatusUpdate.filter_by_perm_objects.get_update_status( user, status_id ) comment_uri = self.create_comment( bundle.data['comment'], status_update.id, user ) if "condition" not in bundle.data: bundle.data['condition'] = None if "POB" not in bundle.data: bundle.data['POB'] = None if "current_location" not in bundle.data: bundle.data['current_location'] = None try: bundle.data['actor_comments'].append(comment_uri) except KeyError: bundle.data['actor_comments'] = [comment_uri, ] with reversion.create_revision(): bundle = super(ActorResource, self)\ .obj_update(bundle, **kwargs) reversion.add_meta( VersionStatus, status='edited', user=user ) reversion.set_user(user) reversion.set_comment(bundle.data['comment']) update_object.delay(username) return bundle
def revert(request): if not request.is_ajax() or not request.POST: raise Http404 version_id = request.POST['id'] document_url_title = request.POST['url_title'] document = get_object_or_404(Document, url_title=document_url_title) check_permissions(document, request.user, [document.edit_permission_name]) versions = revisions.get_for_object(document) if not document.can_be_reverted: raise SuspiciousOperation('This Document can not be reverted!') # find the we want to revert to revert_version = None for version in versions: if version.pk == int(version_id): revert_version = version break if revert_version is None: # user supplied version_id that does not exist raise SuspiciousOperation('Could not find document') revert_version.revision.revert(delete=False) fields = revert_version.field_dict document_class = ContentType.objects.get_for_id(fields.pop('polymorphic_ctype')).model_class() # Remove all references to parent objects, rename ForeignKeyFields, extract ManyToManyFields. new_fields = fields.copy() many_to_many_fields = {} for key in fields.keys(): if "_ptr" in key: del new_fields[key] continue if hasattr(document_class, key): field = getattr(document_class, key).field if isinstance(field, models.ManyToManyField): many_to_many_fields[key] = fields[key] else: new_fields[field.attname] = fields[key] del new_fields[key] reverted_document = document_class(**new_fields) with transaction.atomic(), revisions.create_revision(): reverted_document.save() # Restore ManyToManyFields for key in many_to_many_fields.keys(): getattr(reverted_document, key).clear() getattr(reverted_document, key).add(*many_to_many_fields[key]) revisions.set_user(request.user) revisions.set_comment( _('reverted to revision \"{revision_comment}\"'.format(revision_comment=revert_version.revision.comment))) return HttpResponse(reverse('versions', args=[reverted_document.url_title]))
def setUpTestData(cls): cls.user = mommy.make(UserProfile, is_superuser=True) cls.document = mommy.prepare(InformationDocument) with transaction.atomic(), revisions.create_revision(): cls.document.save() revisions.set_user(cls.user) revisions.set_comment('test version') cls.group = mommy.make(Group) cls.user.groups.add(cls.group) cls.document.set_all_permissions(mommy.make(Group)) assign_perm("information_pages.add_informationdocument", cls.group)
def form_valid(self, form): # since the form doesn't have the user or time, we need to insert it form.instance.user = self.request.user form.instance.last_modified = timezone.now() with reversion.create_revision(): reversion.set_user(self.request.user) reversion.set_comment("Form Submission - New") result = super(NewGameView, self).form_valid(form) self.send_email() return result
def mark_as_used(self, user=None, comment='', subscription=None): if not self.used: with transaction.atomic(), reversion.create_revision(): self.used = True self.subscription = subscription # which subscription was paid self.save() if user is not None and not user.is_anonymous(): reversion.set_user(user) reversion.set_comment('Marked as used. ' + comment) return True else: return False
def post(self, request, pk, *args, **kwargs): reversion.set_user(request.user) if self.commission.locked: self.response = redirect('Coms:Detail:Done', pk=pk) form = DetailForm(request.POST, instance=self.commission) contactformset = self.contactfactory(request.POST) if contactformset.is_valid() and form.is_valid(): form.instance.contacts = contactformset.save() form.instance.submitted = True detail = form.save() self.response = redirect("{0}#{1}".format(reverse('Coms:commissions'), detail.id)) self.context.update({'form': form, 'contactformset': contactformset})
def obj_update(self, bundle, **kwargs): username = bundle.request.GET['username'] user = User.objects.filter(username=username)[0] if self.can_edit(user, bundle, Bulletin) is False: raise ImmediateHttpResponse( HttpForbidden('You do not have permission to edit this entity') ) # permission checks if self.is_finalized( Bulletin, kwargs['pk'], 'most_recent_status_bulletin' ) and can_finalize(user) is False: raise ImmediateHttpResponse( HttpForbidden('This item has been finalized') ) if can_assign_users(user) is False and 'assigned_user' in bundle.data: del(bundle.data['assigned_user']) # decide on available status status_id = self.id_from_url(bundle.data) status_update = StatusUpdate.filter_by_perm_objects.get_update_status( user, status_id ) # create the commnt from the status update and the bundled comment comment_uri = self.create_comment( bundle.data['comment'], status_update.id, user ) try: bundle.data['bulletin_comments'].append(comment_uri) except KeyError: bundle.data['bulletin_comments'] = [comment_uri, ] with reversion.create_revision(): bundle = super(BulletinResource, self)\ .obj_update(bundle, **kwargs) reversion.add_meta( VersionStatus, status='edited', user=user ) reversion.set_user(user) reversion.set_comment(bundle.data['comment']) update_object.delay(username) return bundle
def perform_update(self, serializer): """ Update an existing `Measurement` instance, given the validated data. Doesn't hit DB if nothing changed(Doesn't create redundant revisions). """ if not (self.get_object().headers == serializer.validated_data.get('headers') and self.get_object().table_data == serializer.validated_data.get('table_data')): with reversion.create_revision(): serializer.save() reversion.set_user(self.request.user) self.save_recent_activity(RecentActivity.UPDATE, obj=self.get_object().unit, unit=self.get_object().unit.pk, experiment=[unicode(obj.pk) for obj in self.get_object().unit.experiments.all()])
def post(self, request, *args, **kwargs): self.object = self.get_object() page = self.get_comment_page() if self.is_comment_locked(): return HttpResponseForbidden() parent = request.POST.get('parent') if parent: try: parent = int(parent) except ValueError: return HttpResponseNotFound() else: if not Comment.objects.filter( hidden=False, id=parent, page=page).exists(): return HttpResponseNotFound() form = CommentForm(request, request.POST) if form.is_valid(): comment = form.save(commit=False) comment.author = request.profile comment.page = page with LockModel(write=(Comment, Revision, Version), read=(ContentType, )), revisions.create_revision(): revisions.set_user(request.user) revisions.set_comment(_('Posted comment')) comment.save() # add notification for reply if comment.parent and comment.parent.author != comment.author: notification_rep = Notification(owner=comment.parent.author, comment=comment, category='Reply') notification_rep.save() add_mention_notifications(comment) return HttpResponseRedirect(request.path) context = self.get_context_data(object=self.object, comment_form=form) return self.render_to_response(context)
def obj_update(self, bundle, **kwargs): username = bundle.request.GET['username'] user = User.objects.filter(username=username)[0] if self.can_edit(user, bundle, Bulletin) is False: raise ImmediateHttpResponse( HttpForbidden( 'You do not have permission to edit this entity')) # permission checks if self.is_finalized( Bulletin, kwargs['pk'], 'most_recent_status_bulletin') and can_finalize(user) is False: raise ImmediateHttpResponse( HttpForbidden('This item has been finalized')) if can_assign_users(user) is False and 'assigned_user' in bundle.data: del (bundle.data['assigned_user']) # decide on available status status_id = self.id_from_url(bundle.data) status_update = StatusUpdate.filter_by_perm_objects.get_update_status( user, status_id) # create the commnt from the status update and the bundled comment comment_uri = self.create_comment(bundle.data['comment'], status_update.id, user) try: bundle.data['bulletin_comments'].append(comment_uri) except KeyError: bundle.data['bulletin_comments'] = [ comment_uri, ] with reversion.create_revision(): bundle = super(BulletinResource, self)\ .obj_update(bundle, **kwargs) reversion.add_meta(VersionStatus, status='edited', user=user) reversion.set_user(user) reversion.set_comment(bundle.data['comment']) update_object.delay(username) return bundle
def post(self, request, *args, **kwargs): if "room" in request.POST: if request.POST["room"] != "" and request.POST["room"] != 0: roomid = request.POST["room"][0] room = get_object_or_404(Room, pk=roomid) else: room = None else: room = None response = super(DeviceApiLend, self).post(request) if request.POST["device"] != "" and response.status_code == 201: device = Device.objects.get(pk=request.POST["device"]) device.currentlending = self.object if room: device.room = room reversion.set_user(request.user) reversion.set_comment("Device marked as lend") try: template = MailTemplate.objects.get( usage="room", department=self.request.user.main_department) except: template = None messages.error( self.request, _('MAIL NOT SENT - Template for room change does not exist for your main department' )) if template is not None: recipients = [] for recipient in template.default_recipients.all(): recipient = recipient.content_object if isinstance(recipient, Group): recipients += recipient.lageruser_set.all( ).values_list("email")[0] else: recipients.append(recipient.email) template.send(self.request, recipients, { "device": device, "user": self.request.user }) reversion.set_ignore_duplicates(True) device.save() return response
def test_last_author(self): # test whether last author is part of page response = self.app.get(self.document.get_view_url(), user=self.user) self.assertIn('<i>by</i> {}'.format(self.user.username), response.body.decode('utf-8')) # create a second user user2 = mommy.make(UserProfile, is_superuser=True) user2.groups.add(self.group) # create second revision self.document.text_en = 'christi was here' with transaction.atomic(), revisions.create_revision(): self.document.save() revisions.set_user(user2) revisions.set_comment('test version 2') # test whether last author is part of page response = self.app.get(self.document.get_view_url(), user=self.user) self.assertIn('<i>by</i> {}'.format(user2.username), response.body.decode('utf-8'))
def edit_profile(request): if request.method == 'POST': form = ProfileForm(request.POST, instance=request.profile) if form.is_valid(): with transaction.atomic(), revisions.create_revision(): form.save() revisions.set_user(request.user) revisions.set_comment(_('Updated on site')) return HttpResponseRedirect(request.path) else: form = ProfileForm(instance=request.profile) return render( request, 'user/edit-profile.html', { 'form': form, 'title': _('Edit profile'), 'has_math_config': bool(settings.MATHOID_URL), })
def game_edit(request, *args, **kwargs): game = get_object_or_404(models.Game, pk=kwargs.get('game_pk')) if request.method == 'POST': with revisions.create_revision(): form = forms.GameForm(request.POST, instance=game) if form.is_valid(): form.save() revisions.set_user(request.user) return HttpResponseRedirect( reverse('core:game_detail', args=[game.id])) else: context = {'form': form, 'game': game} return render(request, 'core/game_form_edit.html', context=context) else: form = forms.GameForm(instance=game) context = {'form': form, 'game': game} return render(request, 'core/game_form_edit.html', context=context)
def form_valid(self, form): # save as a revision self.work.updated_by_user = self.request.user with reversion.create_revision(): reversion.set_user(self.request.user) resp = super(EditWorkView, self).form_valid(form) # ensure any docs for this work at initial pub date move with it, if it changes if 'publication_date' in form.changed_data: old_date = form.initial[ 'publication_date'] or self.work.commencement_date if old_date and self.work.publication_date: for doc in Document.objects.filter(work=self.work, expression_date=old_date): doc.expression_date = self.work.publication_date doc.save() # if the work title changes, ensure matching document titles do too if 'title' in form.changed_data: old_title = form.initial['title'] if old_title: for doc in Document.objects.filter(work=self.work, title=old_title): doc.title = self.work.title doc.save() if form.has_changed(): # signals work_changed.send(sender=self.__class__, work=self.work, request=self.request) messages.success(self.request, "Work updated.") # rename publication-document if frbr_uri has changed if 'frbr_uri' in form.changed_data: try: self.work.publication_document.save() except PublicationDocument.DoesNotExist: pass return resp
def post(self, request, *args, **kwargs): self.object = self.get_object() page = self.get_comment_page() with LockModel(write=(Comment, Revision, Version), read=(Profile, ContentType, Submission, Problem)): form = CommentForm(request, request.POST) if form.is_valid(): comment = form.save(commit=False) comment.author = request.user.profile comment.page = page with revisions.create_revision(): revisions.set_user(request.user) revisions.set_comment(_('Posted comment')) comment.save() return HttpResponseRedirect(request.path) context = self.get_context_data(object=self.object, comment_form=form) return self.render_to_response(context)
def restore(self, request, *args, **kwargs): # check permissions on the OLD object if not DocumentPermissions().has_object_permission(request, self, self.document): self.permission_denied(self.request) revision = self.get_object() # check permissions on the NEW object version = revision.version_set.all()[0] document = version.object_version.object if not DocumentPermissions().has_object_permission(request, self, document): self.permission_denied(self.request) with reversion.create_revision(): reversion.set_user(request.user) reversion.set_comment("Restored revision %s" % revision.id) revision.revert() return Response(status=200)
def post(self, request, frbr_uri, version_id): version = self.work.versions().filter(pk=version_id).first() if not version: raise Http404() with reversion.create_revision(): reversion.set_user(request.user) reversion.set_comment("Restored version %s" % version.id) version.revert() messages.success(request, 'Restored version %s' % version.id) # signals work_changed.send(sender=self.work.__class__, work=self.work, request=request) url = request.GET.get('next') or reverse( 'work', kwargs={'frbr_uri': self.work.frbr_uri}) return redirect(url)
def post(self, request, *args, **kwargs): if "lending" not in request.DATA: return Response({"error": "you need to provide a valid lending id"}, status=status.HTTP_400_BAD_REQUEST) if "room" in request.DATA: if request.DATA["room"] != "" and request.DATA["room"] != 0: roomid = request.DATA["room"] room = get_object_or_404(Room, pk=roomid) else: room = None else: room = None lending = get_object_or_404(Lending, pk=request.DATA["lending"]) if lending.device and lending.device != "": device = lending.device device.currentlending = None if room: device.room = room reversion.set_user(request.user) try: template = MailTemplate.objects.get(usage="room") except: template = None messages.error(self.request, _('MAIL NOT SENT - Template for room change does not exist')) if template is not None: recipients = [] for recipient in template.default_recipients.all(): recipient = recipient.content_object if isinstance(recipient, Group): recipients += recipient.lageruser_set.all().values_list("email")[0] else: recipients.append(recipient.email) template.send(self.request, recipients, {"device": device, "user": self.request.user}) reversion.set_comment(_("Device returned and moved to room {0}").format(device.room)) device.save() else: pass lending.returndate = datetime.datetime.now() lending.save() return Response({"success": "device is returned"}, status=status.HTTP_200_OK)
def put(self, request, pk, **kwargs): response = super(DeviceApiRoomChange, self).put(request, pk) try: template = MailTemplate.objects.get(usage="room") except: template = None messages.error(self.request, _('MAIL NOT SENT - Template for room change does not exist')) if template is not None: recipients = [] for recipient in template.default_recipients.all(): recipient = recipient.content_object if isinstance(recipient, Group): recipients += recipient.lageruser_set.all().values_list("email")[0] else: recipients.append(recipient.email) template.send(self.request, recipients, {"device": self.get_object(), "user": self.request.user}) reversion.set_user(request.user) reversion.set_comment(_("Device moved to room {0}").format(self.get_object().room)) return response
def obj_create(self, bundle, **kwargs): username = bundle.request.GET['username'] user = User.objects.filter(username=username)[0] status_update = StatusUpdate.objects.get(status_en='Human Created') if can_assign_users(user) is False and 'assigned_user' in bundle.data: del (bundle.data['assigned_user']) comment_uri = self.create_comment(bundle.data['comment'], status_update.id, user) bundle.data['incident_comments'] = [comment_uri] with reversion.create_revision(): bundle = super(IncidentResource, self)\ .obj_create(bundle, **kwargs) reversion.add_meta(VersionStatus, status='created', user=user) reversion.set_user(user) reversion.set_comment(bundle.data['comment']) update_object.delay(username) return bundle
def make_profile(backend, user, response, is_new=False, *args, **kwargs): if is_new: if not hasattr(user, 'profile'): profile = Profile(user=user) profile.language = Language.get_python2() logger.info('Info from %s: %s', backend.name, response) profile.save() return # form = ProfileForm(instance=profile, user=user) else: data = backend.strategy.request_data() logger.info(data) return form = ProfileForm(data, instance=user.profile, user=user) if form.is_valid(): with transaction.atomic(), revisions.create_revision(): form.save() revisions.set_user(user) revisions.set_comment('Updated on registration') return
def delete(self, request, app, model): if request.data: dict_mapp = request.data model = apps.get_model(app, model) objs = model.objects.filter(**dict_mapp) with transaction.atomic(), reversion.create_revision(): [objs[i].save() for i in range(len(objs))] reversion.set_user(request.user) reversion.set_comment(request.method) reversion.set_date_created( date_created=datetime.datetime.now()) GenericSzl = getGenericSerializer(model) serializer = GenericSzl(objs, many=True) org = serializer.data objs.delete() audit_log_list(org, request, app, model) return Response({'Received data': request.data}) else: return Response({"return none instead": "return none instead"})
def done(self, form_list, **kwargs): reversion.set_user(self.request.user) reversion.set_comment("Added via data element concept wizard") oc = self.get_object_class() pr = self.get_property() dec = None for form in form_list: saved_item = form.save() if type(saved_item) == MDR.Property: pr = saved_item messages.success( self.request, mark_safe(_("New Property '{name}' Saved - <a href='{url}'>id:{id}</a>").format( url=url_slugify_concept(saved_item), name=saved_item.name, id=saved_item.id )) ) if type(saved_item) == MDR.ObjectClass: oc = saved_item messages.success( self.request, mark_safe(_("New Object Class '{name}' Saved - <a href='{url}'>id:{id}</a>").format( url=url_slugify_concept(saved_item), name=saved_item.name, id=saved_item.id )) ) if type(saved_item) == MDR.DataElementConcept: dec = saved_item messages.success( self.request, mark_safe(_("New Data Element Concept '{name}' Saved - <a href='{url}'>id:{id}</a>").format( url=url_slugify_concept(saved_item), name=saved_item.name, id=saved_item.id )) ) if dec is not None: dec.objectClass = oc dec.property = pr dec.save() return HttpResponseRedirect(url_slugify_concept(dec))
def setUpTestData(cls): cls.profile = models.Profile.objects.create(username="******", email="*****@*****.**", is_superuser=True, is_active=True, is_staff=True) cls.vatrate = models.VatRate.objects.create(start_at='2014-03-05', rate=0.20, comment='test1') cls.events = {} with reversion.create_revision(): reversion.set_user(cls.profile) cls.events[1] = models.Event.objects.create( name="TE E1", start_date=date.today()) with reversion.create_revision(): reversion.set_user(cls.profile) cls.events[2] = models.Event.objects.create( name="TE E2", start_date='2014-03-05') with reversion.create_revision(): reversion.set_user(cls.profile) cls.events[1].description = "A test description" cls.events[1].save()
def create(self, request, *args, **kwargs): data = request.data if 'concept_type' in request.data.keys(): # We've been passed a single object manifest = {'metadata': [data]} else: manifest = data try: created = [] errors = [] with transaction.atomic(): for s in Deserializer(manifest): if s.object.workgroup is None or perms.user_can_submit_to_workgroup( request.user, s.object.workgroup): with reversion.create_revision(): created.append({ 'uuid': s.object.uuid, 'url': s.object.get_absolute_url() }) s.submitter = request.user s.object.recache_states() reversion.set_user(request.user) reversion.set_comment(_("Imported using API")) s.save() else: errors.append({ 'message': 'You don\'t have permission to create an item in the {} Workgroup' .format(s.object.workgroup) }) return Response({'created': created, 'errors': errors}) except Exception as e: if settings.DEBUG and 'explode' in request.query_params.keys(): raise return Response({'error': str(e)})
def test_show_author_to(self): author_str = '<i>by</i> {}'.format(self.user.username) self.document.show_author_to = InformationDocument.SHOW_AUTHOR_TO_EVERYONE with transaction.atomic(), revisions.create_revision(): self.document.save() revisions.set_user(self.user) revisions.set_comment('test version 2') self.assertIn(author_str, self.app.get(self.document.get_view_url(), user=self.user).body.decode('utf-8')) self.app.reset() self.assertIn(author_str, self.app.get(self.document.get_view_url()).body.decode('utf-8')) self.document.show_author_to = InformationDocument.SHOW_AUTHOR_TO_LOGGED_IN_USERS with transaction.atomic(), revisions.create_revision(): self.document.save() revisions.set_user(self.user) revisions.set_comment('test version 3') self.assertIn(author_str, self.app.get(self.document.get_view_url(), user=self.user).body.decode('utf-8')) self.app.reset() self.assertNotIn(author_str, self.app.get(self.document.get_view_url()).body.decode('utf-8')) self.document.show_author_to = InformationDocument.SHOW_AUTHOR_TO_NO_ONE with transaction.atomic(), revisions.create_revision(): self.document.save() revisions.set_user(self.user) revisions.set_comment('test version 4') self.assertNotIn(author_str, self.app.get(self.document.get_view_url(), user=self.user).body.decode('utf-8')) self.app.reset() self.assertNotIn(author_str, self.app.get(self.document.get_view_url()).body.decode('utf-8'))
def edit_profile(request): profile = Profile.objects.get(user=request.user) if profile.mute: raise Http404() if request.method == 'POST': form = ProfileForm(request.POST, instance=profile, user=request.user) if form.is_valid(): with transaction.atomic(), revisions.create_revision(): form.save() revisions.set_user(request.user) revisions.set_comment(_('Updated on site')) if newsletter_id is not None: try: subscription = Subscription.objects.get(user=request.user, newsletter_id=newsletter_id) except Subscription.DoesNotExist: if form.cleaned_data['newsletter']: Subscription(user=request.user, newsletter_id=newsletter_id, subscribed=True).save() else: if subscription.subscribed != form.cleaned_data['newsletter']: subscription.update(('unsubscribe', 'subscribe')[form.cleaned_data['newsletter']]) return HttpResponseRedirect(request.path) else: form = ProfileForm(instance=profile, user=request.user) if newsletter_id is not None: try: subscription = Subscription.objects.get(user=request.user, newsletter_id=newsletter_id) except Subscription.DoesNotExist: form.fields['newsletter'].initial = False else: form.fields['newsletter'].initial = subscription.subscribed tzmap = getattr(settings, 'TIMEZONE_MAP', None) return render(request, 'user/edit_profile.jade', { 'form': form, 'title': _('Edit profile'), 'TIMEZONE_MAP': tzmap or 'http://momentjs.com/static/img/world.png', 'TIMEZONE_BG': getattr(settings, 'TIMEZONE_BG', None if tzmap else '#4E7CAD'), })
def make_profile(backend, user, response, is_new=False, *args, **kwargs): if is_new: if not hasattr(user, 'profile'): profile = Profile(user=user) profile.language = Language.get_python2() profile.save() form = ProfileForm(instance=profile, user=user) else: data = backend.strategy.request_data() logger.info(data) form = ProfileForm(data, instance=user.profile, user=user) if form.is_valid(): with transaction.atomic(), revisions.create_revision(): form.save() revisions.set_user(user) revisions.set_comment('Updated on registration') return return render(backend.strategy.request, 'registration/profile_creation.html', { 'title': 'Create your profile', 'form': form })
def setupPeople(self): names = ["Regulus Black", "Sirius Black", "Lavender Brown", "Cho Chang", "Vincent Crabbe", "Vincent Crabbe", "Bartemius Crouch", "Fleur Delacour", "Cedric Diggory", "Alberforth Dumbledore", "Albus Dumbledore", "Dudley Dursley", "Petunia Dursley", "Vernon Dursley", "Argus Filch", "Seamus Finnigan", "Nicolas Flamel", "Cornelius Fudge", "Goyle", "Gregory Goyle", "Hermione Granger", "Rubeus Hagrid", "Igor Karkaroff", "Viktor Krum", "Bellatrix Lestrange", "Alice Longbottom", "Frank Longbottom", "Neville Longbottom", "Luna Lovegood", "Xenophilius Lovegood", # noqa "Remus Lupin", "Draco Malfoy", "Lucius Malfoy", "Narcissa Malfoy", "Olympe Maxime", "Minerva McGonagall", "Mad-Eye Moody", "Peter Pettigrew", "Harry Potter", "James Potter", "Lily Potter", "Quirinus Quirrell", "Tom Riddle", "Mary Riddle", "Lord Voldemort", "Rita Skeeter", "Severus Snape", "Nymphadora Tonks", "Dolores Janes Umbridge", "Arthur Weasley", "Bill Weasley", "Charlie Weasley", "Fred Weasley", "George Weasley", "Ginny Weasley", "Molly Weasley", "Percy Weasley", "Ron Weasley", "Dobby", "Fluffy", "Hedwig", "Moaning Myrtle", "Aragog", "Grawp"] # noqa for i, name in enumerate(names): with reversion.create_revision(): reversion.set_user(random.choice(self.profiles)) newPerson = models.Person.objects.create(name=name) if i % 3 == 0: newPerson.email = "*****@*****.**" if i % 5 == 0: newPerson.notes = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua" if i % 7 == 0: newPerson.address = "1 Person Test Street \n Demoton \n United States of TEC \n RMRF 567" if i % 9 == 0: newPerson.phone = "01234 567894" newPerson.save() self.people.append(newPerson)
def activate_profile(request): profile = Profile.objects.get(user=request.user) if profile.mute: raise Http404() if request.method == 'POST': form = ProfileActivateForm(request.POST, instance=profile, user=request.user) if form.is_valid(): with transaction.atomic(), revisions.create_revision(): form.save() revisions.set_user(request.user) revisions.set_comment(_('Updated on site')) return HttpResponseRedirect(reverse('user_page')) else: form = ProfileActivateForm(instance=profile, user=request.user) return render(request, 'user/activate-profile.html', { 'form': form, 'title': _('Congratulations!') })
def handle(self, *args, **options): path = options['path'][0] list_multiple = [] list_doesnt_exist = [] with open(path, 'r') as csvfile: spamreader = csv.reader(csvfile, delimiter=' ') list_wrong_date = [] for row in spamreader: regex_result = url_pattern.match(row[2]) article_year = int(regex_result.group("year")) article_month = int(regex_result.group("month")) article_slug = regex_result.group("slug") article_title = row[1] date_result = date_pattern.match(row[0]) date_year = int(date_result.group("year")) date_month = int(date_result.group("month")) date_day = date_result.group("day") if not (article_month == date_month and article_year == date_year): list_wrong_date.append(row[2] + " > " + row[0]) else: try: article = Article.objects.get( title=article_title, publishin__month=article_month, publishin__year=article_year) article.text = row[3] article.slug = article_slug reversion.set_user(article.author) article.save() except Article.DoesNotExist: pass except Article.MultipleObjectsReturned: pass
def commit_variant_edit(var_data, genevieve_effect_data, relation_id, commit_comment, user): """ Custom update method that records revisions and reports new version. """ if commit_comment: reversion.set_comment(comment=commit_comment) reversion.set_user(user=user) tags = { 'chrom_b37': var_data['chrom'], 'pos_b37': var_data['pos'], 'ref_allele_b37': var_data['ref_allele'], 'var_allele_b37': var_data['var_allele'], } variant, _ = Variant.objects.get_or_create(tags=tags) if relation_id: relation = Relation.objects.get(id=relation_id) relation.tags = genevieve_effect_data else: relation = Relation(variant=variant, tags=genevieve_effect_data) relation.save() return relation
def post(self, request, *args, **kwargs): if not request.user.is_authenticated(): raise Exception( "Not logged in! Only staff have access to this function") if not request.user.is_staff and not request.user.is_superuser: raise Exception("Only staff have access to this function") keys = [('location', Location), ('time_block', TimeBlock), ('time_slot', TimeSlot)] key_text = 0 key_db_object = 1 game_id = request.POST.get('id') game = Game.objects.get(id=game_id) changed = [] for key in keys: incoming_id = request.POST.get(key[key_text]) old = getattr(game, key[key_text]) new = key[key_db_object].objects.get( id=incoming_id) if incoming_id else None setattr(game, key[key_text], new) if old != new: changed.append(key[key_text]) changed.sort() game.last_scheduled = timezone.now() with reversion.create_revision(): reversion.set_user(request.user) reversion.set_comment("AJAX Schedule Submission - %s Changed" % ", ".join(changed)) game.save()
def done(self, form_list, **kwargs): saved_item = None for form in form_list: saved_item = form.save(commit=False) if saved_item is not None: saved_item.submitter = self.request.user saved_item.save() with reversion.create_revision(): reversion.set_user(self.request.user) reversion.set_comment("Added via concept wizard") form.save_custom_fields(saved_item) form.save_m2m() if 'results_postdata' in self.request.session: extra_formsets = self.get_extra_formsets( item=self.model, postdata=self.request.session['results_postdata']) formsets_invalid = self.validate_formsets( extra_formsets) if not formsets_invalid: final_formsets = [] for info in extra_formsets: if info['saveargs'] is not None: info['saveargs']['item'] = saved_item else: info['formset'].instance = saved_item final_formsets.append(info) self.save_formsets(final_formsets) self.request.session.pop('results_postdata') saved_item.save() return HttpResponseRedirect(url_slugify_concept(saved_item))
def save(self): new_entry = not hasattr(self, "registration") if new_entry: self.registration = Registration( user=self.user, registration_date=timezone.now(), payment=PaymentOption.objects.all()[0]) with transaction.atomic(), reversion.create_revision(): reversion.set_user(self.user) reversion.set_comment("Form Submission - %s" % ("Initial" if new_entry else "Update")) self.registration.last_updated = timezone.now() self.registration.save() old_regs = {} for reg in BlockRegistration.objects.filter( registration=self.registration): old_regs[reg.time_block] = reg for key, field in self.time_block_fields().iteritems(): time_block = TimeBlock.objects.filter( id=key.split("_")[1])[0].text if time_block in old_regs: old_regs[time_block].attendance = field.initial old_regs[time_block].save() del old_regs[time_block] else: BlockRegistration(registration=self.registration, time_block=time_block, attendance=field.initial).save() for obsolete in old_regs.values(): obsolete.delete() self.send_mail(self.registration, new_entry)
def test_text_field_types(self): with reversion.create_revision(): reversion.set_user(self.profile) self.event.name = "New event name" # Simple text self.event.description = "hello world" # Long text self.event.save() # Find the most recent version currentVersion = versioning.RIGSVersion.objects.get_for_object( self.event).latest(field_name='revision__date_created') diff = currentVersion.changes # There are two changes self.assertEqual(len(diff.field_changes), 2) self.assertFalse(currentVersion.changes.items_changed) self.assertTrue(currentVersion.changes.fields_changed) self.assertTrue(currentVersion.changes.anything_changed) # Only one has "linebreaks" self.assertEqual(sum([x.linebreaks for x in diff.field_changes]), 1) # None are "long" (email address) self.assertEqual(sum([x.long for x in diff.field_changes]), 0) # Try changing email field in person with reversion.create_revision(): reversion.set_user(self.profile) self.person.email = "*****@*****.**" self.person.save() # Find the most recent version currentVersion = versioning.RIGSVersion.objects.get_for_object( self.person).latest(field_name='revision__date_created') diff = currentVersion.changes # Should be declared as long self.assertTrue(diff.field_changes[0].long)
def form_valid(self, form): existing = self.get_object() with revisions.create_revision(): response = super(TalkReview, self).form_valid(form) revisions.set_user(self.request.user) if existing: revisions.set_comment("Review Modified") else: revisions.set_comment("Review Created") # Because Review.save() was called before any scores were added, # the str() on the version would have had the previous total. Update. review = self.get_object() version = Version.objects.get_for_object(review).order_by( '-pk').first() version.object_repr = str(review) version.save() talk = review.talk if talk.status == SUBMITTED: talk.status = UNDER_CONSIDERATION talk.save() return response