1 files changed, 38 insertions, 30 deletions

diff --git a/src/fields/Doc.ts b/src/fields/Doc.ts
index 74fa3fd91..6dcf34a3a 100644
--- a/src/fields/Doc.ts
+++ b/src/fields/Doc.ts
@@ -21,8 +21,9 @@ import { listSpec } from "./Schema";
 import { ComputedField, ScriptField } from "./ScriptField";
 import { Cast, FieldValue, NumCast, StrCast, ToConstructor } from "./Types";
 import { AudioField, ImageField, PdfField, VideoField, WebField } from "./URLField";
-import { deleteProperty, GetEffectiveAcl, getField, getter, makeEditable, makeReadOnly, normalizeEmail, setter, SharingPermissions, updateFunction } from "./util";
+import { deleteProperty, GetEffectiveAcl, getField, getter, inheritParentAcls, makeEditable, makeReadOnly, normalizeEmail, setter, SharingPermissions, updateFunction } from "./util";
 import JSZip = require("jszip");
+import { CurrentUserUtils } from "../client/util/CurrentUserUtils";
 import { IconProp } from "@fortawesome/fontawesome-svg-core";
 
 export namespace Field {
@@ -61,10 +62,10 @@ export type FieldWaiting<T extends RefField = RefField> = T extends undefined ?
 export type FieldResult<T extends Field = Field> = Opt<T> | FieldWaiting<Extract<T, RefField>>;
 
 /**
- * Cast any field to either a List of Docs or undefined if the given field isn't a List of Docs.  
- * If a default value is given, that will be returned instead of undefined.  
- * If a default value is given, the returned value should not be modified as it might be a temporary value.  
- * If no default value is given, and the returned value is not undefined, it can be safely modified.  
+ * Cast any field to either a List of Docs or undefined if the given field isn't a List of Docs.
+ * If a default value is given, that will be returned instead of undefined.
+ * If a default value is given, the returned value should not be modified as it might be a temporary value.
+ * If no default value is given, and the returned value is not undefined, it can be safely modified.
  */
 export function DocListCastAsync(field: FieldResult): Promise<Doc[] | undefined>;
 export function DocListCastAsync(field: FieldResult, defaultValue: Doc[]): Promise<Doc[]>;
@@ -251,7 +252,8 @@ export class Doc extends RefField {
                         DocServer.GetRefField(this[Id], true);
                     }
                 };
