root/platform/trac/plugins/wlwriter/trunk/wlwriter/atompub.py @ 17263

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

import re
import pkg_resources

# TODO: ページを取得後に画像を追加するとエラーになる。
# TODO: 新規の投稿と、開いてからの投稿で、メソッドがちがう？レスポンスが違う？
# TODO: 添付ファイルに対する HEAD メソッドは何を意味する？
# TODO: ページ取得時のレスポンスに鍵がありそう。

try:
    from cStringIO import StringIO
except ImportError:
    from StringIO import StringIO
    
from trac.core import *
from trac.wiki.model import WikiPage
from trac.attachment import Attachment
from trac.web.main import IRequestHandler
from trac.web.api import RequestDone
from trac.web.chrome import add_link, add_stylesheet,  ITemplateProvider

from blogwiki import BlogWikiCore
from trac.util.datefmt import to_datetime,format_datetime

from genshi import Markup, escape, unescape
from trac.mimeview.api import Context
from trac.resource import *
from wikitohtml import wiki_to_html,WikiToEditHtmlFormatter

from genshi.input import XML
from trac.util.text import unicode_quote,unicode_unquote,to_unicode
from trac.web.api import IAuthenticator
from trac.perm import IPermissionRequestor


class IAtomPubHandler(Interface):
    def atompub_title():
        """aaa
        """    
        
    def atompub_collection(req):
        """aaa
        """    

    def atompub_get_feed(self,req,id):
        """
        return data,location
        """
    def atompub_get_feedlist(req):
        """
        return data
        """

    def atompub_do_create(req,pagename,content_type,content):
        """
        return pageid
        """

    def atompub_do_update(req,pagename,content_type,content):
        """
        return pageid
        """

    def atompub_do_delete(req):
        """aaa
        """


    def atompub_do_create_attachment(self,req):
        """aaa
        """

    def atompub_do_update_attachment(self,req,id):
        """aaa
        """


from xhtmltowiki import XhtmlToWikiFormatter
from wikitohtml import wiki_to_html,WikiToEditHtmlFormatter

