public static MapRepresentation Create(IOidStrategy oidStrategy, HttpRequestMessage req, ContextFacade contextFacade, IList<ContextFacade> contexts, Format format, RestControlFlags flags, MediaTypeHeaderValue mt) {
            var memberValues = contexts.Select(c => new OptionalProperty(c.Id, GetMap(oidStrategy, req, c, flags))).ToList();
            IObjectFacade target = contexts.First().Target;
            MapRepresentation mapRepresentation;

            if (format == Format.Full) {
                var tempProperties = new List<OptionalProperty>();

                if (!string.IsNullOrEmpty(contextFacade?.Reason)) {
                    tempProperties.Add(new OptionalProperty(JsonPropertyNames.XRoInvalidReason, contextFacade.Reason));
                }

                var dt = new OptionalProperty(JsonPropertyNames.DomainType, target.Specification.DomainTypeName(oidStrategy));
                tempProperties.Add(dt);

                var members = new OptionalProperty(JsonPropertyNames.Members, Create(memberValues.ToArray()));
                tempProperties.Add(members);
                mapRepresentation = Create(tempProperties.ToArray());
            }
            else {
                mapRepresentation = Create(memberValues.ToArray());
            }

            mapRepresentation.SetContentType(mt);

            return mapRepresentation;
        }
 public UriMtHelper(IOidStrategy oidStrategy, HttpRequestMessage req, IObjectFacade objectFacade) : this(oidStrategy ,req) {
     this.objectFacade = objectFacade;
     spec = objectFacade.Specification;
     IOidTranslation oid = oidStrategy.FrameworkFacade.OidTranslator.GetOidTranslation(objectFacade);
     cachedId = oid.InstanceId;
     CachedType = oid.DomainType;
 }
 public UriMtHelper(IOidStrategy oidStrategy, HttpRequestMessage req, IMenuFacade menuFacade) : this(oidStrategy, req) {
     //this.objectFacade = objectFacade;
     //spec = objectFacade.Specification;
     //IOidTranslation oid = oidStrategy.FrameworkFacade.OidTranslator.GetOidTranslation(objectFacade);
     //cachedId = oid.InstanceId;
     CachedType = menuFacade.Id;
 }
        public static MapRepresentation Create(IOidStrategy oidStrategy, HttpRequestMessage req, IList<ContextFacade> contexts, Format format, RestControlFlags flags, MediaTypeHeaderValue mt) {
            OptionalProperty[] memberValues = contexts.Select(c => new OptionalProperty(c.Id, GetMap(oidStrategy ,req, c, flags))).ToArray();
            IObjectFacade target = contexts.First().Target;
            MapRepresentation mapRepresentation;

            if (format == Format.Full) {
                var tempProperties = new List<OptionalProperty>();

                if (flags.SimpleDomainModel) {
                    var dt = new OptionalProperty(JsonPropertyNames.DomainType, target.Specification.DomainTypeName(oidStrategy));
                    tempProperties.Add(dt);
                }

                if (flags.FormalDomainModel) {
                    var links = new OptionalProperty(JsonPropertyNames.Links, new[] {
                        Create(new OptionalProperty(JsonPropertyNames.Rel, RelValues.DescribedBy),
                            new OptionalProperty(JsonPropertyNames.Href, new UriMtHelper(oidStrategy, req, target.Specification).GetDomainTypeUri()))
                    });
                    tempProperties.Add(links);
                }

                var members = new OptionalProperty(JsonPropertyNames.Members, Create(memberValues));
                tempProperties.Add(members);
                mapRepresentation = Create(tempProperties.ToArray());
            }
            else {
                mapRepresentation = Create(memberValues);
            }

            mapRepresentation.SetContentType(mt);

            return mapRepresentation;
        }
        public static MapRepresentation Create(IOidStrategy oidStrategy, HttpRequestMessage req, ContextFacade context, Format format, RestControlFlags flags, MediaTypeHeaderValue mt) {
            var objectContext = context as ObjectContextFacade;
            var actionResultContext = context as ActionResultContextFacade;
            MapRepresentation mapRepresentation;


            if (objectContext != null) {
                List<OptionalProperty> optionalProperties = objectContext.VisibleProperties.Where(p => p.Reason != null || p.ProposedValue != null).Select(c => new OptionalProperty(c.Id, GetMap(oidStrategy ,req, c, flags))).ToList();
                if (!string.IsNullOrEmpty(objectContext.Reason)) {
                    optionalProperties.Add(new OptionalProperty(JsonPropertyNames.XRoInvalidReason, objectContext.Reason));
                }
                mapRepresentation = Create(optionalProperties.ToArray());
            }
            else if (actionResultContext != null) {
                List<OptionalProperty> optionalProperties = actionResultContext.ActionContext.VisibleParameters.Select(c => new OptionalProperty(c.Id, GetMap(oidStrategy ,req, c, flags))).ToList();

                if (!string.IsNullOrEmpty(actionResultContext.Reason)) {
                    optionalProperties.Add(new OptionalProperty(JsonPropertyNames.XRoInvalidReason, actionResultContext.Reason));
                }
                mapRepresentation = Create(optionalProperties.ToArray());
            }
            else {
                mapRepresentation = GetMap(oidStrategy ,req, context, flags);
            }


            mapRepresentation.SetContentType(mt);


            return mapRepresentation;
        }
 public UriMtHelper(IOidStrategy oidStrategy, HttpRequestMessage req, PropertyTypeContextFacade propertyContext)
     : this(oidStrategy ,req) {
     assoc = propertyContext.Property;
     spec = propertyContext.OwningSpecification;
     cachedId = "";
     CachedType = spec.DomainTypeName(oidStrategy);
 }
 public RestSnapshot(IOidStrategy oidStrategy, MenuContextFacade menus, HttpRequestMessage req, RestControlFlags flags)
     : this(oidStrategy, req, true) {
     populator = () => {
         Representation = ListRepresentation.Create(oidStrategy, menus, req, flags);
         SetHeaders();
     };
 }
        public static InlineCollectionRepresentation Create(IOidStrategy oidStrategy, HttpRequestMessage req, PropertyContextFacade propertyContext, IList<OptionalProperty> optionals, RestControlFlags flags, bool asTableColumn) {
            var collectionRepresentationStrategy = AbstractCollectionRepresentationStrategy.GetStrategy(asTableColumn, true, oidStrategy, req, propertyContext, flags);

            int? size = collectionRepresentationStrategy.GetSize();

            if (size != null) {
                optionals.Add(new OptionalProperty(JsonPropertyNames.Size, size));
            }

            var value = collectionRepresentationStrategy.GetValue();

            if (value != null) {
                optionals.Add(new OptionalProperty(JsonPropertyNames.Value, value));
            }


            var actions = collectionRepresentationStrategy.GetActions();

            if (actions.Length > 0) {
                var members = RestUtils.CreateMap(actions.ToDictionary(m => m.Id, m => (object)m));
                optionals.Add(new OptionalProperty(JsonPropertyNames.Members, members));
            }


            if (optionals.Count == 0) {
                return new InlineCollectionRepresentation(oidStrategy, collectionRepresentationStrategy);
            }
            return CreateWithOptionals<InlineCollectionRepresentation>(new object[] {oidStrategy, collectionRepresentationStrategy}, optionals);
        }
 protected HomePageRepresentation(IOidStrategy oidStrategy, HttpRequestMessage req, RestControlFlags flags)
     : base(oidStrategy, flags) {
     SelfRelType = new HomePageRelType(RelValues.Self, new UriMtHelper(oidStrategy, req));
     SetLinks(req);
     SetExtensions();
     SetHeader();
 }
 public ActionRepresentationStrategy(IOidStrategy oidStrategy, HttpRequestMessage req, ActionContextFacade actionContext, RestControlFlags flags)
     : base(oidStrategy, flags) {
     this.req = req;
     this.actionContext = actionContext;
     self = new MemberRelType(RelValues.Self, new UriMtHelper(oidStrategy, req, actionContext));
     parameterList = GetParameterList();
 }
 protected MemberRepresentationStrategy(IOidStrategy oidStrategy, HttpRequestMessage req, PropertyContextFacade propertyContext, RestControlFlags flags)
     : base(oidStrategy ,flags) {
     this.req = req;
     this.propertyContext = propertyContext;
     objectUri = new UriMtHelper(oidStrategy ,req, propertyContext);
     self = new MemberRelType(RelValues.Self, new UriMtHelper(oidStrategy , req, propertyContext));
 }
 public static InlinePropertyRepresentation Create(IOidStrategy oidStrategy, HttpRequestMessage req, PropertyContextFacade propertyContext, IList<OptionalProperty> optionals, RestControlFlags flags) {
     if (!RestUtils.IsBlobOrClob(propertyContext.Specification) && !RestUtils.IsAttachment(propertyContext.Specification)) {
         optionals.Add(new OptionalProperty(JsonPropertyNames.Value, GetPropertyValue(oidStrategy ,req, propertyContext.Property, propertyContext.Target, flags)));
     }
     RestUtils.AddChoices(oidStrategy , req, propertyContext, optionals, flags);
     return CreateWithOptionals<InlinePropertyRepresentation>(new object[] {oidStrategy, new PropertyRepresentationStrategy(oidStrategy ,req, propertyContext, flags)}, optionals);
 }
 public RestSnapshot(IOidStrategy oidStrategy, ActionResultContextFacade actionResultContext, HttpRequestMessage req, RestControlFlags flags)
     : this(oidStrategy, actionResultContext, req, true) {
     populator = () => {
         Representation = ActionResultRepresentation.Create(oidStrategy, req, actionResultContext, flags);
         SetHeaders();
     };
 }
 private RestSnapshot(IOidStrategy oidStrategy, HttpRequestMessage req, bool validateAsJson) {
     this.oidStrategy = oidStrategy;
     requestMessage = req;
     if (validateAsJson) {
         ValidateIncomingMediaTypeAsJson();
     }
 }
 protected MemberTypeRepresentation(IOidStrategy oidStrategy, HttpRequestMessage req, PropertyTypeContextFacade propertyContext, RestControlFlags flags)
     : base(oidStrategy, flags) {
     SetScalars(propertyContext);
     SelfRelType = new TypeMemberRelType(RelValues.Self, new UriMtHelper(oidStrategy, req, propertyContext));
     SetExtensions();
     SetHeader();
 }
 public AttachmentRepresentation(IOidStrategy oidStrategy, HttpRequestMessage req, PropertyContextFacade propertyContext, RestControlFlags flags)
     : base(oidStrategy, flags) {
     SetContentType(propertyContext);
     SetContentDisposition(propertyContext);
     SetStream(propertyContext);
     SetHeader(propertyContext.Target);
 }
 public static InlineCollectionRepresentation Create(IOidStrategy oidStrategy, HttpRequestMessage req, PropertyContextFacade propertyContext, IList<OptionalProperty> optionals, RestControlFlags flags) {
     var collectionRepresentationStrategy = new CollectionRepresentationStrategy(oidStrategy, req, propertyContext, flags);
     if (optionals.Count == 0) {
         return new InlineCollectionRepresentation(oidStrategy, collectionRepresentationStrategy);
     }
     return CreateWithOptionals<InlineCollectionRepresentation>(new object[] {oidStrategy, collectionRepresentationStrategy}, optionals);
 }
 protected ParameterRepresentation(IOidStrategy oidStrategy, HttpRequestMessage req, IObjectFacade objectFacade, IActionParameterFacade parameter, RestControlFlags flags)
     : base(oidStrategy, flags) {
     SetName(parameter);
     SetExtensions(req, objectFacade, parameter, flags);
     SetLinks(req, objectFacade, parameter);
     SetHeader(objectFacade);
 }
 protected MemberAbstractRepresentation(IOidStrategy oidStrategy, MemberRepresentationStrategy strategy)
     : base(oidStrategy ,strategy.GetFlags()) {
     SelfRelType = strategy.GetSelf();
     Id = strategy.GetId();
     Links = strategy.GetLinks(false);
     Extensions = strategy.GetExtensions();
     SetHeader(strategy.GetTarget());
 }
 protected InlinePropertyRepresentation(IOidStrategy oidStrategy, AbstractPropertyRepresentationStrategy strategy)
     : base(oidStrategy, strategy.GetFlags()) {
     MemberType = MemberTypes.Property;
     Id = strategy.GetId();
     Links = strategy.GetLinks();
     Extensions = strategy.GetExtensions();
     SetHeader(strategy.GetTarget());
 }
 private ListRepresentation(IOidStrategy oidStrategy, ITypeFacade[] specs, HttpRequestMessage req, RestControlFlags flags)
     : base(oidStrategy, flags) {
     Value = specs.Select(s => CreateDomainLink(oidStrategy, req, s)).ToArray();
     SelfRelType = new TypesRelType(RelValues.Self, new UriMtHelper(oidStrategy, req));
     SetLinks(req);
     SetExtensions();
     SetHeader(true);
 }
 protected ListRepresentation(IOidStrategy oidStrategy, IMenuFacade[] menus, HttpRequestMessage req, RestControlFlags flags)
     : base(oidStrategy, flags) {
     Value = menus.Select(c => CreateMenuLink(oidStrategy, req, c)).ToArray();
     SelfRelType = new ListRelType(RelValues.Self, SegmentValues.Services, new UriMtHelper(oidStrategy, req));
     SetLinks(req);
     SetExtensions();
     SetHeader(true);
 }
 protected ListRepresentation(IOidStrategy oidStrategy, ListContextFacade listContext, HttpRequestMessage req, RestControlFlags flags)
     : base(oidStrategy, flags) {
     Value = listContext.List.Select(c => CreateObjectLink(oidStrategy, req, c)).ToArray();
     SelfRelType = new ListRelType(RelValues.Self, SegmentValues.Services, new UriMtHelper(oidStrategy, req, listContext.ElementType));
     SetLinks(req);
     SetExtensions();
     SetHeader(listContext.IsListOfServices);
 }
 protected InlineCollectionRepresentation(IOidStrategy oidStrategy, AbstractCollectionRepresentationStrategy strategy)
     : base(oidStrategy, strategy.GetFlags()) {
     MemberType = MemberTypes.Collection;
     Id = strategy.GetId();
     Links = strategy.GetLinks(true);
     Extensions = strategy.GetExtensions();
     SetHeader(strategy.GetTarget());
 }
 public RestSnapshot(IOidStrategy oidStrategy, PropertyContextFacade propertyContext, ListContextFacade listContext, HttpRequestMessage req, RestControlFlags flags)
     : this(oidStrategy,req, true) {
     logger.DebugFormat("RestSnapshot:propertyprompt");
     populator = () => {
         representation = PromptRepresentation.Create(oidStrategy ,propertyContext, listContext, req, flags);
         SetHeaders();
     };
 }
 public RestSnapshot(IOidStrategy oidStrategy, IMenuFacade menu, HttpRequestMessage req, RestControlFlags flags, HttpStatusCode httpStatusCode = HttpStatusCode.OK)
     : this(oidStrategy, req, true) {
     populator = () => {
         HttpStatusCode = httpStatusCode;
         Representation = MenuRepresentation.Create(oidStrategy, menu, req, flags);
         SetHeaders();
     };
 }
 protected TypeActionInvokeRepresentation(IOidStrategy oidStrategy, HttpRequestMessage req, TypeActionInvokeContext context, RestControlFlags flags)
     : base(oidStrategy, flags) {
     SelfRelType = new TypeActionInvokeRelType(RelValues.Self, new UriMtHelper(oidStrategy, req, context));
     SetScalars(context);
     SetLinks(req, context);
     SetExtensions();
     SetHeader();
 }
 public RestSnapshot(IOidStrategy oidStrategy, ObjectContextFacade objectContext, HttpRequestMessage req, RestControlFlags flags, HttpStatusCode httpStatusCode = HttpStatusCode.OK)
     : this(oidStrategy, objectContext, req, true) {
     populator = () => {
         HttpStatusCode = httpStatusCode;
         Representation = ObjectRepresentation.Create(oidStrategy, objectContext, req, flags);
         SetHeaders();
     };
 }
 protected ActionResultRepresentation(IOidStrategy oidStrategy, HttpRequestMessage req, ActionResultContextFacade actionResult, RestControlFlags flags)
     : base(oidStrategy, flags) {
     SelfRelType = new ActionResultRelType(RelValues.Self, new UriMtHelper(OidStrategy, req, actionResult.ActionContext));
     SetResultType(actionResult);
     SetLinks(req, actionResult);
     SetExtensions();
     SetHeader();
 }
 private UserRepresentation(IOidStrategy oidStrategy, HttpRequestMessage req, IPrincipal user, RestControlFlags flags)
     : base(oidStrategy, flags) {
     SelfRelType = new UserRelType(RelValues.Self, new UriMtHelper(oidStrategy, req));
     SetLinks(new HomePageRelType(RelValues.Up, new UriMtHelper(oidStrategy, req)));
     SetScalars(user);
     SetExtensions();
     SetHeader();
 }
