def handle_get(http_server, database_manager, session, account):
subscription_plan_template = SubscriptionPlan(database_manager)
subscription_conditions = [{
"column": "is_active",
"equivalence": "=",
"value": 1
}]
subscription_plans = database_manager.fetch_by(subscription_plan_template,
subscription_conditions)
billing_profiles = []
for subscription_plan in subscription_plans:
billing_profiles.append({
"slug":
subscription_plan.name,
"name":
subscription_plan.name.title(),
"amount":
subscription_plan.amount,
"currency":
subscription_plan.currency,
"allowed_requests_per_month":
subscription_plan.allowed_requests_per_month,
"allowed_requests_per_month_printed":
"{:,}".format(subscription_plan.allowed_requests_per_month),
})
template = fetch_template("account/register.jinja.htm")
keys = {"billing_profiles": billing_profiles, "errors": [], "response": []}
output = template.render(keys)
http_server.print_headers()
print(output)
def handle_get(http_server, database_manager, ip, account, api_key):
query_params = http_server.get_query_parameters()
if "city" not in query_params:
raise ApiParamNoCityProvidedError
if "state" not in query_params:
raise ApiParamNoStateCodeProvidedError
raw_city_string = query_params["city"]
raw_state_code_string = query_params["state"]
city_string = raw_city_string.title()
state_code_string = raw_state_code_string.upper()
match = re.match(r'^[A-Z]{2}$', state_code_string)
if match is None:
raise ApiParamInvalidStateCodeError
zip_conditions = [
{
'column': 'city',
'equivalence': '=',
'value': city_string.upper()
},
{
'column': 'state_code',
'equivalence': '=',
'value': state_code_string
}
]
zip_codes = database_manager.fetch_by(
ZipCode(database_manager),
zip_conditions
)
if len(zip_codes) == 0:
raise ApiParamInvalidStateCodeError
state = UsState.fetch_by_code(database_manager, state_code_string)
zip_code_counties_conditions = [{
'column': 'zip',
'equivalence': ' IN ',
'value': [z.zip_code for z in zip_codes]
}]
county_percentages = database_manager.fetch_by(
county2zipCode(database_manager),
zip_code_counties_conditions
)
county_fips = []
if len(county_percentages) > 0:
county_fips = [c.get_state_county_fips() for c in county_percentages]
county_fips = list(set(county_fips))
subscription_plan = SubscriptionPlan.fetch_by_id(
database_manager,
account.subscription_plan_id
)
for header in eligible_headers:
eligible_headers[header] = get_is_eligible(
subscription_plan,
header
)
zip_totals = {}
if len(county_fips) > 0:
voting_county_conditions = [{
"column": "county_code",
"equivalence": "IN",
"value": county_fips
}]
county_totals = database_manager.fetch_by(
VotesCounty(database_manager),
voting_county_conditions
)
else:
raise ApiParamInvalidStateCodeError
for header, is_eligible in eligible_headers.items():
if is_eligible is True:
zip_totals[header] = 0
for county_total in county_totals:
for county_percentage in county_percentages:
if county_percentage.get_state_county_fips() == \
county_total.county_code:
total = getattr(
county_total,
header
)
if total is None:
total = 0
zip_totals[header] += (
round(
total * county_percentage.zip_population_percent
)
)
break
years = [str(x) for x in range(1980, 2010)]
raw_output_data = OrderedDict({})
totals = {}
for year in years:
output_year = {}
for header, value in zip_totals.items():
if year in header:
output_year[header[:-len(year)-1]] = value
if len(output_year) > 0:
raw_output_data[year] = output_year
if year not in totals:
if year in raw_output_data:
totals[year] = raw_output_data[year]["total"]
# get percentages
output_data = OrderedDict({})
notes = []
for year in raw_output_data:
output_data[year] = {"breakdown":{}}
for key, value in raw_output_data[year].items():
if key != "total":
output_data[year]["breakdown"][key] = 100 * value / totals[year]
if get_is_eligible(subscription_plan, "totals") is True:
output_data[year]['total_votes'] = totals[year]
else:
notes.append("Upgrade to a paid plan for totals")
if len(output_data) == 1:
notes.append("Upgrade plan for historical data")
notes = list(set(notes))
state_name = ""
state_code = ""
if state.code is not None:
state_code = state.code
if state.name is not None:
state_name = state.name
output = OrderedDict({
"voting_ranges": output_data,
"units": "percent",
"location": {
"city": {
"name": city_string,
},
"state": {
"name": state_name,
"code": state_code.upper(),
"api_endpoint": '/v1/race/state?code={}'.format(state_code.upper()),
},
"country": {
"name": "United States of America",
"code": "US",
"api_endpoint": '/v1/race/country?code=US',
}
},
"notes": notes
})
http_server.print_headers()
http_server.print_json(output)
def handle_get(http_server, database_manager, ip, account, api_key):
query_params = http_server.get_query_parameters()
if "code" not in query_params:
raise ApiParamNoCountryCodeProvidedError
raw_country_code_string = query_params["code"]
country_code_string = raw_country_code_string.upper()
if country_code_string is None:
raise ApiParamInvalidCountryCodeError
match = re.match(r'^[A-Za-z]{2}$', country_code_string)
if match is None:
raise ApiParamInvalidCountryCodeError
country = Country.fetch_by_code(database_manager, country_code_string)
if country is None:
raise ApiParamInvalidCountryCodeError
country_name = country.name
if country.code == "US":
country_name = "United States"
county_total = GenderCounty.fetch_by_country_name(database_manager,
country_name.upper())
subscription_plan = SubscriptionPlan.fetch_by_id(
database_manager, account.subscription_plan_id)
for header in eligible_headers:
eligible_headers[header] = get_is_eligible(subscription_plan, header)
zip_totals = {}
for header, is_eligible in eligible_headers.items():
if is_eligible is True:
zip_totals[header] = 0
total = getattr(county_total, header)
if total is None:
total = 0
zip_totals[header] = (round(total))
years = [str(year) for year in range(2000, 2010)]
raw_output_data = OrderedDict({})
totals = {}
for year in years:
output_year = {}
for header, value in zip_totals.items():
if year in header:
output_year[header[:-len(year) - 1]] = value
if len(output_year) > 0:
raw_output_data[year] = output_year
if year not in totals:
if year in raw_output_data:
totals[year] = sum(
[v for k, v in raw_output_data[year].items()])
# get percentages
output_data = OrderedDict({})
notes = []
for year in raw_output_data:
output_data[year] = {"breakdown": {}}
for key, value in raw_output_data[year].items():
output_data[year]["breakdown"][key] = 100 * value / totals[year]
if get_is_eligible(subscription_plan, "totals") is True:
output_data[year]['total'] = totals[year]
else:
notes.append("Upgrade to a paid plan for totals")
if len(output_data) == 1:
notes.append("Upgrade plan for historical data")
notes = list(set(notes))
output = OrderedDict({
"gender_breakdown": output_data,
"units": "percent",
"location": {
"country": {
"name": "United States of America",
"code": "US",
}
},
"notes": notes
})
http_server.print_headers()
http_server.print_json(output)
def handle_get(http_server, database_manager, session, account):
if account.is_phone_verified != 1:
redirect_to_phone_confirmation(http_server, database_manager, session,
account)
else:
keys = {'current_page': "billing"}
template = fetch_template("account/billing.jinja.htm")
# http_server.print_headers()
# print(dict(account))
subscription_plan_template = SubscriptionPlan(database_manager)
subscription_conditions = [{
"column": "is_active",
"equivalence": "=",
"value": 1
}]
subscription_plans = database_manager.fetch_by(
subscription_plan_template, subscription_conditions)
subscription_plan_name = None
account_subscription_plan = None
billing_profiles = []
for subscription_plan in subscription_plans:
if subscription_plan.id == account.subscription_plan_id:
subscription_plan_name = subscription_plan.name
account_subscription_plan = subscription_plan
billing_profiles.append({
"slug":
subscription_plan.name,
"name":
subscription_plan.name.title(),
"amount":
subscription_plan.amount,
"currency":
subscription_plan.currency,
"allowed_requests_per_month":
subscription_plan.allowed_requests_per_month,
"allowed_requests_per_month_printed":
"{:,}".format(subscription_plan.allowed_requests_per_month),
})
next_billing_date = account.get_next_billing_date()
if account.stripe_subscription_id is not None and \
account.stripe_subscription_id != "":
stripe.api_key = settings["stripe"]["secret_key"]
stripe_subscription = stripe.Subscription.retrieve(
account.stripe_subscription_id)
next_billing_date = datetime.utcfromtimestamp(
stripe_subscription.current_period_end)
keys = {
"current_page":
"billing",
"billing_profiles":
billing_profiles,
"current_plan_name":
subscription_plan_name,
"errors": [],
"response": [],
"billing_profile_name":
account_subscription_plan.name.title(),
"monthly_cost":
"{:,.2f}".format(account_subscription_plan.amount),
"currency":
account_subscription_plan.currency,
"billing_day":
account.billing_day,
"billing_day_ordinality":
get_ordinality(account.billing_day),
"next_billing_date":
next_billing_date.strftime("%Y-%m-%d"),
"max_api_calls":
"{:,}".format(
account_subscription_plan.allowed_requests_per_month),
"selected_subscription_plan_name":
account_subscription_plan.name
}
output = template.render(keys)
http_server.print_headers()
print(output)
def handle_put_post(http_server, database_manager, session, account):
if account.is_phone_verified != 1:
redirect_to_phone_confirmation(http_server, database_manager, session,
account)
else:
keys = {'current_page': "billing"}
template = fetch_template("account/billing.jinja.htm")
# http_server.print_headers()
# print(dict(account))
subscription_plan_template = SubscriptionPlan(database_manager)
subscription_conditions = [{
"column": "is_active",
"equivalence": "=",
"value": 1
}]
subscription_plans = database_manager.fetch_by(
subscription_plan_template, subscription_conditions)
subscription_plan_name = None
account_subscription_plan = None
billing_profiles = []
for subscription_plan in subscription_plans:
if subscription_plan.id == account.subscription_plan_id:
subscription_plan_name = subscription_plan.name
account_subscription_plan = subscription_plan
billing_profiles.append({
"slug":
subscription_plan.name,
"name":
subscription_plan.name.title(),
"amount":
subscription_plan.amount,
"currency":
subscription_plan.currency,
"allowed_requests_per_month":
subscription_plan.allowed_requests_per_month,
"allowed_requests_per_month_printed":
"{:,}".format(subscription_plan.allowed_requests_per_month),
})
next_billing_date = account.get_next_billing_date()
if account.stripe_subscription_id is not None and \
account.stripe_subscription_id != "":
stripe.api_key = settings["stripe"]["secret_key"]
stripe_subscription = stripe.Subscription.retrieve(
account.stripe_subscription_id)
next_billing_date = datetime.utcfromtimestamp(
stripe_subscription.current_period_end)
keys = {
"current_page":
"billing",
"billing_profiles":
billing_profiles,
"current_plan_name":
subscription_plan_name,
"errors": [],
"response": [],
"billing_profile_name":
account_subscription_plan.name.title(),
"monthly_cost":
"{:,.2f}".format(account_subscription_plan.amount),
"currency":
account_subscription_plan.currency,
"billing_day":
account.billing_day,
"billing_day_ordinality":
get_ordinality(account.billing_day),
"next_billing_date":
next_billing_date.strftime("%Y-%m-%d"),
"max_api_calls":
"{:,}".format(
account_subscription_plan.allowed_requests_per_month),
"selected_subscription_plan_name":
account_subscription_plan.name
}
# new get post info
errors = []
required_keys = [
"billing_id",
]
post_params = http_server.get_post_parameters()
if "billing_id" in post_params:
if post_params["billing_id"] != "free":
required_keys += ["stripe_token"]
keys["response"] = post_params
for required_key in required_keys:
if required_key not in post_params or post_params[
required_key] == "":
errors.append(required_key)
if len(errors) == 0:
subscription_plan_name = post_params["billing_id"]
subscription_plan = SubscriptionPlan.fetch_by_name(
database_manager, subscription_plan_name)
if subscription_plan is None:
errors.append("billing_id")
keys["errors"] = errors
for error in errors:
keys["error_{}".format(error)] = True
if len(errors) > 0:
output = template.render(keys)
# http_server.set_status(400)
http_server.print_headers()
print(output)
else:
if account.stripe_customer_id:
stripe_subscription_id = account.stripe_subscription_id
if account.stripe_subscription_id:
try:
subscription = stripe.Subscription.retrieve(
account.stripe_subscription_id)
subscription.delete()
except:
pass
stripe_source_token = None
stripe_subscription_id = None
if subscription_plan.amount > 0:
stripe.api_key = settings["stripe"]["secret_key"]
stripe_plan = stripe.Plan.retrieve(subscription_plan.stripe_id)
# How to acquire stripe tokens
# https://stripe.com/docs/sources/cards
stripe_source_token = post_params["stripe_token"]
stripe_customer_description = account.email
# will throw an exception if it fails. Must catch
subscription = stripe.Subscription.create(
customer=account.stripe_customer_id,
items=[{
"plan": stripe_plan.id
}])
stripe_subscription_id = subscription.id
billing_epoch = datetime.now()
account.subscription_plan_id = subscription_plan.id
account.stripe_source_id = stripe_source_token
account.stripe_subscription_id = stripe_subscription_id
account.billing_interval = "monthly"
account.billing_year = billing_epoch.year
account.billing_month = billing_epoch.month
account.billing_day = billing_epoch.day
account.update()
#keys["update_succeeded"] = True
# retrieve updated subscription plan info
subscription_plan_name = None
account_subscription_plan = None
billing_profiles = []
for subscription_plan in subscription_plans:
if subscription_plan.id == account.subscription_plan_id:
subscription_plan_name = subscription_plan.name
account_subscription_plan = subscription_plan
billing_profiles.append({
"slug":
subscription_plan.name,
"name":
subscription_plan.name.title(),
"amount":
subscription_plan.amount,
"currency":
subscription_plan.currency,
"allowed_requests_per_month":
subscription_plan.allowed_requests_per_month,
"allowed_requests_per_month_printed":
"{:,}".format(
subscription_plan.allowed_requests_per_month),
})
next_billing_date = account.get_next_billing_date()
if account.stripe_subscription_id is not None and \
account.stripe_subscription_id != "":
stripe.api_key = settings["stripe"]["secret_key"]
stripe_subscription = stripe.Subscription.retrieve(
account.stripe_subscription_id)
next_billing_date = datetime.utcfromtimestamp(
stripe_subscription.current_period_end)
keys = {
'current_page':
"billing",
"update_succeeded":
True,
"billing_profiles":
billing_profiles,
"current_plan_name":
subscription_plan_name,
"errors": [],
"response": [],
"billing_profile_name":
account_subscription_plan.name.title(),
"monthly_cost":
"{:,.2f}".format(account_subscription_plan.amount),
"currency":
account_subscription_plan.currency,
"billing_day":
account.billing_day,
"billing_day_ordinality":
get_ordinality(account.billing_day),
"next_billing_date":
next_billing_date.strftime("%Y-%m-%d"),
"max_api_calls":
"{:,}".format(
account_subscription_plan.allowed_requests_per_month),
"selected_subscription_plan_name":
account_subscription_plan.name
}
http_server.set_status(200)
http_server.print_headers()
output = template.render(keys)
print(output)
def handle_get(http_server, database_manager, ip, account, api_key):
query_params = http_server.get_query_parameters()
if "zip" not in query_params:
raise ApiParamNoZipCodeProvidedError
raw_zip_code_string = query_params["zip"]
zip_code_string = raw_zip_code_string
if "-" in raw_zip_code_string:
dash_position = raw_zip_code_string.find("-")
zip_code_string = raw_zip_code_string[0:dash_position]
match = re.match(r'^\d+$', zip_code_string)
if match is None:
raise ApiParamInvalidZipCodeError
zip_code_int = int(zip_code_string)
zip_code = ZipCode.fetch_by_zip_int(database_manager,
zip_code_int,
is_decommisioned=False)
if zip_code is None:
raise ApiParamInvalidZipCodeError
state = UsState.fetch_by_id(database_manager, zip_code.state_id)
city_name = zip_code.city
if zip_code.city is not None:
city_name = zip_code.city.title()
county_percentages = zip_code.get_county_percentages()
county_fips = []
if len(county_percentages) > 0:
county_fips = [c.get_state_county_fips() for c in county_percentages]
county_fips = list(set(county_fips))
subscription_plan = SubscriptionPlan.fetch_by_id(
database_manager, account.subscription_plan_id)
for header in eligible_headers:
eligible_headers[header] = get_is_eligible(subscription_plan, header)
zip_totals = {}
if len(county_fips) > 0:
population_county_conditions = [{
"column": "county_code",
"equivalence": "IN",
"value": county_fips
}]
county_totals = database_manager.fetch_by(
PopulationCounty(database_manager), population_county_conditions)
else:
raise ApiParamInvalidZipCodeError
for header, is_eligible in eligible_headers.items():
if is_eligible is True:
zip_totals[header] = 0
for county_total in county_totals:
for county_percentage in county_percentages:
if county_percentage.get_state_county_fips() == \
county_total.county_code:
total = getattr(county_total, header)
if total is None:
total = 0
zip_totals[header] += (round(
total * county_percentage.zip_population_percent))
break
years = [str(x) for x in range(1930, 2011)]
raw_output_data = OrderedDict({})
totals = {}
for year in years:
output_year = {}
for header, value in zip_totals.items():
if year in header:
output_year[header[:-len(year) - 1]] = value
if len(output_year) > 0:
raw_output_data[year] = output_year
# get percentages
output_data = OrderedDict({})
notes = []
for year in raw_output_data:
output_data[year] = None
for key, value in raw_output_data[year].items():
output_data[year] = value
if len(output_data) == 1:
notes.append("Upgrade plan for historical data")
notes = list(set(notes))
state_name = ""
state_code = ""
if state.code is not None:
state_code = state.code
if state.name is not None:
state_name = state.name
output = OrderedDict({
"population_estimates": output_data,
"units": "people",
"location": {
"city": {
"name":
city_name,
"api_endpoint":
'/v1/population/city?city={}&state={}'.format(
requote_uri(city_name), state_code.upper()),
},
"state": {
"name":
state_name,
"code":
state_code.upper(),
"api_endpoint":
'/v1/population/state?code={}'.format(state_code.upper()),
},
"country": {
"name": "United States of America",
"code": "US",
"api_endpoint": '/v1/population/country?code=US',
}
},
"notes": notes
})
http_server.print_headers()
http_server.print_json(output)
def handle_put_post(http_server, database_manager, session, account):
subscription_plan_template = SubscriptionPlan(database_manager)
subscription_conditions = [{
"column": "is_active",
"equivalence": "=",
"value": 1
}]
subscription_plans = database_manager.fetch_by(subscription_plan_template,
subscription_conditions)
billing_profiles = []
for available_subscription_plan in subscription_plans:
billing_profiles.append({
"slug":
available_subscription_plan.name,
"name":
available_subscription_plan.name.title(),
"amount":
available_subscription_plan.amount,
"currency":
available_subscription_plan.currency,
"allowed_requests_per_month":
available_subscription_plan.allowed_requests_per_month,
"allowed_requests_per_month_printed":
"{:,}".format(
available_subscription_plan.allowed_requests_per_month),
})
template = fetch_template("account/register.jinja.htm")
keys = {
"current_page": "register",
"billing_profiles": billing_profiles,
}
errors = []
required_keys = [
"billing_id",
"email",
"password",
"verify_password",
"phone",
#"g-recaptcha-response"
]
post_params = http_server.get_post_parameters()
if "billing_id" in post_params:
if post_params["billing_id"] != "free":
required_keys += ["stripe_token"]
keys["response"] = post_params
for required_key in required_keys:
if required_key not in post_params or post_params[required_key] == "":
errors.append(required_key)
if len(errors) == 0:
email = post_params["email"]
password = post_params["password"]
verify_password = post_params["verify_password"]
phone = post_params["phone"]
formatted_number = phone
if password != verify_password:
errors.append("verify_password")
#try:
phone_details = phonenumbers.parse(phone, "US")
if phonenumbers.is_valid_number(phone_details) is False:
errors.append("phone")
else:
formatted_number = "+{} {}".format(
phone_details.country_code,
phonenumbers.format_number(
phone_details, phonenumbers.PhoneNumberFormat.NATIONAL))
client = Client(settings["twilio"]["account_sid"],
settings["twilio"]["auth_token"])
twilio_phone_details = client.lookups.phone_numbers(
formatted_number).fetch(type='carrier')
if twilio_phone_details.carrier["error_code"] is not None:
errors.append("phone")
else:
if twilio_phone_details.carrier["type"] == "voip":
errors.append("phone_voip")
#except:
# errors.append("phone")
if validate_email(email) is False:
errors.append("email")
else:
subscription_plan_name = post_params["billing_id"]
subscription_plan = SubscriptionPlan.fetch_by_name(
database_manager, subscription_plan_name)
if subscription_plan is None:
errors.append("billing_id")
keys["errors"] = errors
for error in errors:
keys["error_{}".format(error)] = True
if len(errors) > 0:
output = template.render(keys)
# http_server.set_status(400)
http_server.print_headers()
print(output)
else:
is_captcha_valid = True
'''
recaptcha_response = post_params['g-recaptcha-response']
captcha_data = {
"secret": settings["google_recaptcha3"]["secret_key"],
"response": recaptcha_response
}
recaptcha_response = requests.post(
settings["google_recaptcha3"],
data=captcha_data
)
recapcha_json = recaptcha_response.json()
is_captcha_valid = True
if recapcha_json['success']:
is_captcha_valid = True
else:
is_captcha_valid = False
'''
if is_captcha_valid is False:
keys["error_invalid_captcha"] = True
output = template.render(keys)
# http_server.set_status(400)
http_server.print_headers()
print(output)
else:
is_marketing_ok = False
if "subscribe" in post_params:
if int(post_params["subscribe"]) == 1:
is_marketing_ok = True
keys["is_marketing_ok"] = True
do_continue = True
stripe_source_token = None
stripe_customer_id = None
stripe_subscription_id = None
if subscription_plan.amount > 0:
stripe.api_key = settings["stripe"]["secret_key"]
discount_code = None
stripe_coupon = None
stripe_coupon_id = None
if "discount_code" in post_params:
discount_code = post_params["discount_code"]
try:
stripe_coupon = stripe.Coupon.retrieve(discount_code)
do_continue = True
stripe_coupon_id = stripe_coupon.id
except Exception:
errors += ["discount_code"]
keys["errors"] = errors
for error in errors:
keys["error_{}".format(error)] = True
output = template.render(keys)
# http_server.set_status(400)
http_server.print_headers()
print(output)
if do_continue is True:
stripe_plan = stripe.Plan.retrieve(
subscription_plan.stripe_id)
# How to acquire stripe tokens
# https://stripe.com/docs/sources/cards
# if "stripe_token" not in post_params:
# raise ApiParamMissingStripeTokenError
stripe_source_token = post_params["stripe_token"]
stripe_customer_description = email
try:
customer = stripe.Customer.create(
description=stripe_customer_description,
source=stripe_source_token)
stripe_customer_id = customer.id
# will throw an exception if it fails. Must catch
subscription = stripe.Subscription.create(
customer=stripe_customer_id,
items=[{
"plan": stripe_plan.id
}],
coupon=stripe_coupon_id)
stripe_subscription_id = subscription.id
except Exception:
errors += ["duplicate_submission"]
keys["errors"] = errors
for error in errors:
keys["error_{}".format(error)] = True
output = template.render(keys)
# http_server.set_status(400)
http_server.print_headers()
print(output)
do_continue = False
if do_continue is True:
# verify email doesn't already exist
account = Account.fetch_by_email(database_manager, email)
if account is not None:
errors += ["email_taken"]
keys["errors"] = errors
for error in errors:
keys["error_{}".format(error)] = True
output = template.render(keys)
# http_server.set_status(400)
http_server.print_headers()
print(output)
else:
registration = AccountRegistration.fetch_by_email(
database_manager, email)
if registration is not None:
errors += ["email_taken"]
keys["errors"] = errors
for error in errors:
keys["error_{}".format(error)] = True
output = template.render(keys)
# http_server.set_status(400)
http_server.print_headers()
print(output)
else:
registration_epoch = datetime.now()
registration = AccountRegistration(database_manager)
registration.email = post_params["email"]
registration.password = post_params["password"]
registration.phone = formatted_number
registration.subscription_plan_id = subscription_plan.id
registration.is_marketing_ok = is_marketing_ok
registration.stripe_source_id = stripe_source_token
registration.stripe_customer_id = stripe_customer_id
registration.stripe_subscription_id = stripe_subscription_id
registration.billing_interval = "monthly"
registration.billing_year = registration_epoch.year
registration.billing_month = registration_epoch.month
registration.billing_day = registration_epoch.day
confirmation_code = registration.generate_confirmation_code(
)
# send confirmation email
courier = Courier(settings["sendgrid"])
from_email = settings["email"]["from"]["email"]
subject = "Confirm your account"
template_id = "d-46d40e8316ba439095fdefb20b171a3e"
substitutions = {"confirm_code": confirmation_code}
response = courier.send_template_email(
email, from_email, subject, template_id,
substitutions)
if response.status_code != 202:
errors += ["email_delivery"]
keys["errors"] = errors
for error in errors:
keys["error_{}".format(error)] = True
output = template.render(keys)
# http_server.set_status(400)
http_server.print_headers()
print(output)
else:
registration.insert()
template = fetch_template(
"account/register-success.jinja.htm")
keys["email"] = post_params["email"]
http_server.set_status(200)
http_server.print_headers()
output = template.render(keys)
print(output)
def handle_get(http_server, database_manager, ip, account, api_key):
query_params = http_server.get_query_parameters()
if "code" not in query_params:
raise ApiParamNoStateCodeProvidedError
raw_state_code_string = query_params["code"]
state_code_string = raw_state_code_string.upper()
match = re.match(r'^[A-Za-z]{2}$', state_code_string)
if match is None:
raise ApiParamInvalidStateCodeError
state = UsState.fetch_by_code(database_manager, state_code_string)
if state is None:
raise ApiParamInvalidStateCodeError
county_total = AncestryCounty.fetch_by_state_name(database_manager,
state.name.upper())
subscription_plan = SubscriptionPlan.fetch_by_id(
database_manager, account.subscription_plan_id)
for header in eligible_headers:
eligible_headers[header] = get_is_eligible(subscription_plan, header)
zip_totals = {}
for header, is_eligible in eligible_headers.items():
if is_eligible is True:
zip_totals[header] = 0
total = getattr(county_total, header)
if total is None:
total = 0
zip_totals[header] = (round(total))
years = [str(x) for x in range(1980, 2010)]
raw_output_data = OrderedDict({})
totals = {}
for year in years:
output_year = {}
for header, value in zip_totals.items():
if year in header:
output_year[header[:-len(year) - 1]] = value
if len(output_year) > 0:
raw_output_data[year] = output_year
if year not in totals:
totals[year] = 0
else:
totals[year] += value
# get percentages
output_data = OrderedDict({})
notes = []
for year in raw_output_data:
output_data[year] = {"breakdown": {}}
for key, value in raw_output_data[year].items():
output_data[year]["breakdown"][key] = value / totals[year]
if get_is_eligible(subscription_plan, "totals") is True:
output_data[year]['total'] = totals[year]
else:
notes.append("Upgrade to a paid plan for totals")
if len(output_data) == 1:
notes.append("Upgrade plan for historical data")
notes = list(set(notes))
output = {
"ancestry_ranges": output_data,
"units": "percent",
"location": {
"state": {
"name": state.name,
"code": state.code.upper(),
},
"country": {
"name": "United States of America",
"code": "US",
"api_endpoint": '/v1/ancestry/country?code=US',
}
},
"notes": notes
}
http_server.print_headers()
http_server.print_json(output)
def handle_get(http_server, database_manager, session, account):
keys = {
"current_page": "register"
}
template = fetch_template("account/confirm.jinja.htm")
query_parameters = http_server.get_query_parameters()
if "code" not in query_parameters:
keys["no_code_provided"] = True
output = template.render(keys)
# http_server.set_status(400)
http_server.print_headers()
print(output)
else:
code = query_parameters["code"]
registration = AccountRegistration.fetch_by_confirmation_code(
database_manager,
code
)
if registration is None:
keys["invalid_code"] = True
output = template.render(keys)
# http_server.set_status(400)
http_server.print_headers()
print(output)
else:
existing_account = Account.fetch_by_from_registration_id(
database_manager,
registration.id
)
if existing_account is not None:
keys["already_confirmed"] = True
output = template.render(keys)
# http_server.set_status(400)
http_server.print_headers()
print(output)
else:
account = Account.from_registration(registration)
account.insert()
if account.id is None or account.id < 1:
account = Account.fetch_by_from_registration_id(
database_manager,
registration.id
)
subscription = SubscriptionPlan.fetch_by_id(
database_manager,
account.subscription_plan_id
)
if subscription is None:
subscription = SubscriptionPlan.fetch_by_name(
database_manager,
"free"
)
new_api_key = ApiKey(database_manager)
new_api_key.generate_key()
new_api_key.generate_secret()
new_api_key.account_id = account.id
new_api_key.update_plan(subscription)
new_api_key.insert()
# log in
ip_string = http_server.get_remote_address()
session = Session(database_manager)
session.set_expiration_days_from_now(
settings["confirm_page"]["session_timeout_days"]
)
session_slug = session.generate_slug()
session.account_id = account.id
session.ip_address = ip_string
session.slug = session_slug
session.insert()
http_server.set_cookie("session_id", session_slug)
output = template.render(keys)
http_server.print_headers()
print(output)
def handle_get(http_server, database_manager, ip, account, api_key):
query_params = http_server.get_query_parameters()
if "code" not in query_params:
raise ApiParamNoStateCodeProvidedError
raw_state_code_string = query_params["code"]
state_code_string = raw_state_code_string.upper()
match = re.match(r'^[A-Za-z]{2}$', state_code_string)
if match is None:
raise ApiParamInvalidStateCodeError
state = UsState.fetch_by_code(database_manager, state_code_string)
if state is None:
raise ApiParamInvalidStateCodeError
county_total = EducationCounty.fetch_by_state_name(database_manager,
state.name.upper())
subscription_plan = SubscriptionPlan.fetch_by_id(
database_manager, account.subscription_plan_id)
for header in eligible_headers:
eligible_headers[header] = get_is_eligible(subscription_plan, header)
zip_totals = {}
for header, is_eligible in eligible_headers.items():
if is_eligible is True:
zip_totals[header] = 0
total = getattr(county_total, header)
if total is None:
total = 0
zip_totals[header] = (round(total))
years = ["1980", "1990", "2000", "2009"]
raw_output_data = OrderedDict({})
totals = {}
for year in years:
output_year = {}
for header, value in zip_totals.items():
if "num_adults" not in header:
if year in header:
ending = year
end = len(ending) + 1
if "_2005_" in header:
ending = "2005_{}".format(year)
end = len(ending) + 1
output_year[header[:-end]] = 100 * value / zip_totals[
"num_adults_{}".format(ending)]
if len(output_year) > 0:
raw_output_data[year] = output_year
if year not in totals:
if year in raw_output_data:
ending = year
if year == "2009":
ending = "2005_2009"
totals[year] = zip_totals["num_adults_{}".format(ending)]
# get percentages
output_data = OrderedDict({})
notes = []
for year in raw_output_data:
output_data[year] = {"breakdown": {}}
for key, value in raw_output_data[year].items():
output_data[year]["breakdown"][key] = value
if get_is_eligible(subscription_plan, "totals") is True:
output_data[year]['total_adults'] = totals[year]
else:
notes.append("Upgrade to a paid plan for totals")
notes = list(set(notes))
state_name = ""
state_code = ""
if state.code is not None:
state_code = state.code
if state.name is not None:
state_name = state.name
output = {
"education_ranges": output_data,
"location": {
"state": {
"name": state.name,
"code": state.code.upper(),
},
"country": {
"name": "United States of America",
"code": "US",
"api_endpoint": '/v1/education/country?code=US',
}
},
"notes": notes
}
http_server.print_headers()
http_server.print_json(output)
def handle_get(http_server, database_manager, ip, account, api_key):
query_params = http_server.get_query_parameters()
if "zip" not in query_params:
raise ApiParamNoZipCodeProvidedError
raw_zip_code_string = query_params["zip"]
zip_code_string = raw_zip_code_string
if "-" in raw_zip_code_string:
dash_position = raw_zip_code_string.find("-")
zip_code_string = raw_zip_code_string[0:dash_position]
match = re.match(r'^\d+$', zip_code_string)
if match is None:
raise ApiParamInvalidZipCodeError
zip_code_int = int(zip_code_string)
zip_code = ZipCode.fetch_by_zip_int(
database_manager,
zip_code_int,
is_decommisioned=False
)
if zip_code is None:
raise ApiParamInvalidZipCodeError
state = UsState.fetch_by_id(database_manager, zip_code.state_id)
city_name = zip_code.city
if zip_code.city is not None:
city_name = zip_code.city.title()
county_percentages = zip_code.get_county_percentages()
county_fips = []
if len(county_percentages) > 0:
county_fips = [c.get_state_county_fips() for c in county_percentages]
county_fips = list(set(county_fips))
subscription_plan = SubscriptionPlan.fetch_by_id(
database_manager,
account.subscription_plan_id
)
for header in eligible_headers:
eligible_headers[header] = get_is_eligible(
subscription_plan,
header
)
zip_totals = {}
if len(county_fips) > 0:
education_county_conditions = [{
"column": "county_code",
"equivalence": "IN",
"value": county_fips
}]
county_totals = database_manager.fetch_by(
EducationCounty(database_manager),
education_county_conditions
)
else:
raise ApiParamInvalidZipCodeError
for header, is_eligible in eligible_headers.items():
if is_eligible is True:
zip_totals[header] = 0
for county_total in county_totals:
for county_percentage in county_percentages:
if county_percentage.get_state_county_fips() == \
county_total.county_code:
total = getattr(
county_total,
header
)
if total is None:
total = 0
zip_totals[header] = (
round(
total * county_percentage.zip_population_percent
)
)
break
years = ["1980", "1990", "2000", "2009"]
raw_output_data = OrderedDict({})
totals = {}
for year in years:
output_year = {}
for header, value in zip_totals.items():
if "num_adults" not in header:
if year in header:
ending = year
end = len(ending) + 1
if "_2005_" in header:
ending = "2005_{}".format(year)
end = len(ending) + 1
output_year[header[:-end]] = 100 * value / zip_totals[
"num_adults_{}".format(ending)
]
if len(output_year) > 0:
raw_output_data[year] = output_year
if year not in totals:
if year in raw_output_data:
ending = year
if year == "2009":
ending = "2005_2009"
totals[year] = zip_totals["num_adults_{}".format(ending)]
# get percentages
output_data = OrderedDict({})
notes = []
for year in raw_output_data:
output_data[year] = {"breakdown":{}}
for key, value in raw_output_data[year].items():
output_data[year]["breakdown"][key] = value
if get_is_eligible(subscription_plan, "totals") is True:
output_data[year]['total_adults'] = totals[year]
else:
notes.append("Upgrade to a paid plan for totals")
if len(output_data) == 1:
notes.append("Upgrade plan for historical data")
notes = list(set(notes))
state_name = ""
state_code = ""
if state.code is not None:
state_code = state.code
if state.name is not None:
state_name = state.name
output = OrderedDict({
"education_ranges": output_data,
"city": {
"name": city_name,
"api_endpoint": '/v1/education/city?city={}&state={}'.format(
requote_uri(city_name),
state_code.upper()
),
},
"state": {
"name": state_name,
"code": state_code.upper(),
"api_endpoint": '/v1/education/state?code={}'.format(state_code.upper()),
},
"country": {
"name": "United States of America",
"code": "US",
"api_endpoint": '/v1/education/country?code=US',
}
})
http_server.print_headers()
http_server.print_json(output)