def reminder(date, slot): creds = None # The file token.pickle stores the user's access and refresh tokens, and is # created automatically when the authorization flow completes for the first # time. if os.path.exists('token.pickle'): with open('token.pickle', 'rb') as token: creds = pickle.load(token) # If there are no (valid) credentials available, let the user log in. if not creds or not creds.valid: if creds and creds.expired and creds.refresh_token: creds.refresh(Request()) else: flow = InstalledAppFlow.from_client_secrets_file( 'credentials.json', SCOPES) creds = flow.run_local_server(port=0) # Save the credentials for the next run with open('token.pickle', 'wb') as token: pickle.dump(creds, token) service = build('calendar', 'v3', credentials=creds) event = { 'summary': 'appointment with doctor', 'location': '', 'description': 'visit doctor and get yourself checked', 'start': { 'dateTime': '2020-05-11T09:00:30-00:30', 'timeZone': 'America/Los_Angeles', }, 'end': { 'dateTime': '2020-05-11T09:00:30-00:30', 'timeZone': 'America/Los_Angeles', }, 'recurrence': [''], 'attendees': [{ 'email': '*****@*****.**' }], 'reminders': { 'useDefault': False, 'overrides': [ { 'method': 'email', 'minutes': 24 * 60 }, { 'method': 'popup', 'minutes': 10 }, ], }, } try: event = service.events().insert(calendarId='primary', body=event).execute() print('Event created: %s' % (event.get('htmlLink'))) return "event created" except: return "something went wrong"
def save(data): emails = [] SCOPES = ['https://www.googleapis.com/auth/drive.file'] print('\nPlease select a method to save your lecture links:') if os.path.exists('token.json'): with open('token.json', 'r') as preferences: users = json.load(preferences) emails = users["emails"] for user in range(len(emails)): print( f'{user + 1}. Upload to Google Drive as a Spreadsheet ({emails[user]})' ) choice = int( input( f'{len(emails) + 1}. Upload to Google Drive as a Spreadsheet{" (Use another account)" if emails else ""}\n{len(emails) + 2}. Save locally as a CSV file\nChoose: ' )) if choice <= len(emails): creds = Credentials.from_authorized_user_info( users['tokens'][choice - 1], SCOPES) if creds.expired and creds.refresh_token: creds.refresh(Request()) users['tokens'][choice - 1] = json.loads(creds.to_json()) with open('token.json', 'w') as token: token.write(json.dumps(users)) service = build('drive', 'v3', credentials=creds) elif choice == 1 or choice == (len(emails) + 1): print('Opening authorization window...') client_credentials = { "installed": { "client_id": "292011036249-a6r9097a7q4216d0copqhdbkon3flsa5.apps.googleusercontent.com", "project_id": "lecture-links-collector", "auth_uri": "https://accounts.google.com/o/oauth2/auth", "token_uri": "https://oauth2.googleapis.com/token", "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs", "client_secret": "qRsAEyh_9ddbzoLGMIM989_m", "redirect_uris": ["urn:ietf:wg:oauth:2.0:oob", "http://localhost"] } } flow = InstalledAppFlow.from_client_config(client_credentials, SCOPES) creds = flow.run_local_server( port=0, authorization_prompt_message= 'Please authorize Lecture Links Collector at this URL: {url}', success_message= 'Thank you for the authorization. Please close this window and return to the program.' ) print('Authorization Completed') service = build('drive', 'v3', credentials=creds) email_address = service.about().get( fields='user(emailAddress)').execute()['user']['emailAddress'] if emails: users['emails'].append(email_address) users['tokens'].append(json.loads(creds.to_json())) else: users = { 'tokens': [json.loads(creds.to_json())], 'emails': [email_address] } with open('token.json', 'w') as token: token.write(json.dumps(users)) else: filename = input(f"Save As(Enter filename/path without extension): " ).strip().replace('\\\\', '\\') with open(filename + '.csv', 'w') as f: f.write(data) print( f'File \'{filename}\' has been successfully locally saved as a CSV File.' ) return print( 'NOTE: You will now be asked to enter a desired name for your lecture links file. If you want to update an older file instead of creating a new file, just write the name of that old file.' ) filename = input("Save As(Enter filename without extension): ").strip() media = MediaIoBaseUpload(io.BytesIO(data.encode('utf-8')), mimetype='text/csv') files_on_drive = service.files().list(q = f"name = '{filename}'", fields = 'files(id, name, webViewLink, createdTime, viewedByMeTime, owners(emailAddress))') \ .execute().get('files') if files_on_drive: print( 'Some existing files with the same name have been found in your drive. Enter the corresponding number to the file description', 'to update that particular file or create a new file.') for f in range(len(files_on_drive)): print(( f'{f + 1}. NAME: {files_on_drive[f]["name"]} OWNER: {files_on_drive[f]["owners"][0]["emailAddress"]}\n' f' CREATED ON: {convert_to_ist(files_on_drive[f]["createdTime"].rstrip("Z"))} ' f'LAST VIEWED BY YOU ON: {convert_to_ist(files_on_drive[f]["viewedByMeTime"].rstrip("Z"))}\n' f' LINK: {files_on_drive[f]["webViewLink"]}')) choice = int( input(f'{len(files_on_drive) + 1}. Create new file\nChoose: ')) if choice != (len(files_on_drive) + 1): print('Updating file...') result = service.files().update( fileId=files_on_drive[choice - 1]['id'], media_body=media, fields='id, name, createdTime, webViewLink').execute() print( f'UPDATE SUCCESSFUL\nFile \'{result["name"]}\' that was created on {convert_to_ist(result["createdTime"].rstrip("Z"))} has been successfully updated on your drive account. \ \nLink to the file: {result["webViewLink"]}') return print('Uploading file...') metadata = { 'name': filename, 'mimeType': 'application/vnd.google-apps.spreadsheet' } result = service.files().create( body=metadata, media_body=media, fields='id, name, webViewLink, createdTime').execute() print( f'UPLOAD SUCCESSFUL\nFile \'{result["name"]}\' has been successfully created on your drive account on {convert_to_ist(result["createdTime"].rstrip("Z"))}. \ \nLink to the file: {result["webViewLink"]}')
def cal(): """Shows basic usage of the Google Calendar API. Prints the start and name of the next 10 events on the user's calendar. """ creds = None # The file token.pickle stores the user's access and refresh tokens, and is # created automatically when the authorization flow completes for the first # time. if os.path.exists('token.pickle'): with open('token.pickle', 'rb') as token: creds = pickle.load(token) # If there are no (valid) credentials available, let the user log in. if not creds or not creds.valid: if creds and creds.expired and creds.refresh_token: creds.refresh(Request()) else: flow = InstalledAppFlow.from_client_secrets_file( 'credentials.json', SCOPES) creds = flow.run_local_server(port=0) # Save the credentials for the next run with open('token.pickle', 'wb') as token: pickle.dump(creds, token) service = build('calendar', 'v3', credentials=creds) # Call the Calendar API now = datetime.datetime.utcnow().isoformat() + 'Z' # 'Z' indicates UTC time # ------------- Calling the calendar -------------- print('Printing events from', cal_name) events_result = service.events().list(calendarId=calid, timeMin=now, maxResults=100, singleEvents=True, orderBy='startTime').execute() events = events_result.get('items', []) #---------------- Deleting ALL EVENTS ---------------------- for event in events: service.events().delete(calendarId=cal_id, eventId=event['id']).execute() #---------------- Creating EVENTS ---------------------- event = { 'summary': ' Papa', 'description': 'TNM', 'location': 'TNM', 'start': { 'dateTime': '2020-01-27T09:00:00', 'timeZone': 'America/Toronto', }, 'end': { 'dateTime': '2020-01-27T17:10:00', 'timeZone': 'America/Toronto', } } event = service.events().insert(calendarId=cal_id, body=event).execute() # print('Event created: %s' % (event.get('htmlLink'))) #---------------- Printing EVENTS ---------------------- if not events: print('No upcoming events found.') for event in events: start = event['start'].get('dateTime', event['start'].get('date'))
def callCalenderAPI(): """Shows basic usage of the Google Calendar API. Prints the start and name of the next 10 events on the user's calendar. """ creds = None # The file token.pickle stores the user's access and refresh tokens, and is # created automatically when the authorization flow completes for the first # time. if os.path.exists('token.pickle'): with open('token.pickle', 'rb') as token: creds = pickle.load(token) # If there are no (valid) credentials available, let the user log in. if not creds or not creds.valid: if creds and creds.expired and creds.refresh_token: creds.refresh(Request()) else: flow = InstalledAppFlow.from_client_secrets_file( 'credentials.json', SCOPES) creds = flow.run_local_server(port=0) # Save the credentials for the next run with open('token.pickle', 'wb') as token: pickle.dump(creds, token) service = build('calendar', 'v3', credentials=creds) # Call the Calendar API now = datetime.utcnow().isoformat() + 'Z' # 'Z' indicates UTC time print('Getting the upcoming 10 events') events_result = service.events().list(calendarId='primary', timeMin=now, maxResults=10, singleEvents=True, orderBy='startTime').execute() events = events_result.get('items', []) today_events = [] if not events: print('No upcoming events found.') for event in events: start = event['start'].get('dateTime', event['start'].get('date')) # print(start.split("T"), event['summary'], event["colorId"]) event_date = start.split("T")[0].split("-") # print(event_date) dt = datetime.today() if (str(dt.year) == event_date[0] and str(dt.month) == event_date[1] and str(dt.day) == event_date[2]): # if (event_date[2] == '25'): print("added todays event") colour = None try: colour = event["colorId"] except: colour = '7' today_events.append({ "datetime": { "date": start.split("T")[0], "time": start.split("T")[1] }, "event": event['summary'], "colour": colour }) if not today_events: today_events = None return today_events
def __init__(self, credentials_file=os.path.join(os.path.expanduser('~'), '.config', 'google-oauthlib-tool', 'credentials.json'), device_config=os.path.join(os.path.expanduser('~'), '.config', 'googlesamples-assistant', 'device_config.json'), language='en-US', play_response=True, tts_plugin=None, tts_args=None, **kwargs): """ :param credentials_file: Path to the Google OAuth credentials file (default: ~/.config/google-oauthlib-tool/credentials.json). See https://developers.google.com/assistant/sdk/guides/library/python/embed/install-sample#generate_credentials for instructions to get your own credentials file. :type credentials_file: str :param device_config: Path to device_config.json. Register your device (see https://developers.google.com/assistant/sdk/guides/library/python/embed/register-device) and create a project, then run the pushtotalk.py script from googlesamples to create your device_config.json :type device_config: str :param language: Assistant language (default: en-US) :type language: str :param play_response: If True (default) then the plugin will play the assistant response upon processed response. Otherwise nothing will be played - but you may want to handle the ``ResponseEvent`` manually. :type play_response: bool :param tts_plugin: Optional text-to-speech plugin to be used to process response text. :type tts_plugin: str :param tts_args: Optional arguments for the TTS plugin ``say`` method. :type tts_args: dict """ import googlesamples.assistant.grpc.audio_helpers as audio_helpers super().__init__(**kwargs) self.audio_sample_rate = audio_helpers.DEFAULT_AUDIO_SAMPLE_RATE self.audio_sample_width = audio_helpers.DEFAULT_AUDIO_SAMPLE_WIDTH self.audio_iter_size = audio_helpers.DEFAULT_AUDIO_ITER_SIZE self.audio_block_size = audio_helpers.DEFAULT_AUDIO_DEVICE_BLOCK_SIZE self.audio_flush_size = audio_helpers.DEFAULT_AUDIO_DEVICE_FLUSH_SIZE self.language = language self.credentials_file = credentials_file self.device_config = device_config self.play_response = play_response self.tts_plugin = tts_plugin self.tts_args = tts_args or {} self.assistant = None self.interactions = [] with open(self.device_config) as f: device = json.load(f) self.device_id = device['id'] self.device_model_id = device['model_id'] # Load OAuth 2.0 credentials. try: from google.oauth2.credentials import Credentials from google.auth.transport.requests import Request with open(self.credentials_file, 'r') as f: self.credentials = Credentials(token=None, **json.load(f)) self.http_request = Request() self.credentials.refresh(self.http_request) except Exception as ex: self.logger.error('Error loading credentials: %s', str(ex)) self.logger.error('Run google-oauthlib-tool to initialize ' 'new OAuth 2.0 credentials.') raise self.grpc_channel = None self.conversation_stream = None
def make_iap_request(url, client_id, method='GET', **kwargs): """Makes a request to an application protected by Identity-Aware Proxy. Args: url: The Identity-Aware Proxy-protected URL to fetch. client_id: The client ID used by Identity-Aware Proxy. method: The request method to use ('GET', 'OPTIONS', 'HEAD', 'POST', 'PUT', 'PATCH', 'DELETE') **kwargs: Any of the parameters defined for the request function: https://github.com/requests/requests/blob/master/requests/api.py Returns: The page body, or raises an exception if the page couldn't be retrieved. """ # Figure out what environment we're running in and get some preliminary # information about the service account. bootstrap_credentials, _ = google.auth.default( scopes=[IAM_SCOPE]) if isinstance(bootstrap_credentials, google.oauth2.credentials.Credentials): raise Exception('make_iap_request is only supported for service ' 'accounts.') elif isinstance(bootstrap_credentials, google.auth.app_engine.Credentials): requests_toolbelt.adapters.appengine.monkeypatch() # For service account's using the Compute Engine metadata service, # service_account_email isn't available until refresh is called. bootstrap_credentials.refresh(Request()) signer_email = bootstrap_credentials.service_account_email if isinstance(bootstrap_credentials, google.auth.compute_engine.credentials.Credentials): # Since the Compute Engine metadata service doesn't expose the service # account key, we use the IAM signBlob API to sign instead. # In order for this to work: # # 1. Your VM needs the https://www.googleapis.com/auth/iam scope. # You can specify this specific scope when creating a VM # through the API or gcloud. When using Cloud Console, # you'll need to specify the "full access to all Cloud APIs" # scope. A VM's scopes can only be specified at creation time. # # 2. The VM's default service account needs the "Service Account Actor" # role. This can be found under the "Project" category in Cloud # Console, or roles/iam.serviceAccountActor in gcloud. signer = google.auth.iam.Signer( Request(), bootstrap_credentials, signer_email) else: # A Signer object can sign a JWT using the service account's key. signer = bootstrap_credentials.signer # Construct OAuth 2.0 service account credentials using the signer # and email acquired from the bootstrap credentials. service_account_credentials = google.oauth2.service_account.Credentials( signer, signer_email, token_uri=OAUTH_TOKEN_URI, additional_claims={ 'target_audience': client_id }) # service_account_credentials gives us a JWT signed by the service # account. Next, we use that to obtain an OpenID Connect token, # which is a JWT signed by Google. google_open_id_connect_token = get_google_open_id_connect_token( service_account_credentials) # Fetch the Identity-Aware Proxy-protected URL, including an # Authorization header containing "Bearer " followed by a # Google-issued OpenID Connect token for the service account. resp = requests.request( method, url, headers={'Authorization': 'Bearer {}'.format( google_open_id_connect_token)}, **kwargs) if resp.status_code == 403: raise Exception('Service account {} does not have permission to ' 'access the IAP-protected application.'.format( signer_email)) elif resp.status_code != 200: raise Exception( 'Bad response from application: {!r} / {!r} / {!r}'.format( resp.status_code, resp.headers, resp.text)) else: return resp.text
def wrapper(*args): self: SheetHandler = args[0] if stripped_utcnow() > self.expiry: self.auth.refresh(Request()) return func(*args)
def getCalendarEvents(): """Shows basic usage of the Google Calendar API. Prints the start and name of the next 10 events on the user's calendar. """ creds = None # The file token.pickle stores the user's access and refresh tokens, and is # created automatically when the authorization flow completes for the first # time. if os.path.exists('.credentials/token.pickle'): with open('.credentials/token.pickle', 'rb') as token: creds = pickle.load(token) # If there are no (valid) credentials available, let the user log in. if not creds or not creds.valid: if creds and creds.expired and creds.refresh_token: creds.refresh(Request()) else: flow = InstalledAppFlow.from_client_secrets_file( '.credentials/credentials.json', SCOPES) creds = flow.run_local_server(port=0) # Save the credentials for the next run with open('.credentials/token.pickle', 'wb') as token: pickle.dump(creds, token) service = build('calendar', 'v3', credentials=creds) # Call the Calendar API now = datetime.datetime.utcnow().isoformat( ) + 'Z' # 'Z' indicates UTC time # print('Getting the upcoming 10 events') events_result = service.events().list(calendarId='primary', timeMin=now, maxResults=10, singleEvents=True, orderBy='startTime').execute() events = events_result.get('items', []) if not events: print('No upcoming events found.') for event in events: startTimeStr = (event['start'].get('dateTime', event['start'].get('date')))[:-6] descLength = len(event['description']) # get the meeting ID meetingIDIndexStart = int(event['description'].find('Meeting ID:')) meetingIDIndexEnd = meetingIDIndexStart + len('Meeting ID:') meetingIDStarted = False meetingIDExists = False meetingID = '' while meetingIDIndexEnd < descLength: # read only number occuring after meetingIDIndexEnd nextOccurringCharacter = event['description'][meetingIDIndexEnd] meetingIDIndexEnd += 1 if nextOccurringCharacter.isnumeric(): meetingIDStarted = True meetingID += nextOccurringCharacter elif nextOccurringCharacter is '<' and meetingIDStarted is True: break if meetingID is not '': meetingIDExists = True meetingID = int(meetingID) # getting meeting password meetingPasswordIndexStart = int(event['description'].find('Passcode:')) meetingPasswordIndexEnd = meetingPasswordIndexStart + len('Passcode:') meetingPasswordStarted = False meetingPasswordExists = False meetingPassword = '' while meetingPasswordIndexEnd < descLength: # read only alphanumeric occuring after meetingPasswordIndexEnd nextOccurringCharacter = event['description'][ meetingPasswordIndexEnd] meetingPasswordIndexEnd += 1 if nextOccurringCharacter.isalnum(): meetingPasswordStarted = True meetingPassword += nextOccurringCharacter elif nextOccurringCharacter is '\n' and meetingPasswordStarted is True: break # getting meeting password meetingLinkIndexStart = int( event['description'].find('Join Zoom Meeting')) meetingLinkIndexEnd = meetingLinkIndexStart + len( 'Join Zoom Meeting') + 13 meetingLinkStarted = False meetingLinkExists = False meetingLink = '' # print(event['description']) while meetingLinkIndexEnd < meetingIDIndexStart: # read only alphanumeric occuring after meetingLinkIndexEnd nextOccurringCharacter = event['description'][meetingLinkIndexEnd] meetingLinkIndexEnd += 1 if nextOccurringCharacter == '<': while event['description'][meetingLinkIndexEnd] != '>': meetingLinkIndexEnd += 1 meetingLinkIndexEnd += 1 elif nextOccurringCharacter == '"' and meetingLinkStarted is True: break else: meetingLinkStarted = True meetingLink += nextOccurringCharacter print(meetingLink) if meetingIDExists is True: meetings[event['summary']] = { 'Time': datetime.datetime.strptime(startTimeStr, '%Y-%m-%dT%H:%M:%S'), 'Meeting ID': meetingID, 'Link': meetingLink, 'Password': meetingPassword }
def main(): """Shows basic usage of the Drive v3 API. Prints the names and ids of the first 10 files the user has access to. """ creds = None # The file token.pickle stores the user's access and refresh tokens, and is # created automatically when the authorization flow completes for the first # time. if os.path.exists('token.pickle'): with open('token.pickle', 'rb') as token: creds = pickle.load(token) # If there are no (valid) credentials available, let the user log in. if not creds or not creds.valid: if creds and creds.expired and creds.refresh_token: creds.refresh(Request()) else: flow = InstalledAppFlow.from_client_secrets_file( 'credentials.json', SCOPES) creds = flow.run_local_server() # Save the credentials for the next run with open('token.pickle', 'wb') as token: pickle.dump(creds, token) service = build('drive', 'v3', credentials=creds) # # Call the Drive v3 API # results = service.files().list( # pageSize=1000, fields="nextPageToken, files(id, name)").execute() # items = results.get('files', []) # all_files = [] # if not items: # print('No files found.') # else: # print('Files:') # for item in items: # print(u'{0} ({1})'.format(item['name'], item['id'])) # all_files.append((item['name'], item['id'])) # return all_files page_token = None all_files = [] while True: response = service.files().list( pageSize=1000, q="'184b0EFkuuI1nbeXQZACxQEcJlwzzPyvh' in parents", pageToken=page_token, fields="nextPageToken, files(id, name)").execute() items = response.get('files', []) if not items: print('No files found') else: for item in items: # print('Found file: %s (%s)' % (item['name'], item['id'])) all_files.append((item['name'], item['id'])) all_files = list(set(all_files)) print(len(all_files)) page_token = response.get('nextPageToken', None) print('next page token', page_token) if page_token is None: break return all_files
def main(): """Shows basic usage of the Admin SDK Directory API. Prints the emails and names of the first 10 users in the domain. """ creds = None # The file token.pickle stores the user's access and refresh tokens, and is # created automatically when the authorization flow completes for the first # time. if os.path.exists('token.pickle'): with open('token.pickle', 'rb') as token: creds = pickle.load(token) # If there are no (valid) credentials available, let the user log in. if not creds or not creds.valid: if creds and creds.expired and creds.refresh_token: creds.refresh(Request()) else: flow = InstalledAppFlow.from_client_secrets_file( 'credentials.json', SCOPES) creds = flow.run_local_server(port=0) # Save the credentials for the next run with open('token.pickle', 'wb') as token: pickle.dump(creds, token) # delete unused users service = build('admin', 'directory_v1', credentials=creds) page_token = None params = {'customer': 'my_customer'} page = 0 users_total = 0 while True: try: if page_token: params['pageToken'] = page_token current_page = service.users().list(**params).execute() users = current_page.get('users', []) if not users: print('No users in the domain.') break else: users_total = users_total + len(users) print('Users page: ', page) for user in users: last_login_time = datetime.strptime(user['lastLoginTime'], '%Y-%m-%dT%H:%M:%S.%fz') # here go the date if last_login_time < datetime(2016, 1, 1): print('delete mail') print(user['primaryEmail']) service.users().delete(userKey=user['id']).execute() page_token = current_page.get('nextPageToken') page = page + 1 if not page_token: break except: print('errors') break print(users_total)
def main(): # A quick check to see if the token already exists. if (not (path.exists("token.pickle"))): tkinter.messagebox.showinfo( "Excel to Google Event", "You will be prompted to login & give permission to Google Cal") #This is taken directly from the Google API Quickstart guide """Shows basic usage of the Google Calendar API. """ creds = None # The file token.pickle stores the user's access and refresh tokens, and is # created automatically when the authorization flow completes for the first # time. if os.path.exists('token.pickle'): with open('token.pickle', 'rb') as token: creds = pickle.load(token) # If there are no (valid) credentials available, let the user log in. if not creds or not creds.valid: if creds and creds.expired and creds.refresh_token: creds.refresh(Request()) else: flow = InstalledAppFlow.from_client_secrets_file( 'credentials.json', SCOPES) creds = flow.run_local_server(port=0) # Save the credentials for the next run with open('token.pickle', 'wb') as token: pickle.dump(creds, token) #Here the service is built with credentials & we can move on to creating the event service = build('calendar', 'v3', credentials=creds) #Build gspread client = gspread.authorize(creds) #Open gspread gsheet = client.open("Nexus Recording Schedule - Master") gworksheet = gsheet.worksheet("2-Schedule Recording-Instructional Day") #Init & print list of Cals calHolder = [] page_token = None while True: calendar_list = service.calendarList().list(pageToken=page_token).execute() for calendar_list_entry in calendar_list['items']: print (calendar_list_entry['summary']) calHolder.append({"in": calendar_list_entry['summary'], "cal_id":calendar_list_entry['id']}) page_token = calendar_list.get('nextPageToken') if not page_token: break #Append to single string in order to display in msgbox cal_msg = "Please match the numbers for the Calendars for each location, if no match exists enter \'-1\' " + '\n' + "Calanders on your account: " + '\n' cal_msg2 = '\n' index = 0 for dicts in calHolder: msg = '\n' + ' [ ' + str(index) + ' ]: ' + dicts["in"] + ' ' cal_msg2 += msg index += 1 #Adding on sheets service sheets_service = build('sheets', 'v4', credentials=creds) #Prompt user for selection via messagebox cal_msg2 += '\n' print(cal_msg) print(cal_msg2) USER_INP = -1 #Yes this is janky/bad code, but I mean cmon sheet3 = sheets_service.spreadsheets() result3 = sheet3.values().get(spreadsheetId=SPREADSHEET_ID, range=INSTRUCTORS_SHEET_RANGE).execute() values3 = result3.get('values', []) for row in values3: if (len(row) >= 5): print(row[4]) if (len(row) >= 16): print(" MGR: " + row[15]) if (len(row) >= 17): print(" IPS: " + row[16]) if (len(row) >= 18): print(" MA: " + row[17]) if (len(row) >= 19): print(" Other: " + row[18]) if (len(row) >= 21): print(" " + row[19] + ": " + row[20]) if (len(row) >= 22): print(" CCBK: " + row[21]) if (len(row) >= 23): print(" o-CC: " + row[22]) if (len(row) >= 25): print(" nc-mary: " + row[24]) if (len(row) >= 26): print(" nc-dru: " + row[25]) if (len(row) >= 27): print(" nc-paul: " + row[26]) dict_of_locations = {} if path.exists("calconfig.pickle"): with open('calconfig.pickle', 'rb') as handle: dict_of_locations = pickle.load(handle) else: if not values3: print('No data found.') else: for row in values3: if (len(row) >= 5): if row[4]: dict_of_locations[row[4]] = -1 with open('calconfig.pickle', 'wb') as handle: pickle.dump(dict_of_locations, handle, protocol=pickle.HIGHEST_PROTOCOL) list_of_variables = [] master = Tk() def deleter(): sys.exit(1) master.protocol("WM_DELETE_WINDOW", deleter) def callback(): for i, location in enumerate(dict_of_locations): print(list_of_variables[i].get()) dict_of_locations[location] = list_of_variables[i].get() master.destroy() master.quit() print(dict_of_locations) with open('calconfig.pickle', 'wb') as handle: pickle.dump(dict_of_locations, handle, protocol=pickle.HIGHEST_PROTOCOL) for i in range(len(dict_of_locations)): list_of_variables.append(IntVar(master)) tk.Label(master, text=cal_msg, padx = 10, pady = 5, anchor = 'center').grid(row=0) tk.Label(master, text=cal_msg2, padx = 10, pady = 5, justify = 'left').grid(row=1) endrow = 0 for i, location in enumerate(dict_of_locations): tk.Label(master, text=location, padx = 10, pady = 5).grid(row=i+2) ee = tk.Entry(master, textvariable=list_of_variables[i]) ee.delete(0, END) ee.insert(0, dict_of_locations[location]) ee.grid(row = i+2, column = 1) endrow = i+2 endrow += 2 b = Button(master, text="Submit", width=10, command=callback) b.grid(row=endrow+2, column=0) master.mainloop() #Convert indexes to CAL ID for i, location in enumerate(dict_of_locations): for j, cal in enumerate(calHolder): if (dict_of_locations[location] == j): dict_of_locations[location] = cal["cal_id"] print(dict_of_locations) #Get what kind of method to select events search_method = 0 window = Tk() def deleter(): sys.exit(1) window.protocol("WM_DELETE_WINDOW", deleter) v = IntVar(window) v.set(0) def ShowChoice(): print(v.get()) if (v.get() == 0): sys.exit(1) search_method = v.get() window.destroy() window.quit() tk.Label(window, text="""Choose method for selecting events:""", padx = 20, pady = 5).pack() tk.Radiobutton(window, text="By Date RANGE (MM/DD/YYYY)", indicatoron = 0, width = 20, padx = 20, variable=v, command=ShowChoice, value=1).pack() tk.Radiobutton(window, text="By Row In RANGE ex: (1-9999)", indicatoron = 0, width = 20, padx = 20, variable=v, command=ShowChoice, value=2).pack() tk.Radiobutton(window, text="By Row in LIST ex: (64, 65, 77, 81)", indicatoron = 0, width = 20, padx = 20, variable=v, command=ShowChoice, value=3).pack() window.mainloop() search_method = v.get() print(search_method) #sys.exit(1) # Call the Sheets API sheet = sheets_service.spreadsheets() result = sheet.values().get(spreadsheetId=SPREADSHEET_ID, range=SAMPLE_RANGE_NAME).execute() values = result.get('values', []) print (len(values)) #Prompt & convert date range search = [] search_indexes = [] if search_method == 1: START_DATE = simpledialog.askstring(title="Date From (inclusive)", prompt="Enter the start of the date range (MM/DD/YYYY)" ) RANGE_START = datetime.datetime.strptime(START_DATE, '%m/%d/%Y') END_DATE = simpledialog.askstring(title="Date Until (inclusive)", prompt="Enter the end of the date range (MM/DD/YYYY)" ) RANGE_END = datetime.datetime.strptime(END_DATE, '%m/%d/%Y') if search_method == 2: START_ROW = simpledialog.askinteger(title="First Row (Inclusive):", prompt="Enter the first row:" ) END_ROW = simpledialog.askinteger(title="Last Row (Inclusive):", prompt="Enter the Last row:" ) if (START_ROW > END_ROW): print("startstop error 1") sys.exit(1) if search_method == 3: USER_LIST = simpledialog.askstring(title="Enter List of Rows:", prompt="Enter list of rows seperated by Commas. Ex: (16, 22, 2, 1999)" ) ROW_LIST = USER_LIST.split(",") #Search for valid entries within range s_index = 0 if not values: print('No data found.') else: for row in values: print(row) if not (len(row) > 26): continue if search_method == 1: TEST_DATE = datetime.datetime.strptime(row[0], '%m/%d/%Y') if (RANGE_START <= TEST_DATE <= RANGE_END): search.append(row) search_indexes.append(s_index) print('0 ' + row[0] + ' 1 ' + row[1] + ' 4 ' + row[4] + ' 5 ' + row[5] + ' 6 ' + row[6] + ' 7 ' + row[7] + ' 8 ' + row[8] + ' 9 ' + row[9] + ' 10 ' + row[10] + ' 11 ' + row[11] + ' 12 ' + row[12] + ' 13 ' + row[13] + ' 18 ' + row[18] + ' 19 ' + row[19] + ' 25 ' + row[25] + ' 26 ' + row[26]) if search_method == 2: if (START_ROW <= int(row[26]) <= END_ROW): search.append(row) search_indexes.append(s_index) print('0 ' + row[0] + ' 1 ' + row[1] + ' 4 ' + row[4] + ' 5 ' + row[5] + ' 6 ' + row[6] + ' 7 ' + row[7] + ' 8 ' + row[8] + ' 9 ' + row[9] + ' 10 ' + row[10] + ' 11 ' + row[11] + ' 12 ' + row[12] + ' 13 ' + row[13] + ' 18 ' + row[18] + ' 19 ' + row[19] + ' 25 ' + row[25] + ' 26 ' + row[26]) if search_method == 3: for rowval in ROW_LIST: if (int(rowval) == int(row[26])): search.append(row) search_indexes.append(s_index) print('0 ' + row[0] + ' 1 ' + row[1] + ' 4 ' + row[4] + ' 5 ' + row[5] + ' 6 ' + row[6] + ' 7 ' + row[7] + ' 8 ' + row[8] + ' 9 ' + row[9] + ' 10 ' + row[10] + ' 11 ' + row[11] + ' 12 ' + row[12] + ' 13 ' + row[13] + ' 18 ' + row[18] + ' 19 ' + row[19] + ' 25 ' + row[25] + ' 26 ' + row[26]) s_index += 1 #Read in instructor emails inst_to_email = {} for row in values3: if (len(row) >= 2): if row[1]: print('0: ' + row[0] + " 20: " + row[1]) inst_to_email[row[0]] = row[1] else: print('0: ' + row[0] + " 20: [email protected]") inst_to_email[row[0]] = "*****@*****.**" else: print('0: ' + row[0] + " 20: [email protected]") inst_to_email[row[0]] = "*****@*****.**" #Read in staff emails staff_to_email = {} for row in values3: if (len(row) >= 21): if row[20]: print('0: ' + row[19] + " 1: " + row[20]) staff_to_email[row[19]] = row[20] else: print('0: ' + row[19] + " 1: [email protected]") staff_to_email[row[19]] = "*****@*****.**" else: if (len(row) >= 20): if row[19]: print('0: ' + row[19] + " 1: [email protected]") staff_to_email[row[19]] = "*****@*****.**" #Setup list of events for printing event_printlist = [] event_skiplist = [] #Begin creating & sending events s_index = 0 for row in search: #skip if the event was already made if row[25] != 'N': event_skiplist.append("Row " + row[26] + ": " + row[10] + " " + row[0] + " was already marked as: " + row[25]) print("skipped " + row[10] + " " + row[0]) continue #Convert location to CAL ID if dict_of_locations[row[1]] == -1: event_skiplist.append("Row " + row[26] + ": " + row[10] + " " + row[0] + " Calendar for location " + row[1] + " was not found.") print("skipped " + row[10] + " " + row[0] + " No Cal") continue gworksheet.update_cell(int(row[26]), 26, "Y") s_index += 1 #Get Title/Summary summary_in = (row[10] + " - " + row[9]) if row[11]: summary_in += (" - " + row[11] + " MGR ") if row[12]: summary_in += (" - " + row[12] + " IPS ") if row[13]: summary_in += (" - " + row[13] + " MA ") if row[14]: summary_in += (" - " + row[14] + " Backup ") #Get Location loc_in = (row[1]) if (row[1] == "Chrysler Studio"): loc_in = "Chrysler Studio 109 B" #Get Desc desc_in = (row[10]) #Get Start Time and Date start_dts = row[0] + ' ' + row[5] #Get End Time and Date end_dts = row[0] + ' ' + row[6] #Date & timestamp stuff is janky because the JSON object "event" wants RCF formatted time, #whereas the Excel file could have any kind of time input, so using strptime with concacted strings is probably the most #flexible approach for now dto_start = datetime.datetime.strptime(start_dts, '%m/%d/%Y %I:%M %p') dto_end = datetime.datetime.strptime(end_dts, '%m/%d/%Y %I:%M %p') #Get Attendees #List of attendees is a "list of dicts" which is the input the JSON object "event" wants instructor = inst_to_email[row[9]] print(instructor) #Staff list_of_emailed_names = [] list_of_emailed_names.append(row[9]) list_of_attendees = [ {'email': instructor} ] if row[11]: if not (row[11] in list_of_emailed_names): their_email = staff_to_email[row[11]] list_of_attendees.append({'email': their_email}) list_of_emailed_names.append(row[11]) print(their_email) if row[12]: if not (row[11] in list_of_emailed_names): their_email = staff_to_email[row[12]] list_of_attendees.append({'email': their_email}) list_of_emailed_names.append(row[12]) print(their_email) if row[13]: if not (row[11] in list_of_emailed_names): their_email = staff_to_email[row[13]] list_of_attendees.append({'email': their_email}) list_of_emailed_names.append(row[13]) print(their_email) if row[14]: if not (row[11] in list_of_emailed_names): their_email = staff_to_email[row[14]] list_of_attendees.append({'email': their_email}) list_of_emailed_names.append(row[14]) print(their_email) #Credit/Noncredit list(?) WIP print(row[18]) if (row[18] == "Credit"): print("It's a Credit Course. ") for roww in values3: if (len(roww) >= 23): if (roww[22]): if not (roww[22] in list_of_emailed_names): list_of_emailed_names.append(roww[22]) their_email = staff_to_email[roww[22]] list_of_attendees.append({'email': their_email, 'optional': 1}) else: print("It's a Non-Credit Course. ") if (row[11] == "Mary Lynn"): for roww in values3: if (len(roww) >= 25): if not (roww[24] in list_of_emailed_names): list_of_emailed_names.append(roww[24]) their_email = staff_to_email[roww[24]] list_of_attendees.append({'email': their_email, 'optional': 1}) if (row[11] == "Dru"): for roww in values3: if (len(roww) >= 26): if not (roww[25] in list_of_emailed_names): list_of_emailed_names.append(roww[25]) their_email = staff_to_email[roww[25]] list_of_attendees.append({'email': their_email, 'optional': 1}) if (row[11] == "Paul"): if (len(roww) >= 27): if not (roww[26] in list_of_emailed_names): list_of_emailed_names.append(roww[26]) their_email = staff_to_email[roww[26]] list_of_attendees.append({'email': their_email, 'optional': 1}) #The actual JSON style event object, time zone is static just because not really necessary event = { 'summary': summary_in, 'location': loc_in, 'description': desc_in, 'start': { 'dateTime': dto_start.isoformat("T"), 'timeZone': 'US/Eastern', }, 'end': { 'dateTime': dto_end.isoformat("T"), 'timeZone': 'US/Eastern', }, # 'recurrence': [ # 'RRULE:FREQ=DAILY;COUNT=2' # ], 'attendees': list_of_attendees, 'reminders': { 'useDefault': False, 'overrides': [ {'method': 'email', 'minutes': 24 * 60}, {'method': 'popup', 'minutes': 10}, ], }, } print(dict_of_locations[row[1]]) #Uses the service to insert the event #event = service.events().insert(calendarId=dict_of_locations[row[1]], body=event, sendUpdates='all').execute() #print ('Event created: %s' % (event.get('htmlLink'))) #event_link = event.get('htmlLink') event_link = "google.com" event_printlist.append({'summary':summary_in, 'date':row[0], 'link':event_link}) print(event) f = open("CreatedEvents.html", 'w') f.write("<h1>Created the Following Events:</h1>" + '\n' + "<blockquote>") for event in event_printlist: f.write('\n' + "<p>" + event['summary'] + ' ' + event['date'] + ':' + "</p>") f.write('\n' + "<p><a href=\"" + event['link'] + "\">" + event['link'] + "</a></p>") f.write('\n' + "</blockquote>") f.write('\n' + "<h3>Skipped the Following Events:</h3>" + '\n') for event in event_skiplist: f.write('\n' + "<p>" + event + "</p>") f.close() os.startfile("CreatedEvents.html") sys.exit(1)
from google.auth.transport.requests import Request from oauth2client.service_account import ServiceAccountCredentials # Google Sheets Auth SCOPES = ['https://www.googleapis.com/auth/spreadsheets'] TOKEN_FILE = 'token.pickle' CREDENTIAL_FILE = 'credentials.json' credentials = None if os.path.exists(TOKEN_FILE): with open(TOKEN_FILE, 'rb') as token: credentials = pickle.load(token) if not credentials or not credentials.valid: if credentials and credentials.expired and credentials.refresh_token: credentials.refresh(Request()) else: flow = InstalledAppFlow.from_client_secrets_file( CREDENTIAL_FILE, SCOPES) credentials = flow.run_local_server(port=10800) # Save the credentials for the next run with open(TOKEN_FILE, 'wb') as token: pickle.dump(credentials, token) service = discovery.build('sheets', 'v4', credentials=credentials) ######################################################################################################### def exportreport(AdvertiserName, AdvertiserID, spreadsheet_ID): print("Checking for open sales")
def __init__(self, mongo, logger): """ METHOD SETS ATTRIBUTES AND CONNECTS TO GMAIL API Args: mongo ([object]): MONGODB OBJECT logger ([object]): LOGGER OBJECT """ self.SCOPES = ["https://mail.google.com/"] self.logger = logger self.creds = None self.service = None self.users = mongo.users self.emails = mongo.emails self.ids_to_delete = [] self.token_file = f"{THIS_FOLDER}/creds/token.json" self.creds_file = f"{THIS_FOLDER}/creds/credentials.json" try: self.logger.INFO("CONNECTING TO GMAIL...") if os.path.exists(self.token_file): with open(self.token_file, 'r') as token: self.creds = Credentials.from_authorized_user_file( self.token_file, self.SCOPES) # If there are no (valid) credentials available, let the user log in. if not self.creds or not self.creds.valid: if self.creds and self.creds.expired and self.creds.refresh_token: self.creds.refresh(Request()) else: flow = InstalledAppFlow.from_client_secrets_file( self.creds_file, self.SCOPES) self.creds = flow.run_local_server(port=0) # Save the credentials for the next run with open(self.token_file, 'w') as token: token.write(self.creds.to_json()) self.service = build('gmail', 'v1', credentials=self.creds) self.logger.INFO("CONNECTED TO GMAIL!\n") except Exception as e: print(e) self.logger.CRITICAL("FAILED TO CONNECT TO GMAIL!\n")
def refresh_token(self): if self.credentials.expired: self.credentials.refresh(Request()) _l.debug('token refreshed')
def serviceaccountfactory(credentials='credentials.json', token='token.pickle', path=None, list_projects=False, list_sas=None, create_projects=None, max_projects=12, enable_services=None, services=['iam', 'drive'], create_sas=None, delete_sas=None, download_keys=None): selected_projects = [] proj_id = loads(open(credentials, 'r').read())['installed']['project_id'] creds = None if os.path.exists(token): with open(token, 'rb') as t: creds = pickle.load(t) if not creds or not creds.valid: if creds and creds.expired and creds.refresh_token: creds.refresh(Request()) else: flow = InstalledAppFlow.from_client_secrets_file( credentials, SCOPES) creds = flow.run_local_server(port=0) with open(token, 'wb') as t: pickle.dump(creds, t) cloud = build('cloudresourcemanager', 'v1', credentials=creds) iam = build('iam', 'v1', credentials=creds) serviceusage = build('serviceusage', 'v1', credentials=creds) projs = None while projs == None: try: projs = _get_projects(cloud) except HttpError as e: if loads(e.content.decode( 'utf-8'))['error']['status'] == 'PERMISSION_DENIED': try: serviceusage.services().enable( name= 'projects/%s/services/cloudresourcemanager.googleapis.com' % proj_id).execute() except HttpError as e: print(e._get_reason()) input('Press Enter to retry.') if list_projects: return _get_projects(cloud) if list_sas: return _list_sas(iam, list_sas) if create_projects: if create_projects > 0: current_count = len(_get_projects(cloud)) if current_count + create_projects < max_projects: print('Creating %d projects' % create_projects) nprjs = _create_projects(cloud, create_projects) selected_projects = nprjs else: print('%d projects already exist!' % current_count) else: print('Please specify a number larger than 0.') if enable_services: ste = [] ste.append(enable_services) if enable_services == '~': ste = selected_projects elif enable_services == '*': ste = _get_projects(cloud) services = [i + '.googleapis.com' for i in services] print('Enabling services') _enable_services(serviceusage, ste, services) if create_sas: stc = [] stc.append(create_sas) if create_sas == '~': stc = selected_projects elif create_sas == '*': stc = _get_projects(cloud) for i in stc: _create_remaining_accounts(iam, i) if download_keys: try: os.mkdir(path) except FileExistsError: pass std = [] std.append(download_keys) if download_keys == '~': std = selected_projects elif download_keys == '*': std = _get_projects(cloud) _create_sa_keys(iam, std, path) if delete_sas: std = [] std.append(delete_sas) if delete_sas == '~': std = selected_projects elif delete_sas == '*': std = _get_projects(cloud) for i in std: print('Deleting service accounts in %s' % i) _delete_sas(iam, i)
def default_google_access_token(): # get token for google-based auth use, assumes application default credentials work for specified environment credentials, _ = google.auth.default(scopes=['openid', 'email', 'profile']) credentials.refresh(Request()) return credentials.token
def main(): """Shows basic usage of the Google Calendar API. Prints the start and name of the next 10 events on the user's calendar. """ creds = None # The file token.pickle stores the user's access and refresh tokens, and is # created automatically when the authorization flow completes for the first # time. if os.path.exists('token.pickle'): with open('token.pickle', 'rb') as token: creds = pickle.load(token) # If there are no (valid) credentials available, let the user log in. if not creds or not creds.valid: if creds and creds.expired and creds.refresh_token: creds.refresh(Request()) else: flow = InstalledAppFlow.from_client_secrets_file( 'credentials.json', SCOPES) creds = flow.run_local_server(port=0) # Save the credentials for the next run with open('token.pickle', 'wb') as token: pickle.dump(creds, token) service = build('calendar', 'v3', credentials=creds) # Call the Calendar API now = datetime.utcnow().isoformat() + 'Z' # 'Z' indicates UTC time print('Getting the upcoming 10 events') events_result = service.events().list(calendarId='primary', timeMin=now, maxResults=10, singleEvents=True, orderBy='startTime').execute() events = events_result.get('items', []) d = datetime.now().date() tomorrow = datetime(d.year, d.month, d.day, 10) + timedelta(days=1) start = tomorrow.isoformat() end = (tomorrow + timedelta(hours=1)).isoformat() event_result = service.events().insert( calendarId='primary', body={ "summary": 'Automating calendar', "description": 'This is a tutorial example of automating google calendar with python', "start": { "dateTime": start, "timeZone": 'Asia/Kolkata' }, "end": { "dateTime": end, "timeZone": 'Asia/Kolkata' }, }).execute() print("created event") print("id: ", event_result['id']) print("summary: ", event_result['summary']) print("starts at: ", event_result['start']['dateTime']) print("ends at: ", event_result['end']['dateTime']) if not events: print('No upcoming events found.') for event in events: start = event['start'].get('dateTime', event['start'].get('date')) print(start, event['summary'])
def make_iap_request(url, client_id, method='GET', **kwargs): """Makes a request to an application protected by Identity-Aware Proxy. Info: https://github.com/requests/requests/blob/master/requests/api.py""" # Set the default timeout, if missing if 'timeout' not in kwargs: kwargs['timeout'] = 90 # Figure out what environment we're running in and get some preliminary # information about the service account. bootstrap_credentials, _ = google.auth.default(scopes=[IAM_SCOPE]) if isinstance(bootstrap_credentials, google.oauth2.credentials.Credentials): raise Exception('make_iap_request is only supported for service ' 'accounts.') elif isinstance(bootstrap_credentials, google.auth.app_engine.Credentials): requests_toolbelt.adapters.appengine.monkeypatch() # For service account's using the Compute Engine metadata service, # service_account_email isn't available until refresh is called. bootstrap_credentials.refresh(Request()) signer_email = bootstrap_credentials.service_account_email if isinstance(bootstrap_credentials, google.auth.compute_engine.credentials.Credentials): signer = google.auth.iam.Signer(Request(), bootstrap_credentials, signer_email) else: # A Signer object can sign a JWT using the service account's key. signer = bootstrap_credentials.signer # Construct OAuth 2.0 service account credentials using the signer # and email acquired from the bootstrap credentials. credentials = google.oauth2.service_account.Credentials( signer, signer_email, token_uri=OAUTH_TOKEN_URI, additional_claims={'target_audience': client_id}) # Obtain an OpenID Connect token, which is a JWT signed by Google. google_open_id_connect_token = get_google_open_id_connect_token( credentials) # Fetch the Identity-Aware Proxy-protected URL, including a Bearer token. resp = requests.request( method, url, headers={ 'Authorization': 'Bearer {}'.format(google_open_id_connect_token) }, **kwargs) if resp.status_code == 403: raise Exception( 'Service account {} does not have permission to ' 'access the IAP-protected application.'.format(signer_email)) elif resp.status_code != 200: raise Exception( 'Bad response from application: {!r} / {!r} / {!r}'.format( resp.status_code, resp.headers, resp.text)) else: return resp.text
def main(): """Shows basic usage of the Docs API. Prints the title of a sample document. """ creds = None # The file token.pickle stores the user's access and refresh tokens, and is # created automatically when the authorization flow completes for the first # time. if os.path.exists('token.pickle'): with open('token.pickle', 'rb') as token: creds = pickle.load(token) # If there are no (valid) credentials available, let the user log in. if not creds or not creds.valid: if creds and creds.expired and creds.refresh_token: creds.refresh(Request()) else: flow = InstalledAppFlow.from_client_secrets_file( 'credentials.json', SCOPES) creds = flow.run_local_server(port=0) # Save the credentials for the next run with open('token.pickle', 'wb') as token: pickle.dump(creds, token) drive_service = build('drive', 'v3', credentials=creds) doc_service = build('docs', 'v1', credentials=creds) spreadsheet_service = build('sheets', 'v4', credentials=creds) # create external folder file_metadata = { 'name': 'ParenText Moa', 'mimeType': 'application/vnd.google-apps.folder' } folder_file = drive_service.files().create(body=file_metadata, fields='id').execute() parent_id = folder_file.get('id') parentext_folder_id = parent_id # get names of the JSON files for docs doc_file_names = [ f for f in listdir('./JSON_files') if isfile(join('./JSON_files', f)) ] doc_flows_names = [ line.strip('\n').replace('PLH - ', '') for line in doc_file_names ] doc_flows_names = [line[:-5] for line in doc_flows_names] # remove .json from string # get names of the csv files for sheets sheet_file_names = [ f for f in listdir('./csv_files') if isfile(join('./csv_files', f)) ] sheet_flows_names = [line.strip('\n') for line in sheet_file_names] sheet_flows_names = [line[:-4] for line in sheet_flows_names ] # remove .csv from string # combine the 2 lists flows_names = doc_flows_names + sheet_flows_names # create list for building folder structure from the names of the files folders_names_in_strings = [] max_depth = 3 for name in flows_names: name_list = name.split(" - ") name_list.pop() if len(name_list) > max_depth: name_list.pop() folders_names_in_strings.append(' - '.join(name_list)) folders_names_in_strings = list(set(folders_names_in_strings)) folders_in_lists = list( fol.split(" - ") for fol in folders_names_in_strings) # variable for saving the IDs of the created folders and files folders_IDs = {} files_IDs = {} files_urls = {} parent_folders_path = "" # function to create the folder structure def create_layer_of_folders(folders_in_lists, parent_folders_path, parent_id): curr_layer_folders_to_create = list( set([folder[0] for folder in folders_in_lists])) for folder in curr_layer_folders_to_create: file_metadata = { 'name': folder, 'mimeType': 'application/vnd.google-apps.folder', 'parents': [parent_id] } folder_file = drive_service.files().create(body=file_metadata, fields='id').execute() folders_IDs[parent_folders_path + folder + ' - '] = folder_file.get('id') new_folders_in_lists = list( filter(lambda fol: (len(fol) > 0 and fol[0] == folder), folders_in_lists)) for fol in new_folders_in_lists: fol.pop(0) new_folders_in_lists = list( filter(lambda fol: len(fol) > 0, new_folders_in_lists)) if len(new_folders_in_lists) != 0: new_parents_folder_path = parent_folders_path + folder + ' - ' create_layer_of_folders(new_folders_in_lists, new_parents_folder_path, folder_file.get('id')) # create the folder structure create_layer_of_folders(folders_in_lists, parent_folders_path, parent_id) # save the IDS of the created folders folders_IDs['ParenText'] = parentext_folder_id with open('./folders_IDs.json', 'w') as outfile: json.dump(folders_IDs, outfile, indent=4) ################################################################################## # functions to create spreadsheets def export_csv_file(file_path: str, name: str): if not os.path.exists(file_path): print("file path does not exists") return try: file_metadata = { 'name': name, 'mimeType': 'application/vnd.google-apps.spreadsheet', 'properties': { 'title': title } } media = MediaFileUpload(filename=file_path, mimetype='text/csv') response = drive_service.files().create( media_body=media, body=file_metadata).execute() return response except Exception as e: print(e) return # create spreadsheets ############################################# for fl in range(len(sheet_flows_names)): time.sleep(6) # define title curr_flow = sheet_flows_names[fl] curr_flow_split = curr_flow.split(" - ") title = curr_flow_split[-1] curr_flow_split.pop() curr_flow_path = ' - '.join(curr_flow_split) csv_file_path = './csv_files/' + sheet_file_names[fl] spreadsheet_file = export_csv_file(csv_file_path, title) print('Created spreadsheet with title: ' + title) DOCUMENT_ID = spreadsheet_file.get('id') files_IDs[curr_flow] = DOCUMENT_ID files_urls[ curr_flow] = "https://docs.google.com/spreadsheets/d/" + DOCUMENT_ID + "/edit#gid=0" #formatting of the file (column width, background color, text wrapping) ranges = [] # True if grid data should be returned. # This parameter is ignored if a field mask was set in the request. include_grid_data = False request = spreadsheet_service.spreadsheets().get( spreadsheetId=DOCUMENT_ID, includeGridData=include_grid_data) response = request.execute() sheetId = response.get("sheets")[0].get("properties").get("sheetId") n_rows = response.get("sheets")[0].get("properties").get( "gridProperties").get("rowCount") formatting_requests = [] formatting_requests.append({ "repeatCell": { "range": { "sheetId": sheetId, "startRowIndex": 1, "endRowIndex": n_rows - 1, "startColumnIndex": 4, "endColumnIndex": 5 }, "cell": { 'userEnteredFormat': { "backgroundColor": { "red": 0.39, "green": 0.65, "blue": 0.39, "alpha": 1 } } }, "fields": 'userEnteredFormat.backgroundColor' } }) formatting_requests.append({ "repeatCell": { "range": { "sheetId": sheetId, "startRowIndex": 0, "startColumnIndex": 0 }, "cell": { 'userEnteredFormat': { "wrapStrategy": "WRAP" } }, "fields": 'userEnteredFormat.wrapStrategy' } }) formatting_requests.append( { "updateDimensionProperties": { "range": { "sheetId": sheetId, "dimension": "COLUMNS", "startIndex": 4, "endIndex": 5 }, "properties": { "pixelSize": 300 }, "fields": "pixelSize" } }, ) formatting_requests.append( { "updateDimensionProperties": { "range": { "sheetId": sheetId, "dimension": "COLUMNS", "startIndex": 0, "endIndex": 2 }, "properties": { "pixelSize": 150 }, "fields": "pixelSize" } }, ) formatting_requests.append( { "updateDimensionProperties": { "range": { "sheetId": sheetId, "dimension": "COLUMNS", "startIndex": 5, "endIndex": 16 }, "properties": { "pixelSize": 200 }, "fields": "pixelSize" } }, ) spreadsheet_service.spreadsheets().batchUpdate( spreadsheetId=DOCUMENT_ID, body={ 'requests': formatting_requests }).execute() print('Sent requests to document: {0}'.format( len(formatting_requests))) # move document to correct folder folder_id = folders_IDs[curr_flow_path + ' - '] # Retrieve the existing parents to remove file = drive_service.files().get(fileId=DOCUMENT_ID, fields='parents').execute() previous_parents = ",".join(file.get('parents')) # Move the file to the new folder file = drive_service.files().update(fileId=DOCUMENT_ID, addParents=folder_id, removeParents=previous_parents, fields='id, parents').execute() ################################################################################## # functions to create google docs def insert_text(text, style, first=False): requests = [{ 'insertText': { 'location': { 'index': 1, }, 'text': text if first else "\n" + text } }] if style: requests.append({ 'updateParagraphStyle': { 'range': { 'startIndex': 1 if first else 2, 'endIndex': len(text) }, 'paragraphStyle': { 'namedStyleType': style, }, 'fields': 'namedStyleType' } }) return requests def make_requests(key, value, level, requests): requests.append(insert_text(text=key, style='HEADING_' + str(level))) if isinstance(value, str): req = insert_text(text=value, style='') requests.append(req) elif isinstance(value, dict): for i in value: make_requests(i, value[i], level=level + 1, requests=requests) elif isinstance(value, list): for item in value: if isinstance(item, dict): for i in item: make_requests(i, item[i], level=level + 1, requests=requests) elif isinstance(item, str): req = insert_text(text=item, style='') requests.append(req) requests # create google docs ############################################# for fl in range(len(doc_flows_names)): time.sleep(6) # initialise the doc curr_flow = doc_flows_names[fl] curr_flow_split = curr_flow.split(" - ") title = curr_flow_split[-1] curr_flow_split.pop() curr_flow_path = ' - '.join(curr_flow_split) body = { "title": title, } doc = doc_service.documents().create(body=body).execute() print('Created document with title: {0}'.format(doc.get('title'))) DOCUMENT_ID = doc.get('documentId') files_IDs[curr_flow] = DOCUMENT_ID files_urls[ curr_flow] = "https://docs.google.com/document/d/" + DOCUMENT_ID + "/edit" # load json file with open('./JSON_files/' + doc_file_names[fl], encoding="utf8") as json_file: data = json.load(json_file) requests = [] for i in data: make_requests(i, data[i], level=1, requests=requests) requests.reverse() result = doc_service.documents().batchUpdate(documentId=DOCUMENT_ID, body={ 'requests': requests }).execute() print('Sent requests to document: {0}'.format(len(requests))) # move document to correct folder folder_id = folders_IDs[curr_flow_path + ' - '] # Retrieve the existing parents to remove file = drive_service.files().get(fileId=DOCUMENT_ID, fields='parents').execute() previous_parents = ",".join(file.get('parents')) # Move the file to the new folder file = drive_service.files().update(fileId=DOCUMENT_ID, addParents=folder_id, removeParents=previous_parents, fields='id, parents').execute() #create files with files IDS and urls with open('./files_IDs.json', 'w') as outfile: json.dump(files_IDs, outfile) with open('./files_urls.json', 'w') as outfile: json.dump(files_urls, outfile)
def create_calendar(data): # AUTHENTICATION SCOPES = ['https://www.googleapis.com/auth/calendar'] creds = None # The file token.pickle stores the user's access and refresh tokens, and is # created automatically when the authorization flow completes for the first # time. if os.path.exists('token.pickle'): with open('token.pickle', 'rb') as token: creds = pickle.load(token) # If there are no (valid) credentials available, let the user log in. if not creds or not creds.valid: if creds and creds.expired and creds.refresh_token: creds.refresh(Request()) else: flow = InstalledAppFlow.from_client_secrets_file( 'credentials.json', SCOPES) creds = flow.run_local_server() # Save the credentials for the next run with open('token.pickle', 'wb') as token: pickle.dump(creds, token) service = build('calendar', 'v3', credentials=creds) # CREATE CALENDAR calendar = { 'summary': settings['GOOGLE-CalendarName'], 'timeZone': 'Asia/Manila' } created_calendar = service.calendars().insert(body=calendar).execute() print("CREATED CALENDAR:", created_calendar['id']) for i in data: print(i) start_time = (datetime.datetime.strptime( DAYS_OF_THE_WEEK[i['day']][1], '%Y-%m-%dT%H:%M:%S%z').replace( hour=int(i['start-time'][0]), minute=int(i['start-time'][1]), second=int(i['start-time'][2]))).isoformat() end_time = (datetime.datetime.strptime( DAYS_OF_THE_WEEK[i['day']][1], '%Y-%m-%dT%H:%M:%S%z').replace( hour=int(i['end-time'][0]), minute=int(i['end-time'][1]), second=int(i['end-time'][2]))).isoformat() try: event = { 'summary': i['description'], 'description': f"{i['subject_code']} ", #@{i['room']} # 'location': i['location'], 'start': { 'dateTime': start_time, 'timeZone': settings['GOOGLE-TimeZone'], }, 'end': { 'dateTime': end_time, 'timeZone': settings['GOOGLE-TimeZone'], }, 'reminders': { 'useDefault': False, 'overrides': [ { 'method': 'popup', 'minutes': 60 }, ], }, 'recurrence': [ 'RRULE:FREQ=WEEKLY;UNTIL=%s' % (settings['SIS-SemEnd']), ] } event = service.events().insert(calendarId=created_calendar['id'], body=event).execute() print('Event created: %s' % (event.get('htmlLink'))) except Exception as e: service.calendars().delete( calendarId=created_calendar['id']).execute() raise e
def get_google(calendarId, token_name, start, end, event_count=0): creds = None token_path = f'./tokens/{token_name}.pickle' # If this path doesn't work, try the absolute path creds_path = './assets/credentials.json' # If this path doesn't work, try the absolute path if os.path.exists(token_path): with open(token_path, 'rb') as token: creds = pickle.load(token) if not creds or not creds.valid: print(f'Verify Google Calendar for profile "{token_name}"') if creds and creds.expired and creds.refresh_token: creds.refresh(Request()) else: flow = InstalledAppFlow.from_client_secrets_file( creds_path, SCOPES) creds = flow.run_local_server(port=0) with open(token_path, 'wb') as token: pickle.dump(creds, token) service = build('calendar', 'v3', credentials=creds) timeMin = start.isoformat() + 'Z' timeMax = end.isoformat() + 'Z' data = {} data_events = {} events_result = service.events().list(calendarId=calendarId, timeMin=timeMin, timeMax=timeMax, singleEvents=True, orderBy='startTime').execute() events = events_result.get('items', []) if not events: return data, None for event in events: if 'description' in event and '#no#' in event['description']: continue st = event['start'].get('dateTime', event['start'].get('date')) en = event['end'].get('dateTime', event['end'].get('date')) # TODO: Beautify next if if ':' in st: st_time = datetime.datetime.strptime(st[:-3] + st[-2:], google_datetime) en_time = datetime.datetime.strptime(en[:-3] + en[-2:], google_datetime) else: st_time = datetime.datetime.strptime( st, google_date).replace(tzinfo=utc) en_time = datetime.datetime.strptime(en, google_date) en_time = (en_time + datetime.timedelta(minutes=-1)).replace(tzinfo=utc) if event_count > 0: if 'summary' in event: if st_time not in data_events: data_events[st_time] = [] data_events[st_time] += [event['summary']] event_count -= 1 if st_time.day == en_time.day: st_ret = st_time.hour + st_time.minute / 60.0 en_ret = en_time.hour + en_time.minute / 60.0 if st_time.weekday() in data: data[st_time.weekday()] += [(st_ret, en_ret)] else: data[st_time.weekday()] = [(st_ret, en_ret)] else: # TODO: Beautify this part too day = start if st_time >= utc.localize(day): day = st_time i = 0 while day.day != en_time.day: if i == 5: break if day.weekday() in data: data[day.weekday()] += [(0, 23.999)] else: data[day.weekday()] = [(0, 23.999)] day += datetime.timedelta(days=1) i += 1 if i != 5: en_ret = en_time.hour + en_time.minute / 60.0 if en_time.weekday() in data: data[en_time.weekday()] += [(0, en_ret)] else: data[en_time.weekday()] = [(0, en_ret)] return data, data_events
def main(): p = Adafruit_Thermal() p.setDefault() p.setSize('L') p.println('Calendar') creds = None if os.path.exists('token.pickle'): with open('token.pickle', 'rb') as token: creds = pickle.load(token) if not creds or not creds.valid: if creds and creds.expired and creds.refresh_token: creds.refresh(Request()) else: flow = InstalledAppFlow.from_client_secrets_file( 'credentials.json', SCOPES) creds = flow.run_local_server(port=0) with open('token.pickle', 'wb') as token: pickle.dump(creds, token) service = build('calendar', 'v3', credentials=creds) now = datetime.utcnow().isoformat() + 'Z' timeMax = (datetime.utcnow() + timedelta(days=config.calendar_days)).isoformat() + 'Z' event_results = service.events().list(calendarId='primary', timeMin=now, timeMax=timeMax, singleEvents=True, orderBy='startTime').execute() events = event_results.get('items', []) p.setSize('M') if not events: p.println("Nothing to do... chill out!") for event in events: # print(event) start_d_in = event['start'].get('date') start_dt_in = event['start'].get('dateTime') start_t_out = None if start_dt_in is not None: start_dt = dateutil.parser.parse(start_dt_in) start_d_out = start_dt.strftime(config.date_format) start_t_out = start_dt.strftime(config.time_format) else: start_d_out = dateutil.parser.parse(start_d_in).strftime( config.date_format) p.boldOn() p.underlineOn() p.justify('L') if start_t_out is not None: p.print(start_t_out) p.print(' ') p.println(start_d_out) p.boldOff() p.underlineOff() p.justify('R') p.println(event['summary']) p.setDefault() p.sleep()
def main(): creds = None # The file token.pickle stores the user's access and refresh tokens, and is # created automatically when the authorization flow completes for the first # time. if os.path.exists('token.pickle'): with open('token.pickle', 'rb') as token: creds = pickle.load(token) # If there are no (valid) credentials available, let the user log in. if not creds or not creds.valid: if creds and creds.expired and creds.refresh_token: creds.refresh(Request()) else: flow = InstalledAppFlow.from_client_secrets_file( 'client_secret_179357125629-hi519qg1ili8qqpttoqdasaor75ou49t.apps.googleusercontent.com.json', SCOPES) creds = flow.run_local_server(port=0) # Save the credentials for the next run with open('token.pickle', 'wb') as token: pickle.dump(creds, token) service = build('gmail', 'v1', credentials=creds) # Call the Gmail API to fetch INBOX results = service.users().messages().list(userId='me', labelIds=['INBOX']).execute() messages = results.get('messages', []) # Lue viestien otsikot ja IDt listaan for message in messages: messageheader = service.users().messages().get( userId="me", id=message["id"]).execute() gmailtime = int(messageheader["internalDate"]) / 1000 date = datetime.fromtimestamp(gmailtime) headers = messageheader["payload"]["headers"] ID = messageheader["id"] subject = str([i['value'] for i in headers if i["name"] == "Subject"]) sender = str([i['value'] for i in headers if i["name"] == "From"]) print("Otsikko:", subject) print("Saapumisaika:", date) print("Lähettäjä:", sender) lähettäjä = sender.split("<") lähettäjä = lähettäjä[1].split(">") lähettäjä = lähettäjä[0].replace('[', '').replace(']', '') subject = subject.replace('[', '').replace(']', '') # Poista välit, jotta muuttuja menee läpi otsikko = subject.replace(' ', '') # Lähetä varmistusviesti # Kopio "Reports.py":stä. Pitää viestis olla projekti hei.. project = "" if "ncl" in otsikko: project = "NCL" if "icon" in otsikko: project = "ICON" if "seabourn" in otsikko: project = "Seabourn" if project != "": IDsend(otsikko, lähettäjä, project, teksti) sekunnit = 900 # Ajetaan jos maili on semituore if time.time() - gmailtime < sekunnit: subprocess.call('start python Reports.py %s %s' % (otsikko, lähettäjä), shell=True) else: print("Liian vanha prosessoitavaks:", time.time() - gmailtime) # Archivaa maili try: service.users().messages().modify(userId="me", id=message["id"], body={ 'removeLabelIds': ['INBOX'], 'addLabelIds': ['STARRED'], 'ids': ID }).execute() print('Email archived.') except: print('An error occurred while archiving email.') exit()
def createMeeting(group_name, emails, date, startTime, endTime): #group_name will be a string #emails will be a list of strings #date will be a string in yyyy-mm-dd format #starttime will be in hh:mm:ss #timezone will awlays be eastern creds = None # The file token.pickle stores the user's access and refresh tokens, and is # created automatically when the authorization flow completes for the first # time. if os.path.exists('virtualstuddybuddy/token.pickle'): with open('virtualstuddybuddy/token.pickle', 'rb') as token: creds = pickle.load(token) # If there are no (valid) credentials available, let the user log in. if not creds or not creds.valid: if creds and creds.expired and creds.refresh_token: creds.refresh(Request()) else: flow = InstalledAppFlow.from_client_secrets_file( 'virtualstuddybuddy/oldCredentials.json', SCOPES) creds = flow.run_local_server(port=0) # Save the credentials for the next run with open('virtualstuddybuddy/token.pickle', 'wb') as token: pickle.dump(creds, token) service = build('calendar', 'v3', credentials=creds) event = { 'summary': group_name + " meeting", 'attendees': [{ 'email': str(e) } for e in emails], 'start': { 'dateTime': str(date) + "T" + str(startTime), 'timeZone': 'America/New_York' }, 'end': { 'dateTime': str(date) + "T" + str(endTime), 'timeZone': 'America/New_York' }, 'conferenceData': { 'createRequest': { "conferenceSolutionKey": { "type": "hangoutsMeet" }, "requestId": group_name, } } } event = service.events().insert(calendarId='primary', sendUpdates="all", body=event, conferenceDataVersion=1).execute() # g = "vsb test" # emails = ["*****@*****.**"]#, "*****@*****.**","*****@*****.**",] # date = "2020-11-24" # startTime = "10:00:00" # endTime = "14:00:00" # createMeeting(g, emails, date, startTime, endTime)
if __name__ == '__main__': """Shows basic usage of the Sheets API. Prints values from a sample spreadsheet. """ creds = None # The file token.pickle stores the user's access and refresh tokens, and is # created automatically when the authorization flow completes for the first # time. if os.path.exists('token.pickle'): with open('token.pickle', 'rb') as token: creds = pickle.load(token) # If there are no (valid) credentials available, let the user log in. if not creds or not creds.valid: if creds and creds.expired and creds.refresh_token: creds.refresh(Request()) else: flow = InstalledAppFlow.from_client_secrets_file('credentials_web.json', SCOPES) creds = flow.run_local_server() # Save the credentials for the next run with open('token.pickle', 'wb') as token: pickle.dump(creds, token) service = build('sheets', 'v4', credentials=creds) #Only needed when need to upload all of the images onto Qualtrics if len(sys.argv) == 3: flag = sys.argv[2] upload_all_images(DATACENTER, APITOKEN, service,flag) else: flag = sys.argv[1]
def main(): """Shows basic usage of the Google Calendar API. Prints the start and name of the next 10 events on the user's calendar. """ creds = None # The file token.pickle stores the user's access and refresh tokens, and is # created automatically when the authorization flow completes for the first # time. """if os.path.exists('token.pickle'): with open('token.pickle', 'rb') as token: creds = pickle.load(token)""" # If there are no (valid) credentials available, let the user log in. if not creds or not creds.valid: if creds and creds.expired and creds.refresh_token: creds.refresh(Request()) else: flow = InstalledAppFlow.from_client_secrets_file( 'credentials (1).json', SCOPES) creds = flow.run_local_server("127.0.0.1") # Save the credentials for the next run with open('token.pickle', 'wb') as token: pickle.dump(creds, token) service = build('calendar', 'v3', credentials=creds) # Call the Calendar API """now = datetime.datetime.utcnow().isoformat() + 'Z' # 'Z' indicates UTC time print('Getting the upcoming 10 events') events_result = service.events().list(calendarId='primary', timeMin=now, maxResults=10, singleEvents=True, orderBy='startTime').execute() events = events_result.get('items', []) if not events: print('No upcoming events found.') for event in events: start = event['start'].get('dateTime', event['start'].get('date')) print(start, event['summary'])""" #Extract data from textprocessing data = main_func( inpramesh ) #Later, instead of impful we will connect it to web to read data from there print(data) current_date, time = ret_date_time(str(datetime.today())) dates_till_six_days = find_date_from_a_week(current_date) weekdays = generate_weekday_lst(datetime.today().weekday()) dictionary_of_weekdays = {'M': 0, 'Tu': 1, 'W': 2, 'Th': 3, 'F': 4} dictionary_of_dates = {} for i in range(len(weekdays)): dictionary_of_dates[weekdays[i]] = dates_till_six_days[i] #Adding an Event to Calendar for d in data: if 'TBA' not in d and 'TBA' not in d[1]: for days in d[1]: start_time = "" end_time = "" if d[2][len(d[2]) - 1] == 'P' and d[2][:2] != "12": #print(d[2][:2]) get_colon_index = 0 while d[2][get_colon_index] is not ":": get_colon_index += 1 start_time = str(int(d[2][:get_colon_index]) + 12) + d[2][get_colon_index:len(d[2]) - 1] + ":00" else: start_time = d[2][:len(d[2]) - 1] + ":00" if d[3][len(d[3]) - 1] == 'P' and d[3][:2] != "12": get_colon_index = 0 while d[3][get_colon_index] is not ":": get_colon_index += 1 end_time = str(int(d[3][:get_colon_index]) + 12) + d[3][get_colon_index:len(d[3]) - 1] + ":00" else: end_time = d[3][:len(d[3]) - 1] + ":00" event = { 'summary': d[0], 'location': None, 'description': None, 'start': { 'dateTime': dictionary_of_dates[dictionary_of_weekdays[days]] + "T" + start_time, 'timeZone': 'America/Los_Angeles', }, 'end': { 'dateTime': dictionary_of_dates[dictionary_of_weekdays[days]] + "T" + end_time, 'timeZone': 'America/Los_Angeles', }, 'recurrence': [ 'RRULE:FREQ=WEEKLY;UNTIL=20191220T235959Z' #COUNT=1' ], 'attendees': [ { 'email': '*****@*****.**' }, { 'email': '*****@*****.**' }, ], 'reminders': { 'useDefault': False, 'overrides': [ { 'method': 'email', 'minutes': 24 * 60 }, { 'method': 'popup', 'minutes': 10 }, ], }, } event = service.events().insert(calendarId='primary', body=event).execute() print('Event created: %s' % event.get('htmlLink'))
def api_from_token_pickle(cls, token_path: str): with open(token_path, 'rb') as token: creds = pickle.load(token) if creds and creds.expired and creds.refresh_token: creds.refresh(Request()) return build('gmail', 'v1', credentials=creds)
def check_deploy_status(args): logging.info("check deployment status") # Figure out what environment we're running in and get some preliminary # information about the service account. credentials, _ = google.auth.default(scopes=[IAM_SCOPE]) if isinstance(credentials, google.oauth2.credentials.Credentials): raise Exception('make_iap_request is only supported for service ' 'accounts.') # For service account's using the Compute Engine metadata service, # service_account_email isn't available until refresh is called. credentials.refresh(Request()) signer_email = credentials.service_account_email if isinstance(credentials, google.auth.compute_engine.credentials.Credentials): signer = google.auth.iam.Signer(Request(), credentials, signer_email) else: # A Signer object can sign a JWT using the service account's key. signer = credentials.signer # Construct OAuth 2.0 service account credentials using the signer # and email acquired from the bootstrap credentials. service_account_credentials = google.oauth2.service_account.Credentials( signer, signer_email, token_uri=OAUTH_TOKEN_URI, additional_claims={'target_audience': may_get_env_var("CLIENT_ID")}) google_open_id_connect_token = get_google_open_id_connect_token( service_account_credentials) # Wait up to 30 minutes for IAP access test. retry_credit = 180 status_code = 0 while retry_credit > 0: retry_credit -= 1 sleep(10) try: resp = requests.request( METHOD, "https://%s.endpoints.%s.cloud.goog" % (args.deployment, args.project), headers={ 'Authorization': 'Bearer {}'.format(google_open_id_connect_token) }) status_code = resp.status_code if resp.status_code == 200: break except Exception: logging.info("IAP not ready, exception caught, retry credit: %s" % retry_credit) continue logging.info("IAP not ready, retry credit: %s" % retry_credit) if status_code != 200: raise RuntimeError( "IAP endpoint not ready after 30 minutes, time out...") else: # Optionally upload ssl cert if os.listdir(SSL_DIR) == []: for sec in ["envoy-ingress-tls", "letsencrypt-prod-secret"]: os.system("kubectl get secret %s -n kubeflow -o yaml > %s" % (sec, os.path.join(SSL_DIR, sec + ".yaml"))) os.system("gsutil cp %s/* gs://%s/%s/" % (SSL_DIR, SSL_BUCKET, args.cert_group))
def Snagajobimport(): # data, context creds = None storage_client = storage.Client() if storage_client.get_bucket('hc_tokens_scripts').blob('Tokens/Reporting-token.pickle').exists(): with gcsfs.GCSFileSystem(project="hireclix").open('hc_tokens_scripts/Tokens/Reporting-token.pickle', 'rb') as token: creds = pickle.load(token) if not creds or not creds.valid: if creds and creds.expired and creds.refresh_token: creds.refresh(Request()) with gcsfs.GCSFileSystem(project="hireclix").open('hc_tokens_scripts/Tokens/Reporting-token.pickle', 'wb') as token: pickle.dump(creds, token) service = build('gmail', 'v1', credentials=creds) userId = 'me' labelid = 'Label_4319400225407627751' query = '*****@*****.**' messages = service.users().messages().list(userId=userId, q=query, labelIds=labelid).execute() def multiple_replace(dict, text): regex = re.compile("(%s)" % "|".join(map(re.escape, dict.keys()))) return regex.sub(lambda mo: dict[mo.string[mo.start():mo.end()]], text) regexes = { 'Snag Campaign Leads ': '', 'Salesforce ': '', 'Timestamp ': '', ' ': '_' } for m_id in messages['messages']: messagemeta = service.users().messages().get(userId=userId, id=m_id['id']).execute() dates = parser.parse(re.sub("^.*,|-.*$", "", messagemeta['payload']['headers'][1]['value']).strip()).date() today = datetime.today().date() #- timedelta(1) if dates == today: attachment = messagemeta['payload']['parts'][1]['body']['attachmentId'] attachments = service.users().messages().attachments().get(userId=userId, messageId=messagemeta['id'], id=attachment).execute() f = base64.urlsafe_b64decode(attachments['data']) toread = io.BytesIO() toread.write(f) toread.seek(0) dataframe = pd.read_excel(toread, header=0) pd.set_option('display.max_rows', 500) pd.set_option('display.max_columns', 500) pd.set_option('display.width', 1000) reformattedcolumns = [] for column in dataframe.columns: reformattedcolumns.append(multiple_replace(regexes, column)) dataframe.columns = reformattedcolumns dataframe['Date'] = pd.to_datetime(dataframe['Date'], errors='coerce').dt.date dataframe.drop(['Account_Name'], inplace=True, axis=1) dataframe.dropna(how='any', inplace=True) pandas_gbq.to_gbq(dataframe, 'snagajob.Snagajob_spend', project_id='hireclix', if_exists='append', table_schema=[ {'name': 'Date', 'type': 'DATE'} ]) dataframe.to_csv('gs://hc_snagajob/snagajob_daily_'+str(today), index=False) print(dataframe)
def main(): downloaded = 0 totalsize = 0 deletedfiles = 0 creds = None # CREDENTIALS AND LOGIN if os.path.exists('token.pickle'): with open('token.pickle', 'rb') as token: creds = pickle.load(token) # REQUIRE LOGIN IF CREDENTIAL EXPIRES if not creds or not creds.valid: if creds and creds.expired and creds.refresh_token: creds.refresh(Request()) else: flow = InstalledAppFlow.from_client_secrets_file( 'credentials.json', SCOPES) creds = flow.run_local_server(port=0) # Save the credentials for the next run with open('token.pickle', 'wb') as token: pickle.dump(creds, token) service = build('drive', 'v3', credentials=creds) # DOWNLOAD def download_file(service_download, file_id, local_fd): request = service_download.files().get_media(fileId=file_id) media_request = http.MediaIoBaseDownload(local_fd, request) while True: try: download_progress, done = media_request.next_chunk() except errors.HttpError as error: print('An error occurred: %s' % error) return if download_progress: print('Download Progress: %d%%' % int(download_progress.progress() * 100)) if done: print('Download Complete') return # DELETE def delete_file(service_del, file_id): try: service.files().delete(fileId=file_id).execute() except errors.HttpError as error: print('An error occurred: %s' % error) # COUNT ALL FILES results_count = service.files().list(q=f"mimeType!='application/vnd.google-apps.folder' ", pageSize=ammount, fields="nextPageToken, files(id, name, size)").execute() counts = results_count.get('files', []) alltotalsize = 0 for count in counts: countsize = int(count['size']) alltotalsize += countsize total = len(counts) print(f'{total} files found, {round(float(alltotalsize) / 1048576, 2)}MB') # LIST ALL FOLDERS folder_results = service.files().list(q="mimeType='application/vnd.google-apps.folder'", pageSize=ammount, fields="nextPageToken, files(id, name)").execute() folders = folder_results.get('files', []) if not folders: print('No folder found.') else: print('Folders:') for folder in folders: print(f"{folder['name']}") # LIST ALL FILES IN FOLDER results = service.files().list(q=f"mimeType!='application/vnd.google-apps.folder' andparents in '{folder['id']}' ", pageSize=ammount, fields="nextPageToken, files(id, name, size)").execute() items = results.get('files', []) if not items: print('------ No file found') else: path = f"{sync_path}\\{folder['name']}" if os.path.exists(path): print('') else: # print(f'Folder {path} doesnt exists, creating...\n') os.mkdir(path) # print(path) #print('Files:\n') for item in items: print(f"------ ID: {item['id']} | Filename: {item['name']}") file = f"{path}\\{item['name']}" pathfile = file # DOWNLOAD ALL FILES if os.path.exists(pathfile): localfile = open(pathfile, 'r') localfile.seek(0, 2) localsize = int(localfile.tell()) remotesize = int(item['size']) # IGNORE EXISTING FILES print(f'Local file size: {localsize} bytes / Remote file size: {remotesize} bytes') if localsize == remotesize: print( f"File {item['name']} already exists with same size, ignoring and deleting remote file...\n") delete_file(service, item['id']) deletedfiles += 1 else: # DOWNLOAD INCOMPLETE FILES if localsize == 0: print(f"File {item['name']} already exists with different size, downloading...\n") filedownload = open(pathfile, 'wb') # print(f"Downloading {item['name']}...") try: download_file(service, item['id'], filedownload) downloaded += 1 print(f"Deleting {item['name']}...\n") delete_file(service, item['id']) except: print('Erro ao baixar') else: filedownload = open(pathfile, 'wb') # print(f"Downloading {item['name']}...") try: download_file(service, item['id'], filedownload) print(f"Deleting {item['name']}...") delete_file(service, item['id']) except: print('Error') remotesize = int(item['size']) downloaded += 1 totalsize += remotesize print(f'{downloaded}/{total}') percent = totalsize / alltotalsize * 100 print(f'Total: {round(float(totalsize) / 1048576, 2)}MB of {round(float(alltotalsize) / 1048576, 2)}MB downloaded ({round(float(percent), 2)}%)\n\n') totalsizeinmb = round(float(totalsize) / 1048576, 2) print(f'\nTotal files downloaded: {downloaded} ({totalsizeinmb}MB)')