def parseEventbrite(organizer): eventbrite = Eventbrite(config.EVENTBRITE_OAUTH_TOKEN) events = eventbrite.event_search(**{'organizer.id': organizer}) event_list = [] venues = {} for event in events["events"]: event_data = { "title": event["name"]["text"], "start": event["start"]["local"], "end": event["end"]["local"], "url": event["url"] } try: event_data["description"] = event["description"]["text"] except AttributeError: pass venue_id = event["venue_id"] try: venue_str = venues[venue_id] except KeyError: venue = eventbrite.get("/venues/%s" % venue_id) venue_str = "%s, %s, %s %s" % (venue["name"], venue["address"]["address_1"], venue["address"]["postal_code"], venue["address"]["city"]) venues[venue_id] = venue_str event_data["location"] = venue_str event_list.append(event_data) return event_list
def get_eventbrite_events(): """Get events from eventbrite.""" eb = Eventbrite(config.EVENTBRITE_TOKEN) # me = eb.event_search(**{"user.id": eb.get_user()["id"]}) # print(json.dumps(me)) has_more = True events = [] while has_more: search_results = eb.event_search( **{"location.address": "New+York", "location.within": "5mi"} ) has_more = search_results.get("pagination", "").get( "has_more_items", False ) for i in search_results.get("events", []): events.append( { "id": i.get("id"), "name": i.get("name").get("text"), "description": i.get("description").get("text"), "summary": i.get("summary"), "start": i.get("start").get("local"), "end": i.get("end").get("local"), "status": i.get("status"), "url": i.get("url"), } ) return search_results["events"]
class Event: def __init__(self): self.eventbrite = Eventbrite(settings.EVENTBRITE_API_KEY) def get(self, events_id): """ Given an eventbrite ID, returns the event object :param events_id: :return: """ data = self.eventbrite.get_event(events_id) if data.status_code == 200: return data else: return None def get_multiple(self, category_ids, page_number): """ Given a set of categories, returns relevant events :param category_ids: :param page_number: :return: """ data = self.eventbrite.event_search(**{"page": page_number, "categories": category_ids}) if data.status_code == 200: return data else: return None
def parseEventbrite(organizer): eventbrite = Eventbrite(config.EVENTBRITE_OAUTH_TOKEN) events = eventbrite.event_search(**{'organizer.id': organizer}) event_list = [] venues = {} for event in events["events"]: event_data = { "title": event["name"]["text"], "start": event["start"]["local"], "end": event["end"]["local"], "url": event["url"] } try: event_data["description"] = event["description"]["text"] except AttributeError: pass venue_id = event["venue_id"] try: venue_str = venues[venue_id] except KeyError: venue = eventbrite.get("/venues/%s" % venue_id) venue_str = "%s, %s, %s %s" % ( venue["name"], venue["address"]["address_1"], venue["address"]["postal_code"], venue["address"]["city"]) venues[venue_id] = venue_str event_data["location"] = venue_str event_list.append(event_data) return event_list
def search_events(self): preferences = self.user_preferences eventbrite = Eventbrite(self.api_token) events = eventbrite.event_search(**{ 'venue.city': preferences.venue_city, 'price' : preferences.price, 'categories' : ",".join(preferences.category_id), 'start_date.keyword': preferences.start_date_keyword }) list_of_events = [] for i in events["events"]: try: list_of_events += [{ 'event_name':i['name']['text'] if len(i['name']['text'])<50 else i['name']['text'][:50]+"...", 'description':i['description'].get("text","")[:150]+"..." if i['description'].get("text","") != None else "", 'start':datetime.strptime(i['start']['local'],"%Y-%m-%dT%H:%M:%S").strftime("%a, %d %b, %I:%M %p"), 'end':datetime.strptime(i['end']['local'],"%Y-%m-%dT%H:%M:%S").strftime("%a, %d %b, %I:%M %p"), 'url':i['url'], 'logo':i['logo']['url'] }] except TypeError: list_of_events += [{ 'event_name':i['name']['text'] if len(i['name']['text'])<50 else i['name']['text'][:50]+"...", 'description':i['description'].get("text","")[:150]+"..." if i['description'].get("text","") != None else "", 'start':datetime.strptime(i['start']['local'],"%Y-%m-%dT%H:%M:%S").strftime("%a, %d %b, %I:%M %p"), 'end':datetime.strptime(i['end']['local'],"%Y-%m-%dT%H:%M:%S").strftime("%a, %d %b, %I:%M %p"), 'url':i['url'] }] return list_of_events
def get_events(): eventbrite = Eventbrite(settings.EVENTBRITE_KEY) # Get my own User ID my_id = eventbrite.get_user()['id'] # Get a raw list of events (includes pagination details) return eventbrite.event_search(**{'user.id': my_id})
def suggestEvents(flightJson, testDate=None): eventbrite = Eventbrite('JPFW2R7QDBH4J62PPDO2') flight = flightJson arrival_airport = flight["segmentReferences"]["arrivalAirport"] #print ("arrival airport", arrival_airport) if testDate is None: date = flight["segmentReferences"]['arrivalDate'] time = flight["segmentReferences"]['arrivalTime'] arrival_time = date[:-1] + 'T' + time + ":00" else: time = flight["segmentReferences"]['arrivalTime'] arrival_time = testDate[:-1] + 'T' + time + ":00" #print (arrival_time) end_date = arrival_time[:8] + str(int(arrival_time[8:10]) + 3) + arrival_time[10:] #print (end_date) airports = pd.read_csv( 'https://raw.githubusercontent.com/jpatokal/openflights/master/data/airports.dat', header=None) latitude = airports[airports[4] == arrival_airport][6] longitude = airports[airports[4] == arrival_airport][7] events = eventbrite.event_search( **{ 'sort_by': 'best', 'location.latitude': latitude, 'location.longitude': longitude, "location.within": "70km", "start_date.range_start": arrival_time, "start_date.range_end": end_date, 'high_affinity_categories': 'business' }) #return events response = {} if type(events) is str: return None else: if len(events['events']) < 3: response.append(events['events']['name']['text']) else: #print ('ffdsfdsf') for event_name in events['events'][:3]: response[event_name['name']['text']] = event_name['url'] #response.append(event_name['url']) return response
def handle(self, *args, **options): "Pull events from Eventbrite and store them in the db as Event instances" # https://github.com/eventbrite/eventbrite-sdk-python/blob/master/eventbrite/client.py eventbrite = Eventbrite(settings.EVENTBRITE_OAUTH_TOKEN or options.get('token')) number_of_events_to_parse = options['number_of_events'] count = 0 page = 1 events = eventbrite.event_search( expand='ticket_availability,organizer', page=page) while count < number_of_events_to_parse: for event in events.get('events'): cost = int( (float(event['ticket_availability']['minimum_ticket_price']['major_value']) \ + float(event['ticket_availability']['maximum_ticket_price']['major_value']) )/2 ) try: # only unique events with values for all fields will be saved Event.objects.create( name=event['name']['text'], organization=event['organizer']['name'], event_original_id=event['id'], start_date=parser.parse(event['start']['local']), cost=cost) count += 1 except: pass if count >= number_of_events_to_parse: break if events.get('pagination').get( 'has_more_items') and count < number_of_events_to_parse: page += 1 events = eventbrite.event_search( expand='ticket_availability,organizer', page=page) else: break print("\nSaved {} events in the database!\n".format(count))
class TestEvents(unittest.TestCase): def setUp(self): self.eventbrite = Eventbrite(OAUTH_TOKEN) @unittest.skipIf(condition=skip_user_id_tests, reason='Needs a USER_ID') @unittest.skipIf( condition=skip_integration_tests, reason='Needs an OAUTH_TOKEN') def test_post_event(self): event_name = 'client_test_{0}'.format(datetime.now()) event_data = { 'event.name': { 'html': event_name, }, 'event.start': { 'utc': '2015-03-07T20:00:00Z', 'timezone': 'America/Los_Angeles', }, 'event.end': { 'utc': '2015-03-07T23:00:00Z', 'timezone': 'America/Los_Angeles', }, 'event.currency': 'USD', 'event.online_event': True, 'event.listed': False, 'event.category_id': '110', 'event.format_id': '5', 'event.password': "******", 'event.capacity': 10, } event = self.eventbrite.post('/events/', data=event_data) self.assertEqual(event_name, event['name']['text']) self.assertEqual(event_name, event['name']['html']) # Just for access to see the event, not full authentication self.assertEqual(event['password'], "test") @unittest.skipIf(condition=skip_user_id_tests, reason='Needs a USER_ID') @unittest.skipIf( condition=skip_integration_tests, reason='Needs an OAUTH_TOKEN') def test_search_events(self): data = { 'location.latitude': '40.4313684', 'start_date.keyword': 'today', 'location.longitude': '-79.9805005', 'location.within': '10km' } events = self.eventbrite.event_search(**data) self.assertLess(events['pagination'][u'object_count'], 1000)
def handle(self, *args, **options): eventbrite = Eventbrite(generic_keys.eventbrite_oauth_token) # for getting all the events from washington DC # **{'venue.city': 'new york'} nyc_events = [] for i in range(2, 500): try: nyc_events = eventbrite.event_search(**{'page': i})['events'] except: pass for line in nyc_events: event_name, event_description, event_website, event_image, start_date, start_time, end_date, end_time, event_address, event_faq, phone_number = '', '', '', '', '', '', '', '', '', '', '' try: event_name = line['name']['text'] event_description = line['description']['text'] except: pass try: event_website = line['url'] event_image = line['logo']['url'] except: pass try: start_time = line['start']['local'].split('T')[1] start_date = line['start']['local'].split('T')[0] end_time = line['end']['local'].split('T')[1] end_date = line['end']['local'].split('T')[0] except: pass try: event_address = eventbrite.get('/venues/{}/'.format( line['venue_id']))['address']['address_1'] except Exception as e: print e try: Activity.objects.create( event_name=event_name, event_location=event_address, event_address=event_address, event_website=event_website, event_description=event_description, event_image=event_image, start_time=start_time, end_time=end_time, start_date=start_date, end_date=end_date, event_faq=event_faq) except Exception as e: print e
class TestEvents(unittest.TestCase): def setUp(self): self.eventbrite = Eventbrite(OAUTH_TOKEN) @unittest.skipIf(condition=skip_user_id_tests, reason='Needs a USER_ID') @unittest.skipIf(condition=skip_integration_tests, reason='Needs an OAUTH_TOKEN') def test_post_event(self): event_name = 'client_test_{0}'.format(datetime.now()) event_data = { 'event.name': { 'html': event_name, }, 'event.start': { 'utc': '2015-03-07T20:00:00Z', 'timezone': 'America/Los_Angeles', }, 'event.end': { 'utc': '2015-03-07T23:00:00Z', 'timezone': 'America/Los_Angeles', }, 'event.currency': 'USD', 'event.online_event': True, 'event.listed': False, 'event.category_id': '110', 'event.format_id': '5', 'event.password': "******", 'event.capacity': 10, } event = self.eventbrite.post('/events/', data=event_data) self.assertEqual(event_name, event['name']['text']) self.assertEqual(event_name, event['name']['html']) # Just for access to see the event, not full authentication self.assertEqual(event['password'], "test") @unittest.skipIf(condition=skip_user_id_tests, reason='Needs a USER_ID') @unittest.skipIf(condition=skip_integration_tests, reason='Needs an OAUTH_TOKEN') def test_search_events(self): data = { 'location.latitude': '40.4313684', 'start_date.keyword': 'today', 'location.longitude': '-79.9805005', 'location.within': '10km' } events = self.eventbrite.event_search(**data) self.assertLess(events['pagination'][u'object_count'], 1000)
def tod_events(search_args, category, am_end, pm_st): eventbrite = Eventbrite(keys["eventbrite_key"]) events = eventbrite.event_search(**search_args) ## Use this for filtering # events = [x for x in events['events'] if x['category_id'] == "103"] events = [x for x in events['events']] for item in events: location_id = eventbrite.get('/venues/' + str(item['venue_id'])) item.update( {"latitude": location_id['latitude']}) item.update( {"longitude": location_id['longitude']}) item.update( {"address": location_id['address']}) return events
def show_events_view(request): eventbrite = Eventbrite(eventtoken) my_id = eventbrite.get_user()['id'] events = eventbrite.event_search(**{'user.id': my_id}) existing_events = Event.objects.all().values("event_id") events_list = [] for i in existing_events: events_list.append(i['event_id']) for x in events['events']: event_id = (x['id']) if event_id in events_list: pass else: start_time = parse_datetime(x['start']['local']) api_url = (x['url']) event_id = (x['id']) event_url = (x['url']) title = (x['name']['html']) name_code = title[4:7].lower() if name_code == "cor": code = "core" elif name_code == "int": code = "inter" elif name_code == "hig": code = "higher" else: code = "other" print(event_id) print(start_time) new_event = Event(api_url=api_url, event_start=start_time, title=title, event_url=api_url, event_code=code, event_id=event_id) print(new_event) new_event.save() context = {} return render(request, 'showevents.html', context)
def get_event_results(q, datestring): datestring = datetime.strptime(datestring, "%m/%d/%Y") datestring = datetime.strftime(datestring, "%Y-%m-%d") client = Eventbrite(auth_key) start_date = datestring+"T01:00:00" end_date = datestring+"T23:55:00" popular = True sort_by = "best" categories ="103,110" # expand = "https://www.eventbriteapi.com/v3/events/search/?location.address=Indore&expand=organizer,venue&token=JXPOFPSSCU4OQGRAG5RH" params = {"q": q, "start_date.range_start": start_date, "start_date.range_end": end_date, "sort_by": sort_by, "popular": popular, "categories": categories, 'expand': 'venue'} search_response = client.event_search(**params) events = search_response.get('events', []) rendered_responses = [] for event in events: if event.get('logo'): image_url = event['logo']['url'] else: image_url = None rendered_responses.append({'name': event['name']['html'], 'start': datetime.strptime(event['start']['local'], ('%Y-%m-%dT%H:%M:%S')), 'status': event['status'], 'url': event['url'], 'locale': event['locale'], 'id': event['id'], 'description': event['description']['text'], 'image':image_url, 'venue': event['venue']['address'], 'latitude': event['venue']['latitude'], 'longitude': event['venue']['longitude']}) pprint.pprint(rendered_responses) return rendered_responses
def handle(self, *args, **options): eventbrite = Eventbrite(generic_keys.eventbrite_oauth_token) # for getting all the events from washington DC # **{'venue.city': 'new york'} nyc_events = [] for i in range(2, 500): try: nyc_events = eventbrite.event_search(**{'page': i})['events'] except: pass for line in nyc_events: event_name, event_description, event_website, event_image, start_date, start_time, end_date, end_time, event_address, event_faq, phone_number = '', '', '', '', '', '', '', '', '', '', '' try: event_name = line['name']['text'] event_description = line['description']['text'] except: pass try: event_website = line['url'] event_image = line['logo']['url'] except: pass try: start_time = line['start']['local'].split('T')[1] start_date = line['start']['local'].split('T')[0] end_time = line['end']['local'].split('T')[1] end_date = line['end']['local'].split('T')[0] except: pass try: event_address = eventbrite.get('/venues/{}/'.format(line['venue_id']))['address']['address_1'] except Exception as e: print e try: Activity.objects.create(event_name=event_name, event_location=event_address, event_address=event_address, event_website=event_website, event_description=event_description, event_image=event_image, start_time=start_time, end_time=end_time, start_date=start_date, end_date=end_date, event_faq=event_faq) except Exception as e: print e
def get_recommendation(desired_time): # GET EVENT RECOMMENDATION FROM EVENTBRITE # GET EVENTBRITE API KEY eventbrite_api_key = get_key('EVENTBRITE_TOKEN') eventbrite = Eventbrite(eventbrite_api_key) # GET ADDRESS FROM HOTEL NAME (GOOGLEMAPS) google_api_key = get_key('GOOGLE') gmaps = googlemaps.Client(key=google_api_key) places_result = gmaps.places(query=session.attributes['hotel']) hotel_address = [e['formatted_address'] for e in places_result['results']] # GET CATEGORY ID FROM CATEGORY NAME address = hotel_address category_input = 'Music' subcategory_input = session.attributes['music_cat_id'] location_radius = '10mi' event_timing = desired_time categoryquery = eventbrite.get_categories() category_name = [c['name'] for c in categoryquery['categories']] category_ids = [c['id'] for c in categoryquery['categories']] categories = zip(category_name, category_ids) category_id = None for x in categories: if x[0] == category_input: category_id = x[1] # GET SUBCATEGORY ID FROM CATEGORY ID #subcategoryquery = eventbrite.get_subcategories() #subcategory_name = [c['name'] for c in subcategoryquery['subcategories']] #subcategory_ids = [c['id'] for c in subcategoryquery['subcategories']] #subcategories = zip(subcategory_name, subcategory_ids) subcategory_id = subcategory_input #for x in subcategories: #if x[0] == subcategory_input: #subcategory_id = x[1] # GET LIST OF EVENTS eventquery = eventbrite.event_search(**{'location.address': address, 'categories': category_id, 'subcategories': subcategory_id, 'location.within': location_radius, 'start_date.keyword': event_timing}) eventnames = [e['name']['text'] for e in eventquery['events']] if not eventnames: return False event1 = eventnames[0] eventdescr = [e['description']['text'] for e in eventquery['events']] descr1 = eventdescr[0] # COLLECT ADDITIONAL INFO FOR FILES #eventdescr2 = [] #for i in eventdescr: #if i is None: #eventdescr2.append("") #eventdescr2.append(((i.replace("\n", " ")).replace("\r", " "))[0:30]) eventlogo = [] for e in eventquery['events']: eventlogo.append(e['logo']['original']['url'] if e['logo'] else '') logo1 = eventlogo[0] eventkeys = [] for i in eventnames: eventkeys.append(('event-' + i).replace(" ", "-")) eventlist = zip(eventkeys, eventnames, eventnames, eventlogo) eventstart = [l['local'] for l in (e['start'] for e in eventquery['events'])] start1 = eventstart[0] eventend = [l['local'] for l in (e['end'] for e in eventquery['events'])] end1 = eventend[0] eventvenue = [v['venue_id'] for v in eventquery['events']] venue1 = eventvenue[0] venuequery = eventbrite.get('/venues/{0}'.format(venue1)) venue_list = venuequery['address']['localized_multi_line_address_display'] venue_string = " ".join(str(x) for x in venue_list) eventurl = [u['url'] for u in eventquery['events']] url1 = eventurl[0] # CREATE EVENT TERMS eventterms = [] for i in eventnames: eventterms.append((((category_input + '__' + session.attributes['music_cat']).replace(" ", "_")).replace("/", "and")).lower()) termfile = zip(eventkeys, eventterms) with get_connection() as conn: with conn.cursor() as cursor: cursor.executemany(""" INSERT INTO products (id, name, description, image_link) VALUES (%s, %s, %s, %s) """, eventlist) cursor.executemany(""" INSERT INTO terms (event_key, event_term) VALUES (%s, %s) """, termfile) conn.close() # TEXT EVENT DETAILS account_sid = get_key('TWILIO_SID') auth_token = get_key('TWILIO_TOKEN') client = twilio.rest.Client(account_sid, auth_token) phone_number = session.attributes['phone_number'] client.messages.create( to=phone_number, from_=get_key('TWILIO_PHONE'), body="Your IHG Concierge has sent you an event you may enjoy: " + '\n' + event1 + '\n' + descr1[:800] + '\n' + "Start Time: " + start1 + '\n' + "End Time: " + end1 + '\n' + "Venue: " + venue_string + '\n' + url1, media_url=logo1 if phone_number.startswith('+1') else None) return eventnames[0]
def get_events(self): """ Queries Eventful, LastFM, and Eventbrite APIs and returns events within an area based on geo parameters """ # Datetime format for event start date/time datetime_format = '%b %d, %Y -- %I:%M %p' lst_events = [] ### ----- Eventful ----- ### # Queries Eventful API and returns events within an area based on geo # parameters. Exception handling to prevent error in case no events # are found. api = eventful.API(Eventful_Key) try: eventful_events = api.call('/events/search', location=(str(self.latitude) + ',' + str(self.longitude)), within=self.miles, sort_order="date") except: eventful_events = dict({'events': None}) # Appends Eventful event details to 'lst_events' list. Two different # 'For Loops' are used because if only one event is found, it is returned # as a dict, otherwise it is returned as a list if eventful_events['events'] != None: if isinstance(eventful_events['events']['event'], list): for event in eventful_events['events']['event']: tmp_event = [] tmp_time = [] tmp_event.append(event['title'][:35]) tmp_event.append(event['venue_name'][:20]) # converts datetime format tmp_time = event['start_time'] tmp_time_adj = datetime.strptime( tmp_time, '%Y-%m-%d %H:%M:%S').strftime(datetime_format) tmp_event.append(tmp_time_adj) tmp_event.append(event['url']) lst_events.append(tmp_event) elif isinstance(eventful_events['events']['event'], dict): tmp_event = [] tmp_time = [] tmp_event.append( eventful_events['events']['event']['title'][:35]) tmp_event.append( eventful_events['events']['event']['venue_name'][:20]) tmp_time = eventful_events['events']['event']['start_time'] # converts datetime format tmp_time_adj = datetime.strptime( tmp_time, '%Y-%m-%d %H:%M:%S').strftime(datetime_format) tmp_event.append(tmp_time_adj) tmp_event.append(eventful_events['events']['event']['url']) lst_events.append(tmp_event) ### ----- LastFM ----- ### # Queries LastFM API and returns events within an area based on geo # parameters. Exception handling to prevent error in case no events # are found. network = pylast.LastFMNetwork(api_key=Last_fm_Key, api_secret=Last_fm_Secret) try: lastfm_events = network.get_geo_events(longitude=self.longitude, latitude=self.latitude, distance=self.miles) except: lastfm_events = [] # Appends LastFM event details to 'lst_events' list. Exception handling # in case no events are found or etracting certain event details creates # an error for i in range(len(lastfm_events)): try: tmp_event = [] tmp_time = [] tmp_event.append(lastfm_events[i].get_title()) tmp_event.append(lastfm_events[i].get_venue().get_name()) # converts datetime format tmp_time = lastfm_events[i].get_start_date() tmp_time_adj = datetime.strptime( tmp_time, '%a, %d %b %Y %H:%M:%S').strftime(datetime_format) tmp_event.append(tmp_time_adj) tmp_event.append(lastfm_events[i].get_url()) lst_events.append(tmp_event) except: continue ### ----- Eventbrite ----- ### # Queries Eventbrite API and returns events within an area based on geo # parameters. eventbrite = Eventbrite(Eventbrite_API) # Eventbrite API requires radius ('within' param) to be integer # not less than 1. eventbrite_within = max('1', str(int(float(self.miles)))) eventbrite_events = eventbrite.event_search( **{ 'location.within': eventbrite_within + "mi", 'location.latitude': str(self.latitude), 'location.longitude': str(self.longitude), 'popular': 'true', 'sort_by': 'date' }) # Appends Eventbrite event details to 'lst_events' list. Exception handling # in case no events are found or extracting certain event details creates # an error for i in range(len(eventbrite_events)): try: tmp_event = [] tmp_time = [] tmp_event.append( eventbrite_events['events'][i]['name']['text'][:35]) tmp_event.append( eventbrite_events['events'][i]['venue']['name'][:20]) # converts datetime format tmp_time = eventbrite_events['events'][i]['start']['local'] tmp_time_adj = datetime.strptime( tmp_time, '%Y-%m-%dT%H:%M:%S').strftime(datetime_format) tmp_event.append(tmp_time_adj) tmp_event.append(eventbrite_events['events'][i]['url']) lst_events.append(tmp_event) except: continue # Events in lst_events are sorted by chronological order return sorted(lst_events, key=lambda x: datetime.strptime(x[-2], datetime_format)) # x = GlocalAPI("1500 Massachusetts Ave NW", "washington","dc","1" ) # # # # x.get_instagram() # x.get_events() # # # # # y = GlocalAPI("","Sanaa","Yemen","10") # # # y.get_events() # # z = GlocalAPI("42 mar elias street","al-mina, tripoli", "lebanon","5") # z.get_events()
def retrieve_events_for_states(us_states, oauth_token): for us_state in us_states: print(us_state) db = mysql.connect(host=config['mysql']['host'], user=config['mysql']['user'], passwd=config['mysql']['pass'], database="state_of_music") cursor = db.cursor() eventbrite = Eventbrite(oauth_token) params = { 'categories': categories, 'formats': formats, 'location.viewport.northeast.latitude': us_state[4], 'location.viewport.northeast.longitude': us_state[3], 'location.viewport.southwest.latitude': us_state[2], 'location.viewport.southwest.longitude': us_state[1], 'start_date.range_start': start_date, 'start_date.range_end': end_date } events_response = eventbrite.event_search(**params) try: total_events = events_response['pagination']['object_count'] except KeyError: eb_list = token_swap(oauth_token) oauth_token = eb_list[0] eventbrite = eb_list[1] events_response = eventbrite.event_search(**params) total_events = events_response['pagination']['object_count'] pages_list = [ 1 ] if events_response['pagination']['page_count'] == 1 else list( range(1, events_response['pagination']['page_count'] + 1)) if total_events > 0: for page in pages_list: params = { 'categories': categories, 'formats': formats, 'location.viewport.northeast.latitude': us_state[4], 'location.viewport.northeast.longitude': us_state[3], 'location.viewport.southwest.latitude': us_state[2], 'location.viewport.southwest.longitude': us_state[1], 'start_date.range_start': start_date, 'start_date.range_end': end_date, 'page': page } events_response = eventbrite.event_search(**params) try: events = events_response['events'] except KeyError: eb_list = token_swap(oauth_token) oauth_token = eb_list[0] eventbrite = eb_list[1] events_response = eventbrite.event_search(**params) events = events_response['events'] for event in events: event_id = event['id'] event_name = event['name']['text'] if (len(event_name) > 100): event_name = event_name[0:99] event_date = event['start']['local'] venue_id = event['venue_id'] subcategory_id = event['subcategory_id'] venue_url = '/venues/' + venue_id venue_response = eventbrite.get(venue_url) try: venue_name = venue_response['name'] except KeyError: eb_list = token_swap(oauth_token) oauth_token = eb_list[0] eventbrite = eb_list[1] venue_response = eventbrite.get(venue_url) venue_name = venue_response['name'] if (venue_name and len(venue_name) > 50): venue_name = venue_name[0:49] venue_lat = venue_response['latitude'] venue_long = venue_response['longitude'] if subcategory_id: subcategory_url = '/subcategories/' + subcategory_id subcategory_response = eventbrite.get(subcategory_url) try: subcategory_name = subcategory_response['name'] except KeyError: eb_list = token_swap(oauth_token) oauth_token = eb_list[0] eventbrite = eb_list[1] subcategory_response = eventbrite.get( subcategory_url) subcategory_name = subcategory_response['name'] else: subcategory_name = '' event_exists_query = """SELECT eventbrite_id FROM eventbrite_events WHERE eventbrite_id = '""" + event_id + "'" cursor.execute(event_exists_query) existing_event = cursor.fetchall() if (not len(existing_event)): query = """INSERT INTO eventbrite_events (eventbrite_id, local_date, event_name, venue_name, venue_lat, venue_long, genre) VALUES (%s, %s, %s, %s, %s, %s, %s)""" values = (event_id, event_date, event_name, venue_name, venue_lat, venue_long, subcategory_name) cursor.execute(query, values) db.commit() db.close()
class TestEvents(unittest.TestCase): def setUp(self): self.eventbrite = Eventbrite(OAUTH_TOKEN) @unittest.skipIf(condition=skip_user_id_tests, reason='Needs a USER_ID') @unittest.skipIf(condition=skip_integration_tests, reason='Needs an OAUTH_TOKEN') def test_post_event(self): event_name = 'client_test_{0}'.format(datetime.now()) event_data = self._get_event_data(event_name) event = self.eventbrite.post_event(event_data) self.assertEqual(event_name, event['name']['text']) self.assertEqual(event_name, event['name']['html']) # Just for access to see the event, not full authentication self.assertEqual(event['password'], "test") @unittest.skipIf(condition=skip_user_id_tests, reason='Needs a USER_ID') @unittest.skipIf(condition=skip_integration_tests, reason='Needs an OAUTH_TOKEN') def test_search_events(self): data = { 'location.latitude': '40.4313684', 'start_date.keyword': 'today', 'location.longitude': '-79.9805005', 'location.within': '10km' } events = self.eventbrite.event_search(**data) self.assertLess(events['pagination'][u'object_count'], 1000) @unittest.skipIf(condition=skip_integration_tests, reason='Needs an OAUTH_TOKEN') def test_publish_unpublish_event(self): """ First, creat a draft event """ event_data = self._get_event_data() event = self.eventbrite.post_event(event_data) self.assertTrue(event.ok, msg=event.get('error_description', None)) """ Next, create a ticket class for the event, because an event can't be published without one """ ticket_data = self._get_ticket_data() response = self.eventbrite.post_event_ticket_class(event['id'], data=ticket_data) """Finally, try to publish the event""" response = self.eventbrite.publish_event(event['id']) self.assertTrue(response.ok, msg=response.get('error_description', None)) """Now try to unpublish the event""" response = self.eventbrite.unpublish_event(event['id']) self.assertTrue(response.ok, msg=response.get('error_description', None)) @unittest.skipIf(condition=skip_integration_tests, reason='Needs an OAUTH_TOKEN') def test_create_ticket_class(self): event_data = self._get_event_data() event = self.eventbrite.post_event(event_data) ticket_data = self._get_ticket_data() response = self.eventbrite.post_event_ticket_class(event['id'], data=ticket_data) self.assertTrue(response.ok, msg=response.get('error_description', None)) def _get_ticket_data(self): return { 'ticket_class.name': 'client_test_ticket_{0}'.format(datetime.now()), 'ticket_class.description': 'Python API Client testing', 'ticket_class.quantity_total': 100, 'ticket_class.cost': 'USD,4500' } def _get_event_data(self, event_name='client_test_{0}'.format(datetime.now())): """ Returns a dictionary representing a valid event """ # if not event_name: # event_name = 'client_test_{0}'.format(datetime.now()) return { 'event.name': { 'html': event_name, }, 'event.start': { 'utc': (datetime.now() + timedelta(days=1)).strftime(EB_ISO_FORMAT), 'timezone': 'America/Los_Angeles', }, 'event.end': { 'utc': (datetime.now() + timedelta(days=1, hours=1)).strftime(EB_ISO_FORMAT), 'timezone': 'America/Los_Angeles', }, 'event.currency': 'USD', 'event.online_event': True, 'event.listed': False, 'event.category_id': '110', 'event.format_id': '5', 'event.password': "******", 'event.capacity': 10, }
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 # Perform a search. If nothing found, exit. try: events = results['events'] except: sys.exit(results) start_time_fmt = '%A, %d %B %Y, %I:%M %p'
class TestEvents(unittest.TestCase): def setUp(self): self.eventbrite = Eventbrite(OAUTH_TOKEN) @unittest.skipIf(condition=skip_user_id_tests, reason='Needs a USER_ID') @unittest.skipIf( condition=skip_integration_tests, reason='Needs an OAUTH_TOKEN') def test_post_event(self): event_name = 'client_test_{0}'.format(datetime.now()) event_data = self._get_event_data(event_name) event = self.eventbrite.post_event(event_data) self.assertEqual(event_name, event['name']['text']) self.assertEqual(event_name, event['name']['html']) # Just for access to see the event, not full authentication self.assertEqual(event['password'], "test") @unittest.skipIf(condition=skip_user_id_tests, reason='Needs a USER_ID') @unittest.skipIf( condition=skip_integration_tests, reason='Needs an OAUTH_TOKEN') def test_search_events(self): data = { 'location.latitude': '40.4313684', 'start_date.keyword': 'today', 'location.longitude': '-79.9805005', 'location.within': '10km' } events = self.eventbrite.event_search(**data) self.assertLess(events['pagination'][u'object_count'], 1000) @unittest.skipIf( condition=skip_integration_tests, reason='Needs an OAUTH_TOKEN') def test_publish_unpublish_event(self): """ First, creat a draft event """ event_data = self._get_event_data() event = self.eventbrite.post_event(event_data) self.assertTrue(event.ok, msg=event.get('error_description', None)) """ Next, create a ticket class for the event, because an event can't be published without one """ ticket_data = self._get_ticket_data() response = self.eventbrite.post_event_ticket_class(event['id'], data=ticket_data) """Finally, try to publish the event""" response = self.eventbrite.publish_event(event['id']) self.assertTrue(response.ok, msg=response.get('error_description', None)) """Now try to unpublish the event""" response = self.eventbrite.unpublish_event(event['id']) self.assertTrue(response.ok, msg=response.get('error_description', None)) @unittest.skipIf( condition=skip_integration_tests, reason='Needs an OAUTH_TOKEN') def test_create_ticket_class(self): event_data = self._get_event_data() event = self.eventbrite.post_event(event_data) ticket_data = self._get_ticket_data() response = self.eventbrite.post_event_ticket_class(event['id'], data=ticket_data) self.assertTrue(response.ok, msg=response.get('error_description', None)) def _get_ticket_data(self): return { 'ticket_class.name': 'client_test_ticket_{0}'.format(datetime.now()), 'ticket_class.description': 'Python API Client testing', 'ticket_class.quantity_total': 100, 'ticket_class.cost': 'USD,4500' } def _get_event_data(self, event_name='client_test_{0}'.format(datetime.now())): """ Returns a dictionary representing a valid event """ # if not event_name: # event_name = 'client_test_{0}'.format(datetime.now()) return { 'event.name': { 'html': event_name, }, 'event.start': { 'utc': (datetime.now() + timedelta(days=1)).strftime(EB_ISO_FORMAT), 'timezone': 'America/Los_Angeles', }, 'event.end': { 'utc': (datetime.now() + timedelta(days=1,hours=1)).strftime(EB_ISO_FORMAT), 'timezone': 'America/Los_Angeles', }, 'event.currency': 'USD', 'event.online_event': True, 'event.listed': False, 'event.category_id': '110', 'event.format_id': '5', 'event.password': "******", 'event.capacity': 10, }
#===================== #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}) # HOW many events are there total_events = events['pagination']['object_count'] print(total_events) #print(events['events']) # For the total number of events return an array of their id numbers -(Add later if too many people)(If the events are still live) eventid = [] for x in range(0, total_events - 1): print(x) eventid.append(events['events'][x]['id']) print(eventid[x]) #============================= # For each event get all eventbrite attendees