Example #31
0
 public static object GetChoiceValue(IOidStrategy oidStrategy, HttpRequestMessage req, IObjectFacade item, IActionParameterFacade parameter, RestControlFlags flags)
 {
     return(GetChoiceValue(oidStrategy, item, () => new ChoiceRelType(parameter, new UriMtHelper(oidStrategy, req, item)), flags));
 }
Example #32
0
 public static Representation Create(IOidStrategy oidStrategy, ParameterContextFacade parmContext, HttpRequestMessage req, RestControlFlags flags)
 {
     return(new PromptRepresentation(oidStrategy, parmContext, req, flags));
 }
Example #33
0
 public object GetValue(IFrameworkFacade facade, UriMtHelper helper, IOidStrategy oidStrategy)
 {
     return(value);
 }
 public static Representation Create(IOidStrategy oidStrategy, HttpRequestMessage req, PropertyContextFacade propertyContext, RestControlFlags flags)
 {
     return(new AttachmentRepresentation(oidStrategy, req, propertyContext, flags));
 }
 private static UriMtHelper GetHelper(IOidStrategy oidStrategy, HttpRequest req, ObjectContextFacade objectContext) => new UriMtHelper(oidStrategy, req, objectContext.Target);
Example #36
0
        public static MapRepresentation GetExtensions(string friendlyname,
                                                      string description,
                                                      string pluralName,
                                                      string domainType,
                                                      bool?isService,
                                                      bool?hasParams,
                                                      bool?optional,
                                                      int?maxLength,
                                                      string pattern,
                                                      int?memberOrder,
                                                      DataType?dataType,
                                                      string presentationHint,
                                                      IDictionary <string, object> customExtensions,
                                                      ITypeFacade returnType,
                                                      ITypeFacade elementType,
                                                      IOidStrategy oidStrategy,
                                                      bool useDateOverDateTime)
        {
            var exts = new Dictionary <string, object> {
                { JsonPropertyNames.FriendlyName, friendlyname },
                { JsonPropertyNames.Description, description }
            };

            if (pluralName != null)
            {
                exts.Add(JsonPropertyNames.PluralName, pluralName);
            }

            if (domainType != null)
            {
                exts.Add(JsonPropertyNames.DomainType, domainType);
            }

            if (hasParams != null)
            {
                exts.Add(JsonPropertyNames.HasParams, hasParams);
            }

            if (isService != null)
            {
                exts.Add(JsonPropertyNames.IsService, isService);
            }

            if (optional != null)
            {
                exts.Add(JsonPropertyNames.Optional, optional);
            }

            if (memberOrder != null)
            {
                exts.Add(JsonPropertyNames.MemberOrder, memberOrder);
            }

            if (dataType != null)
            {
                exts.Add(JsonPropertyNames.CustomDataType, dataType.ToString().ToLower());
            }

            if (!string.IsNullOrEmpty(presentationHint))
            {
                exts.Add(JsonPropertyNames.PresentationHint, presentationHint);
            }


            if (returnType != null && !returnType.IsVoid)
            {
                Tuple <string, string> jsonDataType = SpecToTypeAndFormatString(returnType, oidStrategy, useDateOverDateTime);
                exts.Add(JsonPropertyNames.ReturnType, jsonDataType.Item1);

                if (jsonDataType.Item2 != null)
                {
                    exts.Add(JsonPropertyNames.Format, jsonDataType.Item2);
                }

                if (jsonDataType.Item1 == PredefinedJsonType.String.ToRoString())
                {
                    exts.Add(JsonPropertyNames.MaxLength, maxLength ?? 0);
                    exts.Add(JsonPropertyNames.Pattern, pattern ?? "");
                }
                // blob and clobs are arrays hence additional checks
                else if (returnType.IsCollection && (jsonDataType.Item1 == PredefinedJsonType.List.ToRoString() || jsonDataType.Item1 == PredefinedJsonType.Set.ToRoString()))
                {
                    exts.Add(JsonPropertyNames.ElementType, SpecToTypeAndFormatString(elementType, oidStrategy, useDateOverDateTime).Item1);
                    exts.Add(JsonPropertyNames.PluralName, elementType.PluralName);
                }
            }

            if (customExtensions != null)
            {
                foreach (var kvp in customExtensions)
                {
                    exts.Add(kvp.Key, kvp.Value);
                }
            }

            return(CreateMap(exts));
        }
