def download(self, remote_path, filename): 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') self.request.context.authenticate_request(options) self.request.context.ensure_form_digest(options) retry = 5 while retry: 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) if 'timed out' in error or '2130575252' in error: time.sleep(2) self.login() retry -= 1 continue raise Exception(error) with open(filename, 'wb') as file: for chunk in r.iter_content(chunk_size=8192): if chunk: file.write(chunk) retry = 0 return filename
def list(self, remote_path): #webUri = '%s%s' % (self.path, remote_path) #request_url = "%s_api/web/getfilebyserverrelativeurl('%s')/files" % (self.baseurl, webUri) request_url = "%s_api/web/getfolderbyserverrelativeurl('%s')/files" % ( self.baseurl, remote_path) print request_url 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.context.authenticate_request(options) self.request.context.ensure_form_digest(options) result = requests.get(url=request_url, headers=options.headers, auth=options.auth) #result = requests.post(url=request_url, data="", headers=options.headers, auth=options.auth) result = result.json() '''if result.status_code not in (200, 201): print 'Error code: ' print result.status_code raise Exception(result.content) ''' #return True files = [] for i in range(len(result['d']['results'])): item = result['d']['results'][i] files.append(item) print files[0]['Name'] return files
def save_binary(ctx, server_relative_url, content): server_relative_url = urllib.quote(server_relative_url) url = "{0}web/getfilebyserverrelativeurl('{1}')/\$value".format( ctx.service_root_url, server_relative_url) request = RequestOptions(url) request.method = HttpMethod.Post request.set_header('X-HTTP-Method', 'PUT') request.data = content ctx.execute_query_direct(request)
def get(self, path): # request = ClientRequest(self.ctx_auth) options = RequestOptions('{}_api/web/{}'.format(self.site_url, path)) options.set_header('Accept', 'application/json') options.set_header('Content-Type', 'application/json') data = self.request.execute_request_direct(options) if data.status_code == 404: raise ValueError('Site does not exist') s = json.loads(data.content) return s
def save_binary(ctx, server_relative_url, content): """Uploads a file""" url = r"{0}web/getfilebyserverrelativeurl('{1}')/\$value".format( ctx.serviceRootUrl, server_relative_url) request = RequestOptions(url) request.method = HttpMethod.Post request.set_header('X-HTTP-Method', 'PUT') request.data = content response = ctx.execute_request_direct(request) return response
def read_list_items(context, list_title, url): """Read list items example""" request = ClientRequest(context) options = RequestOptions("{0}/web/lists/getbyTitle('{1}')/items".format(url, list_title)) options.set_header('Accept', 'application/json; odata=nometadata') print("Retrieving list items from List {0}".format(list_title)) response = request.execute_request_direct(options) data = json.loads(response.content) for item in data['value']: print("Item title: {0}".format(item["Title"]))
def create_list_item(context, list_title, url): """Create list item example""" request = ClientRequest(context) options = RequestOptions("{0}/web/lists/getbyTitle('{1}')/items".format(url, list_title)) options.set_header('Accept', 'application/json; odata=nometadata') # JSON Light nometadata mode! options.data = {'Title': 'New Task'} options.method = HttpMethod.Post print("Creating list item...") response = request.execute_request_direct(options) item = json.loads(response.content) print("Task {0} has been successfully [created]".format(item['Title'])) return item
def delete(self, remote_path): webUri = '%s%s' % (self.path, remote_path) request_url = "%s/_api/web/getfilebyserverrelativeurl('%s')" % (self.baseurl, webUri) options = RequestOptions(request_url) options.method = HttpMethod.Delete options.set_header("X-HTTP-Method", "DELETE") self.request.context.authenticate_request(options) self.request.context.ensure_form_digest(options) result = requests.post(url=request_url, data="", headers=options.headers, auth=options.auth) if result.status_code not in (200, 201): raise Exception(result.content) return True
def save_binary(ctx, server_relative_url, content): try: from urllib import quote # Python 2.X except ImportError: from urllib.parse import quote # Python 3+ server_relative_url = quote(server_relative_url) url = "{0}web/getfilebyserverrelativeurl('{1}')/\$value".format(ctx.service_root_url, server_relative_url) request = RequestOptions(url) request.method = HttpMethod.Post request.set_header('X-HTTP-Method', 'PUT') request.data = content ctx.execute_query_direct(request)
def build_request(self, query): request = RequestOptions(query.url) # set json format headers request.set_headers(self.context.json_format.build_http_headers()) if isinstance(self.context.json_format, JsonLightFormat): # set custom method headers if query.action_type == ActionType.DeleteEntity: request.set_header("X-HTTP-Method", "DELETE") request.set_header("IF-MATCH", '*') elif query.action_type == ActionType.UpdateEntity: request.set_header("X-HTTP-Method", "MERGE") request.set_header("IF-MATCH", '*') # set method if not (query.action_type == ActionType.ReadEntity or query.action_type == ActionType.GetMethod): request.method = HttpMethod.Post else: if query.action_type == ActionType.CreateEntity: request.method = HttpMethod.Post elif query.action_type == ActionType.UpdateEntity: request.method = HttpMethod.Patch elif query.action_type == ActionType.DeleteEntity: request.method = HttpMethod.Delete # set request payload if query.payload is not None: request.data = ODataEncoder(self.context.json_format).default( query.payload) return request
def upload_file_from_local(local_file_path, sharepoint_folder_path): """Upload a file to a folder give file name and folder path The sharepoint_folder_path is any subdirectory in Shared Documents/""" if ctx.acquire_token_for_user(username=USERNAME, password=PASSWORD): s_folder = sharepoint_folder_path fname = os.path.basename(os.path.normpath(local_file_path)) files_url = "{0}/_api/web/GetFolderByServerRelativeUrl('{1}')/Files/add(url='{2}', overwrite=true)" full_url = files_url.format(BASE_URL, s_folder, fname) options = RequestOptions(BASE_URL) context = ClientContext(BASE_URL, ctx) context.request_form_digest() options.set_header('Accept', 'application/json; odata=verbose') options.set_header('Content-Type', 'application/octet-stream') options.set_header('Content-Length', str(os.path.getsize(local_file_path))) options.set_header('X-RequestDigest', context.contextWebInformation.form_digest_value) options.method = 'POST' with open(local_file_path, 'rb') as outfile: context.authenticate_request(options) data = requests.post(url=full_url, data=outfile, headers=options.headers, auth=options.auth) if data.status_code == 200: print(data.ok) else: print(data.content)
def upload_binary_file(file_path, base_url, folder_url, ctx_auth): """Attempt to upload a binary file to SharePoint""" file_name = basename(file_path) files_url = "{0}/_api/web/GetFolderByServerRelativeUrl('{1}')/Files/add(url='{2}', overwrite=true)" full_url = files_url.format(base_url, folder_url, file_name) options = RequestOptions(base_url) context = ClientContext(base_url, ctx_auth) context.request_form_digest() options.set_header('Accept', 'application/json; odata=verbose') options.set_header('Content-Type', 'application/octet-stream') options.set_header('Content-Length', str(os.path.getsize(file_path))) options.set_header('X-RequestDigest', context.contextWebInformation.form_digest_value) options.method = 'POST' with open(file_path, 'rb') as outfile: # instead of executing the query directly, we'll try to go around # and set the json data explicitly context.authenticate_request(options) data = requests.post(url=full_url, data=outfile, headers=options.headers, auth=options.auth) if data.status_code != 200: print("upload_binary_file error code: " + str(data.status_code))
def handle(self): email, password = self.email, self.password authentication_context = AuthenticationContext(settings.SHAREPOINT_URL) authentication_context.acquire_token_for_user(email, password) if not authentication_context.get_last_error(): request = ClientRequest(authentication_context) os.makedirs(settings.BIOS_ROOT, exist_ok=True) for bio in self._get_bios_list( authentication_context, settings.BIOS_URL ): if not 'template' in bio.lower(): options = RequestOptions( '{0}mexico/Shared Documents/Resumes/{1}'.format( settings.SHAREPOINT_URL, bio ) ) options.set_header('Accept', 'application/json') options.set_header('Content-Type', 'application/json') data = request.execute_query_direct(options) docx = open('{0}/{1}'.format( settings.BIOS_ROOT, bio.replace( "a%C3%A1", "á" ).replace( "e%CC%81", "é" ).replace( "i%C3%AD", "í" ).replace( "o%C3%B3", "ó" ).replace( "u%C3%BA", "ú" ).replace( "%C3%91", "Ñ" ).replace( "A%C3%81", "Á" ).replace( "E%C3%89", "É" ).replace( "I%C3%8D", "Í" ).replace( "O%C3%93", "Ó" ).replace( "U%C3%9A", "Ú" ) ), "wb") docx.write(data.content) docx.close() else: self.error = authentication_context.get_last_error()
def get_excel(): # Authentication ctx_auth = AuthenticationContext(r"https://Domain.sharepoint.com/") # Get Access Token ctx_auth.acquire_token_for_user("*****@*****.**", "Password") ctx = ClientContext(r'Exact URL of the file you want to download,ctx_auth) # Initiate Client Request Using Authentication request = ClientRequest(ctx_auth) # Create Options and create Headers options = RequestOptions(ctx.web.resource_url) options.set_header('Accept', 'application/json') options.set_header('Content-Type', 'application/json') # Start Request data = request.execute_request_direct(options) # get Result content in Json String Format myjsondump = json.dumps(data.content.decode('utf-8')) myjsonload = json.loads(myjsondump) curr_str = "" for load in myjsonload: curr_str = curr_str + load # extract "File Get URL" from json string start_index = curr_str.find(r'"FileGetUrl":"') + len(r'"FileGetUrl":"') url_text_dump = curr_str[start_index:] url_end_Index = url_text_dump.find(r'",') # File URL my_url = url_text_dump[:url_end_Index] my_url = my_url.strip(' \n\t') print(my_url) # get replace encoded characters qurl = my_url.replace(r"\u0026", "&") # get request resp = requests.get(url=qurl) url_data = requests.get(url=qurl) # Open an Write in Excel file VIP_Excel_File = open("Filename which you want to download.xlsx", mode="wb") VIP_Excel_File.write(url_data.content) print("Excel Sheet from Sharepoint Extracted Successfully")
def getDigest(url, username, password, site=None): # url = 'https://xebialabs.sharepoint.com/sites/TestCommunicationSite' if site: url = "%s/sites/%s" % (url, site) ctx_auth = AuthenticationContext(url) if ctx_auth.acquire_token_for_user(username, password): request = ClientRequest(ctx_auth) options = RequestOptions("{0}/_api/contextinfo".format(url)) options.method = 'POST' options.set_header('Accept', 'application/json') options.set_header('Content-Type', 'application/json') data = request.execute_request_direct(options) digest = json.loads(data.content)['FormDigestValue'] return digest else: return "Failed to acquire authentication token"
def download(self, remote_path, filename): 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') self.request.context.authenticate_request(options) self.request.context.ensure_form_digest(options) result = requests.get(url=request_url, headers=options.headers, auth=options.auth) with open(filename, 'wb') as file: file.write(result.content) return filename
def _get_bios_list(self, authentication_context, url, first_last=None): request = ClientRequest(authentication_context) options = RequestOptions(url) options.set_header('Accept', 'application/json') options.set_header('Content-Type', 'application/json') data = request.execute_query_direct(options) resumes = set() last = '' lasts = [] for count, part in enumerate(list(str(data.content).split('.docx'))[:-1]): if 'bio' in part.lower(): try: last = part.rsplit('file=')[1] + '.docx' lasts.append(last) last = ( last ).replace( '%20', ' ' ).replace( '%C3%B1', 'ñ' ) resumes.add(last) except: pass if self.global_last: try: while self.global_last == lasts.pop(): pass except: return set() last = self.global_last = lasts.pop() else: self.global_last = lasts.pop() url = '{0}{1}{2}{3}'.format( settings.SHAREPOINT_URL, settings.SHAREPOINT_PREFIX, self.global_last, settings.SHAREPOINT_SUFFIX ) return resumes.union( self._get_bios_list(authentication_context, url, last) )
def runRestQuery(ctx, endpoint: str): request = ClientRequest(ctx) options = RequestOptions("{0}/_api/{1}".format(webUrl, endpoint)) options.set_header("Accept", "application/xml") options.set_header("Content-Type", "application/xml") data = request.execute_request_direct(options) endPoints = getEndpointsFromXML(str(data.content)) for ep in endPoints: ep = removeNoise(ep) # check diff beforeLength = len(uniquEndpoints) uniquEndpoints.add(ep) if len(uniquEndpoints) > beforeLength: runRestQuery(ctx, ep)
def get_digest(self): # logger.info("Executing get_digest()") print("Executing get_digest()") # logger.info("url %s" % self.url) # logger.info("username %s" % self.username) # logger.info("password %s" % self.password) ctx_auth = AuthenticationContext(self.tokenServer, self.url) if ctx_auth.acquire_token_for_user(self.username, self.password): request = ClientRequest(ctx_auth) options = RequestOptions("{0}/_api/contextinfo".format(self.url)) options.method = 'POST' options.set_header('Accept', 'application/json') options.set_header('Content-Type', 'application/json') data = request.execute_request_direct(options) if "odata.error" in data.content: self.throw_error(data.content['odata.error']['message']['value']) else: return json.loads(data.content)['FormDigestValue'] else: self.throw_error("Failed to acquire authentication token for %s" % self.url)
def retrieve_file_list(url): url = url + '/Files' if ctx.acquire_token_for_user(username=USERNAME, password=PASSWORD): options = RequestOptions(BASE_URL) context = ClientContext(BASE_URL, ctx) context.request_form_digest() options.set_header('Accept', 'application/json; odata=verbose') options.method = 'GET' context.authenticate_request(options) data = requests.get(url=url, headers=options.headers, auth=options.auth) if data.status_code == 200: file_list = [] datam = json.loads(data.text) for f in range(len(datam['d']['results'])): uri = datam['d']['results'][f]['__metadata']['uri'] file_list.append(uri) return file_list else: print(data.content)
def test7_upload_file_session(self): file_name = "big_buck_bunny.mp4" path = "{0}/data/{1}".format(os.path.dirname(__file__), file_name) # 1. create a file target_item = self.client.me.drive.root.upload(file_name, None) self.client.execute_query() self.assertIsNotNone(target_item.properties['id']) # 2. create upload session item = DriveItemUploadableProperties() item.name = file_name session_result = target_item.create_upload_session(item) self.client.execute_query() self.assertIsNotNone(session_result.value) # 3. start upload f = open(path, 'rb') st = os.stat(path) f_pos = 0 for piece in read_in_chunks(f, chunk_size=1000000): req = RequestOptions(session_result.value.uploadUrl) req.method = HttpMethod.Put req.set_header('Content-Length', str(len(piece))) req.set_header('Content-Range', 'bytes {0}-{1}/{2}'.format(f_pos, (f_pos + len(piece) - 1), st.st_size)) req.set_header('Accept', '*/*') req.data = piece resp = self.client.execute_request_direct(req) self.assertTrue(resp.ok) f_pos += len(piece)
def execute(self, chunk_uploaded=None): ctx = self._target_folder.context file_name = os.path.basename(self._source_path) # 1. create an empty file target_item = self._target_folder.upload(file_name, None) ctx.execute_query() # 2. create upload session item = DriveItemUploadableProperties() item.name = file_name session_result = target_item.create_upload_session(item) ctx.execute_query() # 3. start upload fh = open(self._source_path, 'rb') st = os.stat(self._source_path) f_pos = 0 for piece in read_in_chunks(fh, chunk_size=self._chunk_size): req = RequestOptions(session_result.value.uploadUrl) req.method = HttpMethod.Put req.set_header('Content-Length', str(len(piece))) req.set_header( 'Content-Range', 'bytes {0}-{1}/{2}'.format(f_pos, (f_pos + len(piece) - 1), st.st_size)) req.set_header('Accept', '*/*') req.data = piece resp = ctx.execute_request_direct(req) f_pos += len(piece) if chunk_uploaded is not None: chunk_uploaded(f_pos) return target_item
def checkin_file(file_path, base_url, folder_url, ctx_auth): """Attempt to check in a file in SharePoint""" file_name = basename(file_path) files_url = "{0}/_api/web/GetFileByServerRelativeUrl('{1}/{2}')/CheckIn(comment='Comment',checkintype=0)" full_url = files_url.format(base_url, folder_url, file_name) options = RequestOptions(base_url) context = ClientContext(base_url, ctx_auth) context.request_form_digest() options.set_header('X-RequestDigest', context.contextWebInformation.form_digest_value) options.method = 'POST' context.authenticate_request(options) data = requests.post(url=full_url, headers=options.headers, auth=options.auth) if data.status_code != 200: print("checkin_file error code: " + str(data.status_code))
def get(path): if url is not None or username is not None or password is not None: try: ctx_auth = AuthenticationContext(url) if ctx_auth.acquire_token_for_user(username, password): ClientRequest(ctx_auth) request_url = "{0}{1}".format(url, path) log.info("Getting '{0}' from '{1}'".format(path, url)) options = RequestOptions("{0}".format(request_url)) options.set_header('Accept', 'application/json') options.set_header('Content-Type', 'application/text') ctx_auth.authenticate_request(options) data = requests.get(url=options.url, headers=options.headers, auth=options.auth) return Response(data.content, mimetype="application/text") except BaseException as e: log.exception("Failed to get resource '{0}': {1}".format( request_url, e)) raise e else: raise ValueError( "Missing one or more required environment variables (baseurl, username, password)" )
def delete_list_item(context, list_title, item_id, url): """Delete list item example""" request = ClientRequest(context) options = RequestOptions( "{0}/web/lists/getbyTitle('{1}')/items({2})".format(url, list_title, item_id)) options.set_header('Accept', 'application/json; odata=nometadata') # JSON Light nometadata mode! options.set_header('IF-MATCH', '*') options.set_header('X-HTTP-Method', 'DELETE') options.data = {'Title': 'New Task (updated)'} options.method = HttpMethod.Post print("Deleting list item...") request.execute_request_direct(options) print("Task has been successfully [deleted]")
def main(self, fcreate, fname, furl): file_to_create = fcreate file_name = fname #### --- Create Sharepoint Authorized Connection ---- #### ctx_auth = AuthenticationContext(url) if ctx_auth.acquire_token_for_user(username, password): ctx= ClientContext(url,ctx_auth) ctx.request_form_digest() request = ClientRequest(ctx) full_url = ("{0}/_api/web/GetFolderByServerRelativeUrl('{1}')/Files/add(url='{2}', overwrite=true)".format(url, furl, file_to_create)) options = RequestOptions(full_url) options.set_header('Accept', 'application/json; odata=nometadata') options.set_header('Content-Type', 'application/octet-stream') options.set_header('Content-Length', str(os.path.getsize(file_name))) options.set_header('X-RequestDigest', ctx.contextWebInformation.form_digest_value) options.method = HttpMethod.Post ### --- Upload File to Sharepoint Site ---- #### with open(file_name, 'rb') as outfile: ctx.authenticate_request(options) data = requests.post(url=full_url, data=outfile, headers=options.headers, auth=options.auth) ### --- Verify succuess of upload ---- ### if data.status_code == 200: print("success") else: print(data.status_code) return data.json()['error'] else: print(ctx_auth.get_last_error()) ### --- Script Start ---- #### #fileOpenBackLogCreate() #fileBillingsCreate() #msdShipDate() #read_file()
def build_request(self, query): request = RequestOptions(query.url) # set json format headers request.set_headers(self.context.json_format.build_http_headers()) # set method request.method = query.method # set custom method headers if isinstance(self.context.json_format, JsonLightFormat): if isinstance(query, DeleteEntityQuery): request.set_header("X-HTTP-Method", "DELETE") request.set_header("IF-MATCH", '*') elif isinstance(query, UpdateEntityQuery): request.set_header("X-HTTP-Method", "MERGE") request.set_header("IF-MATCH", '*') else: if isinstance(query, UpdateEntityQuery): request.method = HttpMethod.Patch elif isinstance(query, DeleteEntityQuery): request.method = HttpMethod.Delete # set request payload if query.payload is not None: request.data = ODataEncoder(self.context.json_format).default( query.payload) return request
def delete_list_item(context, list_title, item_id): """ Deletes item with given id in given list :param context: auth context :param list_title: name of list :param item_id: :return: requests/response object """ req = ClientRequest(context) options = RequestOptions( f"{URL}/_api/web/lists/getbyTitle('{list_title}')/items({item_id})") options.set_header('Accept', 'application/json; odata=nometadata') options.set_header('IF-MATCH', '*') options.set_header('X-HTTP-Method', 'DELETE') options.method = HttpMethod.Post res = req.execute_request_direct(options) return res
def update_list_item(context, list_title, item_id, values_to_send): """ Updates item with given id in given list with given properties :param context: auth context :param list_title: name of list :param item_id: :param values_to_send: dict with key-value pairs :return: requests/result object """ request = ClientRequest(context) options = RequestOptions( "{2}/_api/web/lists/getbyTitle('{0}')/items({1})".format( list_title, item_id, URL)) options.set_header('Accept', 'application/json; odata=nometadata') options.set_header('IF-MATCH', '*') options.set_header('X-HTTP-Method', 'MERGE') options.data = values_to_send options.method = HttpMethod.Post result = request.execute_request_direct(options) return result
def create_sharepoint_folder(new_folder_name): """THIS API CAN ONLY HANDLE 1 FOLDER CREATION AT A TIME""" if ctx.acquire_token_for_user(username=USERNAME, password=PASSWORD): create_folder_url = "{0}/_api/web/GetFolderByServerRelativeUrl('Shared Documents')/folders".format( BASE_URL) options = RequestOptions(BASE_URL) context = ClientContext(BASE_URL, ctx) context.request_form_digest() options.set_header('Accept', 'application/json; odata=verbose') options.set_header('Content-Type', 'application/json;odata=verbose') options.set_header('X-RequestDigest', context.contextWebInformation.form_digest_value) options.method = 'POST' context.authenticate_request(options) body = {} body['__metadata'] = {'type': 'SP.Folder'} body['ServerRelativeUrl'] = new_folder_name string_body = json.dumps(body) data = requests.post(url=create_folder_url, data=string_body, headers=options.headers, auth=options.auth) return data.ok