VerificationRequestServices.hxx

Go to the documentation of this file.

//Copyright 2022 Siemens Digital Industries Software
//==================================================
//Copyright $2020.
//Siemens Product Lifecycle Management Software Inc.
//All Rights Reserved.
//==================================================
//Copyright 2022 Siemens Digital Industries Software

#ifndef TEAMCENTER_CRT0_VERIFICATION_REQUEST_MANAGEMENT_HXX
#define TEAMCENTER_CRT0_VERIFICATION_REQUEST_MANAGEMENT_HXX

#include <string>
#include <vector>
#include <map>

#include <unidefs.h>
#include <pom/pom/pom.h>

#include <Crt0ValidationContract/libcrt0validationcontract_exports.h>

namespace Teamcenter
{
    class CRT0VALIDATIONCONTRACT_API VerificationRequestServices
    {
    public:
        struct ParameterInfoS
        {
            tag_t   parameter;  /* Parameter object to be added to Verification Request as Input or Output. */

            std::string  direction;    /* The direction to be set for Parameter. Valid values are: “Input”, “Output”  */

            ParameterInfoS()
            {
                parameter = NULLTAG;
                direction = "";
            }
        };

        struct RecipeDataS
        {
            std::string            recipeName; /* Name of the Fnd0Recipe object to be executed for the given content. */

            std::string            recipeUid;  /* The Fnd0Recipe object UID to be executed for the given content. */

            std::vector<tag_t>     bomWindows; /* A list of BOMWindow objects to which qualified business objects are resolved. */

            RecipeDataS() : recipeName(""), recipeUid("")
            {}
        };

        struct AddObjectInputS
        {
            tag_t                       objectTobeAdded;            /* Object (BOMLine or Workspace) to be added */

            std::string                      childPathObjectTobeAdded;   /* PS Occurrence Thread child path of object to be added */

            tag_t                       objectTobeAddedCtx;         /* The context (BOMLine) of object to added */

            std::string                      childPathCtx;              /* PS Occurrence Thread child path of context */

            std::map<std::string, std::vector<std::string> > additionalProps; /* Additional properties for objectToBeAdded */

            std::vector<ParameterInfoS>      parameters;        /* List of parameter and its direction to be set */

            RecipeDataS                 recipeData;               /* The recipe to be executed on given content */

            AddObjectInputS()
            {
                objectTobeAdded = NULLTAG;
                childPathObjectTobeAdded = "";
                objectTobeAddedCtx = NULLTAG;
                childPathCtx = "";
            }
        };

        struct ParticipantInfoS
        {
            tag_t   user;    /* The User object to be added as Participant to Verification Request */

            std::string  role;    /* Role of user as participant to be added to Verification Request.
                                Valid values for role are “Systems Designer” and “Simulation Engineer”. */

            ParticipantInfoS()
            {
                user = NULLTAG;
                role = "";
            }
        };

        struct InitiateWorkflowInfoS
        {
            std::string   worflowTemplateToInitiate;    /* Workflow template to initiate */

            std::string   name;                         /* Name of created process */

            std::string   description;                  /* description of created process */

            InitiateWorkflowInfoS()
            {}
        };

        struct CreateVRInputDataS
        {
            std::string                      clientId;                          /* Unique client id */

            std::string                      verificationRequestName;           /* Verification Request object name */

            std::string                      verificationRequestType;           /* Verification Request type */

            tag_t                       verificationRequestDefinition;     /* Crt0VCDefnRevision object */

            tag_t                       reviseVerificationRequestRevision; /* Existing Crt0VldnContractRevision Verification Request Object. */

            std::vector<AddObjectInputS>     verificationRequestContent;        /* A list of AddObjectInputInfo structure. Represents, contents to be added */

            std::map<std::string, std::vector<std::string> > verificationRequestProps;          /* Additional properties to set on Verification Request object */

            std::string                      createParamterCopyOptions;         /* To set given parameter directly or create copy */

            RecipeDataS                 recipeData;                        /* The recipe to be executed on given content */

            std::vector<ParticipantInfoS>    participants;                      /* List of Participant details to be set*/

            std::string                      workflowNameToInitiate;            /* Workflow to initiate */

            bool                        populateFromParent;                /* Flag to populate content from parent */

            tag_t                       parentVerificationRequest;         /* Parent Verification Request */

            CreateVRInputDataS() :clientId(""), verificationRequestName(""), verificationRequestType(""), verificationRequestDefinition(NULLTAG),
                reviseVerificationRequestRevision(NULLTAG), createParamterCopyOptions(""), workflowNameToInitiate(""),
                populateFromParent(false), parentVerificationRequest(NULLTAG)