Example #37
0
 public object GetChoiceValue(IOidStrategy oidStrategy, HttpRequestMessage req, IObjectFacade item, RestControlFlags flags)
 {
     return(association != null?RestUtils.GetChoiceValue(oidStrategy, req, item, association, flags) : RestUtils.GetChoiceValue(oidStrategy, req, item, parameter, flags));
 }
Example #38
0
 public static ListRepresentation Create(IOidStrategy oidStrategy, ListContextFacade listContext, HttpRequestMessage req, RestControlFlags flags)
 {
     return(new ListRepresentation(oidStrategy, listContext, req, flags));
 }
Example #39
0
 private LinkRepresentation CreateDomainLink(IOidStrategy oidStrategy, HttpRequestMessage req, ITypeFacade spec)
 {
     return(LinkRepresentation.Create(oidStrategy, new DomainTypeRelType(new UriMtHelper(oidStrategy, req, spec)), Flags));
 }
Example #40
0
 public static MapRepresentation Create(IOidStrategy oidStrategy, HttpRequestMessage req, IList <ContextFacade> contexts, Format format, RestControlFlags flags, MediaTypeHeaderValue mt)
 {
     return(Create(oidStrategy, req, null, contexts, format, flags, mt));
 }
 public ActionRepresentationStrategy(IOidStrategy oidStrategy, HttpRequest req, ActionContextFacade actionContext, RestControlFlags flags)
     : base(oidStrategy, req, actionContext, flags)
 {
 }
