Example #1
0
        private EmpMetaData createEMPExampleMetaData()
        {
            EmpMetaData empMetaData = new EmpMetaData();

            empMetaData.Id          = empNodeId;
            empMetaData.Description = "Upper Shell Provider - OPC-UA Server";
            empMetaData.Methods     = new Dictionary <Guid, MethodMetaData>();

            //Method GetCoOrdinates
            MethodMetaData GetCoOrdinatesMetaData = new MethodMetaData();

            GetCoOrdinatesMetaData.Id          = GetCoOrdinatesMethodId;
            GetCoOrdinatesMetaData.Name        = "GetCoOrdinates";
            GetCoOrdinatesMetaData.Description = "Gets Current X,Y and Z CoOrdinates of the Upper Shell Provider";
            GetCoOrdinatesMetaData.RequiresDestinationSystem = false;

            GetCoOrdinatesMetaData.InputParameters = new Dictionary <string, Tuple <string, Type> >();

            GetCoOrdinatesMetaData.OutputParameters = new Dictionary <string, Tuple <string, Type> >();
            GetCoOrdinatesMetaData.OutputParameters.Add("xCoOrdinate", new Tuple <string, Type>("X CoOrdinate of Circuit Board Provider", Type.GetType("System.Int32")));
            GetCoOrdinatesMetaData.OutputParameters.Add("yCoOrdinate", new Tuple <string, Type>("Y CoOrdinate of Circuit Board Provider", Type.GetType("System.Int32")));
            GetCoOrdinatesMetaData.OutputParameters.Add("zCoOrdinate", new Tuple <string, Type>("Z CoOrdinate of Circuit Board Provider", Type.GetType("System.Int32")));

            empMetaData.Methods.Add(GetCoOrdinatesMethodId, GetCoOrdinatesMetaData);
            return(empMetaData);
        }
Example #2
0
        private EmpMetaData createEMPExampleMetaData()
        {
            EmpMetaData empMetaData = new EmpMetaData();

            empMetaData.Id          = empTestNodeId;
            empMetaData.Description = "Circuit Board Provider - OPC-UA Server";
            empMetaData.Methods     = new Dictionary <Guid, MethodMetaData>();

            //Method GetCoOrdinates
            MethodMetaData GetCoOrdinatesMetaData = new MethodMetaData();

            GetCoOrdinatesMetaData.Id          = GetCoOrdinatesMethodId;
            GetCoOrdinatesMetaData.Name        = "GetCoOrdinates";
            GetCoOrdinatesMetaData.Description = "Gets Current X,Y and Z CoOrdinates of the Circuit Board Provider";
            GetCoOrdinatesMetaData.RequiresDestinationSystem = false;

            GetCoOrdinatesMetaData.InputParameters = new Dictionary <string, Tuple <string, Type> >();

            GetCoOrdinatesMetaData.OutputParameters = new Dictionary <string, Tuple <string, Type> >();
            GetCoOrdinatesMetaData.OutputParameters.Add("xCoOrdinate", new Tuple <string, Type>("X CoOrdinate of Circuit Board Provider", Type.GetType("System.Int32")));
            GetCoOrdinatesMetaData.OutputParameters.Add("yCoOrdinate", new Tuple <string, Type>("Y CoOrdinate of Circuit Board Provider", Type.GetType("System.Int32")));
            GetCoOrdinatesMetaData.OutputParameters.Add("zCoOrdinate", new Tuple <string, Type>("Z CoOrdinate of Circuit Board Provider", Type.GetType("System.Int32")));

            empMetaData.Methods.Add(GetCoOrdinatesMethodId, GetCoOrdinatesMetaData);

            //Method IsFilled
            MethodMetaData IsFiledMetaData = new MethodMetaData();

            IsFiledMetaData.Id          = IsFilledMethodId;
            IsFiledMetaData.Name        = "isFilled";
            IsFiledMetaData.Description = "This method provides information whether warehouse has circuit board(s)";
            IsFiledMetaData.RequiresDestinationSystem = false;
            IsFiledMetaData.InputParameters           = new Dictionary <string, Tuple <string, Type> >();
            IsFiledMetaData.OutputParameters          = new Dictionary <string, Tuple <string, Type> >();
            empMetaData.Methods.Add(IsFilledMethodId, IsFiledMetaData);

            //Method Supply
            MethodMetaData SupplyMetaData = new MethodMetaData();

            SupplyMetaData.Id          = SupplyMethodId;
            SupplyMetaData.Name        = "supply";
            SupplyMetaData.Description = "This method provides circuit boards(s)";
            SupplyMetaData.RequiresDestinationSystem = false;

            SupplyMetaData.InputParameters    = new Dictionary <string, Tuple <string, Type> >();
            SupplyMetaData.OutputParameters   = new Dictionary <string, Tuple <string, Type> >();
            SupplyMetaData.InputEmpVariables  = new Dictionary <string, Tuple <string, Type> >();
            SupplyMetaData.OutputEmpVariables = new Dictionary <string, Tuple <string, Type> >();

            empMetaData.Methods.Add(SupplyMethodId, SupplyMetaData);

            return(empMetaData);
        }
