@addsign/moje-agenda-shared-lib 1.0.60 → 2.0.0

package/lib/utils/PdfManager.ts

@@ -0,0 +1,224 @@
+import jsPDF from "jspdf";
+import "jspdf-autotable";
+import fontArial from "../fonts/arial";
+import fontArialBold from "../fonts/arialBold";
+
+class PDFManager {
+  private doc: jsPDF;
+  private currentYPosition: number;
+  private pageHeight: number;
+
+  constructor() {
+    this.doc = new jsPDF();
+    this.pageHeight = this.doc.internal.pageSize.height; // Get page height
+    this.currentYPosition = 10; // Start position at the top of the page
+    this.loadFonts();
+  }
+  public getPageHeight(): number {
+    return this.pageHeight;
+  }
+  public getCurrentY(): number {
+    return this.currentYPosition;
+  }
+
+  /**
+ * Adds a new page and resets the Y position.
+ */
+  public addNewPage() {
+    this.doc.addPage();
+    this.currentYPosition = 10; // Reset Y position for the new page
+  }
+
+  private loadFonts() {
+    this.doc.addFileToVFS("arial.ttf", fontArial);
+    this.doc.addFont("arial.ttf", "Arial", "normal");
+    this.doc.addFileToVFS("arialBold.ttf", fontArialBold);
+    this.doc.addFont("arialBold.ttf", "Arial", "bold");
+    this.doc.setFont("Arial", "normal");
+  }
+
+  /**
+   * Checks if a page break is needed and adds a new page if required.
+   */
+  private checkPageBreak(lineHeight: number) {
+    if (this.currentYPosition + lineHeight >= this.pageHeight) {
+      this.doc.addPage();
+      this.currentYPosition = 10; // Reset Y position for the new page
+    }
+  }
+
+  /**
+   * Appends text to the current PDF document.
+   */
+  appendText(
+    text: string,
+    options: {
+      fontSize?: number;
+      bold?: boolean;
+      marginLeft?: number;
+      marginTop?: number;
+      marginBottom?: number;
+    } = {},
+    textOptions: any = {},
+  ) {
+    const {
+      fontSize = 12,
+      bold = false,
+      marginTop = 0,
+      marginLeft = 0,
+      marginBottom = 0,
+    } = options;
+    const lineHeight = fontSize * 0.5; // Approximate line height based on font size
+    const maxWidth = textOptions.width || 190 - marginLeft; // Adjust width based on offset
+
+    this.doc.setFontSize(fontSize);
+
+    this.doc.setFont("Arial", bold ? "bold" : "normal");
+
+    // Split the text into multiple lines if it exceeds the maxWidth
+    const textLines = this.doc.splitTextToSize(text, maxWidth);
+    this.currentYPosition += marginTop;
+    // Loop through each line and append it to the document
+    textLines.forEach((line: string) => {
+      this.checkPageBreak(lineHeight); // Check if new page is needed
+      this.doc.text(line, 10 + marginLeft, this.currentYPosition, {
+        maxWidth, ...textOptions
+      });
+
+      this.currentYPosition += lineHeight; // Update Y position after each line
+    });
+    this.currentYPosition += marginBottom;
+  }
+
+  appendSquare(
+    options: {
+      color?: [number, number, number] | string; // RGB color or string (default is black)
+      height?: number; // Square height (default is 10 units)
+      width?: number; // Square width (default is 10 units)
+      marginLeft?: number; // Left margin before the table
+      marginTop?: number; // Top margin before the table
+      marginBottom?: number; // Bottom margin after the table
+      startX?: number; // X coordinate where the square starts (default is 10)
+      fill?: boolean; // Whether the square should be filled or outlined (default is true)
+    } = {},
+  ) {
+    const {
+      color = [0, 0, 0], // Default black color
+      height = 10, // Default square height
+      width = 10, // Default square width
+      marginTop = 0, // Default no offset
+      marginBottom = 0, // Default no offset
+      marginLeft = 0, // Default no offset
+      startX = 10, // Default starting X position
+      fill = true, // Default to filled square
+    } = options;
+
+    // Adjust currentYPosition for any offset
+    this.currentYPosition += marginTop;
+
+    // Check if a new page is needed
+    this.checkPageBreak(height + marginTop + marginBottom);
+
+    // Set the color for the square
+    if (Array.isArray(color)) {
+      this.doc.setFillColor(...color); // For RGB color
+      this.doc.setDrawColor(...color); // For outline color in case it's not filled
+    } else {
+      this.doc.setFillColor(color); // For string color (e.g., 'red', '#FF0000')
+      this.doc.setDrawColor(color); // For outline color in case it's not filled
+    }
+
+    // Draw the square (filled or outlined)
+    if (fill) {
+      this.doc.rect(startX + marginLeft, this.currentYPosition, width, height, "F"); // F for filled
+    } else {
+      this.doc.rect(startX + marginLeft, this.currentYPosition, width, height, "S"); // S for outlined (stroke)
+    }
+
+    // Update Y position after the square (including bottom margin)
+    this.currentYPosition += height + marginBottom;
+  }
+  appendTable(
+    headers: string[] | null, // The table headers
+    data: any[][], // The table data as an array of arrays
+    options: {
+      bold?: boolean; // Bold font for headers
+      marginLeft?: number; // Left margin before the table
+      marginRight?: number; // Left margin before the table
+      marginTop?: number; // Top margin before the table
+      marginBottom?: number; // Bottom margin after the table
+    } = {},
+    tableOptions: any = {},
+  ) {
+    const {
+      bold = true,
+      marginLeft = 0,
+      marginRight = 0,
+      marginTop = 0,
+      marginBottom = 0,
+    } = options;
+
+    // Adjust the current Y position with the top margin
+    this.currentYPosition += marginTop;
+
+    // Append the table using autoTable
+    (this.doc as any).autoTable({
+      head: headers ? [headers] : null,
+      body: data,
+      startY: this.currentYPosition,
+      margin: { left: 10 + marginLeft, right: 10 + marginRight }, // Adjust the left margin
+      styles: { ...tableOptions.styles },
+      headStyles: { fontStyle: bold ? "bold" : "normal" },
+      ...tableOptions,
+    });
+
+    // Update the Y position after the table
+    this.currentYPosition =
+      (this.doc as any).lastAutoTable.finalY + marginBottom;
+  }
+
+  //helper function for appening title with square
+  appendPageTitle(title: string) {
+    this.appendText(title, { fontSize: 14, bold: true });
+
+  }
+  appendPageTitleWithLine(title: string, fontSize: number = 14) {
+    this.appendText(title, { fontSize: fontSize, bold: true });
+    this.appendSquare({
+      color: "#000",
+      height: 0.2,
+      width: 190,
+      marginTop: -fontSize / 3, // Add space between squares
+      marginBottom: (fontSize / 2) + 1, // Add space between squares
+      startX: 10,
+      fill: true, // Filled green square
+    });
+  }
+
+  appendPageTitleWithSquare(title: string) {
+    this.appendSquare({
+      color: "#000", // Green square
+      height: 10,
+      width: 10,
+      marginTop: 0, // Add space between squares
+      marginBottom: 0, // Add space between squares
+      startX: 10,
+      fill: true, // Filled green square
+    });
+    this.appendText(title, { fontSize: 14, bold: true, marginLeft: 12, marginTop: -6, marginBottom: 5 });
+
+  }
+
+
+
+
+  /**
+   * Saves the current PDF document.
+   */
+  savePDF(fileName: string = "report.pdf") {
+    this.doc.save(fileName);
+    this.doc.close()
+  }
+}
+
+export default PDFManager;

