ufload3 2.0__tar.gz → 2.2__tar.gz

{ufload3-2.0/ufload3.egg-info → ufload3-2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ufload3
-Version: 2.0
+Version: 2.2
 Summary: UniField  python3 loader
 Author: MSF
 Project-URL: Homepage, https://github.com/Unifield/ufload3

{ufload3-2.0 → ufload3-2.2}/ufload3/__init__.py

@@ -1,7 +1,7 @@
 from . import cloud; assert cloud
 from . import db; assert db
 
-__version__ = '2.0'
+__version__ = '2.2'
 
 # null progress, can be overridden by importers
 def _progress(p):

{ufload3-2.0 → ufload3-2.2}/ufload3/cli/main.py

@@ -233,9 +233,6 @@ def _dirRestore(args):
         return 2, None
 
 def _multiRestore(args):
-    if not _required(args, [ 'user', 'pw' ]):
-        ufload3.progress('With no -file or -dir argument, cloud credentials are mandatory.')
-        return 2, None
 
     if args.i is None:
         if not _required(args, [ 'oc' ]):
@@ -308,7 +305,7 @@ def _multiRestore(args):
 
     ufload3.progress("Instances to be restored: %s" % ", ".join(list(instances.keys())))
     dbs=[]
-    pattern = re.compile('.*-[A-Z]{1}[a-z]{2}\.zip$')
+    pattern = re.compile(r'.*-[A-Z]{1}[a-z]{2}\.zip$')
 
     for i in instances:
 
@@ -491,8 +488,14 @@ def _syncLink(args, dbs, sdb):
 
 
 def _cmdLs(args):
-    if not _required(args, [ 'user', 'pw', 'oc' ]):
+    if not _required(args, [ 'tenant', 'client_id', 'oc' ]):
+        return 2
+    if not args.cert_path and not args.cert_content:
+        ufload3.progress('Argument --cert-content or --cert-path is required for this sub-command.')
         return 2
+
+
+
     if args.subdir is None:
         args.subdir = ''
 
@@ -563,14 +566,14 @@ def _cmdUpgrade(args):
             return 1
 
         #Download the patch
-        patches.sort(key=lambda s: list(map(int, re.split('\.|-|p',re.search('uf(.+?)\.patch\.zip',  s[1], re.I).group(1)))))
+        patches.sort(key=lambda s: list(map(int, re.split(r'\.|-|p',re.search(r'uf(.+?)\.patch\.zip',  s[1], re.I).group(1)))))
         i = 0
         for j in patches:
             filename = dav.download(j[2], j[1])
 
             #Set patch and version args
             args.patch = filename
-            m = re.search('(.+?)\.patch\.zip', filename)
+            m = re.search(r'(.+?)\.patch\.zip', filename)
             if m:
                 args.version = m.group(1)
 
@@ -727,7 +730,7 @@ def _cmdUpgrade(args):
         if len(patches) == 0:
             ufload3.progress("No User Rights found.")
             return 1
-        patches.sort(key=lambda s: list(map(int, re.split('\.|-|p',re.search('User Rights v(.+?).zip',  s[1], re.I).group(1)))))
+        patches.sort(key=lambda s: list(map(int, re.split(r'\.|-|p',re.search('User Rights v(.+?).zip',  s[1], re.I).group(1)))))
 
         urfilename = None
         for j in patches:
@@ -788,8 +791,9 @@ spinner = spinning_cursor()
 def parse():
     parser = argparse.ArgumentParser(prog='ufload3')
 
-    parser.add_argument("-user", help="Cloud username")
-    parser.add_argument("-pw", help="Cloud password")
+    parser.add_argument("-tenant", help="Cloud Tenant")
+    parser.add_argument("-client-id", help="Cloud App-Id")
+    parser.add_argument("-cert-path", help="Cloud CertPath")
     parser.add_argument("-oc", help="OC (OCG, OCA and OCB accepted) - optional for the restore command (if not provided, ufload will try and deduce the right OC(s) from the name of the requested instances)")
 
     parser.add_argument("-syncuser", help="username to access the sync server backup")

{ufload3-2.0 → ufload3-2.2}/ufload3/cloud.py

@@ -49,9 +49,6 @@ def instance_to_dir(instance):
 
 def get_cloud_info(args, sub_dir=''):
 
-    #Cloud password is encrypted
-    pword = _decrypt(args.pw)
-
     #Cloud path depends on the OC
     if args.oc:
         dir = '/personal/UF_' + args.oc.upper() + '_msf_geneva_msf_org/'
@@ -67,17 +64,18 @@ def get_cloud_info(args, sub_dir=''):
     except:
         #The argument cloudpath is not defined, forget about it (this is not the upgrade process)
         pass
+    
+    if args.cert_path:
+        with open(args.cert_path, 'r') as c:
+            args.cert_content = c.read()
 
     ret = {
         'url': args.cloud_url,
         'dir': dir + sub,
         'site': dir,
         'path': args.cloud_path,
-        'login': args.user,
-        'password': pword,
         'tenant': args.tenant,
         'client_id': args.client_id,
-        'thumbprint': args.thumbprint,
         'cert_content': args.cert_content,
     }
 
@@ -88,10 +86,12 @@ def get_onedrive_connection(args):
     info = get_cloud_info(args)
     if not info.get('url'):
         ufload3.progress('URL is not set!')
-    if not info.get('login'):
-        ufload3.progress('login is not set!')
-    if not info.get('password'):
-        ufload3.progress('Password is not set!')
+    if not info.get('tenant'):
+        ufload3.progress('Tenant is not set!')
+    if not info.get('client_id'):
+        ufload3.progress('Client_id is not set!')
+    if not info.get('cert_content'):
+        ufload3.progress('Cert is not set!')
 
     url = urlparse(info['url'])
     if not url.netloc:
@@ -100,8 +100,7 @@ def get_onedrive_connection(args):
     path = info.get('site') + url.path
 
     try:
-        dav = webdav.Client(url.netloc, port=url.port, protocol=url.scheme, username=info['login'],
-                            password=info['password'], tenant=info['tenant'], client_id= info['client_id'], thumbprint=info['thumbprint'], cert_content=info['cert_content'], path=path)
+        dav = webdav.Client(url.netloc, tenant=info['tenant'], client_id= info['client_id'], cert_content=info['cert_content'], path=path)
         return dav
     except webdav.ConnectionFailed as e:
         ufload3.progress('Unable to connect: {}'.format(e))
@@ -124,24 +123,20 @@ def _get_all_files_and_timestamp(dav, d):
     ret = []
     for f in all_zip:
         #if not f['Name'] or f['Name'][-1] == '/':
-        if not f['Name']:
+        if not f.name:
             continue
 
-        # We try to extract a timestamp to get an idea of the creation date
-        #  Format: Mon, 14 Mar 2016 03:31:40 GMT
-        t = time.strptime(f['TimeLastModified'], '%Y-%m-%dT%H:%M:%SZ')
-
         # We don't take into consideration backups that are too recent.
         # Otherwise they could be half uploaded (=> corrupted)
-        if abs(time.time() - time.mktime(t)) < 900:
+        if abs(time.time() - f.time_last_modified.timestamp()) < 900:
             continue
 
         # ufload3.progress('File found: %s' % f['Name'])
 
-        if f['Name'].split(".")[-1] != "zip":
-            logging.warn("Ignoring non-zipfile: %s" % f['Name'])
+        if f.name.split(".")[-1] != "zip":
+            logging.warn("Ignoring non-zipfile: %s" % f.name)
             continue
-        ret.append((t, f['Name'], f['ServerRelativeUrl']))
+        ret.append((f.time_last_modified, f.name, f.serverRelativeUrl))
     return ret
 
 # returns True if x has instance as a substring

{ufload3-2.0 → ufload3-2.2}/ufload3/db.py

@@ -361,7 +361,7 @@ def instantiate(args, db):
             connection = transport.make_connection(host)
             connection.timeout = 4
             sock = xmlrpc.client.ServerProxy('http://%s:%s/xmlrpc/common' % (host, port), transport=transport)
-            uid = sock.login(db, args.adminuser.lower(), args.adminpw)
+            sock.login(db, args.adminuser.lower(), args.adminpw)
         except Exception as e:
             ufload3.progress("non blocking error at first connection %s" % e)
 
@@ -498,8 +498,8 @@ def delive(args, db):
             if args.db_prefix:
                 db_name = db_name.split(args.db_prefix+'_', 1)[1]
             new_pass_dict = []
-            for pass_part in re.split( '(\[\d+\+\d+\])', args.newuserspw):
-                m = re.search('\[(\d+)\+(\d+)\]', pass_part)
+            for pass_part in re.split(r'(\[\d+\+\d+\])', args.newuserspw):
+                m = re.search(r'\[(\d+)\+(\d+)\]', pass_part)
                 if m:
                     pos = int(m.group(1)) - 1
                     add = int(m.group(2))
@@ -511,7 +511,17 @@ def delive(args, db):
 
         for new_user_info in args.createusers.split(';'):
             new_user_data = new_user_info.split(':')
-            if len(new_user_data) == 3:
+            new_user_dpt = False
+            new_user_name = False
+            new_user_email = False
+            if len(new_user_data) == 6:
+                new_user = new_user_data[0]
+                new_user_name = new_user_data[1]
+                new_user_email = new_user_data[2]
+                new_user_dpt = new_user_data[3]
+                new_user_pass = new_user_data[4]
+                groups = new_user_data[5]
+            elif len(new_user_data) == 3:
                 new_user= new_user_data[0]
                 new_user_pass = new_user_data[1]
                 groups = new_user_data[2]
@@ -519,12 +529,25 @@ def delive(args, db):
                 new_user= new_user_data[0]
                 new_user_pass = newpass
                 groups = new_user_data[1]
+
+            if not new_user_name:
+                new_user_name = new_user
             rc, new_userid = psql(args, """ insert into res_users (name, active, login, password, context_lang, company_id, view, menu_id) values
                 ('%s', 't', '%s', '%s', 'en_MF', 1, 'simple', 1) returning id;"""
-                % (new_user, new_user.lower(), new_user_pass), db, silent=True)
+                % (new_user_name, new_user.lower(), new_user_pass), db, silent=True)
             if rc != 0:
                 return rc
