コード例 #1
0
 def __init__(self, sharepoint_base_url, username, password):
     self.username = username
     self.password = password
     self.sharepoint_base_url = sharepoint_base_url
     self.authcookie = Office365(sharepoint_base_url,
                                 username=username,
                                 password=password).GetCookies()
コード例 #2
0
def call_for_content():
    APP_ID = '5995b22a-e094-4d5b-8523-edd7bb089d89'
    APP_PASSWORD = '******'
    CHANNEL_ID = 'msteams'
    BOT_ID = '5995b22a-e094-4d5b-8523-edd7bb089d89'
    authcookie = Office365('https://thespurgroup.sharepoint.com', username='******', password='******').GetCookies()
    site = Site('https://thespurgroup.sharepoint.com/sites/bot_project_test/', version=Version.v2016, authcookie=authcookie)
    folder_path = 'Shared Documents/Lono2docs/'
    teams_tracker = folder.get_file('testing.csv')
    source_stream = io.BytesIO(teams_tracker)
    df = pd.read_csv(source_stream).drop(columns=['Unnamed: 0'])
    for index, row in df.iterrows():
        SERVICE_URL = row.serviceURL
        recipient_id = row.recipientID
        TENANT_ID = row.tenantID
        NAME = row.Name
        to = ChannelAccount(id=recipient_id)
        bot_channel = ChannelAccount(id=CHANNEL_ID)
        MicrosoftAppCredentials.trust_service_url(SERVICE_URL)
        credentials = MicrosoftAppCredentials(APP_ID, APP_PASSWORD)
        conn_client = ConnectorClient(credentials, SERVICE_URL)
        message_activity = MessageFactory.text(f"Hello {NAME}, are you going to submit an article for this month's newsletter?");
        
        conversation_params = ConversationParameters(members=[to], channel_data={ 'tenant': { 'id': TENANT_ID } })
        conversation = conn_client.conversations.create_conversation(conversation_params)
        conn_client.conversations.send_to_conversation(conversation.id, message_activity)
コード例 #3
0
def main(req: func.HttpRequest) -> func.HttpResponse:
    # Configuration Sanity Check
    o365HostUri = os.environ['O365HostUri']
    o365UserName = os.environ['O365UserName']
    o365UserPassword = os.environ['O365UserPassword']
    o365SiteUri = os.environ['O365SiteUri']
    o365ListName = os.environ['O365ListName']

    validationError = False
    if not o365HostUri:
        validationError = True
        logging.error('O365HostUri configuration missing.')
    if not o365UserName:
        validationError = True
        logging.error('O365UserName configuration missing.')
    if not o365UserPassword:
        validationError = True
        logging.error('O365UserPassword configuration missing.')
    if not o365SiteUri:
        validationError = True
        logging.error('O365SiteUri configuration missing.')
    if not o365ListName:
        validationError = True
        logging.error('O365ListName configuration missing.')

    if validationError:
        return func.HttpResponse("Invalid configuration.", status_code=400)

    authcookie = Office365(o365HostUri, username=o365UserName, password=o365UserPassword).GetCookies()
    site = Site(o365SiteUri, version=Version.v365, authcookie=authcookie)
    sp_list = site.List(o365ListName)
    data = sp_list.GetListItems('All Items')
    logging.info(data)

    return func.HttpResponse(json.dumps(data), status_code=200, mimetype='application/json')
コード例 #4
0
 def login(self):
     authcookie = Office365(
         StringUtils.StringUtils.website,
         username=StringUtils.StringUtils.email,
         password=StringUtils.StringUtils.passwort).GetCookies()
     self.__site = Site(StringUtils.StringUtils.websiteAPI,
                        version=Version.v365,
                        authcookie=authcookie)