package/lib/utils/getFullName.tsx

@@ -0,0 +1,83 @@
+// userDataFetcher.ts
+
+import { IEmployee, IPositionEmployee } from "../types";
+
+const getFullName = (
+  employee: IEmployee,
+  showEmplNumb: boolean = false,
+  highlighManagers: boolean = true
+) => {
+  if (!employee) {
+    return "Neobsazené systemizované místo";
+  }
+  const fullName =
+    (employee?.degreeBefore ? employee?.degreeBefore + " " : "") +
+    (employee?.firstName || "") +
+    " " +
+    (employee?.lastName || "") +
+    (employee?.degreeAfter ? " " + employee?.degreeAfter : "") +
+    (showEmplNumb ? " (" + employee?.employeeId + ")" : "");
+
+  if (highlighManagers) {
+    if (employee?.manager == "1") {
+      return <span className="font-bold"> {fullName} </span>;
+    } else {
+      return fullName;
+    }
+  } else {
+    return fullName;
+  }
+};
+const getFullNameList = (
+  employee: IEmployee,
+  showEmplNumb: boolean = false,
+  highlighManagers: boolean = true
+) => {
+  if (!employee) {
+    return "Neobsazené systemizované místo";
+  }
+  const fullName =
+    (employee?.lastName || "") +
+    " " +
+    (employee?.firstName || "") +
+    (employee?.degreeBefore ? " " + employee?.degreeBefore : "") +
+    (employee?.degreeAfter ? " " + employee?.degreeAfter : "") +
+    (showEmplNumb ? " (" + employee?.employeeId + ")" : "");
+
+  if (highlighManagers) {
+    if (employee?.manager == "1") {
+      return <span className="font-bold"> {fullName} </span>;
+    } else {
+      return fullName;
+    }
+  } else {
+    return fullName;
+  }
+};
+
+const getFullNamePositionWithEmployee = (
+  position: IPositionEmployee,
+  showEmplNumb: boolean = false,
+  highlighManagers: boolean = true
+) => {
+  if (!position.employee)
+    return "Neobsazená pozice (" + position.positionNumber + ")";
+  return getFullName(position.employee, showEmplNumb, highlighManagers);
+};
+const getFullNameListPositionWithEmployee = (
+  position: IPositionEmployee,
+  showEmplNumb: boolean = false,
+  highlighManagers: boolean = true
+) => {
+  if (!position.employee)
+    return "Neobsazená pozice (" + position.positionNumber + ")";
+  return getFullNameList(position.employee, showEmplNumb, highlighManagers);
+};
+export {};
+
+export {
+  getFullName,
+  getFullNameList,
+  getFullNamePositionWithEmployee,
+  getFullNameListPositionWithEmployee,
+};

