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
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 = r"{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
response = ctx.execute_request_direct(request)
return response
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 delete_list_item(context, list_title, item_id):
"""Delete list item example"""
request = ClientRequest(context)
options = RequestOptions("web/lists/getbyTitle('{0}')/items({1})".format(
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 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 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 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 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 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 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 download_file(uri):
"""Give the URI (returned from retrieve file query)
and the path you want to write to."""
uriR = uri + '/$value'
if ctx.acquire_token_for_user(username=USERNAME, password=PASSWORD):
options = RequestOptions(BASE_URL)
context = ClientContext(BASE_URL, ctx)
context.request_form_digest()
options.method = 'GET'
context.authenticate_request(options)
byte_doc = requests.get(url=uriR,
headers=options.headers,
auth=options.auth)
hack_file_name = uri.split("/")
hack_file = hack_file_name[len(hack_file_name) - 1]
file_name = hack_file[0:len(hack_file) - 2]
return file_name, byte_doc.content
else:
print('Incorrect login credentials')
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 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 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
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 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 upload(self,
fileobj,
remote_path,
buffer_size=None,
log=False,
progress_obj=False):
iid = uuid.uuid1()
if progress_obj:
log = True
if log:
logger = logging.getLogger('cloud.backup')
try:
size = os.path.getsize(fileobj.name)
except:
size = None
offset = -1
if not buffer_size:
buffer_size = 10 * 1024 * 1024
x = ""
webUri = '%s%s' % (self.path, remote_path)
while True:
if offset == -1:
request_url = "%s/_api/web/GetFolderByServerRelativeUrl('%s')/Files/add(url='%s',overwrite=true)" % (
self.baseurl, self.path, remote_path)
offset = 0
elif not offset:
if len(x) == buffer_size:
request_url = "%s/_api/web/getfilebyserverrelativeurl('%s')/startupload(uploadId=guid'%s')" % (
self.baseurl, webUri, iid)
else:
request_url = "%s/_api/web/GetFolderByServerRelativeUrl('%s')/Files/add(url='%s',overwrite=true)" % (
self.baseurl, self.path, remote_path)
elif len(x) == buffer_size:
request_url = "%s/_api/web/getfilebyserverrelativeurl('%s')/continueupload(uploadId=guid'%s',fileOffset=%s)" % (
self.baseurl, webUri, iid, offset)
else:
request_url = "%s/_api/web/getfilebyserverrelativeurl('%s')/finishupload(uploadId=guid'%s',fileOffset=%s)" % (
self.baseurl, webUri, iid, offset)
offset += len(x)
options = RequestOptions(request_url)
options.method = HttpMethod.Post
self.request.context.authenticate_request(options)
self.request.context.ensure_form_digest(options)
result = requests.post(url=request_url,
data=x,
headers=options.headers,
auth=options.auth)
if result.status_code not in (200, 201):
raise Exception(result.content)
if log and offset and offset % buffer_size * 10 == 0:
percent_txt = ''
if size:
percent = round(offset * 100 / size)
percent_txt = '%d%%' % percent
if progress_obj:
progress_obj.write({'name': percent})
logger.info('OneDrive: %d bytes sent on %s bytes %s' %
(offset, size or 'unknown', percent_txt))
x = fileobj.read(buffer_size)
if not x:
break
return True
confObject = sConf(ci_tokenServer, site_url, site_sourceSite)
# from sharepoint.SharePointClientUtil import SharePoint_Client_Util
# sharepointClient = SharePoint_Client_Util.create_sharepoint_client(confObject, site_username, site_password)
# FormDigestValue = sharepointClient.get_digest()
# we are going to manually get the digest
# Some more setup
ctx_auth = AuthenticationContext(ci_tokenServer, site_url)
ctx_auth.acquire_token_for_user(site_username, site_password)
request = ClientRequest(ctx_auth)
options = RequestOptions(site_url + "/Sites/" + site_sourceSite + "/_api/contextinfo")
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']
# If the script has reached this point, our session is authenticated
# Run payload (your desired action) here
# Note: our convention across this plugin is that destinationPath begins with "/",
# and site_url, site_sourceSite, site_destinationSite do not end with /
# Move or copy across sites
# site_url must end with /
options = RequestOptions(site_source_url + "/sites/" + site_sourceSite + "/_api/site/CreateCopyJobs")
options.method = 'POST'
