def load_events():
""" Add event to events table"""
print "Events"
Event.query.delete()
user = User.query.get(1)
nums = [1, -1, -2, 2]
for x, i in enumerate(range(0, len(user.days), 3)):
day = user.days[i]
event = Event(user_id=1,
event_name='event %s' % x,
overall_mood=(day.overall_mood + choice(nums)))
db.session.add(event)
db.session.commit()
event_day = EventDay(event_id=event.event_id, day_id=day.day_id)
db.session.add(event_day)
db.session.commit()
event = Event(user_id=1,
event_name='Ate an amazing sandwich',
overall_mood='8')
db.session.add(event)
db.session.commit()
event.associate_day(user.days[4].date)
def example_data():
"""Create some sample data for tests file to use."""
# Create some fake users
u1 = User(user_id=1,
email="*****@*****.**",
name="Jessi DiTocco",
password="******")
u2 = User(user_id=2,
email="*****@*****.**",
name="Liz Lee",
password="******")
# Create some fake events
e1 = Event(event_id="43104373341",
name="Aristophanes @ Cafe du Nord",
start_time="Friday, February 16 at 9:30PM+",
end_time="Saturday, February 17 at 2:00AM",
address="2174 Market Street, San Francisco, CA 94114",
latitude=37.7649659,
longitude=-122.431,
venue_name="Slate")
e2 = Event(event_id="41465350981",
name="Funk",
start_time="Friday, February 15 at 9:30PM+",
end_time="Saturday, February 18 at 2:00AM",
address="4123 Market Street, San Francisco, CA 94114",
latitude=39.7649659,
longitude=-122.431,
venue_name="The Jam")
# Create some bookmark types
bt1 = BookmarkType(bookmark_type_id=1, bookmark_type="going")
bt2 = BookmarkType(bookmark_type_id=2, bookmark_type="interested")
# Create some fake bookmarks
b1 = Bookmark(bookmark_id=1,
user_id=1,
event_id="43104373341",
bookmark_type_id=2)
b2 = Bookmark(bookmark_id=2,
user_id=2,
event_id="43104373341",
bookmark_type_id=1)
# Create some fake Comments
c1 = Comment(comment_id=1,
user_id=1,
event_id="43104373341",
comment="HI!")
c2 = Comment(comment_id=2,
user_id=2,
event_id="43104373341",
comment="HI!")
db.session.add_all([u1, u2, e1, e2, bt1, bt2, b1, b2, c1, c2])
db.session.commit()
def method_specification_success(user_id, relatp_id):
"""Add the methods specified to the relationship."""
# Grab the recommendation list specified for the relationship.
desired_list = request.form.getlist('rcmdn')
# Add the customized list to the respective relationship.
update_relatp = Relationship.query.filter_by(user_id=user_id,
id=relatp_id).first()
update_relatp.rcmdn_list = desired_list
# The created_at column should be placed in the Relationship table.
created_at = db.session.query(
Relationship.created_date).filter_by(id=relatp_id).one()
# Turn the query result (a tuple of datetime) into an Arrow-friendly format.
arrow_created_at = arrow.get(created_at[0])
# The start date of all events will be a month from the date he/she was added.
start_date = arrow_created_at.replace(months=+1)
# Events will be scheduled for a max of a year for demo purposes.
yr_from_now = start_date.replace(years=+1)
# Create events for the duration of the year.
# Friends and family should have an event a month.
# Professional contacts should have an event per quarter.
while start_date < yr_from_now:
for desired_item in desired_list:
if update_relatp.relatp_type == 'fr' or update_relatp.relatp_type == 'fam':
# Convert from arrow format to datetime format for db storage.
new_event = Event(user_id=user_id,
relatp_id=relatp_id,
rcmdn=desired_item,
scheduled_at=start_date.datetime)
db.session.add(new_event)
start_date = start_date.replace(months=+1)
else:
new_event = Event(user_id=user_id,
relatp_id=relatp_id,
rcmdn=desired_item,
scheduled_at=start_date.datetime)
db.session.add(new_event)
start_date = start_date.replace(months=+4)
db.session.commit()
return render_template('reach_out_added.html',
user_id=user_id,
desired_list=desired_list)
def example_data():
phone = os.environ.get('MY_NUMBER')
email = os.environ.get('MY_EMAIL')
fb_at = os.environ.get('FB_AT')
fb_uid = os.environ.get('FB_UID')
# ADD USERS
jane = User(email='*****@*****.**',
password='******',
fname='Jane',
lname='Hacks',
phone='+11234567890')
bob = User(email='*****@*****.**',
password='******',
fname='Bob',
lname='Baller',
phone='+10987654321')
db.session.add_all([jane, bob])
# db.session.add(inny)
db.session.commit()
# ADD CONTACTS
john = Contact(name='John Recruitor',
email='*****@*****.**',
user_id=jane.id)
sally = Contact(name='Sally Secretary',
email='*****@*****.**',
user_id=bob.id)
ian = Contact(name='Ian Interviewer', email='*****@*****.**', user_id=bob.id)
db.session.add_all([john, sally, ian])
db.session.commit()
# ADD TEMPLATES
fup = Template(name='follow up', text='hello there')
ty = Template(name='thank you', text='thank you for meeting!')
ty2 = Template(name='thank you', text='thank you for meeting!')
fup2 = Template(name='follow up', text='hello there')
db.session.add_all([ty, ty2, fup, fup2])
db.session.commit()
# ADD EVENTS
e1 = Event(contact_id=ian.id,
date=datetime.datetime(2017, 12, 30),
template_id=fup.id)
e2 = Event(contact_id=john.id, template_id=ty.id)
e3 = Event(contact_id=ian.id, template_id=ty2.id)
e4 = Event(contact_id=sally.id,
date=datetime.datetime(2018, 1, 1),
template_id=fup2.id)
db.session.add_all([e1, e2, e3, e4])
db.session.commit()
# ADD CONTACTEVENT ASSOCIATIONS
ce1 = ContactEvent(contact_id=e1.contact_id, event_id=e1.id)
ce2 = ContactEvent(contact_id=e2.contact_id, event_id=e2.id)
ce3 = ContactEvent(contact_id=e3.contact_id, event_id=e3.id)
ce4 = ContactEvent(contact_id=e4.contact_id, event_id=e4.id)
db.session.add_all([ce1, ce2, ce3, ce4])
db.session.commit()
def edit_event(id):
event_selected = Event.query.filter(Event.id == id).first()
found_players_number = JoinedEvent.query.filter(
JoinedEvent.event_id == id).count() - 1
if found_players_number == 0:
found_players_number = 1
session['sport_selected'] = event_selected.sport_id
create_event_form = CreateEvent()
if create_event_form.is_submitted():
Event.query.filter(Event.id == id).delete()
db.session.commit()
if create_event_form.sport_club.data == "other":
event = Event(id=id,
town_id=create_event_form.town.data,
sport_id=create_event_form.sport.data,
place=create_event_form.place.data,
date_start=create_event_form.date_start.data,
date_end=create_event_form.date_end.data,
wanted_players_number=create_event_form.
wanted_players_number.data,
creator_id=session['user_id'])
db.session.add(event)
db.session.commit()
else:
event = Event(id=id,
town_id=create_event_form.town.data,
sport_id=create_event_form.sport.data,
sport_club_id=create_event_form.sport_club.data,
date_start=create_event_form.date_start.data,
date_end=create_event_form.date_end.data,
wanted_players_number=create_event_form.
wanted_players_number.data,
creator_id=session['user_id'])
db.session.add(event)
db.session.commit()
return redirect(url_for('event', id=id))
towns = Town.query.all()
sports = Sport.query.all()
sportclubs = User.query.filter(User.role_id == 3).all()
details = SportClubDetails.query.all()
practicable_sports = FavouriteSport.query.all()
return render_template('edit_event.html',
create_event_form=create_event_form,
towns=towns,
sports=sports,
sportclubs=sportclubs,
details=details,
practicable_sports=practicable_sports,
event_selected=event_selected,
found_players_number=found_players_number)
def member_update():
"""Member updation process"""
first_name = request.form.get("Member_Firstname")
last_name = request.form.get("Member_Lastname")
email = request.form.get("Member_Email")
phonenumber = request.form.get("Member_Phonenumber")
date_of_birth_str = request.form.get("Member_Birthday")
date_of_birth = datetime.strptime(date_of_birth_str, '%Y-%m-%d')
marriage_date_str = request.form.get("Member_Marriage_Anniversary")
if marriage_date_str != '':
marriage_date = datetime.strptime(marriage_date_str, '%Y-%m-%d')
else:
marriage_date = None
relation = request.form.get("Member_Relation")
user_profile = get_profile()
member_profile = Member(profile_id=user_profile.profile_id,
first_name=first_name,
last_name=last_name,
email=email,
phonenumber=phonenumber,
date_of_birth=date_of_birth,
marriage_date=marriage_date,
relation=relation)
db.session.add(member_profile)
db.session.commit()
#Add birthday and marriage anniversary to events
text = f"Birthday for {first_name} {last_name}"
member_db_event = Event(profile_id=user_profile.profile_id,
member_id=member_profile.member_id,
event_type='Birthday',
event_date=date_of_birth,
event_text=text)
db.session.add(member_db_event)
if marriage_date is not None:
text = f"Marriage Anniversary for {first_name} {last_name} and {user_profile.fullname()}"
marriage_event = Event(profile_id=user_profile.profile_id,
member_id=member_profile.member_id,
event_type='Marriage_Anniversary',
event_date=marriage_date,
event_text=text)
db.session.add(marriage_event)
db.session.commit()
return redirect("/member")
def create_event():
create_event_form = CreateEvent()
if create_event_form.is_submitted():
if create_event_form.sport_club.data == "other":
event = Event(town_id=create_event_form.town.data,
sport_id=create_event_form.sport.data,
place=create_event_form.place.data,
date_start=create_event_form.date_start.data,
date_end=create_event_form.date_end.data,
wanted_players_number=create_event_form.
wanted_players_number.data,
creator_id=session['user_id'])
db.session.add(event)
db.session.commit()
else:
event = Event(town_id=create_event_form.town.data,
sport_id=create_event_form.sport.data,
sport_club_id=create_event_form.sport_club.data,
date_start=create_event_form.date_start.data,
date_end=create_event_form.date_end.data,
wanted_players_number=create_event_form.
wanted_players_number.data,
creator_id=session['user_id'])
db.session.add(event)
db.session.commit()
last_event = Event.query.filter(
Event.creator_id == session['user_id']).order_by(
Event.date_added.desc()).first()
je = JoinedEvent(user_id=session['user_id'], event_id=last_event.id)
db.session.add(je)
db.session.commit()
return redirect("events")
towns = Town.query.all()
sports = Sport.query.all()
sportclubs = User.query.filter(User.role_id == 3).all()
details = SportClubDetails.query.all()
practicable_sports = FavouriteSport.query.all()
return render_template('create_event.html',
create_event_form=create_event_form,
towns=towns,
sports=sports,
sportclubs=sportclubs,
details=details,
practicable_sports=practicable_sports)
def generate_event(max_possible_id, ev_id=None):
if ev_id is None:
ev_id = randint(0, max_possible_id)
ev = Event("/some/dummy/path%d" % ev_id)
ev.id = ev_id
return ev
def load_events():
"""Load events from event.txt into database."""
print "Events"
for i, row in enumerate(open("data/event.txt")):
row = row.rstrip()
concert_id, name, location, start, end, logistics = row.split("| ")
start_day_time = datetime.datetime.strptime(start, "%b-%d-%Y-%H:%M")
end_day_time = datetime.datetime.strptime(end, "%b-%d-%Y-%H:%M")
event = Event(concert_id=concert_id,
name=name,
location=location,
start_day_time=start_day_time,
end_day_time=end_day_time,
event_logistics=logistics)
# Add to the session.
db.session.add(event)
# Commit the session/data to the dbase.
db.session.commit()
def create_event():
"""Add a new event into database."""
# POST reqs have a body, so you can extract out the parsed JSON data
# req_body = request.get_json()
req_body = {
'title': request.form.get('title'),
'start_on': request.form.get('startTime'),
'end_on': request.form.get('endTime')
}
datetime_format = "%Y-%m-%dT%H:%M"
req_body['start_on'] = datetime.strptime(req_body['start_on'],
datetime_format)
req_body['end_on'] = datetime.strptime(req_body['end_on'], datetime_format)
req_body['created_on'] = datetime.now()
req_body['host'] = session['user_id']
# Note: ** is used to "spread" an object into keyword arguments, where (key=argument name), and (value=argument value)
event = Event(**req_body)
db.session.add(event)
db.session.commit()
# Need to refresh db.session to obtain the newly created event instance
# Useful for extracting out the event id to redirect to another API
db.session.refresh(event)
return jsonify(event.event_id)
def load_events(event_filename):
"""Load events from event_data.csv into DB."""
print("Events")
for i, row in enumerate(open(event_filename)):
row = row.rstrip()
event_id, host, category, title, start_str, end_str, created_str = row.split(
"|")
host = int(host)
start_on = datetime.strptime(start_str, "%m/%d/%Y %H:%M")
end_on = datetime.strptime(end_str, "%m/%d/%Y %H:%M")
created_on = datetime.strptime(created_str, "%m/%d/%Y %H:%M")
# Instantiate event
event = Event(host=host,
category=category,
title=title,
start_on=start_on,
end_on=end_on,
created_on=created_on)
# Add event to session
db.session.add(event)
# Commit all event instances to DB
db.session.commit()
def saving_event_results():
"""save a specific event to the database"""
e_name = request.form.get('name')
e_link = request.form.get('url')
e_description = request.form.get('description')
e_catergory_id = request.form.get('category_id')
e_location = request.form.get('address')
new_event = Event(e_name=e_name,
e_link=e_link,
e_description=e_description,
e_catergory_id=e_catergory_id,
e_location=e_location)
db.session.add(new_event)
#commit() is a two way interaction. Sends event info to my db and can return the event_id.
db.session.commit()
user_id = session.get("user_id")
new_no_table = NightOut(user_id=user_id, event_id=new_event.event_id)
db.session.add(new_no_table)
db.session.commit()
return jsonify({"sucess": True})
def add_event(title,start, end, descrip, picfile): """ Add a event to the database """ event = Event(name=title, start=start, end = end, desc=descrip,image=picfile) session.add(event) session.commit()
def load_events():
"""Load events from u.event into database."""
print "Events"
# Delete db to avoid duplicates
Event.query.delete()
# Read u.event file and insert data
for row in open("seed_data/u.event"):
row = row.rstrip()
start_at, end_at, image_url, link, podcast_id = row.split("|")
event = Event(start_at=start_at,
end_at=end_at,
image_url=image_url,
link=link,
podcast_id=podcast_id)
# add event to session
db.session.add(event)
# Commit the add of an event
db.session.commit()
def load_events():
"""Load events from csv file into database."""
print('Events')
# Read data from 19hz wbsite and insert data to database
for row in open(BASE_PATH + 'seed_data/19hz_scrape.csv'):
row = row.rstrip()
name, location, date, genre, price_age, organizer, link = row.split(
'\t')
event = Event(
name=name,
location=location,
date=date,
genre=genre,
price_age=price_age,
organizer=organizer,
link=link,
)
# add to the session to store
db.session.add(event)
# commit the work
db.session.commit()
logger.info('Events table updated successfully.')
def process_event_mood_log():
""" Add event log to db"""
# get user inputs
event_name = request.form.get('event-name')
event_date = datetime.strptime(request.form.get('today-event-date'),
'%Y-%m-%d').date()
# end_date = datetime.strptime(request.form.get('end-date'), '%Y-%m-%d').date()
user_id, overall_mood, min_mood, max_mood, notes = get_mood_rating()
# create event
event = Event(event_name=event_name,
user_id=user_id,
overall_mood=overall_mood,
max_mood=max_mood,
min_mood=min_mood,
notes=notes)
db.session.add(event)
db.session.commit()
# event.associate_days(start_date, end_date)
if not event_date in [day.date for day in event.user.days]:
event.create_dummy_day(event_date)
flash('Event %s on today (%s) successfully created' %
(event_name, event_date))
return redirect('/user_profile')
def createEvent():
if request.method == 'POST':
if request.headers.getlist("X-Forwarded-For"):
ip = request.headers.getlist("X-Forwarded-For")[0]
else:
ip = request.remote_addr
if verifyCaptcha(request.form['g-recaptcha-response'], ip).status_code != 200:
flash(u'You Are Not A Human. Gain A Corpeal Form And Try Again')
redirect(url_for('home'))
event_type = request.form['event_type']
title = request.form['title']
description = request.form['description']
print 'b'
signup_email = request.form['signup_email']
signup_email = True if signup_email == 'on' else False
reminder_email = request.form['reminder_email']
reminder_email = True if reminder_email == 'Yes' else False
reminder_time = request.form['reminder_time']
country = request.form['country']
address1 = request.form['address1']
address2 = request.form['address2']
city = request.form['city']
state = request.form['state']
zipCode = request.form['zipCode']
venue = request.form['venue']
capacity = request.form['capacity']
directions = request.form['directions']
date = request.form['date']
date = date.split('-')
time_hour = int(request.form['time_hour'])
time_minutes = request.form['time_minutes']
time_day = request.form['time_day']
if time_day == 'pm':
time_hour += 12
event_time = datetime.datetime(int(date[0]), int(date[1]), int(date[2]), int(time_hour), int(time_minutes), 0)
length = request.form['length']
length_unit = request.form['length_unit']
phone = request.form['phone']
public_phone = request.form['public_phone']
host = request.form['host']
email = request.form['email']
loc = address1 + " " + address2 + " " + city + ", " + state + " " + zipCode
print loc
geolocator = Nominatim()
location = geolocator.geocode(loc)
print(location.address)
print((location.latitude, location.longitude))
lat = location.latitude
lng = location.longitude
newEvent = Event(event_type=event_type, title=title, description= description, signup_email=signup_email, reminder_email=reminder_email, reminder_time=reminder_time, country=country, address1=address1, address2=address2, city=city, state=state, zipCode=zipCode, venue=venue, capacity=capacity, directions=directions, event_time = event_time, length=length, length_unit=length_unit, phone=phone, public_phone=public_phone, host=host, email=email, lat = lat, lng =lng)
session.add(newEvent)
session.commit()
flash(u'You Have Created a New Event')
return redirect(url_for('home'))
else:
resp = make_response(render_template('event.html', captcha=True))
return resp
def deserialise_event(dic) -> Event:
id = UUID(dic[K_ID])
title = dic[K_TITLE]
desc = dic.get(K_DESC, None)
timespec_se = dic.get(K_TIMESPEC, None)
timespec = deserialise_reltimespec(timespec_se)
return Event(id=id, title=title, desc=desc, timespec=timespec)
def add_events_db(results):
"""Add event listing info to events table."""
for event in results:
name = event['name']
starts_at = event['starts_at']
ends_at = event['ends_at']
venue = event['venue']
address = event['address']
url = event['url']
img = event['img']
# checks for existing event in table. if found, skip
if Event.query.filter_by(eventbrite_url=url).first():
continue
else:
new_event = Event(name=name,
starts_at=starts_at,
ends_at=ends_at,
venue=venue,
address=address,
eventbrite_url=url,
img=img)
db.session.add(new_event)
db.session.commit()
def post(self):
data = request.json
event_obj = Event()
event_obj.id_partnership = data.get('id_partnership', None)
if not event_obj.id_partnership:
raise BadRequest('Partnership is Mandatory')
event_obj.hour_since = data.get('hour_since', None)
if not event_obj.hour_since:
raise BadRequest('Hour since is Mandatory')
event_obj.hour_until = data.get('hour_until', None)
if not event_obj.hour_until:
raise BadRequest('Hour until is Mandatory', None)
event_obj.id_user = data.get('id_user', None)
if not event_obj.id_user:
raise BadRequest('User id is Mandatory', None)
try:
db.session.add(event_obj)
db.session.commit()
except Exception as e:
db.session.rollback()
print(str(e))
raise InternalServerError('Unable to store a new Visitor')
event_save = Event.query.order_by(Event.id.desc()).first()
event_save = self.event_schema.dump(event_save).data
return jsonify({'Event': event_save})
def load_seed_events():
"""Load sample events from seed_events.csv"""
for row in open("seed_data/seed_events.csv"):
row = row.rstrip()
user_id, haz_id, event_title, active, datetime_seen, event_start, event_end, description, last_edited, last_edited_user, latitude, longitude = row.split(
",")
if active == 'TRUE':
active = True
else:
active = False
event = Event(user_id=user_id,
haz_id=haz_id,
event_title=event_title,
active=active,
datetime_seen=datetime_seen,
event_start=event_start,
event_end=event_end,
description=description,
last_edited=last_edited,
last_edited_user=last_edited_user,
latitude=latitude,
longitude=longitude)
db.session.add(event)
db.session.commit()
print("Successfully seeded into the events table!")
def load_events():
"Load events from dataeventbrite.json into database"
# print ("*")*20, "loading event bright!", ("*")*20
data = open("seed_data/data.json").read()
data = json.loads(data)
counter = 0
# event_data = {}
for event in data:
# row = row.rstrip()
# event_id, title, date, location, event_category, picture, organizer = row.split(",")
#check if event at title is type ascii ,if it is event then "contiune"
# if type(event["title"]) == ascii:
# contiune
print event['title']
event_db = Event(title=event["title"],
date=event["date"],
address=event["address"],
picture=event["picture"],
lat=event["lat"],
longi=event["long"])
print event_db
#add to the session
db.session.add(event_db)
counter = counter + 1
print counter
#commit the work
db.session.commit()
def load_all(self):
with open(self.event_file, 'r') as evfile:
data = evfile.read()
events = []
raw_events = data.split("# New Event")
for e in raw_events:
if len(e) > 0:
ev_dict = yaml.load(e)
ev_id = ev_dict["id"]
new_event = Event(ev_id, self.directory)
xhits = ev_dict["xhits"]
yhits = ev_dict["yhits"]
new_event.hits = [Hit(x, y) for x, y in zip(xhits, yhits)]
events.append(new_event)
with open(self.track_file, 'r') as trfile:
data = trfile.read()
raw_tracks = data.split("---")
tracks = [yaml.load(t) for t in raw_tracks if t.split()]
for t in tracks:
t.displayed = True
t.parameters = {}
if not hasattr(t, "color"):
t.color = get_color(t.id)
event_id = t.event_id
filt_events = filter(lambda ev: ev.id == event_id, events)
if len(filt_events) > 0:
event = filt_events[0]
event.add_track(t)
return events
def save_event():
"""Save an event's details to user's saved events list in database"""
eventbrite_id = request.form.get('evtID')
print("id: " + eventbrite_id)
if not Event.query.filter(Event.eventbrite_id == eventbrite_id).first():
response = requests.get(EVENTBRITE_URL + "events/" + eventbrite_id,
headers=HEADERS)
data = response.json()
debug_print(data)
new_event = Event(
eventbrite_id=eventbrite_id,
event_name=data['name']['text'],
event_url=data['url'],
date=data["start"]["local"],
category=data["category_id"],
description=data["summary"],
)
db.session.add(new_event)
new_save = UserEvent(eventbrite_id=eventbrite_id,
user_id=session['user']['user_id'])
db.session.add(new_save)
db.session.commit()
return jsonify(status="success")
def testFirst(self):
first_query = self.first_query
session.query(Event).delete()
session.commit()
session.flush()
e = Event(self.et)
e.title = 'First event'
e.time_start = datetime(1970, 1, 1, 0, 0)
e.time_end = datetime(1970, 1, 1, 3, 0)
e.description = 'First description'
e.source_type = EventSourceType.EMPTY
session.add(e)
session.commit()
all_first = first_query.all()
self.assertEquals(len(all_first), 1)
e = all_first[0]
self.assertEquals(e.title, 'First event')
self.assertEquals(e.time_start, datetime(1970, 1, 1, 0, 0))
self.assertEquals(e.time_end, datetime(1970, 1, 1, 3, 0))
self.assertEquals(e.description, 'First description')
self.assertEquals(e.source_type, EventSourceType.EMPTY)
self.assertEquals(e.event_type.name, 'first')
all_date_empty = session.query(Event).filter(
Event.time_start == date(1971, 1, 1)).all()
self.assertEquals(len(all_date_empty), 0)
all_date_fine = session.query(Event).filter(
Event.time_start == date(1970, 1, 1)).all()
self.assertEquals(len(all_date_fine), 1)
session.delete(e)
session.commit()
def create_events(event_name,location, date,time,limitations):
events = Event(event_name = event_name,location = location,date = date,time = time,limitations =limitations)
db.session.add(events)
db.session.commit()
return events
def load_events():
"""Load goals from goal.txt into database."""
print "Seeding events"
# Delete all rows in table, so if we need to run this a second time,
# we won't be trying to add duplicate users
Event.query.delete()
# Read u.user file and insert data
for row in open("seed_data/event.txt"):
row = row.rstrip()
event_id, start_time, stop_time, user_id, timer_id \
= row.split("|")
event = Event(event_id=event_id,
start_time=start_time,
stop_time=stop_time,
user_id=user_id,
timer_id=timer_id,
status='active')
db.session.add(event)
db.session.commit()
def load_events():
"""Load events from u.event into database."""
print "Events"
# Delete all rows in table, so if we need to run seed.py multiple times,
# won't add duplicate events
Event.query.delete()
# Read u.event file and insert data
for row in open("seed_data/u.event"):
row = row.rstrip()
# row = row.split('|')
# row = row[1:]
animal_id, time, long_location, lat_location = row.split('|')
timestamp = datetime.strptime(time, '%Y-%m-%d %H:%M:%S')
long_location = float(long_location)
lat_location = float(lat_location)
event = Event(animal_id=animal_id,
timestamp=timestamp,
long_location=long_location,
lat_location=lat_location)
db.session.add(event)
db.session.commit()
def process_user_shows():
"""processes selected shows and redirects to display shows user is attending"""
user = get_user_object()
shows = request.args.getlist('shows')
if shows:
for show in shows:
show_there = db.session.query(Event).filter(
Event.eventbrite_event_id == show).first()
if show_there and show not in [
event.eventbrite_event_id for event in user.events
]:
user.events.append(show_there)
else:
new_show = Event(
eventbrite_event_id=request.args.get(
show + "_eventbrite_event_id"),
event_name=request.args.get(show + "_event_name"),
venue_id=request.args.get(show + "_venue_id"),
eventbrite_url=request.args.get(show + "_eventbrite_url"),
logo_url=request.args.get(show + "_logo_url"),
start=request.args.get(show + "_start"),
end=request.args.get(show + "_end"),
users=[user],
)
db.session.add(new_show)
db.session.commit()
return redirect("/account/shows/attending")
def load_events():
print "Event"
for row in open("seed_data/u.event_data"):
row = row.rstrip()
print row.split("|")
city_id, event_id, destination, event_date, event_time, event_name, event_location, event_cost, event_theme, event_description = row.split(
"|")
event = Event(city_id=city_id,
event_id=event_id,
destination=destination,
event_date=event_date,
event_time=event_time,
event_name=event_name,
event_location=event_location,
event_cost=event_cost,
event_theme=event_theme,
event_description=event_description)
# Add to the session
db.session.add(event)
# provide some sense of progress
# Once we're done, we should commit our work
db.session.commit()
