create-dovite 2.0.0 → 2.2.0

package/templates/react-js/src/API/dataApi.js

@@ -0,0 +1,235 @@
+import domo from "ryuu.js";
+import axios from "axios";
+
+export async function fetchAIData(prompt, template, maxWords) {
+  try {
+    // Validate the required "prompt" parameter
+    if (!prompt || typeof prompt !== "string") {
+      throw new Error("The 'prompt' parameter is required and must be a string.");
+    }
+
+    // Construct the body dynamically, including properties only if they are valid
+    const body = {
+      input: prompt,
+      ...(template && typeof template === "string" && {
+        promptTemplate: {
+          template,
+        },
+      }),
+      ...(maxWords && !isNaN(maxWords) && {
+        parameters: {
+          max_words: maxWords.toString(),
+        },
+      }),
+    };
+
+    // Send the POST request
+    const response = await domo.post(`/domo/ai/v1/text/generation`, body);
+    console.log("AI Response:", response.output);
+    
+    return response?.output;
+  } catch (error) {
+    console.error("Error fetching data:", error);
+    throw error; // Re-throw the error for better upstream handling
+  }
+}
+
+
+export async function fetchData(dataset) {
+  try {
+    const response = await domo.get(`/data/v1/${dataset}`).then((data) => {
+      return data;
+    });
+    // console.log(response);
+    return response;
+  } catch (error) {
+    console.error("Error fetching data:", error);
+  }
+}
+
+export async function fetchSqlData(dataset, query) {
+  // console.log("Query",query);
+  
+  // Ensure the query is a string
+  if (typeof query !== "string") {
+    throw new Error("Query must be a string");
+  }
+
+  try {
+    // Fetch data from the API
+    const apiData = await domo
+      .post(`/sql/v1/${dataset}`, query, { contentType: "text/plain" })
+      .then((data) => {
+        // console.log('Fetched Data:', data);
+        return data;
+      });
+
+    // Validate the fetched data
+    if (!apiData || !apiData.columns || !apiData.rows) {
+      throw new Error("Invalid data received from the API");
+    }
+
+    // Extract and clean column names
+    const cleanedColumns = apiData.columns.map((column) => {
+      return column
+        .replace(/`/g, "")
+        .replace(/T1\./g, "")
+        .replace(/avg\((.*?)\)/i, "$1")
+        .trim();
+    });
+
+    // Map rows to cleaned column names
+    const jsonResult = apiData.rows.map((row) => {
+      const jsonObject = {};
+      cleanedColumns.forEach((cleanedColumn, index) => {
+        jsonObject[cleanedColumn] = row[index];
+      });
+      return jsonObject;
+    });
+
+    // console.log("Mapped SQL DATA",jsonResult);
+
+    // Return the dynamically created JSON
+    return jsonResult;
+  } catch (error) {
+    console.error("Error fetching or processing data:", error);
+    throw error; // Rethrow the error for the caller to handle
+  }
+}
+
+export async function sendEmail(to, subject, body, attachment) {
+  const data = {
+    to,
+    subject,
+    body,
+    ...(attachment && { attachment: [attachment] }),
+  };
+
+  if (data) {
+    try {
+      const response = await domo.post(
+        `/domo/workflow/v1/models/email/start`,
+        data
+      );
+      if (response) {
+        console.log("response", response);
+      }
+    } catch (err) {
+      console.error("Error sending email:", err);
+    }
+  }
+}
+
+//Dataflow
+export const DataflowsActions = async (action, dataflowId) => {
+  const data = {
+    action,
+    dataflowId,
+    result: true,
+  };
+
+  if (data) {
+    try {
+      const response = await domo.post(
+        `/domo/workflow/v1/models/dataflow/start`,
+        data
+      );
+      if (response) {
+        console.log("response", response);
+      }
+    } catch (err) {
+      console.error("Error sending email:", err);
+    }
+  }
+};
+export const generateAccessToken = async (clientId, clientSecret) => {
+  const tokenUrl = "https://api.domo.com/oauth/token";
+  try {
+    const response = await axios.post(
+      tokenUrl,
+      new URLSearchParams({
+        grant_type: "client_credentials",
+        scope: "user",
+      }).toString(),
+      {
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+        },
+        auth: {
+          username: clientId,
+          password: clientSecret,
+        },
+      }
+    );
+    console.log("Response:", response);
+
+    console.log("Access Token:", response.data.access_token);
+
+    return response.data.access_token;
+  } catch (err) {
+    console.error("Error:", err);
+    throw err;
+  }
+};
+
+//List Of Users
+export const fetchUsers = async (accessToken) => {
+  const userUrl = `https://api.domo.com/v1/users?limit=500`;
+  console.log("accessToken", accessToken);
+  try {
+    if (!accessToken) {
+      console.log("Access token not found");
+      return;
+    }
+    const response = await axios.get(userUrl, {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+      },
+    });
+    console.log("List of users with access token", response.data);
+    return response.data;
+  } catch (err) {
+    console.error("Error fetching User details:", err);
+  }
+};
+
+//List Of Dataset
+export const fetchDatasets = async (accessToken) => {
+  const datasetUrl = `https://api.domo.com/v1/datasets`;
+
+  try {
+    if (!accessToken) {
+      await generateAccessToken();
+    }
+    const response = await axios.get(datasetUrl, {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+      },
+    });
+    // console.log("List of dataset", response.data);
+    return response.data;
+  } catch (err) {
+    console.error("Error fetching dataset details:", err);
+  }
+};
+
+//Perticaular Dataset Details
+export const fetchDatasetDetails = async (accessToken, datasetId) => {
+  const datasetUrl = `https://api.domo.com/v1/datasets/${datasetId}`;
+
+  try {
+    if (!accessToken) {
+      await generateAccessToken();
+    }
+
+    const response = await axios.get(datasetUrl, {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+      },
+    });
+    // console.log("data", response.data)
+    return response.data;
+  } catch (err) {
+    console.error("Error fetching dataset details:", err);
+  }
+};

package/templates/react-js/src/API/domoAPI.js

@@ -0,0 +1,311 @@
+import domo from "ryuu.js";
+// import Download from "downloadjs";
+
+const BASE_URL = "/domo/datastores/v1";
+
+const GetCurrentUser = () => {
+  return domo
+    .get("/domo/environment/v1")
+    .then((user) => ({
+      ...user,
+      displayName: user.userName,
+      avatarKey: `/domo/avatars/v2/USER/${user.userId}`,
+    }))
+    .catch((error) => {
+      console.error("Error getting current user:", error);
+      throw error;
+    });
+};
+
+const GetAllUser = () => {
+  return domo
+    .get(`/domo/users/v1?limit={500}`)
+    .then((response) => response)
+    .catch((error) => {
+      console.error("Error getting All users:", error);
+      throw error;
+    });
+};
+
+const GetUser = (userId) => {
+  return domo
+    .get(`/domo/users/v1/${userId}?includeDetails=true`)
+    .then((user) => ({ ...user, userName: user.displayName }))
+    .catch((error) => {
+      console.error("Error getting user:", error);
+      throw error;
+    });
+};
+
+const CreateDocument = (collectionName, document) => {
+  console.log(document);
+  console.log(collectionName);
+
+  return domo
+    .post(`${BASE_URL}/collections/${collectionName}/documents/`, {
+      content: document,
+    })
+    .then((response) => response)
+    .catch((error) => {
+      console.error("Error creating document:", error);
+      throw error;
+    });
+};
+
+const ListDocuments = (collectionName) => {
+  return domo
+    .get(`${BASE_URL}/collections/${collectionName}/documents/`)
+    .then((response) => response)
+    .catch((error) => {
+      console.error("Error listing documents:", error);
+      throw error;
+    });
+};
+
+const GetDocument = (collectionName, documentId) => {
+  return domo
+    .get(`${BASE_URL}/collections/${collectionName}/documents/${documentId}`)
+    .then((response) => response)
+    .catch((error) => {
+      console.error("Error getting document:", error);
+      throw error;
+    });
+};
+
+const UpdateDocument = (collectionName, documentId, document) => {
+  return domo
+    .put(`${BASE_URL}/collections/${collectionName}/documents/${documentId}`, {
+      content: document,
+    })
+    .then((response) => response)
+    .catch((error) => {
+      console.error("Error updating document:", error);
+      throw error;
+    });
+};
+const queryDocumentsWithAggregations = (
+  collectionName,
+  query = {},
+  aggregations = {},
+  options = {}
+) => {
+  // Base URL for the query
+  let url = `${BASE_URL}/collections/${collectionName}/documents/query?`;
+
+  // Helper function to format aggregation parameters
+  const formatAggregationParams = (params) => {
+    return Object.entries(params)
+      .map(([property, alias]) => `${property} ${alias}`)
+      .join(", ");
+  };
+
+  // Append aggregation parameters to URL
+  if (aggregations.groupby) url += `groupby=${aggregations.groupby.join(",")}&`;
+  if (aggregations.count) url += `count=${aggregations.count}&`;
+  if (aggregations.avg)
+    url += `avg=${formatAggregationParams(aggregations.avg)}&`;
+  if (aggregations.min)
+    url += `min=${formatAggregationParams(aggregations.min)}&`;
+  if (aggregations.max)
+    url += `max=${formatAggregationParams(aggregations.max)}&`;
+  if (aggregations.sum)
+    url += `sum=${formatAggregationParams(aggregations.sum)}&`;
+  if (aggregations.unwind) url += `unwind=${aggregations.unwind.join(",")}&`;
+
+  // Append options to the URL
+  if (options.orderby) url += `orderby=${options.orderby}&`;
+  if (options.limit !== undefined) url += `limit=${options.limit}&`;
+  if (options.offset !== undefined) url += `offset=${options.offset}&`;
+
+  // Remove trailing "&" or "?" from the URL
+  url = url.replace(/[&?]$/, "");
+
+  return domo
+    .post(url, query)
+    .then((response) => {
+      console.log("Query successful:", response);
+      return response;
+    })
+    .catch((error) => {
+      console.error("Error querying documents with aggregations:", error);
+      throw error;
+    });
+};
+
+const DeleteDocument = (collectionName, documentId) => {
+  return domo
+    .delete(`${BASE_URL}/collections/${collectionName}/documents/${documentId}`)
+    .then((response) => response.data)
+    .catch((error) => {
+      console.error("Error deleting document:", error);
+      throw error;
+    });
+};
+
+const QueryDocument = (collectionName, query = {}, options = {}) => {
+  // Base URL for querying documents
+  let url = `${BASE_URL}/collections/${collectionName}/documents/query?`;
+
+  // Append optional parameters to the URL
+  if (options.limit !== undefined) url += `limit=${options.limit}&`;
+  if (options.offset !== undefined) url += `offset=${options.offset}&`;
+  if (options.orderby) url += `orderby=${options.orderby}&`;
+
+  // Remove trailing "&" or "?" from the URL
+  url = url.replace(/[&?]$/, "");
+
+  return domo
+    .post(url, query)
+    .then((response) => {
+      // console.log("Query successful:", response);
+      return response;
+    })
+    .catch((error) => {
+      console.error("Error querying documents:", error);
+      throw error;
+    });
+};
+
+// Query documents based on a specific date range
+const queryDocumentsByDate = (collectionName, dateString, options = {}) => {
+  const query = {
+    "createdOn": {
+      "$lte": { "$date": dateString }
+    }
+  };
+  return QueryDocument(collectionName, query, options);
+};
+
+const BulkDeleteDocuments = (collectionName, ids) => {
+  return domo
+    .delete(
+      `${BASE_URL}/collections/${collectionName}/documents/bulk?ids=${ids}`
+    )
+    .then((response) => response)
+    .catch((error) => {
+      console.error("Error bulk deleting documents:", error);
+      throw error;
+    });
+};
+
+const UploadFile = (file, name, description = "", isPublic = false) => {
+  const formData = new FormData();
+  formData.append("file", file);
+  const url = `/domo/data-files/v1?name=
+             ${name}&description=${description}&public=${isPublic}`;
+  const options = { contentType: "multipart" };
+  return domo
+    .post(url, formData, options)
+    .then((response) => response)
+    .catch((err) => {
+      console.log(err);
+      throw err;
+    });
+};
+
+const UploadRevision = (file, fileId) => {
+  const formData = new FormData();
+  formData.append("file", file);
+  const url = `/domo/data-files/v1/${fileId}`;
+  const options = { contentType: "multipart" };
+  return domo
+    .put(url, formData, options)
+    .then((response) => response)
+    .catch((err) => {
+      console.log(err);
+      throw err;
+    });
+};
+
+// const DownloadFile = (fileId, filename, revisionId) => {
+//   const options = { responseType: "blob" };
+//   const url = `/domo/data-files/v1/${fileId}${
+//     revisionId ? `/revisions/${revisionId}` : ""
+//   }`;
+//   return domo
+//     .get(url, options)
+//     .then((data) => {
+//       Download(data, filename);
+//     })
+//     .then((response) => response)
+//     .catch((err) => {
+//       console.log(err);
+//       throw err;
+//     });
+// };
+
+const GetFile = (fileId, revisionId) => {
+  const options = { responseType: "blob" };
+  const url = `/domo/data-files/v1/${fileId}${
+    revisionId ? `/revisions/${revisionId}` : ""
+  }`;
+  return domo
+    .get(url, options)
+    .then((data) => data)
+    .catch((err) => {
+      console.log(err);
+      throw err;
+    });
+};
+
+const ListAllUsers = async (
+  includeDetails = false,
+  limit = 100,
+  offset = 0
+) => {
+  try {
+    const response = await domo.get(
+      `/domo/users/v1?includeDetails=${includeDetails}&limit=${limit}&offset=${offset}`
+    );
+    return response;
+  } catch (error) {
+    console.error("Error listing users:", error);
+    throw error;
+  }
+};
+
+const partialupdateDocument = (collectionName, query, operation) => {
+  const requestBody = {
+    query: query,
+    operation: operation,
+  };
+
+  console.log("Request body:", requestBody);
+
+  return domo
+    .put(
+      `${BASE_URL}/collections/${collectionName}/documents/update`,
+      requestBody
+    )
+    .then((response) => {
+      console.log("Document updated successfully:", response);
+      return response;
+    })
+    .catch((error) => {
+      console.error("Error updating document:", error);
+      throw error;
+    });
+};
+
+const DomoApi = {
+  GetCurrentUser,
+  GetAllUser,
+  GetUser,
+  CreateDocument,
+  ListDocuments,
+  DeleteDocument,
+  BulkDeleteDocuments,
+  GetDocument,
+  UpdateDocument,
+  QueryDocument,
+  queryDocumentsByDate,
+  UploadFile,
+  UploadRevision,
+  // DownloadFile,
+  GetFile,
+  queryDocumentsWithAggregations,
+  ListAllUsers,
+  partialupdateDocument,
+};
+
+export default DomoApi;

package/templates/react-js/src/App.jsx

@@ -0,0 +1,7 @@
+import DefaultPage from "./pages/index";
+
+function App() {
+  return <DefaultPage />;
+}
+
+export default App;

package/templates/react-js/src/index.css

@@ -0,0 +1 @@
+@import "tailwindcss";

package/templates/react-js/src/pages/index.css

@@ -0,0 +1,96 @@
+/* Landing Page Background */
+.landing-page {
+  background: linear-gradient(135deg, #0f0f23 0%, #1a1a2e 50%, #16213e 100%);
+}
+
+/* Logo Icon Base Styles */
+.logo-icon {
+  height: 4rem;
+  width: 4rem;
+  padding: 0.5rem;
+  will-change: filter, transform;
+  transition: filter 300ms, transform 300ms;
+}
+
+/* Logo Hover Effects with Glow */
+.logo-vite:hover {
+  filter: drop-shadow(0 0 2em rgba(189, 52, 254, 0.667));
+}
+
+.logo-react:hover {
+  filter: drop-shadow(0 0 2em rgba(97, 218, 251, 0.667));
+}
+
+.logo-domo:hover {
+  filter: drop-shadow(0 0 2em rgba(0, 181, 226, 0.667));
+}
+
+.logo-tailwind:hover {
+  filter: drop-shadow(0 0 2em rgba(6, 182, 212, 0.667));
+}
+
+.logo-shadcn {
+  color: #27272a;
+}
+
+.logo-shadcn:hover {
+  filter: drop-shadow(0 0 2em rgba(161, 161, 170, 0.667));
+}
+
+/* React Logo Spin Animation */
+@keyframes logo-spin {
+  from {
+    transform: rotate(0deg);
+  }
+  to {
+    transform: rotate(360deg);
+  }
+}
+
+@media (prefers-reduced-motion: no-preference) {
+  .logo-react {
+    animation: logo-spin infinite 20s linear;
+  }
+}
+
+/* Gradient Text Animation */
+.gradient-text {
+  background: linear-gradient(
+    135deg,
+    #bd34fe 0%,
+    #41d1ff 25%,
+    #0072bc 50%,
+    #06b6d4 75%,
+    #a1a1aa 100%
+  );
+  background-size: 200% auto;
+  background-clip: text;
+  -webkit-background-clip: text;
+  -webkit-text-fill-color: transparent;
+  animation: gradient-shift 5s ease infinite;
+}
+
+@keyframes gradient-shift {
+  0%,
+  100% {
+    background-position: 0% 50%;
+  }
+  50% {
+    background-position: 100% 50%;
+  }
+}
+
+/* Responsive Logo Sizes */
+@media (max-width: 768px) {
+  .logo-icon {
+    height: 3rem;
+    width: 3rem;
+  }
+}
+
+@media (max-width: 480px) {
+  .logo-icon {
+    height: 2.5rem;
+    width: 2.5rem;
+  }
+}