@oneuptime/common 7.0.4922 → 7.0.4976

package/Server/Utils/Workspace/Slack/Actions/ScheduledMaintenance.ts

@@ -34,6 +34,7 @@ import OneUptimeDate from "../../../../../Types/Date";
 import AccessTokenService from "../../../../Services/AccessTokenService";
 import CaptureSpan from "../../../Telemetry/CaptureSpan";
 import WorkspaceType from "../../../../../Types/Workspace/WorkspaceType";
+import WorkspaceNotificationLogService from "../../../../Services/WorkspaceNotificationLogService";
 
 export default class SlackScheduledMaintenanceActions {
   @CaptureSpan()
@@ -582,6 +583,38 @@ export default class SlackScheduledMaintenanceActions {
         userId,
       );
 
+      // Log the button interaction
+      if (slackRequest.projectId) {
+        try {
+          const logData: {
+            projectId: ObjectID;
+            workspaceType: WorkspaceType;
+            channelId?: string;
+            userId: ObjectID;
+            buttonAction: string;
+            scheduledMaintenanceId?: ObjectID;
+          } = {
+            projectId: slackRequest.projectId,
+            workspaceType: WorkspaceType.Slack,
+            userId: userId,
+            buttonAction: "mark_scheduled_maintenance_as_ongoing",
+          };
+
+          if (slackRequest.slackChannelId) {
+            logData.channelId = slackRequest.slackChannelId;
+          }
+          logData.scheduledMaintenanceId = scheduledMaintenanceId;
+
+          await WorkspaceNotificationLogService.logButtonPressed(logData, {
+            isRoot: true,
+          });
+        } catch (err) {
+          logger.error("Error logging button interaction:");
+          logger.error(err);
+          // Don't throw the error, just log it so the main flow continues
+        }
+      }
+
       // Scheduled Maintenance Feed will send a message to the channel that the scheduledMaintenance has been Ongoing.
       return;
     }
@@ -679,6 +712,38 @@ export default class SlackScheduledMaintenanceActions {
         userId,
       );
 
+      // Log the button interaction
+      if (slackRequest.projectId) {
+        try {
+          const logData: {
+            projectId: ObjectID;
+            workspaceType: WorkspaceType;
+            channelId?: string;
+            userId: ObjectID;
+            buttonAction: string;
+            scheduledMaintenanceId?: ObjectID;
+          } = {
+            projectId: slackRequest.projectId,
+            workspaceType: WorkspaceType.Slack,
+            userId: userId,
+            buttonAction: "mark_scheduled_maintenance_as_complete",
+          };
+
+          if (slackRequest.slackChannelId) {
+            logData.channelId = slackRequest.slackChannelId;
+          }
+          logData.scheduledMaintenanceId = scheduledMaintenanceId;
+
+          await WorkspaceNotificationLogService.logButtonPressed(logData, {
+            isRoot: true,
+          });
+        } catch (err) {
+          logger.error("Error logging button interaction:");
+          logger.error(err);
+          // Don't throw the error, just log it so the main flow continues
+        }
+      }
+
       return;
     }
 

package/Server/Utils/Workspace/Slack/Slack.ts