コード例 #5
0
    def run():

        wb = load_workbook(filename='data.xlsx', read_only=True)
        ws = wb['Raw Data']

        data = ws.values
        columns = next(data)[1:]
        data = list(data)
        idx = [r[0] for r in data]
        data = (islice(r, 1, None) for r in data)
        df = pd.DataFrame(data, index=idx, columns=columns)

        # print(df.loc[[1130359]])

        authcookie = Office365('https://purdue0.sharepoint.com',
                               username='',
                               password='').GetCookies()
        site = Site('https://purdue0.sharepoint.com/sites/HRIS',
                    version=Version.o365,
                    authcookie=authcookie)

        test_list = site.List('ELT-Test')

        # while True:
        #     list_items = test_list.GetListItems('All Items', fields=['ID'], row_limit=500)

        #     if len(list_items) == 0:
        #         break

        #     id_list = [x['ID'] for x in list_items]

        #     log.info('Starting deletion of {} records'.format(str(len(list_items))))
        #     test_list.UpdateListItems(data=id_list, kind='Delete')
        #     log.info('Deletion complete.')

        # print (len(list_items))

        list_items = []
        try:
            list_items = test_list.GetListItems(
                'All Items',
                fields=['ID', 'Employee Name'],
                # query={'Where': ['Or', ('Eq', 'Employee Name', 'Mark Holmes'), ('Eq', 'Employee Name', 'Patricia Prince')]},
                query={'Where': [('Eq', 'Employee Name', 'Mark Holmes')]},
            )
        except shareplum.errors.ShareplumRequestError as err:
            log.error(err)
            if err.details and type(
                    err.details) == requests.exceptions.HTTPError:
                if err.details.response.status_code in [429, 503]:
                    # TODO: Sleep for Retry-After to prevent further throttling
                    pass
                elif err.details.response.status_code in [500]:
                    log.error(err.details.response.request.body)
                    log.error(err.details.response.content)

        for list_item in list_items:
            log.info(list_item)
コード例 #6
0
def o365_login(tenant, username, password, site_o365, shared_folder):
    authcookie = Office365(
        tenant,
        username=base64.b64decode(username).decode('utf-8'),
        password=base64.b64decode(password).decode('utf-8')).GetCookies()
    site = Site(site_o365, version=Version.v365, authcookie=authcookie)
    folder_shared_o365 = site.Folder(shared_folder)
    print(time_now(), f'    Login to O365 to {site_o365} is successful!')
    return folder_shared_o365
コード例 #7
0
    def connect(self):
        config_details = config('config.ini', 'sharepoint')

        auth_cookie = Office365(config_details['base_url'],
                                username=config_details['user'],
                                password=config_details['pass']).GetCookies()

        conn = Site(config_details['url'], authcookie=auth_cookie)
        return conn
コード例 #8
0
    def auth(self):
        self.authcookie = Office365(SHAREPOINT_URL,
                                    username=USERNAME,
                                    password=PASSWORD).GetCookies()
        self.site = Site(SHAREPOINT_SITE,
                         version=Version.v365,
                         authcookie=self.authcookie)

        return self.site
コード例 #9
0
    def download(self) -> list:

        dl_files = []

        # parse url
        parsed = urlparse(self.site)
        scheme = 'https' if parsed.scheme == '' else parsed.scheme
        version = 365

        if self.version == '365':
            sp_version = Version.v365
        else:
            sp_version = Version.v2007

        try:
            if sp_version == Version.v365:
                authcookie = Office365(f'{scheme}://{parsed.netloc}',
                                       username=self.username,
                                       password=self.password).GetCookies()
            else:
                cred = HttpNtlmAuth(self.username, self.password)
        except:
            raise Exception(
                f'Unable to authenticate using supplied user name and password.'
            )
        else:
            self.display_info('Sucessfully authnticated')

        try:
            if sp_version == Version.v365:
                site = Site(self.site,
                            version=sp_version,
                            authcookie=authcookie)
            else:
                site = Site(self.site, version=sp_version, auth=cred)
        except:
            raise Exception(f'{self.site} is not a valid site')
        else:
            self.display_info(f'Sucessfully accessed site {self.site}')

        # build path to document folder
        doc_path = os.path.join(parsed.path, self.docs)

        try:
            folder = site.Folder(doc_path)
            for f in folder.files:
                fname = f['Name']
                if fnmatch.fnmatch(fname, self.filespec):
                    dest = os.path.join(self.savepath, fname)
                    with open(dest, mode='wb') as file:
                        file.write(folder.get_file(fname))
                        dl_files.append(dest)
        except:
            raise Exception(f'Unable to download files from {self.docs}')

        return dl_files