Example #3
0
        private EmpMetaData createEMPExampleMetaData()
        {
            EmpMetaData empMetaData = new EmpMetaData();

            empMetaData.Id          = empTestNodeId;
            empMetaData.Description = "OPC UA Server - Intelligent Key Finder Assembly";
            empMetaData.Methods     = new Dictionary <Guid, MethodMetaData>();


            //Method GetCoOrdinates
            MethodMetaData MoveMetaData = new MethodMetaData();

            MoveMetaData.Id          = MoveMethodId;
            MoveMetaData.Name        = "move";
            MoveMetaData.Description = "Rotates the arm of robot in specified direction";
            MoveMetaData.RequiresDestinationSystem = false;

            MoveMetaData.InputParameters = new Dictionary <string, Tuple <string, Type> >();
            MoveMetaData.InputParameters.Add("direction", new Tuple <string, Type>("Direction of rotation", Type.GetType("System.Int32")));

            MoveMetaData.OutputParameters = new Dictionary <string, Tuple <string, Type> >();
            empMetaData.Methods.Add(MoveMethodId, MoveMetaData);

            //Method SumInt
            MethodMetaData StopMetaData = new MethodMetaData();

            StopMetaData.Id          = StopMethodId;
            StopMetaData.Name        = "stop";
            StopMetaData.Description = "Stops rotation of arm of robot";
            StopMetaData.RequiresDestinationSystem = false;

            StopMetaData.InputParameters    = new Dictionary <string, Tuple <string, Type> >();
            StopMetaData.OutputParameters   = new Dictionary <string, Tuple <string, Type> >();
            StopMetaData.InputEmpVariables  = new Dictionary <string, Tuple <string, Type> >();
            StopMetaData.OutputEmpVariables = new Dictionary <string, Tuple <string, Type> >();

            empMetaData.Methods.Add(StopMethodId, StopMetaData);


            return(empMetaData);
        }
Example #4
0
        private EmpMetaData createEMPExampleMetaData()
        {
            EmpMetaData empMetaData = new EmpMetaData();

            empMetaData.Id          = empTestNodeId;
            empMetaData.Description = "OPC UA Server - Intelligent Key Finder Assembly";
            empMetaData.Methods     = new Dictionary <Guid, MethodMetaData>();


            //Method GetCoOrdinates
            MethodMetaData GetCoOrdinatesMetaData = new MethodMetaData();

            GetCoOrdinatesMetaData.Id          = GetCoOrdinatesMethodId;
            GetCoOrdinatesMetaData.Name        = "GetCoOrdinates";
            GetCoOrdinatesMetaData.Description = "Gets CoOrdinates from the Pneumatic Assembly Unit";
            GetCoOrdinatesMetaData.RequiresDestinationSystem = false;

            GetCoOrdinatesMetaData.InputParameters = new Dictionary <string, Tuple <string, Type> >();

            GetCoOrdinatesMetaData.OutputParameters = new Dictionary <string, Tuple <string, Type> >();
            GetCoOrdinatesMetaData.OutputParameters.Add("x_CoOrdinate", new Tuple <string, Type>("X CoOrdinate of Assembly Unit", Type.GetType("System.Int32")));
            GetCoOrdinatesMetaData.OutputParameters.Add("y_CoOrdinate", new Tuple <string, Type>("Y CoOrdinate of Assembly Unit", Type.GetType("System.Int32")));
            GetCoOrdinatesMetaData.OutputParameters.Add("z_CoOrdinate", new Tuple <string, Type>("Z CoOrdinate of Assembly Unit", Type.GetType("System.Int32")));

            empMetaData.Methods.Add(GetCoOrdinatesMethodId, GetCoOrdinatesMetaData);

            //Method Identify
            MethodMetaData IdentifyMetaData = new MethodMetaData();

            IdentifyMetaData.Id          = IdentifyMethodId;
            IdentifyMetaData.Name        = "Identify";
            IdentifyMetaData.Description = "Identifies the Component based on RFID Read Operation";
            IdentifyMetaData.RequiresDestinationSystem = false;

            IdentifyMetaData.InputParameters  = new Dictionary <string, Tuple <string, Type> >();
            IdentifyMetaData.OutputParameters = new Dictionary <string, Tuple <string, Type> >();
            empMetaData.Methods.Add(IdentifyMethodId, IdentifyMetaData);

            return(empMetaData);
        }
