public void AddEmbeddedResource(string key, CrichtonRepresentor resource)
        {
            if (!representor.EmbeddedResources.ContainsKey(key))
                representor.EmbeddedResources[key] = new List<CrichtonRepresentor>();

            representor.EmbeddedResources[key].Add(resource);
        }
        private JObject CreateJObjectForRepresentor(CrichtonRepresentor representor)
        {
            var jObject = SerializeAttributesToJObject(representor);

            if (!String.IsNullOrWhiteSpace(representor.SelfLink))
            {
                AddLinkFromTransition(jObject, new CrichtonTransition {
                    Rel = "self", Uri = representor.SelfLink
                });
            }

            foreach (var transition in representor.Transitions.Where(t => !ReservedLinkRels.Contains(t.Rel)))
            {
                AddLinkFromTransition(jObject, transition);
            }

            // embedded resources and Collections both require _embedded
            if (representor.EmbeddedResources.Any() || representor.Collection.Any())
            {
                var embeddedJObject = new JObject();
                jObject.Add("_embedded", embeddedJObject);

                // create embedded resources
                foreach (var embeddedResourceKey in representor.EmbeddedResources.Keys)
                {
                    var list = representor.EmbeddedResources[embeddedResourceKey];
                    AddRepresentorsToEmbedded(list, embeddedJObject, embeddedResourceKey);
                }

                // add Collection objects to _embedded.items
                AddRepresentorsToEmbedded(representor.Collection.ToList(), embeddedJObject, "items");
            }

            return(jObject);
        }
 public void Init()
 {
     Fixture     = GetFixture();
     representor = Fixture.Create <CrichtonRepresentor>();
     sut         = new NavigateToRepresentorQueryStep(representor);
     requestor   = MockRepository.GenerateMock <ITransitionRequestHandler>();
 }
Пример #4
0
        /// <summary>
        /// Executes the representor
        /// </summary>
        /// <param name="currentRepresentor">the currentRepresentor</param>
        /// <param name="transitionRequestHandler">the transitionRequestHandler</param>
        /// <returns>crichton representor</returns>
        public Task <CrichtonRepresentor> ExecuteAsync(CrichtonRepresentor currentRepresentor, ITransitionRequestHandler transitionRequestHandler)
        {
            var transition = new CrichtonTransition()
            {
                Uri = Url
            };

            return(transitionRequestHandler.RequestTransitionAsync(transition));
        }
        /// <summary>
        /// Initializes a new instance of the NavigateToRelativeUrlQueryStep class.
        /// </summary>
        /// <param name="representor">the representor</param>
        public NavigateToRepresentorQueryStep(CrichtonRepresentor representor)
        {
            if (representor == null)
            {
                throw new ArgumentNullException("representor");
            }

            this.Representor = representor;
        }
Пример #6
0
        /// <summary>
        /// Serializes the representor
        /// </summary>
        /// <param name="representor">the representor</param>
        /// <returns>serialized string</returns>
        public virtual string Serialize(CrichtonRepresentor representor)
        {
            if (representor == null)
            {
                throw new ArgumentNullException("representor");
            }

            return(SerializeAttributesToJObject(representor).ToString());
        }
        /// <summary>
        /// Serializes the representor
        /// </summary>
        /// <param name="representor">the representor</param>
        /// <returns>serialized string</returns>
        public override string Serialize(CrichtonRepresentor representor)
        {
            if (representor == null)
            {
                throw new ArgumentNullException("representor");
            }

            var jObject = CreateJObjectForRepresentor(representor);

            return(jObject.ToString());
        }
        public CrichtonTransition LocateTransition(CrichtonRepresentor currentRepresentor)
        {
            if (currentRepresentor == null)
            {
                throw new ArgumentNullException("currentRepresentor");
            }

            var transition = currentRepresentor.Transitions.Single(selectionFunc);

            return(transition);
        }
        /// <summary>
        /// Creates a query
        /// </summary>
        /// <param name="representor">the representor</param>
        /// <returns>created query</returns>
        public IHypermediaQuery CreateQuery(CrichtonRepresentor representor = null)
        {
            var query = new HypermediaQuery();

            if (representor == null)
            {
                return(query);
            }

            query.AddStep(new NavigateToRepresentorQueryStep(representor));
            return(query);
        }
Пример #10
0
        /// <summary>
        /// Returns a new query being added a NavigateToRepresentorQueryStep.
        /// </summary>
        /// <param name="hypermediaQuery">this IHypermediaQuery</param>
        /// <param name="representor">the representor</param>
        /// <returns>the query</returns>
        public static IHypermediaQuery WithRepresentor(this IHypermediaQuery hypermediaQuery,
                                                       CrichtonRepresentor representor)
        {
            if (representor == null)
            {
                throw new ArgumentNullException("representor");
            }

            var query = hypermediaQuery.Clone();

            query.AddStep(new NavigateToRepresentorQueryStep(representor));
            return(query);
        }
Пример #11
0
        protected JObject SerializeAttributesToJObject(CrichtonRepresentor representor)
        {
            var jObject = new JObject();

            if (representor.Attributes != null)
            {
                foreach (var property in representor.Attributes.Properties().Where(p => !IgnoredAttributes.Contains(p.Name)))
                {
                    jObject.Add(property.Name, property.Value);
                }
            }

            return(jObject);
        }
        /// <summary>
        /// Executes the representor
        /// </summary>
        /// <param name="currentRepresentor">the currentRepresentor</param>
        /// <param name="transitionRequestHandler">the transitionRequestHandler</param>
        /// <returns>crichton representor</returns>
        public Task <CrichtonRepresentor> ExecuteAsync(CrichtonRepresentor currentRepresentor, ITransitionRequestHandler transitionRequestHandler)
        {
            if (currentRepresentor == null)
            {
                throw new ArgumentNullException("currentRepresentor");
            }
            if (transitionRequestHandler == null)
            {
                throw new ArgumentNullException("transitionRequestHandler");
            }

            var transition = LocateTransition(currentRepresentor);

            return(transitionRequestHandler.RequestTransitionAsync(transition));
        }
