def _archives():
rpm = flask.Blueprint("archives", __name__)
AutoIndex(rpm,
browse_root=path.join(
self.app_repo_config.artifacts_directory,
'archives'))
self.register_blueprint(rpm, url_prefix="/archives")
def main():
config = configparser.ConfigParser()
# INI file validation.
try:
with open('log_access.ini') as f:
config.read('log_access.ini')
except IOError:
print("log_access.ini doesn't exist. Hence taking a default dict."
" with path : /var/log/redant and port : 5000")
config = {"serverdata": {"path": "/var/log/redant", "port": 5000}}
# Path extraction and validation.
try:
ppath = config['serverdata']['path']
except Exception as KeyError:
print("Key error in path. Defaulting to /var/log/redant as log path.")
ppath = "/var/log/redant"
# Port extraction and validation.
try:
fport = int(config['serverdata']['port'])
except Exception as KeyError:
print("Key error in port. Defaulting to 5000.")
fport = 5000
except Exception as ValueError:
print("Value error in port. Defaulting to 5000.")
fport = 5000
app = Flask(__name__)
AutoIndex(app, browse_root=ppath)
app.run(host='0.0.0.0', port=fport)
def _ova_updates():
ova = flask.Blueprint("ova", __name__)
AutoIndex(ova,
browse_root=path.join(
self.app_repo_config.artifacts_directory, 'ova',
'updates'))
self.register_blueprint(ova, url_prefix="/ova")
def start_server(port, directory):
print("Starting server normal")
# output_file.write("Starting server normal")
os.chdir(directory)
app = Flask("Files")
AutoIndex(app, browse_root=os.path.curdir)
port = int(port)
try:
app.run(port=port)
finally:
print("Closing Server")
class cdn :
app = Flask(__name__)
AutoIndex(app, browse_root=os.path.curdir)
@app.route('/list')
def list():
r=[]
f=[os.path.join(dirpath, f)
for dirpath, dirnames, files in os.walk(os.getcwd())
for f in files]
for i in range(-1,len(f)-1) :
s=str(f[i]).replace(str(os.getcwd()),'')
s=s.replace('\\','/')
r.append(s[1:len(s)])
return str(r)
def start_server_tor(port, directory, output_fileer):
print("Starting server TOR")
os.chdir(directory)
app = Flask(__name__)
AutoIndex(app, browse_root=os.path.curdir)
print('Connecting to tor')
with Controller.from_port() as controller:
controller.authenticate()
response = controller.create_ephemeral_hidden_service(
{80: 5000}, await_publication=True)
print("%s.onion" % response.service_id)
output_fileer = str(output_fileer)
output_fileer = output_fileer.replace("\\\\", "/")
print(output_fileer)
temp = open(output_fileer, "w")
temp.write("%s.onion" % response.service_id)
temp.close()
try:
app.run()
finally:
print("Stopping server")
database = databases.Database(DATABASE_URL)
user_db = fastusr.db.SQLAlchemyUserDatabase(user_db_model=mdl.UserDB,
database=database,
users=base.UserTable.__table__)
jwt_authentication = fastusr.authentication.JWTAuthentication(
secret=SECRET, lifetime_seconds=28800, tokenUrl='/auth/jwt/login')
api_users = fastusr.FastAPIUsers(db=user_db,
auth_backends=[jwt_authentication],
user_model=mdl.User,
user_create_model=mdl.UserCreate,
user_update_model=mdl.UserUpdate,
user_db_model=mdl.UserDB)
# Flask AutoIndex module for exploring directories
flask_app = Flask(__name__)
AutoIndex(flask_app, browse_root=RESULTS_DIR)
app.mount('/index', WSGIMiddleware(flask_app))
@app.on_event("startup")
async def startup():
await database.connect()
@app.on_event("shutdown")
async def shutdown():
await database.disconnect()
@app.get('/')
async def root():
from flask import Flask, request, jsonify
from flask_autoindex import AutoIndex
from exception import ValueBadRequest, JSONExceptionHandler
from werkzeug.utils import secure_filename
from checksum import ck
app = Flask(__name__)
AutoIndex(app, browse_root='./data')
JSONExceptionHandler(app)
cache = {'crc32': {}, 'sha1': {}, 'md5': {}}
@app.route('/checksum', methods=['GET'], strict_slashes=False)
def checksum():
mode = request.args.get('mode')
filename = request.args.get('filename')
checksum_user = request.args.get('checksum')
if mode is None:
raise ValueBadRequest('mode')
if filename is None:
raise ValueBadRequest('filename')
if checksum_user is None:
raise ValueBadRequest('checksum')
if cache[mode].get(filename) is None:
cache[mode][filename] = ck('./data/{}'.format(filename), mode)
checksum_server = cache[mode][filename]
from flask_autoindex import AutoIndex
from flask_restful import Api
import logging
import platform
import os.path
import sys
env = Environment()
# prepare the RESTful application
# prepare static webserver
# set the project root directory as the static folder, you can set others.
app = Flask(__name__,
static_url_path='',
static_folder=str(env.projectPath) + '/web')
files_index = AutoIndex(app, browse_root=env.games, add_url_rules=False)
api = Api(app)
# app.logger.addHandler(logging.StreamHandler(STDOUT))
app.logger.setLevel(logging.INFO)
if WebApp.debug:
app.logger.setLevel(logging.DEBUG)
app.logger.info("python src folder is %s" % (env.scriptPath))
# check if we are running on a raspberry PI
app.logger.info("Running on %s" % (platform.system()))
# https://raspberrypi.stackexchange.com/questions/5100/detect-that-a-python-program-is-running-on-the-pi
if platform.system() == 'Linux' and os.path.exists(
'/sys/firmware/devicetree/base/model'):
app.logger.info("Running on Raspberry PI")
import os
import tarfile
from flask import Flask, request, flash, redirect, render_template
from flask import Blueprint
from flask_autoindex import AutoIndex
import shutil
from werkzeug.utils import secure_filename
app = Flask(__name__)
app.config.from_object('tarhosting.config')
app.secret_key = app.config['SECRET_KEY']
auto_index = AutoIndex(app,
browse_root=app.config['STATIC_DIR'],
add_url_rules=False)
@app.route("/")
def index():
return render_template('index.html', URL=request.url)
@app.route('/browse')
@app.route('/browse/')
@app.route('/browse/<path:path>')
def autoindex(path='.'):
return auto_index.render_autoindex(path)
@app.route('/deploy/<path:name>', methods=['POST'])
def deploy(name):
from flask import *
from flask_autoindex import AutoIndex
from werkzeug.utils import secure_filename
import os, json
with open('backend/path.json', 'r') as f:
k = json.loads(f.read())
UPLOAD_FOLDER = k['path']
# pls change this, thanks!
ALLOWED_EXTENSIONS = {'txt', 'pdf', 'png', 'jpg', 'jpeg', 'gif'}
app = Flask(__name__)
AutoIndex(app, browse_root=UPLOAD_FOLDER)
app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
app.secret_key = 'super secret key'
app.config['SESSION_TYPE'] = 'filesystem'
def allowed_file(filename):
return '.' in filename and \
filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
@app.route('/upload', methods=['GET', 'POST'])
def upload_file():
x = request.args.get('path')
if request.method == 'POST':
# check if the post request has the file part
if 'file' not in request.files:
flash('No file part')
return redirect(request.url)
import os.path
from flask import Flask
from flask_autoindex import AutoIndex
app = Flask(__name__)
AutoIndex(app, browse_root=os.path.curdir + "/output")
if __name__ == '__main__':
app.run(host='0.0.0.0', port=80)
#!/usr/bin/env python3
from subprocess import Popen, PIPE
from functools import wraps
import requests
import atexit
from flask import Flask, render_template, request, jsonify, escape
from flask_autoindex import AutoIndex
import giphypop
from music_backend import sched
from deezer import deezer_search, start_deezer_keepalive, stop_deezer_keepalive, is_deezer_session_valid
from configuration import config
app = Flask(__name__)
auto_index = AutoIndex(app,
config["download_dirs"]["base"],
add_url_rules=False)
auto_index.add_icon_rule('music.png', ext='m3u8')
giphy = giphypop.Giphy()
# user input validation
def validate_schema(*parameters_to_check):
def decorator(f):
@wraps(f)
def wrapper(*args, **kw):
j = request.get_json(force=True)
print("User request: {} with {}".format(request.path, j))
# check if all parameters are supplied by the user
if set(j.keys()) != set(parameters_to_check):
WHERE filename = ?'''
cur = conn.cursor()
cur.execute(sql, comic)
conn.commit()
def init_db():
sql = '''CREATE TABLE comics(filename TEXT,status INT,page INT)'''
conn = create_connection(db_file)
cur = conn.cursor()
cur.execute(sql)
conn.commit()
ppath = "/comics/" # update your own parent directory here
files_index = AutoIndex(app, ppath, add_url_rules=False)
files_index.add_icon_rule('contrast.png', rule=is_comic_reading)
files_index.add_icon_rule('tick.png', rule=is_comic_read)
db_file = r"/usr/src/app/sqlite.db"
@app.route('/')
@app.route('/index')
def index():
if not os.path.isfile(db_file):
init_db()
# TODO : List currently reading comics
return render_template('index.html', comics=get_reading_comics())
@app.route('/update_path')
def _python():
rpm = flask.Blueprint("python", __name__)
AutoIndex(rpm,
browse_root=path.join(
self.app_repo_config.artifacts_directory, 'python'))
self.register_blueprint(rpm, url_prefix="/python")
import os.path
from flask import Flask, escape, request, send_from_directory
from flask_autoindex import AutoIndex
from environs import Env
import subprocess
import demjson
import requests
import tempfile
import json
from flask_cors import CORS
env = Env()
env.read_env()
app = Flask(__name__)
CORS(app)
AutoIndex(app, browse_root=os.path.curdir)
def form_to_ini(form):
"""Take the form submitted and convert it to an INI file."""
ini_dict = {}
for k in form.keys():
v = form[k]
sec_key = k.split(':')
if len(sec_key) != 2:
continue
if not sec_key[0] in ini_dict:
ini_dict[sec_key[0]] = {sec_key[1]: v}
else:
ini_dict[sec_key[0]][sec_key[1]] = v
#!/usr/bin/python3
import json, os, yaml, time, sys
from flask import Flask, render_template
from flask_autoindex import AutoIndex
start_time = time.time()
with open("settings.yml", "r") as file:
settings = yaml.load(file, Loader=yaml.FullLoader)
app = Flask(__name__)
AutoIndex(app,browse_root=settings['files_path'])
@app.errorhandler(404)
def page_not_found(e):
return render_template('404.html', 404)
if settings['status_path'] != "OFF":
@app.route(settings['status_path'])
def status():
return render_template("status.html", version=settings['version'], uptime=time.time()-start_time)
if __name__ == "__main__":
app.run()
from flask import render_template, flash, redirect, url_for, request
from flask_login import login_user, logout_user, current_user, login_required
from werkzeug.urls import url_parse
from app import app, db
from app.forms import LoginForm, RegistrationForm
from app.models import User
import os
import os.path
from flask_autoindex import AutoIndex
files_index = AutoIndex(app,
os.path.curdir + '/app/zapis',
add_url_rules=False)
@app.route('/asd')
@app.route('/asd <path:path>')
def autoindex(path='.'):
return files_index.render_autoindex(path)
@app.route('/')
@app.route('/index')
@login_required
def index():
posts = [{
'author': {
'username': '******'
},
'body': 'Beautiful day in Portland!'
}, {
last_name='toilet',
email='*****@*****.**',
password='******',
is_authenticated='False')
db.session.add(user)
db.session.add(admin)
db.session.commit()
print('Database seeded.')
# db_create()
# db_seed()
# db_drop()
files_index = AutoIndex(app, browse_root=os.path.curdir, add_url_rules=False)
# Custom indexing
@app.route('/dir')
@app.route('/dir/<path:path>')
def autoindex(path='.'):
return files_index.render_autoindex(path)
@app.errorhandler(404)
def page_not_found(error):
print(basedir)
template = '''
<h1>That page doesn't exist.</h1>
<h3>%s Not found</h3>''' % (urllib.parse.unquote(request.url))
# ----------------------------------------------------------------#
# file serving related
# defining the root folder to allow looking
# just into it
root1 = get_config("base_path")
#------------------------------------------------------------------#
# FLASK related
#-------------------------------------------------#
# creating app
app = Flask(__name__)
# allowing different origins to communicate with it
cors = CORS(app, resources={r"/*": {"origins": "*"}})
AutoIndex(app, browse_root=root1)
#-------------------------------------------------#
# route to VIEW docs and folders in the shared folder
@app.route("/docs_view/", methods=["GET"])
@app.route('/docs_view/<path:path>', methods=["GET"])
def get_dir(**kwargs):
# using **kwargs allows having any argument with any name
# also allows having no arguments (needed to access most
# exterior folder)
# creating a list of the args given (only 1 or 0 in this case)
# to use them later on as path
relative_path = list(kwargs.items())
from sqlalchemy.orm.exc import NoResultFound
from sqlalchemy import or_
import main
import config
import lgogdaemon
import models
from models import Game, User, LoginStatus, Status, Session
app = main.app
download_scheduler = ThreadPoolExecutor(max_workers=2)
update_scheduler = ThreadPoolExecutor(max_workers=2)
# Create instance of AutoIndex used to display contents of game download
# directory. Explicitely disable add_url_rules as it would define some default
# routes for "/"
index = AutoIndex(app, config.lgog_library, add_url_rules=False)
# Define logger handlers and start update timer
if not app.debug or os.environ.get("WERKZEUG_RUN_MAIN") == "true":
_session = Session()
app.logger.info("Initialize lgogwebui ...")
app.logger.info(sys.version)
# Make sure that the database exists
models.Base.metadata.create_all(models.ENGINE)
# Make sure that login state exists in the DB
try:
_user = _session.query(User).one()
except NoResultFound:
_user = User()
_session.add(_user)
_session.commit()
return ""
################################################################################
# state: import new documents
@app.route("/state")
def state():
imp()
f = open(dir + "/Scan/state", "r")
state = f.read()
f.close()
state = state.strip()
if state != "":
state = state + "<br/><br />"
return state
################################################################################
@app.route('/')
@app.route('/index.html')
def index():
return render_template('index.html')
################################################################################
AutoIndex(app, browse_root=dir)
if __name__ == '__main__':
app.debug = True
app.run(host='0.0.0.0', port=5000)
help="Sets the path for the Private Key",
default="privkey.key")
args = parser.parse_args()
UPLOAD_FOLDER = args.folder
app = Flask(__name__, static_url_path=UPLOAD_FOLDER)
app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
app.secret_key = 'super secret key'
app.config['SESSION_TYPE'] = 'filesystem'
if args.ssl:
context = ssl.SSLContext()
context.load_cert_chain(args.fullchain, args.privkey)
AutoIndex(app, browse_root=app.config['UPLOAD_FOLDER'])
logging.basicConfig(filename='filebrowser.log', level=logging.DEBUG)
log = logging.getLogger('pydrop')
@app.route("/", defaults={'path': ''}, methods=['GET', 'POST'])
@app.route('/<path:path>', methods=['GET', 'POST'])
def index(path):
if request.method == 'POST':
if request.files['file'].filename != '':
file = request.files['file']
save_path = os.path.join(
os.path.join(app.config['UPLOAD_FOLDER'], path),
secure_filename(file.filename))
current_chunk = int(request.form['dzchunkindex'])
from flask import *
from . import login_manager
from .models import db, User
from flask_autoindex import AutoIndex
import json
# Blueprint configuration.
main_bp = Blueprint('main_bp',
__name__,
template_folder='templates',
static_folder='static')
# assets config - locally uploaded.
assets_files_index = AutoIndex(
main_bp, 'flask_internals/', add_url_rules=False)
@main_bp.route('/<path:path>')
def autoindex(path='.'):
"""
Serving /css, images/, and /js paths
"""
return assets_files_index.render_autoindex('static/assets/' + path)
@main_bp.route('/')
@main_bp.route('/index.html')
def load_index():
return render_template('index.html')
def index():
AutoIndex(horse, browse_root=os.path.curdir + 'Engineering')
def _deb():
deb = flask.Blueprint("deb", __name__)
AutoIndex(deb,
browse_root=path.join(
self.app_repo_config.artifacts_directory, 'deb'))
self.register_blueprint(deb, url_prefix="/deb")
try:
parse = reqparse.RequestParser()
parse.add_argument('file',
type=werkzeug.datastructures.FileStorage,
location='files')
args = parse.parse_args()
image_file = args['file']
image_file.save("files/name.jpg")
return "Uploaded", 200
except:
return "Some error", 401
def get(self):
return "F**K YOU", 200
def delete(self):
return "F**K YOU", 200
def put(self):
return "F**K YOU", 200
api.add_resource(User, "/api/user/<string:name>")
api.add_resource(Download, "/api/download/<string:name>")
api.add_resource(Upload, '/api/upload/')
AutoIndex(app)
# app.run(host='0.0.0.0', port=5000, debug=True, threaded=True)
if __name__ == "main":
app.run()
# Create flask app
application = Flask(__name__, static_folder="static")
# Load the default configuration
application.config.from_object("config.DefaultConfig")
# Define the database object which is imported
# by modules and controllers
db = SQLAlchemy(application)
# Authetication scheme
auth = HTTPTokenAuth(scheme="Token")
# Listing reports directory
autoindex = AutoIndex(application,
browse_root=Files.REPORTS_FOLDER,
add_url_rules=False)
@auth.verify_token
def verify_token(token):
"""
Verify token for authentication
:param token: Token used by client
:return: Boolean
"""
if token in AppTokens.tokens:
g.current_user = AppTokens.tokens[token]
return True
return False
import os.path
from flask import Flask
from flask_autoindex import AutoIndex
app = Flask(__name__)
AutoIndex(app, browse_root='/home/pi/Desktop/surveillance/images')
if __name__ == '__main__':
app.run(host='0.0.0.0', port=80)
def _directory_index():
packages = flask.Blueprint("packages", __name__)
AutoIndex(packages,
browse_root=self.app_repo_config.packages_directory)
self.register_blueprint(packages, url_prefix="/packages")
