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 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
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()
'email',
'facebook_id',
)
class DropAdmin(ModelAdmin):
columns = (
'drop_owner',
'drop_address',
'drop_lat',
'drop_long',
'drop_tags',
)
admin.register(auth.User)
admin.register(Owner, OwnerAdmin)
admin.register(Drop, DropAdmin)
admin.setup()
@app.route('/')
def index():
return render_template('index.html')
@app.route('/login')
def login():
return facebook.authorize(callback=url_for('facebook_authorized',
next=request.args.get('next')
or request.referrer or None,
# -*- 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()
# the password
def save_model(self, instance, form, adding=False):
orig_password = instance.password
user = super(UserAdmin, self).save_model(instance, form, adding)
if orig_password != form.password.data:
user.set_password(form.password.data)
user.save()
#
# pbkdf2 = hp.make_hash(instance.password)
# print "***** ", instance.password, pbkdf2
# print "----- ", orig_password, form.password.data
#
# user = super(UserAdmin, self).save_model(instance, form, adding)
#
# user.pbkdf2 = pbkdf2
#
return user
class AclAdmin(ModelAdmin):
columns = ('user', 'topic', 'rw',)
foreign_key_lookups = {'user': '******'}
filter_fields = ('user', 'topic', 'rw', 'user__username')
exclude = ('user__password', )
auth.register_admin(admin)
admin.register(User, UserAdmin)
admin.register(Location, LocationAdmin)
admin.register(Acl, AclAdmin)
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()
columns = ('destination', 'id_cc_card', 'id_cc_did', 'activated')
class CountryServerAdmin(ModelAdmin):
columns = ('id', 'countrycode', 'countryname', 'countryprefix', 'server',
'port')
class TicketAdmin(ModelAdmin):
columns = ('id', 'title', 'description', 'creationdate', 'priority',
'creator', 'creator_type', 'id_component', 'status',
'viewed_cust', 'viewed_agent', 'viewed_admin')
admin = Admin(app, auth, branding='Redirect 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)
admin.register(CountryServer, CountryServerAdmin)
admin.register(Ticket, TicketAdmin)
auth.register_admin(admin)
'''
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()
'''
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)
from flask import session
from flask_peewee.admin import Admin
from web.app import app, auth
from web.model import Label, Inspiration, LabelInspirationRelationShip
admin = Admin(app, auth)
register_class = [Label, Inspiration, LabelInspirationRelationShip, auth.User]
for klass in register_class:
admin.register(klass)
admin.setup()
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)
# 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!"
# -*- 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)
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()
# ------------------------------------------------------------------------------
# Flask Views
@app.route('/')
def index():
return render_template('shakespurrean_twitter_bot.html')
@app.route('/shakespurrean_twitter_bot')
def tweet():
return render_template('shakespurrean_twitter_bot.html')
# ------------------------------------------------------------------------------
# Run Server
if __name__ == "__main__":
ShakespeareQuote.create_table(fail_silently=True)
auth.User.create_table(fail_silently=True)
admin.register(ShakespeareQuote, ShakespeareQuoteAdmin)
admin.setup()
if 'liveconsole' not in gethostname():
app.run(
host='0.0.0.0',
port=int(environ.get("PORT", 5000))
)
class PhotoForm(Form):
image = HiddenField()
image_file = FileField('Image file')
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
admin = Admin(app, auth)
admin.register(Photo, PhotoAdmin)
admin.register(Goods, GoodsAdmin)
admin.register(Users, UsersAdmin)
admin.register(Reviews, ReviewsAdmin)
admin.setup()
######################API#############################
from flask_peewee.rest import RestAPI, UserAuthentication, RestResource
class ForeignResource(RestResource):
exclude = (
'amount',
'size',
'photo',
)
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')
pbkdf2 = hp.make_hash(instance.password)
print "***** ", instance.password, pbkdf2
print "----- ", orig_password, form.password.data
user = super(UserAdmin, self).save_model(instance, form, adding)
user.pbkdf2 = pbkdf2
if orig_password != form.password.data:
user.set_password(form.password.data)
user.save()
return user
class AclAdmin(ModelAdmin):
columns = (
'user',
'topic',
'rw',
)
foreign_key_lookups = {'user': '******'}
filter_fields = ('user', 'topic', 'rw', 'user__username')
exclude = ('user__password', )
auth.register_admin(admin)
admin.register(User, UserAdmin)
admin.register(Location, LocationAdmin)
admin.register(Acl, AclAdmin)
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()
# -*- 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.
#
# 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)
for mod_class in MASTER_CLASSES.keys():
if not MODELS_CLASS[mod_class].table_exists():
MODELS_CLASS[mod_class].create_table()
for mod_class in sorted(DEPENDENT_CLASSES.keys()):
if not MODELS_CLASS[mod_class].table_exists():
MODELS_CLASS[mod_class].create_table()
init_db()
for mod_class in MODELS_CLASS:
admin.register(MODELS_CLASS[mod_class])
admin.register(User)
# Enable the admin interface.
admin.setup()
#
# 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)
for mod_class in MASTER_CLASSES.keys():
if not MODELS_CLASS[mod_class].table_exists():
MODELS_CLASS[mod_class].create_table()
for mod_class in sorted(DEPENDENT_CLASSES.keys()):
if not MODELS_CLASS[mod_class].table_exists():
MODELS_CLASS[mod_class].create_table()
init_db()
for mod_class in MODELS_CLASS:
admin.register(MODELS_CLASS[mod_class])
admin.register(User)
# Enable the admin interface.
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)
import datetime
from flask_peewee.admin import Admin, ModelAdmin, AdminPanel
from app import app
from auth import auth
from models import User, Relationship
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.joined > last_week).count()
return {
'signups': signups_this_week,
}
class UserAdmin(ModelAdmin):
# it doesn't work yet because flask-peewe has error
columns = ('email', 'active', 'admin', 'joined')
admin = Admin(app, auth, branding=app.config['BRAND'])
auth.register_admin(admin, UserAdmin)
admin.register_panel('User stats', UserStatsPanel)
admin.register(Relationship)
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)
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()
@app.route('/api/add/homework/<password>/<subject>/<int:year>/<int:month>/<int:day>/<long_desc>')
def get_display_name(self):
return self.get_admin_name()
user_datastore = PeeweeUserDatastore(db, Users, Role, UserRoles)
security = Security(app,
user_datastore,
login_form=LoginForms,
register_form=RegisterForm,
confirm_register_form=RegisterForm,
forgot_password_form=ForgotForm,
reset_password_form=ResetForm,
change_password_form=ChangeForm)
admin = Admin(app, auth)
admin.register(Role, ModelAdmin)
admin.register(UserRoles, ModelAdmin)
admin.register(Category, CategoryAdmin)
admin.register(Product, ProductAdmin)
admin.register(Order_detail, Order_detailAdmin)
admin.register(Period, PeriodAdmin)
admin.register(Configure, ConfigureAdmin)
admin.register(Users, UsersAdmin)
admin.register(Show, ShowAdmin)
admin.register(Address, AddressAdmin)
admin.register(WinRecord, WinRecordAdmin)
admin.register(WinRecord, WinRecordAdmin)
auth.register_admin(admin)
admin.setup()
'created_date',
)
exclude = ('created_date', )
class CityAdmin(ModelAdmin):
columns = ('name', )
class PincheAdmin(ModelAdmin):
columns = (
'city',
'title',
'phone',
'route',
'publisher',
'content',
)
exclude = ('pub_date', )
auth.register_admin(admin)
admin.register(Relationship)
admin.register(Message, MessageAdmin)
admin.register(Note, NoteAdmin)
admin.register_panel('Notes', NotePanel)
admin.register_panel('User stats', UserStatsPanel)
admin.register(City, CityAdmin)
admin.register(Pinche, PincheAdmin)
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)
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)
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
admin.setup()
api.setup()
def init_admin(app, auth, models):
admin = Admin(app, auth)
for model in models:
admin.register(model)
admin.setup()
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)
admin.register(Note, NoteAdmin)
admin.register_panel('Notes', NotePanel)
admin.register_panel('User stats', UserStatsPanel)
exclude = ('created_date',)
class CityAdmin(ModelAdmin):
columns = ('name',)
class PincheAdmin(ModelAdmin):
columns = ('city', 'title', 'phone', 'route', 'publisher', 'content',)
exclude = ('pub_date',)
class CarBrandAdmin(ModelAdmin):
columns = ('name',)
class CarSeriesAdmin(ModelAdmin):
columns = ('brand', 'name',)
class CarModelAdmin(ModelAdmin):
columns = ('series', 'name',)
auth.register_admin(admin)
admin.register(Relationship)
admin.register(Message, MessageAdmin)
admin.register(Note, NoteAdmin)
admin.register_panel('Notes', NotePanel)
admin.register_panel('User stats', UserStatsPanel)
admin.register(City, CityAdmin)
admin.register(Pinche, PincheAdmin)
admin.register(CarBrand, CarBrandAdmin)
admin.register(CarSeries, CarSeriesAdmin)
admin.register(CarModel, CarModelAdmin)
# -*- 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.
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()
time = 0
# 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)
}
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',)
exclude = ('pub_date',)
auth.register_admin(admin)
admin.register(Relationship)
admin.register(Message, MessageAdmin)
admin.register(Note, NoteAdmin)
admin.register_panel('Notes', NotePanel)
admin.register_panel('User stats', UserStatsPanel)
admin.register(City, CityAdmin)
admin.register(Pinche, PincheAdmin)
)
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()
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)
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)
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()
}
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,
}
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)
admin.register(Note, NoteAdmin)
admin.register_panel('Notes', NotePanel)
admin.register_panel('User stats', UserStatsPanel)
# 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)
Tariff.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)
'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)
# -*- 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()
columns = ('b', 'c_field',)
include_foreign_keys = {'b': 'b_field'}
class DAdmin(ModelAdmin):
columns = ('c', 'd_field',)
include_foreign_keys = {'c': 'c_field'}
class MessageAdmin(ModelAdmin):
columns = ('user', 'content', 'pub_date',)
class NoteAdmin(ModelAdmin):
columns = ('user', 'message', 'created_date',)
auth.register_admin(admin)
admin.register(AModel, AAdmin)
admin.register(BModel, BAdmin)
admin.register(CModel, CAdmin)
admin.register(DModel, DAdmin)
admin.register(BDetails)
admin.register(Message, MessageAdmin)
admin.register(Note, NoteAdmin)
admin.register_panel('Notes', NotePanel)
class UserResource(RestResource):
exclude = ('password', 'email',)
def get_query(self):
return User.filter(active=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)
login_manager.login_view = '/login'
# configure our database
DATABASE = {
'name': 'expense.db',
'engine': 'peewee.SqliteDatabase',
}
DEBUG = True
SECRET_KEY = 'ssshhhh'
app = Flask(__name__)
app.config.from_object(__name__)
# create an Auth object for use with our flask app and database wrapper
# auth = Auth(app, db)
admin = Admin(app, None)
admin.register(User)
admin.register(Expense)
admin.register(Chat)
admin.setup()
# create a RestAPI container
api = RestAPI(app)
# register the Note model
api.register(User)
api.register(Expense)
api.register(Chat)
api.setup()
cors = CORS(app, resources={r"/api/*": {"origins": "*"}})
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)
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)
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)
admin.register(Note, NoteAdmin)
admin.register_panel('Notes', NotePanel)
admin.register_panel('User stats', UserStatsPanel)
msg = Message("Contact Form Submission (%s)" % email,
reply_to=email,
recipients=[app.config['ADMIN_EMAIL']],
body=message)
mail.send(msg)
logging.info('%s (%s): %s' % (name, email, message,))
flash("Thanks for contacting me.. I'll get back to you as soon as possible!", 'success')
return redirect(url_for('gallery'))
return render_template('contact.html', form=form)
@app.before_request
def redirect_non_www():
"""Redirect non-www requests to www."""
urlparts = urlparse(request.url)
if urlparts.netloc == 'michaelwarkentin.com':
urlparts_list = list(urlparts)
urlparts_list[1] = 'www.michaelwarkentin.com'
return redirect(urlunparse(urlparts_list), code=301)
auth.User.create_table(fail_silently=True)
Piece.create_table(fail_silently=True)
PieceImage.create_table(fail_silently=True)
admin.register(Piece, PieceAdmin)
admin.register(PieceImage, PieceImageAdmin)
admin.setup()
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)
http_server.serve_forever()
columns = ('name',)
class ScoreAdmin(ModelAdmin):
columns = ('user', 'week', 'week_start','week_end','score')
exclude = ('created_at',)
class TeamLeaderAdmin(ModelAdmin):
columns = ('leader', 'team')
class LeadershipAdmin(ModelAdmin):
columns = ('leader', 'employee')
class GovernorAdmin(ModelAdmin):
columns = ('user',)
class WeekAdmin(ModelAdmin):
columns = ('name','start','end')
auth.register_admin(admin)
admin.register_panel('User stats', UserStatsPanel)
admin.register(Team, TeamAdmin)
admin.register(Score, ScoreAdmin)
admin.register(TeamLeader, TeamLeaderAdmin)
admin.register(Governor, GovernorAdmin)
admin.register(Week, WeekAdmin)
admin.register(Leadership, LeadershipAdmin)
