def get_event(evt):
event = Event.query.get(evt)
log.info("Querying event")
if event is None:
return not_found()
results = event_schema.dump(event)
return jsonify({'event': results.data})
def sell_basegood(bg):
current_user = User.query.get(1)
basegood = BaseGood.query.get(bg)
pmap = current_user.season.pmap
if basegood is None:
return not_found()
log.info("Selling {}".format(basegood.name))
if basegood in current_user.inv_expanded():
inv = Inventory.query.\
filter(Inventory.user_id == current_user.id).\
filter(Inventory.basegood_id == basegood.id).\
first()
Inventory.query.filter_by(id=inv.id).delete()
# .delete() is designed to bulk delete
# .limit() does not work
# .first() does not work
# how to savely delete only one item? this is bad..
try:
current_user.balance += basegood.price
if pmap:
corresp_map_object = [map_o for map_o in pmap if map_o.basegood.name == basegood.name][0]
corresp_map_object.ammount += 1
results = basegood_schema.dump(basegood)
db_session.commit()
corresponding_map_object = [ x for x in pmap if x.id == bg ][0]
new_price = calculations.new_price_test1(corresponding_map_object.initial_ammount, corresponding_map_object.ammount, basegood.initprice)
basegood.price = new_price
calculate_new_prod_price(basegood.producable)
db_session.commit()
return jsonify({'message': 'sold',
'basegood': results.data})
except:
return service_unavailable()
else:
return not_in_inv()
def get_technology(tcn):
tech = Technology.query.get(tcn)
log.info("Querying technology")
if tech is None:
return not_found()
results = technology_schema.dump(tech)
return jsonify({'technology': results.data})
def get_basegood(bg):
log.info("Querying basegood")
basegood = BaseGood.query.get(bg)
if basegood is None:
return not_found()
basegood_result = basegood_schema.dump(basegood)
return jsonify({'basegood': basegood_result.data})
def get_buildqueue(usr):
current_user = User.query.get(usr)
if current_user is None:
return not_found(basegood_idbasegood_id )
log.info("Querying buildqueue for user {}".format(current_user.name))
results = buildqueue_schema.dump(current_user.buildqueue)
return jsonify({'buildqueue': results.data})
def get_effect(efc):
effect = Effect.query.get(efc)
log.info("Querying effect")
if effect is None:
return not_found()
results = effect_schema.dump(effect)
return jsonify({'effect': results.data})
def get_user(usr):
user = User.query.get(usr)
log.info("Querying user")
if user is None:
return not_found()
results = user_schema.dump(user)
return jsonify({'user': results.data})
def get_producable(pr):
producable = Producable.query.get(pr)
if producable is None:
return not_found()
else:
log.info("Querying producable")
result = producable_schema.dump(producable)
return jsonify({'producable': result.data})
def get_inventory(usr):
current_user = User.query.get(usr)
if current_user is None:
return not_found()
log.info("Querying inventory for user {}".format(current_user.name))
results = inventory_schema.dump(current_user.inventory)
return jsonify({'inventory': results.data})
def get_capabilities(bg):
basegood = BaseGood.query.get(bg)
if basegood is None:
return not_found()
else:
log.info("Querying capabilities for basegood {}".format(basegood.name))
result = capabilities_schema.dump(basegood)
return jsonify({'basegood': result.data})
def get_inventory_for_basegood(usr, bg):
current_user = User.query.get(usr)
bg = BaseGood.query.get(bg)
if current_user is None or bg is None:
return not_found()
log.info("Querying inventory for user {} and basegood {}".format(current_user.name, bg.name))
inv = Inventory.query.\
filter(Inventory.user_id == current_user.id).\
filter(Inventory.basegood_id == bg.id).all()
return jsonify({'basegood': basegood_schema.dump(bg), 'ammount': len(inv)})
def get_inventory_for_producable(usr, pr):
pr = Producable.query.get(pr)
current_user = User.query.get(usr)
if current_user is None or pr is None:
return not_found()
log.info("Querying inventory for user {} and producable {}".format(current_user.name, pr.name))
inv = Inventory.query.\
filter(Inventory.user_id == current_user.id).\
filter(Inventory.producable_id == pr.id).all()
return jsonify({'producable': producable_schema.dump(pr), 'ammount': len(inv)})
def get_blueprint(pr):
producable = Producable.query.get(pr)
if producable is None:
return not_found()
else:
log.info("Querying blueprint for producable {}".format(producable.name))
result = producable.blueprint_dict()
ret = {}
ret_arr = []
for key, value in result.items():
ret_arr.append({'basegood': basegood_schema.dump(key).data, 'ammount': value})
return jsonify(ret_arr)
def sell_producable(pr):
current_user = User.query.get(1)
producable = Producable.query.get(pr)
if producable is None:
return not_found()
if producable in current_user.inv_expanded():
log.info("Selling {}".format(producable.name))
inv = Inventory.query.\
filter(Inventory.user_id == current_user.id).\
filter(Inventory.producable_id == producable.id).\
first()
Inventory.query.filter_by(id=inv.id).delete()
try:
db_session.commit()
current_user.balance += producable.price
results = producable_schema.dump(producable)
return jsonify({'message': 'sold',
'producable': results.data})
except:
return service_unavailable()
else:
return not_in_inv()
def trigger_build(pr):
current_user = User.query.get(1)
producable = Producable.query.get(pr)
if producable is None:
return not_found()
log.info("Triggering build for {}".format(producable.name))
inv = current_user.inv_expanded()
for basegood in producable.blueprint():
if basegood in inv:
# dont know if thats the best option ?
# just count the respective len and ask the DB
inv.remove(basegood)
else:
return insufficient_funds()
for basegood in producable.blueprint():
# .delete() is designed to bulk delete
# .limit() does not work
# .first() does not work
# how to savely delete only one item? this is bad..
inv = Inventory.query.\
filter(Inventory.user_id == current_user.id).\
filter(Inventory.basegood_id == basegood.id).\
first()
Inventory.query.filter_by(id=inv.id).delete()
try:
build_queue = BuildQueue(user_id=current_user.id,
producable_id=producable.id,
time_start=datetime.datetime.utcnow(),
time_done=datetime.datetime.utcnow() +
datetime.timedelta(minutes=producable.time),
active=False,
processed=False)
db_session.add(build_queue)
db_session.commit()
result = producable_schema.dump(producable)
return jsonify({'message': 'production initialized',
'producable': result.data})
except:
return service_unavailable()
def buy_producable(pr):
current_user = User.query.get(1)
producable = Producable.query.get(pr)
if producable is None:
return not_found()
log.info("Buying {}".format(producable.name))
# TODO: Only allow to buy from a CPU.
# CPU has it's own inventory
if current_user.has_enough_money_for(producable):
inv = Inventory(user_id=current_user.id,
basegood_id=None,
producable_id=producable.id)
current_user.inventory.append(inv)
try:
current_user.balance -= producable.price
db_session.commit()
results = producable_schema.dump(producable)
return jsonify({'message': 'bought',
'producable': results.data})
except:
return service_unavailable()
else:
return insufficient_funds()
def buy_basegood(bg):
current_user = User.query.get(1)
basegood = BaseGood.query.get(bg)
if basegood is None:
return not_found()
log.info("Buying {}".format(basegood.name))
pmap = current_user.season.pmap
# Find the map object that has pmap.basegood.name => basegood.name
if pmap:
corresp_map_object = [map_o for map_o in pmap if map_o.basegood.name == basegood.name][0]
if current_user.has_enough_money_for(basegood):
# and if basegood is still available -> check map_resoources
# Change when bulk buys are implemented
if corresp_map_object.ammount < 1:
return resource_exceeded()
corresp_map_object.ammount -= 1
inv = Inventory(user_id=current_user.id,
basegood_id=basegood.id,
producable_id=None)
current_user.inventory.append(inv)
current_user.balance -= basegood.price
try:
db_session.commit()
results = basegood_schema.dump(basegood)
corresponding_map_object = [ x for x in pmap if x.id == bg ][0]
new_price = calculations.new_price_test1(corresponding_map_object.initial_ammount, corresponding_map_object.ammount, basegood.initprice)
basegood.price = new_price
db_session.commit()
calculate_new_prod_price(basegood.producable)
return jsonify({'message': 'bought',
'basegood': results.data})
except:
return service_unavailable()
else:
return insufficient_funds()
else:
return resource_exceeded()
def process_buildqueue():
while (1):
prs = Producable.query.all()
for pr in prs:
log.debug("Checking buildqueue for {}".format(pr.name))
queue = BuildQueue.query.filter(BuildQueue.active == True).filter(
BuildQueue.producable_id == pr.id)
itm = queue.first()
if not itm:
# add a 'done' callback that compares time_done and datetime.now
log.info(
"Getting BuildQueue items with criteria: Not active, Not Processed"
)
all_possible_new = BuildQueue.query.filter(
BuildQueue.active == False).filter(
BuildQueue.processed == False).filter(
BuildQueue.producable_id == pr.id)
if len(
all_possible_new.filter(BuildQueue.time_done > datetime
.datetime.now()).all()) > 0:
log.info(
"Found items that have not been processed although they are done."
)
log.info("Do something")
apn = all_possible_new.all()
if len(apn) >= 1:
apn[0].active = True
db_session.commit()
log.info("Setting item {} to active".format(apn[0].id))
else:
log.info("No items in buildqueue for Producable {}".format(
pr.name))
if itm:
log.info("#{} has an active flag".format(itm.id))
now = datetime.datetime.now()
if itm.time_done <= now:
inv = Inventory(basegood_id=None,
producable_id=itm.producable_id,
user_id=itm.user_id)
prod_name = Producable.query.get(itm.producable_id).name
user_name = User.query.get(itm.user_id).name
log.info("{} finished building.".format(prod_name))
log.info("Adding {} to {}'s inventory".format(
prod_name, user_name))
itm.active = False
itm.processed = True
log.info("Marking #{} as processed and Non-active".format(
itm.id))
db_session.add(inv)
db_session.commit()
else:
d1_ts = time.mktime(now.timetuple())
d2_ts = time.mktime(itm.time_done.timetuple())
minutes_left = int(d2_ts - d1_ts) / 60
log.info(
"#{} is not ready yet. Takes {} minutes more.".format(
itm.id, minutes_left))
time.sleep(3)
def get_events():
log.info("Querying events")
events = Event.query.all()
results = events_schema.dump(events)
return jsonify({'events': results.data})
def get_effects():
log.info("Querying effects")
effects = Effect.query.all()
results = effects_schema.dump(effects)
return jsonify({'effects': results.data})
def get_technologies():
log.info("Querying technolgies")
technologies = Technology.query.all()
results = technologies_schema.dump(technologies)
return jsonify({'techonologies': results.data})
def get_basegoods():
log.info("Querying basegoods")
basegoods = BaseGood.query.all()
results = basegoods_schema.dump(basegoods)
return jsonify({'basegoods': results.data})
def get_producables():
log.info("Querying producables")
producables = Producable.query.all()
results = producables_schema.dump(producables)
return jsonify({'producables': results.data})