QOF  0.7.5
qsf-xml.h File Reference

Private QSF header - not for use by applications. More...

#include <stdio.h>
#include <stdlib.h>
#include <regex.h>
#include <time.h>
#include "qof.h"
#include <libintl.h>

Go to the source code of this file.

Data Structures

struct  QsfObject_s
 Holds a description of the QofObject. More...
 
struct  QsfMetadata_s
 QSF Parameters. More...
 
struct  QsfValidates_s
 Validation metadata. More...
 
struct  QsfNodeIterate
 One iterator, two typedefs. More...
 

Macros

#define _(String)   dgettext (GETTEXT_PACKAGE, String)
 
#define QSF_QOF_VERSION   QOF_OBJECT_VERSION
 
#define QSF_XSD_TIME   QOF_UTC_DATE_FORMAT
 
#define QSF_XML_BOOLEAN_TEST   "true"
 
#define QSF_OBJECT_SCHEMA   "qsf-object.xsd.xml"
 
#define QSF_MAP_SCHEMA   "qsf-map.xsd.xml"
 
QSF Object XML
#define QSF_ROOT_TAG   "qof-qsf"
 
#define QSF_DEFAULT_NS   "http://qof.sourceforge.net/"
 
#define QSF_DATE_LENGTH   MAX_DATE_LENGTH
 
#define QSF_BOOK_TAG   "book"
 
#define QSF_BOOK_GUID   "book-guid"
 
#define QSF_BOOK_COUNT   "count"
 
#define QSF_OBJECT_TAG   "object"
 
#define QSF_OBJECT_TYPE   "type"
 
#define QSF_OBJECT_COUNT   "count"
 
#define QSF_XML_VERSION   "1.0"
 
Representing KVP as XML

<kvp type="kvp" path="/from-sched-xaction" value="guid">c858b9a3235723b55bc1179f0e8c1322</kvp> A kvp type KVP parameter located at $path containing a GUID $value.

The relevance of type="kvp" won't be evident in GnuCash, they all use "kvp".

A non-GnuCash example helps: <kvp type="pilot_addr_kvp" path="/user/name" value="guid">c858b9a3235723b55bc1179f0e8c1322</kvp> A pilot_addr_kvp type KVP parameter located at /user/name containing a guid value.

#define QSF_OBJECT_KVP   "path"
 
#define QSF_OBJECT_VALUE   "value"
 
QSF Map XML
#define MAP_ROOT_TAG   "qsf-map"
 
#define MAP_DEFINITION_TAG   "definition"
 
#define MAP_DEFINE_TAG   "define"
 
#define MAP_ITERATE_ATTR   "foreach"
 
#define MAP_DEFAULT_TAG   "default"
 
#define MAP_OBJECT_TAG   "object"
 
#define MAP_CALCULATE_TAG   "calculate"
 
#define MAP_QOF_VERSION   "qof_version"
 
#define MAP_NAME_ATTR   "name"
 
#define MAP_TYPE_ATTR   "type"
 
#define MAP_VALUE_ATTR   "value"
 
#define MAP_OBJECT_ATTR   "object"
 
#define MAP_E_TYPE   "e_type"
 
#define MAP_ENUM_TYPE   "enum"
 
#define QSF_BOOLEAN_DEFAULT   "boolean"
 A specific boolean default for this map.
 
#define QSF_CONDITIONAL   "if"
 
#define QSF_CONDITIONAL_SET   "set"
 
#define QSF_CONDITIONAL_ELSE   "else"
 
#define QSF_OPTION   "option"
 
#define QSF_FORMATTING_OPTION   "format"
 

Typedefs

typedef struct QsfObject_s QsfObject
 Holds a description of the QofObject. More...
 
typedef struct QsfMetadata_s QsfParam
 QSF Parameters. More...
 
typedef struct QsfValidates_s QsfValidator
 Validation metadata. More...
 

Enumerations

enum  QsfType {
  QSF_UNDEF = 0, IS_QSF_MAP, IS_QSF_OBJ, HAVE_QSF_MAP,
  OUR_QSF_OBJ
}
 
enum  QsfStatus {
  QSF_NO_OBJECT = 0, QSF_DEFINED_OBJECT, QSF_REGISTERED_OBJECT, QSF_CALCULATED_OBJECT,
  QSF_INVALID_OBJECT
}
 Status of various object during mapping. More...
 

Functions

gint qsf_compare_tag_strings (const xmlChar *node_name, gchar *tag_name)
 shorthand function More...
 
gint qsf_strings_equal (const xmlChar *node_name, gchar *tag_name)
 shorthand function More...
 
gint qsf_is_element (xmlNodePtr a, xmlNsPtr ns, gchar *c)
 shorthand function More...
 
gint qsf_check_tag (QsfParam *params, gchar *qof_type)
 shorthand function More...
 
void qsf_object_validation_handler (xmlNodePtr child, xmlNsPtr ns, QsfValidator *valid)
 Checks all incoming objects for QOF registration. More...
 
gboolean qsf_is_valid (const gchar *schema_dir, const gchar *schema_filename, xmlDocPtr doc)
 Compares an xmlDoc in memory against the schema file. More...
 
GList ** qsf_map_prepare_list (GList **maps)
 Prepare the default list of maps. More...
 
void qsf_book_node_handler (xmlNodePtr child, xmlNsPtr qsf_ns, QsfParam *params)
 Book and book-guid node handler. More...
 
KvpValuestring_to_kvp_value (const gchar *content, KvpValueType type)
 Convert a string value into KvpValue. More...
 
void qsf_valid_foreach (xmlNodePtr parent, QsfValidCB cb, struct QsfNodeIterate *qsfiter, QsfValidator *valid)
 
void qsf_node_foreach (xmlNodePtr parent, QsfNodeCB cb, struct QsfNodeIterate *qsfiter, QsfParam *params)
 
xmlDocPtr qsf_object_convert (xmlDocPtr mapDoc, xmlNodePtr qsf_root, QsfParam *params)
 Convert between QSF objects. More...
 
void qsf_object_node_handler (xmlNodePtr child, xmlNsPtr qsf_ns, QsfParam *params)
 

Why two sets of functions and typedefs?

These functions are in pairs, one to use in an existing session and one to use when deciding which backend should be selected for a new session.

  • When there is an existing QofSession, the qsf_param context will be available, so set error codes in the backend. Use the *_be functions.
  • When just determining the type of file, qsf_param is not necessary and no backend is available (it has not been selected yet). Use the twin function. e.g. in ::qsf_file_type()
typedef void(* QsfNodeCB )(xmlNodePtr, xmlNsPtr, QsfParam *)
 map and qsf object callback More...
 
typedef void(* QsfValidCB )(xmlNodePtr, xmlNsPtr, QsfValidator *)
 validator callback More...
 
gboolean is_qsf_object_be (QsfParam *params)
 Validate a QSF file and identify a suitable QSF map. More...
 
gboolean is_qsf_object (const gchar *path)
 Validate a QSF file and identify a suitable QSF map. More...
 
gboolean is_our_qsf_object_be (QsfParam *params)
 Validate a QSF file and determine type. More...
 
