def new_gallery(request):
    '''
    Creates a new gallery
    '''
    if request.method == 'POST':
        form = GalleryForm(request.POST)
        if form.is_valid():
            data = form.data
            # Creating the gallery
            gal = Gallery()
            gal.title = data['title']
            gal.subtitle = data['subtitle']
            gal.slug = slugify(data['title'])
            gal.pubdate = datetime.now()
            gal.save()

            # Attach user
            userg = UserGallery()
            userg.gallery = gal
            userg.mode = 'W'
            userg.user = request.user
            userg.save()

            return redirect(gal.get_absolute_url())

        else:
            # TODO: add errors to the form and return it
            raise Http404
    else:
        form = GalleryForm()
        return render_template('gallery/new_gallery.html', {
            'form': form
        })

 def get_absolute_url_beta(self):
     if self.sha_beta != None:
         return reverse('zds.tutorial.views.view_tutorial', args=[
             self.pk, slugify(self.title)
         ])+'?version='+self.sha_beta
     else:
         return self.get_absolute_url()

def new_gallery(request):
    """Creates a new gallery."""

    if request.method == "POST":
        form = GalleryForm(request.POST)
        if form.is_valid():
            data = form.data

            # Creating the gallery

            gal = Gallery()
            gal.title = data["title"]
            gal.subtitle = data["subtitle"]
            gal.slug = slugify(data["title"])
            gal.pubdate = datetime.now()
            gal.save()

            # Attach user

            userg = UserGallery()
            userg.gallery = gal
            userg.mode = "W"
            userg.user = request.user
            userg.save()
            return redirect(gal.get_absolute_url())
        else:
            return render_template("gallery/gallery/new.html", {"form": form})
    else:
        form = GalleryForm()
        return render_template("gallery/gallery/new.html", {"form": form})

def new_image(request, gal_pk):
    '''
    Creates a new image
    '''
    gal = get_object_or_404(Gallery, pk=gal_pk)

    if request.method == 'POST':
        form = ImageForm(request.POST, request.FILES)
        if form.is_valid() \
           and request.FILES['physical'].size < settings.IMAGE_MAX_SIZE:
            img = Image()
            img.physical = request.FILES['physical']
            img.gallery = gal
            img.title = request.POST['title']
            img.slug = slugify(request.FILES['physical'])
            img.legend = request.POST['legend']
            img.pubdate = datetime.now()

            img.save()

            # Redirect to the document list after POST
            return redirect(gal.get_absolute_url())
        else:
            # TODO: add errors to the form and return it
            raise Http404
    else:
        form = ImageForm()  # A empty, unbound form
        return render_template('gallery/new_image.html', {
            'form': form,
            'gallery': gal
        })

    def test_notification_read(self):
        """
        When we post on a topic, a notification is created for each subscriber. We can
        read a notification when we display the list of messages of the said topic.
        """
        topic1 = TopicFactory(forum=self.forum11, author=self.user2)
        PostFactory(topic=topic1, author=self.user2, position=1)

        result = self.client.post(
            reverse('post-new') + '?sujet={0}'.format(topic1.pk),
            {
                'last_post': topic1.last_message.pk,
                'text': 'C\'est tout simplement l\'histoire de la ville de Paris que je voudrais vous conter '
            },
            follow=False)

        self.assertEqual(result.status_code, 302)

        notification = Notification.objects.get(subscription__user=self.user2)
        self.assertEqual(notification.is_read, False)

        self.client.logout()
        self.assertTrue(self.client.login(username=self.user2.username, password='hostel77'), True)

        result = self.client.get(reverse('topic-posts-list', args=[topic1.pk, slugify(topic1.title)]), follow=True)
        self.assertEqual(result.status_code, 200)

        notification = Notification.objects.get(subscription__user=self.user2)
        self.assertEqual(notification.is_read, True)

def topic(request, topic_pk, topic_slug):
    """Display a thread and its posts using a pager."""

    # TODO: Clean that up
    g_topic = get_object_or_404(PrivateTopic, pk=topic_pk)

    if not g_topic.author == request.user \
            and request.user not in list(g_topic.participants.all()):
        raise PermissionDenied

    # Check link
    if not topic_slug == slugify(g_topic.title):
        return redirect(g_topic.get_absolute_url())

    if request.user.is_authenticated():
        if never_privateread(g_topic):
            mark_read(g_topic)

    posts = PrivatePost.objects.filter(privatetopic__pk=g_topic.pk)\
        .order_by('position_in_topic')\
        .all()

    last_post_pk = g_topic.last_message.pk

    # Handle pagination
    paginator = Paginator(posts, settings.POSTS_PER_PAGE)

    try:
        page_nbr = int(request.GET['page'])
    except KeyError:
        page_nbr = 1

    try:
        posts = paginator.page(page_nbr)
    except PageNotAnInteger:
        posts = paginator.page(1)
    except EmptyPage:
        raise Http404

    res = []
    if page_nbr != 1:
        # Show the last post of the previous page
        last_page = paginator.page(page_nbr - 1).object_list
        last_post = (last_page)[len(last_page) - 1]
        res.append(last_post)

    for post in posts:
        res.append(post)

    # Build form to add an answer for the current topid.
    form = PrivatePostForm(g_topic, request.user)

    return render_template('mp/topic/index.html', {
        'topic': g_topic,
        'posts': res,
        'pages': paginator_range(page_nbr, paginator.num_pages),
        'nb': page_nbr,
        'last_post_pk': last_post_pk,
        'form': form
    })

