def create_project():
if request.method == 'POST':
newname = request.form.get('projectname', 'New project')
newkeywords = request.form.get('keywords', None)
newfollowers = request.form.get('followers', None)
newtweetslimit = request.form.get('tweetslimit', None)
newtweetsperyear = request.form.get('tweetsperyear', None)
newnotweetsfor = request.form.get('notweetsfor', None)
newlocation = request.form.get('location', None)
newexclude = request.form.get('exclude', False)
newproject = Project(name=newname)
db.session.add(newproject)
db.session.commit()
newsettings = Settings(project_id=newproject.id,
include_keywords=newkeywords,
exclude=newexclude,
followers=newfollowers,
tweets=newtweetslimit,
tweetsperyear=newtweetsperyear,
notweetsfor=newnotweetsfor,
fromcountries=newlocation)
db.session.add(newsettings)
db.session.commit()
flash('New project created', category='success')
return redirect(url_for('index'))
else:
return render_template('parameters.html', action='new')
def startup():
# db initializations
db.create_all()
settings = Settings(secret_key=pyotp.random_base32())
db.session.add(settings)
db.session.commit()
def thewarbase():
db_query = Settings.query.order_by(Settings.WarbaseFaction).first()
the_id = "No faction stored" if not db_query else db_query.WarbaseFaction
the_form = FactionIDForm(obj=db_query, WarbaseFaction=the_id)
get_members = WarBase.query.order_by(WarBase.Level.desc()).all()
if request.method == "POST":
if the_form.validate_on_submit():
try:
get_input = request.form['WarbaseFaction']
if not db_query:
form = Settings(WarbaseFaction=get_input)
db_session.add(form)
db_session.commit()
flash('Saved successfully, you may now hit update.', 'success')
if db_query:
if str(db_query.WarbaseFaction) != str(get_input):
db_query.WarbaseFaction = get_input
all_mems = WarBase.query.order_by(WarBase.Level.desc()).all()
for person in all_mems:
db_session.delete(person)
db_session.commit()
get_members = WarBase.query.order_by(WarBase.Level.desc()).all()
flash('Saved successfully, you may now hit update.', 'success')
else:
flash(f'{get_input} is already the faction saved, hit update.', 'danger')
except Exception as e:
db_session.rollback()
flash(f'Error updating faction {e}.', 'danger')
return render_template('warbase.html', members=get_members, form=the_form)
return render_template('warbase.html', members=get_members, form=the_form)
if request.method == "GET":
return render_template('warbase.html', members=get_members, form=the_form)
def edit_settings(request):
settings = Settings(Dbus.get_temperature_settings(),
Dbus.get_manual_mode())
if not request.POST:
return _get_settings(request, settings)
else:
return _edit_settings(request, settings)
def register(request):
if request.GET.get('username'):
username = request.GET['username']
password = request.GET['password1']
email = request.GET['email']
data = {}
if User.objects.filter(username=username):
data['invalid_user'] = True
if User.objects.filter(email=email):
data['invalid_email'] = True
if (not data.get('invalid_user') and (not data.get('invalid_email'))):
user = User.objects.create_user(username, request.GET['email'],
password)
user.save()
sett = Settings()
sett.usuario = user
sett.clave = "tooltips"
sett.valor = "true"
sett.save()
user = authenticate(username=username, password=password)
if user is not None:
if user.is_active:
djlogin(request, user)
data['user'] = username
return js(data)
return render_to_response('registrar.html',
context_instance=RequestContext(request))
def __init__(self, id):
self.id = id
self.tables = BTree()
self.messages = BTree()
self.clients = BTree()
self.network = Network()
self.settings = Settings(self.id)
def txn(): settings = Settings(key_name=config.SETTINGS_KEY, auth_key=d['auth_key'], default_subject=d['default_subject'], default_sender=d['default_sender'], allowed_ips=d['allowed_ips']) settings.put()
def runProcess():
jar = cookielib.CookieJar()
u = get("https://www.rbi.org.in/Scripts/bs_viewcontent.aspx?Id=2009", cookies=jar)
pattern = re.compile(r'<th>.*as on\s(.*)</th>')
dateString = pattern.findall(u.content)[0]
rbiLastModifiedDate = datetime.strptime(dateString.strip(), '%B %d, %Y')
if(Settings.objects(settingsID="datesettings").first()):
settings = Settings.objects.get(settingsID="datesettings")
if rbiLastModifiedDate > settings.lastUpdated:
print ("Data modified in rbi website.\nDownloading new data..")
settings.lastUpdated = rbiLastModifiedDate
settings.save()
#Download files from rbi and save to xls/
downloadFiles()
#Parse details from xls files and insert into mongodb
parseFiles()
else:
print ("Data is up to date.\n")
else:
print ("Running for the first time.")
settings = Settings()
settings.lastUpdated = rbiLastModifiedDate
settings.yomLastFetched = rbiLastModifiedDate
settings.save()
downloadFiles()
parseFiles()
return True
async def announce_time(self, msg, time: int = None):
try:
# Make sure we receive a positive number
if int(time) < 1:
raise ValueError
self.delay = int(time)
updated = session.query(Settings).filter(Settings.key == "announcement_delay").update({"value": self.delay})
if not updated:
# Insert if it wasn't updated, because it didn't exist.
insert = Settings(key="announcement_delay", value=self.delay)
session.add(insert)
session.commit()
self.restart_task()
await msg.reply(f"{bot.msg_prefix}New announce time is {time} seconds")
except ValueError:
await msg.reply(f"{bot.msg_prefix}Invalid time, please use an integer in seconds")
except TypeError:
await msg.reply(f"{bot.msg_prefix} Current announce time is {self.delay} seconds.")
except Exception as e:
print(type(e), e)
def post(self):
try:
delete = str(self.request.get('delete'))
if delete == "I wish to delete all records":
all_keys = StudentGradesModel.get_all_keys()
for a in all_keys:
a.key.delete()
return self.redirect('/admin?message=' + 'RECORDS DELETED')
quarter = int(self.request.get('quarter'))
year = int(self.request.get('year'))
course = str(self.request.get('course'))
current_settings = SettingsModel.get_current_settings()
if current_settings == None:
new_settings = Settings()
new_settings.quarter = quarter
new_settings.year = year
new_settings.course = course
new_settings.put()
else:
current_settings.quarter = quarter
current_settings.year = year
current_settings.course = course
current_settings.put()
return self.redirect('/admin?message=' +
'Successfully changed settings')
except Exception, e:
return self.redirect(
'/admin/settings?message=' +
'There was a problem changing the settings: ' + str(e))
def mutate(self, info, user_data=None):
# NOTE: Netlify creates the account regardless of this response
portfolio = Portfolio()
settings = Settings()
metrics = UserMetrics()
try:
user = User.objects.get(pk=user_data.email)
# If no query error, then either the user exists or
# user variable becomes None. In both cases the response fails.
return CreateUserMutation(user=None, success=False)
except Exception as e: # email not taken
if "matching query does not exist" not in str(e):
# unexpected error during query
return CreateUserMutation(user=None, success=False)
user = User(name=user_data.name,
bio=user_data.bio,
email=user_data.email,
password=user_data.password,
profile_pic=user_data.profile_pic,
metrics=metrics,
achievements=[],
personal_portfolio=portfolio,
groups=[],
settings=settings)
checkAchievements(user)
user.save()
return CreateUserMutation(user=user, success=True)
def index_get(request):
status = Status(Dbus.get_temperature_status(), Dbus.get_manual_mode())
settings = Settings(Dbus.get_temperature_settings(),
Dbus.get_manual_mode())
return render(request, 'stat/index.html', {
'status': status,
'settings': settings
})
def add_setting(name, value, type, id=-1):
setting = Settings(name=name,
value=str(value),
type=type,
user_id=id if id > -1 else current_user.id)
db.session.add(setting)
db.session.commit()
log.info('add : {}'.format(setting.log()))
return True
def add_setting(name, value):
if Settings.query.filter_by(setting=name).first():
s = Settings.query.get(name)
s.value = value
db.session.commit()
else:
s = Settings(setting=name, value=value)
db.session.add(s)
db.session.commit()
def userSettings():
if Settings.query.filter_by(id=1).first() is None:
settings = Settings(indeed=True, craigslist=True)
try:
db.session.add(settings)
db.session.commit()
db.session.close()
return True
except Exception as inst:
print(inst)
print("Error DB")
return False
return True
def save_topic(topic: dict):
topic_json = json.dumps(topic)
rows_affected = session.query(Settings).filter(
Settings.key == "topic").update({"value": topic_json})
if not rows_affected:
ins = Settings(key="topic", value=topic_json)
session.add(ins)
session.commit()
return True
def getsettings():
settings = Settings.query.first()
#check if no settings are set
if not settings:
print('Settings are missing, setting defaults')
default_settings = Settings(res_x=1920,
res_y=1080,
rotation=180,
effect='none')
db.session.add(default_settings)
db.session.commit()
settings = Settings.query.first()
return (settings.res_x, settings.res_y, settings.rotation, settings.effect)
async def shoutout_msg(self, msg: Message, *args):
message = ""
for word in args:
message += f"{word} "
successful = session.query(Settings.value).filter(Settings.key == "shoutout_msg").update({"value": message})
if not successful:
insert = Settings(key="shoutout_msg", value=message)
session.add(insert)
session.commit()
await msg.reply(f"{bot.msg_prefix} Message updated.")
async def set_topic(self, msg, *args):
topic = ""
for arg in args:
topic += f"{arg} "
rows_affected = session.query(Settings).filter(Settings.key == "topic").update({"value": topic})
if not rows_affected:
ins = Settings(key="topic", value=topic)
session.add(ins)
session.commit()
await msg.reply(f"{bot.msg_prefix}Topic set.")
def setUp(self):
self.shop_items = (
{
'id': 1234,
'title': 'Wine Glass',
'price': 9.99,
},
{
'id': 2345,
'title': 'Frosted Shot Glasses, set of 4',
'price': 14.99,
},
)
f = open('secret_settings.json')
self.settings = Settings(**json.load(f))
def __init__(self):
query = session.query(Settings.value).filter(Settings.key == "announcement_delay").one_or_none()
self.delay = int(query[0]) if query is not None else 900
self.chan = cfg.channels[0]
self.next_run = datetime.min
self.timezone = pytz.timezone("America/Chicago")
self.channel_active = False
self.announcements_sleeping = True
self.sleep_override = False
self.current_category_setting = "announcement_category"
self.enable = session.query(Settings.value).filter(Settings.key == "announcement_enabled").one_or_none()
if self.enable is None:
insert = Settings(key="announcement_enabled", value=True)
session.add(insert)
def set_cooldown(self, feed: str, cooldown: int) -> None:
"""
Sets the MQTT cooldown
Updates or inserts the value into the database
Exception handling should be done in the calling function
"""
q = session.query(Settings.id).filter(Settings.key == f"mqtt_cooldown_{feed}").one_or_none()
if q is None:
# Value wasn't in the database, lets insert it.
insert = Settings(key=f"mqtt_cooldown_{feed}", value=cooldown)
session.add(insert)
self.mqtt_cooldown[feed] = cooldown
else:
session.query(Settings).filter(Settings.key == f"mqtt_cooldown_{feed}").update({"value": cooldown})
self.mqtt_cooldown[feed] = cooldown
session.commit()
def get_cooldown(self, feed: str):
"""
Returns the cooldown
Loads it from the database,
or returns 0 if one is not set.
"""
if feed not in self.mqtt_cooldown:
q = session.query(Settings.value).filter(Settings.key == f"mqtt_cooldown_{feed}").one_or_none()
if q is None:
# Value wasn't in the database, lets insert it.
insert = Settings(key=f"mqtt_cooldown_{feed}", value=0)
session.add(insert)
self.mqtt_cooldown[feed] = 0
else:
self.mqtt_cooldown[feed] = int(q[0])
return self.mqtt_cooldown[feed]
def override_settings(f, *args, **kwargs):
arg_index = f.__code__.co_varnames.index('settings')
new_settings = Settings().to_dict()
if 'settings' in kwargs:
new_settings.update(kwargs['settings'])
del kwargs['settings']
if len(args) < arg_index + 1:
kwargs['settings'] = new_settings
else: # need to place it in args
args = list(args)
args[arg_index] = new_settings
args = tuple(args)
# print args, kwargs
return f(*args, **kwargs)
def settings():
if not g.user.can_create_ballot():
abort(403)
settings = db.session.query(Settings).get(g.user.id)
if settings is None:
settings = Settings(id=g.user.id, signature=default_signature())
form = SettingsForm(request.form, obj=settings)
if request.method == "POST" and form.validate_on_submit():
form.populate_obj(settings)
db.session.add(settings)
db.session.commit()
flash(u"Nastavení bylo uloženo.", "success")
return redirect(url_for("settings"))
return render_template('settings.html', form=form)
def create_new_user(update) -> User:
"""
:param update: PTB update
:return: new or fetched user
"""
try:
return User.get_user(uid=update.message.from_user.id)
except LookupError:
user = User(
user_id=update.message.from_user.id,
settings=Settings(
language=utility.lang(
update.message.from_user.language_code, txt['LANG_CODES']
)
)
)
user.save()
return user
def start(self, start_year, end_year, duration, budget_per_player):
years_to_play = end_year - start_year
budget_per_player_per_year = budget_per_player / years_to_play
seconds_per_year = duration * 60 * 60 / years_to_play
td = timedelta(seconds=seconds_per_year)
now = datetime.now()
next_game_year_start = now + td
if not hasattr(self, 'settings'):
self.settings = Settings(self.id)
self.settings.current_game_year_start = now
self.settings.current_game_year = start_year
self.settings.next_game_year_start = next_game_year_start
self.settings.budget_per_cycle = budget_per_player_per_year
self.settings.max_spend_per_tick = budget_per_player_per_year / (
seconds_per_year / TICKINTERVAL)
return start_year
def startup():
db.create_all()
# create settings object if it doesn't exist
settings = Settings.query.first()
if not settings:
s = Settings()
# load example questions json
with open("data/question_example.json", "r") as example:
s.questions = example.read()
# detect number of response IDs required
data = json.loads(s.questions)
ids = len(data)
for d in data:
if "data" in d.keys():
ids += len(d["data"])
s.required_ids = ids
# set example response text
with open("data/response_example.txt", "r") as resp:
s.response_body = resp.read()
db.session.add(s)
db.session.commit()
async def lost(self, msg: Message, *args):
# Check if user is on ignore list
if bot.user_ignored(str(msg.author)):
return
# Increase both counts
self.lost_count["session"] += 1
self.lost_count["total"] += 1
rows_affected = (session.query(Settings).filter(
Settings.key == "lost_count").update(
{"value": json.dumps(self.lost_count)}))
if not rows_affected:
ins = Settings(key="lost_count", value=json.dumps(self.lost_count))
session.add(ins)
session.commit()
await msg.reply(
f"@baldengineer has lost {self.lost_count['session']} things so far today, {self.lost_count['total']} total."
)
def mutate(self, info, user_data=None):
'''
Need separate mutations for:
- change email
- change password
'''
user = UpdateUserMutation.getUser(user_data.id)
if user_data.name:
user.name = user_data.name
if user_data.bio:
user.bio = user_data.bio
if user_data.profile_pic:
user.profile_pic = user_data.profile_pic
if user_data.art_to_add:
artToAdd = UpdateArtworkMutation.getArtwork(user_data.art_to_add)
# Check if none
user.personal_portfolio.artworks.append(artToAdd)
user.metrics.works_visited += 1
artToAdd.metrics.total_visits += 1
artToAdd.save()
if user_data.art_to_remove:
artToRemove = (UpdateArtworkMutation.getArtwork(
user_data.art_to_remove))
index = user.personal_portfolio.artworks.index(artToRemove)
if index == -1:
print(f"Art ({artToRemove.id}) is not in User's portfolio")
else:
user.personal_portfolio.artworks.pop(index)
if user_data.group: # to be tested
user.groups.append(UpdateGroupMutation.getGroup(user_data.group))
if user_data.settings: # to be tested but I imagine works
user.settings = Settings(
autoAddToGroupPortfolio=settings.autoAddToGroupPortfolio)
# Need to add success/failure responses
checkAchievements(user)
user.save()
UpdateUserMutation.updateMetrics(user)
return UpdateUserMutation(user=user)
