def test_init_app(self):
app = Flask(__name__)
moment = Moment()
moment.init_app(app)
assert app.extensions['moment'].__name__ == 'moment'
assert app.template_context_processors[None][1].__globals__[
'__name__'] == 'flask_moment'
def main(env):
app = Flask(__name__)
moment = Moment()
app.config.from_object(Config(env))
Config(env).init_app(app)
moment.init_app(app)
from spiders import spider
app.register_blueprint(spider)
return app
def register_extensions(app):
"""Register Flask extensions."""
# initialize extensions
migrate = Migrate()
moment = Moment()
csrf = CSRFProtect()
toolbar = DebugToolbarExtension()
# register extensions
moment.init_app(app)
migrate.init_app(app, db)
db.init_app(app)
toolbar.init_app(app)
csrf.init_app(app)
csrf.exempt("fyyur.controllers.venues.search_venues")
csrf.exempt("fyyur.controllers.venues.delete_venue")
csrf.exempt("fyyur.controllers.artists.search_artists")
app.jinja_env.filters["datetime"] = format_datetime
from flask_login import LoginManager, logout_user, login_user, current_user, login_required
import enum
from flask_moment import Moment
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get('DATABASE_URL')
app.config['SEND_FILE_MAX_AGE_DEFAULT'] = 0
db = SQLAlchemy(app)
app.secret_key = 'My super secret secret'
moment = Moment()
moment.init_app(app)
#set up flask migration
migrate = Migrate(app,db)
login_manager = LoginManager(app)
@login_manager.user_loader
def load_user(user_id):
return User.query.get(user_id)
from project.models import Post, User, Comment
from project.users.views import users_blueprint
app.register_blueprint(users_blueprint)
celery.Task = ContextTask
return celery
#创建和配置flask_app
ENV = os.getenv('FLASK_CONFIG') or 'default'
flask_app = Flask(__name__, instance_relative_config=True)
flask_app.config.from_object(config[ENV])
config[ENV].init_app(flask_app)
#初始化celery
celery = make_celery(flask_app)
#时间处理
moment.init_app(flask_app)
#初始化数据库
db.init_app(flask_app)
mail.init_app(flask_app)
login_manager.init_app(flask_app)
bootstrap.init_app(flask_app)
#注册用户认证蓝图
from .auth import auth as auth_blueprint
flask_app.register_blueprint(auth_blueprint, url_prefix='/auth')
#注册update wellink蓝图
from app.welllink import welllink as welllink_blueprint
flask_app.register_blueprint(welllink_blueprint, url_prefix='/welllink')
#注册update picchk蓝图
if bulk.config['LOG_TO_STDOUT']:
stream_handler = logging.StreamHandler()
stream_handler.setLevel(logging.INFO)
bulk.logger.addHandler(stream_handler)
else:
# error logging configurations
if not os.path.exists(our_logs):
os.mkdir(our_logs)
file_handler = RotatingFileHandler(os.path.join(our_logs, "bulkops.log"), maxBytes=10240, backupCount=10)
file_handler.setFormatter(logging.Formatter(
"%(asctime)s %(levelname)s: %(message)s [in %(pathname)s:%(lineno)d]"))
file_handler.setLevel(logging.INFO)
bulk.logger.addHandler(file_handler)
bulk.logger.setLevel(logging.INFO)
bulk.logger.info("BulkOps Start")
db.init_app(bulk)
migrate.init_app(bulk, db)
login.init_app(bulk)
mail.init_app(bulk)
moment.init_app(bulk)
from bulkops import database
from bulkops.main import views
from bulkops.secure import views
from bulkops.errors import errors
# end of program
'songs':
'sqlite:///D:\\All of My folders\\Assignment\\Flask Project\\MusicDatabse.db'
}
app.config['CSRF_ENABLED'] = True
#no money to buy server...
app.config['SERVER_NAME'] = 'localhost:5000'
app.config["MAIL_SERVER"] = "smtp.gmail.com"
app.config["MAIL_PORT"] = 465
app.config["MAIL_USE_SSL"] = True
app.config["MAIL_USERNAME"] = '******'
app.config["MAIL_PASSWORD"] = '******'
app.config['MAX_CONTENT_LENGTH'] = 100 * 1024 * 1024
Mail.init_app(app)
Moment.init_app(app)
LoginManager.init_app(app)
db.create_all()
LoginManager.session_protection = 'strong'
LoginManager.login_view = 'login'
LoginManager.login_message = 'You need to login!'
class Song(db.Model):
__bind_key__ = 'songs'
id = db.Column(db.Integer, primary_key=True)
ArtistName = db.Column(db.String(30))
SongName = db.Column(db.String(40))
def create_app(test_config=None):
app = Flask(__name__)
app.config.from_object('config')
moment = Moment(app)
CORS(app)
setup_db(app)
moment.init_app(app)
migrate.init_app(app)
#----------------------------------------------------------------------------#
# Filters.
#----------------------------------------------------------------------------#
def format_datetime(value, format='medium'):
date = dateutil.parser.parse(value)
if format == 'full':
format = "EEEE MMMM, d, y 'at' h:mma"
elif format == 'medium':
format = "EE MM, dd, y h:mma"
return babel.dates.format_datetime(date, format)
app.jinja_env.filters['datetime'] = format_datetime
#----------------------------------------------------------------------------#
# Controllers.
#----------------------------------------------------------------------------#
@app.route('/')
def index():
return render_template('pages/home.html')
# Venues
# ----------------------------------------------------------------
@app.route('/venues')
def venues():
data = []
uniqueAreas = db.session.query(Venue.city, Venue.state).group_by(
Venue.city, Venue.state).all()
for area in uniqueAreas:
venueTemp = []
venueInArea = Venue.query.filter_by(state=area[1]).filter_by(
city=area[0]).all()
for venue in venueInArea:
upcomingShow = 0
for show in venue.shows:
if show.start_time > datetime.now():
upcomingShow += 1
venueTemp.append({
"id": venue.id,
"name": venue.name,
"num_upcoming_shows": upcomingShow
})
data.append({
"city": area[0],
"state": area[1],
"venues": venueTemp
})
return render_template('pages/venues.html', areas=data)
@app.route('/venues/search', methods=['POST'])
def search_venues():
# case insensitive search of venues using city, state and name
searchTerm = request.form.get("search_term", "")
searchTerm = "%{}%".format(searchTerm)
searchVenues = Venue.query.filter(
or_(Venue.name.ilike(searchTerm), Venue.city.ilike(searchTerm),
Venue.state.ilike(searchTerm))).all()
searchVenueCount = len(searchVenues)
data = []
for searchVenue in searchVenues:
upcomingShow = 0
for show in searchVenue.shows:
if show.start_time > datetime.now():
upcomingShow += 1
data.append({
"id": searchVenue.id,
"name": searchVenue.name,
"num_upcoming_shows": upcomingShow
})
response = {"count": searchVenueCount, "data": data}
return render_template('pages/search_venues.html',
results=response,
search_term=request.form.get('search_term', ''))
@app.route('/venues/<int:venue_id>')
def show_venue(venue_id):
# shows the venue page with the given venue_id
venueWithID = Venue.query.get(venue_id)
pastShows, pastShowCount, upcomingShows, upcomingShowCount = [], 0, [], 0
for show in venueWithID.shows:
if show.start_time > datetime.now():
showArtist = Artist.query.get(show.artist_id)
upcomingShows.append({
"artist_id": showArtist.id,
"artist_name": showArtist.name,
"start_time": str(show.start_time)
})
upcomingShowCount += 1
else:
showArtist = Artist.query.get(show.artist_id)
pastShows.append({
"artist_id": showArtist.id,
"artist_name": showArtist.name,
"start_time": str(show.start_time)
})
pastShowCount += 1
pastShows, pastShowCount, upcomingShows, upcomingShowCount = [], 0, [], 0
venueGenres = str(''.join(venueWithID.genres)).strip('\{\}').split(",")
data = {
"id": venueWithID.id,
"name": venueWithID.name,
"genres": venueGenres,
"address": venueWithID.address,
"city": venueWithID.city,
"state": venueWithID.state,
"phone": venueWithID.phone,
"facebook_link": venueWithID.facebook_link,
"website_link": venueWithID.website_link,
"image_link": venueWithID.image_link,
"seeking_talent": venueWithID.seeking_talent,
"past_shows": pastShows,
"upcoming_shows": upcomingShows,
"past_shows_count": pastShowCount,
"upcoming_shows_count": upcomingShowCount,
}
return render_template('pages/show_venue.html', venue=data)
# Create Venue
# ----------------------------------------------------------------
@app.route('/venues/create', methods=['GET'])
def create_venue_form():
form = VenueForm()
return render_template('forms/new_venue.html', form=form)
@app.route('/venues/create', methods=['POST'])
def create_venue_submission():
# called upon submitting the new venue listing form
form = VenueForm()
error = False
if form.validate_on_submit():
try:
venueExist = Venue.query.filter_by(
name=request.form['name']).scalar()
if venueExist:
pass
else:
if request.form.get("seeking_talent") == 'y':
seeking_talent = True
else:
seeking_talent = False
venue = Venue(
name=request.form['name'],
city=request.form['city'],
state=request.form['state'],
address=request.form['address'],
phone=request.form['phone'],
facebook_link=request.form['facebook_link'],
genres=request.form.getlist("genres"),
website_link=request.form['website_link'],
image_link=request.form['image_link'],
seeking_talent=seeking_talent,
)
db.session.add(venue)
db.session.commit()
data = Venue.query.all()[-1]
except:
error = True
db.session.rollback()
print(sys.exc_info())
finally:
if venueExist:
flash('Venue with name: \" ' + request.form['name'] +
'\" already exists.')
return render_template('forms/new_venue.html', form=form)
elif error:
db.session.close()
flash('An error occurred. Venue ' + request.form['name'] +
' could not be listed.')
return render_template('forms/new_venue.html', form=form)
else:
db.session.close()
flash('Venue ' + data.name + ' was successfully listed!')
return render_template('pages/home.html')
else:
flash_errors(form)
return render_template('forms/new_venue.html', form=form)
@app.route('/venues/<venue_id>', methods=['DELETE'])
def delete_venue(venue_id):
try:
venueWithID = Venue.query.get(venue_id)
for show in venueWithID.shows:
db.session.delete(show)
db.session.delete(venueWithID)
db.session.commit()
except:
db.session.rollback()
print(sys.exc_info())
finally:
db.session.close()
return jsonify({'success': True})
# Artists
# ----------------------------------------------------------------
@app.route('/artists')
def artists():
artists = Artist.query.all()
data = []
for artist in artists:
data.append({"id": artist.id, "name": artist.name})
return render_template('pages/artists.html', artists=data)
@app.route('/artists/search', methods=['POST'])
def search_artists():
# case-insensitive search
searchTerm = request.form.get("search_term", "")
searchTerm = "%{}%".format(searchTerm)
searchArtists = Artist.query.filter(
or_(Artist.name.ilike(searchTerm), Artist.city.ilike(searchTerm),
Artist.state.ilike(searchTerm))).all()
searchArtistCount = len(searchArtists)
data = []
upcoming_shows = 0
for searchArtist in searchArtists:
for show in searchArtist.shows:
if show.start_time > datetime.now():
upcoming_shows += 1
upcoming_shows = 0
data.append({
"id": searchArtist.id,
"name": searchArtist.name,
"num_upcoming_shows": upcoming_shows
})
response = {
"count": searchArtistCount,
"data": data,
}
return render_template('pages/search_artists.html',
results=response,
search_term=request.form.get('search_term', ''))
@app.route('/artists/<int:artist_id>')
def show_artist(artist_id):
artistWithID = Artist.query.get(artist_id)
print(artistWithID.name)
pastShows, pastShowCount, upcomingShows, upcomingShowCount = [], 0, [], 0
for show in artistWithID.shows:
if show.start_time > datetime.now():
showVenue = Venue.query.get(show.venue_id)
upcomingShows.append({
"venue_id": showVenue.id,
"venue_name": showVenue.name,
"start_time": str(show.start_time)
})
upcomingShowCount += 1
else:
showVenue = Venue.query.get(show.venue_id)
pastShows.append({
"venue_id": showVenue.id,
"venue_name": showVenue.name,
"start_time": str(show.start_time)
})
pastShowCount += 1
pastShows, pastShowCount, upcomingShows, upcomingShowCount = [], 0, [], 0
artistGenres = str(''.join(
artistWithID.genres)).strip('\{\}').split(",")
data = {
"id": artistWithID.id,
"name": artistWithID.name,
"genres": artistGenres,
"city": artistWithID.city,
"state": artistWithID.state,
"phone": artistWithID.phone,
"facebook_link": artistWithID.facebook_link,
"website_link": artistWithID.website_link,
"image_link": artistWithID.image_link,
"seeking_venue": artistWithID.seeking_venue,
"past_shows": pastShows,
"upcoming_shows": upcomingShows,
"past_shows_count": pastShowCount,
"upcoming_shows_count": upcomingShowCount,
}
return render_template('pages/show_artist.html', artist=data)
# Update
# ----------------------------------------------------------------
@app.route('/artists/<int:artist_id>/edit', methods=['GET'])
def edit_artist(artist_id):
artist = Artist.query.get(artist_id)
form = ArtistForm(obj=artist)
return render_template('forms/edit_artist.html',
form=form,
artist=artist)
@app.route('/artists/<int:artist_id>/edit', methods=['POST'])
def edit_artist_submission(artist_id):
form = ArtistForm()
error = False
existArtist = Artist.query.get(artist_id)
if form.validate_on_submit():
try:
print(existArtist.name)
existArtist.name = request.form.get("name")
existArtist.city = request.form.get("city")
existArtist.state = request.form.get("state")
existArtist.phone = request.form.get("phone")
existArtist.genres = request.form.getlist("genres")
existArtist.facebook_link = request.form.get("facebook_link")
existArtist.website_link = request.form.get("website_link")
existArtist.image_link = request.form.get("image_link")
if request.form.get("seeking_venue") == 'y':
existArtist.seeking_venue = True
else:
existArtist.seeking_venue = False
db.session.commit()
except:
error = True
# db.session.rollback()
print(sys.exc_info())
finally:
if error:
flash('Artist ' + existArtist.name +
' record is not edited')
db.session.close()
return render_template('forms/edit_artist.html',
form=form,
artist=existArtist)
else:
flash('Artist ' + existArtist.name +
' has been edited successfully')
db.session.close()
artist = Artist.query.get(artist_id)
print(artist_id)
return redirect(url_for('show_artist',
artist_id=artist_id))
else:
flash_errors(form)
return render_template('forms/edit_artist.html',
form=form,
artist=existArtist)
@app.route('/venues/<int:venue_id>/edit', methods=['GET'])
def edit_venue(venue_id):
venue = Venue.query.get(venue_id)
form = VenueForm(obj=venue)
return render_template('forms/edit_venue.html', form=form, venue=venue)
@app.route('/venues/<int:venue_id>/edit', methods=['POST'])
def edit_venue_submission(venue_id):
form = VenueForm()
error = False
existVenue = Venue.query.get(venue_id)
if form.validate_on_submit():
try:
existVenue.name = request.form.get("name")
existVenue.city = request.form.get("city")
existVenue.state = request.form.get("state")
existVenue.address = request.form.get("address")
existVenue.phone = request.form.get("phone")
existVenue.genres = request.form.getlist("genres")
existVenue.facebook_link = request.form.get("facebook_link")
existVenue.website_link = request.form.get("website_link")
existVenue.image_link = request.form.get("image_link")
if request.form.get("seeking_talent") == 'y':
existVenue.seeking_talent = True
else:
existVenue.seeking_talent = False
db.session.commit()
except:
error = True
db.session.rollback()
print(sys.exc_info())
finally:
if error:
flash('Venue ' + existVenue.name + ' record is not edited')
db.session.close()
return render_template('forms/edit_venue.html',
form=form,
venue=existVenue)
else:
flash('Venue ' + existVenue.name +
' has been edited successfully')
db.session.close()
return redirect(url_for('show_venue', venue_id=venue_id))
else:
flash_errors(form)
return render_template('forms/edit_venue.html',
form=form,
venue=existVenue)
# ----------------------------------------------------------------
# Create Artist
# ----------------------------------------------------------------
@app.route('/artists/create', methods=['GET'])
def create_artist_form():
form = ArtistForm()
return render_template('forms/new_artist.html', form=form)
@app.route('/artists/create', methods=['POST'])
def create_artist_submission():
# called upon submitting the new artist listing form
form = ArtistForm()
error = False
if form.validate_on_submit():
try:
artistExist = Artist.query.filter_by(
name=request.form['name']).scalar()
if artistExist:
pass
else:
if request.form.get("seeking_venue") == 'y':
seeking_venue = True
else:
seeking_venue = False
artist = Artist(
name=request.form['name'],
city=request.form['city'],
state=request.form['state'],
phone=request.form['phone'],
facebook_link=request.form['facebook_link'],
genres=request.form.getlist("genres"),
website_link=request.form['website_link'],
image_link=request.form['image_link'],
seeking_venue=seeking_venue,
)
db.session.add(artist)
db.session.commit()
data = Artist.query.all()[-1]
except:
error = True
db.session.rollback()
print(sys.exc_info())
finally:
if artistExist:
flash('Artist with name: \" ' + request.form['name'] +
'\" already exists.')
return render_template('forms/new_artist.html', form=form)
elif error:
db.session.close()
flash('An error occurred. Artist ' + request.form['name'] +
' could not be listed.')
return render_template('forms/new_artist.html', form=form)
else:
db.session.close()
flash('Artist ' + data.name + ' was successfully listed!')
return render_template('pages/home.html')
else:
flash_errors(form)
return render_template('forms/new_artist.html', form=form)
@app.route('/artists/<artist_id>', methods=['DELETE'])
def delete_artist(artist_id):
try:
artistWithID = Artist.query.get(artist_id)
for show in artistWithID.shows:
db.session.delete(show)
db.session.delete(artistWithID)
db.session.commit()
except:
db.session.rollback()
print(sys.exc_info())
finally:
db.session.close()
return jsonify({'success': True})
# ----------------------------------------------------------------
# Shows
# ----------------------------------------------------------------
@app.route('/shows')
def shows():
upcomingShows = Show.query.filter(
Show.start_time > datetime.now()).all()
data = []
for show in upcomingShows:
showVenue = Venue.query.get(show.venue_id)
showArtist = Artist.query.get(show.artist_id)
data.append({
"venue_id": showVenue.id,
"venue_name": showVenue.name,
"artist_id": showArtist.id,
"artist_name": showArtist.name,
"artist_image_link": showArtist.image_link,
"start_time": str(show.start_time)
})
return render_template('pages/shows.html', shows=data)
@app.route('/shows/create')
def create_shows():
# renders form. do not touch.
form = ShowForm()
return render_template('forms/new_show.html', form=form)
@app.route('/shows/create', methods=['POST'])
def create_show_submission():
form = ShowForm()
if form.validate_on_submit():
error = False
try:
artistid = Artist.query.filter_by(
id=request.form['artist_id']).scalar()
venueid = Venue.query.filter_by(
id=request.form['venue_id']).scalar()
if not venueid:
pass
elif not artistid:
pass
else:
show = Show(artist_id=request.form['artist_id'],
venue_id=request.form['venue_id'],
start_time=request.form['start_time'])
db.session.add(show)
db.session.commit()
except:
error = True
db.session.rollback()
print(sys.exc_info())
finally:
if not venueid:
flash('Venue with ID ' + request.form['venue_id'] +
' does not exist.')
return render_template('forms/new_show.html', form=form)
elif not artistid:
flash('Artist with ID ' + request.form['artist_id'] +
' does not exist.')
return render_template('forms/new_show.html', form=form)
elif error:
db.session.close()
flash('Show was not successfully listed!')
return render_template('forms/new_show.html', form=form)
else:
flash('Show was successfully listed!')
return render_template('pages/home.html')
else:
flash_errors(form)
return render_template('forms/new_show.html', form=form)
@app.errorhandler(404)
def not_found_error(error):
return render_template('errors/404.html'), 404
@app.errorhandler(500)
def server_error(error):
return render_template('errors/500.html'), 500
if not app.debug:
file_handler = FileHandler('error.log')
file_handler.setFormatter(
Formatter(
'%(asctime)s %(levelname)s: %(message)s [in %(pathname)s:%(lineno)d]'
))
app.logger.setLevel(logging.INFO)
file_handler.setLevel(logging.INFO)
app.logger.addHandler(file_handler)
app.logger.info('errors')
return app
def moment(app):
moment = Moment()
moment.init_app(app)
yield moment
# import Mongo Exceptions
from mongoengine import MultipleObjectsReturned, DoesNotExist
# import local
from . import config
from . import models
# import moment
from flask_moment import Moment
login_manager = LoginManager()
moment = Moment()
schedule_app = Flask(__name__)
login_manager.init_app(schedule_app)
moment.init_app(schedule_app)
# configure the app
schedule_app.config["SECRET_KEY"] = config.SECRET_KEY
schedule_app.config["DEBUG"] = config.LOCAL
login_manager.login_view = "login"
def sanity_checks():
# Check to make sure there is at least one administrative user.
users = models.User.objects()
locations = models.Location.objects()
admins = any([user.is_admin for user in users])
if not admins:
def test_create_default_with_timestamp(self):
moment = Moment()
moment.init_app(self.app)
ts = datetime(2017, 1, 15, 22, 47, 6, 479898)
assert moment.create(timestamp=ts).timestamp == ts
def test_create_default_no_timestamp(self, dt):
ts = datetime(2017, 1, 15, 22, 1, 21, 101361)
dt.utcnow.return_value = ts
moment = Moment()
moment.init_app(self.app)
assert moment.create().timestamp == ts
app = Flask(__name__)
login_manager = LoginManager()
db = SQLAlchemy()
socketio = SocketIO()
oauth = OAuth(app)
redis = Redis()
moment = Moment()
with app.app_context():
config_name = os.getenv('FLASK_CONFIG') or 'development'
app.config.from_object(config[config_name])
config[config_name].init_app(app)
db.app = app
db.init_app(app)
login_manager.init_app(app)
login_manager.session_protection = 'strong'
login_manager.login_view = 'login'
login_manager.login_message = u'请先登陆系统,若遗忘密码，请联系管理员'
login_manager.login_message_category = 'warning'
socketio.init_app(app, async_mode=async_mode)
redis.init_app(app)
moment.init_app(app)
from .views import * # noqa
from .models import * # noqa