class CommonHandler(BlogWikiCore):

    
    def _attachment(self, req, pagename=None,username=None,filename=None,realm='wiki',put_flag=True):
        username = req.authname
        status_code=200
        if pagename == None or pagename == '':
            pagename = self._getTempPage(username,realm)
        
        page = WikiPage(self.env, pagename, version=None)
        if put_flag == True:
            status_code=201
            if filename == None:
                filename = req.get_header('Slug')
                ex = req.get_header('Content-Type').split('/').pop()
                filename = filename + '.' + ex

            #filename = reqfile['name'].split('/')[-1]
            rawdata =req.read(int(req.get_header('Content-Length')))
            #data = file['bits']
            if not page.exists:
                pagename=self._getTempPage(username)
                page = WikiPage(self.env, pagename)
                if not page.exists:
                    page.text = 'dumy'
                    page.save(username,
                              None,
                              req.remote_addr)
            try:
                attachment = Attachment(self.env, realm, pagename, filename)
                attachment.delete()
            except TracError:
                pass
            attachment = Attachment(self.env, realm, pagename)
            attachment.author = req.authname or 'anonymous'
            attachment.description = None
            attachment.insert(filename, StringIO(rawdata), len(rawdata))
            filename = attachment.filename
            #req.send_header('Location', req.abs_href.atompub('login/%s/attachment/%s/%s'%(realm,page.name,filename)))
            location = req.abs_href.atompub('login/%s/attachment/%s/%s'%(realm,page.name,filename))

        else:
            attachment = Attachment(self.env, realm, pagename)
            location = None

        href = req.abs_href('raw-attachment',realm, pagename, filename)
        #self.log.debug (href)
        
        entry= {  'id':attachment.filename,
                 'title':attachment.filename,
                 'author':attachment.author,
                 'updated':format_datetime(attachment.date,'iso8601'),
                 #'src':req.abs_href('raw-attachment','wiki', page.name, filename), #req.href.attachment('%s/%s/%s'%(realm,page.name,filename)),
                 'content_src':req.abs_href('raw-attachment',realm, pagename, filename), #req.href.attachment('%s/%s/%s'%(realm,page.name,filename)),
                 'content_type':'image/png',
                 'content':None,
                 'edit_media_href':req.abs_href.atompub('login/%s/edit_attachment/%s/%s'%(realm,page.name,filename)),
                 'edit_href':req.abs_href.atompub('login/%s/attachment/%s/%s'%(realm,page.name,filename)),
                 'href':req.abs_href.atompub('login/%s/attachment/%s/%s'%(realm,page.name,filename))
                 #'href':req.abs_href.atompub('%s/edit/%s'%(realm,page.name)),
                 
                 #'content':Markup(html),
                 }
                 
        data = {'entry':entry}
        
        self._response_entry(req,data,status_code,location)
        #req.send_header('Location', entry['edit_href'])
        #return 'atom_media_entry.xml',data,'application/atom+xml'
        #return data


    def _response_entry(self,req,data,status_code=200,location=None):
        req.send_response(status_code)
        req.send_header('Content-Type', 'application/atom+xml')
        if location:
            req.send_header('location', location)
        req.end_headers()
        if req.method != 'HEAD':
            
            id = data['entry']['id']
            title = data['entry']['title']
            author = data['entry']['author']
            updated = data['entry']['updated']
            href = data['entry']['href']
            content = data['entry']['content']
            content_src = data['entry']['content_src']
            content_type = data['entry']['content_type']
            req.write('''<?xml version="1.0" encoding="utf-8"?>''')
            req.write('''
<entry xmlns="http://www.w3.org/2005/Atom" xmlns:app="http://www.w3.org/2007/app">
    <id>%s</id>
    <title type="text">%s</title>
    <author>
        <name>%s</name>
    </author>
    <updated>%s</updated>
    <app:edited>%s</app:edited>
    <summary type="xhtml">
        <div xmlns="http://www.w3.org/1999/xhtml"/>
    </summary>
    <link rel="self" type='application/atom+xml' href="%s" />
    <link rel="edit" type='application/atom+xml' href="%s" />
    <link rel="edit-media" type='application/atom+xml' href="%s" />
'''%(id,title,author,updated,updated,href,href,href,href))
            if content_src:
                req.write('''
<content type="%s" src="%s"/>
</entry>
'''%(content_type,content_src))            
            else:
                req.write('''
    <content type="%s" >
        <div xmlns="http://www.w3.org/1999/xhtml">%s</div>
    </content>
</entry>
'''%(content_type,content))            

    def _responsez(self, req, type_code=200, doc=None):
        req.send_response(type_code)
        req.send_header('Content-Type', 'application/atom+xml')
        req.end_headers()
        
        if req.method != 'HEAD' and doc != None:
            req.write(doc.toprettyxml(indent = '    '))
        raise RequestDone
    

    def _response_errorz(self, req, error_type,error_code=500,error_mes=''):
        
        if error_type == 'BadRequest':
             error_code = 400
             error_mes = 'XML parse failed.'
        elif error_type == 'Unauthorized WSSE':
             error_code = 401
             error_mes = 'X-WSSE authentication required'
             req.send_header('WWW-Authenticate','WSSE profile="UsernameToken"')
        elif error_type == 'Unauthorized Basic':
             error_code = 401
             error_mes = 'Basic authentication required'
             req.send_header('WWW-Authenticate','Basic realm="SECRET AREA"')
        elif error_type == 'Unauthorized Digest':
             error_code = 401
             error_mes = 'Basic authentication required'
             req.send_header('WWW-Authenticate','Basic realm="SECRET AREA"')
        elif error_type == 'Forbidden':
             error_code = 403
             error_mes = 'Forbidden'
        elif error_type == 'MethodNotAllowed':
             error_code = 405
             error_mes = 'Method Not Allowed'
        
        req.send_response(error_code)
        req.send_header('Content-Type', 'text/html;charset=UTF-8')
        req.end_headers()
        
        if req.method != 'HEAD':
            req.write('''
<HTML><HEAD><TITLE>%s</TITLE></HEAD><BODY></BODY></HTML>
'''%(error_mes))
            
            #req.write('<?xml version="1.0" encoding="UTF-8"?>\n')
            #req.write('<error>%s</error>'%error_mes)
        raise RequestDone



      


