src/types.c

/* 
Copyright (C) 2004,2005,2006 Piotr Pokora <piotr.pokora@infoglob.pl>
Copyright (C) 2004 Alexander Bokovoy <ab@samba.org>

This program is free software; you can redistribute it and/or modify it
under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#include <config.h>
#include <stdlib.h>
#include "midgard/midgard_type.h"
#include "midgard/midgard_object.h"
#include "midgard/midgard_metadata.h"
#include "midgard/query.h"
#include "midgard/midgard_legacy.h"
//#include "midgard/mgderr.h"
#include "midgard/query_builder.h"
#include "midgard/midgard_timestamp.h"
#include "midgard/midgard_datatypes.h"
#include "midgard/midgard_quota.h"
#include "schema.h"
#include "midgard_mysql.h"
#include "midgard/midgard_reflection_property.h"
#include "midgard/midgard_error.h"
#include "midgard_core_object.h"
#include "midgard_core_object_class.h"

GType _midgard_attachment_type = 0;

enum {
        MIDGARD_PROPERTY_NULL = 0,
        MIDGARD_PROPERTY_GUID,
        MIDGARD_PROPERTY_SITEGROUP,
        MIDGARD_PROPERTY_METADATA
};

typedef enum {
        OBJECT_UPDATE_NONE = 0,
        OBJECT_UPDATE_EXPORTED,
        OBJECT_UPDATE_IMPORTED
} _ObjectActionUpdate;

static GParamSpec **_midgard_object_class_paramspec()
{
        /* Hardcode MidgardRepligardClass parameters. Those will be inherited with MgdObject 
         * and thus do not bother about Midgard basic and core parameters later.
         * We also should hardcode these parameters to keep one real Midgard object
         * which has "one logic" properties and methods.
         */
  
        /* Last value is 'params[n]+1' */
        GParamSpec **params = g_malloc(sizeof(GParamSpec*)*5);
        params[0] = g_param_spec_string ("guid", "", "GUID",
                        " ", G_PARAM_READWRITE);
        params[1] = g_param_spec_uint ("sitegroup", "", 
                        "Sitegroup which object belongs to. Only for old objects",
                        0, G_MAXUINT32, 0, G_PARAM_READWRITE); 
        params[2] = g_param_spec_object ("metadata", "",
                        "Property with Midgard metadata object",
                        G_TYPE_OBJECT, G_PARAM_READWRITE);
        params[3] = g_param_spec_string ("action", "", "What was done with object",
                        " ", G_PARAM_READWRITE);    
        params[4] = NULL;
          
        return params;     
}

/* Initialize instance for all types that are not MidgardRepligardClass type. */
static void 
_object_instance_init(GTypeInstance *instance, gpointer g_class)
{
    GType own_type = G_TYPE_FROM_INSTANCE(instance);
    MgdSchemaTypeAttr *priv = G_TYPE_INSTANCE_GET_PRIVATE (instance, own_type, MgdSchemaTypeAttr);

    MgdObject *self = (MgdObject *) instance;

    self->private = g_new0(MidgardTypePrivate, 1);
    self->private->guid = NULL;
    self->private->sg = -1;
    self->private->action = NULL;
    self->private->exported = NULL;
    self->private->imported = NULL;
    
    /* Initialize metadata object */
    self->metadata = (MidgardMetadata *) g_object_new(MIDGARD_TYPE_METADATA, NULL);
    /* LEAK! */
    /* Piotras: I do not understand this, there is object_unref call for metadata
     * object in MgdObject finalize. I am completely blind here */ 
    
    self->private->parameters = NULL;   
    self->private->_params = NULL;
        
    priv->base_index = 1;
    
    guint propn;
    GParamSpec **props =
        g_object_class_list_properties(g_type_class_peek(own_type), &propn);
    g_free(props);
    
    priv->num_properties = propn;

    /* g_debug("New object instance for class '%s'", g_type_name(own_type)); */
  
    /* TODO 
     * Add functionality to get properties from self class instead of looking 
     * for cached type. We can not store GTypeInfo structure in MgdSchema as this require making 
     * schema real global value.
     */ 
 
    /* Allocate properties storage for this instance  */
    priv->properties = 
        priv->num_properties ? g_new0 (MgdSchemaPropertyAttr*, priv->num_properties) : NULL;
    if (priv->properties) {
        guint idx;
        for (idx = 0; idx < priv->num_properties; idx++) {
            priv->properties[idx] = g_new0 (MgdSchemaPropertyAttr, 1);
        }
    }
}
                
/* AB: This is shortcut macro for traversing through class hierarchy (from child to ancestor)
 * until we reach GObject. On each iteration we fetch private data storage for the object
 * according to the current class type and run supplied code.
 * This allows us to implement dynamic subclassing cast which is done usually via compiled 
 * time structure casts in appropriate class-specific hooks for each class in a hierarchy.
 * As our object classes have the same structure at each level of inheritance, we are able
 * to use the same triple of functions for get_property(), set_property(), and finalize()
 * for each class.
 */
#define G_MIDGARD_LOOP_HIERARCHY_START              \
  do {                      \
                          \
    priv = G_TYPE_INSTANCE_GET_PRIVATE (object, current_type, MgdSchemaTypeAttr);  \

#define G_MIDGARD_LOOP_HIERARCHY_STOP             \
  current_type = g_type_parent(current_type);           \
  } while (current_type != G_TYPE_OBJECT);