コード例 #10
0
def get_data(team_slug, folder_name, file_name):
    authcookie = Office365('https://devpatrol.sharepoint.com',
                           username=SP_USERNAME,
                           password=SP_PASSWORD).GetCookies()
    site = Site('https://devpatrol.sharepoint.com/sites/' + team_slug,
                version=Version.v365,
                authcookie=authcookie,
                verify_ssl=False)
    folder = site.Folder('Shared Documents/' + folder_name)
    response = folder.get_file(file_name)
    return response
コード例 #11
0
    def setUp(self):
        if TEST_SETTINGS["version"] in ["2014", "2016", "2019", "365"]:
            version = Version.v2016
        else:
            version = Version.v2007

        authcookie = Office365(TEST_SETTINGS["server_url"],
                               username=TEST_SETTINGS["username"],
                               password=TEST_PASSWORD).GetCookies()
        self.site = Site(TEST_SETTINGS["site_url"],
                         version=version,
                         authcookie=authcookie)
コード例 #12
0
    def setUp(self):
        with open("test_server.json") as f:
            self.server = json.load(f)

        if self.server["version"] in ["2014", "2016", "2019", "365"]:
            version = Version.v2016
        else:
            version = Version.v2007

        authcookie = Office365(
            self.server["server_url"],
            username=self.server["username"],
            password=os.environ.get('TEST_PASSWORD')).GetCookies()
        self.site = Site(self.server["site_url"],
                         version=version,
                         authcookie=authcookie)
コード例 #13
0
def sharepoint_list(Secrets):
    """
    Connection to SharePoint API with password authentication
    """
    username = Secrets['sharepoint']['user_name']
    password = Secrets['sharepoint']['password']
    web_site = Secrets['sharepoint']['web_site']
    my_site = Secrets['sharepoint']['my_site']

    authcookie = Office365(my_site, username=username,
                           password=password).GetCookies()

    site = Site(web_site, authcookie=authcookie)

    result = site.List('Risk Registry').GetListItems()

    return result
コード例 #14
0
    def setUp(self):
        if TEST_SETTINGS["version"] in ["2014", "2016", "2019", "365"]:
            version = Version.v2016
        else:
            version = Version.v2007

        if TEST_SETTINGS["version"] == "365":
            authcookie = Office365(TEST_SETTINGS["server_url"],
                                   username=TEST_SETTINGS["username"],
                                   password=TEST_PASSWORD).GetCookies()
            self.site = Site(TEST_SETTINGS["site_url"],
                             version=version,
                             authcookie=authcookie)
        else:
            auth = HttpNtlmAuth(TEST_SETTINGS["username"], TEST_PASSWORD)
            self.site = Site(TEST_SETTINGS["site_url"],
                             version=version,
                             auth=auth)
        self.test_list = TEST_SETTINGS["test_list"]
コード例 #15
0
ファイル: bot_dialog.py プロジェクト: hlezama001/PythonBot
from botbuilder.core import TurnContext, ActivityHandler, ConversationState, MessageFactory
from botbuilder.dialogs import DialogSet, WaterfallDialog, WaterfallStepContext
from botbuilder.dialogs.prompts import TextPrompt, NumberPrompt, PromptOptions, ChoicePrompt
from botbuilder.dialogs.choices import Choice
import requests
import pymsteams
from shareplum import Site
from shareplum import Office365
from shareplum.site import Version

sharepointUsername = "******"
sharepointPassword = "******"
sharepointSite = "https://azdemoclient01.sharepoint.com/sites/site0"
website = "https://azdemoclient01.sharepoint.com"
authcookie = Office365(website,
                       username=sharepointUsername,
                       password=sharepointPassword).GetCookies()
site = Site(sharepointSite, version=Version.v2016, authcookie=authcookie)


