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 getTwitterObject():
options = Option.all()
options.filter('name =', 'oauth-access-token')
access_token = options.get()
options = Option.all()
options.filter('name =', 'oauth-access-token-secret')
access_token_secret = options.get()
twitter = OAuthApi(consumer_key, consumer_secret, access_token.value, access_token_secret.value)
return twitter
def test_save_raw_data(self):
ids = []
for raw_option_name in self.raw_option_names:
oc = Option()
oc.save_raw_data(raw_contract=raw_option_name)
ids.append(oc.id)
print 'Inserted IDs: %s\n' % ids
print 'option row count in db: %d' % len(Option.objects.all())
print 'option rows:\n%s\n%s\n' % \
(Option.objects.get(id=1), Option.objects.get(id=2))
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 get(self, **kwargs):
admin = False
user = self.current_user
page_id = kwargs.get('pageid')
options_dict = {}
try:
pages = Page.get(user.pages)
for p in pages:
if p.id == page_id:
admin = True
page = p
widgets = Widget.all().filter('page =', page).filter('deleted = ', False).order('order')
options = Option.all().filter('type_reference =', page)
for option in options:
options_dict[option.name] = {'id': str(option.key().id()), 'value': option.value}
except:
page = None
widgets = None
options_dict = None
if admin:
#page = Page.get_by_key_name(str(page_id))
#add_app_url = 'https://www.facebook.com/add.php?api_key=a284fdd504b5191923362afabc0ea6c7&pages=1&page=141947329155355'
upload_url = blobstore.create_upload_url('/upload')
page_id = encrypt(page_id).encode('hex')
self.render("app/edit.html", admin=True, page=page,upload_url=upload_url, page_id=page_id,widgets= widgets, options=options_dict)
else:
self.redirect('/dashboard')
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 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 put(capsule_id, user):
capsule = _get_capsule(capsule_id, user)
webapp = capsule.webapp
webapp_data = request.get_json()
# PUT become POST if there is no webapp
if webapp is None:
return post(capsule_id=capsule_id, webapp_data=webapp_data)
data = webapp_schema.load(webapp_data)
webapp.env = None
if "env" in webapp_data:
webapp.env = webapp_data["env"]
# Ensure new runtime_id has same familly
new_runtime_id = str(data["runtime_id"])
try:
new_runtime = Runtime.query.get(new_runtime_id)
except StatementError:
raise BadRequest(description=f"'{new_runtime_id}' is not a valid id.")
if new_runtime is None:
raise BadRequest(description=f"The runtime_id '{new_runtime_id}' "
"does not exist.")
new_fam = str(new_runtime.fam)
old_fam = str(webapp.runtime.fam)
if new_fam != old_fam:
raise BadRequest(f"Changing runtime familly from '{old_fam}' "
f"to '{new_fam}' is not possible")
webapp.runtime_id = data["runtime_id"]
webapp.opts = []
if "opts" in data:
opts = Option.create(data["opts"], data["runtime_id"], user.role)
webapp.opts = opts
if "volume_size" in data:
if (user.role is RoleEnum.user) and (not user.parts_manager):
raise Forbidden(description='You cannot set webapp volume size.')
remaining_size = getWebappsVolumeUsage(str(webapp.id))
target_size = data['volume_size'] + remaining_size
if target_size > current_app.config['VOLUMES_GLOBAL_SIZE']:
msg = 'Please set a lower volume size for this webapp or prepare '\
'some Bitcoins... :-)'
raise PaymentRequired(description=msg)
webapp.volume_size = data['volume_size']
capsule.webapp = webapp
db.session.commit()
now = datetime.datetime.now()
if now > (capsule.no_update + datetime.timedelta(hours=24)):
nats.publish_webapp_present(capsule)
return get(capsule_id)
def post(capsule_id, user, addon_data=None):
capsule = _get_capsule(capsule_id, user)
if addon_data is None:
addon_data = request.get_json()
data = addon_schema.load(addon_data)
runtime_id = data["runtime_id"]
runtime = Runtime.query.get(runtime_id)
if runtime is None:
raise BadRequest(description=f"The runtime_id '{runtime_id}' "
"does not exist.")
if runtime.runtime_type is not RuntimeTypeEnum.addon:
raise BadRequest(description=f"The runtime_id '{runtime.id}' "
"has not type 'addon'.")
if "opts" in data:
opts = Option.create(data["opts"], runtime_id, user.role)
data.pop("opts")
addon = AddOn(**data, opts=opts)
else:
addon = AddOn(**data)
(addon.uri, addon.name) = runtime.generate_uri_dbname(capsule)
# HACK: if addon.name is not setted, we will use addon.id after commit
if addon.name is None:
addon.name = "changeme"
capsule.addons.append(addon)
db.session.add(addon)
db.session.commit()
if addon.name == "changeme":
addon.name = str(addon.id)
db.session.commit()
if addon.description is None:
addon.description = addon.name
db.session.commit()
now = datetime.datetime.now()
if now > (capsule.no_update + datetime.timedelta(hours=24)):
nats.publish_addon_present(addon, capsule.name)
result_json = addon_schema.dump(addon)
return result_json, 201, {
'Location':
f'{request.base_url}/capsules/{capsule_id}/addons/{addon.id}',
}
def main(request):
url = request.POST.get('url', '')
type = request.POST.get('submit', '').lower()
new_url = ''
error = ''
if type:
if url.startswith('http://'):
if type == 'shorten':
# Get the current count from the database
# This count keeps track of how many urls we have made
# Increment this number and call make_url
# Save it to the database and we are good to go
try:
count_ref = Option.objects.get(title="count")
except:
# No existing count so we must create it
count_ref = Option(title="count", value=0)
count_ref.save()
count_ref.value += 1
count_ref.save()
internal_url = make_url(count_ref.value)
new_url = 'http://%s/%s' % (request.get_host(),
internal_url)
r = Relation(internal_url=internal_url, external_url = url)
r.save()
else:
error = "Invalid url. Urls must start with \"http://\""
t = loader.get_template('index.html')
c = Context({
'new_url': new_url,
'error': error,
})
return http.HttpResponse(t.render(c))
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 __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 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 post(self, **kwargs):
#logging.info(self.request)
signed_request = facebook.parse_signed_request(self.request.get('signed_request'),self.get_config('facebook','app_secret'))
#logging.info(signed_request)
try:
user_id = signed_request['user_id']
except:
user_id = None
page_id = signed_request['page']['id']
liked = signed_request['page']['liked']
admin = signed_request['page']['admin']
options_dict = {}
status = 'True'
try:
page = Page.get_by_key_name(page_id)
#check active account or for expired account.
if page.upgraded != '1':
expire_date = page.created + datetime.timedelta(days=14)
min_expire_date = datetime.datetime(2011,5,1)
if (expire_date < min_expire_date):
expire_date = min_expire_date
if expire_date < datetime.datetime.now():
status = 'False'
widgets = Widget.all().filter('page =', page).filter('deleted = ', False).order('order')
options = Option.all().filter('type_reference =', page)
for option in options:
options_dict[option.name] = {'id': str(option.key().id()), 'value': option.value}
except:
page=None
widgets=None
options_dict = None
self.render("app/fb-tab.html", page=page,widgets=widgets, method="post",options=options_dict,admin=admin,status=status)
def put(capsule_id, addon_id, user):
capsule = _get_capsule(capsule_id, user)
addon_data = request.get_json()
data = addon_schema.load(addon_data)
try:
addon = AddOn.query.get(addon_id)
except StatementError:
raise BadRequest(description=f"'{addon_id}' is not a valid id.")
if not addon:
raise NotFound(description=f"The requested addon '{addon_id}' "
"has not been found.")
if str(addon.capsule.id) != capsule_id:
raise Forbidden(description="bad capsule id")
addon.description = data["description"]
if data["runtime_id"] != str(addon.runtime_id):
raise BadRequest(description="The runtime_id cannot be changed.")
addon.runtime_id = data["runtime_id"]
addon.env = data["env"]
if "opts" in data:
opts = Option.create(data["opts"], data['runtime_id'], user.role)
addon.opts = opts
else:
addon.opts = []
if addon.description is None:
addon.description = addon.name
db.session.commit()
now = datetime.datetime.now()
if now > (capsule.no_update + datetime.timedelta(hours=24)):
nats.publish_addon_present(addon, capsule.name)
return get(capsule_id, addon_id)
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 add_option(self, option_text: str):
Option(option_text, self.id).save()
def post(self, **kwargs):
user = self.current_user
admin = False
method = kwargs.get('method')
if method == 'deletewidget':
key_name = self.request.get("wid")
widget = Widget.get_by_key_name(key_name)
if widget:
widget.deleted = True
widget.last_modified_by = user
try:
db.put(widget)
self.response.out.write('True')
except:
self.response.out.write('False')
if method == 'savepageorder':
page_order = self.request.get('pageorder')
page_order = page_order.split(',')
batch = []
for k,v in enumerate(page_order):
widget = Widget.get_by_key_name(v)
if widget:
widget.order = k
widget.last_modified_by = user
batch.append(widget)
try:
db.put(batch)
self.response.out.write('True')
except:
self.response.out.write('False')
if method == 'savewidget':
page = Page.get_by_key_name(self.request.get('pageid'))
key_name = self.request.get('wid')
widget = Widget.get_by_key_name(key_name)
if self.request.get('wtype') == 'embedly':
fields = simplejson.loads(self.request.get('wcontents'))
#get_embedly_code({'id':self.request.get('wid'),"url":fields['embedly_url'],"type":"embedly"})
deferred.defer(get_embedly_code,{'id':self.request.get('wid'),"url":fields['embedly_url'],"type":"embedly"})
if self.request.get('wtype') == 'googlemaps':
fields = simplejson.loads(self.request.get('wcontents'))
deferred.defer(get_embedly_code,{'id':self.request.get('wid'),"url":fields['googlemaps_link'],"type":"googlemaps"})
if not widget:
widget = Widget(key_name=key_name,
id = key_name,
type = self.request.get('wtype'),
name = self.request.get('wname'),
page = page,
contents = self.request.get('wcontents'),
last_modified_by = user
)
fields = simplejson.loads(self.request.get('wcontents'))
for k,v in fields.iteritems():
db_type = k.split('__')
try:
db_type = db_type[1]
except IndexError:
db_type = None
logging.info(db_type)
if db_type == 'text':
setattr(widget, k, db.Text(v))
else:
setattr(widget, k, v)
else:
widget.name = self.request.get('wname')
widget.contents = self.request.get('wcontents')
widget.last_modified_by = user
fields = simplejson.loads(self.request.get('wcontents'))
for k,v in fields.iteritems():
db_type = k.split('__')
try:
db_type = db_type[1]
except IndexError:
db_type = None
logging.info(db_type)
if db_type == 'text':
setattr(widget, k, db.Text(v))
else:
setattr(widget, k, v)
try:
db.put(widget)
self.response.out.write('True')
except:
self.response.out.write('False')
if method == 'saveoption':
try:
option = Option.get_by_id(int(self.request.get('id')))
except:
option = None
if self.request.get('otype') == 'page':
link = Page.get_by_key_name(self.request.get('opageid'))
if not option:
option = Option(
name = self.request.get('oname'),
value = self.request.get('ovalue'),
type = self.request.get('otype'),
type_reference = link
)
else:
option.value = self.request.get('ovalue')
try:
db.put(option)
self.response.out.write('True')
except:
self.response.out.write('False')
if method == 'upgradedowngrade':
try:
username = self.get_config('saasy','username')
password = self.get_config('saasy','password')
product = self.get_config('saasy','product')
qty = str(self.request.get('qty'))
basic_auth = base64.b64encode('%s:%s' % (username, password))
xml_data = "<subscription><productPath>/%s</productPath><quantity>%s</quantity><no-end-date/></subscription>" % (product,qty)
subscriber_info=simplejson.loads(self.current_user.subscriber_info)
url = "https://api.fastspring.com/company/seedprod/subscription/%s" % subscriber_info['reference']
response = urlfetch.fetch(url=url,payload=xml_data,headers={'Authorization': 'Basic %s' % basic_auth ,'Content-Type': 'application/xml' },method=urlfetch.PUT)
if response.status_code == 200:
# Update Pages
upgraded_pages = self.request.get('pages').split(',')
pages = Page.get(user.pages)
batch = []
for p in pages:
if p.id in upgraded_pages:
p.upgraded = '1'
p.upgraded_by = user
else:
if p.upgraded_by:
if p.upgraded_by.id == user.id:
p.upgraded = '0'
p.upgraded_by = None
batch.append(p)
db.put(batch)
self.response.out.write('True')
else:
self.response.out.write('False')
except:
self.response.out.write('False')
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,
]
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 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 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 post(capsule_id, user, webapp_data=None):
capsule = _get_capsule(capsule_id, user)
if len(capsule.fqdns) == 0:
raise Conflict(description="A webapp need at least one FQDN.")
webapp = capsule.webapp
# Only one webapp per capsule
if webapp is not None:
raise Conflict(description="This capsule already has a webapp.")
# Datas could come from PUT
if webapp is None:
webapp_data = request.get_json()
data = webapp_schema.load(webapp_data)
runtime_id = data["runtime_id"]
try:
runtime = Runtime.query.get(runtime_id)
except StatementError:
raise BadRequest(description=f"'{runtime_id}' is not a valid id.")
if runtime is None:
raise BadRequest(description=f"The runtime_id '{runtime_id}' "
"does not exist.")
if runtime.runtime_type is not RuntimeTypeEnum.webapp:
raise BadRequest(description=f"The runtime_id '{runtime.id}' "
"has not type 'webapp'.")
newArgs = dict()
if "opts" in data:
opts = Option.create(data["opts"], runtime_id, user.role)
data.pop("opts")
newArgs["opts"] = opts
if "volume_size" not in data:
data['volume_size'] = current_app.config['VOLUMES_DEFAULT_SIZE']
else:
if (user.role is RoleEnum.user) and (not user.parts_manager):
raise Forbidden(description='You cannot set webapp volume size.')
remaining_size = getWebappsVolumeUsage()
target_size = data['volume_size'] + remaining_size
if target_size > current_app.config['VOLUMES_GLOBAL_SIZE']:
msg = 'Please set a lower volume size for this webapp or prepare '\
'some Bitcoins... :-)'
raise PaymentRequired(description=msg)
webapp = WebApp(**data, **newArgs)
capsule.webapp = webapp
db.session.add(webapp)
db.session.commit()
result = WebApp.query.get(capsule.webapp_id)
now = datetime.datetime.now()
if now > (capsule.no_update + datetime.timedelta(hours=24)):
nats.publish_webapp_present(capsule)
# Api response
result_json = webapp_schema.dump(result)
return result_json, 201, {
'Location': f'{request.base_url}/{capsule.id}/webapp',
}
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")
