Merge remote-tracking branch 'origin/master'

Signum.Engine/Operations/OperationLogic.cs

@@ -644,7 +644,7 @@ public static OperationType OperationType(Type type, OperationSymbol operationSy
                 {
                     var operations = operationSymbols.Select(opKey => FindOperation(grLites.Key, opKey)).ToList();
 
-                    foreach (var grOperations in operations.GroupBy(a => a.GetType().GetGenericArguments().Let(arr=>Tuple.Create(arr[0], arr[1]))))
+                    foreach (var grOperations in operations.GroupBy(a => a.GetType().GetGenericArguments().Let(arr => Tuple.Create(arr[0], arr[1]))))
                     {
                         var dic = giGetContextualGraphCanExecute.GetInvoker(grLites.Key, grOperations.Key.Item1, grOperations.Key.Item2)(grLites, grOperations);
                         if (result == null)

Signum.React/ApiControllers/OperationController.cs

@@ -218,10 +218,17 @@ public StateCanExecuteResponse StateCanExecutes([Required, FromBody]StateCanExec
                 .ToList();
 
             var result = OperationLogic.GetContextualCanExecute(request.lites, operationSymbols)!;
+            var anyReadonly = AnyReadonly.GetInvocationListTyped().Any(f => f(request.lites));
 
-            return new StateCanExecuteResponse(result.SelectDictionary(a => a.Key, v => v));
+            return new StateCanExecuteResponse(result.SelectDictionary(a => a.Key, v => v))
+            {
+                anyReadonly = anyReadonly
+            };
         }
 
+
+        public static Func<Lite<Entity>[], bool> AnyReadonly; 
+
 #pragma warning disable CS8618 // Non-nullable field is uninitialized.
         public class StateCanExecuteRequest
         {
@@ -237,9 +244,8 @@ public StateCanExecuteResponse(Dictionary<string, string> canExecutes)
                 this.canExecutes = canExecutes;
             }
 
+            public bool anyReadonly;
             public Dictionary<string, string> canExecutes { get; set; }
         }
-
-
     }
 }

Signum.React/Scripts/Operations.tsx

@@ -18,6 +18,11 @@ import { ContextualItemsContext } from './SearchControl/ContextualItems';
 import { BsColor, KeyCodes } from "./Components/Basic";
 import { IconProp } from "@fortawesome/fontawesome-svg-core";
 import { bool } from "prop-types";
+export namespace Options {
+  export function maybeReadonly(ti: TypeInfo) {
+    return false;
+  }
+}
 
 export function start() {
   ButtonBar.onButtonBarRender.push(getEntityOperationButtons);
@@ -32,7 +37,8 @@ export function start() {
     {
       isVisible: getTypeInfo(ctx.lite.EntityType) && getTypeInfo(ctx.lite.EntityType).requiresSaveOperation && Finder.isFindable(OperationLogEntity, false),
       icon: "history",
-      iconColor: "green"
+      iconColor: "green",
+      isShy: true,
     }));
 }
 
@@ -156,6 +162,7 @@ export class ContextualOperationSettings<T extends Entity> extends OperationSett
 
   isVisible?: (coc: ContextualOperationContext<T>) => boolean;
   hideOnCanExecute?: boolean;
+  showOnReadOnly?: boolean;
   confirmMessage?: (coc: ContextualOperationContext<T>) => string | undefined | null;
   onClick?: (coc: ContextualOperationContext<T>) => void;
   color?: BsColor;
