def read_list_items(context, list_title):
"""Read list items example"""
request = ClientRequest(context)
options = RequestOptions("{0}web/lists/getbyTitle('{1}')/items".format(
context.service_root_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 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 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 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 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_request_direct(request_url=request_url,
data=item_payload)
print("Task {0} has been successfully [created]".format(
data['d']['Title']))
return data['d']
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)
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())
tenant_url = "https://abc.sharepoint.com"
site_url = "https://abc.sharepoint.com/sites/s01"
ctx_auth = AuthenticationContext(tenant_url)
if ctx_auth.acquire_token_for_user("*****@*****.**", "xxxxx"):
request = ClientRequest(ctx_auth)
# get digest
optiondigest = RequestOptions("{0}/_api/contextinfo".format(site_url))
optiondigest.method = HttpMethod.Post
optiondigest.set_header('Accept', 'application/json')
optiondigest.set_header('Content-Type', 'application/json')
datadigest = request.execute_request_direct(optiondigest)
s = json.loads(datadigest.content)
FormDigestValue = s['FormDigestValue']
print("FormDigestValue" + FormDigestValue)
# Send email
options = RequestOptions(
"{0}/_api/SP.Utilities.Utility.SendEmail".format(site_url))
options.set_header('Accept', 'application/json')
options.set_header('Content-Type', 'application/json;odata=verbose')
options.set_header('X-RequestDigest', FormDigestValue)
options.method = HttpMethod.Post
options.data = {
"properties": {
"__metadata": {
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)
})