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())