/* AB: Handle property assignments. Despite its simplicity, this is *very* important function */
static void
_object_set_property (GObject *object, guint prop_id, 
    const GValue *value, GParamSpec   *pspec)
{       
        gint prop_id_local = 0;
        MgdSchemaTypeAttr *priv;
        GType current_type = G_TYPE_FROM_INSTANCE(object);
        MgdObject *self = (MgdObject *) object;
        MgdSchemaPropertyAttr *prop;

        switch(prop_id) {
                        
                case MIDGARD_PROPERTY_GUID:
                        g_free ((gchar *)self->private->guid);
                        self->private->guid = g_value_dup_string (value);
                        break;
                
                case MIDGARD_PROPERTY_SITEGROUP:
                        self->private->sg = g_value_get_uint(value);
                        break;
                
                case MIDGARD_PROPERTY_METADATA:
                        self->metadata = g_value_get_object (value);
                        break;
                        
                default:
                        G_MIDGARD_LOOP_HIERARCHY_START
                                prop_id_local = prop_id - priv->base_index - 1;
                        if ((prop_id_local >= 0) && (prop_id_local < priv->num_properties)) {
                                if (priv->num_properties) {
                                        prop = priv->properties[prop_id_local];
                                        if (!G_IS_VALUE(&prop->value)) {
                                                g_value_init(&prop->value, G_VALUE_TYPE(value));
                                                /* g_debug(" Set property %s", pspec->name );  */
                                        }
                                        g_value_copy(value, &prop->value);
                                }
                                return;
                        }
                        G_MIDGARD_LOOP_HIERARCHY_STOP
        }
}

/* Get object's property */
static void
_object_get_property (GObject *object, guint prop_id,
                GValue *value, GParamSpec   *pspec)
{
        gint prop_id_local = 0;
        MgdSchemaTypeAttr *priv;
        GType current_type = G_TYPE_FROM_INSTANCE(object);
        MgdObject *self = (MgdObject *) object;

        switch(prop_id) {

                case MIDGARD_PROPERTY_GUID:
                        g_value_set_string (value, self->private->guid);
                        break;
                
                case MIDGARD_PROPERTY_SITEGROUP:
                        g_value_set_uint (value, (guint)self->private->sg);
                        break;
                
                case MIDGARD_PROPERTY_METADATA:
                        g_value_set_object(value,
                                        (MidgardMetadata *) self->metadata);
                        break;
                
                default:
                        G_MIDGARD_LOOP_HIERARCHY_START
                        prop_id_local = prop_id - priv->base_index - 1;
                        if ((prop_id_local >= 0) && (
                                                prop_id_local < priv->num_properties)) {
                                if (priv->num_properties) {
                                        if (priv->properties && G_IS_VALUE(
                                                                &priv->properties[prop_id_local]->value)) {
                                                g_value_copy(&priv->properties[prop_id_local]->value, 
                                                                value);
                                        }
                                }
                                return;
                        }
                        G_MIDGARD_LOOP_HIERARCHY_STOP
        }
}


/* 
 * Finalizer for GMidgardObject instance.
 * Cleans up all allocated data. As optimization, it handles all data
 * which belongs to its ancestors up to but not inluding GObject.
 * It is really makes no sense to call this function recursively
 * for each ancestor because we already know object's structure.
 * For GObject we call its finalizer directly.
 */

static void _object_finalize (GObject *object) 
{
        guint idx;
        MgdSchemaTypeAttr *priv;
        
        if(object == NULL)
                return;
        
        MgdObject *self = (MgdObject *)object;
        
        /* Free private struct members and MidgardTypePrivate */
        g_free((gchar *)self->private->guid); 
        g_free((gchar *)self->private->action);
        g_free(self->private->exported);
        g_free(self->private->imported);
        
        /* Free object's parameters */
        if(self->private->parameters != NULL) {
                
                GSList *_param = self->private->parameters;
                for (; _param; _param = _param->next) {
                        g_object_unref(_param->data);   
                }
                g_slist_free(_param);
        }

        if(self->private->_params != NULL)
                g_hash_table_destroy(self->private->_params);

        g_free(self->private);

        /* FIXME emmit signal?*/
        g_object_run_dispose(G_OBJECT(self->metadata));
        g_object_unref(self->metadata);
        
        GType current_type = G_TYPE_FROM_INSTANCE(object); 
        
        G_MIDGARD_LOOP_HIERARCHY_START
                for (idx = 0; idx < priv->num_properties; idx++) {
                        if (priv->properties[idx]) {
                                if (G_IS_VALUE(&priv->properties[idx]->value)) {
                                        g_value_unset(&priv->properties[idx]->value);
                                }
                                g_free (priv->properties[idx]);
                                priv->properties[idx] = NULL;
                        }
                }
        if (priv->properties) {
                g_free (priv->properties);
                priv->properties = NULL;
        }
        G_MIDGARD_LOOP_HIERARCHY_STOP
                
        /* Call parent's finalizer if it is there */
        {
                GObjectClass *parent_class = g_type_class_ref (current_type);           
                if (parent_class->finalize) {
                        parent_class->finalize (object);
                }
                g_type_class_unref (parent_class);
        }
}