Пример #13
0
        private static JObject CreateJObjectForRepresentor(CrichtonRepresentor representor)
        {
            var jObject = new JObject();

            if (!String.IsNullOrWhiteSpace(representor.SelfLink)) AddLink(jObject, "self", representor.SelfLink, null);

            foreach (var transition in representor.Transitions.Where(t => !ReservedLinkRels.Contains(t.Rel)))
            {
                AddLink(jObject, transition.Rel, transition.Uri, transition.Title);
            }

            // add a root property for each property on data
            foreach (var property in representor.Attributes.Properties().Where(p => !ReservedAttributes.Contains(p.Name)))
            {
                jObject.Add(property.Name, property.Value);
            }

            // create embedded resources
            if (representor.EmbeddedResources.Any())
            {
                var embeddedJObject = new JObject();

                foreach (var embeddedResourceKey in representor.EmbeddedResources.Keys)
                {
                    var list = representor.EmbeddedResources[embeddedResourceKey];
                    if (list.Count == 1)
                    {
                        // single embedded resources are resources
                        embeddedJObject.Add(embeddedResourceKey, CreateJObjectForRepresentor(list.Single()));
                    }
                    else if (list.Count > 1)
                    {
                        // multiple embedded resources are an array of resources
                        var array = new JArray();
                        foreach (var resource in list)
                        {
                            array.Add(CreateJObjectForRepresentor(resource));
                        }
                        embeddedJObject.Add(embeddedResourceKey, array);
                    }
                }

                jObject.Add("_embedded", embeddedJObject);
            }

            return jObject;
        }
Пример #14
0
        /// <summary>
        /// Execute the query
        /// </summary>
        /// <param name="requestHandler">the requestHandler</param>
        /// <returns>task including a CrichtonRepresentor</returns>
        public async Task <CrichtonRepresentor> ExecuteAsync(ITransitionRequestHandler requestHandler)
        {
            if (requestHandler == null)
            {
                throw new ArgumentNullException("requestHandler");
            }

            CrichtonRepresentor representor = null;

            // ReSharper disable once LoopCanBeConvertedToQuery
            foreach (var step in Steps)
            {
                representor = await step.ExecuteAsync(representor, requestHandler);
            }

            return(representor);
        }
Пример #15
0
        /// <summary>
        /// Executes the representor
        /// </summary>
        /// <param name="currentRepresentor">the currentRepresentor</param>
        /// <param name="transitionRequestHandler">the transitionRequestHandler</param>
        /// <returns>crichton representor</returns>
        public Task <CrichtonRepresentor> ExecuteAsync(CrichtonRepresentor currentRepresentor, ITransitionRequestHandler transitionRequestHandler)
        {
            if (currentRepresentor == null)
            {
                throw new ArgumentNullException("currentRepresentor");
            }
            if (transitionRequestHandler == null)
            {
                throw new ArgumentNullException("transitionRequestHandler");
            }

            var selfTransition = new CrichtonTransition()
            {
                Uri = currentRepresentor.SelfLink
            };

            return(transitionRequestHandler.RequestTransitionAsync(selfTransition));
        }
Пример #16
0
 public void Init()
 {
     sut = new HalSerializer();
     Fixture = GetFixture();
     representor = Fixture.Create<CrichtonRepresentor>();
     builderFactoryMethod = () => MockRepository.GenerateMock<IRepresentorBuilder>();
 }
Пример #17
0
        public void Serialize_WorksWithEmptyRepresentor()
        {
            var representor = new CrichtonRepresentor();

            sut.Serialize(representor);
        }
 /// <summary>
 /// Executes the representor
 /// </summary>
 /// <param name="currentRepresentor">the currentRepresentor</param>
 /// <param name="transitionRequestHandler">the transitionRequestHandler</param>
 /// <returns>crichton representor</returns>
 public async Task <CrichtonRepresentor> ExecuteAsync(CrichtonRepresentor currentRepresentor, ITransitionRequestHandler transitionRequestHandler)
 {
     return(Representor);
 }
 public void Init()
 {
     sut = new CrichtonRepresentor();
     Fixture = GetFixture();
 }
Пример #20
0
        public string Serialize(CrichtonRepresentor representor)
        {
            var jObject = CreateJObjectForRepresentor(representor);

            return jObject.ToString();
        }
Пример #21
0
 public RepresentorBuilder()
 {
     representor = new CrichtonRepresentor();
 }
        /// <summary>
        /// Executes the representor
        /// </summary>
        /// <param name="currentRepresentor">the currentRepresentor</param>
        /// <param name="transitionRequestHandler">the transitionRequestHandler</param>
        /// <returns>crichton representor</returns>
        public Task <CrichtonRepresentor> ExecuteAsync(CrichtonRepresentor currentRepresentor, ITransitionRequestHandler transitionRequestHandler)
        {
            var transition = LocateTransition(currentRepresentor);

            return(transitionRequestHandler.RequestTransitionAsync(transition, Data));
        }
 public void Init()
 {
     sut     = new CrichtonRepresentor();
     Fixture = GetFixture();
 }