Esempio n. 1
0
        public async Task <ActionResult <ConceptDTO> > Update(Guid id, [FromBody] ConceptDTO o)
        {
            try
            {
                if (o == null)
                {
                    return(BadRequest(CRUDError.From("Concept missing.")));
                }
                o.Id = id;

                var c       = o.Concept();
                var updated = await cService.Update(c);

                return(Ok(new ConceptDTO(updated)));
            }
            catch (LeafDbException le)
            {
                return(StatusCode(le.StatusCode, CRUDError.From(le.Message)));
            }
            catch (Exception ex)
            {
                logger.LogError("Could not update concept. Concept:{@Concept}, Error:{Error}", o, ex.ToString());
                return(StatusCode(StatusCodes.Status500InternalServerError));
            }
        }
Esempio n. 2
0
        public async Task <ActionResult <ConceptDTO> > Single(
            Guid ident,
            [FromServices] ConceptTreeSearcher searcher)
        {
            try
            {
                var concept = await searcher.GetAsync(ident);

                if (concept == null)
                {
                    return(NotFound());
                }

                var dto = new ConceptDTO(concept);
                return(Ok(dto));
            }
            catch (LeafRPCException le)
            {
                return(StatusCode(le.StatusCode));
            }
            catch (Exception ex)
            {
                log.LogError("Failed to retrieve Concept:{Id}. Error:{Error}", ident, ex.ToString());
                return(StatusCode(StatusCodes.Status500InternalServerError));
            }
        }
Esempio n. 3
0
        public void PBToDTOConcept()
        {
            ConceptDTO dtoStart = Misc.CreateConceptDTO;
            PBConcept  pb       = dtoStart.ToPBConcept();
            ConceptDTO dtoEnd   = pb.ToConcept();

            Assert.True(dtoStart.CompareTo(dtoEnd) == 0);
        }
Esempio n. 4
0
        public void ConceptDTOConstructor()
        {
            String     uuidString = $"[\"{Misc.g1.ToString()}\" \"{Misc.g2.ToString()}\" \"{Misc.g3.ToString()}\"]";
            ConceptDTO dto        = ConceptDTO.Make(uuidString);

            Assert.True(dto.PublicId.UuidCount == 3);
            Assert.True(dto.PublicId.AsUuidArray[0] == Misc.g1);
            Assert.True(dto.PublicId.AsUuidArray[1] == Misc.g2);
            Assert.True(dto.PublicId.AsUuidArray[2] == Misc.g3);
        }
Esempio n. 5
0
        public void ConceptDTOCompareToTest()
        {
            {
                ConceptDTO a = Misc.CreateConceptDTO;
                ConceptDTO b = Misc.CreateConceptDTO;
                Assert.True(a.CompareTo(b) == 0);
            }

            {
                ConceptDTO a = Misc.CreateConceptDTO;
                ConceptDTO b = new ConceptDTO(new PublicId(Misc.g1, Misc.g3, Misc.g4));
                Assert.False(a.CompareTo(b) == 0);
            }
        }
Esempio n. 6
0
        public void ConceptDTOIsEquivalentTest()
        {
            {
                ConceptDTO a = Misc.CreateConceptDTO;
                ConceptDTO b = Misc.CreateConceptDTO;
                Assert.True(a.IsEquivalent(b));
            }

            {
                ConceptDTO a = Misc.CreateConceptDTO;
                ConceptDTO b = new ConceptDTO(new PublicId(Misc.other));
                Assert.False(a.IsEquivalent(b));
            }
        }
Esempio n. 7
0
        /// <summary>
        /// Read Tinkar items from file.
        /// </summary>
        /// <returns>Object[].</returns>
        public IEnumerable <ComponentDTO> GetComponents()
        {
            JObject jObject = this.ReadJsonObject();
            JArray  items   = (JArray)jObject["root"];

            foreach (JObject item in items)
            {
                String className = (String)item["class"];
                switch (className)
                {
                case ConceptChronologyDTO.JSONCLASSNAME:
                    yield return(ConceptChronologyDTO.Make(item));

                    break;

                case PatternChronologyDTO.JSONCLASSNAME:
                    yield return(PatternChronologyDTO.Make(item));

                    break;

                case SemanticChronologyDTO.JSONCLASSNAME:
                    yield return(SemanticChronologyDTO.Make(item));

                    break;

                case ConceptDTO.JSONCLASSNAME:
                    yield return(ConceptDTO.Make(item));

                    break;

                case PatternDTO.JSONCLASSNAME:
                    yield return(PatternDTO.Make(item));

                    break;

                case SemanticDTO.JSONCLASSNAME:
                    yield return(SemanticDTO.Make(item));

                    break;

                default:
                    throw new NotImplementedException($"Tinkar class {className} not known");
                }
            }
        }
