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 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 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 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 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 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 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 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')),
             '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 nr_of_versions(self):
     version_list = reversion.get_unique_for_object(self)
     return len(version_list)

 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 {}