bool CPlaylistOperations::HandleItemsParameter(int playlistid, const CVariant &itemParam, CFileItemList &items)
{
std::vector<CVariant> vecItems;
if (itemParam.isArray())
vecItems.assign(itemParam.begin_array(), itemParam.end_array());
else
vecItems.push_back(itemParam);
bool success = false;
for (std::vector<CVariant>::iterator itemIt = vecItems.begin(); itemIt != vecItems.end(); ++itemIt)
{
if (!CheckMediaParameter(playlistid, *itemIt))
continue;
switch (playlistid)
{
case PLAYLIST_VIDEO:
(*itemIt)["media"] = "video";
break;
case PLAYLIST_MUSIC:
(*itemIt)["media"] = "music";
break;
case PLAYLIST_PICTURE:
(*itemIt)["media"] = "pictures";
break;
}
success |= FillFileItemList(*itemIt, items);
}
return success;
}
std::string ArrayToString(SortAttribute attributes, const CVariant &variant, const std::string &seperator = " / ")
{
std::vector<std::string> strArray;
if (variant.isArray())
{
for (CVariant::const_iterator_array it = variant.begin_array(); it != variant.end_array(); it++)
{
if (attributes & SortAttributeIgnoreArticle)
strArray.push_back(SortUtils::RemoveArticles(it->asString()));
else
strArray.push_back(it->asString());
}
return StringUtils::Join(strArray, seperator);
}
else if (variant.isString())
{
if (attributes & SortAttributeIgnoreArticle)
return SortUtils::RemoveArticles(variant.asString());
else
return variant.asString();
}
return "";
}
void CJSONVariantParser::PushObject(CVariant variant)
{
if (m_status == ParseObject)
{
(*m_parse[m_parse.size() - 1])[m_key] = variant;
m_parse.push_back(&(*m_parse[m_parse.size() - 1])[m_key]);
}
else if (m_status == ParseArray)
{
CVariant *temp = m_parse[m_parse.size() - 1];
temp->push_back(variant);
m_parse.push_back(&(*temp)[temp->size() - 1]);
}
else if (m_parse.size() == 0)
{
m_parse.push_back(new CVariant(variant));
}
if (variant.isObject())
m_status = ParseObject;
else if (variant.isArray())
m_status = ParseArray;
else
m_status = ParseVariable;
}
JSONRPC_STATUS CAddonsOperations::ExecuteAddon(const std::string &method, ITransportLayer *transport, IClient *client, const CVariant ¶meterObject, CVariant &result)
{
std::string id = parameterObject["addonid"].asString();
AddonPtr addon;
if (!CServiceBroker::GetAddonMgr().GetAddon(id, addon) || addon.get() == NULL ||
addon->Type() < ADDON_VIZ || addon->Type() >= ADDON_MAX)
return InvalidParams;
std::string argv;
CVariant params = parameterObject["params"];
if (params.isObject())
{
for (CVariant::const_iterator_map it = params.begin_map(); it != params.end_map(); it++)
{
if (it != params.begin_map())
argv += ",";
argv += it->first + "=" + it->second.asString();
}
}
else if (params.isArray())
{
for (CVariant::const_iterator_array it = params.begin_array(); it != params.end_array(); it++)
{
if (it != params.begin_array())
argv += ",";
argv += StringUtils::Paramify(it->asString());
}
}
else if (params.isString())
{
if (!params.empty())
argv = StringUtils::Paramify(params.asString());
}
std::string cmd;
if (params.empty())
cmd = StringUtils::Format("RunAddon(%s)", id.c_str());
else
cmd = StringUtils::Format("RunAddon(%s, %s)", id.c_str(), argv.c_str());
if (params["wait"].asBoolean())
CApplicationMessenger::GetInstance().SendMsg(TMSG_EXECUTE_BUILT_IN, -1, -1, nullptr, cmd);
else
CApplicationMessenger::GetInstance().PostMsg(TMSG_EXECUTE_BUILT_IN, -1, -1, nullptr, cmd);
return ACK;
}
bool CDatabaseQueryRuleCombination::Load(const CVariant &obj, const IDatabaseQueryRuleFactory *factory)
{
if (!obj.isObject() && !obj.isArray())
return false;
CVariant child;
if (obj.isObject())
{
if (obj.isMember("and") && obj["and"].isArray())
{
m_type = CombinationAnd;
child = obj["and"];
}
else if (obj.isMember("or") && obj["or"].isArray())
{
m_type = CombinationOr;
child = obj["or"];
}
else
return false;
}
else
child = obj;
for (CVariant::const_iterator_array it = child.begin_array(); it != child.end_array(); it++)
{
if (!it->isObject())
continue;
if (it->isMember("and") || it->isMember("or"))
{
boost::shared_ptr<CDatabaseQueryRuleCombination> combo(factory->CreateCombination());
if (combo && combo->Load(*it, factory))
m_combinations.push_back(combo);
}
else
{
boost::shared_ptr<CDatabaseQueryRule> rule(factory->CreateRule());
if (rule && rule->Load(*it))
m_rules.push_back(rule);
}
}
return true;
}
bool CAudioLibrary::CheckForAdditionalProperties(const CVariant &properties, const std::set<std::string> &checkProperties, std::set<std::string> &foundProperties)
{
if (!properties.isArray() || properties.empty())
return false;
std::set<std::string> checkingProperties = checkProperties;
for (CVariant::const_iterator_array itr = properties.begin_array(); itr != properties.end_array() && !checkingProperties.empty(); itr++)
{
if (!itr->isString())
continue;
std::string property = itr->asString();
if (checkingProperties.find(property) != checkingProperties.end())
{
checkingProperties.erase(property);
foundProperties.insert(property);
}
}
return !foundProperties.empty();
}
void CJSONVariantParser::PopObject()
{
CVariant *variant = m_parse[m_parse.size() - 1];
m_parse.pop_back();
if (m_parse.size())
{
variant = m_parse[m_parse.size() - 1];
if (variant->isObject())
m_status = ParseObject;
else if (variant->isArray())
m_status = ParseArray;
else
m_status = ParseVariable;
}
else if (m_callback)
{
m_callback->onParsed(variant);
delete variant;
m_parse.clear();
m_status = ParseVariable;
}
}
JSONRPC_STATUS CTextureOperations::GetTextures(const std::string &method, ITransportLayer *transport, IClient *client, const CVariant ¶meterObject, CVariant &result)
{
CFileItemList listItems;
CTextureDatabase db;
if (!db.Open())
return InternalError;
CDatabase::Filter dbFilter;
const CVariant &filter = parameterObject["filter"];
if (filter.isObject())
{
CVariant xspObj(CVariant::VariantTypeObject);
if (filter.isMember("field"))
{
xspObj["and"] = CVariant(CVariant::VariantTypeArray);
xspObj["and"].push_back(filter);
}
else
xspObj = filter;
// decipher the rules
CDatabaseQueryRuleCombination rule;
if (!rule.Load(xspObj, &db))
return InvalidParams;
dbFilter.AppendWhere(rule.GetWhereClause(db, ""));
}
// fetch textures from the database
CVariant items = CVariant(CVariant::VariantTypeArray);
if (!db.GetTextures(items, dbFilter))
return InternalError;
// return only what was asked for, plus textureid
CVariant prop = parameterObject["properties"];
prop.push_back("textureid");
if (!items.empty() && prop.isArray())
{
std::set<std::string> fields;
CVariant &item = items[0];
for (CVariant::const_iterator_map field = item.begin_map(); field != item.end_map(); ++field)
{
if (std::find(prop.begin_array(), prop.end_array(), field->first) == prop.end_array())
fields.insert(field->first);
}
// erase these fields
for (CVariant::iterator_array item = items.begin_array(); item != items.end_array(); ++item)
{
for (std::set<std::string>::const_iterator i = fields.begin(); i != fields.end(); ++i)
item->erase(*i);
}
if (fields.find("url") == fields.end())
{
// wrap cached url to something retrieval from Files.GetFiles()
for (CVariant::iterator_array item = items.begin_array(); item != items.end_array(); ++item)
{
CVariant &cachedUrl = (*item)["url"];
cachedUrl = CTextureUtils::GetWrappedImageURL(cachedUrl.asString());
}
}
}
result["textures"] = items;
return OK;
}
JSONRPC_STATUS CSettingsOperations::SetSettingValue(const std::string &method, ITransportLayer *transport, IClient *client, const CVariant ¶meterObject, CVariant &result)
{
std::string settingId = parameterObject["setting"].asString();
CVariant value = parameterObject["value"];
SettingPtr setting = CServiceBroker::GetSettings().GetSetting(settingId);
if (setting == NULL ||
!setting->IsVisible())
return InvalidParams;
switch (setting->GetType())
{
case SettingTypeBool:
if (!value.isBoolean())
return InvalidParams;
result = std::static_pointer_cast<CSettingBool>(setting)->SetValue(value.asBoolean());
break;
case SettingTypeInteger:
if (!value.isInteger() && !value.isUnsignedInteger())
return InvalidParams;
result = std::static_pointer_cast<CSettingInt>(setting)->SetValue((int)value.asInteger());
break;
case SettingTypeNumber:
if (!value.isDouble())
return InvalidParams;
result = std::static_pointer_cast<CSettingNumber>(setting)->SetValue(value.asDouble());
break;
case SettingTypeString:
if (!value.isString())
return InvalidParams;
result = std::static_pointer_cast<CSettingString>(setting)->SetValue(value.asString());
break;
case SettingTypeList:
{
if (!value.isArray())
return InvalidParams;
std::vector<CVariant> values;
for (CVariant::const_iterator_array itValue = value.begin_array(); itValue != value.end_array(); ++itValue)
values.push_back(*itValue);
result = CServiceBroker::GetSettings().SetList(settingId, values);
break;
}
case SettingTypeNone:
case SettingTypeAction:
default:
return InvalidParams;
}
return OK;
}
