def init_memcache():
client = pylibmc.Client([keys.get('redis_memcache_endpoint')],
binary=True,
username='******',
password=keys.get('redis_memcache_password'))
# Non-existent functions necessary to adhere to the memcache API expected by gae_memcache's setup_client()
client.set_servers = None
client.forget_dead_hosts = None
client.debuglog = None
client.replace_multi = None
client.offset_multi = None
if gae_memcache:
# Try to use this redis memcache for all GAE stuff seamlessly
gae_memcache.setup_client(client)
return client
def post(self):
if self.json_body:
event_id = self.json_body.get('event_id')
language = self.json_body.get('language') or self.json_body.get(
'locale')
if not event_id:
self.add_error('Need to pass event_id argument')
if not language:
self.add_error('Need to pass language/locale argument')
else:
self.add_error('Need to pass a post body of json params')
# Remap our traditional/simplified chinese languages
if language == 'zh':
language = 'zh-TW'
elif language == 'zh-Hant':
language = 'zh-TW'
elif language == 'zh-Hans':
language = 'zh-CN'
self.errors_are_fatal()
db_event = eventdata.DBEvent.get_by_id(event_id)
service = build('translate',
'v2',
developerKey=keys.get('google_server_key'))
result = service.translations().list(
target=language,
format='text',
q=[db_event.name or '', db_event.description or '']).execute()
translations = [x['translatedText'] for x in result['translations']]
self.write_json_success({
'name': translations[0],
'description': translations[1]
})
def handle(self):
logging.info('Mandrill webhook: %s', self.request)
if self.request.get('secret_key') != keys.get('mandrill_webhook_secret'):
logging.error('Got mandrill webhook with bad secret: %s', self.request.get('secret_key'))
self.response.set_status(403)
self.response.out.write('Forbidden: bad secret')
return
if not self.request.get('mandrill_events'):
logging.error('Got mandrill webhook without events')
self.response.set_status(400)
self.response.out.write('Bad Request: no mandrill_events')
return
mandrill_events = json.loads(self.request.get('mandrill_events'))
logging.info('Processing %s webhook events', len(mandrill_events))
for event in mandrill_events:
if event['event'] in ['hard_bounce', 'spam', 'unsub', 'reject']:
logging.info('Processing webhook event %s', event)
metadata = event['msg']['metadata']
if 'user_id' in metadata:
user_id = metadata['user_id']
user = users.User.get_by_id(user_id)
if metadata['email_type'] == 'weekly':
user.send_email = False
logging.info('Unsubscribing user %s (%s) in response to Mandrill %s', user.fb_uid, user.full_name, event['event'])
user.put()
else:
email = event['msg']['email']
logging.info('Unsubscribing %s in response to Mandrill %s', email, event['event'])
event_emails.unsubscribe_email(email)
def get(self):
if self.request.get('hub.mode') == 'subscribe':
if self.request.get('hub.verify_token') != keys.get('fb_webhook_verify_token'):
logging.critical('Received invalid verify_token: %s', self.request.get('hub.verify_token'))
return
self.response.out.write(self.request.get('hub.challenge'))
else:
logging.critical('Unknown hub.mode received: %s', self.request.get('hub.mode'))
def make_request(server, path, params):
new_params = params.copy()
new_params['scrapinghub_key'] = keys.get('scrapinghub_key')
data = json.dumps(new_params)
quoted_data = urllib.quote_plus(data)
f = urllib2.urlopen('http://%s/%s' % (server, path), quoted_data)
result = f.read()
return result
def post(self):
if self.json_body['scrapinghub_key'] != keys.get('scrapinghub_key'):
self.response.status = 403
return
for json_body in self.json_body['items']:
add_entities.add_update_web_event(json_body)
self.response.status = 200
def make_request(server, path, params):
new_params = params.copy()
new_params['scrapinghub_key'] = keys.get('scrapinghub_key')
data = json.dumps(new_params)
quoted_data = urllib.quote_plus(data)
f = urllib2.urlopen('http://%s/%s' % (server, path), quoted_data)
result = f.read()
return result
def post(self):
if self.json_body['scrapinghub_key'] != keys.get('scrapinghub_key'):
self.response.status = 403
return
for item in self.json_body['items']:
logging.info('Processing %s', item)
process_uploaded_item(item)
process_upload_finalization(self.json_body['studio_name'])
self.response.status = 200
def post(self):
if self.json_body['scrapinghub_key'] != keys.get('scrapinghub_key'):
self.response.status = 403
return
for item in self.json_body['items']:
logging.info('Processing %s', item)
process_uploaded_item(item)
process_upload_finalization(self.json_body['studio_name'])
self.response.status = 200
def get(self):
if self.request.get('hub.mode') == 'subscribe':
if self.request.get('hub.verify_token') != keys.get(
'fb_webhook_verify_token'):
logging.critical('Received invalid verify_token: %s',
self.request.get('hub.verify_token'))
return
self.response.out.write(self.request.get('hub.challenge'))
else:
logging.critical('Unknown hub.mode received: %s',
self.request.get('hub.mode'))
def translate(options):
queries = options.keywords
service = build('translate', 'v2', developerKey=keys.get('google_server_key'))
translations = {}
for q in queries:
for language, language_name in LANGUAGES:
result = service.translations().list(source='en', target=language, format='text', q=[q]).execute()
result_translations = [x['translatedText'] for x in result['translations']]
translation = result_translations[0].lower()
translation_repr = my_repr(canonicalize(translation, options))
translations.setdefault(translation_repr, []).append(language_name)
translation_repr = my_repr(canonicalize(q, options))
translations.setdefault(translation_repr, []).append('english')
print '\n'.join(sorted('%s, # %s' % (k, ', '.join(sorted(v))) for (k, v) in translations.items()))
def post(self):
if self.json_body['private_key'] != keys.get('private_readonly_key'):
self.response.status = 403
return
lookup_type = self.json_body['lookup_type']
lookup_kwargs = self.json_body['lookup']
if lookup_type == 'places':
result = gmaps_api.places_api.get_json(**lookup_kwargs)
elif lookup_type == 'geocode':
result = gmaps_api.geocode_api.get_json(**lookup_kwargs)
else:
self.response.status = 404
return
self.response.write(json.dumps(result))
def get_json(self, **kwargs):
post_data = json.dumps({
'private_key': keys.get('private_readonly_key'),
'lookup_type': self.lookup_type,
'lookup': kwargs,
})
url = 'https://www.dancedeets.com/_gmaps_api'
file = urllib.urlopen(url, post_data)
try:
response = file.read()
finally:
file.close()
if file.getcode() == 200:
logging.info('Returning result from prod server: %s', post_data)
return json.loads(response)
else:
return self.backend.get_json(**kwargs)
def handle(self):
logging.info('Mailchimp webhook: %s', self.request)
if self.request.get('secret_key') != keys.get('mailchimp_webhook_secret'):
self.response.set_status(403)
self.response.out.write('Forbidden: bad secret')
return ''
# email update
if self.request.get('type') == 'upemail':
if self.request.get('data[list_id]') == mailchimp_api.LIST_ID:
old_email = self.request.get('data[old_email]')
new_email = self.request.get('data[new_email]')
email_users = users.User.query(users.User.email == old_email).fetch(100)
logging.info('Found %s users for old_email %s, updating to %s', len(email_users), old_email, new_email)
for user in email_users:
user.email = new_email
user.put()
else:
logging.error('Unexpected webhook list_id: %s', self.request.get('data[list_id]'))
else:
logging.error('Unexpected webhook type: %s', self.request.get('type'))
def real_notify(user, event_id, extra_data):
if not can_notify(user):
logging.info("No android GCM tokens.")
return
# We don't pass debug=True, because gcm.py library keeps adding more loggers ad-infinitum.
# Instead we call GCM.enable_logging() once at the top-level.
g = gcm.GCM(keys.get('google_server_key'))
tokens = user.device_tokens('android')
data = {
# Important data for clientside lookups
'event_id': event_id,
}
data.update(extra_data)
response = g.json_request(registration_ids=tokens, data=data)
changed_tokens = False
if 'errors' in response:
for error, reg_ids in response['errors'].iteritems():
if error in ('NotRegistered', 'InvalidRegistration'):
for reg_id in reg_ids:
tokens.remove(reg_id)
changed_tokens = True
else:
logging.error("Error for user %s with event %s: %s", user.fb_uid, event_id, error)
if 'canonical' in response:
for reg_id, canonical_id in response['canonical'].iteritems():
tokens.remove(reg_id)
tokens.append(canonical_id)
changed_tokens = True
if changed_tokens:
user.put()
logging.info("User %s (%s), event %s: sent notification!", user.fb_uid, user.full_name, event_id)
return 'success' in response
def post(self):
if self.json_body['scrapinghub_key'] != keys.get('scrapinghub_key'):
self.response.status = 403
return
fb_uid = '701004'
user = users.User.get_by_id(fb_uid)
fbl = fb_api.FBLookup(fb_uid, user.fb_access_token)
for event_url in self.json_body['events']:
logging.info('Adding %s', event_url)
event_id = urls.get_event_id_from_url(event_url)
if not event_id:
logging.warning('Not a valid fb event for adding: %s',
event_url)
continue
fb_event = fbl.get(fb_api.LookupEvent, event_id, allow_cache=False)
try:
add_entities.add_update_fb_event(
fb_event, fbl, creating_method=eventdata.CM_AUTO_WEB)
except add_entities.AddEventException:
logging.exception('Error adding event %s', event_id)
def query(query):
search_service = PyMsCognitiveWebSearch(keys.get('bing_api_key'), query)
first_fifty_result = search_service.search(limit=10, format='json') #1-50
return [(x.name, x.display_url) for x in first_fifty_result]
from apiclient.discovery import build
from dancedeets import app
from dancedeets import base_servlet
from dancedeets import fb_api
from dancedeets import keys
from dancedeets.logic import api_format
from dancedeets.topics import grouping
from dancedeets.topics import topic_db
from dancedeets.search import search
from dancedeets.search import search_base
# Set DEVELOPER_KEY to the "API key" value from the Google Developers Console:
# https://console.developers.google.com/project/_/apiui/credential
# Please ensure that you have enabled the YouTube Data API for your project.
DEVELOPER_KEY = keys.get('google_server_key')
YOUTUBE_API_SERVICE_NAME = 'youtube'
YOUTUBE_API_VERSION = 'v3'
@app.bio_route('/?')
@app.route('/topic/?')
class TopicListHandler(base_servlet.BaseRequestHandler):
def requires_login(self):
return False
def get(self):
topics = topic_db.Topic.query().fetch(500)
self.display['topics'] = sorted(topics, key=lambda x: x.url_path)
self.render_template('topic_list')
def query(query):
search_service = PyMsCognitiveWebSearch(keys.get('bing_api_key'), query)
first_fifty_result = search_service.search(limit=10, format='json') #1-50
return [(x.name, x.display_url) for x in first_fifty_result]
from flask import Flask
from flask_graphql import GraphQL
import graphene
from dancedeets import keys
app = Flask(__name__)
app.debug = True
app.secret_key = keys.get('flask_session_key')
# http://dev.dancedeets.com:8080/graphql?query={rebels%20{name,ships(first:1%20after:%22YXJyYXljb25uZWN0aW9uOjA=%22){edges{cursor,node{name}}}}}
#from starwars import schema
schema = graphene.Schema()
class Query(graphene.ObjectType):
hello = graphene.String(description='A typical hello world')
schema.query = Query
#schema.mutation = Mutation
GraphQL(app, schema=schema)
if __name__ == '__main__':
# Start app
app.run(debug=True)
import suds.client
from dancedeets import keys
SOURCE_NAME = "DanceDeets"
SOURCE_PASSWORD = keys.get("mindbody_api_password")
_CLIENTS = {}
def get_client(service_name):
global _CLIENTS
if service_name not in _CLIENTS:
url = "https://api.mindbodyonline.com/0_5/" + service_name + "Service.asmx?wsdl"
_CLIENTS[service_name] = suds.client.Client(url)
return _CLIENTS[service_name]
def fill_credentials(client, request, site_ids):
source_creds = client.factory.create('SourceCredentials')
source_creds.SourceName = SOURCE_NAME
source_creds.Password = SOURCE_PASSWORD
source_creds.SiteIDs.int = site_ids
request.XMLDetail = 'Full'
request.SourceCredentials = source_creds
def get_request(client, request_name, site_id):
request = client.factory.create(request_name)
if hasattr(request, 'Request'):
def get_local_access_token_for_testing():
return keys.get('local_access_token_for_testing')
from dancedeets import keys
consumer_key = 'xzpiBnUCGqTWSqTgmE6XtLDpw'
consumer_secret = keys.get("twitter_consumer_secret")
import random
from firebase import firebase
import time
from dancedeets import keys
from dancedeets.servlets import api
auth = firebase.FirebaseAuthentication(keys.get('firebase_secret'), None)
db = firebase.FirebaseApplication('https://dancedeets-hrd.firebaseio.com',
auth)
#result = db.get('/events', None)
#print result
@api.apiroute(r'/event_signups/register')
class RegisterHandler(api.ApiHandler):
supports_auth = True
def post(self):
event_id = self.json_body.get('event_id')
category_id = self.json_body.get('category_id')
team = self.json_body.get('team')
team_name = team.get('team_name')
dancers = []
dancer_index = 1
while team.get('dancer_name_%s' % dancer_index):
dancer_name = team.get('dancer_name_%s' % dancer_index)
dancer_id = team.get('dancer_id_%s' % dancer_index) or dancer_name
dancers.append({'name': dancer_name, 'id': dancer_id})
dancer_index += 1
import logging
from twilio.rest import TwilioRestClient
from twilio.rest.resources import base
# This is the right import for 3.5.2
from twilio import TwilioRestException
from dancedeets import keys
# put your own credentials here
ACCOUNT_SID = "AC4fe8564ea12bfcb3af18df2ee99c2bd9"
AUTH_TOKEN = keys.get("twilio_auth_token")
class InvalidPhoneNumberException(Exception):
pass
def send_email_link(phone_number):
client = TwilioRestClient(ACCOUNT_SID, AUTH_TOKEN)
orig_get_cert_file = base.get_cert_file
try:
# We monkey patch the cert file to not use anything
base.get_cert_file = lambda: None
logging.info("Sending SMS to %s", phone_number)
client.messages.create(
to=phone_number,
from_="+12566932623",
body="Download the DanceDeets App at https://www.dancedeets.com/mobile_apps?action=download",
)
except TwilioRestException as e:
import logging
from mailchimp3 import MailChimp
import md5
from requests import exceptions
from dancedeets import keys
from dancedeets.util import runtime
client = MailChimp(keys.get('mailchimp_username'), keys.get('mailchimp_key'))
LIST_WEB_ID = 554989
LIST_ID = '93ab23d636'
class UserNotFound(Exception):
pass
def get_list_id():
lists = client.lists.all()
list_id = [x['id'] for x in lists['lists'] if x['web_id'] == LIST_WEB_ID][0]
return list_id
def add_members(list_id, members):
data = {
'members': members,
'update_existing': True,
}
if runtime.is_appengine():
return client.lists.update_members(list_id=list_id, data=data)
import logging
from twilio.rest import TwilioRestClient
from twilio.rest.resources import base
# This is the right import for 3.5.2
from twilio import TwilioRestException
from dancedeets import keys
# put your own credentials here
ACCOUNT_SID = "AC4fe8564ea12bfcb3af18df2ee99c2bd9"
AUTH_TOKEN = keys.get("twilio_auth_token")
class InvalidPhoneNumberException(Exception):
pass
def send_email_link(phone_number):
client = TwilioRestClient(ACCOUNT_SID, AUTH_TOKEN)
orig_get_cert_file = base.get_cert_file
try:
# We monkey patch the cert file to not use anything
base.get_cert_file = lambda: None
logging.info("Sending SMS to %s", phone_number)
client.messages.create(
to=phone_number,
from_="+12566932623",
body=
"Download the DanceDeets App at https://www.dancedeets.com/mobile_apps?action=download",
)
from urllib.error import HTTPError
from urllib.parse import quote
from urllib.parse import urlencode
except ImportError:
# Fall back to Python 2's urllib2 and urllib
from urllib2 import HTTPError
from urllib import quote
from urllib import urlencode
from dancedeets import keys
# OAuth credential placeholders that must be filled in by users.
# You can find them on
# https://www.yelp.com/developers/v3/manage_app
CLIENT_ID = 'jIfBNs0i8p0IQ6sjXkYyQA'
CLIENT_SECRET = keys.get('yelp_api_secret')
# API constants, you shouldn't have to change these.
API_HOST = 'https://api.yelp.com'
SEARCH_PATH = '/v3/businesses/search'
BUSINESS_PATH = '/v3/businesses/' # Business ID will come after slash.
TOKEN_PATH = '/oauth2/token'
GRANT_TYPE = 'client_credentials'
# Defaults for our simple example.
DEFAULT_TERM = 'dance studios'
DEFAULT_LOCATION = 'New York, NY'
SEARCH_LIMIT = 50
import random
from firebase import firebase
import time
from dancedeets import keys
from dancedeets.servlets import api
auth = firebase.FirebaseAuthentication(keys.get('firebase_secret'), None)
db = firebase.FirebaseApplication('https://dancedeets-hrd.firebaseio.com', auth)
#result = db.get('/events', None)
#print result
@api.apiroute(r'/event_signups/register')
class RegisterHandler(api.ApiHandler):
supports_auth = True
def post(self):
event_id = self.json_body.get('event_id')
category_id = self.json_body.get('category_id')
team = self.json_body.get('team')
team_name = team.get('team_name')
dancers = []
dancer_index = 1
while team.get('dancer_name_%s' % dancer_index):
dancer_name = team.get('dancer_name_%s' % dancer_index)
dancer_id = team.get('dancer_id_%s' % dancer_index) or dancer_name
dancers.append({'name': dancer_name, 'id': dancer_id})
dancer_index += 1
class BrowserScraperMixin(object):
# So we can log in to our scrapinghub splash instance
http_user = keys.get('scrapinghub_key')
http_pass = ''
def get_shub_project():
conn = scrapinghub.Connection(keys.get('scrapinghub_key'))
project = scrapinghub.Project(conn, 27474)
return project
import logging
from mailchimp3 import MailChimp
import md5
from requests import exceptions
from dancedeets import keys
from dancedeets.util import runtime
client = MailChimp(keys.get('mailchimp_username'), keys.get('mailchimp_key'))
LIST_WEB_ID = 554989
LIST_ID = '93ab23d636'
class UserNotFound(Exception):
pass
def get_list_id():
lists = client.lists.all()
list_id = [x['id'] for x in lists['lists']
if x['web_id'] == LIST_WEB_ID][0]
return list_id
def add_members(list_id, members):
data = {
'members': members,
'update_existing': True,
}
if runtime.is_appengine():
import hmac
import json
import logging
import urllib
from dancedeets import keys
from . import gmaps_backends
try:
from dancedeets.util import mr
except ImportError:
logging.exception('Failed to import mr module')
mr = None
from dancedeets.util import urls
google_maps_private_key = keys.get("google_maps_private_key")
google_server_key = keys.get("google_server_key")
class LiveBackend(gmaps_backends.GMapsBackend):
def __init__(self, name, protocol_host, path, use_private_key):
self.name = name
self.protocol_host = protocol_host
self.path = path
self.use_private_key = use_private_key
def get_json(self, **kwargs):
if mr:
mr.increment('gmaps-api-%s' % self.name)
if self.use_private_key:
kwargs['client'] = 'free-dancedeets'
import logging
import mandrill
from dancedeets import keys
mandrill_client = mandrill.Mandrill(keys.get('mandrill_api_key'))
def send_message(message):
try:
result = mandrill_client.messages.send(message=message, async=False)
logging.info('Message Contents: %s', message)
logging.info('Message Result: %s', result)
return result
except mandrill.Error, e:
logging.error('A mandrill error occurred: %s: %s', e.__class__, e)
logging.error('Erroring message is %s', message)
return None
def get_local_access_token_for_testing():
return keys.get('local_access_token_for_testing')
