def venues_create_post():
# TODO: insert form data as a new Venue record in the db, instead
# TODO: modify data to be the data object returned from db insertion
try:
form = VenueForm(request.form)
if form.validate():
name = request.form.get('name', '')
city = request.form.get('city', '')
state = request.form.get('state', '')
address = request.form.get('address', '')
phone = request.form.get('phone', '')
genres = request.form.getlist('genres')
facebook_link = request.form.get('facebook_link', '')
venue = Venue(name=name,
city=city,
state=state,
address=address,
phone=phone,
genres=genres,
facebook_link=facebook_link)
venue.insert()
# db.session.add(venue)
# db.session.commit()
# on successful db insert, flash success
flash('Venue ' + request.form['name'] + ' was successfully listed!')
return render_template('pages/home.html')
except:
db.session.rollback()
flash('An error occurred. Venue ' + request.form['name'] +
' could not be listed.')
def create_venue_submission():
error = False
try:
venue = Venue()
venue.name = request.form['name']
venue.city = request.form['city']
venue.state = request.form['state']
venue.address = request.form['address']
venue.phone = request.form['phone']
genre = request.form.getlist('genres')
venue.genres = ','.join(genre)
venue.facebook_link = request.form['facebook_link']
db.session.add(venue)
db.session.commit()
except:
error = True
db.session.rollback()
print(sys.exc_info())
db.session.close()
if error:
flash('An error occured. Venue ' +
request.form['name'])
else:
flash('Venue ' + request.form['name'] +
' was successfully added!')
return render_template('pages/home.html')
def merge(self, id, other_id):
try:
old = Venue.get(id)
new = Venue.get(other_id)
Venue.merge(old, new)
# add this to fixup dict, so will never have to merge again
venue_fixup_dict[old.name] = new.name
venue_fixup_dict.tidy(old.name, new.name)
flash("%s merged into %s and learned" % (old.name, new.name))
except SQLObjectNotFound:
flash("Could not move")
util.redirect("/venues/%s" % other_id)
def save(self, id=0, **kw):
if id:
try:
v = Venue.get(id)
v.set(**v.clean_dict(kw))
flash("Updated")
except SQLObjectNotFound:
flash("Update Error")
else:
v = Venue(added_by=identity.current.user, **Venue.clean_dict(kw))
flash("Added")
v.approved = datetime.now()
util.redirect("/venues/%s" % v.id)
def update_venues():
refresh_date = datetime.date.today() - datetime.timedelta(venue_refresh_days)
venues = Venue.select(
AND(Venue.q.approved != None, OR(Venue.q.batch_updated == None, Venue.q.batch_updated < refresh_date))
)
count = venues.count()
if not util.is_production():
count = min(count, 10)
for venue in venues[:count]:
if venue.zip_code:
area = ", " + venue.zip_code
else:
area = ", Portland, OR"
if venue.address:
try:
lat, lon, zip_code = geo.get_geocode(venue.address + area)
venue.geocode_lat = lat
venue.geocode_lon = lon
if not venue.zip_code:
venue.zip_code = zip_code
except IOError:
pass
venue.batch_updated = datetime.datetime.now()
return count
def create_venue_submission():
form = VenueForm()
# TODO: insert form data as a new Venue record in the db, instead
# TODO: modify data to be the data object returned from db insertion
if request.method == 'POST':
try:
venue = Venue(
name=form.name.data,
city=form.city.data,
state=form.state.data,
address=form.address.data,
genres=form.genres.data,
phone=form.phone.data,
website=form.website.data,
image_link=form.image_link.data,
facebook_link=form.facebook_link.data
)
db.session.add(venue)
db.session.commit()
# on successful db insert, flash success
flash('Venue ' + form.name.data + ' was successfully listed!')
except:
db.session.rollback()
# DONE: on unsuccessful db insert, flash an error instead.
flash('An error occurred. Venue ' +
form.name.data + ' could not be listed.')
finally:
db.session.close()
return render_template('pages/home.html')
def load_venues(file_user):
# Venue.query.delete()
for row in (open(file_user)):
row = row.strip()
user_id, venue_name, venue_url, venue_email, venue_address, venue_city, venue_type, venue_backspace, venue_capacity, venue_license, time_id, venue_rent, venue_ranking = row.split(
",")
# IF YOU ADD THE ACT PREFERRED: ADD THE venue_show_preferred TO THE UMPAKING
new_venue = Venue(user_id=user_id,
venue_name=venue_name,
venue_url=venue_url,
venue_email=venue_email,
venue_address=venue_address,
venue_city=venue_city,
venue_type=venue_type,
venue_backspace=venue_backspace,
venue_capacity=venue_capacity,
venue_license=venue_license,
time_id=time_id,
venue_rent=venue_rent,
venue_ranking=venue_ranking)
db.session.add(new_venue)
db.session.commit()
def load_venues():
"""Load venue information into database"""
print('load_venues')
Venue.query.delete()
for row in open("seed_data/venues.csv"):
row = row.rstrip()
subcategory, \
created_by, \
title, \
addr_1, \
addr_2, \
city, \
postal_code, \
state = row.split(',')
cat_sub = Category_Subcategory.query.filter_by(name=subcategory).first()
vnu = Venue(subcategory_id=cat_sub.id,
created_by=created_by,
name=title,
addr_1=addr_1,
addr_2=addr_2,
city=city,
postal_code=postal_code,
state=state)
db.session.add(vnu)
db.session.commit()
def register_venue():
name = request.form.get('name')
addr_1 = request.form.get('addr_1')
addr_2 = request.form.get('addr_2')
city = request.form.get('city')
postal_code = request.form.get('postal_code')
state = request.form.get('state')
country = request.form.get('country')
category = request.form.get('category')
if Venue.query.filter_by(name=name).first():
return jsonify({'error': 'duplicate name'})
user_id = session['user_id']
user = User.query.get(user_id)
created_by = user.id
venue = Venue(name=name, \
addr_1=addr_1, \
addr_2=addr_2, \
city=city, \
postal_code=postal_code, \
state=state, \
country=country, \
created_by=created_by)
db.session.add(venue)
db.session.commit()
session['venue_id'] = venue.id
return redirect('/create')
def edit(self, id=0, **kw):
form_vals = {}
template = ".templates.event.add"
if id:
try:
e = Event.get(id)
form_vals = util.so_to_dict(e)
form_vals['artists'] = "\n".join([a.name for a in e.artists])
form_vals['venue'] = dict(text=e.venue.name)
template = ".templates.event.edit"
except SQLObjectNotFound:
pass
else:
form_vals = dict(id=id)
try:
a = Artist.get(int(kw['artist_prefill']))
form_vals['artists'] = a.name
except (SQLObjectNotFound, KeyError):
pass
try:
v = Venue.get(int(kw['venue_prefill']))
flash(form_vals)
form_vals['venue'] = dict(text=v.name)
except (SQLObjectNotFound, KeyError):
pass
return dict(tg_template=template, event_form=event_form, form_vals=form_vals)
def create_venue_submission():
try:
venueData = request.form
venueName = venueData.get('name')
venueCity = venueData.get('city')
venueState = venueData.get('state')
venueAddress = venueData.get('address')
venuePhone = venueData.get('phone')
venueFacebookLink = venueData.get('facebook_link')
venueGenresList = venueData.getlist('genres')
venue = Venue(name=venueName,
city=venueCity,
state=venueState,
address=venueAddress,
phone=venuePhone,
facebook_link=venueFacebookLink)
for venueGenres in venueGenresList:
if Genres.query.filter_by(name=venueGenres).first():
venue.genres.append(
Genres.query.filter_by(name=venueGenres).first())
else:
genres = Genres(name=venueGenres)
venue.genres.append(genres)
db.session.add(venue)
db.session.commit()
flash('Venue ' + request.form['name'] + ' was successfully listed!')
except:
db.session.rollback()
flash('An error occurred. Venue ' + request.form['name'] +
' could not be listed!')
finally:
db.session.close()
return render_template('pages/home.html')
def create_venue_submission():
form = VenueForm(request.form)
flashType = 'fail' #default Initialization of flash type to false
if form.validate():
try:
venue = Venue(name = request.form['name'],
city = request.form['city'],
state = request.form['state'],
address = request.form['address'],
phone = request.form['phone'],
genres = request.form.getlist('genres'),
facebook_link = request.form['facebook_link']
)
db.session.add(venue)
db.session.commit()
flashType = 'success'
flash('Venue ' + request.form['name'] + ' was successfully listed!')
except:
flash('An error occurred due to database insertion error. Venue {} could not be listed.'.format(request.form['name']))
finally:
db.session.close()
else:
flash(form.errors)
flash('An error occurred due to form validation. Venue {} could not be listed.'.format(request.form['name']))
return render_template('pages/home.html')
def show_search_result():
location = request.form["location"]
venue = findAVenue(location)
name = venue.get("name", "")
img_url = venue.get("img_url", "")
address = venue.get("address", "")
matched_venue = Venue.query.filter_by(img_url=img_url).first()
print(matched_venue)
if venue == "No matching venues.":
flash("No result for that location. Try, 'San Francisco, CA'.")
return redirect("/")
if matched_venue:
return render_template("search_result.html",
matched_venue=matched_venue)
else:
matched_venue = None
if img_url:
new_venue = Venue(name=name, address=address, img_url=img_url)
db.session.add(new_venue)
db.session.commit()
return render_template("search_result.html",
name=name,
img_url=img_url,
address=address,
matched_venue=matched_venue)
def create_venue_submission():
error = False
try:
dict = request.form
new_venue = Venue(name=dict.get('name'),
city=dict.get('city'),
state=dict.get('state'),
address=dict.get('address'),
phone=dict.get('phone'),
genres=dict.getlist('genres'),
facebook_link=dict.get('facebook_link'))
db.session.add(new_venue)
db.session.commit()
except:
error = True
db.session.rollback()
print(sys.exc_info())
finally:
db.session.close()
if error:
flash('An error occurred. Venue ' + request.form['name'] +
' could not be listed.')
else:
flash('Venue ' + request.form['name'] + ' was successfully listed!')
return render_template('pages/home.html')
def edit(self, id=0):
if id:
try:
v = Venue.get(id)
except SQLObjectNotFound:
flash("Invalid ID")
util.redirect("/venues/list")
else:
v = {}
return dict(venue_form=venue_form, form_vals=v)
def delete(self, id):
try:
v = Venue.get(id)
v.destroySelf()
flash("Deleted")
except SQLObjectNotFound:
flash("Not Found")
except SQLObjectIntegrityError:
flash("Cannot delete")
util.redirect("/venues/list")
def untrack(self, id, viewing="no"):
u = identity.current.user
try:
v = Venue.get(id)
if v in u.venues:
u.removeVenue(v)
except SQLObjectNotFound:
flash("Venue not found")
util.redirect("/")
if viewing == "no":
util.redirect_previous()
else:
util.redirect("/venues/%s" % v.id)
def create_venue_submission():
# TODO: insert form data as a new Venue record in the db, instead
# TODO: modify data to be the data object returned from db insertion
error = False
data = {}
try:
name = request.form.get('name')
city = request.form.get('city')
state = request.form.get('state')
address = request.form.get('address')
phone = request.form.get('phone')
image_link = request.form.get('image_link')
genres = request.form.getlist('genres')
facebook_link = request.form.get('facebook_link')
website = request.form.get('website')
seeking_talent = request.form.get('seeking_talent')
if seeking_talent == "True":
seeking_talent = True
else:
seeking_talent = False
seeking_description = request.form.get('seeking_description')
venue = Venue(name=name,
city=city,
state=state,
address=address,
phone=phone,
image_link=image_link,
genres=genres,
facebook_link=facebook_link,
website=website,
seeking_talent=seeking_talent,
seeking_description=seeking_description)
db.session.add(venue)
db.session.commit()
data = venue
print(data)
except:
error = True
db.session.rollback()
print(sys.exc_info())
finally:
db.session.close()
if error:
# TODO: on unsuccessful db insert, flash an error instead.
flash('An error occurred. Venue ' + data.name +
' could not be listed.')
else:
# on successful db insert, flash success
flash('Venue ' + data.name + ' was successfully listed!')
return render_template('pages/home.html')
def create_venue_submission():
"""
Submit new venue form and persist
"""
try:
request.get_data()
genres = request.form.getlist('genres')
venue_dict = request.form.to_dict()
seeking_talent = venue_dict['seeking_talent'] == "True"
venue = Venue(name=venue_dict['name'], city=venue_dict['city'], state=venue_dict['state'],\
address=venue_dict['address'], phone=venue_dict['phone'],\
facebook_link=venue_dict['facebook_link'],\
website_link=venue_dict['website_link'], image_link=venue_dict['image_link'],\
seeking_talent=seeking_talent, seeking_description=venue_dict['seeking_description'])
venue.create(genres)
flash('Venue ' + request.form['name'] + ' was successfully listed!')
except Exception as e:
print("Error while creating new venue: ", e)
print(traceback.format_exc())
flash('An error occurred. Venue ' + request.form['name'] +
' could not be listed.')
abort(500)
return render_template('pages/home.html')
def dyntrack(self, id, track):
u = identity.current.user
ret = "Error"
try:
v = Venue.get(id)
if track == "true" and v not in u.venues:
u.addVenue(v)
ret = "Tracked"
if track == "false" and v in u.venues:
u.removeVenue(v)
ret = "Untracked"
except SQLObjectNotFound:
pass
return ret
def show(self, id, list_all=0):
try:
v = Venue.get(id)
except SQLObjectNotFound:
flash("Venue ID not found")
util.redirect("/venues/list")
except ValueError:
try:
v = Venue.byNameI(urllib.unquote_plus(id))
except SQLObjectNotFound:
flash("Venue ID not found")
util.redirect("/venues/list")
is_tracked = identity.current.user and v in identity.current.user.venues
past_events = v.past_events.orderBy('-date')
if not list_all:
past_events = past_events[:5]
future_events = v.future_events.orderBy('date')
return dict(venue=v, past_events=past_events, future_events=future_events,
description=util.desc_format(v.description), googlemap=googlemap,
tracked_count=v.users.count(), is_tracked=is_tracked)
def all_venues_handler():
# Return all venuess in database.
# If request method is GET, run a query on the database's Venue table
# (Class) for all venues. Return value is a list of Venue objects.
if request.method == 'GET':
venues = session.query(Venue).all()
print(venues)
# Query results (variable venues which is a list data type) are
# serialized, or, made into a dictionary then added to a list via a list
# comprehension. This list is then jsonfied for injestion by front end.
return jsonify(venues=[i.serialize for i in venues])
# Make a new venue and store it in the database.
elif request.method == 'POST':
# Flask.Request.args creates a MultiDict (dictionary subclass customized
# to deal with multiple values for the same key which, is used by the
# parsing functions in the wrappers. This is necessary because some HTML
# form elements pass multiple values for the same key.) with the parsed
# contents of the query string (strings in the URL after the "?").
# Prototype: get(key, default=None, type=None)
location = request.args.get('location', '')
venueType = request.args.get('mealType', '')
# Create venue_info variable by calling the imported
# findAVenue function.
venue_info = findAVenue(venueType, location)
# If there is venue info, create a venue variable that is
# equal to the instantiation of the Venue Class defined in our
# model(models.py).
if venue_info != "No Venues Found":
venue = Venue(venue_name=unicode(venue_info['name']),
venue_address=unicode(venue_info['address']),
venue_image=venue_info['image'])
# Add venue variable just created to session.
session.add(venue)
# Commit VEnue instance (venue variable created) to db.
session.commit()
# Return jsonified dictionary that results when object is serialized
# via the Venue serialize attribute method.
return jsonify(venue=venue.serialize)
else:
# If no venue data resulted from running findAVenue on
# the meal type and location passed in the address bar upon url
# request, return error message.
return jsonify(
{"error": f"No Venues Found for {venueType} in {location}"})
def create_venue_submission():
# DONE: insert form data as a new Venue record in the db, instead
# DONE: modify data to be the data object returned from db insertion
form = VenueForm()
error = False
name = form.name.data
city = form.city.data
state = form.state.data
address = form.address.data
phone = form.phone.data
genres = form.genres.data
web_site = form.web_site.data
facebook_link = form.facebook_link.data
image_link = form.image_link.data
seeking_talent = True if form.seeking_talent.data == 'Yes' else False
seeking_description = form.seeking_description.data
try:
venue = Venue(name=name,
city=city,
state=state,
address=address,
phone=phone,
image_link=image_link,
genres=genres,
facebook_link=facebook_link,
web_site=web_site,
seeking_talent=seeking_talent,
seeking_description=seeking_description)
db.session.add(venue)
db.session.commit()
except:
db.session.rollback()
print(sys.exc_info())
error = True
finally:
db.session.close()
if error:
flash('An error occurred. Venue ' + request.form['name'] +
' could not be listed.')
else:
flash('Venue ' + request.form['name'] + ' was successfully listed!')
# DONE: on unsuccessful db insert, flash an error instead.
# e.g., flash('An error occurred. Venue ' + data.name + ' could not be listed.')
# see: http://flask.pocoo.org/docs/1.0/patterns/flashing/
return render_template('pages/home.html')
def create_venue_submission():
# TODO: insert form data as a new Venue record in the db, instead
# TODO: modify data to be the data object returned from db insertion
error = False
try:
data = Venue()
data.name = request.form['name']
data.city = request.form['city']
data.state = request.form['state']
data.address = request.form['address']
data.phone = request.form['phone']
data.genres = request.form.getlist('genres')
data.facebook_link = request.form['facebook_link']
if Venue.query.filter_by(name=data.name).filter_by(
city=data.city).filter_by(state=data.state).filter_by(
address=data.address) != None:
flash("Venue " + request.form['name'] +
" is already in the database")
return render_template('pages/home.html')
db.session.add(data)
db.session.commit()
except:
error = True
db.session.rollback()
print(sys.exc_info())
finally:
db.session.close()
if error:
flash("error occurs at " + request.form['name'])
print(sys.exc_info())
if not error:
# on successful db insert, flash success
flash('Venue ' + request.form['name'] + ' was successfully listed!')
# TODO: on unsuccessful db insert, flash an error instead.
# e.g., flash('An error occurred. Venue ' + data.name + ' could not be listed.')
# see: http://flask.pocoo.org/docs/1.0/patterns/flashing/
return render_template('pages/home.html')
def create_venue_submission():
data = request.form
name = data['name']
city = data['city']
state = data['state']
address = data['address']
phone = data['phone']
genres = data.getlist('genres')
facebook_link = data['facebook_link']
website = data['website']
image_link = data['image_link']
seeking_talent = bool(data['seeking_talent'])
seeking_description = data['seeking_description']
if Venue.query.first() != None and Venue.query.filter_by(
phone=phone).first() != None:
flash('this Venue is already listed!')
else:
try:
new_venue = Venue(name=name,
city=city,
state=state,
address=address,
phone=phone,
genres=genres,
facebook_link=facebook_link,
image_link=image_link,
website=website,
seeking_talent=seeking_talent,
seeking_description=seeking_description)
db.session.add(new_venue)
db.session.commit()
# on successful db insert, flash success
flash('Venue ' + request.form['name'] +
' was successfully listed!')
except:
db.session.rollback()
# TODO: on unsuccessful db insert, flash an error instead.
flash('Something went wrong :( Venue ' + request.form['name'] +
' could not be listed')
finally:
db.session.close()
# e.g., flash('An error occurred. Venue ' + data.name + ' could not be listed.')
# see: http://flask.pocoo.org/docs/1.0/patterns/flashing/
return render_template('pages/home.html')
def edit_artist_submission(artist_id):
# TODO: take values from the form submitted, and update existing
# artist record with ID <artist_id> using the new attributes
edit_artist = Venue(name=request.form.get('name'),
genres=request.form.get('genres'),
address=request.form.get('address'),
city=request.form.get('city'),
state=request.form.get('state'),
phone=request.form.get('phone'))
try:
data = edit_artist
db.session.commit()
except:
db.session.rollback()
finally:
db.session.close()
return redirect(url_for('show_artist', artist_id=artist_id))
def create_venue(obj):
if hasattr(obj, 'website'):
website = obj['website']
else:
website = None
new_venue = Venue(name=obj['name'],
slug=obj['slug'],
website=website,
address=obj['address'],
google_id=obj['google_id'],
location=obj['location'],
phone=obj['phone'])
session.add(new_venue)
session.commit()
return
def create_venue_submission():
try:
name = request.form.get('name')
city = request.form.get('city')
state = request.form.get('state')
genres = request.form.getlist('genres')
address = request.form.get('address')
phone = request.form.get('phone')
image_link = request.form.get('image_link')
facebook_link = request.form.get('facebook_link')
website = request.form.get('website')
seeking_talent = request.form.get('seeking_talent')
seeking_description = request.form.get('seeking_description')
# TODO: insert form data as a new Venue record in the db, instead
data = Venue(
name=name,
city=city,
state=state,
genres=genres,
address=address,
phone=phone,
image_link=image_link,
facebook_link=facebook_link,
website=website,
seeking_talent=seeking_talent,
seeking_description=seeking_description
)
# TODO: modify data to be the data object returned from db insertion
db.session.add(data)
db.session.commit()
# on successful db insert, flash success
flash('Venue ' + request.form['name'] + ' was successfully listed!')
except:
db.session.rollback()
# TODO: on unsuccessful db insert, flash an error instead.
flash('An error occurred. Venue ' + data.name + ' could not be listed.')
return
finally:
db.session.close()
# see: http://flask.pocoo.org/docs/1.0/patterns/flashing/
return render_template('pages/home.html')
def edit_venue_submission(venue_id):
# TODO: take values from the form submitted, and update existing
form = VenueForm()
venue = Venue.query.filter_by(Venue.id == venue_id)
edit_venue = Venue(name=request.form.get('name'),
genres=request.form.get('genres'),
address=request.form.get('address'),
city=request.form.get('city'),
state=request.form.get('state'),
phone=request.form.get('phone'))
try:
data = edit_venue
db.session.commit()
except:
db.session.rollback()
finally:
db.session.close()
# venue record with ID <venue_id> using the new attributes
return redirect(url_for('show_venue', venue_id=venue_id))
def create_venue_submission():
# TODO: insert form data as a new Venue record in the db, instead
# TODO: insert form data as a new Venue record in the db, instead
# TODO: modify data to be the data object returned from db insertion
# on successful db insert, flash success
# flash('Venue ' + request.form['name'] + ' was successfully listed!')
# TODO: on unsuccessful db insert, flash an error instead.
# e.g., flash('An error occurred. Venue ' + data.name + ' could not be listed.')
# see: http://flask.pocoo.org/docs/1.0/patterns/flashing/
new_venue = Venue(
name=request.form.get('name'),
genres=request.form.get('genres'),
address=request.form.get('address'),
city=request.form.get('city'),
state=request.form.get('state'),
phone=request.form.get('phone'),
website_link=request.form.get('website_link'),
facebook_link=request.form.get('facebook_link'),
image_link=request.form.get('image_link'),
seeking_talent=request.form.get('seeking_talent'),
seeking_description=request.form.get('seeking_description'),
past_shows_count=request.form.get('past_shows_count'),
upcoming_shows_count=request.form.get('upcoming_shows_count'))
try:
data = new_venue
db.session.add(data)
db.session.commit()
flash('Venue ' + request.form['name'] + ' was successfully listed!')
except:
db.session.rollback()
flash('An error occurred. Venue ' + data.name +
' could not be listed.')
finally:
db.session.close()
return render_template('pages/home.html')
def create_venue_submission():
try:
form = VenueForm(request.form)
venue = Venue(name=form.name.data,
city=form.city.data,
state=form.state.data,
address=form.address.data,
phone=form.phone.data,
genres=form.genres.data,
facebook_link=form.facebook_link.data,
image_link=form.image_link.data)
db.session.add(venue)
db.session.commit()
flash('Venue: {0} created successfully'.format(venue.name))
except Exception as err:
flash('An error occurred creating the Venue: {0}. Error: {1}'.format(
venue.name, err))
db.session.rollback()
finally:
db.session.close()
return render_template('pages/home.html'), 201
def load_venues(venues_json):
"""load venues & information into database"""
# import pdb; pdb.set_trace()
py_dict = json.loads(open(venues_json).read())
for venue in py_dict:
venue_id = venue['id']
city = venue['city']
name = venue['name']
country_code = venue['country_code']
description = venue['description']
status = venue['status']
length = venue['length']
turns = venue['turns']
latitude = venue['latitude']
longitude = venue['longitude']
maplink = venue['maplink']
fulllap = venue['fulllap']
motogpfulllap = venue['motogpfulllap']
venue = Venue(venue_id=venue_id,
city=city,
name=name,
country_code=country_code,
description=description,
status=status,
length=length,
turns=turns,
longitude=longitude,
latitude=latitude,
maplink=maplink,
fulllap=fulllap,
motogpfulllap=motogpfulllap)
print(venue)
db.session.add(venue)
db.session.commit()
def create_venue_submission():
try:
new_venue = Venue(
name=request.form['name'],
city=request.form['city'],
state=request.form['state'],
address=request.form['address'],
phone=request.form['phone'],
genres=request.form.get('genres', ''),
facebook_link=request.form.get('facebook_link', ''),
website=request.form.get('website', ''),
image_link=request.form.get('image_link', ''),
seeking_talent=bool(request.form.get('seeking_talent', False)),
seeking_description=request.form.get('seeking_description', ''))
db.session.add(new_venue)
db.session.commit()
flash('Venue ' + request.form['name'] + ' was successfully listed!')
except:
flash('Venue ' + request.form['name'] + ' could not be listed!')
flash(sys.exc_info())
db.session.rollback()
finally:
db.session.close()
return render_template('pages/home.html')
def insert_venues(venues):
"""Instantiate into db Venues table a venue record."""
for venue in venues:
try:
# Check if venue's SeatGeek id is already in db.
Venue.query.filter(Venue.venue_sg_id == venue).one()
except:
# If not in db, create venue record with SeatGeek response.
venue_dict = get_sg_venue(venue)
try:
venue_name = venue_dict['venues'][0]['name']
if venue_name == None:
venue_name = "Venue name"
except:
venue_name = "Venue name"
try:
venue_add = venue_dict['venues'][0]['address']
if venue_add == None:
venue_add = "345 Address"
except:
venue_add = "345 Address"
try:
venue_city = venue_dict['venues'][0]['city']
if venue_city == None:
venue_city = "Venue City"
except:
venue_city = "Venue City"
try:
venue_state = venue_dict['venues'][0]['state']
if venue_state == None:
venue_state = "ST"
except:
venue_state = "ST"
try:
venue_zip = venue_dict['venues'][0]['postal_code']
if venue_zip == None:
venue_zip = "12492"
except:
venue_zip = "12492"
# Insert into db.
new_venue = Venue(venue_sg_id=venue,
venue_name=venue_name,
venue_add=venue_add,
venue_city=venue_city,
venue_state=venue_state,
venue_zip=venue_zip)
db.session.add(new_venue)
db.session.commit()
def save(self, id, **kw):
try:
v = Venue.byName(kw['venue']['text'])
except SQLObjectNotFound:
v = Venue(name=kw['venue']['text'], added_by=identity.current.user)
artists = kw.pop('artists')
if not artists:
artists = ""
artist_name_list = [artist.strip() for artist in artists.split('\n')]
# elim blank items in list
artist_name_list = [artist for artist in artist_name_list if artist]
if not kw.get('name'):
kw['name'] = ", ".join(artist_name_list)
# updating
if id:
try:
e = Event.get(id)
flash_msg = "updated"
except SQLObjectNotFound:
flash("Database error, please try again")
redirect("/")
# inserting
else:
e = Event(name=kw['name'], date=kw['date'], time=kw['time'], venue=v,
added_by=identity.current.user)
# mark user as going to all added events by default
if not "admin" in identity.current.groups:
att = Attendance(user=identity.current.user, event=e, planning_to_go=True)
flash_msg = "added, will be reviewed and posted within 24 hrs"
del kw['venue']
e.set(**e.clean_dict(kw))
old_venue = e.venue
e.venue = v
old_venue.destroy_if_unused()
old_artists = set([a.name for a in e.artists])
# add new artists
artist_list = []
for artist in artist_name_list:
try:
a = Artist.byNameI(artist)
if not a in e.artists:
e.addArtist(a)
except SQLObjectNotFound:
a = Artist(name=artist, added_by=identity.current.user)
e.addArtist(a)
artist_list.append(a)
# remove old artists
for artist in e.artists:
if artist not in artist_list:
e.removeArtist(artist)
artist.destroy_if_unused()
new_artists = set([a.name for a in e.artists])
# approve all artists at approved events
if e.approved:
for artist in e.artists:
if not artist.approved:
artist.approved = datetime.now()
# add entry to UpdateLog
if old_artists != new_artists and e.approved:
u = UpdateLog(
changed_by=identity.current.user.id,
table_name="artist_event",
table_id=e.id,
attrib_name="artists",
attrib_old_value=old_artists,
attrib_new_value=new_artists
)
flash("Event %s" % flash_msg)
util.redirect("/events/%s" % e.id)
def import_to_db(self, event):
flag_for_review = False
venue_name = self.venue_name_fix(event['venue']['name'])
try:
v = Venue.byNameI(venue_name)
except SQLObjectNotFound:
v = Venue(name=venue_name, added_by=identity.current.user)
flag_for_review = True
if event['venue'].has_key('phone'):
phone = event['venue']['phone']
if not len(phone) >= 8:
phone = "503-" + phone
p = validators.PhoneNumber()
try:
event['venue']['phone'] = p.to_python(phone)
except:
event['venue']['phone'] = None
self._set_optional_fields(v, event['venue'], ("address", "phone", "zip_code",
"url", "description"))
event_name = self.event_name_fix(event['name'])
event_date = event["date"]
event_time = event.get("time")
if event_time:
event_time = event_time.lower()
# check same venue, date, time
db_events = Event.selectBy(date=event_date,
time=event_time, venue=v)
if db_events.count():
e = db_events[0]
new_event = False
else:
# no time? still could be skippable, if event name is the same
db_events = Event.selectBy(date=event_date,
name=event_name, venue=v)
if db_events.count():
e = db_events[0]
new_event = False
else:
e = Event(venue=v, name=event_name,
date=event_date, time=event_time,
added_by=identity.current.user)
new_event = True
try:
s = Source.byName(event["source"])
except SQLObjectNotFound:
s = Source(name=event["source"])
flag_for_review = True
e.addSource(s)
self._set_optional_fields(e, event, ("cost", "ages", "url",
"description", "ticket_url"))
for artist in self.artists_clean(event['artists']):
try:
a = Artist.byNameI(artist)
# artist was a similar, but now it's listed as having an event
# so approve it
if not a.approved:
a.approved = datetime.now()
except SQLObjectNotFound:
a = Artist(name=artist, added_by=identity.current.user)
flag_for_review = True
if not e.id in [existing.id for existing in a.events]:
a.addEvent(e)
# flag all events from certain unreliable sources
if event["source"] in ("ticketswest", "upcoming", "lastfm"):
flag_for_review = True
if new_event and not flag_for_review:
e.approved = datetime.now()
elif flag_for_review:
e.approved = None
return (new_event, flag_for_review)
def get_image_url():
"""
Retrieves venue image URL from db and returns JSON object with the URL.
"""
image_url = Venue.get_venue_img()
return jsonify(image_url)
def search_closest(self):
search_text = "sw 4th and burnside, portland or"
venue_list = Venue.closest(search_text, with_event=True)
return dict(venues=venue_list, saddr=search_text, start=search_text)
def venue_page_process():
"""Process new venue"""
user_id = session.get("user_id")
user = User.query.filter_by(user_id=user_id).first()
monday = request.json.get("monday")
tuesday = request.json.get("tuesday")
wednesday = request.json.get("wednesday")
thursday = request.json.get("thursday")
friday = request.json.get("friday")
saturday = request.json.get("saturday")
sunday = request.json.get("sunday")
morning = request.json.get("morning")
late_morning = request.json.get("late_morning")
early_night = request.json.get("early_night")
late_night = request.json.get("late_night")
venue_name = request.json.get("venue_name")
venue_url = request.json.get("venue_url")
venue_email = request.json.get("venue_email")
venue_address = request.json.get("venue_address")
venue_city = request.json.get("venue_city")
venue_type = request.json.get("venue_type")
venue_backspace = request.json.get("venue_backspace")
venue_capacity = request.json.get("venue_capacity")
venue_license = request.json.get("venue_license")
venue_rent = request.json.get("venue_rent")
check_venue_info = Venue.query.filter_by(
venue_address=venue_address).first()
if check_venue_info:
return jsonify("venue_already_register")
else:
new_time = Time(monday=monday,
tuesday=tuesday,
wednesday=wednesday,
thursday=thursday,
friday=friday,
saturday=saturday,
sunday=sunday,
morning=morning,
late_morning=late_morning,
early_night=early_night,
late_night=late_night)
db.session.add(new_time)
db.session.commit()
db.session.refresh(new_time)
new_venue = Venue(user_id=user_id,
venue_name=venue_name,
venue_url=venue_url,
venue_email=venue_email,
venue_address=venue_address,
venue_city=venue_city,
venue_type=venue_type,
venue_backspace=venue_backspace,
venue_capacity=venue_capacity,
venue_license=venue_license,
time_id=new_time.time_id,
venue_rent=venue_rent)
db.session.add(new_venue)
db.session.commit()
db.session.refresh(new_venue)
venue_rarking = adding_ranking("venue", new_venue.venue_id)
return jsonify(time_id=new_time.time_id,
monday=new_time.monday,
tuesday=new_time.tuesday,
wednesday=new_time.wednesday,
thursday=new_time.thursday,
friday=new_time.friday,
saturday=new_time.saturday,
sunday=new_time.sunday,
morning=new_time.morning,
late_morning=new_time.late_morning,
early_night=new_time.early_night,
late_night=new_time.late_night,
venue_id=new_venue.venue_id,
venue_name=new_venue.venue_name,
venue_url=new_venue.venue_url,
venue_email=new_venue.venue_email,
venue_address=new_venue.venue_address,
venue_city=new_venue.venue_city,
venue_type=new_venue.venue_type,
venue_backspace=new_venue.venue_backspace,
venue_capacity=new_venue.venue_capacity,
venue_license=new_venue.venue_license,
venue_rent=new_venue.venue_rent)