-            for new_group in groups.split(','):
+            if new_user_dpt:
+                psql(args, """ update res_users u set context_department_id = d.id
+                    from hr_department d
+                    where d.name = '%s' and u.id = %s """ % (new_user_dpt, new_userid), db)
+
+            if new_user_email:
+                rc, address_id = psql(args, """ insert into res_partner_address (name, email) values ('%s', '%s') returning id """ % (new_user_name, new_user_email), db, silent=True)
+                if address_id:
+                    psql(args,"update res_users set address_id=%s where id=%s" % (address_id, new_userid), db)
+
+            for new_group in  groups.split(','):
                 rc = psql(args, " insert into res_groups_users_rel (uid, gid) (select %s, id from res_groups where name='%s');" % (new_userid, new_group), db)
                 if rc != 0:
                     return rc
@@ -608,7 +631,7 @@ def get_hwid(args):
         import winreg
         try:
             with winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE,
-                                 "SYSTEM\ControlSet001\services\eventlog\Application\openerp-web-6.0",
+                                 r"SYSTEM\ControlSet001\services\eventlog\Application\openerp-web-6.0",
                                  0, winreg.KEY_READ) as registry_key:
                 hwid, regtype = winreg.QueryValueEx(registry_key, "HardwareId")
                 ufload3.progress("Hardware id from registry key: %s" % hwid)

