src/midgard_error.c

/* 
 * Copyright (C) 2006 Piotr Pokora <piotr.pokora@infoglob.pl>
 *
 * 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 <midgard/midgard_error.h>
#include <midgard/midgard_legacy.h>

GQuark midgard_error_generic(void)
{
        static GQuark q = 0;
        if (q == 0)
                q = g_quark_from_static_string ("midgard-generic-error-quark");
        return q;
}

const gchar *midgard_error_string(GQuark domain, gint errcode)
{
        switch(errcode){

                case MGD_ERR_OK:
                        return _("MGD_ERR_OK");
                        break;

                case MGD_ERR_ACCESS_DENIED:
                        return _("Access Denied");
                        break;
                
                case MGD_ERR_SITEGROUP_VIOLATION:
                        return _("Resource link crosses sitegroup borders");
                        break;

                case MGD_ERR_NOT_OBJECT:
                        return _("Not Midgard Object");
                        break;

                case MGD_ERR_NOT_EXISTS:
                        return _("Object does not exist");
                        break;

                case MGD_ERR_NO_MEM:
                        return _("Can't allocate memory"); /* FIXME This should be returned by GLib error */
                        break;

                case MGD_ERR_INVALID_NAME:
                        return _("Invalid characters in object's name");
                        break;

                case MGD_ERR_DUPLICATE:
                        return _("Object already exist");
                        break;
                        
                case MGD_ERR_HAS_DEPENDANTS:
                        return _("Object has dependants");
                        break;
                        
                case MGD_ERR_RANGE:
                        return _("Date range error"); /* FIXME , replace with invalid date range or format */
                        break;

                case MGD_ERR_NOT_CONNECTED:
                        return _("Not connected to the Midgard database");
                        break;

                case MGD_ERR_SG_NOTFOUND:
                        return _("Sitegroup not found");
                        break;

                case MGD_ERR_INVALID_OBJECT:
                        return _("Object not registered as Midgard Object");
                        break;
                        
                case MGD_ERR_QUOTA:
                        return _("Quota limit reached");
                        break;
                        
                case MGD_ERR_INTERNAL:
                        return _("Critical internal error");
                        break;

                case MGD_ERR_OBJECT_NAME_EXISTS:
                        return _("Object with such name exists in tree");
                        break;
                        
                case MGD_ERR_OBJECT_NO_STORAGE:
                        return _("Storage table not defined for object");
                        break;

                case MGD_ERR_OBJECT_NO_PARENT:
                        return _("Parent object in tree not defined");
                        break;

                case MGD_ERR_INVALID_PROPERTY_VALUE:
                        return _("Invalid property value.");
                        break;

                case MGD_ERR_USER_DATA:
                        return "";
                        break;

                case MGD_ERR_OBJECT_DELETED:
                        return _("Object deleted");
                        break;

                case MGD_ERR_OBJECT_PURGED:
                        return _("Object purged");
                        break;

                case MGD_ERR_OBJECT_EXPORTED:
                        return _("Object already exported");
                        break;

                case MGD_ERR_OBJECT_IMPORTED:
                        return _("Object already imported");
                        break;

                case MGD_ERR_MISSED_DEPENDENCE:
                        return _("Missed dependence for object.");
                        break;

                default:
                        return _("Undefined error");
                                        
        }               
}

static gchar* _midgard_error_format(const gchar *msg, va_list args)
{
        if(!msg)
                return g_strdup("");

        gchar *new_string = 
                g_strdup_vprintf(msg, args);

        return new_string;
}

void midgard_set_error(
                MidgardConnection *mgd, GQuark domain, gint errcode, const gchar *msg, ...)
{
        g_assert(mgd != NULL);

        if(!domain) 
                domain = MGD_GENERIC_ERROR;
        
        if(mgd->errstr)
                g_free(mgd->errstr);

        gchar *new_msg;
        va_list args;

        va_start(args, msg);
        new_msg =  _midgard_error_format(msg, args);
        va_end(args);   

        /* watch out! midgard 1.7 and midcom needs MGD_ERR_OK string.
         * Keep string formatters together */
        g_set_error(&mgd->err, domain, errcode,
                        "%s%s", 
                        midgard_error_string(domain, errcode),
                        new_msg);
        g_free(new_msg);

        mgd->errnum = errcode;
        mgd->errstr = g_strdup(mgd->err->message);      

        /* FIXME, remove later , this is legacy compatible stuff */
        if(mgd->mgd)
                mgd->mgd->errn = errcode;       
        
        return;         
}

---