more cleanup; pending proto adjustments

Tool: gitpod/catfood.gitpod.cloud

Author: geropl

components/gitpod-db/src/typeorm/entity/db-team-settings.ts

@@ -25,34 +25,34 @@ export class DBOrgSettings implements OrganizationSettings {
     workspaceSharingDisabled?: boolean;
 
     @Column("varchar", { nullable: true })
-    defaultWorkspaceImage?: string | null;
+    defaultWorkspaceImage?: string;
 
     @Column("json", { nullable: true })
-    allowedWorkspaceClasses?: string[] | null;
+    allowedWorkspaceClasses?: string[];
 
     @Column("json", { nullable: true })
-    pinnedEditorVersions?: { [key: string]: string } | null;
+    pinnedEditorVersions?: { [key: string]: string };
 
     @Column("json", { nullable: true })
-    restrictedEditorNames?: string[] | null;
+    restrictedEditorNames?: string[];
 
     @Column("varchar", { nullable: true })
-    defaultRole?: OrgMemberRole | undefined;
+    defaultRole?: OrgMemberRole;
 
     @Column("json", { nullable: true })
-    timeoutSettings?: TimeoutSettings | undefined;
+    timeoutSettings?: TimeoutSettings;
 
     @Column("json", { nullable: true })
-    roleRestrictions?: RoleRestrictions | undefined;
+    roleRestrictions?: RoleRestrictions;
 
     @Column({ type: "int", default: 0 })
     maxParallelRunningWorkspaces: number;
 
     @Column("json", { nullable: true })
-    onboardingSettings?: OnboardingSettings | undefined;
+    onboardingSettings?: OnboardingSettings;
 
     @Column({ type: "boolean", default: false })
-    annotateGitCommits?: boolean | undefined;
+    annotateGitCommits?: boolean;
 
     @Column()
     deleted: boolean;

components/gitpod-protocol/src/teams-projects-protocol.ts

@@ -216,15 +216,15 @@ export interface Organization {
 
 export interface OrganizationSettings {
     workspaceSharingDisabled?: boolean;
-    // null or empty string to reset to default
-    defaultWorkspaceImage?: string | null;
+    // undefined or empty string to reset to default
+    defaultWorkspaceImage?: string;
 
     // empty array to allow all kind of workspace classes
-    allowedWorkspaceClasses?: string[] | null;
+    allowedWorkspaceClasses?: string[];
 
-    pinnedEditorVersions?: { [key: string]: string } | null;
+    pinnedEditorVersions?: { [key: string]: string };
 
-    restrictedEditorNames?: string[] | null;
+    restrictedEditorNames?: string[];
 
     // what role new members will get, default is "member"
     defaultRole?: OrgMemberRole;

components/server/src/api/organization-service-api.ts

@@ -45,7 +45,6 @@ import { PaginationResponse } from "@gitpod/public-api/lib/gitpod/v1/pagination_
 import { validate as uuidValidate } from "uuid";
 import { ctxUserId } from "../util/request-context";
 import { ApplicationError, ErrorCodes } from "@gitpod/gitpod-protocol/lib/messaging/error";
-import { EntitlementService } from "../billing/entitlement-service";
 
 @injectable()
 export class OrganizationServiceAPI implements ServiceImpl<typeof OrganizationServiceInterface> {
@@ -54,8 +53,6 @@ export class OrganizationServiceAPI implements ServiceImpl<typeof OrganizationSe
         private readonly orgService: OrganizationService,
         @inject(PublicAPIConverter)
         private readonly apiConverter: PublicAPIConverter,
-        @inject(EntitlementService)
-        private readonly entitlementService: EntitlementService,
     ) {}
 
     async listOrganizationWorkspaceClasses(
@@ -266,16 +263,14 @@ export class OrganizationServiceAPI implements ServiceImpl<typeof OrganizationSe
                 "updateRestrictedEditorNames is required to be true to update restrictedEditorNames",
             );
         }
-        if (typeof req.workspaceSharingDisabled === "boolean") {
-            update.workspaceSharingDisabled = req.workspaceSharingDisabled;
-        }
-        if (typeof req.defaultWorkspaceImage === "string") {
-            update.defaultWorkspaceImage = req.defaultWorkspaceImage;
-        }
+
+        update.workspaceSharingDisabled = req.workspaceSharingDisabled;
+        update.defaultWorkspaceImage = req.defaultWorkspaceImage;
         update.allowedWorkspaceClasses = req.allowedWorkspaceClasses;
-        if (req.updatePinnedEditorVersions) {
-            update.pinnedEditorVersions = req.pinnedEditorVersions;
-        }
+        update.pinnedEditorVersions = req.pinnedEditorVersions;
+        update.annotateGitCommits = req.annotateGitCommits;
+        update.maxParallelRunningWorkspaces = req.maxParallelRunningWorkspaces;
+
         if (typeof req.defaultRole === "string" && req.defaultRole !== "") {
             switch (req.defaultRole) {
                 case "owner":
@@ -288,13 +283,8 @@ export class OrganizationServiceAPI implements ServiceImpl<typeof OrganizationSe
             }
         }
 
-        if (typeof req.timeoutSettings?.denyUserTimeouts === "boolean") {
-            update.timeoutSettings = update.timeoutSettings || {};
-            update.timeoutSettings.denyUserTimeouts = req.timeoutSettings.denyUserTimeouts;
-        }
-        if (typeof req.timeoutSettings?.inactivity === "object") {
-            update.timeoutSettings = update.timeoutSettings || {};
-            update.timeoutSettings.inactivity = this.apiConverter.toDurationString(req.timeoutSettings.inactivity);
+        if (req.timeoutSettings) {
+            update.timeoutSettings = this.apiConverter.fromTimeoutSettings(req.timeoutSettings);
         }
 
         if (req.roleRestrictions.length > 0 && !req.updateRoleRestrictions) {
@@ -304,35 +294,7 @@ export class OrganizationServiceAPI implements ServiceImpl<typeof OrganizationSe
             );
         }
         if (req.updateRoleRestrictions) {
-            update.roleRestrictions = update.roleRestrictions ?? {};
-            for (const roleRestriction of req.roleRestrictions) {
-                const role = this.apiConverter.fromOrgMemberRole(roleRestriction.role);
-                const permissions = roleRestriction.permissions.map((p) =>
-                    this.apiConverter.fromOrganizationPermission(p),
-                );
-                update.roleRestrictions[role] = permissions;
-            }
-        }
-
-        if (typeof req.maxParallelRunningWorkspaces === "number") {
-            if (req.maxParallelRunningWorkspaces < 0) {
-                throw new ApplicationError(ErrorCodes.BAD_REQUEST, "maxParallelRunningWorkspaces must be >= 0");
-            }
-            const maxAllowance = await this.entitlementService.getMaxParallelWorkspaces(
-                ctxUserId(),
-                req.organizationId,
-            );
-            if (maxAllowance && req.maxParallelRunningWorkspaces > maxAllowance) {
-                throw new ApplicationError(
-                    ErrorCodes.BAD_REQUEST,
-                    `maxParallelRunningWorkspaces must be <= ${maxAllowance}`,
-                );
-            }
-            if (!Number.isInteger(req.maxParallelRunningWorkspaces)) {
-                throw new ApplicationError(ErrorCodes.BAD_REQUEST, "maxParallelRunningWorkspaces must be an integer");
-            }
-
-            update.maxParallelRunningWorkspaces = req.maxParallelRunningWorkspaces;
+            update.roleRestrictions = this.apiConverter.fromRoleRestrictions(req.roleRestrictions);
         }
 
         if (req.onboardingSettings) {
@@ -349,10 +311,6 @@ export class OrganizationServiceAPI implements ServiceImpl<typeof OrganizationSe
             }
         }
 
-        if (req.annotateGitCommits !== undefined) {
-            update.annotateGitCommits = req.annotateGitCommits;
-        }
-
         if (Object.keys(update).length === 0) {
             throw new ApplicationError(ErrorCodes.BAD_REQUEST, "nothing to update");
         }

components/server/src/orgs/organization-service.ts

@@ -36,6 +36,7 @@ import { UsageService } from "./usage-service";
 import { CostCenter_BillingStrategy } from "@gitpod/gitpod-protocol/lib/usage";
 import { CreateUserParams, UserAuthentication } from "../user/user-authentication";
 import isURL from "validator/lib/isURL";
+import { EntitlementService } from "../billing/entitlement-service";
 
 @injectable()
 export class OrganizationService {
@@ -53,6 +54,7 @@ export class OrganizationService {
         @inject(DefaultWorkspaceImageValidator)
         private readonly validateDefaultWorkspaceImage: DefaultWorkspaceImageValidator,
         @inject(UserAuthentication) private readonly userAuthentication: UserAuthentication,
+        @inject(EntitlementService) private readonly entitlementService: EntitlementService,
     ) {}
 
     async listOrganizations(
@@ -490,19 +492,21 @@ export class OrganizationService {
         settings: Partial<OrganizationSettings>,
     ): Promise<OrganizationSettings> {
         await this.auth.checkPermissionOnOrganization(userId, "write_settings", orgId);
+
         if (typeof settings.defaultWorkspaceImage === "string") {
             const defaultWorkspaceImage = settings.defaultWorkspaceImage.trim();
             if (defaultWorkspaceImage) {
                 await this.validateDefaultWorkspaceImage(userId, defaultWorkspaceImage, orgId);
                 settings = { ...settings, defaultWorkspaceImage };
             } else {
-                settings = { ...settings, defaultWorkspaceImage: null };
+                settings = { ...settings, defaultWorkspaceImage: undefined };
             }
         }
+
         if (settings.allowedWorkspaceClasses) {
             if (settings.allowedWorkspaceClasses.length === 0) {
                 // Pass an empty array to allow all workspace classes
-                settings.allowedWorkspaceClasses = null;
+                settings.allowedWorkspaceClasses = undefined;
             } else {
                 const allClasses = await this.installationService.getInstallationWorkspaceClasses(userId);
                 const availableClasses = allClasses.filter((e) => settings.allowedWorkspaceClasses!.includes(e.id));
@@ -550,6 +554,22 @@ export class OrganizationService {
             }
         }
 
+        if (settings.maxParallelRunningWorkspaces !== undefined) {
+            if (settings.maxParallelRunningWorkspaces < 0) {
+                throw new ApplicationError(ErrorCodes.BAD_REQUEST, "maxParallelRunningWorkspaces must be >= 0");
+            }
+            const maxAllowance = await this.entitlementService.getMaxParallelWorkspaces(userId, orgId);
+            if (maxAllowance && settings.maxParallelRunningWorkspaces > maxAllowance) {
+                throw new ApplicationError(
+                    ErrorCodes.BAD_REQUEST,
+                    `maxParallelRunningWorkspaces must be <= ${maxAllowance}`,
+                );
+            }
+            if (!Number.isInteger(settings.maxParallelRunningWorkspaces)) {
+                throw new ApplicationError(ErrorCodes.BAD_REQUEST, "maxParallelRunningWorkspaces must be an integer");
+            }
+        }
+
         if (settings.onboardingSettings) {
             if (settings.onboardingSettings.internalLink) {
                 if (settings.onboardingSettings.internalLink.length > 255) {
@@ -636,10 +656,7 @@ export class OrganizationService {
             result.defaultRole = settings.defaultRole;
         }
         if (settings.timeoutSettings) {
-            result.timeoutSettings = {
-                denyUserTimeouts: settings.timeoutSettings?.denyUserTimeouts,
-                inactivity: settings.timeoutSettings?.inactivity,
-            };
+            result.timeoutSettings = settings.timeoutSettings;
         }
         if (settings.roleRestrictions) {
             result.roleRestrictions = settings.roleRestrictions;