from eventbrite import Eventbrite
import yaml
import datetime
import pytz
with open('input.yml', 'r') as file:
data = yaml.load(file)
output = open('result.csv', 'w')
output.write("Date,Time,Link,Status,Presenter,Capacity,Password\n")
eventbrite = Eventbrite(data['token'])
user = eventbrite.get_user()
for e in data['events']:
for d in e['when']:
tz = pytz.timezone(e['tz'])
date = tz.localize(datetime.datetime.strptime(d, '%b-%d %Y %I%p'))
name = 'OpenShift Workshop (%s)(%s)' % (date.strftime('%b-%d;%I%p'),
e['who'])
event = eventbrite.get_user_events(user['id'], **{'name_filter': name})
if len(event['events']) > 0:
print('Event %s already exists' % name)
event = event['events'][0]
else:
event = eventbrite.post_event({
'event.name': {
'html': name
},
'subcategory':
i['category']['name'],
'distance_to_totem_1':
vincenty((i['lat'], i['lon']),
(totem_location_1_lat, totem_location_1_lon)).meters,
'distance_to_totem_2':
vincenty((i['lat'], i['lon']),
(totem_location_2_lat, totem_location_2_lon)).meters
}]
places_all.append(places)
except Exception, e:
if str(e) == 'KeyError':
pass
##### Eventbrite cleaning and adding poi properties. Need to call the API again for the catgories.
eventbrite_categories = Eventbrite(
keys["eventbrite_key"]).get_categories()['categories']
for i in filter(lambda d: d['category_id'] != None, data_eventbrite):
places = {}
places['category'] = 'event'
places['name'] = i['name']['text']
places['coordinates'] = [i['longitude'], i['latitude']]
places['address'] = i['address']['address_1']
places['source'] = 'eventbrite'
places['properties'] = [{
'free':
i['is_free'],
'start':
i['start']['local'],
'description':
i['description']['text'],
'subcategory': [
def __init__(self, provider_id, oauth_token):
super().__init__(provider_id)
self.client = Eventbrite(oauth_token=oauth_token)
def delete_webhook(token, webhook_id):
webhook = UserWebhook.objects.get(webhook_id=webhook_id)
webhook.delete()
Eventbrite(token).delete('/webhooks/' + webhook_id + '/')
return HttpResponseRedirect('/')
from eventbrite import Eventbrite
from tok import secret
from datetime import datetime
import pprint
token = secret()
eventbrite = Eventbrite(token)
pp = pprint.PrettyPrinter(indent=4)
user = eventbrite.get_user() # Not passing an argument returns yourself
print(user["id"])
print(user["name"])
def eb_api_query():
# dictionary keys of argument are the fields we care about
argument = {}
# do something like this...
argument["location.address"] = "Berkeley"
argument["start_date.range_start"] = "2019-09-29T00:00:00"
#this line is to expand the venue field (necessary to retrieve address)
argument["expand"] = "venue"
events = eventbrite.event_search(**argument)['events']
#populate this dictionary with info from the search
ret_events = []
for event in events:
curr = {}
curr['name'] = event['name']['text']
def get_api_events_id(token, event_id):
"""
Get events from the user of the token from the api
"""
eventbrite = Eventbrite(token)
return eventbrite.get('/events/{}'.format(event_id))
def get_api_order_barcode(token, org_id, barcode):
eventbrite = Eventbrite(token)
url = '/organizations/{}/orders/search?barcodes={}'.format(org_id, barcode)
return eventbrite.get(url).get('orders')[0]
def get_event(self, event_id):
eventbrite = Eventbrite(
self.request.user.social_auth.all()[0].access_token)
event = eventbrite.get_event(event_id)
return event
from eventbrite import Eventbrite
import csv
import os
url_pre = 'https://www.eventbriteapi.com/v3/events/'
url_post = '/?expand=ticket_classes'
eb = Eventbrite('IM2AEVS63P2EB6BYY7GH')
f = open('event_ids_cleaned.csv', 'r')
rd = csv.reader(f, delimiter=',')
event_ids = [id for id in rd] #turns out to be a list of lists
event_ids = event_ids[0]
#convert IDs to integers
event_ids_int = [int(id) for id in event_ids]
from django.conf import settings
from django.db.models.fields.related import ReverseSingleRelatedObjectDescriptor
from django.db.models.options import FieldDoesNotExist
from eventbrite import Eventbrite
from eventbrite.access_methods import AccessMethodsMixin
from .models import Event, TicketType, Attendee, Order
from decimal import Decimal
from moneyed import Money
import dateutil.parser
import pytz
import traceback
eb = Eventbrite(settings.EVENTBRITE_OAUTH_TOKEN)
LOCAL_TO_EB_KEY_MAPPING = (
('eb_id', 'id'),
('event', 'event_id'),
('eb_url', 'url'),
('fee', 'eventbrite_fee'),
('tickets', 'ticket_classes'),
('canceled', 'cancelled'), # ugh. Their API is inconsistent.
)
TIME_FIELDS = (
'end',
'start',
)
SAVE_FIRST = (Event, )
FK_MAP = {
def get_event(self):
social = self.request.user.social_auth.filter(provider='eventbrite')[0]
eb = Eventbrite(social.access_token)
events = eb.get('/users/me/events/')
# [event for event in events['events']]
return events
#=====================
# Import Eventbrite
#=====================
import time
from eventbrite import Eventbrite
#WORKS prints the objects inside the eventbrite file print(dir())
#Authorization
eventbrite = Eventbrite('D6P5CGYEQMZQXPBSPJDG')
user = eventbrite.get_user() # Not passing an argument returns yourself
# Get my own User ID
my_id = eventbrite.get_user()['id']
#=====================
# Import Mailchimp
#=====================
#import requests
#import json
#from config import MailChimpConfig
#=====================
# Get the current date
#=====================settings
today = time.strftime("%Y-%m-%d")
print(time.strftime("%Y-%m-%d"))
#===============================
# Get all of my event id numbers
#===============================
events = eventbrite.event_search(**{'user.id': my_id})
from dateutil import parser
from eventbrite import Eventbrite
# Settings
from_email = Email("*****@*****.**")
to_email = Email("*****@*****.**")
search_term = 'event name' # The event name or keyword to search for
search_location = '00000' # Replace with zip code or postal code
search_radius = '20km' # The search radius around the location to search for listed events
EVENTBRITE_TOKEN = 'MY_EVENTBRITE_TOKEN'
SENDGRID_API_KEY = 'MY_SENDGRID_API_KEY'
# No need to edit below this line
eventbrite = Eventbrite(EVENTBRITE_TOKEN)
sg = sendgrid.SendGridAPIClient(apikey=SENDGRID_API_KEY)
# Alternatively, use a stored environment variable
#sg = sendgrid.SendGridAPIClient(apikey=os.environ.get('SENDGRID_API_KEY'))
# Get a raw list of events (includes pagination details)
results = eventbrite.event_search(**{'q': search_term,\
'location.address': search_location,\
'location.within': search_radius})
# See what attributes you can pass to the event_search method at
# https://www.eventbrite.com/developer/v3/endpoints/events/#ebapi-get-events-search
#
# Eventbrite SDK for Python
# http://eventbrite-sdk-python.readthedocs.io/en/latest/cookbook.html
def webhook():
logger.debug('Received HTTP request')
if request.method == 'POST':
logger.debug('HTTP request is type POST')
# event payload
request_data = request.data.decode('utf-8')
# webhook signature
request_sig = request.headers.get('X-CC-Webhook-Signature', None)
logger.debug('Validating webhook event signature')
# signature verification and event object construction
try:
event = Webhook.construct_event(request_data, request_sig, config.webhook_secret)
except (WebhookInvalidPayload, SignatureVerificationError) as e:
return str(e), 400
logger.info("Received event: id={id}, code={code}, type={type}".format(id=event.id, code=event.data.code, type=event.type))
# check event.type. We should only receive charge:confirmed. If webhook is misconfigured we want to ignore pending or failed charges.
if event.type != "charge:confirmed":
logger.debug('Event is not a confirmed charge. Waiting...')
return 'Event received', 200
logger.debug('Processing confirmed charge')
# Add all payments and divide by tickets price to get number of tickets purchased
# event.data.payments is a list, usually contains one payment, but might have more than one.
try:
logger.debug('Calculating payment total')
payment_total = 0
# add all payments in list
for payment in event.data.payments:
payment_total += float(payment.value.local.amount)
logger.debug('Calculating number of tickets')
# Payment should be exact multiple of ticket_price
num_tickets = int(payment_total // config.ticket_price)
# A confirmed charge should have payment_total > 0
assert(payment_total > 0)
# num_tickets should be > 0, if ticket_price is set correctly
assert(num_tickets > 0)
except Exception as e:
logger.error(str(e))
return 'Error processing event: '+str(e), 400
logger.debug("Payment total: " + str(payment_total))
logger.debug("Number of tickets: " + str(num_tickets))
logger.debug('Creating EventBrite discount code '+str(event.data.code))
# Create a dicsount code, based on the Coinbase charge code
# Set quantity to num_tickets and discount to 100%
eventbrite = Eventbrite(config.eventbrite_token)
result = eventbrite.post_event_discount(
config.event_id,
discount_code=event.data.code,
discount_percent_off=100,
discount_quantity_available=num_tickets
)
# Check result from EventBrite API
if 'status_code' in result and result.status_code == 400:
logger.error("Error creating EventBrite discount code: "+str(result))
return "Error creating EventBrite discount code", 400
else:
logger.info("EventBrite success: "+str(result))
return 'Success', 200
def get_api_event_id(token, event_id):
eventbrite = Eventbrite(token)
return eventbrite.get('/events/{}'.format(event_id))
import os
from dateutil.parser import parse
from dotenv import find_dotenv, load_dotenv
from eventbrite import Eventbrite
from flask import Flask, redirect, render_template, url_for
from flask_sslify import SSLify
load_dotenv(find_dotenv(usecwd=True))
# We fetch our constants by taking them from environment variables
# defined in the .env file.
EVENTBRITE_OAUTH_TOKEN = os.environ["EVENTBRITE_OAUTH_TOKEN"]
# Instantiate the Eventbrite API client.
eb = Eventbrite(EVENTBRITE_OAUTH_TOKEN)
app = Flask(__name__)
sslify = SSLify(app)
class Event(object):
def __init__(self, event_dict):
self.title = event_dict["name"]["text"]
self.url = event_dict["url"]
self.location_title = event_dict["venue"]["name"]
self.address = event_dict["venue"]["address"][
"localized_multi_line_address_display"
]
self.date = parse(event_dict["start"]["local"]).strftime(
"%B %-d, %Y, %-I:%M%p PDT"
def get_api_organization(token):
"""
Get organization from the user of the token from the api
"""
eventbrite = Eventbrite(token)
return eventbrite.get('/users/me/organizations').get('organizations')
def setup_eventbrite():
eventbrite = Eventbrite(config.eventbrite_client_id)
return eventbrite
def get_api_order(token, order_id):
eventbrite = Eventbrite(token)
url = '/orders/{}'.format(order_id)
return eventbrite.get(url, expand=('merchandise', ))
# std lib import
import os
import pprint
import requests
import json
# 3rd party imports
from eventbrite import Eventbrite
EVENTBRITE_API_TOKEN = os.getenv("EVENTBRITE_API_TOKEN")
EVENTS_ENDPOINT = os.getenv("EVENTS_ENDPOINT")
LOCATION = os.getenv("LOCATION")
client = Eventbrite(EVENTBRITE_API_TOKEN)
def init():
if not EVENTBRITE_API_TOKEN:
raise Exception("EVENTBRITE_API_TOKEN is not defined")
if not EVENTS_ENDPOINT:
raise Exception("EVENTS_ENDPOINT is not defined")
if not LOCATION:
raise Exception("LOCATION is not defined")
print(f"Loading events for {LOCATION}")
print(f"Configured Eventbrite Events to POST to {EVENTS_ENDPOINT}")
def _transform_event(event):
return {
"name": event["name"]["text"],
def get_api_attendee_checked(token, attendee_id, event_id):
eventbrite = Eventbrite(token)
url = '/events/{}/attendees/{}/'.format(event_id, attendee_id)
return eventbrite.get(url)
def get_events(user):
social_user = user.social_auth.filter(provider='eventbrite')[0]
eb = Eventbrite(social_user.access_token)
events = eb.get('/users/me/events')
return [event for event in events['events']]
"""
This is the main Python file that sets up rendering and templating
for Techtonica.org
"""
import os
import pendulum
from dotenv import find_dotenv, load_dotenv
from eventbrite import Eventbrite
from flask import Flask, redirect, render_template, url_for
from flask_sslify import SSLify
load_dotenv(find_dotenv(usecwd=True))
eventbrite = Eventbrite(os.environ["EVENTBRITE_OAUTH_TOKEN"])
app = Flask(__name__)
sslify = SSLify(app)
# MAIN HANDLERS
@app.route("/")
def render_home_page():
"""
Renders the home page from jinja2 template
"""
events = get_events()
return render_template("home.html", events=events)
@app.route("/team/")
def render_team_page():
def get_event(user, id):
social_user = user.social_auth.filter(provider='eventbrite')[0]
eb = Eventbrite(social_user.access_token)
event = eb.get_event(id)
return event
from eventbrite import Eventbrite
from src import config
eventbrite = Eventbrite(config.api_key)
events = eventbrite.get(
'/events/search?location.address=vancovuer&location.within=10km&expand=venue'
)
print(events)
import os
import sys
# sys.path.append(os.path.join(os.path.dirname(__file__), ''))
from airtable import airtable
from eventbrite import Eventbrite
EVENTBRITE_API_SECRET = os.getenv('EVENTBRITE_API_SECRET')
AIRTABLE_BASE_ID = os.getenv('EVENT_AIRTABLE_BASE_ID')
AIRTABLE_API_KEY = os.getenv('EVENT_AIRTABLE_API_KEY')
AIRTABLE_EVENTS_TABLE_ID = '🗓 Events'
AIRTABLE_CONTACTS_TABLE_ID = '🗃 Community'
AIRTABLE_TICKETS_TABLE_ID = '🎟 Tickets'
airtable_client = airtable.Airtable(AIRTABLE_BASE_ID, AIRTABLE_API_KEY)
eventbrite = Eventbrite(EVENTBRITE_API_SECRET)
# Receives this payload from Eventbrite:
# {
# "api_url": "https://www.eventbriteapi.com/v3/events/36702403878/attendees/823010854/",
# "config": {
# "action": "attendee.updated",
# "endpoint_url": "https://2vv4q857ml.execute-api.us-east-1.amazonaws.com/prod/import-eventbrite-attendees-to-airtable",
# "user_id": "162648120486",
# "webhook_id": "455733"
# }
# }
def lambda_handler(event, context):
print("Received event: " + json.dumps(event, indent=2))
def setUp(self):
self.eventbrite = Eventbrite(OAUTH_TOKEN)
def get_api_events(token):
eventbrite = Eventbrite(token)
return eventbrite.get('/users/me/events/?page_size=10')
from eventbrite import Eventbrite
import re
# ################# insert to DB code ############################
# conn = pyodbc.connect('Driver={ODBC Driver 17 for SQL Server};'
# 'Server=stream-hub.database.windows.net;'
# 'Database=streamHub;'
# 'UID=stream-hub;'
# 'PWD=sS8370098;'
# 'Integrated Security=False;'
# )
# ################# insert to DB code ############################
print("Scrapping data from: Eventbrite.com")
eb = Eventbrite('FKXG73X6Z4XT37PXBFGN')
myurl = "https://www.eventbrite.com/d/online/israel/?page=1"
#Write path depending if on Linux Azure VM or Win laptop
if path.exists("C:/Users/omerm/Desktop/Hackorona/Data-Scrapping"):
the_path = "C:/Users/omerm/Desktop/Hackorona/Data-Scrapping"
else:
the_path = "/home/streamhub/datascrape"
#Grapping page
uClient = uReq(myurl)
page_html = uClient.read()
uClient.close()
#parses the info
page_soup = soup(page_html, "html.parser")
def loadDb(config):
eventId = config['id']
db_file = config['db']
directory = os.path.dirname(db_file)
if not os.path.exists(directory):
os.makedirs(directory)
conn = sqlite3.connect(db_file)
createDB(conn)
if 'eventbrite_key' not in os.environ:
print('Required enviroment var "eventbrite_key" missing. Exiting...')
return
eventbrite = Eventbrite(os.environ['eventbrite_key'])
questions = loadQuestions(eventbrite, eventId, conn)
response = eventbrite.get('/events/%s/attendees/' % eventId)
page = int(response["pagination"]["page_number"])
pageCount = int(response["pagination"]["page_count"])
while page <= pageCount:
for attendee in response["attendees"]:
if attendee["status"] == "Attending":
user_id = attendee["id"]
order_id = attendee['order_id']
name = fixname(attendee["profile"]["name"])
if "email" in attendee["profile"]:
email = attendee["profile"]["email"]
else:
print ("MISSING email for %s" % attendee["profile"])
ticket = attendee["ticket_class_name"]
if 'company' in attendee["profile"]:
company = attendee["profile"]['company']
else:
for questionId in config['company']:
# get from custom quetsions
company = findQuestion(attendee["answers"],questionId) # non consortium
if company:
break
lastmod = parser.parse(attendee["changed"])
created = parser.parse(attendee["created"])
returnValue = conn.execute('INSERT INTO users VALUES (?, ?, ?, ?, ?, ?, ?, ?)', [ user_id, order_id, name, email, ticket, company, lastmod, created])
for question in attendee["answers"]:
question_id = question["question_id"]
if "answer" in question:
answer = question["answer"]
returnValue = conn.execute('INSERT INTO question_link VALUES (?, ?, ?)', [ user_id, question_id, answer])
else:
returnValue = conn.execute('INSERT INTO question_link (user_id, question_id) VALUES (?, ?)', [ user_id, question_id])
page += 1
if page <= pageCount:
response = eventbrite.get('/events/%s/attendees/?page=%s' % (eventId, page))
date = arrow.now()
conn.execute('insert into updates VALUES(?,?)', [date.timestamp, date.datetime])
conn.commit()
conn.close()