gboolean is_our_qsf_object (const gchar *path)
 Validate a QSF file. More...
 
gboolean is_qsf_map_be (QsfParam *params)
 Validate a QSF map file. More...
 
gboolean is_qsf_map (const gchar *path)
 Validate a QSF map file. More...
 
gboolean is_qsf_object_with_map_be (gchar *map_path, QsfParam *params)
 Validate a QSF file and a selected QSF map. More...
 
gboolean is_qsf_object_with_map (const gchar *path, gchar *map_file)
 Validate a QSF file and a selected QSF map. More...
 

Detailed Description

Private QSF header - not for use by applications.

Author
Copyright (C) 2004-2005 Neil Williams linux.nosp@m.@cod.nosp@m.ehelp.nosp@m..co..nosp@m.uk

Definition in file qsf-xml.h.

Macro Definition Documentation

#define MAP_CALCULATE_TAG   "calculate"
One calculation for every parameter

that needs to be set.

QSF follows the same rule as qof_book_merge. Only if a getter and a setter function are defined for a parameter is it available to QSF. If a QofAccessFunc and QofSetterFunc are both defined for any QofObject parameter, that parameter MUST be calculated in any map that defines that object.

Definition at line 251 of file qsf-xml.h.

#define MAP_DEFAULT_TAG   "default"
User editable defaults for data not

available within the available QSF objects.

Some defaults will relate to how to format descriptive dates, whether discount should be considered, which account to use for certain QSF data from applications that do not use accounts.

Some defaults are pre-defined and cannot be over-written:

  • qsf_time_now
  • qsf_time_string

Attributes (All are mandatory):

name The text name for this default. Certain pre-defined defaults exist but user- or map-defined defaults can have any unique text name. Spaces are NOT allowed, use undersccores instead. The value of name must not duplicate any existing default, define, object or parameter unless the special type, enum, is used.

type QOF_TYPE - must be one of the recognised QOF data types for the qof_version in use or the special type, enum.

value Text representation of the required value. For numeric, use the format [0-9]?/[0-9]?

Attention
Using boolean defaults

A boolean default is not output in the QSF directly, instead the value is used in the calculations to modify certain values. If the boolean default is set to true, the if statement containing the boolean name will be evaluated. If the boolean default is set to false, the corresponding else will be evaluted. Make sure your calculations contain an appropriate else statement so that the boolean value can be adjusted without invalidating the map!

QSF deals with partial QofBooks - each object is fully described but the book does not have to contain any specific object types or have any particular structure. To merge partial books into usual QofBook data sources, the map must deal with entities that need to be referenced in the target QofBook but which simply do not exist in the QofBook used to generate the QSF. e.g. pilot-link knows nothing of Accounts yet when QSF creates a gncInvoice from qof-datebook, gncInvoice needs to know the GUID of certain accounts in the target QofBook. This is handled in the map by specifying the name of the account as a default for that map. When imported, the QSF QofBackend looks up the object required using the name of the parameter to obtain the parameter type. This is the only situation where QSF converts between QOF data types. A string description of the required object is converted to the GUID for that specific entity. The map cannot contain the GUID as it is generic and used by multiple users.

Attention
Using enumerators
  • enum types are the only defaults that are allowed to use the same name value more than once.
  • enum types are used to increase the readability of a QSF map.
  • The enum name acts to group the enum values together - in a similar fashion to radio buttons in HTML forms.
  • enum types are used only where the QOF object itself uses an enum type.

e.g. the tax_included enum type allows maps to use the full name of the enum value GNC_TAXINCLUDED_YES, instead of the cryptic digit value, 1.

Definition at line 229 of file qsf-xml.h.

#define MAP_DEFINE_TAG   "define"
defines each object supported by this QSF map 

Attributes: e_type Copied directly from the QofObject definition. Content: The full QofObject description for the defined QOF object.

Definition at line 154 of file qsf-xml.h.

#define MAP_DEFINITION_TAG   "definition"
Second level container for defined objects 

Attributes: qof_version - Taken from the QOF_OBJECT_VERSION macro in QOF. At the time of QSF development, QOF_OBJECT_VERSION is defined as 3. All QSF maps and QSF objects must use the same qof_version which in turn must match the QOF_OBJECT_VERSION for the QOF library in use by the calling process.

No text content allowed.

Definition at line 147 of file qsf-xml.h.

#define MAP_E_TYPE   "e_type"
Validates the objects defined in the map 

The e_type will be used to match incoming QSF objects with the relevant QSF map. The value of the e_type must be the value of the e_type for that object in the originating QOF application. The define tag must contain the value of the description of the same object in the same originating QOF application.

Definition at line 303 of file qsf-xml.h.

#define MAP_ENUM_TYPE   "enum"
Todo:
enum is an attempt to make enumerator values descriptive in the maps and QSF (possibly). Not working yet.

Definition at line 307 of file qsf-xml.h.

#define MAP_ITERATE_ATTR   "foreach"
Dictate which object type is the basis

for iteration in a hierarchical object set.

Definition at line 158 of file qsf-xml.h.

#define MAP_NAME_ATTR   "name"
The name of the default setting.

Use this name to refer to the value of this default in the map calculations.

Make sure that the type of this default matches the type of the parameter being set by the parent calculation!

Definition at line 270 of file qsf-xml.h.

#define MAP_OBJECT_ATTR   "object"
The object to use to provide the data being set using 

the map.

Definition at line 293 of file qsf-xml.h.

#define MAP_OBJECT_TAG   "object"
Contains all the calculations to make one

object from others.

Note that creating an object for the import application can involve using data from more than one QSF object, as well as defaults and lookups in the import application itself. Conditionals, simple arithmetic and date/time formatting options are also available.

Definition at line 240 of file qsf-xml.h.

#define MAP_QOF_VERSION   "qof_version"
This is the QOF_OBJECT_VERSION from QOF.

QSF maps may need to be updated if QOF itself is upgraded. This setting is coded into QOF and maps for one version cannot necessarily be used by other versions. At the first release of QSF, QOF_OBJECT_VERSION = 3.

Definition at line 260 of file qsf-xml.h.

#define MAP_ROOT_TAG   "qsf-map"

Top level root tag for QSF Maps

Definition at line 136 of file qsf-xml.h.

#define MAP_TYPE_ATTR   "type"
QSF will NOT convert between QOF types.

QSF will allow a conditional to use a parameter of one type to determine the value from a parameter of another type, but the final value assigned MUST be of the same type as the parent calculation.

Definition at line 279 of file qsf-xml.h.

#define MAP_VALUE_ATTR   "value"
The value of the tag, used in defaults and calculations.

The value of a default is a string representation of the value to be inserted into the calculation where the default is used.

The value of a calculation is the name of the parameter that will be set by that calculation.

Definition at line 289 of file qsf-xml.h.

#define QSF_BOOK_COUNT   "count"

Sequential counter of each book in this file

Definition at line 99 of file qsf-xml.h.

#define QSF_BOOK_GUID   "book-guid"
QOF GUID tag for the QofBook

described by this QSF object file

Definition at line 97 of file qsf-xml.h.

#define QSF_BOOK_TAG   "book"

First level child: book tag - the QofBook.

