def post(self):
user = users.get_current_user()
if not user:
self.redirect(users.create_login_url())
system_name = self.request.get("name")
system_description = self.request.get("description")
system = System(id=system_name, description=system_description)
key = system.put()
# This is correct but is a hack, other solution is to use a sleep()
must_stop = False
systems = []
while not must_stop:
systems = System.query().fetch()
for system in systems:
if system.key.id() == system_name:
must_stop = True
systems = System.query().fetch()
template_values = {
"systems": systems,
"message": {
"type": "success",
"payload": "Created system #{0}".format(key.id())
},
"user": user,
"users": users
}
template = JINJA_ENVIRONMENT.get_template("templates/list_system.html")
self.response.write(template.render(template_values))
return
def create_system_variable(variable, value):
"""
Creates and returns a system variable with given arguments.
"""
variable = System(variable=variable, value=value)
session.add(variable)
session.commit()
return variable
def add_system():
print("adding systems")
data = request.json
print(data)
if ((data.get('name') == '')):
abort(422)
# try:
system = System(name=data.get('name'))
system.rank = data.get('rank')
system.insert()
# except Exception:
# abort(422)
return jsonify({'message': 'success', 'id': system.id})
def save():
lastID = db.session.query(func.max(System.system_id)).first()[0]
if lastID:
system_id = str(lastID + 1)
else:
system_id = "1"
system_name = request.form["system_name"]
system_description = request.form.get("system_description")
tags = request.form.getlist("system_tags[]")
system_tags = []
for tag in tags:
temp = db.session.query(Tag).filter(Tag.tag_name == tag).first()
if temp is None: #adds tag to database in case it doesn't exist
temp = Tag(tag)
db.session.add(temp)
system_tags.append(temp)
system_date_created = datetime.utcnow()
# saves files to server and paths to database
system_chart = request.form.get("system_chart") #series values of chart
system_chart_filename = "static/systems/charts/systemChart" + system_id #create path to save on database
chart_save_location = os.path.join(
MYDIR, system_chart_filename) #create path to save to server
with open(chart_save_location, 'w') as file:
file.write(system_chart)
system_page = request.form.get("system_page")
system_page_filename = "static/systems/pages/systemPage" + system_id + ".txt"
page_save_location = os.path.join(MYDIR, system_page_filename)
with open(page_save_location, 'w') as file:
file.write(system_page)
system_model = request.form.get("system_model")
system_model_filename = "static/systems/models/systemModel" + system_id
model_save_location = os.path.join(MYDIR, system_model_filename)
with open(model_save_location, 'w') as file:
file.write(system_model)
system = System(system_name, system_description, system_tags,
system_date_created, system_chart_filename,
system_page_filename, system_model_filename)
db.session.add(system)
db.session.commit()
return render_template('index.html')
def api_fuec_marcas_all():
system_all = System.query.first()
if system_all is None:
dict_system = dict(name=None
, address=None
, owner=None
, phone=None
, email=None
, nit_1=None
, nit_2=None
, logo=None
, sign=None
)
db.session.add(System(None, None, None, None, None, None, None, None, None))
db.session.commit()
else:
dict_system = system_all.get_json()
return jsonify(dict(jsonrpc="2.0", result=dict_system)), 200
def load_system(self):
sys_data = self.__read_csv("system")[0]
localized_sys_data = self.__read_csv("system_localized")
## READ SYSTEM
#system csv structure: name;api_key
self.system = System()
self.__fill_members_with_csv_data(self.system,
('name', 'api_key', 'base_url'),
sys_data)
## READ LOCALIZED SYSTEM DATA
# localized system csv structure lang;display_name;description;long_description
for item in localized_sys_data:
lang = LocalizedSystemInformation()
self.__fill_members_with_csv_data(
lang,
('lang', 'display_name', 'description', 'long_description'),
item)
self.system.localized_information.append(lang)
def newSystem():
"""Create a new system entry."""
with session_scope() as session:
images = session.query(Image).order_by(Image.alt_text).all()
manufacturers = session.query(Manufacturer).order_by(
Manufacturer.name).all()
if request.method == 'GET':
return render_template('new-system.html',
images=images,
manufacturers=manufacturers)
if request.method == 'POST':
system = System(
name=request.form["system_name"],
image_id=request.form["system_image"],
year_released=request.form["system_release_year"],
description=request.form["system_description"],
manufacturer_id=request.form["manufacturer"],
owner_id=login_session['user_id']
)
session.add(system)
session.commit()
return redirect(url_for('allSystems'))
def systems():
#Return all systems in the galaxy_id and their variables
if request.method == "GET":
if "galaxy_id" in request.args:
result = []
try:
g = Galaxy.query.get(request.args["galaxy_id"])
for s in g.systems:
result.append({
"id": s.id,
"name": s.name,
"quadrant": s.quadrant,
"x": s.x,
"y": s.y,
"image": s.image
})
data = {'status': 'ok', 'results': result}
except:
data = {'status': 'error', 'note': 'database error'}
elif "system_id" in request.args:
try:
s = System.query.get(request.args["system_id"])
data = {
'status': 'ok',
"id": s.id,
"name": s.name,
"quadrant": s.quadrant,
"x": s.x,
"y": s.y,
"image": s.image
}
except:
data = {'status': 'error', 'note': 'database error'}
else:
data = {'status': 'error', 'note': 'wrong params'}
resp = post(data)
return resp
#Create a new System!
if request.method == "POST" and request.headers[
'Content-Type'] == 'application/json':
provided_js = request.json
provided_galaxy_id = provided_js["galaxy_id"]
provided_name = provided_js["name"]
provided_quadrant = provided_js["quadrant"]
provided_x = provided_js["x"]
provided_y = provided_js["y"]
provided_image = provided_js["image"]
g = Galaxy.query.get(provided_galaxy_id)
if g != None:
try:
s = System(name=provided_name,
x=provided_x,
y=provided_y,
image=provided_image,
quadrant=provided_quadrant,
galaxy=g)
db.session.add(s)
db.session.commit()
data = {'status': 'ok'}
except:
db.session.rollback()
data = {'status': 'error', 'note': 'database error'}
finally:
db.session.close()
else:
data = {'status': 'error', 'note': 'galaxy does not exist'}
resp = post(data)
return resp
def setUp(self):
tinydocs.app.config[
'SQLALCHEMY_DATABASE_URI'] = 'sqlite:////tmp/tinydocs.test.db'
db.create_all()
self.c = tinydocs.app.test_client()
System(name="asystem", description="adescription").put()
def update_marca_id():
data = {}
json_data = request.get_json()
if not json_data.has_key('params') or len(json_data.get('params')) == 0:
return jsonify({"jsonrpc": "2.0", "result": False, "error": 'incorrect parameters'}), 400
params = request.json.get('params')
if params.has_key('name') and len(params['name']) != 0:
name = params['name']
data.update(dict(name=name))
else:
name = None
if params.has_key('address') and len(params['address']) != 0:
address = params['address']
data.update(dict(address=address))
else:
address = None
if params.has_key('owner') and len(params['owner']) != 0:
owner = params['owner']
data.update(dict(owner=owner))
else:
owner = None
if params.has_key('phone') and params['phone'] > 0:
phone = params['phone']
data.update(dict(phone=phone))
else:
phone = None
if params.has_key('email') and len(params['email']) != 0:
email = params['email']
data.update(dict(email=email))
else:
email = None
if params.has_key('nit_1') and params['nit_1'] > 0:
nit_1 = params['nit_1']
data.update(dict(nit_1=nit_1))
else:
nit_1 = None
if params.has_key('nit_2') and params['nit_2'] > 0:
nit_2 = params['nit_2']
data.update(dict(nit_2=nit_2))
else:
nit_2 = None
if params.has_key('secuence_contract') and params['secuence_contract'] > 0:
secuence_contract = params['secuence_contract']
data.update(dict(secuence_contract=secuence_contract))
else:
secuence_contract = None
if params.has_key('id_company_legal') and params['id_company_legal'] > 0:
id_company_legal = params['id_company_legal']
data.update(dict(id_company_legal=id_company_legal))
else:
id_company_legal = None
if params.has_key('secuence_payroll') and params['secuence_payroll'] > 0:
secuence_payroll = params['secuence_payroll']
data.update(dict(secuence_payroll=secuence_payroll))
else:
secuence_payroll = None
if params.has_key('secuence_vehicle') and params['secuence_vehicle'] > 0:
secuence_vehicle = params['secuence_vehicle']
data.update(dict(secuence_vehicle=secuence_vehicle))
else:
secuence_vehicle = None
if params.has_key('logo') and params['logo'] != None and len(params['logo']) != 0:
logo_data = params['logo'].split(',')
image_dec = logo_data[1].decode('base64')
type_data = logo_data[0].split(':')[1].split(';')[0]
if type_data == 'image/png':
data.update(dict(logo=image_dec))
logo = image_dec
else:
logo = None
else:
logo = None
if params.has_key('sign') and params['sign'] != None and len(params['sign']) != 0:
sign_data = params['sign'].split(',')
image_dec = sign_data[1].decode('base64')
type_data = sign_data[0].split(':')[1].split(';')[0]
if type_data == 'image/png':
data.update(dict(sign=image_dec))
sign = image_dec
else:
sign = None
else:
sign = None
systemF = System.query.first()
if systemF is not None and len(data) > 0:
systemF.query.update(data)
db.session.commit()
elif systemF is None:
db.session.add(System(name
, address
, phone
, owner
, email
, nit_1
, nit_2
, logo
, sign
, id_company_legal
, secuence_contract
, secuence_payroll
, secuence_vehicle))
db.session.commit()
else:
return jsonify({"jsonrpc": "2.0", "result": False}), 400
return jsonify({"jsonrpc": "2.0", "result": True}), 200
raise BadEditAuth('bad auth parameter')
return edit, d['auth']
def activate(request):
try:
edit, auth = _check_edit_auth(request, "activate")
except BadEditAuth, e:
return HttpResponseForbidden(str(e))
if not edit.confirmed and request.method == 'POST':
system = System(name=edit.name,
owner_email=edit.owner_email,
operating_system=edit.operating_system,
graphics=edit.graphics,
processor=edit.processor,
notes=edit.notes,
secret_key=edit.secret_key)
system.save()
edit.system = system
edit.confirmed = True
edit.save()
return render_to_response(
'pages/activate.html', {
'page': 'activate',
'page_title': "Activate System",
'settings': settings,
'auth': auth,
'edit': edit
def post(self, weapitoken):
r = request.get_json()
sys = System(keyword=r['keyword'], value=r['value'], ttl=r['ttl'])
db.session.add(sys)
db.session.commit()
return {'keyword': sys.keyword, 'value': sys.value, 'ttl': sys.ttl}
