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