def form_valid(self, form):
if form.instance.InputType.pk == settings.OPTIONS_ID:
formOptions = GetFormOptions(self.request)
instanceOptionGroup = GetInstanceOptionGroup(form)
if instanceOptionGroup != None:
for option in instanceOptionGroup.Options.all():
if option.Value in formOptions:
formOptions.remove(option.Value)
else:
instanceOptionGroup.Options.remove(option)
option.delete(keep_parents=True)
else:
instanceOptionGroup = OptionGroup(Name=form.instance.Text +
"Answer Group")
instanceOptionGroup.save()
form.instance.OptionGroup = instanceOptionGroup
for newOption in formOptions:
newOptionObject = Option(Value=newOption)
newOptionObject.save()
instanceOptionGroup.Options.add(newOptionObject)
instanceOptionGroup.save()
form.instance.OptionGroup = instanceOptionGroup
form.save()
return super(UpdateQuestion, self).form_valid(form)
else:
return super(UpdateQuestion, self).form_valid(form)
def option(option, section):
if request.method == "GET":
db_option = db.session.query(Option).filter_by(
name=option, section=section).first()
if db_option:
return jsonify(db_option.serialize) if db_option else jsonify(None)
return make_response(jsonify({}), 200)
elif request.method == "PUT":
db_option = db.session.query(Option).filter_by(
name=option, section=section).first()
if not db_option:
# create the new option
db_option = Option(name=option, section=section, value="")
db.session.add(db_option)
# do update
changed = db_option.update_value(request.json)
db.session.commit()
if option == "notifications":
if changed:
return process_ipc_response(IPCClient().update_configuration())
elif db_option.name == "network" and db_option.section == "dyndns":
if os.environ.get("ARGUS_DEVELOPMENT", "0") == "0":
return process_ipc_response(IPCClient().update_dyndns())
elif db_option.name == "network" and db_option.section == "access":
if os.environ.get("ARGUS_DEVELOPMENT", "0") == "0":
return process_ipc_response(IPCClient().update_ssh())
return make_response("", 204)
return make_response(jsonify({"error": "Unknown action"}), 400)
def save(self):
for field_name, value in self._fields.iteritems():
if field_name.upper().startswith("SITE_"):
value = self._fields[field_name].data
app.config[field_name] = value
op = Option(id=field_name)
op.value = value
op.put()
def insert_into_db(meals):
for meal in meals:
pizza = Pizza(title=meal['title'], description=meal['description'])
session.add(pizza)
for choise in meal['choices']:
option = Option(size=choise['title'], price=choise['price'])
pizza.options.append(option)
session.add(pizza)
session.commit()
def append(request, id):
""" 添加投票选项信息 """
obj = get_object_or_404(model_class, id=id)
if request.method == "POST":
name = request.POST.get('option_name', '')
if name:
option = Option(subject=obj, name=name)
option.save()
return HttpResponseRedirect(reverse("table_detail", args=[obj.pk]))
def setup_fake_data():
print('Adding fake data to database...')
tool = Tool(name=u'Martillo',
description=u'Pa martillar',
location=u'AETEL – Panel de herramientas',
manual=u'here',
documentation=u'there')
db_session.add(tool)
workshop1 = Workshop(name=u'Croquetas Caseras', description=u'¿Alguna vez has querido hacer tus propias croquetas caseras?', \
members_only=False, participants=99, date=(datetime.now() + timedelta(days=1)))
db_session.add(workshop1)
workshop2 = Workshop(name=u'Empanadillas Caseras', description=u'¿Alguna vez has querido hacer tus propias empanadillas caseras?', \
members_only=True, participants=99, date=datetime.now())
db_session.add(workshop2)
test_user = db_session.query(User).filter_by(dni='00000001A').first()
test_user.workshop_instructor.append(workshop1)
test_user.workshop_instructor.append(workshop2)
tool.workshops.append(workshop1)
test_user.tool_maintainer.append(tool)
db_session.commit()
nombre = u'¡Elegimos fiesta nacional!'
voting = Voting(name=nombre, description='Fiesta fiesta fiesta', \
start_date=datetime.now(), end_date=(datetime.now() + timedelta(days=3)) )
db_session.add(voting)
db_session.commit()
option1 = Option(
name=u'Día Nacional de la croqueta',
voting_id=db_session.query(Voting).filter_by(name=nombre).first().id)
db_session.add(option1)
option2 = Option(
name=u'Día Nacional de la empanadilla',
voting_id=db_session.query(Voting).filter_by(name=nombre).first().id)
db_session.add(option2)
db_session.commit()
def update_futopt_tables(db_future_nrows, db_option_nrows):
text_errors = []
data = get_data()
# clear table with staled data
db.session.query(Future).delete()
# write fresh data
for row in data["futures"].drop_duplicates().iterrows():
future = Future(secid=row[1].SECID, shortname=row[1].SHORTNAME, lasttradedate=row[1].LASTTRADEDATE,
assetcode=row[1].ASSETCODE, prevopenposition=row[1].PREVOPENPOSITION,
prevsettleprice=row[1].PREVSETTLEPRICE, oi_rub=row[1].OI_RUB,
oi_percentage=row[1].OI_PERCENTAGE, lasttrademonth=row[1].LASTTRADEMONTH,
date_created=datetime.utcnow())
db.session.add(future)
try:
editions = db.session.query(Edition).filter(Edition.table == "futures").first()
editions.edition = data["future_edition"]
editions.date_created = datetime.utcnow()
except AttributeError:
editions = Edition(table="futures", edition=data["future_edition"], date_created=datetime.utcnow())
db.session.add(editions)
# clear table with staled data
db.session.query(Option).delete()
# write fresh data
for row in data["options"].drop_duplicates().iterrows():
option = Option(secid=row[1].SECID, shortname=row[1].SHORTNAME, lasttradedate=row[1].LASTTRADEDATE,
assetcode=row[1].ASSETCODE, prevopenposition=row[1].PREVOPENPOSITION,
prevsettleprice=row[1].PREVSETTLEPRICE, oi_rub=row[1].OI_RUB,
oi_percentage=row[1].OI_PERCENTAGE, lasttrademonth=row[1].LASTTRADEMONTH,
underlying_future=row[1].UNDERLYING, date_created=datetime.utcnow())
db.session.add(option)
try:
editions = db.session.query(Edition).filter(Edition.table == "options").first()
editions.edition = data["option_edition"]
editions.date_created = datetime.utcnow()
except AttributeError:
editions = Edition(table="options", edition=data["option_edition"], date_created=datetime.utcnow())
db.session.add(editions)
db.session.commit()
df_fut = pd.read_sql(db.session.query(Future).statement, db.session.bind)
df_opt = pd.read_sql(db.session.query(Option).statement, db.session.bind)
return [df_fut, df_opt, text_errors]
def add_category():
league_id = request.form.get('id')
if current_user.is_admin_user():
try:
question = request.form.get('question')
max_bet = int(request.form.get('max_bet'))
option1 = request.form.get('option1')
perc_1 = float(request.form.get('odds2'))
option2 = request.form.get('option2')
new_category = Category(question=question,
max_bet=max_bet,
league_id=int(league_id))
db.session.add(new_category)
db.session.commit()
odds1 = int((100 / perc_1) * 100) / 100
odds2 = int((100 / (100 - perc_1)) * 100) / 100
new_option1 = Option(name=option1,
odds=odds1,
category_id=new_category.id)
new_option2 = Option(name=option2,
odds=odds2,
category_id=new_category.id)
db.session.add(new_option1)
db.session.add(new_option2)
db.session.commit()
flash('Category added successfully', 'success')
return redirect(url_for('admin.edit', league_id=league_id))
except:
flash('Please check your data', 'error')
return redirect(url_for('admin.edit', league_id=league_id))
else:
flash('User is not an admin', 'error')
return redirect(url_for('main.profile'))
def set(self, value, username):
if self.type == 'bool':
if value:
value = '1'
else:
value = '0'
try:
opt = self.get(username)
opt.data = value
except:
u = User.objects.get(username=username)
opt = Option(optid=self.id, data=value, type=self.type, user=u)
finally:
opt.save()
def __insert(self, item):
option = Option(
name=item['name'],
description=item['description'],
link=item['link'],
source=item['source'],
)
for subject in item['subjects']:
subject = Subject(
link=subject['link'],
source=subject['source'],
orientation=Orientation[subject['orientation']],
)
option.subjects.append(subject)
return option
def form_valid(self, form):
if form.instance.InputType.pk == settings.OPTIONS_ID:
newOptionGroup = OptionGroup(Name=form.instance.Text +
' Answer Group')
newOptionGroup.save()
for option in GetFormOptions(self.request):
newOption = Option(Value=option)
newOption.save()
newOptionGroup.Options.add(newOption)
newOptionGroup.save()
form.instance.OptionGroup = newOptionGroup
form.save()
return super(NewQuestion, self).form_valid(form)
return super(NewQuestion, self).form_valid(form)
def api_create_option():
name = request.args.get('name')
description = request.args.get('description')
option = Option(name=name)
option.update_description(description)
db.session.add(option)
db.session.commit()
current_user = Admin.query.filter_by(email=session['user']).first()
action = Action(
owner=current_user.id,
type='createoption',
target_type='option',
text='created option ({0})'.format(name),
target_id=option.id)
db.session.add(action)
db.session.commit()
return jsonify(status="OK")
def register_survey(survey_id):
survey = request.get_json()
survey_size = survey['size']
survey_title = survey['title']
survey_subtitle = survey['subtitle']
user = User.query.filter_by(id=session['userid']).first()
if user.q_point < 100:
return jsonify({'result': 'q_shortage'})
user.q_point -= 100
question_len = len(session['tmp_question_dict'][survey_id])
if question_len < 5:
survey_que = question_len * 10
else:
survey_que = 50
survey = Survey(link=survey_id,
title=survey_title,
subtitle=survey_subtitle,
userID=user.id,
que=survey_que)
db.session.add(survey)
db.session.commit()
db.session.flush()
session['userid'] = user.id
print 'question dict', session['tmp_question_dict'][survey_id]
for question_idx, each_question in session['tmp_question_dict'][
survey_id].iteritems():
print 'value', each_question
question = Question(title=each_question['title'],
subtitle=each_question['subtitle'],
questionType=each_question['type'],
isEssential=True,
surveyID=survey.id)
db.session.add(question)
db.session.commit()
db.session.flush()
question = Question.query.filter_by(title=question.title).first()
for each_option in each_question['option']:
option = Option(content=each_option, questionID=question.id)
db.session.add(option)
db.session.commit()
db.session.flush()
return jsonify({'result': 'success'})
def new_product():
if request.method == 'GET':
return render_template('newproduct.html')
else:
try:
data = request.get_json()
prices = []
for price in data['prices']:
options = []
for option_id in price['options']:
current_option = data['options'][option_id]
options.append(
Option(option_id=option_id,
option_type=current_option['type'],
option_text=current_option['text'],
option_value=current_option['value']).save())
current = Price(
valid_from=datetime.utcnow(),
valid_to=datetime.utcnow(),
currency=price['currency'],
original_price=price['originalPrice'],
discounted_price=price['discountedPrice'],
discount_rate=price['discountRate'],
# stock=price['stock'],
# is_active=price['isActive'],
options=options)
prices.append(current)
product = Product(title=data['title'],
description=data['description'],
image_url=data['imageURL'],
prices=prices).save()
return jsonify({'created': str(product.id), 'success': True})
except Exception as e:
traceback.print_exc()
return make_response('An error occured while adding product.', 400)
return jsonify({'hello': 'world'})
def options(self) -> List[Option]:
connection = create_connection()
options = database.get_poll_options(connection, self.id)
connection.close()
return [Option(option[1], option[2], option[0]) for option in options]
def add_option(self, option_text: str):
Option(option_text, self.id).save()
def view_voting():
votes = {}
if request.method == 'GET':
if 'id' in request.args:
uid = request.args.get('id')
result = db_session.query(Voting).filter_by(id=uid).first()
form = VoteForm()
options = db_session.query(Option).filter_by(voting_id=uid).all()
choices = []
votes['number'] = {}
votes['user'] = 0
for option in options:
choices.append((option.id, option.name))
votes['number'][option.name] = db_session.query(
VotesUsers).filter_by(option_id=option.id).count()
votes['user'] += db_session.query(VotesUsers).filter_by(
option_id=option.id).filter_by(
user_id=current_user.id).count()
form.option.choices = choices
if result.end_date + timedelta(1) > date.today(
): #bigger means older
votes['end'] = 0
else:
votes['end'] = 1
return render_template('voting.html',
result=result,
form=form,
votes=votes,
title='cutrenet',
subtitle=result.name)
elif not current_user.has_role('admin'):
flash(u'No tienes permisos para añadir o borrar votaciones',
'error')
return redirect('/votaciones', code=302)
elif 'add' in request.args:
form = VotingForm()
return render_template('voting.html',
form=form,
title='cutrenet',
subtitle="new voting")
elif 'delete' in request.args:
delete = request.args.get('delete')
voting = db_session.query(Voting).filter_by(id=delete).first()
db_session.delete(voting)
db_session.commit()
flash(u'Votación eliminada', 'success')
return redirect('/votaciones', code=302)
else:
flash(u'Tienes que seleccionar una votación', 'error')
return redirect('/votaciones', code=302)
if request.method == 'POST':
if 'add' in request.args and current_user.has_role('admin'):
voting = Voting()
form = VotingForm()
if form.validate_on_submit():
voting.name = request.form['name']
voting.description = request.form['description']
voting.start_date = form.start_date.data
voting.end_date = form.end_date.data
names = request.form['options'].split('|')
for name in names:
option = Option()
option.name = name
voting.options.append(option)
db_session.add(voting)
db_session.commit()
flash(u'Votación añadida', 'success')
return redirect('votaciones', code=302)
return render_template('voting.html',
form=form,
votes=votes,
title='cutrenet',
subtitle="new voting")
elif 'vote' in request.args:
uid = request.args.get('vote')
form = VoteForm()
options = db_session.query(Option).filter_by(voting_id=uid).all()
choices = []
votes['number'] = {}
votes['user'] = 0
for option in options:
choices.append((option.id, option.name))
votes['number'][option.name] = db_session.query(
VotesUsers).filter_by(option_id=option.id).count()
votes['user'] += db_session.query(VotesUsers).filter_by(
option_id=option.id).filter_by(
user_id=current_user.id).count()
form.option.choices = choices
result = db_session.query(Voting).filter_by(id=uid).first()
if result.end_date + timedelta(1) > date.today(
): #bigger means older
votes['end'] = 0
else:
votes['end'] = 1
if form.validate_on_submit():
if votes['user'] == 0:
option = db_session.query(Option).filter_by(
id=request.form['option']).first()
user = db_session.query(User).filter_by(
id=current_user.id).first()
option.votes.append(user)
db_session.add(option)
db_session.commit()
votes['user'] = 0
for option in options:
votes['number'][option.name] = db_session.query(
VotesUsers).filter_by(option_id=option.id).count()
votes['user'] = 1
flash(u'Voto registrado', 'success')
else:
flash(u'Ya has votado, mamón', 'alert')
return render_template('voting.html',
form=form,
result=result,
votes=votes,
title='cutrenet',
subtitle=u"voted ✔️")
def get(self, action):
# Depending on the action requested /admin/<action>/
if action == 'register':
# Register a Twitter user with the application using
# OAuth. Works with the Option model to store the request and
# access tokens.
# Remove all the previous tokens matching oauth-* from the datastore.
options = Option.all()
options.filter('name >=', 'oauth-').filter('name <',
'oauth-' + u'\ufffd')
options.fetch(1000)
for option in options:
option.delete()
# Request an OAuth token and show the authorization URL on Twitter.
twitter = OAuthApi(consumer_key, consumer_secret)
credentials = twitter.getRequestToken()
url = twitter.getAuthorizationURL(credentials)
rendertext(self, '<a href="%s">%s</a><br />' % (url, url))
rendertext(
self,
'<form action="/admin/verify/" method="GET"><input type="text" name="oauth_verifier" /><input type="submit" /></form>'
)
# Save the tokens to the datastore for later authentication
oauth_token = credentials['oauth_token']
oauth_token_secret = credentials['oauth_token_secret']
# Record the tokens
opt = Option(name='oauth-request-token', value=oauth_token)
opt.put()
opt = Option(name='oauth-request-token-secret',
value=oauth_token_secret)
opt.put()
elif action == 'verify':
# Used to verify an initiated registration request. Request tokens should
# by now be stored in the data store. Retrieve them and initiate a change.
twitter = OAuthApi(consumer_key, consumer_secret)
oauth_verifier = self.request.get('oauth_verifier')
options = Option.all()
options.filter('name =', 'oauth-request-token')
oauth_token = options.get()
options = Option.all()
options.filter('name =', 'oauth-request-token-secret')
oauth_token_secret = options.get()
# Form a request and ask Twitter to exchange request tokens for access tokens using
# an OAuth verifier (PIN code).
credentials = {
'oauth_token': oauth_token.value,
'oauth_token_secret': oauth_token_secret.value,
'oauth_callback_confirmed': 'true'
}
credentials = twitter.getAccessToken(credentials, oauth_verifier)
# Record the access tokens and remove the previously stored request tokens.
access_token = Option(name='oauth-access-token',
value=credentials['oauth_token'])
access_token_secret = Option(
name='oauth-access-token-secret',
value=credentials['oauth_token_secret'])
oauth_token.delete()
oauth_token_secret.delete()
access_token.put()
access_token_secret.put()
# Tokens are now saved, getTwitterObject can be used.
self.response.out.write("You are now registered as @%s!" %
credentials['screen_name'])
# Uses the Task Queues API
elif action == 'cron':
if self.request.get('task') == 'geocode':
for i in range(2, 140, 2):
deferred.defer(tasks.geocode,
_countdown=i,
_queue='geocoding')
rendertext(self, "Geo task added to queue")
def __init__(self, db):
self.validation_rule1 = AvailableOptionValidationRule(
type=ValidationRuleEnum.min,
arg="1",
)
self.validation_rule2 = AvailableOptionValidationRule(
type=ValidationRuleEnum.max,
arg="42",
)
self.validation_rule1bis = AvailableOptionValidationRule(
type=ValidationRuleEnum.min,
arg="1",
)
self.validation_rule2bis = AvailableOptionValidationRule(
type=ValidationRuleEnum.max,
arg="42",
)
self.validation_rule3 = AvailableOptionValidationRule(
type=ValidationRuleEnum.regex,
arg="^[a-z0-9][-a-z0-9]*[a-z0-9]$",
)
self.validation_rule4 = AvailableOptionValidationRule(
type=ValidationRuleEnum.eq,
arg="foobar",
)
self.validation_rule5 = AvailableOptionValidationRule(
type=ValidationRuleEnum.neq,
arg="barfoo",
)
self.validation_rule6 = AvailableOptionValidationRule(
type=ValidationRuleEnum.format,
arg="json",
)
self.validation_rule7 = AvailableOptionValidationRule(
type=ValidationRuleEnum.into,
arg="[a, b, c]",
)
self.available_opt1 = AvailableOption(
access_level=RoleEnum.user,
tag="Apache",
field_name="vhost.conf",
value_type=OptionValueTypeEnum.base64,
field_description="Apache2 vhost configuration file.",
default_value="",
)
self.available_opt2 = AvailableOption(
access_level=RoleEnum.user,
tag="PHP",
field_name="worker",
value_type=OptionValueTypeEnum.integer,
field_description="PHP worker count.",
default_value="6",
validation_rules=[
self.validation_rule1,
self.validation_rule2,
],
)
self.available_opt2bis = AvailableOption(
access_level=RoleEnum.user,
tag="PHP",
field_name="test_min_max",
value_type=OptionValueTypeEnum.integer,
field_description="Test min and max option rules",
default_value="6",
validation_rules=[
self.validation_rule1bis,
self.validation_rule2bis,
],
)
self.available_opt3 = AvailableOption(
access_level=RoleEnum.user,
tag="SQL",
field_name="my.cnf",
value_type=OptionValueTypeEnum.base64,
field_description="MySQL configuration file.",
)
self.available_opt4 = AvailableOption(
access_level=RoleEnum.admin,
tag="PHP",
field_name="test_regex",
value_type=OptionValueTypeEnum.string,
field_description="Test regex option rule",
validation_rules=[
self.validation_rule3,
]
)
self.available_opt5 = AvailableOption(
access_level=RoleEnum.admin,
tag="PHP",
field_name="test_eq",
value_type=OptionValueTypeEnum.string,
field_description="Test eq option rule",
validation_rules=[
self.validation_rule4,
]
)
self.available_opt6 = AvailableOption(
access_level=RoleEnum.admin,
tag="PHP",
field_name="test_neq",
value_type=OptionValueTypeEnum.string,
field_description="Test neq option rule",
validation_rules=[
self.validation_rule5,
]
)
self.available_opt7 = AvailableOption(
access_level=RoleEnum.admin,
tag="PHP",
field_name="test_format",
value_type=OptionValueTypeEnum.string,
field_description="Test format option rule",
validation_rules=[
self.validation_rule6,
]
)
self.available_opt8 = AvailableOption(
access_level=RoleEnum.admin,
tag="PHP",
field_name="test_into",
value_type=OptionValueTypeEnum.string,
field_description="Test into option rule",
validation_rules=[
self.validation_rule7,
]
)
self.runtime1 = Runtime(
name="apache-2.4 php-7.2.x",
description="Stack web classique Apache 2.4 + PHP 7.2.x",
fam="Apache PHP",
runtime_type=RuntimeTypeEnum.webapp,
available_opts=[
self.available_opt1,
self.available_opt2,
],
)
self.runtime2 = Runtime(
name="MariaDB 10.1",
description="SQL server",
fam="SQL",
runtime_type=RuntimeTypeEnum.addon,
available_opts=[
self.available_opt3,
],
uri_template='{"pattern": "mysql://{udbname}:{password}@'
'host:port/{udbname}",'
'"variables": [{"length": 16, "name": "udbname", '
'"src": "capsule", "unique": true, "set_name": true},'
'{"length": 32, "name": "password", '
'"set_name": false, "src": "random", '
'"unique": false}]}',
)
self.runtime3 = Runtime(
name="MariaDB 12.1",
description="SQL server",
fam="SQL",
runtime_type=RuntimeTypeEnum.addon,
)
self.runtime4 = Runtime(
name="apache-3.1 php-9.3.x",
description="Stack web futuriste Apache 3.1 + PHP 9.3.x",
fam="Apache PHP",
runtime_type=RuntimeTypeEnum.webapp,
available_opts=[
self.available_opt2bis,
self.available_opt4,
self.available_opt5,
self.available_opt6,
self.available_opt7,
self.available_opt8,
],
)
self.fqdn1 = FQDN(
name="main.fqdn.ac-versailles.fr",
alias=False,
)
self.fqdn2 = FQDN(
name="secondary.fqdn.ac-versailles.fr",
alias=True,
)
self.option1 = Option(
field_name="worker",
tag="PHP",
value="42",
value_type='integer',
)
self.cron1 = Cron(
command="rm -rf *",
hour="*/6",
minute="15",
month="*",
)
self.webapp1 = WebApp(
env='{"HTTP_PROXY": "http://*****:*****@doe",
)
self.sshkey2 = SSHKey(
public_key="ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAAAgQC/YCx71smBufMXF"
"thQQsjSW18adRCpI5L+I8z4qtx+8SQeTSFWZF/E9QSgG6UoajwzCb"
"5oQM/+M9Hmel1rSUUfjGx8HQV4smVbCRTgRGDJTpFhbvoeO0AC6YJ"
"6n/eBzu0zKVlW0UqMqJU1cQLWgnFfSDURmzLHlnPn467uXPx5Pw=="
" jane@doe",
)
self.sshkey3 = SSHKey(
public_key="ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAAAgQDCVu8lOZxm+7fjM"
"QpdNuU2HinAhWmmEtYcX9wxCcBs14GmDrDSOhZB61bq9vdzkSlV0W"
"st711mUlEZlXh/999NL7iAy6COKYxsEmRgbCU+9k8rBsSTDcXS6MW"
"+aJI4vnqMgVSGwBDgxZs4X2mthYhCitgbk9D3WbstAinUkhEtzQ=="
" phpseclib-generated-key"
)
token = "KDCte1raIV-ItPQf-sf_tapY4q-kLmvlcJ9yUKPlqbo"
hashed_token = sha512(token.encode('ascii')).hexdigest()
self.apptoken1 = AppToken(
app="My super app",
token=hashed_token)
# Users.
self.admin_user = User(
name="admin_user", role=RoleEnum.admin)
self.superadmin_user = User(
name="superadmin_user", role=RoleEnum.superadmin)
self.fake_user = User(
name="fake_user", role=RoleEnum.user)
self.user1 = User(
name="user1", role=RoleEnum.user)
self.user2 = User(
name="user2", role=RoleEnum.user)
self.user3 = User(
name="user3", role=RoleEnum.user)
self.user1.public_keys.append(self.sshkey1)
self.user2.public_keys.append(self.sshkey2)
self.user3.apptokens.append(self.apptoken1)
self.capsule1 = Capsule(
name="test-default-capsule",
owners=[
self.user1,
self.user2,
],
webapp=self.webapp1,
addons=[
self.addon1,
],
authorized_keys=[
self.sshkey2,
self.sshkey3,
],
fqdns=[
self.fqdn1,
self.fqdn2,
],
force_redirect_https=True,
enable_https=True,
)
array_obj = []
for name, value in vars(self).items():
array_obj.append(value)
db.session.add_all(array_obj)
db.session.commit()
# Just handy in test functions.
self.users = [
self.admin_user,
self.superadmin_user,
self.fake_user,
self.user1,
self.user2,
self.user3,
]
self.runtimes = [
self.runtime1,
self.runtime2,
self.runtime3,
self.runtime4,
]