Example #42
0
 public PropertyMemberRepresentationStrategy(IOidStrategy oidStrategy, HttpRequest req, PropertyContextFacade propertyContext, RestControlFlags flags) :
     base(oidStrategy, req, propertyContext, flags)
 {
 }
 public Representation(IOidStrategy oidStrategy, RestControlFlags flags)
 {
     OidStrategy = oidStrategy;
     Flags       = flags;
 }
        public static ObjectRepresentation Create(IOidStrategy oidStrategy, IObjectFacade target, HttpRequest req, RestControlFlags flags)
        {
            var oc = target.FrameworkFacade.GetObject(target);

            return(Create(oidStrategy, oc, req, flags));
        }
Example #45
0
 public static OptionalProperty CreateArgumentProperty(IOidStrategy oidStrategy, HttpRequestMessage req, Tuple <string, ITypeFacade> pnt, RestControlFlags flags)
 {
     return(new OptionalProperty(pnt.Item1, MapRepresentation.Create(new OptionalProperty(JsonPropertyNames.Value, null, typeof(object)),
                                                                     new OptionalProperty(JsonPropertyNames.Links, new LinkRepresentation[] {}))));
 }
Example #46
0
 public IOidFacade GetSid(IOidStrategy oidStrategy)
 {
     return(oidStrategy.RestoreSid(this));
 }
 public static TypeActionInvokeRepresentation Create(IOidStrategy oidStrategy, HttpRequestMessage req, TypeActionInvokeContext context, RestControlFlags flags)
 {
     return(new TypeActionInvokeRepresentation(oidStrategy, req, context, flags));
 }