ufload3-2.2/ufload3/webdav.py

@@ -0,0 +1,229 @@
+# -*- coding: utf-8 -*-
+
+import requests
+from office365.sharepoint.client_context import ClientContext
+from office365.runtime.client_runtime_context import ClientRuntimeContext
+from office365.runtime.client_request_exception import ClientRequestException
+from office365.sharepoint.files.file import File
+from office365.sharepoint.folders.folder import Folder
+from office365.runtime.queries.service_operation import ServiceOperationQuery
+from cryptography.x509 import load_pem_x509_certificate
+from cryptography.hazmat.primitives import hashes
+
+def move_to_newname(self, destination, newname, flag):
+    """Moves the file to the specified destination url.
+
+    :param str or office365.sharepoint.folders.folder.Folder destination: Specifies the existing folder or folder
+         site relative url
+    :param str new file name
+    :param int flag: Specifies the kind of move operation.
+    """
+
+    def _moveto(destination_folder):
+        # type: (Folder) -> None
+        file_url = "/".join([str(destination_folder.serverRelativeUrl), newname])
+
+        params = {"newurl": file_url, "flags": flag}
+        qry = ServiceOperationQuery(self, "moveto", params)
+        self.context.add_query(qry)
+
+        def _update_file(return_type):
+            self.set_property("ServerRelativeUrl", file_url)
+
+        self.context.after_query_execute(_update_file)
+
+    def _source_file_resolved():
+        if isinstance(destination, Folder):
+            destination.ensure_property("ServerRelativeUrl", _moveto, destination)
+        else:
+            self.context.web.ensure_folder_path(destination).get().after_execute(
+                _moveto
+            )
+
+    self.ensure_properties(["ServerRelativeUrl", "Name"], _source_file_resolved)
+    return self
+
+File.move_to_newname = move_to_newname
+
+import logging
+import os
+import posixpath
+from urllib.parse import urlparse, urljoin
+from time import sleep
+
+def execute_query_retry(
+    self,
+    max_retry=5,
+    timeout_secs=5,
+    success_callback=None,
+    failure_callback=None,
+    exceptions=(ClientRequestException,),
+):
+    """
+    Executes the current set of data retrieval queries and method invocations and retries it if needed.
+
+    :param int max_retry: Number of times to retry the request
+    :param int timeout_secs: Seconds to wait before retrying the request.
+    :param (office365.runtime.client_object.ClientObject)-> None success_callback:
+    :param (int, requests.exceptions.RequestException)-> None failure_callback:
+    :param exceptions: tuple of exceptions that we retry
+    """
+    retry = 1
+    while True:
+        try:
+            self.execute_query()
+            if callable(success_callback):
+                success_callback(self.current_query.return_type)
+            break
+        except exceptions as e:
+            if retry > max_retry:
+                raise
+            retry += 1
+            self.add_query(self.current_query)
+            if callable(failure_callback):
+                failure_callback(retry, e)
+            sleep(timeout_secs)
+ClientRuntimeContext.execute_query_retry=execute_query_retry
+
+
+class ConnectionFailed(Exception):
+    pass
+
+class PasswordFailed(Exception):
+    pass
+
+class Client(object):
+    def __init__(self, host, tenant, client_id, cert_content=False, cert_path=False, max_retry=1, path=None):
+        self.tenant = tenant
+        self.client_id = client_id
+        if not cert_content and cert_path:
+            with open(cert_path, 'r') as c:
+                cert_content = c.read()
+        self.cert_content = cert_content
+        cert = load_pem_x509_certificate(bytes(self.cert_content, 'utf8'))
+        self.thumbprint = cert.fingerprint(hashes.SHA1()).hex()
+
+        self.path = path or ''
+
+        self.url = 'https://{0}'.format(host)
+
+        self.max_retry = max_retry
+        self.login()
+
+    def login(self):
+        full_path = urljoin(self.url, self.path)
+        self.request = ClientContext(full_path)
+
+        self.request.with_client_certificate(
+            tenant=self.tenant,
+            client_id=self.client_id,
+            private_key=self.cert_content,
+            thumbprint=self.thumbprint,
+        )
+        self.baseurl = self.request._get_context_web_information().WebFullUrl
+        self.request._auth_context.url = self.baseurl
+        if not self.baseurl:
+            raise requests.exceptions.RequestException("Full Url not found %s" % self.path)
+        if not self.baseurl.endswith('/'):
+            self.baseurl = '%s/' % self.baseurl
+        self.path = urlparse(full_path).path
+
+        if not self.path.startswith('/'):
+            self.path = '/%s' % self.path
+        if not self.path.endswith('/') and len(self.path) > 1:
+            self.path = '%s/' % (self.path, )
+
+    def create_folder(self, remote_path):
+        if not self.folder_exists(remote_path):
+            self.request.web.get_folder_by_server_relative_url(self.path).add(remote_path).execute_query_with_incremental_retry(max_retry=self.max_retry)
+        return True
+
+    def delete(self, remote_path):
+        webUri = '%s%s' % (self.path, remote_path)
+        return self.request.web.get_file_by_server_relative_url(webUri).delete_object().execute_query_with_incremental_retry(max_retry=self.max_retry)
+
+    def move(self, remote_path, dest, retry=True):
+        # Move file to folder
+        webUri = '%s%s' % (self.path, remote_path)
+
+        to_folder_dest = posixpath.join(self.path, dest)
+        self.request.web.get_file_by_server_relative_path(webUri).moveto(to_folder_dest, 1).execute_query_with_incremental_retry(max_retry=self.max_retry)
+        return True
+
+    def move_to_file(self, remote_path, dest):
+        webUri = '%s%s' % (self.path, remote_path)
+        full_name_dest = '/'.join([self.path, dest])
+
+        dest_file_name = full_name_dest.split('/')[-1]
+        dest_folder = '/'.join(full_name_dest.split('/')[0:-1])
+        self.request.web.get_file_by_server_relative_path(webUri).move_to_newname(dest_folder, dest_file_name, 1).execute_query_with_incremental_retry(max_retry=self.max_retry)
+        return True
+
+    def upload(self, fileobj, remote_path, buffer_size=None, log=False, progress_obj=False, continuation=False):
+        split_name = remote_path.split('/')
+        new_file = split_name.pop()
+        split_name.insert(0, self.path)
+        path  = '/'.join(split_name)
+        if path[-1] != '/':
+            path += '/'
+
+        if buffer_size is None:
+            buffer_size = 10 * 1024 * 1024
+
+        if progress_obj:
+            log = True
+
+        report_method = None
+        def report_progress(uploaded, **a):
+            percent_txt = ''
+            if size:
+                percent = round(uploaded*100/size)
+                percent_txt = '%d%%' % percent
+                if progress_obj:
+                    progress_obj.write({'name': percent})
+
+            if logger:
+                logger.info('OneDrive: %d bytes sent on %s bytes %s' % (uploaded, size or 'unknown', percent_txt))
+
+        if log:
+            logger = logging.getLogger('cloud.backup')
+            try:
+                size = os.path.getsize(fileobj.name)
+            except:
+                size = None
+            report_method = report_progress
+
+        target_folder = self.request.web.get_folder_by_server_relative_url(path)
+        return target_folder.files.create_upload_session(
+            fileobj, buffer_size, chunk_uploaded=report_method, file_name=new_file
+        ).execute_query_with_incremental_retry(max_retry=self.max_retry)
+
+    def list(self, remote_path):
+        if not remote_path.startswith(self.path):
+            remote_path = posixpath.join(self.path, remote_path)
+        return (
+            self.request.web.get_folder_by_server_relative_path(remote_path)
+            .get_files()
+            .expand(["TimeLastModified"])
+            .execute_query_retry(max_retry=self.max_retry)
+        )
+
+    def folder_exists(self, remote_path):
+        webUri = '%s%s' % (self.path, remote_path)
+        try:
+            self.request.web.get_folder_by_server_relative_url(webUri).get().execute_query_with_incremental_retry(max_retry=self.max_retry)
+        except ClientRequestException as e:
+            if e.response.status_code == 404:
+                return False
+            raise
+        return True
+
+    def download(self, remote_path, filename):
+        if not remote_path.startswith(self.path):
+            remote_path = posixpath.join(self.path, remote_path)
+
+        src = self.request.web.get_file_by_server_relative_path(remote_path)
+        with open(filename, 'wb') as file:
+            src.download_session(file).execute_query_with_incremental_retry(max_retry=self.max_retry)
+        return filename
+