static GHashTable *_build_create_or_update_query(MgdObject *object)
{
        GParamSpec **props;
        guint propn, i;
        GValue pval = {0,};
        GHashTable *sqls = midgard_hash_strings_new();
        gchar **table, *sqlset = "", *sqlsetf = "";
        const gchar *nick, *strval;
        GString *tmpsql;
        MidgardObjectClass *klass = MIDGARD_OBJECT_GET_CLASS(object);
        const gchar *primary_property = midgard_object_class_get_primary_property(klass);

        if(( props = g_object_class_list_properties(
                                        G_OBJECT_GET_CLASS(G_OBJECT(object)), &propn)) == NULL)
                return NULL;

        g_hash_table_insert(sqls, g_strdup(
                                midgard_object_class_get_table(
                                        MIDGARD_OBJECT_GET_CLASS(object))), g_strdup(sqlset));
        
        for (i = 0; i < propn; i++) {
                
                nick =  g_param_spec_get_nick (props[i]);
                
                if ((strlen(nick)) > 0) {
                        
                        table = g_strsplit_set(nick, ".", 0);
                        g_value_init(&pval,props[i]->value_type);
                        g_object_get_property(G_OBJECT(object), (gchar*)props[i]->name, &pval);

                        if ((sqlsetf = g_hash_table_lookup(sqls, table[0])) == NULL) {
                                sqlset = g_strdup("");        
                                g_hash_table_insert(sqls, g_strdup(table[0]), sqlset);
                        }

                        tmpsql = g_string_new(sqlsetf); 
                        
                        switch (props[i]->value_type) {
                                
                                case MGD_TYPE_STRING:
                                        strval = g_value_get_string(&pval);
                                        if(strval == NULL)
                                                strval = "";
                                        guint length = strlen(strval);
                                        gchar *escaped = g_new(gchar, 2 * length + 1);
                                        mysql_real_escape_string(
                                                        object->mgd->msql->mysql, 
                                                        escaped, strval, length);
                                        g_string_append_printf(tmpsql,
                                                        "%s='%s', ",
                                                        table[1],
                                                        escaped);
                                        g_free(escaped);
                                        break;

                                        
                                case MGD_TYPE_UINT:
                                        /* Avoid using primary field with integer type */
                                        if(!g_str_equal(props[i]->name, primary_property)) {
                                                g_string_append_printf(tmpsql,
                                                                "%s=%d, ",
                                                                table[1],
                                                                g_value_get_uint(&pval));
                                        }
                                        break;
                                        
                                case MGD_TYPE_INT:
                                        if(!g_str_equal(props[i]->name, primary_property)) {
                                                g_string_append_printf(tmpsql,
                                                                "%s=%d, ",
                                                                table[1],
                                                                g_value_get_int(&pval));
                                        }
                                        break;                                  
                                
                                case MGD_TYPE_FLOAT:
                                        g_string_append_printf(tmpsql,
                                                        "%s=%f, ",
                                                        table[1], 
                                                        g_value_get_float(&pval));
                                        break;
                                
                                case MGD_TYPE_BOOLEAN:
                                        g_string_append_printf(tmpsql,
                                                        "%s=%d, ",
                                                        table[1],
                                                        g_value_get_boolean(&pval));
                                        break;                                          
                        }

                        g_hash_table_insert(sqls, g_strdup(table[0]), g_string_free(tmpsql, FALSE));
                        g_value_unset(&pval);  
                        g_strfreev(table);
                }
        }
        
        g_free(props);
        return sqls;    
}

void _insert_records(gpointer key, gpointer value, gpointer userdata)
{
        gchar *table = (gchar *) key;
        gchar *sql = (gchar *) value;
        MgdSchemaTypeQuery *query;
        gint qr, rid;
        guint object_sitegroup;
        MgdObject *object = (MgdObject *) userdata;
        /* Get object's sitegroup value. It is set by SG0 admin or from 
         * midgard connection handler */
        g_object_get(G_OBJECT(object), "sitegroup", &object_sitegroup, NULL);
        MidgardObjectClass *klass = MIDGARD_OBJECT_GET_CLASS(object);

        if(!g_str_equal(midgard_object_class_get_table(klass), table)){
                query = g_hash_table_lookup(klass->data->tables, table);
                if (query->use_lang) {
                        //langsql = mgd_format(cmo->mobj->mgd, pool,
                        //    ", lang=$d ", cmo->mobj->mgd->lang );
                        //sqlf = g_strconcat(sql, langsql, NULL);
                }

                GString *fquery = g_string_new("INSERT INTO ");
                g_string_append_printf(fquery,
                                "%s SET %s sitegroup=%d",
                                table, 
                                sql,
                                object_sitegroup);
                gchar *tmpstr = g_string_free(fquery, FALSE);
                
                qr = mysql_query(object->mgd->msql->mysql, tmpstr);
                g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "query=%s", tmpstr);
                
                if (qr != 0) {
                        g_warning("query failed: %s \n %s", 
                                        tmpstr, 
                                        mysql_error(object->mgd->msql->mysql));
                } else {
                        /* Keep backward compatibility ( repligard's table )*/
                        /* No need to define typename here. It's only type's
                         * "external" data */
                        if ((query->use_lang == 1) && (qr == 0)) {
                                rid = mysql_insert_id(object->mgd->msql->mysql);
                                gchar *guid = midgard_guid_new(object->mgd);
                                fquery =  g_string_new("INSERT INTO repligard ");
                                g_string_append_printf(fquery,
                                                "(realm,guid,id,changed,action,sitegroup)"
                                                " VALUES ('%s', '%s', %d , NULL, 'create', %d)", 
                                                table, guid, rid, object_sitegroup);
                                gchar *rtmpstr = g_string_free(fquery, FALSE);
                                g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "query=%s", rtmpstr);
                                qr = mysql_query(object->mgd->msql->mysql, rtmpstr);
                                if (qr != 0) 
                                        g_warning("query failed: %s \n %s",
                                                        rtmpstr,
                                                        mysql_error(object->mgd->msql->mysql));
                                g_free(guid);
                                g_free(rtmpstr);
                        }
                }               
                g_free(tmpstr);
        }
}