def new_image(request, gal_pk):
    """Creates a new image."""

    gal = get_object_or_404(Gallery, pk=gal_pk)

    # check if the user can upload new image in this gallery
    try:
        gal_mode = UserGallery.objects.get(gallery=gal, user=request.user)
        if gal_mode.mode != 'W':
            raise PermissionDenied
    except:
        raise PermissionDenied

    if request.method == "POST":
        form = ImageForm(request.POST, request.FILES)
        if form.is_valid() and request.FILES["physical"].size < settings.IMAGE_MAX_SIZE:
            img = Image()
            img.physical = request.FILES["physical"]
            img.gallery = gal
            img.title = request.POST["title"]
            img.slug = slugify(request.FILES["physical"])
            img.legend = request.POST["legend"]
            img.pubdate = datetime.now()
            img.save()

            # Redirect to the newly uploaded image edit page after POST
            return redirect(reverse("zds.gallery.views.edit_image",
                                    args=[gal.pk, img.pk]))
        else:
            return render_template("gallery/image/new.html", {"form": form,
                                                              "gallery": gal})
    else:
        form = ImageForm(initial={"new_image": True})  # A empty, unbound form
        return render_template("gallery/image/new.html", {"form": form,
                                                          "gallery": gal})

def home(request):
    """Display the home page with last topics added."""

    tutos = []
    for tuto in get_last_tutorials():
        data = tuto.load_json_for_public()
        data['pk'] = tuto.pk
        data['image'] = tuto.image
        data['gallery'] = tuto.gallery
        data['pubdate'] = tuto.pubdate
        data['update'] = tuto.update
        data['subcategory'] = tuto.subcategory
        data['get_absolute_url_online'] = reverse(
            'zds.tutorial.views.view_tutorial_online',
            args=[
                tuto.pk,
                slugify(
                    data['title'])])

        tutos.append(data)

    try:
        with open(os.path.join(SITE_ROOT, 'quotes.txt'), 'r') as fh:
            quote = random.choice(fh.readlines())
    except:
        quote = u'Zeste de Savoir, la connaissance pour tous et sans pépins !'

    return render_template('home.html', {
        'last_topics': get_last_topics(request.user),
        'last_tutorials': tutos,
        'last_articles': get_last_articles(),
        'quote': quote,
    })

 def slug(self):
     """
     PrivateTopic doesn't have a slug attribute of a private topic. To be compatible
     with older private topic, the slug is always re-calculate when we need one.
     :return: title slugify.
     """
     return slugify(self.title)

 def get_prod_path(self):
     if self.chapter.tutorial:
         chapter_path = os.path.join(os.path.join(settings.REPO_PATH_PROD, self.chapter.tutorial.slug), self.chapter.slug)
     else:
         chapter_path = os.path.join(os.path.join(os.path.join(settings.REPO_PATH_PROD, self.chapter.part.tutorial.slug), self.chapter.part.slug), self.chapter.slug)
         
     return os.path.join(chapter_path, slugify(self.title)+'.md.html') 

 def get(self, request, *args, **kwargs):
     self.object = self.get_object()
     if not self.object.forum.can_read(request.user):
         raise PermissionDenied
     if not self.kwargs.get('topic_slug') == slugify(self.object.title):
         return redirect(self.object.get_absolute_url())
     return super(TopicPostsListView, self).get(request, *args, **kwargs)

 def load_dic(self, article_version):
     article_version['pk'] = self.pk
     article_version['slug'] = slugify(article_version['title'])
     article_version['image'] = self.image
     article_version['pubdate'] = self.pubdate
     article_version['is_locked'] = self.is_locked
     article_version['sha_draft'] = self.sha_draft
     article_version['sha_validation'] = self.sha_validation
     article_version['sha_public'] = self.sha_public
     article_version['last_read_reaction'] = self.last_read_reaction
     article_version['get_reaction_count'] = self.get_reaction_count
     article_version['get_absolute_url'] = reverse('zds.article.views.view', 
                                                   args=[self.pk, self.slug])
     article_version['get_absolute_url_online'] = reverse('zds.article.views.view_online', 
                                                          args=[self.pk, slugify(article_version['title'])])
     
     return article_version