class BotDialog(ActivityHandler):
    def __init__(self, conversation: ConversationState):
        self.con_statea = conversation
        self.state_prop = self.con_statea.create_property("dialog_set")
        self.dialog_set = DialogSet(self.state_prop)
        self.dialog_set.add(TextPrompt("text_prompt"))
        self.dialog_set.add(NumberPrompt("number_prompt"))
        self.dialog_set.add(ChoicePrompt(ChoicePrompt.__name__))
        self.dialog_set.add(
            WaterfallDialog("main_dialog", [
                self.GetUserName, self.DisplayChoiceList, self.GetProblem,
コード例 #16
0
from shareplum import Site
from shareplum import Office365
from shareplum.site import Version

# DICT WITH THE INFO THAT YOU NEED TO FILL THE FORM INTO THE LIST
upload_dict = {"ID":4,"ClientName":"JOHN RED","StreetAdrress":"120 BROADWAY","Created":"2020-05-05"}

# Authenticate to Office365 Sharepoint
authcookie = Office365('https://YOUR-NAME.sharepoint.com', username='******',password='******').GetCookies()
site = Site('https://YOUR-NAME.sharepoint.com/sites/YOUR-SITE/', version=Version.v2016, authcookie=authcookie)
sp_list = site.List('YOUR-LIST')

# GET ALL LIST EXIST OF MY ACCOUNT
sp_data = sp_list.GetListItems()

# CHECK IF LIST IS ALREADY EXIST
sp_dataListItems = sp_list.GetListItems(fields=['ID', 'Title'])
for spResultData in sp_dataListItems:
    id = spResultData.get("ID")
    Title = spResultData.get("Title")

# IF ALREADY EXIST MADE UPDATE OF THE LIST IF DOESNT EXIST MADE NEW LIST
    if id == "1" and Title == 'TEST':
        update_date = [upload_dict]
        sp_list.UpdateListItems(data=update_date, kind='Update')
    else:
        update_date = [upload_dict]
        sp_list.UpdateListItems(data=update_date, kind='New')
コード例 #17
0
import requests
from shareplum import Office365
from config import config

# get data from configuration
username = config['sp_user']
password = config['sp_password']
site_name = config['sp_site_name']
base_path = config['sp_base_path']
doc_library = config['sp_doc_library']

file_name = "cat_pic.jpg"

# Obtain auth cookie
authcookie = Office365(base_path, username=username, password=password).GetCookies()
session = requests.Session()
session.cookies = authcookie
session.headers.update({'user-agent': 'python_bite/v1'})
session.headers.update({'accept': 'application/json;odata=verbose'})


# perform the actual upload
with open( file_name, 'rb') as file_input:
    try: 
        response = session.post( 
            url=base_path + "/sites/" + site_name + "/Shared%20Documents/Forms/AllItems.aspx/_api/web/GetFolderByServerRelativeUrl('" + doc_library + "')/Files/add(url='" 
            + file_name + "',overwrite=true)",
            data=file_input)
    except Exception as err: 
        print("Some error occurred: " + str(err))
コード例 #18
0
#Python package for geocode location
from geopy.geocoders import Nominatim
geolocator = Nominatim(user_agent="Simple Application")

#Sharepoint site information
server_url = "https://ytpl.sharepoint.com"
site_url = "https://ytpl.sharepoint.com/sites/demosite/PowerApps/"

username = ""
passwd = ""
leave_balance_list = 'lm_emp_leave_balance_record'
leave_records_list = 'lm_employee_leave_record'

#Get Authentication cookies
authcookie = Office365(server_url, username=username,
                       password=passwd).GetCookies()
site = Site(site_url, authcookie=authcookie)

#Get all the data from sharepoint list which holds employess leave balance record
sp_list = site.List(leave_balance_list)

#Get all the data from sharepoint list which holds employees leave records
leave_records = site.List(leave_records_list)

# Create an object of Flask Class  and configure it run in debug mode
app = flask.Flask(__name__)
app.config["DEBUG"] = True


#------------------------------------------------------------------------------------------------------
#Route to get leave balance based on user id (email address - for example [email protected]"
コード例 #19
0

class Request(object):
    def __init__(self, name, item):
        self.name = name
        self.item = item
        self.email = ""


user = config('iptvmail')

pwd = config('pwd')

emailist = []
authcookie = Office365('https://reutlingenuniversityde.sharepoint.com/',
                       username=config('username'),
                       password=config('password')).GetCookies()
site = Site('https://reutlingenuniversityde.sharepoint.com/sites/Test01',
            authcookie=authcookie)

sp_list = site.List('KK_Test_List_01')
sp_list1 = site.List('Taschen_Liste')
fields = ['Person', 'Item']
fields1 = ['Person', 'Tasche']
query = {'Where': [('Lt', 'EndDate', str(date.today()))]}

data = pd.DataFrame(sp_list.GetListItems(fields=fields,
                                         query=query)[0:]).dropna(thresh=1)

data1 = pd.DataFrame(sp_list1.GetListItems(fields=fields1,
                                           query=query)[0:]).dropna(thresh=1)
コード例 #20
0
# -*- coding: utf-8 -*-
"""
Created on Thu Feb 20 11:22:12 2020

@author: FL014036

"*****@*****.**", "P@$$word"
"""

from shareplum import Site
from shareplum import Office365
import pandas as pd

authcookie = Office365('https://cocacolaflorida.sharepoint.com',
                       username='******',
                       password='******').GetCookies()
site = Site('https://cocacolaflorida.sharepoint.com/Distribution/',
            authcookie=authcookie)
sp_list = site.List('Hazardous Material Disclosure Statement')
data = sp_list.GetListItems()

data_df = pd.DataFrame(data)

data_df = data_df[['Date', 'Drivers Name', 'Shipment number', 'DSD Location']]
コード例 #21
0
from flask import Flask, jsonify, render_template, request
import pandas as pd
import pymysql
from sqlalchemy import create_engine
pymysql.install_as_MySQLdb()
from shareplum import Site
import json
from shareplum import Office365
from flask_wtf.csrf import CSRFProtect
csrf = CSRFProtect()
app = Flask(__name__)
csrf.init_app(app)
app.config['SECRET_KEY'] = 'venkata789123'
authcookie = Office365('https://svm12.sharepoint.com',
                       username='******',
                       password='******').GetCookies()
site = Site('https://svm12.sharepoint.com/sites/GENIV', authcookie=authcookie)


def connect_site():
    return site


@app.route('/label_new', methods=['GET', 'POST'])
def labelmatrix_new():
    site = connect_site()
    program = site.List('GENIV_Product_ADB2')
    feature = site.List('GENIV Features_ADB2')
    rel_name = site.List('GENIV Releases_ADB2')
    program_data = program.GetListItems('All Items')
    feature_data = feature.GetListItems('All Items')
    x['Achieved result'] = x['Achieved result'].fillna(0)
    x['Achieved result'] = x['Achieved result'].replace([''], 0)

    ##GMS code
    x['GMS Code'] = x[['Indicator code',
                       'GMS Code']].apply(lambda x: fix_gms(*x), axis=1)

    #Export to Excel file
    output_data = pd.concat([output_data, x])
    output_data.to_excel('Output.xlsx', index=False)

#upload to sharepoint online
#load libraries needed for sharepoint upload
from shareplum import Site
from shareplum import Office365
from shareplum.site import Version

import pandas as pd
#setup access to sharepoint online
authcookie = Office365('https://urlname.sharepoint.com',
                       username='******',
                       password='******').GetCookies()
site = Site('https://urlname.sharepoint.com/sites/',
            version=Version.v2016,
            authcookie=authcookie)
folder = site.Folder('Shared Documents/Folder/')

with open('Output.xlsx', mode='rb') as file:
    fileContent = file.read()
folder.upload_file(fileContent, "Output.xlsx")
コード例 #23
0
ファイル: sharepoint.py プロジェクト: seliger/splistutils
 def __login(self, sharepoint_url, username, password):
     authcookie = Office365(sharepoint_url, username=username, password=password).GetCookies()
     return authcookie
コード例 #24
0
from config import config
from shareplum import Site
from shareplum import Office365
from shareplum.site import Version

# get data from configuration
username = config['sp_user']
password = config['sp_password']

authcookie = Office365('https://xxxxxx.sharepoint.com', username=username, password=password).GetCookies()

site = Site('https://xxxxxx.sharepoint.com/sites/sbdev/subtest01',version=Version.v365, authcookie=authcookie)

newlist=site.AddList('My New List', description='Great List!', template_id='Document Library')

print(newlist)
コード例 #25
0
import requests
from shareplum import Office365

# Obtain auth cookie
authcookie = Office365('https://gruposimbio.sharepoint.com/sites/dev',
                       username='******',
                       password='******').GetCookies()
session = requests.Session()
session.cookies = authcookie
session.headers.update({'user-agent': 'python_bite/v1'})
session.headers.update({'accept': 'application/json;odata=verbose'})
コード例 #26
0
 def __init__(self, url, folder_path, username, password):
     self.folder_path = folder_path
     authcookie = Office365(url, username=username,
                            password=password).GetCookies()
     self.site = Site(site_url=url, authcookie=authcookie)
コード例 #27
0
from sys import argv
from timeit import default_timer as timer
import time
from datetime import datetime

# Starting the timer
start = timer()

# Decoding the Sharepoint and SQL passwords
pwd = E.decrypt(secret.sharepoint_password.encode("utf-8"))
pwd1 = E.decrypt(secret.password.encode("utf-8"))
# Printing to the console for easy debugging.
print("Starting......................\n")
# setting up the connection and authentication to sharepint site
authcookie = Office365('https://foundationriskpartners.sharepoint.com',
                       username=secret.sharepoint_username,
                       password=pwd).GetCookies()


def MetaData():
    '''This function retreive metadat from the admin sharepoint list where there we specify the source SQL table and destination sharepoint list'''
    # Connecting to the Sharepoint site where the Sharepoint_Admin lists lives.
    site1 = Site(
        f'https://foundationriskpartners.sharepoint.com.us3.cas.ms/sites/bidash/',
        authcookie=authcookie)
    # Reading The Sharepoiny admin input
    global sp_list
    sp_list = site1.List('Adm SqlToSharepoint')
    # Reading the last records in the SQltoshqrepoint list (one sql table at time )
    data = sp_list.GetListItems('All Items')
    return data
コード例 #28
0
emp_mgt_classes = ['M/P Management', 'Executive', 'Faculty', 'Management']
emp_classes = [
    'Resident', 'Professional', 'Police/Fire Hourly', 'Fellowship Pre Doc',
    'Post Doc', 'LTD', 'PAA/PRF/PolyTech', 'Police/Fire BW Sal',
    'Police/Fire Admin', 'Non-Pay', 'Continuing Lecturer', 'Visiting Faculty',
    'Graduate Student', 'Temporary', 'Police/Fire Mgmt',
    'Limited Term Lecturer', 'M/P Professional', 'Service', 'Support',
    'Clinical/Research', 'Intern', 'Residence Hall Counselor', 'Student'
]

logging.info('Starting up...')

fake = Faker()

authcookie = Office365('https://purdue0.sharepoint.com',
                       username='',
                       password='').GetCookies()
site = Site('https://purdue0.sharepoint.com/sites/HRIS',
            version=Version.o365,
            authcookie=authcookie)

test_list = site.List('ELT-Test')

employees = []
supervisor = None
count = 0
for x in range(1, 10001):
    if supervisor == None or x % randint(3, 7) == 0:
        # print ("SUPER: {}\t COUNT: {}".format(supervisor, str(count)))
        count = 1
        supervisor = fake.name()
コード例 #29
0
from shareplum import Site
from shareplum import Office365
from shareplum.site import Version
import json
import os

wd = os.getcwd()
json_path = os.path.join(wd, "src", "authentification",
                         "sharepoint_authentification.json")

with open(json_path, "r") as read_file:
    sp_auth = json.load(read_file)

authcookie = Office365(sp_auth["url"],
                       username=sp_auth["username"],
                       password=sp_auth['password']).GetCookies()
site = Site(sp_auth["url_site"], version=Version.v2016, authcookie=authcookie)
folder = site.Folder('Github_upload')

csv_path = os.path.join(wd, "src", "data", "51427.csv")
with open(csv_path, 'r', encoding="Latin-1") as file:
    data = file.read()

folder.upload_file(data, "51427.csv")
コード例 #30
0
from shareplum import Site
from shareplum import Office365
from shareplum.site import Version
import os
import sys

authcookie = Office365('https://yourcompany.atsharepoint.com',
                       username='******',
                       password='******').GetCookies()
site = Site('https://yourcompany.atsharepoint.com/sites/Your-Sites',
            version=Version.v2019,
            authcookie=authcookie)  # set the version if necessary

for root, subdirs, files in os.walk('/path/to/root/dir'):
    dest_folder = root.split('/path/to/root')[
        1]  # this will get directory after /path/to/dir and its subdir
    folder = site.Folder(
        'Shared Document/your_dir_ifany/%s' % dest_folder
    )  # this set destination directory or will create directory in sharepoint if doesn't exist
    for fname in files:
        fullfname = os.path.join(root,
                                 fname)  # get the full path of source file
        with open(fullfname, mode='rb') as file:  # read the file in binary
            fileContent = file.read()
        folder.upload_file(fileContent, fname)  # upload the file