Box Developer Documentation
 

    Setup Shared Folders

    Setup Shared Folders

    As a final step to manage access to shared folders, we'll create the folder structures needed within the service account. Then, groups will map to the needed permissions based on user types and level of access needed to those folders. We'll use a Market Department as an example.

    marketing_folders.json
    {
      "name": "Marketing Department",
      "parent": {
        "id": "0"
      },
      "children": [
        {
          "name": "Projects",
          "children": []
        },
        {
          "name": "Newsletter",
          "children": [
            {
              "name": "Drafts",
              "children": []
            }
          ]
        }
      ]
    }
    

    Working from this sample folder structure, we can use the folder tree creator code we used earlier to create the etc/skel structure. That code may be modified to make your own structure.

    Once created, we'll need the IDs of the folders that each group will need to access. For example, Marketing managers will likely have editor access to all folders within the Marketing Department. On the other hand, Marketing project managers will likely need editor access to only the Projects folder. We'll create two groups and give them these permissions.

    Node
    "use strict";
    const fs = require("fs");
    const box = require("box-node-sdk");
    
    let configFile = fs.readFileSync("config.json");
    configFile = JSON.parse(configFile);
    
    let session = box.getPreconfiguredInstance(configFile);
    let serviceAccountClient = session.getAppAuthClient("enterprise");
    
    const marketingDeptFolderID = "45765309069";
    const marketingProjectsFolderID = "45765461670";
    const marketingManagersGroupName = "Marketing Managers";
    const marketingProjectManagersGroupName = "Marketing Project Managers";
    
    (async () => {
        let marketingManagerGroup;
        try {
            marketingManagerGroup = await serviceAccountClient.groups.create(
                marketingManagersGroupName,
                {
                    description: "For Marketing department leadership team.",
                    invitability_level: "admins_only",
                    member_viewability_level: "admins_only"
                }
            );
        } catch (e) {
          marketingManagerGroup = await handleGroupConflictError(
              e,
              marketingManagersGroupName,
              serviceAccountClient
          );
        }
    
        console.log(marketingManagerGroup);
    
        let marketingProjectManagerGroup;
        try {
            marketingProjectManagerGroup = await serviceAccountClient.groups.create(
                marketingProjectManagersGroupName,
                {
                    description: "All team members who manage Marketing projects.",
                    invitability_level: "admins_and_members",
                    member_viewability_level: "admins_and_members"
                }
            );
        } catch (e) {
            marketingProjectManagerGroup = await handleGroupConflictError(
                e,
                marketingProjectManagersGroupName,
                serviceAccountClient
            );
        }
    
        console.log(marketingProjectManagerGroup);
    
        let collabMarketingManagers;
        try {
            collabMarketingManagers = await serviceAccountClient.collaborations.createWithGroupID(
                marketingManagerGroup.id,
                marketingDeptFolderID,
                serviceAccountClient.collaborationRoles.EDITOR
            );
        } catch (e) {
            collabMarketingManagers = await handleFolderCollaborationConflictError(
                e,
                marketingDeptFolderID,
                marketingManagerGroup.id,
                serviceAccountClient
            );
        }
        console.log(collabMarketingManagers);
    
        let collabMarketingProjectManagers;
        try {
            collabMarketingProjectManagers = await serviceAccountClient.collaborations.createWithGroupID(
                marketingProjectManagerGroup.id,
                marketingProjectsFolderID,
                serviceAccountClient.collaborationRoles.EDITOR
            );
        } catch (e) {
            collabMarketingProjectManagers = await handleFolderCollaborationConflictError(
                e,
                marketingProjectsFolderID,
                marketingProjectManagerGroup.id,
                serviceAccountClient
            );
        }
        console.log(collabMarketingProjectManagers);
    })();
    
    async function autoPage(iterator, collection = []) {
        let moveToNextItem = async () => {
            let item = await iterator.next();
            if (item.value) {
                collection.push(item.value);
            }
    
            if (item.done !== true) {
                return moveToNextItem();
            } else {
                return collection;
            }
        };
        return moveToNextItem();
    }
    
    async function handleGroupConflictError(e, groupName, boxClient) {
        let storeIteratorSetting = boxClient._useIterators;
        if (e && e.response && e.response.body && e.response.body.status === 409) {
            boxClient._useIterators = true;
            let groupsIterator = await boxClient.groups.getAll({
                name: groupName
            });
            let groups = await autoPage(groupsIterator);
            let results = groups.filter(group => {
                return group.name === groupName;
            });
            if (results.length > 0) {
                boxClient._useIterators = storeIteratorSetting;
                return results[0];
            } else {
                throw new Error("Couldn't create group or find existing group.");
            }
        } else {
            throw e;
        }
    }
    
    async function handleFolderCollaborationConflictError(
        e,
        folderID,
        groupID,
        boxClient
    ) {
        let storeIteratorSetting = boxClient._useIterators;
        if (e && e.response && e.response.body && e.response.body.status === 409) {
            boxClient._useIterators = true;
            let collaborationsIterator = await boxClient.folders.getCollaborations(
                folderID
            );
            let collaborations = await autoPage(collaborationsIterator);
            let results = collaborations.filter(collaboration => {
                return collaboration.accessible_by.id === groupID;
            });
            console.log(results);
            if (results.length > 0) {
                boxClient._useIterators = storeIteratorSetting;
                return results[0];
            } else {
                throw new Error(
                    "Couldn't create new collaboration or located existing collaboration."
                );
            }
        } else {
            throw e;
        }
    }
    

    Once the groups are created, add the user to that group and they will have the prescribed access to the shared folders created within the service account.

    Node
    'use strict'
    const fs = require('fs');
    const box = require('box-node-sdk');
    
    let configFile = fs.readFileSync('config.json');
    configFile = JSON.parse(configFile);
    
    let session = box.getPreconfiguredInstance(configFile);
    let serviceAccountClient = session.getAppAuthClient("enterprise");
    
    const marketingManagerGroupID = "839790214";
    const marketingManagerUserID = "275111793";
    
    (async () => {
        let addedUser;
        try {
            addedUser = await
                serviceAccountClient.groups.addUser(marketingManagerGroupID,
                marketingManagerUserID, {
                role: serviceAccountClient.groups.userRoles.ADMIN
            });
        } catch (e) {
            addedUser =
                await handleGroupMembershipConflictError(e,
                marketingManagerGroupID, marketingManagerUserID, serviceAccountClient);
        }
        console.log(addedUser);
    })();
    
    async function autoPage(iterator, collection = []) {
        let moveToNextItem = async () => {
            let item = await iterator.next();
            if (item.value) {
                collection.push(item.value);
            }
    
            if (item.done !== true) {
                return moveToNextItem();
            } else {
                return collection;
            }
        }
        return moveToNextItem();
    }
    
    async function handleGroupMembershipConflictError(e,
        groupID, userID, boxClient) {
        let storeIteratorSetting = boxClient._useIterators;
        if (e && e.response
            && e.response.body
            && e.response.body.status === 409) {
            boxClient._useIterators = true;
            let groupMembershipsIterator = await boxClient.groups.getMemberships(groupID);
            let groupMemberships = await autoPage(groupMembershipsIterator);
            let results = groupMemberships.filter((groupMembership) => {
                return groupMembership.user.id === userID;
            });
            if (results.length > 0) {
                boxClient._useIterators = storeIteratorSetting;
                return results[0];
            } else {
                throw new Error("Couldn't create group membership or find existing group membership.");
            }
        } else {
            throw e;
        }
    }