def edit_image(request, gal_pk, img_pk):
    """Edit an existing image."""

    gal = get_object_or_404(Gallery, pk=gal_pk)
    img = get_object_or_404(Image, pk=img_pk)

    # Check if user can edit image
    try:
        permission = UserGallery.objects.get(user=request.user, gallery=gal)
        if permission.mode != 'W':
            raise PermissionDenied
    except:
        raise PermissionDenied

    # Check if the image belong to the gallery
    if img.gallery != gal:
        raise PermissionDenied

    if request.method == "POST":
        form = UpdateImageForm(request.POST, request.FILES)
        if form.is_valid():
            if "physical" in request.FILES:
                if request.FILES["physical"].size > settings.IMAGE_MAX_SIZE:
                    messages.error(request, "Votre image est beaucoup trop lourde, réduisez sa taille à moins de {} \
                    <abbr title=\"kibioctet\">Kio</abbr> avant de l'envoyer".format(str(settings.IMAGE_MAX_SIZE/1024)))
                else:
                    img.title = request.POST["title"]
                    img.legend = request.POST["legend"]
                    img.physical = request.FILES["physical"]
                    img.slug = slugify(request.FILES["physical"])
                    img.update = datetime.now()
                    img.save()
                    # Redirect to the newly uploaded image edit page after POST
                    return redirect(reverse("zds.gallery.views.edit_image", args=[gal.pk, img.pk]))
            else:
                img.title = request.POST["title"]
                img.legend = request.POST["legend"]
                img.update = datetime.now()
                img.save()
                # Redirect to the newly uploaded image edit page after POST
                return redirect(reverse("zds.gallery.views.edit_image", args=[gal.pk, img.pk]))

    else:
        form = UpdateImageForm(initial={
            "title": img.title,
            "legend": img.legend,
            "physical": img.physical,
            "new_image": False,
        })

    as_avatar_form = ImageAsAvatarForm()
    return render_template(
        "gallery/image/edit.html", {
            "form": form,
            "as_avatar_form": as_avatar_form,
            "gallery": gal,
            "image": img
        })

 def get_absolute_url_beta(self):
     if self.sha_beta is not None:
         return (
             reverse("zds.tutorial.views.view_tutorial", args=[self.pk, slugify(self.title)])
             + "?version="
             + self.sha_beta
         )
     else:
         return self.get_absolute_url()

def view(request, article_pk, article_slug):
    """Show the given offline article if exists."""
    article = get_object_or_404(Article, pk=article_pk)

    # Only authors of the article and staff can view article in offline.
    if request.user not in article.authors.all():
        if not request.user.has_perm('article.change_article'):
            raise PermissionDenied

    # The slug of the article must to be right.
    if article_slug != slugify(article.title):
        return redirect(article.get_absolute_url())

    # Retrieve sha given by the user. This sha must to be exist.
    # If it doesn't exist, we take draft version of the article.
    try:
        sha = request.GET['version']
    except KeyError:
        sha = article.sha_draft

    # Find the good manifest file
    repo = Repo(article.get_path())

    # Load the article.
    try:
        manifest = get_blob(repo.commit(sha).tree, 'manifest.json')
    except:
        sha = article.sha_draft
        manifest = get_blob(repo.commit(sha).tree, 'manifest.json')

    article_version = json_reader.loads(manifest)
    article_version['txt'] = get_blob(
        repo.commit(sha).tree,
        article_version['text'])
    article_version['pk'] = article.pk
    article_version['slug'] = article.slug
    article_version['image'] = article.image
    article_version['pubdate'] = article.pubdate
    article_version['sha_draft'] = article.sha_draft
    article_version['sha_validation'] = article.sha_validation
    article_version['sha_public'] = article.sha_public
    article_version['get_absolute_url_online'] = article.get_absolute_url_online()

    validation = Validation.objects.filter(article__pk=article.pk,
                                            version=sha)\
                                    .order_by("-date_proposition")\
                                    .first()

    return render_template('article/member/view.html', {
        'article': article_version,
        'authors': article.authors,
        'tags': article.subcategory,
        'version': sha,
        'validation': validation
    })

