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 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 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_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 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 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 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 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 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, 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)
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))
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