class Wiki(CommonHandler):
    implements(IAtomPubHandler)

    def _getTempPage(self,username,realm='wiki'):
        return  'tempolaryOf' + username

    ""
    ""

    # IAtomPubHandler methods
    def atompub_title(self):
        return 'wiki'
    
    def atompub_collection(self,req):
        return """
      <atom:title>Wiki</atom:title>
      <accept>*/*</accept>
      <categories fixed="no"/>
        """
#      <accept>image/*</accept>
#      <accept>application/atom+xml;type=entry</accept>

    def atompub_do_create(self,req,pagename,content_type,content):
        #TODO:should return page name and status_code
        username = req.authname
        status_code = 201
        try:
            self._do_save(req, pagename,content,username)
        except TracError:
            if TracError.title == "Page not modified":
                status_code = 304
            else:
                status_code = 500
        return pagename,status_code

    def atompub_do_update(self,req,pagename,content_type,content):
        return self.atompub_do_create(req,pagename,content_type,content)


    def atompub_do_delete(self,req):
        version = None
        page = WikiPage(self.env, id, version)
        page.delete(version)


    def atompub_do_create_attachment(self,req):
        return self._attachment(req,put_flag=True)

    def atompub_do_update_attachment(self,req,id):
        words = id.split('/')
        filename = words.pop()
        pagename = '/'.join(words)
        return self._attachment(req,filename=filename,pagename=pagename,realm='wiki',put_flag=False)



    def atompub_get_feedlist(self,req):
        # feed list request
        orderby = ''
        numberOfPosts = -1
        #entries = []

        db = self.env.get_db_cnx()
        cursor = db.cursor()
        limit=''
        if orderby != '':
            orderby = " ORDER BY %s "%orderby
            self.log.debug('orderby:%s'%orderby)
        if numberOfPosts != -1:
            limit = " Limit %s "%numberOfPosts
            
        cursor.execute('SELECT name, max(time), author, version, comment FROM wiki'
                       '  GROUP BY name ' + orderby + limit )
        result = []
        rowid = 0
        cate = []
        #cate.append(dict(discription='hoge',title='wiki'))
        entries = []

        for name, time, author, version, comment in cursor:
            entry = {'title':name,
                     'alternate_url':req.abs_href.atompub('login/wiki/edit/%s'%(name)),
                     'service_edit_url':req.abs_href.atompub('login/wiki/edit/%s'%(name)),
                     'service_feed_url':req.abs_href.atompub('login/wiki/feed/%s'%(name)),
                     'modified':format_datetime(to_datetime(time),'iso8601'),
                     'realm':'wiki:%s'%(name),
                     'content':''
                     }
            entries.append(entry)
        data = {'alternate_url':req.abs_href(), #ﾂﾱﾂﾱﾂﾪwlwﾂﾪﾊￇﾗﾝﾂﾷﾂ￩URLﾂ￉ﾂ￈ﾂ￩,
                'service_post_url':req.abs_href.atompub('post'),
                'service_feed_url':req.abs_href.atompub('feed'),
                'service_upload_url':req.abs_href.atompub('login/wiki/feed'),
                'title':'title:hoge',
                'author':'',
                'entries':entries      
                }
            #entries.append(entry)
        #self.log.debug(entries)
        #data['entriess'] = entries 
        #data['alternate'] = req.abs_href.wiki()