package/lib/utils/getIntersectingDays.ts

@@ -0,0 +1,28 @@
+import { ICalendarItem } from "../types";
+
+const getIntersectingDays = (range: ICalendarItem, ranges: ICalendarItem[]): number => {
+    if (!range.from || !range.to || !ranges || ranges.length == 0) return 0
+
+    const msInDay = 1000 * 60 * 60 * 24
+    // Helper function to calculate the number of overlapping days between two ranges
+    const calculateOverlap = (start1: Date, end1: Date, start2: Date, end2: Date): number => {
+        const start = new Date(Math.max(start1.getTime(), start2.getTime()))
+        const end = new Date(Math.min(end1.getTime(), end2.getTime()))
+
+        if (start > end) {
+            return 0
+        }
+
+        // Calculate the number of days between the start and end dates
+        return Math.ceil((end.getTime() - start.getTime()) / msInDay) + 1
+    }
+
+    let totalIntersectingDays = 0
+
+    ranges?.forEach((item) => {
+        totalIntersectingDays += calculateOverlap(range.from, range.to, item.from, item.to)
+    })
+
+    return totalIntersectingDays
+}
+export { getIntersectingDays }

package/lib/utils/handleErrors.ts

@@ -0,0 +1,28 @@
+import { AxiosError } from "axios";
+import { Emitter } from "mitt";
+import { Events } from "../types";
+
+const handleErrors = (error: AxiosError, emitter: Emitter<Events>, customMessage?: string) => {
+    let errmsgToDisplay = (customMessage || "") + " " + ((error.response?.data as any)?.error?.message || error.message || "")
+
+    let errorTitle = ""
+    if (error.code == 'ERR_NETWORK') {
+        errorTitle = "Síťová chyba"
+        errmsgToDisplay = errmsgToDisplay + " " + new Date().toLocaleString();
+    } else if (error.code == 'ERR_BAD_REQUEST') {
+        if (error.response?.status == 403) {
+            errorTitle = "Přístup zamítnut"
+        } else {
+            errorTitle = "Interní chyba aplikace"
+        }
+        errmsgToDisplay = new Date().toLocaleString() + " (" + error.response?.status + ") \n" + errmsgToDisplay;
+    }
+    console.error(error);
+    emitter.emit("message", {
+        title: errorTitle,
+        message: errmsgToDisplay,
+        classes: "bg-danger ",
+        timeout: 0
+    });
+}
+export { handleErrors }

package/lib/utils/hasRightInModule.ts

@@ -0,0 +1,17 @@
+import { IAuthApps } from "../types";
+
+const hasRightInModule = (
+  authApps: IAuthApps,
+  moduleName: string = "global",
+  role?: string,
+): boolean => {
+  if (role === undefined) {
+    return authApps.some((app) => app.name === moduleName);
+  } else {
+    return authApps.some(
+      (app) => app.name === moduleName && app.roles?.includes(role),
+    );
+  }
+};
+
+export { hasRightInModule };

package/lib/utils/hasRole.ts

@@ -0,0 +1,12 @@
+import { IAuthApps } from "../types";
+
+const hasRole = (
+  authApps: IAuthApps,
+  role: string,
+): boolean => {
+
+  return authApps.some((app) => app.roles.includes(role));
+
+};
+
+export { hasRole };

package/lib/utils/utils.ts

@@ -0,0 +1,6 @@
+import { clsx, type ClassValue } from "clsx"
+import { twMerge } from "tailwind-merge"
+
+export function cn(...inputs: ClassValue[]) {
+    return twMerge(clsx(inputs))
+}

package/lib/vite-env.d.ts

@@ -0,0 +1 @@
+/// <reference types="vite/client" />

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@addsign/moje-agenda-shared-lib",
   "private": false,
-  "version": "1.0.60",
+  "version": "2.0.0",
   "type": "module",
   "main": "dist/main.js",
   "types": "dist/main.d.ts",
   "files": [
-    "dist"
+    "dist",
+    "lib"
   ],
   "sideEffects": [
     "**/*.css"
@@ -65,6 +66,7 @@
     "@radix-ui/react-dialog": "^1.1.2",
     "@radix-ui/react-label": "^2.1.0",
     "@radix-ui/react-popover": "^1.1.2",
+    "@radix-ui/react-radio-group": "^1.2.1",
     "@radix-ui/react-scroll-area": "^1.2.0",
     "@radix-ui/react-select": "^2.1.2",
     "@radix-ui/react-slot": "^1.1.0",
@@ -72,6 +74,7 @@
     "axios": "^1.7.2",
     "class-variance-authority": "^0.7.0",
     "clsx": "^2.1.1",
+    "cmdk": "^1.0.4",
     "date-fns": "^3.6.0",
     "file-saver": "^2.0.5",
     "jspdf": "^2.5.2",