static PHP_METHOD(midgard_object_class, has_metadata)
{
MidgardConnection *mgd = mgd_handle(TSRMLS_C);
CHECK_MGD(mgd);
zval *zvalue;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &zvalue) == FAILURE) {
return;
}
const char *php_classname = NULL;
if (Z_TYPE_P(zvalue) == IS_STRING) {
php_classname = Z_STRVAL_P(zvalue);
} else if (Z_TYPE_P(zvalue) == IS_OBJECT) {
php_classname = Z_OBJCE_P(zvalue)->name;
} else {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "argument should be object or string");
return;
}
const gchar *g_classname = php_class_name_to_g_class_name(php_classname);
MidgardObjectClass *klass = MIDGARD_OBJECT_GET_CLASS_BY_NAME(g_classname);
if (!klass) {
php_error(E_WARNING, "MidgardObjectClass not found");
return;
}
RETURN_BOOL(midgard_reflector_object_has_metadata_class(g_classname));
}
void midgard_test_object_tree_basic(MidgardObjectTest *mot, gconstpointer data)
{
g_assert(mot != NULL);
MidgardObject *object = MIDGARD_OBJECT(mot->object);
MidgardObjectClass *klass = MIDGARD_OBJECT_GET_CLASS(object);
/* Get parent (in tree) class and check if parent has the same child declared */
const gchar *pname = midgard_schema_object_tree_get_parent_name (object);
if (!pname)
return;
MidgardObjectClass *pklass = MIDGARD_OBJECT_GET_CLASS_BY_NAME(pname);
g_assert(pklass != NULL);
/* There is tree parent declared so parent property can not be NULL */
const gchar *parent_property = midgard_reflector_object_get_property_parent (G_OBJECT_CLASS_NAME (klass));
g_assert(parent_property != NULL);
guint n_child;
gchar **children = midgard_reflector_object_list_children (G_OBJECT_CLASS_NAME (pklass), &n_child);
g_assert(children != NULL);
guint i = 0;
gboolean has_child_class = FALSE;
for (i = 0; i < n_child; i++) {
if (g_type_from_name (children[i]) == G_OBJECT_CLASS_TYPE(klass))
has_child_class = TRUE;
}
g_free(children);
g_assert(has_child_class != FALSE);
}
MidgardObject *midgard_core_object_parameters_create(
MidgardConnection *mgd, const gchar *class_name,
const gchar *guid, guint n_params, const GParameter *parameters)
{
g_assert(mgd != NULL);
g_assert(class_name != NULL);
g_assert(guid != NULL);
g_assert(n_params > 0);
guint i;
GParamSpec *pspec = NULL;
GValue pval;
const gchar *prop_name;
MidgardObjectClass *klass =
MIDGARD_OBJECT_GET_CLASS_BY_NAME(class_name);
MidgardObject *object = midgard_object_new(mgd, class_name, NULL);
/* Check if properties in parameters are registered for given class */
for ( i = 0; i < n_params; i++) {
prop_name = parameters[i].name;
pval = parameters[i].value;
pspec = g_object_class_find_property(G_OBJECT_CLASS(klass), prop_name);
if(!pspec) {
MIDGARD_ERRNO_SET(mgd, MGD_ERR_INVALID_PROPERTY);
g_warning("Property '%s' not registered for '%s' class",
parameters[i].name, class_name);
g_object_unref(object);
return NULL;
}
g_object_set_property(G_OBJECT(object), prop_name, &pval);
}
/* Set parentguid so we definitely define parameter or attachment*/
g_object_set(object, "parentguid", guid, NULL);
if(!midgard_object_create(object)) {
g_object_unref(object);
/* error code is set by create method */
return NULL;
}
return object;
}
static PHP_METHOD(midgard_object_class, get_schema_value)
{
MidgardConnection *mgd = mgd_handle(TSRMLS_C);
CHECK_MGD(mgd);
zval *zvalue;
char *name;
int name_length;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zs", &zvalue, &name, &name_length) == FAILURE) {
return;
}
const gchar *classname = NULL;
if (Z_TYPE_P(zvalue) == IS_STRING) {
classname = (const gchar *) Z_STRVAL_P(zvalue);
} else if (Z_TYPE_P(zvalue) == IS_OBJECT) {
classname = (const gchar *) Z_OBJCE_P(zvalue)->name;
} else {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "first argument should be object or string");
return;
}
MidgardObjectClass *klass = MIDGARD_OBJECT_GET_CLASS_BY_NAME(classname);
if (!klass) {
php_error(E_WARNING, "MidgardObjectClass not found");
return;
}
const gchar *schema_value = midgard_reflector_object_get_schema_value(classname, (const gchar *)name);
if (!schema_value)
RETURN_NULL();
RETURN_STRING((char *)schema_value, 1);
}
static PHP_METHOD(midgard_object_class, get_property_parent)
{
MidgardConnection *mgd = mgd_handle(TSRMLS_C);
CHECK_MGD(mgd);
zval *zvalue;
MidgardObjectClass *klass = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &zvalue) == FAILURE) {
return;
}
const gchar *classname = NULL;
if (Z_TYPE_P(zvalue) == IS_STRING) {
classname = (const gchar *)Z_STRVAL_P(zvalue);
} else if (Z_TYPE_P(zvalue) == IS_OBJECT) {
classname = (const gchar *)Z_OBJCE_P(zvalue)->name;
} else {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "argument should be object or string");
return;
}
klass = MIDGARD_OBJECT_GET_CLASS_BY_NAME(classname);
if (!klass) {
php_error(E_WARNING, "MidgardObjectClass not found");
return;
}
const gchar *property_parent = midgard_reflector_object_get_property_parent(classname);
if (!property_parent)
RETURN_NULL();
RETURN_STRING((gchar *)property_parent, 1);
}
void midgard_test_object_tree_basic(MgdObjectTest *mot, gconstpointer data)
{
g_assert(mot != NULL);
MgdObject *object = MIDGARD_OBJECT(mot->object);
MidgardObjectClass *klass = MIDGARD_OBJECT_GET_CLASS(object);
/* Get parent (in tree) class and check if parent has the same child declared */
const gchar *pname = midgard_object_parent(object);
if(!pname)
return;
MidgardObjectClass *pklass = MIDGARD_OBJECT_GET_CLASS_BY_NAME(pname);
g_assert(pklass != NULL);
/* There is tree parent declared so parent property can not be NULL */
const gchar *parent_property = midgard_object_class_get_parent_property(klass);
g_assert(parent_property != NULL);
MidgardObjectClass **children = midgard_object_class_list_children(pklass);
g_assert(children != NULL);
guint i = 0;
gboolean has_child_class = FALSE;
while(children[i] != NULL) {
if(G_OBJECT_CLASS_TYPE(children[i]) == G_OBJECT_CLASS_TYPE(klass))
has_child_class = TRUE;
i++;
}
g_free(children);
g_assert(has_child_class != FALSE);
}
/**
* midgard_replicator_export_by_guid:
* @mgd: #MidgardConnection instance
* @guid: guid which identifies object to be exported
*
* Marks object's storage record as exported.
*
* Cases to return %FALSE:
* <itemizedlist>
* <listitem><para>
* Given guid is NULL or empty string (MGD_ERR_INVALID_PROPERTY_VALUE)
* </para></listitem>
* <listitem><para>
* Object identified by given guid doesn't exist (MGD_ERR_NOT_EXISTS)
* </para></listitem>
* <listitem><para>
* Object identified by given guid is purged (MGD_ERR_OBJECT_PURGED)
* </para></listitem>
* <listitem><para>
* Internal storage error (MGD_ERR_INTERNAL)
* </para></listitem>
* </itemizedlist>
*
* Returns: %TRUE on success, %FALSE otherwise
*/
gboolean
midgard_replicator_export_by_guid (MidgardConnection *mgd, const gchar *guid)
{
g_return_val_if_fail (mgd != NULL, FALSE);
if(guid == NULL || (guid && (*guid == '\0'))) {
MIDGARD_ERRNO_SET_STRING (mgd, MGD_ERR_INVALID_PROPERTY_VALUE, "Empty or NULL guid given");
return FALSE;
}
MIDGARD_ERRNO_SET(mgd, MGD_ERR_OK);
MidgardDBObject *repligard = NULL;
GError *error = NULL;
GValue gval = {0, };
g_value_init (&gval, G_TYPE_STRING);
g_value_set_string (&gval, guid);
midgard_core_query_get_object (mgd, g_type_name (MIDGARD_TYPE_REPLIGARD), &repligard, FALSE, &error, "guid", &gval, NULL);
g_value_unset (&gval);
if (error) {
MIDGARD_ERRNO_SET_STRING (mgd, error->code, "%s", error->message);
g_clear_error (&error);
if (repligard)
g_object_unref (G_OBJECT (repligard));
return FALSE;
}
guint action;
gchar *classname;
g_object_get (repligard,
"action", &action,
"type", &classname, NULL);
g_object_unref (repligard);
MidgardObjectClass *klass = MIDGARD_OBJECT_GET_CLASS_BY_NAME(classname);
if(klass == NULL) {
g_warning("Failed to get class pointer for '%s', an object identified with '%s'", classname, guid);
MIDGARD_ERRNO_SET(mgd, MGD_ERR_INTERNAL);
g_free (classname);
return FALSE;
}
g_free (classname);
const gchar *table = midgard_core_class_get_table(MIDGARD_DBOBJECT_CLASS(klass));
GValue tval = {0, };
gchar *timeupdated;
gint qr;
GString *sql = NULL;
switch(action) {
case MGD_OBJECT_ACTION_PURGE:
MIDGARD_ERRNO_SET(mgd, MGD_ERR_OBJECT_PURGED);
return FALSE;
break;
default:
sql = g_string_new ("UPDATE ");
g_string_append_printf(sql, "%s SET ", table);
midgard_timestamp_new_current (&tval);
timeupdated = midgard_timestamp_get_string_from_value (&tval);
g_string_append_printf(sql, "metadata_exported='%s' WHERE guid = '%s' ",
timeupdated, guid);
qr = midgard_core_query_execute(mgd, sql->str, TRUE);
g_string_free(sql, TRUE);
g_value_unset (&tval);
g_free(timeupdated);
if (qr == 0) {
MIDGARD_ERRNO_SET(mgd, MGD_ERR_INTERNAL);
return FALSE;
}
return TRUE;
break;
}
return FALSE;
}
static void __get_view_properties(xmlNode *node, MgdSchemaTypeAttr *type)
{
xmlNode *cur;
MgdSchemaPropertyAttr *rprop_attr = NULL;
gchar *property_name = NULL;
for (cur = node->children; cur; cur = cur->next) {
if (cur->type == XML_ELEMENT_NODE
&& g_str_equal(cur->name, "property")) { /* FIXME, add property to reserved words constants */
property_name = NULL;
rprop_attr = NULL;
xmlChar *name = xmlGetProp(cur, (const xmlChar *)TYPE_RW_NAME);
if (!name || (name && *name == '\0'))
__view_error(cur, "Can not register view with empty property", NULL);
xmlChar *use_prop = xmlGetProp(cur, (const xmlChar *) "use"); /* FIXME, use reserved word */
if (!use_prop || (use_prop && *use_prop == '\0'))
__view_error(cur, "Referenced class:property can not be empty", NULL);
gchar **rprop = g_strsplit_set ((const gchar *)use_prop, ":.", -1);
xmlFree (use_prop);
if (!rprop || rprop[0] == NULL || rprop[1] == NULL) {
__view_error(cur, "Referenced property can not be empty", NULL);
return;
}
MidgardObjectClass *klass = MIDGARD_OBJECT_GET_CLASS_BY_NAME(rprop[0]);
if (!klass)
__view_error (cur, "Defined '%s' class is not registered as midagrd_object derived one", rprop[0]);
const gchar *table = midgard_core_class_get_table (MIDGARD_DBOBJECT_CLASS (klass));
if (table == NULL)
__view_error (cur, "Can not create proper view. Defined '%s' class has NULL storage", rprop[0]);
__get_property_attribute (cur, rprop, &property_name, &rprop_attr, MIDGARD_DBOBJECT_CLASS (klass));
midgard_core_schema_type_property_copy(rprop_attr, type);
/* TODO, refactor with some usable TypeAttr related API */
/* Create property attributes copy using original property.
Then change name. */
MgdSchemaPropertyAttr *prop_attr = g_hash_table_lookup(type->prophash, property_name);
if (!prop_attr)
g_warning("Can not find %s.%s in newly registered view", type->name, name);
if (prop_attr) {
g_free((gchar *)prop_attr->name);
prop_attr->name = g_strdup((gchar *)name);
/* Free old key and remove new one in hash table */
g_hash_table_remove(type->prophash, (gconstpointer) rprop[1]);
gchar *property_name = g_strdup ((gchar *)name);
g_hash_table_insert(type->prophash, property_name, prop_attr);
/* FIXME
* Workaround for properties not being registered in the same order as defined
* in view xml file */
type->_properties_list = g_slist_append (type->_properties_list, property_name);
}
g_strfreev(rprop);
xmlFree(name);
}
}
}
static void __get_view_constraints(xmlNode *node, MgdSchemaTypeAttr *type)
{
xmlNode *cur;
for (cur = node->children; cur; cur = cur->next) {
if (cur->type == XML_ELEMENT_NODE
&& g_str_equal(cur->name, "constraint")) { /* FIXME, add constraint to reserved words constants */
xmlChar *property = xmlGetProp(cur, (const xmlChar *)"property");
if (!property || (property && *property == '\0'))
__view_error(cur, "Can not add constraint with empty property", NULL);
gchar **classprop = g_strsplit((gchar *)property, ":", 2);
if (!classprop || classprop[0] == NULL || classprop[1] == NULL) {
__view_error(cur, "Constraint property misconfigured", NULL);
return;
}
MidgardDBObjectClass *klass =
MIDGARD_DBOBJECT_CLASS(MIDGARD_OBJECT_GET_CLASS_BY_NAME((const gchar *)classprop[0]));
if (!klass)
__view_error(cur, "Class %s not registered", classprop[0]);
MidgardCoreQueryConstraint *constraint = midgard_core_query_constraint_new();
if (!midgard_core_query_constraint_parse_property(&constraint, klass, classprop[1]))
__view_error(cur, "Can not parse %s constraint property", classprop[1]);
g_strfreev(classprop);
xmlFree(property);
/* Add operator */
xmlChar *operator = xmlGetProp(cur, (const xmlChar *)"operator");
if (!operator || (operator && *operator == '\0'))
__view_error(cur, "Can not add constraint with empty operator", NULL);
if (!midgard_core_query_constraint_add_operator(constraint, (const gchar *)operator))
__view_error(cur, "Invalid operator", NULL);
xmlFree(operator);
/* Add value */
xmlChar *valtype = xmlGetProp(cur, (const xmlChar *)"value_type");
if (!valtype || (valtype && *valtype == '\0'))
__view_error(cur, "Can not add constraint with empty value_type", NULL);
GType vtype = midgard_core_schema_gtype_from_string((const gchar *)valtype);
if (!vtype)
__view_error(cur, "Invalid %s value_type", valtype);
xmlFree(valtype);
xmlChar *value = xmlGetProp(cur, (const xmlChar *)"value");
if (!value || (value && *value == '\0'))
__view_error(cur, "Can not add constraint with empty value", NULL);
/* Get value as string and convert to declared type */
GValue strval = {0, };
g_value_init(&strval, G_TYPE_STRING);
g_value_set_string(&strval, (const gchar *)value);
GValue val = {0, };
g_value_init(&val, vtype);
g_value_transform((const GValue *) &strval, &val);
midgard_core_query_constraint_add_value(constraint, &val);
midgard_core_query_constraint_build_condition(constraint);
type->constraints = g_slist_append(type->constraints, (gpointer) constraint);
g_value_unset(&val);
g_value_unset(&strval);
xmlFree(value);
}
}
}
static void __get_view_joins(xmlNode *node, MgdSchemaTypeAttr *type)
{
xmlNode *cur;
gchar *property_name = NULL;
MgdSchemaPropertyAttr *propright = NULL;
MgdSchemaPropertyAttr *propleft = NULL;
for (cur = node->children; cur; cur = cur->next) {
if (cur->type == XML_ELEMENT_NODE
&& g_str_equal(cur->name, "join")) { /* FIXME, add join to reserved words constants */
property_name = NULL;
propright = NULL;
propleft = NULL;
xmlChar *jointype = xmlGetProp(cur, (const xmlChar *)"type");
if (!jointype || (jointype && *jointype == '\0'))
__view_error(cur, "Can not create join with empty type", NULL);
if (!midgard_core_xml_attribute_is_allowed(__allowed_joins, jointype))
__view_error(cur, "%s join type is not allowed", jointype);
xmlChar *classname = xmlGetProp(cur, (const xmlChar *)"class");
xmlChar *table = NULL;
if (!classname || (classname && *classname == '\0')) {
table = xmlGetProp(cur, (const xmlChar *) TYPE_RW_TABLE);
if (!table)
__view_error(cur, "Can not create join. Empty, not defined class or table", NULL);
}
MidgardDBObjectClass *klass = NULL;
MidgardDBObjectClass *joinklass = NULL;
if (classname)
joinklass = MIDGARD_DBOBJECT_CLASS(MIDGARD_OBJECT_GET_CLASS_BY_NAME((const gchar *)classname));
if (!joinklass) {
g_warning ("%s is not registered in GType system", classname);
__view_error (cur, "Invalid classname for defined join");
return;
}
gchar *left = midgard_core_xml_get_child_attribute_content_by_name(cur, "condition", "left");
if (!left)
__view_error(cur, "Condition left is missing", NULL);
gchar *right = midgard_core_xml_get_child_attribute_content_by_name(cur, "condition", "right");
if (!right)
__view_error(cur, "Condition right is missing", NULL);
/* Get left property attribute */
gchar **classprop = g_strsplit_set(left, ":.", -1);
if (!classprop || classprop[0] == NULL || classprop[1] == NULL) {
__view_error(cur, "Condition left problem", NULL);
return;
}
klass = MIDGARD_DBOBJECT_CLASS(MIDGARD_OBJECT_GET_CLASS_BY_NAME((const gchar *)classprop[0]));
if (!klass) {
__view_error(cur, "Class %s not registered", classprop[0]);
return;
}
MgdSchemaPropertyAttr *propleft =
g_hash_table_lookup(klass->dbpriv->storage_data->prophash, classprop[1]);
if (!propleft)
__view_error(cur, "Property %s not registered for %s", classprop[1], classprop[0]);
/* __get_property_attribute (cur, classprop, &property_name, &propleft, klass); */
g_strfreev(classprop);
/* Get right property attribute */
classprop = g_strsplit_set(right, ":.", -1);
if (!classprop || classprop[0] == NULL || classprop[1] == NULL) {
__view_error(cur, "Condition right problem", NULL);
return;
}
klass = MIDGARD_DBOBJECT_CLASS(MIDGARD_OBJECT_GET_CLASS_BY_NAME((const gchar *)classprop[0]));
if (!klass) {
__view_error(cur, "Class %s not registered", classprop[0]);
return;
}
MgdSchemaPropertyAttr *propright =
g_hash_table_lookup(klass->dbpriv->storage_data->prophash, classprop[1]);
if (!propright)
__view_error(cur, "Property %s not registered for %s", classprop[1], classprop[0]);
/* __get_property_attribute (cur, classprop, &property_name, &propright, klass); */
g_strfreev(classprop);
MidgardDBJoin *mdbj = midgard_core_dbjoin_new();
mdbj->type = g_utf8_strup((const gchar *)jointype, strlen((gchar *)jointype));
/* configure table, if there's class, get it's table, in other case, get table directly */
if (classname)
mdbj->table = g_strdup(midgard_core_class_get_table(joinklass));
else
mdbj->table = g_strdup((gchar *)table);
mdbj->left = propleft;
mdbj->right = propright;
g_free(left);
g_free(right);
type->joins = g_slist_append(type->joins, (gpointer) mdbj);
xmlFree(jointype);
xmlFree(classname);
if (table)
xmlFree(table);
}
}
}
void midgard_test_object_tree_create(MidgardObjectTest *mot, gconstpointer data)
{
g_assert(mot != NULL);
MidgardObject *_object = MIDGARD_OBJECT(mot->object);
MidgardConnection *mgd = MIDGARD_CONNECTION(midgard_object_get_connection(_object));
MidgardObjectClass *klass = MIDGARD_OBJECT_GET_CLASS(_object);
/* Get parent (in tree) class and check if parent has the same child declared */
const gchar *pname = midgard_schema_object_tree_get_parent_name(_object);
if(!pname)
return;
MidgardObjectClass *pklass = MIDGARD_OBJECT_GET_CLASS_BY_NAME(pname);
g_assert(pklass != NULL);
/* Check if class has unique property */
const gchar *unique_name = midgard_reflector_object_get_property_unique (G_OBJECT_CLASS_NAME (klass));
if (!unique_name)
return;
/* Check if class has 'name' property registered */
GParamSpec *unique_name_pspec = g_object_class_find_property(G_OBJECT_CLASS(klass), unique_name);
g_assert (unique_name_pspec != NULL);
/* Empty name */
MidgardObject *object = midgard_object_new(mgd, G_OBJECT_TYPE_NAME(_object), NULL);
g_object_set(object, unique_name, "", NULL);
/* Workaround */
const gchar *parent_property = midgard_reflector_object_get_property_parent (G_OBJECT_CLASS_NAME (klass));
if (parent_property)
g_object_set(object, parent_property, 1, NULL);
gboolean created = midgard_object_create(object);
MIDGARD_TEST_ERROR_OK(mgd);
g_assert(created != FALSE);
gboolean purged = midgard_object_purge(object, TRUE);
g_assert(purged != FALSE);
g_object_unref(object);
object = midgard_object_new(mgd, G_OBJECT_TYPE_NAME(_object), NULL);
g_object_set(object, "name", "", NULL);
/* Workaround */
parent_property = midgard_reflector_object_get_property_parent (G_OBJECT_CLASS_NAME (klass));
if (parent_property)
g_object_set(object, parent_property, 1, NULL);
created = midgard_object_create(object);
MIDGARD_TEST_ERROR_OK(mgd);
g_assert(created != FALSE);
purged = midgard_object_purge(object, TRUE);
g_assert(purged != FALSE);
g_object_unref(object);
/* Unique name */
object = midgard_object_new(mgd, G_OBJECT_TYPE_NAME(_object), NULL);
g_object_set(object, unique_name, "Unique", NULL);
/* Workaround */
parent_property = midgard_reflector_object_get_property_parent (G_OBJECT_CLASS_NAME (klass));
if (parent_property)
g_object_set(object, parent_property, 1, NULL);
created = midgard_object_create(object);
MIDGARD_TEST_ERROR_OK(mgd);
g_assert(created != FALSE);
MidgardObject *dupobject = midgard_object_new(mgd, G_OBJECT_TYPE_NAME(_object), NULL);
g_object_set(dupobject, unique_name, "Unique", NULL);
/* Workaround */
parent_property = midgard_reflector_object_get_property_parent (G_OBJECT_CLASS_NAME (klass));
if (parent_property)
g_object_set(dupobject, parent_property, 1, NULL);
gboolean dupcreated = midgard_object_create(dupobject);
MIDGARD_TEST_ERROR_ASSERT(mgd, MGD_ERR_DUPLICATE);
g_assert(dupcreated != TRUE);
g_object_unref(dupobject);
purged = midgard_object_purge(object, TRUE);
g_assert(purged != FALSE);
g_object_unref(object);
}