Example #5
0
        private EmpMetaData createEMPExampleMetaData()
        {
            EmpMetaData empMetaData = new EmpMetaData();

            empMetaData.Id          = empNodeId;
            empMetaData.Description = "GeSCo Server";
            empMetaData.Methods     = new Dictionary <Guid, MethodMetaData>();

            //Method start
            MethodMetaData StartMetaData = new MethodMetaData();

            StartMetaData.Id          = StartMethodId;
            StartMetaData.Name        = "start";
            StartMetaData.Description = "This method caches the next available SFC from CMES and " +
                                        "starts production execution and control to produce the end-product.";
            StartMetaData.RequiresDestinationSystem = false;

            StartMetaData.InputParameters  = new Dictionary <string, Tuple <string, Type> >();
            StartMetaData.OutputParameters = new Dictionary <string, Tuple <string, Type> >();
            empMetaData.Methods.Add(StartMethodId, StartMetaData);

            return(empMetaData);
        }
        private EmpMetaData createEMPExampleMetaData()
        {
            EmpMetaData empMetaData = new EmpMetaData();

            empMetaData.Id          = empTestNodeId;
            empMetaData.Description = "OPC UA Server - RFID Reader";
            empMetaData.Methods     = new Dictionary <Guid, MethodMetaData>();

            //Method GetCoOrdinates
            MethodMetaData GetCoOrdinatesMetaData = new MethodMetaData();

            GetCoOrdinatesMetaData.Id          = GetCoOrdinatesMethodId;
            GetCoOrdinatesMetaData.Name        = "GetCoOrdinates";
            GetCoOrdinatesMetaData.Description = "Gets CoOrdinates of the RFID Reader";
            GetCoOrdinatesMetaData.RequiresDestinationSystem = false;

            GetCoOrdinatesMetaData.InputParameters = new Dictionary <string, Tuple <string, Type> >();

            GetCoOrdinatesMetaData.OutputParameters = new Dictionary <string, Tuple <string, Type> >();
            GetCoOrdinatesMetaData.OutputParameters.Add("x_CoOrdinate", new Tuple <string, Type>("X CoOrdinate of RFID Reader", Type.GetType("System.Int32")));
            GetCoOrdinatesMetaData.OutputParameters.Add("y_CoOrdinate", new Tuple <string, Type>("Y CoOrdinate of RFID Reader", Type.GetType("System.Int32")));
            GetCoOrdinatesMetaData.OutputParameters.Add("z_CoOrdinate", new Tuple <string, Type>("Z CoOrdinate of RFID Reader", Type.GetType("System.Int32")));

            empMetaData.Methods.Add(GetCoOrdinatesMethodId, GetCoOrdinatesMetaData);

            //Method Identify
            MethodMetaData IdentifyMetaData = new MethodMetaData();

            IdentifyMetaData.Id          = RFIDIdentifyMethodId;
            IdentifyMetaData.Name        = "rfidIdentify";
            IdentifyMetaData.Description = "Identifies the Component based on RFID Read Operation";
            IdentifyMetaData.RequiresDestinationSystem = false;

            IdentifyMetaData.InputParameters  = new Dictionary <string, Tuple <string, Type> >();
            IdentifyMetaData.OutputParameters = new Dictionary <string, Tuple <string, Type> >();
            empMetaData.Methods.Add(RFIDIdentifyMethodId, IdentifyMetaData);

            //Method Read
            MethodMetaData ReadMetaData = new MethodMetaData();

            ReadMetaData.Id          = ReadMethodId;
            ReadMetaData.Name        = "read";
            ReadMetaData.Description = "RFID Read Operation";
            ReadMetaData.RequiresDestinationSystem = false;

            ReadMetaData.InputParameters    = new Dictionary <string, Tuple <string, Type> >();
            ReadMetaData.OutputParameters   = new Dictionary <string, Tuple <string, Type> >();
            ReadMetaData.InputEmpVariables  = new Dictionary <string, Tuple <string, Type> >();
            ReadMetaData.OutputEmpVariables = new Dictionary <string, Tuple <string, Type> >();

            ReadMetaData.InputParameters.Add("position", new Tuple <string, Type>("Position of Read Operation", Type.GetType("System.Int32")));
            ReadMetaData.InputParameters.Add("length", new Tuple <string, Type>("Length of Read Operation", Type.GetType("System.Int32")));

            empMetaData.Methods.Add(ReadMethodId, ReadMetaData);

            //Method Write
            MethodMetaData WriteMetaData = new MethodMetaData();

            WriteMetaData.Id          = WriteMethodId;
            WriteMetaData.Name        = "write";
            WriteMetaData.Description = "RFID Write Operation";
            WriteMetaData.RequiresDestinationSystem = false;

            WriteMetaData.InputParameters    = new Dictionary <string, Tuple <string, Type> >();
            WriteMetaData.OutputParameters   = new Dictionary <string, Tuple <string, Type> >();
            WriteMetaData.InputEmpVariables  = new Dictionary <string, Tuple <string, Type> >();
            WriteMetaData.OutputEmpVariables = new Dictionary <string, Tuple <string, Type> >();

            WriteMetaData.InputParameters.Add("position", new Tuple <string, Type>("Position of Read Operation", Type.GetType("System.Int32")));
            WriteMetaData.InputParameters.Add("data", new Tuple <string, Type>("Length of Read Operation", Type.GetType("System.Int32[]")));

            empMetaData.Methods.Add(WriteMethodId, WriteMetaData);


            return(empMetaData);
        }
        private EmpMetaData createEMPExampleMetaData()
        {
            EmpMetaData empMetaData = new EmpMetaData();

            empMetaData.Id          = empTestNodeId;
            empMetaData.Description = "Pick and Place Robot - OPC-UA Server";
            empMetaData.Methods     = new Dictionary <Guid, MethodMetaData>();

            //Method GetCoOrdinates
            MethodMetaData GetCoOrdinatesMetaData = new MethodMetaData();

            GetCoOrdinatesMetaData.Id          = GetCoOrdinatesMethodId;
            GetCoOrdinatesMetaData.Name        = "GetCoOrdinates";
            GetCoOrdinatesMetaData.Description = "Gets current Z CoOrdinate from the Robot";
            GetCoOrdinatesMetaData.RequiresDestinationSystem = false;

            GetCoOrdinatesMetaData.InputParameters = new Dictionary <string, Tuple <string, Type> >();

            GetCoOrdinatesMetaData.OutputParameters = new Dictionary <string, Tuple <string, Type> >();
            GetCoOrdinatesMetaData.OutputParameters.Add("z_CoOrdinate", new Tuple <string, Type>("Z CoOrdinate of Robot", Type.GetType("System.Int32")));

            empMetaData.Methods.Add(GetCoOrdinatesMethodId, GetCoOrdinatesMetaData);

            //Method Home
            MethodMetaData HomeMetaData = new MethodMetaData();

            HomeMetaData.Id          = HomeMethodId;
            HomeMetaData.Name        = "home";
            HomeMetaData.Description = "The robot moves to home in Z - direction";
            HomeMetaData.RequiresDestinationSystem = false;
            HomeMetaData.InputParameters           = new Dictionary <string, Tuple <string, Type> >();
            HomeMetaData.OutputParameters          = new Dictionary <string, Tuple <string, Type> >();
            empMetaData.Methods.Add(HomeMethodId, HomeMetaData);

            //Method JogMove
            MethodMetaData JogMoveMetaData = new MethodMetaData();

            JogMoveMetaData.Id          = JogMoveMethodId;
            JogMoveMetaData.Name        = "jogMove";
            JogMoveMetaData.Description = "The robot jogs in a given direction";
            JogMoveMetaData.RequiresDestinationSystem = false;

            JogMoveMetaData.InputParameters    = new Dictionary <string, Tuple <string, Type> >();
            JogMoveMetaData.OutputParameters   = new Dictionary <string, Tuple <string, Type> >();
            JogMoveMetaData.InputEmpVariables  = new Dictionary <string, Tuple <string, Type> >();
            JogMoveMetaData.OutputEmpVariables = new Dictionary <string, Tuple <string, Type> >();

            empMetaData.Methods.Add(JogMoveMethodId, JogMoveMetaData);


            /////
            //Method JogMoveStop
            MethodMetaData JogMoveStopMetaData = new MethodMetaData();

            JogMoveStopMetaData.Id          = JogMoveStopMethodId;
            JogMoveStopMetaData.Name        = "jogMoveStop";
            JogMoveStopMetaData.Description = "The robot stops jogging";
            JogMoveStopMetaData.RequiresDestinationSystem = false;
            JogMoveStopMetaData.httpVerb = "POST";

            JogMoveStopMetaData.InputParameters    = new Dictionary <string, Tuple <string, Type> >();
            JogMoveStopMetaData.OutputParameters   = new Dictionary <string, Tuple <string, Type> >();
            JogMoveStopMetaData.InputEmpVariables  = new Dictionary <string, Tuple <string, Type> >();
            JogMoveStopMetaData.OutputEmpVariables = new Dictionary <string, Tuple <string, Type> >();

            empMetaData.Methods.Add(JogMoveStopMethodId, JogMoveStopMetaData);

            /////
            //Method MoveAbsolute
            MethodMetaData MoveAbsoluteMetaData = new MethodMetaData();

            MoveAbsoluteMetaData.Id          = MoveAbsoluteMethodId;
            MoveAbsoluteMetaData.Name        = "moveAbsolute";
            MoveAbsoluteMetaData.Description = "The robot moves to a instructed X Co-Ordinate";
            MoveAbsoluteMetaData.RequiresDestinationSystem = false;

            MoveAbsoluteMetaData.InputParameters    = new Dictionary <string, Tuple <string, Type> >();
            MoveAbsoluteMetaData.OutputParameters   = new Dictionary <string, Tuple <string, Type> >();
            MoveAbsoluteMetaData.InputEmpVariables  = new Dictionary <string, Tuple <string, Type> >();
            MoveAbsoluteMetaData.OutputEmpVariables = new Dictionary <string, Tuple <string, Type> >();

            MoveAbsoluteMetaData.InputParameters.Add("position", new Tuple <string, Type>("z-Position", Type.GetType("System.Int32")));
            MoveAbsoluteMetaData.InputParameters.Add("velocity", new Tuple <string, Type>("velocity of robot", Type.GetType("System.Int32")));
            MoveAbsoluteMetaData.InputParameters.Add("acceleration", new Tuple <string, Type>("acceleration of robot", Type.GetType("System.Int32")));
            MoveAbsoluteMetaData.InputParameters.Add("deceleration", new Tuple <string, Type>("deceleration of robot", Type.GetType("System.Int32")));

            MoveAbsoluteMetaData.OutputParameters.Add("moveFin", new Tuple <string, Type>("Move Finish Status", Type.GetType("System.Boolean")));

            empMetaData.Methods.Add(MoveAbsoluteMethodId, MoveAbsoluteMetaData);


            /////
            //Method ReadActualPosition
            MethodMetaData ReadActualPositionMetaData = new MethodMetaData();

            ReadActualPositionMetaData.Id          = ReadActualPositionMethodId;
            ReadActualPositionMetaData.Name        = "readActualPosition";
            ReadActualPositionMetaData.Description = "Reads the current position of robot";
            ReadActualPositionMetaData.RequiresDestinationSystem = false;

            ReadActualPositionMetaData.InputParameters    = new Dictionary <string, Tuple <string, Type> >();
            ReadActualPositionMetaData.OutputParameters   = new Dictionary <string, Tuple <string, Type> >();
            ReadActualPositionMetaData.InputEmpVariables  = new Dictionary <string, Tuple <string, Type> >();
            ReadActualPositionMetaData.OutputEmpVariables = new Dictionary <string, Tuple <string, Type> >();

            ReadActualPositionMetaData.OutputParameters.Add("actualPosition", new Tuple <string, Type>("Current Position of Robot", Type.GetType("System.Boolean")));

            empMetaData.Methods.Add(ReadActualPositionMethodId, ReadActualPositionMetaData);

            /////
            //Method Stop
            MethodMetaData StopMetaData = new MethodMetaData();

            StopMetaData.Id          = StopMethodId;
            StopMetaData.Name        = "stop";
            StopMetaData.Description = "The robot stops jogging";
            StopMetaData.RequiresDestinationSystem = false;
            StopMetaData.httpVerb = "POST";

            StopMetaData.InputParameters    = new Dictionary <string, Tuple <string, Type> >();
            StopMetaData.OutputParameters   = new Dictionary <string, Tuple <string, Type> >();
            StopMetaData.InputEmpVariables  = new Dictionary <string, Tuple <string, Type> >();
            StopMetaData.OutputEmpVariables = new Dictionary <string, Tuple <string, Type> >();

            empMetaData.Methods.Add(StopMethodId, StopMetaData);

            return(empMetaData);
        }
        private EmpMetaData createEMPExampleMetaData()
        {
            EmpMetaData empMetaData = new EmpMetaData();

            empMetaData.Id          = empTestNodeId;
            empMetaData.Description = "OPC UA Server - Intelligent Key Finder Assembly";
            empMetaData.Methods     = new Dictionary <Guid, MethodMetaData>();


            //Method GetCoOrdinates
            MethodMetaData GetCoOrdinatesMetaData = new MethodMetaData();

            GetCoOrdinatesMetaData.Id          = GetCoOrdinatesMethodId;
            GetCoOrdinatesMetaData.Name        = "GetCoOrdinates";
            GetCoOrdinatesMetaData.Description = "Gets CoOrdinates from the Pneumatic Assembly Unit";
            GetCoOrdinatesMetaData.RequiresDestinationSystem = false;

            GetCoOrdinatesMetaData.InputParameters = new Dictionary <string, Tuple <string, Type> >();

            GetCoOrdinatesMetaData.OutputParameters = new Dictionary <string, Tuple <string, Type> >();
            GetCoOrdinatesMetaData.OutputParameters.Add("x_CoOrdinate", new Tuple <string, Type>("X CoOrdinate of Assembly Unit", Type.GetType("System.Int32")));
            GetCoOrdinatesMetaData.OutputParameters.Add("y_CoOrdinate", new Tuple <string, Type>("Y CoOrdinate of Assembly Unit", Type.GetType("System.Int32")));
            GetCoOrdinatesMetaData.OutputParameters.Add("z_CoOrdinate", new Tuple <string, Type>("Z CoOrdinate of Assembly Unit", Type.GetType("System.Int32")));

            empMetaData.Methods.Add(GetCoOrdinatesMethodId, GetCoOrdinatesMetaData);

            //Method SumInt
            MethodMetaData PrepareMetaData = new MethodMetaData();

            PrepareMetaData.Id          = PrepareMethodId;
            PrepareMetaData.Name        = "Prepare";
            PrepareMetaData.Description = "Prepares for assembly of individual components of Key Finder";
            PrepareMetaData.RequiresDestinationSystem = false;

            PrepareMetaData.InputParameters    = new Dictionary <string, Tuple <string, Type> >();
            PrepareMetaData.OutputParameters   = new Dictionary <string, Tuple <string, Type> >();
            PrepareMetaData.InputEmpVariables  = new Dictionary <string, Tuple <string, Type> >();
            PrepareMetaData.OutputEmpVariables = new Dictionary <string, Tuple <string, Type> >();

            empMetaData.Methods.Add(PrepareMethodId, PrepareMetaData);


            /////
            //Method Assemble
            MethodMetaData AssembleMetaData = new MethodMetaData();

            AssembleMetaData.Id          = AssembleMethodId;
            AssembleMetaData.Name        = "Assemble";
            AssembleMetaData.Description = "Assembles the Key Finder Components";
            AssembleMetaData.RequiresDestinationSystem = false;
            AssembleMetaData.httpVerb             = "POST";
            AssembleMetaData.parametersInHTTPBody = true;

            AssembleMetaData.InputParameters    = new Dictionary <string, Tuple <string, Type> >();
            AssembleMetaData.OutputParameters   = new Dictionary <string, Tuple <string, Type> >();
            AssembleMetaData.InputEmpVariables  = new Dictionary <string, Tuple <string, Type> >();
            AssembleMetaData.OutputEmpVariables = new Dictionary <string, Tuple <string, Type> >();

            empMetaData.Methods.Add(AssembleMethodId, AssembleMetaData);

            /////
            //Method IsInUse
            MethodMetaData IsInUseMetaData = new MethodMetaData();

            IsInUseMetaData.Id          = IsInUseMethodId;
            IsInUseMetaData.Name        = "IsInUse";
            IsInUseMetaData.Description = "Provides the Status of the Assembly Unit";
            IsInUseMetaData.RequiresDestinationSystem = false;

            IsInUseMetaData.InputParameters    = new Dictionary <string, Tuple <string, Type> >();
            IsInUseMetaData.OutputParameters   = new Dictionary <string, Tuple <string, Type> >();
            IsInUseMetaData.InputEmpVariables  = new Dictionary <string, Tuple <string, Type> >();
            IsInUseMetaData.OutputEmpVariables = new Dictionary <string, Tuple <string, Type> >();

            empMetaData.Methods.Add(IsInUseMethodId, IsInUseMetaData);

            return(empMetaData);
        }