Definition at line 94 of file qsf-xml.h.

#define QSF_CONDITIONAL   "if"
child of calculate.

Conditionals can reference objects as if within the original application. In operation, the map is overlaid across both sets of defined objects, an import object in the source application and an output object for the destination object. The current import and output QSF objects are therefore always available to the map. Conditionals can reference parameter as well as object values.

Definition at line 322 of file qsf-xml.h.

#define QSF_CONDITIONAL_ELSE   "else"
Alternative

if(){} else{} is also supported. Nesting of conditionals causes problems for validating the final map against any sensible XML Schema and a map that does not validate will be rejected. When editing conditionals in a QSF map, ALWAYS validate the map using xmllint. If necessary, define a variable at the foot of the definitions block, using a similar syntax to a default, then use that variable in another conditional

variable name="my_rate" type="numeric" value="0/1"

The syntax for xmllint is:

xmllint –schema <schema file> <qsf-file>

Use the qsf-object.xsd.xml schema for objects and qsf-map.xsd.xml for map files.

e.g. xmllint –schema qsf-object.xsd.xml –noout qof-qsf.xml

Definition at line 358 of file qsf-xml.h.

#define QSF_CONDITIONAL_SET   "set"
Assignment statement

Map assignments can use the native values within the output object. The output object must support setting the relevant parameter using the value exactly as given in the map because the relevant set() function will be called using this value. This may reduce the readability of the map but the relevant application could also be modified to support a more readable set function.

Definition at line 334 of file qsf-xml.h.

#define QSF_DATE_LENGTH   MAX_DATE_LENGTH
Max length of QSF_XSD_TIME.

MAX_DATE_LENGTH itself is defined in qof-time.h

Definition at line 91 of file qsf-xml.h.

#define QSF_DEFAULT_NS   "http://qof.sourceforge.net/"
Default namespace for QSF root tag

The map namespace is not included as maps are not currently written out by QOF.

Definition at line 87 of file qsf-xml.h.

#define QSF_FORMATTING_OPTION   "format"
How to format dates/times

When the QSF map uses a date/time value as a string, the formatting can be adjusted to personal preference. format will only be evaluated if the calculated parameter is a QOF_TYPE_STRING - any format attributes on other data types will be ignored.

Definition at line 376 of file qsf-xml.h.

#define QSF_MAP_SCHEMA   "qsf-map.xsd.xml"

Name of the QSF Map Schema.

Definition at line 423 of file qsf-xml.h.

#define QSF_OBJECT_COUNT   "count"

Sequential counter for each QSF object in this file

Definition at line 105 of file qsf-xml.h.

#define QSF_OBJECT_KVP   "path"

The path to this KVP value in the entity frame.

Definition at line 127 of file qsf-xml.h.

#define QSF_OBJECT_SCHEMA   "qsf-object.xsd.xml"

Name of the QSF Object Schema.

Definition at line 420 of file qsf-xml.h.

#define QSF_OBJECT_TAG   "object"

Second level child: object tag

Definition at line 101 of file qsf-xml.h.

#define QSF_OBJECT_TYPE   "type"

QSF parameter name for object type specifiers

Definition at line 103 of file qsf-xml.h.

#define QSF_OBJECT_VALUE   "value"

The KVP Value.

Definition at line 129 of file qsf-xml.h.

#define QSF_OPTION   "option"
enum operator

Not implemented yet - may need to change once work starts. Theoretically, option will specify when an enumerator value is in use - it is quite possible that it will be unnecessary.

Definition at line 366 of file qsf-xml.h.

#define QSF_QOF_VERSION   QOF_OBJECT_VERSION
 QOF Version check.

Make sure the same version of QOF is in use in both applications.

Definition at line 70 of file qsf-xml.h.

#define QSF_ROOT_TAG   "qof-qsf"

The top level root tag

Definition at line 81 of file qsf-xml.h.

#define QSF_XML_BOOLEAN_TEST   "true"

needs to be lowercase for XML validation

Definition at line 417 of file qsf-xml.h.

#define QSF_XML_VERSION   "1.0"

The current XML version.

Definition at line 107 of file qsf-xml.h.

#define QSF_XSD_TIME   QOF_UTC_DATE_FORMAT
xsd:dateTime format in coordinated universal time, UTC.

You can reproduce the string from the GNU/Linux command line using the date utility:

date -u +Y-m-dTH:M:SZ

2004-12-12T23:39:11Z

The datestring must be timezone independent and include all specified fields.

Remember to use gmtime() NOT localtime()!. From the command line, use the -u switch with the date command: date -u

To generate a timestamp based on a real time, use the qsf_time_now and qsf_time_string defaults.

qsf_time_now : Format: QOF_TYPE_DATE. The current time taken from the moment the default is read into a QSF object at runtime.

qsf_time_string : Format: QOF_TYPE_STRING. The current timestamp taken from the moment the default is read into a QSF object at runtime. This form is used when the output parameter needs a formatted date string, not an actual date object. The format is determined by the optional format attribute of the set tag which takes the same operators as the GNU C Library for strftime() and output may therefore be dependent on the locale of the calling process - take care. Default value is F, used when qsf_time_string is set without the format attribute.

Both defaults use UTC.

Definition at line 414 of file qsf-xml.h.

Typedef Documentation

typedef void(* QsfNodeCB)(xmlNodePtr, xmlNsPtr, QsfParam *)

map and qsf object callback

This callback cannot do both the map and the validation tasks because validation sometimes needs to be done without qsf_params.

e.g. when selecting which backend should be used for a particular data source where two or more backends share the same access_method.

Definition at line 677 of file qsf-xml.h.

typedef struct QsfObject_s QsfObject

Holds a description of the QofObject.

Used when converting QOF objects from another application. The incoming, unknown, objects need to be stored prior to conversion. This allows many-to-many conversions where an invoice can receive data from an incoming expense AND datebook and use data from an incoming contacts object to lookup the customer for the invoice.

typedef struct QsfMetadata_s QsfParam

QSF Parameters.

This struct is a catch-all for all parameters required for various stages of the process. There are lots of elements here that will finally be removed.

typedef struct QsfValidates_s QsfValidator

Validation metadata.

The validation is a separate parse with separate data. This is used to determine which backend should load the data.

typedef void(* QsfValidCB)(xmlNodePtr, xmlNsPtr, QsfValidator *)

validator callback

Todo:
The need for separate metadata means a separate callback typedef is needed for the validator, but this should be fixed to only need one.

Definition at line 684 of file qsf-xml.h.

Enumeration Type Documentation

enum QsfStatus

Status of various object during mapping.

When handling a map, the incoming QSF objects are not registered with this instance of QOF - they originate from another QOF user. Each object in a map needs to be defined. If the object is registered, the map is checked to locate a calculation that can be used to generate this object. If the object is not registered, the incoming QSF is checked to ensure it provides the object data for the calculation. If anything goes wrong, QSF_INVALID_OBJECT is used.

Maps can be unidirectional or bidirectional so QOF registration is used to determine which calculations should be used and which should be ignored.

