def file(self): """Get file""" if self.is_property_available("File"): return self.properties["File"] else: from office365.sharepoint.file import File return File( self.context, ResourcePathEntity(self.context, self.resourcePath, "File"))
def download_file(context): path = "../ref_docs/lkpEntityLocation.xlsx" # path = "../ref_docs/Test.docx" response = File.open_binary( context, "/teams/UDPDevTeam/MasterData/dev/access/lkpEntityLocation.xlsx") response.raise_for_status() with open(path, "wb") as local_file: local_file.write(response.content)
def test3_update_file_content(self): """Test file upload operation""" files = self.__class__.target_list.rootFolder.files self.client.load(files) self.client.execute_query() for file_upload in files: response = File.save_binary(self.client, file_upload.properties["ServerRelativeUrl"], self.content_placeholder) self.assertTrue(response.ok)
def upload_file(self, file_path, file_name, data_type, software_version): upload_into_library = True # rn_test_1.csv with open(file_path, 'rb') as content_file: file_content = content_file.read() if upload_into_library: list_title = "Solar Test Data" target_folder = self.context.web.lists.get_by_title( list_title).root_folder file_extension = os.path.basename(file_path).split(".")[-1] # [filename][mdl] # [filename][xlsx][xlsm] split_file_name = file_name.split(".")[0] uploaded_file_name = split_file_name + "_" + data_type[ 0] + "." + file_extension file = self.upload_file_alt(target_folder, uploaded_file_name, file_content) new_file_url = file.properties["ServerRelativeUrl"] print("File url: {0}".format(new_file_url)) #for testing you dafty remove later ######################### ################## #data_type = "Clean data" #software_version = "3.1" update_properties = self.edit_uploaded_properties( file, uploaded_file_name, new_file_url, self.unit_dict, data_type, software_version) print(update_properties) else: target_url = "/Shared Documents/{0}".format( os.path.basename(file_path)) File.save_binary(self.context, target_url, file_content)
def add_template_file(self, url_of_file, template_file_type): """Adds a ghosted file to an existing list or document library.""" target_file = File(self.context) self.add_child(target_file) qry = ServiceOperationQuery(self, "addTemplateFile", { "urlOfFile": url_of_file, "templateFileType": template_file_type }, None, None, target_file) self.context.add_query(qry) return target_file
def add_template_file(self, url_of_file, template_file_type): """Adds a ghosted file to an existing list or document library.""" file_new = File(self.context) qry = ServiceOperationQuery(self, "addTemplateFile", { "urlOfFile": url_of_file, "templateFileType": template_file_type }) self.context.add_query(qry, file_new) self.add_child(file_new) return file_new
def download_file_alt(context, file_url, local_path): """ Download a file by server relative url :param local_path: str :param file_url: str :type context: ClientContext """ response = File.open_binary(context, file_url) response.raise_for_status() with open(local_path, "wb") as local_file: local_file.write(response.content)
def add(self, file_creation_information): """Creates a File resource""" target_file = File(self.context) self.add_child(target_file) qry = ServiceOperationQuery( self, "add", { "overwrite": file_creation_information.overwrite, "url": file_creation_information.url }, file_creation_information.content, None, target_file) self.context.add_query(qry) return target_file
def add(self, file_creation_information): """Creates a File resource""" file_new = File(self.context) qry = ClientQuery.service_operation_query( self, ActionType.PostMethod, "add", { "overwrite": file_creation_information.overwrite, "url": file_creation_information.url }, file_creation_information.content) self.context.add_query(qry, file_new) self.add_child(file_new) return file_new
def add(self, file_creation_information): """Creates a File resource""" file_new = File(self.context) qry = ServiceOperationQuery( self, "add", { "overwrite": file_creation_information.overwrite, "url": file_creation_information.url }, file_creation_information.content) self.context.add_query(qry, file_new) self.add_child(file_new) return file_new
def __init__(self, container, file_creation_information): """ :type file_creation_information: office365.sharepoint.file_creation_information.FileCreationInformation :type container: FileCollection """ self._return_type = File(container.context) super().__init__( container, "add", { "overwrite": file_creation_information.overwrite, "url": file_creation_information.url }, file_creation_information.content, None, self._return_type) container.add_child(self._return_type)
def add(self, attachment_file_information): """Creates an attachment""" if isinstance(attachment_file_information, dict): attachment_file_information = AttachmentfileCreationInformation( attachment_file_information.get('filename'), attachment_file_information.get('content')) file_new = File(self.context) qry = ClientQuery.service_operation_query( self, ActionType.PostMethod, "add", { "filename": attachment_file_information.filename, }, attachment_file_information.content) self.context.add_query(qry, file_new) self.add_child(file_new) return file_new
def add(self, attachment_file_information): """Creates an attachment""" if isinstance(attachment_file_information, dict): attachment_file_information = AttachmentfileCreationInformation( attachment_file_information.get('filename'), attachment_file_information.get('content')) target_file = File(self.context) self.add_child(target_file) qry = ServiceOperationQuery( self, "add", { "filename": attachment_file_information.filename, }, attachment_file_information.content, None, target_file) self.context.add_query(qry) return target_file
def download_file(context): path = "../../tests/data/SharePoint User Guide.docx" response = File.open_binary(context, "Shared Documents/SharePoint User Guide.docx") response.raise_for_status() with open(path, "wb") as local_file: local_file.write(response.content)
def test_3_download_file(self): """Test file upload operation""" response = File.open_binary(self.context, self.report_file_url) self.assertEqual(response.content, '"' + self.report_content + '"')
def test_2_update_file(self): """Test file upload operation""" File.save_binary(self.context, self.report_file_url, self.report_content)
def download_file(context): response = File.open_binary( context, "/Shared Documents/SharePoint User Guide.docx") with open("./data/SharePoint User Guide.docx", "wb") as local_file: local_file.write(response.content)
from office365.runtime.auth.authentication_context import AuthenticationContext from office365.sharepoint.client_context import ClientContext from office365.sharepoint.file import File import pandas as pd url = 'https://s.' ctx_auth = AuthenticationContext(url) ctx_auth.acquire_token_for_user('e.com', 'xxx') ctx = ClientContext(url, ctx_auth) response = File.open_binary(ctx, "/veille.csv") with open("./veille.csv", "wb") as local_file: local_file.write(response.content)
def test4_get_file_from_absolute_url(self): file_abs_url = self.client.base_url + self.__class__.target_file.properties[ 'ServerRelativeUrl'] file = File.from_url(file_abs_url).with_credentials( self.credentials).load().execute_query() self.assertIsNotNone(file.serverRelativeUrl)
def download_files(self, src, dest, file_pattern, period, worksheet_names, table_names, exec_id, script_path): #print ("In download_files") """ Download all the files in a src SharePoint directory to local dest directory. :param src: Source SharePoint folder from which to download files :type src: string :param dest: Destination local directory into which to download files :type dest: string :return: Number of files downloaded """ # # Create some useful variables from download source folder # Incoming src variable should be like: /sites/SageDS/Shared Documents/NPT/Oct 2018 # _base_path = os.path.dirname( src ) # Grab the head of dir (ie. /sites/SageDS/Shared Documents/NPT) #print("_base_path :", _base_path) _date_folder = os.path.basename( src) # Grab the base of dir (ie. Oct 2018) #print("_date_folder :", _date_folder) _move_to_path = "{}/Archived/{}/".format(_base_path, _date_folder) ##print("_move_to_path :", _move_to_path) self.log.debug( "download_files: Starting src:{} base:{} date:{}".format( src, _base_path, _date_folder)) # # Make sure Archived folder exists in SharePoint before moving on # self.check_archived_folder(src) # # Get the list of filenames in the SharePoint folder # _files = self.list_files(src) ##print ("_files :", _files) # # Keep a count of the number of files downloaded # _num_downloaded = 0 # # Make sure there's something to download # if not len(_files): self.log.info( "download_files: No files found to download from {} of {}". format(src, self.url)) return _num_downloaded self.log.info( "files_found: Number of files {} found from {} of {}".format( len(_files), src, self.url)) # # Walk the list of files, downloading each one into destination directory # for _f, _fct in _files.items(): #print ("In _files Loop") _spn = "{}/{}".format(src, _f) # Source pathname ##print ('_spn =', _spn) _dpn = os.path.join(dest, _f) # Destination pathname ##print ('_dpn =', _dpn) _upper_file_name = _f.upper() ##print ('_upper_file_name =', _upper_file_name) # self.log.info('_upper_file_name = ' + _upper_file_name) _upper_file_pattern = file_pattern.upper() # self.log.info('_upper_file_pattern = ' + _upper_file_pattern) ##print ('_upper_file_pattern =', _upper_file_pattern) file_pattern_match = re.findall(_upper_file_pattern, _upper_file_name) # self.log.info('file_pattern_match = ' + str(file_pattern_match)) if file_pattern_match: ##print ("Found files with the pattern {}".format(file_pattern)) self.log.debug("download_files: Downloading {} to {}".format( _spn, _dpn)) # self.log.info("download_files: Downloading {} to {}".format(_spn, _dpn)) # Insert Log proc_name = _f statement_type = "Download File -> " + _f table_name = 'null' # success_failure = "Download Complete" # self.log.info('exec_id = ' + str(exec_id) + ' proc_name = ' + proc_name + ' statement_type = ' # + statement_type) qrs.insert_log(exec_id, proc_name, statement_type, table_name, 'null', "Started") # # Download the file # try: with open(_dpn, 'wb') as _ofd: _response = File.open_binary(self._ctx, _spn) _ofd.write(_response.content) # success_failure = "Download Complete" qrs.insert_log(exec_id, proc_name, statement_type, table_name, 'null', "Completed") except Exception as e: _msg = "{} error encountered creating destination file {}".format( e, _dpn) log.critical(_msg) raise ValueError(_msg) dct = datetime.fromtimestamp(os.path.getmtime(_dpn)) ##print ("down load time : " ,dct) ##print ("type of _fct = ", type(_fct)) #_fp.append(dct) ##print ("_fp = ", _fp) #valid_files_dict[_f] = _fp ##print ("valid_files_dict = ", valid_files_dict) sqlcmd = "INSERT INTO [T_STG_FILES_DOWNLOADED]" \ + "([FILE_NAME_PATTERN],[FILE_NAME],[DOWNLOADED_TIME],[PERIOD],[PROJECT],[FILE_CREATION_TIME]) " \ + "VALUES(" \ + "'" + file_pattern + "'," \ + "'" + _f + "'," \ + "CAST(left('" + str(dct) + "',23)" + " AS datetime),'" \ + period + "'," \ +"'" + qrs.Project_Name + "'," \ + "CAST ('" +_fct + "' AS datetime))" ##print('sqlcmd = ', sqlcmd) qrs.dml_cursor(sqlcmd) LOG.info( "Uploaded to data base strarts:Work sheet {} Table: {} ". format(worksheet_names, table_names)) os_cmd = script_path + 'Opex_dynamic_upload_to_DB.py ' + str( exec_id ) + ' "' + _dpn + '" "' + table_names + '" "' + worksheet_names + '"' print('Initiating System Command -> \n' + os_cmd) qrs.run_os_cmd(os_cmd) LOG.info( "All Work sheet {} Uploaded to Table: {} was successful". format(worksheet_names, table_names)) #print ("file = " , "'" + dest + "\\" +_f + "'") #print ("worksheet_names = " , "'" + worksheet_names+ "'") #print ("table_names = " , "'" + table_names + "'") _num_downloaded += 1 # # File downloaded, move it to Archived folder # _to_path = _move_to_path + _f #commented by Mukesh not archieve for testing self.log.debug("download_files: Moving {} to {}".format( _spn, _to_path)) # # Moving the file # try: print("in moving block") LOG.info("\n Sharepoint:File {} has been archived in {} ". format(self._ctx, _spn, _to_path)) _resp = File.move( self._ctx, _spn, _to_path ) #commented by Mukesh not archieve for testing ##print ("in moving block after MOve") except Exception as e: _msg = "{} error encountered moving {} to file {}".format( e, _spn, _to_path) log.critical(_msg) raise ValueError(_msg) #_resp = File.move(self._ctx, _spn, _to_path) # # Was move successful # if _resp.status_code != 200: self.log.error( "download_files: Error: {} moving {} to {}".format( _resp.status_code, _spn, _to_path)) else: self.log.debug("download_files: Moved {} to {}".format( _spn, _to_path)) # # Return count of files downloaded # return _num_downloaded
from office365.runtime.auth.authentication_context import AuthenticationContext from office365.sharepoint.client_context import ClientContext from office365.sharepoint.file import File app_settings = { 'url': 'https://xxxx.sharepoint.com/sites/testprivate', 'client_id': '3601b9xxxxf8b67e3a', 'client_secret': '4qr3urbxxxxEUESzc13Ys=', } ctx_auth = AuthenticationContext(url=app_settings['url']) ctx_auth.acquire_token_for_app(client_id=app_settings['client_id'], client_secret=app_settings['client_secret']) ctx = ClientContext(app_settings['url'], ctx_auth) path = "D:\dest.txt" response = File.open_binary( ctx, "/sites/testprivate/Shared%20Documents/source.txt") response.raise_for_status() with open(path, "wb") as local_file: local_file.write(response.content) print('f')
def get_by_url(self, url): """Retrieve File object by url""" return File( self.context, ResourcePathServiceOperation(self.context, self.resource_path, "GetByUrl", [url]))
import os import tempfile from office365.runtime.auth.userCredential import UserCredential from office365.sharepoint.file import File from settings import settings abs_file_url = "{site_url}sites/team/Shared Documents/sample.docx".format( site_url=settings.get('url')) user_credentials = UserCredential( settings.get('user_credentials').get('username'), settings.get('user_credentials').get('password')) file_name = os.path.basename(abs_file_url) with tempfile.TemporaryDirectory() as local_path: with open(os.path.join(local_path, file_name), 'wb') as local_file: file = File.from_url(abs_file_url).with_credentials( user_credentials).download(local_file).execute_query() print("'{0}' file has been downloaded into {1}".format( file.serverRelativeUrl, local_file.name))
def qr_batch(): print("") print( "The batch QR code tool is used to automatically create multiple QR codes by referencing a .csv file. The tool will automatically create QR codes for each participant's email address and save each QR image to the SharePoint site. \n" ) input("Press Enter to Continue \n") # this code creates a batch of QR codes from a csv file stored in the local directory # QR code image size and input filename can be modified below resp = File.open_binary(ctx, relative_url) status = resp.status_code if status == 404: print( "The batch file '" + relative_url + "' doesn't exist. Please copy 'names.csv' to the sharepoint site.") return False with open(qrbatchfile, 'wb') as output_file: output_file.write(resp.content) with open(qrbatchfile) as csvfile: reader = csv.reader(csvfile) for row in reader: labeldata = row[0] qr = qrcode.QRCode( version=1, error_correction=qrcode.constants.ERROR_CORRECT_L, box_size=10, border=4) qr.add_data(labeldata) qr.make(fit=True) print("Creating QR code: " + labeldata) # draw QR image img = qr.make_image() qrfile = labeldata + ".jpg" img.save(qrfile) # open QR image and add qr data as name img = Image.open(qrfile) draw = ImageDraw.Draw(img) font = ImageFont.truetype("arial", 18) color = 0 draw.text((37, 10), labeldata, font=font, fill=color) img.save(qrfile) # upload file with open(qrfile, 'rb') as content_file: file_content = content_file.read() upload_file(ctx, file_content, qrfile, qrfolder) os.remove(qrfile) os.remove(qrbatchfile) print("Success! \n")
def get_by_id(self, _id): """Gets the File with the specified ID.""" return File( self.context, ResourcePathServiceOperation(self.context, self.resource_path, "getById", [_id]))
def test_3_download_file(self): """Test file upload operation""" response = File.open_binary(self.context, self.report_file_url) str_output_content = response.content.decode("utf-8") self.assertEqual(str_output_content, '"{0}"'.format(self.report_content))