{ufload3-2.0 → ufload3-2.2/ufload3.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ufload3
-Version: 2.0
+Version: 2.2
 Summary: UniField  python3 loader
 Author: MSF
 Project-URL: Homepage, https://github.com/Unifield/ufload3

ufload3-2.0/ufload3/webdav.py

@@ -1,280 +0,0 @@
-# -*- coding: utf-8 -*-
-
-import requests
-from office365.sharepoint.client_context import ClientContext
-from office365.runtime.http.request_options import RequestOptions
-from office365.runtime.http.http_method import HttpMethod
-from office365.runtime.auth.providers.saml_token_provider import SamlTokenProvider
-import uuid
-import logging
-import os
-import posixpath
-import time
-from urllib.parse import urlparse, urljoin
-
-
-class ConnectionFailed(Exception):
-    pass
-
-class PasswordFailed(Exception):
-    pass
-
-class Client(object):
-    def __init__(self, host, port=0, auth=None, username=None, password=None, tenant=None, client_id=None, thumbprint=None, cert_content=None, protocol='http', path=None):
-        self.requests_timeout = 45
-        self.session_uuid = False
-        self.session_offset = -1
-        self.session_nb_error = 0
-
-        self.username = username
-        self.password = password
-
-        self.tenant = tenant
-        self.client_id = client_id
-        self.thumbprint = thumbprint
-        self.cert_content = cert_content
-
-
-        self.path = path or ''
-
-        self.url = '{0}://{1}'.format(protocol, host)
-
-        self.login()
-
-    def login(self):
-        baseurl = urljoin(self.url, self.path)
-        self.request = ClientContext(baseurl)
-
-        if not self.tenant:
-            self.request.with_user_credentials(self.username, self.password)
-            if not isinstance(self.request.authentication_context._provider, SamlTokenProvider) or \
-                    not self.request.authentication_context._provider.get_authentication_cookie():
-                raise requests.exceptions.RequestException(self.request.get_last_error())
-
-            # get the server_site url
-            if not self.path.startswith('/'):
-                self.path = '/%s' % self.path
-            options = RequestOptions(self.url)
-            self.request._ensure_form_digest(options)
-            baseurl = self.request._contextWebInformation.WebFullUrl
-        else:
-            self.ctx = self.request.with_client_certificate(
-                tenant=self.tenant,
-                client_id=self.client_id,
-                #cert_path=self.cert_path,
-                private_key=self.cert_content,
-                thumbprint=self.thumbprint,
-            )
-            self.ctx.web.get().execute_query()
-
-
-        if not baseurl:
-            raise requests.exceptions.RequestException("Full Url not found %s" % self.path)
-        if not baseurl.endswith('/'):
-            baseurl = '%s/' % baseurl
-        parsed_base = urlparse(baseurl).path
-        self.baseurl = '%s%s' % (self.url, parsed_base)
-        if not self.path.startswith('/'):
-            self.path = '/%s' % self.path
-        if not self.path.endswith('/') and len(self.path) > 1:
-            self.path = '%s/' % (self.path, )
-
-
-    def format_request(self, url, method='POST', data="", session=False):
-        assert(method in ['POST', 'DELETE'])
-        r_meth = {
-            'POST': HttpMethod.Post,
-            'DELETE': HttpMethod.Delete,
-        }
-        options = RequestOptions(url)
-        options.method = r_meth[method]
-        options.set_header("X-HTTP-Method", method)
-        options.set_header('Accept', 'application/json')
-        options.set_header('Content-Type', 'application/json')
-        self.request._authenticate_request(options)
-        self.request._ensure_form_digest(options)
-
-        if session:
-            return session.post(url, data=data, headers=options.headers, auth=options.auth, timeout=self.requests_timeout)
-
-        return requests.post(url, data=data, headers=options.headers, auth=options.auth, timeout=self.requests_timeout)
-
-    def parse_error(self, result):
-        try:
-            if 'application/json' in result.headers.get('Content-Type'):
-                resp_content = result.json()
-                msg = resp_content['odata.error']['message']
-                error = []
-                if isinstance(msg, dict):
-                    error = [msg['value']]
-                else:
-                    error = [msg]
-                if resp_content['odata.error'].get('code'):
-                    error.append('Code: %s' % resp_content['odata.error']['code'])
-                return ' '.join(error)
-        except:
-            pass
-        return result.content
-
-    def create_folder(self, remote_path):
-        webUri = '%s%s' % (self.path, remote_path)
-        request_url = "%s_api/web/GetFolderByServerRelativeUrl('%s')" % (self.baseurl, webUri)
-        result = self.format_request(request_url, 'POST')
-        if result.status_code not in (200, 201):
-            result = self.format_request("%s_api/Web/Folders/add('%s')" % (self.baseurl, webUri), 'POST')
-            if result.status_code not in (200, 201):
-                raise Exception(self.parse_error(result))
-        return True
-
-    def delete(self, remote_path):
-        webUri = '%s%s' % (self.path, remote_path)
-        request_url = "%s_api/web/getfilebyserverrelativeurl('%s')" % (self.baseurl, webUri)
-        result = self.format_request(request_url, 'DELETE')
-        if result.status_code not in (200, 201):
-            raise Exception(self.parse_error(result))
-        return True
-
-    def move(self, remote_path, dest, retry=True):
-        webUri = '%s%s' % (self.path, remote_path)
-        destUri = '%s%s' % (self.path, dest)
-        # falgs=1 to overwrite existing file
-        request_url = "%s_api/web/getfilebyserverrelativeurl('%s')/moveto(newurl='%s',flags=1)" % (self.baseurl, webUri, destUri)
-        result = self.format_request(request_url, 'POST')
-        if result.status_code not in (200, 201):
-            error = self.parse_error(result)
-            if retry and ('timed out' in error or '2130575252' in error):
-                logging.getLogger('cloud.backup').info('OneDrive move: session time out')
-                self.login()
-                return self.move(remote_path, dest, retry=False)
-            raise Exception(self.parse_error(result))
-        return True
-
-    def upload(self, fileobj, remote_path, buffer_size=None, log=False, progress_obj=False, continuation=False):
-        if not self.session_uuid:
-            self.session_uuid = uuid.uuid1()
-
-        if progress_obj:
-            log = True
-
-        if log:
-            logger = logging.getLogger('cloud.backup')
-            try:
-                size = os.path.getsize(fileobj.name)
-            except:
-                size = None
-
-        if not continuation:
-            self.session_offset = -1
-
-        if self.session_offset != -1:
-            fileobj.seek(self.session_offset)
-
-        if not buffer_size:
-            buffer_size = 10* 1024 * 1024
-
-        x = ""
-        split_name = remote_path.split('/')
-        new_file = split_name.pop()
-        split_name.insert(0, self.path)
-        path  = '/'.join(split_name)
-        if path[-1] != '/':
-            path += '/'
-        webUri = '%s%s' % (path, new_file)
-        s = requests.Session()
-
-        while True:
-            if self.session_offset == -1:
-                # first loop create an empty file
-                request_url = "%s_api/web/GetFolderByServerRelativeUrl('%s')/Files/add(url='%s',overwrite=true)" % (self.baseurl, path, new_file)
-                self.session_offset = 0
-            else:
-                x = fileobj.read(buffer_size)
-                if not x:
-                    break
-                if not self.session_offset:
-                    # 2nd loop
-                    if len(x) == buffer_size:
-                        # split needed
-                        request_url="%s_api/web/getfilebyserverrelativeurl('%s')/startupload(uploadId=guid'%s')" % (self.baseurl, webUri, self.session_uuid)
-                    else:
-                        # file size < buffer: no need to split
-                        request_url = "%s_api/web/GetFolderByServerRelativeUrl('%s')/Files/add(url='%s',overwrite=true)" % (self.baseurl, path, new_file)
-                elif len(x) == buffer_size:
-                    request_url = "%s_api/web/getfilebyserverrelativeurl('%s')/continueupload(uploadId=guid'%s',fileOffset=%s)" % (self.baseurl, webUri, self.session_uuid, self.session_offset)
-                else:
-                    request_url = "%s_api/web/getfilebyserverrelativeurl('%s')/finishupload(uploadId=guid'%s',fileOffset=%s)" % (self.baseurl, webUri, self.session_uuid, self.session_offset)
-
-            result = self.format_request(request_url, method='POST', data=x, session=s)
-            if result.status_code not in (200, 201):
-                return (False, self.parse_error(result))
-            self.session_nb_error = 0
-            self.session_offset += len(x)
-
-            if log and self.session_offset and self.session_offset % (buffer_size*5) == 0:
-                percent_txt = ''
-                if size:
-                    percent = round(self.session_offset*100/size)
-                    percent_txt = '%d%%' % percent
-                    if progress_obj:
-                        progress_obj.write({'name': percent})
-
-                logger.info('OneDrive: %d bytes sent on %s bytes %s' % (self.session_offset, size or 'unknown', percent_txt))
-        self.session_offset = -1
-        return (True, '')
-
-    def list(self, remote_path):
-        if not remote_path.startswith(self.path):
-            remote_path = posixpath.join(self.path, remote_path)
-        request_url = "%s_api/web/getfolderbyserverrelativeurl('%s')/files" % (self.baseurl, remote_path)
-        options = RequestOptions(request_url)
-        options.method = HttpMethod.Get
-        options.set_header("X-HTTP-Method", "GET")
-        options.set_header('accept', 'application/json;odata=verbose')
-        self.request._authenticate_request(options)
-        self.request._ensure_form_digest(options)
-        result = requests.get(url=request_url, headers=options.headers, auth=options.auth)
-        if result.status_code not in (200, 201):
-            raise requests.exceptions.RequestException(self.parse_error(result))
-
-        result = result.json()
-        files=[]
-        for i in range(len(result['d']['results'])):
-            item = result['d']['results'][i]
-            files.append(item)
-        return files
-
-
-    def download(self, remote_path, filename):
-        if not remote_path.startswith(self.path):
-            remote_path = posixpath.join(self.path, remote_path)
-        request_url = "%s_api/web/getfilebyserverrelativeurl('%s')/$value" % (self.baseurl, remote_path)
-        options = RequestOptions(request_url)
-        options.method = HttpMethod.Get
-        options.set_header("X-HTTP-Method", "GET")
-        options.set_header('accept', 'application/json;odata=verbose')
-        retry = 5
-        while retry:
-            try:
-                self.request._authenticate_request(options)
-                self.request._ensure_form_digest(options)
-                with requests.get(url=request_url, headers=options.headers, auth=options.auth, stream=True, timeout=120) as r:
-                    if r.status_code not in (200, 201):
-                        error = self.parse_error(r)
-                        raise requests.exceptions.RequestException(error)
-
-                    with open(filename, 'wb') as file:
-                        for chunk in r.iter_content(chunk_size=8192):
-                            if chunk:
-                                file.write(chunk)
-            except requests.exceptions.RequestException:
-                time.sleep(3)
-                self.login()
-                retry -= 1
-                if not retry:
-                    raise
-                continue
-
-            retry = 0
-
-        return filename
-