All QSF_REGISTERED_OBJECT types need a calculation - if any types remain tagged as QSF_REGISTERED_OBJECT when the map validation is complete, the validation must fail. The only acceptable end values for QsfStatus are QSF_DEFINED_OBJECT, QSF_CALCULATED_OBJECT or QSF_INVALID_OBJECT.

Enumerator
QSF_NO_OBJECT 

Init value.

QSF_DEFINED_OBJECT 

The object is unregistered but defined. Objects of this type must exist in the incoming QSF and must provide data for the calculation of registered objects.

QSF_REGISTERED_OBJECT 

Temporary value. The object is registered and defined - a calculation is needed but has not been found, yet.

QSF_CALCULATED_OBJECT 

The object is registered, defined and can be calculated.

QSF_INVALID_OBJECT 

Oops value.

Definition at line 446 of file qsf-xml.h.

467 {
enum QsfType
Enumerator
QSF_UNDEF 

Initial undefined value.

IS_QSF_MAP 

A QSF map

IS_QSF_OBJ 

A QSF object without a map - it may or may not need one.

HAVE_QSF_MAP 

A QSF object with the map it needs.

OUR_QSF_OBJ 

A QSF object that can be loaded without a map.

Definition at line 41 of file qsf-xml.h.

42 {
44  QSF_UNDEF = 0,
46  IS_QSF_MAP,
48  IS_QSF_OBJ,
53 } QsfType;

Function Documentation

gboolean is_our_qsf_object ( const gchar *  path)

Validate a QSF file.

Parameters
pathAbsolute or relative path to the file to be validated

The file is validated against the QSF object schema, qsf-object.xsd.xml and each object described in the file is checked to see if it is registered with QOF within the QOF environment of the calling process.

Files that pass the test can be imported into the QOF application without the need for a QSF map.

Returns
TRUE if the file validates and all objects pass, otherwise FALSE.

Definition at line 180 of file qsf-xml.c.

181 {
182  xmlDocPtr doc;
183  struct QsfNodeIterate qsfiter;
184  xmlNodePtr object_root;
185  QsfValidator valid;
186  gint table_count;
187 
188  g_return_val_if_fail ((path != NULL), FALSE);
189  doc = xmlParseFile (path);
190  if (doc == NULL)
191  {
192  return FALSE;
193  }
194  if (TRUE != qsf_is_valid (QSF_SCHEMA_DIR, QSF_OBJECT_SCHEMA, doc))
195  {
196  PINFO (" validation failed %s %s %s", QSF_SCHEMA_DIR,
197  QSF_OBJECT_SCHEMA, path);
198  return FALSE;
199  }
200  object_root = xmlDocGetRootElement (doc);
201  /* check that all objects in the file are already registered in QOF */
202  valid.object_table = g_hash_table_new (g_str_hash, g_str_equal);
203  valid.qof_registered_count = 0;
204  valid.valid_object_count = 0;
205  qsfiter.ns = object_root->ns;
206  qsf_valid_foreach (object_root, qsf_object_validation_handler,
207  &qsfiter, &valid);
208  table_count = g_hash_table_size (valid.object_table);
209  g_hash_table_destroy (valid.object_table);
210  xmlFreeDoc (doc);
211  if (table_count == valid.qof_registered_count)
212  {
213  return TRUE;
214  }
215  return FALSE;
216 }
gboolean is_our_qsf_object_be ( QsfParam params)

Validate a QSF file and determine type.

Parameters
paramsPointer to qsf_param context

The file is validated against the QSF object schema, qsf-object.xsd.xml and each object described in the file is checked to see if it is registered with QOF within the QOF environment of the calling process.

Files that pass the test can be imported into the QOF appliction without the need for a QSF map.

Returns
TRUE if the file validates and all objects pass, otherwise FALSE.

Definition at line 243 of file qsf-xml.c.

244 {
245  xmlDocPtr doc;
246  struct QsfNodeIterate qsfiter;
247  xmlNodePtr object_root;
248  QsfValidator valid;
249  gint table_count;
250 
251  g_return_val_if_fail ((params != NULL), FALSE);
252  if (params->filepath == NULL)
253  {
254  qof_error_set_be (params->be, qof_error_register
255  (_("The QSF XML file '%s' could not be found."), TRUE));
256  return FALSE;
257  }
258  if (params->file_type != QSF_UNDEF)
259  {
260  return FALSE;
261  }
262  doc = xmlParseFile (params->filepath);
263  if (doc == NULL)
264  {
265  qof_error_set_be (params->be, qof_error_register
266  (_("There was an error parsing the file '%s'."), TRUE));
267  return FALSE;
268  }
269  if (TRUE != qsf_is_valid (QSF_SCHEMA_DIR, QSF_OBJECT_SCHEMA, doc))
270  {
271  qof_error_set_be (params->be, qof_error_register
272  (_("Invalid QSF Object file! The QSF object file '%s' "
273  " failed to validate against the QSF object schema. "
274  "The XML structure of the file is either not well-formed "
275  "or the file contains illegal data."), TRUE));
276  xmlFreeDoc (doc);
277  return FALSE;
278  }
279  params->file_type = IS_QSF_OBJ;
280  object_root = xmlDocGetRootElement (doc);
281  xmlFreeDoc (doc);
282  valid.object_table = g_hash_table_new (g_str_hash, g_str_equal);
283  valid.qof_registered_count = 0;
284  qsfiter.ns = object_root->ns;
285  qsf_valid_foreach (object_root, qsf_object_validation_handler,
286  &qsfiter, &valid);
287  table_count = g_hash_table_size (valid.object_table);
288  if (table_count == valid.qof_registered_count)
289  {
290  g_hash_table_destroy (valid.object_table);
291  return TRUE;
292  }
293  g_hash_table_destroy (valid.object_table);
294  qof_error_set_be (params->be, params->err_nomap);
295  return FALSE;
296 }
gboolean is_qsf_map ( const gchar *  path)

Validate a QSF map file.

Parameters
pathAbsolute or relative path to the file to be validated

These functions are in pairs. When called from within a QofSession, the qsf_param context will be available. When just determining the type of file, qsf_param is not necessary. Use the *_be functions from within the QofBackend and the corresponding function in other code.

The file is validated aginst the QSF map schema, qsf-map.xsd.xsml. This function is called by is_qsf_object. If called directly, the map file is validated and closed, no data is retrieved. QSF maps do not contain user data but are used to import QSF object files from other applications.

Returns
TRUE if the map validates, otherwise FALSE.

Definition at line 372 of file qsf-xml-map.c.

373 {
374  xmlDocPtr doc;
375  struct QsfNodeIterate qsfiter;
376  QsfValidator valid;
377  xmlNodePtr map_root;
378  xmlNsPtr map_ns;
379 
380  g_return_val_if_fail ((path != NULL), FALSE);
381  if (path == NULL)
382  {
383  return FALSE;
384  }
385  doc = xmlParseFile (path);
386  if (doc == NULL)
387  {
388  return FALSE;
389  }
390  if (TRUE != qsf_is_valid (QSF_SCHEMA_DIR, QSF_MAP_SCHEMA, doc))
391  {
392  return FALSE;
393  }
394  map_root = xmlDocGetRootElement (doc);
395  map_ns = map_root->ns;
396  qsfiter.ns = map_ns;
397  valid.error_state = QOF_SUCCESS;
398  valid.map_table = g_hash_table_new (g_str_hash, g_str_equal);
399  qsf_valid_foreach (map_root, qsf_map_validation_handler,
400  &qsfiter, &valid);
401  if (valid.error_state != QOF_SUCCESS)
402  {
403  g_hash_table_destroy (valid.map_table);
404  return FALSE;
405  }
406  g_hash_table_destroy (valid.map_table);
407  return TRUE;
408 }
gboolean is_qsf_map_be ( QsfParam params)

Validate a QSF map file.

Parameters
paramsPointer to qsf_param context

The file is validated aginst the QSF map schema, qsf-map.xsd.xsml. This function is called by is_qsf_object. If called directly, the map file is validated and closed with a QofBackend error. QSF maps do not contain user data and are used to import QSF object files.

Returns
TRUE if the map validates, otherwise FALSE.

Definition at line 320 of file qsf-xml-map.c.

321 {
322  xmlDocPtr doc;
323  struct QsfNodeIterate qsfiter;
324  QsfValidator valid;
325  xmlNodePtr map_root;
326  xmlNsPtr map_ns;
327  gchar *path;
328 
329  g_return_val_if_fail ((params != NULL), FALSE);
330  path = g_strdup (params->filepath);
331  if (path == NULL)
332  {
333  qof_error_set_be (params->be, qof_error_register
334  (_("The QSF XML file '%s' could not be found."), TRUE));
335  return FALSE;
336  }
337  doc = xmlParseFile (path);
338  if (doc == NULL)
339  {
340  qof_error_set_be (params->be, qof_error_register
341  (_("There was an error parsing the file '%s'."), TRUE));
342  return FALSE;
343  }
344  if (TRUE != qsf_is_valid (QSF_SCHEMA_DIR, QSF_MAP_SCHEMA, doc))
345  {
346  qof_error_set_be (params->be,
348  _("Invalid QSF Map file! The QSF map file "
349  "failed to validate against the QSF map schema. "
350  "The XML structure of the file is either not well-formed "
351  "or the file contains illegal data."), FALSE));
352  return FALSE;
353  }
354  map_root = xmlDocGetRootElement (doc);
355  map_ns = map_root->ns;
356  qsfiter.ns = map_ns;
357  valid.object_table = g_hash_table_new (g_str_hash, g_str_equal);
358  valid.map_table = g_hash_table_new (g_str_hash, g_str_equal);
359  valid.error_state = QOF_SUCCESS;
360  qsf_valid_foreach (map_root, qsf_map_validation_handler,
361  &qsfiter, &valid);
362  if (valid.error_state != QOF_SUCCESS)
363  {
364  g_hash_table_destroy (valid.object_table);
365  return FALSE;
366  }
367  g_hash_table_destroy (valid.object_table);
368  return TRUE;
369 }
gboolean is_qsf_object ( const gchar *  path)