def edit_image(request, gal_pk, img_pk):
    """Creates a new image."""

    gal = get_object_or_404(Gallery, pk=gal_pk)
    img = get_object_or_404(Image, pk=img_pk)

    # check if user can edit image
    try:
        permission = UserGallery.objects.get(user=request.user, gallery=gal)
        if permission.mode != 'W':
            raise PermissionDenied
    except:
        raise PermissionDenied

    # check if the image belong to the gallery
    if img.gallery != gal:
        raise PermissionDenied
    
    
    if request.method == "POST":
        form = ImageForm(request.POST, request.FILES)
        if form.is_valid():
            if "physical" in request.FILES:
                if request.FILES["physical"].size > settings.IMAGE_MAX_SIZE:
                    messages.error(request, "Votre image est beaucoup trop lourde, réduidez sa taille à moins de {} avant de l'envoyer".format(str(settings.IMAGE_MAX_SIZE/1024*1024)))
                else:
                    img.title = request.POST["title"]
                    img.legend = request.POST["legend"]
                    img.physical = request.FILES["physical"]
                    img.slug = slugify(request.FILES["physical"])
                    img.update = datetime.now()
                    img.save()
                    # Redirect to the document list after POST
                    return redirect(gal.get_absolute_url())
            else:
                img.title = request.POST["title"]
                img.legend = request.POST["legend"]
                img.update = datetime.now()
                img.save()

                # Redirect to the document list after POST
                return redirect(gal.get_absolute_url())
    else:
        form = ImageForm(initial={"title": img.title, "legend": img.legend, "physical": img.physical})
    
    as_avatar_form = ImageAsAvatarForm()
    return render_template(
        "gallery/image/edit.html", {
            "form": form,
            "as_avatar_form": as_avatar_form,
            "gallery": gal,
            "image": img
        })

def repo_extract(extract, sha=None):
    if sha == None:
        return {'text': extract.get_text()}
    else:
        repo_e = Repo(extract['path'])
        bls_e = repo_e.commit(sha).tree.blobs
        
        for bl in bls_e:
            if bl.path==slugify(extract['title'])+'.md':
                text = bl.data_stream.read()
                return {'text': text.decode('utf-8')}
    return {'text': ''}

    def save(self, *args, **kwargs):
        self.slug = slugify(self.title)
        
        if has_changed(self, 'image') and self.image:
            old = get_old_field_value(self, 'image', 'objects')
            
            if old is not None and len(old.name) > 0:
                root = settings.MEDIA_ROOT
                name = os.path.join(root, old.name)
                os.remove(name)

        super(Article, self).save(*args, **kwargs)

 def get_prod_path(self):
     
     if self.chapter.tutorial:
         data = self.chapter.tutorial.load_json_for_public()
         mandata = tutorial.load_dic(data)
         if "chapter" in mandata:
             for ext in mandata["chapter"]["extracts"]:
                 if ext['pk'] == self.pk:
                     return os.path.join(settings.REPO_PATH_PROD,
                                         str(self.chapter.tutorial.pk) + '_' + slugify(mandata['title']),
                                         str(ext['pk']) + "_" + slugify(ext['title'])) \
                                         + '.md.html'
     else:
         data = self.chapter.part.tutorial.load_json_for_public()
         mandata = tutorial.load_dic(data)
         for part in mandata["parts"]:
             for chapter in part["chapters"]:
                 for ext in chapter["extracts"]:
                     if ext['pk'] == self.pk:
                         chapter_path = os.path.join(settings.REPO_PATH_PROD,
                                                     str(mandata['pk']) + '_' + slugify(mandata['title']),
                                                     str(part['pk']) + "_" + slugify(part['title']),
                                                     str(chapter['pk']) + "_" + slugify(chapter['title']),
                                                     str(ext['pk']) + "_" + slugify(ext['title'])) \
                                                     + '.md.html'

def edit(request):
    '''Edit article identified by given GET paramter'''
    try:
        article_pk = request.GET['article']
    except KeyError:
        raise Http404

    article = get_object_or_404(Article, pk=article_pk)
    json = article.load_json()

    # Make sure the user is allowed to do it
    if not request.user in article.authors.all():
        raise Http404

    if request.method == 'POST':
        form = ArticleForm(request.POST, request.FILES)
        if form.is_valid():
            data = form.data
            old_slug = article.get_path()
            article.title = data['title']
            article.description = data['description']
            if 'image' in request.FILES:
                article.image = request.FILES['image']

            article.subcategory.clear()
            for subcat in form.cleaned_data['subcategory']:
                article.subcategory.add(subcat)

            article.save()

            new_slug = os.path.join(settings.REPO_ARTICLE_PATH, slugify(data['title']))
            
            maj_repo_article(request,
                          old_slug_path=old_slug, 
                          new_slug_path=new_slug, 
                          article=article, 
                          text=data['text'],
                          action = 'maj')
            
            return redirect(article.get_absolute_url())
    else:

        form = ArticleForm({
            'title': json['title'],
            'description': json['description'],
            'text': article.get_text(),
            'subcategory': article.subcategory.all(),
        })

    return render_template('article/edit.html', {
        'article': article, 'form': form
    })