int
removeAVUMetadataFromKVPairs( rsComm_t *rsComm, char *objName, char *inObjType,
keyValPair_t *kVP ) {
char objType[10];
if ( strcmp( inObjType, "-1" ) ) {
snprintf( objType, sizeof( objType ), "%s", inObjType );
}
else {
int status = getObjType( rsComm, objName, objType );
if ( status < 0 ) {
return status;
}
}
for ( int i = 0; i < kVP->len ; i++ ) {
/* Call rsModAVUMetadata to call chlAddAVUMetadata.
rsModAVUMetadata connects to the icat-enabled server if the
local host isn't.
*/
modAVUMetadataInp_t modAVUMetadataInp;
modAVUMetadataInp.arg0 = "rm";
modAVUMetadataInp.arg1 = objType;
modAVUMetadataInp.arg2 = objName;
modAVUMetadataInp.arg3 = kVP->keyWord[i];
modAVUMetadataInp.arg4 = kVP->value[i];
modAVUMetadataInp.arg5 = "";
int status = rsModAVUMetadata( rsComm, &modAVUMetadataInp );
if ( status < 0 ) {
return status;
}
}
return 0;
}
int
removeAVUMetadataFromKVPairs (rsComm_t *rsComm, char *objName, char *inObjType,
keyValPair_t *kVP)
{
int i,j;
char objType[10];
modAVUMetadataInp_t modAVUMetadataInp;
if (strcmp(inObjType,"-1")) {
strcpy(objType,inObjType);
}
else {
i = getObjType(rsComm, objName,objType);
if (i < 0)
return(i);
}
modAVUMetadataInp.arg0 = "rm";
for (i = 0; i < kVP->len ; i++) {
/* Call rsModAVUMetadata to call chlAddAVUMetadata.
rsModAVUMetadata connects to the icat-enabled server if the
local host isn't.
*/
modAVUMetadataInp.arg1 = objType;
modAVUMetadataInp.arg2 = objName;
modAVUMetadataInp.arg3 = kVP->keyWord[i];
modAVUMetadataInp.arg4 = kVP->value[i];
modAVUMetadataInp.arg5 = "";
j = rsModAVUMetadata (rsComm, &modAVUMetadataInp);
if (j < 0)
return(j);
}
return(0);
}
/**
* \fn msiApplyDCMetadataTemplate(msParam_t* inpParam, msParam_t* outParam, ruleExecInfo_t *rei)
*
* \brief This microservice adds 15 empty Dublin Core Metadata fields to an object or collection.
*
* \module framework
*
* \since pre-2.1
*
* \author Antoine de Torcy
* \date 2008-04-04
*
* \usage See clients/icommands/test/rules3.0/
*
* \param[in] inpParam - a STR_MS_T containing the target object's path
* \param[out] outParam - an INT_MS_T containing the status
* \param[in,out] rei - The RuleExecInfo structure that is automatically
* handled by the rule engine. The user does not include rei as a
* parameter in the rule invocation.
*
* \DolVarDependence none
* \DolVarModified none
* \iCatAttrDependence none
* \iCatAttrModified none
* \sideeffect none
*
* \return integer
* \retval 0 on success
* \pre none
* \post none
* \sa none
**/
int
msiApplyDCMetadataTemplate(msParam_t* inpParam, msParam_t* outParam, ruleExecInfo_t *rei)
{
char *objPath;
char objType[NAME_LEN];
modAVUMetadataInp_t modAVUMetadataInp;
int i, status;
/* Dublin Core metadata elements */
char *elements[]={"DC.Title", "DC.Creator", "DC.Subject", "DC.Description", "DC.Publisher", "DC.Contributor", "DC.Date", "DC.Type", "DC.Format", "DC.Identifier", "DC.Source", "DC.Language", "DC.Relation", "DC.Coverage", "DC.Rights" };
/* For testing mode when used with irule --test */
RE_TEST_MACRO (" Calling msiApplyDCMetadataTemplate")
/* microservice check */
if (rei == NULL || rei->rsComm == NULL) {
rodsLog (LOG_ERROR, "msiApplyDCMetadataTemplate: input rei or rsComm is NULL");
return (SYS_INTERNAL_NULL_INPUT_ERR);
}
/* Check for proper input */
if ((objPath = parseMspForStr(inpParam)) == NULL) {
rodsLog (LOG_ERROR, "msiApplyDCMetadataTemplate: input parameter is NULL");
return (USER__NULL_INPUT_ERR);
}
/* Get type of target object */
status = getObjType(rei->rsComm, objPath, objType);
/* Add each DC element */
for (i=0; i<15; i++) {
/* set up our modAVU input */
memset (&modAVUMetadataInp, 0, sizeof(modAVUMetadataInp_t));
modAVUMetadataInp.arg0 = "add";
modAVUMetadataInp.arg1 = objType;
modAVUMetadataInp.arg2 = objPath;
modAVUMetadataInp.arg3 = elements[i]; /* attribute */
modAVUMetadataInp.arg4 = " "; /* value, cannot be empty */
modAVUMetadataInp.arg5 = ""; /* units, can be empty */
/* add metadata AVU triplet */
status = rsModAVUMetadata (rei->rsComm, &modAVUMetadataInp);
}
/* return operation status through outParam */
fillIntInMsParam (outParam, status);
return(status);
}
int writeICatUserInfo( char *userName, char *attr, char *value, rsComm_t *rsComm ) {
modAVUMetadataInp_t modAVUMetadataInp;
modAVUMetadataInp.arg0 = "set";
modAVUMetadataInp.arg1 = "-u";
modAVUMetadataInp.arg2 = userName;
modAVUMetadataInp.arg3 = attr;
modAVUMetadataInp.arg4 = value;
modAVUMetadataInp.arg5 = "";
return rsModAVUMetadata( rsComm, &modAVUMetadataInp );
}
int msiset_avu(
msParam_t* _item_type,
msParam_t* _item_name,
msParam_t* _attr_name,
msParam_t* _attr_val,
msParam_t* _attr_unit,
ruleExecInfo_t* _rei ) {
char *it_str = parseMspForStr( _item_type );
if( !it_str ) {
return SYS_INVALID_INPUT_PARAM;
}
char *in_str = parseMspForStr( _item_name );
if( !in_str ) {
return SYS_INVALID_INPUT_PARAM;
}
char *an_str = parseMspForStr( _attr_name );
if( !an_str ) {
return SYS_INVALID_INPUT_PARAM;
}
char *av_str = parseMspForStr( _attr_val );
if( !av_str ) {
return SYS_INVALID_INPUT_PARAM;
}
char *au_str = parseMspForStr( _attr_unit );
if( !au_str ) {
return SYS_INVALID_INPUT_PARAM;
}
char op[] = "set";
modAVUMetadataInp_t avuOp;
memset(&avuOp, 0, sizeof(avuOp));
avuOp.arg0 = op;
avuOp.arg1 = it_str;
avuOp.arg2 = in_str;
avuOp.arg3 = an_str;
avuOp.arg4 = av_str;
avuOp.arg5 = au_str;
_rei->status = rsModAVUMetadata(_rei->rsComm, &avuOp);
return _rei->status;
}
int
addAVUMetadataFromKVPairs( rsComm_t *rsComm, char *objName, char *inObjType,
keyValPair_t *kVP ) {
char objType[10];
if ( strcmp( inObjType, "-1" ) ) {
if ( strlen( inObjType ) >= sizeof( objType ) ) {
rodsLog( LOG_ERROR, "inObjType: [%s] must be fewer than %ju characters", inObjType, ( uintmax_t )sizeof( objType ) );
return SYS_INVALID_INPUT_PARAM;
}
strcpy( objType, inObjType );
}
else {
int status = getObjType( rsComm, objName, objType );
if ( status < 0 ) {
return status;
}
}
for ( int i = 0; i < kVP->len ; i++ ) {
/* Call rsModAVUMetadata to call chlAddAVUMetadata.
rsModAVUMetadata connects to the icat-enabled server if the
local host isn't.
*/
modAVUMetadataInp_t modAVUMetadataInp;
memset( &modAVUMetadataInp, 0, sizeof( modAVUMetadataInp ) );
modAVUMetadataInp.arg0 = "add";
modAVUMetadataInp.arg1 = objType;
modAVUMetadataInp.arg2 = objName;
modAVUMetadataInp.arg3 = kVP->keyWord[i];
modAVUMetadataInp.arg4 = kVP->value[i];
modAVUMetadataInp.arg5 = "";
int status = rsModAVUMetadata( rsComm, &modAVUMetadataInp );
if ( status < 0 ) {
return status;
}
}
return 0;
}
/**
* Creates the specified metadata object on the given object path
**/
bool createMetadataOnObject(char * objPath, char * attributeName, char * attributeValue, char * attributeUnit, ruleExecInfo_t* rei) {
rodsLog( LOG_NOTICE, "Calling createMetadataOnObject()\n");
// Metadata control block
modAVUMetadataInp_t modAVUMetadataInp;
memset( &modAVUMetadataInp, 0, sizeof( modAVUMetadataInp_t ) );
modAVUMetadataInp.arg0 = (char*) "add";
modAVUMetadataInp.arg1 = (char*) "-d";
modAVUMetadataInp.arg2 = objPath;
modAVUMetadataInp.arg3 = attributeName;
modAVUMetadataInp.arg4 = attributeValue;
modAVUMetadataInp.arg5 = attributeUnit;
int status = rsModAVUMetadata( rei->rsComm, &modAVUMetadataInp );
if ( status < 0 ) {
irods::log( ERROR( status, "msiobjput_mdmanifest failed." ) );
return false;
}
return true;
}
/**
* \fn msiExtractNaraMetadata (ruleExecInfo_t *rei)
*
* \brief This microservice extracts NARA style metadata from a local configuration file.
*
* \module core
*
* \since pre-2.1
*
* \author DICE
* \date 2007
*
* \usage See clients/icommands/test/rules3.0/
*
* \param[in,out] rei - The RuleExecInfo structure that is automatically
* handled by the rule engine. The user does not include rei as a
* parameter in the rule invocation.
*
* \DolVarDependence none
* \DolVarModified none
* \iCatAttrDependence none
* \iCatAttrModified none
* \sideeffect none
*
* \return integer
* \retval 0 on success
* \pre none
* \post none
* \sa none
**/
int
msiExtractNaraMetadata( ruleExecInfo_t *rei ) {
FILE *fp;
char str[500];
char *substring;
int counter;
int flag;
char attr[100];
char value[500];
modAVUMetadataInp_t modAVUMetadataInp;
int status;
/* specify the location of the metadata file here */
char metafile[MAX_NAME_LEN];
snprintf( metafile, MAX_NAME_LEN, "%-s/reConfigs/%-s", getConfigDir(),
NARA_META_DATA_FILE );
if ( ( fp = fopen( metafile, "r" ) ) == NULL ) {
rodsLog( LOG_ERROR,
"msiExtractNaraMetadata: Cannot open the metadata file %s.", metafile );
return UNIX_FILE_OPEN_ERR;
}
memset( &modAVUMetadataInp, 0, sizeof( modAVUMetadataInp ) );
modAVUMetadataInp.arg0 = "add";
while ( !feof( fp ) ) {
counter = 0;
flag = 0;
if ( fgets( str, 500, fp ) ) {
substring = strtok( str, "|" );
while ( substring != NULL ) {
if ( flag == 0 && strcmp( substring, rei->doi->objPath ) == 0 ) {
flag = 2;
}
if ( counter == 1 ) {
if ( strlen( substring ) >= sizeof( attr ) ) {
rodsLog( LOG_ERROR,
"attr: [%s] is too long for attr, which may only be %ju characters in length.",
( uintmax_t )sizeof( attr ) );
}
snprintf( attr, sizeof( attr ), "%s", substring );
}
if ( flag == 2 && counter == 2 ) {
if ( strlen( substring ) >= sizeof( value ) ) {
rodsLog( LOG_ERROR,
"value: [%s] is too long for value, which may only be %ju characters in length.",
( uintmax_t )sizeof( value ) );
}
snprintf( value, sizeof( value ), "%s", substring );
/*Call the function to insert metadata here.*/
modAVUMetadataInp.arg1 = "-d";
modAVUMetadataInp.arg2 = rei->doi->objPath;
modAVUMetadataInp.arg3 = attr;
modAVUMetadataInp.arg4 = value;
modAVUMetadataInp.arg5 = "";
status = rsModAVUMetadata( rei->rsComm, &modAVUMetadataInp );
if ( status < 0 ) {
irods::log( ERROR( status, "rsModAVUMetadata failed." ) );
}
rodsLog( LOG_DEBUG, "msiExtractNaraMetadata: %s:%s", attr, value );
}
substring = strtok( NULL, "|" );
counter++;
}
}
}
fclose( fp );
return 0;
}
int
msiLoadMetadataFromXml(msParam_t *targetObj, msParam_t *xmlObj, ruleExecInfo_t *rei)
{
/* for parsing msParams and to open iRODS objects */
dataObjInp_t xmlDataObjInp, *myXmlDataObjInp;
dataObjInp_t targetObjInp, *myTargetObjInp;
int xmlObjID;
/* for getting size of objects to read from */
rodsObjStat_t *rodsObjStatOut = NULL;
/* for reading from iRODS objects */
openedDataObjInp_t openedDataObjInp;
bytesBuf_t *xmlBuf;
/* misc. to avoid repeating rei->rsComm */
rsComm_t *rsComm;
/* for xml parsing */
xmlDocPtr doc;
/* for XPath evaluation */
xmlXPathContextPtr xpathCtx;
xmlXPathObjectPtr xpathObj;
xmlChar xpathExpr[] = "//AVU";
xmlNodeSetPtr nodes;
int avuNbr, i;
/* for new AVU creation */
modAVUMetadataInp_t modAVUMetadataInp;
int max_attr_len = 2700;
char attrStr[max_attr_len];
/********************************* USUAL INIT PROCEDURE **********************************/
/* For testing mode when used with irule --test */
RE_TEST_MACRO (" Calling msiLoadMetadataFromXml")
/* Sanity checks */
if (rei == NULL || rei->rsComm == NULL)
{
rodsLog (LOG_ERROR, "msiLoadMetadataFromXml: input rei or rsComm is NULL.");
return (SYS_INTERNAL_NULL_INPUT_ERR);
}
rsComm = rei->rsComm;
/********************************** RETRIEVE INPUT PARAMS **************************************/
/* Get path of target object */
rei->status = parseMspForDataObjInp (targetObj, &targetObjInp, &myTargetObjInp, 0);
if (rei->status < 0)
{
rodsLog (LOG_ERROR, "msiLoadMetadataFromXml: input targetObj error. status = %d", rei->status);
return (rei->status);
}
/* Get path of XML document */
rei->status = parseMspForDataObjInp (xmlObj, &xmlDataObjInp, &myXmlDataObjInp, 0);
if (rei->status < 0)
{
rodsLog (LOG_ERROR, "msiLoadMetadataFromXml: input xmlObj error. status = %d", rei->status);
return (rei->status);
}
/******************************** OPEN AND READ FROM XML OBJECT ********************************/
/* Open XML file */
if ((xmlObjID = rsDataObjOpen(rsComm, &xmlDataObjInp)) < 0)
{
rodsLog (LOG_ERROR, "msiLoadMetadataFromXml: Cannot open XML data object. status = %d", xmlObjID);
return (xmlObjID);
}
/* Get size of XML file */
rei->status = rsObjStat (rsComm, &xmlDataObjInp, &rodsObjStatOut);
if (rei->status < 0 || !rodsObjStatOut)
{
rodsLog (LOG_ERROR, "msiLoadMetadataFromXml: Cannot stat XML data object. status = %d", rei->status);
return (rei->status);
}
/* xmlBuf init */
/* memory for xmlBuf->buf is allocated in rsFileRead() */
xmlBuf = (bytesBuf_t *) malloc (sizeof (bytesBuf_t));
memset (xmlBuf, 0, sizeof (bytesBuf_t));
/* Read XML file */
memset (&openedDataObjInp, 0, sizeof (openedDataObjInp_t));
openedDataObjInp.l1descInx = xmlObjID;
openedDataObjInp.len = (int)rodsObjStatOut->objSize;
rei->status = rsDataObjRead (rsComm, &openedDataObjInp, xmlBuf);
/* Make sure that the result is null terminated */
if (strlen((char*)xmlBuf->buf) > (size_t)openedDataObjInp.len)
{
((char*)xmlBuf->buf)[openedDataObjInp.len-1]='\0';
}
/* Close XML file */
rei->status = rsDataObjClose (rsComm, &openedDataObjInp);
/* cleanup */
freeRodsObjStat (rodsObjStatOut);
/******************************** PARSE XML DOCUMENT ********************************/
xmlSubstituteEntitiesDefault(1);
xmlLoadExtDtdDefaultValue = 1;
/* Parse xmlBuf.buf into an xmlDocPtr */
doc = xmlParseDoc((xmlChar*)xmlBuf->buf);
/* Create xpath evaluation context */
xpathCtx = xmlXPathNewContext(doc);
if(xpathCtx == NULL)
{
rodsLog (LOG_ERROR, "msiLoadMetadataFromXml: Unable to create new XPath context.");
xmlFreeDoc(doc);
return(-1);
}
/* Evaluate xpath expression */
xpathObj = xmlXPathEvalExpression(xpathExpr, xpathCtx);
if(xpathObj == NULL)
{
rodsLog (LOG_ERROR, "msiLoadMetadataFromXml: Unable to evaluate XPath expression \"%s\".", xpathExpr);
xmlXPathFreeContext(xpathCtx);
xmlFreeDoc(doc);
return(-1);
}
/* How many AVU nodes did we get? */
if ((nodes = xpathObj->nodesetval) != NULL)
{
avuNbr = nodes->nodeNr;
}
else
{
avuNbr = 0;
}
/******************************** CREATE AVU TRIPLETS ********************************/
/* Add a new AVU for each node. It's ok to process the nodes in forward order since we're not modifying them */
for(i = 0; i < avuNbr; i++)
{
if (nodes->nodeTab[i])
{
// /* temporary: Add index number to avoid duplicating attribute names */
// memset(attrStr, '\0', MAX_NAME_LEN);
// snprintf(attrStr, MAX_NAME_LEN - 1, "%04d: %s", i+1, (char*)xmlNodeGetContent(getChildNodeByName(nodes->nodeTab[i], "Attribute")) );
/* Truncate if needed. No prefix. */
memset(attrStr, '\0', max_attr_len);
snprintf(attrStr, max_attr_len - 1, "%s", (char*)xmlNodeGetContent(getChildNodeByName(nodes->nodeTab[i], "Attribute")) );
/* init modAVU input */
memset (&modAVUMetadataInp, 0, sizeof(modAVUMetadataInp_t));
modAVUMetadataInp.arg0 = "add";
modAVUMetadataInp.arg1 = "-d";
/* Use target object if one was provided, otherwise look for it in the XML doc */
if (myTargetObjInp->objPath != NULL && strlen(myTargetObjInp->objPath) > 0)
{
modAVUMetadataInp.arg2 = myTargetObjInp->objPath;
}
else
{
modAVUMetadataInp.arg2 = xmlURIUnescapeString((char*)xmlNodeGetContent(getChildNodeByName(nodes->nodeTab[i], "Target")),
MAX_NAME_LEN, NULL);
}
modAVUMetadataInp.arg3 = attrStr;
modAVUMetadataInp.arg4 = (char*)xmlNodeGetContent(getChildNodeByName(nodes->nodeTab[i], "Value"));
modAVUMetadataInp.arg5 = (char*)xmlNodeGetContent(getChildNodeByName(nodes->nodeTab[i], "Unit"));
/* invoke rsModAVUMetadata() */
rei->status = rsModAVUMetadata (rsComm, &modAVUMetadataInp);
}
}
/************************************** WE'RE DONE **************************************/
/* cleanup of all xml parsing stuff */
xmlFreeDoc(doc);
xmlCleanupParser();
return (rei->status);
}
