def test_overrides(self): # Try to render a page from a nonexistent template override # and make sure it doesn't exist self.expect_template_error('BLAARG.NOTANACTUALTEMPLATE') # Create a template override and make sure you can see it with reversion.create_revision(): to = TemplateOverride(name='BLAARG.TEMPLATEOVERRIDE', content='Hello') to.save() self.assertTrue( self.get_response_for_template('BLAARG.TEMPLATEOVERRIDE') == 'Hello') # Save an update to the template override and make sure you see that too with reversion.create_revision(): to.content = 'Goodbye' to.save() self.assertTrue( self.get_response_for_template('BLAARG.TEMPLATEOVERRIDE') == 'Goodbye') # Revert the update to the template and make sure you see the old version reversion.get_unique_for_object(to)[1].revert() self.assertTrue( self.get_response_for_template('BLAARG.TEMPLATEOVERRIDE') == 'Hello') # Delete the original template override and make sure you see nothing TemplateOverride.objects.filter( name='BLAARG.TEMPLATEOVERRIDE').delete() self.expect_template_error('BLAARG.TEMPLATEOVERRIDE')
def reversionItemBase(request, id_item, id_fase, id_version): """ *Funcion para realizar la reversión de un ítem. Una reversión consiste en recuperar todos los atributos definidos y la relación establecida para la versión a la cual se esta reversionando el item* :param request: HttpRequest necesario para establecer la reversión, es la solicitud de la acción. :param id_fase: Identificador de la fase dentro del proyecto a la cual pertenece el ítem. :param id_item: Identificador del Item al cual se desea realizar una reversion. :param id_version: Identificador de la versión a la cual se desea realizar una reversion. :param args: Argumentos para el modelo ``Item``. :param kwargs: Keyword Arguments para la el modelo ``Item``. :return: El ítem es reversionado exitosamente. """ fase = Fase.objects.get(pk=id_fase) item = ItemBase.objects.get(pk=id_item) tipoitem = item.tipoitem atributos = Atributo.objects.filter(tipoDeItem=tipoitem) id_new_version = int('0'+id_version) campos = [] lista_version = reversion.get_unique_for_object(item) relacion = ItemRelacion.objects.filter(itemHijo=item) if relacion: versionRelacion = reversion.get_for_object(relacion.get()) for version_relacion in versionRelacion: if version_relacion.revision.id == id_new_version: version_relacion.revert() ItemPadre = ItemRelacion.objects.get(itemHijo=item).itemPadre padre = ItemBase.objects.get(nombre=ItemPadre) if padre.estado == 'DDB': print 'Padre en baja' relacion[0].itemPadre = None relacion[0].save() campos.extend(CampoTextoLargo.objects.filter(atributo__in=atributos, item=item)) campos.extend(CampoTextoCorto.objects.filter(atributo__in=atributos, item=item)) campos.extend(CampoNumero.objects.filter(atributo__in=atributos, item=item)) campos.extend(CampoFile.objects.filter(atributo__in=atributos, item=item)) campos.extend(CampoImagen.objects.filter(atributo__in=atributos, item=item)) for campo in campos: versionAttr = reversion.get_unique_for_object(campo) for version_attr in versionAttr: if version_attr.revision.id == id_new_version: version_attr.revert() for version in lista_version: if version.revision.id == id_new_version: version.revert() error = 0 mensajes = [] mensajes.append('Item: ' + item.nombre + '. Reversionado correctamente.') request.session['messages'] = mensajes request.session['error'] = error return HttpResponseRedirect('/workphase/' + str(fase.id))
def relacionarItemBase(request, id_item_hijo, id_item_padre, id_fase): """ *Funcion para establecer relaciones entre los items. Se pueden establecer relaciones del tipo Padre-Hijo cuando los ítems pertenecen a la misma fase y del tipo Antecesor-Sucesor cuando los ítem pertenecen a fases consecutivas.* :param request: HttpRequest necesario para establecer las relaciones entre ítems, es la solicitud de la acción. :param id_item_hijo: Identificador del ítem que cumplirá con el rol de Hijo/Sucesor en la relación. :param id_item_padre: Identificador del ítem que cumplirá con el rol de Padre/Antecesor en la relación. :param args: Argumentos para el modelo ``Item``. :param kwargs: Keyword Arguments para la el modelo ``Item``. :return: Relación establecida correctamente """ item_hijo = ItemBase.objects.get(pk=id_item_hijo) item_padre = ItemBase.objects.get(pk=id_item_padre) mensajes = [] try: ItemRelacion.objects.get(itemHijo=item_hijo) except: relacion = ItemRelacion() relacion.itemHijo = item_hijo relacion.itemPadre = item_padre relacion.save() item_hijo.fecha_modificacion = timezone.now() item_hijo.usuario_modificacion = request.user item_hijo.version = reversion.get_unique_for_object(item_hijo).__len__() + 1 item_hijo.save() mensaje = 'Relacion establecida entre ' + item_hijo.nombre + ' y ' + item_padre.nombre + '.' mensajes.append(mensaje) error = 0 request.session['messages'] = mensajes request.session['error'] = error return HttpResponseRedirect('/workphase/' + str(id_fase)) relacion = ItemRelacion.objects.get(itemHijo=item_hijo) padre = relacion.itemPadre if padre == item_padre: mensaje = 'El item ' + item_hijo.nombre + ' ya cuenta con una relacion hacia el item especificado.' duplicado = 1 mensajes.append(mensaje) request.session['messages'] = mensajes request.session['error'] = duplicado return HttpResponseRedirect('/workphase/' + str(id_fase)) else: relacion.itemPadre = item_padre relacion.save() item_hijo.version = reversion.get_unique_for_object(item_hijo).__len__() + 1 item_hijo.save() mensaje = 'Relacion establecida entre ' + item_hijo.nombre + ' y ' + item_padre.nombre + '.' error = 0 mensajes.append(mensaje) request.session['messages'] = mensajes request.session['error'] = error return HttpResponseRedirect('/workphase/' + str(id_fase))
def testCanGetUniqueForObject(self): with reversion.create_revision(): self.test11.save() self.test21.save() # Test a model with an int pk. self.assertEqual(reversion.get_for_object(self.test11).count(), 3) self.assertEqual(len(reversion.get_unique_for_object(self.test11)), 2) # Test a model with a str pk. self.assertEqual(reversion.get_for_object(self.test21).count(), 3) self.assertEqual(len(reversion.get_unique_for_object(self.test21)), 2)
def form_valid(self, form): version_list = reversion.get_unique_for_object(self.object) if version_list: version = version_list[0] # get difference between last version and new version diff = {} for k,v in version.field_dict.iteritems(): if v not in form.cleaned_data.values(): if k != u"id": diff[k] = form.cleaned_data[k] # get the help_text of the field using name for k,v in diff.items(): for field in Passport._meta.fields: if field.name == k: diff[smart_text(field.help_text)] = v del diff[k] with reversion.create_revision(): form.save() changed = u"Изменено: " for k, v in diff.items(): changed += u" %s -> %s | " % (k, v) reversion.set_comment(changed) else: with reversion.create_revision(): form.save() return super(PassportUpdateView, self).form_valid(form)
def test_create_userstory_from_issue_by_membership(self): issue = create_issue(1, self.user2, self.project1, self.milestone1) data = { "subject": "Test UserStory creation from issue", "description": "A Test UserStory example description", "project": self.project1.id, "milestone": self.milestone1.id, "status": self.project1.us_statuses.all()[1].id, "generated_from_issue": issue.id, "issue_comment": "This is a test example", "generated_from_issue": issue.id } self.assertEqual(UserStory.objects.all().count(), 4) self.assertEqual(len(mail.outbox), 0) response = self.client.login(username=self.user2.username, password=self.user2.username) self.assertTrue(response) response = self.client.post( reverse("userstories-list"), json.dumps(data), content_type="application/json") self.assertEqual(response.status_code, 201) self.assertEqual(UserStory.objects.all().count(), 5) self.assertEqual(len(mail.outbox), 1) self.assertEqual(response.data["origin_issue"]["subject"], issue.subject) issue_historical = reversion.get_unique_for_object(issue) self.assertTrue(data["subject"] in issue_historical[0].revision.comment) self.client.logout()
def iter_object_with_version(self, model_cls): qs = model_cls.objects.all() for obj in qs: revs = get_unique_for_object(obj) for rev in revs: yield obj, rev
def page_history(request, slug): link_groups = LinkGroup.objects.all() page = Page.objects.get(slug=slug) version_list = reversion.get_unique_for_object(page) changelog = list() for i in range(len(version_list)): if i < len(version_list) - 1: diff = len(version_list[i].field_dict['content'].replace('\n', '').replace('\r', '')) - len(version_list[i+1].field_dict['content'].replace('\n', '').replace('\r', '')) if diff < 0: diff_text = '-{} characters'.format(abs(diff)) else: diff_text = '+{} characters'.format(diff) else: diff_text = '+{} characters'.format(len(version_list[i].field_dict['content'].replace('\n', '').replace('\r', ''))) changelog.append({ 'id': version_list[i].revision.id, 'user': version_list[i].revision.user, 'date': version_list[i].revision.date_created, 'diff': diff_text }) return render(request, 'page_history.html', { 'page': page, 'slug': slug, 'changelog': changelog, 'link_groups': link_groups, })
def page_change(request, slug, version_id): try: version_id = abs(int(version_id)) except TypeError: version_id = 0 page = Page.objects.get(slug=slug) version_list = reversion.get_unique_for_object(page) try: if version_id + 1 >= len(version_list): compare = '' else: compare = version_list[version_id + 1].field_dict['content'] html = reversion_compare.helpers.html_diff(compare, version_list[version_id].field_dict['content']) except IndexError: html = '' return JsonResponse({ 'slug': slug, 'page_title': slug.replace('_', ' '), 'html': html, })
def save(self, *args, **kwargs): author = None if 'author' in kwargs.keys(): author = kwargs.pop('author') if 'at' in kwargs.keys(): at = kwargs.pop('at') else: at = timezone.now() create_revision = False try: last_version = reversion.get_unique_for_object(self)[0].field_dict except (IndexError, AttributeError, TypeError): create_revision = True last_version = {} for field in ('role', 'location', 'is_active'): if field == 'is_active': current_value = getattr(self, field, False) else: current_value = getattr(getattr(self, field), 'slug') if last_version.get(field, current_value) != current_value: create_revision = True break if create_revision: self.access_since = at with reversion.create_revision(): super(Provider, self).save(*args, **kwargs) reversion.set_user(author) else: super(Provider, self).save(*args, **kwargs)
def get_context_data(self, **kwargs): context = super(ProgramReportEditView, self).get_context_data(**kwargs) context['page_title'] = self.page_title context['period'] = self.object.summary()['period_name'] context['program'] = self.object.program.code context['reporter'] = self.object.reporter context['versions'] = reversion.get_unique_for_object(self.object) return context
def viewevent(request, id): context = {} event = get_object_or_404(Event, pk=id) if not (request.user.has_perm('events.view_event') or request.user.has_perm('events.view_event', event)): raise PermissionDenied context['event'] = event context['history'] = reversion.get_unique_for_object(event) return render(request, 'uglydetail.html', context)
def get_context_data(self, **kwargs): context = super().get_context_data(**kwargs) version_list = reversion.get_unique_for_object(self.object) context.update( { 'version_list': version_list } ) return context
def getFieldHistory(self, keys): """ FIXME: work in progress.. just notes right now.. """ fieldID = keys.get('id') attributeMappingObj = get_object_or_404(AttributeMapping, id=attrID) serverObj = attributeMappingObj.server history = reversion.get_unique_for_object(serverObj) historyList = sorted([ (h.revision.date_created, h.field_dict) for h in history ]) return historyList
def getFieldHistory(self, keys): """ FIXME: work in progress.. just notes right now.. """ fieldID = keys.get("id") attributeMappingObj = get_object_or_404(AttributeMapping, id=attrID) serverObj = attributeMappingObj.server history = reversion.get_unique_for_object(serverObj) historyList = sorted([(h.revision.date_created, h.field_dict) for h in history]) return historyList
def get_revisions(request, pk): user = request.user.groups.filter(name='Moderator') if user: joke = Joke.objects.get(pk=pk) version_list = reversion.get_unique_for_object(joke) versions = [] for version in version_list: date = version.revision.date_created body = version.field_dict['body'] versions.append({'date': date, 'body': body}) return JsonResponse(versions, safe=False) else: return HttpResponse('User not authorised to get revisions', status=401)
def history(self): version_list = reversion.get_unique_for_object(self) updates = [] for version in reversed(version_list): vdata = version.field_dict inside_date = vdata.get('access_since') updates.append({ 'is_active': vdata.get('is_active'), # 'role': Role.get_or_none(vdata.get('role')), 'site': Entity.get_or_none(vdata.get('site')), 'from': vdata.get('access_since'), # TODO: fix end date of access 'to': None, 'access': self.get_access(at=inside_date), 'name': self.name(at=inside_date) }) return updates
def history(self): version_list = reversion.get_unique_for_object(self) updates = [] for version in reversed(version_list): vdata = version.field_dict inside_date = vdata.get('access_since') updates.append({ 'is_active': vdata.get('is_active'), 'role': Role.get_or_none(vdata.get('role')), 'location': Entity.get_or_none(vdata.get('location')), 'from': vdata.get('access_since'), # TODO: fix end date of access 'to': None, 'access': self.get_access(at=inside_date), 'name': self.name(at=inside_date) }) return updates
def changeItem(request, id_item): """ *Vista para la modificacion de una fase dentro del sistema.* *Opción válida para usuarios con los roles correspondientes.* :param request: HttpRequest necesario para modificar la fase, es la solicitud de la acción. :param id_fase: Identificador de la fase dentro del sistema la cual se desea modificar. :param args: Argumentos para el modelo ``Fase``. :param kwargs: Keyword Arguments para la el modelo ``Fase``. :return: Proporciona la pagina ``changephase.html`` con el formulario correspondiente. Modifica la fase especifica y luego regresa al menu principal """ mensajes = [] items = ItemBase.objects.filter(pk=id_item) if items: print 'Inicio de Proceso de Modificacion' else: return item = ItemBase.objects.get(pk=id_item) tipoItem = item.tipoitem phase = tipoItem.fase project = phase.proyecto if request.method == 'POST': form = itemForm(request.POST, instance=item) form.fields['tipoitem'].queryset = TipoItem.objects.filter(fase=phase.id) if form.is_valid(): item = form.save(commit=False) item.fecha_modificacion = timezone.now() item.usuario_modificacion = request.user item.version = reversion.get_unique_for_object(item).__len__() + 1 item.save() message = 'Modificaciones concluidas con exito en el Item: ' + item.nombre error = 0 mensajes.append(message) request.session['messages'] = mensajes request.session['error'] = error return HttpResponseRedirect('/workphase/' + str(phase.id)) else: form = itemForm(instance=item) form.fields['tipoitem'].queryset = TipoItem.objects.filter(fase=phase.id) return render(request, 'item/changeitem.html', {'form': form, 'item': item, 'phase': phase, 'project': project, 'tiposItem': tipoItem, 'user': request.user}, )
def note(request, note_id): o = {} o['note'] = get_object_or_404(Note, id=note_id) if request.method == 'POST': if not request.user.is_authenticated(): return HttpResponseForbidden() form = main_forms.NoteSectionForm(request.POST) user = request.user if form.is_valid(): # Quick fix with checking if a document field is blank: wymeditor by # default posts '<br/>' if not (request.POST.get('document') or len(request.POST.get('content')) > 6): messages.add_message( request, messages.ERROR, 'Enter a value for one or both of the fields "Content" and "Description"') return HttpResponseRedirect(request.path) new_section = NoteSection.objects.create( creator=user, last_updater=user, note=o['note']) if len(request.POST.get('content')) > 6: new_section.content = request.POST.get('content') if request.POST.get('document'): new_section.document = get_object_or_404( Document, id=request.POST.get('document')) new_section.save() messages.add_message( request, messages.SUCCESS, 'Added section to %s' % o['note']) return HttpResponseRedirect(request.path) if request.user.is_authenticated(): user_profile = request.user.get_profile() o['affiliated'] = len([p for p in o['note'].get_project_affiliation() if user_profile.get_project_role(p) is not None]) > 0 o['add_section_form'] = main_forms.NoteSectionForm() o['history'] = get_unique_for_object(o['note']) o['topics'] = [ ta.topic for ta in o['note'].topics.all() ] o['cites'] = _sort_citations(o['note']) return render_to_response( 'note.html', o, context_instance=RequestContext(request))
def historialItemBase(request, id_fase, id_item): """ *Funcion para visualizar el historial de versiones de los ítems. * Obs. Cada modificación realizada en el ítem es una nueva versión del ítem. :param request: HttpRequest necesario para visualizar las versiones de un ítem, es la solicitud de la acción. :param id_fase: Identificador de la fase dentro del proyecto a la cual pertenece el ítem. :param id_item: Identificador del Item al cual se esta consultando su historial de versiones :param args: Argumentos para el modelo ``Item``. :param kwargs: Keyword Arguments para la el modelo ``Item``. :return: Regresa una lista de todas las versiones del ítem. """ usuario = request.user fase = Fase.objects.get(pk=id_fase) proyecto = fase.proyecto item = ItemBase.objects.get(pk=id_item) lista_versiones = reversion.get_unique_for_object(item) return render(request, 'item/historialitem.html', {'lista_versiones': lista_versiones, 'item': item, 'proyecto': proyecto, 'fase': fase, 'user': usuario}, )
def note(request, note_id, project_slug): o = {} qs = Note.objects\ .select_related('license', 'project__default_license')\ .prefetch_related('related_topics') note = get_object_or_404(qs, id=note_id, project__slug=project_slug) if note.is_private: can_view = (request.user.is_authenticated() and request.user.has_project_perm( note.project, 'main.view_private_note')) if not can_view: raise PermissionDenied() o['breadcrumb'] = ( (note.project.name, note.project.get_absolute_url()), ("Notes", reverse('all_notes_view', kwargs={'project_slug': note.project.slug})), (note.title, None), ) o['note'] = note o['license'] = note.license or note.project.default_license o['history'] = reversion.get_unique_for_object(note) o['topics'] = [ta.topic for ta in o['note'].related_topics.all()] o['sections'] = note.sections\ .order_by('ordering', 'note_section_id')\ .all()\ .select_subclasses()\ .select_related('citationns__document__project', 'notereferencens__note_reference__project') o['can_edit'] = (request.user.is_authenticated() and request.user.has_project_perm(o['note'].project, 'main.change_note')) return render_to_response('note.html', o, context_instance=RequestContext(request))
def note(request, note_id, project_slug): o = {} qs = Note.objects\ .select_related('license', 'project__default_license')\ .prefetch_related('related_topics') note = get_object_or_404(qs, id=note_id, project__slug=project_slug) if note.is_private: can_view = ( request.user.is_authenticated() and request.user.has_project_perm(note.project, 'main.view_private_note')) if not can_view: raise PermissionDenied() o['breadcrumb'] = ( (note.project.name, note.project.get_absolute_url()), ("Notes", reverse('all_notes_view', kwargs={'project_slug': note.project.slug})), (note.title, None), ) o['note'] = note o['license'] = note.license or note.project.default_license o['history'] = reversion.get_unique_for_object(note) o['topics'] = [ta.topic for ta in o['note'].related_topics.all()] o['sections'] = note.sections\ .order_by('ordering', 'note_section_id')\ .all()\ .select_subclasses()\ .select_related('citationns__document__project', 'notereferencens__note_reference__project') o['can_edit'] = ( request.user.is_authenticated() and request.user.has_project_perm(o['note'].project, 'main.change_note')) return render_to_response( 'note.html', o, context_instance=RequestContext(request))
def save(self, *args, **kwargs): # assign_role(self, Guest) author = None if 'author' in kwargs.keys(): author = kwargs.pop('author') if 'at' in kwargs.keys(): at = kwargs.pop('at') else: at = timezone.now() create_revision = False try: last_version = reversion.get_unique_for_object(self)[0].field_dict except (IndexError, AttributeError, TypeError): create_revision = True last_version = {} # for field in ('role', 'site', 'is_active'): # if field == 'is_active': # current_value = getattr(self, field, False) # else: # current_value = getattr(getattr(self, field), 'slug') # if last_version.get(field, current_value) != current_value: # create_revision = True # break if create_revision: self.access_since = at with reversion.create_revision(): super(Provider, self).save(*args, **kwargs) reversion.set_user(author) else: super(Provider, self).save(*args, **kwargs)
def get(self, request, *args, **kwargs): a = super(GenericRevisionView, self).get(request, *args, **kwargs) self.version_list = reversion.get_unique_for_object(self.get_object()) context = self.get_context_data(version_list=self.version_list) return self.render_to_response(context)
def get_context_data(self, **kwargs): context = super(BaseUpdatePageView, self).get_context_data(**kwargs) context['body'] = self.object.body context['version_list'] = reversion.get_unique_for_object(self.object) context['editor_css'] = settings.PAGEPLANT_SETTINGS['editor_css'] return context
def iter_object_versions(self, instance): revs = get_unique_for_object(instance) for rev in revs: yield rev
def get_object_old_fields(self, obj): versions = reversion.get_unique_for_object(obj.object) try: return versions[versions.index(obj) + 1].field_dict except IndexError: return {}
def workItem(request, id_item): """ *Vista para el desarrollo de ítems creados en una Fase de un Proyecto. Opción válida para usuarios asociados a un proyecto, con permisos de creación y modificación de ítems en la Fase en cuestión* *En caso de que el método de la solicitud HTTP sea GET, gestiona un formulario con los datos actueles del ítem y sus atributos. En el caso de que el método sea POST, gestiona la actualización de los datos del ítem y sus atributos en la base de datos.* :param request: Solicitud HTTP relacionada a la ejecución de esta vista. :param id_item: Identificador del ítem sobre el cual se desea trabajar. :param error: Indicador de la existencia de errores en los formularios. :param message: Mensaje de error o de éxito a ser desplegado según corresponda. :return: Proporciona la pagina ``workitem.html``, página dedicada al desarrollo del ítem especificado. """ mensajes = [] item = ItemBase.objects.get(pk=id_item) tipoItem = item.tipoitem faseActual = tipoItem.fase proyectoActual = faseActual.proyecto atributos = Atributo.objects.filter(tipoDeItem=tipoItem) formNum_list = None formSTR_list = None formTXT_list = None formIMG_list = None formFile_list = None CampoNumeroFormset = inlineformset_factory(ItemBase, CampoNumero, formset=CustomInlineFormSet_NUM, form=campoEnteroForm, extra=0, can_delete=False) atributosNumericos = atributos.filter(tipo='NUM') camposNumericos = CampoNumero.objects.filter(item=item, atributo__in=atributosNumericos).order_by('id') existen_NUM = False if camposNumericos: existen_NUM = True CampoSTRFormset = inlineformset_factory(ItemBase, CampoTextoCorto, formset=CustomInlineFormSet_STR, form=campoTextoCortoForm, extra=0, can_delete=False) atributosSTR = atributos.filter(tipo='STR') camposSTR = CampoTextoCorto.objects.filter(item=item, atributo__in=atributosSTR).order_by('id') existen_STR = False if camposSTR: existen_STR = True CampoTXTFormset = inlineformset_factory(ItemBase, CampoTextoLargo, formset=CustomInlineFormSet_TXT, form=campoTextoLargoForm, extra=0, can_delete=False) atributosTXT = atributos.filter(tipo='TXT') camposTXT = CampoTextoLargo.objects.filter(item=item, atributo__in=atributosTXT).order_by('id') existen_TXT = False if camposTXT: existen_TXT = True CampoIMGFormset = inlineformset_factory(ItemBase, CampoImagen, formset=CustomInlineFormSet_IMG, form=campoImagenForm, extra=0, can_delete=False) atributosIMG = atributos.filter(tipo='IMG') camposIMG = CampoImagen.objects.filter(item=item, atributo__in=atributosIMG).order_by('id') existen_IMG = False if camposIMG: existen_IMG = True CampoFILFormset = inlineformset_factory(ItemBase, CampoFile, formset=CustomInlineFormSet_FIL, form=campoFileForm, extra=0, can_delete=False) atributosFIL = atributos.filter(tipo='FIL') camposFIL = CampoFile.objects.filter(item=item, atributo__in=atributosFIL).order_by('id') existen_FIL = False if camposFIL: existen_FIL = True if request.method == 'POST': formDatosItem = modificarDatosItemForm(request.POST, instance=item) formAtributosBasicos = modificarAtributosBasicosForm(request.POST, instance=item) if existen_NUM: formNum_list = CampoNumeroFormset(request.POST, queryset=camposNumericos, instance=item, prefix='formularios_NUM') if existen_STR: formSTR_list = CampoSTRFormset(request.POST, queryset=camposSTR, instance=item, prefix='formularios_STR') if existen_TXT: formTXT_list = CampoTXTFormset(request.POST, queryset=camposTXT, instance=item, prefix='formularios_TXT') if existen_IMG: formIMG_list = CampoIMGFormset(request.POST, request.FILES, queryset=camposIMG, instance=item, prefix='formularios_IMG') if existen_FIL: formFile_list = CampoFILFormset(request.POST, request.FILES, queryset=camposFIL, instance=item, prefix='formularios_FIL') if formsValidos(formDatosItem, formAtributosBasicos, formNum_list, formSTR_list, formTXT_list, formIMG_list, formFile_list, existen_FIL, existen_TXT, existen_NUM, existen_IMG, existen_STR): reversion.create_revision() saveForms(formDatosItem, formAtributosBasicos, formNum_list, formSTR_list, formTXT_list, formIMG_list, formFile_list, existen_FIL, existen_TXT, existen_NUM, existen_IMG, existen_STR) item.fecha_modificacion = timezone.now() item.usuario_modificacion = request.user if item.estado != 'REV': item.estado = 'ACT' item.version = reversion.get_unique_for_object(item).__len__() +1 item.save() no_error = 0 mensajes.append('Item: ' + item.nombre + '. Modificacion exitosa.') request.session['messages'] = mensajes request.session['error'] = no_error return HttpResponseRedirect(reverse('administrarFases.views.workphase', kwargs={'id_fase': faseActual.id})) else: formAtributosBasicos = modificarAtributosBasicosForm(instance=item) formDatosItem = modificarDatosItemForm(instance=item) if existen_NUM: formNum_list = CampoNumeroFormset(queryset=camposNumericos, instance=item, prefix='formularios_NUM') if existen_STR: formSTR_list = CampoSTRFormset(queryset=camposSTR, instance=item, prefix='formularios_STR') if existen_TXT: formTXT_list = CampoTXTFormset(queryset=camposTXT, instance=item, prefix='formularios_TXT') if existen_IMG: formIMG_list = CampoIMGFormset(queryset=camposIMG, instance=item, prefix='formularios_IMG') if existen_FIL: formFile_list = CampoFILFormset(queryset=camposFIL, instance=item, prefix='formularios_FIL') return render(request, 'item/workItem.html', {'user': request.user, 'fase': faseActual, 'proyecto': proyectoActual, 'item': item, 'formAtributosBasicos': formAtributosBasicos, 'formDatosItem': formDatosItem, 'formNumericos': formNum_list, 'formTXT': formTXT_list, 'formSTR': formSTR_list, 'formFile': formFile_list, 'formIMG': formIMG_list, 'existen_formNumericos': existen_NUM, 'existen_formSTR': existen_STR, 'existen_formTXT': existen_TXT, 'existen_formIMG': existen_IMG, 'existen_formFile': existen_FIL},)
def get_context_data(self, **kwargs): context = super(PollDetailView, self).get_context_data(**kwargs) context['pie_data'] = [[', '.join(choice.content_rawtext.splitlines()), choice.num_votes()] for choice in self.get_object().choices.all()] context['versions'] = reversion.get_unique_for_object(self.get_object()) return context
def handle(self, *args, **options): questions = Question.objects.all() for i in xrange(300): user, created = User.objects.get_or_create( username="******".format(num=i), first_name="Tester", last_name="Number {num}".format(num=i), email="tester{num}@test.com".format(num=i), password="******", ) user.password = make_password("test") user.save() for question in questions: distribution = [-1, 0, 1, 1, 1] Vote.objects.record_vote(question, user, distribution[randrange(len(distribution))]) num_choices = question.choices.count() choice = question.choices.all()[randrange(num_choices)] Answer.objects.get_or_create(choice=choice, user=user) exit(0) # q = Question.objects.get(pk=24) # choices = q.choices.all() # user = User.objects.get(pk=1) # a = Answer.objects.get_or_create(user=user, choice=choices[0])[0] # print a.choice.question.choices.exclude(answers=a).filter(answers__user=user) # # a.full_clean() # b = Answer.objects.get_or_create(user=user, choice=choices[2])[0] # print b.choice.question.choices.exclude(answers=b).filter(answers__user=user) # # b.full_clean() # print b.choice.question.choices.filter(answers__user=user) # exit(0) questions = Question.objects.all() print questions[0].choices.answers.all() exit(0) unanswered = questions.filter(choices__answers__isnull=True).aggregate(Count("choices__answers")) print unanswered exit(0) q = Question.objects.get(pk=27) context = {} context["versions"] = reversion.get_unique_for_object(q) print dir(context["versions"][0].revision) exit(0) print context["versions"][0].revision.date_created context["diffs"] = [] for a in context["versions"][-1].revision.version_set.all(): print generate_patch_html(dummy, a, "content_markdown", cleanup="semantic") for i, (a, b) in enumerate(pairwise(reversed(context["versions"]))): temp = {} temp["related"] = [] for j, (c, d) in enumerate(zip(a.revision.version_set.all(), b.revision.version_set.all())): diff_patch = generate_patch_html(c, d, "content_markdown", cleanup="semantic") if not j: temp["primary"] = (diff_patch, d) else: temp["related"].append((diff_patch, d)) context["diffs"].append(temp) pprint.pprint(context) exit(0) q = Question.objects.get(pk=24) for i, (a, b) in enumerate(pairwise(reversed(reversion.get_unique_for_object(q)))): for c, d in zip(a.revision.version_set.all(), b.revision.version_set.all()): print generate_patch_html(c, d, "content_markdown", cleanup="semantic") exit(0) d = reversion.get_unique_for_object(q)[0] print d.revision.version_set.all() exit(0) a, b = reversion.get_unique_for_object(q)[0:2] print dir(b) print a.object_version.object.choices.all() print b.object_version.object.choices.all() print generate_patch_html(a, b, "content_markdown", cleanup="semantic")
def nr_of_versions(self): version_list = reversion.get_unique_for_object(self) return len(version_list)
def versions(self): #version_list = reversion.get_for_object(self) version_list = reversion.get_unique_for_object(self) return version_list
def get_last_revision(self): try: return reversion.get_unique_for_object(self)[0].revision except: return None
def versions(self): return list(reversion.get_unique_for_object(self))
def get_historical_queryset(self): return reversion.get_unique_for_object(self.get_object())
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)