def create_app(settings_override=None):
app = factory.create_app(__name__, __path__, settings_override)
admin = Admin(app, auth)
register_admin(admin)
admin.setup()
return app
class InitAdminDashboard(InitBaseExtension):
name = 'admin'
def init_app(self, app): # Инициируем Админку
self.extension = Admin(app.web_app, app.auth)
def configurate_extension(self):
from ui.admin import get_admin_models
for m in get_admin_models():
orm_m, adm_m = m if len(m) == 2 else [m[0], ModelAdmin]
self.extension.register(orm_m, adm_m)
self.extension.setup()
def setup_admin():
auth = Auth(app, db, user_model=User)
admin = Admin(app, auth)
admin.register(User, UserAdmin)
admin.register(Photo, PhotoAdmin)
auth.register_admin(admin)
admin.setup()
return auth, admin
def init_admin(app, db):
auth_admin = Auth(app, db)
User = auth_admin.User
User.create_table(fail_silently=True)
if not User.select().where(User.username == 'admin').exists():
admin = User(username='******', email='', admin=True, active=True)
admin.set_password('admin')
admin.save()
admin = Admin(app, auth_admin)
from hse_arch.models.customer import Customer
from hse_arch.models.order import Order, OrderItem
from hse_arch.models.product import Product, ProductIngredient, Ingredient
from hse_arch.models.producers import Producer
from hse_arch.models.category import Category
from hse_arch.models.user import User
admin.register(Customer, CustomerAdmin)
admin.register(Order)
admin.register(OrderItem)
admin.register(Product)
admin.register(Ingredient)
admin.register(Producer)
admin.register(Category)
admin.register(ProductIngredient)
admin.register(User)
admin.setup()
return admin
def setup_admin():
auth = Auth(app, db)
admin = Admin(app, auth)
admin.register(Note, NoteAdmin)
admin.register(Author, AuthorAdmin)
auth.register_admin(admin)
admin.setup()
return auth, admin
def create_app():
app = Flask(__name__)
app.config.update(
DEBUG=True,
SECRET_KEY='supersecret',
DATABASE={
'name': 'example.db',
'engine': 'peewee.SqliteDatabase',
},
)
app.db = Database(app)
Feedloggr(app, app.db)
# OPTIONALLY SETUP BEGINS
# Simple authentication for the admin interface
app.auth = Auth(app, app.db)
app.auth.User.create_table(fail_silently=True)
# Try to create a new admin user, but fail silently if it already exists
try:
user = app.auth.User.create(
username='******',
email='.',
password='',
admin=True,
active=True,
)
except PIE:
pass
else:
user.set_password('admin')
user.save()
# Initialize the admin interface
app.admin = Admin(app, app.auth)
app.auth.register_admin(app.admin)
# Register the feedloggr feeds model
app.admin.register(feedloggr_Feeds, feedloggr_FeedsAdmin)
app.admin.setup()
# OPTIONALLY SETUP ENDS
return app
# -*- coding: utf-8 -*- """ admin imports app, auth and models, but none of these import admin so we're OK """ from flask_peewee.admin import Admin, ModelAdmin from app import app, db from auth import auth from models import User admin = Admin(app, auth) # auth.register_admin(admin) admin.register(User, ModelAdmin) # register any other models here.
}
class UserStatsPanel(AdminPanel):
template_name = 'admin/user_stats.html'
def get_context(self):
last_week = datetime.datetime.now() - datetime.timedelta(days=7)
signups_this_week = User.select().where(User.join_date > last_week).count()
messages_this_week = Message.select().where(Message.pub_date > last_week).count()
return {
'signups': signups_this_week,
'messages': messages_this_week,
}
admin = Admin(app, auth)
class MessageAdmin(ModelAdmin):
columns = ('user', 'content', 'pub_date',)
foreign_key_lookups = {'user': '******'}
filter_fields = ('user', 'content', 'pub_date', 'user__username')
class NoteAdmin(ModelAdmin):
columns = ('user', 'message', 'created_date',)
exclude = ('created_date',)
auth.register_admin(admin)
admin.register(Relationship)
admin.register(Message, MessageAdmin)
description = CharField(max_length=2000, null=True)
url = CharField()
price = DecimalField(max_digits=10, decimal_places=2)
wishlist = ForeignKeyField(WishList, related_name='items')
numberOfParts = IntegerField()
class Part(db.Model):
"""
A part is the smallest subdivision of an item.
Thanks to this, an item can be bought by several different users.
"""
user = ForeignKeyField(auth.User, related_name='gifts')
item = ForeignKeyField(Item, related_name='parts')
# admin part
admin = Admin(app, auth)
admin.register(WishList)
admin.register(Item)
admin.register(Part)
# api part
user_auth = UserAuthentication(auth)
api = RestAPI(app, default_auth=user_auth)
api.register(WishList)
api.register(Item, ItemResource)
api.register(Part)
# setup
from flask_peewee.admin import Admin, ModelAdmin
from app import app
from auth import auth
from models import Song
class SongAdmin(ModelAdmin):
columns = ('title', 'artist', 'album', 'genre', 'path', 'created',)
admin = Admin(app, auth)
admin.register(Song, SongAdmin)
auth.register_admin(admin)
auth = Auth(app, db)
# REST API
api = RestAPI(app)
api.register(Person)
api.register(Company)
api.register(Payment)
api.register(Tariff)
api.register(Point)
api.register(Bike)
api.register(ReservationState)
api.register(Reservation)
api.setup()
# REST ADMIN
admin = Admin(app, auth)
admin.register(Person, PersonAdmin)
admin.register(Company, CompanyAdmin)
admin.register(Payment, PaymentAdmin)
admin.register(Tariff, TariffAdmin)
admin.register(Point, PointAdmin)
admin.register(Bike, BikeAdmin)
admin.register(ReservationState, ReservationStateAdmin)
admin.register(Reservation, ReservationAdmin)
admin.setup()
def setup_tbl():
Person.create_table(fail_silently=True)
Company.create_table(fail_silently=True)
Payment.create_table(fail_silently=True)
from flask_peewee.admin import Admin, ModelAdmin
from app import app
from auth import auth
from models import Note
class NoteAdmin(ModelAdmin):
columns = ('message', 'created',)
admin = Admin(app, auth)
admin.register(Note, NoteAdmin)
auth.register_admin(admin)
admin.setup()
import datetime
from flask import request, redirect
from flask_peewee.admin import Admin, ModelAdmin, AdminPanel
from flask_peewee.filters import QueryFilter
from app import app, db
from auth import auth
from models import User, News, OursNews
admin = Admin(app, auth)
class NewsAdmin(ModelAdmin):
columns = ('user', 'text', 'favorited', 'thumbnail_pic', 'bmiddle_pic',
'original_pic', 'reposts_count', 'comments_count',
'attitudes_count', 'screen_name', 'name', 'profile_image_url',
'avatar_large', 'uid', 'ret_text', 'created_at', 'score')
class OursNewsAdmin(ModelAdmin):
columns = ('user', 'text', 'favorited', 'thumbnail_pic', 'bmiddle_pic',
'original_pic', 'reposts_count', 'comments_count',
'attitudes_count', 'screen_name', 'name', 'profile_image_url',
'avatar_large', 'uid', 'ret_text', 'created_at', 'score')
# admin.register(User, UserAdmin)
admin.register(News, NewsAdmin)
admin.register(OursNews, OursNewsAdmin)
def save_model(self, instance, form, adding=False):
instance = super(PhotoAdmin, self).save_model(instance, form, adding)
if 'image_file' in request.files:
file = request.files['image_file']
instance.save_image(file)
return instance
class NotePanel(AdminPanel):
template_name = 'admin/note.html'
def get_context(self):
return {
'list': Order.select(),
}
admin = Admin(app, auth, branding='Example Site')
auth.register_admin(admin)
admin = CustomAdmin(app, auth)
admin.register(Photo, PhotoAdmin)
admin.register(Goods, GoodsAdmin)
admin.register(User, UserAdmin)
admin.register(Reviews, ReviewsAdmin)
admin.register(Order)
admin.register_panel('Orders', NotePanel)
day = DateField(default=datetime.date.today, unique=True, verbose_name="Dzien")
soup = CharField(null=True, verbose_name="Zupa")
main_dish = CharField(null=True, verbose_name="Drugie danie")
def __str__(self):
return "%s - %s - %s" % (self.day, self.soup, self.main_dish)
Obiad.create_table(fail_silently=True)
class Cytat(db.Model):
timestamp = DateTimeField(default=datetime.datetime.now(), verbose_name="Czas dodania")
content = TextField(unique=True, verbose_name="Tresc")
def __str__(self):
return self.content
Cytat.create_table(fail_silently=True)
auth = Auth(app, db)
auth.User.create_table(fail_silently=True)
admin = Admin(app, auth)
auth.register_admin(admin)
admin.register(Przedmiot)
class PracaDomowaAdmin(ModelAdmin):
columns = ('deadline', 'subject', 'short_name', 'description', 'checked',)
admin.register(PracaDomowa, PracaDomowaAdmin)
class SprawdzianAdmin(ModelAdmin):
columns = ('date', 'subject', 'short_name', 'description', 'done',)
admin.register(Sprawdzian, SprawdzianAdmin)
class ObiadAdmin(ModelAdmin):
columns = ('day', 'soup', 'main_dish',)
admin.register(Obiad, ObiadAdmin)
class CytatAdmin(ModelAdmin):
columns = ('content',)
admin.register(Cytat, CytatAdmin)
admin.setup()
# -*- coding: utf-8 -*- """Copyright (c) 2012 Sergio Gabriel Teves All rights reserved. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see <http://www.gnu.org/licenses/>. """ """ Created on 29/09/2012 """ from flask_peewee.admin import Admin from pystatus.app import application, auth from pystatus.app.models import Process admin = Admin(application, auth) admin.register(Process)
Configures the admin interface.
"""
from flask_peewee.admin import Admin
from app import app
from auth import auth
from user import User
from sync_log import SyncLog
from implemented_models import MODELS_CLASS, MASTER_CLASSES, DEPENDENT_CLASSES
from flask_peewee.utils import make_password
#
# Setup the admin interface.
#
admin = Admin(app, auth)
auth.register_admin(admin)
#
# Register the models available in the admin interface.
#
def init_db():
if not SyncLog.table_exists():
SyncLog.create_table()
if not User.table_exists():
User.create_table()
User.create(username='******',
password=make_password('admin'),
admin=True)
# -*- coding: utf-8 -*- """ admin imports app, auth and models, but none of these import admin so we're OK """ from flask_peewee.admin import Admin, ModelAdmin from app import app, db from auth import auth from models import User admin = Admin(app, auth) # auth.register_admin(admin) admin.register(User, ModelAdmin) # register any other models here.
from flask_peewee.admin import Admin, ModelAdmin
from app import app, db
from auth import auth
from models import User, Location, Acl
from pbkdf2 import hashing_passwords as hp
admin = Admin(app, auth, branding='MQTTitude')
# or you could admin.register(User, ModelAdmin) -- you would also register
# any other models here.
class LocationAdmin(ModelAdmin):
columns = (
'tst',
'username',
'device',
'lat',
'lon',
)
class UserAdmin(ModelAdmin):
columns = (
'username',
'superuser',
'pbkdf2',
)
# Upon saving the User model in admin, set the PBKDF2 hash for
class CountryAdmin(ModelAdmin):
columns = ('id', 'countrycode', 'countryname')
class ChargeAdmin(ModelAdmin):
columns = ('id', 'id_cc_card', 'creationdate', 'amount', 'chargetype')
class DidAdmin(ModelAdmin):
columns = ('id', 'did', 'iduser', 'activated', 'reserved')
class DidDestinationAdmin(ModelAdmin):
columns = ('destination', 'id_cc_card', 'id_cc_did', 'activated')
admin = Admin(app, auth, branding='A2Billing API Admin Site')
admin.register(Card, CardAdmin)
admin.register(CardGroup, CardGroupAdmin)
admin.register(Callerid, CalleridAdmin)
admin.register(Logrefill, LogrefillAdmin)
admin.register(Logpayment, LogpaymentAdmin)
admin.register(Call, CallAdmin)
admin.register(Country, CountryAdmin)
admin.register(Charge, ChargeAdmin)
# admin.register(Did, DidAdmin)
# admin.register(DidDestination, DidDestinationAdmin)
auth.register_admin(admin)
# Copyright (C) 2013-2014 Avencall
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>
import datetime
from flask_peewee.admin import Admin, ModelAdmin
from app import app, db
from auth import auth
from models import comments
class commentsAdmin(ModelAdmin):
columns = ('model', 'comment', 'author', 'email', 'created')
admin = Admin(app, auth)
admin.register(comments, commentsAdmin)
)
class DownloadAdmin(ModelAdmin):
columns = (
'project',
'command',
)
foreign_key_lookups = {'project': 'name'}
class AddonAdmin(ModelAdmin):
columns = (
'project',
'number',
'repo',
'custom',
)
foreign_key_lookups = {'project': 'name'}
admin = Admin(app, auth)
auth.register_admin(admin)
admin.register(User, UserAdmin)
admin.register(Project, ProjectAdmin)
admin.register(Addon, AddonAdmin)
admin.register(Download, DownloadAdmin)
admin.setup()
def init_admin(app, auth, models):
admin = Admin(app, auth)
for model in models:
admin.register(model)
admin.setup()
from flask_peewee.admin import Admin from gistsurfr.app import app, db from gistsurfr.auth import auth from gistsurfr.models import User, UserRelationship, UserGithub, UserGistFavorite admin = Admin(app, auth, branding='Gistsurfr') auth.register_admin(admin) admin.register(UserRelationship) admin.register(UserGithub) admin.register(UserGistFavorite)
if form.validate_on_submit():
flash("User Created", "success")
models.Taco.create(user=g.user._get_current_object(),
phoneNumber=form.phoneNumber.data,
fullName=form.fullName.data,
email=form.email.data,
member=form.member.data)
return redirect(url_for('signIn'))
return render_template('signup.html', form=form)
if __name__ == '__main__':
models.initialize()
admin = Admin(app, name="Temple")
admin.add_view(MyModelView(models.User))
admin.add_view(MyModelView(models.Taco, name="Member Info"))
admin.add_view(MyModelView(models.Check))
try:
models.User.create_user(
email='*****@*****.**',
password='******',
admin = True
)
except ValueError:
pass
app.run(debug=DEBUG, host=HOST, port=PORT)
return PhotoForm
def save_model(self, instance, form, adding=False):
instance = super(PhotoAdmin, self).save_model(instance, form, adding)
if 'image_file' in request.files:
file = request.files['image_file']
instance.save_image(file)
return instance
class TagAdmin(ModelAdmin):
columns = ['tag']
class PhotoTagsAdmin(ModelAdmin):
columns = ['tags', 'photo']
admin = Admin(app,auth)
auth.register_admin(admin)
admin.register(Note, NoteAdmin)
admin.register(Articles,Article_Custom_Admin)
admin.register(Photo, PhotoAdmin)
admin.register(Tag, TagAdmin)
admin.register(PhotoTags, PhotoTagsAdmin)
admin.register_panel('Notes', NotePanel)
}
class UserStatsPanel(AdminPanel):
template_name = 'admin/user_stats.html'
def get_context(self):
last_week = datetime.datetime.now() - datetime.timedelta(days=7)
signups_this_week = User.filter(join_date__gt=last_week).count()
messages_this_week = Message.filter(pub_date__gt=last_week).count()
return {
'signups': signups_this_week,
'messages': messages_this_week,
}
admin = Admin(app, auth)
class MessageAdmin(ModelAdmin):
columns = ('user', 'content', 'pub_date',)
foreign_key_lookups = {'user': '******'}
filter_fields = ('user', 'content', 'pub_date', 'user__username')
class NoteAdmin(ModelAdmin):
columns = ('user', 'message', 'created_date',)
exclude = ('created_date',)
class CityAdmin(ModelAdmin):
columns = ('name',)
class PincheAdmin(ModelAdmin):
columns = ('city', 'title', 'phone', 'route', 'publisher', 'content',)
url_prefix='/%s' % app_config.PROJECT_SLUG)
file_handler = logging.FileHandler('%s/app.log' % app_config.SERVER_LOG_PATH)
file_handler.setLevel(logging.INFO)
app.logger.addHandler(file_handler)
app.logger.setLevel(logging.INFO)
class SlideAdmin(ModelAdmin):
exclude = ('slug', )
# Set up flask peewee db wrapper
db = Database(app)
auth = Auth(app, db, prefix='/%s/accounts' % app_config.PROJECT_SLUG)
admin = Admin(app, auth, prefix='/%s/admin' % app_config.PROJECT_SLUG)
admin.register(Slide, SlideAdmin)
admin.register(SlideSequence)
admin.setup()
@app.route('/%s/admin/stack/' % app_config.PROJECT_SLUG, methods=['GET'])
def _stack():
"""
Administer a stack of slides.
"""
context = make_context(asset_depth=1)
sequence = SlideSequence.select()
sequence_dicts = sequence.dicts()
}
class UserStatsPanel(AdminPanel):
template_name = 'admin/user_stats.html'
def get_context(self):
last_week = datetime.datetime.now() - datetime.timedelta(days=7)
signups_this_week = User.filter(join_date__gt=last_week).count()
messages_this_week = Message.filter(pub_date__gt=last_week).count()
return {
'signups': signups_this_week,
'messages': messages_this_week,
}
admin = Admin(app, auth)
class MessageAdmin(ModelAdmin):
columns = ('user', 'content', 'pub_date',)
foreign_key_lookups = {'user': '******'}
filter_fields = ('user', 'content', 'pub_date', 'user__username')
class NoteAdmin(ModelAdmin):
columns = ('user', 'message', 'created_date',)
exclude = ('created_date',)
class CityAdmin(ModelAdmin):
columns = ('name',)
class PincheAdmin(ModelAdmin):
columns = ('city', 'title', 'phone', 'route', 'publisher', 'content',)
from flask_peewee.admin import Admin, ModelAdmin
from app import app, db
from auth import auth
from models import User, Location, Acl
from pbkdf2 import hashing_passwords as hp
admin = Admin(app, auth, branding='ownTracks')
# Check for existing admin user and in none
# exists create one
# TODO: Show flash message for newly created
# admin user
try:
test_admin = User.get(User.username == 'admin')
except:
# No Admin user yet, so create one
test_admin = auth.User(username='******', email='', admin=True, active=True, superuser=True)
test_admin.set_password('admin')
test_admin.save()
# or you could admin.register(User, ModelAdmin) -- you would also register
# any other models here.
class LocationAdmin(ModelAdmin):
columns = ('tst', 'username', 'device', 'lat', 'lon', )
class UserAdmin(ModelAdmin):
columns = ('username', 'superuser', 'pbkdf2',)
Model.create_table(fail_silently=True)
user_datastore.create_user(email='*****@*****.**', password='******')
# Views
@app.route('/')
@login_required
def home():
return render_template('index.html')
# needed for authentication
auth = Auth(app, db)
class MessageAdmin(ModelAdmin):
columns = ('user', 'content', 'pub_date')
class Message(db.Model):
user = ForeignKeyField(User)
content = TextField()
pub_date = DateTimeField(default=datetime.datetime.now)
def __unicode__(self):
return '%s: %s' % (self.user, self.content)
admin = Admin(app, auth)
admin.register(Message, MessageAdmin)
admin.setup()
app.run(host = '0.0.0.0',
port = 8080,
debug = True,
threaded = True)
self.facebook_id = facebook_id'''
class Drop(db.Model):
drop_owner = ForeignKeyField(Owner)
drop_address = TextField()
drop_lat = CharField()
drop_long = CharField()
drop_tags = CharField()
'''def __init__(self, drop_owner, drop_address, drop_tags):
self.drop_owner = drop_owner
self.drop_address = drop_address
self.drop_tags = drop_tags'''
admin = Admin(app, auth)
class OwnerAdmin(ModelAdmin):
columns = (
'name',
'email',
'facebook_id',
)
class DropAdmin(ModelAdmin):
columns = (
'drop_owner',
'drop_address',
'drop_lat',
from flask_peewee.admin import Admin, ModelAdmin
from app import app
from auth import auth
from models import User
class UserView(ModelAdmin):
columns = ('username', 'email',)
admin = Admin(app, auth)
auth.register_admin(admin)
admin.register(User, UserView)
admin.setup()
from flask import Flask, render_template, redirect, url_for, jsonify
from flask_peewee.auth import Auth
from flask_peewee.db import Database
from flask_peewee.admin import Admin
from werkzeug import secure_filename
app = Flask(__name__)
app.config.from_pyfile('config.py')
db = Database(app)
auth = Auth(app, db)
admin = Admin(app, auth)
import models
@app.route('/nodos.json')
def main():
return jsonify(models.generar_diccionario_nodos())
@app.route('/')
def main():
return render_template('test.html', json_data=models.generar_diccionario_nodos())
if __name__ == "__main__":
auth.register_admin(admin)
admin.register(models.Cooperativa)
admin.register(models.Federacion)
admin.register(models.CoopFederacion)
admin.setup()
app.run(host='0.0.0.0')
def init_app(self, app): # Инициируем Админку
self.extension = Admin(app.web_app, app.auth)
def get_context(self):
ins = celery.control.inspect()
return {
"scheduled_tasks": ins.scheduled(),
"active_tasks": ins.active()
}
class ConfigAdmin(ModelAdmin):
columns = ("name", "value")
class TweetAdmin(ModelAdmin):
columns = ("id", "created_at", "tweeted_by", "text", "score")
class UserAdmin(ModelAdmin):
columns = ("username", "email", "admin")
admin = Admin(app, auth, branding="Power Poetry Twitter Demo")
admin.register(Config, ConfigAdmin)
admin.register(Tweet, TweetAdmin)
admin.register(User, UserAdmin)
admin.register_panel("Celery Tasks", TasksPanel)
admin.setup()
# create an Auth object for use with our flask app and database wrapper
auth = Auth(app, db)
# instantiate the user auth
user_auth = UserAuthentication(auth, protected_methods=['GET', 'POST', 'PUT', 'DELETE'])
# create a RestAPI container
api = RestAPI(app, default_auth=user_auth)
# register the models
api.register(Card, CardResource, auth=user_auth)
api.register(CardGroup, auth=user_auth)
api.register(auth.User, UserResource, auth=user_auth)
api.setup()
admin = Admin(app, auth, branding='A2Billing API Admin Site')
admin.register(Card, CardAdmin)
admin.register(CardGroup, CardGroupAdmin)
auth.register_admin(admin)
admin.setup()
if __name__ == '__main__':
auth.User.create_table(fail_silently=True)
# Note.create_table(fail_silently=True)
try:
admin = auth.User(username='******', email='', admin=True, active=True)
admin.set_password('admin')
admin.save()
except IntegrityError:
print "User 'admin' already created!"
from flask import request, redirect
from auth import auth
from models import *
from app import app, psql_db
class EntryAdmin(ModelAdmin):
columns = ('title', 'publishdate', 'recipe', 'private')
def get_query(self):
return Entry.select().order_by(-Entry.publishdate)
class UserAdmin(ModelAdmin):
columns = ('username', 'email', 'twitter', 'admin', 'active')
class RecipeAdmin(ModelAdmin):
def get_query(self):
return Recipe.select().order_by(Recipe.slug)
class PageAdmin(ModelAdmin):
def get_query(self):
return Page.select().order_by(-Page.publishdate)
admin = Admin(app, auth, branding = "Carboy admin")
auth.register_admin(admin)
admin.register(Entry, EntryAdmin)
admin.register(Page, PageAdmin)
admin.register(Recipe, RecipeAdmin)
admin.register(User, UserAdmin)
admin.setup()
from flask_peewee.admin import Admin, ModelAdmin
from app import app, db
from auth import auth
from models import *
class CarAdmin(ModelAdmin):
columns = ('user', 'vehicle_id', 'model', 'year', 'name', 'picture');
class CommuteAdmin(ModelAdmin):
columns = ('car', 'trip_mpg', 'trip_milage', 'duration')
class CBSMessageAdmin(ModelAdmin):
columns = ('car', 'type', 'state', 'description', 'remaining_mileage', 'due_date', 'update_time')
class CCMMessageAdmin(ModelAdmin):
columns = ('car', 'ccm_id', 'mileage', 'description', 'update_time')
class RawDataAdmin(ModelAdmin):
columns = ('car', 'update_time', 'tank_level', 'fuel_range', 'fuel_reserve', 'odometer', 'ave_mpg', 'headlights', 'speed', 'engine_status')
admin = Admin(app, auth)
auth.register_admin(admin)
admin.register(Car, CarAdmin)
admin.register(RawData, RawDataAdmin)
admin.register(CCMMessage, CCMMessageAdmin)
admin.register(CBSMessage, CBSMessageAdmin)
admin.register(Commute, CommuteAdmin)
Configures the admin interface.
"""
from flask_peewee.admin import Admin
from app import app
from auth import auth
from user import User
from sync_log import SyncLog
from implemented_models import MODELS_CLASS, MASTER_CLASSES, DEPENDENT_CLASSES
from flask_peewee.utils import make_password
#
# Setup the admin interface.
#
admin = Admin(app, auth)
auth.register_admin(admin)
#
# Register the models available in the admin interface.
#
def init_db():
if not SyncLog.table_exists():
SyncLog.create_table()
if not User.table_exists():
User.create_table()
User.create(username='******',
password=make_password('admin'),
admin=True)
from flask_peewee.auth import Auth
from flask_peewee.db import Database
from flask_peewee.utils import get_object_or_404
from flask_sslify import SSLify
from peewee import BooleanField, CharField, DateTimeField, ForeignKeyField, TextField
import stripe
logging.basicConfig(level=logging.INFO)
app = Flask(__name__)
app.config.from_object(os.environ['CONFIG'])
assets = Environment(app)
db = Database(app)
auth = Auth(app, db)
admin = Admin(app, auth)
mail = Mail(app)
sslify = SSLify(app)
css = Bundle(app.config['CSS_BOOTSTRAP'], 'css/custom.css')
assets.register('css_all', css)
js = Bundle(app.config['JS_BOOTSTRAP'])
assets.register('js_all', js)
stripe.api_key = app.config['STRIPE_KEYS']['secret_key']
class Piece(db.Model):
title = CharField()
slug = CharField()
'''
Modulo di Amministrazione
Accesso all'area admin: http://localhost:8080/admin
'''
from app import app
from auth import auth
from flask_peewee.admin import Admin, ModelAdmin
from models import Relay
class RelayAdmin(ModelAdmin):
'''
Amministrazione Model Relay
'''
columns = ('channel', 'device', 'active',)
"Crea oggetto Admin associandolo ad un'Authenticator"
admin = Admin(app, auth)
auth.register_admin(admin)
"Registra Model"
admin.register(Relay, RelayAdmin)
import datetime
from flask import request, redirect
from flask_peewee.auth import Auth
from flask_peewee.admin import Admin, ModelAdmin
from app import app, db
from models import Image, Imageuri, ImageFragment, Metadata, Annotation
# create an Auth object for use with our flask app and database wrapper
auth = Auth(app, db)
class ImageAdmin(ModelAdmin):
columns = ('id','width', 'created',)
class ImageuriAdmin(ModelAdmin):
columns = ('image','uri', 'created',)
admin = Admin(app, auth)
admin.register(Image, ImageAdmin)
admin.register(Imageuri, ImageuriAdmin)
admin.register(ImageFragment)
admin.register(Metadata)
admin.register(Annotation)
auth.register_admin(admin)
admin.setup()
auth.User.create_table(fail_silently=True)
def save_model(self, instance, form, adding=True):
'''function that is responsible for persisting user password changes to the database
parameters
----------
instance: an unsaved user model instance
form: a validated form instance
adding: boolean to indicate whether a new instance is being added or saving an existing instance
'''
orig_password = instance.password
user = super(UserAdmin, self).save_model(instance, form, adding)
if orig_password != form.password.data: # if user adds or edits password
user.set_password(form.password.data) # set as new password
user.save() # save new password
return user
# instantiate Admin object
admin = Admin(app, auth)
auth.register_admin(admin)
# register models to expose them to the admin area
admin.register(room,
RoomAdmin) # pass model and subclass with display variables
admin.register(module, ModuleAdmin)
admin.register(timetable, TimetableAdmin)
admin.register(User, UserAdmin)
}
class UserStatsPanel(AdminPanel):
template_name = 'admin/user_stats.html'
def get_context(self):
last_week = datetime.datetime.now() - datetime.timedelta(days=7)
signups_this_week = User.select().where(User.join_date > last_week).count()
messages_this_week = Message.select().where(Message.pub_date > last_week).count()
return {
'signups': signups_this_week,
'messages': messages_this_week,
}
admin = Admin(app, auth, branding='Admin the boat')
class MessageAdmin(ModelAdmin):
columns = ('user', 'content', 'pub_date',)
foreign_key_lookups = {'user': '******'}
filter_fields = ('user', 'content', 'pub_date', 'user__username')
class NoteAdmin(ModelAdmin):
columns = ('user', 'message', 'created_date',)
exclude = ('created_date',)
auth.register_admin(admin)
#admin.register(Relationship)
admin.register(Message, MessageAdmin)
# -*- coding: utf-8 -*- """ Admin dashboard. Configures the admin interface. """ from flask_peewee.admin import Admin from app import app from auth import auth from user import User from product import Product from customer import Customer # # Setup the admin interface. # admin = Admin(app, auth) auth.register_admin(admin) # # Register the models available in the admin interface. # admin.register(User) admin.register(Customer) admin.register(Product) # Enable the admin interface. admin.setup()
from flask_peewee.auth import Auth
from flask_peewee.admin import Admin
from flask_peewee.rest import RestAPI, UserAuthentication
from phrases.app import app, db
from phrases.models import Phrase, Volume, NotePhrase, NoteVolume, UserResource
auth = Auth(app, db)
admin = Admin(app, auth)
user_auth = UserAuthentication(auth)
api = RestAPI(app, default_auth=user_auth)
if __name__ == "__main__":
admin.register(Phrase, NotePhrase)
admin.register(Volume, NoteVolume)
auth.register_admin(admin)
admin.setup()
Phrase.create_table(fail_silently=True)
Volume.create_table(fail_silently=True)
auth.User.create_table(fail_silently=True)
api.register(Phrase, UserResource)
api.setup()
app.run()
# app.scripts.config.serve_locally = True
app.title = 'Test Dash Project'
server = app.server
DATABASE = {
'name': DB_NAME,
'engine': 'peewee.SqliteDatabase',
}
SECRET_KEY = SECRET_KEY_SERVER
server.config.from_object(__name__)
db = DataBase(server)
auth = Auth(app=server, db=db, user_model=Users)
admin = Admin(app=server, auth=auth)
admin.register(model=Cities)
admin.register(model=Date)
admin.register(model=Devices)
admin.register(model=HoursInDay)
admin.register(model=PageViewsByDevices)
admin.register(model=RegionsMap)
admin.register(model=TrafficSource)
admin.register(model=Users)
admin.register(model=VisitsCountByHour)
admin.register(model=VisitsCountByTrafficSource)
admin.setup()
# Setup the LoginManager for the server
login_manager = LoginManager()
login_manager.init_app(server)
DEBUG = True
SECRET_KEY = settings.SECRET_KEY
# ------------------------------------------------------------------------------
# Flask App Settings
app = Flask(__name__)
app.config.from_object(__name__)
db = Database(app)
auth = Auth(app, db)
admin = Admin(app, auth)
# ------------------------------------------------------------------------------
# Flask Models
class ShakespeareQuote(db.Model):
quote = TextField()
created = DateTimeField(default=datetime.datetime.now)
source_url = TextField()
is_tweeted = BooleanField(default=False)
def set_tweeted(self):
self.is_tweeted = True
self.save()
return render_template('apply.html', title='Apply', form=form)
@app.route('/')
def index():
auth = Auth(app, models.DATABASE)
#admin = Admin(app, auth)
#admin.register(models.User)
#admin.setup()
if __name__ == '__main__':
models.initialize()
# needed for authentication
admin = Admin(app, name="GrizzHacks")
admin.add_view(UserView(models.User))
admin.add_view(MyModelView(models.Apply))
admin.add_view(MyModelView(models.emailSignup))
# admin.set_password('admin')
try:
models.User.create_user(email='*****@*****.**',
password='******',
admin=True)
except ValueError:
pass
app.run(debug=DEBUG, host=HOST, port=PORT)
}
class UserStatsPanel(AdminPanel):
template_name = 'admin/user_stats.html'
def get_context(self):
last_week = datetime.datetime.now() - datetime.timedelta(days=7)
signups_this_week = User.select().where(User.join_date > last_week).count()
messages_this_week = Message.select().where(Message.pub_date > last_week).count()
return {
'signups': signups_this_week,
'messages': messages_this_week,
}
admin = Admin(app, auth, branding='Example Site')
class MessageAdmin(ModelAdmin):
columns = ('user', 'content', 'pub_date',)
foreign_key_lookups = {'user': '******'}
filter_fields = ('user', 'content', 'pub_date', 'user__username')
class NoteAdmin(ModelAdmin):
columns = ('user', 'message', 'created_date',)
exclude = ('created_date',)
auth.register_admin(admin)
admin.register(Relationship)
admin.register(Message, MessageAdmin)
'name': 'database.db',
'engine': 'peewee.SqliteDatabase',
}
DEBUG = True
SECRET_KEY = 'bleubleu'
# Lancement de l'application
app = Flask(__name__)
app.config.from_object(__name__)
db = Database(app)
auth = Auth(app, db)
from room_service.models import Room, RoomAdmin
import room_service.views
# Admin interface #
admin = Admin(app, auth)
admin.register(Room, RoomAdmin)
auth.register_admin(admin)
admin.setup()
# Assets
assets = Environment(app)
assets.url = app.static_url_path
scss = Bundle('main.scss', filters='pyscss', output='main.css')
assets.register('scss_all', scss)
from app import app, db
from auth import auth
from models import *
class UserStatsPanel(AdminPanel):
template_name = 'admin/user_stats.html'
def get_context(self):
last_week = datetime.datetime.now() - datetime.timedelta(days=7)
signups_this_week = User.select().where(User.join_date > last_week).count()
return {
'signups': signups_this_week,
}
admin = Admin(app, auth, branding='Example Site')
class TeamAdmin(ModelAdmin):
columns = ('name',)
class ScoreAdmin(ModelAdmin):
columns = ('user', 'week', 'week_start','week_end','score')
exclude = ('created_at',)
class TeamLeaderAdmin(ModelAdmin):
columns = ('leader', 'team')
if request.form.get('message'):
Note.create(
user=auth.get_logged_in_user(),
message=request.form['message'],
)
next = request.form.get('next') or self.dashboard_url()
return redirect(next)
def get_context(self):
return {
'note_list': Note.select().order_by(('created_date', 'desc')).paginate(1, 3)
}
auth = Auth(app, db, user_model=User)
admin = Admin(app, auth)
class AAdmin(ModelAdmin):
columns = ('a_field',)
class BAdmin(ModelAdmin):
columns = ('a', 'b_field',)
include_foreign_keys = {'a': 'a_field'}
class CAdmin(ModelAdmin):
columns = ('b', 'c_field',)
include_foreign_keys = {'b': 'b_field'}
class DAdmin(ModelAdmin):
columns = ('c', 'd_field',)
# -*- coding: utf-8 -*- from flask_peewee.admin import Admin from flask_peewee.auth import Auth from app import app, db from models import * auth = Auth(app, db, user_model=AdminUser) admin = Admin(app, auth, branding=app.config['BRANDING']) auth.register_admin(admin) admin.register(AdminUser) admin.register(User) admin.register(Travel) admin.register(Document) admin.setup()
import psyc.models.processor as processor
import psyc.models.execution as execution
from gevent.wsgi import WSGIServer
from flask_peewee.admin import Admin
port = 9080
auth.User.create_table(fail_silently=True)
url.Url.create_table(fail_silently=True)
resource.Resource.create_table(fail_silently=True)
catalog.Catalog.create_table(fail_silently=True)
processor.Processor.create_table(fail_silently=True)
execution.Execution.create_table(fail_silently=True)
admin = Admin(app,auth)
auth.register_admin(admin)
admin.register(url.Url, url.UrlAdmin)
admin.register(resource.Resource, resource.ResourceAdmin)
admin.register(catalog.Catalog, catalog.CatalogAdmin)
admin.register(processor.Processor, processor.ProcessorAdmin)
admin.register(execution.Execution, execution.ExecutionAdmin)
admin.setup()
import psyc.rest
import psyc.views
catalog.register()
#app.run(host='0.0.0.0', port=port, debug=True)
http_server = WSGIServer(('', port), app)
""" admin imports app, auth and models, but none of these import admin so we're OK """ from flask_peewee.admin import Admin, ModelAdmin from app import app, db from auth import auth from models import User admin = Admin(app, auth) auth.register_admin(admin) # or you could admin.register(User, ModelAdmin) -- you would also register # any other models here.
