233 lines
7.4 KiB
Python
233 lines
7.4 KiB
Python
# -*- coding: utf-8 -*-
|
|
##############################################################################
|
|
#
|
|
# OpenERP, Open Source Management Solution
|
|
# Copyright (C) 2004-2010 Tiny SPRL (<http://tiny.be>).
|
|
# Copyright (c) 1999 Christian Scholz (ruebe@aachen.heimat.de)
|
|
#
|
|
# This program is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU Affero General Public License as
|
|
# published by the Free Software Foundation, either version 3 of the
|
|
# License, or (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU Affero General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU Affero General Public License
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
#
|
|
##############################################################################
|
|
|
|
import xml.dom.minidom
|
|
domimpl = xml.dom.minidom.getDOMImplementation()
|
|
import urlparse
|
|
import urllib
|
|
from osv import osv
|
|
|
|
try:
|
|
from DAV import utils
|
|
from DAV.propfind import PROPFIND
|
|
except ImportError:
|
|
raise osv.except_osv('PyWebDAV Import Error!','Please install PyWebDAV \
|
|
from http://code.google.com/p/pywebdav/downloads/detail?name=PyWebDAV-0.9.4.tar.gz&can=2&q=/')
|
|
|
|
import tools
|
|
|
|
|
|
super_mk_prop_response = PROPFIND.mk_prop_response
|
|
def mk_prop_response(self, uri, good_props, bad_props, doc):
|
|
""" make a new <prop> result element
|
|
|
|
We differ between the good props and the bad ones for
|
|
each generating an extra <propstat>-Node (for each error
|
|
one, that means).
|
|
|
|
"""
|
|
re=doc.createElement("D:response")
|
|
# append namespaces to response
|
|
nsnum=0
|
|
namespaces = self.namespaces
|
|
if 'DAV:' in namespaces:
|
|
namespaces.remove('DAV:')
|
|
for nsname in namespaces:
|
|
re.setAttribute("xmlns:ns"+str(nsnum),nsname)
|
|
nsnum=nsnum+1
|
|
|
|
def _prop_child(xnode, ns, prop, value):
|
|
"""Append a property xml node to xnode, with <prop>value</prop>
|
|
|
|
And a little smarter than that, it will consider namespace and
|
|
also allow nested properties etc.
|
|
|
|
:param ns the namespace of the <prop/> node
|
|
:param prop the name of the property
|
|
:param value the value. Can be:
|
|
string: text node
|
|
tuple ('elem', 'ns') for empty sub-node <ns:elem />
|
|
tuple ('elem', 'ns', sub-elems) for sub-node with elements
|
|
list, of above tuples
|
|
"""
|
|
if ns == 'DAV:':
|
|
ns_prefix = 'D:'
|
|
else:
|
|
ns_prefix="ns"+str(namespaces.index(ns))+":"
|
|
|
|
pe=doc.createElement(ns_prefix+str(prop))
|
|
if hasattr(value, '__class__') and value.__class__.__name__ == 'Element':
|
|
pe.appendChild(value)
|
|
else:
|
|
if ns == 'DAV:' and prop=="resourcetype" and isinstance(value, int):
|
|
# hack, to go..
|
|
if value == 1:
|
|
ve=doc.createElement("D:collection")
|
|
pe.appendChild(ve)
|
|
else:
|
|
_prop_elem_child(pe, ns, value, ns_prefix)
|
|
|
|
xnode.appendChild(pe)
|
|
|
|
def _prop_elem_child(pnode, pns, v, pns_prefix):
|
|
|
|
if isinstance(v, list):
|
|
for vit in v:
|
|
_prop_elem_child(pnode, pns, vit, pns_prefix)
|
|
elif isinstance(v,tuple):
|
|
need_ns = False
|
|
if v[1] == pns:
|
|
ns_prefix = pns_prefix
|
|
elif v[1] == 'DAV:':
|
|
ns_prefix = 'D:'
|
|
elif v[1] in namespaces:
|
|
ns_prefix="ns"+str(namespaces.index(v[1]))+":"
|
|
else:
|
|
ns_prefix="ns"+str(nsnum)+":"
|
|
need_ns = True
|
|
|
|
ve=doc.createElement(ns_prefix+v[0])
|
|
if need_ns:
|
|
ve.setAttribute("xmlns:ns"+str(nsnum), v[1])
|
|
if len(v) > 2 and isinstance(v[2], list):
|
|
# support nested elements like:
|
|
# ( 'elem', 'ns:', [('sub-elem1', 'ns1'), ...]
|
|
_prop_elem_child(ve, v[1], v[2], ns_prefix)
|
|
pnode.appendChild(ve)
|
|
else:
|
|
ve=doc.createTextNode(tools.ustr(v))
|
|
pnode.appendChild(ve)
|
|
|
|
# write href information
|
|
uparts=urlparse.urlparse(uri)
|
|
fileloc=uparts[2]
|
|
if isinstance(fileloc, unicode):
|
|
fileloc = fileloc.encode('utf-8')
|
|
href=doc.createElement("D:href")
|
|
davpath = self._dataclass.parent.get_davpath()
|
|
hurl = '%s://%s%s%s' % (uparts[0], uparts[1], davpath, urllib.quote(fileloc))
|
|
huri=doc.createTextNode(hurl)
|
|
href.appendChild(huri)
|
|
re.appendChild(href)
|
|
|
|
# write good properties
|
|
ps=doc.createElement("D:propstat")
|
|
if good_props:
|
|
re.appendChild(ps)
|
|
|
|
gp=doc.createElement("D:prop")
|
|
for ns in good_props.keys():
|
|
if ns == 'DAV:':
|
|
ns_prefix = 'D:'
|
|
else:
|
|
ns_prefix="ns"+str(namespaces.index(ns))+":"
|
|
for p,v in good_props[ns].items():
|
|
if not v:
|
|
continue
|
|
_prop_child(gp, ns, p, v)
|
|
|
|
ps.appendChild(gp)
|
|
s=doc.createElement("D:status")
|
|
t=doc.createTextNode("HTTP/1.1 200 OK")
|
|
s.appendChild(t)
|
|
ps.appendChild(s)
|
|
re.appendChild(ps)
|
|
|
|
# now write the errors!
|
|
if len(bad_props.items()):
|
|
|
|
# write a propstat for each error code
|
|
for ecode in bad_props.keys():
|
|
ps=doc.createElement("D:propstat")
|
|
re.appendChild(ps)
|
|
bp=doc.createElement("D:prop")
|
|
ps.appendChild(bp)
|
|
|
|
for ns in bad_props[ecode].keys():
|
|
if ns == 'DAV:':
|
|
ns_prefix='D:'
|
|
else:
|
|
ns_prefix="ns"+str(self.namespaces.index(ns))+":"
|
|
|
|
for p in bad_props[ecode][ns]:
|
|
pe=doc.createElement(ns_prefix+str(p))
|
|
bp.appendChild(pe)
|
|
|
|
s=doc.createElement("D:status")
|
|
t=doc.createTextNode(utils.gen_estring(ecode))
|
|
s.appendChild(t)
|
|
ps.appendChild(s)
|
|
re.appendChild(ps)
|
|
|
|
# return the new response element
|
|
return re
|
|
|
|
|
|
def mk_propname_response(self,uri,propnames,doc):
|
|
""" make a new <prop> result element for a PROPNAME request
|
|
|
|
This will simply format the propnames list.
|
|
propnames should have the format {NS1 : [prop1, prop2, ...], NS2: ...}
|
|
|
|
"""
|
|
re=doc.createElement("D:response")
|
|
|
|
# write href information
|
|
uparts=urlparse.urlparse(uri)
|
|
fileloc=uparts[2]
|
|
if isinstance(fileloc, unicode):
|
|
fileloc = fileloc.encode('utf-8')
|
|
href=doc.createElement("D:href")
|
|
davpath = self._dataclass.parent.get_davpath()
|
|
hurl = '%s://%s%s%s' % (uparts[0], uparts[1], davpath, urllib.quote(fileloc))
|
|
huri=doc.createTextNode(hurl)
|
|
href.appendChild(huri)
|
|
re.appendChild(href)
|
|
|
|
ps=doc.createElement("D:propstat")
|
|
nsnum=0
|
|
|
|
for ns,plist in propnames.items():
|
|
# write prop element
|
|
pr=doc.createElement("D:prop")
|
|
if ns == 'DAV':
|
|
nsp = 'D'
|
|
else:
|
|
nsp="ns"+str(nsnum)
|
|
ps.setAttribute("xmlns:"+nsp,ns)
|
|
nsnum=nsnum+1
|
|
|
|
# write propertynames
|
|
for p in plist:
|
|
pe=doc.createElement(nsp+":"+p)
|
|
pr.appendChild(pe)
|
|
|
|
ps.appendChild(pr)
|
|
|
|
re.appendChild(ps)
|
|
|
|
return re
|
|
|
|
PROPFIND.mk_prop_response = mk_prop_response
|
|
PROPFIND.mk_propname_response = mk_propname_response
|
|
|