Validate a QSF file and identify a suitable QSF map.

Parameters
pathAbsolute or relative path to the file to be validated.

These functions are in pairs. When called from within a QofSession, the qsf_param context will be available. When just determining the type of file, qsf_param is not necessary. Use the *_be functions from within the QofBackend and the corresponding function in other code.

The file is validated against the QSF object schema, qsf-object.xsd.xml and each object described in the file is checked to find out if a suitable QSF map exists. Map files are accepted if all objects described in the QSF object file are defined in the QSF map.

Returns
TRUE if the file validates and a QSF map can be found, otherwise FALSE.

Definition at line 219 of file qsf-xml.c.

220 {
221  xmlDocPtr doc;
222 
223  g_return_val_if_fail ((path != NULL), FALSE);
224  if (path == NULL)
225  {
226  return FALSE;
227  }
228  doc = xmlParseFile (path);
229  if (doc == NULL)
230  {
231  return FALSE;
232  }
233  if (TRUE != qsf_is_valid (QSF_SCHEMA_DIR, QSF_OBJECT_SCHEMA, doc))
234  {
235  return FALSE;
236  }
237  /* Note cannot test against a map here, so if the file is valid QSF,
238  accept it and work out the details later. */
239  return TRUE;
240 }
gboolean is_qsf_object_be ( QsfParam params)

Validate a QSF file and identify a suitable QSF map.

Parameters
paramsPointer to qsf_param context

These functions are in pairs. When called from within a QofSession, the qsf_param context will be available. When just determining the type of file, qsf_param is not necessary. Use the *_be functions from within the QofBackend and the corresponding function in other code.

The file is validated against the QSF object schema, qsf-object.xsd.xml and each object described in the file is checked to find out if a suitable QSF map exists. Map files are accepted if all objects described in the QSF object file are defined in the QSF map.

Returns
TRUE if the file validates and a QSF map can be found, otherwise FALSE.

Definition at line 299 of file qsf-xml.c.

300 {
301  gboolean result;
302  xmlDocPtr doc;
303  GList *maps;
304  gchar *path;
305 
306  g_return_val_if_fail ((params != NULL), FALSE);
307  path = g_strdup (params->filepath);
308  if (path == NULL)
309  {
310  qof_error_set_be (params->be, qof_error_register
311  (_("The QSF XML file '%s' could not be found."), TRUE));
312  return FALSE;
313  }
314  /* skip validation if is_our_qsf_object has already been called. */
315 /* if (ERR_QSF_INVALID_OBJ == qof_backend_get_error (params->be))
316  {
317  return FALSE;
318  }*/
319  if (params->file_type == QSF_UNDEF)
320  {
321  doc = xmlParseFile (path);
322  if (doc == NULL)
323  {
324  qof_error_set_be (params->be, qof_error_register
325  (_("There was an error parsing the file '%s'."), TRUE));
326  return FALSE;
327  }
328  if (TRUE != qsf_is_valid (QSF_SCHEMA_DIR, QSF_OBJECT_SCHEMA, doc))
329  {
330  qof_error_set_be (params->be, qof_error_register
331  (_("Invalid QSF Object file! The QSF object file '%s' "
332  " failed to validate against the QSF object schema. "
333  "The XML structure of the file is either not well-formed "
334  "or the file contains illegal data."), TRUE));
335  return FALSE;
336  }
337  }
338  result = FALSE;
339  /* retrieve list of maps from config frame. */
340  for (maps = params->map_files; maps; maps = maps->next)
341  {
342  QofErrorId err;
343  result = is_qsf_object_with_map_be (maps->data, params);
344  err = qof_error_check_be (params->be);
345  if ((err == QOF_SUCCESS) && result)
346  {
347  params->map_path = maps->data;
348  PINFO ("map chosen = %s", params->map_path);
349  break;
350  }
351  }
352  return result;
353 }
gboolean is_qsf_object_with_map ( const gchar *  path,
gchar *  map_file 
)

Validate a QSF file and a selected QSF map.

Parameters
pathAbsolute or relative path to the selected QSF object file
map_fileName of the QSF map file, located in QSF_SCHEMA_DIR.

The file is validated against the QSF object schema, qsf-object.xsd.xml and each object described in the file is checked to find out if the supplied QSF map is suitable. Map files are accepted if all objects described in the QSF object file are defined in the QSF map.

