Hiding google sheet tab from users

Question

I have a google sheets document with two tabs one called called internal and the other called external. How can i hide the internal tab from other users? the lock function already avialble is not good enough I only want people from my company to be able to see both tabs, clients should only be able to see the external tab.

function validUsers() { 
String[] adminUsers = {”email1@gmail.com”,”email2@gmail.com”,”email3@gmail.com”};

if (adminUsers.indexOf(Session.getEffectiveUser().getEmail()) >= 0) { 
    SpreadsheetApp.getActiveSpreadsheet().getSheetByName('Internal').showSheet() 
else
    SpreadsheetApp.getActiveSpreadsheet().getSheetByName('Internal').hideSheet() 
} 

}

Answer 1

Issue:

• You want to hide or show a sheet in your spreadsheet depending on which user is accessing the spreadsheet.

Solution:

You could do the following:

• Install an onOpen trigger which executes a function (let's call it fireOnOpen) every time a user opens the spreadsheet.
• The function fireOnOpen should check which user is accessing the spreadsheet, and hide or show a certain sheet (called Internal) depending on this.
• In order to check the current user accessing the spreadsheet, you can use getActiveUser() (instead of getEffectiveUser(), which will return the user who installed the trigger).

Workflow:

• The trigger can be installed either manually or programmatically. To do it programmatically, copy this function to your script editor and execute it once:

function createOnOpenTrigger() {
  var ss = SpreadsheetApp.getActive();
  ScriptApp.newTrigger("fireOnOpen")
  .forSpreadsheet(ss)
  .onOpen()
  .create();
}

• This will result in fireOnOpen being executed every time a user accessed the spreadsheet. The fireOnOpen function could be something like this:

function fireOnOpen() { 
  const adminUsers = ["email1@gmail.com","email2@gmail.com","email3@gmail.com"];
  const currentUser = Session.getActiveUser().getEmail();
  const internalSheet = SpreadsheetApp.getActiveSpreadsheet().getSheetByName("Internal");
  if (adminUsers.includes(currentUser)) internalSheet.showSheet();
  else internalSheet.hideSheet();
} 

Important notes:

• You cannot hide sheets for some users but not for others. A hidden sheet is hidden for all users, and a visible sheet is visible for all users. Therefore, this will only work if internal and external users don't access the spreadsheet at the same time. If they do, external users might be able to access the Internal sheet.
• getActiveUser() is not always populated, as you can see on this answer, so please make sure that all admin users are from the same G Suite domain. Otherwise, this won't work.
• If the privacy of the Internal sheet is critical and there is a possibility of internal and external users accessing the spreadsheet at the time, I would not recommend this solution.

Edit:

As mentioned in comments, a possible workaround for the occasions when admin and non-admin users access the file at the time could be the following:

• When an admin user accesses the file, store the time in which that happened.
• Create a time-driven trigger to execute a function periodically (every 5 minutes, let's say), which will check if an admin accessed the file a short time ago (let's say 30 minutes). If the admin has done that, remove the Permissions for the different non-admin domains. If that's not the case, add these Permissions back.
• Enabling the Drive Advanced Service would be required in this case.

Updated code sample:

function fireOnOpen() { 
  const adminUsers = ["email1@gmail.com","email2@gmail.com","email3@gmail.com"];
  const currentUser = Session.getActiveUser().getEmail();
  const internalSheet = SpreadsheetApp.getActiveSpreadsheet().getSheetByName("Internal");
  if (adminUsers.includes(currentUser)) {
    internalSheet.showSheet();    
    const documentProperties = PropertiesService.getDocumentProperties();
    documentProperties.setProperty("lastAdminAccess", new Date().getTime()); // Store time of admin access
  } else internalSheet.hideSheet();
} 

function createOnOpenTrigger() {
  var ss = SpreadsheetApp.getActive();
  ScriptApp.newTrigger("fireOnOpen")
  .forSpreadsheet(ss)
  .onOpen()
  .create();
}

function updatePermissions() {
  const fileId = SpreadsheetApp.getActive().getId();
  const lastAdminAccess = PropertiesService.getDocumentProperties().getProperty("lastAdminAccess"); // Last time of admin access in ms
  const now = new Date().getTime(); // Current time in milliseconds
  const thirtyMinutes = 1000 * 60 * 30; // 30 minutes in milliseconds
  if (now - lastAdminAccess < thirtyMinutes) {
    const currentPermissions = Drive.Permissions.list(fileId)["items"];
    const publicPermissionIds = currentPermissions.filter(permission => permission["type"] === "anyone")
                                                  .map(permission => permission["id"]);
    publicPermissionIds.forEach(permissionId => Drive.Permissions.remove(fileId, permissionId));
  } else {
    const resource = {
      type: "anyone",
      role: "reader"
    }      
    Drive.Permissions.insert(resource, fileId);
  }
}

function createTimeTrigger() {
  ScriptApp.newTrigger("updatePermissions")
  .timeBased()
  .everyMinutes(5)
  .create();
}

Answer 2

As soon as you share a sheet you should assume that anyone can see the data in it. Even if someone shouldn't be able to see the internal tab, they can always e.g. make a copy of the sheet and thus get to the data.

You could try creating a separate sheet and using =IMPORTRANGE() to refer to the original one. But know that once you allow the connection between the two sheets, anyone with access to the second one might be able to access anything in the first one. Maybe get around that using three sheets:

1. Internal + External - your current sheet

2. A sheet-in-the-middle that only you can access. It has a single tab Internal that uses =IMPORTRANGE() to access data from 1)

3. The External sheet for clients. Linked to 2) through =IMPORTRANGE()

This way 3) only has access to the data in 2) which in turn only includes a link to 1).

I do not promise that this will make the data safe from those who shouldn't see it. But it will at least be safer.