예제 #1
0
        public override bool Execute(ProgramOptions programOptions)
        {
            Stopwatch stopWatch = new Stopwatch();

            stopWatch.Start();

            StepTiming stepTimingFunction = new StepTiming();

            stepTimingFunction.JobFileName = programOptions.ReportJobFilePath;
            stepTimingFunction.StepName    = programOptions.ReportJob.Status.ToString();
            stepTimingFunction.StepID      = (int)programOptions.ReportJob.Status;
            stepTimingFunction.StartTime   = DateTime.Now;
            stepTimingFunction.NumEntities = 0;

            this.DisplayJobStepStartingStatus(programOptions);

            this.FilePathMap = new FilePathMap(programOptions);

            SnowSQLDriver snowSQLDriver = null;

            try
            {
                snowSQLDriver = new SnowSQLDriver(programOptions.ConnectionName);

                if (snowSQLDriver.ValidateToolInstalled() == false)
                {
                    return(false);
                }
                ;

                FileIOHelper.CreateFolder(this.FilePathMap.Data_FolderPath());
                FileIOHelper.CreateFolder(this.FilePathMap.Data_User_FolderPath());
                FileIOHelper.CreateFolder(this.FilePathMap.Data_Role_FolderPath());
                FileIOHelper.CreateFolder(this.FilePathMap.Data_Grant_FolderPath());

                #region List of roles and users

                loggerConsole.Info("Retrieving list of roles and users");

                StringBuilder sb = new StringBuilder(1024);

                sb.AppendFormat("ALTER SESSION SET QUERY_TAG='Snowflake Grant Report Version {0}';", Assembly.GetEntryAssembly().GetName().Version); sb.AppendLine();

                sb.AppendLine("!set output_format=csv");
                sb.AppendLine("!set header=true");

                sb.AppendLine("USE ROLE SECURITYADMIN;");
                sb.AppendFormat("!spool \"{0}\"", FilePathMap.Data_ShowRoles_FilePath()); sb.AppendLine();
                sb.AppendLine("SHOW ROLES;");
                sb.AppendLine(@"!spool off");

                sb.AppendFormat("!spool \"{0}\"", FilePathMap.Data_ShowUsers_FilePath()); sb.AppendLine();
                sb.AppendLine("SHOW USERS;");
                sb.AppendLine(@"!spool off");

                FileIOHelper.SaveFileToPath(sb.ToString(), FilePathMap.Data_UsersAndRoles_SQLQuery_FilePath(), false);

                snowSQLDriver.ExecuteSQLStatementsInFile(this.FilePathMap.Data_UsersAndRoles_SQLQuery_FilePath(), programOptions.ReportFolderPath);

                #endregion

                #region User details

                List <User> usersList = FileIOHelper.ReadListFromCSVFile <User>(FilePathMap.Data_ShowUsers_FilePath(), new UserShowUsersMinimalMap());
                if (usersList != null)
                {
                    loggerConsole.Info("Retrieving user details for {0} users", usersList.Count);

                    sb = new StringBuilder(256 * usersList.Count);

                    sb.AppendFormat("ALTER SESSION SET QUERY_TAG='Snowflake Grant Report Version {0}';", Assembly.GetEntryAssembly().GetName().Version); sb.AppendLine();

                    sb.AppendLine("!set output_format=csv");
                    sb.AppendLine("!set header=true");

                    sb.AppendLine("USE ROLE SECURITYADMIN;");
                    sb.AppendLine("USE ROLE ACCOUNTADMIN;");

                    for (int i = 0; i < usersList.Count; i++)
                    {
                        User user = usersList[i];

                        sb.AppendFormat("!spool \"{0}\"", FilePathMap.Data_DescribeUser_FilePath(user.NAME)); sb.AppendLine();
                        sb.AppendFormat("DESCRIBE USER {0};", quoteObjectIdentifier(user.NAME)); sb.AppendLine();
                        sb.AppendLine(@"!spool off");
                    }

                    FileIOHelper.SaveFileToPath(sb.ToString(), FilePathMap.DescribeUserSQLQuery_FilePath(), false);

                    snowSQLDriver.ExecuteSQLStatementsInFile(FilePathMap.DescribeUserSQLQuery_FilePath(), programOptions.ReportFolderPath);
                }

                #endregion

                #region Role Grants

                List <Role> rolesList = FileIOHelper.ReadListFromCSVFile <Role>(FilePathMap.Data_ShowRoles_FilePath(), new RoleShowRolesMinimalMap());
                if (rolesList != null)
                {
                    #region Role Grants On

                    loggerConsole.Info("Retrieving role grants ON for {0} roles", rolesList.Count);

                    sb = new StringBuilder(256 * rolesList.Count);

                    sb.AppendFormat("ALTER SESSION SET QUERY_TAG='Snowflake Grant Report Version {0}';", Assembly.GetEntryAssembly().GetName().Version); sb.AppendLine();

                    sb.AppendLine("!set output_format=csv");
                    sb.AppendLine("!set header=true");

                    sb.AppendLine("USE ROLE SECURITYADMIN;");
                    sb.AppendFormat("!spool \"{0}\"", FilePathMap.Data_RoleShowGrantsOn_FilePath()); sb.AppendLine();
                    for (int i = 0; i < rolesList.Count; i++)
                    {
                        Role role = rolesList[i];
                        sb.AppendFormat("SHOW GRANTS ON ROLE {0};", quoteObjectIdentifier(role.Name)); sb.AppendLine();
                        if (i == 0)
                        {
                            sb.AppendLine("!set header=false");
                        }
                    }
                    sb.AppendLine(@"!spool off");

                    FileIOHelper.SaveFileToPath(sb.ToString(), FilePathMap.Data_RoleGrantsOn_SQLQuery_FilePath(), false);

                    snowSQLDriver.ExecuteSQLStatementsInFile(FilePathMap.Data_RoleGrantsOn_SQLQuery_FilePath(), programOptions.ReportFolderPath);

                    #endregion

                    #region Role Grants To

                    loggerConsole.Info("Retrieving role grants TO for {0} roles", rolesList.Count);

                    sb = new StringBuilder(256 * rolesList.Count);

                    sb.AppendFormat("ALTER SESSION SET QUERY_TAG='Snowflake Grant Report Version {0}';", Assembly.GetEntryAssembly().GetName().Version); sb.AppendLine();

                    sb.AppendLine("!set output_format=csv");
                    sb.AppendLine("!set header=true");

                    sb.AppendLine("USE ROLE SECURITYADMIN;");
                    sb.AppendFormat("!spool \"{0}\"", FilePathMap.Data_RoleShowGrantsTo_FilePath()); sb.AppendLine();
                    for (int i = 0; i < rolesList.Count; i++)
                    {
                        Role role = rolesList[i];
                        sb.AppendFormat("SHOW GRANTS TO ROLE {0};", quoteObjectIdentifier(role.Name)); sb.AppendLine();
                        if (i == 0)
                        {
                            sb.AppendLine("!set header=false");
                        }
                    }
                    sb.AppendLine(@"!spool off");

                    FileIOHelper.SaveFileToPath(sb.ToString(), FilePathMap.Data_RoleGrantsTo_SQLQuery_FilePath(), false);

                    snowSQLDriver.ExecuteSQLStatementsInFile(FilePathMap.Data_RoleGrantsTo_SQLQuery_FilePath(), programOptions.ReportFolderPath);

                    #endregion

                    #region Role Grants Of

                    loggerConsole.Info("Retrieving role grants OF for {0} roles", rolesList.Count);

                    sb = new StringBuilder(256 * rolesList.Count);
                    sb.AppendFormat("ALTER SESSION SET QUERY_TAG='Snowflake Grant Report Version {0}';", Assembly.GetEntryAssembly().GetName().Version); sb.AppendLine();

                    sb.AppendLine("!set output_format=csv");
                    sb.AppendLine("!set header=true");

                    sb.AppendLine("USE ROLE SECURITYADMIN;");
                    sb.AppendFormat("!spool \"{0}\"", FilePathMap.Data_RoleShowGrantsOf_FilePath()); sb.AppendLine();
                    for (int i = 0; i < rolesList.Count; i++)
                    {
                        Role role = rolesList[i];
                        // Output header for only the first item
                        sb.AppendFormat("SHOW GRANTS OF ROLE {0};", quoteObjectIdentifier(role.Name)); sb.AppendLine();
                        if (i == 0)
                        {
                            sb.AppendLine("!set header=false");
                        }
                    }
                    sb.AppendLine(@"!spool off");

                    FileIOHelper.SaveFileToPath(sb.ToString(), FilePathMap.Data_RoleGrantsOf_SQLQuery_FilePath(), false);

                    snowSQLDriver.ExecuteSQLStatementsInFile(FilePathMap.Data_RoleGrantsOf_SQLQuery_FilePath(), programOptions.ReportFolderPath);

                    #endregion
                }

                #endregion

                #region Future Grants

                List <Grant> grantsToRolesList = FileIOHelper.ReadListFromCSVFile <Grant>(FilePathMap.Data_RoleShowGrantsTo_FilePath(), new GrantShowGrantsMap(), new string[] { "No data returned", "SQL compilation error", "does not exist" });
                if (grantsToRolesList != null)
                {
                    // Get list of all databases and process them
                    List <string> databasesList = grantsToRolesList.Where(g => g.ObjectType == "DATABASE").Select(g => g.ObjectName).Distinct().ToList();
                    if (databasesList != null)
                    {
                        loggerConsole.Info("Retrieving future grants in {0} databases", databasesList.Count);

                        databasesList.Sort();
                        databasesList.Remove("ORGANIZATION_USAGE");
                        databasesList.Remove("SNOWFLAKE");

                        sb = new StringBuilder(256 * databasesList.Count);
                        sb.AppendFormat("ALTER SESSION SET QUERY_TAG='Snowflake Grant Report Version {0}';", Assembly.GetEntryAssembly().GetName().Version); sb.AppendLine();

                        sb.AppendLine("!set output_format=csv");
                        sb.AppendLine("!set header=true");

                        sb.AppendLine("USE ROLE SECURITYADMIN;");
                        sb.AppendFormat("!spool \"{0}\"", FilePathMap.Data_FutureGrantsInDatabases_FilePath()); sb.AppendLine();
                        for (int i = 0; i < databasesList.Count; i++)
                        {
                            sb.AppendFormat("SHOW FUTURE GRANTS IN DATABASE {0};", databasesList[i]); sb.AppendLine();
                            if (i == 0)
                            {
                                sb.AppendLine("!set header=false");
                            }
                        }
                        sb.AppendLine(@"!spool off");

                        FileIOHelper.SaveFileToPath(sb.ToString(), FilePathMap.Data_FutureGrantsInDatabases_SQLQuery_FilePath(), false);

                        snowSQLDriver.ExecuteSQLStatementsInFile(FilePathMap.Data_FutureGrantsInDatabases_SQLQuery_FilePath(), programOptions.ReportFolderPath);
                    }

                    // Get list of all schemas and process them
                    List <string> schemasList = grantsToRolesList.Where(g => g.ObjectType == "SCHEMA").Select(g => g.ObjectName).Distinct().ToList();
                    if (schemasList != null)
                    {
                        loggerConsole.Info("Retrieving future grants in {0} schemas", schemasList.Count);

                        schemasList.Sort();
                        schemasList.RemoveAll(s => s.StartsWith("ORGANIZATION_USAGE."));
                        schemasList.RemoveAll(s => s.StartsWith("SNOWFLAKE."));

                        sb = new StringBuilder(256 * schemasList.Count);
                        sb.AppendFormat("ALTER SESSION SET QUERY_TAG='Snowflake Grant Report Version {0}';", Assembly.GetEntryAssembly().GetName().Version); sb.AppendLine();

                        sb.AppendLine("!set output_format=csv");
                        sb.AppendLine("!set header=true");

                        sb.AppendLine("USE ROLE SECURITYADMIN;");
                        sb.AppendFormat("!spool \"{0}\"", FilePathMap.Data_FutureGrantsInSchemas_FilePath()); sb.AppendLine();
                        for (int i = 0; i < schemasList.Count; i++)
                        {
                            sb.AppendFormat("SHOW FUTURE GRANTS IN SCHEMA {0};", schemasList[i]); sb.AppendLine();
                            if (i == 0)
                            {
                                sb.AppendLine("!set header=false");
                            }
                        }
                        sb.AppendLine(@"!spool off");

                        FileIOHelper.SaveFileToPath(sb.ToString(), FilePathMap.Data_FutureGrantsInSchemas_SQLQuery_FilePath(), false);

                        snowSQLDriver.ExecuteSQLStatementsInFile(FilePathMap.Data_FutureGrantsInSchemas_SQLQuery_FilePath(), programOptions.ReportFolderPath);
                    }
                }

                #endregion

                return(true);
            }
            catch (Exception ex)
            {
                logger.Error(ex);
                loggerConsole.Error(ex);

                return(false);
            }
            finally
            {
                stopWatch.Stop();

                this.DisplayJobStepEndedStatus(programOptions, stopWatch);

                stepTimingFunction.EndTime    = DateTime.Now;
                stepTimingFunction.Duration   = stopWatch.Elapsed;
                stepTimingFunction.DurationMS = stopWatch.ElapsedMilliseconds;

                List <StepTiming> stepTimings = new List <StepTiming>(1);
                stepTimings.Add(stepTimingFunction);
                FileIOHelper.WriteListToCSVFile(stepTimings, new StepTimingReportMap(), FilePathMap.StepTimingReportFilePath(), true);
            }
        }
        public override bool Execute(ProgramOptions programOptions)
        {
            Stopwatch stopWatch = new Stopwatch();

            stopWatch.Start();

            StepTiming stepTimingFunction = new StepTiming();

            stepTimingFunction.JobFileName = programOptions.ReportJobFilePath;
            stepTimingFunction.StepName    = programOptions.ReportJob.Status.ToString();
            stepTimingFunction.StepID      = (int)programOptions.ReportJob.Status;
            stepTimingFunction.StartTime   = DateTime.Now;
            stepTimingFunction.NumEntities = 0;

            this.DisplayJobStepStartingStatus(programOptions);

            this.FilePathMap = new FilePathMap(programOptions);

            try
            {
                FileIOHelper.CreateFolder(this.FilePathMap.Report_FolderPath());
                FileIOHelper.CreateFolder(this.FilePathMap.Report_Grant_FolderPath());
                FileIOHelper.CreateFolder(this.FilePathMap.Report_Role_FolderPath());

                #region Grants OF - Members of Roles (Roles and Users)

                loggerConsole.Info("Process Grants OF");

                List <RoleMember> grantsOfRolesAndUsersList = FileIOHelper.ReadListFromCSVFile <RoleMember>(FilePathMap.Data_RoleShowGrantsOf_FilePath(), new RoleMemberShowGrantsMap(), new string[] { "No data returned", "SQL compilation error", "does not exist" });
                if (grantsOfRolesAndUsersList != null)
                {
                    foreach (RoleMember roleMember in grantsOfRolesAndUsersList)
                    {
                        // Unescape special names of roles
                        roleMember.Name      = roleMember.Name.Trim('"');
                        roleMember.GrantedTo = roleMember.GrantedTo.Trim('"');
                        roleMember.GrantedBy = roleMember.GrantedBy.Trim('"');
                    }

                    grantsOfRolesAndUsersList = grantsOfRolesAndUsersList.OrderBy(g => g.ObjectType).ThenBy(g => g.Name).ToList();

                    FileIOHelper.WriteListToCSVFile <RoleMember>(grantsOfRolesAndUsersList, new RoleMemberMap(), FilePathMap.Report_RoleMember_FilePath());
                }

                #endregion

                #region Grants ON and Grants TO grants for everything

                loggerConsole.Info("Process Grants ON, TO and FUTURE grants");

                List <Grant> grantsNonUniqueList = new List <Grant>();

                List <Grant> grantsOnRolesList = FileIOHelper.ReadListFromCSVFile <Grant>(FilePathMap.Data_RoleShowGrantsOn_FilePath(), new GrantShowGrantsMap(), new string[] { "No data returned", "SQL compilation error", "does not exist" });
                if (grantsOnRolesList != null)
                {
                    loggerConsole.Info("Granted ON {0} grants", grantsOnRolesList.Count);
                    grantsNonUniqueList.AddRange(grantsOnRolesList);
                }

                List <Grant> grantsToRolesList = FileIOHelper.ReadListFromCSVFile <Grant>(FilePathMap.Data_RoleShowGrantsTo_FilePath(), new GrantShowGrantsMap(), new string[] { "No data returned", "SQL compilation error", "does not exist" });
                if (grantsToRolesList != null)
                {
                    loggerConsole.Info("Granted TO {0} grants", grantsToRolesList.Count);
                    grantsNonUniqueList.AddRange(grantsToRolesList);
                }

                List <Grant> grantsFutureDatabasesList = FileIOHelper.ReadListFromCSVFile <Grant>(FilePathMap.Data_FutureGrantsInDatabases_FilePath(), new GrantShowFutureGrantsMap(), new string[] { "No data returned", "SQL compilation error", "does not exist" });
                if (grantsFutureDatabasesList != null)
                {
                    loggerConsole.Info("Future Grants on Databases {0} grants", grantsFutureDatabasesList.Count);
                    grantsNonUniqueList.AddRange(grantsFutureDatabasesList);
                }

                List <Grant> grantsFutureSchemasList = FileIOHelper.ReadListFromCSVFile <Grant>(FilePathMap.Data_FutureGrantsInSchemas_FilePath(), new GrantShowFutureGrantsMap(), new string[] { "No data returned", "SQL compilation error", "does not exist" });
                if (grantsFutureSchemasList != null)
                {
                    loggerConsole.Info("Future Grants on Schemas {0} grants", grantsFutureSchemasList.Count);
                    grantsNonUniqueList.AddRange(grantsFutureSchemasList);
                }

                loggerConsole.Info("All Grants on Schemas {0} grants", grantsNonUniqueList.Count);

                #region Remove duplicates

                loggerConsole.Info("Removing duplicate grants");

                // Now remove duplicate USAGE and OWNERSHIP rows using these kinds of IDs
                // OWNERSHIP-ROLE-AAD_PROVISIONER-USERADMIN
                // USAGE-ROLE-AAD_PROVISIONER-USERADMIN
                // These occur only on ROLEs and because a role in hierarchy can be seen when parent says SHOW GRANTS ON and child says SHOW GRANTS TO
                List <Grant> grantsUniqueList    = new List <Grant>(grantsNonUniqueList.Count);
                var          uniqueGrantsGrouped = grantsNonUniqueList.GroupBy(g => g.UniqueIdentifier);
                foreach (var group in uniqueGrantsGrouped)
                {
                    grantsUniqueList.Add(group.First());
                }

                // Unescape special names of objects
                foreach (Grant grant in grantsUniqueList)
                {
                    grant.GrantedTo = grant.GrantedTo.Trim('"');
                    if (grant.GrantedBy != null)
                    {
                        grant.GrantedBy = grant.GrantedBy.Trim('"');
                    }
                }

                grantsUniqueList = grantsUniqueList.OrderBy(g => g.ObjectType).ThenBy(g => g.ObjectName).ThenBy(g => g.GrantedTo).ToList();
                FileIOHelper.WriteListToCSVFile <Grant>(grantsUniqueList, new GrantMap(), FilePathMap.Report_RoleGrant_FilePath());

                #endregion

                #region Individual Object Types

                loggerConsole.Info("Processing individual Object Types");

                // Break them up by the type
                var groupObjectTypesGrouped            = grantsUniqueList.GroupBy(g => g.ObjectType);
                List <SingleStringRow> objectTypesList = new List <SingleStringRow>(groupObjectTypesGrouped.Count());
                foreach (var group in groupObjectTypesGrouped)
                {
                    loggerConsole.Info("Processing grants for {0}", group.Key);

                    SingleStringRow objectType = new SingleStringRow();
                    objectType.Value = group.Key;
                    objectTypesList.Add(objectType);

                    #region Save this set of grants for Object Type

                    List <Grant> grantsOfObjectTypeList = group.ToList();

                    // Save this set as is for one of the tables in report
                    FileIOHelper.WriteListToCSVFile <Grant>(grantsOfObjectTypeList, new GrantMap(), FilePathMap.Report_RoleGrant_ObjectType_FilePath(group.Key));

                    // Pivot each section into this kind of table
                    //
                    // ObjectType | ObjectName | GrantedTo | OWNERSHIP | USAGE | REFERENCE | GrantN
                    // DATABASE   | SomeDB     | SomeRole  | X         | x+    |           |
                    // Where X+ means WithGrantOption=True
                    //       X  means WithGrantOption=False
                    List <ObjectTypeGrant>   objectGrantsList            = new List <ObjectTypeGrant>(grantsOfObjectTypeList.Count / 5);
                    Dictionary <string, int> privilegeToColumnDictionary = new Dictionary <string, int>(20);

                    #endregion

                    #region Convert this set into pivot

                    List <string> listOfPrivileges = grantsOfObjectTypeList.Select(g => g.Privilege).Distinct().OrderBy(g => g).ToList();

                    // Make USAGE and OWNERSHIP be the first columns
                    switch (group.Key)
                    {
                    case "ACCOUNT":
                        break;

                    case "DATABASE":
                    case "FILE_FORMAT":
                    case "FUNCTION":
                    case "INTEGRATION":
                    case "PROCEDURE":
                    case "ROLE":
                    case "SCHEMA":
                    case "SEQUENCE":
                    case "WAREHOUSE":
                        listOfPrivileges.Remove("OWNERSHIP");
                        listOfPrivileges.Insert(0, "OWNERSHIP");
                        listOfPrivileges.Remove("USAGE");
                        listOfPrivileges.Insert(1, "USAGE");
                        break;

                    case "EXTERNAL_TABLE":
                    case "MANAGED_ACCOUNT":
                    case "MASKING_POLICY":
                    case "MATERIALIZED_VIEW":
                    case "NETWORK_POLICY":
                    case "NOTIFICATION_SUBSCRIPTION":
                    case "PIPE":
                    case "RESOURCE_MONITOR":
                    case "SHARE":
                    case "STAGE":
                    case "STREAM":
                    case "TABLE":
                    case "TASK":
                    case "USER":
                    case "VIEW":
                        listOfPrivileges.Remove("OWNERSHIP");
                        listOfPrivileges.Insert(0, "OWNERSHIP");
                        break;

                    default:
                        break;
                    }
                    for (int i = 0; i < listOfPrivileges.Count; i++)
                    {
                        privilegeToColumnDictionary.Add(listOfPrivileges[i], i);
                    }

                    ObjectTypeGrant latestGrantRow = new ObjectTypeGrant();
                    foreach (Grant grant in grantsOfObjectTypeList)
                    {
                        // Loop through rows, starting new objects for each combination of ObjectType+ObjectName+GrantedTo when necessary
                        // ObjectType is always the same in this grouping
                        // ObjectName
                        if (latestGrantRow.ObjectType != grant.ObjectType ||
                            latestGrantRow.ObjectName != grant.ObjectName ||
                            latestGrantRow.GrantedTo != grant.GrantedTo)
                        {
                            // Need to start new row
                            latestGrantRow            = new ObjectTypeGrant();
                            latestGrantRow.ObjectType = grant.ObjectType;
                            latestGrantRow.ObjectName = grant.ObjectName;
                            latestGrantRow.DBName     = grant.DBName;
                            latestGrantRow.SchemaName = grant.SchemaName;
                            latestGrantRow.EntityName = grant.EntityName;
                            latestGrantRow.GrantedTo  = grant.GrantedTo;

                            objectGrantsList.Add(latestGrantRow);
                        }

                        // Find out which column to use
                        int privilegeColumnNumber = privilegeToColumnDictionary[grant.Privilege];

                        switch (privilegeColumnNumber)
                        {
                        case 0:
                            latestGrantRow.Privilege0 = grant.DisplaySettingWithGrantOption;
                            break;

                        case 1:
                            latestGrantRow.Privilege1 = grant.DisplaySettingWithGrantOption;
                            break;

                        case 2:
                            latestGrantRow.Privilege2 = grant.DisplaySettingWithGrantOption;
                            break;

                        case 3:
                            latestGrantRow.Privilege3 = grant.DisplaySettingWithGrantOption;
                            break;

                        case 4:
                            latestGrantRow.Privilege4 = grant.DisplaySettingWithGrantOption;
                            break;

                        case 5:
                            latestGrantRow.Privilege5 = grant.DisplaySettingWithGrantOption;
                            break;

                        case 6:
                            latestGrantRow.Privilege6 = grant.DisplaySettingWithGrantOption;
                            break;

                        case 7:
                            latestGrantRow.Privilege7 = grant.DisplaySettingWithGrantOption;
                            break;

                        case 8:
                            latestGrantRow.Privilege8 = grant.DisplaySettingWithGrantOption;
                            break;

                        case 9:
                            latestGrantRow.Privilege9 = grant.DisplaySettingWithGrantOption;
                            break;

                        case 10:
                            latestGrantRow.Privilege10 = grant.DisplaySettingWithGrantOption;
                            break;

                        case 11:
                            latestGrantRow.Privilege11 = grant.DisplaySettingWithGrantOption;
                            break;

                        case 12:
                            latestGrantRow.Privilege12 = grant.DisplaySettingWithGrantOption;
                            break;

                        case 13:
                            latestGrantRow.Privilege13 = grant.DisplaySettingWithGrantOption;
                            break;

                        case 14:
                            latestGrantRow.Privilege14 = grant.DisplaySettingWithGrantOption;
                            break;

                        case 15:
                            latestGrantRow.Privilege15 = grant.DisplaySettingWithGrantOption;
                            break;

                        case 16:
                            latestGrantRow.Privilege16 = grant.DisplaySettingWithGrantOption;
                            break;

                        case 17:
                            latestGrantRow.Privilege17 = grant.DisplaySettingWithGrantOption;
                            break;

                        case 18:
                            latestGrantRow.Privilege18 = grant.DisplaySettingWithGrantOption;
                            break;

                        case 19:
                            latestGrantRow.Privilege19 = grant.DisplaySettingWithGrantOption;
                            break;

                        default:
                            // Can't fit more than 20 privileges
                            logger.Warn("More then 20 Privileges reached with {0} privilege for object type {1}", grant.Privilege, grant.ObjectType);
                            break;
                        }
                    }

                    List <string> privilegeColumnNames = new List <string>(privilegeToColumnDictionary.Count);
                    for (int i = 0; i < privilegeToColumnDictionary.Count; i++)
                    {
                        privilegeColumnNames.Add(String.Empty);
                    }
                    foreach (var entry in privilegeToColumnDictionary)
                    {
                        privilegeColumnNames[entry.Value] = entry.Key;
                    }

                    // Save the pivot
                    FileIOHelper.WriteListToCSVFile <ObjectTypeGrant>(objectGrantsList, new ObjectTypeGrantMap(privilegeColumnNames), FilePathMap.Report_RoleGrant_ObjectType_Pivoted_FilePath(group.Key));

                    #endregion
                }

                FileIOHelper.WriteListToCSVFile <SingleStringRow>(objectTypesList, new SingleStringRowMap(), FilePathMap.Report_RoleGrant_ObjectTypes_FilePath());

                #endregion

                #endregion

                return(true);
            }
            catch (Exception ex)
            {
                logger.Error(ex);
                loggerConsole.Error(ex);

                return(false);
            }
            finally
            {
                stopWatch.Stop();

                this.DisplayJobStepEndedStatus(programOptions, stopWatch);

                stepTimingFunction.EndTime    = DateTime.Now;
                stepTimingFunction.Duration   = stopWatch.Elapsed;
                stepTimingFunction.DurationMS = stopWatch.ElapsedMilliseconds;

                List <StepTiming> stepTimings = new List <StepTiming>(1);
                stepTimings.Add(stepTimingFunction);
                FileIOHelper.WriteListToCSVFile(stepTimings, new StepTimingReportMap(), FilePathMap.StepTimingReportFilePath(), true);
            }
        }