Returns
TRUE if the file validates and the supplied QSF map is usable, otherwise FALSE.

Definition at line 290 of file qsf-xml-map.c.

291 {
292  xmlDocPtr doc, map_doc;
293  QofErrorId result;
294  gchar *map_path;
295 
296  map_path = g_strdup_printf ("%s/%s", QSF_SCHEMA_DIR, map_file);
297  if (path == NULL)
298  {
299  return FALSE;
300  }
301  doc = xmlParseFile (path);
302  if (doc == NULL)
303  {
304  return FALSE;
305  }
306  if (TRUE != qsf_is_valid (QSF_SCHEMA_DIR, QSF_OBJECT_SCHEMA, doc))
307  {
308  return FALSE;
309  }
310  if (map_path == NULL)
311  {
312  return FALSE;
313  }
314  map_doc = xmlParseFile (map_path);
315  result = check_qsf_object_with_map_internal (map_doc, doc);
316  return (result == QOF_SUCCESS) ? TRUE : FALSE;
317 }
gboolean is_qsf_object_with_map_be ( gchar *  map_path,
QsfParam params 
)

Validate a QSF file and a selected QSF map.

Parameters
map_pathAbsolute or relative path to the selected QSF map file
paramsPointer to qsf_param context

The file is validated against the QSF object schema, qsf-object.xsd.xml and each object described in the file is checked to find out if the supplied QSF map is suitable. Map files are accepted if all objects described in the QSF object file are defined in the QSF map.

This backend twin also sets QofErrorId codes.

Returns
TRUE if the file validates and the supplied QSF map is usable, otherwise FALSE.

Definition at line 240 of file qsf-xml-map.c.

241 {
242  xmlDocPtr doc, map_doc;
243  QofErrorId result;
244  gchar *path, *map_path;
245 
246  g_return_val_if_fail ((params != NULL), FALSE);
247  path = g_strdup (params->filepath);
248  map_path = g_strdup_printf ("%s/%s", QSF_SCHEMA_DIR, map_file);
249  PINFO (" checking map file '%s'", map_path);
250  if (path == NULL)
251  {
252  qof_error_set_be (params->be, qof_error_register
253  (_("The QSF XML file '%s' could not be found."), TRUE));
254  return FALSE;
255  }
256  doc = xmlParseFile (path);
257  if (doc == NULL)
258  {
259  qof_error_set_be (params->be, qof_error_register
260  (_("There was an error parsing the file '%s'."), TRUE));
261  return FALSE;
262  }
263  if (TRUE != qsf_is_valid (QSF_SCHEMA_DIR, QSF_OBJECT_SCHEMA, doc))
264  {
265  qof_error_set_be (params->be, qof_error_register
266  (_("Invalid QSF Object file! The QSF object file '%s' "
267  " failed to validate against the QSF object schema. "
268  "The XML structure of the file is either not well-formed "
269  "or the file contains illegal data."), TRUE));
270  return FALSE;
271  }
272  if (map_path == NULL)
273  {
274  qof_error_set_be (params->be, qof_error_register
275  (_("The QSF map file '%s' could not be found."), TRUE));
276  return FALSE;
277  }
278  map_doc = xmlParseFile (map_path);
279  if (map_doc == NULL)
280  {
281  qof_error_set_be (params->be, qof_error_register
282  (_("There was an error parsing the file '%s'."), TRUE));
283  return FALSE;
284  }
285  result = check_qsf_object_with_map_internal (map_doc, doc);
286  return (result == QOF_SUCCESS) ? TRUE : FALSE;
287 }
void qsf_book_node_handler ( xmlNodePtr  child,
xmlNsPtr  qsf_ns,
QsfParam params 
)

Book and book-guid node handler.

Reads the book count="" attribute (currently only 1 QofBook is supported per QSF object file). Sets the book-guid as the GUID of the current QofBackend QofBook in qsf_param. Calls the next handler, qsf_object_node_handler, with the child of the book tag.

Definition at line 424 of file qsf-xml.c.

425 {
426  gchar *book_count_s, *tail;
427  gint book_count;
428  xmlNodePtr child_node;
429  struct QsfNodeIterate qsfiter;
430  gchar *buffer;
431  GUID book_guid;
432 
433  g_return_if_fail (child);
434  g_return_if_fail (params);
435  ENTER (" child=%s", child->name);
436  if (qsf_is_element (child, ns, QSF_BOOK_TAG))
437  {
438  book_count_s =
439  (gchar *) xmlGetProp (child, BAD_CAST QSF_BOOK_COUNT);
440  if (book_count_s)
441  {
442  book_count = (gint) strtol (book_count_s, &tail, 0);
443  /* More than one book not currently supported. */
444  g_free (book_count_s);
445  g_return_if_fail (book_count == 1);
446  }
447  qsfiter.ns = ns;
448  child_node = child->children->next;
449  if (qsf_is_element (child_node, ns, QSF_BOOK_GUID))
450  {
451  DEBUG (" trying to set book GUID");
452  buffer = BAD_CAST xmlNodeGetContent (child_node);
453  g_return_if_fail (TRUE == string_to_guid (buffer, &book_guid));
454  qof_entity_set_guid ((QofEntity *) params->book, &book_guid);
455  xmlNewChild (params->output_node, params->qsf_ns,
456  BAD_CAST QSF_BOOK_GUID, BAD_CAST buffer);
457  xmlFree (buffer);
458  }
459  qsf_node_foreach (child, qsf_object_node_handler, &qsfiter, params);
460  }
461  LEAVE (" ");
462 }
gint qsf_check_tag ( QsfParam params,
gchar *  qof_type 
)

shorthand function

This may look repetitive but each one is used separately as well as in a block.

Definition at line 69 of file qsf-xml.c.

70 {
71  return qsf_is_element (params->child_node, params->qsf_ns, qof_type);
72 }
gint qsf_compare_tag_strings ( const xmlChar *  node_name,
gchar *  tag_name 
)

shorthand function

This may look repetitive but each one is used separately as well as in a block.

Definition at line 39 of file qsf-xml.c.

40 {
41  return xmlStrcmp (node_name, (const xmlChar *) tag_name);
42 }
gint qsf_is_element ( xmlNodePtr  a,
xmlNsPtr  ns,
gchar *  c 
)

shorthand function

This may look repetitive but each one is used separately as well as in a block.

Definition at line 55 of file qsf-xml.c.

56 {
57  g_return_val_if_fail (a != NULL, 0);
58  g_return_val_if_fail (ns != NULL, 0);
59  g_return_val_if_fail (c != NULL, 0);
60  if ((a->ns == ns) && (a->type == XML_ELEMENT_NODE) &&
61  qsf_strings_equal (a->name, c))
62  {
63  return 1;
64  }
65  return 0;
66 }
gboolean qsf_is_valid ( const gchar *  schema_dir,
const gchar *  schema_filename,
xmlDocPtr  doc 
)

Compares an xmlDoc in memory against the schema file.

Parameters
schema_dirset at compile time to $prefix/share/qsf/
schema_filenameEither the QSF Object Schema or the QSF Map Schema.
docThe xmlDoc read from the file using libxml2.