void _update_records(gpointer key, gpointer value, gpointer userdata)
{
        gchar *table = (gchar *) key;
        gchar *sql = (gchar *) value, *tmpstr = NULL;
        const gchar *otable;
        MgdSchemaTypeQuery *query;
        gint qr, doins = 0;
        gpointer rid;
        GString *where;
        MgdObject *object = (MgdObject *) userdata;
        guint object_sitegroup, id;

        g_object_get(G_OBJECT(object), "sitegroup", 
                        &object_sitegroup, NULL);       
        g_object_get(G_OBJECT(object), "id",
                        &id, NULL);
        
        otable = midgard_object_class_get_table(
                        MIDGARD_OBJECT_GET_CLASS(object));
        
        if(!g_str_equal(otable, table)){
                        
                query = g_hash_table_lookup(object->data->tables, table); 
                if(!query)
                        return;
                
                if (query->use_lang) {
                        where = g_string_new(" sid=");
                        g_string_append_printf(where,
                                        "%d AND lang=%d",
                                        id, mgd_lang(object->mgd));
                        tmpstr = g_string_free(where, FALSE);
                        rid =  midgard_query_field_get(object->mgd,
                                        "id", 
                                        table, 
                                        (const gchar*)tmpstr);
                        g_free(tmpstr);
                        
                        if(rid != NULL) {
                                id = (guint) atoi(rid);
                                where = g_string_new("UPDATE ");
                                g_string_append_printf(where, 
                                                "%s SET %s sitegroup=%d "
                                                "WHERE id=%d AND sitegroup=%d",
                                                table, sql, object_sitegroup,
                                                id, object_sitegroup);
                        } else {
                                where = g_string_new("INSERT INTO ");
                                g_string_append_printf(where, 
                                                "%s SET %s sitegroup=%d",
                                                table, sql,
                                                object_sitegroup);
                                doins = 1;
                        }
                } else {
                        /* TODO Add "join" fields */
                        where = g_string_new("UPDATE ");
                        g_string_append_printf(where,
                                        "%s SET %s, sitegroup=%d",
                                        table, sql, object_sitegroup);
                }

                tmpstr = g_string_free(where, FALSE);
                qr = mysql_query(object->mgd->msql->mysql, tmpstr);
                                                
                if (query->use_lang && qr == 1 && doins == 1) {
                        rid =  midgard_query_field_get(object->mgd,
                                        "id",
                                        table,
                                        tmpstr);
                        if(rid != NULL) 
                                id = (guint) atoi(rid);
                }
                g_free(tmpstr);
                if (qr) {
                        /* Keep backward compatibility ( repligard's table )*/
                        if (query->use_lang == 1)
                                UPDATE_REPLIGARD(object->mgd, table, id);  
                }
        }                                                                                       
}

/* TODO, replace execute with distinct if needed */  
gboolean _object_in_tree(MgdObject *object)
{
        guint n_objects = 0;
        GParamSpec *name_prop, *up_prop, *primary;
        GValue pval = {0,}, fval = {0,};

        MidgardObjectClass *klass = MIDGARD_OBJECT_GET_CLASS(object);
        const gchar *primary_prop = midgard_object_class_get_primary_property(klass);
        const gchar *upname = midgard_object_class_get_parent_property(klass);
        if(upname == NULL)
                upname = midgard_object_class_get_up_property(klass);

        if(upname == NULL)
                return FALSE;
        
        up_prop = g_object_class_find_property(
                        G_OBJECT_GET_CLASS(G_OBJECT(object)), upname);
        name_prop = g_object_class_find_property(
                        G_OBJECT_GET_CLASS(G_OBJECT(object)), "name");

        if((name_prop == NULL) || (up_prop == NULL))
                return FALSE;
        
        MidgardQueryBuilder *builder =
                midgard_query_builder_new(object->mgd,
                                G_OBJECT_TYPE_NAME(object));
        /* Add up or parent constraint */
        g_value_init(&pval,up_prop->value_type);
        g_object_get_property(G_OBJECT(object), upname, &pval);
        midgard_query_builder_add_constraint(builder,
                        upname,
                        "=", &pval);
        g_value_unset(&pval);
                        
        /* Add name property constraint */
        g_value_init(&pval,name_prop->value_type);
        g_object_get_property(G_OBJECT(object), "name", &pval);
        /* Check empty name, not null */
        const gchar *tmpstr = g_value_get_string(&pval);
        if(!tmpstr)
                tmpstr = "";
        if(g_str_equal(tmpstr, "")){
                g_object_unref(builder);
                g_value_unset(&pval);
                return FALSE;
        }
        midgard_query_builder_add_constraint(builder,
                        "name",
                        "=", &pval);
        g_value_unset(&pval);
                                 
        GObject **ret_object = 
                midgard_query_builder_execute(
                                builder, &n_objects);

        /* Name is not duplicated, return */
        if(n_objects < 1){
                g_object_unref(G_OBJECT(builder));
                return FALSE;
        }
                        
        /* we must compare primary properties and its values.
         * if eqaul , we may update object , if not we return false */
        primary = g_object_class_find_property(
                        G_OBJECT_GET_CLASS(G_OBJECT(ret_object[0])), primary_prop);
        
        gboolean duplicate = TRUE;
        g_value_init(&fval, primary->value_type);
        g_object_get_property(G_OBJECT(ret_object[0]), primary_prop, &fval);
        
        g_value_init(&pval, primary->value_type);
        g_object_get_property(G_OBJECT(object), primary_prop, &pval);
                
        switch(primary->value_type){

                case G_TYPE_UINT:
                        if(g_value_get_uint(&fval) == g_value_get_uint(&pval))
                                duplicate = FALSE;
                        break;

                case G_TYPE_STRING:
                        if(g_str_equal(g_value_get_string(&fval),
                                                g_value_get_string(&pval)))
                                duplicate = FALSE;
                        break;                                  
        }

        g_object_unref(ret_object[0]);
        g_object_unref(builder);
                
        if(duplicate)
                return TRUE;
        
        /* PP:I am not sure if we really need this for every object. 
         * Static path for dynamic applications is needless.
         * However path should be build or used for applications 
         * which do not change paths for libraries snippets code
         * */
        /* (void *) midgard_object_build_path(mobj); */
  
        return FALSE;
}

