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 loadSystem(request):
f = open('C:/Users/anna/Desktop/Doktorat/typeii/src/typeii/sourceData/proteins_new.csv')
systems = []
first_line = 1
pieces = DNAPiece.objects.all()
for line in f:
p = line.split(',')
system_number = p[3]
if system_number in systems or first_line == 1:
first_line = 0
pass
else:
dnapiece = p[2].replace('"', '')
subunit_composition = p[8].replace('"', '')
family_composition = p[9].replace('"', '')
split_family = family_composition.split('_')
merge = ''
for idx, char in enumerate(subunit_composition):
merge += char
merge += split_family[idx]+'_'
subunit_family_composition = merge
system_kind = p[14].replace('"', '')
real_name = ''
print (subunit_composition + ' ' + family_composition + ' ' + subunit_family_composition + ' ' +
system_kind + ' ' + real_name)
systems.append(system_number)
for record in pieces:
if record.name == dnapiece:
s = System(dnapiece=record, subunit_composition=subunit_composition, family_composition=family_composition,
subunit_family_composition=subunit_family_composition, system_kind=system_kind,
real_name=real_name)
s.save()
print ('System added')
return HttpResponse('Action complete.')
def post(self):
user = users.get_current_user()
if not user:
self.redirect(users.create_login_url())
system_id = self.request.get("system")
if not system_id:
template = JINJA_ENVIRONMENT.get_template(
"templates/not_found.html")
template_values = {
"user": user,
"users": users,
"not_found_msg": "Please select a system"
}
self.response.write(template.render(template_values))
return
sys = System.get_by_id(system_id)
if sys is None:
template = JINJA_ENVIRONMENT.get_template(
"templates/not_found.html")
template_values = {
"user": user,
"users": users,
"not_found_msg": "The system #{0} not exists".format(system_id)
}
self.response.write(template.render(template_values))
return
sys.key.delete()
# Hack to not use sleep solution
found = True
systems = []
while found:
found = False
systems = System.query().fetch()
print(systems)
for system in systems:
print(system.key.id(), sys.key.id())
if system.key.id() == sys.key.id():
found = True
break
systems = System.query().fetch()
template_values = {
"systems": systems,
"message": {
"type": "success",
"payload": "Deleted system #{0}".format(system_id)
},
"user": user,
"users": users
}
template = JINJA_ENVIRONMENT.get_template("templates/list_system.html")
self.response.write(template.render(template_values))
return
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 organize_assets_by_location(character, asset_list):
asset_ids = set(entry['item_id'] for entry in asset_list)
asset_dict = {entry['item_id']: entry for entry in asset_list}
location_set = set(entry['location_id'] for entry in asset_list)
location_data_dict = {id: {'items': {}} for id in location_set}
for entry in asset_list:
location_data_dict[entry['location_id']]['items'][
entry['item_id']] = entry
for item_id, entry in asset_dict.items():
if item_id in location_data_dict:
entry['items'] = location_data_dict[item_id]['items']
location_id_list = list(
set(location_data_dict.keys()).difference(asset_ids))
location_model_dict = get_location_multi(character, location_id_list)
systems_dict = {}
for location_id in location_model_dict:
location = location_model_dict[location_id]
location_data_dict[location_id]['name'] = location.name
if isinstance(location, System):
system = location
elif location.system_id is not None:
system = System.get(location.system_id)
else:
system = DummySystem
systems_dict[system.id] = systems_dict.get(system.id, (system, []))
systems_dict[system.id][1].append(location_id)
return_dict = {}
for system, location_list in systems_dict.values():
if system.region_id is not None:
region = Region.get(system.region_id)
else:
region = DummyRegion
if region.id not in return_dict:
return_dict[region.id] = {
'redlisted': [],
'name': region.name,
'items': {},
'id': region.id,
}
if region.is_redlisted:
return_dict[region.id]['redlisted'].append('name')
return_dict[region.id]['items'][system.id] = {
'redlisted': [],
'name': system.name,
'id': system.id,
'items':
{id: location_data_dict[id]
for id in systems_dict[system.id][1]},
}
if system.is_redlisted:
return_dict[region.id]['items'][system.id]['redlisted'].append(
'name')
return return_dict
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 move_ship(request, game_id):
err = _check_phase(request.game, game_constants.MOVE_PHASE)
if err:
return err
system_id = System.id_str_to_pk(request.REQUEST['systemId'])
ship_id = Ship.id_str_to_pk(request.REQUEST['shipId'])
system = System.objects.get(pk=system_id)
ship = Ship.objects.get(pk=ship_id)
if ship.owner != request.player:
return _forbidden("You don't own that ship!")
if ship.on_deploy_queue:
return _forbidden(
"That ship is deploying; cancel deployment to move it")
enemy_fighters = ship.system.ship_set.exclude(owner=request.player). \
exclude(attack_tech=0)
if len(enemy_fighters):
return _forbidden("You can't run from enemy ships")
lane_traveled = ship.system.neighbors.filter(system=system)
if not lane_traveled or not lane_traveled[0].lane.passable:
return _forbidden("Those systems aren't connected")
ship.system = system
ship.moves -= 1
ship.save();
map_changed = False
if request.player not in system.visible_to.all():
system.visible_to.add(request.player)
map_changed = True
neighbors = system.neighbors.all()
for neighbor in neighbors:
if request.player not in neighbor.lane.visible_to.all():
map_changed = True
neighbor.lane.visible_to.add(request.player)
neighbor.lane.save()
_game_state_changed(request.game)
if map_changed:
_map_changed(request.game, [request.player])
return _json(_game_state(request.game, request.player))
def get(self):
user = users.get_current_user()
if not user:
self.redirect(users.create_login_url())
systems = System.query().fetch()
template_values = {
"systems": systems,
"message": {
"type": "success",
"payload": ""
},
"user": user,
"users": users
}
template = JINJA_ENVIRONMENT.get_template("templates/list_system.html")
self.response.write(template.render(template_values))
return
def process_mining(mining_data):
return_list = []
for entry in mining_data:
redlisted = []
type = Type.get(entry['type_id'])
system = System.get(entry['solar_system_id'])
if system.is_redlisted:
redlisted.append('system_name')
return_list.append({
'date': entry['date'],
'quantity': entry['quantity'],
'system_id': entry['solar_system_id'],
'system_name': system.name,
'type_id': entry['type_id'],
'type_name': type.name,
'value': entry['quantity'] * type.price,
'redlisted': redlisted,
})
return {'info': return_list}
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 post(self):
try:
log_param = json.loads(self.request.body)
except ValueError as e:
self.response.out.write(e)
self.response.set_status(400)
return
except:
self.response.set_status(500)
return
if not isinstance(log_param, list):
log_param = [log_param]
for log_item in log_param:
log_system = log_item.get("system")
if not log_system:
self.response.out.write("System not found")
self.response.set_status(404)
system = System.get_by_id(log_system)
if not system:
self.response.out.write("System not found")
self.response.set_status(404)
return
try:
log_key = ndb.Key("Log", log_item.get("id"), parent=system.key)
log_msg = log_item.get("msg")
log_level = log_item.get("level")
log_ts = log_item.get("ts")
log = Log(key=log_key, msg=log_msg, level=log_level, ts=log_ts)
# CHANNEL API
channel.send_message(system.key.id(),
json.dumps(log.to_dict()))
except BadValueError as e:
self.response.out.write(e)
self.response.set_status(400)
return
return
def helper_test_assets_success(self, result):
for region_id, region_data in result.items():
if region_id > 0:
region = Region.get(region_id)
self.assertEqual(region_data['name'], region.name)
self.assertIsInstance(region_data['items'], dict)
for system_id, system_data in region_data['items'].items():
if system_id > 0:
system = System.get(system_id)
self.assertIsInstance(system_data, dict)
self.assertEqual(system_data['name'], system.name)
self.assertIsInstance(system_data['items'], dict)
for structure_id, structure_data in system_data['items'].items(
):
self.assertIsInstance(structure_data, dict)
self.assertIsInstance(structure_data['name'], str)
self.assertIsInstance(structure_data['items'], dict)
for identifier, data in structure_data['items'].items():
self.assertIsInstance(identifier, int)
self.helper_process_asset_item(data)
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 get(self):
user = users.get_current_user()
system_param = self.request.get('system')
if not system_param:
template = JINJA_ENVIRONMENT.get_template(
"templates/not_found.html")
template_values = {
"user": user,
"users": users,
"not_found_msg": "Please select a system"
}
self.response.write(template.render(template_values))
return
system = System.get_by_id(system_param)
if system is None:
template = JINJA_ENVIRONMENT.get_template(
"templates/not_found.html")
template_values = {
"user": user,
"users": users,
"not_found_msg":
"The system #{0} not exists".format(system_param)
}
self.response.write(template.render(template_values))
return
#logs = Log.query(ancestor = system.key).fetch()
logs = []
template_values = {
"system": system,
"logs": logs,
"token": channel.create_channel(system.key.id()),
"user": user,
"users": users
}
template = JINJA_ENVIRONMENT.get_template("templates/logs.html")
self.response.write(template.render(template_values))
return
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 get_location_multi(character, location_id_list, raise_on_missing=True):
station_id_list = []
structure_id_list = []
system_id_list = []
for location_id in location_id_list:
if 60000000 <= location_id < 64000000: # station
station_id_list.append(location_id)
elif 30000000 < location_id < 32000000: # system
system_id_list.append(location_id)
elif location_id > 50000000: # structure
structure_id_list.append(location_id)
elif location_id == 2004:
structure_id_list.append(location_id)
elif raise_on_missing:
raise BadLocationError(
'location_id {} does not correspond to station'
', system, or structure'.format(location_id))
location_dict = {}
location_dict.update(Station.get_multi(station_id_list))
location_dict.update(System.get_multi(system_id_list))
location_dict.update(Structure.get_multi(character, structure_id_list))
return location_dict
def get_character_planetary_interaction(character_id, current_user=None):
character = Character.get(character_id)
character_application_access_check(current_user, character)
planet_data = character.get_op(
'get_characters_character_id_planets',
character_id=character_id,
)
system_ids = set()
for entry in planet_data:
system_ids.add(entry['solar_system_id'])
system_dict = System.get_multi(list(system_ids))
for entry in planet_data:
entry['redlisted'] = []
system = system_dict[entry.pop('solar_system_id')]
entry['system_id'] = system.id
entry['system_name'] = system.name
entry['region_id'] = system.region_id
entry['region_name'] = system.region.name
if system.is_redlisted:
entry['redlisted'].append('system_name')
if system.region.is_redlisted:
entry['redlisted'].append('region_name')
return {'info': planet_data}
if not edit.check_auth(action, d['auth']):
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}
def init(m):
User.create_table(fail_silently=True)
Message.create_table(fail_silently=True)
System.create_table(fail_silently=True)
System.init()
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 get(self):
user = users.get_current_user()
systems = System.query().fetch()
template_values = {"systems": systems, "user": user, "users": users}
template = JINJA_ENVIRONMENT.get_template("templates/index.html")
self.response.write(template.render(template_values))
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