Ensure that you call the right schema_filename for the doc in question!

Incorrect validation will result in output to the terminal window.

Returns
TRUE if the doc validates against the assigned schema, otherwise FALSE.

Definition at line 75 of file qsf-xml.c.

77 {
78  xmlSchemaParserCtxtPtr qsf_schema_file;
79  xmlSchemaPtr qsf_schema;
80  xmlSchemaValidCtxtPtr qsf_context;
81  gchar *schema_path;
82  gint result;
83 
84  g_return_val_if_fail (doc || schema_filename, FALSE);
85  schema_path = g_strdup_printf ("%s/%s", schema_dir, schema_filename);
86  qsf_schema_file = xmlSchemaNewParserCtxt (schema_path);
87  qsf_schema = xmlSchemaParse (qsf_schema_file);
88  qsf_context = xmlSchemaNewValidCtxt (qsf_schema);
89  result = xmlSchemaValidateDoc (qsf_context, doc);
90  xmlSchemaFreeParserCtxt (qsf_schema_file);
91  xmlSchemaFreeValidCtxt (qsf_context);
92  xmlSchemaFree (qsf_schema);
93  g_free (schema_path);
94  if (result == 0)
95  {
96  return TRUE;
97  }
98  return FALSE;
99 }
GList** qsf_map_prepare_list ( GList **  maps)

Prepare the default list of maps.

Prepend the default maps to the supplied GList.

The GList remains the property of the caller.

Todo:
Automate this once map support is stable

Definition at line 167 of file qsf-backend.c.

168 {
169  /* Add new map filenames here. */
171  *maps = g_list_prepend (*maps, "pilot-qsf-GnuCashInvoice.xml");
172  *maps = g_list_prepend (*maps, "pilot-qsf-gncCustomer.xml");
173  return maps;
174 }
void qsf_node_foreach ( xmlNodePtr  parent,
QsfNodeCB  cb,
struct QsfNodeIterate qsfiter,
QsfParam params 
)
Iterate over the children of the parent node.

Only iterates over the immediate children of the parent - this function is not recursive.

Definition at line 116 of file qsf-xml.c.

118 {
119  xmlNodePtr cur_node;
120 
121  if (!parent)
122  return;
123  g_return_if_fail (params);
124  g_return_if_fail (qsfiter->ns);
125  qsfiter->fcn = &cb;
126  for (cur_node = parent->children; cur_node != NULL;
127  cur_node = cur_node->next)
128  {
129  cb (cur_node, qsfiter->ns, params);
130  }
131 }
xmlDocPtr qsf_object_convert ( xmlDocPtr  mapDoc,
xmlNodePtr  qsf_root,
QsfParam params 
)

Convert between QSF objects.

This is the main workhorse of the conversion between QSF objects using maps.

Parameters
mapDocThe map document, parsed by libxml2.
qsf_rootThe top node of the QSF object to be converted using the map.
paramsThe QSF backend parameters.

Each calculation in the map is performed over the child nodes of the object tree. A new xmlDoc is created and this is made available to QOF to be loaded into the book.

Definition at line 954 of file qsf-xml-map.c.

956 {
957  /* mapDoc : map document. qsf_root: incoming QSF root node. */
958  struct QsfNodeIterate qsfiter;
959  xmlDocPtr output_doc;
960  xmlNode *cur_node;
961  xmlNode *map_root, *output_root;
962 
963  g_return_val_if_fail ((mapDoc && qsf_root && params), NULL);
964  ENTER (" root=%s", qsf_root->name);
965  /* prepare the intermediary document */
966  qsfiter.ns = params->qsf_ns;
967  output_doc = xmlNewDoc (BAD_CAST QSF_XML_VERSION);
968  output_root = xmlNewNode (NULL, BAD_CAST QSF_ROOT_TAG);
969  xmlDocSetRootElement (output_doc, output_root);
970  xmlSetNs (output_root, params->qsf_ns);
971  params->output_node = xmlNewChild (output_root, params->qsf_ns,
972  BAD_CAST QSF_BOOK_TAG, NULL);
973  xmlNewProp (params->output_node, BAD_CAST QSF_BOOK_COUNT,
974  BAD_CAST "1");
975  /* parse the incoming QSF */
976  qsf_book_node_handler (qsf_root->children->next, params->qsf_ns,
977  params);
978  /* parse the map and calculate the values */
979  map_root = xmlDocGetRootElement (mapDoc);
980  params->foreach_limit = 0;
981  qsfiter.ns = params->map_ns;
982  /* sets qof_foreach iterator, defines and defaults. */
983  qsf_node_foreach (map_root, qsf_map_top_node_handler, &qsfiter, params);
984  /* identify the entities of iterator type. */
985  qsfiter.ns = params->qsf_ns;
986  qsf_node_foreach (qsf_root->children->next, iterator_cb, &qsfiter,
987  params);
988  PINFO (" counted %d records", params->foreach_limit);
989  params->count = 0;
990  for (cur_node = map_root->children; cur_node != NULL;
991  cur_node = cur_node->next)
992  {
993  params->convert_node = cur_node;
994  if (qsf_is_element (cur_node, params->map_ns, MAP_OBJECT_TAG))
995  {
996  gint i;
997 
998  params->lister = NULL;
999  PINFO (" found an object tag. starting calculation");
1000  /* cur_node describes the target object */
1001  if (!qof_class_is_registered (BAD_CAST
1002  xmlGetProp (cur_node, MAP_TYPE_ATTR)))
1003  {
1004  continue;
1005  }
1006  qsf_add_object_tag (params, params->count);
1007  params->count++;
1008  qsfiter.ns = params->map_ns;
1009  PINFO (" params->foreach_limit=%d", params->foreach_limit);
1010  for (i = -1; i < params->foreach_limit; i++)
1011  {
1012  qsf_node_foreach (cur_node, qsf_map_object_handler,
1013  &qsfiter, params);
1014  params->qsf_object_list =
1015  g_list_next (params->qsf_object_list);
1016  params->count++;
1017  }
1018  }
1019  }
1020  params->file_type = OUR_QSF_OBJ;
1021  /* use for debugging */
1022  xmlSaveFormatFileEnc ("-", output_doc, "UTF-8", 1);
1023  LEAVE (" ");
1024  return output_doc;
1025 }
void qsf_object_node_handler ( xmlNodePtr  child,
xmlNsPtr  qsf_ns,
QsfParam params 
)
Despite the name, this function handles the QSF object book 

tag AND the object tags.

Used to parse object and map files.

Definition at line 385 of file qsf-xml.c.

