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 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 remove_trainees(self, trainees): with reversion.create_revision() and transaction.atomic(): if reversion.is_active(): reversion.set_comment('Removed trainees') for trainee in trainees: self.trainees.remove(trainee) self.save()
def handle(self, *app_labels, **options): verbosity = options["verbosity"] using = options["using"] model_db = options["model_db"] comment = options["comment"] batch_size = options["batch_size"] meta = options["meta"] meta_models = [] for label in meta.keys(): try: model = apps.get_model(label) meta_models.append(model) except LookupError: raise CommandError("Unknown model: {}".format(label)) meta_values = meta.values() # Create revisions. using = using or router.db_for_write(Revision) with transaction.atomic(using=using): for model in self.get_models(options): # Check all models for empty revisions. if verbosity >= 1: self.stdout.write("Creating revisions for {name}".format( name=model._meta.verbose_name, )) created_count = 0 live_objs = _safe_subquery( "exclude", model._default_manager.using(model_db), model._meta.pk.name, Version.objects.using(using).get_for_model( model, model_db=model_db, ), "object_id", ) # Save all the versions. ids = list(live_objs.values_list("pk", flat=True).order_by()) total = len(ids) for i in range(0, total, batch_size): chunked_ids = ids[i:i+batch_size] objects = live_objs.in_bulk(chunked_ids) for obj in objects.values(): with create_revision(using=using): if meta: for model, values in zip(meta_models, meta_values): add_meta(model, **values) set_comment(comment) add_to_revision(obj, model_db=model_db) created_count += 1 reset_queries() if verbosity >= 2: self.stdout.write("- Created {created_count} / {total}".format( created_count=created_count, total=total, )) # Print out a message, if feeling verbose. if verbosity >= 1: self.stdout.write("- Created {total} / {total}".format( total=total, ))
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 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 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 log_change(self, request, object, message): if is_active(): if isinstance(message, list): set_comment(LogEntry(change_message=json.dumps(message)).get_change_message()) else: set_comment(message) super(VersionAdmin, self).log_change(request, object, message)
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 import_lag(self, lag_fn=None): reversion.set_comment("Import frå Access") liste = csv.reader(open(lag_fn or self.lag_fil)) liste.next() alle_lag = {} for rad in liste: namn = rad[2].decode('utf-8') \ .title() \ .replace(' Og ', ' og ') \ .replace(' I ', ' i ') \ .replace(u' På ', u' på ') \ .replace('Fmu', 'FMU') \ .replace('Nmu', 'NMU') \ .replace(' Mu', ' MU') lag = Lokallag.objects.filter(pk=rad[3]) if len(lag): lag = lag[0] lag.namn = namn lag.andsvar = rad[4].decode('utf-8') else: lag = Lokallag(pk=rad[3], namn=namn, andsvar=rad[4].decode('utf-8')) lag.save() alle_lag[rad[3]] = lag return alle_lag
def test_page_versions(self): self.client.login(username="******", password="******") page = Page(name="Test Name", url="test-url", content="Content goes here") with reversion.create_revision(): reversion.set_comment("initial") page.save() versions = reversion.get_for_object(page) self.assertEquals(len(versions), 1) self.assertEquals(versions[0].revision.comment, "initial") url = reverse("admin:page_page_change", args=[page.id]) self.client.post(url, {"name": "2nd name", "url": "test-url", "content": "New content"}) page = Page.objects.get(id=page.id) self.assertEquals(page.name, "2nd name") self.assertEquals(page.content, "New content") versions = map(lambda x: x, reversion.get_for_object(page)) self.assertEquals(len(versions), 2) self.assertEquals(versions[0].revision.comment, "Changed name and content.") actual_initial = json.loads(versions[1].serialized_data)[0] self.assertEquals(actual_initial["fields"]["name"], "Test Name") self.assertEquals(actual_initial["fields"]["url"], "test-url") self.assertEquals(actual_initial["fields"]["content"], "Content goes here") actual_final = json.loads(versions[0].serialized_data)[0] self.assertEquals(actual_final["fields"]["name"], "2nd name") self.assertEquals(actual_final["fields"]["url"], "test-url") self.assertEquals(actual_final["fields"]["content"], "New content")
def ingest(cls, open_file, force=False): name = os.path.basename(open_file.name) content = open_file.read() stat_info = os.stat(open_file.name) file_modified = datetime.utcfromtimestamp(stat_info.st_mtime).replace(tzinfo=tzutc()) with transaction.atomic(), revisions.create_revision(): revisions.set_comment('Ingested {name}'.format(name=name)) try: existing = cls.objects.get(name=name) except cls.DoesNotExist: logger.info('Ingest %s', name) return cls.objects.create(name=name, content=content) else: if file_modified <= existing.updated_at: if force: logger.warn('Ingest %s (force)', name) else: logger.info('Ignore %s (older)', name) return existing else: logger.info('Ingest %s (newer)', name) existing.content = content existing.save() return existing
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 handle(self, *args, **options): reversion.set_comment('Updating actions.') action_names = settings.ACTIONS.keys() if options['action_name']: action_names = [name for name in action_names if name in options['action_name']] for name in action_names: self.stdout.write('Updating action {}...'.format(name), ending='') implementation = get_implementation(name) arguments_schema = get_arguments_schema(name) # Create a new action or update the existing one. try: action = Action.objects.get(name=name) should_update = ( action.implementation != implementation or action.arguments_schema != arguments_schema ) if should_update: action.implementation = implementation action.arguments_schema = arguments_schema action.save() except Action.DoesNotExist: action = Action( name=name, implementation=implementation, arguments_schema=arguments_schema ) action.save() self.stdout.write('Done')
def form_valid(self, form): """ Sets EDID and identification when creating new timing. Used for CreateView and UpdateView. """ # For CreateView, set EDID if not form.instance.EDID_id: form.instance.EDID = form.edid if not form.instance.identification: # Get count of available timings count = self.model.objects.filter(EDID=form.instance.EDID)\ .count() # Set identification to count + 1 form.instance.identification = count + 1 # Set the user form.instance.user = self.request.user # Set revision comment if isinstance(self, CreateView): comment = 'Created %s %s.' elif isinstance(self, UpdateView): comment = 'Updated %s %s.' reversion.set_comment(comment % ( form.instance._meta.verbose_name, form.instance )) reversion.add_to_revision(form.instance.EDID) return super(TimingMixin, self).form_valid(form)
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 _reversion_revisionform_view(self, request, version, template_name, extra_context=None): # Check that database transactions are supported. if not connection.features.uses_savepoints: raise ImproperlyConfigured("Cannot use VersionAdmin with a database that does not support savepoints.") # Run the view. try: with transaction.atomic(using=version.db): # Revert the revision. version.revision.revert(delete=True) # Run the normal changeform view. with self.create_revision(request): response = self.changeform_view(request, version.object_id, request.path, extra_context) # Decide on whether the keep the changes. if request.method == "POST" and response.status_code == 302: set_comment(_("Reverted to previous version, saved on %(datetime)s") % { "datetime": localize(template_localtime(version.revision.date_created)), }) else: response.template_name = template_name # Set the template name to the correct template. response.render() # Eagerly render the response, so it's using the latest version. raise _RollBackRevisionView(response) # Raise exception to undo the transaction and revision. except RevertError as ex: opts = self.model._meta messages.error(request, force_text(ex)) return redirect("{}:{}_{}_changelist".format(self.admin_site.name, opts.app_label, opts.model_name)) except _RollBackRevisionView as ex: return ex.response 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 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 log_addition(self, request, object, change_message=None): change_message = change_message or _("Initial version.") if is_active(): set_comment(change_message) try: super(VersionAdmin, self).log_addition(request, object, change_message) except TypeError: # Django < 1.9 pragma: no cover super(VersionAdmin, self).log_addition(request, object)
def post(self, request, *args, **kwargs): user = get_object_or_404(Lageruser, pk=kwargs["pk"]) ipaddress = get_object_or_404(IpAddress, pk=kwargs["ipaddress"]) ipaddress.user = None reversion.set_comment(_("Removed from User {0}".format(six.text_type(user)))) ipaddress.save() return HttpResponseRedirect(reverse("userprofile", kwargs={"pk": user.pk}))
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 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 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 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 handle(self, *args, **options): f = io.open(args[0], 'r', encoding='utf8') date = datetime.strptime(args[1], "%Y-%m-%d") comment = unicode(args[2], 'utf8') with reversion.create_revision(): self.do_import(f, date, comment) reversion.set_comment(u"Import balance: %s" % comment)
def update(self, page, validated_data): revisions.set_comment("Changed via REST api") page.parent = validated_data['parent'] page.content = validated_data['content'] page.include_in_menu = validated_data['include_in_menu'] page.exclude_from_static = validated_data['exclude_from_static'] page.people = validated_data.get('people') page.save() return page
def form_valid(self, form): ipaddresses = form.cleaned_data["ipaddresses"] user = form.cleaned_data["user"] reversion.set_comment(_("Assigned to User {0}").format(six.text_type(user))) for ipaddress in ipaddresses: ipaddress.user = user ipaddress.save() return HttpResponseRedirect(reverse("userprofile", kwargs={"pk": user.pk}))
def add_trainees(self, trainees): with reversion.create_revision() and transaction.atomic(): if reversion.is_active(): reversion.set_comment('Added trainees') existing_trainees = self.trainees.all() for trainee in trainees: if trainee not in existing_trainees: self.trainees.add(trainee) self.save()
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 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 = '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 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() 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 post(self, request, *args, **kwargs): oldobject = get_object_or_404(self.model, pk=kwargs["oldpk"]) newobject = get_object_or_404(self.model, pk=kwargs["newpk"]) # adds all devices of old devicetype to new devicetype devices = Device.objects.filter(devicetype=oldobject) for device in devices: device.devicetype = newobject reversion.set_comment( _("Merged Devicetype {0} into {1}".format( oldobject, newobject))) device.save() # adds all attributes of old devicetype to new devicetype attributes = TypeAttribute.objects.filter(devicetype=oldobject) for attribute in attributes: attribute.devicetype = newobject attribute.save() oldobject.delete() return HttpResponseRedirect(newobject.get_absolute_url())
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 handle(self, *app_labels, **options): verbosity = getattr(options, "verbosity", 0) using = getattr(options, "using", None) model_db = getattr(options, "model_db", None) comment = getattr(options, "comment", "Initial version.") batch_size = getattr(options, "batch_size", 500) # Create revisions. using = using or router.db_for_write(Revision) with transaction.atomic(using=using): for model in self.get_models(options): # Check all models for empty revisions. if verbosity >= 1: self.stdout.write("Creating revisions for {name}".format( name=model._meta.verbose_name, )) created_count = 0 # _safe_subquery does not work in Django 1.7 # So we replace it with this query for now live_objs = model._default_manager.db_manager(model_db).all() # Save all the versions. ids = list(live_objs.values_list("pk", flat=True).order_by()) total = len(ids) for i in range(0, total, batch_size): chunked_ids = ids[i:i + batch_size] objects = live_objs.in_bulk(chunked_ids) for obj in objects.values(): with create_revision(using=using): set_comment(comment) add_to_revision(obj, model_db=model_db) created_count += 1 reset_queries() if verbosity >= 2: self.stdout.write( "- Created {created_count} / {total}".format( created_count=created_count, total=total, )) # Print out a message, if feeling verbose. if verbosity >= 1: self.stdout.write("- Created {total} / {total}".format( total=total, ))
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 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 import_medlem(self, medlem_fn): with reversion.create_revision(): reversion.set_comment(u"CSV import") for num, [medlem_dict, raw_data] in enumerate(self._get_medlem(medlem_fn)): if not self.clean_medlem_dict(medlem_dict, raw_data): continue val = medlem_dict.get('_val', []) tmp = dict((k, medlem_dict[k]) for k in medlem_dict if not k.startswith('_')) m = Medlem(**tmp) m.save() for v in val: m.set_val(v) # Print first 200 names if num < 199: yield u"{0:>3}. {1}".format(unicode(num), unicode(m)) elif num % 200 == 0 and num != 0: yield unicode(num)
def test_page_versions(self): self.client.login(username="******", password="******") page = Page(name="Test Name", url="test-url", content="Content goes here") with reversion.create_revision(): reversion.set_comment("initial") page.save() versions = reversion.get_for_object(page) self.assertEquals(len(versions), 1) self.assertEquals(versions[0].revision.comment, "initial") url = reverse("admin:page_page_change", args=[page.id]) self.client.post(url, { "name": "2nd name", "url": "test-url", "content": "New content" }) page = Page.objects.get(id=page.id) self.assertEquals(page.name, "2nd name") self.assertEquals(page.content, "New content") versions = map(lambda x: x, reversion.get_for_object(page)) self.assertEquals(len(versions), 2) self.assertEquals(versions[0].revision.comment, "Changed name and content.") actual_initial = json.loads(versions[1].serialized_data)[0] self.assertEquals(actual_initial["fields"]["name"], "Test Name") self.assertEquals(actual_initial["fields"]["url"], "test-url") self.assertEquals(actual_initial["fields"]["content"], "Content goes here") actual_final = json.loads(versions[0].serialized_data)[0] self.assertEquals(actual_final["fields"]["name"], "2nd name") self.assertEquals(actual_final["fields"]["url"], "test-url") self.assertEquals(actual_final["fields"]["content"], "New content")
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 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 merge(self, request, queryset): if request.POST.get('post'): # Has the user confirmed which is the master record? try: masterObjectPk = request.POST.get('master') masterObject = queryset.get(pk=masterObjectPk) except ObjectDoesNotExist: self.message_user(request, "An error occured. Did you select a 'master' record?", level=messages.ERROR) return with transaction.atomic(), reversion.create_revision(): for obj in queryset.exclude(pk=masterObjectPk): events = obj.event_set.all() for event in events: masterObject.event_set.add(event) obj.delete() reversion.set_comment('Merging Objects') self.message_user(request, "Objects successfully merged.") return else: # Present the confirmation screen class TempForm(ModelForm): class Meta: model = queryset.model fields = self.merge_fields forms = [] for obj in queryset: forms.append(TempForm(instance=obj)) context = { 'title': _("Are you sure?"), 'queryset': queryset, 'action_checkbox_name': helpers.ACTION_CHECKBOX_NAME, 'forms': forms } return TemplateResponse(request, 'RIGS/admin_associate_merge.html', context)
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 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 _reversion_revisionform_view(self, request, version, template_name, extra_context=None): try: with transaction.atomic(using=version.db): # Revert the revision. version.revision.revert(delete=True) # Run the normal changeform view. with self.create_revision(request): response = self.changeform_view(request, version.object_id, request.path, extra_context) # Decide on whether the keep the changes. if request.method == "POST" and response.status_code == 302: set_comment( _("Reverted to previous version, saved on %(datetime)s" ) % { "datetime": localize( template_localtime( version.revision.date_created)), }) else: response.template_name = template_name # Set the template name to the correct template. response.render( ) # Eagerly render the response, so it's using the latest version. raise _RollBackRevisionView # Raise an exception to undo the transaction and the revision. except RevertError as ex: opts = self.model._meta messages.error(request, force_text(ex)) return redirect("{}:{}_{}_changelist".format( self.admin_site.name, opts.app_label, opts.model_name)) except _RollBackRevisionView: pass return response
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 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
def save(self, *args, **kwargs): """ This falls back on using an admin user if a thread request object wasn't found """ User = get_user_model() _locals = threading.local() if ((not hasattr(_locals, "request") or _locals.request.user.is_anonymous())): if hasattr(_locals, "user"): user = _locals.user else: try: user = User.objects.get(pk=_locals.request.user.pk) except Exception: user = User.objects.get(id=1) _locals.user = user else: try: user = User.objects.get(pk=_locals.request.user.pk) except Exception: user = User.objects.get(id=1) # If saving a new model, set the creator. if not self.pk: try: self.creator except ObjectDoesNotExist: self.creator = user try: self.modifier except ObjectDoesNotExist: self.modifier = user created = True else: created = False self.modifier = user super(Audit, self).save(*args, **kwargs) if created: with create_revision(): set_comment('Initial version.') else: if self.has_changed(): comment = 'Changed ' + ', '.join(self.changed_data) + '.' with create_revision(): set_comment(comment) else: with create_revision(): set_comment('Nothing changed.')
def log_change(self, request, object, message): if is_active(): set_comment(message) super(VersionAdmin, self).log_change(request, object, message)
def generate_scratch_codes(request): profile = request.profile with revisions.create_revision(atomic=True): revisions.set_user(request.user) revisions.set_comment(_('Generated scratch codes for user')) return JsonResponse({'data': {'codes': profile.generate_scratch_codes()}})
def log_addition(self, request, object, message): change_message = message or _("Initial version.") entry = super().log_addition(request, object, change_message) if is_active(): set_comment(entry.get_change_message()) return entry
def log_change(self, request, object, message): entry = super().log_change(request, object, message) if is_active(): set_comment(entry.get_change_message()) return entry
def form_valid(self, form): revisions.set_user(self.request.user) revisions.set_comment("Talk Modified") return super(TalkUpdate, self).form_valid(form)
def ajax_update_contest_tasks(request): user = request.user if not request.is_ajax(): raise PermissionDenied if 'tasks_with_contest[]' not in request.POST or 'contest_id' not in request.POST: raise PermissionDenied contest_id = int(request.POST['contest_id']) response = {'is_error': False, 'contest_id': contest_id, 'error': '', 'tasks_title': {}} got_info, contest_info = get_contest_info(contest_id) if got_info: problem_req = FakeResponse() problem_req = requests.get(settings.CONTEST_API_URL + 'problems?contestId=' + str(contest_id), headers={'Authorization': 'OAuth ' + settings.CONTEST_OAUTH}) problems = [] if 'error' in problem_req: response['is_error'] = True if 'IndexOutOfBoundsException' in problem_req['error']['name']: response['error'] = _(u'kontesta_ne_sushestvuet') else: response['error'] = _(u'oshibka_kontesta') + ' ' + problem_req['error']['message'] if 'result' in problem_req.json(): problems = problem_req.json()['result']['problems'] contest_responses = [contest_info, problems] else: response['is_error'] = True if "You're not allowed to view this contest." in contest_info: response['error'] = _(u"net_prav_na_kontest") elif "Contest with specified id does not exist." in contest_info: response['error'] = _(u'kontesta_ne_sushestvuet') else: response['error'] = _(u'oshibka_kontesta') + contest_info if not response['is_error']: for task in Task.objects.filter(id__in=dict(request.POST)['tasks_with_contest[]']): alias = task.problem_id if contest_id != task.contest_id: continue for problem in contest_responses[0]['problems']: if problem['alias'] == alias: task.title = problem['problemTitle'] task.task_text = problem['statement'] if 'endTime' in contest_responses[0]: deadline = contest_responses[0]['endTime'].split('+')[0] task.deadline_time = datetime.datetime.strptime(deadline, '%Y-%m-%dT%H:%M:%S.%f') else: task.deadline_time = None break for problem in contest_responses[1]: if problem['title'] == alias: if 'score' in problem: task.score_max = problem['score'] task.save() reversion.set_user(user) reversion.set_comment("Update from contest") response['tasks_title'][task.id] = task.get_title(user.profile.language) return HttpResponse(json.dumps(response), content_type="application/json")
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 = Version.objects.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_id')).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 try: field = getattr(document_class, key).field except AttributeError: continue if isinstance(field, models.ManyToManyField): many_to_many_fields[key] = fields[key] del new_fields[key] else: new_fields[field.attname] = 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}\" (at {date})'.format( revision_comment=revert_version.revision.get_comment(), date=datetime.utcnow().strftime("%Y-%m-%d %H:%M"), ))) return HttpResponse(reverse('versions', args=[reverted_document.url_title]))
import os import csv import re import django os.environ.setdefault("DJANGO_SETTINGS_MODULE", "msap.settings") django.setup() from staff.models import * from reversion import revisions as reversion from django.db import transaction reload(sys) sys.setdefaultencoding('utf-8') with open(sys.argv[1], 'rb') as f: for row in f: s = re.split('[ \t]', row.strip()) if SiteUser.has_by_fio(s[0], s[1], s[2]): print 'Skipping "%s" -- already exist' % row.strip() else: if SiteUser.has(s[3]): print 'Skipping "%s" -- BAG' % row.strip(), s[3] continue with transaction.atomic(), reversion.create_revision(): print u'Addind', row.strip() u = SiteUser.create(s[1], s[2], s[0], s[3], 'xxx') reversion.set_comment( "Auto generated by 'add_users.py' from '%s'" % sys.argv[1])