            {}
        };

        struct ParameterDataS
        {
            tag_t   parameter; /* Parameter object associated with Verification Request. */

            std::string  direction; /* Direction of parameter. “Input” or “Output”. */

            ParameterDataS()
            {}
        };

        struct AddParameterInfoS
        {
            tag_t            owningObj;         /* Element */
            tag_t            owningVldnLinkObj;  /* Validation Link*/
            tag_t            parameter;      /* parameter */
            std::string           direction;      /* parameter directions. */

            AddParameterInfoS()
            {}
        };

        struct AddParameterOutputS
        {
            tag_t            attributeElement;      /* Attribute Element */
            tag_t            owningObj;              /* Owning Object */
            tag_t            owningVldnLinkObj;   /* Validation Link */
            tag_t            source_parameter;    /* List of parameter directions. */
            tag_t            target_parameter;    /* List of parameter directions. */
            std::string           direction;           /* List of parameter directions. */

            AddParameterOutputS()
            {
                attributeElement = NULLTAG;
                owningObj = NULLTAG;
                owningVldnLinkObj = NULLTAG;
                source_parameter = NULLTAG;
                target_parameter = NULLTAG;
                direction = "";
            }
        };

        struct AddObjectOutputS
        {
            tag_t    addedObject;                                                   /* Element of Verification Request  */

            tag_t    addedObjectVldnLink;                                           /* Element Validation Link   */

            std::vector<AddParameterOutputS>     parameters;      /* Parameters of Verification Request  */

            // Add any additional data required data of element

            AddObjectOutputS()
            {
                addedObject = NULLTAG;
                addedObjectVldnLink = NULLTAG;
            }
        };

        struct CreateVRDataS
        {
            std::string                    clientId;            /* Unique client id */

            tag_t                     verificationRequest; /* Created Verification Request object */

            std::vector<AddObjectOutputS>  verificationRequestAddObjectData;     /* added obejcts and parameters details of Verification Request */

            CreateVRDataS()
            {
                clientId = "";
                verificationRequest = NULLTAG;
            }
        };

        struct AddParticipantOutputS
        {
            tag_t    addedParticipant = NULLTAG;

            tag_t    participantType = NULLTAG;

            // Add any other output data, if required.

            AddParticipantOutputS()
            {}
        };

        static int createVerificationRequest(
            const std::vector<CreateVRInputDataS>& input,
            std::vector<CreateVRDataS>& output
        );

        static int addObjectsAndParametersToVerificationRequest(
            const tag_t verificationRequest,
            const RecipeDataS& recipeData,
            const std::vector<AddObjectInputS>& addObjectInputs,
            const std::string& createParamterCopyOptions,
            std::vector<AddObjectOutputS>& addObjectOutputDatas
        );

        static int addParticipantToVerficationRequest(
            const std::map < tag_t, std::vector<ParticipantInfoS> >& vrToPartcipantInfoMap,
            std::map < tag_t, std::vector<tag_t> >& outVrToParticipants
        );

        static int initiateWorflowToVerficationRequest(
            const std::map < tag_t, InitiateWorkflowInfoS >& vrToWorkSSflowInfoMap,
            std::map < tag_t, tag_t >& outVrToCreatedProcessMap
        );

        static int getAbsOccDatasBasedOnQualiferAndAbsOcc(const std::vector<tag_t> &listOfQualifier,
            const std::vector<tag_t> &listOfAbsOcc,
            std::vector<tag_t> &listOfQualiferOut,
            std::vector<tag_t> &listOfAbsOccOut,
            std::vector<tag_t> &listOfAbsOccDataOut);
    };
}

#ifdef __cplusplus
extern "C" {
#endif

    extern CRT0VALIDATIONCONTRACT_API int CRT0_createValidationLinks(
        tag_t verificationRequestTag,                                                             
        const std::vector<tag_t>& wsoObjects,                                                     
        const std::map<tag_t, tag_t> &elementToContextMap,                                        
        std::map< tag_t, tag_t >& assignedElementToValidationLinkMap                              
    );


    extern CRT0VALIDATIONCONTRACT_API int CRT0_deleteMappingPreAction(
        const tag_t attributeAlignmentTag, 
        const tag_t contextObjTag          
        );

    extern CRT0VALIDATIONCONTRACT_API int CRT0_IsObjectiveModifiable(
        tag_t affectedObj,            
        bool& isApplicable,           
        int& errorCode,               
        std::string& errorMessage     
        );

#ifdef __cplusplus
}
#endif

#include <Crt0ValidationContract/libcrt0validationcontract_undef.h>
#endif