def test_ByteSequence(self):
b1 = uno.ByteSequence(bytes("abcdefg", encoding="utf8"))
b2 = uno.ByteSequence(bytes("abcdefg", encoding="utf8"))
b3 = uno.ByteSequence(bytes("1234567", encoding="utf8"))
self.assertEqual(b1, b1)
self.assertEqual(b1, b2)
self.assertFalse(b1 != b2)
self.assertNotEqual(b1, b3)
def read(size=None):
if size is None:
data = ''
while True:
bytes = uno.ByteSequence('')
n_read, bytes = stream.readBytes(bytes, 4096)
if n_read == 0:
return data
data += bytes.value
bytes = uno.ByteSequence('')
n_read, bytes = stream.readBytes(bytes, size)
return bytes.value
def doConvert(self, buff):
inputprops = self.unoProps(Hidden=True,
ReadOnly=True,
UpdateDocMode=QUIET_UPDATE)
inputStream = self.svcmgr.createInstanceWithContext(
"com.sun.star.io.SequenceInputStream", self.context)
inputStream.initialize(
(uno.ByteSequence(buff), )) #Use stream from node ?
inputprops += self.unoProps(InputStream=inputStream)
inputurl = 'private:stream'
document = self.desktop.loadComponentFromURL(inputurl, "_blank", 0,
inputprops)
if not document:
raise Exception("The document could not be opened.")
outputStream = OutputStream()
outputprops = self.unoProps(FilterName=self.filterName,
OutputStream=outputStream,
Overwrite=True)
outputurl = "private:stream"
try:
document.storeToURL(outputurl, tuple(outputprops))
except IOException as e:
raise Exception(
"Unable to store document to %s (ErrCode %d)\n\nProperties: %s"
% (outputurl, e.ErrCode, outputprops), None)
document.dispose()
document.close(True)
return outputStream.buff
def insertSubreports(self, oo_subreports):
"""
Inserts the given file into the current document.
The file contents will replace the placeholder text.
"""
import os
for subreport in oo_subreports:
fd = file(subreport, 'rb')
placeholder_text = "<insert_doc('%s')>" % subreport
subdata = fd.read()
subStream = self.serviceManager.createInstanceWithContext(
"com.sun.star.io.SequenceInputStream", self.localContext)
subStream.initialize((uno.ByteSequence(subdata), ))
search = self.document.createSearchDescriptor()
search.SearchString = placeholder_text
found = self.document.findFirst(search)
#while found:
try:
found.insertDocumentFromURL(
'private:stream',
self._toProperties(InputStream=subStream,
FilterName="writer8"))
except Exception, ex:
print(
_("Error inserting file %s on the OpenOffice document: %s")
% (subreport, ex))
#found = self.document.findNext(found, search)
os.unlink(subreport)
def actionPerformed(self, event):
try:
if event.ActionCommand == "Run":
code = self.editor.getControl("EditorTextField").getText()
code = ensureSourceState(code)
mod = imp.new_module("ooo_script_framework")
mod.__dict__[
GLOBAL_SCRIPTCONTEXT_NAME] = self.provCtx.scriptContext
exec(code, mod.__dict__)
values = mod.__dict__.get(CALLABLE_CONTAINER_NAME, None)
if not values:
values = mod.__dict__.values()
for i in values:
if isScript(i):
i()
break
elif event.ActionCommand == "Save":
toWrite = uno.ByteSequence(
self.editor.getControl("EditorTextField").getText().encode(
sys.getdefaultencoding()))
copyUrl = self.uri + ".orig"
self.provCtx.sfa.move(self.uri, copyUrl)
out = self.provCtx.sfa.openFileWrite(self.uri)
out.writeBytes(toWrite)
out.close()
self.provCtx.sfa.kill(copyUrl)
# log.debug("Save is not implemented yet")
# text = self.editor.getControl("EditorTextField").getText()
# log.debug("Would save: " + text)
except:
# TODO: add an error box here!
log.error(lastException2String())
def convertByStream(self, stdinBytes, outputExt='pdf'):
inputStream = self.ServiceManager.createInstanceWithContext(
"com.sun.star.io.SequenceInputStream", self.localContext)
inputStream.initialize((uno.ByteSequence(stdinBytes), ))
document = self.desktop.loadComponentFromURL(
'private:stream', "_blank", 0,
self._toProperties(Hidden=True, InputStream=inputStream))
if not document:
raise Exception, "Error making document"
try:
document.refresh()
except AttributeError:
pass
filterName = FILTER_MAP[outputExt]
outputStream = OutputStream(False)
try:
outputprops = self._toProperties(OutputStream=outputStream,
FilterName=filterName,
Overwrite=True)
document.storeToURL("private:stream", outputprops)
finally:
document.close(True)
data = outputStream.data.getvalue()
outputStream.close()
return data
def run(self):
address = self.controller.Configuration.Url.Scope.Provider.RedirectAddress
port = self.controller.Configuration.Url.Scope.Provider.RedirectPort
result = uno.getConstantByName(
'com.sun.star.ui.dialogs.ExecutableDialogResults.CANCEL')
connection = self.acceptor.accept(
'socket,host=%s,port=%s,tcpNoDelay=1' % (address, port))
if connection:
with self.lock:
result = self._getResult(connection)
basename = getResourceLocation(self.ctx, g_identifier,
'OAuth2OOo')
basename += '/OAuth2Success_%s.html' if result else '/OAuth2Error_%s.html'
locale = getCurrentLocale(self.ctx)
length, body = getFileSequence(self.ctx,
basename % locale.Language,
basename % 'en')
header = uno.ByteSequence(b'''\
HTTP/1.1 200 OK
Content-Length: %d
Content-Type: text/html; charset=utf-8
Connection: Closed
''' % length)
connection.write(header + body)
connection.close()
self.acceptor.stopAccepting()
self.controller.Handler.Wizard.DialogWindow.endDialog(result)
self.lock.notifyAll()
def convertByStream(self, stdinBytes, filterName):
inputStream = self.serviceManager.createInstanceWithContext("com.sun.star.io.SequenceInputStream", self.localContext)
inputStream.initialize((uno.ByteSequence(stdinBytes),))
document = self.desktop.loadComponentFromURL('private:stream', "_blank", 0, self._toProperties(
InputStream=inputStream,
Hidden=False))
if not document:
raise Exception, "Error making document"
try:
document.refresh()
except AttributeError:
pass
outputStream = OutputStreamWrapper(False)
properties = dict(
Overwrite=True,
OutputStream=outputStream,
FilterName=filterName)
anyException = False
if "pdf_" in filterName:
properties["FilterData"] = self._addPdf()
try:
document.storeToURL('private:stream', self._toProperties(**properties))
except Exception, e:
anyException = e
pass
def storeByPath(self, stdinBytes, outputExt='pdf'):
inputStream = self.ServiceManager.createInstanceWithContext(
"com.sun.star.io.SequenceInputStream", self.localContext)
inputStream.initialize((uno.ByteSequence(stdinBytes), ))
document = self.desktop.loadComponentFromURL(
'private:stream', "_blank", 0,
self._toProperties(Hidden=True, InputStream=inputStream))
if not document:
raise Exception, "Error making document"
try:
document.refresh()
except AttributeError:
pass
filterName = FILTER_MAP[outputExt]
outputFile = tempfile.mktemp(suffix='.%s' % outputExt)
outputUrl = self._toFileUrl(outputFile)
try:
document.storeToURL(
outputUrl,
self._toProperties(FilterName=FILTER_MAP[outputExt],
Overwrite=True))
finally:
document.close(True)
data = open(outputFile, "rb").read()
return data
def putDocument(self, data):
try:
self.desktop = self._context.ServiceManager.createInstanceWithContext(
"com.sun.star.frame.Desktop", self._context)
except UnknownPropertyException:
self._context = self._resolver.resolve(RESOLVESTR %
(self._host, self._port))
self.desktop = self._context.ServiceManager.createInstanceWithContext(
"com.sun.star.frame.Desktop", self._context)
inputStream = self.serviceManager.createInstanceWithContext(
"com.sun.star.io.SequenceInputStream", self.localContext)
inputStream.initialize((uno.ByteSequence(data), ))
props = self._toProperties(InputStream=inputStream,
FilterName="writer8")
try:
self.document = self.desktop.loadComponentFromURL(
'private:stream', "_blank", 0, props)
except:
exceptionType, exceptionValue, exceptionTraceback = sys.exc_info()
traceback.print_exception(exceptionType,
exceptionValue,
exceptionTraceback,
limit=2,
file=sys.stdout)
inputStream.closeInput()
def convert_by_stream(self, data, format=LIBREOFFICE_OPEN_DOCUMENT):
data.seek(0)
input_stream = self._service_manager.createInstanceWithContext(
"com.sun.star.io.SequenceInputStream", self._local_context)
input_stream.initialize((uno.ByteSequence(data.read()), ))
document = self._desktop.loadComponentFromURL(
'private:stream', "_blank", 0,
self._to_properties(InputStream=input_stream, ReadOnly=True))
if not document:
raise Exception, "Error making document"
try:
document.refresh()
except AttributeError:
pass
output_stream = output_stream_wrapper()
try:
document.storeToURL(
'private:stream',
self._to_properties(OutputStream=output_stream,
FilterName=format))
finally:
document.close(True)
if format == LIBREOFFICE_OPEN_DOCUMENT:
doc_type = document_type.detect_document_type(output_stream.data)
if doc_type != document_type.types.oasis_open_document:
raise docvert_exception.converter_unable_to_generate_open_document(
)
return output_stream.data
def run(self):
connection = None
try:
connection = self.acceptor.accept(self.argument)
except AlreadyAcceptingException as e:
msg = "Error: %s - %s" % (e, traceback.print_exc())
logMessage(self.ctx, SEVERE, msg, 'Server', 'run()')
except ConnectionSetupException as e:
msg = "Error: %s - %s" % (e, traceback.print_exc())
logMessage(self.ctx, SEVERE, msg, 'Server', 'run()')
except IllegalArgumentException as e:
msg = "Error: %s - %s" % (e, traceback.print_exc())
logMessage(self.ctx, SEVERE, msg, 'Server', 'run()')
if connection:
with self.lock:
result = self._getResult(connection)
location = self._getResultLocation(result)
location += '?%s' % urlencode({'user': self.user})
header = '''\
HTTP/1.1 302 Found
Location: %s
Connection: Closed
''' % location
try:
connection.write(uno.ByteSequence(header.encode('utf8')))
except IOException as e:
msg = "Error: %s - %s" % (e, traceback.print_exc())
logMessage(self.ctx, SEVERE, msg, 'Server', 'run()')
connection.flush()
connection.close()
self.acceptor.stopAccepting()
self.lock.notifyAll()
logMessage(self.ctx, INFO, "Server Running ... Done", 'Server',
'run()')
def getFileSequence(ctx, url, default=None):
length, sequence = 0, uno.ByteSequence(b'')
fs = getSimpleFile(ctx)
if fs.exists(url):
length, sequence = _getSequence(fs.openFileRead(url), fs.getSize(url))
elif default is not None and fs.exists(default):
length, sequence = _getSequence(fs.openFileRead(default), fs.getSize(default))
return length, sequence
def joinDocuments(self, docs):
while(docs):
subStream = self.serviceManager.createInstanceWithContext("com.sun.star.io.SequenceInputStream", self.localContext)
subStream.initialize((uno.ByteSequence(docs.pop()),))
try:
self.document.Text.getEnd().insertDocumentFromURL('private:stream', self._toProperties(InputStream = subStream, FilterName = "writer8"))
except Exception, ex:
print (_("Error inserting file %s on the OpenOffice document: %s") % (docs, ex))
def readBytes( self, retSeq, nByteCount ):
nRet = 0
if( self.nIndex + nByteCount > len(self.s) ):
nRet = len(self.s) - self.nIndex
else:
nRet = nByteCount
retSeq = uno.ByteSequence(self.s.value[self.nIndex : self.nIndex + nRet ])
self.nIndex = self.nIndex + nRet
return nRet, retSeq
def readTextFromStream(inputStream):
# read the file
code = uno.ByteSequence("")
while True:
read, out = inputStream.readBytes(None, BLOCK_SIZE)
code = code + out
if read < BLOCK_SIZE:
break
return code.value
def convert(self,
document,
format=None,
output_filename=None,
delete_on_close=True):
output_filename, format = guess_format_and_filename(
output_filename, format)
### Do the OpenOffice component dance
context = uno.getComponentContext()
resolver = context.ServiceManager.createInstanceWithContext(
'com.sun.star.bridge.UnoUrlResolver', context)
unocontext = resolver.resolve('uno:%s' % OOO_CONNECTION)
### And some more OpenOffice magic
unosvcmgr = unocontext.ServiceManager
desktop = unosvcmgr.createInstanceWithContext(
'com.sun.star.frame.Desktop', unocontext)
config = unosvcmgr.createInstanceWithContext(
'com.sun.star.configuration.ConfigurationProvider', unocontext)
### Load inputfile
instream = InputStream(uno.ByteSequence(document.read()))
inputprops = [
PropertyValue('InputStream', 0, instream, 0),
]
if document.format == 'html':
inputprops.append(
PropertyValue('FilterName', 0, 'HTML (StarWriter)', 0))
doc = desktop.loadComponentFromURL('private:stream', '_blank', 0,
tuple(inputprops))
### Update document links
# skip ...
### Update document indexes
# skip ...
### Write outputfile
fd = open(output_filename, 'w')
filter_name = formats[format]
outputprops = [
PropertyValue(
'FilterData', 0,
uno.Any(
'[]com.sun.star.beans.PropertyValue',
tuple(),
), 0),
PropertyValue('FilterName', 0, filter_name, 0),
PropertyValue('OutputStream', 0, OutputStream(fd), 0),
PropertyValue('Overwrite', 0, True, 0),
]
if filter_name == 'Text (encoded)':
outputprops.append(PropertyValue('FilterFlags', 0, 'UTF8, LF', 0))
doc.storeToURL('private:stream', tuple(outputprops))
doc.dispose()
doc.close(True)
fd.close()
fd = Document(output_filename,
mode='r',
delete_on_close=delete_on_close)
return fd
def putDocument(self, data):
try:
desktop = self._context.ServiceManager.createInstanceWithContext("com.sun.star.frame.Desktop", self._context)
except UnknownPropertyException:
self._context = self._resolver.resolve("uno:socket,host=%s,port=%s;urp;StarOffice.ComponentContext" % (self._host, self._port))
desktop = self._context.ServiceManager.createInstanceWithContext("com.sun.star.frame.Desktop", self._context)
inputStream = self.serviceManager.createInstanceWithContext("com.sun.star.io.SequenceInputStream", self.localContext)
inputStream.initialize((uno.ByteSequence(data),))
self.document = desktop.loadComponentFromURL('private:stream', "_blank", 0, self._toProperties(InputStream = inputStream))
inputStream.closeInput()
def __detect(self, xInputStream):
bytes = uno.ByteSequence('')
# Input with and without UTF-8 BOM is OK.
for i in ["0 HEAD", "\ufeff0 HEAD"]:
xInputStream.seek(0)
# readBytes() returns a (read, bytes) tuple.
bytes = xInputStream.readBytes(bytes, len(i.encode('utf-8')))[1]
if bytes.value.decode('utf-8') == i:
return True
return False
def __detect(input_stream: Any) -> bool:
byte_sequence = uno.ByteSequence(bytes())
# Input with and without UTF-8 BOM is OK.
for i in ["0 HEAD", "\ufeff0 HEAD"]:
input_stream.seek(0)
# readBytes() returns a (read, byte_sequence) tuple.
byte_sequence = input_stream.readBytes(byte_sequence, len(i.encode('utf-8')))[1]
if byte_sequence.value.decode('utf-8') == i:
return True
return False
def create_graphic_from_binary(self, binary):
"""グラフィックオブジェクトを生成"""
istream = self.smgr.createInstanceWithContext(
CSS + ".io.SequenceInputStream", self.context)
istream.initialize((uno.ByteSequence(binary), ))
logging.debug("Istream created %s" % (istream))
gobj = self.graphicprovider.queryGraphic(
(PropertyValue("InputStream", 0, istream, 0), ))
logging.debug("queryGraphic %s" % (gobj, ))
return gobj
def readBytes(self, sequence, length):
i = length - len(self.buffers)
if i < 0:
j = abs(i)
sequence = uno.ByteSequence(self.buffers[:j])
self.buffers = self.buffers[j:]
return len(sequence), sequence
sequence = uno.ByteSequence(self.buffers)
self.buffers = b''
while i > 0:
chunk = next(self.chunks, b'')
j = len(chunk)
if j == 0:
break
elif j > i:
sequence += chunk[:i]
self.buffers = chunk[i:]
break
sequence += chunk
i = length - len(sequence)
return len(sequence), sequence
def readTextFromStream(inputStream):
# read the file
code = uno.ByteSequence(b"")
while True:
read, out = inputStream.readBytes(None, BLOCK_SIZE)
code = code + out
if read < BLOCK_SIZE:
break
if sys.version_info[0] > 2:
return str(code.value, 'utf-8')
else:
return code.value
def getFileSequence(ctx, url, default=None):
length = 0
sequence = uno.ByteSequence(b'')
fs = getSimpleFile(ctx)
if fs.exists(url):
inputstream = fs.openFileRead(url)
size = fs.getSize(url)
length, sequence = _getSequence(inputstream, size)
elif default is not None and fs.exists(default):
inputstream = fs.openFileRead(default)
size = fs.getSize(default)
length, sequence = _getSequence(inputstream, size)
return length, sequence
def convert(source, target, target_format):
home_dir = tempfile.mkdtemp()
errcode = None
popen = None
try:
port = get_free_port()
popen, context, desktop = start_openoffice(home_dir, port)
input_stream = context.ServiceManager.createInstanceWithContext(
'com.sun.star.io.SequenceInputStream', context)
input_stream.initialize((uno.ByteSequence(source.read()), ))
doc = desktop.loadComponentFromURL(
'private:stream', '_blank', 0,
to_properties({
'InputStream': input_stream,
}))
try:
doc.refresh()
except AttributeError:
pass
try:
doc.storeToURL(
'private:stream',
to_properties({
'FilterName': FILTER_MAP[target_format],
'OutputStream': OutputStream(target),
}))
finally:
doc.close(True)
try:
desktop.terminate()
except:
pass
if popen.returncode is None:
errcode = popen.wait()
except Exception as e:
print >> sys.stderr, e
errcode = 1
finally:
if errcode is None and popen and popen.returncode is None:
try:
errcode = popen.kill()
except:
pass
time.sleep(0.5)
shutil.rmtree(home_dir)
exit(errcode)
def testByteSequence( self ):
s = uno.ByteSequence( "ab" )
self.failUnless( s == uno.ByteSequence( "ab" ) )
self.failUnless( uno.ByteSequence( "abc" ) == s + uno.ByteSequence( "c" ) )
self.failUnless( uno.ByteSequence( "abc" ) == s + "c" )
self.failUnless( s + "c" == "abc" )
self.failUnless( s == uno.ByteSequence( s ) )
self.failUnless( s[0] == 'a' )
self.failUnless( s[1] == 'b' )
def readBytes(self, sequence, length):
i = length - len(self.buffers)
if i < 0:
j = abs(i)
sequence = uno.ByteSequence(self.buffers[:j])
self.buffers = self.buffers[j:]
return len(sequence), sequence
sequence = uno.ByteSequence(self.buffers)
self.buffers = b''
while i > 0:
chunk = next(self.chunks, b'')
j = len(chunk)
print("Request.InputStream.readBytes()1: %s - %s" % (j, length))
if j == 0:
break
elif j > i:
sequence += chunk[:i]
self.buffers = chunk[i:]
break
sequence += chunk
i = length - len(sequence)
print("Request.InputStream.readBytes()2: %s - %s" %
(length, len(sequence)))
return len(sequence), sequence
def getFileSequence(ctx, url, default=None):
length = 0
sequence = uno.ByteSequence(b'')
fileservice = ctx.ServiceManager.createInstance(
'com.sun.star.ucb.SimpleFileAccess')
if fileservice.exists(url):
inputstream = fileservice.openFileRead(url)
length, sequence = inputstream.readBytes(None,
fileservice.getSize(url))
inputstream.closeInput()
elif default is not None and fileservice.exists(default):
inputstream = fileservice.openFileRead(default)
length, sequence = inputstream.readBytes(None,
fileservice.getSize(default))
inputstream.closeInput()
return length, sequence
def filter(self, props):
try:
self.props = self.toDict(props)
path = unohelper.fileUrlToSystemPath(self.props["URL"])
buf = self.__toSvg(path)
xInputStream = self.createUnoService("io.SequenceInputStream")
xInputStream.initialize((uno.ByteSequence(buf), ))
xFilter = self.createUnoService("comp.Draw.SVGFilter")
xFilter.setTargetDocument(self.xDstDoc)
value = PropertyValue()
value.Name = "InputStream"
value.Value = xInputStream
xFilter.filter((value, ))
return True
except:
self.printTraceback()
return False
def _write_to_file(self, file_url, text):
""" Write text to the file. """
import bookmarks.tools
import uno
sfa = bookmarks.tools.create_service(
self.ctx, "com.sun.star.ucb.SimpleFileAccess")
if sfa.exists(file_url):
sfa.kill(file_url)
io = sfa.openFileWrite(file_url)
try:
total = len(text) - 1
n = 0
while True:
io.writeBytes(uno.ByteSequence(text[n:n + 0xffff]))
n += 0xffff
if n >= total:
break
except Exception as e:
print(e)
io.closeOutput()
