/**
* Returns a new ItemTypeQuery object.
*
* @param string $modelAlias The alias of a model in the query
* @param ItemTypeQuery|Criteria $criteria Optional Criteria to build the query from
*
* @return ItemTypeQuery
*/
public static function create($modelAlias = null, $criteria = null)
{
if ($criteria instanceof ItemTypeQuery) {
return $criteria;
}
$query = new ItemTypeQuery();
if (null !== $modelAlias) {
$query->setModelAlias($modelAlias);
}
if ($criteria instanceof Criteria) {
$query->mergeWith($criteria);
}
return $query;
}
/**
* @param $API_JSON
* @param $offset
*/
function processApiData($API_JSON, $offset)
{
$APIItems = APIItemV2::getMultipleItemsByJSON($API_JSON);
try {
$itemCount = $offset;
foreach ($APIItems as $APIItem) {
$itemCount++;
if ($APIItem == null) {
print "Skipped item {$itemCount} on page {$offset}.\n";
continue;
}
echo "{$itemCount}: {$APIItem->getName()} (ID: {$APIItem->getItemId()})\n";
$itemData = array('TypeId' => getOrCreateTypeID($APIItem->getMarketType()), 'DataId' => $APIItem->getItemId(), 'Name' => $APIItem->getName(), 'RestrictionLevel' => $APIItem->getLevel(), 'Rarity' => getRarityID($APIItem->getRarity()), 'VendorSellPrice' => $APIItem->getVendorValue(), 'Img' => $APIItem->getImageURL(), 'RarityWord' => $APIItem->getRarity(), 'UnsellableFlag' => $APIItem->isUnsellable());
$item = ItemQuery::create()->findPK($APIItem->getItemId());
if ($item === null) {
$item = new Item();
}
$item->fromArray($itemData);
$itemType = ItemTypeQuery::create()->findPk($itemData['TypeId']);
if ($itemType !== null) {
if ($APIItem->getSubType() !== null) {
$itemSubType = ItemSubTypeQuery::create()->findOneByTitle($APIItem->getDBSubType());
if ($itemSubType === null) {
//All of the below types are known to not exist in the market data with an ID (by this name).
//Rune/Sigil/Utility/Gem/Booze/Halloween/LargeBundle/RentableContractNpc/ContractNPC/UnlimitedConsumable
//TwoHandedToy/AppearanceChange/Immediate/Unknown
$itemSubTypes = ItemSubTypeQuery::create()->filterByMainTypeId($itemData['TypeId'])->withColumn('MAX(id)', 'MAXid')->find();
$SubTypeID = $itemSubTypes[0]->getMAXid() + 1;
$itemSubType = new ItemSubType();
$itemSubType->fromArray(array('Id' => $SubTypeID, 'MainTypeId' => $itemData['TypeId'], 'Title' => $APIItem->getDBSubType()));
$itemSubType->save();
$itemType->addSubType($itemSubType);
$item->setItemSubType($itemSubType);
}
$itemType->addSubType($itemSubType);
$item->setItemSubType($itemSubType);
}
$item->setItemType($itemType);
}
$item->save();
}
} catch (Exception $e) {
echo "failed [[ {$e->getMessage()} ]] .. \n";
}
}
public function connect(Application $app)
{
$controllers = $app['controllers_factory'];
/**
* ----------------------
* route /types
* ----------------------
*/
$controllers->get("/{format}/types", function (Request $request, $format) use($app) {
$results = array();
foreach (ItemTypeQuery::getAllTypes() as $type) {
$result = array('id' => $type->getId(), 'name' => $type->getTitle(), 'subtypes' => array());
foreach ($type->getSubTypes() as $subtype) {
$result['subtypes'][] = array('id' => $subtype->getId(), 'name' => $subtype->getTitle());
}
$results[] = $result;
}
$response = array('results' => $results);
if ($format == 'csv') {
ob_start();
echo "id,name,parent_id\r\n";
foreach ($results as $result) {
echo "{$result['id']},{$result['name']},\r\n";
foreach ($result['subtypes'] as $subresult) {
echo "{$subresult['id']},{$subresult['name']},{$result['id']}\r\n";
}
}
return $app['api-helper']->outputResponse($request, ob_get_clean(), $format, "types", true);
} else {
return $app['api-helper']->outputResponse($request, $response, $format, "types");
}
})->assert('format', 'csv|json|xml');
/**
* ----------------------
* route /disciplines
* ----------------------
*/
$controllers->get("/{format}/disciplines", function (Request $request, $format) use($app) {
$results = array();
foreach (DisciplineQuery::getAllDisciplines() as $disc) {
$results[] = array('id' => $disc->getId(), 'name' => $disc->getName());
}
$response = array('results' => $results);
return $app['api-helper']->outputResponse($request, $response, $format, "disciplines");
})->assert('format', 'csv|json|xml');
/**
* ----------------------
* route /rarities
* ----------------------
*/
$controllers->get("/{format}/rarities", function (Request $request, $format) use($app) {
$results = array(array("id" => 0, "name" => "Junk"), array("id" => 1, "name" => "Common"), array("id" => 2, "name" => "Fine"), array("id" => 3, "name" => "Masterwork"), array("id" => 4, "name" => "Rare"), array("id" => 5, "name" => "Exotic"), array("id" => 6, "name" => "Ascended"), array("id" => 7, "name" => "Legendary"));
$response = array('results' => $results);
return $app['api-helper']->outputResponse($request, $response, $format, "rarities");
})->assert('format', 'csv|json|xml');
/**
* ----------------------
* route /all-items
* ----------------------
*/
$controllers->match("/{format}/all-items/{typeId}", function (Request $request, $format, $typeId) use($app) {
$q = ItemQuery::create()->select(ItemPeer::getFieldNames(\BasePeer::TYPE_PHPNAME));
$q->filterByUnsellableFlag(false);
if (in_array($typeId, array('all', '*all*'))) {
$typeId = null;
}
if (!is_null($typeId)) {
if (!($type = ItemTypeQuery::create()->findPk($typeId))) {
return $app->abort(404, "Invalid type [{$typeId}]");
}
$q->filterByItemType($type);
}
$count = $q->count();
$results = array();
foreach ($q->find() as $item) {
$results[] = $app['api-helper']->buildItemDataArray($item);
}
$response = array('count' => $count, 'results' => $results);
return $app['api-helper']->outputResponse($request, $response, $format, "all-items-{$typeId}");
})->assert('format', 'csv|json|xml')->assert('typeId', '\\d+|\\*?all\\*?');
/**
* ----------------------
* route /items
* ----------------------
*/
$controllers->match("/{format}/items/{typeId}/{page}", function (Request $request, $format, $typeId, $page) use($app) {
$itemsperpage = min($request->get('perpage', 100), 250);
$page = intval($page > 0 ? $page : 1);
$q = ItemQuery::create()->select(ItemPeer::getFieldNames(\BasePeer::TYPE_PHPNAME));
if (in_array($typeId, array('all', '*all*'))) {
$typeId = null;
}
if (!is_null($typeId)) {
if (!($type = ItemTypeQuery::create()->findPk($typeId))) {
return $app->abort(404, "Invalid type [{$typeId}]");
}
$q->filterByItemType($type);
}
if (($sortTrending = $request->get('sort_trending')) && in_array($sortTrending, array('sale', 'offer'))) {
$q->filterBySaleAvailability(200, \Criteria::GREATER_THAN);
$q->filterByOfferAvailability(200, \Criteria::GREATER_THAN);
if ($sortTrending == 'sale') {
$q->orderBySalePriceChangeLastHour(\Criteria::DESC);
} else {
if ($sortTrending == 'offer') {
$q->orderByOfferPriceChangeLastHour(\Criteria::DESC);
}
}
}
if ($rarity = $request->get('rarity')) {
$q->filterByRarity($rarity);
}
if ($filterIds = $request->get('filter_ids')) {
$filterIds = array_unique(array_filter(array_map('intval', explode(",", $filterIds))));
if (count($filterIds) > $itemsperpage) {
return $app->abort(400, "More IDs in filter_ids than allowed.");
}
$q->filterByDataId($filterIds, \Criteria::IN);
}
$total = $q->count();
if ($total > 0) {
$lastpage = ceil($total / $itemsperpage);
} else {
$page = 1;
$lastpage = 1;
}
$q->offset($itemsperpage * ($page - 1))->limit($itemsperpage);
$count = $q->count();
$results = array();
foreach ($q->find() as $item) {
$results[] = $app['api-helper']->buildItemDataArray($item);
}
$response = array('count' => $count, 'page' => $page, 'last_page' => $lastpage, 'total' => $total, 'results' => $results);
return $app['api-helper']->outputResponse($request, $response, $format, "items-{$typeId}-{$page}");
})->assert('format', 'csv|json|xml')->assert('typeId', '\\d+|\\*?all\\*?')->assert('page', '\\d*')->value('page', 1);
/**
* ----------------------
* route /item
* ----------------------
*/
$controllers->get("/{format}/item/{dataId}", function (Request $request, $format, $dataId) use($app) {
$q = ItemQuery::create();
// $q = ItemQuery::create()->select(ItemPeer::getFieldNames(\BasePeer::TYPE_PHPNAME));
$q->filterByPrimaryKey($dataId);
if (!($item = $q->findOne())) {
return $app->abort(404, "Item Not Found [{$dataId}].");
}
$response = array('result' => $app['api-helper']->buildItemDataArray($item));
return $app['api-helper']->outputResponse($request, $response, $format, "item-{$dataId}");
})->assert('format', 'csv|json|xml')->assert('dataId', '\\d+');
/**
* ----------------------
* route /listings
* ----------------------
*/
$controllers->get("/{format}/listings/{dataId}/{type}/{page}", function (Request $request, $format, $dataId, $type, $page) use($app) {
if ($small = $request->get('small')) {
$itemsperpage = 10;
} else {
$itemsperpage = 1000;
}
$page = intval($page > 0 ? $page : 1);
if ($type == 'sell') {
$q = SellListingQuery::create()->select(SellListingPeer::getFieldNames(\BasePeer::TYPE_PHPNAME));
} else {
$q = BuyListingQuery::create()->select(BuyListingPeer::getFieldNames(\BasePeer::TYPE_PHPNAME));
}
$q->filterByItemId($dataId);
$q->orderByListingDatetime(\ModelCriteria::DESC);
$total = $q->count();
if ($total > 0) {
$lastpage = ceil($total / $itemsperpage);
} else {
$page = 1;
$lastpage = 1;
}
$q->offset($itemsperpage * ($page - 1))->limit($itemsperpage);
$count = 0;
$results = array();
foreach ($q->find() as $listing) {
$results[] = $app['api-helper']->buildListingDataArray($listing);
$count++;
}
$response = array('sell-or-buy' => $type, 'count' => $count, 'page' => $page, 'last_page' => $lastpage, 'total' => $total, 'results' => $results);
return $app['api-helper']->outputResponse($request, $response, $format, "item-listings-{$dataId}-{$type}-{$page}");
})->assert('dataId', '\\d+')->assert('format', 'csv|json|xml')->assert('page', '\\d*')->assert('type', 'sell|buy')->value('page', 1);
/**
* ----------------------
* route /item-search
* ----------------------
*/
$controllers->get("/{format}/item-search/{name}/{page}", function (Request $request, $format, $name, $page) use($app) {
$itemsperpage = 50;
$page = intval($page > 0 ? $page : 1);
$q = ItemQuery::create()->select(ItemPeer::getFieldNames(\BasePeer::TYPE_PHPNAME));
$q->filterByName("%{$name}%");
if ($request->get('exclude_unsellable', false)) {
$q->filterByUnsellableFlag(false);
}
if ($q->count() == 0 && $name != trim($name)) {
$name = trim($name);
$q = ItemQuery::create()->select(ItemPeer::getFieldNames(\BasePeer::TYPE_PHPNAME));
$q->filterByName("%{$name}%");
if ($request->get('exclude_unsellable', false)) {
$q->filterByUnsellableFlag(false);
}
}
$total = $q->count();
if ($total > 0) {
$lastpage = ceil($total / $itemsperpage);
} else {
$page = 1;
$lastpage = 1;
}
$q->offset($itemsperpage * ($page - 1))->limit($itemsperpage)->addAscendingOrderByColumn('name');
$count = $q->count();
$results = array();
foreach ($q->find() as $item) {
$results[] = $app['api-helper']->buildItemDataArray($item);
}
$response = array('count' => $count, 'page' => $page, 'last_page' => $lastpage, 'total' => $total, 'results' => $results);
return $app['api-helper']->outputResponse($request, $response, $format, "item-search-{$page}");
})->assert('format', 'csv|json|xml')->assert('page', '\\d*')->value('page', 1);
/**
* ----------------------
* route /recipes
* ----------------------
*/
$controllers->get("/{format}/recipes/{discId}/{page}", function (Request $request, $format, $discId, $page) use($app) {
$itemsperpage = 100;
$page = intval($page > 0 ? $page : 1);
$q = RecipeQuery::create();
if (in_array($discId, array('all', '*all*'))) {
$discId = null;
}
if (!is_null($discId)) {
if (!($disc = DisciplineQuery::create()->findPk($discId))) {
return $app->abort(404, "Invalid discipline [{$discId}]");
}
$q->filterByDiscipline($disc);
}
$total = $q->count();
if ($total > 0) {
$lastpage = ceil($total / $itemsperpage);
} else {
$page = 1;
$lastpage = 1;
}
$q->offset($itemsperpage * ($page - 1))->limit($itemsperpage);
$count = $q->count();
$results = array();
foreach ($q->find() as $recipe) {
$results[] = $app['api-helper']->buildRecipeDataArray($recipe);
}
$response = array('count' => $count, 'page' => $page, 'last_page' => $lastpage, 'total' => $total, 'results' => $results);
return $app['api-helper']->outputResponse($request, $response, $format, "recipes-{$discId}-{$page}");
})->assert('format', 'csv|json|xml')->assert('discId', '\\d+|\\*?all\\*?')->assert('page', '\\d*')->value('page', 1);
/**
* ----------------------
* route /all-recipes
* ----------------------
*/
$controllers->match("/{format}/all-recipes/{discId}", function (Request $request, $format, $discId) use($app) {
$t = microtime(true);
$q = RecipeQuery::create();
if (in_array($discId, array('all', '*all*'))) {
$discId = null;
}
if (!is_null($discId)) {
if (!($disc = DisciplineQuery::create()->findPk($discId))) {
return $app->abort(404, "Invalid discipline [{$discId}]");
}
$q->filterByDiscipline($disc);
}
$count = $q->count();
$results = array();
foreach ($q->find() as $recipe) {
$results[] = $app['api-helper']->buildRecipeDataArray($recipe);
}
$response = array('count' => $count, 'results' => $results);
return $app['api-helper']->outputResponse($request, $response, $format, "all-recipes-{$discId}");
})->assert('format', 'csv|json|xml')->assert('typeId', '\\d+|\\*?all\\*?');
/**
* ----------------------
* route /recipe
* ----------------------
*/
$controllers->get("/{format}/recipe/{dataId}", function (Request $request, $format, $dataId) use($app) {
if (!($recipe = RecipeQuery::create()->findPk($dataId))) {
return $app->abort(404, "Recipe Not Found [{$dataId}].");
}
$response = array('result' => $app['api-helper']->buildRecipeDataArray($recipe));
return $app['api-helper']->outputResponse($request, $response, $format, "recipe-{$dataId}");
})->assert('format', 'csv|json|xml')->assert('dataId', '\\d+');
/**
* ----------------------
* route /gem-price
* ----------------------
*/
$controllers->get("/{format}/gem-price", function (Request $request, $format) use($app) {
$gemtogold = GemToGoldRateQuery::create()->addDescendingOrderByColumn("rate_datetime")->offset(-1)->limit(1)->findOne();
$goldtogem = GoldToGemRateQuery::create()->addDescendingOrderByColumn("rate_datetime")->offset(-1)->limit(1)->findOne();
if (!$gemtogold || !$goldtogem) {
return $app->abort(404, "Gem Data Not Found.");
}
$response = array('result' => array('gem_to_gold' => $gemtogold->getRate(), 'gold_to_gem' => $goldtogem->getRate()));
return $app['api-helper']->outputResponse($request, $response, $format, "gem-price");
})->assert('format', 'csv|json|xml');
/**
* ----------------------
* route /item-tooltip
* ----------------------
*/
$controllers->get("/{format}/item-tooltip/{dataId}", function (Request $request, $format, $dataId) use($app) {
$APIItem = APIItem::getItemById($dataId);
$response = array('result' => array('Tooltip' => $APIItem->getTooltip(), 'Type' => 'api/v0.9/json/item-tooltip', 'Id' => $dataId));
return $app['api-helper']->outputResponse($request, $response, $format, "item-tooltip-{$dataId}");
})->assert('format', 'csv|json|xml')->assert('dataId', '\\d+');
/**
* ----------------------
* route /recipe-tooltip
* ----------------------
*/
$controllers->get("/{format}/recipe-tooltip/{dataId}", function (Request $request, $format, $dataId) use($app) {
$APIRecipe = APIRecipe::getRecipeById($dataId);
$response = array('result' => array('Tooltip' => $APIRecipe->getTooltip(), 'Type' => 'api/v0.9/json/recipe-tooltip', 'Id' => $dataId));
return $app['api-helper']->outputResponse($request, $response, $format, "recipe-tooltip-{$dataId}");
})->assert('format', 'csv|json|xml')->assert('dataId', '\\d+');
return $controllers;
}
/**
* Get the associated ItemType object
*
* @param PropelPDO $con Optional Connection object.
* @return ItemType The associated ItemType object.
* @throws PropelException
*/
public function getItemType(PropelPDO $con = null)
{
if ($this->aItemType === null && $this->item_type_id !== null) {
$this->aItemType = ItemTypeQuery::create()->findPk($this->item_type_id, $con);
/* The following can be used additionally to
guarantee the related object contains a reference
to this object. This level of coupling may, however, be
undesirable since it could result in an only partially populated collection
in the referenced object.
$this->aItemType->addItems($this);
*/
}
return $this->aItemType;
}
/**
* Removes this object from datastore and sets delete attribute.
*
* @param PropelPDO $con
* @return void
* @throws PropelException
* @throws Exception
* @see BaseObject::setDeleted()
* @see BaseObject::isDeleted()
*/
public function delete(PropelPDO $con = null)
{
if ($this->isDeleted()) {
throw new PropelException("This object has already been deleted.");
}
if ($con === null) {
$con = Propel::getConnection(ItemTypePeer::DATABASE_NAME, Propel::CONNECTION_WRITE);
}
$con->beginTransaction();
try {
$deleteQuery = ItemTypeQuery::create()->filterByPrimaryKey($this->getPrimaryKey());
$ret = $this->preDelete($con);
if ($ret) {
$deleteQuery->delete($con);
$this->postDelete($con);
$con->commit();
$this->setDeleted(true);
} else {
$con->commit();
}
} catch (Exception $e) {
$con->rollBack();
throw $e;
}
}
public function getDisplayTypes()
{
if (is_null($this->displayTypes)) {
$this->displayTypes = ItemTypeQuery::getAllTypes();
foreach ($this->displayTypes as $k => $type) {
if (!$type->getTitle()) {
unset($this->displayTypes[$k]);
}
}
}
return $this->displayTypes;
}
/**
* ----------------------
* route /type
* ----------------------
*/
$app->get("/type/{type}/{subtype}/{page}", function (Request $request, $type, $subtype, $page) use($app) {
$page = $page > 0 ? $page : 1;
$q = ItemQuery::create();
if ($type == -1) {
$type = null;
}
if ($subtype == -1) {
$subtype = null;
}
if (!is_null($type)) {
if (!($type = ItemTypeQuery::create()->findPk($type))) {
return $app->abort(404, "bad type");
}
$q->filterByItemType($type);
if (!is_null($subtype)) {
if (!($subtype = ItemSubTypeQuery::create()->findPk(array($subtype, $type->getId())))) {
return $app->abort(404, "bad type");
}
$q->filterByItemSubType($subtype);
}
}
// use generic function to render
return item_list($app, $request, $q, $page, 50, array('type' => $type, 'subtype' => $subtype));
})->assert('type', '-?\\d*')->assert('subtype', '-?\\d*')->assert('page', '-?\\d*')->value('type', -1)->value('subtype', -1)->value('page', 1)->bind('type');
/**
* ----------------------