Esempio n. 8
0
        public void ConceptDTOMarshalTest()
        {
            ConceptDTO dtoStart = Misc.CreateConceptDTO;

            MemoryStream ms = new MemoryStream();

            using (TinkarOutput output = new TinkarOutput(ms))
            {
                output.WriteField(dtoStart);
            }

            ms.Position = 0;
            using (TinkarInput input = new TinkarInput(ms))
            {
                ConceptDTO dtoRead = (ConceptDTO)input.GetField();
                Assert.True(dtoStart.CompareTo(dtoRead) == 0);
            }
        }
Esempio n. 9
0
        public void ConceptDTOJsonMarshal()
        {
            ConceptDTO   dtoStart = Misc.CreateConceptDTO;
            MemoryStream ms       = new MemoryStream();

            using (TinkarJsonOutput output = new TinkarJsonOutput(ms, true))
            {
                dtoStart.Marshal(output);
            }

            ms.Dump();
            ms.Position = 0;
            using (TinkarJsonInput input = new TinkarJsonInput(ms))
            {
                ConceptDTO dtoEnd = ConceptDTO.Make(input.ReadJsonObject());
                Assert.True(dtoStart.CompareTo(dtoEnd) == 0);
            }
        }
Esempio n. 10
0
        /// <summary>
        /// Read IJsonMarshalable values from the named child property.
        /// </summary>
        /// <param name="jObj">JSON parent container.</param>
        /// <returns>IJsonMarshalable values.</returns>
        private static IJsonMarshalable ReadJsonMarshable(this JObject jObj)
        {
            String actualClassName = jObj[ComponentFieldForJson.CLASS]?.Value <String>();

            switch (actualClassName)
            {
            case null:
                throw new Exception($"{TErr} Missing CLASS Declaration");

            case ConceptChronologyDTO.JSONCLASSNAME:
                return(ConceptChronologyDTO.Make(jObj));

            case ConceptDTO.JSONCLASSNAME:
                return(ConceptDTO.Make(jObj));

            case PatternChronologyDTO.JSONCLASSNAME:
                return(PatternChronologyDTO.Make(jObj));

            case PatternDTO.JSONCLASSNAME:
                return(PatternDTO.Make(jObj));

            case SemanticChronologyDTO.JSONCLASSNAME:
                return(SemanticChronologyDTO.Make(jObj));

            case SemanticDTO.JSONCLASSNAME:
                return(SemanticDTO.Make(jObj));

            case SpatialPointDTO.JSONCLASSNAME:
                return(SpatialPointDTO.Make(jObj));

            case PlanarPointDTO.JSONCLASSNAME:
                return(PlanarPointDTO.Make(jObj));

            default:
                throw new NotImplementedException($"Class {actualClassName} not known");
            }
        }
