Synnefo » snf-cloudcms

# -*- coding: utf-8 -*-

import zipfile

import tempfile

import os

import glob

import logging

from django import forms

from django.conf import settings

from django.db import transaction

from django.core.files import File

from feincms.module.medialibrary.models import Category as MediaCategory, \

        MediaFile

from cloudcmsguide.models import UserGuideEntry

from cloudcmsfaq.models import Category as FaqCategory, Question

from cloudcms.rstutils import generate_rst_contents_from_dir

from cloudcms.models import Service, ServiceTranslation, Application

from feincms.content.raw.models import RawContent

logger = logging.getLogger('cloudcms.rstimport')

# base filename to service slug map

DEFAULT_SERVICE_MAP = {

        'cyclades':'cyclades',

        'okeanos':'okeanos',

        'pithos':'pithos'

}

DEFAULT_REGION_MAP = {

        'faq':'main',

        'userguide':'main',

}

DEFAULT_RESIZE_GEOMETRY = (400, 400)

SERVICE_MAP = getattr(settings, 'CMS_RST_IMPORT_SERVICE_FILE_MAP',

        DEFAULT_SERVICE_MAP)

REGIONS_MAP = getattr(settings, 'CMS_RST_IMPORT_REGIONS_MAP',

        DEFAULT_REGION_MAP)

RESIZE_GEOMETRY = getattr(settings, 'CMS_RST_IMPORT_RESIZE_GEOMETRY',

    DEFAULT_RESIZE_GEOMETRY)

def service_from_filename(rst):

    fname = os.path.basename(rst).replace(".rst","")

    service_slug = DEFAULT_SERVICE_MAP.get(fname, None)

    if not service_slug:

        return None

    try:

        return Service.objects.filter(translations__slug=service_slug)[0]

    except IndexError:

        return None

    except Service.DoesNotExist:

        return None

    return None

def get_media_category(slug):

    return MediaCategory.objects.get(slug=slug)

CATEGORIES_CHOICES = (('faqs', 'FAQs'), ('guide', 'User guide'))

