static gboolean
as_app_validate_releases (AsApp *app, AsAppValidateHelper *helper, GError **error)
{
GPtrArray *releases;
AsFormat *format;
gboolean require_release = FALSE;
/* only for AppData */
format = as_app_get_format_default (app);
if (as_format_get_kind (format) != AS_FORMAT_KIND_APPDATA &&
as_format_get_kind (format) != AS_FORMAT_KIND_METAINFO)
return TRUE;
/* make the requirements more strict */
if ((helper->flags & AS_APP_VALIDATE_FLAG_RELAX) == 0) {
/* only for desktop and console apps */
if (as_app_get_kind (app) == AS_APP_KIND_DESKTOP ||
as_app_get_kind (app) == AS_APP_KIND_CONSOLE) {
require_release = TRUE;
}
}
/* require releases */
releases = as_app_get_releases (app);
if (require_release && releases->len == 0) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_TAG_MISSING,
"<release> required");
return TRUE;
}
for (guint i = 0; i < releases->len; i++) {
AsRelease *release = g_ptr_array_index (releases, i);
if (!as_app_validate_release (app, release, helper, error))
return FALSE;
}
/* check the version numbers go down each time */
if (releases->len > 1) {
AsRelease *release_old = g_ptr_array_index (releases, 0);
for (guint i = 1; i < releases->len; i++) {
AsRelease *release = g_ptr_array_index (releases, i);
const gchar *version = as_release_get_version (release);
const gchar *version_old = as_release_get_version (release_old);
if (version == NULL || version_old == NULL)
continue;
if (as_utils_vercmp_full (version, version_old, AS_VERSION_COMPARE_FLAG_NONE) > 0) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_TAG_INVALID,
"<release> versions are not in order "
"[%s before %s]",
version_old, version);
}
release_old = release;
}
}
return TRUE;
}
static AsApp *
load_appdata (const gchar *prefix, const gchar *app_name, GError **error)
{
g_autofree gchar *appdata_basename = NULL;
g_autofree gchar *appdata_path = NULL;
g_autoptr(AsApp) app = NULL;
g_autoptr(GPtrArray) problems = NULL;
AsProblemKind problem_kind;
AsProblem *problem;
guint i;
appdata_basename = g_strconcat (app_name,
".appdata.xml",
NULL);
appdata_path = g_build_filename (prefix,
"share",
"appdata",
appdata_basename,
NULL);
g_debug ("Looking for %s", appdata_path);
app = as_app_new ();
if (!as_app_parse_file (app, appdata_path,
AS_APP_PARSE_FLAG_USE_HEURISTICS,
error))
return NULL;
if (as_app_get_kind (app) == AS_APP_KIND_UNKNOWN) {
g_set_error (error,
AS_APP_ERROR,
AS_APP_ERROR_FAILED,
"%s has no recognised type",
as_app_get_id (AS_APP (app)));
return NULL;
}
problems = as_app_validate (app,
AS_APP_VALIDATE_FLAG_NO_NETWORK |
AS_APP_VALIDATE_FLAG_RELAX,
error);
if (problems == NULL)
return NULL;
for (i = 0; i < problems->len; i++) {
problem = g_ptr_array_index (problems, i);
problem_kind = as_problem_get_kind (problem);
as_compose_app_log (app,
"AppData problem: %s : %s",
as_problem_kind_to_string (problem_kind),
as_problem_get_message (problem));
}
if (problems->len > 0) {
g_set_error (error,
AS_APP_ERROR,
AS_APP_ERROR_FAILED,
"AppData file %s was not valid",
appdata_path);
return NULL;
}
return g_steal_pointer (&app);
}
static AsApp *
load_desktop (const gchar *prefix,
const gchar *icons_dir,
guint min_icon_size,
const gchar *app_name,
const gchar *appdata_id,
GError **error)
{
AsIcon *icon;
g_autofree gchar *desktop_basename = NULL;
g_autofree gchar *desktop_path = NULL;
g_autoptr(AsApp) app = NULL;
if (appdata_id != NULL)
desktop_basename = g_strdup (appdata_id);
else
desktop_basename = g_strconcat (app_name, ".desktop", NULL);
desktop_path = g_build_filename (prefix, "share/applications", desktop_basename, NULL);
app = as_app_new ();
if (!as_app_parse_file (app, desktop_path,
AS_APP_PARSE_FLAG_USE_HEURISTICS |
AS_APP_PARSE_FLAG_ALLOW_VETO,
error))
return NULL;
if (as_app_get_kind (app) == AS_APP_KIND_UNKNOWN) {
g_set_error (error,
AS_APP_ERROR,
AS_APP_ERROR_FAILED,
"%s has no recognised type",
as_app_get_id (AS_APP (app)));
return NULL;
}
icon = as_app_get_icon_default (AS_APP (app));
if (icon != NULL) {
g_autofree gchar *key = NULL;
key = g_strdup (as_icon_get_name (icon));
if (as_icon_get_kind (icon) == AS_ICON_KIND_STOCK) {
as_compose_app_log (app,
"using stock icon %s", key);
} else {
g_autoptr(GError) error_local = NULL;
gboolean ret;
g_ptr_array_set_size (as_app_get_icons (AS_APP (app)), 0);
ret = add_icons (app,
icons_dir,
min_icon_size,
prefix,
key,
error);
if (!ret)
return NULL;
}
}
return g_steal_pointer (&app);
}
void
asb_plugin_merge (AsbPlugin *plugin, GList *list)
{
AsApp *app;
AsApp *found;
GList *l;
g_autoptr(GHashTable) hash = NULL;
/* make a hash table of ID->AsApp */
hash = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free, (GDestroyNotify) g_object_unref);
for (l = list; l != NULL; l = l->next) {
app = AS_APP (l->data);
if (as_app_get_kind (app) != AS_APP_KIND_DESKTOP)
continue;
g_hash_table_insert (hash,
g_strdup (as_app_get_id (app)),
g_object_ref (app));
}
/* add addons where the pkgname is different from the
* main package */
for (l = list; l != NULL; l = l->next) {
if (!ASB_IS_APP (l->data))
continue;
app = AS_APP (l->data);
if (as_app_get_kind (app) != AS_APP_KIND_ADDON)
continue;
found = g_hash_table_lookup (hash, as_app_get_id (app));
if (found == NULL)
continue;
if (g_strcmp0 (as_app_get_pkgname_default (app),
as_app_get_pkgname_default (found)) != 0)
continue;
as_app_add_veto (app,
"absorbing addon %s shipped in "
"main package %s",
as_app_get_id (app),
as_app_get_pkgname_default (app));
as_app_subsume_full (found, app, AS_APP_SUBSUME_FLAG_PARTIAL);
}
}
/**
* as_app_builder_search_provides:
* @app: an #AsApp
* @prefix: a prefix to search, e.g. "/usr"
* @flags: #AsAppBuilderFlags, e.g. %AS_APP_BUILDER_FLAG_USE_FALLBACKS
* @error: a #GError or %NULL
*
* Searches a prefix for auto-detected provides.
*
* Returns: %TRUE for success
*
* Since: 0.5.8
**/
gboolean
as_app_builder_search_provides (AsApp *app,
const gchar *prefix,
AsAppBuilderFlags flags,
GError **error)
{
/* skip for addons */
if (as_app_get_kind (AS_APP (app)) == AS_APP_KIND_ADDON)
return TRUE;
if (!as_app_builder_search_dbus (app, prefix,
"share/dbus-1/system-services",
AS_PROVIDE_KIND_DBUS_SYSTEM,
flags, error))
return FALSE;
if (!as_app_builder_search_dbus (app, prefix,
"share/dbus-1/services",
AS_PROVIDE_KIND_DBUS_SESSION,
flags, error))
return FALSE;
return TRUE;
}
static void
gs_design_dialog_buffer_changed_cb (GtkTextBuffer *buffer, GsEditor *self)
{
GtkTextIter iter_end;
GtkTextIter iter_start;
g_autofree gchar *css = NULL;
/* ignore, self change */
if (self->is_in_refresh)
return;
gtk_text_buffer_get_bounds (buffer, &iter_start, &iter_end);
css = gtk_text_buffer_get_text (buffer, &iter_start, &iter_end, FALSE);
g_debug ("CSS now '%s'", css);
if (as_app_get_kind (self->selected_item) == AS_APP_KIND_OS_UPGRADE) {
as_app_add_metadata (self->selected_item, "GnomeSoftware::UpgradeBanner-css", NULL);
as_app_add_metadata (self->selected_item, "GnomeSoftware::UpgradeBanner-css", css);
} else {
as_app_add_metadata (self->selected_item, "GnomeSoftware::FeatureTile-css", NULL);
as_app_add_metadata (self->selected_item, "GnomeSoftware::FeatureTile-css", css);
}
self->pending_changes = TRUE;
gs_design_dialog_refresh_details_delayed (self);
}
/**
* asb_plugin_loader_merge:
* @plugin_loader: A #AsbPluginLoader
* @apps: (element-type AsbApp): a list of applications that need merging
*
* Merge the list of applications using the plugins.
*
* Since: 0.2.5
**/
void
asb_plugin_loader_merge (AsbPluginLoader *plugin_loader, GList *apps)
{
AsbApp *app;
AsbApp *found;
AsbPluginLoaderPrivate *priv = GET_PRIVATE (plugin_loader);
AsbPluginMergeFunc plugin_func = NULL;
AsbPlugin *plugin;
GList *l;
const gchar *key;
const gchar *tmp;
gboolean ret;
guint i;
g_autoptr(GHashTable) hash = NULL;
/* run each plugin */
for (i = 0; i < priv->plugins->len; i++) {
plugin = g_ptr_array_index (priv->plugins, i);
ret = g_module_symbol (plugin->module,
"asb_plugin_merge",
(gpointer *) &plugin_func);
if (!ret)
continue;
plugin_func (plugin, apps);
}
/* FIXME: move to font plugin */
for (l = apps; l != NULL; l = l->next) {
if (!ASB_IS_APP (l->data))
continue;
app = ASB_APP (l->data);
as_app_remove_metadata (AS_APP (app), "FontFamily");
as_app_remove_metadata (AS_APP (app), "FontFullName");
as_app_remove_metadata (AS_APP (app), "FontIconText");
as_app_remove_metadata (AS_APP (app), "FontParent");
as_app_remove_metadata (AS_APP (app), "FontSampleText");
as_app_remove_metadata (AS_APP (app), "FontSubFamily");
as_app_remove_metadata (AS_APP (app), "FontClassifier");
}
/* deduplicate */
hash = g_hash_table_new (g_str_hash, g_str_equal);
for (l = apps; l != NULL; l = l->next) {
if (!ASB_IS_APP (l->data))
continue;
app = ASB_APP (l->data);
if (as_app_get_vetos(AS_APP(app))->len > 0)
continue;
key = as_app_get_id (AS_APP (app));
found = g_hash_table_lookup (hash, key);
if (found == NULL) {
g_hash_table_insert (hash,
(gpointer) key,
(gpointer) app);
continue;
}
if (as_app_get_kind (AS_APP (app)) == AS_APP_KIND_FIRMWARE) {
as_app_subsume_full (AS_APP (found), AS_APP (app),
AS_APP_SUBSUME_FLAG_MERGE);
}
tmp = asb_package_get_nevr (asb_app_get_package (found));
as_app_add_veto (AS_APP (app), "duplicate of %s", tmp);
asb_package_log (asb_app_get_package (app),
ASB_PACKAGE_LOG_LEVEL_WARNING,
"duplicate %s not included as added from %s",
key, tmp);
}
}
/**
* gs_appstream_refine_app:
*/
gboolean
gs_appstream_refine_app (GsPlugin *plugin,
GsApp *app,
AsApp *item,
GError **error)
{
AsRelease *rel;
GHashTable *urls;
GPtrArray *pkgnames;
GPtrArray *kudos;
const gchar *tmp;
guint i;
/* set the kind to be more precise */
if (gs_app_get_kind (app) == AS_APP_KIND_UNKNOWN ||
gs_app_get_kind (app) == AS_APP_KIND_GENERIC) {
gs_app_set_kind (app, as_app_get_kind (item));
}
/* is installed already */
if (gs_app_get_state (app) == AS_APP_STATE_UNKNOWN) {
switch (as_app_get_source_kind (item)) {
case AS_APP_SOURCE_KIND_APPDATA:
case AS_APP_SOURCE_KIND_DESKTOP:
gs_app_set_kind (app, AS_APP_KIND_DESKTOP);
gs_app_set_state (app, AS_APP_STATE_INSTALLED);
break;
case AS_APP_SOURCE_KIND_METAINFO:
gs_app_set_state (app, AS_APP_STATE_INSTALLED);
break;
case AS_APP_SOURCE_KIND_APPSTREAM:
gs_app_set_state (app, as_app_get_state (item));
break;
default:
break;
}
}
/* set management plugin automatically */
gs_refine_item_management_plugin (app, item);
/* set id */
if (as_app_get_id (item) != NULL && gs_app_get_id (app) == NULL)
gs_app_set_id (app, as_app_get_id (item));
/* set name */
tmp = as_app_get_name (item, NULL);
if (tmp != NULL) {
if (g_str_has_prefix (tmp, "(Nightly) ")) {
tmp += 10;
if (gs_app_get_metadata_item (app, "X-XdgApp-Tags") == NULL)
gs_app_set_metadata (app, "X-XdgApp-Tags", "nightly");
}
gs_app_set_name (app, GS_APP_QUALITY_HIGHEST, tmp);
}
/* set summary */
tmp = as_app_get_comment (item, NULL);
if (tmp != NULL) {
gs_app_set_summary (app, GS_APP_QUALITY_HIGHEST, tmp);
}
/* add urls */
urls = as_app_get_urls (item);
if (g_hash_table_size (urls) > 0 &&
gs_app_get_url (app, AS_URL_KIND_HOMEPAGE) == NULL) {
GList *l;
g_autoptr(GList) keys = NULL;
keys = g_hash_table_get_keys (urls);
for (l = keys; l != NULL; l = l->next) {
gs_app_set_url (app,
as_url_kind_from_string (l->data),
g_hash_table_lookup (urls, l->data));
}
}
/* set licence */
if (as_app_get_project_license (item) != NULL && gs_app_get_license (app) == NULL)
gs_app_set_license (app,
GS_APP_QUALITY_HIGHEST,
as_app_get_project_license (item));
/* set keywords */
if (as_app_get_keywords (item, NULL) != NULL &&
gs_app_get_keywords (app) == NULL) {
gs_app_set_keywords (app, as_app_get_keywords (item, NULL));
gs_app_add_kudo (app, GS_APP_KUDO_HAS_KEYWORDS);
}
/* set origin */
if (as_app_get_origin (item) != NULL &&
gs_app_get_origin (app) == NULL) {
gs_app_set_origin (app, as_app_get_origin (item));
}
/* set description */
tmp = as_app_get_description (item, NULL);
if (tmp != NULL) {
g_autofree gchar *from_xml = NULL;
from_xml = as_markup_convert_simple (tmp, error);
if (from_xml == NULL) {
g_prefix_error (error, "trying to parse '%s': ", tmp);
return FALSE;
}
gs_app_set_description (app, GS_APP_QUALITY_HIGHEST, from_xml);
}
/* set icon */
if (as_app_get_icon_default (item) != NULL && gs_app_get_pixbuf (app) == NULL)
gs_refine_item_pixbuf (plugin, app, item);
/* set categories */
if (as_app_get_categories (item) != NULL &&
gs_app_get_categories (app)->len == 0)
gs_app_set_categories (app, as_app_get_categories (item));
/* set project group */
if (as_app_get_project_group (item) != NULL &&
gs_app_get_project_group (app) == NULL)
gs_app_set_project_group (app, as_app_get_project_group (item));
/* this is a core application for the desktop and cannot be removed */
if (_as_app_has_compulsory_for_desktop (item, "GNOME") &&
gs_app_get_kind (app) == AS_APP_KIND_DESKTOP)
gs_app_add_quirk (app, AS_APP_QUIRK_COMPULSORY);
/* set id kind */
if (gs_app_get_kind (app) == AS_APP_KIND_UNKNOWN)
gs_app_set_kind (app, as_app_get_kind (item));
/* copy all the metadata */
gs_appstream_copy_metadata (app, item);
/* set package names */
pkgnames = as_app_get_pkgnames (item);
if (pkgnames->len > 0 && gs_app_get_sources(app)->len == 0)
gs_app_set_sources (app, pkgnames);
/* set addons */
gs_appstream_refine_add_addons (plugin, app, item);
/* set screenshots */
gs_appstream_refine_add_screenshots (app, item);
/* are the screenshots perfect */
if (gs_appstream_are_screenshots_perfect (item))
gs_app_add_kudo (app, GS_APP_KUDO_PERFECT_SCREENSHOTS);
/* was this application released recently */
if (gs_appstream_is_recent_release (item))
gs_app_add_kudo (app, GS_APP_KUDO_RECENT_RELEASE);
/* add kudos */
if (as_app_get_language (item, plugin->locale) > 50)
gs_app_add_kudo (app, GS_APP_KUDO_MY_LANGUAGE);
/* add new-style kudos */
kudos = as_app_get_kudos (item);
for (i = 0; i < kudos->len; i++) {
tmp = g_ptr_array_index (kudos, i);
switch (as_kudo_kind_from_string (tmp)) {
case AS_KUDO_KIND_SEARCH_PROVIDER:
gs_app_add_kudo (app, GS_APP_KUDO_SEARCH_PROVIDER);
break;
case AS_KUDO_KIND_USER_DOCS:
gs_app_add_kudo (app, GS_APP_KUDO_INSTALLS_USER_DOCS);
break;
case AS_KUDO_KIND_APP_MENU:
gs_app_add_kudo (app, GS_APP_KUDO_USES_APP_MENU);
break;
case AS_KUDO_KIND_MODERN_TOOLKIT:
gs_app_add_kudo (app, GS_APP_KUDO_MODERN_TOOLKIT);
break;
case AS_KUDO_KIND_NOTIFICATIONS:
gs_app_add_kudo (app, GS_APP_KUDO_USES_NOTIFICATIONS);
break;
case AS_KUDO_KIND_HIGH_CONTRAST:
gs_app_add_kudo (app, GS_APP_KUDO_HIGH_CONTRAST);
break;
case AS_KUDO_KIND_HI_DPI_ICON:
gs_app_add_kudo (app, GS_APP_KUDO_HI_DPI_ICON);
break;
default:
g_debug ("no idea how to handle kudo '%s'", tmp);
break;
}
}
/* is there any update information */
rel = as_app_get_release_default (item);
if (rel != NULL) {
tmp = as_release_get_description (rel, NULL);
if (tmp != NULL) {
g_autofree gchar *desc = NULL;
desc = as_markup_convert (tmp,
AS_MARKUP_CONVERT_FORMAT_MARKDOWN,
error);
if (desc == NULL)
return FALSE;
gs_app_set_update_details (app, desc);
}
gs_app_set_update_urgency (app, as_release_get_urgency (rel));
gs_app_set_update_version (app, as_release_get_version (rel));
}
return TRUE;
}
static gboolean
as_app_validate_release (AsApp *app,
AsRelease *release,
AsAppValidateHelper *helper,
GError **error)
{
const gchar *tmp;
guint64 timestamp;
guint number_para_max = 10;
guint number_para_min = 1;
gboolean required_timestamp = TRUE;
/* relax the requirements a bit */
if ((helper->flags & AS_APP_VALIDATE_FLAG_RELAX) > 0) {
number_para_max = 20;
required_timestamp = FALSE;
}
/* make the requirements more strict */
if ((helper->flags & AS_APP_VALIDATE_FLAG_STRICT) > 0) {
number_para_max = 4;
}
/* check version */
tmp = as_release_get_version (release);
if (tmp == NULL) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_ATTRIBUTE_MISSING,
"<release> has no version");
}
/* check timestamp */
timestamp = as_release_get_timestamp (release);
if (required_timestamp && timestamp == 0) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_ATTRIBUTE_MISSING,
"<release> has no timestamp");
}
if (timestamp > 20120101 && timestamp < 20251231) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_ATTRIBUTE_INVALID,
"<release> timestamp should be a UNIX time");
}
/* check the timestamp is not in the future */
if (timestamp > (guint64) g_get_real_time () / G_USEC_PER_SEC) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_ATTRIBUTE_INVALID,
"<release> timestamp is in the future");
}
/* for firmware, check urgency */
if (as_app_get_kind (app) == AS_APP_KIND_FIRMWARE &&
as_release_get_urgency (release) == AS_URGENCY_KIND_UNKNOWN) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_ATTRIBUTE_INVALID,
"<release> urgency is required for firmware");
}
/* check description */
tmp = as_release_get_description (release, "C");
if (tmp != NULL) {
if (as_app_validate_has_hyperlink (tmp)) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_STYLE_INCORRECT,
"<release> description should be "
"prose and not contain hyperlinks [%s]",
tmp);
}
if (!as_app_validate_description (tmp,
helper,
number_para_min,
number_para_max,
TRUE,
error))
return FALSE;
}
return TRUE;
}
static void
as_app_validate_screenshots (AsApp *app, AsAppValidateHelper *helper)
{
AsFormat *format;
AsScreenshot *ss;
GPtrArray *screenshots;
gboolean screenshot_has_default = FALSE;
guint number_screenshots_max = 25;
guint number_screenshots_min = 1;
guint i;
/* relax the requirements a bit */
if ((helper->flags & AS_APP_VALIDATE_FLAG_RELAX) > 0) {
number_screenshots_max = 10;
number_screenshots_min = 0;
}
/* firmware does not need screenshots */
if (as_app_get_kind (app) == AS_APP_KIND_FIRMWARE ||
as_app_get_kind (app) == AS_APP_KIND_DRIVER ||
as_app_get_kind (app) == AS_APP_KIND_RUNTIME ||
as_app_get_kind (app) == AS_APP_KIND_ADDON ||
as_app_get_kind (app) == AS_APP_KIND_LOCALIZATION)
number_screenshots_min = 0;
/* metainfo and inf do not require any screenshots */
format = as_app_get_format_default (app);
if (as_format_get_kind (format) == AS_FORMAT_KIND_METAINFO)
number_screenshots_min = 0;
/* only for AppData and AppStream */
if (as_format_get_kind (format) == AS_FORMAT_KIND_DESKTOP)
return;
screenshots = as_app_get_screenshots (app);
if (screenshots->len < number_screenshots_min) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_STYLE_INCORRECT,
"Not enough <screenshot> tags, minimum is %u",
number_screenshots_min);
}
if (screenshots->len > number_screenshots_max) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_STYLE_INCORRECT,
"Too many <screenshot> tags, maximum is %u",
number_screenshots_max);
}
for (i = 0; i < screenshots->len; i++) {
ss = g_ptr_array_index (screenshots, i);
as_app_validate_screenshot (ss, helper);
if (as_screenshot_get_kind (ss) == AS_SCREENSHOT_KIND_DEFAULT) {
if (screenshot_has_default) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_MARKUP_INVALID,
"<screenshot> has more than one default");
}
screenshot_has_default = TRUE;
continue;
}
}
if (screenshots->len > 0 && !screenshot_has_default) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_MARKUP_INVALID,
"<screenshots> has no default <screenshot>");
}
}
static void
as_app_validate_icons (AsApp *app, AsAppValidateHelper *helper)
{
AsIcon *icon;
AsIconKind icon_kind;
const gchar *icon_name;
/* just check the default icon */
icon = as_app_get_icon_default (app);
if (icon == NULL) {
AsFormat *fmt = as_app_get_format_default (app);
if (fmt != NULL &&
as_format_get_kind (fmt) == AS_FORMAT_KIND_APPSTREAM &&
as_app_get_kind (app) == AS_APP_KIND_DESKTOP) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_TAG_MISSING,
"desktop application has no icon");
}
return;
}
/* check the content is correct */
icon_kind = as_icon_get_kind (icon);
switch (icon_kind) {
case AS_ICON_KIND_STOCK:
icon_name = as_icon_get_name (icon);
if (!as_utils_is_stock_icon_name (icon_name)) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_TAG_INVALID,
"stock icon is not valid [%s]",
icon_name);
}
break;
case AS_ICON_KIND_LOCAL:
icon_name = as_icon_get_filename (icon);
if (icon_name == NULL ||
!g_str_has_prefix (icon_name, "/")) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_TAG_INVALID,
"local icon is not a filename [%s]",
icon_name);
}
break;
case AS_ICON_KIND_CACHED:
icon_name = as_icon_get_name (icon);
if (icon_name == NULL ||
g_str_has_prefix (icon_name, "/")) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_TAG_INVALID,
"cached icon is a filename [%s]",
icon_name);
}
break;
case AS_ICON_KIND_REMOTE:
icon_name = as_icon_get_url (icon);
if (!g_str_has_prefix (icon_name, "http://") &&
!g_str_has_prefix (icon_name, "https://")) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_TAG_INVALID,
"remote icon is not a url [%s]",
icon_name);
}
break;
default:
break;
}
}
/**
* as_app_validate:
* @app: a #AsApp instance.
* @flags: the #AsAppValidateFlags to use, e.g. %AS_APP_VALIDATE_FLAG_NONE
* @error: A #GError or %NULL.
*
* Validates data in the instance for style and consistency.
*
* Returns: (transfer container) (element-type AsProblem): A list of problems, or %NULL
*
* Since: 0.1.4
**/
GPtrArray *
as_app_validate (AsApp *app, guint32 flags, GError **error)
{
AsAppProblems problems;
AsFormat *format;
GError *error_local = NULL;
GHashTable *urls;
GList *l;
const gchar *description;
const gchar *key;
const gchar *license;
const gchar *name;
const gchar *summary;
const gchar *tmp;
const gchar *update_contact;
gboolean deprecated_failure = FALSE;
gboolean require_appstream_spec_only = FALSE;
gboolean require_contactdetails = FALSE;
gboolean require_copyright = FALSE;
gboolean require_description = FALSE;
gboolean require_project_license = FALSE;
gboolean require_sentence_case = FALSE;
gboolean require_translations = FALSE;
gboolean require_url = TRUE;
gboolean require_content_license = TRUE;
gboolean require_name = TRUE;
gboolean require_translation = FALSE;
gboolean require_content_rating = FALSE;
gboolean require_name_shorter_than_summary = FALSE;
gboolean validate_license = TRUE;
gboolean ret;
guint length_name_max = 60;
guint length_name_min = 3;
guint length_summary_max = 200;
guint length_summary_min = 8;
guint number_para_max = 10;
guint number_para_min = 1;
guint str_len;
g_autoptr(GList) keys = NULL;
g_autoptr(AsAppValidateHelper) helper = g_new0 (AsAppValidateHelper, 1);
/* has to be set */
format = as_app_get_format_default (app);
if (format == NULL) {
g_set_error_literal (error,
AS_APP_ERROR,
AS_APP_ERROR_FAILED,
"cannot validate without at least one format");
return NULL;
}
/* only for desktop and console apps */
if (as_app_get_kind (app) == AS_APP_KIND_DESKTOP ||
as_app_get_kind (app) == AS_APP_KIND_CONSOLE) {
require_content_rating = TRUE;
require_description = TRUE;
}
/* relax the requirements a bit */
if ((flags & AS_APP_VALIDATE_FLAG_RELAX) > 0) {
length_name_max = 100;
length_summary_max = 200;
require_content_license = FALSE;
validate_license = FALSE;
require_url = FALSE;
number_para_max = 20;
number_para_min = 1;
require_sentence_case = FALSE;
require_content_rating = FALSE;
switch (as_format_get_kind (format)) {
case AS_FORMAT_KIND_METAINFO:
case AS_FORMAT_KIND_APPDATA:
require_name = FALSE;
break;
default:
break;
}
}
/* make the requirements more strict */
if ((flags & AS_APP_VALIDATE_FLAG_STRICT) > 0) {
deprecated_failure = TRUE;
require_copyright = TRUE;
require_translations = TRUE;
require_project_license = TRUE;
require_content_license = TRUE;
require_appstream_spec_only = TRUE;
require_sentence_case = TRUE;
require_name_shorter_than_summary = TRUE;
require_contactdetails = TRUE;
require_translation = TRUE;
number_para_min = 2;
number_para_max = 4;
}
/* addons don't need such a long description */
switch (as_format_get_kind (format)) {
case AS_FORMAT_KIND_METAINFO:
case AS_FORMAT_KIND_APPDATA:
number_para_min = 1;
break;
default:
break;
}
/* set up networking */
helper->app = app;
helper->probs = g_ptr_array_new_with_free_func ((GDestroyNotify) g_object_unref);
helper->screenshot_urls = g_ptr_array_new_with_free_func (g_free);
helper->flags = flags;
if (!as_app_validate_setup_networking (helper, error))
return NULL;
/* invalid component type */
if (as_app_get_kind (app) == AS_APP_KIND_UNKNOWN) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_ATTRIBUTE_INVALID,
"<component> has invalid type attribute");
}
as_app_validate_check_id (helper, as_app_get_id (app));
/* metadata_license */
license = as_app_get_metadata_license (app);
if (license != NULL) {
if (require_content_license &&
!as_app_validate_is_content_license (license)) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_TAG_INVALID,
"<metadata_license> is not valid [%s]",
license);
} else if (validate_license) {
if (!as_app_validate_license (license, &error_local)) {
g_prefix_error (&error_local,
"<metadata_license> is not valid [%s]",
license);
ai_app_validate_add (helper,
AS_PROBLEM_KIND_TAG_INVALID,
"%s", error_local->message);
g_clear_error (&error_local);
}
}
}
if (license == NULL) {
switch (as_format_get_kind (format)) {
case AS_FORMAT_KIND_APPDATA:
case AS_FORMAT_KIND_METAINFO:
ai_app_validate_add (helper,
AS_PROBLEM_KIND_TAG_MISSING,
"<metadata_license> is not present");
break;
default:
break;
}
}
/* project_license */
license = as_app_get_project_license (app);
if (license != NULL && validate_license) {
if (!as_app_validate_license (license, &error_local)) {
g_prefix_error (&error_local,
"<project_license> is not valid [%s]",
license);
ai_app_validate_add (helper,
AS_PROBLEM_KIND_TAG_INVALID,
"%s", error_local->message);
g_clear_error (&error_local);
}
}
if (require_project_license && license == NULL) {
switch (as_format_get_kind (format)) {
case AS_FORMAT_KIND_APPDATA:
case AS_FORMAT_KIND_METAINFO:
ai_app_validate_add (helper,
AS_PROBLEM_KIND_TAG_MISSING,
"<project_license> is not present");
break;
default:
break;
}
}
/* categories */
if (as_format_get_kind (format) == AS_FORMAT_KIND_APPSTREAM &&
as_app_get_kind (app) == AS_APP_KIND_DESKTOP) {
GPtrArray *categories = as_app_get_categories (app);
guint nr_toplevel_cats = 0;
const gchar *cats[] = { "AudioVideo",
"Development",
"Education",
"Game",
"Graphics",
"Network",
"Office",
"Science",
"Settings",
"System",
"Utility",
NULL };
for (guint i = 0; i < categories->len; i++) {
const gchar *cat = g_ptr_array_index (categories, i);
for (guint j = 0; cats[j] != NULL; j++) {
if (g_strcmp0 (cats[j], cat) == 0)
nr_toplevel_cats++;
}
}
if (nr_toplevel_cats == 0) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_TAG_MISSING,
"<category> must include main categories "
"from the desktop entry spec");
} else if (nr_toplevel_cats > 3) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_TAG_MISSING,
"too many main <category> types: %u",
nr_toplevel_cats);
}
}
/* translation */
if (require_translation &&
as_format_get_kind (format) == AS_FORMAT_KIND_APPDATA &&
as_app_get_translations (app)->len == 0) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_TAG_MISSING,
"<translation> not specified");
}
/* pkgname */
if (as_app_get_pkgname_default (app) != NULL &&
as_format_get_kind (format) == AS_FORMAT_KIND_METAINFO) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_TAG_INVALID,
"<pkgname> not allowed in metainfo");
}
/* appdata */
if (as_format_get_kind (format) == AS_FORMAT_KIND_APPDATA &&
as_app_get_kind (app) == AS_APP_KIND_DESKTOP) {
AsIcon *icon = as_app_get_icon_default (app);
if (icon != NULL &&
as_icon_get_kind (icon) != AS_ICON_KIND_REMOTE) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_TAG_INVALID,
"<icon> not allowed in desktop appdata");
}
}
/* extends */
if (as_app_get_extends(app)->len == 0 &&
as_app_get_kind (app) == AS_APP_KIND_ADDON &&
as_format_get_kind (format) == AS_FORMAT_KIND_METAINFO) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_TAG_MISSING,
"<extends> is not present");
}
/* update_contact */
update_contact = as_app_get_update_contact (app);
if (g_strcmp0 (update_contact,
"someone_who_cares@upstream_project.org") == 0) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_TAG_INVALID,
"<update_contact> is still set to a dummy value");
}
if (update_contact != NULL && strlen (update_contact) < 6) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_STYLE_INCORRECT,
"<update_contact> is too short [%s]",
update_contact);
}
if (require_contactdetails && update_contact == NULL) {
switch (as_format_get_kind (format)) {
case AS_FORMAT_KIND_APPDATA:
case AS_FORMAT_KIND_METAINFO:
ai_app_validate_add (helper,
AS_PROBLEM_KIND_TAG_MISSING,
"<update_contact> is not present");
break;
default:
break;
}
}
/* only found for files */
problems = as_app_get_problems (app);
if (as_format_get_kind (format) == AS_FORMAT_KIND_APPDATA ||
as_format_get_kind (format) == AS_FORMAT_KIND_METAINFO) {
if ((problems & AS_APP_PROBLEM_NO_XML_HEADER) > 0) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_MARKUP_INVALID,
"<?xml> header not found");
}
if (require_copyright &&
(problems & AS_APP_PROBLEM_NO_COPYRIGHT_INFO) > 0) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_VALUE_MISSING,
"<!-- Copyright [year] [name] --> is not present");
}
if (deprecated_failure &&
(problems & AS_APP_PROBLEM_UPDATECONTACT_FALLBACK) > 0) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_TAG_INVALID,
"<updatecontact> should be <update_contact>");
}
}
/* check invalid values */
if ((problems & AS_APP_PROBLEM_INVALID_PROJECT_GROUP) > 0) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_TAG_INVALID,
"<project_group> is not valid");
}
/* only allow XML in the specification */
if (require_appstream_spec_only &&
(problems & AS_APP_PROBLEM_INVALID_XML_TAG) > 0) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_TAG_INVALID,
"XML data contains unknown tag");
}
/* only allow XML in the specification */
if (problems & AS_APP_PROBLEM_EXPECTED_CHILDREN) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_TAG_INVALID,
"Expected children for tag");
}
/* only allow XML in the specification */
if (problems & AS_APP_PROBLEM_INVALID_KEYWORDS) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_TAG_INVALID,
"<keyword> invalid contents");
}
/* releases all have to have unique versions */
if (problems & AS_APP_PROBLEM_DUPLICATE_RELEASE) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_TAG_INVALID,
"<release> version was duplicated");
}
if (problems & AS_APP_PROBLEM_DUPLICATE_SCREENSHOT) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_TAG_INVALID,
"<screenshot> content was duplicated");
}
if (problems & AS_APP_PROBLEM_DUPLICATE_CONTENT_RATING) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_TAG_INVALID,
"<content_rating> was duplicated");
}
/* check for things that have to exist */
if (as_app_get_id (app) == NULL) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_TAG_MISSING,
"<id> is not present");
}
/* games require a content rating */
if (require_content_rating) {
GPtrArray *ratings = as_app_get_content_ratings (app);
if (ratings->len == 0) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_TAG_MISSING,
"<content_rating> required "
"[use https://odrs.gnome.org/oars]");
}
}
/* url */
urls = as_app_get_urls (app);
keys = g_hash_table_get_keys (urls);
for (l = keys; l != NULL; l = l->next) {
key = l->data;
if (g_strcmp0 (key, "unknown") == 0) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_TAG_INVALID,
"<url> type invalid [%s]", key);
}
tmp = g_hash_table_lookup (urls, key);
if (tmp == NULL || tmp[0] == '\0')
continue;
if (!g_str_has_prefix (tmp, "http://") &&
!g_str_has_prefix (tmp, "https://")) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_TAG_INVALID,
"<url> does not start with 'http://' [%s]",
tmp);
}
}
/* screenshots */
as_app_validate_screenshots (app, helper);
/* icons */
as_app_validate_icons (app, helper);
/* releases */
if (!as_app_validate_releases (app, helper, error))
return NULL;
/* kudos */
if (!as_app_validate_kudos (app, helper, error))
return NULL;
/* name */
name = as_app_get_name (app, "C");
if (name != NULL) {
str_len = (guint) strlen (name);
if (str_len < length_name_min) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_STYLE_INCORRECT,
"<name> is too short [%s] minimum is %u chars",
name, length_name_min);
}
if (str_len > length_name_max) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_STYLE_INCORRECT,
"<name> is too long [%s] maximum is %u chars",
name, length_name_max);
}
if (ai_app_validate_fullstop_ending (name)) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_STYLE_INCORRECT,
"<name> cannot end in '.' [%s]",
name);
}
if (as_app_validate_has_hyperlink (name)) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_STYLE_INCORRECT,
"<name> cannot contain a hyperlink [%s]",
name);
}
if (require_sentence_case &&
!as_app_validate_has_first_word_capital (helper, name)) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_STYLE_INCORRECT,
"<name> requires sentence case [%s]",
name);
}
} else if (require_name) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_TAG_MISSING,
"<name> is not present");
}
/* comment */
summary = as_app_get_comment (app, "C");
if (summary != NULL) {
str_len = (guint) strlen (summary);
if (str_len < length_summary_min) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_STYLE_INCORRECT,
"<summary> is too short [%s] minimum is %u chars",
summary, length_summary_min);
}
if (str_len > length_summary_max) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_STYLE_INCORRECT,
"<summary> is too long [%s] maximum is %u chars",
summary, length_summary_max);
}
if (require_sentence_case &&
ai_app_validate_fullstop_ending (summary)) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_STYLE_INCORRECT,
"<summary> cannot end in '.' [%s]",
summary);
}
if (as_app_validate_has_hyperlink (summary)) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_STYLE_INCORRECT,
"<summary> cannot contain a hyperlink [%s]",
summary);
}
if (require_sentence_case &&
!as_app_validate_has_first_word_capital (helper, summary)) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_STYLE_INCORRECT,
"<summary> requires sentence case [%s]",
summary);
}
} else if (require_name) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_TAG_MISSING,
"<summary> is not present");
}
if (require_name_shorter_than_summary &&
summary != NULL && name != NULL &&
strlen (summary) < strlen (name)) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_STYLE_INCORRECT,
"<summary> is shorter than <name>");
}
description = as_app_get_description (app, "C");
if (description == NULL) {
if (require_description) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_TAG_MISSING,
"<description> required");
}
} else {
ret = as_app_validate_description (description,
helper,
number_para_min,
number_para_max,
FALSE,
&error_local);
if (!ret) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_MARKUP_INVALID,
"%s", error_local->message);
g_error_free (error_local);
}
}
if (require_translations) {
if (name != NULL &&
as_app_get_name_size (app) == 1 &&
(problems & AS_APP_PROBLEM_INTLTOOL_NAME) == 0) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_TRANSLATIONS_REQUIRED,
"<name> has no translations");
}
if (summary != NULL &&
as_app_get_comment_size (app) == 1 &&
(problems & AS_APP_PROBLEM_INTLTOOL_SUMMARY) == 0) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_TRANSLATIONS_REQUIRED,
"<summary> has no translations");
}
if (description != NULL &&
as_app_get_description_size (app) == 1 &&
(problems & AS_APP_PROBLEM_INTLTOOL_DESCRIPTION) == 0) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_TRANSLATIONS_REQUIRED,
"<description> has no translations");
}
}
/* developer_name */
name = as_app_get_developer_name (app, NULL);
if (name != NULL) {
str_len = (guint) strlen (name);
if (str_len < length_name_min) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_STYLE_INCORRECT,
"<developer_name> is too short [%s] minimum is %u chars",
name, length_name_min);
}
if (str_len > length_name_max) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_STYLE_INCORRECT,
"<developer_name> is too long [%s] maximum is %u chars",
name, length_name_max);
}
if (as_app_validate_has_hyperlink (name)) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_STYLE_INCORRECT,
"<developer_name> cannot contain a hyperlink [%s]",
name);
}
if (as_app_validate_has_email (name)) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_STYLE_INCORRECT,
"<developer_name> cannot contain an email address [%s]",
name);
}
}
/* using deprecated names */
if (deprecated_failure && (problems & AS_APP_PROBLEM_DEPRECATED_LICENCE) > 0) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_ATTRIBUTE_INVALID,
"<licence> is deprecated, use "
"<metadata_license> instead");
}
if ((problems & AS_APP_PROBLEM_MULTIPLE_ENTRIES) > 0) {
ai_app_validate_add (helper,
AS_PROBLEM_KIND_MARKUP_INVALID,
"<application> used more than once");
}
/* require homepage */
if (require_url && as_app_get_url_item (app, AS_URL_KIND_HOMEPAGE) == NULL) {
switch (as_format_get_kind (format)) {
case AS_FORMAT_KIND_APPDATA:
case AS_FORMAT_KIND_METAINFO:
ai_app_validate_add (helper,
AS_PROBLEM_KIND_TAG_MISSING,
"<url> is not present");
break;
default:
break;
}
}
return helper->probs;
}
static void
gs_editor_refresh_details (GsEditor *self)
{
AsAppKind app_kind = AS_APP_KIND_UNKNOWN;
GtkWidget *widget;
const gchar *css = NULL;
g_autoptr(GError) error = NULL;
g_autoptr(GsApp) app = NULL;
/* ignore changed events */
self->is_in_refresh = TRUE;
/* create a GsApp for the AsApp */
if (self->selected_item != NULL) {
app = gs_editor_convert_app (self, self->selected_item);
g_debug ("refreshing details for %s", gs_app_get_id (app));
}
/* get kind */
if (self->selected_item != NULL)
app_kind = as_app_get_kind (self->selected_item);
/* feature tiles */
if (app_kind != AS_APP_KIND_OS_UPGRADE) {
if (self->selected_item != NULL) {
gs_app_tile_set_app (GS_APP_TILE (self->featured_tile1), app);
gtk_widget_set_sensitive (self->featured_tile1, TRUE);
} else {
gtk_widget_set_sensitive (self->featured_tile1, FALSE);
}
gtk_widget_set_visible (self->featured_tile1, TRUE);
} else {
gtk_widget_set_visible (self->featured_tile1, FALSE);
}
/* upgrade banner */
if (app_kind == AS_APP_KIND_OS_UPGRADE) {
if (self->selected_item != NULL) {
gs_upgrade_banner_set_app (GS_UPGRADE_BANNER (self->upgrade_banner), app);
gtk_widget_set_sensitive (self->upgrade_banner, TRUE);
} else {
gtk_widget_set_sensitive (self->upgrade_banner, FALSE);
}
gtk_widget_set_visible (self->upgrade_banner, TRUE);
} else {
gtk_widget_set_visible (self->upgrade_banner, FALSE);
}
/* name */
widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "box_name"));
if (self->selected_item != NULL) {
const gchar *tmp;
gtk_widget_set_visible (widget, app_kind == AS_APP_KIND_OS_UPGRADE);
widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "entry_name"));
tmp = as_app_get_name (self->selected_item, NULL);
if (tmp != NULL)
gtk_entry_set_text (GTK_ENTRY (widget), tmp);
} else {
gtk_widget_set_visible (widget, FALSE);
}
/* summary */
widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "box_summary"));
if (self->selected_item != NULL) {
const gchar *tmp;
gtk_widget_set_visible (widget, app_kind == AS_APP_KIND_OS_UPGRADE);
widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "entry_summary"));
tmp = as_app_get_comment (self->selected_item, NULL);
if (tmp != NULL)
gtk_entry_set_text (GTK_ENTRY (widget), tmp);
} else {
gtk_widget_set_visible (widget, FALSE);
}
/* kudos */
widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "box_kudos"));
if (self->selected_item != NULL) {
gtk_widget_set_visible (widget, app_kind != AS_APP_KIND_OS_UPGRADE);
} else {
gtk_widget_set_visible (widget, TRUE);
}
/* category featured */
widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "checkbutton_category_featured"));
if (self->selected_item != NULL) {
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget),
as_app_has_category (self->selected_item,
"Featured"));
gtk_widget_set_sensitive (widget, TRUE);
} else {
gtk_widget_set_sensitive (widget, FALSE);
}
/* kudo popular */
widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "checkbutton_editors_pick"));
if (self->selected_item != NULL) {
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget),
as_app_has_kudo (self->selected_item,
"GnomeSoftware::popular"));
gtk_widget_set_sensitive (widget, TRUE);
} else {
gtk_widget_set_sensitive (widget, FALSE);
}
/* featured */
widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "textview_css"));
if (self->selected_item != NULL) {
GtkTextBuffer *buffer;
GtkTextIter iter_end;
GtkTextIter iter_start;
g_autofree gchar *css_existing = NULL;
if (app_kind == AS_APP_KIND_OS_UPGRADE) {
css = as_app_get_metadata_item (self->selected_item,
"GnomeSoftware::UpgradeBanner-css");
} else {
css = as_app_get_metadata_item (self->selected_item,
"GnomeSoftware::FeatureTile-css");
}
if (css == NULL)
css = "";
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (widget));
gtk_text_buffer_get_bounds (buffer, &iter_start, &iter_end);
css_existing = gtk_text_buffer_get_text (buffer, &iter_start, &iter_end, FALSE);
if (g_strcmp0 (css_existing, css) != 0)
gtk_text_buffer_set_text (buffer, css, -1);
gtk_widget_set_sensitive (widget, TRUE);
} else {
gtk_widget_set_sensitive (widget, FALSE);
}
/* desktop ID */
widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "entry_desktop_id"));
if (self->selected_item != NULL) {
const gchar *id = as_app_get_id (self->selected_item);
if (id == NULL)
id = "";
gtk_entry_set_text (GTK_ENTRY (widget), id);
gtk_widget_set_sensitive (widget, TRUE);
} else {
gtk_entry_set_text (GTK_ENTRY (widget), "");
gtk_widget_set_sensitive (widget, FALSE);
}
/* validate CSS */
if (css == NULL) {
widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "label_infobar_css"));
gtk_label_set_label (GTK_LABEL (widget), "");
widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "infobar_css"));
gtk_info_bar_set_message_type (GTK_INFO_BAR (widget), GTK_MESSAGE_OTHER);
} else if (!gs_design_validate_css (self, css, &error)) {
g_autofree gchar *msg = g_strdup (error->message);
g_strdelimit (msg, "\n\r<>", '\0');
widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "label_infobar_css"));
gtk_label_set_label (GTK_LABEL (widget), msg);
widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "infobar_css"));
gtk_info_bar_set_message_type (GTK_INFO_BAR (widget), GTK_MESSAGE_WARNING);
} else {
widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "label_infobar_css"));
gtk_label_set_label (GTK_LABEL (widget), _("CSS validated OK!"));
widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "infobar_css"));
gtk_info_bar_set_message_type (GTK_INFO_BAR (widget), GTK_MESSAGE_OTHER);
}
/* do not ignore changed events */
self->is_in_refresh = FALSE;
}
static gboolean
asb_plugin_process_filename (AsbPlugin *plugin,
AsbPackage *pkg,
const gchar *filename,
GList **apps,
GError **error)
{
AsProblemKind problem_kind;
AsProblem *problem;
GPtrArray *icons;
const gchar *tmp;
guint i;
g_autoptr(AsbApp) app = NULL;
g_autoptr(GPtrArray) problems = NULL;
app = asb_app_new (NULL, NULL);
if (!as_app_parse_file (AS_APP (app), filename,
AS_APP_PARSE_FLAG_USE_HEURISTICS,
error))
return FALSE;
if (as_app_get_kind (AS_APP (app)) == AS_APP_KIND_UNKNOWN) {
g_set_error (error,
ASB_PLUGIN_ERROR,
ASB_PLUGIN_ERROR_FAILED,
"%s has no recognised type",
as_app_get_id (AS_APP (app)));
return FALSE;
}
/* validate */
problems = as_app_validate (AS_APP (app),
AS_APP_VALIDATE_FLAG_NO_NETWORK |
AS_APP_VALIDATE_FLAG_RELAX,
error);
if (problems == NULL)
return FALSE;
asb_app_set_package (app, pkg);
for (i = 0; i < problems->len; i++) {
problem = g_ptr_array_index (problems, i);
problem_kind = as_problem_get_kind (problem);
asb_package_log (asb_app_get_package (app),
ASB_PACKAGE_LOG_LEVEL_WARNING,
"AppData problem: %s : %s",
as_problem_kind_to_string (problem_kind),
as_problem_get_message (problem));
}
/* nuke things that do not belong */
icons = as_app_get_icons (AS_APP (app));
if (icons->len > 0)
g_ptr_array_set_size (icons, 0);
/* fix up the project license */
tmp = as_app_get_project_license (AS_APP (app));
if (tmp != NULL && !as_utils_is_spdx_license (tmp)) {
g_autofree gchar *license_spdx = NULL;
license_spdx = as_utils_license_to_spdx (tmp);
if (as_utils_is_spdx_license (license_spdx)) {
asb_package_log (asb_app_get_package (app),
ASB_PACKAGE_LOG_LEVEL_WARNING,
"project license fixup: %s -> %s",
tmp, license_spdx);
as_app_set_project_license (AS_APP (app), license_spdx);
} else {
asb_package_log (asb_app_get_package (app),
ASB_PACKAGE_LOG_LEVEL_WARNING,
"project license is invalid: %s", tmp);
as_app_set_project_license (AS_APP (app), NULL);
}
}
/* check license */
tmp = as_app_get_metadata_license (AS_APP (app));
if (tmp == NULL) {
g_set_error (error,
ASB_PLUGIN_ERROR,
ASB_PLUGIN_ERROR_FAILED,
"AppData %s has no licence",
filename);
return FALSE;
}
if (!as_utils_is_spdx_license (tmp)) {
g_set_error (error,
ASB_PLUGIN_ERROR,
ASB_PLUGIN_ERROR_FAILED,
"AppData %s license '%s' invalid",
filename, tmp);
return FALSE;
}
/* log updateinfo */
tmp = as_app_get_update_contact (AS_APP (app));
if (tmp != NULL) {
asb_package_log (asb_app_get_package (app),
ASB_PACKAGE_LOG_LEVEL_INFO,
"Upstream contact <%s>", tmp);
}
/* add icon for firmware */
if (as_app_get_kind (AS_APP (app)) == AS_APP_KIND_FIRMWARE) {
g_autoptr(AsIcon) icon = NULL;
icon = as_icon_new ();
as_icon_set_kind (icon, AS_ICON_KIND_STOCK);
as_icon_set_name (icon, "application-x-executable");
as_app_add_icon (AS_APP (app), icon);
}
/* fix up input methods */
if (as_app_get_kind (AS_APP (app)) == AS_APP_KIND_INPUT_METHOD) {
g_autoptr(AsIcon) icon = NULL;
icon = as_icon_new ();
as_icon_set_kind (icon, AS_ICON_KIND_STOCK);
as_icon_set_name (icon, "system-run-symbolic");
as_app_add_icon (AS_APP (app), icon);
as_app_add_category (AS_APP (app), "Addons");
as_app_add_category (AS_APP (app), "InputSources");
}
/* fix up codecs */
if (as_app_get_kind (AS_APP (app)) == AS_APP_KIND_CODEC) {
g_autoptr(AsIcon) icon = NULL;
icon = as_icon_new ();
as_icon_set_kind (icon, AS_ICON_KIND_STOCK);
as_icon_set_name (icon, "application-x-executable");
as_app_add_icon (AS_APP (app), icon);
as_app_add_category (AS_APP (app), "Addons");
as_app_add_category (AS_APP (app), "Codecs");
}
/* success */
asb_app_set_hidpi_enabled (app, asb_context_get_flag (plugin->ctx,
ASB_CONTEXT_FLAG_HIDPI_ICONS));
asb_plugin_add_app (apps, AS_APP (app));
return TRUE;
}
