def upload_batch_to_alfresco(files):
from cmislib import CmisClient
def map_to_alfresco(prop):
return {
'ag:{}'.format(k.lower().replace(' ', '_')): str(v)
for k, v in prop.iteritems()
}
client = CmisClient(ATOM_URL, USER, PASSWORD)
repo = client.getDefaultRepository()
folder = repo.getObjectByPath(FILE_BASE_PATH)
for index, (_properties, upload_file_path) in enumerate(files):
try:
properties = map_to_alfresco(_properties)
properties.update({'cmis:objectTypeId': 'D:ag:consignment_note'})
upload_file = open(upload_file_path, 'rb')
file_name = '{}.pdf'.format(properties['ag:consignment_name'])
doc = folder.createDocument(file_name,
properties,
contentFile=upload_file)
upload_file.close()
print('File Uploaded ({} of {}) {}'.format(index + 1, len(files),
properties))
except Exception as e:
logging.error("Failed to upload file {} \n caused by {}".format(
properties, e))
raise
def update_cmis(doc_id, repo_name, text):
repo = CmisClient(flow.settings["cmis_url"], flow.settings["cmis_username"], flow.settings["cmis_password"]).defaultRepository
document = repo.getObject(doc_id)
logging.debug(document)
update_dict = {}
update_dict[repo_name] = text
logging.debug(update_dict)
document.updateProperties(update_dict)
def upload_sample_documents(self):
repo = CmisClient(self.settings["cmis_url"], self.settings["cmis_username"], self.settings["cmis_password"]).defaultRepository
try:
repo.getObjectByPath(self.settings["capture_folder"])
self.LOGGER.debug("Capture folder available")
except:
self.LOGGER.debug("CMIS folder not present. Uploading demo files.")
parent_folder_name = "/".join(self.settings["capture_folder"].split("/")[:-1])
parent_folder = repo.getObjectByPath(parent_folder_name)
demoFolder = repo.createFolder(parent_folder, self.settings["capture_folder"].split("/")[-1])
demoFolder.createDocument('Invoice01.pdf', contentFile=open("test/data-barcode-skeleton/doc001/Invoice01.pdf"))
demoFolder.createDocument('Invoice02.pdf', contentFile=open("test/data-barcode-skeleton/doc002/Invoice02.pdf"))
def ensure_connection(self):
if self.connection is None:
self.cmis_client = CmisClient(
self.settings_dict['HOST'],
self.settings_dict['USER'],
self.settings_dict['PASSWORD'],
binding=self.cmis_binding()
)
repo_name = self.settings_dict['NAME']
if repo_name == "default" or not repo_name:
self.connection = self.cmis_client.defaultRepository
else:
self.connection = self.cmis_client.getRepository(repo_name)
if django.conf.settings.DEBUG:
print "Connected to Repository with ID %s" % self.connection.id
def __init__(self, alfresco_repository_url, alfresco_cmis_rest_api_url,
alfresco_admin_user, alfresco_admin_password):
self.alfresco_repository_url = alfresco_repository_url
self.alfresco_cmis_rest_api_url = alfresco_cmis_rest_api_url
self.alfresco_admin_user = alfresco_admin_user
self.alfresco_admin_password = alfresco_admin_password
try:
self.cmis_client = CmisClient(self.alfresco_cmis_rest_api_url,
self.alfresco_admin_user,
self.alfresco_admin_password)
except:
return HttpResponseBadRequest(
'<h1>Failed to connect to Alfresco</h1>')
def setUp(self):
""" Create a root test folder for the test. """
self._cmisClient = CmisClient(REPOSITORY_URL, USERNAME, PASSWORD, **EXT_ARGS)
self._repo = self._cmisClient.getDefaultRepository()
self._rootFolder = self._repo.getObjectByPath(TEST_ROOT_PATH)
self._folderName = " ".join(["cmislibalf", self.__class__.__name__, str(time())])
self._testFolder = self._rootFolder.createFolder(self._folderName)
def get_cmis_client(self, config_file):
with open(config_file) as json_file:
config = json.load(json_file)
self.cmis_client = CmisClient(config['endpoint'], config['username'], config['password'])
self.repo = self.cmis_client.defaultRepository
def setUp(self):
super(BaseTestCmisProxy, self).setUp()
cmis_location = os.environ.get('CMIS_LOCATION') or \
('http://10.7.20.179:8080/alfresco/api/-default-'
'/public/cmis/versions/1.1/browser/')
cmis_user = os.environ.get('CMIS_USER') or 'admin'
cmis_pwd = os.environ.get('CMIS_PWD') or 'admin'
self.cmis_test_root_path = os.environ.get('CMIS_ROOT') or '/Odoo_proxy'
if not cmis_location or not cmis_user or not cmis_pwd:
self.skipTest("To run these tests you must provide the following "
"env var: CMIS_LOCATION, CMIS_USER, CMIS_PWD")
cmis_backend = self.env['cmis.backend']
cmis_backend.search([(1, '=', 1)]).unlink()
self.cmis_backend = cmis_backend.create({
'name': 'TEST_CMIS_PROXY',
'location': cmis_location,
'is_cmis_proxy': True,
'apply_odoo_security': False,
'username': cmis_user,
'password': cmis_pwd,
'version': '1.0'
})
web_descr = self.cmis_backend.get_web_description()[
self.cmis_backend.id]
proxy_path = web_descr['cmis_location']
self.authenticate('admin', 'admin')
self.cmis_url = 'http://%s:%d%s' % (common.HOST, common.PORT,
proxy_path)
self.headers = {'Cookie': 'session_id=%s' % self.session_id}
self.cmis_client = CmisClient(self.cmis_url,
'admin',
'admin',
headers=self.headers)
self.cmis_client.binding = BrowserBinding(headers=self.headers)
def setup_module(module):
try:
module.TestConnection.client = CmisClient(CMISURL, CMISUSER, CMISPASS)
module.TestConnection.client.getDefaultRepository()
except cmislib.exceptions.PermissionDeniedException:
pytest.fail('Connection error')
except Exception, e:
pytest.fail('Error ', str(e))
def __init__(self, url, user, password, repository_id=None,
document_root='/'):
self.client = CmisClient(url, user, password)
if not repository_id:
self.repo = self.client.getDefaultRepository()
else:
self.repo = self.client.getRepository(repository_id)
self.docroot = self.repo.getObjectByPath(document_root)
class CMISRepo(object):
implements(ICMISRepo)
def __init__(self, url, user, password, repository_id=None,
document_root='/'):
self.client = CmisClient(url, user, password)
if not repository_id:
self.repo = self.client.getDefaultRepository()
else:
self.repo = self.client.getRepository(repository_id)
self.docroot = self.repo.getObjectByPath(document_root)
def docroot_path(self):
paths = self.docroot.getPaths()
if paths:
return paths[0]
return None
def upload_document(self):
configs = self.env['office.alfresco.configuration'].search([('is_default', '=', 'True')])[0]
url = configs.url
port = configs.port
user = configs.user
mp = configs.mp
try:
client = CmisClient('http://' + url + ':' + repr(port) + '/alfresco/service/cmis', user, mp)
repo = client.defaultRepository
except:
print "failed to connect to Alfresco"
quit()
repo = client.getDefaultRepository()
root = repo.rootFolder
try:
Client = repo.getObjectByPath('/Clients')
except:
Client = root.createFolder('Clients')
try:
eFolder = repo.getObjectByPath('/Clients/' + self._get_name(self.env.context))
except:
eFolder = Client.createFolder(self._get_name(self.env.context))
try:
sFolder = repo.getObjectByPath('/Clients/' + self._get_name(self.env.context) + '/Bons de commande')
except:
sFolder = eFolder.createFolder('Bons de commande')
#added by salwa ksila 06/04/2017
data = base64.decodestring(self.chemin)
# create a temporary file, and save the image
fobj = tempfile.NamedTemporaryFile(delete=False)
fname = fobj.name
fobj.write(data)
fobj.close()
eContent = open(fname, 'r')
eFile = sFolder.createDocument(self.nom_fichier, contentFile=eContent)
self.env['office.document.alfresco.vente'].create({'node': eFile.id, 'nom_fichier':
self.nom_fichier,'vente_id': self._get_active_id(self.env.context),
'nom_client': self._get_partner(self.env.context)})
def __init__(self, url=None, user=None, password=None):
"""
Connect to the CMIS repository and store the root folder for further
operations.
:param url: string, CMIS provider url.
:param user: string, username to login on the document store
:param password: string, password to login on the document store
"""
if url is None:
url = settings.CMIS_CLIENT_URL
if user is None:
user = settings.CMIS_CLIENT_USER
if password is None:
password = settings.CMIS_CLIENT_USER_PASSWORD
_client = CmisClient(url, user, password)
self._repo = _client.getDefaultRepository()
self._root_folder = self._repo.getObjectByPath('/')
self.upload_to = import_string(settings.CMIS_UPLOAD_TO)
class DatabaseWrapper(BaseDatabaseWrapper):
vender = "cmis"
operators = {}
def __init__(self, *args, **kwargs):
super(DatabaseWrapper, self).__init__(*args, **kwargs)
self.charset = "utf-8"
self.features = DatabaseFeatures(self)
self.ops = DatabaseOperations(self)
self.client = DatabaseClient(self)
self.creation = DatabaseCreation(self)
self.introspection = DatabaseIntrospection(self)
self.validation = BaseDatabaseValidation(self)
def close(self):
if self.connection is not None:
self.connection.close()
self.connection = None
def ensure_connection(self):
if self.connection is None:
self.cmis_client = CmisClient(
self.settings_dict['HOST'],
self.settings_dict['USER'],
self.settings_dict['PASSWORD'],
binding=self.cmis_binding()
)
repo_name = self.settings_dict['NAME']
if repo_name == "default" or not repo_name:
self.connection = self.cmis_client.defaultRepository
else:
self.connection = self.cmis_client.getRepository(repo_name)
if django.conf.settings.DEBUG:
print "Connected to Repository with ID %s" % self.connection.id
def _commit(self):
pass
def _by_path(self, path):
self.ensure_connection()
return self.connection.getObjectByPath(path)
def _cursor(self):
self.ensure_connection()
return DatabaseCursor(self.connection)
def _query(self, query):
self.ensure_connection()
return self.connection.query(query)
def _rollback(self):
pass
def download_from_cmis(self):
if "cmis_url" not in self.settings:
self.LOGGER.warn("No CMIS repo specified. Processing documents is datadir.")
return
repo = CmisClient(self.settings["cmis_url"], self.settings["cmis_username"], self.settings["cmis_password"]).defaultRepository
for document in repo.getObjectByPath(self.settings["capture_folder"]).getChildren():
document_name = document.getName()
docid = document.getObjectId()
docid = docid.replace("workspace://SpacesStore/", "")
# remove version identifier ;1.0
if ";" in docid:
docid = docid.split(";")[0]
document_workdir = os.path.join(self.settings["datadir"], docid)
if not os.path.exists(document_workdir):
os.makedirs(document_workdir)
local_document_path = os.path.join(document_workdir, document_name)
if os.path.exists(local_document_path):
self.LOGGER.debug("{} exists. skipping download from CMIS".format(local_document_path))
else:
self.LOGGER.debug("downloading {}".format(document_name))
with open(local_document_path, "w") as fh:
fh.write(document.getContentStream().read())
class CmisAlfTestBase(unittest.TestCase):
""" Common ancestor class for most cmislib unit test classes. """
def setUp(self):
""" Create a root test folder for the test. """
self._cmisClient = CmisClient(REPOSITORY_URL, USERNAME, PASSWORD, **EXT_ARGS)
self._repo = self._cmisClient.getDefaultRepository()
self._rootFolder = self._repo.getObjectByPath(TEST_ROOT_PATH)
self._folderName = " ".join(["cmislibalf", self.__class__.__name__, str(time())])
self._testFolder = self._rootFolder.createFolder(self._folderName)
def tearDown(self):
""" Clean up after the test. """
self._testFolder.deleteTree()
def check_credentials(self, cr, uid, password):
#~ if not password == config.get('admin_passwd',False) and uid not in CMIS_LOGIN.keys(): # admin_passwd overrides
global CMIS_CLIENT, CMIS_LOGIN, CMIS_SERVER
if not CMIS_CLIENT:
try:
values = self.pool['ir.config_parameter'].get_param(cr,uid,'attachment_cmis.remote_server')
CMIS_SERVER = values.split(',')[0]
CMIS_CLIENT = CmisClient(CMIS_SERVER, values.split(',')[1], values.split(',')[2])
except Exception as e:
_logger.warn('CMIS_CLIENT: %s %s' %(e,values))
if CMIS_CLIENT:
if not cr.dbname in CMIS_LOGIN.keys():
CMIS_LOGIN[cr.dbname] = {}
if not uid in CMIS_LOGIN[cr.dbname].keys():
CMIS_LOGIN[cr.dbname][uid] = {}
CMIS_LOGIN[cr.dbname][uid]['password'] = password
CMIS_LOGIN[cr.dbname][uid]['login'] = self.pool['res.users'].browse(cr,uid,uid).login
try:
CMIS_LOGIN[cr.dbname][uid]['client'] = CmisClient(CMIS_SERVER, CMIS_LOGIN[cr.dbname][uid]['login'], password)
except Exception as e:
_logger.warn('CMIS_LOGIN: %s %s %s' %(e, CMIS_SERVER, CMIS_LOGIN[cr.dbname][uid]['login']))
_logger.warn('CMIS_CLIENT: %s CMIS_SERVER %s CMIS_LOGIN %s' %(CMIS_CLIENT, CMIS_SERVER,CMIS_LOGIN))
return super(res_users, self).check_credentials(cr, uid, password)
def connect(self):
"""
:return: Returns True if the connection succeeded, else False.
Failure to connect can be due to invalid URL or wrong authentication
credentials.
:rtype: bool
"""
status = False
self._cmis_client = CmisClient(self.url, self.username, self.password)
try:
self._default_repo = self._cmis_client.defaultRepository
self._connected = True
status = True
except Exception as ex:
pass
return status
def setUp(self):
super(BaseTestCmisProxy, self).setUp()
cmis_location = os.environ.get("CMIS_LOCATION") or (
"http://10.7.20.179:8080/alfresco/api/-default-"
"/public/cmis/versions/1.1/browser/"
)
cmis_user = os.environ.get("CMIS_USER") or "admin"
cmis_pwd = os.environ.get("CMIS_PWD") or "admin"
self.cmis_test_root_path = os.environ.get("CMIS_ROOT") or "/Odoo_proxy"
if not cmis_location or not cmis_user or not cmis_pwd:
self.skipTest(
"To run these tests you must provide the following "
"env var: CMIS_LOCATION, CMIS_USER, CMIS_PWD"
)
cmis_backend = self.env["cmis.backend"]
cmis_backend.search([(1, "=", 1)]).unlink()
self.cmis_backend = cmis_backend.create(
{
"name": "TEST_CMIS_PROXY",
"location": cmis_location,
"is_cmis_proxy": True,
"apply_odoo_security": False,
"username": cmis_user,
"password": cmis_pwd,
"version": "1.0",
}
)
web_descr = self.cmis_backend.get_web_description()[
self.cmis_backend.id
]
proxy_path = web_descr["cmis_location"]
self.authenticate("admin", "admin")
self.cmis_url = "http://%s:%d%s" % (
common.HOST,
common.PORT,
proxy_path,
)
self.headers = {"Cookie": "session_id=%s" % self.session_id}
self.cmis_client = CmisClient(
self.cmis_url, "admin", "admin", headers=self.headers
)
self.cmis_client.binding = BrowserBinding(headers=self.headers)
def __init__(self, fw):
global CMIS_CLIENT,CMIS_LOGIN,CMIS_SERVER
self.env = fw.env
try:
self.personal_repo = CMIS_LOGIN[self.env.cr.dbname][self.env.uid]['client'].defaultRepository
except Exception as e:
self.personal_repo = None
try:
self.repo = CMIS_CLIENT.defaultRepository
except Exception as e:
self.repo = None
if not self.repo:
remote_server = fw.env['ir.config_parameter'].get_param('attachment_cmis.remote_server', '').split(',', 2)
if len(remote_server) != 3:
self.repo = None
return
(CMIS_SERVER, user, password) = [fw.env['ir.config_parameter'].get_param(v) for v in remote_server]
CMIS_CLIENT = CmisClient(CMIS_SERVER, user, password)
_logger.error('server: %s user: %s password: %s' % (CMIS_SERVER, user, password))
self.repo = CMIS_CLIENT.defaultRepository
_logger.warn('CMIS_repo : general %s personal %s' %(self.repo,self.personal_repo))
class AlfrescoRM():
def __init__(self, alfresco_repository_url, alfresco_cmis_rest_api_url,
alfresco_admin_user, alfresco_admin_password):
self.alfresco_repository_url = alfresco_repository_url
self.alfresco_cmis_rest_api_url = alfresco_cmis_rest_api_url
self.alfresco_admin_user = alfresco_admin_user
self.alfresco_admin_password = alfresco_admin_password
try:
self.cmis_client = CmisClient(self.alfresco_cmis_rest_api_url,
self.alfresco_admin_user,
self.alfresco_admin_password)
except:
return HttpResponseBadRequest(
'<h1>Failed to connect to Alfresco</h1>')
def get_repository_url(self):
return self.alfresco_repository_url
def get_default_repository(self):
default_repository = self.cmis_client.getRepository(
self.cmis_client.defaultRepository.id)
return default_repository
def get_sites(self, repository):
alfresco_sites = repository.query(
"select * from cmis:folder where cmis:objectTypeId='F:st:site'")
sites = []
for s in alfresco_sites:
obj = repository.getObject(s.id)
s = {}
s['isSite'] = True
for key, val in obj.properties.items():
if key == 'cmis:name' or key == 'cmis:title' or key == 'cmis:description' or key == 'cmis:path' or key == 'cmis:objectId' or key == 'cmis:objectTypeId' or key == 'cmis:parentId':
s[key] = val
document_library = repository.getObjectByPath(s['cmis:path'] +
'/documentLibrary')
children = document_library.getChildren()
folders = []
for child in children:
if child.properties['cmis:objectTypeId'] == 'cmis:folder':
folder = {
'name':
child.properties['cmis:name'],
'description':
child.properties['cmis:description'],
'objectId':
child.properties['cmis:objectId'],
'path':
child.properties['cmis:path'],
'parent':
child.properties['cmis:parentId'],
'url':
self.alfresco_repository_url + '#filter=path|' +
child.properties['cmis:path']
}
folders.append(folder)
s['folders'] = folders
sites.append(s)
return sites
def get_folder_content(self, repository, object_id):
object_id = object_id.replace('workspace://SpacesStore/', '')
f = repository.getObject(object_id)
content = {}
content['isSite'] = False
for key, val in f.properties.items():
if key == 'cmis:name' or key == 'cmis:title' or key == 'cmis:description' or key == 'cmis:path' or key == 'cmis:objectId' or key == 'cmis:objectTypeId' or key == 'cmis:parentId':
content[key] = val
folderChildren = f.getChildren()
folders = []
for child in folderChildren:
if child.properties['cmis:objectTypeId'] == 'cmis:folder':
folder = {
'name':
child.properties['cmis:name'],
'description':
child.properties['cmis:description'],
'objectId':
child.properties['cmis:objectId'],
'path':
child.properties['cmis:path'],
'parent':
child.properties['cmis:parentId'],
'url':
self.alfresco_repository_url + '#filter=path|' +
child.properties['cmis:path']
}
folders.append(folder)
content['folders'] = folders
return content
def main():
""" Main function """
# Read info from file
filename = 'config.json'
# Open file
try:
with open(filename) as fileIn:
data = json.load(fileIn)
except EnvironmentError:
print("Settings file does not exist!")
exit(1)
# Set the variables
# File with 4 lines, info on each.
try:
repository = data['repository']
user = data['user']
password = data['password']
folder = data['folder']
except Exception as e:
print('Error reading file')
exit(1)
# Connect to the repository
try:
print(repository, user, password)
repository = CmisClient(repository, user, password)
if not repository:
print('Error retrying info from repository.Exiting.')
exit(1)
print('Connected to repository')
# Get the default repository
repo = repository.defaultRepository
if not repo:
print('Error retrying info from repository.Exiting.')
exit(1)
print(repo)
# Query folder
repoResults = repo.getObjectByPath(folder)
print('Looking inside %s folder', folder)
# Print name of contents in folder
children = repoResults.getChildren()
if not children:
print("Error while retrying results! Exiting...")
exit(1)
# Loop and print
i = 0
for child in children:
print("Item: %s is called %s" % (i, child.name))
# Get object's properties
childProperties = child.getProperties()
# Now I want to check the StreamMimeType
stream = childProperties['cmis:contentStreamMimeType']
# If framemaker, do something
if ('framemaker' in stream):
changeUrl(child)
i = i + 1
except Exception as e:
print('There is an error connecting to the repo')
print(e)
GESTDOC = 'https://gestdoc.cnr.it/alfresco'
AS7PREPROD = 'http://as7preprod.cedrc.cnr.it:8080/alfresco'
AS8PREPROD = 'http://as8preprod.cedrc.cnr.it:8080/alfresco'
TEST7 = 'http://test7.si.cnr.it/alfresco'
LOCALHOST = 'http://fuliana.si.cnr.it:8181/alfresco-app-doccnr'
USER = '******'
PASSW = 'admin'
HOST = TEST7
#HOST = AS11
if HOST == GESTDOC:
print colored('PRODUZIONE !!!', 'red')
REPO = CmisClient(HOST + '/cmisatom', USER, PASSW).defaultRepository
INFO = REPO.getRepositoryInfo()
print INFO.get('vendorName') + ' ' + INFO.get('productVersion')
print USER + '@' + HOST
def print_title(folder):
"""print title"""
print folder.getTitle()
def sons(parent, callback=print_title, height=0):
"""apply parameter callback to each parent's son"""
prefix = ''
for _ in range(height + 1):
prefix += '-'
for doc in parent.getChildren():
# (at your option) any later version.
#
# CMIS MARCH test 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
##############################################################################
from cmislib import CmisClient
from common import CMISURL, CMISUSER, CMISPASS
client = CmisClient(CMISURL, CMISUSER, CMISPASS)
# Number of repositories
print "Number of repositories: %d\n" % len(client.repositories)
# List of all repositories
print '=======[ REPOSITORIES INFORMATIONS ]============='
for r in client.repositories:
print 'Repository Name: %s' % r['repositoryName']
print 'Reporistory ID: %s' % r['repositoryId']
print '----'
print '=======[ END REPOSITORIES INFORMATIONS ]=========\n'
repo = client.defaultRepository
#!/usr/bin/env python
# Alfresco extension to CMIS
import cmislibalf
from cmislib import CmisClient, Repository, Folder
from cmislib.model import CmisId
from cmislib.exceptions import CmisException, UpdateConflictException
import os, sys
try:
# client = CmisClient('https://cmis.alfresco.com/api/-default-/public/cmis/versions/1.0/atom', 'admin', 'password')
# http://172.20.19.50:8080/alfresco
cmisClient = CmisClient('http://<IP>:8080/alfresco/service/cmis', 'admin', 'Tobereplaced')
repo = cmisClient.getDefaultRepository()
except CmisException as cme:
print "failed to connect to Alfresco: \r\n%s" % cme
quit()
try:
print 'Getting list of sites ..'
folders = repo.query("select * from cmis:folder where cmis:objectTypeId='F:st:site'")
docs = repo.query("select * from cmis:document where cmis:objectId='workspace://SpacesStore/dbac1e58-5b0b-4611-aafb-520df12f0bb1'")
print 'Processing list ..'
for folder in folders:
obj = repo.getObject(folder.id)
# properties items are key-value TUPLES ..
for key,val in obj.properties.items():
if key=='cm:name' or key=='cm:title' or key=='cmis:path':
print key,'=',val
