def connect(self): self.ctx_auth = AuthenticationContext(self.site_url) self.connected = self.ctx_auth.acquire_token_for_user( self.username, self.password) self.request = ClientRequest(self.ctx_auth) print('Authentication was {}successful'.format( 'not ' if not self.connected else '')) return self.connected
def delete_list_item(web_url, ctx_auth, list_title, item_id): """Delete list item example""" request = ClientRequest(web_url, ctx_auth) request_url = "{0}/_api/web/lists/getbyTitle('{1}')/items({2})".format( web_url, list_title, item_id) print("Deleting list item...") headers = {'IF-MATCH': '*', 'X-HTTP-Method': 'DELETE'} request.execute_request_direct(request_url=request_url, headers=headers) print("Task has been successfully [deleted]")
def read_list_items(web_url, ctx_auth, list_title): """Read list items example""" request = ClientRequest(web_url, ctx_auth) request_url = "{0}/_api/web/lists/getbyTitle('{1}')/items".format(web_url, list_title) # Web resource endpoint print("Retrieving list items from List {0}".format(list_title)) data = request.execute_query_direct(request_url=request_url) for item in data['d']['results']: print("Item title: {0}".format(item["Title"]))
def create_list_item(web_url, ctx_auth, list_title): """Create list item example""" request = ClientRequest(web_url, ctx_auth) request_url = "{0}/_api/web/lists/getbyTitle('{1}')/items".format(web_url, list_title) # Web resource endpoint print("Creating list item...") item_payload = {'__metadata': {'type': 'SP.Data.TasksListItem'}, 'Title': 'New Task'} data = request.execute_query_direct(request_url=request_url, data=item_payload) print("Task {0} has been successfully [created]".format(data['d']['Title'])) return data['d']
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 update_list_item(web_url, ctx_auth, list_title, item_id): """Update list item example""" request = ClientRequest(web_url, ctx_auth) request_url = "{0}/_api/web/lists/getbyTitle('{1}')/items({2})".format(web_url, list_title, item_id) print("Updating list item...") item_payload = {'__metadata': {'type': 'SP.Data.TasksListItem'}, 'Title': 'New Task (updated)'} headers = { 'IF-MATCH': '*', 'X-HTTP-Method': 'MERGE' } request.execute_query_direct(request_url=request_url, headers=headers, data=item_payload) print("Task has been successfully [updated]")
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_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 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 FetchMSPData(auth_creds, endpoint, entrylist): print("Fetching data for: ", endpoint) MSP_ROOT_URL = auth_creds[0] MSP_USERNAME = auth_creds[1] MSP_PASS = auth_creds[2] ctx_auth = AuthenticationContext(MSP_ROOT_URL) if ctx_auth.acquire_token_for_user(MSP_USERNAME, MSP_PASS): request = ClientRequest(ctx_auth) dataList = GetAllData( auth_creds, request, "/sites/pwa/_api/projectdata/{0}".format(endpoint) ) d = {} if len(entrylist) == 1 and entrylist[0] == "all": ParseAndAddAllToDict(dataList, d) else: for entry in entrylist: ParseAndAddToDict(dataList, entry, d) data_df = pd.DataFrame(d) print("Success data fetching for: ", endpoint) return data_df else: print(ctx_auth.get_last_error())
def FetchMSPAvailableFields(auth_creds): MSP_ROOT_URL = auth_creds[0] MSP_USERNAME = auth_creds[1] MSP_PASS = auth_creds[2] ctx_auth = AuthenticationContext(MSP_ROOT_URL) if ctx_auth.acquire_token_for_user(MSP_USERNAME, MSP_PASS): request = ClientRequest(ctx_auth) options = RequestOptions(MSP_ROOT_URL + "/sites/pwa/_api/projectdata") data = request.execute_request_direct(options) root = ET.fromstring(data.content) l = set() for elem in root.iter(): if elem.text: if not (elem.text == "None" or elem.text == "Default"): l.add(elem.text) return l
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 __init__(self, host, port=0, auth=None, username=None, password=None, protocol='http', path=None): if not port: port = 443 if protocol == 'https' else 80 self.path = path or '' if not self.path.endswith('/'): self.path = '%s/' % self.path # oneDrive: need to split /site/ and path # in our config site is /personal/UF_OCX_msf_geneva_msf_org/ # path is /Documents/Tests/ self.baseurl = '{0}://{1}:{2}{3}/'.format( protocol, host, port, '/'.join(self.path.split('/')[0:3])) ctx_auth = AuthenticationContext(self.baseurl) #if len(self.path.split('/')) < 5: # self.path = '%sDocuments/' % self.path if ctx_auth.acquire_token_for_user(username, cgi.escape(password)): self.request = ClientRequest(ctx_auth) self.request.context = ClientContext(self.baseurl, ctx_auth) if not ctx_auth.provider.FedAuth or not ctx_auth.provider.rtFa: raise ConnectionFailed(ctx_auth.get_last_error()) else: raise ConnectionFailed(ctx_auth.get_last_error())
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 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 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 login(self): ctx_auth = AuthenticationContext(self.baseurl) if ctx_auth.acquire_token_for_user(self.username, cgi.escape(self.password)): self.request = ClientRequest(ctx_auth) self.request.context = ClientContext(self.baseurl, ctx_auth) if not ctx_auth.provider.FedAuth or not ctx_auth.provider.rtFa: raise ConnectionFailed(ctx_auth.get_last_error()) else: raise ConnectionFailed(ctx_auth.get_last_error())
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 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 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)" )
class SharePoint(): def __init__(self, url, username, password): self.site_url = url if self.site_url[-1] != '/': self.site_url += '/' self.username = username self.password = password self.connected = False def connect(self): self.ctx_auth = AuthenticationContext(self.site_url) self.connected = self.ctx_auth.acquire_token_for_user( self.username, self.password) self.request = ClientRequest(self.ctx_auth) print('Authentication was {}successful'.format( 'not ' if not self.connected else '')) return self.connected @authenticate 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 @authenticate def get_raw(self, path): # request = ClientRequest(self.ctx_auth) options = RequestOptions('{}_api/web/{}'.format(self.site_url, path)) data = self.request.execute_request_direct(options) return data @authenticate def post_raw(self, path, headers={}, data={}): options = RequestOptions('{}{}'.format(self.site_url, path)) options.method = HttpMethod.Post options.set_headers(headers) if isinstance(data, abc.Mapping): options.data.update(data) data = self.request.execute_request_direct(options) if data.status_code == 403: import traceback traceback.print_tb() print(options.url) print(data.content) print(options.headers) return data @authenticate def post(self, path, headers={}, data={}): # request = ClientRequest(self.ctx_auth) options = RequestOptions('{}_api/web/{}'.format(self.site_url, path)) options.method = HttpMethod.Post options.set_headers(headers) options.data = data data = self.request.execute_request_direct(options) if data.status_code == 403: import traceback traceback.print_tb() print(options.url) print(data.content) print(options.headers) return data def get_digest(self): data = self.post_raw( '_api/contextinfo', headers=dict(Accept='application/json; odata=verbose')) data = json.loads(data.content) return data['d']['GetContextWebInformation']['FormDigestValue'] def lists(self): return self.get('lists') def get_list(self, name): return self.get("lists/getbytitle('{}')".format(quote_file(name))) def get_list_items(self, name): return self.get("lists/getbytitle('{}')/Items".format( quote_file(name))) def get_folder(self, path): return Folder(self, path, None) def get_file(self, path): return File(self, path) def find_file(self, root, path): file = self.get_folder(root) for x in path.components: file = file[x] return file def delete(self, path, is_folder=False): form_digest = self.get_digest() return self.post("Get{}ByServerRelativeUrl('{}')".format( 'Folder' if is_folder else 'File', quote_file(path)), headers={ 'X-RequestDigest': form_digest, 'IF-MATCH': 'etag or "*"', 'X-HTTP-Method': 'DELETE' }) def create_file(self, path, f, size): form_digest = self.get_digest() return self.post( "GetFolderByServerRelativeUrl('{}')/Files/add(url='{}', overwrite=true)" .format(quote_file(path.parent), quote_file(path.name)), headers={ 'X-RequestDigest': form_digest, 'Content-Length': str(size) }, data=f) def create_folder(self, path): form_digest = self.get_digest() return self.post("folders", headers={ 'X-RequestDigest': form_digest, 'accept': 'application/json;odata=verbose', 'content-type': 'application/json;odata=verbose' }, data={ '__metadata': { 'type': 'SP.Folder' }, 'ServerRelativeUrl': str(path) })
from office365.sharepoint.files.file import File # Import Authentication tokens from decouple import config """ Sharepoint File Access """ sharepoint_url = config('sharepoint') username = config('username') #input('username: '******'password') #getpass.getpass() site_url = config('site') folder_url = config('folder') # Access sharepoint folder with authentication ctx_auth = AuthenticationContext(sharepoint_url) if ctx_auth.acquire_token_for_user(username, password): request = ClientRequest(ctx_auth) ctx = ClientContext(site_url, ctx_auth) web = ctx.web ctx.load(web) ctx.execute_query() print(f"\n...Logged into: {web.properties['Title']}...") else: print(ctx_auth.get_last_error()) # Function to load a file from sharepoint onto python def load_file(filename): # Open the file in temporary memory response = File.open_binary(ctx, str(folder_url + filename)) bytes_file_obj = io.BytesIO()
def execute(self, context, client_object=None): from office365.runtime.client_request import ClientRequest return ClientRequest(context).execute_single_query(self, client_object)
from office365.runtime.auth.authentication_context import AuthenticationContext from office365.sharepoint.client_context import ClientContext from office365.runtime.client_request import ClientRequest from office365.runtime.utilities.request_options import RequestOptions import json from config import config url = 'https://gruposimbio.sharepoint.com/sites/dev' username = config['sp_user'] password = config['sp_password'] def disable_ssl(request): request.verify = False # Disable certification verification ctx_auth = AuthenticationContext(url) if ctx_auth.acquire_token_for_user(username, password): request = ClientRequest(ctx_auth) options = RequestOptions( "{0}/_api/web/lists/GetByTitle('Area')/items".format(url)) options.set_header('Accept', 'application/json') options.set_header('Content-Type', 'application/json') data = request.execute_request_direct(options) s = json.loads(data.content) print(s) else: print(ctx_auth.get_last_error())
from office365.runtime.auth.authentication_context import AuthenticationContext from office365.runtime.client_request import ClientRequest from office365.runtime.utilities.request_options import RequestOptions from settings import settings import json if __name__ == '__main__': context_auth = AuthenticationContext(url=settings['url']) if context_auth.acquire_token_for_user(username=settings['username'], password=settings['password']): """Read Web client object""" request = ClientRequest(settings['url'], context_auth) options = RequestOptions("{0}/_api/web/".format(settings['url'])) options.set_header('Accept', 'application/json') options.set_header('Content-Type', 'application/json') data = request.execute_query_direct(options) s = json.loads(data.content) web_title = s['Title'] print "Web title: " + web_title else: print context_auth.get_last_error()
def pending_request(self): if not self.__pending_request: self.__pending_request = ClientRequest(self) return self.__pending_request
import json from settings import settings from office365.runtime.auth.authentication_context import AuthenticationContext from office365.runtime.client_request import ClientRequest from office365.runtime.utilities.request_options import RequestOptions from office365.sharepoint.client_context import ClientContext if __name__ == '__main__': context_auth = AuthenticationContext(url=settings['url']) if context_auth.acquire_token_for_user(username=settings['user_credentials']['username'], password=settings['user_credentials']['password']): """Read Web client object""" ctx = ClientContext(settings['url'], context_auth) request = ClientRequest(ctx) options = RequestOptions("{0}/_api/web/".format(settings['url'])) options.set_header('Accept', 'application/json') options.set_header('Content-Type', 'application/json') data = ctx.execute_request_direct(options) s = json.loads(data.content) web_title = s['Title'] print("Web title: {0}".format(web_title)) else: print(context_auth.get_last_error())