#        return 'wlwmanifest.xml',data
        return data
        #return 'atom_feed.xml', data, 'text/xml' #'application/atom+xml'


            
 
    def _do_save(self, req, pagename, content, username):
        self.username = username
        """ writes the content of the page. """
        page = WikiPage(self.env, pagename)
        if page.readonly:
            req.perm.assert_permission('WIKI_ADMIN')
        elif not page.exists:
            req.perm.assert_permission('WIKI_CREATE')
        else:
            req.perm.assert_permission('WIKI_MODIFY')

        ctx = Context.from_request(req,'wiki', pagename,absurls=True)

        self.log.debug(content['description'])
        hoge = XhtmlToWikiFormatter(self.env,ctx)
        hoge.setReq(req)
        hoge.setCaller(self)

        hoge.setTempPage(self._getTempPage(username))
        text = hoge.xhtmltowiki(content['description'])
        self.log.debug(text)
        page.text = text
        #try:
        page.save(username,
                  None,
                  req.remote_addr)
        #except TracError:
            #TODO: DELETE temp attachment,temp page
            #self._delete_temp_page(username)
            #raise TracError
            
        self._move_temp_attachment(pagename,username)
        #delete temp page
        self._delete_temp_page(username)
        return True

    def _move_temp_attachment(self,pagename,username):
        db = self.env.get_db_cnx()
        temp_attachments = Attachment.select(self.env, 'wiki', self._getTempPage(self.username),db=db)
        for temp_att in temp_attachments:
            filename = temp_att.filename
            try:
                data = temp_att.open().read()
                new_att = Attachment(self.env, 'wiki', pagename)
                new_att.author = username or 'anonymous'
                new_att.description = temp_att.description
                new_att.insert(filename, StringIO(data), len(data),db=db)
            except ResourceNotFound:
                self.log.error('ResourceNotFound: Attachment %s not found'%filename)
                pass
        Attachment.delete_all(self.env, 'wiki', self._getTempPage(self.username),db=db)
        db.commit()

    def _delete_temp_page(self,username):
        db = self.env.get_db_cnx()
        page = WikiPage(self.env, self._getTempPage(username))
        if page.exists:
            page.delete(db=db)

        db.commit()

    def atompub_get_feed(self,req,pagename,need_location=False):
        self.log.debug(pagename)
        #self._response_wiki(req,pagename=id)
        page = WikiPage(self.env, pagename, version=None)
        if page.exists:
            resource = Resource('wiki',pagename)
            context = Context(Resource('wiki',pagename))
            context.req = req
            html = wiki_to_html(page.text, self.env, req, absurls=1,resource=resource)
        else:
            msg = 'Wiki page "%s" does not exist' % pagename
            #if version is not None:
            #    msg += ' at version %s' % version
            raise TracError( msg)

        entry = {'id':page.name,
                 'title':page.name,
                 'author':page.author,
                 'updated':format_datetime(page.time,'iso8601'),
                 'content':Markup(html),
                 'content_src':None,
                 'content_type':'xhtml',
                 'href':req.abs_href.atompub('login/wiki/edit/%s'%(unicode_quote(to_unicode(page.name))))
                 }
        data = {'entry':entry}
        
        eo = Entry()
        eo.id = page.name
        eo.title = page.name
        eo.author = page.author
        eo.updated = format_datetime(page.time,'iso8601')
        eo.content = Markup(html)
        eo.href = req.abs_href.atompub('login/wiki/edit/%s'%(unicode_quote(to_unicode(page.name))))
        
        self.log.debug(data)
        
        # LocationをつけないとPostできないがつけると、Broken Pipeになる
        #location_header = None
        #if need_location==True:
        location_header= req.abs_href.atompub('login/wiki/edit/%s'%(unicode_quote(to_unicode(page.name))))
        
        return data,location_header


class Entry(object):

    def __init__(self):

        self.id = None
        self.title = None
        self.author = None
        self.updated = None
        self.content = None
        self.href = None
    

    
class Ticket(Wiki):
    implements(IAtomPubHandler)


    # IAtomPubHandler methods
    def atompub_title(self):
        return 'ticket'
    
    def atompub_collection(self,req):
        return """
      <atom:title>Ticket</atom:title>
      <accept>application/atom+xml;type=entry</accept>
      <accept>image/png</accept>
      <accept>image/jpeg</accept>
      <accept>image/gif</accept>
      <categories fixed="no"/>
        """

    def atompub_do_create(self,req,pagename,content_type,content):
        username = req.authname
        
        return self._do_save(req, pagename,content,username)

    def atompub_do_update(self,req,pagename,content_type,content):
        return self.atompub_do_create(req,pagename,content_type,content)


    def atompub_do_delete(self,req):
        pass


    def atompub_do_create_attachment(self,req):
        return self._attachment(req,put_flag=True)

    def atompub_do_update_attachment(self,req,id):
        words = id.split('/')
        filename = words.pop()
        pagename = '/'.join(words)
        return self._attachment(req,filename=filename,pagename=pagename,realm='ticket',put_flag=False)


    def atompub_get_feedlist(self,req):
        orderby = 'id desc'
        numberOfPosts = -1

        db = self.env.get_db_cnx()
        cursor = db.cursor()
        limit=''
        if orderby != '':
            orderby = " ORDER BY %s "%orderby
            self.log.debug('orderby:%s'%orderby)
        if numberOfPosts != -1:
            limit = " Limit %s "%numberOfPosts
            
        cursor.execute('SELECT id, summary ,changetime FROM ticket '+ orderby + limit )
        result = []
        rowid = 0
        cate = []
        #cate.append(dict(discription='hoge',title='wiki'))
        entries = []

        for id, summary ,changetime in cursor:
            entry = {'title':'#%s: %s'%(str(id),summary),
                     'alternate_url':req.abs_href.atompub('login/ticket/edit/%s'%(id)),
                     'service_edit_url':req.abs_href.atompub('login/ticket/edit/%s'%(id)),
                     'service_feed_url':req.abs_href.atompub('login/ticket/feed/%s'%(id)),
                     'modified':format_datetime(to_datetime(changetime),'iso8601'),
                     'realm':'ticket:%s'%(str(id)),
                     'content':''
                     }
            entries.append(entry)
        data = {'alternate_url':req.abs_href(),
                'service_post_url':req.abs_href.atompub('post'),
                'service_feed_url':req.abs_href.atompub('feed'),
                'service_upload_url':req.abs_href.atompub('upload'),
                'title':'title:hoge',
                'author':'',
                'entries':entries      
                }
            #entries.append(entry)
        #self.log.debug(entries)
        #data['entriess'] = entries 
        #data['alternate'] = req.abs_href.wiki()
