def hello(short_url=None):
domain_url = os.getenv('DOMAIN')
if not short_url:
# data = create_line_items(request)
# total_lines = len(data['line_items'])
return render_template('success.html', **locals())
else:
try:
air_base = os.getenv('AIR_TABLE_BASE')
air_api_key = os.getenv('AIR_TABLE_API')
air_table_name = os.getenv('AIR_PROTOCOLO_TABLE_NAME')
at = Airtable(air_base, air_table_name, api_key=air_api_key)
lookup_record = at.search('short_url', short_url)
text_qs = lookup_record[0]['fields']['query_string']
visits = int(lookup_record[0]['fields']['visits']) + 1 if lookup_record[0]['fields']['visits'] >= 0 else 0
dict_qs = dict(parse_qsl(text_qs))
data = create_line_items(dict_qs)
total_lines = len(data['line_items'])
view_counter = {'visits': visits}
at.update(lookup_record[0]['id'], view_counter)
if 'imagen_protocolo' in lookup_record[0]['fields']:
images = [image['url'] for image in lookup_record[0]['fields']['imagen_protocolo']]
images = images[:3]
else:
images = []
except Exception as e:
return jsonify(error=str(e)), 403
return render_template('index.html', **locals())
async def get_or_create_airtable_record(
airtable: Airtable,
search_field: str,
search_value: Any,
new_fields: dict[str, Any],
) -> str:
results: list[AirtableRecordReadModel] = \
airtable.search( # type: ignore
search_field,
search_value,
)
if len(results) > 1:
raise RuntimeError((
f"{len(results)} records in {airtable.table_name} " # type: ignore
f"found for {search_field} equal to '{search_value}'"))
result = nth(results, 0)
if result is not None:
return result["id"]
record: AirtableRecordReadModel = airtable.insert( # type: ignore
new_fields, )
return record["id"]
def events():
# if ENV != 'production':
# with open('fixtures/events.json', 'r') as json_file:
# json = json_file.read()
# return json
events_table = Airtable(AIRTABLE_APP,
EVENTS_TABLE,
api_key=AIRTABLE_API_KEY)
fields = [
'id', 'assignment_status', 'assignment', 'name', 'agency_name',
'classification', 'description', 'start_time', 'end_time',
'location_address', 'status', 'community_area', 'Custom Start Time',
'Custom End Time', 'url'
]
event_rows = events_table.search('assignment_status',
'Open Assignment',
fields=fields,
sort="start_time")
print(event_rows)
# handle custom start and end times :/
for row in event_rows:
fields = row['fields']
if 'Custom Start Time' in fields:
fields['start_time'] = fields['Custom Start Time']
del fields['Custom Start Time']
if 'Custom End Time' in fields:
fields['end_time'] = fields['Custom End Time']
del fields['Custom End Time']
return jsonify(event_rows)
def cfgToDict():
f = open("clientsettings.cfg", "r")
s = f.read().strip()
contents = dict(item.split("=") for item in s.split("\n"))
if 'UW_Owner_or_Fiscal_Group' in contents:
airtable = Airtable('app9og4P1Z4iet5fT', 'Departments',
'keybFjYyk9LuWpxNw')
res = airtable.search('Name',
contents['UW_Owner_or_Fiscal_Group'],
fields=['Name'])
print(res)
if len(res) == 0:
del contents['UW_Owner_or_Fiscal_Group']
else:
contents['Department'] = [res['id']]
if 'UW_Location' in contents:
contents['Location'] = contents['UW_Location']
del contents['UW_Location']
if 'UW_NetID' in contents:
contents['NetID'] = contents['UW_NetID']
del contents['UW_NetID']
if 'UW_PURCHASE_DATE' in contents:
contents['Purchased'] = contents['UW_PURCHASE_DATE']
del contents['UW_PURCHASE_DATE']
return contents
def getuserid_bylevel(level):
airtable = Airtable(BASE_KEY, 'member', api_key=API_KEY)
records = airtable.search('Classification level', level)
idlist = [
record['fields']['User id'] for record in records
if 'Unsubscribe' not in record['fields']
]
return idlist
class Airtable_API:
def __init__(self, base_key, table_name, api_key):
self.__table = Airtable(base_key, table_name, api_key)
def search(self, field_name, field_value):
return self.__table.search(field_name, field_value)
def insert(self, fields):
self.__table.insert(fields)
def get_all(self):
return self.__table.get_all()
def get_id_of_all_moderators(media):
table = Airtable(BASE_ID, USERS_TABLE_NAME, api_key=API_KEY)
users_from_table = table.search('is_moderator', '1')
res_users = list()
for i in users_from_table:
try:
user_id = i['fields'][media.name.lower() + '_id']
res_users.append(user_id)
except KeyError:
pass
logging.info('get_id_of_all_moderators')
return res_users
def get_data(table):
load_dotenv()
AIRTABLE_API_KEY = os.getenv("AIRTABLE_API_KEY")
AIRTABLE_BASE_ID = os.getenv("AIRTABLE_BASE_ID")
airtable = Airtable(AIRTABLE_BASE_ID, table, api_key=AIRTABLE_API_KEY)
# Only published Tools should be returned; for other tables return all
if table == "Tools":
all_data = airtable.search('Publish', 1)
else:
all_data = airtable.get_all()
return(all_data)
def get_supplier_id(name):
"""
Get the Supplier ID for a given name
If the supplier doesn't exist, create it
"""
suppliers = Airtable(OPERATIONS_ID, "Suppliers")
results = suppliers.search("Name", name)
if len(results) == 0:
# Create supplier
result = suppliers.insert({
"Name": name
})
return result['id']
else:
return results[0]['id']
def get_manufacturer_id(name):
"""
Get the Manufacturer ID for a given name
If the manfacturer doesn't exist, create it
"""
manufacturers = Airtable(OPERATIONS_ID, "Manufacturers")
results = manufacturers.search("Name", name)
if len(results) == 0:
# Create manufacturer
result = manufacturers.insert({
"Name": name
})
return result['id']
else:
return results[0]['id']
class ATable():
def __init__(self, api_key: str, base_id: str, table: str):
self.tbl_obj = Airtable(base_id, table, api_key=api_key)
self.table: list = self.tbl_obj.get_all()
self.fields: list = list(self.table[0]['fields'].keys())
def table_search(self, column_name, search_value) -> (list, None):
if column_name not in self.fields:
print('"{}" is not a valid field name')
return None
results = self.tbl_obj.search(column_name, search_value)
return results
def get_contact_suggestions(self,
n: int = 10,
pers=True,
prof=True,
srch: str = "Chat > 0"):
# TODO: Catch cases where format of srch string is incorrect
records = self.tbl_obj.get_all(formula=srch)
both_records = [
i for i in records if i['fields']['Category'] == 'Both'
]
pers_records = []
prof_records = []
if pers:
pers_records = [
i for i in records if i['fields']['Category'] == 'Personal'
]
if prof:
prof_records = [
i for i in records if i['fields']['Category'] == 'Professional'
]
all_recs = both_records + pers_records + prof_records
all_recs = sorted(all_recs,
key=lambda rec: rec['fields']['Chat'],
reverse=True)
if n and len(all_recs) > n:
return (all_recs[:n])
return all_recs
def comparte_gana_sms():
domain_url = os.getenv('DOMAIN')
air_base = os.getenv('AIR_TABLE_BASE')
air_api_key = os.getenv('AIR_TABLE_API')
air_table_name = os.getenv('AIR_PROTOCOLO_TABLE_NAME')
try:
#at = Airtable(air_base, air_table_name, api_key=air_api_key)
email = request.form.get('Email')
iban = request.form.get('IBAN')
name = request.form.get('Name')
codigo_pais_movil = request.form.get('Código País')
movil = request.form.get('Número de Teléfono Móvil')
protocolo = request.form.get('Protocolo')[2:-2]
at = Airtable(air_base, air_table_name, api_key=air_api_key)
lookup_record = at.search('airtableID', protocolo)
if 'imagen_protocolo' in lookup_record[0]['fields']:
del lookup_record[0]['fields']['imagen_protocolo']
del lookup_record[0]['fields']['date_created']
del lookup_record[0]['fields']['date_modified']
if 'pedidos_pagados_clientes' in lookup_record[0]['fields']:
del lookup_record[0]['fields']['pedidos_pagados_clientes']
del lookup_record[0]['fields']['airtableID']
del lookup_record[0]['fields']['short_url']
base_encoded_email = urlencode({"email_login": lookup_record[0]['fields']['email_login']})
lookup_record[0]['fields']['email_login'] = email
lookup_record[0]['fields']['query_string'] = lookup_record[0]['fields']['query_string'].replace(base_encoded_email, urlencode({"email_login": email}))
new_record = at.insert(lookup_record[0]['fields'])
short_url = {'short_url': new_record['id'].split('rec')[1],
'airtableID': new_record['id'], 'visits': 0}
at.update(new_record['id'], short_url)
mensaje = "Este es tu link para compartir el protocolo {} de Prescriptum: {}/{}/".format(lookup_record[0]['fields']['nombre_protocolo'], domain_url, short_url['short_url'])
send_sms(codigo_pais_movil+movil, mensaje, "Prescriptum")
return request.args
except Exception as e:
return jsonify(error=str(e)), 403
def main():
serial = getSerial()
airtable = Airtable('app9og4P1Z4iet5fT', 'Computers', 'keybFjYyk9LuWpxNw')
computers = []
records = airtable.search('SN', serial)
print(records)
cfgDict = cfgToDict()
# print(cfgDict)
if len(records) == 0:
c = Computer(serial)
airtable.insert(createFields(c, cfgDict))
for record in records:
curr = Computer(serial, record)
computers.append(curr)
for c in computers:
airtable.update(c.comp.get('id'), createFields(c, cfgDict))
def add_mfg_part(mfg_part):
"""
Add a manufacturer part to the Manufacturer Parts table in airtable
"""
mfg_id = get_manufacturer_id(mfg_part.manufacturer.name)
part_number = mfg_part.manufacturer_part_number
manufacturer_parts = Airtable(OPERATIONS_ID, "Manufacturer Parts")
# Check if the part already exists
results = manufacturer_parts.search("Part Number", part_number)
if len(results) != 0:
return results[0]['id']
result = manufacturer_parts.insert({
"Part Number": part_number,
"Manufacturer": [
mfg_id
]
})
return result["id"]
def add_part(part):
"""
Add a part to the Inventory table in airtable
"""
# Create part_url
part_url = f"https://{Site.objects.get_current().domain}/bom/part/{part.id}"
# Get manufacturer and manfacturer part information
mfg_parts = []
for mfg_part in part.manufacturer_parts():
mfg_part_id = add_mfg_part(mfg_part)
if mfg_part_id not in mfg_parts:
mfg_parts.append(mfg_part_id)
# Get supplier and supplier part information
suppliers = []
for supplier_part in part.seller_parts():
supplier_id = get_supplier_id(supplier_part.seller.name)
if supplier_id not in suppliers:
suppliers.append(supplier_id)
part_info = {
"Part Number": part.full_part_number(),
"Description": part.description(),
"Manufacturer Part": mfg_parts,
"Supplier": suppliers,
"Django-BOM URL": part_url
}
inventory = Airtable(OPERATIONS_ID, "Inventory")
# Check if part has already been added
results = inventory.search("Part Number", part.full_part_number())
if len(results) == 0:
result = inventory.insert(part_info)
else:
result = inventory.update(results[0]['id'], part_info)
return result['id']
def success():
air_base = os.getenv('AIR_TABLE_BASE')
air_api_key = os.getenv('AIR_TABLE_API')
air_table_name = os.getenv('AIR_PEDIDOS_TABLE_NAME')
at = Airtable(air_base, air_table_name, api_key=air_api_key)
at_prot = Airtable(air_base, os.getenv('AIR_PROTOCOLO_TABLE_NAME'), api_key=air_api_key)
session_id = request.args.get('session_id', '')
session = stripe.checkout.Session.retrieve(session_id)
payment = stripe.PaymentIntent.retrieve(session['payment_intent'])
at.update_by_field('stripe_session_id', session_id, {'stripe_payment_id': payment['id']})
at.update_by_field('stripe_session_id', session_id, {'status': payment['status']})
at.update_by_field('stripe_session_id', session_id, {'paid_amount': payment['amount']/100})
pedido = at.search('stripe_session_id', session_id)[0]['fields']
protocolo = at_prot.get(pedido['protocolo'][0])['fields']
email = {'nombre_consulta': protocolo['nombre_consulta'],
'nombre_protocolo': protocolo['nombre_protocolo'],
'shipping_name': pedido['shipping_name'],
'shipping_email': pedido['shipping_email'],
'shipping_phone': pedido['shipping_phone'],
'preciofinal': protocolo['preciofinal'],
'comisionesfinal': protocolo['comisionesfinal'],
'modo_empleo': protocolo['modo_empleo'] if protocolo['modo_empleo'] else ''
}
email_login = protocolo['email_login']
subject = 'Tienes una nueva venta de tu protocolo {}'.format(email['nombre_protocolo'])
send_mail(subject, email_login, 'email.html', **email)
return render_template('success.html', **locals())
class AirTableDB:
"""
Airtable class for all airtable opeartions to table
"""
def __init__(self, base_key, api_key):
self.member_table = Airtable(base_key, "Members", api_key)
self.college_table = Airtable(base_key, "Campus", api_key)
self.skill_set = Airtable(base_key, "Skills View List", api_key)
def insert_member_details(self, data):
return self.member_table.insert(data)
def get_colleges(self):
raw_college_list = self.college_table.get_all()
college_list = [{
"id":
college.get("id"),
"name":
college.get("fields").get("Your campus/ school name"),
} for college in raw_college_list]
return college_list
def get_skills(self):
raw_skills_list = self.skill_set.get_all()
skills_list = [{
"id": skill.get("id"),
"name": skill.get("fields").get("Skill"),
} for skill in raw_skills_list]
return skills_list
def check_member_exist(self, member):
member = self.member_table.search("MobileNumber", member)
if len(member) != 0:
return member[0]["id"]
else:
return False
dns_env = 'unknown'
# Format shortname
dns_short_name = dns_short_name.replace('.clare.ai', '')
dns_short_name = dns_short_name.replace('-demo', 'Demo')
dns_short_name = dns_short_name.replace('-hkdemo', 'HKDemo')
row = {
'ShortName': dns_short_name,
'Name': dns_name,
'IP': dns_content,
'Environment': dns_env,
'LastUpdated': str(datetime.utcnow()),
'ModifiedOn': dns_modified_on
}
# Search by name
print('* Update environment for record %s' % dns_name)
exist_row = airtable.search('Name', dns_name)
if len(exist_row) == 0:
# Insert new row
airtable.insert(row)
elif len(exist_row) == 1:
last_modified = datetime.strptime(exist_row[0]['fields']['ModifiedOn'],
'%Y-%m-%dT%H:%M:%S.%fZ')
current_modified = datetime.strptime(dns_modified_on,
'%Y-%m-%dT%H:%M:%S.%fZ')
# Only update the row when dns record was modified.
if last_modified < current_modified:
# Replace exist row with new one
airtable.replace(exist_row[0]['id'], row)
else:
exit('Airtable has multiple rows with name %s' % dns_name)
def handle_people_logic(data, problem_id, rec_subgroup):
people_table = Airtable(intake_form_constants.AIRTABLE_BASE_KEY, 'People', api_key=os.environ['AIRTABLE_KEY'])
data_people = people_table.search('email', data['sponsor_email'])
# Existing Person
if len(data_people):
people_update_data = {}
logger.info(data_people)
# Add this problem to this person based on whether they are already associated with problems
if 'Problems' in data_people[0]['fields']:
people_update_data['Problems'] = data_people[0]['fields']['Problems']
if problem_id not in people_update_data['Problems']:
people_update_data['Problems'].append(problem_id)
logger.info('Added Problem List to update data')
else:
people_update_data['Problems'] = [problem_id]
logger.info('Created New Problem List for update data')
# Add subgroup/group/org to person if needed
if 'Sub Group' in data_people[0]['fields']:
people_update_data['Sub Group'] = data_people[0]['fields']['Sub Group']
logger.info('Added sub group to the update data')
if rec_subgroup['id'] not in data_people[0]['fields']['Sub Group']:
people_update_data['Sub Group'].append(rec_subgroup['id'])
logger.info('Added new subgroup to the update data')
if 'Group' in rec_subgroup['fields']:
if 'Group' not in data_people[0]['fields']:
people_update_data['Group'] = rec_subgroup['fields']['Group']
logger.info('Added Group to the update data')
else:
people_update_data['Group'] = data_people[0]['fields']['Group']
for grp in rec_subgroup['fields']['Group']:
if grp not in people_update_data['Group']:
people_update_data['Group'].append(grp)
logger.info('Added new groups to the update data')
group_table = Airtable(intake_form_constants.AIRTABLE_BASE_KEY, 'Group', api_key=os.environ['AIRTABLE_KEY'])
if 'Organization' in data_people[0]['fields']:
people_update_data['Organization'] = data_people[0]['fields']['Organization']
logger.info('Added Organization to the update data')
else:
people_update_data['Organization'] = []
for grp in people_update_data['Group']:
rec_group = group_table.get(grp)
if 'Organization' in rec_group['fields']:
for org in rec_group['fields']['Organization']:
if org not in people_update_data['Organization']:
people_update_data['Organization'].append(org)
logger.info('Added organization to the update data')
if not people_update_data['Organization']:
people_update_data.pop('Organization')
logger.info('Removing organization from update data because there are none')
rec_people = update_in_airtable(data_people[0]['id'], 'People', people_update_data)
logger.info('Updated record in airtable: {}'.format(rec_people))
if 'statusCode' in rec_people:
return False, rec_people
return True, rec_people
else:
logger.info('Creating new person entry {}'.format(data))
data_people = {'email': data['sponsor_email']}
if len(data['sponsor_name'].split(' ', 1)) > 1:
data_people['first_name'] = data['sponsor_name'].split(' ', 1)[0]
data_people['last_name'] = data['sponsor_name'].split(' ', 1)[1]
else:
data_people['first_name'] = data['sponsor_name']
if 'Group' in rec_subgroup['fields']:
data_people['Group'] = rec_subgroup['fields']['Group']
group_table = Airtable(intake_form_constants.AIRTABLE_BASE_KEY, 'Group', api_key=os.environ['AIRTABLE_KEY'])
data_people['Organization'] = []
for grp in data_people['Group']:
rec_group = group_table.get(grp)
if 'Organization' in rec_group['fields']:
for org in rec_group['fields']['Organization']:
if org not in data_people['Organization']:
data_people['Organization'].append(org)
data_people['Sub Group'] = [rec_subgroup['id']]
data_people['Problems'] = [problem_id]
if 'sponsor_division' in data:
data_people['Division'] = data['sponsor_division']
rec_people = submit_to_airtable(data_people, 'People')
logger.info('New person entry {}'.format(rec_people))
if 'statusCode' in rec_people:
return False, rec_people
return True, rec_people
from airtable import Airtable
from collections import defaultdict
import sys
from datetime import datetime
# AirTable API setup - replace the values with your own
airtable = Airtable('base-key', 'table-name', api_key='your-api-key')
# Get only records that are in the correct Status
records = airtable.search('Status', 'Ready to Post: All Data Provided')
# Create defaultdict structure
records_list = defaultdict(list)
# Process each record from AirTable
for record in records:
# For ease of code writing
record = record['fields']
# Sanitize bad data in AirTable - Formatting the information
event_title = record['Event Title'].replace("\n", "")
event_date = record['Event Date']
# Remove anything past the city name
display_city = record['Display City'].split(',')[0]
# URL might not be provided, catch this error
try:
event_url = record['Event URL']
except KeyError:
def update_airtable(df_links, airtable_base_key, airtable_table_name):
logging.info('... send to airtable ...')
# connect to airtable
airtable = Airtable(airtable_base_key,
airtable_table_name,
api_key=os.environ['AIRTABLE_KEY'])
inserted_count = 0
updated_count = 0
for i, row in df_links.iterrows():
airtable_records = airtable.search('link', row['link'])
if len(airtable_records) == 0:
logging.info('... new record ({})...'.format(row['link']))
record_fields = {
'link': row['link'],
'domain': row['domain'],
'first_seen': row['created_utc'],
'last_seen': row['created_utc'],
'first_added': row['last_seen'],
'last_added': row['last_seen'],
'times_seen': 1,
'score_avg': row['score'],
'score_min': row['score'],
'score_max': row['score'],
'score_sum': row['score'],
'title_list': row['title'],
'last_title': row['title'],
'permalink_list': row['permalink'],
'last_permalink': row['permalink'],
}
airtable.insert(record_fields)
logging.info('... inserted ...')
inserted_count += 1
elif len(airtable_records) > 0:
for record in airtable_records:
logging.info('... update record ({})...'.format(row['link']))
record_id = record['id']
old = airtable.get(record_id)['fields']
new_score_avg = (old['score_sum'] +
row['score']) / (old['times_seen'] + 1)
new_score_min = old['score_min'] if old['score_min'] <= row[
'score'] else row['score']
new_score_max = old['score_max'] if old['score_max'] >= row[
'score'] else row['score']
new_score_sum = old['score_sum'] + row['score']
new_times_seen = old['times_seen'] + 1
if row['title'] not in old['title_list']:
new_title_list = '{}|{}'.format(old['title_list'],
row['title'])
else:
new_title_list = old['title_list']
if row['permalink'] not in old['permalink_list']:
new_permalink_list = '{}|{}'.format(
old['permalink_list'], row['permalink'])
else:
new_permalink_list = old['permalink_list']
record_fields = {
'link': old['link'],
'domain': old.get('domain', 'N/A'),
'first_seen': old['first_seen'],
'last_seen': row['created_utc'],
'first_added': old['first_added'],
'last_added': row['last_seen'],
'times_seen': new_times_seen,
'score_avg': new_score_avg,
'score_min': new_score_min,
'score_max': new_score_max,
'score_sum': new_score_sum,
'title_list': new_title_list,
'last_title': row['title'],
'permalink_list': new_permalink_list,
'last_permalink': row['permalink'],
}
airtable.update(record_id, record_fields)
logging.info('... updated ...')
updated_count += 1
logging.info('... inserted_count = {} ...'.format(inserted_count))
logging.info('... updated_count = {} ...'.format(updated_count))
return inserted_count, updated_count
def gather_video_descriptions():
at_orange = Airtable(os.getenv('AT_APP_KEY_ORANGE'), 'Session hosting',
os.getenv('AT_API_KEY'))
at_optin = Airtable(os.getenv('AT_APP_KEY_ORANGE'), 'optin',
os.getenv('AT_API_KEY'))
at_gray = Airtable(os.getenv('AT_APP_KEY_GRAY'), 'submissions',
os.getenv('AT_API_KEY'))
payloads = []
for row in at_orange.get_all():
submission_ids = row['fields']['submission_ids'].split(', ')
for num, submission_id in enumerate(submission_ids):
col = f'videoid_{num}'
if col not in row['fields']:
continue
if checked(f'posted_{num}', row['fields']):
# No use in reposting the information
continue
matches = at_optin.search('submission_id', submission_id)
yes = 'I want my presentation video posted to YouTube'
if not all([match['fields']['choice'] == yes
for match in matches]) or len(matches) == 0 and (
not checked('manually_approved', row['fields'])):
# Not yet approved to send out
continue
extended_info = at_gray.match('submission_id', submission_id)
all_info = {**row['fields'], **extended_info['fields']}
if f'extra_info_{num}' in all_info:
all_info['extra_info'] = all_info[f'extra_info_{num}']
else:
all_info['extra_info'] = ""
print(all_info['extra_info'])
payload = {
'id': row['fields'][col],
'snippet': {
'title': generate_title(all_info), # Max 100 characters
'description':
generate_description(all_info), # Max 5000 bytes
'categoryId': "28",
'defaultLanguage': 'en',
},
'status': {
'embeddable': True,
'license': 'youtube',
'privacyStatus': 'public',
'publicStatsViewable': True,
'selfDeclaredMadeForKids': False,
},
'recordingDetails': {
'recordingDate': all_info['starttime']
}
}
payloads.append(payload)
return payloads
airtable_apiKey = os.environ.get("airtable_apiKey")
blogsTable = Airtable(airtable_baseKey, airtable_blogsTableName, airtable_apiKey)
blogPostsTable = Airtable(airtable_baseKey, airtable_blogPostsTableName, airtable_apiKey)
pocket_consumer_key = os.environ.get("pocket_consumer_key")
pocket_access_token = os.environ.get("pocket_access_token")
pocket_headers = { "Content-Type": "application/json; charset=UTF-8" }
for blog in blogsTable.get_all():
print blog['fields']['Name']
feed_url = blog['fields']['FeedUrl']
d = feedparser.parse(feed_url)
for post in d.entries:
results = blogPostsTable.search('Url', post.link.encode('ascii', 'ignore'))
if len(results) == 0:
payload = {
'title': post.title,
'url': post.link,
'consumer_key': pocket_consumer_key,
'access_token': pocket_access_token
}
try:
res = requests.post('https://getpocket.com/v3/add', headers=pocket_headers, data=json.dumps(payload))
except Exception as e:
sys.stderr.write('An error occurred when trying to deliver the message:\n{0}'.format(e.message))
else:
if res.ok:
blogPostsTable.insert({'Title': post.title, 'Url': post.link.encode('ascii', 'ignore')})
domains.append(domain)
df_links['domain'] = domains
df_links['domain'] = df_links['domain'].str.lower().str.replace('www.', '')
print(f' ... df_links.shape = {df_links.shape} ...')
#%%
# connect to airtable
airtable = Airtable(airtable_base_key, airtable_table_name, api_key=os.environ['AIRTABLE_KEY'])
inserted_count = 0
updated_count = 0
for i, row in df_links.iterrows():
airtable_records = airtable.search('link', row['link'])
if len(airtable_records) == 0:
print('... new record ({})...'.format(row['link']))
record_fields = {
'link': row['link'],
'domain': row['domain'],
'first_seen': row['created_utc'],
'last_seen': row['created_utc'],
'first_added': row['last_seen'],
'last_added': row['last_seen'],
'times_seen': 1,
'score_avg': row['score'],
'score_min': row['score'],
'score_max': row['score'],
'score_sum': row['score'],
'title_list': row['title'],
obj_Disk = psutil.disk_usage('/')
total = obj_Disk.total / (1024.0**3)
totalstorage = roundup(total)
# wmi gets computersystem information
c = wmi.WMI()
pcinfo = c.Win32_ComputerSystem()[0]
osinfo = c.Win32_OperatingSystem()[0]
with open("serial.txt", 'rb') as file:
s = file.read().decode('utf-16')
serialfile = s.split('\n')
serialfile[1] = serialfile[1].strip()
airtable = Airtable('app9og4P1Z4iet5fT', 'Computers', 'keybFjYyk9LuWpxNw')
computer = airtable.search('SN', serialfile[1])
print(computer)
fmake = pcinfo.Manufacturer.split(' ', 1)[0]
fram = math.ceil(int(pcinfo.TotalPhysicalMemory) / 1024**3)
fcpu = cpuinfo.get_cpu_info()['brand']
fos = osinfo.Caption.split(' ', 1)[1].strip()
fdate = arrow.now().format('YYYY-MM-DD')
if len(computer) == 0:
print("Computer not in Airtable, creating new record")
elif len(computer) > 1:
# print("Multiple records found with matching serial")
#fdept = chooseDept().strip()
# print(fdept)