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 test_11_execute_get_and_update_batch_request(self):
page_url = "/sites/team/SitePages/Home.aspx"
client = ClientContext(test_team_site_url).with_credentials(
test_user_credentials)
list_item = client.web.get_file_by_server_relative_url(
page_url).listItemAllFields
new_title = create_unique_name("Page")
list_item.set_property("Title", new_title).update()
client.execute_batch()
updated_list_item = client.web.get_file_by_server_relative_url(
page_url).listItemAllFields.get().execute_query()
self.assertEqual(updated_list_item.properties['Title'], new_title)
def test_1_get_app_catalog(self):
admin_client = ClientContext(test_admin_site_url).with_credentials(
test_user_credentials)
tenant_settings = TenantSettings.current(
admin_client).get().execute_query()
self.assertIsNotNone(tenant_settings.resource_path)
site = Site.from_url(
tenant_settings.corporate_catalog_url).with_credentials(
test_user_credentials)
catalog = site.root_web.site_collection_app_catalog.get(
).execute_query()
self.assertIsNotNone(catalog.resource_path)
self.__class__.catalog = catalog
def test4_register_hub_site(self):
client_admin = ClientContext(test_admin_site_url).with_credentials(
test_user_credentials)
tenant = Tenant(client_admin)
props = tenant.register_hub_site(
self.__class__.site_response.SiteUrl).execute_query()
self.assertIsNotNone(props.site_id)
target_site = Site.from_url(
self.__class__.site_response.SiteUrl).with_credentials(
test_user_credentials)
target_site.get().execute_query()
self.assertTrue(target_site.is_hub_site)
def download(tenant_url, folder, file):
file_path = "%s%s" % (folder, file)
ctx_auth = AuthenticationContext(tenant_url)
ctx_auth.acquire_token_for_user(username, password)
# ctx_auth.with_client_certificate(tenant, client_id, thumbprint, cert_path)
# ctx_auth.acquire_token_for_app(client_id, client_secret)
ctx = ClientContext(tenant_url, ctx_auth)
target = "%s%s%s" % (os.path.dirname(
os.path.abspath(__file__)), "/import/", file)
response = File.open_binary(ctx, file_path)
with open(target, "wb") as local_file:
local_file.write(response.content)
def test8_execute_update_batch_request(self):
client = ClientContext(
settings['url']).with_credentials(user_credentials)
web = client.web
new_web_title = "Site %s" % random_seed
web.set_property("Title", new_web_title)
web.update()
client.execute_batch()
updated_web = client.web
client.load(updated_web)
client.execute_query()
self.assertEqual(updated_web.properties['Title'], new_web_title)
def test_10_execute_update_batch_request(self):
client = ClientContext(test_site_url).with_credentials(
test_user_credentials)
web = client.web
new_web_title = create_unique_name("Site")
web.set_property("Title", new_web_title)
web.update()
client.execute_batch()
updated_web = client.web
client.load(updated_web)
client.execute_query()
self.assertEqual(updated_web.properties['Title'], new_web_title)
def test_16_ensure_property(self):
client = ClientContext(test_site_url).with_credentials(
test_user_credentials)
me = client.web.current_user.get()
site = client.site
def _owner_loaded():
self.assertIsNotNone(site.owner.id)
site.ensure_property("Owner", _owner_loaded).get()
lib = client.web.default_document_library().get()
client.execute_query()
self.assertIsNotNone(me.login_name)
self.assertIsNotNone(lib.title)
def test_13_get_and_delete_batch_request(self):
file_name = create_unique_file_name("TestFile", "txt")
client = ClientContext(test_site_url).with_credentials(test_user_credentials)
list_pages = client.web.lists.get_by_title("Documents")
files = list_pages.root_folder.files.get().execute_query()
files_count_before = len(files)
new_file = list_pages.root_folder.upload_file(file_name, "-some content goes here-").execute_query()
self.assertTrue(new_file.name, file_name)
new_file.delete_object()
files_after = list_pages.root_folder.files
client.load(files_after)
client.execute_batch()
self.assertTrue(len(files_after), files_count_before)
def authSharpoint() -> ClientContext:
'''
Authenticates with sharepoint
'''
ctx_auth = AuthenticationContext(env.sp_url)
if ctx_auth.acquire_token_for_user(env.sp_username, env.sp_password):
ctx = ClientContext(env.sp_url, ctx_auth)
web = ctx.web
ctx.load(web)
ctx.execute_query()
return(ctx)
else:
print(ctx_auth.get_last_error())
return(False)
def upload_files(self):
"""
Upload files from configuration to the Sharepoint site from the configuration.
"""
ctx = ClientContext(self._url, self._context_auth)
root = ctx.web.lists.get_by_title("Documents").root_folder
target_folder = root.folders.get_by_url(self._fconfig.out_folder)
file_size = 0
for f in self._fconfig.files:
self._logger.info(f"File upload: {os.path.basename(f)}")
file_size = os.path.getsize(f)
with tqdm(
total=file_size,
file=sys.stdout,
unit="B",
unit_scale=True,
unit_divisor=1024,
ascii=True,
) as pbar:
def display_upload_progress(offset): # pylint: disable=unused-argument
# print_progress callback in create_upload_session requires
# the offset parameter to show progress like:
# (`offset` out of `file_size` uploaded)
# but tqdm instead works with `chunk_size`, i.e. size of step to
# update the progress bar.
"""
Callback used to print progress to stdout during file update.
"""
# pbar is only ever used here, so it's safe to silence
# the warning from pylint.
pbar.update( # pylint: disable=cell-var-from-loop
self._runtime.chunk_size)
uploaded_file = target_folder.files.create_upload_session(
f, self._runtime.chunk_size, display_upload_progress)
try:
ctx.execute_query()
except ClientRequestException as err:
self._logger.error(err.args[self._MESSAGE])
return False
self._logger.success(
f"File {f} uploaded to: {uploaded_file.serverRelativeUrl}")
return True
def test9_execute_get_and_update_batch_request(self):
client = ClientContext(
settings['url']).with_credentials(user_credentials)
list_item = client.web.get_file_by_server_relative_url(
"/SitePages/Home.aspx").listItemAllFields
new_title = "Page %s" % random_seed
list_item.set_property("Title", new_title)
list_item.update()
client.execute_batch()
updated_list_item = client.web.get_file_by_server_relative_url(
"/SitePages/Home.aspx").listItemAllFields
client.load(updated_list_item)
client.execute_query()
self.assertEqual(updated_list_item.properties['Title'], new_title)
def test5_construct_batch_request(self):
client = ClientContext(
settings['url']).with_credentials(user_credentials)
current_user = client.web.currentUser
client.load(current_user)
current_web = client.web
client.load(current_web)
batch_request = ODataBatchRequest(
client, JsonLightFormat(ODataMetadataLevel.Verbose))
def _prepare_request(request):
client.ensure_form_digest(request)
batch_request.beforeExecute += _prepare_request
batch_request.execute_query()
def verify_url(self):
"""
Verify that the url given with runtime configuration actually
exists on the Sharepoint site given in global configuration.
Must authenticate using get_token first.
"""
ctx = ClientContext(self._url, self._context_auth)
try:
web = ctx.web.get().execute_query()
except ClientRequestException as err:
self._logger.error(err.args[self._MESSAGE])
return False
self._logger.success(f"Site {web.properties['Title']}: {web.url}")
return True
def __init__(self, *args, **kwargs) -> None:
self.relative_url = kwargs.get('relative_url', None)
self.site_path = kwargs.get('url', config.SHAREPOINT_TENANT)
if config.SHAREPOINT_CONNECTION == 'app':
client_id = kwargs.get('client_id', config.SHAREPOINT_CLIENT_ID)
client_secret = kwargs.get('client_secret',
config.SHAREPOINT_CLIENT_SECRET)
credentials = ClientCredential(client_id, client_secret)
elif config.SHAREPOINT_CONNECTION == 'user':
username = kwargs.get('username', config.SHAREPOINT_USERNAME)
password = kwargs.get('password', config.SHAREPOINT_PASSWORD)
credentials = UserCredential(username, password)
else:
raise SharePointClientException('Invalid connection type')
self.folder = kwargs.get('folder', 'Documents')
self.context = ClientContext(
self.site_path).with_credentials(credentials)
def test_12_get_and_delete_batch_request(self):
file_name = "TestFile{0}.txt".format(random_seed)
client = ClientContext(settings['url']).with_credentials(user_credentials)
list_pages = client.web.lists.get_by_title("Documents")
files = list_pages.rootFolder.files
client.load(files)
client.execute_query()
files_count_before = len(files)
new_file = list_pages.rootFolder.upload_file(file_name, "-some content goes here-")
client.execute_query()
self.assertTrue(new_file.name, file_name)
new_file.delete_object()
files_after = list_pages.rootFolder.files
client.load(files_after)
client.execute_batch()
self.assertTrue(len(files_after), files_count_before)
def add_folder(self):
"""
Add folder given in FilesConfig.out to the list collection of the Sharepoint
site from the configuration.
"""
ctx = ClientContext(self._url, self._context_auth)
target_folder = ctx.web.lists.get_by_title("Documents").root_folder
new_folder = target_folder.add(self._fconfig.out_folder)
try:
ctx.execute_query()
except ClientRequestException as err:
self._logger.error(err.args[self._MESSAGE])
return False
self._logger.success(f"Added folder: {new_folder.serverRelativeUrl}")
return True
def make_context(self):
ctx_auth = AuthenticationContext(url=self.site_url)
ctx_auth.acquire_token_for_user(
username=self.authentication_dict['username'],
password=self.authentication_dict['password'])
#ctx_auth.acquire_token_for_user(username='******', password='******')
self.context = ClientContext(self.site_url, ctx_auth)
if self.context.auth_context.provider.error is not '':
#the the login didnt work!
returning_variable = False
else:
#the login worked!
returning_variable = True
return returning_variable
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 get_site_users():
"""
Fetch SharepointUsers users
:return:
"""
def generate(entities):
yield "["
for index, entity in enumerate(entities):
if index > 0:
yield ","
yield json.dumps(entity.properties)
yield ']'
ctx_auth = AuthenticationContext(URL)
if ctx_auth.acquire_token_for_user(USERNAME, PASSWORD):
ctx = ClientContext(URL, ctx_auth)
user_col = ctx.web.site_users
ctx.load(user_col)
ctx.execute_query()
return Response(generate(user_col), mimetype='application/json')
def openShiftPlan(creds):
ctx_auth = AuthenticationContext(siteURL)
if ctx_auth.acquire_token_for_user(creds[0], creds[1]):
ctx = ClientContext(siteURL, ctx_auth)
web = ctx.web
ctx.load(web)
ctx.execute_query()
print("Web title: {0}".format(web.properties['Title']))
else:
print(ctx_auth.get_last_error())
response = File.open_binary(ctx, relativeURL)
#print(ctx.service_root_url())
#save data to BytesIO stream
bytes_file_obj = io.BytesIO()
bytes_file_obj.write(response.content)
bytes_file_obj.seek(0) #set file object to start
#read file into pandas dataframe
return pd.read_excel(bytes_file_obj, sheet_name='Daily - Infra')
def upload_zipfile(configuration):
spbase = configuration['sharepointbase']
test_team_site_url = configuration['sharepointsite']
sharepointlibrary = configuration['sharepointlibrary']
zipfolder = configuration['zipfolder']
zipfilename = configuration['zipfile']
cred = get_user_credentials()
ctx = ClientContext(test_team_site_url).with_user_credentials(cred['username'], cred['password'])
zippath = path.join(sharepointlibrary, spbase, zipfolder)
target_folder = ctx.web.ensure_folder_path(zippath).execute_query()
with open(zipfilename, 'rb') as content_file:
file_content = content_file.read()
name = path.basename(zipfilename)
target_file = target_folder.upload_file(name, file_content).execute_query()
return target_file.serverRelativeUrl if target_file else None
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 get_data_from_excel(self, relative_url, worksheet_name, header_row,
start_row):
# adapted from: https://stackoverflow.com/a/69292234/14125255
# (accessed 2021-10-15)
ctx = ClientContext(self.conn.site_url).with_credentials(
UserCredential(self.conn.user, self.conn.password))
response = File.open_binary(ctx, relative_url)
bytes_file_obj = io.BytesIO()
bytes_file_obj.write(response.content)
bytes_file_obj.seek(0)
ws = load_workbook(bytes_file_obj, data_only=True)[worksheet_name]
headers = {
ws.cell(row=header_row, column=col).value: col
for col in range(1, ws.max_column + 1)
if ws.cell(row=header_row, column=col)
}
data = [{
k: ws.cell(row=row, column=v).value
for k, v in headers.items()
} for row in range(start_row, ws.max_row + 1)]
return data
def create_typed_object(self, properties, client_object_type):
from office365.sharepoint.client_context import ClientContext
from office365.runtime.resource_path_entity import ResourcePathEntity
if client_object_type is None:
raise AttributeError("No class for object type '{0}' found".format(
client_object_type))
web_url, resource_path = properties["__metadata"]["uri"].split(
"/_api/")
context = self.context
if client_object_type.__name__ == "Web":
# create a new context to represent the new web object
context = ClientContext(web_url, self.context.auth_context)
client_object = client_object_type(
context, ResourcePathEntity.from_uri(resource_path, self.context))
client_object._parent_collection = self
client_object.map_json(properties)
return client_object
def eventFromSharePoint():
collection = db['calendar']
calendar_url = "https://mirageworks.sharepoint.com/sites/msteams_a0f4c8/_api/web/lists(guid'%s')/items" %(ACCOUNT['guid'])
ctx = ClientContext(calendar_url).with_credentials(UserCredential(ACCOUNT['email'], ACCOUNT['password']))
request = RequestOptions(calendar_url)
response = ctx.execute_request_direct(request)
json_data = json.loads(response.content)
for i, data in enumerate(json_data['d']['results']):
event = {}
event['title'] = data['Title']
event['start'] = data['EventDate']
event['end'] = data['EndDate']
event['id'] = data['ID']
event['allday'] = data['fAllDayEvent']
event['every'] = data['fRecurrence']
if data['fRecurrence']:
collection.update_one({'id': event['id']}, {'$set': event}, upsert=True)
else:
collection.update_one({'id': event['id']}, {'$set': event}, upsert=True)
def get_from_list(list_name):
"""
Fetch list of entities from given sharepoint list
:param list_name:
:return:
"""
def generate(entities):
yield "["
for index, entity in enumerate(entities):
if index > 0:
yield ","
yield json.dumps(entity.properties)
yield ']'
ctx_auth = AuthenticationContext(URL)
if ctx_auth.acquire_token_for_user(USERNAME, PASSWORD):
ctx = ClientContext(URL, ctx_auth)
list_object = ctx.web.lists.get_by_title(list_name)
items = list_object.get_items()
ctx.load(items)
ctx.execute_query()
return Response(generate(items), mimetype='application/json')
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 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 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()
