def search():
if request.args.get("id"):
return redirect(url_for("ordering.home",
item=request.args.get("id") + ";" + request.args.get("qty-" +
request.args.get("id"), 1)))
elif not request.args.get("name"):
return redirect(url_for("ordering.home"))
regex_search = re.compile(request.args.get("name", ""), re.IGNORECASE)
item_list = {}
for item in g.mongo.db.items.find({"name": regex_search}):
if item["name"].find("SKIN") == -1 and item["name"].lower().find("blueprint") == -1:
item_list[item["_id"]] = [item["name"], "{:,.02f}".format(item["volume"])]
prices, prices_usable = market_hub_prices(list(item_list.keys()))
search_table = []
for key, value in item_list.items():
search_table.append(value + ["{:,.02f}".format(prices[key]["sell"]), 1, key])
with open("configs/base.json") as base_config_file:
base_config = json.load(base_config_file)
market_hub_name = base_config["market_hub_name"]
return render_template("ordering_search.html", search_table=search_table, market_hub_name=market_hub_name,
prices_usable=prices_usable)
def search():
if request.args.get("id"):
return redirect(
url_for("ordering.home",
item=request.args.get("id") + ";" +
request.args.get("qty-" + request.args.get("id"), 1)))
elif not request.args.get("name"):
return redirect(url_for("ordering.home"))
regex_search = re.compile(request.args.get("name", ""), re.IGNORECASE)
item_list = {}
for item in g.mongo.db.items.find({"name": regex_search}):
if item["name"].find("SKIN") == -1 and item["name"].lower().find(
"blueprint") == -1:
item_list[item["_id"]] = [
item["name"], "{:,.02f}".format(item["volume"])
]
prices, prices_usable = market_hub_prices(list(item_list.keys()))
search_table = []
for key, value in item_list.items():
search_table.append(value +
["{:,.02f}".format(prices[key]["sell"]), 1, key])
with open("configs/base.json") as base_config_file:
base_config = json.load(base_config_file)
market_hub_name = base_config["market_hub_name"]
return render_template("ordering_search.html",
search_table=search_table,
market_hub_name=market_hub_name,
prices_usable=prices_usable)
def home(item=""):
cart_item_list = {}
error_string = request.args.get("error_string")
bulk_op_update = g.mongo.db.carts.initialize_unordered_bulk_op()
bulk_run_update = False
# Change qty if post from this page
if request.method == "POST" and request.form.get("action") == "qty":
for key, value in request.form.items():
if key != "action" and not key.startswith("DataTables"):
if value.strip():
if int(float(value)) != 0:
bulk_op_update.find({"_id": session["CharacterOwnerHash"]}).upsert().update({
"$set": {"items." + key: int(float(value))}})
else:
bulk_op_update.find({"_id": session["CharacterOwnerHash"]}).upsert().update({
"$unset": {"items." + key: int(float(value))}})
bulk_run_update = True
if request.method == "POST" and request.form.get("action") == "clear":
g.mongo.db.carts.remove({"_id": session["CharacterOwnerHash"]})
# Add new item to database
input_string = request.form.get("parse", session.get("fitting"))
if item or input_string:
if item:
try:
item_adjustment_list = item.split(":")
for adjustment_item in item_adjustment_list:
adjustment_item_info = adjustment_item.split(";")
if request.args.get("action") == "edit":
bulk_op_update.find({"_id": session["CharacterOwnerHash"]}).upsert().update({
"$set": {"items." + adjustment_item_info[0]: int(adjustment_item_info[1])}})
else:
bulk_op_update.find({"_id": session["CharacterOwnerHash"]}).upsert().update({
"$inc": {"items." + adjustment_item_info[0]: int(adjustment_item_info[1])}})
bulk_run_update = True
except IndexError:
error_string = "Was not able to add {}".format(item)
elif input_string:
session.pop("fitting", None)
parse_error = None
parse_result = ""
try:
if input_string.startswith("["):
eft_parser = conversions.eft_parsing(input_string)
parse_result = eft_parser[3] # DNA String
parse_error = eft_parser[4]
else:
parse_array = []
item_input, item_qty = conversions.manual_parsing(input_string)[1:3]
pre_parse_db = g.mongo.db.items.find({"name": {"$in": item_input}})
for pre_parse_item in pre_parse_db:
parse_array.append(str(pre_parse_item["_id"]) + ";" +
str(item_qty[pre_parse_item["name"].upper()]))
if len(parse_array) != len(item_input):
error_string = "There is an item that could not be parsed. Check your input and try again."
parse_result = ":".join(parse_array)
except KeyError:
error_string = "Could not parse the input. Please ensure it is correctly formatted."
if parse_error:
if parse_error == "parsing":
error_string = "Could not parse the EFT-Formatted fit. Please ensure it is correctly formatted."
else:
error_string = parse_error
parse_item_list = parse_result.split(":")
for parse_item in parse_item_list:
if parse_item:
direct_info = parse_item.split(";")
if len(direct_info) == 1:
bulk_op_update.find({"_id": session["CharacterOwnerHash"]}).upsert().update({
"$inc": {"items." + direct_info[0]: 1}})
bulk_run_update = True
else:
bulk_op_update.find({"_id": session["CharacterOwnerHash"]}).upsert().update({
"$inc": {"items." + direct_info[0]: int(direct_info[1])}})
bulk_run_update = True
if bulk_run_update:
bulk_op_update.execute()
if item or input_string:
flash(error_string)
return redirect(url_for("ordering.home"))
else:
error_string = get_flashed_messages()
error_string = error_string[0] if error_string else None
# Load cart
total_volume = 0
sell_price = 0
current_cart = g.mongo.db.carts.find_one({"_id": session["CharacterOwnerHash"]})
fittings_info = []
fittings_breakdown = {}
# Redirect to fittings if saving pack
ordering_admin = auth_check("ordering_admin")
if ordering_admin and request.form.get("action") == "pack":
pack_fit = {
"fit": "",
"items": {},
"submitter": session["CharacterOwnerHash"],
"price": 0,
"volume": 0,
"name": request.form.get("pack"),
"notes": None,
"dna": None,
"ship": "Pack",
"source": None,
"doctrine": False
}
fit_array = []
dna_array = []
for table_key, table_info in current_cart.get("item_table", {}).items():
pack_fit["items"][table_info["name"]] = table_info["qty"]
fit_array.append(table_info["name"] + " " + str(table_info["qty"]))
dna_array.append(table_key + ";" + str(table_info["qty"]))
pack_fit["fit"] = "\n".join(fit_array)
pack_fit["dna"] = ":".join(dna_array)
fit_id = g.mongo.db.fittings.insert(pack_fit)
return redirect(url_for("fittings.fit", fit_id=fit_id))
# Determine processing cost
order_db = g.mongo.db.preferences.find_one({"_id": "ordering"})
if session["UI_Corporation"]:
order_tax = order_db.get("tax_corp", 0) if order_db else 0
else:
order_tax = order_db.get("tax", 0) if order_db else 0
# Continue loading cart
if current_cart and current_cart.get("items"):
cart_item_list_pre = current_cart["items"]
# Filter fittings from items
fittings_id_list = []
for cart_item_id, cart_item_qty in cart_item_list_pre.items():
try:
fittings_id_list.append(ObjectId(cart_item_id))
except bson.errors.InvalidId:
cart_item_list[cart_item_id] = cart_item_qty
# Unpack fittings
for selected_fit in g.mongo.db.fittings.find({"_id": {"$in": fittings_id_list}}):
fit_item_list = selected_fit["dna"].split(":")
fittings_info.append([str(selected_fit["_id"]),
"[Fit] " + selected_fit["name"],
current_cart["items"][str(selected_fit["_id"])],
"{:,.02f}".format(selected_fit["volume"]),
"{:,.02f}".format(selected_fit["price"] * (1 + order_tax / 100)),
"{:,.02f}".format(selected_fit["volume"] *
current_cart["items"][str(selected_fit["_id"])]),
"{:,.02f}".format(selected_fit["price"] *
current_cart["items"][str(selected_fit["_id"])] *
(1 + order_tax / 100))
])
sell_price += selected_fit["price"] * current_cart["items"][str(selected_fit["_id"])]
for fit_item in fit_item_list:
if fit_item:
item_info = fit_item.split(";")
fittings_breakdown.setdefault(item_info[0], 0)
if len(item_info) == 1:
fittings_breakdown[item_info[0]] += 1 * current_cart["items"][str(selected_fit["_id"])]
else:
fittings_breakdown[item_info[0]] += int(item_info[1]) * current_cart["items"][
str(selected_fit["_id"])]
cart_item_list_int = [int(x) for x in cart_item_list.keys()]
fittings_breakdown_int = [int(x) for x in fittings_breakdown.keys()]
prices_int = cart_item_list_int + fittings_breakdown_int
prices, prices_usable = market_hub_prices(prices_int) if prices_int else ({}, True)
full_cart = {}
invoice_info = [["Name", "Qty", "Vol/Item", "Isk/Item + Markup",
"Vol Subtotal", "Isk Subtotal w/ Markup"]] + fittings_info
for db_item in g.mongo.db.items.find({"_id": {"$in": cart_item_list_int}}):
invoice_info.append([
db_item["_id"],
db_item["name"],
cart_item_list[str(db_item["_id"])],
"{:,.02f}".format(db_item["volume"]),
"{:,.02f}".format(prices[db_item["_id"]]["sell"] * (1 + order_tax / 100)),
"{:,.02f}".format(db_item["volume"] * cart_item_list[str(db_item["_id"])]),
"{:,.02f}".format(prices[db_item["_id"]]["sell"] * cart_item_list[str(db_item["_id"])] *
(1 + order_tax / 100))
])
full_cart[str(db_item["_id"])] = {
"name": db_item["name"],
"qty": cart_item_list[str(db_item["_id"])],
"volume": db_item["volume"],
"price": prices[db_item["_id"]]["sell"],
"volume_total": db_item["volume"] * cart_item_list[str(db_item["_id"])],
"price_total": prices[db_item["_id"]]["sell"] * cart_item_list[str(db_item["_id"])]
}
total_volume += db_item["volume"] * cart_item_list[str(db_item["_id"])]
sell_price += prices[db_item["_id"]]["sell"] * cart_item_list[str(db_item["_id"])]
breakdown_info = [["Name", "Qty", "Vol/Item", "Isk/Item + Markup", "Vol Subtotal", "Isk Subtotal w/ Markup"]]
for db_item_breakdown in g.mongo.db.items.find({"_id": {"$in": fittings_breakdown_int}}):
breakdown_info.append([
db_item_breakdown["_id"],
db_item_breakdown["name"],
fittings_breakdown[str(db_item_breakdown["_id"])],
"{:,.02f}".format(db_item_breakdown["volume"]),
"{:,.02f}".format(prices[int(db_item_breakdown["_id"])]["sell"] * (1 + order_tax / 100)),
"{:,.02f}".format(db_item_breakdown["volume"] * fittings_breakdown[str(db_item_breakdown["_id"])]),
"{:,.02f}".format(prices[int(db_item_breakdown["_id"])]["sell"] *
fittings_breakdown[str(db_item_breakdown["_id"])] * (1 + order_tax / 100))
])
total_volume += db_item_breakdown["volume"] * fittings_breakdown[str(db_item_breakdown["_id"])]
if full_cart.get(str(db_item_breakdown["_id"])):
full_cart[str(db_item_breakdown["_id"])]["qty"] += fittings_breakdown[str(db_item_breakdown["_id"])]
full_cart[str(db_item_breakdown["_id"])]["volume_total"] += (db_item_breakdown["volume"] *
fittings_breakdown[
str(db_item_breakdown["_id"])])
full_cart[str(db_item_breakdown["_id"])]["price_total"] += (prices[int(db_item_breakdown["_id"])]["sell"] *
fittings_breakdown[
str(db_item_breakdown["_id"])])
else:
full_cart[str(db_item_breakdown["_id"])] = {
"id": db_item_breakdown["_id"],
"name": db_item_breakdown["name"],
"qty": fittings_breakdown[str(db_item_breakdown["_id"])],
"volume": db_item_breakdown["volume"],
"price": prices[int(db_item_breakdown["_id"])]["sell"],
"volume_total": db_item_breakdown["volume"] * fittings_breakdown[str(db_item_breakdown["_id"])],
"price_total": (prices[int(db_item_breakdown["_id"])]["sell"] *
fittings_breakdown[str(db_item_breakdown["_id"])])
}
# List routes
with open("configs/base.json") as base_config_file:
base_config = json.load(base_config_file)
market_hub_name = base_config["market_hub_name"]
min_id_limit = base_config["market_hub_station"] * 100000000
max_id_limit = base_config["market_hub_station"] * 100000000 + 100000000
market_hub_routes = g.mongo.db.jf_routes.find({"_id": {"$gte": min_id_limit, "$lt": max_id_limit}})
if request.args.get("end"):
selected_route = int(request.args.get("end"))
else:
selected_route = 0
valid_stations = []
route_name = ""
new_cart = g.mongo.db.carts.find_one({"_id": session["CharacterOwnerHash"]})
for route in market_hub_routes:
if request.args.get("end"):
if route["_id"] == int(request.args.get("end")):
valid_stations.append([route["_id"], route["end"], True])
selected_route = route["_id"] if selected_route == 0 else selected_route
route_name = route["end"]
else:
valid_stations.append([route["_id"], route["end"], False])
elif new_cart:
if route["_id"] == new_cart.get("route"):
valid_stations.append([route["_id"], route["end"], True])
selected_route = route["_id"] if selected_route == 0 else selected_route
route_name = route["end"]
else:
valid_stations.append([route["_id"], route["end"], False])
elif not request.args.get("end") and route["end"] == base_config["default_ship_to"]:
valid_stations.append([route["_id"], route["end"], True])
selected_route = route["_id"] if selected_route == 0 else selected_route
route_name = route["end"]
else:
valid_stations.append([route["_id"], route["end"], False])
# JF Calculations
if selected_route == 0:
selected_route = int(str(base_config["market_hub_station"]) + str(base_config["home_station"]))
selected_route_info = g.mongo.db.jf_routes.find_one({"_id": selected_route})
if selected_route_info:
rate_info = conversions.valid_value(selected_route_info["prices"], time.time())
if session.get("UI_Corporation"):
jf_rate = rate_info["corp"]
else:
jf_rate = rate_info["general"]
jf_total = jf_rate * total_volume
# Min 1 Mil Isk
if jf_total < 1000000:
jf_total = 1000000
else:
jf_rate = 0
jf_total = 0
order_tax_total = sell_price * order_tax / 100
order_total = jf_total + sell_price + order_tax_total
# List of characters and notes
character_list = []
db_api_list = g.mongo.db.api_keys.find_one({"_id": session["CharacterOwnerHash"]})
if not request.args.get("action") == "character" and current_cart and request.args.get("action") != "order":
current_character = current_cart.get("contract_to")
elif request.args.get("character"):
current_character = request.args.get("character")
else:
current_character = session["CharacterName"]
if not request.args.get("action") == "notes" and current_cart and request.args.get("action") != "order":
notes = current_cart.get("notes", "")
else:
notes = request.args.get("notes", "")
if db_api_list:
for character in db_api_list["keys"]:
if character["character_name"] == current_character:
character_list.append((character["character_name"], True))
else:
character_list.append((character["character_name"], False))
# Update DB
g.mongo.db.carts.update({"_id": session["CharacterOwnerHash"]},
{"$set": {
"item_table": full_cart,
"route": selected_route,
"volume": total_volume,
"jf_rate": jf_rate,
"jf_total": jf_total,
"sell_price": sell_price,
"order_total": order_total,
"jf_end": route_name,
"order_tax": order_tax,
"order_tax_total": order_tax_total,
"prices_usable": prices_usable,
"notes": notes,
"contract_to": current_character
}}, upsert=True)
if request.args.get("action") == "order":
return redirect(url_for("ordering.invoice"))
# Round order total
order_total = round(order_total + 50000, -5)
# Formatting
total_volume = "{:,.02f}".format(total_volume)
sell_price = "{:,.02f}".format(sell_price)
jf_total = "{:,.02f}".format(jf_total)
order_total = "{:,.02f}".format(order_total)
order_tax = "{:,.02f}".format(order_tax)
order_tax_total = "{:,.02f}".format(order_tax_total)
return render_template("ordering.html", invoice_info=invoice_info, total_volume=total_volume,
sell_price=sell_price, valid_stations=valid_stations, jf_rate=jf_rate,
jf_total=jf_total, order_total=order_total, market_hub_name=market_hub_name,
prices_usable=prices_usable, error_string=error_string, breakdown_info=breakdown_info,
order_tax=order_tax, order_tax_total=order_tax_total, character_list=character_list,
notes=notes, ordering_admin=ordering_admin)
def price_calc(names, character_id, jf_rate=0):
item_list = g.mongo.db.items.find({"name": {"$in": names}})
id_list = g.mongo.db.items.find({"name": {"$in": names}}).distinct("_id")
mineral_list = {}
item_materials = conversions.refine_calc(id_list, character_id)
material_id_list = set()
non_refine_list = []
for item in item_list:
if item["materials"] and (not item["meta"] or item["meta"] < 4):
for material_id, material_amount in item_materials[item["_id"]].items():
material_id_list.add(material_id)
mineral_list.setdefault(material_id, 0)
mineral_list[material_id] += material_amount
else:
item_materials[item["_id"]] = {}
non_refine_list.append(item["_id"])
market_prices, prices_usable = eve_central.market_hub_prices(list(mineral_list.keys()) +
list(item_materials.keys()) +
non_refine_list)
# Material info for volume
material_info_db = g.mongo.db.items.find({"_id": {"$in": list(material_id_list)}})
material_volumes = {}
for material_info in material_info_db:
material_volumes[material_info["_id"]] = material_info.get("volume", 0)
# Tax Checks
taxes_list = g.mongo.db.taxes.find({"_id": {"$in": list(item_materials.keys()) + non_refine_list}})
tax_definition = {}
for tax_item in taxes_list:
tax_definition[tax_item["_id"]] = tax_item["tax"]
refine_preferences = g.mongo.db.preferences.find_one({"_id": "buyback_yield"})
if refine_preferences:
default_tax = refine_preferences.get("tax", 0)
default_refine_tax = refine_preferences.get("tax_refine", 0)
else:
default_tax = 0
default_refine_tax = 0
# Refined Calculations
calculations = {}
for key, value in item_materials.items():
item_cost = 0
volume = 0
for material_id, material_amount in value.items():
item_cost += material_amount * market_prices[material_id]["buy"]
volume += material_amount * material_volumes[material_id]
jf_price = jf_rate * volume
calculations[key] = {"total": item_cost * (1 - tax_definition.get(key, default_refine_tax) / 100),
"no_tax": item_cost,
"sell": market_prices[key]["sell"],
"buy": market_prices[key]["buy"],
"volume": volume,
"jf_price": jf_price,
"delta_sell": item_cost - (market_prices[key]["sell"] - jf_price),
"delta_buy": item_cost - (market_prices[key]["buy"] - jf_price),
"tax": tax_definition.get(key, default_refine_tax)}
# Info for non-refined
non_refine_info_db = g.mongo.db.items.find({"_id": {"$in": non_refine_list}})
# Non-refined modules
for non_refine_item in non_refine_info_db:
calculations[non_refine_item["_id"]] = {
"total": market_prices[non_refine_item["_id"]]["buy"] * (
1 - tax_definition.get(non_refine_item["_id"], default_tax) / 100),
"no_tax": market_prices[non_refine_item["_id"]]["buy"],
"sell": market_prices[non_refine_item["_id"]]["sell"],
"buy": market_prices[non_refine_item["_id"]]["buy"],
"volume": non_refine_item["volume"],
"jf_price": non_refine_item["volume"] * jf_rate,
"delta_sell": item_cost - (market_prices[non_refine_item["_id"]]["sell"] - jf_price),
"delta_buy": item_cost - (market_prices[non_refine_item["_id"]]["buy"] - jf_price),
"tax": tax_definition.get(non_refine_item["_id"], default_tax)
}
mineral_prices = {}
for mineral in mineral_list.keys():
mineral_prices[mineral] = market_prices[mineral]
return calculations, mineral_prices, item_materials, prices_usable
def home(item=""):
cart_item_list = {}
error_string = request.args.get("error_string")
bulk_op_update = g.mongo.db.carts.initialize_unordered_bulk_op()
bulk_run_update = False
# Change qty if post from this page
if request.method == "POST" and request.form.get("action") == "qty":
for key, value in request.form.items():
if key != "action" and not key.startswith("DataTables"):
if value.strip():
if int(float(value)) != 0:
bulk_op_update.find({
"_id":
session["CharacterOwnerHash"]
}).upsert().update(
{"$set": {
"items." + key: int(float(value))
}})
else:
bulk_op_update.find({
"_id":
session["CharacterOwnerHash"]
}).upsert().update(
{"$unset": {
"items." + key: int(float(value))
}})
bulk_run_update = True
if request.method == "POST" and request.form.get("action") == "clear":
g.mongo.db.carts.remove({"_id": session["CharacterOwnerHash"]})
# Add new item to database
input_string = request.form.get("parse", session.get("fitting"))
if item or input_string:
if item:
try:
item_adjustment_list = item.split(":")
for adjustment_item in item_adjustment_list:
adjustment_item_info = adjustment_item.split(";")
if request.args.get("action") == "edit":
bulk_op_update.find({
"_id":
session["CharacterOwnerHash"]
}).upsert().update({
"$set": {
"items." + adjustment_item_info[0]:
int(adjustment_item_info[1])
}
})
else:
bulk_op_update.find({
"_id":
session["CharacterOwnerHash"]
}).upsert().update({
"$inc": {
"items." + adjustment_item_info[0]:
int(adjustment_item_info[1])
}
})
bulk_run_update = True
except IndexError:
error_string = "Was not able to add {}".format(item)
elif input_string:
session.pop("fitting", None)
parse_error = None
parse_result = ""
try:
if input_string.startswith("["):
eft_parser = conversions.eft_parsing(input_string)
parse_result = eft_parser[3] # DNA String
parse_error = eft_parser[4]
else:
parse_array = []
item_input, item_qty = conversions.manual_parsing(
input_string)[1:3]
pre_parse_db = g.mongo.db.items.find(
{"name": {
"$in": item_input
}})
for pre_parse_item in pre_parse_db:
parse_array.append(
str(pre_parse_item["_id"]) + ";" +
str(item_qty[pre_parse_item["name"].upper()]))
if len(parse_array) != len(item_input):
error_string = "There is an item that could not be parsed. Check your input and try again."
parse_result = ":".join(parse_array)
except KeyError:
error_string = "Could not parse the input. Please ensure it is correctly formatted."
if parse_error:
if parse_error == "parsing":
error_string = "Could not parse the EFT-Formatted fit. Please ensure it is correctly formatted."
else:
error_string = parse_error
parse_item_list = parse_result.split(":")
for parse_item in parse_item_list:
if parse_item:
direct_info = parse_item.split(";")
if len(direct_info) == 1:
bulk_op_update.find({
"_id":
session["CharacterOwnerHash"]
}).upsert().update(
{"$inc": {
"items." + direct_info[0]: 1
}})
bulk_run_update = True
else:
bulk_op_update.find({
"_id":
session["CharacterOwnerHash"]
}).upsert().update({
"$inc": {
"items." + direct_info[0]: int(direct_info[1])
}
})
bulk_run_update = True
if bulk_run_update:
bulk_op_update.execute()
if item or input_string:
flash(error_string)
return redirect(url_for("ordering.home"))
else:
error_string = get_flashed_messages()
error_string = error_string[0] if error_string else None
# Load cart
total_volume = 0
sell_price = 0
current_cart = g.mongo.db.carts.find_one(
{"_id": session["CharacterOwnerHash"]})
fittings_info = []
fittings_breakdown = {}
# Redirect to fittings if saving pack
ordering_admin = auth_check("ordering_admin")
if ordering_admin and request.form.get("action") == "pack":
pack_fit = {
"fit": "",
"items": {},
"submitter": session["CharacterOwnerHash"],
"price": 0,
"volume": 0,
"name": request.form.get("pack"),
"notes": None,
"dna": None,
"ship": "Pack",
"source": None,
"doctrine": False
}
fit_array = []
dna_array = []
for table_key, table_info in current_cart.get("item_table",
{}).items():
pack_fit["items"][table_info["name"]] = table_info["qty"]
fit_array.append(table_info["name"] + " " + str(table_info["qty"]))
dna_array.append(table_key + ";" + str(table_info["qty"]))
pack_fit["fit"] = "\n".join(fit_array)
pack_fit["dna"] = ":".join(dna_array)
fit_id = g.mongo.db.fittings.insert(pack_fit)
return redirect(url_for("fittings.fit", fit_id=fit_id))
# Determine processing cost
order_db = g.mongo.db.preferences.find_one({"_id": "ordering"})
if session["UI_Corporation"]:
order_tax = order_db.get("tax_corp", 0) if order_db else 0
else:
order_tax = order_db.get("tax", 0) if order_db else 0
# Continue loading cart
if current_cart and current_cart.get("items"):
cart_item_list_pre = current_cart["items"]
# Filter fittings from items
fittings_id_list = []
for cart_item_id, cart_item_qty in cart_item_list_pre.items():
try:
fittings_id_list.append(ObjectId(cart_item_id))
except bson.errors.InvalidId:
cart_item_list[cart_item_id] = cart_item_qty
# Unpack fittings
for selected_fit in g.mongo.db.fittings.find(
{"_id": {
"$in": fittings_id_list
}}):
fit_item_list = selected_fit["dna"].split(":")
fittings_info.append([
str(selected_fit["_id"]), "[Fit] " + selected_fit["name"],
current_cart["items"][str(selected_fit["_id"])],
"{:,.02f}".format(selected_fit["volume"]), "{:,.02f}".format(
selected_fit["price"] * (1 + order_tax / 100)),
"{:,.02f}".format(
selected_fit["volume"] *
current_cart["items"][str(selected_fit["_id"])]),
"{:,.02f}".format(
selected_fit["price"] *
current_cart["items"][str(selected_fit["_id"])] *
(1 + order_tax / 100))
])
sell_price += selected_fit["price"] * current_cart["items"][str(
selected_fit["_id"])]
for fit_item in fit_item_list:
if fit_item:
item_info = fit_item.split(";")
fittings_breakdown.setdefault(item_info[0], 0)
if len(item_info) == 1:
fittings_breakdown[
item_info[0]] += 1 * current_cart["items"][str(
selected_fit["_id"])]
else:
fittings_breakdown[item_info[0]] += int(
item_info[1]) * current_cart["items"][str(
selected_fit["_id"])]
cart_item_list_int = [int(x) for x in cart_item_list.keys()]
fittings_breakdown_int = [int(x) for x in fittings_breakdown.keys()]
prices_int = cart_item_list_int + fittings_breakdown_int
prices, prices_usable = market_hub_prices(prices_int) if prices_int else (
{}, True)
full_cart = {}
invoice_info = [[
"Name", "Qty", "Vol/Item", "Isk/Item + Markup", "Vol Subtotal",
"Isk Subtotal w/ Markup"
]] + fittings_info
for db_item in g.mongo.db.items.find({"_id": {"$in": cart_item_list_int}}):
invoice_info.append([
db_item["_id"], db_item["name"],
cart_item_list[str(db_item["_id"])],
"{:,.02f}".format(db_item["volume"]), "{:,.02f}".format(
prices[db_item["_id"]]["sell"] * (1 + order_tax / 100)),
"{:,.02f}".format(db_item["volume"] *
cart_item_list[str(db_item["_id"])]),
"{:,.02f}".format(prices[db_item["_id"]]["sell"] *
cart_item_list[str(db_item["_id"])] *
(1 + order_tax / 100))
])
full_cart[str(db_item["_id"])] = {
"name":
db_item["name"],
"qty":
cart_item_list[str(db_item["_id"])],
"volume":
db_item["volume"],
"price":
prices[db_item["_id"]]["sell"],
"volume_total":
db_item["volume"] * cart_item_list[str(db_item["_id"])],
"price_total":
prices[db_item["_id"]]["sell"] *
cart_item_list[str(db_item["_id"])]
}
total_volume += db_item["volume"] * cart_item_list[str(db_item["_id"])]
sell_price += prices[db_item["_id"]]["sell"] * cart_item_list[str(
db_item["_id"])]
breakdown_info = [[
"Name", "Qty", "Vol/Item", "Isk/Item + Markup", "Vol Subtotal",
"Isk Subtotal w/ Markup"
]]
for db_item_breakdown in g.mongo.db.items.find(
{"_id": {
"$in": fittings_breakdown_int
}}):
breakdown_info.append([
db_item_breakdown["_id"], db_item_breakdown["name"],
fittings_breakdown[str(db_item_breakdown["_id"])],
"{:,.02f}".format(db_item_breakdown["volume"]),
"{:,.02f}".format(prices[int(db_item_breakdown["_id"])]["sell"] *
(1 + order_tax / 100)),
"{:,.02f}".format(
db_item_breakdown["volume"] *
fittings_breakdown[str(db_item_breakdown["_id"])]),
"{:,.02f}".format(
prices[int(db_item_breakdown["_id"])]["sell"] *
fittings_breakdown[str(db_item_breakdown["_id"])] *
(1 + order_tax / 100))
])
total_volume += db_item_breakdown["volume"] * fittings_breakdown[str(
db_item_breakdown["_id"])]
if full_cart.get(str(db_item_breakdown["_id"])):
full_cart[str(
db_item_breakdown["_id"])]["qty"] += fittings_breakdown[str(
db_item_breakdown["_id"])]
full_cart[str(db_item_breakdown["_id"])]["volume_total"] += (
db_item_breakdown["volume"] *
fittings_breakdown[str(db_item_breakdown["_id"])])
full_cart[str(db_item_breakdown["_id"])]["price_total"] += (
prices[int(db_item_breakdown["_id"])]["sell"] *
fittings_breakdown[str(db_item_breakdown["_id"])])
else:
full_cart[str(db_item_breakdown["_id"])] = {
"id":
db_item_breakdown["_id"],
"name":
db_item_breakdown["name"],
"qty":
fittings_breakdown[str(db_item_breakdown["_id"])],
"volume":
db_item_breakdown["volume"],
"price":
prices[int(db_item_breakdown["_id"])]["sell"],
"volume_total":
db_item_breakdown["volume"] *
fittings_breakdown[str(db_item_breakdown["_id"])],
"price_total":
(prices[int(db_item_breakdown["_id"])]["sell"] *
fittings_breakdown[str(db_item_breakdown["_id"])])
}
# List routes
with open("configs/base.json") as base_config_file:
base_config = json.load(base_config_file)
market_hub_name = base_config["market_hub_name"]
min_id_limit = base_config["market_hub_station"] * 100000000
max_id_limit = base_config["market_hub_station"] * 100000000 + 100000000
market_hub_routes = g.mongo.db.jf_routes.find(
{"_id": {
"$gte": min_id_limit,
"$lt": max_id_limit
}})
if request.args.get("end"):
selected_route = int(request.args.get("end"))
else:
selected_route = 0
valid_stations = []
route_name = ""
new_cart = g.mongo.db.carts.find_one(
{"_id": session["CharacterOwnerHash"]})
for route in market_hub_routes:
if request.args.get("end"):
if route["_id"] == int(request.args.get("end")):
valid_stations.append([route["_id"], route["end"], True])
selected_route = route[
"_id"] if selected_route == 0 else selected_route
route_name = route["end"]
else:
valid_stations.append([route["_id"], route["end"], False])
elif new_cart:
if route["_id"] == new_cart.get("route"):
valid_stations.append([route["_id"], route["end"], True])
selected_route = route[
"_id"] if selected_route == 0 else selected_route
route_name = route["end"]
else:
valid_stations.append([route["_id"], route["end"], False])
elif not request.args.get(
"end") and route["end"] == base_config["default_ship_to"]:
valid_stations.append([route["_id"], route["end"], True])
selected_route = route[
"_id"] if selected_route == 0 else selected_route
route_name = route["end"]
else:
valid_stations.append([route["_id"], route["end"], False])
# JF Calculations
if selected_route == 0:
selected_route = int(
str(base_config["market_hub_station"]) +
str(base_config["home_station"]))
selected_route_info = g.mongo.db.jf_routes.find_one(
{"_id": selected_route})
if selected_route_info:
rate_info = conversions.valid_value(selected_route_info["prices"],
time.time())
if session.get("UI_Corporation"):
jf_rate = rate_info["corp"]
else:
jf_rate = rate_info["general"]
jf_total = jf_rate * total_volume
# Min 1 Mil Isk
if jf_total < 1000000:
jf_total = 1000000
else:
jf_rate = 0
jf_total = 0
order_tax_total = sell_price * order_tax / 100
order_total = jf_total + sell_price + order_tax_total
# List of characters and notes
character_list = []
db_api_list = g.mongo.db.api_keys.find_one(
{"_id": session["CharacterOwnerHash"]})
if not request.args.get(
"action") == "character" and current_cart and request.args.get(
"action") != "order":
current_character = current_cart.get("contract_to")
elif request.args.get("character"):
current_character = request.args.get("character")
else:
current_character = session["CharacterName"]
if not request.args.get(
"action") == "notes" and current_cart and request.args.get(
"action") != "order":
notes = current_cart.get("notes", "")
else:
notes = request.args.get("notes", "")
if db_api_list:
for character in db_api_list["keys"]:
if character["character_name"] == current_character:
character_list.append((character["character_name"], True))
else:
character_list.append((character["character_name"], False))
# Update DB
g.mongo.db.carts.update({"_id": session["CharacterOwnerHash"]}, {
"$set": {
"item_table": full_cart,
"route": selected_route,
"volume": total_volume,
"jf_rate": jf_rate,
"jf_total": jf_total,
"sell_price": sell_price,
"order_total": order_total,
"jf_end": route_name,
"order_tax": order_tax,
"order_tax_total": order_tax_total,
"prices_usable": prices_usable,
"notes": notes,
"contract_to": current_character
}
},
upsert=True)
if request.args.get("action") == "order":
return redirect(url_for("ordering.invoice"))
# Round order total
order_total = round(order_total + 50000, -5)
# Formatting
total_volume = "{:,.02f}".format(total_volume)
sell_price = "{:,.02f}".format(sell_price)
jf_total = "{:,.02f}".format(jf_total)
order_total = "{:,.02f}".format(order_total)
order_tax = "{:,.02f}".format(order_tax)
order_tax_total = "{:,.02f}".format(order_tax_total)
return render_template("ordering.html",
invoice_info=invoice_info,
total_volume=total_volume,
sell_price=sell_price,
valid_stations=valid_stations,
jf_rate=jf_rate,
jf_total=jf_total,
order_total=order_total,
market_hub_name=market_hub_name,
prices_usable=prices_usable,
error_string=error_string,
breakdown_info=breakdown_info,
order_tax=order_tax,
order_tax_total=order_tax_total,
character_list=character_list,
notes=notes,
ordering_admin=ordering_admin)
def fit(fit_id=None):
if not fit_id:
abort(404)
# Redirect if fit is purchased
if request.method == "GET" and request.args.get("action") == "purchase":
return redirect(url_for("ordering.home", item=fit_id + ";" + request.args.get("multiply", 1)))
selected_fit = None
try:
selected_fit = g.mongo.db.fittings.find_one({"_id": ObjectId(fit_id)})
except bson.errors.InvalidId:
abort(404)
if not selected_fit:
return redirect(url_for("fittings.home", error="not_found"))
elif request.method == "GET" and request.args.get("action") == "direct":
# Use direct to cart
session["fitting"] = selected_fit["fit"]
return redirect(url_for("ordering.home"))
# Check if fittings admin
admin = auth_check("fittings_admin")
# Delete Permissions
if selected_fit["submitter"] == session["CharacterOwnerHash"] or admin:
can_delete = True
else:
can_delete = False
# Modifications
notes_change = request.args.get("notes") if request.args.get("notes") else selected_fit["notes"]
source_change = request.args.get("source") if request.args.get("source") else selected_fit.get("source")
doctrine_change = bool(request.args.get("doctrine")) if request.args.get("doctrine") else False
if request.args.get("action") == "delete" and can_delete:
g.mongo.db.fittings.remove({"_id": ObjectId(fit_id)})
return redirect(url_for("fittings.home"))
elif request.args.get("action") == "edit" and can_delete:
g.mongo.db.fittings.update({"_id": ObjectId(fit_id)},
{"$set": {
"notes": notes_change,
"source": source_change,
"doctrine": doctrine_change
}})
return redirect(url_for("fittings.fit", fit_id=fit_id))
fit_by_line = selected_fit["fit"].splitlines()
with open("resources/nameConversions.json") as name_conversions_file:
name_conversions = json.load(name_conversions_file)
actual_fit_items = []
pre_name_conversion = {}
for pre_filter_item in selected_fit["items"].keys():
pre_filter_item = pre_filter_item.replace("Thermic", "Thermal") # EVE parallax patch
actual_fit_items.append(name_conversions.get(pre_filter_item, pre_filter_item))
if name_conversions.get(pre_filter_item):
pre_name_conversion[name_conversions.get(pre_filter_item)] = pre_filter_item
# ID Matching
item_list = list(g.mongo.db.items.find({"name": {"$in": actual_fit_items}}))
item_prices, prices_usable = eve_central.market_hub_prices([x["_id"] for x in item_list])
item_table = [["Name", "Qty", "Isk/Item", "Vol/Item", "Total Isk", "Total Volume"]]
total_fit_isk = 0
total_volume = 0
multiply = 1 if not request.args.get("multiply") else int(request.args.get("multiply"))
for fit_item in item_list:
try:
# Check if thermal is correct in fit
qty = selected_fit["items"][fit_item["name"]] * multiply
except KeyError:
try:
# Check if it's an old fit with thermic
qty = selected_fit["items"][fit_item["name"].replace("Thermal", "Thermic")] * multiply
except KeyError:
# Check if the item name has changed
qty = selected_fit["items"][pre_name_conversion[fit_item["name"]]] * multiply
isk_per_item = item_prices[fit_item["_id"]]["sell"]
vol_per_item = fit_item["volume"]
item_isk_total = qty * isk_per_item
item_vol_total = qty * vol_per_item
total_fit_isk += item_isk_total
total_volume += item_vol_total
# Formatting
isk_per_item = "{:,.02f}".format(isk_per_item)
vol_per_item = "{:,.02f}".format(vol_per_item)
item_isk_total = "{:,.02f}".format(item_isk_total)
item_vol_total = "{:,.02f}".format(item_vol_total)
item_table.append([fit_item["name"], qty, isk_per_item, vol_per_item, item_isk_total, item_vol_total])
if multiply == 1 and prices_usable:
g.mongo.db.fittings.update({"_id": ObjectId(fit_id)}, {"$set": {
"price": total_fit_isk, "volume": total_volume}})
# List routes
with open("configs/base.json") as base_config_file:
base_config = json.load(base_config_file)
market_hub_name = base_config["market_hub_name"]
min_id_limit = base_config["market_hub_station"] * 100000000
max_id_limit = base_config["market_hub_station"] * 100000000 + 100000000
market_hub_routes = g.mongo.db.jf_routes.find({"_id": {"$gte": min_id_limit, "$lt": max_id_limit}})
if request.args.get("end"):
selected_route = int(request.args.get("end"))
else:
selected_route = 0
valid_stations = []
current_route = g.mongo.db.carts.find_one({"_id": session["CharacterOwnerHash"]})
for route in market_hub_routes:
if request.args.get("end") and route["_id"] == int(request.args.get("end")):
valid_stations.append([route["_id"], route["end"], True])
g.mongo.db.carts.update({"_id": session["CharacterOwnerHash"]},
{"$set": {"route": route["_id"]}}, upsert=True)
elif current_route:
if route["_id"] == current_route.get("route"):
valid_stations.append([route["_id"], route["end"], True])
selected_route = route["_id"] if selected_route == 0 else selected_route
else:
valid_stations.append([route["_id"], route["end"], False])
elif not request.args.get("end") and route["end"] == base_config["default_ship_to"]:
valid_stations.append([route["_id"], route["end"], True])
g.mongo.db.carts.update({"_id": session["CharacterOwnerHash"]},
{"$set": {"route": route["_id"]}}, upsert=True)
selected_route = route["_id"] if selected_route == 0 else selected_route
else:
valid_stations.append([route["_id"], route["end"], False])
# JF Calculations
selected_route_info = g.mongo.db.jf_routes.find_one({"_id": selected_route})
if selected_route_info:
rate_info = conversions.valid_value(selected_route_info["prices"], time.time())
if session.get("UI_Corporation"):
jf_rate = rate_info["corp"]
else:
jf_rate = rate_info["general"]
jf_total = jf_rate * total_volume
else:
jf_rate = 0
jf_total = 0
order_total = jf_total + total_fit_isk
# Submission date
date_added = ObjectId(fit_id).generation_time.strftime("%Y-%m-%d %H:%M:%S")
# Formatting
total_fit_isk = "{:,.02f}".format(total_fit_isk)
total_volume = "{:,.02f}".format(total_volume)
jf_total = "{:,.02f}".format(jf_total)
jf_rate = "{:,.02f}".format(jf_rate)
order_total = "{:,.02f}".format(order_total)
return render_template("fittings_fit.html", item_table=item_table, fit_string=fit_by_line,
total_fit_isk=total_fit_isk, total_volume=total_volume, valid_stations=valid_stations,
market_hub_name=market_hub_name, jf_rate=jf_rate, jf_total=jf_total, order_total=order_total,
dna_string=selected_fit["dna"], fit_name=selected_fit["name"], multiply=multiply,
can_delete=can_delete, notes=selected_fit["notes"], source=selected_fit.get("source"),
admin=admin, doctrine=selected_fit["doctrine"], prices_usable=prices_usable,
category=selected_fit.get("category"), date_added=date_added)
def fit(fit_id=None):
if not fit_id:
abort(404)
# Redirect if fit is purchased
if request.method == "GET" and request.args.get("action") == "purchase":
return redirect(
url_for("ordering.home",
item=fit_id + ";" + request.args.get("multiply", 1)))
selected_fit = None
try:
selected_fit = g.mongo.db.fittings.find_one({"_id": ObjectId(fit_id)})
except bson.errors.InvalidId:
abort(404)
if not selected_fit:
return redirect(url_for("fittings.home", error="not_found"))
elif request.method == "GET" and request.args.get("action") == "direct":
# Use direct to cart
session["fitting"] = selected_fit["fit"]
return redirect(url_for("ordering.home"))
# Check if fittings admin
admin = auth_check("fittings_admin")
# Delete Permissions
if selected_fit["submitter"] == session["CharacterOwnerHash"] or admin:
can_delete = True
else:
can_delete = False
# Modifications
notes_change = request.args.get("notes") if request.args.get(
"notes") else selected_fit["notes"]
source_change = request.args.get("source") if request.args.get(
"source") else selected_fit.get("source")
doctrine_change = bool(request.args.get("doctrine")) if request.args.get(
"doctrine") else False
if request.args.get("action") == "delete" and can_delete:
g.mongo.db.fittings.remove({"_id": ObjectId(fit_id)})
return redirect(url_for("fittings.home"))
elif request.args.get("action") == "edit" and can_delete:
g.mongo.db.fittings.update({"_id": ObjectId(fit_id)}, {
"$set": {
"notes": notes_change,
"source": source_change,
"doctrine": doctrine_change
}
})
return redirect(url_for("fittings.fit", fit_id=fit_id))
fit_by_line = selected_fit["fit"].splitlines()
with open("resources/nameConversions.json") as name_conversions_file:
name_conversions = json.load(name_conversions_file)
actual_fit_items = []
pre_name_conversion = {}
for pre_filter_item in selected_fit["items"].keys():
pre_filter_item = pre_filter_item.replace(
"Thermic", "Thermal") # EVE parallax patch
actual_fit_items.append(
name_conversions.get(pre_filter_item, pre_filter_item))
if name_conversions.get(pre_filter_item):
pre_name_conversion[name_conversions.get(
pre_filter_item)] = pre_filter_item
# ID Matching
item_list = list(g.mongo.db.items.find({"name": {
"$in": actual_fit_items
}}))
item_prices, prices_usable = eve_central.market_hub_prices(
[x["_id"] for x in item_list])
item_table = [[
"Name", "Qty", "Isk/Item", "Vol/Item", "Total Isk", "Total Volume"
]]
total_fit_isk = 0
total_volume = 0
multiply = 1 if not request.args.get("multiply") else int(
request.args.get("multiply"))
for fit_item in item_list:
try:
# Check if thermal is correct in fit
qty = selected_fit["items"][fit_item["name"]] * multiply
except KeyError:
try:
# Check if it's an old fit with thermic
qty = selected_fit["items"][fit_item["name"].replace(
"Thermal", "Thermic")] * multiply
except KeyError:
# Check if the item name has changed
qty = selected_fit["items"][pre_name_conversion[
fit_item["name"]]] * multiply
isk_per_item = item_prices[fit_item["_id"]]["sell"]
vol_per_item = fit_item["volume"]
item_isk_total = qty * isk_per_item
item_vol_total = qty * vol_per_item
total_fit_isk += item_isk_total
total_volume += item_vol_total
# Formatting
isk_per_item = "{:,.02f}".format(isk_per_item)
vol_per_item = "{:,.02f}".format(vol_per_item)
item_isk_total = "{:,.02f}".format(item_isk_total)
item_vol_total = "{:,.02f}".format(item_vol_total)
item_table.append([
fit_item["name"], qty, isk_per_item, vol_per_item, item_isk_total,
item_vol_total
])
if multiply == 1 and prices_usable:
g.mongo.db.fittings.update(
{"_id": ObjectId(fit_id)},
{"$set": {
"price": total_fit_isk,
"volume": total_volume
}})
# List routes
with open("configs/base.json") as base_config_file:
base_config = json.load(base_config_file)
market_hub_name = base_config["market_hub_name"]
min_id_limit = base_config["market_hub_station"] * 100000000
max_id_limit = base_config["market_hub_station"] * 100000000 + 100000000
market_hub_routes = g.mongo.db.jf_routes.find(
{"_id": {
"$gte": min_id_limit,
"$lt": max_id_limit
}})
if request.args.get("end"):
selected_route = int(request.args.get("end"))
else:
selected_route = 0
valid_stations = []
current_route = g.mongo.db.carts.find_one(
{"_id": session["CharacterOwnerHash"]})
for route in market_hub_routes:
if request.args.get("end") and route["_id"] == int(
request.args.get("end")):
valid_stations.append([route["_id"], route["end"], True])
g.mongo.db.carts.update({"_id": session["CharacterOwnerHash"]},
{"$set": {
"route": route["_id"]
}},
upsert=True)
elif current_route:
if route["_id"] == current_route.get("route"):
valid_stations.append([route["_id"], route["end"], True])
selected_route = route[
"_id"] if selected_route == 0 else selected_route
else:
valid_stations.append([route["_id"], route["end"], False])
elif not request.args.get(
"end") and route["end"] == base_config["default_ship_to"]:
valid_stations.append([route["_id"], route["end"], True])
g.mongo.db.carts.update({"_id": session["CharacterOwnerHash"]},
{"$set": {
"route": route["_id"]
}},
upsert=True)
selected_route = route[
"_id"] if selected_route == 0 else selected_route
else:
valid_stations.append([route["_id"], route["end"], False])
# JF Calculations
selected_route_info = g.mongo.db.jf_routes.find_one(
{"_id": selected_route})
if selected_route_info:
rate_info = conversions.valid_value(selected_route_info["prices"],
time.time())
if session.get("UI_Corporation"):
jf_rate = rate_info["corp"]
else:
jf_rate = rate_info["general"]
jf_total = jf_rate * total_volume
else:
jf_rate = 0
jf_total = 0
order_total = jf_total + total_fit_isk
# Submission date
date_added = ObjectId(fit_id).generation_time.strftime("%Y-%m-%d %H:%M:%S")
# Formatting
total_fit_isk = "{:,.02f}".format(total_fit_isk)
total_volume = "{:,.02f}".format(total_volume)
jf_total = "{:,.02f}".format(jf_total)
jf_rate = "{:,.02f}".format(jf_rate)
order_total = "{:,.02f}".format(order_total)
return render_template("fittings_fit.html",
item_table=item_table,
fit_string=fit_by_line,
total_fit_isk=total_fit_isk,
total_volume=total_volume,
valid_stations=valid_stations,
market_hub_name=market_hub_name,
jf_rate=jf_rate,
jf_total=jf_total,
order_total=order_total,
dna_string=selected_fit["dna"],
fit_name=selected_fit["name"],
multiply=multiply,
can_delete=can_delete,
notes=selected_fit["notes"],
source=selected_fit.get("source"),
admin=admin,
doctrine=selected_fit["doctrine"],
prices_usable=prices_usable,
category=selected_fit.get("category"),
date_added=date_added)
def price_calc(names, character_id, jf_rate=0):
item_list = g.mongo.db.items.find({"name": {"$in": names}})
id_list = g.mongo.db.items.find({"name": {"$in": names}}).distinct("_id")
mineral_list = {}
item_materials = conversions.refine_calc(id_list, character_id)
material_id_list = set()
non_refine_list = []
for item in item_list:
if item["materials"] and (not item["meta"] or item["meta"] < 4):
for material_id, material_amount in item_materials[
item["_id"]].items():
material_id_list.add(material_id)
mineral_list.setdefault(material_id, 0)
mineral_list[material_id] += material_amount
else:
item_materials[item["_id"]] = {}
non_refine_list.append(item["_id"])
market_prices, prices_usable = eve_central.market_hub_prices(
list(mineral_list.keys()) + list(item_materials.keys()) +
non_refine_list)
# Material info for volume
material_info_db = g.mongo.db.items.find(
{"_id": {
"$in": list(material_id_list)
}})
material_volumes = {}
for material_info in material_info_db:
material_volumes[material_info["_id"]] = material_info.get("volume", 0)
# Tax Checks
taxes_list = g.mongo.db.taxes.find(
{"_id": {
"$in": list(item_materials.keys()) + non_refine_list
}})
tax_definition = {}
for tax_item in taxes_list:
tax_definition[tax_item["_id"]] = tax_item["tax"]
refine_preferences = g.mongo.db.preferences.find_one(
{"_id": "buyback_yield"})
if refine_preferences:
default_tax = refine_preferences.get("tax", 0)
default_refine_tax = refine_preferences.get("tax_refine", 0)
else:
default_tax = 0
default_refine_tax = 0
# Refined Calculations
calculations = {}
for key, value in item_materials.items():
item_cost = 0
volume = 0
for material_id, material_amount in value.items():
item_cost += material_amount * market_prices[material_id]["buy"]
volume += material_amount * material_volumes[material_id]
jf_price = jf_rate * volume
calculations[key] = {
"total":
item_cost *
(1 - tax_definition.get(key, default_refine_tax) / 100),
"no_tax":
item_cost,
"sell":
market_prices[key]["sell"],
"buy":
market_prices[key]["buy"],
"volume":
volume,
"jf_price":
jf_price,
"delta_sell":
item_cost - (market_prices[key]["sell"] - jf_price),
"delta_buy":
item_cost - (market_prices[key]["buy"] - jf_price),
"tax":
tax_definition.get(key, default_refine_tax)
}
# Info for non-refined
non_refine_info_db = g.mongo.db.items.find(
{"_id": {
"$in": non_refine_list
}})
# Non-refined modules
for non_refine_item in non_refine_info_db:
calculations[non_refine_item["_id"]] = {
"total":
market_prices[non_refine_item["_id"]]["buy"] *
(1 -
tax_definition.get(non_refine_item["_id"], default_tax) / 100),
"no_tax":
market_prices[non_refine_item["_id"]]["buy"],
"sell":
market_prices[non_refine_item["_id"]]["sell"],
"buy":
market_prices[non_refine_item["_id"]]["buy"],
"volume":
non_refine_item["volume"],
"jf_price":
non_refine_item["volume"] * jf_rate,
"delta_sell":
item_cost -
(market_prices[non_refine_item["_id"]]["sell"] - jf_price),
"delta_buy":
item_cost -
(market_prices[non_refine_item["_id"]]["buy"] - jf_price),
"tax":
tax_definition.get(non_refine_item["_id"], default_tax)
}
mineral_prices = {}
for mineral in mineral_list.keys():
mineral_prices[mineral] = market_prices[mineral]
return calculations, mineral_prices, item_materials, prices_usable
