zOPER_EXPORT zSHORT OPERATION zwTZCMRPTD_CloseRefresh( zVIEW vSubtask ) { zVIEW vView; if ( GetViewByName( &vView, "TZCMRPTO", vSubtask, zLEVEL_TASK ) > 0 ) DropObjectInstance( vView ); if ( GetViewByName( &vView, "TZCMRPTO_New", vSubtask, zLEVEL_TASK ) > 0 ) DropObjectInstance( vView ); return( 0 ); } // zwTZCMRPTD_CloseRefresh
///////////////////////////////////////////////////////////////////////////// // // OPERATION: zwTZCMRPTD_DropViewForAudittrail // // ///////////////////////////////////////////////////////////////////////////// zOPER_EXPORT zSHORT /*DIALOG */ OPERATION zwTZCMRPTD_DropViewForAudittrail( zVIEW vSubtask ) { zVIEW vTZBRAUDO; if ( GetViewByName( &vTZBRAUDO, "TZBRAUDO", vSubtask, zLEVEL_TASK ) > 0 ) DropObjectInstance( vTZBRAUDO ); if ( GetViewByName( &vTZBRAUDO, "TZBRAU2O", vSubtask, zLEVEL_TASK ) > 0 ) DropObjectInstance( vTZBRAUDO ); if ( GetViewByName( &vTZBRAUDO, "TZBRAU3O", vSubtask, zLEVEL_TASK ) > 0 ) DropObjectInstance( vTZBRAUDO ); return( 0 ); } // zwTZCMRPTD_DropViewForAudittrail
zOPER_EXPORT zSHORT OPERATION zwTZCMRPTD_RefreshAllComponents( zVIEW vSubtask ) { zVIEW vTZCMLPLO; zVIEW vTZCMRPTO; zVIEW vCompList; zCHAR szName[ 33 ]; zCHAR szERR_Msg[ 254 ]; if ( GetViewByName( &vTZCMRPTO, "TZCMRPTO", vSubtask, zLEVEL_TASK ) > 0 ) DropObjectInstance( vTZCMRPTO ); if ( zwTZCMLPLD_OptionRefreshFromRepo( vSubtask, &vTZCMLPLO, szName, zRefreshLPLR ) < 0 ) { return( -1 ); } zstrcpy( szERR_Msg, "Project '" ); GetStringFromAttribute( &szERR_Msg[ zstrlen( szERR_Msg ) ], vTZCMLPLO, "LPLR", "Name" ); zstrcat( szERR_Msg, "' has been successfully refreshed." ); MessageSend( vSubtask, "CM00279", "Configuration Management", szERR_Msg, zMSGQ_OBJECT_CONSTRAINT_INFORMATION, zBEEP ); if ( GetViewByName( &vCompList, "CompList", vSubtask, zLEVEL_TASK ) >= 0 ) RefreshWindow( vCompList ); return( 0 ); } // zwTZCMRPTD_RefreshAllComponents
//./ ADD NAME=oTZCMQSYO_ActivateREPO_Enqueue // Source Module=tzcmrepo.c //////////////////////////////////////////////// // // OPERATION: oTZCMQSYO_ActivateREPO_Enqueue // // PURPOSE: Checks for REPOS_Enqueue via the SystemAdmin. // // PARAMETERS: vTZCMREPO - A pointer to the return Repository Enqueue view // vSubtask - A qualifying view for the Activation // // RETURNS: >= 0 - TZCMREPO activated successfully // -1 - Error encountered during activation // //////////////////////////////////////////////// //./ END + 2 zOPER_EXPORT zSHORT OPERATION oTZCMQSYO_ActivateREPO_Enqueue( zPVIEW vTZCMQSYO, zVIEW vSubtask ) { zVIEW vKZDBHQUA; zSHORT nRC; if ( GetViewByName( &vKZDBHQUA, "KZDBHQUA", vSubtask, zLEVEL_TASK ) < 0 ) { if ( ActivateEmptyObjectInstance( &vKZDBHQUA, "KZDBHQUA", vSubtask, zSINGLE ) >= 0 ) { SetNameForView( vKZDBHQUA, "KZDBHQUA", vSubtask, zLEVEL_TASK ); CreateEntity( vKZDBHQUA, "EntitySpec", zPOS_AFTER ); CreateEntity( vKZDBHQUA, "QualAttrib", zPOS_AFTER ); } else return( -1 ); } SetAttributeFromString( vKZDBHQUA, "EntitySpec", "EntityName", "SysEnqueue" ); SetAttributeFromString( vKZDBHQUA, "QualAttrib", "EntityName", "SysEnqueue" ); SetAttributeFromString( vKZDBHQUA, "QualAttrib", "AttributeName", "TimeStamp" ); SetAttributeFromString( vKZDBHQUA, "QualAttrib", "Oper", ">" ); SetAttributeFromString( vKZDBHQUA, "QualAttrib", "Value", "19000101000000000" ); nRC = ActivateObjectInstance( vTZCMQSYO, "TZCMQSYO", vSubtask, vKZDBHQUA, zLEVEL_TASK | zMULTIPLE ); DropObjectInstance( vKZDBHQUA ); return( nRC ); }
///////////////////////////////////////////////////////////////////////////// // // OPERATION: zwTZHKEYAD_SwitchLPLR // // PURPOSE: This Entry switches to a new LPLR. All named views to // the current LPLR file List must be droped first. // ///////////////////////////////////////////////////////////////////////////// zOPER_EXPORT zSHORT OPERATION zwTZHKEYAD_SwitchLPLR( zVIEW vSubtask ) { zSHORT nRC; zVIEW vKZHKEYSO; // Get Access to current HK Object and prompt for Save. nRC = GetViewByName( &vKZHKEYSO, "KZHKEYSO", vSubtask, zLEVEL_ANY ); if ( nRC > 0 && ObjectInstanceUpdatedFromFile( vKZHKEYSO ) == 1 ) { zCHAR szMsg[ 300 ]; zstrcpy( szMsg, "Do you wish to save current Application Hotkeys?" ); nRC = MessagePrompt( vSubtask, "HK00103", "Hot Keys", szMsg, zBEEP, zBUTTONS_YESNOCANCEL, zRESPONSE_NO, 0 ); if ( nRC == zRESPONSE_CANCEL ) { SetWindowActionBehavior( vSubtask, zWAB_ReturnToTopWindow, "TZHKEYAD", "Application" ); return( 0 ); } else { if ( nRC == zRESPONSE_YES ) zwTZHKEYAD_SaveHK_ForLPLR( vSubtask ); } } // Drop object to force reloading later. DropObjectInstance( vKZHKEYSO ); return( 0 ); }
zOPER_EXPORT zSHORT OPERATION zwTZCMRPTD_RefreshSelComponents( zVIEW vSubtask ) { zVIEW vTZCMLPLO; zVIEW vTZCMRPTO; zVIEW vCompList; zVIEW vTZCMRPTO_New; zCHAR szName[ 33 ]; zCHAR szERR_Msg[ 254 ]; SetNameForView( vSubtask,"TZCM_ChkInWindow", vSubtask, zLEVEL_TASK ); GetViewByName( &vTZCMRPTO, "TZCMRPTO", vSubtask, zLEVEL_TASK ); if ( SetCursorFirstSelectedEntity( vTZCMRPTO, "ReportLine", "" ) < zCURSOR_SET ) { zstrcpy( szERR_Msg, "No Component selected to Refresh." ); MessageSend( vSubtask, "CM00241", "Configuration Management", szERR_Msg, zMSGQ_OBJECT_CONSTRAINT_WARNING, zBEEP ); return( 0 ); } if ( zwTZCMLPLD_OptionRefreshFromRepo( vSubtask, &vTZCMLPLO, szName, zRefreshUserDefined ) < 0 ) { return( -1 ); } GetViewByName( &vTZCMRPTO_New, "TZCMRPTO_New", vSubtask, zLEVEL_TASK ); // if component refreshed? if ( CompareAttributeToInteger( vTZCMRPTO_New, "CPLR", "ComponentRefreshed", 1 ) == 0 ) { zstrcpy( szERR_Msg, "Project '" ); GetStringFromAttribute( &szERR_Msg[ zstrlen( szERR_Msg ) ], vTZCMLPLO, "LPLR", "Name" ); zstrcat( szERR_Msg, "' has been successfully refreshed \nfrom CPLR '" ); zstrcat( szERR_Msg, szName ); zstrcat( szERR_Msg, "'." ); MessageSend( vSubtask, "CM00279", "Configuration Management", szERR_Msg, zMSGQ_OBJECT_CONSTRAINT_INFORMATION, zBEEP ); } if ( GetViewByName( &vTZCMRPTO, "TZCMRPTO", vSubtask, zLEVEL_TASK ) > 0 ) DropObjectInstance( vTZCMRPTO ); // Build new Refresh List if ( zwTZCMLPLD_RefreshUserDefined( vSubtask ) < 1 ) return( -1 ); RefreshWindow( vSubtask ); if ( GetViewByName( &vCompList, "CompList", vSubtask, zLEVEL_TASK ) >= 0 ) RefreshWindow( vCompList ); return( 0 ); } // zwTZCMRPTD_RefreshSelComponents
zOPER_EXPORT zSHORT OPERATION zwTZCMRPTD_LoadAudittrail( zVIEW vSubtask ) { zVIEW vTZCMRPTO; zVIEW vTZBRAUDO; zVIEW vKZDBHQUA; zULONG ulZKey; zCHAR szZKey[18]; zSHORT nRC; if ( GetViewByName( &vTZCMRPTO, "TZCMRPTO", vSubtask, zLEVEL_TASK ) > 0 ) { if ( CheckExistenceOfEntity( vTZCMRPTO, "Z_MetaDef" ) == 0 ) { if ( ActivateEmptyObjectInstance ( &vKZDBHQUA, "KZDBHQUA", vSubtask, zSINGLE ) >= 0 ) { SetNameForView( vKZDBHQUA, "KZDBHQUA", vSubtask, zLEVEL_TASK ); CreateEntity( vKZDBHQUA, "EntitySpec", zPOS_AFTER ); CreateEntity( vKZDBHQUA, "QualAttrib", zPOS_AFTER ); } else return( -1 ); GetIntegerFromAttribute(( zPLONG )&ulZKey, vTZCMRPTO, "Z_MetaDef", "ZKey" ); SetAttributeFromString( vKZDBHQUA, "EntitySpec", "EntityName", "Z_MetaDef" ); SetAttributeFromString( vKZDBHQUA, "QualAttrib", "EntityName", "Z_MetaDef" ); SetAttributeFromString( vKZDBHQUA, "QualAttrib", "AttributeName", "ZKey" ); SetAttributeFromString( vKZDBHQUA, "QualAttrib", "Oper", "=" ); zltoa( ulZKey, szZKey ); SetAttributeFromString( vKZDBHQUA, "QualAttrib", "Value", szZKey ); nRC = ActivateObjectInstance( &vTZBRAUDO, "TZBRAUDO", vSubtask, vKZDBHQUA, zSINGLE | zLEVEL_APPLICATION ); DropObjectInstance( vKZDBHQUA ); if ( CheckExistenceOfEntity( vTZBRAUDO, "AuditTrail" ) == 0 ) SetNameForView( vTZBRAUDO, "TZBRAUDO", vSubtask, zLEVEL_TASK ); else { MessageSend( vSubtask, "CM00299", "Audit Trail:", "There are no AuditTrail-Information for the component in this CPLR.", zMSGQ_OBJECT_CONSTRAINT_INFORMATION, zBEEP ); SetWindowActionBehavior( vSubtask, zWAB_StayOnWindow, 0, 0 ); return( -1 ); } } } else return( -1 ); return( 0 ); }
static zSHORT zwfnTZCMRPTD_LoadNewAudittrail( zVIEW vSubtask, zPVIEW vTZBRAU2O ) { zVIEW vTZCMCPL; zVIEW vKZDBHQUA; zULONG ulZKey; zCHAR szZKey[18]; zSHORT nRC; if ( GetViewByName( &vTZCMCPL, "TZCMCPL", vSubtask, zLEVEL_TASK ) < 0 ) return( -1 ); if ( CheckExistenceOfEntity( vTZCMCPL, "CPLR" ) == zCURSOR_SET ) { if ( ActivateEmptyObjectInstance( &vKZDBHQUA, "KZDBHQUA", vSubtask, zSINGLE ) >= 0 ) { SetNameForView( vKZDBHQUA, "KZDBHQUA", vSubtask, zLEVEL_TASK ); CreateEntity( vKZDBHQUA, "EntitySpec", zPOS_AFTER ); CreateEntity( vKZDBHQUA, "QualAttrib", zPOS_AFTER ); } else return( -1 ); GetIntegerFromAttribute( (zPLONG)&ulZKey, vTZCMCPL, "CPLR", "ZKey" ); SetAttributeFromString( vKZDBHQUA, "EntitySpec", "EntityName", "CPLR" ); SetAttributeFromString( vKZDBHQUA, "QualAttrib", "EntityName", "CPLR" ); SetAttributeFromString( vKZDBHQUA, "QualAttrib", "AttributeName", "ZKey" ); SetAttributeFromString( vKZDBHQUA, "QualAttrib", "Oper", "=" ); zltoa( ulZKey, szZKey ); SetAttributeFromString( vKZDBHQUA, "QualAttrib", "Value", szZKey ); nRC = ActivateObjectInstance( vTZBRAU2O, "TZBRAU2O", vSubtask, vKZDBHQUA, zSINGLE | zLEVEL_APPLICATION ); DropObjectInstance( vKZDBHQUA ); SetNameForView( *vTZBRAU2O, "TZBRAU2O", vSubtask, zLEVEL_TASK ); } else { MessageSend( vSubtask, "CM00299", "Audit Trail:", "There are no Audit Trail Information for a non-repository LPLR.", zMSGQ_OBJECT_CONSTRAINT_WARNING, zBEEP ); SetWindowActionBehavior( vSubtask, zWAB_StayOnWindow, 0, 0 ); return( -1 ); } return( 0 ); } // zwfnTZCMRPTD_LoadNewAudittrail
///////////////////////////////////////////////////////////////////////////// // // OPERATION: zwTZCMRPTD_LoadNewAudittrail // ///////////////////////////////////////////////////////////////////////////// zOPER_EXPORT zSHORT /*DIALOG */ OPERATION zwTZCMRPTD_LoadNewAudittrail( zVIEW vSubtask ) { zVIEW vTZCMCPL; zVIEW vTZBRAU2O; zVIEW vParentWindow; zULONG ulZKey; zULONG ulZKeyCPLR; zCHAR szName[ 33 ]; zCHAR szControlText[40]; GetViewByName( &vTZCMCPL, "TZCMCPL", vSubtask, zLEVEL_TASK ); GetIntegerFromAttribute( (zPLONG) &ulZKey, vTZCMCPL, "CPLR", "ZKey" ); GetStringFromAttribute( szName, vTZCMCPL, "CPLR", "Name" ); if ( GetViewByName( &vTZBRAU2O, "TZBRAU2O", vSubtask, zLEVEL_TASK ) > 0 ) { GetIntegerFromAttribute( (zPLONG) &ulZKeyCPLR, vTZBRAU2O, "CPLR", "ZKey" ); if ( ulZKey == ulZKeyCPLR ) return( 0 ); else DropObjectInstance( vTZBRAU2O ); } if ( zwfnTZCMRPTD_LoadNewAudittrail( vSubtask, &vTZBRAU2O ) < 0 ) { return( -1 ); } GetStringFromAttribute( szName, vTZCMCPL, "CPL", "Name" ); zstrcpy( szControlText, " CPL: " ); zstrcat( szControlText, szName ); SetCtrlText( vSubtask, "txtCPL", szControlText ); GetParentWindow( &vParentWindow, vSubtask ); RefreshCtrl( vParentWindow, "lbCPLRList" ); return( 0 ); } // zwTZCMRPTD_LoadNewAudittrail
zSHORT /* LOCAL */ OPERATION zwTZCMRPTD_LoadDesc_AUX( zVIEW vSubtask, zLONG CPLR_ZKey, zPCHAR pszTimeStamp ) { zVIEW vTZBRAU3O; zVIEW vKZDBHQUA; zCHAR szZKey[18]; zSHORT nRC; if ( GetViewByName( &vTZBRAU3O, "TZBRAU3O", vSubtask, zLEVEL_TASK ) > 0 ) DropObjectInstance( vTZBRAU3O ); if ( ActivateEmptyObjectInstance ( &vKZDBHQUA, "KZDBHQUA", vSubtask, zSINGLE ) >= 0 ) { SetNameForView( vKZDBHQUA, "KZDBHQUA", vSubtask, zLEVEL_TASK ); CreateEntity( vKZDBHQUA, "EntitySpec", zPOS_AFTER ); CreateEntity( vKZDBHQUA, "QualAttrib", zPOS_AFTER ); } else return( -1 ); // QualAttrib for "WHERE CPLR.ZKey = CPLR_ZKey" SetAttributeFromString( vKZDBHQUA, "EntitySpec", "EntityName", "AuditTrail" ); SetAttributeFromString( vKZDBHQUA, "QualAttrib", "EntityName", "CPLR" ); SetAttributeFromString( vKZDBHQUA, "QualAttrib", "AttributeName", "ZKey" ); SetAttributeFromString( vKZDBHQUA, "QualAttrib", "Oper", "=" ); zltoa( CPLR_ZKey, szZKey ); SetAttributeFromString( vKZDBHQUA, "QualAttrib", "Value", szZKey ); // QualAttrib for "AND" CreateEntity( vKZDBHQUA, "QualAttrib", zPOS_AFTER ); SetAttributeFromString( vKZDBHQUA, "QualAttrib", "Oper", "AND" ); // QualAttrib for "WHERE AuditTrail.TimeStamp = pszTimeStamp" CreateEntity( vKZDBHQUA, "QualAttrib", zPOS_AFTER ); SetAttributeFromString( vKZDBHQUA, "QualAttrib", "EntityName", "AuditTrail" ); SetAttributeFromString( vKZDBHQUA, "QualAttrib", "AttributeName", "TimeStamp" ); SetAttributeFromString( vKZDBHQUA, "QualAttrib", "Oper", "=" ); SetAttributeFromString( vKZDBHQUA, "QualAttrib", "Value", pszTimeStamp ); nRC = ActivateObjectInstance( &vTZBRAU3O, "TZBRAU3O", vSubtask, vKZDBHQUA, zSINGLE | zLEVEL_APPLICATION ); DropObjectInstance( vKZDBHQUA ); if (CheckExistenceOfEntity( vTZBRAU3O, "AuditTrail" ) == 0 ) SetNameForView( vTZBRAU3O, "TZBRAU3O", vSubtask, zLEVEL_TASK ); else { MessageSend( vSubtask, "CM00299", "Audit Trail:", "There are no AuditTrail-Information for the component.", zMSGQ_OBJECT_CONSTRAINT_INFORMATION, zBEEP ); SetWindowActionBehavior( vSubtask, zWAB_StayOnWindow, 0, 0 ); return( -1 ); } return( 0 ); }
///////////////////////////////////////////////////////////////////////////// // // OPERATION: oTZDMXGPO_GetViewForXDM // // PURPOSE: Get access to XDM View. Activate if not loaded // and get at application level if loaded. // ///////////////////////////////////////////////////////////////////////////// zOPER_EXPORT zSHORT OPERATION oTZDMXGPO_GetViewForXDM( zVIEW vSubtask, zPVIEW pvTZDMXGPO, zSHORT nCurrentOrReload ) { zVIEW vT; zVIEW vTask; zCHAR szXDM_FileName[ zMAX_FILESPEC_LTH + 1 ]; zCHAR szAppViewName[ 66 ] = "dmDOMAINS."; zSHORT nRScope; zSHORT nRC; // Set up the XDM File Name and the View Name GetViewByName( &vTask, "TaskLPLR", vSubtask, zLEVEL_TASK ); GetStringFromAttribute( &szAppViewName[ 10 ], vTask, "LPLR", "Name" ); GetStringFromAttribute( szXDM_FileName, vTask, "LPLR", "ExecDir" ); zstrcat( szXDM_FileName, "\\zeidon.xdm" ); // See if XDM View is at the Application level nRScope = GetViewByName( &vT, szAppViewName, vTask, zLEVEL_APPLICATION ); if ( nRScope == zCALL_ERROR ) return( zCALL_ERROR ); if ( nRScope == zLEVEL_APPLICATION && nCurrentOrReload == zFORCE_RELOAD ) { nRC = DropObjectInstance( vT ); nRScope = -1; } if ( nRScope != zLEVEL_APPLICATION ) { // Load it from a file or create a new one if file is missing. if ( ActivateOI_FromFile( &vT, "TZDMXGPO", vTask, szXDM_FileName, zSINGLE | zLEVEL_APPLICATION | zNOI_OKAY ) != 0 ) { ActivateEmptyObjectInstance( &vT, "TZDMXGPO", vTask, zSINGLE | zLEVEL_APPLICATION ); CreateEntity( vT, "DomainGroup", zPOS_AFTER ); SetAttributeFromString( vT, "DomainGroup", "Name", &szAppViewName[ 10 ] ); SetNameForView( vT, szAppViewName, 0, zLEVEL_APPLICATION ); CommitOI_ToFile( vT, szXDM_FileName, zASCII ); // MessageSend( vT, "DM00201", "Domain Management", // "The Executable Domain File was not found. " // "An empty one is being created. You may want " // "to save all Domains OR re-Initialze the LPLR.", // zMSGQ_OBJECT_CONSTRAINT_WARNING, zBEEP ); nRC = 1; } else { SetNameForView( vT, szAppViewName, 0, zLEVEL_APPLICATION ); nRC = 0; } } else { nRC = 0; } CreateViewFromViewForTask( pvTZDMXGPO, vT, 0 ); return( nRC ); }
/////////////////////////////////////////////////////////////////////////////// // // OPERATION: TZZAPPSD_SendServerExecs // // PURPOSE: This Entry takes the zeidon.xdm and all xod object instances // and sends them to the Server for running the application on // the server. // //////////////////////////////////////////////////////////////////////// zOPER_EXPORT zSHORT OPERATION TZZAPP2D_SendServerExecs( zVIEW vSubtask ) { zVIEW vZApp; zVIEW vLPLR; zVIEW vMeta; zSHORT nRC; zCHAR szFileName[ zMAX_FILESPEC_LTH + 1 ]; zCHAR szMetaName[ 13 ]; zCHAR szAppName[ 32 ]; zCHAR szServerSubDir[ 33 ]; zCHAR szLPLR_Path[ zMAX_FILESPEC_LTH + 1 ]; zCHAR szMsg[ zSHORT_MESSAGE_LTH + 1 ]; zVIEW vApplSubtask; zCHAR szServer[ 33 ]; // get XLP for selceted application GetViewByName( &vZApp, "KZAPPLOO", vSubtask, zLEVEL_TASK ); GetStringFromAttribute( szAppName, vZApp, "APPLICATION", "APP_NAME" ); GetStringFromAttribute( szLPLR_Path, vZApp, "APPLICATION", "APP_ADOBIN" ); SysAppendcDirSep( szLPLR_Path ); zstrcpy( szFileName, szLPLR_Path ); zstrcat( szFileName, szAppName ); zstrcat( szFileName, ".XLP" ); // open Task LPLR nRC = ActivateOI_FromFile( &vLPLR, "TZCMLPLO", vSubtask, szFileName, zMULTIPLE ); if ( nRC ) { MessageSend( vSubtask, "CM00285", "Configuration Management", "Can't activate XLP for task.", zMSGQ_OBJECT_CONSTRAINT_ERROR, zBEEP ); return( -1 ); } SetNameForView( vLPLR, "TaskLPLR", vSubtask, zLEVEL_TASK); zmemset (szServer,0,sizeof(szServer)); // GetViewByName( &vLPLR, "TaskLPLR", vSubtask, zLEVEL_TASK ); // Start the network if necessary. Use zeidon and hzkzoe as constants for now. nRC = NetStatus( "zeidon" ); if ( nRC == 0 ) { nRC = NetStartup( "zeidon", "hzkzoe" ); if ( nRC ) { MessageSend( vSubtask, "CM00285", "Configuration Management", "Network cannot be started.", zMSGQ_OBJECT_CONSTRAINT_ERROR, zBEEP ); return( 0 ); } } // First get the application name and make sure it exists in the // zeidon.app object on the server. If it isn't there, add it. GetStringFromAttribute( szAppName, vLPLR, "LPLR", "Name" ); zstrcpy( szFileName, "zeidon.app" ); SfCreateSubtask( &vApplSubtask, vSubtask, "Zeidon System" ); nRC = NetActivateOI_FromFile( 0, szServer, &vMeta, "KZAPPLOO", vApplSubtask, szFileName, zSINGLE ); if ( nRC >= 0 ) { nRC = SetCursorFirstEntityByString( vMeta, "APPLICATION", "APP_NAME", szAppName, 0 ); if ( nRC >= zCURSOR_SET ) DropObjectInstance( vMeta ); else { CreateEntity( vMeta, "APPLICATION", zPOS_LAST ); SetAttributeFromString( vMeta, "APPLICATION", "APP_NAME", szAppName ); zstrcpy( szServerSubDir, szAppName ); zstrcat( szServerSubDir, "/" ); SetAttributeFromString( vMeta, "APPLICATION", "APP_DLL", szServerSubDir ); SetAttributeFromString( vMeta, "APPLICATION", "APP_ADOBIN", szServerSubDir ); SetAttributeFromString( vMeta, "APPLICATION", "APP_LOCAL", szServerSubDir ); TraceLineS( "*** Committing server file: ", szFileName ); zstrcpy( szMsg, "Sending ZEIDON.APP: " ); MB_SetMessage( vSubtask, 1, szMsg ); // Send OI to server. NetCommitOI_ToFile( 0, szServer, vMeta, szFileName, zASCII ); DropObjectInstance( vMeta ); } } else { SfDropSubtask( vApplSubtask, 0 ); MessageSend( vSubtask, "CM00286", "Configuration Management", "ZEIDON.APP cannot be activated.", zMSGQ_OBJECT_CONSTRAINT_ERROR, zBEEP ); return( 0 ); } SfDropSubtask( vApplSubtask, 0 ); // Send the XDM before all the xods. // First format the file name for activation on the client and then // format it for commit on the server. // GetStringFromAttribute( szFileName, vLPLR, "LPLR", "ExecDir" ); zstrcpy( szFileName, szLPLR_Path ); zstrcpy( szMetaName, "ZEIDON.XDM" ); zstrcat( szFileName, szMetaName ); TraceLineS( "*** Activating client file: ", szFileName ); nRC = ActivateOI_FromFile( &vMeta, "TZDMXGPO", vSubtask, szFileName, zSINGLE ); if ( nRC >= 0 ) { // Filename includes Directory-prefix **HH** GetStringFromAttribute( szFileName, vLPLR, "LPLR", "Name" ); zstrcat( szFileName, "/" ); zstrcat( szFileName, szMetaName ); TraceLineS( "*** Committing server file: ", szFileName ); MB_SetMessage( vSubtask, 1, "Sending XDM" ); // Send OI to server. NetCommitOI_ToFile( 0, szServer, vMeta, szFileName, zASCII ); } // Next loop through all the LODs, activating each XOD and sending // it to the server. SetCursorFirstEntityByInteger( vLPLR, "W_MetaType", "Type", zREFER_LOD_META, 0 ); nRC = SetCursorFirstEntity( vLPLR, "W_MetaDef", 0 ); while ( nRC >= zCURSOR_SET ) { zstrcpy( szFileName, szLPLR_Path ); GetStringFromAttribute( szMetaName, vLPLR, "W_MetaDef", "Name" ); zstrcat( szFileName, szMetaName ); zstrcat( szFileName, ".XOD" ); TraceLineS( "*** Activating client file: ", szFileName ); nRC = ActivateOI_FromFile( &vMeta, "TZZOXODO", vSubtask, szFileName, zSINGLE ); if ( nRC >= 0 ) { // Filename includes Directory-prefix **HH** GetStringFromAttribute( szFileName, vLPLR, "LPLR", "Name" ); zstrcat( szFileName, "/" ); zstrcat( szFileName, szMetaName ); zstrcat( szFileName, ".XOD" ); TraceLineS( "*** Committing server file: ", szFileName ); zstrcpy( szMsg, "Sending XOD: " ); zstrcat( szMsg, szMetaName ); MB_SetMessage( vSubtask, 1, szMsg ); // Send OI to server. NetCommitOI_ToFile( 0, szServer, vMeta, szFileName, zASCII ); } nRC = SetCursorNextEntity( vLPLR, "W_MetaDef", 0 ); } MB_SetMessage( vSubtask, 1, "Transmission Complete" ); return( 0 ); }
///////////////////////////////////////////////////////////////////////////// // // OPERATION: EnqueueInstance // // PARAMETERS: zVIEW vInstance - View to the instance to be enqueued // zPCHAR szEntityNames - A string containing 1 or // more entity names on which to enqueue // the instance. The first entity name // MUST BE the root of the object and // the remaining entity names MUST be // separated by the plus '+' character. // // RETURN CODES: 0 - Enqueue successful // 1 - Enqueue unsuccessful, the instance is already // Enqueued // zCALL_ERROR - Enqueue unsuccessful, error in processing // ///////////////////////////////////////////////////////////////////////////// zSHORT OPERATION EnqueueInstance( zVIEW vInstance, zPCHAR szEntityNames ) { zVIEW vEnqueue; zVIEW vEnqueueHolder; zVIEW vQual; zVIEW vWkInstance; zPCHAR szEntityNamePtr; zCHAR szCurrentEntity[ 34 ]; zCHAR szLevel[ 2 ]; zSHORT nEntity, nEnqueue, nIdx, nRC, nRetries; zLONG lER_Token; zCHAR szTimestamp[ 6 ]; zCHAR szObjectName[ 34 ]; zCHAR szUserID[ 34 ]; zCHAR szPassword[ 34 ]; zCHAR szKey[ 64 ]; zCHAR szMsg[ 256 ]; // We put the enqueue logic in a for loop so we can restart the // enqueue if the enqueue fails and we cannot find the owner of // the enqueue. nRetries = 4; if ( MiGetObjectNameForView( szObjectName, vInstance ) < 0 ) return( zCALL_ERROR ); for ( ; ; ) { // Set up work variables szEntityNamePtr = szEntityNames; _fstrcpy( szLevel, "R" ); nEntity = nEnqueue = 0; // Set up a multiple root instance for enqueueing if ( ActivateEmptyObjectInstance( &vEnqueue, szlCGENQUEU, vInstance, zMULTIPLE ) != 0 ) { return( zCALL_ERROR ); } // Create a view on the instance so we do not step on the applications // cursor positions. CreateViewFromViewForTask( &vWkInstance, vInstance, 0 ); // Get timestamp and user information for enqueue MiGetDateTimeForOI( szTimestamp, vWkInstance ); SysGetUserID( vInstance, szUserID, szPassword ); if ( szUserID[ 0 ] == 0 ) _fstrcpy( szUserID, "(null)" ); // Loop for each entity type to be enqueued while ( szEntityNamePtr[ 0 ] ) { // Gather the next entity name on which to enqueue nIdx = 0; while ( szEntityNamePtr[ 0 ] && szEntityNamePtr[ 0 ] != '+' ) { szCurrentEntity[ nIdx++ ] = szEntityNamePtr[ 0 ]; szEntityNamePtr++; } szCurrentEntity[ nIdx ] = 0; if ( szEntityNamePtr[ 0 ] == '+' ) szEntityNamePtr++; nEntity++; // Now that an entity name has been gathered, troll the instance // for every occurrence of that entity type and create an // enqueue instance for it nRC = SetCursorFirstEntity( vWkInstance, szCurrentEntity, zSCOPE_OI ); if ( nRC == zCALL_ERROR ) { DropView( vWkInstance ); DropObjectInstance( vEnqueue ); return( zCALL_ERROR ); } if ( nRC >= zCURSOR_SET ) { lER_Token = MiGetERTokenForEntity( vWkInstance, szCurrentEntity ); do { // Set up an enqueue instance, The ER_Token and the Instance // key are the unique keys to the object, a duplicate instance // on the database will result in an enqueue failure with the // instance in use. The UserID combined with the Timestamp is // the non-unique key for deletion of a logical enqueue. // The object name and level ( 'R' - root, 'C' - child ) are // informational only. CreateEntity( vEnqueue, szlEnqueue, zPOS_AFTER ); SetAttributeFromInteger( vEnqueue, szlEnqueue, szlER_Token, lER_Token ); MiGetKeyFromInstance( szKey, 61, vWkInstance, szCurrentEntity ); SetAttributeFromString( vEnqueue, szlEnqueue, szlInstanceKey, szKey ); SetAttributeFromVariable( vEnqueue, szlEnqueue, szlTimestamp, szTimestamp, zTYPE_DATETIME, 6, 0, 0 ); SetAttributeFromString( vEnqueue, szlEnqueue, szlType, "U" ); SetAttributeFromString( vEnqueue, szlEnqueue, szlUser, szUserID ); SetAttributeFromString( vEnqueue, szlEnqueue, szlObject, szObjectName ); SetAttributeFromString( vEnqueue, szlEnqueue, szlLevel, szLevel ); nEnqueue++; } while ( SetCursorNextEntity( vWkInstance, szCurrentEntity, zSCOPE_OI ) >= zCURSOR_SET ); } // After processing an entity type, all other enqueues are at the // child level szLevel[ 0 ] = 'C'; } // Now that we're done gathering the enqueue information, we can drop // the view to the instance DropView( vWkInstance ); // The enqueue instance has been built, now it is time to insert it // into the database for locking the instance. nRC = CommitObjectInstance( vEnqueue ); if ( nRC != zDUPLICATE_ROOT ) { DropObjectInstance( vEnqueue ); return( nRC ); } // The enqueue failed, now we will determine the owner of the enqueue // to see if we are conflicting with ourself or to report the owner // to the enqueue requestor SetCursorFirstEntity( vEnqueue, szlEnqueue, 0 ); do { fnBuildQualForEnqueue( vEnqueue, &vQual ); nRC = ActivateObjectInstance( &vEnqueueHolder, szlCGENQUEU, vInstance, vQual, zSINGLE ); DropObjectInstance( vQual ); if ( nRC < -1 ) return( zCALL_ERROR ); else if ( nRC >= 0 ) break; else DropObjectInstance( vEnqueueHolder ); } while ( SetCursorNextEntity( vEnqueue, szlEnqueue, 0 ) >= zCURSOR_SET ); // If the enqueue holder was not found, then the enqueue may have // disappeared while trying to find the holder, retry the enqueue // operation. nRetries--; if ( nRC == -1 ) { if ( nRetries == 0 ) return( zCALL_ERROR ); } // Report on the enqueue holder GetStringFromAttribute( szKey, vEnqueueHolder, szlEnqueue, szlUser ); GetStringFromAttribute( &szKey[ 30 ], vEnqueueHolder, szlEnqueue, szlObject ); // if the current enqueue holder is the current user for the // same object type, then offer to drop the previous enqueue and // re-establish the enqueue for the current user if ( _fstrcmp( szUserID, szKey ) == 0 && _fstrcmp( szObjectName, &szKey[ 30 ] ) == 0 && nRetries ) { // we will retry this once and once only nRetries = 1; _fstrcpy( szMsg, "The " ); _fstrcat( szMsg, szObjectName ); _fstrcat( szMsg, " is already enqueued by you in this session or" " a previous session. Would you like to release" " the previously held enqueue?" ); nRC = MessagePrompt( vInstance, "1", szlEnqueue, szMsg, 0, zBUTTONS_YESNO, zRESPONSE_YES, zICON_QUESTION ); if ( nRC == zRESPONSE_NO ) { DropObjectInstance( vEnqueue ); DropObjectInstance( vEnqueueHolder ); return( 1 ); } // The user wants to delete a previous enqueue for the same // object type, build the qualification for the delete and remove // the prior enqueue. fnBuildQualForEnqueueDelete( vEnqueueHolder, &vQual ); DropObjectInstance( vEnqueueHolder ); nRC = ActivateObjectInstance( &vEnqueueHolder, szlCGENQUEU, vInstance, vQual, zMULTIPLE ); DropObjectInstance( vQual ); if ( nRC < 0 ) return( zCALL_ERROR ); nRC = SetCursorFirstEntity( vEnqueueHolder, szlEnqueue, 0 ); while ( nRC >= zCURSOR_SET ) nRC = DeleteEntity( vEnqueueHolder, szlEnqueue, zREPOS_NEXT ); nRC = CommitObjectInstance( vEnqueueHolder ); DropObjectInstance( vEnqueueHolder ); // If the attempt to reuse the enqueue failed on a database error, // return that error. Otherwise, return zero ==> the enqueue was // reused. if ( nRC < 0 ) return( zCALL_ERROR ); else return( 0 ); } else { // Report on the owner of the enqueue _fstrcpy( szMsg, "The " ); _fstrcat( szMsg, szObjectName ); _fstrcat( szMsg, " is currently in use by " ); _fstrcat( szMsg, szKey ); if ( _fstrcmp( szObjectName, &szKey[ 30 ] ) != 0 ) { _fstrcat( szMsg, " under the object " ); _fstrcat( szMsg, &szKey[ 30 ] ); } _fstrcat( szMsg, "." ); MessagePrompt( vInstance, "1", szlEnqueue, szMsg, 0, zBUTTONS_OK, zRESPONSE_OK, 0 ); DropObjectInstance( vEnqueue ); DropObjectInstance( vEnqueueHolder ); return( 1 ); } } // End of for loop for enqueueing // If we reach here, then the enqueue was in use and failed. return( 1 ); }
///////////////////////////////////////////////////////////////////////////// // // OPERATION: DequeueInstance // // PARAMETERS: zVIEW vInstance - View to the instance to be dequeued // zSHORT nCheckOnly - 0 to dequeue // - non-zero to check the instance is // enqueued only. // // RETURN CODES: 0 - Dequeue successful // 1 - Enqueue not found // zCALL_ERROR - Dequeue unsuccessful, error in processing // ///////////////////////////////////////////////////////////////////////////// zSHORT OPERATION DequeueInstance( zVIEW vInstance, zSHORT nCheckOnly ) { zVIEW vEnqueue; zVIEW vQual; zLONG lActivateFlags; zCHAR szObjectName[ 34 ]; zCHAR szUserID[ 34 ]; zCHAR szPassword[ 34 ]; zCHAR szTimestamp[ 6 ]; zSHORT nRC; if ( MiGetObjectNameForView( szObjectName, vInstance ) < 0 ) return( zCALL_ERROR ); // Set up a an enqueue instance for building the qual object if ( ActivateEmptyObjectInstance( &vEnqueue, szlCGENQUEU, vInstance, zSINGLE ) != 0 ) { return( zCALL_ERROR ); } SysGetUserID( vInstance, szUserID, szPassword ); if ( szUserID[ 0 ] == 0 ) zstrcpy( szUserID, "(null)" ); MiGetDateTimeForOI( szTimestamp, vInstance ); if ( nCheckOnly ) lActivateFlags = zSINGLE; else lActivateFlags = zMULTIPLE; // Build a partial enqueue instance for passing to the qualification // build function fnBuildQualForEnqueueDelete. CreateEntity( vEnqueue, szlEnqueue, zPOS_FIRST ); SetAttributeFromVariable( vEnqueue, szlEnqueue, szlTimestamp, szTimestamp, zTYPE_DATETIME, 6, 0, 0 ); SetAttributeFromString( vEnqueue, szlEnqueue, szlUser, szUserID ); fnBuildQualForEnqueueDelete( vEnqueue, &vQual ); DropObjectInstance( vEnqueue ); nRC = ActivateObjectInstance( &vEnqueue, szlCGENQUEU, vInstance, vQual, lActivateFlags ); DropObjectInstance( vQual ); if ( nRC < -1 ) return( zCALL_ERROR ); else if ( nRC == -1 ) { DropObjectInstance( vEnqueue ); return( 1 ); } // The enqueue was found, if it is a check only, drop the instance // and return 0, otherwise, delete the enqueue. if ( nCheckOnly ) { DropObjectInstance( vEnqueue ); return( 0 ); } nRC = SetCursorFirstEntity( vEnqueue, szlEnqueue, 0 ); while ( nRC >= zCURSOR_SET ) nRC = DeleteEntity( vEnqueue, szlEnqueue, zREPOS_NEXT ); nRC = CommitObjectInstance( vEnqueue ); DropObjectInstance( vEnqueue ); if ( nRC < 0 ) return( zCALL_ERROR ); return( 0 ); }
//:VIEW OperationXOG BASED ON LOD TZZOXOGO zOPER_EXPORT zSHORT OPERATION oTZOGSRCO_GenerateXOG( zVIEW OperationGroup ) { zVIEW OperationXOG = 0; //:VIEW OperationGroupT BASED ON LOD TZOGSRCO zVIEW OperationGroupT = 0; //:VIEW CurrentLPLR BASED ON LOD TZCMLPLO zVIEW CurrentLPLR = 0; //:STRING ( 513 ) XOG_FileName zCHAR XOG_FileName[ 514 ] = { 0 }; //:STRING ( 513 ) POG_FileName zCHAR POG_FileName[ 514 ] = { 0 }; //:STRING ( 200 ) szMsg zCHAR szMsg[ 201 ] = { 0 }; //:INTEGER lFile zLONG lFile = 0; //:SHORT nRC zSHORT nRC = 0; zSHORT RESULT; zCHAR szTempString_0[ 33 ]; zCHAR szTempString_1[ 33 ]; //:// Build the executable Global Object executable for all Operations in the LPLR. //:// Activate or initialize the XOG executable object. //:GET VIEW CurrentLPLR NAMED "TaskLPLR" RESULT = GetViewByName( &CurrentLPLR, "TaskLPLR", OperationGroup, zLEVEL_TASK ); //:XOG_FileName = CurrentLPLR.LPLR.ExecDir + "\" + CurrentLPLR.LPLR.Name + ".XOG" GetStringFromAttribute( XOG_FileName, CurrentLPLR, "LPLR", "ExecDir" ); ZeidonStringConcat( XOG_FileName, 1, 0, "\\", 1, 0, 514 ); GetVariableFromAttribute( szTempString_0, 0, 'S', 33, CurrentLPLR, "LPLR", "Name", "", 0 ); ZeidonStringConcat( XOG_FileName, 1, 0, szTempString_0, 1, 0, 514 ); ZeidonStringConcat( XOG_FileName, 1, 0, ".XOG", 1, 0, 514 ); //:lFile = SysOpenFile( OperationGroup, XOG_FileName, COREFILE_READ ) lFile = SysOpenFile( OperationGroup, XOG_FileName, COREFILE_READ ); //:IF lFile < 0 if ( lFile < 0 ) { //:// Executable has not yet been generated. //:ACTIVATE OperationXOG EMPTY RESULT = ActivateEmptyObjectInstance( &OperationXOG, "TZZOXOGO", OperationGroup, zSINGLE ); //:CREATE ENTITY OperationXOG.TZZOXOGO RESULT = CreateEntity( OperationXOG, "TZZOXOGO", zPOS_AFTER ); //:OperationXOG.TZZOXOGO.NAME = CurrentLPLR.LPLR.Name SetAttributeFromAttribute( OperationXOG, "TZZOXOGO", "NAME", CurrentLPLR, "LPLR", "Name" ); //:ELSE } else { //:SysCloseFile( OperationGroup, lFile, 0 ) SysCloseFile( OperationGroup, lFile, 0 ); //:// Get current executable File. //:ActivateOI_FromFile( OperationXOG, "TZZOXOGO", OperationGroup, XOG_FileName, zSINGLE ) ActivateOI_FromFile( &OperationXOG, "TZZOXOGO", OperationGroup, XOG_FileName, zSINGLE ); //:// Delete current source file entries. //:FOR EACH OperationXOG.GLOBALOPERATIONSOURCEFILE RESULT = SetCursorFirstEntity( OperationXOG, "GLOBALOPERATIONSOURCEFILE", "" ); while ( RESULT > zCURSOR_UNCHANGED ) { //:DELETE ENTITY OperationXOG.GLOBALOPERATIONSOURCEFILE NONE RESULT = DeleteEntity( OperationXOG, "GLOBALOPERATIONSOURCEFILE", zREPOS_NONE ); RESULT = SetCursorNextEntity( OperationXOG, "GLOBALOPERATIONSOURCEFILE", "" ); } //:END } //:END //:NAME VIEW OperationXOG "OperationXOG" SetNameForView( OperationXOG, "OperationXOG", 0, zLEVEL_TASK ); //:// Build the executable components from each POG Operation. //:SET CURSOR FIRST CurrentLPLR.W_MetaType WHERE CurrentLPLR.W_MetaType.Type = 14 // 14 is Global Operation Group RESULT = SetCursorFirstEntityByInteger( CurrentLPLR, "W_MetaType", "Type", 14, "" ); //:FOR EACH CurrentLPLR.W_MetaDef RESULT = SetCursorFirstEntity( CurrentLPLR, "W_MetaDef", "" ); while ( RESULT > zCURSOR_UNCHANGED ) { //:POG_FileName = CurrentLPLR.LPLR.MetaSrcDir + "\" + CurrentLPLR.W_MetaDef.Name + ".POG" GetStringFromAttribute( POG_FileName, CurrentLPLR, "LPLR", "MetaSrcDir" ); ZeidonStringConcat( POG_FileName, 1, 0, "\\", 1, 0, 514 ); GetVariableFromAttribute( szTempString_1, 0, 'S', 33, CurrentLPLR, "W_MetaDef", "Name", "", 0 ); ZeidonStringConcat( POG_FileName, 1, 0, szTempString_1, 1, 0, 514 ); ZeidonStringConcat( POG_FileName, 1, 0, ".POG", 1, 0, 514 ); //:nRC = ActivateOI_FromFile( OperationGroupT, "TZOGSRCO", OperationGroup, POG_FileName, zSINGLE + 8192 ) nRC = ActivateOI_FromFile( &OperationGroupT, "TZOGSRCO", OperationGroup, POG_FileName, zSINGLE + 8192 ); //:IF nRC < 0 if ( nRC < 0 ) { //:szMsg = "Can't open POG file, " + POG_FileName ZeidonStringCopy( szMsg, 1, 0, "Can't open POG file, ", 1, 0, 201 ); ZeidonStringConcat( szMsg, 1, 0, POG_FileName, 1, 0, 201 ); //:IssueError( OperationGroup,0,0, szMsg ) IssueError( OperationGroup, 0, 0, szMsg ); //:RETURN -1 return( -1 ); } //:END //:// Create Source file entry. //:CREATE ENTITY OperationXOG.GLOBALOPERATIONSOURCEFILE RESULT = CreateEntity( OperationXOG, "GLOBALOPERATIONSOURCEFILE", zPOS_AFTER ); //:OperationXOG.GLOBALOPERATIONSOURCEFILE.NAME = OperationGroupT.GlobalOperationGroup.Name SetAttributeFromAttribute( OperationXOG, "GLOBALOPERATIONSOURCEFILE", "NAME", OperationGroupT, "GlobalOperationGroup", "Name" ); //:OperationXOG.GLOBALOPERATIONSOURCEFILE.LANGUAGETYPE = OperationGroupT.GlobalOperationGroup.LanguageType SetAttributeFromAttribute( OperationXOG, "GLOBALOPERATIONSOURCEFILE", "LANGUAGETYPE", OperationGroupT, "GlobalOperationGroup", "LanguageType" ); //:// Create each Operation entry. //:FOR EACH OperationGroupT.Operation RESULT = SetCursorFirstEntity( OperationGroupT, "Operation", "" ); while ( RESULT > zCURSOR_UNCHANGED ) { //:CREATE ENTITY OperationXOG.OPERATION RESULT = CreateEntity( OperationXOG, "OPERATION", zPOS_AFTER ); //:OperationXOG.OPERATION.NAME = OperationGroupT.Operation.Name SetAttributeFromAttribute( OperationXOG, "OPERATION", "NAME", OperationGroupT, "Operation", "Name" ); //:OperationXOG.OPERATION.TYPE = OperationGroupT.Operation.Type SetAttributeFromAttribute( OperationXOG, "OPERATION", "TYPE", OperationGroupT, "Operation", "Type" ); //:FOR EACH OperationGroupT.Parameter RESULT = SetCursorFirstEntity( OperationGroupT, "Parameter", "" ); while ( RESULT > zCURSOR_UNCHANGED ) { //:CREATE ENTITY OperationXOG.PARAMETER RESULT = CreateEntity( OperationXOG, "PARAMETER", zPOS_AFTER ); //:OperationXOG.PARAMETER.NAME = OperationGroupT.Parameter.ShortDesc SetAttributeFromAttribute( OperationXOG, "PARAMETER", "NAME", OperationGroupT, "Parameter", "ShortDesc" ); //:OperationXOG.PARAMETER.DATATYPE = OperationGroupT.Parameter.DataType SetAttributeFromAttribute( OperationXOG, "PARAMETER", "DATATYPE", OperationGroupT, "Parameter", "DataType" ); RESULT = SetCursorNextEntity( OperationGroupT, "Parameter", "" ); } RESULT = SetCursorNextEntity( OperationGroupT, "Operation", "" ); //:END } RESULT = SetCursorNextEntity( CurrentLPLR, "W_MetaDef", "" ); //:END } //:END //:CommitOI_ToFile( OperationXOG, XOG_FileName, zASCII ) CommitOI_ToFile( OperationXOG, XOG_FileName, zASCII ); //:DropObjectInstance( OperationXOG ) DropObjectInstance( OperationXOG ); return( 0 ); // END }
//: VIEW OldOperGrp BASED ON LOD TZOGSRCO zOPER_EXPORT zSHORT OPERATION oTZOGSRCO_GlobalOperGrpMigrate( zVIEW NewOperGrp, zPCHAR OperGroupMetaName, zVIEW SourceLPLR, zVIEW vSubtask ) { zVIEW OldOperGrp = 0; //:VIEW CurrentLPLR BASED ON LOD TZCMLPLO zVIEW CurrentLPLR = 0; //:STRING ( 513 ) SourceFileName // size according to zMAX_FILESPEC+1 zCHAR SourceFileName[ 514 ] = { 0 }; //:STRING ( 513 ) SourceFileName2 // size according to zMAX_FILESPEC+1 zCHAR SourceFileName2[ 514 ] = { 0 }; //:STRING ( 36 ) SourceName zCHAR SourceName[ 37 ] = { 0 }; zSHORT lTempInteger_0; zSHORT RESULT; zCHAR szTempString_0[ 33 ]; //:// Activate existing source meta OldOperGroup //:SourceFileName = SourceLPLR.LPLR.MetaSrcDir + "\" + OperGroupMetaName + ".POG" GetStringFromAttribute( SourceFileName, SourceLPLR, "LPLR", "MetaSrcDir" ); ZeidonStringConcat( SourceFileName, 1, 0, "\\", 1, 0, 514 ); ZeidonStringConcat( SourceFileName, 1, 0, OperGroupMetaName, 1, 0, 514 ); ZeidonStringConcat( SourceFileName, 1, 0, ".POG", 1, 0, 514 ); //:// zIGNORE_ATTRIB_ERRORS=8192 //:ActivateOI_FromFile( OldOperGrp, "TZOGSRCO", SourceLPLR, //: SourceFileName, zSINGLE + 8192 ) ActivateOI_FromFile( &OldOperGrp, "TZOGSRCO", SourceLPLR, SourceFileName, zSINGLE + 8192 ); //:NAME VIEW OldOperGrp "OldOperGrp" SetNameForView( OldOperGrp, "OldOperGrp", 0, zLEVEL_TASK ); //://ActivateEmptyMetaOI( vSubtask, NewOperGrp, 14, zSINGLE ) // 14 is zSOURCE_GOPGRP_META //://NAME VIEW NewOperGrp "NewOperGrp" //:IF NewOperGrp.GlobalOperationGroup DOES NOT EXIST lTempInteger_0 = CheckExistenceOfEntity( NewOperGrp, "GlobalOperationGroup" ); if ( lTempInteger_0 != 0 ) { //:// The Global Operation Group does not exist in the target, so simply copy everything over. //:CreateMetaEntity( vSubtask, NewOperGrp, "GlobalOperationGroup", zPOS_AFTER ) CreateMetaEntity( vSubtask, NewOperGrp, "GlobalOperationGroup", zPOS_AFTER ); //:SetMatchingAttributesByName( NewOperGrp, "GlobalOperationGroup", OldOperGrp, "GlobalOperationGroup", zSET_NULL ) SetMatchingAttributesByName( NewOperGrp, "GlobalOperationGroup", OldOperGrp, "GlobalOperationGroup", zSET_NULL ); //:// Copy over the source file to the new LPLR directory, if there is a source file. //:// We will assume a source file exists if the SourceFile.Extension is not null. If there //:// is actually no source file, the CopyFile does no harm. //:IF OldOperGrp.GlobalOperationGroup.Extension != "" if ( CompareAttributeToString( OldOperGrp, "GlobalOperationGroup", "Extension", "" ) != 0 ) { //:RetrieveViewForMetaList( vSubtask, CurrentLPLR, zSOURCE_ERD_META ) // Get view for directory info. RetrieveViewForMetaList( vSubtask, &CurrentLPLR, zSOURCE_ERD_META ); //:ResetViewFromSubobject( CurrentLPLR ) ResetViewFromSubobject( CurrentLPLR ); //:IF OldOperGrp.GlobalOperationGroup.Extension = "C" if ( CompareAttributeToString( OldOperGrp, "GlobalOperationGroup", "Extension", "C" ) == 0 ) { //:SourceName = OperGroupMetaName + ".C" ZeidonStringCopy( SourceName, 1, 0, OperGroupMetaName, 1, 0, 37 ); ZeidonStringConcat( SourceName, 1, 0, ".C", 1, 0, 37 ); //:ELSE } else { //:SourceName = OperGroupMetaName + ".VML" ZeidonStringCopy( SourceName, 1, 0, OperGroupMetaName, 1, 0, 37 ); ZeidonStringConcat( SourceName, 1, 0, ".VML", 1, 0, 37 ); } //:END //:SourceFileName = SourceLPLR.LPLR.PgmSrcDir + "\" + SourceName GetStringFromAttribute( SourceFileName, SourceLPLR, "LPLR", "PgmSrcDir" ); ZeidonStringConcat( SourceFileName, 1, 0, "\\", 1, 0, 514 ); ZeidonStringConcat( SourceFileName, 1, 0, SourceName, 1, 0, 514 ); //:SourceFileName2 = CurrentLPLR.LPLR.PgmSrcDir + "\" + SourceName GetStringFromAttribute( SourceFileName2, CurrentLPLR, "LPLR", "PgmSrcDir" ); ZeidonStringConcat( SourceFileName2, 1, 0, "\\", 1, 0, 514 ); ZeidonStringConcat( SourceFileName2, 1, 0, SourceName, 1, 0, 514 ); //:SysCopyFile( vSubtask, SourceFileName, SourceFileName2, TRUE ) SysCopyFile( vSubtask, SourceFileName, SourceFileName2, TRUE ); //:DropMetaOI( vSubtask, CurrentLPLR ) DropMetaOI( vSubtask, CurrentLPLR ); } //:END //:FOR EACH OldOperGrp.Operation RESULT = SetCursorFirstEntity( OldOperGrp, "Operation", "" ); while ( RESULT > zCURSOR_UNCHANGED ) { //:CreateMetaEntity( vSubtask, NewOperGrp, "Operation", zPOS_AFTER ) CreateMetaEntity( vSubtask, NewOperGrp, "Operation", zPOS_AFTER ); //:SetMatchingAttributesByName ( NewOperGrp, "Operation", OldOperGrp, //: "Operation", zSET_NULL ) SetMatchingAttributesByName( NewOperGrp, "Operation", OldOperGrp, "Operation", zSET_NULL ); //:FOR EACH OldOperGrp.Parameter RESULT = SetCursorFirstEntity( OldOperGrp, "Parameter", "" ); while ( RESULT > zCURSOR_UNCHANGED ) { //:// Make sure the ShortDesc in the Parameter is not null. //:IF OldOperGrp.Parameter.ShortDesc = "" if ( CompareAttributeToString( OldOperGrp, "Parameter", "ShortDesc", "" ) == 0 ) { //:OldOperGrp.Parameter.ShortDesc = "Parm" SetAttributeFromString( OldOperGrp, "Parameter", "ShortDesc", "Parm" ); } //:END //:CreateMetaEntity( vSubtask, NewOperGrp, "Parameter", zPOS_AFTER ) CreateMetaEntity( vSubtask, NewOperGrp, "Parameter", zPOS_AFTER ); //:SetMatchingAttributesByName( NewOperGrp, "Parameter", OldOperGrp, //: "Parameter", zSET_NULL ) SetMatchingAttributesByName( NewOperGrp, "Parameter", OldOperGrp, "Parameter", zSET_NULL ); RESULT = SetCursorNextEntity( OldOperGrp, "Parameter", "" ); } RESULT = SetCursorNextEntity( OldOperGrp, "Operation", "" ); //:END } //:END //:ELSE } else { //:// The Global Operation Group exists in the target, so merge in any new Operations. //:// We will force over any Operations (both prototype and code) for any Operations not flagged as modified in target LPLR. //:FOR EACH OldOperGrp.Operation RESULT = SetCursorFirstEntity( OldOperGrp, "Operation", "" ); while ( RESULT > zCURSOR_UNCHANGED ) { //:SET CURSOR FIRST NewOperGrp.Operation WHERE NewOperGrp.Operation.Name = OldOperGrp.Operation.Name GetStringFromAttribute( szTempString_0, OldOperGrp, "Operation", "Name" ); RESULT = SetCursorFirstEntityByString( NewOperGrp, "Operation", "Name", szTempString_0, "" ); //:IF RESULT < zCURSOR_SET if ( RESULT < zCURSOR_SET ) { //:CreateMetaEntity( vSubtask, NewOperGrp, "Operation", zPOS_AFTER ) CreateMetaEntity( vSubtask, NewOperGrp, "Operation", zPOS_AFTER ); //:SetMatchingAttributesByName ( NewOperGrp, "Operation", OldOperGrp, "Operation", zSET_NULL ) SetMatchingAttributesByName( NewOperGrp, "Operation", OldOperGrp, "Operation", zSET_NULL ); } //:END //:// If the operation is new or modifiable, set new parameters and operation code. //:IF NewOperGrp.Operation.DoNotMergeFlag = "" if ( CompareAttributeToString( NewOperGrp, "Operation", "DoNotMergeFlag", "" ) == 0 ) { //:FOR EACH NewOperGrp.Parameter RESULT = SetCursorFirstEntity( NewOperGrp, "Parameter", "" ); while ( RESULT > zCURSOR_UNCHANGED ) { //:DELETE ENTITY NewOperGrp.Parameter NONE RESULT = DeleteEntity( NewOperGrp, "Parameter", zREPOS_NONE ); RESULT = SetCursorNextEntity( NewOperGrp, "Parameter", "" ); } //:END //:FOR EACH OldOperGrp.Parameter RESULT = SetCursorFirstEntity( OldOperGrp, "Parameter", "" ); while ( RESULT > zCURSOR_UNCHANGED ) { //:// Make sure the ShortDesc in the Parameter is not null. //:IF OldOperGrp.Parameter.ShortDesc = "" if ( CompareAttributeToString( OldOperGrp, "Parameter", "ShortDesc", "" ) == 0 ) { //:OldOperGrp.Parameter.ShortDesc = "Parm" SetAttributeFromString( OldOperGrp, "Parameter", "ShortDesc", "Parm" ); } //:END //:CreateMetaEntity( vSubtask, NewOperGrp, "Parameter", zPOS_AFTER ) CreateMetaEntity( vSubtask, NewOperGrp, "Parameter", zPOS_AFTER ); //:SetMatchingAttributesByName( NewOperGrp, "Parameter", OldOperGrp, "Parameter", zSET_NULL ) SetMatchingAttributesByName( NewOperGrp, "Parameter", OldOperGrp, "Parameter", zSET_NULL ); RESULT = SetCursorNextEntity( OldOperGrp, "Parameter", "" ); } //:END } RESULT = SetCursorNextEntity( OldOperGrp, "Operation", "" ); //: // Add new Operation Code. //: // CopyOperationCode //:END } //:END } //:END //:DropObjectInstance( OldOperGrp ) DropObjectInstance( OldOperGrp ); //:CommitMetaOI( vSubtask, NewOperGrp, 14 ) // 14 is zSOURCE_GOPGRP_META CommitMetaOI( vSubtask, NewOperGrp, 14 ); //:// Build the prototypes in zeidon.h file. //:RetrieveViewForMetaList( vSubtask, CurrentLPLR, zSOURCE_GOPGRP_META ) // Get view for Merge oper. RetrieveViewForMetaList( vSubtask, &CurrentLPLR, zSOURCE_GOPGRP_META ); //:ResetViewFromSubobject( CurrentLPLR ) ResetViewFromSubobject( CurrentLPLR ); //:MergeGlobalPrototypes( NewOperGrp, //: NewOperGrp.GlobalOperationGroup.Name, //: "GlobalOperationGroup", //: CurrentLPLR ) GetStringFromAttribute( szTempString_0, NewOperGrp, "GlobalOperationGroup", "Name" ); MergeGlobalPrototypes( NewOperGrp, szTempString_0, "GlobalOperationGroup", CurrentLPLR ); //:DropMetaOI( vSubtask, CurrentLPLR ) DropMetaOI( vSubtask, CurrentLPLR ); return( 0 ); // END }