def login(self):
try:
self.__site_url = StringUtils.StringUtils.websiteAPI
self.__ctx = ClientContext(self.__site_url).with_credentials(
UserCredential(StringUtils.StringUtils.email, StringUtils.StringUtils.passwort))
except ValueError:
raise LoginException
def __init__(self, url, username, password, log):
"""
SharePoint object initialization.
:param url: SharePoint destination URL (See DEFAULT_SP_URL above for example)
:param username: Username to access SharePoint (See DEFAULT_SP_USERNAME above for example)
:param log: where to send log messages
:type log: logging.Logger
"""
self._url = url
self._username = username
self._password = password
self.log = log
#
# Authenticate for this run
#
log.debug(
"SharePoint: Acquiring AuthenticationContext {} for {}".format(
url, username))
self._ctx_auth = AuthenticationContext(url=url)
#
# Looks like, at the time of this writing, the Office365-REST_Python-Client
# library exception handling leaves a lot to be desired as their internal
# method calls don't test the results of lower-level method calls in order to
# percolate up problems they encounter.
#
# NOTE: Errors will actually go to the log file but not standard output for some
# unknown reason
#
log.debug("SharePoint: Acquiring token from {} for {}".format(
url, username))
self._ctx_auth.acquire_token_for_user(username=username,
password=password)
#
# Kludgy test to see if a problem occurred
# Admittedly this test will break if a different authentication provider is used
#
if self._ctx_auth.provider.token is None:
_msg = "SharePoint: Unable to get SharePoint authorization. Error: {}".format(
self._ctx_auth.get_last_error())
log.critical(_msg)
raise ValueError(_msg)
log.debug(
"SharePoint: Authentication token obtained from {} for {}".format(
url, username))
#
# Get cookies
#
log.debug("SharePoint: Getting cookies from {} for {}".format(
url, username))
self._ctx = ClientContext(self.url, self._ctx_auth)
log.debug("SharePoint: Obtained ClientContext from {} for {}".format(
url, username))
def __init__(self, settings_path):
super().__init__(__version__, r"/home/downloader_settings",
settings_path)
context_auth = AuthenticationContext(url=site_url)
context_auth.acquire_token_for_app(
client_id=app_principal['client_id'],
client_secret=app_principal['client_secret'])
self.ctx = ClientContext(site_url, context_auth)
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).update()
client.execute_batch()
updated_web = client.web.get().execute_query()
self.assertEqual(updated_web.properties['Title'], new_web_title)
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_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 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 alterarGeradas(ID, sumGeradas):
# Definindo parametros de conexão
# ID e Senha criados pelo portal do sharepoint
app_settings = {
'url': 'https://usinacoruripe.sharepoint.com/sites/FaturamentoTorta',
'client_id': 'c74022f1-d1b5-47e3-913f-84d7a98cf032',
'client_secret': 'qfHtOWl6YieOhGAAavzuzUDvuf9pl2ZvD/0JSqvZhsQ='
}
# Chamando conexão com API Rest
context_auth = AuthenticationContext(url=app_settings['url'])
context_auth.acquire_token_for_app(
client_id=app_settings['client_id'],
client_secret=app_settings['client_secret'])
ctx = ClientContext(app_settings['url'], context_auth)
# Puxando valores da lista
listaShare = ctx.web.lists.get_by_title("Autorizações")
items = listaShare.get_items()
ctx.load(items)
ctx.execute_query()
item = listaShare.get_item_by_id(ID)
item.set_property('OData__x006d_kv6', sumGeradas)
item.update()
ctx.execute_query()
def test1_connect_with_app_principal(self):
credentials = ClientCredential(
settings.get('client_credentials').get('client_id'),
settings.get('client_credentials').get('client_secret'))
ctx = ClientContext(settings['url']).with_credentials(credentials)
self.assertIsInstance(ctx.authentication_context._provider,
ACSTokenProvider)
def setUpClass(cls):
ctx_auth = AuthenticationContext(url=settings['url'])
# ctx_auth.acquire_token_for_user(username=settings['user_credentials']['username'],
# password=settings['user_credentials']['password'])
ctx_auth.acquire_token_for_app(client_id=settings['client_credentials']['client_id'],
client_secret=settings['client_credentials']['client_secret'])
cls.context = ClientContext(settings['url'], ctx_auth)
def execute(self, container, args):
l = self.logger
try:
try:
ctx_auth = AuthenticationContext(url=args.sharepointurl)
if ctx_auth.acquire_token_for_user(
username=args.sharepointusername,
password=args.sharepointpass):
ctx = ClientContext(args.sharepointurl, ctx_auth)
filename = args.output
path = args.sharepointfpath
checkin_type = args.uplshr_checkintype
return upload_data_to_sharepoint(path, filename, ctx,
checkin_type, l)
else:
print(ctx_auth.get_last_error())
return
except Exception as e:
l.error("Exception happened boards search " + str(e))
except Exception as e:
l.error("Exception happened during connection establishment " +
str(e))
def __upload_target_reports(adm_sp_value: ADMSharepointValue) -> None:
site_url = adm_sp_value.sharepoint_value.site_url + 'sites/' + adm_sp_value.sharepoint_value.site_id
context_auth = AuthenticationContext(url=site_url)
context_auth.acquire_token_for_app(
client_id=adm_sp_value.sharepoint_value.client_id,
client_secret=adm_sp_value.sharepoint_value.client_secret)
ctx = ClientContext(site_url, context_auth)
target_report_values = adm_sp_value.target_report_values
# Create folder structure
new_path = __create_folder(ctx, adm_sp_value)
# Upload reports without segment by configuration
if target_report_values is not None:
for target_report_value in target_report_values:
file_path = target_report_value.target_report_location
if file_path is not None:
files = glob.glob(file_path)
__upload_file(files, new_path, ctx)
# Upload reports with segment by configuration
target_report_segment_values = target_report_value.target_report_segment_values
if target_report_segment_values is not None:
for target_report_segment_value in target_report_segment_values:
segment_by_value = target_report_segment_value.target_report_segment_by_field_value
segment_file_path = target_report_segment_value.target_report_segment_report_location
segment_files = glob.glob(segment_file_path)
__upload_file(segment_files, new_path, ctx,
segment_by_value)
def setUpClass(cls):
super(TestCommunicationSite, cls).setUpClass()
ctx_auth = AuthenticationContext(url=settings['url'])
ctx_auth.acquire_token_for_user(username=settings['user_credentials']['username'],
password=settings['user_credentials']['password'])
cls.client = ClientContext(settings['url'], ctx_auth)
cls.site_manager = SPSiteManager(cls.client)
def upload_one_excel(configuration, f, people, folders):
spbase = configuration['sharepointbase']
sharepointlibrary = configuration['sharepointlibrary']
spbase = configuration['sharepointbase']
test_team_site_url = configuration['sharepointsite']
sharepointlibrary = configuration['sharepointlibrary']
cred = get_user_credentials()
ctx = ClientContext(test_team_site_url).with_user_credentials(cred['username'], cred['password'])
centro = '00_Generale'
for c, o in people.items():
for organizer in o:
if organizer in path.basename(f):
centro = c
file_date = datetime.strptime(path.basename(f)[:10], '%Y-%m-%d')
for d in folders:
folder = '%s_Report Teams' % d.strftime("%Y-%m-%d")
if file_date <= d:
newpath = path.join(sharepointlibrary, spbase, centro, 'Report FAD', folder)
target_folder = ctx.web.ensure_folder_path(newpath).execute_query()
with open(f, 'rb') as content_file:
file_content = content_file.read()
name = path.basename(f)
target_file = target_folder.upload_file(name, file_content).execute_query()
if target_file:
return [{'origin': f, 'destination': target_file.serverRelativeUrl}]
return None
def setUpClass(cls):
super(TestCommunicationSite, cls).setUpClass()
cls.user_credentials = UserCredential(settings['user_credentials']['username'],
settings['user_credentials']['password'])
cls.client = ClientContext(settings['url']).with_credentials(cls.user_credentials)
cls.site_manager = SPSiteManager(cls.client)
def setUpClass(cls):
credentials = UserCredential(settings['user_credentials']['username'],
settings['user_credentials']['password'])
cls.client = ClientContext(
settings.get("admin_site_url")).with_credentials(credentials)
cls.tenant = Tenant(cls.client)
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 from_url(admin_site_url):
"""
:type admin_site_url: str
"""
from office365.sharepoint.client_context import ClientContext
admin_client = ClientContext(admin_site_url)
return Tenant(admin_client)
def setUpClass(cls):
super(TestTeamSite, cls).setUpClass()
user_credentials = UserCredential(settings['user_credentials']['username'],
settings['user_credentials']['password'])
cls.client = ClientContext(settings['url']).with_credentials(user_credentials)
cls.site_manager = GroupSiteManager(cls.client)
def test3_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)
def test4_unregister_hub_site(self):
admin_site_url = settings.get('admin_site_url')
client_admin = ClientContext(admin_site_url).with_credentials(
self.user_credentials)
tenant = Tenant(client_admin)
tenant.unregister_hub_site(
self.__class__.site_response.SiteUrl).execute_query()
def test1_connect_with_app_principal(self):
credentials = ClientCredential(settings.get('client_credentials').get('client_id'),
settings.get('client_credentials').get('client_secret'))
ctx = ClientContext.connect_with_credentials(settings['url'], credentials)
self.assertIsInstance(ctx.authentication_context.provider, ACSTokenProvider)
self.assertIsInstance(ctx.authentication_context.provider.token, TokenResponse)
self.assertTrue(ctx.authentication_context.provider.token.is_valid)
def test9_execute_get_batch_request(self):
client = ClientContext(test_site_url).with_credentials(test_user_credentials)
current_user = client.web.current_user
client.load(current_user)
current_web = client.web
client.load(current_web)
client.execute_batch()
self.assertIsNotNone(current_web.url)
self.assertIsNotNone(current_user.user_id)
def test8_execute_multiple_queries_sequentially(self):
client = ClientContext(test_site_url).with_credentials(test_user_credentials)
current_user = client.web.current_user
client.load(current_user)
current_web = client.web
client.load(current_web)
client.execute_query()
self.assertIsNotNone(current_web.url)
self.assertIsNotNone(current_user.user_id)
def test5_get_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)
client.execute_batch()
self.assertIsNotNone(current_web.url)
self.assertIsNotNone(current_user.user_id)
class SharePoint():
# Generating Auth Access
auth = AuthenticationContext(sharepoint_base_url)
auth.acquire_token_for_user(sharepoint_user, sharepoint_password)
ctx = ClientContext(sharepoint_base_url, auth)
web = ctx.web
ctx.load(web)
ctx.execute_query()
print('Connected to SharePoint: ', web.properties['Title'])
# Collecting files names from the folder
def folder_details(ctx, folder_in_sharepoint):
folder = ctx.web.get_folder_by_server_relative_url(
folder_in_sharepoint)
folder_names = []
sub_folders = folder.files
ctx.load(sub_folders)
ctx.execute_query()
for each_folder in sub_folders:
folder_names.append(each_folder.properties["Name"])
return folder_names
# Passing auth ctx and folder path
file_list = folder_details(ctx, folder_in_sharepoint)
# Reading File from SharePoint Folder and saving it in local.
print("Downloading 3P & Subledger file from sharepoint")
for each_file in file_list:
sharepoint_file = folder_in_sharepoint + each_file
file_response = File.open_binary(ctx, sharepoint_file)
print(file_response)
with open(each_file, 'wb') as output_file:
output_file.write(file_response.content)
# Downloading the UTC Key file from the sharepoint
print("Downloading UTC Key.xlsx file from sharepoint")
sharepoint_file = utc_key_file_in_sharepoint + "UTC Key.xlsx"
file_response = File.open_binary(ctx, sharepoint_file)
print(file_response)
with open("UTC Key.xlsx", 'wb') as output_file:
output_file.write(file_response.content)
# Processing the files and generating the output file.
print("Processing the files and generating the output file")
import automation
# Uploading the output file in the output folder of sharepoint.
with open(output_xlsx, 'rb') as content_file:
print(output_xlsx)
file_content = content_file.read()
target_folder = ctx.web.get_folder_by_server_relative_url(
'/CP/Shared%20Documents/Automation/Subledger%20Automation/Output/')
print(
"Uploading the output file in the output folder of the sharepoint."
)
target_folder.upload_file(output_xlsx, file_content)
ctx.execute_query()
def setUpClass(cls):
tenant = os.environ.get('office365_python_sdk_tenant', 'mediadev8')
admin_site_url = "https://{0}-admin.sharepoint.com/".format(tenant)
credentials = UserCredential(settings['user_credentials']['username'],
settings['user_credentials']['password'])
cls.client = ClientContext(admin_site_url).with_credentials(credentials)
cls.tenant = Tenant(cls.client)
def setUpClass(cls):
super(TestSearch, cls).setUpClass()
user_credentials = UserCredential(
settings['user_credentials']['username'],
settings['user_credentials']['password'])
cls.client = ClientContext(
settings['url']).with_credentials(user_credentials)
cls.search = SearchService(cls.client)
def test2_connect_with_app_principal_alt(self):
context_auth = AuthenticationContext(url=test_site_url)
context_auth.acquire_token_for_app(
client_id=settings.get('client_credentials', 'client_id'),
client_secret=settings.get('client_credentials', 'client_secret'))
ctx = ClientContext(test_site_url, context_auth)
self.assertIsInstance(ctx.authentication_context._provider,
ACSTokenProvider)
def from_url(url):
"""Construct and return a site instance
:type url: str
"""
from office365.sharepoint.client_context import ClientContext
client = ClientContext(url)
return client.site