Example #9
0
        private EmpMetaData createEMPExampleMetaData()
        {
            EmpMetaData empMetaData = new EmpMetaData();

            empMetaData.Id          = GlobalVariables.empTestNodeId;
            empMetaData.Description = "Test Implementation of EMP methods";
            empMetaData.Methods     = new Dictionary <Guid, MethodMetaData>();

            #region GetSFCs
            //Method GetSFCs
            MethodMetaData GetSFCsMetaData = new MethodMetaData();
            GetSFCsMetaData.Id          = GlobalVariables.GetSFCsMethodID;
            GetSFCsMetaData.Name        = "GetSFCs";
            GetSFCsMetaData.Description = "Gets SFCs from CMES";
            GetSFCsMetaData.RequiresDestinationSystem = true;

            GetSFCsMetaData.InputParameters    = new Dictionary <string, Tuple <string, Type> >();
            GetSFCsMetaData.OutputParameters   = new Dictionary <string, Tuple <string, Type> >();
            GetSFCsMetaData.InputEmpVariables  = new Dictionary <string, Tuple <string, Type> >();
            GetSFCsMetaData.OutputEmpVariables = new Dictionary <string, Tuple <string, Type> >();

            //Input Parameters
            GetSFCsMetaData.InputParameters.Add("inSFCCount", new Tuple <string, Type>("SFC(s) count", Type.GetType("System.Int32")));

            //Output Parameters
            GetSFCsMetaData.OutputParameters.Add("outSFCs", new Tuple <string, Type>("SFCs from ME", Type.GetType("System.String")));
            GetSFCsMetaData.OutputParameters.Add("outStatus", new Tuple <string, Type>("Set in EMP based on the result of ME call", Type.GetType("System.Boolean")));

            //EMP Input Variables (= input variables mapped against the web service input parameters)
            GetSFCsMetaData.InputEmpVariables.Add("inEMPinSFCCount", new Tuple <string, Type>("SFC(s) count", Type.GetType("System.Int32")));

            //EMP Output Variables (= output variables mapped against the web service response)
            GetSFCsMetaData.OutputEmpVariables.Add("outEMPSFCs", new Tuple <string, Type>("SFCs from ME", Type.GetType("System.String")));
            GetSFCsMetaData.OutputEmpVariables.Add("outEMPStatus", new Tuple <string, Type>("Set in EMP based on the result of ME call", Type.GetType("System.Boolean")));

            empMetaData.Methods.Add(GlobalVariables.GetSFCsMethodID, GetSFCsMetaData);
            #endregion

            #region RegisterResource
            //Method MachineRegister
            MethodMetaData RegisterResourceMetaData = new MethodMetaData();
            RegisterResourceMetaData.Id          = GlobalVariables.RegisterResourceMethodID;
            RegisterResourceMetaData.Name        = "RegisterResource";
            RegisterResourceMetaData.Description = "Register a resource";
            RegisterResourceMetaData.RequiresDestinationSystem = false;

            RegisterResourceMetaData.InputParameters  = new Dictionary <string, Tuple <string, Type> >();
            RegisterResourceMetaData.OutputParameters = new Dictionary <string, Tuple <string, Type> >();

            //Input Parameters
            RegisterResourceMetaData.InputParameters.Add("ResourceUrl", new Tuple <string, Type>("Resource Url", Type.GetType("System.String")));

            //Output Parameters
            RegisterResourceMetaData.OutputParameters.Add("outResult", new Tuple <string, Type>("Return Value", Type.GetType("System.Boolean")));

            empMetaData.Methods.Add(GlobalVariables.RegisterResourceMethodID, RegisterResourceMetaData);
            #endregion

            #region StateAvailable
            //Method StateAvailable
            MethodMetaData StateAvailableMetaData = new MethodMetaData();
            StateAvailableMetaData.Id          = GlobalVariables.StateAvailableMethodID;
            StateAvailableMetaData.Name        = "StateAvailable";
            StateAvailableMetaData.Description = "Resource informs PCo that it is free";
            StateAvailableMetaData.RequiresDestinationSystem = false;

            StateAvailableMetaData.InputParameters  = new Dictionary <string, Tuple <string, Type> >();
            StateAvailableMetaData.OutputParameters = new Dictionary <string, Tuple <string, Type> >();

            //Input Parameters
            StateAvailableMetaData.InputParameters.Add("ResourceUrl", new Tuple <string, Type>("Resource Url", Type.GetType("System.String")));

            //Output Parameters
            StateAvailableMetaData.OutputParameters.Add("outResult", new Tuple <string, Type>("Return Value", Type.GetType("System.Boolean")));

            empMetaData.Methods.Add(GlobalVariables.StateAvailableMethodID, StateAvailableMetaData);
            #endregion

            #region CallbackDelegateWork
            //Method CallbackDelegateWork
            MethodMetaData CallbackDelegateWorkMetaData = new MethodMetaData();
            CallbackDelegateWorkMetaData.Id          = GlobalVariables.CallbackDelegateWorkMethodID;
            CallbackDelegateWorkMetaData.Name        = "CallbackDelegateWork";
            CallbackDelegateWorkMetaData.Description = "Resource informs finished task to GSFC";
            CallbackDelegateWorkMetaData.RequiresDestinationSystem = false;

            CallbackDelegateWorkMetaData.InputParameters  = new Dictionary <string, Tuple <string, Type> >();
            CallbackDelegateWorkMetaData.InputParameters  = new Dictionary <string, Tuple <string, Type> >();
            CallbackDelegateWorkMetaData.InputParameters  = new Dictionary <string, Tuple <string, Type> >();
            CallbackDelegateWorkMetaData.OutputParameters = new Dictionary <string, Tuple <string, Type> >();

            //Input Parameters
            CallbackDelegateWorkMetaData.InputParameters.Add("ResourceUrl", new Tuple <string, Type>("Resource Url", Type.GetType("System.String")));
            CallbackDelegateWorkMetaData.InputParameters.Add("WorkElement", new Tuple <string, Type>("WorkElement element", Type.GetType("System.String")));
            CallbackDelegateWorkMetaData.InputParameters.Add("Product", new Tuple <string, Type>("Product string", Type.GetType("System.String")));

            //Output Parameters
            CallbackDelegateWorkMetaData.OutputParameters.Add("outStatus", new Tuple <string, Type>("Return Value", Type.GetType("System.Boolean")));

            empMetaData.Methods.Add(GlobalVariables.CallbackDelegateWorkMethodID, CallbackDelegateWorkMetaData);
            #endregion

            #region StateOnHold
            //Method StateOnHold
            MethodMetaData StateOnHoldMetaData = new MethodMetaData();
            StateOnHoldMetaData.Id          = GlobalVariables.StateOnHoldMethodID;
            StateOnHoldMetaData.Name        = "StateOnHold";
            StateOnHoldMetaData.Description = "Resource informs PCo that it is OnHold";
            StateOnHoldMetaData.RequiresDestinationSystem = false;

            StateOnHoldMetaData.InputParameters  = new Dictionary <string, Tuple <string, Type> >();
            StateOnHoldMetaData.OutputParameters = new Dictionary <string, Tuple <string, Type> >();

            //Input Parameters
            StateOnHoldMetaData.InputParameters.Add("ResourceUrl", new Tuple <string, Type>("Resource Url", Type.GetType("System.String")));

            //Output Parameters
            StateOnHoldMetaData.OutputParameters.Add("outResult", new Tuple <string, Type>("Return Value", Type.GetType("System.Boolean")));

            empMetaData.Methods.Add(GlobalVariables.StateOnHoldMethodID, StateOnHoldMetaData);
            #endregion

            #region SetSFCToComplete
            //Method SetSFCToComplete
            MethodMetaData SetSFCToCompleteMetaData = new MethodMetaData();
            SetSFCToCompleteMetaData.Id          = GlobalVariables.SetSFCToCompleteMethodID;
            SetSFCToCompleteMetaData.Name        = "SetSFCToComplete";
            SetSFCToCompleteMetaData.Description = "Sets an SFC to complete";
            SetSFCToCompleteMetaData.RequiresDestinationSystem = true;

            SetSFCToCompleteMetaData.InputParameters    = new Dictionary <string, Tuple <string, Type> >();
            SetSFCToCompleteMetaData.OutputParameters   = new Dictionary <string, Tuple <string, Type> >();
            SetSFCToCompleteMetaData.InputEmpVariables  = new Dictionary <string, Tuple <string, Type> >();
            SetSFCToCompleteMetaData.OutputEmpVariables = new Dictionary <string, Tuple <string, Type> >();

            //Input Parameters
            SetSFCToCompleteMetaData.InputParameters.Add("inSFC", new Tuple <string, Type>("SFC number", Type.GetType("System.String")));
            SetSFCToCompleteMetaData.InputEmpVariables.Add("inEMPSFC", new Tuple <string, Type>("SFC number", Type.GetType("System.String")));

            //Output Parameters
            SetSFCToCompleteMetaData.OutputParameters.Add("outResult", new Tuple <string, Type>("Return Value", Type.GetType("System.Boolean")));
            SetSFCToCompleteMetaData.OutputEmpVariables.Add("outEMPResult", new Tuple <string, Type>("Return Value", Type.GetType("System.Boolean")));

            empMetaData.Methods.Add(GlobalVariables.SetSFCToCompleteMethodID, SetSFCToCompleteMetaData);
            #endregion


            return(empMetaData);
        }
        private EmpMetaData createEMPExampleMetaData()
        {
            EmpMetaData empMetaData = new EmpMetaData();

            empMetaData.Id          = empTestNodeId;
            empMetaData.Description = "Test Implementation of EMP methods";
            empMetaData.Methods     = new Dictionary <Guid, MethodMetaData>();

            //Method SumInt
            MethodMetaData sumIntMetaData = new MethodMetaData();

            sumIntMetaData.Id          = sumIntegerMethodId;
            sumIntMetaData.Name        = "SumInt";
            sumIntMetaData.Description = "Calculate sum of two integers";
            sumIntMetaData.RequiresDestinationSystem = false;

            sumIntMetaData.InputParameters  = new Dictionary <string, Tuple <string, Type> >();
            sumIntMetaData.OutputParameters = new Dictionary <string, Tuple <string, Type> >();

            //Input Parameters
            sumIntMetaData.InputParameters.Add("inIntOne", new Tuple <string, Type>("First Integer", Type.GetType("System.Int32")));
            sumIntMetaData.InputParameters.Add("inIntTwo", new Tuple <string, Type>("Second Integer", Type.GetType("System.Int32")));

            //Output Parameters
            sumIntMetaData.OutputParameters.Add("outSumInteger", new Tuple <string, Type>("Sum of two integers", Type.GetType("System.Int32")));

            empMetaData.Methods.Add(sumIntegerMethodId, sumIntMetaData);


            /////
            //Method SumDouble
            MethodMetaData sumDoubleMetaData = new MethodMetaData();

            sumDoubleMetaData.Id          = sumDoubleMethodId;
            sumDoubleMetaData.Name        = "SumDouble";
            sumDoubleMetaData.Description = "Calculate sum of two doubles";
            sumDoubleMetaData.RequiresDestinationSystem = false;
            sumDoubleMetaData.httpVerb             = "POST";
            sumDoubleMetaData.parametersInHTTPBody = true;

            sumDoubleMetaData.InputParameters  = new Dictionary <string, Tuple <string, Type> >();
            sumDoubleMetaData.OutputParameters = new Dictionary <string, Tuple <string, Type> >();

            //Input Parameters
            sumDoubleMetaData.InputParameters.Add("inDoubleOne", new Tuple <string, Type>("First Double", Type.GetType("System.Double")));
            sumDoubleMetaData.InputParameters.Add("inDoubleTwo", new Tuple <string, Type>("Second Double", Type.GetType("System.Double")));

            //Output Parameters
            sumDoubleMetaData.OutputParameters.Add("outSumDouble", new Tuple <string, Type>("Sum of two doubles", Type.GetType("System.Double")));

            empMetaData.Methods.Add(sumDoubleMethodId, sumDoubleMetaData);



            /////
            //Method GetWeatherDataByZip
            MethodMetaData getWeatherDataByZiptMetaData = new MethodMetaData();

            getWeatherDataByZiptMetaData.Id          = getWeatherDataByZipId;
            getWeatherDataByZiptMetaData.Name        = "GetWeatherDataByZip";
            getWeatherDataByZiptMetaData.Description = "Get weather data of a city";
            getWeatherDataByZiptMetaData.RequiresDestinationSystem = true;

            getWeatherDataByZiptMetaData.InputParameters    = new Dictionary <string, Tuple <string, Type> >();
            getWeatherDataByZiptMetaData.OutputParameters   = new Dictionary <string, Tuple <string, Type> >();
            getWeatherDataByZiptMetaData.InputEmpVariables  = new Dictionary <string, Tuple <string, Type> >();
            getWeatherDataByZiptMetaData.OutputEmpVariables = new Dictionary <string, Tuple <string, Type> >();

            //Input Parameters
            getWeatherDataByZiptMetaData.InputParameters.Add("inZipCode", new Tuple <string, Type>("Zip Code", Type.GetType("System.String")));

            //Output Parameters
            getWeatherDataByZiptMetaData.OutputParameters.Add("outCity", new Tuple <string, Type>("City", Type.GetType("System.String")));
            getWeatherDataByZiptMetaData.OutputParameters.Add("outDescription", new Tuple <string, Type>("Description", Type.GetType("System.String")));
            getWeatherDataByZiptMetaData.OutputParameters.Add("outTemperature", new Tuple <string, Type>("Temperature", Type.GetType("System.String")));
            getWeatherDataByZiptMetaData.OutputParameters.Add("outWind", new Tuple <string, Type>("Wind", Type.GetType("System.String")));

            //EMP Input Variables (= input variables mapped against the web service input parameters)
            getWeatherDataByZiptMetaData.InputEmpVariables.Add("inEMPZip", new Tuple <string, Type>("Zip Code", Type.GetType("System.String")));

            //EMP Output Variables (= output variables mapped against the web service response)
            getWeatherDataByZiptMetaData.OutputEmpVariables.Add("outEMPCity", new Tuple <string, Type>("City", Type.GetType("System.String")));
            getWeatherDataByZiptMetaData.OutputEmpVariables.Add("outEMPDescription", new Tuple <string, Type>("Description", Type.GetType("System.String")));
            getWeatherDataByZiptMetaData.OutputEmpVariables.Add("outEMPTemperature", new Tuple <string, Type>("Temperature", Type.GetType("System.String")));
            getWeatherDataByZiptMetaData.OutputEmpVariables.Add("outEMPWind", new Tuple <string, Type>("Wind", Type.GetType("System.String")));

            empMetaData.Methods.Add(getWeatherDataByZipId, getWeatherDataByZiptMetaData);



            /////
            //Method getWeatherDataByZiptMetaDataWithResponseManipulation
            MethodMetaData getWeatherDataByZiptMetaDataWithResponseManipulationMetaData = new MethodMetaData();

            getWeatherDataByZiptMetaDataWithResponseManipulationMetaData.Id          = getWeatherDataByZiptMetaDataWithResponseManipulationId;
            getWeatherDataByZiptMetaDataWithResponseManipulationMetaData.Name        = "GetWeatherDataByZipWithResponseManipulation";
            getWeatherDataByZiptMetaDataWithResponseManipulationMetaData.Description = "Manipulates the reponse of the weather of a city";
            getWeatherDataByZiptMetaDataWithResponseManipulationMetaData.RequiresDestinationSystem = true;

            getWeatherDataByZiptMetaDataWithResponseManipulationMetaData.InputParameters    = new Dictionary <string, Tuple <string, Type> >();
            getWeatherDataByZiptMetaDataWithResponseManipulationMetaData.OutputParameters   = new Dictionary <string, Tuple <string, Type> >();
            getWeatherDataByZiptMetaDataWithResponseManipulationMetaData.InputEmpVariables  = new Dictionary <string, Tuple <string, Type> >();
            getWeatherDataByZiptMetaDataWithResponseManipulationMetaData.OutputEmpVariables = new Dictionary <string, Tuple <string, Type> >();

            //Input Parameters
            getWeatherDataByZiptMetaDataWithResponseManipulationMetaData.InputParameters.Add("inZipCode", new Tuple <string, Type>("Zip Code", Type.GetType("System.String")));

            //Output Parameters
            getWeatherDataByZiptMetaDataWithResponseManipulationMetaData.OutputParameters.Add("outCity", new Tuple <string, Type>("City", Type.GetType("System.String")));
            getWeatherDataByZiptMetaDataWithResponseManipulationMetaData.OutputParameters.Add("outDescription", new Tuple <string, Type>("Description", Type.GetType("System.String")));
            getWeatherDataByZiptMetaDataWithResponseManipulationMetaData.OutputParameters.Add("outTemperature", new Tuple <string, Type>("Temperature", Type.GetType("System.String")));
            getWeatherDataByZiptMetaDataWithResponseManipulationMetaData.OutputParameters.Add("outWind", new Tuple <string, Type>("Wind", Type.GetType("System.String")));
            getWeatherDataByZiptMetaDataWithResponseManipulationMetaData.OutputParameters.Add("outResponseXML", new Tuple <string, Type>("ResponseXML", Type.GetType("System.String")));

            //EMP Input Variables (= input variables mapped against the web service input parameters)
            getWeatherDataByZiptMetaDataWithResponseManipulationMetaData.InputEmpVariables.Add("inEMPZip", new Tuple <string, Type>("Zip Code", Type.GetType("System.String")));

            //EMP Output Variables (= output variables mapped against the web service response)
            getWeatherDataByZiptMetaDataWithResponseManipulationMetaData.OutputEmpVariables.Add("outEMPCity", new Tuple <string, Type>("City", Type.GetType("System.String")));
            getWeatherDataByZiptMetaDataWithResponseManipulationMetaData.OutputEmpVariables.Add("outEMPDescription", new Tuple <string, Type>("Description", Type.GetType("System.String")));
            getWeatherDataByZiptMetaDataWithResponseManipulationMetaData.OutputEmpVariables.Add("outEMPTemperature", new Tuple <string, Type>("Temperature", Type.GetType("System.String")));
            getWeatherDataByZiptMetaDataWithResponseManipulationMetaData.OutputEmpVariables.Add("outEMPWind", new Tuple <string, Type>("Wind", Type.GetType("System.String")));
            getWeatherDataByZiptMetaDataWithResponseManipulationMetaData.OutputEmpVariables.Add("outEMPResponseXML", new Tuple <string, Type>("ResponseXML", Type.GetType("System.String")));

            empMetaData.Methods.Add(getWeatherDataByZiptMetaDataWithResponseManipulationId, getWeatherDataByZiptMetaDataWithResponseManipulationMetaData);

            return(empMetaData);
        }