Example #48
0
 public CollectionWithDetailsRepresentationStrategy(IOidStrategy oidStrategy, HttpRequest req, PropertyContextFacade propertyContext, RestControlFlags flags)
     : base(oidStrategy, req, propertyContext, flags)
 {
 }
Example #49
0
 public static string DomainTypeName(this ITypeFacade spec, IOidStrategy oidStrategy)
 {
     return(oidStrategy.GetLinkDomainTypeBySpecification(spec));
 }
Example #50
0
 public CollectionRepresentationStrategy(IOidStrategy oidStrategy, HttpRequestMessage req, PropertyContextFacade propertyContext, RestControlFlags flags)
     : base(oidStrategy, req, propertyContext, flags)
 {
     collection = propertyContext.Property.GetValue(propertyContext.Target);
 }
Example #51
0
 public static TypeActionInvokeRepresentation Create(IOidStrategy oidStrategy, HttpRequest req, TypeActionInvokeContext context, RestControlFlags flags) => new TypeActionInvokeRepresentation(oidStrategy, req, context, flags);
Example #52
0
 private static UriMtHelper GetParentHelper(IOidStrategy oidStrategy, PropertyContextFacade propertyContext, HttpRequest req) => new UriMtHelper(oidStrategy, req, propertyContext.Target);