gboolean _midgard_object_update(MgdObject *gobj, 
                _ObjectActionUpdate replicate)
{
        g_assert(gobj != NULL);
        g_assert(gobj->mgd != NULL);
        
        gchar *sqlsetf = "", *fquery = "";
        guint  qr, oid, id = 0;
        GHashTable *sqls;
        const gchar *table;
        guint object_sitegroup , current_sitegroup;

        if(!_midgard_core_object_is_valid(gobj))
                return FALSE;

        MIDGARD_ERRNO_SET(gobj->mgd, MGD_ERR_OK);

        /* Disable person check */
        /*
        if(gobj->mgd->person == NULL) {
                MIDGARD_ERRNO_SET(gobj->mgd, MGD_ERR_ACCESS_DENIED);
                return FALSE;
        }
        */
        
        if (gobj->data == NULL) {
                MIDGARD_ERRNO_SET(gobj->mgd, MGD_ERR_INTERNAL);
                return FALSE;
        }
        table = midgard_object_class_get_table(MIDGARD_OBJECT_GET_CLASS(gobj));
    
        if(table  == NULL) {
                /* Object has no storage defined. Return FALSE as there is nothing to update */
                g_warning("Object '%s' has no table defined!", gobj->cname);
                MIDGARD_ERRNO_SET(gobj->mgd, MGD_ERR_INTERNAL);
                return FALSE;
        }

        current_sitegroup = mgd_sitegroup(gobj->mgd);
        g_object_get(G_OBJECT(gobj), "sitegroup", &object_sitegroup, NULL);

        /* FIXME: this can not be checked like this. It can be checked 
         * SG borders are "crossed" only if bindings objects are 1:1 with core's 
         * ones. */
        /*if((mgd_isroot(gobj->mgd)) && (object_sitegroup > 0)){
                g_critical("Sitegroup violation! Can not redefine object's sitegroup");
                MIDGARD_ERRNO_SET(gobj->mgd, MGD_ERR_SITEGROUP_VIOLATION);
                return FALSE;
        }       
        */
        /* Just in case. This should be done in _object_set_property, 
         * but we do not provide objects' 1:1 mapping for midgard-php4.
         * SG0 Midgard Administrator is still able to change sitegroup */
        if((current_sitegroup > 0) && (object_sitegroup > 0) &&
                        (current_sitegroup != object_sitegroup))
                g_object_set(G_OBJECT(gobj), "sitegroup", 
                                mgd_sitegroup(gobj->mgd) , NULL);

        /* Check duplicates and parent field */
        if(_object_in_tree(gobj)) {             
                MIDGARD_ERRNO_SET(gobj->mgd, MGD_ERR_DUPLICATE);
                return FALSE;
        }
        /* we need id to set multilanged object's sid property 
         * * * and for repligard table */
        g_object_get((GObject *) gobj, "id", &oid , NULL);
        
        /* Set sid and lang property */    
        if (gobj->data->use_lang) {
                g_object_set((GObject *) gobj, "sid", oid , NULL);
                g_object_set((GObject *) gobj, "lang", mgd_lang(gobj->mgd), NULL);
        }
        
        sqls = _build_create_or_update_query(gobj);
        sqlsetf = g_hash_table_lookup(sqls, gobj->data->table);

        GString *sql = g_string_new("UPDATE ");
        g_string_append_printf(sql, 
                        "%s SET %s ",
                        table, sqlsetf);
        
        /* METADATA START */
        gchar *person_guid ;
        MgdObject *person = (MgdObject *)gobj->mgd->person;                     
        if(person){
                if(G_IS_OBJECT(G_OBJECT(person)))
                        g_object_get(G_OBJECT(person), "guid", &person_guid, NULL);
        }else {
                /* g_info("Anonymous mode"); */
                person_guid = g_strdup("");
        }
                
        GValue tval = {0, };
        g_value_init(&tval, midgard_timestamp_get_type());
        midgard_timestamp_set_time(&tval, time(NULL));
        gchar *timeupdated = midgard_timestamp_dup_string(&tval);

        /* If object is imported it's revised time should be 
         * untouched as property value is copied from imported 
         * object */
        gchar *revised_time;
        gint revision_count = gobj->metadata->private->revision;
        
        if(replicate == OBJECT_UPDATE_IMPORTED){
                revised_time = gobj->metadata->private->revised;
        } else {
                revised_time = timeupdated;
                revision_count++;
        }
        
        switch(replicate){

                case OBJECT_UPDATE_NONE:
                        
                        /* FIXME , revision property is set in hope it will be ok 
                         * I see no other way to set correct revision number without additional 
                         * SELECT made only to get real revision value */
                        /* TODO , move it to private structure when php4 module binding
                         * will use 1:1 objects mapping */
                        g_string_append_printf(sql,
                                        "metadata_revisor='%s', metadata_revised='%s',"
                                        "metadata_revision=%d ",
                                        person_guid, revised_time, revision_count);
                        
                        gchar *metasql = midgard_metadata_get_sql(gobj->metadata);
                        g_string_append_printf(sql, " %s ", metasql);
                        g_free(metasql);
                        
                        g_object_set(G_OBJECT(gobj->metadata),
                                        "revisor", person_guid,
                                        "revised", timeupdated,
                                        "revision", revision_count,
                                        NULL);
                        
                        g_free(person_guid);
                        g_free(timeupdated);
                        break;
                
                case OBJECT_UPDATE_EXPORTED:
                        g_string_append_printf(sql,
                                        "metadata_exported='%s'",
                                        timeupdated);
                        g_free(gobj->private->exported);
                        gobj->private->exported = g_strdup(timeupdated);
                        g_object_set(G_OBJECT(gobj->metadata),
                                        "exported", timeupdated, 
                                        NULL);
                        break;

                case OBJECT_UPDATE_IMPORTED:
                        g_string_append_printf(sql,
                                        "metadata_imported='%s'"
                                        ",metadata_exported='%s'"
                                        ",metadata_revisor='%s' "
                                        ",metadata_revised='%s' "
                                        ",metadata_revision=%d  "
                                        ",metadata_creator='%s' ",
                                        timeupdated, 
                                        gobj->metadata->private->exported,
                                        gobj->metadata->private->revisor,
                                        revised_time,
                                        revision_count,
                                        gobj->metadata->private->creator);
                        
                        g_free(gobj->private->imported);
                        gobj->private->imported = g_strdup(timeupdated);
                        /*g_object_set(G_OBJECT(gobj->metadata),
                                        "exported", exported_time,
                                        "imported", timeupdated,
                                        NULL);
                        */              
                        break;
        }

        /* METADATA END */

        /* get object's primary property to create WHERE part */
        GValue pval = {0, };
        const gchar *pprop = midgard_object_class_get_primary_property(
                        MIDGARD_OBJECT_GET_CLASS(gobj));
        
        GParamSpec *propval =  g_object_class_find_property(
                        G_OBJECT_GET_CLASS(G_OBJECT(gobj)), pprop);
        
        g_value_init(&pval, propval->value_type);
        switch(propval->value_type){
                
                case G_TYPE_STRING:
                        /* id need for repligard anyway */
                        g_object_get(G_OBJECT(gobj), "id", &id, NULL);
                        if(gobj->private->guid == NULL)
                                g_critical("Object's guid is NULL. Can not update");
                        g_string_append_printf(sql,
                                        " WHERE %s = '%s'", pprop, gobj->private->guid);
                        break;
                
                case G_TYPE_UINT:
                        g_object_get_property(G_OBJECT(gobj), pprop, &pval);
                        g_string_append_printf(sql,
                                        " WHERE %s = %d", pprop, g_value_get_uint(&pval));
                        id = g_value_get_uint(&pval);
                        if(id == 0)
                                g_warning("Object's ID is 0. Can not update");
                        break;
        }
        g_value_unset(&pval);

        /* Add sitegroup, if user is non root */ 
        if(!mgd_isroot(gobj->mgd)){
                g_string_append_printf(sql,
                                " AND %s.sitegroup = %d",
                                table,
                                object_sitegroup);
        }                                         
        
        guint object_size;
        g_object_get(G_OBJECT(gobj->metadata), "size", &object_size, NULL);
        fquery = g_string_free(sql, FALSE);
        if(midgard_quota_size_is_reached(gobj, object_size)){
                MIDGARD_ERRNO_SET(gobj->mgd, MGD_ERR_QUOTA);
                g_free(fquery);
                return FALSE;
        }
    
        /* Execute update query */
        g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "query=%s", fquery);
        qr = mysql_query(gobj->mgd->msql->mysql, fquery);
        g_free(fquery);
        
        if (qr != 0) {
                g_warning("query failed: %s", 
                                mysql_error(gobj->mgd->msql->mysql));
                MIDGARD_ERRNO_SET(gobj->mgd, MGD_ERR_INTERNAL);
                return FALSE;
        } else {
                midgard_quota_update(gobj);   
                /* Update repligard's table 
                 * I need to use id in repligard table, do not update repligard table
                 * when object has no integer primary property */
                
                if(id > 0){             
                        sql = g_string_new("UPDATE repligard SET changed=NULL,action='update',");
                        g_string_append_printf(sql,
                                        "typename='%s' WHERE guid='%s' AND realm='%s'",
                                        G_OBJECT_TYPE_NAME(gobj),
                                        gobj->private->guid,
                                        table);
                        fquery = g_string_free(sql, FALSE);
                        g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "query=%s", fquery);
                        mysql_query(gobj->mgd->msql->mysql, fquery);
                        g_free(fquery);
                        /* Should I worry about error in repligard table here? */
                }
        }

        /* sqls = _build_create_or_update_query(gobj); */
        g_hash_table_foreach(sqls, _update_records, gobj);
        g_hash_table_destroy(sqls);   
        MIDGARD_ERRNO_SET(gobj->mgd, MGD_ERR_OK);
        
        return TRUE;
}

