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.")