def app_settings():
api_secret1 = Settings.query.get('api_secret1')
api_secret2 = Settings.query.get('api_secret2')
if not api_secret1:
api_secret1 = Settings(id='api_secret1', value=generate_password(30))
db.session.add(api_secret1)
try:
db.session.commit()
except IntegrityError:
db.session.rollback()
raise
if not api_secret2:
api_secret2 = Settings(id='api_secret2', value=generate_password(30))
db.session.add(api_secret2)
try:
db.session.commit()
except IntegrityError:
db.session.rollback()
raise
key1 = User.generate_api_key(api_secret1.value)
key2 = User.generate_api_key(api_secret2.value)
return render_template('admin/pages/admin_app_settings.html',
title='App Settings',
key1=key1,
key2=key2)
def create_new_user(first_name, last_name, email, password):
""" Creates a new user and sets up any links database entries. """
new_user = User(first_name, last_name, email, password)
db.session.add(new_user)
db.session.commit()
# link a root storage folder to the user
root_folder = Folder()
db.session.add(root_folder)
db.session.commit()
new_user.storage_root_id = root_folder.id
new_user.storage_root = root_folder
db.session.commit()
# link usage tracking to the user
usage = Usage()
usage.user_id = new_user.id
new_user.usage = usage
db.session.add(usage)
db.session.commit()
# link a billing address to the user
billing_address = BillingAddress()
billing_address.user_id = new_user.id
new_user.billing_address = billing_address
db.session.add(billing_address)
db.session.commit()
# link settings to the User
settings = Settings()
settings.user_id = new_user.id
new_user.settings = settings
db.session.add(settings)
db.session.commit()
def alert_switch():
if request.method == 'GET':
alert_switch_value = Settings.get_alert_switch_value()
return jsonify({'status':'ok', 'alert_switch_value': alert_switch_value})
elif request.method == 'POST':
alert_switch_value = request.form.get('alert_switch_value')
alert_switch_value = (alert_switch_value == 'true')
if not (alert_switch_value is None):
Settings.set_alert_switch_value(alert_switch_value)
return jsonify({'status': 'ok', 'alert_switch_value': alert_switch_value})
def fire_value():
if request.method == 'GET':
fire_value = Settings.get_fire_value()
return jsonify({'status':'ok', 'fire_value': fire_value})
elif request.method == 'POST':
fire_value = request.form.get('fire_value')
if fire_value:
fire_value = float(fire_value)
Settings.set_fire_value(fire_value)
return jsonify({'status': 'ok', 'fire_value': fire_value})
def reset_draft():
settings = Settings.query.all()
is_active = [x.active for x in settings][0]
reset = ResetForm()
if reset.submit.data and reset.validate_on_submit() and is_active == 1:
print("reset validated")
PlayerStatus.reset()
Settings.reset()
PlayerWeeklyStats.reset()
Week.reset()
return redirect('/index')
def statistics(request):
'''
'''
response = json_response()
from app.models import Settings
stats = Settings.get('statistics')
if not stats:
import tasks
tasks.update_statistics()
stats = Settings.get('statistics')
response['data'] = stats
return render_to_json_response(response)
def reset_all():
settings = Settings.query.all()
is_active = [x.active for x in settings][0]
reset_all = ResetAllForm()
if reset_all.submit.data and reset_all.validate_on_submit(
) and is_active == 1:
print("resetall validated")
PlayerStatus.reset()
Settings.reset()
PlayerWeeklyStats.reset()
User.delete_users()
Week.reset()
return redirect('/index')
def update_statistics():
def chunker(iterable, chunksize, filler):
return izip_longest(*[iter(iterable)] * chunksize, fillvalue=filler)
stats = Statistics()
ids = [
i['session_key'] for i in models.SessionData.objects.filter(
level__gte=0).values('session_key')
]
for chunk in chunker(ids, 100, None):
chunk = filter(None, chunk)
for u in models.SessionData.objects.filter(pk__in=chunk):
stats.add(u.json())
Settings.set('statistics', stats)
def signup_user(signup_form):
user = User(
firstname=signup_form.firstname.data,
surname=signup_form.surname.data,
email=signup_form.email.data.lower(),
gender=signup_form.gender.data,
)
user.set_password(signup_form.password.data)
user.set_birthdate(signup_form.day.data, signup_form.month.data,
signup_form.year.data)
username_pattern = signup_form.firstname.data + "." + signup_form.surname.data
user.generate_username(username_pattern)
db.session.add(user)
db.session.commit()
try:
Path(app.config["UPLOAD_FOLDER"], str(user.id),
"profile").mkdir(parents=True)
except FileExistsError as e:
general_logger.error(
f"{user.id} id folder already existed when account "
f"created for {user.email}. {e}")
except Exception as e:
general_logger.error(f"{e} happened for user id: {user.id} and email: "
f"{user.email}")
settings = Settings(user_id=user.id)
db.session.add(settings)
db.session.commit()
def setUpClass(cls):
try:
cls.client = webdriver.Chrome(executable_path=chrome_driver)
except:
pass
if cls.client:
# 创建 app
cls.app = create_app('test')
cls.app_context = cls.app.app_context()
cls.app_context.push()
# 建立数据库
db.create_all()
setting = Settings(
site_admin_email='*****@*****.**',
site_initiated=True,
)
db.session.add(setting)
db.session.commit()
user = User(
name='test_user',
password='******',
email='*****@*****.**'
)
db.session.add(user)
db.session.commit()
cls.host = 'http://localhost:5000'
import logging
logger = logging.getLogger('werkzeug')
logger.setLevel("ERROR")
threading.Thread(target=cls.app.run).start()
def post_setting(request):
try:
org_domain = request.form['org_domain']
organization = Organization.query.filter_by(
org_domain=org_domain).first()
if not organization:
return dict(status='FAIL',
message='That organization does not exist.',
request_args=org_domain,
error='No such organization.')
setting_name = request.form['setting_param']
setting_value = request.form['setting_value']
setting = Settings(setting_name=setting_name,
setting_value=setting_value,
setting_org_id=organization.org_id)
db.session.add(setting)
db.session.commit()
return dict(status='OK',
message='Setting has been added successfully.',
error=None)
except Exception as e:
return dict(status='FAIL',
message='An error has occured.',
error=str(e),
request_args=request.form)
def setup2():
if len(Settings.query.all()) == 0:
form = SetupPasswords()
if form.validate_on_submit():
db.session.add(
User(username='******',
password_hash=generate_password_hash(
form.newPassword.data)))
db.session.add(Settings(name='color1', value='007bff'))
db.session.add(Settings(name='color2', value='6c757d'))
db.session.add(Settings(name='colorBG', value='c0c0c0'))
db.session.add(
Settings(name='institutionName', value='Institution Name'))
db.session.add(
Settings(name='institutionAbbrev',
value='Institution Abbreviation'))
db.session.add(Settings(name='siteName', value='Site Name'))
db.session.add(Settings(name='closed', value='1'))
db.session.add(
Subject(name="Not Applicable", code="N/A", teachers='0'))
db.session.add(Subject(name="English", code="ELA", teachers='0'))
db.session.add(
Subject(name="Social Studies", code="SST", teachers='0'))
db.session.add(Subject(name="Math", code="MAT", teachers='0'))
db.session.add(Subject(name="Science", code="SCN", teachers='0'))
db.session.add(Subject(name="Languages", code="LNG", teachers='0'))
db.session.commit()
return redirect(url_for('adminSettings'))
else:
return redirect(url_for('public'))
return render_template('setup2.html', form=form)
def __create_settings(full_phone_number, request_data):
'''
Creates a settings entry for the user
If there exists a settings entry for that specified effective_at date, we
delete the entry and add the new one
Because we want to maintain a full history of all incomes set, we do not
update any existing entries. Only if there are two with the same effective
date do we delete and re enter
'''
try:
# Checks if there exists an entry with the same effective date
settings_for_effective_date = Settings.query.filter(Settings.effective_at == datetime.strptime(request_data['effectiveAt'], '%Y-%m')).first()
# Checks if settings exist
# If so, we delete the settings from the session
if settings_for_effective_date:
db.session.delete(settings_for_effective_date)
# Once we delete, we then get the user to attach to the settings
user = User.query.filter(User.full_phone_number == full_phone_number).first()
# After we get the user, we make the entry
# and read in from the request data
settings = Settings()
settings.from_dict(request_data, user)
# After getting the entry, we add it to the session
db.session.add(settings)
current_app.logger.info('added settings for {0} to the database session'.format(settings.user))
# Commits the user to the database and logs that is has been commited
db.session.commit()
current_app.logger.info('commited settings to the database session')
# Returns the response with status code 201 to indicate the user has been created
return error_response(201)
except Exception as e:
# Logs the exception that has been raised and rolls back all the changes made
current_app.logger.fatal(str(e))
db.session.rollback()
# Returns a 500 response (Internal Server Error)
raise
def add_setting():
key = flask.request.json["key"]
value = flask.request.json["value"]
new_setting = Settings(key=key, value=value)
db.session.add(new_setting)
db.session.commit()
return setting_schema.jsonify(new_setting)
def reset_api_key(key_name):
api_secret = Settings.query.get(key_name)
if not api_secret:
api_secret = Settings(id=key_name, value=generate_password(30))
db.session.add(api_secret)
try:
db.session.commit()
except IntegrityError:
db.session.rollback()
raise
else:
api_secret.value = generate_password(30)
db.session.add(api_secret)
try:
db.session.commit()
except IntegrityError:
db.session.rollback()
raise
return User.generate_api_key(api_secret.value)
def load_settings():
settings = {}
fire_value = None
try:
fire_value = Settings.get_fire_value()
except:
pass
settings['fire_value'] = fire_value
should_alarm = False
try:
should_alarm = Settings.get_alert_switch_value()
except:
pass
settings['should_alarm'] = should_alarm
dev_port = app.config.get('DEV_PORT')
if dev_port:
settings['dev_port'] = dev_port
app.logger.info(settings)
return settings
def post(self):
"""Create new game"""
schema = GameSchema()
game = schema.load(request.json)
settings = SettingsService.initialize(Settings())
settings.game = game
state = StateService.generate_state(State())
game.states.append(state)
db.session.add(game)
db.session.add(settings)
db.session.add(state)
db.session.commit()
return {"msg": "game created", "game": schema.dump(game)}, 201
def init_app():
app.logger.debug("Running pre-init...")
overwrite_init_db = False
app_version = "0.1"
if not AppInfo.query.all() or not Settings.query.all(
) or overwrite_init_db:
db.session.add(AppInfo(key="app_version", value=app_version))
launch_date = str(datetime.utcnow())
db.session.add(AppInfo(key="first_launch_date", value=launch_date))
app.logger.debug("First launch date set to: %s", launch_date)
default_timezone = "America/New_York"
db.session.add(Settings(key="timezone", value=default_timezone))
app.logger.debug("Default timezone set to: %s" % default_timezone)
db.session.commit()
app.logger.debug("Database initialized")
else:
app.logger.debug("Database already initialized (%s)" % app_version)
def userSettings():
form = UserSettings()
dictSettings = {
"emailNotifications": form.emailNotifications.data,
"smsNotifications": form.smsNotifications.data
}
settings = Settings(emailNotifications=form.emailNotifications.data,
smsNotifications=form.smsNotifications.data)
if form.validate_on_submit():
db.session.add(settings)
db.session.commit()
flash("Options Saved.")
return render_template('userSettings.html',
settings=settings,
form=form,
dictSettings=dictSettings)
return render_template('userSettings.html',
settings=settings,
form=form,
dictSettings=dictSettings)
from app import db
from sqlalchemy.exc import IntegrityError
db.create_all()
models = []
models.append(MinerModel(model='L3+', chips='72,72,72,72', temp_keys='temp2_', description='Litecoin Miner 504 MH/s'))
models.append(MinerModel(model='S7', chips='45,45,45', temp_keys='temp', description='Bitcoin Miner 4.5 TH/s'))
models.append(MinerModel(model='S9', chips='63,63,63', temp_keys='temp2_', description='Bitcoin Miner 13.5 TH/s'))
models.append(MinerModel(model='D3', chips='60,60,60', temp_keys='temp2_', description='DASH Miner 17 GH/s'))
models.append(MinerModel(model='T9', chips='57,57,57', temp_keys='temp2_', description='Bitcoin Miner 12.5 TH/s'))
models.append(MinerModel(model='A3', chips='60,60,60', temp_keys='temp2_', description='Siacoin Miner 815 GH/s'))
models.append(MinerModel(model='L3', chips='36,36,36,36', temp_keys='temp2_', description='Litecoin Miner 250 MH/s'))
models.append(MinerModel(model='R4', chips='63,63', temp_keys='temp2_', description='Bitcoin Miner 8 TH/s'))
models.append(MinerModel(model='V9', chips='45,45,45', temp_keys='temp2_', description='Bitcoin Miner 4 TH/s'))
settings = []
settings.append(Settings(name="temperature_alert", value="80", description=""))
settings.append(Settings(name="email_alert", value="True", description="Whether to send an email on alert"))
try:
for model in models:
db.session.add(model)
db.session.commit()
for setting in settings:
db.session.add(setting)
db.session.commit()
except IntegrityError:
print("[INFO] Database already exists.")
else:
print("[INFO] Database successfully created.")
def run():
app = create_app("debug")
with app.app_context():
target_dir = os.path.abspath(os.path.join(BASE_DIR, 'database/backup'))
database = read_json(target_dir)
settings_data = database.get('Settings')
users_data = database.get('User')
posts_data = database.get('Post')
tags_data = database.get('Tag')
categories_data = database.get('Category')
tasks_data = database.get('Task')
flows_data = database.get('Flow')
if settings_data:
for setting in settings_data:
sett = Settings(
_site_admin_email=setting.get('site_admin_email'),
_site_initiated=setting.get('site_initiated') in TRUE,
_enable_post_comment=setting.get('enable_post_comment')
in TRUE,
_posts_per_page=setting.get('posts_per_page'),
_show_abstract=setting.get('show_abstract'),
_comments_per_page=setting.get('comments_per_page'),
_site_title=setting.get('site_title'),
_site_description=setting.get('site_description'),
_disqus_identifier=setting.get('disqus_identifier'),
_google_analytics_code=setting.get(
'google_analytics_code'),
)
db.session.add(sett)
if users_data:
for user in users_data:
u = User(_email=user.get("email"),
_name=user.get("name"),
_is_administrator=user.get("is_administrator"),
_password_hash=user.get("password_hash"))
db.session.add(u)
if posts_data:
for post in posts_data:
po = Post(
_type=post.get('type'),
_main_id=post.get('main_id'),
_title=post.get('title'),
_link=post.get('link'),
_publish_date=datetime.strptime(post.get('publish_date'),
"%Y-%m-%d %H:%M:%S")
if post.get('publish_date') else None,
_edit_date=datetime.strptime(post.get('edit_date'),
"%Y-%m-%d %H:%M:%S"),
_content=post.get('content'),
_abstract=post.get('abstract'),
_commendable=post.get('commendable'),
_public=post.get('public'),
_category=post.get('category'),
_tags=post.get('tags'),
)
db.session.add(po)
if users_data:
for tag in tags_data:
t = Tag(
_name=tag.get('name'),
_link=tag.get('link'),
_posts_count=tag.get('posts_count', 0),
)
db.session.add(t)
if categories_data:
for category in categories_data:
c = Category(
_name=category.get('name'),
_link=category.get('link'),
_level=category.get('level'),
_order=category.get('order'),
_posts_count=category.get('posts_count', 0),
)
db.session.add(c)
if tasks_data:
for task in tasks_data:
t = Task(
_text=task.get('text'),
_level=task.get('level'),
_status=task.get('status'),
_start=datetime.strptime(task.get('start'),
"%Y-%m-%d %H:%M:%S"),
_finish=datetime.strptime(task.get('finish'),
"%Y-%m-%d %H:%M:%S")
if task.get('finish') else None,
_idea=task.get('idea', db.Text),
_flow_index=task.get('flow_index'),
_flow_order=task.get('flow_order'),
)
db.session.add(t)
if flows_data:
for flow in flows_data:
f = Flow(_text=flow.get('text'),
_task=flow.get('task'),
_fake_id=flow.get('fake_id'))
db.session.add(f)
db.session.commit()
def upgrade(self, settings):
for i in settings:
if i in self:
param = Settings.query.get(i)
if param is None:
param = Settings()
param.init(i,self[i].data)
db.session.add(param)
db.session.commit()
else:
param.value = self[i].data
Settings.update(param)
else:
param = Settings()
param.init(i,self[i].data)
db.session.add(param)
db.session.commit()
if not self['key'].data:
param = Settings.query.get('key')
param.value = 0
Settings.update(param)
if not self['emoney'].data:
param = Settings.query.get('emoney')
param.value = 0
Settings.update(param)
if not self['pdel'].data:
param = Settings.query.get('pdel')
param.value = 0
Settings.update(param)
return True
def upgrade(self, settings):
for i in settings:
if i in self:
param = Settings.query.get(i)
if param is None:
param = Settings()
param.init(i, self[i].data)
db.session.add(param)
db.session.commit()
else:
param.value = self[i].data
Settings.update(param)
else:
param = Settings()
param.init(i, self[i].data)
db.session.add(param)
db.session.commit()
if not self['key'].data:
param = Settings.query.get('key')
param.value = 0
Settings.update(param)
if not self['emoney'].data:
param = Settings.query.get('emoney')
param.value = 0
Settings.update(param)
if not self['pdel'].data:
param = Settings.query.get('pdel')
param.value = 0
Settings.update(param)
return True
def settings():
users = Notification.get_all_recievers()
fire_value = Settings.get_fire_value()
alert = Settings.get_alert_switch_value()
return render_template('settings.html', users=users, fire_value=fire_value, alert=alert)
def index(request):
initSettingsStatus()
if not request.user.is_authenticated:
return redirect('login')
if (not Settings.objects.filter(setting="tiempoMaximo")):
s = Settings(setting="tiempoMaximo", value="60")
s.save()
if (not Settings.objects.filter(setting="tiempoConsulta")):
s = Settings(setting="tiempoConsulta", value="30")
s.save()
if (not Settings.objects.filter(setting="tiempoLlega")):
s = Settings(setting="tiempoLlega", value="30")
s.save()
post = request.POST
cookies = request.COOKIES
if (cookies and 'tiempoMaximo' in cookies):
maxT = cookies.get("tiempoMaximo")
else:
maxT = Settings.objects.get(setting="tiempoMaximo").value
if (cookies and 'tiempoConsulta' in cookies):
consT = cookies.get("tiempoConsulta")
else:
consT = Settings.objects.get(setting="tiempoConsulta").value
if (cookies and "tiempoLlega" in cookies):
tiempoL = cookies.get("tiempoLlega")
else:
tiempoL = Settings.objects.get(setting="tiempoLlega").value
if (post):
tiempoMax = post.get("tiempoTransporte", None)
tiempoCons = post.get("tiempoConsulta", None)
tiempoLlega = post.get("tiempoLlega", None)
radioCargado = post.get("optionsRadios", None)
radioMatrix = radioCargado
if (radioCargado):
if (radioCargado == "option1"):
lineas = load.cargarMutualistas(request)
elif (radioCargado == "option2"):
lineas = load.cargarIndividuoAnclas(request)
elif (radioMatrix == "option3"):
lineas = load.cargarTiempos(1, request)
elif (radioMatrix == "option4"):
lineas = load.cargarTiempos(0, request)
elif (radioMatrix == "option5"):
lineas = load.cargarCentroPediatras(request)
elif (radioMatrix == "option6"): # omnibus
lineas = load.cargarTiemposBus(request)
elif (radioMatrix == "option7"):
lineas = load.cargarTiposTransporte(request)
elif (radioMatrix == 'option10'):
lineas = load.loadShapes(request, 1)
elif (radioMatrix == 'option11'):
lineas = load.loadShapes(request, 2)
elif (radioMatrix == 'option12'):
lineas = load.loadShapes(request, 0)
if lineas is not None:
pseudo_buffer = utils.Echo()
writer = csv.writer(pseudo_buffer)
response = StreamingHttpResponse(
(writer.writerow(row) for row in lineas),
content_type="text/csv")
response[
'Content-Disposition'] = 'attachment; filename="errores.csv"'
return response
if (tiempoMax):
maxT = tiempoMax
if (tiempoCons):
consT = tiempoCons
if (tiempoLlega):
tiempoL = tiempoLlega
ejecutarForm = EjecutarForm()
ejecutarHelper = EjecutarHelper()
simularForm = SimularForm()
simularHelper = SimularHelper()
username = request.user.username
try:
statusAuto = int(Settings.objects.get(setting='shapeAutoStatus').value)
except:
statusAuto = -1
try:
statusCaminando = int(
Settings.objects.get(setting='shapeCaminandoStatus').value)
except:
statusCaminando = -1
try:
statusBus = int(Settings.objects.get(setting='shapeBusStatus').value)
except:
statusBus = -1
statuses = {
0:
int(Settings.objects.get(setting='statusMatrizAuto').value),
1:
int(Settings.objects.get(setting='statusMatrizCaminando').value),
2:
int(Settings.objects.get(setting='statusMatrizBus').value),
3:
int(Settings.objects.get(setting='statusMatrizIndividuo').value),
4:
int(Settings.objects.get(setting='statusMatrizCentro').value),
5:
int(
Settings.objects.get(
setting='statusMatrizIndividuoTiempoCentro').value),
6:
TipoTransporte.objects.count(),
7:
Prestador.objects.count(),
10:
statusAuto,
12:
statusCaminando,
11:
statusBus,
8:
int(request.session.get('calculationStatus', -1))
}
context = {
'tiempoMaximo': maxT,
'tiempoConsulta': consT,
"tiempoLlega": tiempoL,
'simularForm': simularForm,
'simularHelper': simularHelper,
'ejecutarForm': ejecutarForm,
'ejecutarHelper': ejecutarHelper,
'username': username,
'statuses': statuses
}
response = render(request, 'app/index.html', context)
response.set_cookie(key='tiempoMaximo', value=maxT)
response.set_cookie(key='tiempoConsulta', value=consT)
response.set_cookie(key='tiempoLlega', value=tiempoL)
return response
settings = {}
fire_value = None
try:
fire_value = Settings.get_fire_value()
except:
pass
settings['fire_value'] = fire_value
should_alarm = False
try:
should_alarm = Settings.get_alert_switch_value()
except:
pass
settings['should_alarm'] = should_alarm
dev_port = app.config.get('DEV_PORT')
if dev_port:
settings['dev_port'] = dev_port
app.logger.info(settings)
return settings
if __name__ == '__main__':
settings = load_settings()
moss = Temperature(**settings)
Settings.on_change(lambda: moss.set_settings(**load_settings()))
moss.setDaemon(True)
moss.start()
app.run(host='0.0.0.0', port=9527, use_reloader=False)