Example #53
0
 private static UriMtHelper GetSelfHelper(IOidStrategy oidStrategy, PropertyContextFacade propertyContext, HttpRequestMessage req)
 {
     return(new UriMtHelper(oidStrategy, req, propertyContext));
 }
Example #54
0
 public static PromptRepresentation Create(IOidStrategy oidStrategy, PropertyContextFacade propertyContext, HttpRequest req, RestControlFlags flags) => new PromptRepresentation(oidStrategy, propertyContext, req, flags);
Example #55
0
        public static Tuple <string, string> SpecToTypeAndFormatString(ITypeFacade spec, IOidStrategy oidStrategy, bool useDateOverDateTime)
        {
            var types = SpecToPredefinedTypes(spec, useDateOverDateTime);

            if (types != null)
            {
                var pdtString = types.Item1.ToRoString();
                var pftString = types.Item2.HasValue ? types.Item2.Value.ToRoString() : null;

                return(new Tuple <string, string>(pdtString, pftString));
            }
            return(new Tuple <string, string>(spec.DomainTypeName(oidStrategy), null));
        }
 public static VersionRepresentation Create(IOidStrategy oidStrategy, HttpRequest req, IDictionary <string, string> capabilities, RestControlFlags flags) => new VersionRepresentation(oidStrategy, req, capabilities, flags);
 protected CollectionTypeRepresentation(IOidStrategy oidStrategy, HttpRequestMessage req, PropertyTypeContextFacade propertyContext, RestControlFlags flags)
     : base(oidStrategy, req, propertyContext, flags)
 {
     SetScalars(propertyContext);
     SetLinks(req, propertyContext);
 }
 public new static CollectionTypeRepresentation Create(IOidStrategy oidStrategy, HttpRequestMessage req, PropertyTypeContextFacade propertyContext, RestControlFlags flags)
 {
     return(new CollectionTypeRepresentation(oidStrategy, req, propertyContext, flags));
 }
Example #59
0
 public static ListRepresentation Create(IOidStrategy oidStrategy, IMenuFacade[] menus, HttpRequestMessage req, RestControlFlags flags)
 {
     return(new ListRepresentation(oidStrategy, menus, req, flags));
 }
Example #60
0
 public static ListRepresentation Create(IOidStrategy oidStrategy, MenuContextFacade menus, HttpRequest req, RestControlFlags flags) => new ListRepresentation(oidStrategy, menus, req, flags);