#        return 'wlwmanifest.xml',data
        return data

    def atompub_get_feed(self,req,pagename,need_location=False):
        self.log.debug(pagename)
        #self._response_wiki(req,pagename=id)
        page = WikiPage(self.env, pagename, version=None)
        if page.exists:
            resource = Resource('wiki',pagename)
            context = Context(Resource('wiki',pagename))
            context.req = req
            html = wiki_to_html(page.text, self.env, req, absurls=1,resource=resource)
        else:
            msg = 'Wiki page "%s" does not exist' % pagename
            #if version is not None:
            #    msg += ' at version %s' % version
            raise TracError( msg)

        entry = {'id':page.name,
                 'title':page.name,
                 'author':page.author,
                 'updated':format_datetime(page.time,'iso8601'),
                 'content':Markup(html),
                 'href':req.abs_href.atompub('login/wiki/edit/%s'%(unicode_quote(to_unicode(page.name))))
                 }
        data = {'entry':entry}
        self.log.debug(data)
        
        # LocationをつけないとPostできないがつけると、Broken Pipeになる
        #location_header = None
        #if need_location==True:
        location_header= req.abs_href.atompub('login/wiki/edit/%s'%(unicode_quote(to_unicode(page.name))))
        
        return data,location_header
        
class AtomPub(Component):
    implements(IRequestHandler,ITemplateProvider,IPermissionRequestor)    

    service_providers = ExtensionPoint(IAtomPubHandler)

    
    # ITemplateProvider methods
    def get_htdocs_dirs(self):
        return []

    def get_templates_dirs(self):
        return [pkg_resources.resource_filename(__name__, 'templates')]
    
    # IRequestHandler methods
    def match_request(self, req):
        match = re.match(r'^/atompub(?:/(.*))?', req.path_info)
        if match:
            if match.group(1):
                req.args['action'] = match.group(1)
            return 1

    def process_request(self, req):
        #self._authorization(req)
        self.log.debug('@@authname:%s'%req.authname)
        pathsplit = req.args.get('action','').split('/')
        service = pathsplit.pop(0)
        if service == 'login':
            #header = req.environ.get('HTTP_AUTHORIZATION')
            #if header ==None:
            #    self.log.debug(req.environ)
            #    return self._response_error(req, 'Unauthorized Basic')
            service = pathsplit.pop(0)
        
        action = ''
        if len(pathsplit) > 0 :
            action = pathsplit.pop(0)
        id = '/'.join(pathsplit)

        try:
            for provider in self.service_providers:
                if service == provider.atompub_title():
                    
                    #return provider.atompub_handler(req,action,id)

                    req.perm.assert_permission('ATOM_PUB')
                    self.log.debug(action)
                    self.log.debug(req.method)
                    username = req.authname
                    
                    if action == 'edit':
                        if req.method == 'POST' or req.method == 'PUT':
                            # update page
                            (pagename,content_type,content) = self._parse_postdata(req)
                            pageid,status_code = provider.atompub_do_update(req, pagename,content_type,content)
                            data,loch = provider.atompub_get_feed(req,pageid)   
                            #return self._response_feed(req,  data,loch)
                            return self._response_entry(req,data,status_code,loch)
                        elif req.method == 'DELETE':
                            # delete page
                            provider.atompub_do_delete(req, id)
                            return self._response(req, 200,None)
                        else:
                            # get page 
                            data,loch = provider.atompub_get_feed(req,id)   
                            return self._response_entry(req,  data,200,None)
                    elif action == 'feed':
                        if req.method == 'POST' or req.method == 'PUT':
                            if req.get_header('Content-Type').startswith('application/atom+xml'):
                                # create page
                                (pagename,content_type,content) = self._parse_postdata(req)
                                pageid,status_code = provider.atompub_do_create(req, pagename,content_type,content)
                                data,loch = provider.atompub_get_feed(req,pageid)   
                                #return self._response_feed(req,  data,loch)
                                return self._response_entry(req,data,status_code,location=loch)
                            else:
                                # create attachment
                                return provider.atompub_do_create_attachment(req)
                        else:
                            # get feedlist
                            return 'atom_feed.xml', provider.atompub_get_feedlist(req), 'application/atom+xml' #'application/atom+xml'

                    elif action == 'attachment' or action == 'edit_attachment':
                        return provider.atompub_do_update_attachment(req,id)

            if service == 'wlwmanifest.xml':
                if action == '':
                    data = {}
                    return "wlwmanifest.xml",data,'application/xml'
                elif action == 'WebLayout':
                    data = {}
                    add_stylesheet(req, 'common/css/wiki.css')
                    add_stylesheet(req, 'wlwriter/css/wiki_temp_view.css')
                    return "WebLayout.html",data,None
                elif action == 'WebPreview':
                    pagename = 'WikiStart'      
                    context = Context.from_request(req,'wiki',pagename)
                    add_stylesheet(req, 'common/css/wiki.css')
                    add_stylesheet(req, 'wlwriter/css/wiki_temp_view.css')
                    data = {'page': context.resource,
                            'context': context,
                            'action': 'view',
                            'page_name': '{post-title}',
                            #'attachments': AttachmentModule(self.env).attachment_list(context),
                            'title': 'WebPreview'}
                    return "WebPreview.html",data,None
            elif service == 'attachment':
                req.perm.assert_permission('ATOM_PUB')
                # atompub/attachment/edit/wiki/pagename/../filename
                realm = pathsplit.pop(0)
                filename = pathsplit.pop()
                id = '/'.join(pathsplit)
                return self._process_attachement(req,action,realm,id,filename)
            else:
                return self._response_service(req)
        except Exception, e:
            self.log.error(e)
            import traceback
            from StringIO import StringIO
            out = StringIO()
            traceback.print_exc(file = out)
            self.log.error(out.getvalue())
            self._response_error(req, '',error_code=500,error_mes=str(e))
            #self._send_response(req, xmlrpclib.dumps(xmlrpclib.Fault(2, "'%s' while executing '%s()'" % (str(e), method))))
           
    def _response_feed(self,req,data,location_header=False):
        if location_header:
            req.send_header('Location', location_header)
        return 'atom_entry.xml',data,'application/atom+xml'


    def _response_entry(self,req,data,status_code=200,location=None):
        req.send_response(status_code)
        req.send_header('Content-Type', 'application/atom+xml')
        if location:
            req.send_header('location', location)
        req.end_headers()
        if req.method != 'HEAD':
            
            id = data['entry']['id']
            title = data['entry']['title']
            author = data['entry']['author']
            updated = data['entry']['updated']
            href = data['entry']['href']
            content = data['entry']['content']
            content_src = data['entry']['content_src']
            content_type = data['entry']['content_type']
            req.write('''<?xml version="1.0" encoding="utf-8"?>''')
            req.write('''
<entry xmlns="http://www.w3.org/2005/Atom" xmlns:app="http://www.w3.org/2007/app">
    <id>%s</id>
    <title type="text">%s</title>
    <author>
        <name>%s</name>
    </author>
    <updated>%s</updated>
    <app:edited>%s</app:edited>
    <summary type="xhtml">
        <div xmlns="http://www.w3.org/1999/xhtml"/>
    </summary>
    <link rel="self" type='application/atom+xml' href="%s" />
    <link rel="edit" type='application/atom+xml' href="%s" />
    <link rel="edit-media" href="%s" />
'''%(id,title,author,updated,updated,href,href,href))
            if content_src:
                req.write('''
<content type="%s" src="%s"/>
</entry>
'''%(content_type,content_src))            
            else:
                req.write('''
    <content type="%s" >
        <div xmlns="http://www.w3.org/1999/xhtml">%s</div>
    </content>
</entry>
'''%(content_type,content))            
        #raise RequestDone
        #TODO : ここでExceptionがおきると、エラーを送信できない
                    
        
    # IPermissionRequestor methods
    def get_permission_actions(self):
        yield 'ATOM_PUB'        
        

    def _parse_postdata(self,req):
        rawreq=req.read(int(req.get_header('Content-Length')))
        self.log.debug(rawreq)
        doc = XML(rawreq)
        description = Markup(doc.select('//content/.'))
        ## if content type="html" : need unescape
        content_type = str(doc.select('//content/@type'))
        if content_type == "html":
            description = unescape(Markup(doc.select('//content/.')))
            description = unescape(Markup(description))
        else :
            description = Markup(doc.select('//content/.'))
        
        #doc = self._loads(rawreq)
        #description = doc.getElementsByTagName('content')[0]
        self.log.debug(description)
        content = {'description':description}
        #pagename = self._get_text_tag(doc,'id')
        pagename = str(doc.select('//title/.'))
        #self.log.debug('@@id'+id)
        #self.log.debug(self._get_text_tag(doc,'content'))
        return (pagename,content_type,content)
 


    def _link(self,doc,rel=None,href=None,type=None,title=None):
        link = doc.createElement('link')
        if rel !=None:
            link.setAttribute('rel',rel)
        if href !=None:
            link.setAttribute('href',href)
        if type !=None:
            link.setAttribute('type',type)
        if title !=None:
            link.setAttribute('title',title)
        return link    
    


    def _process_ticket(self,req,action,id):
        pass


    def _response_service(self, req, type_code=200, doc=None):
        collections = []
        for provider in self.service_providers:
            collection = {'href':req.abs_href.atompub('login/%s/feed'%provider.atompub_title()),
                          'data':Markup(provider.atompub_collection(req))}
            collections.append(collection)
        

        #return 'atom_service.xml',{'collections':collections},'text/xml'#'application/atomsvc+xml'
        return 'atom_service.xml',{'collections':collections},'application/atomsvc+xml'



    def _responsez(self, req, type_code=200, doc=None):
        req.send_response(type_code)
        req.send_header('Content-Type', 'application/atom+xml')
        req.end_headers()
        
        if req.method != 'HEAD' and doc != None:
            req.write(doc.toprettyxml(indent = '    '))
        raise RequestDone
    

    def _response_error(self, req, error_type,error_code=500,error_mes=''):
        
        if error_type == 'BadRequest':
             error_code = 400
             error_mes = 'XML parse failed.'
        elif error_type == 'Unauthorized WSSE':
             error_code = 401
             error_mes = 'X-WSSE authentication required'
             req.send_header('WWW-Authenticate','WSSE profile="UsernameToken"')
        elif error_type == 'Unauthorized Basic':
             error_code = 401
             error_mes = 'Basic authentication required'
             req.send_header('WWW-Authenticate','Basic realm="SECRET AREA"')
        elif error_type == 'Unauthorized Digest':
             error_code = 401
             error_mes = 'Basic authentication required'
             req.send_header('WWW-Authenticate','Basic realm="SECRET AREA"')
        elif error_type == 'Forbidden':
             error_code = 403
             error_mes = 'Forbidden'
        elif error_type == 'MethodNotAllowed':
             error_code = 405
             error_mes = 'Method Not Allowed'
        
        req.send_response(error_code)
        req.send_header('Content-Type', 'text/html;charset=UTF-8')
        req.end_headers()
        
        if req.method != 'HEAD':
            req.write('''
<HTML><HEAD><TITLE>%s</TITLE></HEAD><BODY></BODY></HTML>
'''%(error_mes))
            
            #req.write('<?xml version="1.0" encoding="UTF-8"?>\n')
            #req.write('<error>%s</error>'%error_mes)
        raise RequestDone