@@ -174,6 +181,7 @@ export interface ContextualOperationOptions<T extends Entity> {
   text?: () => string;
   isVisible?: (coc: ContextualOperationContext<T>) => boolean;
   hideOnCanExecute?: boolean;
+  showOnReadOnly?: boolean;
   confirmMessage?: (coc: ContextualOperationContext<T>) => string | undefined | null;
   onClick?: (coc: ContextualOperationContext<T>) => void;
   color?: BsColor;
@@ -188,6 +196,7 @@ export class ContextualOperationContext<T extends Entity> {
   settings?: ContextualOperationSettings<T>;
   entityOperationSettings?: EntityOperationSettings<T>;
   canExecute?: string;
+  isReadonly?: boolean;
   event?: React.MouseEvent<any>;
   onContextualSuccess?: (pack: API.ErrorReport) => void;
   onConstructFromSuccess?: (pack: EntityPack<Entity>) => void;
@@ -325,6 +334,7 @@ export class EntityOperationSettings<T extends Entity> extends OperationSettings
   confirmMessage?: (eoc: EntityOperationContext<T>) => string | undefined | null;
   onClick?: (eoc: EntityOperationContext<T>) => void;
   hideOnCanExecute?: boolean;
+  showOnReadOnly?: boolean;
   group?: EntityOperationGroup | null;
   order?: number;
   color?: BsColor;
@@ -354,6 +364,7 @@ export interface EntityOperationOptions<T extends Entity> {
   confirmMessage?: (ctx: EntityOperationContext<T>) => string | undefined | null;
   onClick?: (ctx: EntityOperationContext<T>) => void;
   hideOnCanExecute?: boolean;
+  showOnReadOnly?: boolean;
   group?: EntityOperationGroup | null;
   order?: number;
   color?: BsColor;
@@ -570,6 +581,7 @@ export namespace API {
 
   export interface CanExecutesResponse {
     canExecutes: { [operationKey: string]: string };
+    isReadOnly?: boolean;
   }
 }
 

Signum.React/Scripts/Operations/ContextualOperations.tsx

@@ -12,6 +12,7 @@ import {
 } from '../Operations'
 import { DropdownItem } from "../Components/DropdownItem";
 import { UncontrolledTooltip } from "../Components/Tooltip";
+import * as Operations from "../Operations";
 import { IconProp } from "@fortawesome/fontawesome-svg-core";
 
 export function getConstructFromManyContextualItems(ctx: ContextualItemsContext<Entity>): Promise<MenuItemBlock | undefined> | undefined {
@@ -109,24 +110,33 @@ export function getEntityOperationsContextualItems(ctx: ContextualItemsContext<E
     return undefined;
 
   let contextPromise: Promise<ContextualOperationContext<Entity>[]>;
-  if (ctx.lites.length == 1 && contexts.some(coc => coc.operationInfo.hasCanExecute)) {
-    contextPromise = Navigator.API.fetchEntityPack(ctx.lites[0]).then(ep => {
-      contexts.forEach(coc => coc.canExecute = ep.canExecute[coc.operationInfo.key]);
-      return contexts;
-    });
-  } else if (ctx.lites.length > 1 && contexts.some(coc => coc.operationInfo.hasStates)) {
-    contextPromise = API.stateCanExecutes(ctx.lites, contexts.filter(coc => coc.operationInfo.hasStates).map(a => a.operationInfo.key))
-      .then(response => {
-        contexts.forEach(coc => coc.canExecute = response.canExecutes[coc.operationInfo.key]);
+  if (contexts.some(coc => coc.operationInfo.hasCanExecute) || Operations.Options.maybeReadonly(ti)) {
+    if (ctx.lites.length == 1) {
+      contextPromise = Navigator.API.fetchEntityPack(ctx.lites[0]).then(ep => {
+        contexts.forEach(coc => {
+          coc.canExecute = ep.canExecute[coc.operationInfo.key];
+          coc.isReadonly = Navigator.isReadOnly(ep);
+        });
         return contexts;
       });
+    } else /*if (ctx.lites.length > 1)*/ {
+      contextPromise = API.stateCanExecutes(ctx.lites, contexts.filter(coc => coc.operationInfo.hasStates).map(a => a.operationInfo.key))
+        .then(response => {
+          contexts.forEach(coc => {
+            coc.canExecute = response.canExecutes[coc.operationInfo.key];
+            coc.isReadonly = response.isReadOnly;
+          });
+          return contexts;
+        });
+    }
   } else {
     contextPromise = Promise.resolve(contexts);
   }
 
-
   return contextPromise.then(ctxs => {
-    const menuItems = ctxs.filter(coc => coc.canExecute == undefined || !hideOnCanExecute(coc))
+    const menuItems = ctxs
+      .filter(coc => coc.canExecute == undefined || !hideOnCanExecute(coc))
+      .filter(coc => !coc.isReadonly || showOnReadonly(coc))
       .orderBy(coc => coc.settings && coc.settings.order != undefined ? coc.settings.order :
         coc.entityOperationSettings && coc.entityOperationSettings.order != undefined ? coc.entityOperationSettings.order : 0)
       .flatMap(coc => MenuItemConstructor.createContextualMenuItem(coc, defaultContextualClick));
@@ -153,6 +163,16 @@ function hideOnCanExecute(coc: ContextualOperationContext<Entity>) {
 }
 
 
+function showOnReadonly(coc: ContextualOperationContext<Entity>) {
+  if (coc.settings && coc.settings.showOnReadOnly != undefined)
+    return coc.settings.showOnReadOnly;
+
+  if (coc.entityOperationSettings && coc.entityOperationSettings.showOnReadOnly != undefined)
+    return coc.entityOperationSettings.showOnReadOnly;
+
+  return false;
+}
+
 
 export function confirmInNecessary(coc: ContextualOperationContext<Entity>): Promise<boolean> {
 

Signum.React/Scripts/Operations/EntityOperations.tsx

@@ -53,6 +53,9 @@ export function getEntityOperationButtons(ctx: ButtonsContext): Array<ButtonBarE
       if (eos && eos.hideOnCanExecute && eoc.canExecute)
         return false;
 
+      if (Navigator.isReadOnly(ctx.pack) && !(eos && eos.showOnReadOnly))
+        return false;
+
       return true;
     })
     .map(eoc => eoc!);

Signum.React/Scripts/QuickLinks.tsx

@@ -155,7 +155,7 @@ export function QuickLinkWidget(p: QuickLinkWidgetProps) {
     <UncontrolledDropdown id="quickLinksWidget">
       <DropdownToggle tag="span" data-toggle="dropdown">
         <a
-          className={classes("badge badge-secondary badge-pill", "sf-widgets-active", "sf-quicklinks")}
+          className={classes("badge badge-pill", links && links.some(l => !l.isShy) ? "badge-warning" : "badge-light", "sf-quicklinks")}
           title={TitleManager.useTitle ? QuickLinkMessage.Quicklinks.niceToString() : undefined}
           role="button"
           href="#"
@@ -179,6 +179,7 @@ export interface QuickLinkOptions {
   order?: number;
   icon?: IconProp;
   iconColor?: string;
+  isShy?: boolean;
 }
 
 export abstract class QuickLink {
@@ -188,6 +189,7 @@ export abstract class QuickLink {
   name: string;
   icon?: IconProp;
   iconColor?: string;
+  isShy?: string;
 
   constructor(name: string, options?: QuickLinkOptions) {
     this.name = name;