@@ -729,13 +729,28 @@ export default class SlackUtil extends WorkspaceBase {
 
     // add channel ids.
     for (const channelId of data.workspaceMessagePayload.channelIds) {
-      const channel: WorkspaceChannel = {
-        id: channelId,
-        name: "",
-        workspaceType: WorkspaceType.Slack,
-      };
+      try {
+        // Get the channel info including name from channel ID
+        const channel: WorkspaceChannel =
+          await this.getWorkspaceChannelFromChannelId({
+            authToken: data.authToken,
+            channelId: channelId,
+          });
 
-      workspaceChannelsToPostTo.push(channel);
+        workspaceChannelsToPostTo.push(channel);
+      } catch (err) {
+        logger.error(`Error getting channel info for channel ID ${channelId}:`);
+        logger.error(err);
+
+        // Fallback: create channel object with empty name if API call fails
+        const channel: WorkspaceChannel = {
+          id: channelId,
+          name: channelId,
+          workspaceType: WorkspaceType.Slack,
+        };
+
+        workspaceChannelsToPostTo.push(channel);
+      }
     }
 
     logger.debug("Channel IDs to post to:");

package/Types/Permission.ts

@@ -142,6 +142,8 @@ enum Permission {
   ReadSmsLog = "ReadSmsLog",
   ReadEmailLog = "ReadEmailLog",
   ReadCallLog = "ReadCallLog",
+  ReadPushLog = "ReadPushLog",
+  ReadWorkspaceNotificationLog = "ReadWorkspaceNotificationLog",
 
   CreateIncidentOwnerTeam = "CreateIncidentOwnerTeam",
   DeleteIncidentOwnerTeam = "DeleteIncidentOwnerTeam",
@@ -3003,6 +3005,24 @@ export class PermissionHelper {
         isAccessControlPermission: false,
       },
 
+      {
+        permission: Permission.ReadPushLog,
+        title: "Read Push Log",
+        description:
+          "This permission can read Push Notification Logs of this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: false,
+      },
+
+      {
+        permission: Permission.ReadWorkspaceNotificationLog,
+        title: "Read Workspace Notification Log",
+        description:
+          "This permission can read Workspace Notification Logs (Slack / Microsoft Teams) of this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: false,
+      },
+
       {
         permission: Permission.CreateMonitorProbe,
         title: "Create Monitor Probe",

package/Types/PushNotification/PushNotificationRequest.ts

@@ -1,5 +1,8 @@
 interface PushNotificationRequest {
-  deviceTokens: string[];
+  devices: Array<{
+    token: string;
+    name?: string;
+  }>;
   message: {
     title: string;
     body: string;

package/Types/PushNotification/PushStatus.ts

@@ -0,0 +1,6 @@
+enum PushStatus {
+  Success = "Success",
+  Error = "Error",
+}
+
+export default PushStatus;

package/Types/Workspace/WorkspaceNotificationActionType.ts

@@ -0,0 +1,8 @@
+enum WorkspaceNotificationActionType {
+  SendMessage = "SendMessage",
+  CreateChannel = "CreateChannel",
+  InviteUser = "InviteUser",
+  ButtonPressed = "ButtonPressed",
+}
+
+export default WorkspaceNotificationActionType;

package/Types/Workspace/WorkspaceNotificationStatus.ts

@@ -0,0 +1,6 @@
+enum WorkspaceNotificationStatus {
+  Success = "Success",
+  Error = "Error",
+}
+
+export default WorkspaceNotificationStatus;

package/Typings/elkjs.d.ts

@@ -0,0 +1,30 @@
+declare module "elkjs/lib/elk.bundled.js" {
+  export interface ElkNode {
+    id?: string;
+    x?: number;
+    y?: number;
+    width?: number | undefined;
+    height?: number | undefined;
+    layoutOptions?: Record<string, string>;
+    children?: ElkNode[];
+    edges?: Array<ElkPrimitiveEdge | ElkExtendedEdge>;
+  }
+
+  export interface ElkPrimitiveEdge {
+    id: string;
+    sources: string[];
+    targets: string[];
+  }
+
+  export interface ElkExtendedEdge extends ElkPrimitiveEdge {
+    sections?: Array<{
+      startPoint?: { x: number; y: number };
+      endPoint?: { x: number; y: number };
+      bendPoints?: Array<{ x: number; y: number }>;
+    }>;
+  }
+
+  export default class ELK {
+    public layout(graph: ElkNode): Promise<ElkNode>;
+  }
+}

package/UI/Components/Detail/Detail.tsx

@@ -420,7 +420,7 @@ const Detail: DetailFunction = <T extends GenericObject>(
                 )}
             </div>
           )}
-          {!data && field.placeholder && (
+          {(data === null || data === undefined) && field.placeholder && (
             <PlaceholderText text={field.placeholder} />
           )}
         </div>

package/UI/Components/Graphs/ServiceDependencyGraph.tsx

@@ -0,0 +1,281 @@
+import React, {
+  FunctionComponent,
+  ReactElement,
+  useEffect,
+  useState,
+} from "react";
+import ReactFlow, {
+  Background,
+  Controls,
+  Edge,
+  MarkerType,
+  MiniMap,
+  Node,
+  Position,
+} from "reactflow";
+import "reactflow/dist/style.css";
+import type { ElkExtendedEdge, ElkNode } from "elkjs";
+import ELK from "elkjs/lib/elk.bundled.js";
+
+export interface ServiceNodeData {
+  id: string;
+  name: string;
+  color?: string;
+}
+
+export interface ServiceEdgeData {
+  fromServiceId: string;
+  toServiceId: string;
+}
+
+export interface ServiceDependencyGraphProps {
+  services: Array<ServiceNodeData>;
+  dependencies: Array<ServiceEdgeData>;
+}
+
+const ServiceDependencyGraph: FunctionComponent<ServiceDependencyGraphProps> = (
+  props: ServiceDependencyGraphProps,
+): ReactElement => {
+  const computeLuminance: (r: number, g: number, b: number) => number = (
+    r: number,
+    g: number,
+    b: number,
+  ): number => {
+    const transform: (v: number) => number = (v: number): number => {
+      const c: number = v / 255;
+      return c <= 0.03928 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+    };
+    const R: number = transform(r);
+    const G: number = transform(g);
+    const B: number = transform(b);
+    return 0.2126 * R + 0.7152 * G + 0.0722 * B;
+  };
+
+  const getContrastText: (bg?: string) => string = (bg?: string): string => {
+    if (!bg) {
+      return "#111827"; // gray-900
+    }
+    // normalize to hex like #rrggbb
+    let hex: string = bg.trim();
+    if (hex.startsWith("rgb")) {
+      // basic rgb(a) parser
+      const m: RegExpMatchArray | null = hex
+        .replace(/\s+/g, "")
+        .match(/rgba?\((\d+),(\d+),(\d+)/i);
+      if (m) {
+        const r: number = parseInt(m[1] as string, 10);
+        const g: number = parseInt(m[2] as string, 10);
+        const b: number = parseInt(m[3] as string, 10);
+        const luminance: number = computeLuminance(r, g, b);
+        return luminance > 0.5 ? "#111827" : "#ffffff";
+      }
+      return "#111827";
+    }
+    if (hex[0] === "#") {
+      hex = hex.slice(1);
+    }
+    if (hex.length === 3) {
+      hex = hex
+        .split("")
+        .map((c: string): string => {
+          return c + c;
+        })
+        .join("");
+    }
+    if (hex.length !== 6) {
+      return "#111827";
+    }
+    const r: number = parseInt(hex.slice(0, 2), 16);
+    const g: number = parseInt(hex.slice(2, 4), 16);
+    const b: number = parseInt(hex.slice(4, 6), 16);
+    const luminance: number = computeLuminance(r, g, b);
+    return luminance > 0.5 ? "#111827" : "#ffffff";
+  };
+
+  const [rfNodes, setRfNodes] = useState<Node[]>([]);
+  const [rfEdges, setRfEdges] = useState<Edge[]>([]);
+
+  useEffect((): void => {
+    const elk: any = new ELK();
+    // fixed node dimensions for layout (px)
+    const NODE_WIDTH: number = 220;
+    const NODE_HEIGHT: number = 56;
+
+    const sortedServices: Array<ServiceNodeData> = [...props.services].sort(
+      (a: ServiceNodeData, b: ServiceNodeData): number => {
+        return a.name.localeCompare(b.name) || a.id.localeCompare(b.id);
+      },
+    );
+    const sortedDeps: Array<ServiceEdgeData> = [...props.dependencies].sort(
+      (a: ServiceEdgeData, b: ServiceEdgeData): number => {
+        if (a.fromServiceId === b.fromServiceId) {
+          return a.toServiceId.localeCompare(b.toServiceId);
+        }
+        return a.fromServiceId.localeCompare(b.fromServiceId);
+      },
+    );
+
+    const elkGraph: ElkNode = {
+      id: "root",
+      layoutOptions: {
+        algorithm: "layered",
+        "elk.direction": "RIGHT",
+        "elk.layered.spacing.nodeNodeBetweenLayers": "120",
+        "elk.spacing.nodeNode": "60",
+        "elk.edgeRouting": "POLYLINE",
+      },
+      children: sortedServices.map((svc: ServiceNodeData): ElkNode => {
+        return {
+          id: svc.id,
+          width: NODE_WIDTH,
+          height: NODE_HEIGHT,
+        } as ElkNode;
+      }),
+      edges: sortedDeps.map((dep: ServiceEdgeData): ElkExtendedEdge => {
+        return {
+          id: `e-${dep.fromServiceId}-${dep.toServiceId}`,
+          sources: [dep.fromServiceId],
+          targets: [dep.toServiceId],
+        };
+      }),
+    };
+
+    const layout: () => Promise<void> = async (): Promise<void> => {
+      try {
+        const res: any = await elk.layout(elkGraph as any);
+        const placedNodes: Node[] = (res.children || []).map(
+          (child: any): Node => {
+            const svc: ServiceNodeData | undefined = sortedServices.find(
+              (s: ServiceNodeData): boolean => {
+                return s.id === child.id;
+              },
+            );
+            const background: string = svc?.color || "#ffffff";
+            const textColor: string = getContrastText(background);
+            return {
+              id: child.id || "",
+              data: { label: svc?.name || "" },
+              position: { x: child.x || 0, y: child.y || 0 },
+              sourcePosition: Position.Right,
+              targetPosition: Position.Left,
+              style: {
+                borderRadius: 8,
+                padding: 8,
+                border: "1px solid rgba(0,0,0,0.08)",
+                background,
+                color: textColor,
+                boxShadow: "0 1px 2px rgba(16,24,40,.05)",
+                width: NODE_WIDTH,
+                height: NODE_HEIGHT,
+              },
+            } as Node;
+          },
+        );
+
+        const stroke: string = "#94a3b8"; // slate-400
+        const placedEdges: Edge[] = sortedDeps.map(
+          (dep: ServiceEdgeData): Edge => {
+            return {
+              id: `e-${dep.fromServiceId}-${dep.toServiceId}`,
+              source: dep.fromServiceId,
+              target: dep.toServiceId,
+              animated: false,
+              style: { stroke, strokeWidth: 2 },
+              markerEnd: { type: MarkerType.Arrow, color: stroke },
+              type: "smoothstep",
+            };
+          },
+        );
+
+        setRfNodes(placedNodes);
+        setRfEdges(placedEdges);
+      } catch {
+        // Fallback: deterministic grid by name
+        const sorted: Array<ServiceNodeData> = sortedServices;
+        const COLS: number = 4;
+        const GAP_X: number = 260;
+        const GAP_Y: number = 120;
+        const nodes: Node[] = sorted.map(
+          (svc: ServiceNodeData, i: number): Node => {
+            const col: number = i % COLS;
+            const row: number = Math.floor(i / COLS);
+            const x: number = col * GAP_X;
+            const y: number = row * GAP_Y;
+            const background: string = svc.color || "#ffffff";
+            const textColor: string = getContrastText(background);
+            return {
+              id: svc.id,
+              data: { label: svc.name },
+              position: { x, y },
+              sourcePosition: Position.Right,
+              targetPosition: Position.Left,
+              style: {
+                borderRadius: 8,
+                padding: 8,
+                border: "1px solid rgba(0,0,0,0.08)",
+                background,
+                color: textColor,
+                boxShadow: "0 1px 2px rgba(16,24,40,.05)",
+                width: NODE_WIDTH,
+                height: NODE_HEIGHT,
+              },
+            };
+          },
+        );
+        const stroke: string = "#94a3b8";
+        const edges: Edge[] = sortedDeps.map((dep: ServiceEdgeData): Edge => {
+          return {
+            id: `e-${dep.fromServiceId}-${dep.toServiceId}`,
+            source: dep.fromServiceId,
+            target: dep.toServiceId,
+            animated: false,
+            style: { stroke, strokeWidth: 2 },
+            markerEnd: { type: MarkerType.Arrow, color: stroke },
+            type: "smoothstep",
+          };
+        });
+        setRfNodes(nodes);
+        setRfEdges(edges);
+      }
+    };
+
+    layout();
+  }, [props.services, props.dependencies]);
+
+  return (
+    <div style={{ width: "100%", height: 600 }}>
+      <style>{`
+        /* Hide/transparentize connection handles (ports) for read-only view */
+        .service-dependency-graph .react-flow__handle {
+          background: transparent !important;
+          border-color: transparent !important;
+        }
+      `}</style>
+      <ReactFlow
+        className="service-dependency-graph"
+        nodes={rfNodes}
+        edges={rfEdges}
+        fitView
+        nodesDraggable={false}
+        nodesConnectable={false}
+        elementsSelectable={false}
+        edgesUpdatable={false}
+        connectOnClick={false}
+      >
+        <MiniMap
+          nodeColor={(n: Node): string => {
+            return (
+              (n.style as any)?.background ||
+              (n.data as any)?.color ||
+              "#ffffff"
+            );
+          }}
+        />
+        <Controls />
+        <Background gap={12} size={1} />
+      </ReactFlow>
+    </div>
+  );
+};
+
+export default ServiceDependencyGraph;

package/UI/Components/Tabs/Tab.tsx

@@ -25,18 +25,19 @@ const TabElement: FunctionComponent<ComponentProps> = (
 ): ReactElement => {
   const backgroundColor: string = "bg-gray-100";
 
+  const baseClasses: string =
+    "rounded-md px-3 py-2 text-sm font-medium cursor-pointer inline-flex whitespace-nowrap flex-shrink-0";
+  const stateClasses: string = props.isSelected
+    ? `${backgroundColor} text-gray-700`
+    : "text-gray-500 hover:text-gray-700";
+
   return (
     <div className="mt-3 mb-3">
       <div
         data-testid={`tab-${props.tab.name}`}
         key={props.tab.name}
         onClick={props.onClick}
-        className={`${
-          (props.isSelected
-            ? backgroundColor + " text-gray-700"
-            : "text-gray-500 hover:text-gray-700") +
-          " rounded-md px-3 py-2 text-sm font-medium cursor-pointer flex"
-        }`}
+        className={`${stateClasses} ${baseClasses}`}
         aria-current={props.isSelected ? "page" : undefined}
       >
         <div>{props.tab.name}</div>
@@ -57,9 +58,7 @@ const TabElement: FunctionComponent<ComponentProps> = (
           >
             {props.tab.countBadge}
           </span>
-        ) : (
-          <></>
-        )}
+        ) : null}
       </div>
     </div>
   );

package/UI/Components/Tabs/Tabs.tsx

@@ -28,22 +28,23 @@ const Tabs: FunctionComponent<ComponentProps> = (
 
   return (
     <div>
-      <div className="hidden sm:block">
-        <nav className="flex space-x-4" aria-label="Tabs">
-          {props.tabs.map((tab: Tab) => {
-            return (
-              <TabElement
-                key={tab.name}
-                tab={tab}
-                onClick={() => {
-                  setCurrentTab(tab);
-                }}
-                isSelected={tab === currentTab}
-              />
-            );
-          })}
-        </nav>
-      </div>
+      <nav
+        className="flex space-x-2 overflow-x-auto md:overflow-visible md:space-x-4"
+        aria-label="Tabs"
+      >
+        {props.tabs.map((tab: Tab) => {
+          return (
+            <TabElement
+              key={tab.name}
+              tab={tab}
+              onClick={() => {
+                setCurrentTab(tab);
+              }}
+              isSelected={tab === currentTab}
+            />
+          );
+        })}
+      </nav>
       <div className="mt-3 ml-1">{currentTab && currentTab.children}</div>
     </div>
   );

package/Utils/Uptime/UptimeUtil.ts

@@ -134,7 +134,26 @@ export default class UptimeUtil {
           eventList[eventList.length - 1]!.endDate,
         )
       ) {
-        if (monitorEvent.priority > eventList[eventList.length - 1]!.priority) {
+        let isEndDateOfCurrenteventAfterLastEvent: boolean = false;
+        if (
+          eventList[eventList.length - 1] &&
+          eventList[eventList.length - 1]?.endDate
+        ) {
+          isEndDateOfCurrenteventAfterLastEvent =
+            OneUptimeDate.isAfter(
+              monitorEvent.endDate,
+              eventList[eventList.length - 1]!.endDate,
+            ) ||
+            OneUptimeDate.isEqualBySeconds(
+              monitorEvent.endDate,
+              eventList[eventList.length - 1]!.endDate,
+            );
+        }
+
+        if (
+          monitorEvent.priority > eventList[eventList.length - 1]!.priority ||
+          isEndDateOfCurrenteventAfterLastEvent
+        ) {
           // end the last event at the start of this event.
 
           const tempLastEvent: Event = {