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 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 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 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 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 nr_of_versions(self):
version_list = reversion.get_unique_for_object(self)
return len(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_last_revision(self):
try:
return reversion.get_unique_for_object(self)[0].revision
except:
return None
def get_historical_queryset(self):
return reversion.get_unique_for_object(self.get_object())
def versions(self):
#version_list = reversion.get_for_object(self)
version_list = reversion.get_unique_for_object(self)
return version_list
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)