Esempio n. 11
0
        /// <summary>
        /// Create serialized output test cases.
        /// These can be read into java side to compare java and c# implementations.
        /// </summary>
        public List <ComponentDTO> CreateComponents()
        {
            List <ComponentDTO> retVal = new List <ComponentDTO>();

            {
                IPublicId pid = NextPublicId(1);
                // Write ConceptChronologyDTO.
                ConceptChronologyDTO dto = new ConceptChronologyDTO(
                    pid,
                    new ConceptVersionDTO[]
                {
                    new ConceptVersionDTO(pid, NextStamp()),
                    new ConceptVersionDTO(pid, NextStamp())
                }.ToImmutableArray()
                    );
                retVal.Add(dto);
            }
            {
                ConceptDTO dto = new ConceptDTO(NextPublicId(4));
                retVal.Add(dto);
            }
            {
                IPublicId            pid = NextPublicId(1);
                PatternChronologyDTO dto = new PatternChronologyDTO(
                    pid,
                    new PatternVersionDTO[]
                {
                    new PatternVersionDTO(
                        pid,
                        NextStamp(),
                        NextPublicId(4),
                        NextPublicId(5),
                        new FieldDefinitionDTO[] {
                        new FieldDefinitionDTO(
                            NextPublicId(4),
                            NextPublicId(3),
                            NextPublicId(2)
                            ),
                        new FieldDefinitionDTO(
                            NextPublicId(1),
                            NextPublicId(2),
                            NextPublicId(3)
                            )
                    }.ToImmutableArray()
                        )
                }.ToImmutableArray()
                    );

                retVal.Add(dto);
            }
            {
                PatternDTO dto = new PatternDTO(NextPublicId(2));
                retVal.Add(dto);
            }
            {
                IPublicId componentPublicId           = NextPublicId(4);
                IPublicId patternForSemanticPublicId  = NextPublicId(3);
                IPublicId referencedComponentPublicId = NextPublicId(2);

                SemanticChronologyDTO dto = new SemanticChronologyDTO(
                    componentPublicId,
                    patternForSemanticPublicId,
                    referencedComponentPublicId,
                    new SemanticVersionDTO[]
                {
                    new SemanticVersionDTO(
                        componentPublicId,
                        NextStamp(),
                        new Object[]
                    {
                        true, false,
                        new byte[] { }, new byte[] { 1, 2, 3 },
                        0.3F,
                        -1, 0, 1,
                        "abcdef",
                        new DateTime(2020, 1, 2),
                        new SpatialPointDTO(1, 2, 3),
                        new PlanarPointDTO(-1, -2)
                    }.ToImmutableArray()
                        )
                }.ToImmutableArray()
                    );

                retVal.Add(dto);
            }
            {
                SemanticDTO dto = new SemanticDTO(NextPublicId(4));
                retVal.Add(dto);
            }
            {
                SemanticVersionDTO dto =
                    new SemanticVersionDTO(
                        NextPublicId(3),
                        NextStamp(),
                        new Object[]
                {
                    true, false,
                    new byte[] { }, new byte[] { 1, 2, 3 },
                    0.3F,
                    -1, 0, 1,
                    "abcdef",
                    new DateTime(2020, 1, 2),
                    new SpatialPointDTO(1, 2, 3),
                    new PlanarPointDTO(-1, -2)
                }.ToImmutableArray()
                        );
            }
            return(retVal);
        }
Esempio n. 12
0
        public void ConceptDTOFieldsTest()
        {
            ConceptDTO dtoStart = Misc.CreateConceptDTO;

            Misc.Compare(dtoStart.PublicId.AsUuidArray, Misc.g1, Misc.g2, Misc.g3, Misc.g4);
        }
Esempio n. 13
0
        /// <summary>
        /// Read an array or Object fields.
        /// </summary>
        /// <returns>Object[].</returns>
        public Object GetField()
        {
            FieldDataType token;

            try
            {
                token = (FieldDataType)this.reader.ReadByte();
            }
            catch
            {
                return(null);
            }

            switch (token)
            {
            case FieldDataType.ConceptChronologyType:
                return(ConceptChronologyDTO.Make(this));

            case FieldDataType.PatternChronologyType:
                return(PatternChronologyDTO.Make(this));

            case FieldDataType.SemanticChronologyType:
                return(SemanticChronologyDTO.Make(this));

            case FieldDataType.ConceptVersionType:
                throw new NotImplementedException();

            case FieldDataType.PatternVersionType:
                throw new NotImplementedException();

            case FieldDataType.SemanticVersionType:
                throw new NotImplementedException();

            case FieldDataType.StampType:
                throw new NotImplementedException();

            case FieldDataType.ConceptType:
                return(ConceptDTO.Make(this));

            case FieldDataType.PatternType:
                return(PatternDTO.Make(this));

            case FieldDataType.SemanticType:
                return(SemanticDTO.Make(this));

            case FieldDataType.DiTreeType:
                return(DiTreeDTO.Make(this));

            case FieldDataType.DiGraphType:
                return(DiGraphDTO.Make(this));

            case FieldDataType.VertexType:
                throw new NotImplementedException();

            case FieldDataType.ComponentIdList:
                return(this.GetPublicIdList());

            case FieldDataType.ComponentIdSet:
                return(this.GetPublicIdSet());

            case FieldDataType.PlanarPoint:
                return(new PlanarPointDTO(this.GetInt32(), this.GetInt32()));

            case FieldDataType.SpatialPoint:
                return(new SpatialPointDTO(this.GetInt32(), this.GetInt32(), this.GetInt32()));

            case FieldDataType.StringType:
                return(this.GetUTF());

            case FieldDataType.IntegerType:
                return(this.GetInt32());

            case FieldDataType.FloatType:
                return(this.GetSingle());

            case FieldDataType.BooleanType:
                return(this.GetBoolean());

            case FieldDataType.ByteArrayType:
                return(this.GetByteArray());

            case FieldDataType.ObjectArrayType:
                return(this.GetObjects().ToArray());

            case FieldDataType.InstantType:
                return(this.GetInstant());

            default:
                throw new NotImplementedException($"FieldDataType {token} not known");
            }
        }