387 {
388  struct QsfNodeIterate qsfiter;
389  QsfObject *object_set;
390  gchar *tail, *object_count_s;
391  gint64 c;
392 
393  g_return_if_fail (child != NULL);
394  g_return_if_fail (qsf_ns != NULL);
395  params->qsf_ns = qsf_ns;
396  if (qsf_is_element (child, qsf_ns, QSF_OBJECT_TAG))
397  {
398  params->qsf_parameter_hash = NULL;
399  c = 0;
400  object_set = g_new (QsfObject, 1);
401  params->object_set = object_set;
402  object_set->object_count = 0;
403  object_set->parameters =
404  g_hash_table_new (g_str_hash, g_str_equal);
405  object_set->object_type = ((gchar *) xmlGetProp (child,
406  BAD_CAST QSF_OBJECT_TYPE));
407  object_count_s = ((gchar *) xmlGetProp (child,
408  BAD_CAST QSF_OBJECT_COUNT));
409  if (object_count_s)
410  {
411  c = (gint64) strtol (object_count_s, &tail, 0);
412  object_set->object_count = (gint) c;
413  g_free (object_count_s);
414  }
415  params->qsf_object_list =
416  g_list_prepend (params->qsf_object_list, object_set);
417  qsfiter.ns = qsf_ns;
418  params->qsf_parameter_hash = object_set->parameters;
419  qsf_node_foreach (child, qsf_parameter_handler, &qsfiter, params);
420  }
421 }
void qsf_object_validation_handler ( xmlNodePtr  child,
xmlNsPtr  ns,
QsfValidator valid 
)

Checks all incoming objects for QOF registration.

Sums all existing objects in the QSF and counts the number of those objects that are also registered with QOF in the host application.

Definition at line 134 of file qsf-xml.c.

136 {
137  xmlNodePtr cur_node;
138  xmlChar *object_declaration;
139  guint count;
140  QsfStatus type;
141  gboolean is_registered;
142 
143  count = 0;
144  type = QSF_NO_OBJECT;
145  is_registered = FALSE;
146  for (cur_node = child->children; cur_node != NULL;
147  cur_node = cur_node->next)
148  {
149  if (qsf_is_element (cur_node, ns, QSF_OBJECT_TAG))
150  {
151  object_declaration =
152  xmlGetProp (cur_node, BAD_CAST QSF_OBJECT_TYPE);
153  is_registered = qof_class_is_registered (object_declaration);
154  if (is_registered)
155  {
156  type = QSF_REGISTERED_OBJECT;
157  }
158  else
159  {
160  type = QSF_DEFINED_OBJECT;
161  }
162  xmlFree (object_declaration);
163  count = g_hash_table_size (valid->object_table);
164  g_hash_table_insert (valid->object_table, object_declaration,
165  GINT_TO_POINTER (type));
166  /* if insert was successful - i.e. object is unique so far */
167  if (g_hash_table_size (valid->object_table) > count)
168  {
169  valid->valid_object_count++;
170  if (is_registered)
171  {
172  valid->qof_registered_count++;
173  }
174  }
175  }
176  }
177 }
gint qsf_strings_equal ( const xmlChar *  node_name,
gchar *  tag_name 
)

shorthand function

This may look repetitive but each one is used separately as well as in a block.

Definition at line 45 of file qsf-xml.c.

46 {
47  if (0 == qsf_compare_tag_strings (node_name, tag_name))
48  {
49  return 1;
50  }
51  return 0;
52 }
void qsf_valid_foreach ( xmlNodePtr  parent,
QsfValidCB  cb,
struct QsfNodeIterate qsfiter,
QsfValidator valid 
)
Validate the children of the parent node.
Note
Slightly different to qsf_node_foreach because the validation can be run without qsf_param being initialized.

Definition at line 102 of file qsf-xml.c.

104 {
105  xmlNodePtr cur_node;
106 
107  qsfiter->v_fcn = &cb;
108  for (cur_node = parent->children; cur_node != NULL;
109  cur_node = cur_node->next)
110  {
111  cb (cur_node, qsfiter->ns, valid);
112  }
113 }
KvpValue* string_to_kvp_value ( const gchar *  content,
KvpValueType  type 
)

Convert a string value into KvpValue.

Partner to kvp_value_to_string. Given the type of KvpValue required, attempts to convert the string into that type of value.

Parameters
contentA string representation of the value, ideally as output by kvp_value_to_string.
typeKvpValueType of the intended KvpValue
Returns
KvpValue* or NULL on failure.
Todo:
reconcile the duplication with the QSF version

Definition at line 1223 of file qsf-backend.c.

1224 {
1225  gchar *tail;
1226  gint64 cm_i64;
1227  gdouble cm_double;
1228  QofNumeric cm_numeric;
1229  GUID *cm_guid;
1230 #ifndef QOF_DISABLE_DEPRECATED
1231  struct tm kvp_time;
1232  time_t kvp_time_t;
1233  Timespec cm_date;
1234 #endif
1235 
1236  switch (type)
1237  {
1238  case KVP_TYPE_GINT64:
1239  {
1240  errno = 0;
1241  cm_i64 = strtoll (content, &tail, 0);
1242  if (errno == 0)
1243  {
1244  return kvp_value_new_gint64 (cm_i64);
1245  }
1246  break;
1247  }
1248  case KVP_TYPE_DOUBLE:
1249  {
1250  errno = 0;
1251  cm_double = strtod (content, &tail);
1252  if (errno == 0)
1253  return kvp_value_new_double (cm_double);
1254  break;
1255  }
1256  case KVP_TYPE_NUMERIC:
1257  {
1258  qof_numeric_from_string (content, &cm_numeric);
1259  return kvp_value_new_numeric (cm_numeric);
1260  break;
1261  }
1262  case KVP_TYPE_STRING:
1263  {
1264  return kvp_value_new_string (content);
1265  break;
1266  }
1267  case KVP_TYPE_GUID:
1268  {
1269  cm_guid = g_new0 (GUID, 1);
1270  if (TRUE == string_to_guid (content, cm_guid))
1271  return kvp_value_new_guid (cm_guid);
1272  break;
1273  }
1274  case KVP_TYPE_TIME :
1275  {
1276  QofDate *qd;
1277  QofTime *qt;
1278  KvpValue *retval;
1279 
1280  qd = qof_date_parse (content, QOF_DATE_FORMAT_UTC);
1281  if(qd)
1282  {
1283  qt = qof_date_to_qtime (qd);
1284  retval = kvp_value_new_time (qt);
1285  qof_date_free (qd);
1286  qof_time_free (qt);
1287  return retval;
1288  }
1289  else
1290  PERR (" failed to parse date");
1291  }
1292 #ifndef QOF_DISABLE_DEPRECATED
1293  case KVP_TYPE_TIMESPEC:
1294  {
1295  strptime (content, QSF_XSD_TIME, &kvp_time);
1296  kvp_time_t = mktime (&kvp_time);
1297  timespecFromTime_t (&cm_date, kvp_time_t);
1298  return kvp_value_new_timespec (cm_date);
1299  break;
1300  }
1301 #endif
1302  case KVP_TYPE_BOOLEAN :
1303  {
1304  gboolean val;
1305  val = qof_util_bool_to_int (content);
1306  return kvp_value_new_boolean (val);
1307  }
1308  case KVP_TYPE_BINARY:
1309 // return kvp_value_new_binary(value->value.binary.data,
1310 // value->value.binary.datasize);
1311  break;
1312  case KVP_TYPE_GLIST:
1313 // return kvp_value_new_glist(value->value.list);
1314  break;
1315  case KVP_TYPE_FRAME:
1316 // return kvp_value_new_frame(value->value.frame);
1317  break;
1318  }
1319  return NULL;
1320 }