gboolean midgard_object_update(MgdObject *self)
{
        return _midgard_object_update(self, OBJECT_UPDATE_NONE);
}


/* Create object's data in storage */
gboolean _midgard_object_create(MgdObject *object, const gchar *create_guid)
{
        gchar *sqlsetf = "", *fquery;
        guint  qr, rid, object_sitegroup;
        GHashTable *sqls;
        GString *query;
        const gchar *table;
        
        if (object->data == NULL)
                return FALSE;

        if(!_midgard_core_object_is_valid(object))
                return FALSE;
        MIDGARD_ERRNO_SET(object->mgd, MGD_ERR_OK);     

        /* Disable person check */
        /*
        if(object->mgd->person == NULL) {
                MIDGARD_ERRNO_SET(object->mgd, MGD_ERR_ACCESS_DENIED);
                return FALSE;
        }
        */
        
        if((table = midgard_object_class_get_table(MIDGARD_OBJECT_GET_CLASS(object))) == NULL) {
                /* Object has no storage defined. Return FALSE as there is nothing to create */
                g_warning("Object '%s' has no table or storage defined!",
                                object->cname);    
                MIDGARD_ERRNO_SET(object->mgd, MGD_ERR_NOT_EXISTS);    
                return FALSE;  
        }
        
        /* Set object's sitegroup */
        if(!mgd_isroot(object->mgd)) {
                g_object_set(G_OBJECT(object), "sitegroup",
                                midgard_sitegroup_get_id(object->mgd) , NULL);
        } 
        /* Get object_sitegroup, this value will change depending on 
         * who is currently logged in */
        g_object_get(G_OBJECT(object), "sitegroup", &object_sitegroup, NULL);
        
        /* If Object has upfield set , check if property which points to up is set and has some value. 
         * In other case, create Object and do INSERT, 
         * as object is not "treeable" and may be created without 
         * any parent object(typical for parameters or attachments).
         */ 
        if(_object_in_tree(object)) {
                MIDGARD_ERRNO_SET(object->mgd, MGD_ERR_DUPLICATE);
                return FALSE;
        }

        /* Create object's guid */
        gchar *guid;
        if(create_guid == NULL)
                guid = midgard_guid_new(object->mgd);
        else
                guid = g_strdup(create_guid);

        g_object_set(G_OBJECT(object), "guid", guid , NULL);
        
        sqls = _build_create_or_update_query(object);
        sqlsetf = g_hash_table_lookup(sqls, object->data->table);

        /* Create object record in its table */
        query = g_string_new("INSERT INTO ");
        g_string_append_printf(query,
                        "%s SET %s guid='%s',",
                        table, sqlsetf, guid);
        
        /* Set sitegroup from current sitegroup only when logged in person is not SG0 admin */
        if(!mgd_isroot(object->mgd))
                object_sitegroup = midgard_sitegroup_get_id(object->mgd);
        
        g_string_append_printf(query,
                        "sitegroup=%d,", object_sitegroup);
        
        g_hash_table_destroy(sqls); 
        
        /* Set metadata */
        /*g_signal_emit_by_name(object->metadata,
         * "set_created", NULL); */
        gchar *person_guid ;
        MgdObject *person = (MgdObject *)object->mgd->person;
        if(person){
                if(G_IS_OBJECT(G_OBJECT(person)))
                        g_object_get(G_OBJECT(person), "guid", &person_guid, NULL);
        } else {
                /* g_info("Anonymous mode"); */
                person_guid = g_strdup("");
        }
        
        /* Set metadata fields creator and created values*/
        GValue tval = {0, };    
        time_t utctime = time(NULL);
        g_value_init(&tval, MIDGARD_TYPE_TIMESTAMP);    
        midgard_timestamp_set_time(&tval, utctime);
        gchar *timecreated = midgard_timestamp_dup_string(&tval);
        g_value_unset(&tval);   
        guint object_size;
        g_object_get(G_OBJECT(object->metadata), "size", &object_size, NULL);
        g_string_append_printf(query,   
                        "metadata_creator='%s', metadata_created='%s', "
                        "metadata_revised='%s', metadata_revision=0, "
                        "metadata_revisor='%s', metadata_size=%d ",      
                        person_guid, timecreated,
                        timecreated, person_guid,
                        object_size);
        
        /* Set metadata properties */
        g_object_set(G_OBJECT(object->metadata), 
                        "creator", person_guid, 
                        "created", timecreated,                 
                        "revised", timecreated,
                        "revision", 0,
                        "revisor", person_guid,
                        "published", timecreated,
                        NULL);    
        
        gchar *metasql = midgard_metadata_get_sql(object->metadata); 
        g_string_append_printf(query, " %s ", metasql);
        
        g_free(metasql);
        g_free(timecreated);
        g_free(person_guid);
        /* metadata end */
        
        fquery = g_string_free(query, FALSE);
        
        if(!midgard_quota_create(object)){
                g_free(fquery);
                return FALSE;
        }
        g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "query=%s", fquery);
        
        qr = mysql_query(object->mgd->msql->mysql, fquery);
        g_free(fquery);
        
        if (qr != 0) {
                g_warning("\n\n QUERY FAILED: %s \n\n", mysql_error(object->mgd->msql->mysql));
                g_free(guid);
                g_object_set(G_OBJECT(object), "guid", "" , NULL);
                MIDGARD_ERRNO_SET(object->mgd, MGD_ERR_NOT_EXISTS);
                return FALSE;
        } else {
                /* Create repligard and other tables entries */
                if ((rid = mysql_insert_id(object->mgd->msql->mysql))){
                        g_object_set(G_OBJECT(object), "id", rid, NULL); /* FIXME */            
                        midgard_quota_update(object);           
                        query = g_string_new("INSERT INTO repligard SET ");
                        g_string_append_printf(query, 
                                        "realm='%s', guid='%s', changed=NULL, "
                                        "action='create', typename='%s', id=%d, "
                                        " sitegroup=%d, object_action = %d ",
                                        table, guid, object->cname, rid, 
                                        object_sitegroup,
                                        MGD_OBJECT_ACTION_NONE);
                        
                        g_free(guid);           
                        fquery = g_string_free(query, FALSE);
                        g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "query=%s", fquery);
                        qr = mysql_query(object->mgd->msql->mysql, fquery);
                        g_free(fquery);
                        
                        if (qr != 0) {
                                g_warning("query failed: %s", mysql_error(object->mgd->msql->mysql));
                                MIDGARD_ERRNO_SET(object->mgd, MGD_ERR_INTERNAL);                
                        }
                        
                        /* Set sid property to newly created object's id if object has such property */
                        if (g_object_class_find_property(
                                                G_OBJECT_GET_CLASS(G_OBJECT(object)), "sid") != NULL) 
                                g_object_set(G_OBJECT(object), "sid", rid, NULL);
                        /* Set lang property */
                        if (g_object_class_find_property(
                                                G_OBJECT_GET_CLASS(G_OBJECT(object)), "lang") != NULL)
                                g_object_set(G_OBJECT(object), 
                                                "lang", midgard_lang_get(object->mgd), NULL);
                        
                        sqls = _build_create_or_update_query(object);
                        g_hash_table_foreach(sqls, _insert_records, object);
                        
                        g_hash_table_destroy(sqls);             
                        g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG,"Object %s created with id=%d", 
                                        object->cname, rid);
                        return TRUE;
                }
        }
        MIDGARD_ERRNO_SET(object->mgd, MGD_ERR_INTERNAL);
        return FALSE;   
}