class RstZipImportForm(forms.Form):

    FAQ_MEDIA_CATEGORY = 'faq-images'

    GUIDE_MEDIA_CATEGORY = 'user-guide-images'

    clean_data = forms.BooleanField(initial=False, required=False)

    dry_run = forms.BooleanField(initial=True, required=False,

            widget=forms.HiddenInput)

    import_file = forms.FileField(required=True)

    def __init__(self, *args, **kwargs):

        super(RstZipImportForm, self).__init__(*args, **kwargs)

        self.log_data = ""

    def log(self, msg):

        self.log_data += "\n" + msg

    def get_tmp_file(self, f):

        tmp = tempfile.mktemp('cloudcms-sphinx-import')

        f.file.reset()

        fd = file(tmp, 'w')

        fd.write(f.read())

        fd.close()

        return tmp

    def clean_import_file(self):

        f = self.cleaned_data['import_file']

        tmpfile = self.get_tmp_file(f)

        if not zipfile.is_zipfile(tmpfile):

            raise forms.ValidationError("Invalid zip file")

        return f

    def clean(self, *args, **kwargs):

        data = super(RstZipImportForm, self).clean(*args, **kwargs)

        return data

    def clean_existing_data(self):

        Question.objects.all().delete()

        UserGuideEntry.objects.all().delete()

        MediaFile.objects.filter(categories__slug__in=[self.FAQ_MEDIA_CATEGORY, \

            self.GUIDE_MEDIA_CATEGORY]).delete()

    def save(self, user, use_dir=None):

        dry_run = self.cleaned_data.get('dry_run')

        clean_data = self.cleaned_data.get('clean_data')

        import_file = self.cleaned_data.get('import_file')

        if not use_dir:

            zipdir = tempfile.mkdtemp('cloudcms-sphinx-exports')

            zipdatafile = self.get_tmp_file(import_file)

            zipf = zipfile.ZipFile(file(zipdatafile))

            zipf.extractall(zipdir)

        else:

            zipdir = use_dir

        subdirs = os.listdir(zipdir)

        if len(subdirs) == 1 and os.path.isdir(os.path.join(zipdir, \

                subdirs[0])) and subdirs[0] != 'source':

            zipdir = os.path.join(zipdir, subdirs[0])

        #sid = transaction.savepoint()

        if clean_data:

            try:

                self.clean_existing_data()

            except Exception, e:

                return False

        ret = ""

        try:

            for data_type, rst, category, slug, title, html_content, \

                    images, stderr in generate_rst_contents_from_dir(zipdir):

                ret += stderr

                #logger.info("Parsed %s" % (rst, ))

                if stderr:

                    pass

                    #logger.info("Error output: %s" % (stderr, ))

                service = service_from_filename(rst)

                if not service:

                    logger.info("Skipping entry for file '%s'. No category found" % rst)

                    continue

                # first save media files

                newimages = []

                if data_type == 'userguide':

                    cat = get_media_category(self.GUIDE_MEDIA_CATEGORY)

                if data_type == 'faq':

                    cat = get_media_category(self.FAQ_MEDIA_CATEGORY)

                if not cat:

                    continue

                for imgname, imgpath, imgabspath in images:

                    newalt, newpath = create_or_update_media_file(cat, \

                            imgname, imgabspath)

                    html_content = html_content.replace(imgpath, newpath)

                # now html contains correct image links, we are ready to save

                # the faq/guide content

                if data_type == 'faq':

                    cat = add_or_update_faq_category(category[0], category[1])

                    question = add_or_update_faq_question(user, service, cat, slug, \

                            title, html_content)

                if data_type == 'userguide':

                    guide_entry = add_or_update_guide_entry(user, service, slug, \

                            title, html_content)

        except Exception, e:

            logger.exception("RST import failed")

            #transaction.savepoint_rollback(sid)

            return False

        if dry_run:

            pass

            #transaction.savepoint_rollback(sid)

        else:

            pass

            #transaction.savepoint_commit(sid)

def create_or_update_media_file(category, name, path):

    name = category.title + " " + name

    try:

        # TODO: Check language ?????

        mf = MediaFile.objects.get(categories=category, translations__caption=name)

    except MediaFile.DoesNotExist:

        mf = MediaFile()

        mf.category = category

        mf.file = File(open(path))

        mf.save()

        mf.translations.create(caption=name)

    # TODO: Check language ?????

    return mf.translations.all()[0].caption, mf.get_absolute_url()

def add_or_update_faq_category(slug, name):

    try:

        category = FaqCategory.objects.get(translations__slug=slug)

    except FaqCategory.DoesNotExist:

        category = FaqCategory()

        category.save()

        category.translations.create(slug=slug, title=name)

    return category

def add_or_update_faq_question(author, service, category, slug,\

        title, html_content):

    try:

        q = Question.objects.get(slug=slug)

    except:

        q = Question()

    q.author = author

    q.is_active = True

    q.category = category

    q.service = service

    q.slug = slug

    q.title = title

    q.save()

    q.application = [Application.current()]

    q.save()

    RawContentModel = Question.content_type_for(RawContent)

    try:

        content = q.rawcontent_set.filter()[0]

    except:

        content = q.rawcontent_set.create(region=REGIONS_MAP['faq'])

    content.text = html_content

    content.save()

    return q

def add_or_update_guide_entry(author, service, slug, title, html_content):

    try:

        guide = UserGuideEntry.objects.get(slug=slug)

    except:

        guide = UserGuideEntry()

    guide.author = author

    guide.is_active = True

    guide.service = service

    guide.slug = slug

    guide.title = title

    guide.save()

    RawContentModel = UserGuideEntry.content_type_for(RawContent)

    try:

        content = guide.rawcontent_set.filter()[0]

    except:

        content = guide.rawcontent_set.create(region=REGIONS_MAP['userguide'])

    content.text = html_content

    content.save()

    return guide