def setup_revision(user, status):
if user is not None:
updater = django.contrib.auth.models.User.objects.get(username=user)
else:
updater = None
reversion.set_user(updater)
reversion.set_comment("Set status to %s" % (status.name, ))
def reject(request, id):
name = _("Activate an Enumeration")
e = get_object_or_404(Enumeration, id=id)
if e.status == "P":
#Remove all gatekeeper errors.
GateKeeperError.objects.filter(enumeration=e).delete()
e.status = "R"
e.last_updated_ip=request.META['REMOTE_ADDR']
e.enumerated_by = request.user
e.save()
msg = "This record has been rejected by %s" % (request.user)
Event.objects.create(enumeration=e, event_type="REJECTION", note= msg,
details=msg,
body = RECJECTION_BODY,
subject = REJECTION_SUBJECT)
reversion.set_user(request.user)
comment = "Application rejected"
reversion.set_comment(comment)
messages.success(request, "This record has been successfully been rejected.")
else:
messages.info(request, "This record was not pending so nothing was done. The record was not rejected.")
return HttpResponseRedirect(reverse('report_index'))
def post_handler(self, object_, record_type, orig_qd):
"""Create or update object_. qd is a QueryDict."""
qd = copy.deepcopy(
orig_qd) # If there are ever errors, we have to preserver
# the original qd
comment = qd.pop('comment', [''])[0].strip()
# This little chunk of code could be factored out, but I think it's
# more clear when you see which objects don't need to call this in one
# spot.
qd, errors = self.modify_qd(qd, object_=object_)
if errors:
return None, errors
# Create a save-able form to create/update the object
if object_:
object_form = self.form(qd, instance=object_)
else:
object_form = self.form(qd)
if object_form.is_valid():
try:
object_ = object_form.save()
reversion.set_comment(comment)
except ValidationError, e:
if 'domain' in qd:
prune_tree(Domain.objects.get(pk=qd['domain']))
e_dict = ErrorDict()
e_dict['__all__'] = ErrorList(e.messages)
return None, e_dict
return object_, None
def deactivate(request, id):
name = _("Deactivate")
e = get_object_or_404(Enumeration, id=id)
#If status is already deactivated then redirect.
if e.status == "D":
messages.info(request, "This record was not deactive so nothing was done. The record was not rejected.")
return HttpResponseRedirect(reverse('report_index'))
if request.method == 'POST':
form = DeactivationForm(request.POST, instance=e)
if form.is_valid():
e = form.save(commit=False)
e.last_updated_ip=request.META['REMOTE_ADDR']
e.status="D"
e.deactivation_date = datetime.date.today()
e.save()
msg = "Enumeration %s has been deactivated by %s." % (e.number, request.user)
Event.objects.create(enumeration=e, event_type="DEACTIVATION", note= msg,
details=msg, body = DEACTIVATED_BODY,
subject = DEACTIVATED_SUBJECT)
reversion.set_user(request.user)
comment = "Deactivation of %s" % (e.number)
reversion.set_comment(comment)
messages.success(request, msg)
return HttpResponseRedirect(reverse('report_index'))
else:
#The form is invalid
messages.error(request,_("Please correct the errors in the form."))
context = {'form': form,'name':name,}
return render(request, 'generic/bootstrapform.html', context)
#this is a GET
context= {'name':name,
'form': DeactivationForm(instance=e)}
return render(request, 'generic/bootstrapform.html', context)
def handle(self, *args, **options):
if (len(args) < 1):
return
csv.register_dialect('quotescolon', quotechar='"', delimiter=';', doublequote=False, lineterminator='\n', quoting=csv.QUOTE_NONE)
f = codecs.open(args[0], mode='rU')
stops = file.UnicodeDictReader(f, 'utf-8', dialect=csv.get_dialect('quotescolon'))
with reversion.create_revision():
source, created = Source.objects.get_or_create(source_id=u'govi', defaults={u'name': "GOVI"})
for stop in stops:
split = unicode(stop['TimingPointName']).split(',')
if len(split) > 1:
city = split[0]
name = split[1].lstrip()
else:
city = stop['TimingPointTown'].capitalize()
name = stop['TimingPointName']
point = geo.transform_rd(Point(x=int(stop['LocationX_EW']), y=int(stop['LocationY_NS']), srid=28992))
s, created = UserStop.objects.get_or_create(tpc=stop[u"TimingPointCode"],
defaults={u'common_name' : name, u'common_city' : city, 'point' : point.wkt})
# Get or create our source
for attr in stop.keys():
self.get_create_update(SourceAttribute, {'stop' : s, 'source' : source, 'key' : attr.capitalize()}, {'value' : stop[attr]} )
reversion.set_comment(u"GOVI Import")
f.close()
def handle_edit(request, document):
context = RequestContext(request)
if request.method == "POST":
form = TextForm(request.POST)
if form.is_valid():
cleaned_data = form.cleaned_data
document.text = cleaned_data["text"]
document.type = cleaned_data["type"]
document.author = request.user
if document.title != cleaned_data["title"]:
# if the user changed the title we have to delete the old version
# because the url_title will change, too...
document.title = cleaned_data["title"]
new_document = Document(
title=document.title, text=document.text, type=document.type, author=document.author
)
document.delete()
document = new_document
# save the document and also save the user and the comment the user added
with transaction.atomic(), reversion.create_revision():
document.save()
reversion.set_user(request.user)
reversion.set_comment(cleaned_data["comment"])
raise FormValidException
else:
context["errors"] = form.errors
context["form"] = form
else:
form_data = {"title": document.title, "text": document.text, "type": document.type}
context["form"] = TextForm(form_data)
context["document"] = document
return context
def edit_enhanced_enumeration(request, id):
name = _("Edit Enhanced Profile Information")
e = get_enumeration_user_manages_or_404(Enumeration, id, request.user)
if request.method == 'POST':
form = EnumerationEnhancementForm(request.POST, request.FILES, instance=e)
if form.is_valid():
e = form.save(commit=False)
e.last_updated_ip=request.META['REMOTE_ADDR']
e.status="E"
e.save()
reversion.set_user(request.user)
reversion.set_comment("Edit Enhancements.")
return HttpResponseRedirect(reverse('edit_enumeration',
args=(e.id,)))
else:
#The form is invalid
messages.error(request,_("Please correct the errors in the form."))
context = {'form': form,'name':name,}
return render(request, 'generic/bootstrapform.html', context)
#this is a GET
context= {'name':name,
'form': EnumerationEnhancementForm(instance=e)}
return render(request, 'generic/bootstrapform.html', context)
def run_merge_tables(self, **kwargs):
source_config_entity = self.config_entity
target_config_entity = self.target_config_entity
print " source"
print source_config_entity
print " target"
print target_config_entity
source_feature_class = source_config_entity.db_entity_feature_class(self.db_entity_key)
source_db_entity = source_config_entity.db_entity_by_key(self.db_entity_key)
# resolve the target table by looking at the import table of the source db_entity
target_db_entity_key = source_db_entity.feature_class_configuration_as_dict.get("import_from_db_entity_key")
target_feature_class = target_config_entity.db_entity_feature_class(target_db_entity_key)
# filter the target features by their approval status
source_features = source_feature_class.objects.filter(approval_status="approved")
# iterate over the features and merge approved rows into the target table
for source_feature in source_features:
with transaction.commit_on_success(), reversion.create_revision():
target_feature = target_feature_class.objects.get(id=source_feature.id)
target_feature.__dict__.update(**source_feature.__dict__)
target_feature.save()
target_feature.comment = "Merge from ConfigEntity %s" % source_config_entity.key
# If we have comments defined on the base table
if hasattr(target_feature, "comments"):
target_feature.comments = target_feature.comment
reversion.set_user(self.updater)
reversion.set_comment(target_feature.comment)
# reset the approval field to null after changes are committed to the target
source_feature.approval_status = None
source_feature.save()
def take_shift(request):
json_data = json.loads(request.read())
if not 'username' in json_data:
user = request.user
else:
username = json_data['username']
try:
user = User.objects.get(username=username)
except:
user = User.objects.create_user(username, None, first_name=username, last_name="", password=username)
contact_info = ContactInfo()
contact_info.user = user
contact_info.auto_user = True
contact_info.claimed = False
contact_info.save()
shift_id = json_data['shift_id']
#shift_id = request.POST['shift_id']
shift = Shift.objects.get(pk=shift_id)
with transaction.atomic(), reversion.create_revision():
if shift.volunteer != None:# and user != shift.volunteer:
return JsonResponse({'status':'taken'})
collision = shift.user_collides(user)
if collision is not None:
return JsonResponse({'status':'collides', 'shift_id':collision.id, 'desc':collision.day_desc()})
shift.volunteer = user
shift.save()
reversion.set_comment("Took shift")
return JsonResponse({'status':'ok'})
return JsonResponse({'status':'failed'})
def form_valid(self, form):
context = self.get_context_data()
version = context["version"]
with reversion.create_revision():
reversion.set_comment("Reverted to '%s'" % version.id)
version.revert()
return HttpResponseRedirect(self.object.get_absolute_url())
def add_company(request):
# FIXME: Make this view honor the returned_url if any for other apps that
# will call it
return_url = request.GET.get('return_url', None)
form = EnterpriseForm(request.POST or None)
if form.is_valid():
customer = form.save(commit=False)
try:
customer.id_user = Users.objects.get(login=request.user.email)
except Users.DoesNotExist:
try:
# FIXME: Remove these and do it just when the connection is first made
user = Users.objects.create(email=request.user.email, login=request.user.email)
customer.id_user = user
except:
# The login is not the email ('admin'), if this fail then crash.
customer.id_user = Users.objects.get(email=request.user.email)
#Cyril wants this to be always 1
customer.company_type = CompanyTypes.objects.get(pk=1)
with reversion.create_revision():
customer.save()
reversion.set_user(request.user)
reversion.set_comment("Company added from %s" % request.META.get('REMOTE_ADDR', None))
manager = Roles.objects.get(name='manager')
Clients2Users.objects.create(user=customer.id_user, client=customer, role=manager)
if return_url:
return redirect(return_url)
return redirect('home')
return render(request, fo_get_template(request.get_host(), 'enterprise/add_company.html'), {'form':form, 'title':_("Add company")})
def free_shift(request):
json_data = json.loads(request.read())
#user = User.objects.get(username=json_data['username'])
#if not user:
# user = request.user
shift_id = json_data['shift_id']
shift = Shift.objects.get(pk=shift_id)
with transaction.atomic(), reversion.create_revision():
# if shift.volunteer != user:
# return JsonResponse({'status':'failed', 'msg':'Not your shift', 'reason':'notyourshift'})
# if shift.start - timezone.now() < timezone.timedelta(days=1):
# return JsonResponse({'status':'failed', 'msg':'Too little time before shift, contact responsible', 'reason':'toshort'})
removed_user = shift.volunteer
shift.volunteer = None
shift.save()
reversion.set_comment("Removed from shift")
try:
if removed_user.contactinfo.auto_user and not removed_user.contactinfo.claimed and removed_user.shifts.count() == 0:
removed_user.delete()
except AttributeError:
pass
return JsonResponse({'status':'ok'})
return JsonResponse({'status':'failed', 'reason':'unknown'})
def patch(self, request, *args, **kwargs):
""" custom patch method to support django-reversion """
with reversion.create_revision():
reversion.set_user(request.user)
reversion.set_comment('changed through the RESTful API from ip %s' % request.META['REMOTE_ADDR'])
kwargs['partial'] = True
return self.update(request, *args, **kwargs)
def save(self, commit=True):
article = super(CreateNewsBlogArticleForm, self).save(commit=False)
# Set owner to current user
article.owner = self.user
# If 'content' field has value, create a TextPlugin with same and add
# it to the PlaceholderField
content = clean_html(self.cleaned_data.get('content', ''), False)
if content and permissions.has_plugin_permission(
self.user, 'TextPlugin', 'add'):
# If the article has not been saved, then there will be no
# Placeholder set-up for this article yet, so, ensure we have saved
# first.
if not article.pk:
article.save()
if article and article.content:
add_plugin(
placeholder=article.content,
plugin_type='TextPlugin',
language=self.language_code,
body=content,
)
with transaction.atomic():
with create_revision():
article.save()
if self.user:
set_user(self.user)
set_comment(ugettext("Initial version."))
return article
def post(self, request, *args, **kwargs):
data = request.POST.dict().copy()
try:
self.model, editable_fields = self.get_editable_model_and_fields(data)
except NoPermission as e:
return HttpResponseForbidden(
json.dumps(dict(message=e.message)),
content_type='application/json')
if 'slugfield' in data:
self.slug_field = data.pop('slugfield')
self.kwargs.update(data)
obj = self.get_object()
for fieldname in editable_fields:
if fieldname in data:
obj.__setattr__(fieldname, data.pop(fieldname))
if REVERSION_INSTALLED:
with reversion.create_revision():
obj.save()
reversion.set_user(request.user)
reversion.set_comment("Contenteditable")
else:
obj.save() # TODO only save if changed
return HttpResponse(
json.dumps(dict(message='ok')),
content_type='application/json')
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 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
))
return super(TimingMixin, self).form_valid(form)
def save(self, bundle, skip_errors=False):
"""
This is a copy of the parent method, but with the object save modified for versioning
:param bundle:
:param skip_errors:
:return:
"""
self.is_valid(bundle)
if bundle.errors and not skip_errors:
raise ImmediateHttpResponse(response=self.error_response(bundle.request, bundle.errors))
# Check if they're authorized.
if bundle.obj.pk:
self.authorized_update_detail(self.get_object_list(bundle.request), bundle)
else:
self.authorized_create_detail(self.get_object_list(bundle.request), bundle)
# Save FKs just in case.
self.save_related(bundle)
# Save the main object.
with transaction.commit_on_success(), reversion.create_revision():
bundle.obj.save()
reversion.set_user(self.resolve_user(bundle.request.GET))
reversion.set_comment(bundle.data['comment'] or '') # Comment cannot be null
bundle.objects_saved.add(self.create_identifier(bundle.obj))
# Now pick up the M2M bits.
m2m_bundle = self.hydrate_m2m(bundle)
self.save_m2m(m2m_bundle)
return bundle
def giro_status_ventar(modeladmin, request, queryset):
with reversion.create_revision():
for g in queryset:
g.status='V'
g.save()
reversion.set_comment("Giro status ventar admin action")
reversion.set_user(request.user)
def reactivate(request, id):
name = _("Reactivate a Deactivated Enumeration")
e = get_object_or_404(Enumeration, id=id)
if e.status == "D":
#Remove all gatekeeper errors.
GateKeeperError.objects.filter(enumeration=e).delete()
# Status A
e.status = "A"
e.last_updated_ip=request.META['REMOTE_ADDR']
e.enumerated_by = request.user
e.save()
msg = "This record has been reactivated by %s" % (request.user)
Event.objects.create(enumeration=e, event_type="REACTIVATION",
note= msg,
details = msg,
subject=REACTIVATED_SUBJECT,
body = REACTIVATED_BODY)
reversion.set_user(request.user)
reversion.set_comment(msg)
messages.success(request, msg)
elif e.status == "A":
messages.info(request, "This record was not deactivated. Nothing was done.")
else:
messages.info(request, "This record was not deactivated. Nothing was done.")
return HttpResponseRedirect(reverse('report_index'))
def registration_step_personal_details(request, eventid=None):
"""
Step in registration process where user fills in personal details
"""
event = get_object_or_404(Event, pk=eventid)
address = None
if hasattr(request.user, 'address'):
address = request.user.address
if request.method == 'POST':
pd_form = PersonalDetailForm(request.POST, instance=address)
if pd_form.is_valid():
with reversion.create_revision():
address = pd_form.save(commit=False) # We can't save yet because user needs to be set
address.user = request.user
address.save()
reversion.set_user(request.user)
reversion.set_comment(_("Personal info updated via frontend. The following "
"fields changed: %(fields)s" % {'fields': ", ".join(pd_form.changed_data)}))
messages.success(request, _('Your personal information was successfully updated!'),
extra_tags='bg-success') # add bootstrap css class
# TODO: send verification e-mail for e-address after figuring out what to use
# Make registration and set status to 'in STATUS_PREPARATION_IN_PROGRESS'
registration = Registration.objects.create(user=request.user, event=event,
status=Registration.STATUS_PREPARATION_IN_PROGRESS)
registration.save()
return redirect('events:medicaldetailform', eventid=event.id)
else:
messages.error(request, _('Please correct the error below.'), extra_tags='bg-danger')
else:
pd_form = PersonalDetailForm(instance=address)
return render(request, 'events/editpersonaldetails.html', {
'pd_form': pd_form,
'event': event,
})
def delete_study(request, pk):
try:
study = Study.objects.get(pk=pk)
except ObjectDoesNotExist:
msg = "Error study matching query does not exist."
messages.add_message(request, messages.ERROR, ugettext(msg))
return redirect('/lifespan/studies/')
form = DeleteStudyForm(request.POST or None)
if request.method == "POST" and form.is_valid:
if 'cancel' in request.POST:
return redirect('/lifespan/study/%s' % pk)
else:
with reversion.create_revision():
try:
if 'delete_study' in request.POST:
study.delete()
if 'delete_reference' in request.POST:
study.delete()
study.reference.delete()
except AttributeError:
msg = "Error study did not have a reference associated."
messages.add_message(request, messages.ERROR, ugettext(msg))
reversion.set_user(request.user)
comment = request.POST['comment'] or "Deleted study"
reversion.set_comment(comment)
log(request, study, comment)
return redirect('/lifespan/studies/')
ctx = {'study': study, 'form': form}
return render_to_response('lifespan/delete_study.html', ctx,
context_instance=RequestContext(request))
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 edit_pii(request, id):
name = _("Birtday, SSN, and ITIN")
e = get_enumeration_user_manages_or_404(Enumeration, id, request.user)
#Do not let this function work if the PII is already locked.
if e.pii_lock:
raise Http404()
if request.method == 'POST':
form = IndividualPIIForm(request.POST, instance=e)
if form.is_valid():
e = form.save(commit=False)
e.last_updated_ip=request.META['REMOTE_ADDR']
e.status="E"
e.save()
reversion.set_user(request.user)
reversion.set_comment("Edit personal PII.")
return HttpResponseRedirect(reverse('edit_enumeration', args=(id,)))
else:
#The form is invalid
messages.error(request,_("Please correct the errors in the form."))
context = {'form': form,'name':name,}
return render(request, 'generic/bootstrapform.html', context)
#this is a GET
context= {'name':name,
'form': IndividualPIIForm(instance=e)}
return render(request, 'generic/bootstrapform.html', context)
def registration_step_medical_details(request, eventid=None):
"""
Step in registration process where user fills in medical details
"""
mdetails = None
if hasattr(request.user, 'medicaldetails'):
mdetails = request.user.medicaldetails
event = get_object_or_404(Event, pk=eventid)
if request.method == 'POST':
md_form = MedicalDetailForm(request.POST, instance=mdetails)
if md_form.is_valid():
with reversion.create_revision():
details = md_form.save(commit=False)
details.user = request.user
details.save()
reversion.set_user(request.user)
reversion.set_comment(_("Medical info updated via frontend. The following "
"fields changed: %(fields)s" % {'fields': ", ".join(md_form.changed_data)}))
messages.success(request, _('Your medical information was successfully updated!'),
extra_tags='bg-success') # add bootstrap css class
return redirect('events:optionsform', eventid=event.id)
else:
messages.error(request, _('Please correct the error below.'), extra_tags='bg-danger')
else:
md_form = MedicalDetailForm(instance=mdetails)
return render(request, 'events/editmedicaldetails.html', {
'md_form': md_form,
'event': event,
})
def self_take_over(request):
name = "Take control of your individual provider identifer"
if request.method == 'POST':
form = SelfTakeOverForm(request.POST)
if form.is_valid():
e = form.get_enumeration()
#Give ownership to the individual
e.managers.add(request.user)
#make sure this user is also the surrogate
s = Surrogate.objects.get(user=request.user)
s.save()
s.enumerations.add(e)
s.save()
reversion.set_user(request.user)
reversion.set_comment("Self Take Over")
messages.success(request,_("You are now in control of your own record."))
return HttpResponseRedirect(reverse('edit_enumeration', args=(e.id,)))
else:
#The form is invalid
messages.error(request,_("Please correct the errors in the form."))
context = {'form': form,'name':name,}
return render(request, 'generic/bootstrapform.html', context)
#this is a GET
context= {'name':name,
'form': SelfTakeOverForm()}
return render(request, 'generic/bootstrapform.html', context)
def military_address(request, address_id, enumeration_id):
a = Address.objects.get(id=address_id)
e = Enumeration.objects.get(id=enumeration_id)
name = "Edit Military %s for %s" % (a.get_address_purpose_display(),
e.name())
e = get_enumeration_user_manages_or_404(Enumeration, enumeration_id,
request.user)
address = Address.objects.get(id=address_id)
if request.method == 'POST':
form = MilitaryAddressForm(request.POST, instance=address)
if form.is_valid():
a = form.save(commit=False)
a.last_updated_ip=request.META['REMOTE_ADDR']
a.save()
e.status="E"
e.save()
reversion.set_user(request.user)
reversion.set_comment("Create/Edit Military Address")
return HttpResponseRedirect(reverse('edit_enumeration',
args=(enumeration_id, )))
else:
#The form is invalid
messages.error(request,_("Please correct the errors in the form."))
context = {'form': form,'name':name,}
return render(request, 'generic/bootstrapform.html', context)
#this is a GET
context= {'name':name,
'form': MilitaryAddressForm(instance=address)}
return render(request, 'generic/bootstrapform.html', context)
def add_other_taxonomies(request, enumeration_id):
name = _("Add Other Taxonomies")
e = get_enumeration_user_manages_or_404(Enumeration, enumeration_id,
request.user)
if request.method == 'POST':
form = OtherTaxonomyForm(request.POST, instance=e)
if form.is_valid():
e = form.save(commit=False)
e.last_updated_ip=request.META['REMOTE_ADDR']
e.save()
form.save()
form.save_m2m()
reversion.set_user(request.user)
reversion.set_comment("Added/Changed other taxonomies.")
messages.success(request,_("Other taxonomies were added/changed."))
return HttpResponseRedirect(reverse('edit_enumeration',
args=(enumeration_id,)))
else:
#The form is invalid
messages.error(request,_("Please correct the errors in the form."))
context = {'form': form,'name':name,}
return render(request, 'generic/bootstrapform.html', context)
#this is a GET
context= {'name':name,
'form': OtherTaxonomyForm(instance=e)}
return render(request, 'generic/bootstrapform.html', context)
def curriculum_view(request, slug):
pdf = request.GET.get('pdf', False)
try:
curriculum = get_object_or_404(Curriculum, slug=slug)
except Curriculum.DoesNotExist:
raise ContinueResolving
if request.user.is_staff:
units = Unit.objects.filter(curriculum=curriculum)
else:
units = Unit.objects.filter(curriculum=curriculum, login_required=False)
# if this is a POST request we need to process the form data
if request.method == 'POST':
# create a form instance and populate it with data from the request:
form = ChangelogForm(request.POST)
# check whether it's valid:
if form.is_valid():
with reversion.create_revision():
changelog_user = User.objects.get(username=settings.CHANGELOG_USER)
curriculum.save()
# Store some meta-information.
reversion.set_user(changelog_user)
reversion.set_comment(form.cleaned_data['comment'])
return HttpResponseRedirect(curriculum.get_absolute_url())
# if a GET (or any other method) we'll create a blank form
form = ChangelogForm()
changelog = Version.objects.get_for_object(curriculum).filter(revision__user__username=settings.CHANGELOG_USER)
return render(request, 'curricula/curriculum.html', {'curriculum': curriculum, 'pdf': pdf, 'units': units,
'form': form, 'changelog': changelog})
def edit_item(request,iid,*args,**kwargs):
item = get_object_or_404(MDR._concept,pk=iid).item
if not user_can_edit(request.user, item):
if request.user.is_anonymous():
return redirect(reverse('django.contrib.auth.views.login')+'?next=%s' % request.path)
else:
raise PermissionDenied
base_form = MDRForms.wizards.subclassed_edit_modelform(item.__class__)
if request.method == 'POST': # If the form has been submitted...
form = base_form(request.POST,instance=item,user=request.user)
if form.is_valid():
with transaction.atomic(), reversion.create_revision():
change_comments = form.data.get('change_comments',None)
item = form.save()
reversion.set_user(request.user)
if not change_comments:
change_comments = construct_change_message(request,form,None)
reversion.set_comment(change_comments)
return HttpResponseRedirect(url_slugify_concept(item))
else:
form = base_form(instance=item,user=request.user)
return render(request,"aristotle_mdr/actions/advanced_editor.html",
{"item":item,
"form":form,
}
)
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 form_valid(self, form):
with transaction.atomic(), reversion.create_revision():
reversion.set_comment('Edited from site')
reversion.set_user(self.request.user)
return super(EditOrganization, self).form_valid(form)
def create_VariantModel_data(self):
with create_revision():
item = VariantModel.objects.create(
boolean=False,
null_boolean=None,
char="a",
choices_char='a',
text="Foo 'one'",
# skip: models.SlugField()
integer=0,
integers="1,2,3", # CommaSeparatedIntegerField
positive_integer=1,
big_integer=(-BigIntegerField.MAX_BIGINT - 1),
# skip:
# models.PositiveSmallIntegerField()
# models.SmallIntegerField()
time=datetime.time(hour=20, minute=15),
date=datetime.date(year=1941, month=5,
day=12), # Z3 was presented in germany ;)
# PyLucid v0.0.1 release date:
datetime=datetime.datetime(year=2005,
month=8,
day=19,
hour=8,
minute=13,
second=24),
decimal=Decimal('1.23456789'),
float=2.345,
email="*****@*****.**",
url="http://www.pylucid.org/",
file_field=os.path.join(settings.UNITTEST_TEMP_PATH, "foo"),
filepath=os.path.join(settings.UNITTEST_TEMP_PATH, "foo"),
ip_address="192.168.0.1",
# skip: models.GenericIPAddressField()
)
set_comment("initial version")
test_data = (
("boolean", True),
("null_boolean", True),
("null_boolean", False),
("char", "B"),
("choices_char", "b"),
("text", "Bar 'two'"),
# skip: models.SlugField()
("integer", -1),
("integers", "2,3,4"), # CommaSeparatedIntegerField
("positive_integer", 3),
("big_integer", BigIntegerField.MAX_BIGINT),
# models.PositiveSmallIntegerField()
# models.SmallIntegerField()
("time", datetime.time(hour=19, minute=30)),
("date", datetime.date(year=2099, month=12, day=31)),
("datetime",
datetime.datetime(year=2000,
month=1,
day=1,
hour=0,
minute=0,
second=1)),
("decimal", Decimal('3.1415926535')),
("float", 3.1415),
("email", "*****@*****.**"),
("url", "https://github.com/jedie/"),
("file_field", os.path.join(settings.UNITTEST_TEMP_PATH, "bar")),
("filepath", os.path.join(settings.UNITTEST_TEMP_PATH, "bar")),
("ip_address", "10.0.0.0"),
)
for no, (field_name, value) in enumerate(test_data):
with create_revision():
setattr(item, field_name, value)
item.save()
set_comment("%i change: %r field." % (no, field_name))
return item, test_data
def create_Factory_reverse_relation_data(self):
from django.db import transaction
with transaction.atomic(), create_revision():
manufacturer = Factory.objects.create(name="factory one",
address="1 Fake Plaza")
different_manufacturer = Factory.objects.create(
name="factory two", address="1 Fake Plaza")
car1 = Car.objects.create(name="motor-car one",
manufacturer=manufacturer)
car2 = Car.objects.create(name="motor-car two",
manufacturer=manufacturer)
car3 = Car.objects.create(name="motor-car three",
manufacturer=manufacturer)
car1.save()
car2.save()
car3.save()
manufacturer.save()
set_comment("initial version 1")
if self.verbose:
print("version 1:", manufacturer)
# Factory One
""" 1 to 2 diff:
"manufacture" ForeignKey:
"factory one" -> "factory I"
"supplier" ManyToManyField:
+ new, would be renamed supplier
- would be deleted supplier
- would be removed supplier
= always the same supplier
"""
with transaction.atomic(), create_revision():
car3.delete()
car4 = Car.objects.create(name="motor-car four",
manufacturer=manufacturer)
car4.save()
worker1 = Person.objects.create(name="Bob Bobertson",
workplace=manufacturer)
worker1.save()
manufacturer.save()
set_comment(
"version 2: discontinued car-three, add car-four, add Bob the worker"
)
if self.verbose:
print("version 2:", manufacturer)
# motor-car one from factory I supplier(s): always the same supplier, new, would be renamed supplier
""" 2 to 3 diff:
"name" CharField:
"motor-car one" -> "motor-car II"
"manufacture" ForeignKey:
"factory I" -> "factory II"
"supplier" ManyToManyField:
new, would be renamed supplier -> not new anymore supplier
= always the same supplier
"""
with transaction.atomic(), create_revision():
car2.manufacturer = different_manufacturer
car2.save()
manufacturer.save()
set_comment("version 3: car2 now built by someone else.")
if self.verbose:
print("version 3:", manufacturer)
# version 3: motor-car II from factory II supplier(s): always the same supplier, not new anymore supplier
return manufacturer
def create_FactoryCar_data(self):
with create_revision():
manufacture = Factory.objects.create(name="factory one",
address="1 Fake Plaza")
supplier1 = Factory.objects.create(name="always the same supplier",
address="1 Fake Plaza")
supplier2 = Factory.objects.create(
name="would be deleted supplier", address="1 Fake Plaza")
supplier3 = Factory.objects.create(
name="would be removed supplier", address="1 Fake Plaza")
car = Car.objects.create(name="motor-car one",
manufacturer=manufacture)
car.supplier.add(supplier1, supplier2, supplier3)
car.save()
set_comment("initial version 1")
if self.verbose:
print("version 1:", car)
# motor-car one from factory one supplier(s): always the same supplier, would be deleted supplier, would be removed supplier
""" 1 to 2 diff:
"manufacture" ForeignKey:
"factory one" -> "factory I"
"supplier" ManyToManyField:
+ new, would be renamed supplier
- would be deleted supplier
- would be removed supplier
= always the same supplier
"""
with create_revision():
manufacture.name = "factory I"
manufacture.save()
supplier2.delete() # - would be deleted supplier
supplier4 = Factory.objects.create(
name="new, would be renamed supplier", address="1 Fake Plaza")
car.supplier.add(supplier4) # + new, would be renamed supplier
car.supplier.remove(supplier3) # - would be removed supplier
car.save()
set_comment("version 2: change ForeignKey and ManyToManyField.")
if self.verbose:
print("version 2:", car)
# motor-car one from factory I supplier(s): always the same supplier, new, would be renamed supplier
""" 2 to 3 diff:
"name" CharField:
"motor-car one" -> "motor-car II"
"manufacture" ForeignKey:
"factory I" -> "factory II"
"supplier" ManyToManyField:
new, would be renamed supplier -> not new anymore supplier
= always the same supplier
"""
with create_revision():
car.name = "motor-car II"
manufacture.name = "factory II"
supplier4.name = "not new anymore supplier"
supplier4.save()
car.save()
set_comment(
"version 3: change CharField, ForeignKey and ManyToManyField.")
if self.verbose:
print("version 3:", car)
# version 3: motor-car II from factory II supplier(s): always the same supplier, not new anymore supplier
return car
def _delete_object(obj):
"""Save an object and delete revision"""
logger.warning('Deleting %s (id: %s)', obj, obj.id)
with transaction.atomic(), revisions.create_revision():
obj.delete()
revisions.set_comment('openstack_sync::_delete_object')
def edit_installer(request, slug):
"""Display an edit form for install scripts
Args:
request: Django request object
slug (str): installer slug
Returns:
Django response
"""
installer = get_object_or_404(Installer, slug=slug)
# Handle installer deletion in a separate view
if "delete" in request.POST:
return redirect(
reverse("delete_installer", kwargs={"slug": installer.slug}))
# Extract optional revision ID from parameters
revision_id = request.GET.get("revision")
try:
revision_id = int(revision_id)
except (ValueError, TypeError):
revision_id = None
draft_data = None
versions = Version.objects.get_for_object(installer)
# Reset reason when the installer is edited.
installer.reason = ""
for version in versions:
if revision_id:
# Display the revision given in the GET parameters
if version.id == revision_id:
draft_data = version.field_dict
break
else:
# Display the latest revision created by the current logged in user
if (version.revision.user == request.user or request.user.is_staff
) and version.revision.date_created > installer.updated_at:
draft_data = version.field_dict
revision_id = version.id
break
if draft_data:
draft_data["reason"] = ""
if "runner_id" in draft_data:
draft_data["runner"] = draft_data["runner_id"]
form = InstallerEditForm(request.POST or None,
instance=installer,
initial=draft_data)
if request.method == "POST" and form.is_valid():
# Force the creation of a revision instead of creating a new installer
with reversion.create_revision():
installer = form.save(commit=False)
reversion.set_user(request.user)
reversion.set_comment("[{}] {} by {} on {}".format(
"draft" if installer.draft else "submission",
slug,
request.user.username,
timezone.now(),
))
reversion.add_to_revision(installer)
messages.info(request, "Installer saved")
if draft_data and draft_data["draft"]:
return redirect("edit_installer", slug=installer.slug)
else:
return redirect("installer_complete", slug=installer.game.slug)
if draft_data:
messages.info(
request,
"You are viewing a draft of the installer which does not "
"reflect the currently available installer. Changes will be "
"published once it goes through moderation.",
)
return render(
request,
"installers/form.html",
{
"form": form,
"game": installer.game,
"new": False,
"installer": installer,
"versions": versions,
"revision_id": revision_id,
},
)
def dispatch(self, request, *args, **kwargs):
if self.revision_request_creates_revision(request):
reversion.set_comment(self.name)
return super().dispatch(request, *args, **kwargs)
def revision_pre_delete_signal(sender, **kwargs):
#send_signal_for_websocket_time_refresh(kwargs['instance'], 'pre_delete')
with reversion.create_revision():
kwargs['instance'].save()
reversion.set_comment("Deletado pelo sinal.")
def handle(self, *args, **options):
if options["date"]:
date = datetime.datetime.strptime(options["date"], "%Y-%m-%d").date()
else:
date = datetime.date.today()
with open(options["file"]) as csvfile:
reader = csv.reader(csvfile)
for row in reader:
with transaction.atomic(), reversion.create_revision():
student_number = row[0]
try:
student = Student.objects.get(student_number=student_number)
except Student.DoesNotExist:
self.stderr.write(
"Failed to find student with student number '{}' in database".format(
student_number
)
)
continue
person = student.person
if not row[1].lower() == options["yes-value"].lower():
student.enrolled = False
student.save()
person = Person.objects.get(pk=student.person_id)
try:
member = person.member
except Member.DoesNotExist:
person.save()
continue
if (
person.membership_status == MembershipStatus.NONE
and member.date_to is None
):
member.date_to = date
message = "Membership revoked. Student is either unknown or no longer a student according to CSa."
reversion.set_comment(message)
member.save()
self.stdout.write(
"Student with student number '{}' is no longer active, membership ended.".format(
student_number
)
)
else:
reversion.set_comment("Student confirmed by CSa")
student.date_verified = date
self.stdout.write(
"Student with student number '{}' is still active".format(
student_number
)
)
student.save()
# Person is saved so the reversion revision is made
person.save()
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.get_profile().language)
return HttpResponse(json.dumps(response),
content_type="application/json")
def edit_swarm(request, swarm_id=None):
if swarm_id:
# Need to populate form from swarm
swarm = get_object_or_404(models.Swarm, id=swarm_id)
initial = {
'app_id': swarm.app.id,
'squad_id': swarm.squad.id,
'tag': swarm.release.build.tag,
'config_name': swarm.config_name,
'config_yaml': yamlize(swarm.config_yaml),
'env_yaml': yamlize(swarm.env_yaml),
'volumes': yamlize(swarm.volumes),
'run_as': swarm.run_as or 'nobody',
'mem_limit': swarm.mem_limit,
'memsw_limit': swarm.memsw_limit,
'proc_name': swarm.proc_name,
'size': swarm.size,
'pool': swarm.pool or '',
'balancer': swarm.balancer,
'config_ingredients': [
ing.pk for ing in swarm.config_ingredients.all()]
}
version_diffs, _last_edited = _get_version_diffs_for_obj(
swarm, VERSION_DIFFS_LIMIT)
compiled_config = yamlize(swarm.get_config())
compiled_env = yamlize(swarm.get_env())
else:
initial = None
swarm = models.Swarm()
version_diffs = []
compiled_config = yamlize({})
compiled_env = yamlize({})
form = forms.SwarmForm(request.POST or None, initial=initial)
error_msg = None
if form.is_valid():
data = form.cleaned_data
# Check if we already have a swarm with these parameters
# Note: exclude itself, in case we are editing an existing swarm
n = models.Swarm.objects.filter(
app=data['app_id'],
proc_name=data['proc_name'],
config_name=data['config_name'],
squad=data['squad_id'],
).exclude(id=swarm_id).count()
if n > 0:
error_msg = (
'Swarm already exists for this app, proc, config and squad!'
)
else:
swarm.app = models.App.objects.get(id=data['app_id'])
swarm.squad = models.Squad.objects.get(id=data['squad_id'])
swarm.config_name = data['config_name']
swarm.config_yaml = data['config_yaml']
swarm.env_yaml = data['env_yaml']
swarm.volumes = data['volumes']
swarm.run_as = data['run_as']
swarm.mem_limit = data['mem_limit']
swarm.memsw_limit = data['memsw_limit']
swarm.proc_name = data['proc_name']
swarm.size = data['size']
swarm.pool = data['pool'] or None
swarm.balancer = data['balancer'] or None
swarm.release = swarm.get_current_release(data['tag'])
swarm.save()
swarm.config_ingredients.clear()
for ingredient in data['config_ingredients']:
swarm.config_ingredients.add(ingredient)
# Set the version metadata as recommended in the low-level API docs
# https://django-reversion.readthedocs.org/en/latest/api.html?#version-meta-data
revisions.set_user(request.user)
revisions.set_comment("Created from web form.")
do_swarm(swarm, request.user)
# If app is part of the user's default dashboard, redirect there.
if app_in_default_dashboard(swarm.app, request.user):
return redirect('default_dash')
return redirect('dash')
return render(request, 'swarm.html', {
'swarm': swarm,
'form': form,
'error_msg': error_msg,
'btn_text': 'Swarm',
'version_diffs': version_diffs,
'version_diffs_limit': VERSION_DIFFS_LIMIT,
'compiled_config': compiled_config,
'compiled_env': compiled_env
})
def workorderwizard_submit(request):
# Manually checking if user is authenticated rather than using @login_required
# in order to return a 401 status that the workorder wizard understands so it can display a specific error message
# instead of returning a 302 redirect to the login page, which wouldn't work because this view is called via AJAX
if not request.user.is_authenticated:
return HttpResponse('Unauthorized', status=401)
# load JSON
data = json.loads(request.body.decode('utf-8'))
# check that all required fields are present
mandatory_fields = ('org', 'event_name', 'location', 'start', 'end',
'setup_complete', 'services')
if not all(key in data for key in mandatory_fields):
return HttpResponse('Unprocessable Entity', status=422)
reversion.set_comment('Event submitted using work order wizard')
# create event object and populate fields
event = events_models.Event2019()
event.submitted_by = request.user
event.submitted_ip = request.META.get('REMOTE_ADDR')
event.contact = request.user
event.event_name = data['event_name']
if 'description' in data:
event.description = data['description']
try:
event.location = events_models.Location.objects.filter(
show_in_wo_form=True).get(pk=data['location'])
except events_models.Location.DoesNotExist:
return HttpResponse('Unprocessable Entity', status=422)
event.datetime_setup_complete = parse_datetime(data['setup_complete'])
event.datetime_start = parse_datetime(data['start'])
event.datetime_end = parse_datetime(data['end'])
try:
org = events_models.Organization.objects.get(pk=data['org'])
except events_models.Organization.DoesNotExist:
return HttpResponse('Unprocessable Entity', status=422)
event.billing_org = org
# populate many-to-many fields
event.save()
event.org.add(org)
# add services
for service_data in data['services']:
if 'id' not in service_data:
return HttpResponse('Unprocessable Entity', status=422)
try:
service = events_models.Service.objects.filter(
enabled_event2019=True).get(shortname=service_data['id'])
except events_models.Service.DoesNotExist:
return HttpResponse('Unprocessable Entity', status=422)
service_instance = events_models.ServiceInstance()
service_instance.service = service
service_instance.event = event
if 'detail' in service_data:
service_instance.detail = service_data['detail']
service_instance.save()
# add extras
for extra_data in data['extras']:
if not all(key in extra_data for key in ('id', 'quantity')):
return HttpResponse('Unprocessable Entity', status=422)
try:
extra = events_models.Extra.objects \
.filter(disappear=False, services__in=event.serviceinstance_set.values_list('service', flat=True)) \
.distinct().get(name=extra_data['id'])
except events_models.Extra.DoesNotExist:
return HttpResponse('Unprocessable Entity', status=422)
extra_instance = events_models.ExtraInstance()
extra_instance.extra = extra
extra_instance.event = event
extra_instance.quant = extra_data['quantity']
extra_instance.save()
# send confirmation email
email_body = 'You have successfully submitted the following event.'
bcc = [settings.EMAIL_TARGET_VP, settings.EMAIL_TARGET_HP
] if event.has_projection else [settings.EMAIL_TARGET_VP]
email = EventEmailGenerator(event=event,
subject='New Event Submitted',
to_emails=[request.user.email],
body=email_body,
bcc=bcc)
email.send()
# If the user does not have permission to submit events on behalf of the selected organization,
# send an email to the organization to alert them that the event was submitted
# if not request.user.has_perm('events.create_org_event', org):
# email_body = ('The following event was submitted. You are receiving this email because the user who submitted '
# 'this event is not expressly authorized to submit events on behalf of {}. The organization owner '
# 'can update authorized users at {}.'.format(org.name,
# request.scheme + '://' + request.get_host() + reverse('my:org-edit', args=(org.pk,))))
# email = EventEmailGenerator(event=event, subject='Event Submitted on behalf of {}'.format(org.name),
# to_emails=[org.exec_email], body=email_body, bcc=[settings.EMAIL_TARGET_W])
# email.send()
# return response with the URL to the event detail page
return HttpResponse(
json.dumps({'event_url': reverse('events:detail', args=[event.pk])}))
def _save_as_revision(self, object_list, user, comment):
for object in object_list:
object.save()
reversion.set_user(user=user)
reversion.set_comment(comment=comment)
def delete(self, request, *args, **kwargs):
with create_revision():
revisions.set_user(self.request.user)
revisions.set_comment("Deleted from web form.")
return super(DeleteApp, self).delete(request)
def from_toolinfo(self, record, creator, origin, comment=None):
"""Create or update a Tool using data from a toolinfo record.
:param self: This manager
:type self: ToolManager
:param record: Toolinfo record. May be mutated as a side effect.
:type record: dict
:param creator: User creating/updating the record
:type creator: settings.AUTH_USER_MODEL
:param origin: Origin of this submission
:type origin: str
:param comment: User provided comment for this change
:type comment: str
:returns: (tool (Tool), was_created (boolean), has_changes (boolean))
:rtype: tuple
"""
record["created_by"] = creator
record["modified_by"] = creator
record["origin"] = origin
record = self.normalize_toolinfo(record)
with reversion.create_revision():
reversion.add_meta(RevisionMetadata)
reversion.set_user(creator)
if comment is not None:
reversion.set_comment(comment)
with auditlog_context(creator, comment):
tool, created, revived = self.get_create_or_revive(
name=record["name"], defaults=record
)
if created:
return tool, created, False
# Compare input to prior model and decide if anything of note has
# changed. Revived models are always considered changed.
has_changes = revived
for key, value in record.items():
if key in self.VARIANT_FIELDS:
continue
prior = getattr(tool, key)
if value != prior:
if not revived and key in self.INVARIANT_FIELDS:
# Invariant fields are allowed to change when reviving
# a deleted record.
raise ValidationError(
_(
"Changing %(key)s after initial "
"object creation is not allowed"
),
code="invariant",
params={"key": key},
)
if value == "" and prior is None:
# T293103: guard against blank as null storage
# conversion causing infinite empty diffs
continue
setattr(tool, key, value)
has_changes = True
logger.debug(
"%s: Updating %s to %s (was %s)",
record["name"],
key,
value,
prior,
)
if has_changes:
with auditlog_context(creator, comment):
tool.save()
return tool, False, has_changes
def set_revision_comment(comment, form):
changes_string = make_changes_string(form)
if changes_string:
reversion.set_comment(comment + " - " + changes_string)
else:
reversion.set_comment(comment)
def _save_object(obj, comment):
"""Save an object and create revision"""
logger.info('Saving {} (id: {}; {})'.format(obj, obj.id, comment))
with transaction.atomic(), revisions.create_revision():
obj.save()
revisions.set_comment(comment)
def ajax_get_item_form(request, course_id, item_id=None):
''' the transaction decorator helps, but people can still hammer the submit button
and create tons of assignments. for some reason, only one shows up right away, and the rest
don't appear until reload '''
course = get_object_or_404(Course, pk=course_id)
item = None
lists = None
if request.POST:
if item_id:
item = get_object_or_404(Item, pk=item_id)
form = ItemForm(request.POST, instance=item, prefix="item")
else:
form = ItemForm(request.POST, prefix="item")
if form.is_valid():
with reversion.create_revision():
if item_id is None:
# a new item!
item = form.save()
dem = None
if item.category.allow_multiple_demonstrations:
# must have at least one demonstration; create a new one
dem = Demonstration()
dem.name = 'Dem. 1'
dem.item = item
dem.save()
# must create blank marks for each student
for student in Student.objects.filter(course=course):
mark, created = Mark.objects.get_or_create(
item=item, student=student, demonstration=dem)
else:
# modifying an existing item
old_item = Item.objects.get(pk=item.pk)
item = form.save()
gradebook_recalculate_on_item_change(item,
old_item=old_item)
reversion.set_user(request.user)
reversion.set_comment("gradebook")
# Should I use the django message framework to inform the user?
# This would not work in ajax unless we make some sort of ajax
# message handler.
messages.success(request, '%s saved' % (item, ))
return HttpResponse('SUCCESS')
else:
if item_id:
item = get_object_or_404(Item, pk=item_id)
form = ItemForm(instance=item, prefix="item")
# TODO: remove TC hard-coding
if item.category.name == 'Standards':
students_missing = Student.objects.filter(
mark__item=item).annotate(
best_mark=Max('mark__mark')).filter(best_mark__lt=3)
if not students_missing: students_missing = ('None', )
lists = ({
'heading': 'Students Missing This Item',
'items': students_missing
}, )
else:
active_mps = course.marking_period.filter(active=True)
if active_mps:
form = ItemForm(initial={
'course': course,
'marking_period': active_mps[0]
},
prefix="item")
else:
form = ItemForm(initial={'course': course}, prefix="item")
form.fields['marking_period'].queryset = course.marking_period.all()
form.fields['category'].queryset = Category.objects.filter(
display_in_gradebook=True)
form.fields['benchmark'].queryset = Benchmark.objects.filter()
form.fields['category'].widget.attrs = {
'onchange':
"Dajaxice.ecwsp.benchmark_grade.check_fixed_points_possible(Dajax.process, {'category':this.value})"
}
if item and item.category.fixed_points_possible:
form.fields['points_possible'].widget.attrs = {'disabled': 'true'}
return render_to_response(
'sis/generic_form_fragment.html',
{
'form': form,
'item_id': item_id,
'lists': lists,
},
RequestContext(request, {}),
)
bundle['errors'] = 'Error while deleting the A record.' + str(e)
return
try:
bundle['ptr'].delete()
except ValidationError, e:
rollback = True
bundle['errors'] = 'Error while deleting the PTR record.' + str(e)
return
try:
sreg.save()
for name in view_names:
sreg.views.add(View.objects.get(name=name))
if use_reversion:
reversion.set_comment('Migrated via combine()')
except ValidationError, e:
rollback = True
bundle['errors'] = 'Error while creating the SREG record.' + str(e)
return
for nic in bundle['hwadapters']:
hw_info, kvs = nic.emit_hwadapter()
if not hw_info['mac']:
rollback = True
return
try:
hw, _ = HWAdapter.objects.get_or_create(sreg=sreg,
mac=hw_info['mac'])
def make_amendment(self, user):
"""
Creates an amendment (new record) of this PCA copying
over all values and related objects, marks the existing
PCA as non current and creates a manual restore point.
The user who created the amendment is also captured.
"""
with transaction.atomic(), reversion.create_revision():
# make original as non current
original = self
original.current = False
original.save()
# copy base properties to new object
amendment = deepcopy(original)
amendment.pk = None
amendment.amendment = True
amendment.amended_at = datetime.datetime.now()
amendment.amendment_number += 1 # increment amendment count
amendment.original = original
amendment.save()
# make manual revision point
reversion.set_user(user)
reversion.set_comment("Amendment {} created for PCA: {}".format(
amendment.amendment_number, amendment.number))
amendment.unicef_managers = original.unicef_managers.all()
# copy over grants
for grant in original.pcagrant_set.all():
PCAGrant.objects.create(pca=amendment,
grant=grant.grant,
funds=grant.funds)
# copy over sectors
for pca_sector in original.pcasector_set.all():
new_sector = PCASector.objects.create(pca=amendment,
sector=pca_sector.sector)
for output in pca_sector.pcasectoroutput_set.all():
PCASectorOutput.objects.create(pca_sector=new_sector,
output=output.output)
for goal in pca_sector.pcasectorgoal_set.all():
PCASectorGoal.objects.create(pca_sector=new_sector,
goal=goal.goal)
for activity in pca_sector.pcasectoractivity_set.all():
PCASectorActivity.objects.create(pca_sector=pca_sector,
activity=activity.activity)
# copy over indicators for sectors and reset programmed number
for pca_indicator in pca_sector.indicatorprogress_set.all():
IndicatorProgress.objects.create(
pca_sector=new_sector,
indicator=pca_indicator.indicator,
programmed=0)
# copy over intermediate results and activities
for pca_ir in pca_sector.pcasectorimmediateresult_set.all():
new_ir = PCASectorImmediateResult.objects.create(
pca_sector=new_sector,
Intermediate_result=pca_ir.Intermediate_result)
new_ir.wbs_activities = pca_ir.wbs_activities.all()
for event in fresh_data['events']:
event['case'] = case
CaseEvent.objects.update_or_create(**event)
diff_keys.append('events')
fresh_linked_cases_ids = fresh_data.get('linked_cases_ids')
if fresh_linked_cases_ids and fresh_linked_cases_ids != old_data.get(
'linked_cases_ids'):
for case_id in fresh_linked_cases_ids:
linked_case = Case.objects.filter(id=case_id).first()
if linked_case:
case.linked_cases.add(linked_case)
diff_keys.append('linked_cases')
if fresh_data['case'].get('linked_case_number'):
for case_num in fresh_data['case']['linked_case_number']:
if not case.linked_cases.filter(case_num=case_num).count():
linked_case = Case.objects.filter(
case_num=case_num,
court=fresh_data['case']['court']).first()
if linked_case:
case.linked_cases.add(linked_case)
if len(diff_keys):
comment_message = 'Изменено: ' + ', '.join(diff_keys)
reversion.set_comment(comment_message)
merger_updater = MergerUpdater()
def testGetComment(self):
with reversion.create_revision():
reversion.set_comment("comment v1")
self.assertEqual(reversion.get_comment(), "comment v1")
def handle(self, **options):
start_time = time.time()
DIFF_FIELDS = [u'title', u'task_text', u'score_max', u'deadline_time']
students_tasks_info = {}
for task in Task.objects.filter(
sended_notify=False).prefetch_related("groups"):
course = task.course
if task.is_hidden:
continue
task_created = False
task_changed = False
version_list = reversion.get_unique_for_object(task)
task_info = [''] * len(DIFF_FIELDS)
for i_version, version in enumerate(version_list):
if version.field_dict['sended_notify']:
break
i_version_next = i_version + 1
if i_version_next == len(version_list):
task_created = True
break
if not version.field_dict['send_to_users']:
continue
for i_field, field in enumerate(DIFF_FIELDS):
if field == u'deadline_time':
prev = add_timezone(version.field_dict[field])
cur = add_timezone(
version_list[i_version_next].field_dict[field])
else:
prev, cur = version.field_dict[field], version_list[
i_version_next].field_dict[field]
if prev != cur:
task_info[i_field] = field
task_changed = True
if not version.field_dict['is_hidden'] and version_list[
i_version_next].field_dict['is_hidden']:
task_created = True
if task_created or task_changed:
for group in task.groups.all():
for student in group.students.all():
translation.activate(student.get_profile().language)
diff_fields_str = {
u'title': _(u'nazvanie').lower(),
u'task_text': _(u'formulirovka').lower(),
u'score_max': _(u'max_ball').lower(),
u'deadline_time': _(u'data_sdachi').lower()
}
task_info_changed = (task, task_created) + tuple(
map(lambda a: diff_fields_str[a],
filter(lambda a: a != '', task_info)))
if student.id in students_tasks_info:
if course.id in students_tasks_info[student.id]:
students_tasks_info[student.id][course.id][
task.id] = task_info_changed
else:
students_tasks_info[student.id][course.id] = {
'course': course,
task.id: task_info_changed
}
else:
students_tasks_info[student.id] = {
'user': student,
course.id: {
'course': course,
task.id: task_info_changed
}
}
translation.deactivate()
with reversion.create_revision():
task.sended_notify = True
task.save()
reversion.set_comment("Send notification")
domain = Site.objects.get_current().domain
from_email = settings.DEFAULT_FROM_EMAIL
notify_messages = []
for key_user, courses_info in students_tasks_info.iteritems():
user = courses_info['user']
if not user.email:
continue
lang = user.get_profile().language
translation.activate(lang)
subject = u"{0}, ".format(
user.first_name) + _(u'proizoshli_izmeneniya_v_kursah')
context = {
"user": user,
"domain": domain,
"title": subject,
"courses_info": courses_info,
}
plain_text = render_to_string('email_notification_task.txt',
context)
html = render_to_string('email_notification_task.html', context)
notify_messages.append(
(subject, plain_text, html, from_email, [user.email]))
translation.deactivate()
num_sent = 0
if notify_messages:
num_sent = send_mass_mail_html(notify_messages)
# logging to cron log
print "Command send_task_notifications send {0} email(s) and took {1} seconds"\
.format(num_sent, time.time() - start_time)
def testSetComment(self):
with reversion.create_revision():
reversion.set_comment("comment v1")
obj = TestModel.objects.create()
self.assertSingleRevision((obj, ), comment="comment v1")
def new_donation(sender, is_pdt, **kwargs):
try:
int(sender.item_number)
# Item number is a number, thus not a donation ID (probably object ID)
return
except ValueError:
pass
timestamp = timezone.now()
amount = decimal.Decimal(sender.mc_gross) - decimal.Decimal(
sender.mc_fee) # Formula in donations/pdf.html as well
donation_by = ' '.join((sender.first_name, sender.last_name))
language = sender.custom
defaults = {
'date': timestamp,
'amount': amount,
'donor':
donation_by, # TODO: Support also anonymous donations (in that case this field should be blank)
'message': sender.memo,
'timestamp': timestamp,
'donation_by':
donation_by, # This field is internal and should still be filled for anonymous donations
'email': sender.payer_email,
'gross': sender.mc_gross,
'fee': sender.mc_fee,
}
if is_pdt:
defaults['pdt_id'] = sender.pk
else:
defaults['ipn_id'] = sender.pk
donation, created = models.Donation.objects.get_or_create(
txn_id=sender.txn_id, defaults=defaults)
if not created:
if is_pdt:
reversion.set_comment("Got PDT, setting ID.")
donation.pdt_id = sender.pk
else:
reversion.set_comment("Got IPN, setting ID.")
donation.ipn_id = sender.pk
if sender.test_ipn:
reversion.set_comment("Got a test IPN, marking it as a test.")
if donation.internal_comment:
donation.internal_comment += ' Test.'
else:
donation.internal_comment += 'Test.'
donation.save()
# Donation has already been created
return
else:
reversion.set_comment("Initial version.")
site = sites_models.Site.objects.get_current()
protocol = 'https' if getattr(settings, 'USE_HTTPS', False) else 'http'
base_url = "%s://%s" % (protocol, site.domain)
donation_url = urlresolvers.reverse(
'admin:%s_%s_change' %
(donation._meta.app_label, donation._meta.object_name.lower()),
args=(donation.pk, ))
donation_url = '%s%s' % (base_url, donation_url)
# TODO: Should we reverse something here?
home_url = '%s%s' % (base_url, '/')
class Request(object):
REQUEST = {
'language': language,
}
current_page = None
context = {
'EMAIL_SUBJECT_PREFIX': settings.EMAIL_SUBJECT_PREFIX,
'site': site,
'protocol': protocol,
'base_url': base_url,
'home_url': home_url,
'donation_url': donation_url,
'obj': sender,
'donation_by': donation_by,
'amount': amount,
'request':
Request(), # Fake request object for page_url to work in e-mails
}
with translation.override(language):
subject = loader.render_to_string('donations/new_donation_subject.txt',
context)
# Email subject *must not* contain newlines
subject = ''.join(subject.splitlines())
email = loader.render_to_string('donations/new_donation_email.txt',
context)
mail.send_mail(subject, email, None,
[settings.PAYPAL_RECEIVER_EMAIL_DONATION_ALIAS])
with translation.override(language):
subject = loader.render_to_string(
'donations/donation_confirmation_subject.txt', context)
# Email subject *must not* contain newlines
subject = ''.join(subject.splitlines())
email = loader.render_to_string(
'donations/donation_confirmation_email.txt', context)
mail.send_mail(subject, email,
settings.PAYPAL_RECEIVER_EMAIL_DONATION_ALIAS,
[sender.payer_email])
def status(self, request, *args, **kwargs):
try:
for item in request.data.get("exams_data"):
serializer = StatusScheduledExamSerializer(
data=item, context={"request": request})
serializer.is_valid(raise_exception=True)
request_data = serializer.data
try:
exams = domain_models.ScheduledExam.objects.filter(
pk__in=request_data["scheduled_exam_ids"])
if not exams:
return Response(
{
"detail": "No exams found",
"status_code": status.HTTP_404_NOT_FOUND
},
status=status.HTTP_404_NOT_FOUND)
for exam in exams:
upd = True
try:
if exam.scheduledexamphonecall.attempt <= 4 and request_data[
"status"] == domain_models.ScheduledExam.PHONE_CALL_NOT_ANSWERED:
# update phonecalltime on schedule
upd = False
with reversion.create_revision():
instance = exam.scheduledexamphonecall.attempt
newtime = instance.call_time + \
datetime.timedelta(minutes=instance.ATTEMPT_INCR_MINUTES(instance.attempt))
instance.call_time = newtime
instance.attempt = instance.attempt + 1
instance.save()
reversion.set_user(self.request.user)
reversion.set_comment(
"Sara Concierge Backoffice Call Attempt: #{}"
.format(instance.attempt))
if instance.attempt >= 4:
upd = True
except Exception as e:
print('Not Scheduled Exam Call')
finally:
if upd is True:
exam.status = request_data["status"]
exam.modified_by = self.request.user
exam.save()
except Exception as exc:
return Response(
{
"detail": str(exc),
"status_code": status.HTTP_400_BAD_REQUEST
},
status=status.HTTP_400_BAD_REQUEST)
return Response(status=status.HTTP_200_OK)
except Exception as e:
return Response(
{
"detail": str(e),
"status_code": status.HTTP_400_BAD_REQUEST
},
status=status.HTTP_400_BAD_REQUEST)
def testSetCommentNoBlock(self):
with self.assertRaises(reversion.RevisionManagementError):
reversion.set_comment("comment v1")
def _generate_lone_pairings(round_, overwrite=False):
with transaction.atomic():
existing_pairings = LonePlayerPairing.objects.filter(round=round_)
if existing_pairings.count() > 0:
if overwrite:
delete_pairings(round_)
else:
raise PairingsExistException()
else:
# Always overwrite pairing byes
PlayerBye.objects.filter(round=round_,
type='full-point-pairing-bye').delete()
# Perform any registrations and withdrawals
for reg in round_.playerlateregistration_set.select_related(
'player').nocache():
reg.perform_registration()
for wd in round_.playerwithdrawal_set.select_related(
'player').nocache():
wd.perform_withdrawal()
# Sort by seed rating/score
season_players = SeasonPlayer.objects.filter(
season=round_.season).select_related('player', 'loneplayerscore',
'season__league').nocache()
for sp in season_players:
if sp.seed_rating is None:
sp.seed_rating = sp.player.rating_for(round_.season.league)
with reversion.create_revision():
reversion.set_comment('Set seed rating.')
sp.save()
season_players = sorted(
season_players,
key=lambda sp: sp.get_loneplayerscore().pairing_sort_key(),
reverse=True)
# Create byes for unavailable players
current_byes = {
bye.player
for bye in PlayerBye.objects.filter(
round=round_).select_related('player').nocache()
}
unavailable_players = {avail.player for avail in
PlayerAvailability.objects.filter(round=round_, is_available=False) \
.select_related('player').nocache()}
active_players = {sp.player for sp in season_players if sp.is_active}
players_needing_byes = unavailable_players & active_players - current_byes
for p in players_needing_byes:
with reversion.create_revision():
reversion.set_comment('Generated pairings.')
PlayerBye.objects.create(round=round_,
player=p,
type='half-point-bye')
# Don't generate pairings for players that have been withdrawn or have byes
include_players = {
sp
for sp in season_players
if sp.is_active and sp.player not in current_byes
and sp.player not in unavailable_players
}
previous_pairings = LonePlayerPairing.objects.filter(round__season=round_.season,
round__number__lt=round_.number) \
.order_by('round__number').select_related('white', 'black', 'round').nocache()
previous_byes = PlayerBye.objects.filter(round__season=round_.season,
round__number__lt=round_.number) \
.order_by('round__number').select_related('player', 'round').nocache()
# Run the pairing algorithm
if round_.season.league.pairing_type == 'swiss-dutch-baku-accel':
pairing_system = DutchLonePairingSystem(accel='baku')
else:
pairing_system = DutchLonePairingSystem()
lone_pairings, byes = pairing_system.create_lone_pairings(
round_, season_players, include_players, previous_pairings,
previous_byes)
# Save the lone pairings
rank_dict = lone_player_pairing_rank_dict(round_.season)
for lone_pairing in lone_pairings:
lone_pairing.refresh_ranks(rank_dict)
with reversion.create_revision():
reversion.set_comment('Generated pairings.')
lone_pairing.save()
# Save pairing byes and update player ranks for all byes
for bye in byes + list(
PlayerBye.objects.filter(
round=round_).select_related('player').nocache()):
bye.refresh_rank(rank_dict)
with reversion.create_revision():
reversion.set_comment('Generated pairings.')
bye.save()
def revision_pre_delete_signal(sender, **kwargs):
with reversion.create_revision():
kwargs['instance'].save()
reversion.set_comment("Deletado pelo sinal.")