gboolean midgard_object_create(MgdObject *object)
{
        return _midgard_object_create(object, NULL);
}



void _object_copy_properties(GObject *src, GObject *dest)
{
        g_assert(src != NULL && dest != NULL);

        guint nprop, i;
        GValue pval = {0, };
        GValue doval = {0, };
        GParamSpec **props = g_object_class_list_properties(
                        G_OBJECT_GET_CLASS(src),
                        &nprop);
        
        for(i = 0; i <+ nprop; i++){            
                
                g_value_init(&pval, props[i]->value_type);      

                if(props[i]->value_type == G_TYPE_OBJECT){                      
                
                        g_object_get_property(src,
                                        props[i]->name,
                                        &pval);
                        
                        g_value_init(&doval, props[i]->value_type);
                        g_object_get_property(dest,
                                        props[i]->name,
                                        &doval);

                        _object_copy_properties(
                                        G_OBJECT(g_value_get_object(&pval)),
                                        G_OBJECT(g_value_get_object(&doval))
                                        );
                        g_value_unset(&doval);

                } else {

                        g_object_get_property(G_OBJECT(src),
                                        props[i]->name,
                                        &pval);
                        g_object_set_property(G_OBJECT(dest),
                                        props[i]->name,
                                        &pval);
                }

                g_value_unset(&pval);
        }

        g_free(props);
}


