Exemplo n.º 1
0
        public void Receive(ImageMessage msg)
        {
            //Grafo 1: (_Input)-[:_R]->(ImageMessage)
            //Grafo 2: (ImageMessage)-[:_R]->(_SELF)
            //Grafo 3: (_SELF)-[:_R]->(_P)
            _I  iFrame = new _I();
            _S  self   = new _S();
            var query  = this.Neo4j.Client.Cypher
                         //Nodes: _I, _S, ImageMessage, _P
                         .Create($"(i:_I {{iFrame}})")
                         .Create($"(m:ImageMessage {{msg}})")
                         .Create($"(s:_S)")
                         .WithParams(new { iFrame, msg })
                         .Create("(i)-[:_L]->(s)")
                         .Create("(s)<-[:_Q]-(m)")
                         .Return((i, m, s) =>
                                 new
            {
                input   = i.As <Neo4jClient.Node <_I> >(),
                message = m.As <Neo4jClient.Node <ImageMessage> >(),
                self    = s.As <Neo4jClient.Node <_S> >()
            }
                                 );
            var result = query.Results.Single();
            //Create Process to Exceute
            _P pToExecute = new _P();

            pToExecute.ManagerType   = "Nasdan.Core.Senses.SensesManager";
            pToExecute.FunctionName  = "Process";
            pToExecute.Argument1Json = this.Serialize(result.self);
            pToExecute.Argument1Type = result.self.GetType().ToString();
            pToExecute.Argument2Json = this.Serialize(result.message);
            pToExecute.Argument2Type = result.message.GetType().ToString();
            pToExecute.ResultType    = "Nasdan.Core.Representation._N`1";
            var query2 = this.Neo4j.Client.Cypher
                         .Create($"(p:_P {{pToExecute}})")
                         .WithParams(new { iFrame, msg, pToExecute })
                         //Edges
                         .Create("(s)-[p:_P {{pToExecute}}]->(m)")
                         .WithParams(new { pToExecute })
                         .Return(p => p.As <Neo4jClient.Node <_P> >());
            var _pNode = query2.Results.Single();
            var _p     = ((Neo4jClient.Node <_P>)_pNode).to_N <_P>();

            SelfActor.Tell(_p);
        }
Exemplo n.º 2
0
 public void Execute(_N <_P> nP)
 {
     try
     {
         //Get Method Info
         var manager    = this.GetManager(nP.Data);
         var method     = manager.GetType().GetMethod(nP.Data.FunctionName);
         var parameter1 = this.GetParameter1(nP.Data);
         var parameter2 = this.GetParameter2(nP.Data);
         var parameters = new object[] { parameter1, parameter2 };
         var result     = method.Invoke(manager, parameters);
         //Hay 3 posibilidades
         //1º) El método no devuelve nada
         //2º) El metodo invocado devuelve un tipo Node<T>
         //3º) Devuelve una clase pero que no es de tipo Node<T>
         if (string.IsNullOrEmpty(nP.Data.ResultType))
         {
             //1º) El método no devuelve nada
         }
         else
         {
             //Is a function (Value expected)
             var assembly   = this.GetAssembly(nP.Data.ResultAssemblyPath);
             var resultType = assembly.GetType(nP.Data.ResultType);
             if (resultType.GetGenericTypeDefinition() == typeof(_N <>))
             {
                 //2º) El metodo invocado devuelve un tipo Node<T>
                 var  reference = result.GetType().GetProperty("Reference").GetValue(result);
                 long resultId  = (long)reference.GetType().GetProperty("Id").GetValue(reference);
                 //DELETE _P (Process)
                 var query = this.Neo4j.Client.Cypher
                             .OptionalMatch($"(p:_P)<-[l:_L]-(s:_S)")
                             .Where($"ID(p) = {{idParam}}")
                             .WithParam("idParam", nP.Reference.Id)
                             .Delete("l,p")
                             .Return(s => s.As <Neo4jClient.Node <_S> >()); //GET SELF
                 var self = query.Results.Single();
                 //Connect new Graph (result) with SELF
                 this.Neo4j.Client.Cypher
                 .Match($"(s:_S)")
                 .Where($"ID(s) = {{idParam1}}")
                 .WithParam("idParam1", self.Reference.Id)
                 .Match($"(n)")
                 .Where($"ID(n) = {{idParam2}}")
                 .WithParam("idParam2", resultId)
                 .Create("(s)-[r:_Q]->(n)")
                 .ExecuteWithoutResults();
             }
             else
             {
                 //3º) Devuelve una clase pero que NO es de tipo Node<T>
             }
         }
         //Tell a Self que ponga Labels de lenguaje una vez acabado.
         SelfActor.Tell(SelfActor.MessageActions.label);
     }
     catch (Exception error)
     {
         this.Neo4j.Client.Cypher
         .Match($"(n:_P)")
         .Where($"ID(n) = {{idParam}}")
         .WithParam("idParam", nP.Reference.Id)
         .Create($"(e:_E {{error}})")
         .WithParam("error", error)
         .Create("(n)-[:_L]->(e)")
         .ExecuteWithoutResults();
         //Creamos un nodo Excepción y lo almacenamos como resultado
         //(SELF)-[_P]->(_E) Error
     }
 }