-                if (sameAuthor || fKey.startsWith("acl") || DocServer.getFieldWriteMode(fKey) !== DocServer.WriteMode.Playground) {
+                const writeMode = DocServer.getFieldWriteMode(fKey as string);
+                if (fKey.startsWith("acl") || writeMode !== DocServer.WriteMode.Playground) {
                     delete this[CachedUpdates][fKey];
                     await fn();
                 } else {
@@ -365,13 +367,13 @@ export namespace Doc {
     /**
      * This function is intended to model Object.assign({}, {}) [https://mzl.la/1Mo3l21], which copies
      * the values of the properties of a source object into the target.
-     * 
+     *
      * This is just a specific, Dash-authored version that serves the same role for our
      * Doc class.
-     * 
-     * @param doc the target document into which you'd like to insert the new fields 
+     *
+     * @param doc the target document into which you'd like to insert the new fields
      * @param fields the fields to project onto the target. Its type signature defines a mapping from some string key
-     * to a potentially undefined field, where each entry in this mapping is optional. 
+     * to a potentially undefined field, where each entry in this mapping is optional.
      */
     export function assign<K extends string>(doc: Doc, fields: Partial<Record<K, Opt<Field>>>, skipUndefineds: boolean = false, isInitializing = false) {
         isInitializing && (doc[Initializing] = true);
@@ -398,7 +400,7 @@ export namespace Doc {
     }
 
     // Gets the data document for the document.  Note: this is mis-named -- it does not specifically
-    // return the doc's proto, but rather recursively searches through the proto inheritance chain 
+    // return the doc's proto, but rather recursively searches through the proto inheritance chain
     // and returns the document who's proto is undefined or whose proto is marked as a base prototype ('isPrototype').
     export function GetProto(doc: Doc): Doc {
         if (doc instanceof Promise) {
@@ -424,6 +426,9 @@ export namespace Doc {
         return Array.from(results);
     }
 
+    /**
+     * @returns the index of doc toFind in list of docs, -1 otherwise
+     */
     export function IndexOf(toFind: Doc, list: Doc[], allowProtos: boolean = true) {
         let index = list.reduce((p, v, i) => (v instanceof Doc && v === toFind) ? i : p, -1);
         index = allowProtos && index !== -1 ? index : list.reduce((p, v, i) => (v instanceof Doc && Doc.AreProtosEqual(v, toFind)) ? i : p, -1);
@@ -536,7 +541,7 @@ export namespace Doc {
                     const clones = await Promise.all(docs.map(async d => Doc.makeClone(d, cloneMap, linkMap, rtfs, exclusions, dontCreate, asBranch)));
                     !dontCreate && assignKey(new List<Doc>(clones));
                 } else if (doc[key] instanceof Doc) {
-                    assignKey(key.includes("layout[") ? undefined : key.startsWith("layout") ? doc[key] as Doc : await Doc.makeClone(doc[key] as Doc, cloneMap, linkMap, rtfs, exclusions, dontCreate, asBranch)); // reference documents except copy documents that are expanded teplate fields 
+                    assignKey(key.includes("layout[") ? undefined : key.startsWith("layout") ? doc[key] as Doc : await Doc.makeClone(doc[key] as Doc, cloneMap, linkMap, rtfs, exclusions, dontCreate, asBranch)); // reference documents except copy documents that are expanded template fields
                 } else {
                     !dontCreate && assignKey(ObjectField.MakeCopy(field));
                     if (field instanceof RichTextField) {
@@ -562,7 +567,7 @@ export namespace Doc {
                 } else if (field instanceof ObjectField) {
                     await copyObjectField(field);
                 } else if (field instanceof Promise) {
-                    debugger; //This shouldn't happend...
+                    debugger; //This shouldn't happen...
                 } else {
                     assignKey(field);
                 }
@@ -667,14 +672,14 @@ export namespace Doc {
     const _pendingMap: Map<string, boolean> = new Map();
     //
     // Returns an expanded template layout for a target data document if there is a template relationship
-    // between the two. If so, the layoutDoc is expanded into a new document that inherits the properties 
+    // between the two. If so, the layoutDoc is expanded into a new document that inherits the properties
     // of the original layout while allowing for individual layout properties to be overridden in the expanded layout.
     // templateArgs should be equivalent to the layout key that generates the template since that's where the template parameters are stored in ()'s at the end of the key.
     // NOTE:  the template will have references to "@params" -- the template arguments will be assigned to the '@params' field
     // so that when the @params key is accessed, it will be rewritten as the key that is stored in the 'params' field and
     // the derefence will then occur on the rootDocument (the original document).
     // in the future, field references could be written as @<someparam> and then arguments would be passed in the layout key as:
-    //   layout_mytemplate(somparam=somearg).   
+    //   layout_mytemplate(somparam=somearg).
     // then any references to @someparam would be rewritten as accesses to 'somearg' on the rootDocument
     export function expandTemplateLayout(templateLayoutDoc: Doc, targetDoc?: Doc, templateArgs?: string) {
         const args = templateArgs?.match(/\(([a-zA-Z0-9._\-]*)\)/)?.[1].replace("()", "") || StrCast(templateLayoutDoc.PARAMS);
@@ -775,7 +780,7 @@ export namespace Doc {
                     copy[key] = cfield[Copy]();// ComputedField.MakeFunction(cfield.script.originalScript);
                 } else if (field instanceof ObjectField) {
                     copy[key] = doc[key] instanceof Doc ?
-                        key.includes("layout[") ? undefined : doc[key] : // reference documents except remove documents that are expanded teplate fields 
+                        key.includes("layout[") ? undefined : doc[key] : // reference documents except remove documents that are expanded teplate fields
                         ObjectField.MakeCopy(field);
                 } else if (field instanceof Promise) {
                     debugger; //This shouldn't happend...
@@ -938,7 +943,7 @@ export namespace Doc {
     }
 
     // the document containing the view layout information - will be the Document itself unless the Document has
-    // a layout field or 'layout' is given.  
+    // a layout field or 'layout' is given.
     export function Layout(doc: Doc, layout?: Doc): Doc {
         const overrideLayout = layout && Cast(doc[`${StrCast(layout.isTemplateForField, "data")}-layout[` + layout[Id] + "]"], Doc, null);
         return overrideLayout || doc[LayoutSym] || doc;
@@ -1117,7 +1122,7 @@ export namespace Doc {
     }
 
     // filters document in a container collection:
-    // all documents with the specified value for the specified key are included/excluded 
+    // all documents with the specified value for the specified key are included/excluded
     // based on the modifiers :"check", "x", undefined
     export function setDocFilter(container: Opt<Doc>, key: string, value: any, modifiers: "remove" | "match" | "check" | "x", toggle?: boolean, fieldSuffix?: string, append: boolean = true) {
         if (!container) return;
@@ -1188,6 +1193,9 @@ export namespace Doc {
             dragFactory["dragFactory-count"] = NumCast(dragFactory["dragFactory-count"]) + 1;
             Doc.SetInPlace(ndoc, "title", ndoc.title + " " + NumCast(dragFactory["dragFactory-count"]).toString(), true);
         }
+
+        if (ndoc) inheritParentAcls(CurrentUserUtils.ActiveDashboard, ndoc);
+
         return ndoc;
     }
     export function delegateDragFactory(dragFactory: Doc) {
@@ -1241,39 +1249,39 @@ export namespace Doc {
         /**
          * This function takes any valid JSON(-like) data, i.e. parsed or unparsed, and at arbitrarily
          * deep levels of nesting, converts the data and structure into nested documents with the appropriate fields.
-         * 
+         *
          * After building a hierarchy within / below a top-level document, it then returns that top-level parent.
-         * 
+         *
          * If we've received a string, treat it like valid JSON and try to parse it into an object. If this fails, the
          * string is invalid JSON, so we should assume that the input is the result of a JSON.parse()
          * call that returned a regular string value to be stored as a Field.
-         * 
+         *
          * If we've received something other than a string, since the caller might also pass in the results of a
          * JSON.parse() call, valid input might be an object, an array (still typeof object), a boolean or a number.
          * Anything else (like a function, etc. passed in naively as any) is meaningless for this operation.
-         * 
+         *
          * All TS/JS objects get converted directly to documents, directly preserving the key value structure. Everything else,
          * lacking the key value structure, gets stored as a field in a wrapper document.
-         * 
+         *
          * @param data for convenience and flexibility, either a valid JSON string to be parsed,
          * or the result of any JSON.parse() call.
          * @param title an optional title to give to the highest parent document in the hierarchy.
          * If whether this function creates a new document or appendToExisting is specified and that document already has a title,
          * because this title field can be left undefined for the opposite behavior, including a title will overwrite the existing title.
          * @param appendToExisting **if specified**, there are two cases, both of which return the target document:
-         * 
+         *
          * 1) the json to be converted can be represented as a document, in which case the target document will act as the root
          * of the tree and receive all the conversion results as new fields on itself
          * 2) the json can't be represented as a document, in which case the function will assign the field-level conversion
          * results to either the specified key on the target document, or to its "json" key by default.
-         * 
+         *
          * If not specified, the function creates and returns a new entirely generic document (different from the Doc.Create calls)
          * to act as the root of the tree.
-         * 
+         *
          * One might choose to specify this field if you want to write to a document returned from a Document.Create function call,
          * say a TreeView document that will be rendered, not just an untyped, identityless doc that would otherwise be created
          * from a default call to new Doc.
-         * 
+         *
          * @param excludeEmptyObjects whether non-primitive objects (TypeScript objects and arrays) should be converted even
          * if they contain no data. By default, empty objects and arrays are ignored.
          */
@@ -1309,7 +1317,7 @@ export namespace Doc {
          * For each value of the object, recursively convert it to its appropriate field value
          * and store the field at the appropriate key in the document if it is not undefined
          * @param object the object to convert
-         * @returns the object mapped from JSON to field values, where each mapping 
+         * @returns the object mapped from JSON to field values, where each mapping
          * might involve arbitrary recursion (since toField might itself call convertObject)
          */
         const convertObject = (object: any, excludeEmptyObjects: boolean, title?: string, target?: Doc): Opt<Doc> => {
@@ -1333,10 +1341,10 @@ export namespace Doc {
         };
 
         /**
-         * For each element in the list, recursively convert it to a document or other field 
+         * For each element in the list, recursively convert it to a document or other field
          * and push the field to the list if it is not undefined
          * @param list the list to convert
-         * @returns the list mapped from JSON to field values, where each mapping 
+         * @returns the list mapped from JSON to field values, where each mapping
          * might involve arbitrary recursion (since toField might itself call convertList)
          */
         const convertList = (list: Array<any>, excludeEmptyObjects: boolean): Opt<List<Field>> => {