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])
