def reset_database(app):
with app.app_context():
from database.models.general.customer import Customer
from database.models.general.user import User
from database.models.cloud.cloud_provider import CloudProvider
from database.models.cloud.cloud_account import CloudAccount
from uuid import uuid4
with open("data/initial_data.json") as fr:
initial_data = json.loads(fr.read())
db.drop_all()
db.create_all()
for dcustomer in initial_data["customers"]:
uid = str(uuid4())
customer = Customer(uid=uid,\
name=dcustomer["name"])
db.session.add(customer)
db.session.commit()
# This saves the last inserted customer_uid
customer_uid = customer.uid
for dcloud_provider in initial_data["cloud_providers"]:
uid = str(uuid4())
cloud_provider = CloudProvider(uid=uid,\
name=dcloud_provider["name"], \
abbreviation=dcloud_provider["abbreviation"])
db.session.add(cloud_provider)
db.session.commit()
# This saves the last inserted cloud_provider_uid
cloud_provider_uid = cloud_provider.uid
for dcloud_account in initial_data["cloud_accounts"]:
uid = str(uuid4())
# This takes customer_uid and cloud_provider_uid recently inserted
cloud_account = CloudAccount(uid=uid, \
name=dcloud_account["name"], \
customer_uid=customer_uid, \
cloud_provider_uid=cloud_provider_uid)
db.session.add(cloud_account)
db.session.commit()
hashing = Hashing()
hashing_salt = initial_data["hashing_salt"]
for dcloud_account in initial_data["users"]:
hashed_password = hashing.hash_value(dcloud_account["password"],
salt=hashing_salt)
user = User(username=dcloud_account["username"], \
password=hashed_password, \
name=dcloud_account["name"])
db.session.add(user)
db.session.commit()
def login():
if request.method == 'POST':
details = request.form
hashing = Hashing(app)
username = details['username']
passwordhash = hashing.hash_value(details['password'], salt='rhino3d')
cur = mysql.connection.cursor()
query = "SELECT employeeid FROM dcip_employees WHERE employeeid = %s AND password = %s"
param = (username, passwordhash)
cur.execute(query, param)
userdata = cur.fetchall()
employeeid = ''
for row in userdata:
employeeid = row[0]
if (len(employeeid) > 0):
session['employeeid'] = employeeid
return redirect(url_for('leaderboard'))
else:
return redirect(url_for('login'))
else:
return render_template('index.html',
title='DCKAP Community Insider Program')
class ImageSaver():
def __init__(self):
self.hashing = Hashing()
self.extensions = set(['png', 'jpg', 'jpeg'])
def save_image(self, image, token, label=""):
'''
Recieves an image from form, a user token and a label
Returns a http response
'''
if not self.check_extensions(image.filename):
return Response("Not an exentsion supported", status=400)
create_directory(path.join(app.config['UPLOAD_FOLDER'], label))
hashed_path = self.hashed_path(image, token, label)
image.save(hashed_path)
return Response("Created", status=201)
def hashed_path(self, image, token, label=""):
'''
Recieves an image object and a token
Returns hashed path of object
'''
filename = secure_filename(image.filename)
hashed_name= self.hashing.hash_value(filename.split('.')[0], salt=token) \
+'.'+ filename.split('.')[1]
return path.join(app.config['UPLOAD_FOLDER'], label, hashed_name)
def check_extensions(self, filename):
'''
Recieves a filename
Returns if file has extension permited
'''
return '.' in filename and \
filename.rsplit('.', 1)[1].lower() in self.extensions
def delete_image(self, image_path):
'''
Recieves a path of a file already hashed
Returns True if file had deleted
'''
if path.exists(image_path):
remove(image_path)
return True
return False
def create_app():
if os.getenv("SENTRY_DSN"):
sentry_sdk.init(
dsn=os.environ["SENTRY_DSN"],
integrations=[FlaskIntegration()],
traces_sample_rate=1.0
)
app = Flask(__name__)
app.secret_key = os.environ["FLASK_SECRET"]
app.config.update(
SESSION_COOKIE_SECURE=True,
SESSION_COOKIE_HTTPONLY=True,
SESSION_COOKIE_SAMESITE="Lax",
REDIS_URL=os.environ["REDIS_URL"],
VERSION="0.0.1",
UPLOAD_FOLDER=os.getenv("UPLOAD_FOLDER", "/tmp")
)
CORS(app,
methods=["GET", "POST", "OPTIONS"],
supports_credential=True)
app.redis_client = FlaskRedis(app)
app.hashing = Hashing(app)
return app
from flask import Flask, render_template
from flask_migrate import Migrate, MigrateCommand
from flask_script import Manager
from flask_socketio import SocketIO
from flask_sqlalchemy import SQLAlchemy
from flask_bcrypt import Bcrypt
from flask_hashing import Hashing
from flask_login import LoginManager
app = Flask(__name__)
app.config.from_object('config')
socketio = SocketIO(app)
bcrypt = Bcrypt(app)
hashing = Hashing(app)
db = SQLAlchemy(app)
migrate = Migrate(app, db)
login_manager = LoginManager()
login_manager.init_app(app)
manager = Manager(app)
manager.add_command('db', MigrateCommand)
from app.models import user
from app.forms import user
from app.controllers import KDC, auth
from flask_login import LoginManager, current_user, login_user, logout_user, login_required, UserMixin
from database import db_session
# Setting APP
app = Flask(__name__)
# Configure app to use in filesystem
app.config["SESSION_PERMANENT"] = False
app.config["SESSION_TYPE"] = "filesystem"
app.config["HASHING_METHOD"] = "sha256"
app.config["SECRET_KEY"] = "lkkajdghdadkglajkgah" # a secret key for login
# Init some fungtion needed in app
Session(app)
socketio = SocketIO(app, manage_session=False)
hash = Hashing(app)
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = 'index' # the login view of your application
login_manager.login_message = 'Silahkan login utuk dapat mengakses halaman.'
login_manager.login_message_category = "warning"
# Prepare Global Variable
data_response = [{"A": 0, "B": 0, "C": 0, "D": 0, "E": 0}]
responden = []
response_done = False
class User(UserMixin):
def __init__(self, id):
self.id = id
from flask_mako import MakoTemplates
from flask_sqlalchemy import SQLAlchemy
from flask_hashing import Hashing
from flask_restful import Api
# from flask_admin import Admin
from flask_principal import Principal, Permission, RoleNeed
from flask_login import LoginManager
from flask_wtf.csrf import CSRFProtect
from flask_cache import Cache
from flask_debugtoolbar import DebugToolbarExtension
# from flask_socketio import SocketIO
from flask_celery import Celery
mako = MakoTemplates()
db = SQLAlchemy()
hashing = Hashing()
# admin = Admin()
csrf = CSRFProtect()
api = Api(decorators=[csrf.exempt]) # decorators参数，给所有api的url加上装饰器，免于csrf检查
cache = Cache()
debug_toolbar = DebugToolbarExtension()
# socketio = SocketIO()
celery = Celery()
principlas = Principal()
admin_permission = Permission(RoleNeed('admin'))
user_permission = Permission(RoleNeed('user'))
login_manager = LoginManager()
login_manager.login_view = "login"
login_manager.session_protection = "basic"
from flask import Flask, render_template, redirect
import insertDB
import os
from flask import Flask
from flask_hashing import Hashing
from flask import Flask, request, session
from flask_login import LoginManager, login_user, logout_user, login_required, UserMixin, current_user
from werkzeug import secure_filename
app = Flask(__name__)
app.config['HASHING_METHOD'] = 'sha384'
hashing = Hashing(app)
hashing.init_app(app)
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = ''
app.config['SECRET_KEY'] = "lkkajdghdadkglajkgah"
app.config['UPLOAD_FOLDER'] = 'static/prodotti'
@login_manager.user_loader
def load_user(user_id):
return User(user_id)
class User(UserMixin):
def __init__(self, id):
self.id = id
'status': 404,
'For more info': "Visit support docs"
},
'ResourceDoesNotExist': {
'message': "A resource with that ID no longer exists.",
'status': 410,
'extra': "Any extra information you want.",
},
}
app = Flask(__name__)
api = Api(app, errors=errors)
salt = config.password #Set salt/key
password = '******'
hashing = Hashing(app)
h = hashing.hash_value('password', salt) #Generate hash
#Home page
@app.route('/')
def home():
#List of Countries
coun = [
'Morocco', 'Paraguay', 'Palau', 'Zimbabwe', 'El Salvador', 'Portugal',
'France', 'Japan', 'Mauritania', 'Sweden', 'Trinidad and Tobago',
'Uzbekistan', 'United Kingdom of Great Britain and Northern Ireland',
'Sri Lanka', 'Mauritius', 'Libya', 'Belarus',
'Saint Vincent and the Grenadines', 'Yemen', 'Uganda', 'Faroe Islands',
'Bhutan', 'Panama', 'Honduras', 'Bosnia and Herzegovina', 'Greenland',
def create_app(test_config=None):
# create the Flask
app = Flask(__name__, instance_relative_config=True)
# instance for scss
assets = Environment(app)
assets.url = app.static_url_path
scss = Bundle('index.scss', filters='scss', output='index.css')
assets.register('scss_all', scss)
assets.init_app(app)
hashing = Hashing(app)
# configure the app
app.config.from_mapping(
SECRET_KEY='dev',
MONGO_URI="mongodb://*****:*****@localhost:27017/souq?authSource=admin"
)
# connect to MongoDB using mongoengine
connect(db='souq', )
@app.route('/test-db')
def test_db():
bert = User(username='******',
password='******',
first_name='Bert',
last_name='Sesame').save()
cookie = User(username='******',
password='******',
first_name='Cookie',
last_name='Monster').save()
c1 = Comment(content='test comment 1', author=bert)
c2 = Comment(content='test comment 2', author=cookie)
# Create Textitem
item1 = TextItem(title='Fun with MongoEngine',
author=bert,
comments=[c1, c2])
item1.content = 'Took a look at MongoEngine today, looks pretty cool.'
item1.tags = ['mongodb', 'mongoengine']
item1.save()
# Create Linkitem
item2 = LinkItem(title='MongoEngine Documentation', author=bert)
item2.link_url = 'http://docs.mongoengine.com/'
item2.tags = ['mongoengine']
item2.save()
# for item in item.objects:
# print(item.title)
return 'data base'
# register the 'item' blueprint
from .blueprints.item import item_bp
app.register_blueprint(item_bp)
# register the 'user' blueprint
from .blueprints.user import user_bp
app.register_blueprint(user_bp)
# register the 'login' blueprint
from .blueprints.login import login_bp
app.register_blueprint(login_bp)
from .blueprints.dashboard import dashboard_bp
app.register_blueprint(dashboard_bp)
return app
# Imports
import time
import random
import string
import re
import os
import sqlite3
from flask import Flask, request, session, g, redirect, url_for, abort, \
render_template, flash, Markup, send_file
from flask_hashing import Hashing
from werkzeug import secure_filename
app = Flask(__name__) # create the application instance :)
app.config.from_object(__name__) # load config from this file , flaskr.py
hashing = Hashing(app)
app.config['TRAP_BAD_REQUEST_ERRORS'] = True
# Load default config and override config from an environment variable
app.config.update(dict(
DATABASE=os.path.join(app.root_path, 'flaskr.db'),
SECRET_KEY='#####',
USERNAME='******', #SUPERADMIN name
PASSWORD= hashing.hash_value('####',salt='####'), #SUPERADMIN password
ALLOWED_EXTENSIONS = set(['jpg', 'jpeg', 'png', 'pdf']), #Allowed extensions to store
UPLOAD_FOLDER = '/var/www/html/family-sharer/static/home',
IMAGE_ROOT = '/static/home/'
))
app.config.from_envvar('FLASKR_SETTINGS', silent=True)
def __init__(self):
self.hashing = Hashing()
self.extensions = set(['png', 'jpg', 'jpeg'])