/* Get object by its id property, id must be uint type */
gboolean  midgard_object_get_by_id(MgdObject *object)
{
        g_assert(object != NULL);
        g_assert(object->mgd != NULL);

        /* Reset errno */
        MIDGARD_ERRNO_SET(object->mgd, MGD_ERR_OK);
        
        guint n_objects = 0;
        GParamSpec *prop;
        MidgardObjectClass *klass = MIDGARD_OBJECT_GET_CLASS(object);
        
        /* Find "primary" property , just in case of fatal error */
        prop = g_object_class_find_property(
                        (GObjectClass*)klass,
                        "id");
        if(prop == NULL){
                MIDGARD_ERRNO_SET(object->mgd, MGD_ERR_INTERNAL);
                g_warning("Primary property id not found for object's klass '%s'",
                                G_OBJECT_TYPE_NAME(object));
                return FALSE;
        }

        /* Stop when property is not uint type */
        g_assert((prop->value_type == G_TYPE_UINT));
        
        /* Initialize QB */
        MidgardQueryBuilder *builder =
                midgard_query_builder_new(object->mgd, 
                                G_OBJECT_TYPE_NAME(object));
        
        if(!builder) {
                MIDGARD_ERRNO_SET(object->mgd, MGD_ERR_INTERNAL);
                g_warning("Invalid query builder configuration (%s)",
                                G_OBJECT_TYPE_NAME(object));
                return FALSE;
        }

        /* Get primary's property value */
        GValue pval = {0,};
        g_value_init(&pval,prop->value_type);   
        g_object_get_property(G_OBJECT(object), "id", &pval);
        if (midgard_query_builder_add_constraint(builder,
                                "id",
                                "=", &pval)) {
                
                GObject **ret_object = midgard_query_builder_execute(
                                builder, &n_objects);

                g_value_unset(&pval);   
                g_object_unref(G_OBJECT(builder));
                                
                if(n_objects < 1) {
                        MIDGARD_ERRNO_SET(object->mgd, MGD_ERR_NOT_EXISTS);
                        return FALSE;
                }
        
                _object_copy_properties(ret_object[0],
                                G_OBJECT(object));

                g_object_unref(ret_object[0]);
                g_free(ret_object);

                MIDGARD_ERRNO_SET(object->mgd, MGD_ERR_OK);
                return TRUE;
        }
        return FALSE;
}

GObject **midgard_object_find(MgdObject *object, guint *n_objects)
{
        GParamSpec **props;
        guint propn, i;
        GValue pval = {0,};
        
        MIDGARD_ERRNO_SET(object->mgd, MGD_ERR_OK);

        props = g_object_class_list_properties(
                        G_OBJECT_CLASS(MIDGARD_OBJECT_GET_CLASS(object)), &propn);
        if(!props){
                g_warning("No properties found for %s class!",
                                object->cname);
                MIDGARD_ERRNO_SET(object->mgd, MGD_ERR_INTERNAL);
                return NULL;
        }
        
        MidgardQueryBuilder *builder =
                        midgard_query_builder_new(object->mgd, object->cname);
        if(!builder){
                MIDGARD_ERRNO_SET(object->mgd, MGD_ERR_INTERNAL);
                return NULL;
        }

        for(i = 0; i < propn; i++) {
                g_value_init(&pval,props[i]->value_type);
                g_object_get_property(G_OBJECT(object),                                                                             props[i]->name, &pval);
                switch (props[i]->value_type) {
                        
                        case G_TYPE_STRING:
                                if(g_value_get_string(&pval))
                                        midgard_query_builder_add_constraint(builder,
                                                        props[i]->name, "=", &pval);
                                break;

                        case G_TYPE_UINT:
                                if(g_value_get_uint(&pval))
                                        midgard_query_builder_add_constraint(builder,
                                                        props[i]->name, "=", &pval);
                                break;
                        
                        case G_TYPE_INT:
                                if(g_value_get_int(&pval))
                                        midgard_query_builder_add_constraint(builder,
                                                        props[i]->name, "=", &pval);
                                break;

                        case G_TYPE_FLOAT:
                                if(g_value_get_float(&pval))
                                        midgard_query_builder_add