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
