@icvdeveloper/common-module 0.0.1

package/dist/runtime/composables/useConferenceHelpers.mjs

@@ -0,0 +1,270 @@
+import { format } from "date-fns";
+import { get, find } from "lodash";
+import { storeToRefs } from "pinia";
+import { ConferenceState } from "../models/conference.mjs";
+import { useDateFormat } from "./useDateFormat.mjs";
+const getConferenceConfigMainValue = (_conference, _name) => {
+  const configPages = get(_conference, "template_config.config.pages", []);
+  const mainPageContent = get(
+    find(configPages, { name: "main" }),
+    "content",
+    []
+  );
+  const configObj = find(mainPageContent, { name: _name });
+  return configObj ? configObj.value : null;
+};
+export const useConferenceHelpers = (conferences) => {
+  const { pagesConfigValue, globalConfigValue } = toRefs(
+    useTemplateConfigsStore()
+  );
+  const { formatTimezoneToLocal } = useDateFormat();
+  const route = useRoute();
+  const { isLoggedIn } = storeToRefs(useAuthStore());
+  const { currentConference } = storeToRefs(useConferencesStore());
+  const _selectedConference = ref(null);
+  if (!Array.isArray(conferences.value)) {
+    _selectedConference.value = conferences.value;
+  }
+  const _setSelectedConference = (conference) => {
+    if (!Array.isArray(conferences.value)) {
+      throw new TypeError(
+        "parameter conferences supplied useConferenceHelpers should be of type Array"
+      );
+    }
+    if (_selectedConference.value && _selectedConference.value.id !== conference.id) {
+      _selectedConference.value = find(conferences.value, {
+        id: conference.id
+      });
+    }
+    if (_selectedConference.value === void 0) {
+      throw new Error("could not find conference in arrray");
+    }
+  };
+  const isSingleDayEvent = (conference) => {
+    if (conference) {
+      _setSelectedConference(conference);
+    }
+    const firstDay = new Date(_selectedConference.value.start_date).getMonth() + "/" + new Date(_selectedConference.value.start_date).getDate();
+    const lastDay = new Date(_selectedConference.value.end_date).getMonth() + "/" + 3;
+    new Date(_selectedConference.value.end_date).getDate();
+    return firstDay === lastDay;
+  };
+  const showConferenceWebcastButton = (conference) => {
+    if (conference) {
+      _setSelectedConference(conference);
+    }
+    return _selectedConference.value.access && _selectedConference.value.state !== "archive" && _selectedConference.value.state !== "hidden";
+  };
+  const getConferenceWebcastUrl = (conference) => {
+    if (conference) {
+      _setSelectedConference(conference);
+    }
+    if (_selectedConference.value.state === "upcoming") {
+      return "/stream-test";
+    }
+    const channel = get(
+      _selectedConference.value,
+      "days[0].tracks[0].channel",
+      1
+    );
+    return _selectedConference.value.agenda_enabled ? `/agenda/${_selectedConference.value.id}` : `/upcoming-events/${_selectedConference.value.id}/webcast/${channel}`;
+  };
+  const getConferenceWebcastButtonText = (conference) => {
+    if (conference) {
+      _setSelectedConference(conference);
+    }
+    if (_selectedConference.value.state === "upcoming") {
+      return "View Test Stream";
+    }
+    const viewNowAliasText = globalConfigValue.value("view_now_button_alias");
+    return viewNowAliasText || "View Now";
+  };
+  const getConferenceDisplayDate = (conference) => {
+    if (conference) {
+      _setSelectedConference(conference);
+    }
+    const startDate = new Date(_selectedConference.value.start_date);
+    const endDate = new Date(_selectedConference.value.end_date);
+    const tzFormat = pagesConfigValue.value("main.use_event_text_tz") ? " zzz" : "";
+    if (isSingleDayEvent()) {
+      const startFormat2 = "MMMM do, yyyy h:mm" + tzFormat;
+      return formatTimezoneToLocal(
+        startDate,
+        startFormat2,
+        _selectedConference.value.timezone
+      );
+    }
+    let startFormat = "MMMM d";
+    if (format(startDate, "yyyy") !== format(endDate, "yyyy")) {
+      startFormat += ", yyyy";
+    }
+    let returnDate = formatTimezoneToLocal(
+      startDate,
+      startFormat,
+      _selectedConference.value.timezone
+    );
+    returnDate += " - ";
+    let endFormat = "d, yyyy" + tzFormat;
+    if (format(startDate, "MMMM") !== format(endDate, "MMMM") || format(startDate, "yyyy") !== format(endDate, "yyyy")) {
+      endFormat = "MMMM " + endFormat;
+    }
+    returnDate += formatTimezoneToLocal(
+      endDate,
+      endFormat,
+      _selectedConference.value.timezone
+    );
+    return returnDate;
+  };
+  const showViewArchiveButton = (conference) => {
+    if (conference) {
+      _setSelectedConference(conference);
+    }
+    if (_selectedConference.value.state !== "archive")
+      return false;
+    if (route.name === "index") {
+      return isLoggedIn && _selectedConference.value.access;
+    } else {
+      return _selectedConference.value.access || _selectedConference.value.agenda_enabled || pagesConfigValue.value("archive_player.preview_enabled", false);
+    }
+  };
+  const getViewArchiveUrl = (conference) => {
+    if (conference) {
+      _setSelectedConference(conference);
+    }
+    if (_selectedConference.value.agenda_enabled) {
+      return `/agenda/${_selectedConference.value.id}`;
+    } else {
+      const presentationId = get(
+        _selectedConference.value,
+        "days[0].tracks[0].presentations[0].id",
+        null
+      );
+      return `/archive/${presentationId}`;
+    }
+  };
+  const getViewArchiveButtonText = (conference) => {
+    if (conference) {
+      _setSelectedConference(conference);
+    }
+    const viewArchiveAliasText = globalConfigValue.value(
+      "view_archive_button_alias",
+      ""
+    );
+    const viewPreviewAliasText = globalConfigValue.value(
+      "view_preview_button_alias",
+      ""
+    );
+    if (!_selectedConference.value.access && pagesConfigValue.value("archive_player.preview_enabled", false)) {
+      if (viewPreviewAliasText.length) {
+        return viewPreviewAliasText;
+      } else {
+        return "Preview";
+      }
+    } else if (viewArchiveAliasText.length) {
+      return viewArchiveAliasText;
+    } else {
+      return "View Archive";
+    }
+  };
+  const showConferenceRegButton = (conference) => {
+    if (conference) {
+      _setSelectedConference(conference);
+    }
+    if (_selectedConference.value.access || globalConfigValue.value("townhall_registration_enabled", false)) {
+      return false;
+    } else {
+      const confSetting = getConferenceConfigMainValue(
+        _selectedConference.value,
+        "conference_reg_button_enabled"
+      );
+      if (confSetting != null) {
+        return confSetting === true;
+      } else {
+        return globalConfigValue.value("reg_button_enabled") === true;
+      }
+    }
+  };
+  const getConferenceRegUrl = (conference) => {
+    if (conference) {
+      _setSelectedConference(conference);
+    }
+    if (globalConfigValue.value("townhall_registration_enabled", false)) {
+      if (_selectedConference.value.id === currentConference.value.id) {
+        return "/";
+      } else if (_selectedConference.value.state === "live" || _selectedConference.value.state === "mixed") {
+        return `/upcoming-events/${_selectedConference.value.id}`;
+      } else {
+        return `/past-events/${_selectedConference.value.id}`;
+      }
+    }
+    const confExternalUrl = getConferenceConfigMainValue(
+      _selectedConference.value,
+      "conference_external_reg_url"
+    );
+    if (confExternalUrl)
+      return confExternalUrl;
+    const portalExternalUrl = globalConfigValue.value("external_reg_url");
+    if (portalExternalUrl)
+      return portalExternalUrl;
+    return `/registration/options/${_selectedConference.value.id}`;
+  };
+  const getConferenceRegText = (conference) => {
+    if (conference) {
+      _setSelectedConference(conference);
+    }
+    const confSetting = getConferenceConfigMainValue(
+      _selectedConference.value,
+      "conference_reg_button_alias"
+    );
+    if (confSetting != null && confSetting !== "") {
+      return confSetting;
+    } else {
+      const portalSetting = globalConfigValue.value("reg_button_alias");
+      if (portalSetting != null && portalSetting !== "") {
+        return portalSetting;
+      }
+    }
+    return "Register";
+  };
+  const showConferenceViewButton = (conference) => {
+    if (conference) {
+      _setSelectedConference(conference);
+    }
+    return isLoggedIn && conference.access;
+  };
+  const conferenceIsLive = (conference) => {
+    if (conference) {
+      _setSelectedConference(conference);
+    }
+    return _selectedConference.value.state === ConferenceState.LIVE || _selectedConference.value.state === ConferenceState.MIXED;
+  };
+  const conferenceIsMixed = (conference) => {
+    if (conference) {
+      _setSelectedConference(conference);
+    }
+    return _selectedConference.value.state === ConferenceState.MIXED;
+  };
+  const conferenceIsArchived = (conference) => {
+    if (conference) {
+      _setSelectedConference(conference);
+    }
+    return _selectedConference.value.state === ConferenceState.ARCHIVED;
+  };
+  return {
+    isSingleDayEvent,
+    showConferenceWebcastButton,
+    getConferenceWebcastButtonText,
+    getConferenceWebcastUrl,
+    getConferenceDisplayDate,
+    showViewArchiveButton,
+    getViewArchiveUrl,
+    getViewArchiveButtonText,
+    showConferenceRegButton,
+    getConferenceRegUrl,
+    getConferenceRegText,
+    showConferenceViewButton,
+    conferenceIsLive,
+    conferenceIsMixed,
+    conferenceIsArchived
+  };
+};

package/dist/runtime/composables/useDateFormat.d.ts

@@ -0,0 +1,12 @@
+export declare type DateFunctions = {
+    /**
+     * Takes a date string and converts it to a formatted date
+     * e.g August 8, 2022
+     */
+    formatDate: (date: string) => string;
+    /**
+     * Takes a date string with its timezone and converts it to the users local time.
+     */
+    formatTimezoneToLocal: (date: string | Date, format: string, timezone: string) => string;
+};
+export declare const useDateFormat: () => DateFunctions;

package/dist/runtime/composables/useDateFormat.mjs

@@ -0,0 +1,21 @@
+import { format as formatTz } from "date-fns-tz";
+import { format } from "date-fns";
+export const useDateFormat = () => {
+  const formatDate = (date) => {
+    return format(new Date(date), "MMMM do, Y");
+  };
+  const formatTimezoneToLocal = (date, format2, timezone) => {
+    return formatTz(
+      new Date(
+        formatTz(date, "yyyy-MM-dd HH:mm z", {
+          timeZone: timezone
+        })
+      ),
+      format2
+    );
+  };
+  return {
+    formatTimezoneToLocal,
+    formatDate
+  };
+};

package/dist/runtime/composables/useLogin.d.ts

@@ -0,0 +1,30 @@
+import { Ref } from "vue";
+import { Conference } from "../models/conference";
+declare type UserLogin = {
+    /**
+     * Email input
+     */
+    email: Ref<string>;
+    /**
+     * Password Input
+     */
+    password: Ref<string>;
+    /**
+     * Login has too many active sessions
+     */
+    tooManySessions: Ref<boolean>;
+    /**
+     * Login errors
+     */
+    loginError: Ref<boolean>;
+    /**
+     * Handle login.
+     */
+    handleLogin: (revoke?: boolean) => void;
+    /**
+     * Reset login
+     */
+    showReset: () => void;
+};
+export declare const useLogin: (conference: Ref<Conference>) => UserLogin;
+export {};

package/dist/runtime/composables/useLogin.mjs

@@ -0,0 +1,58 @@
+import { storeToRefs } from "pinia";
+import { defineEmits } from "vue";
+import { useConferenceHelpers } from "./useConferenceHelpers.mjs";
+export const useLogin = (conference) => {
+  const { login } = useAuthStore();
+  const { currentConference } = storeToRefs(useConferencesStore());
+  const { globalConfigValue } = storeToRefs(useTemplateConfigsStore());
+  const email = ref("");
+  const password = ref("");
+  const tooManySessions = ref(false);
+  const loginError = ref(false);
+  const emit = defineEmits(["showReset", "loggedIn"]);
+  const router = useRouter();
+  const shouldRedirect = () => {
+    let redirectUrl = null;
+    if (currentConference.value !== null) {
+      if (globalConfigValue.value("login_redirect_enabled")) {
+        const { getConferenceWebcastUrl } = useConferenceHelpers(currentConference);
+        redirectUrl = getConferenceWebcastUrl();
+      }
+    } else if (conference.value !== null) {
+      if (globalConfigValue.value("login_redirect_enabled")) {
+        const { getConferenceWebcastUrl } = useConferenceHelpers(conference);
+        redirectUrl = getConferenceWebcastUrl();
+      }
+    }
+    if (redirectUrl === null) {
+      router.push("/");
+    } else if (redirectUrl.trim().length > 0) {
+      router.push(redirectUrl);
+    }
+  };
+  const handleLogin = (revoke = false) => {
+    login({ email: email.value, password: password.value, revoke }).then(() => {
+      emit("loggedIn");
+      shouldRedirect();
+    }).catch((error) => {
+      if (error.response.status === 423) {
+        tooManySessions.value = true;
+      } else {
+        loginError.value = true;
+      }
+    });
+  };
+  const showReset = () => {
+    email.value = "";
+    password.value = "";
+    emit("showReset");
+  };
+  return {
+    email,
+    password,
+    tooManySessions,
+    handleLogin,
+    loginError,
+    showReset
+  };
+};

package/dist/runtime/composables/usePresentation.d.ts

@@ -0,0 +1,53 @@
+import { Ref } from "nuxt/dist/app/compat/capi";
+import { Conference, Presentation, Track } from "../models/conference";
+export declare type UsePresentationMethods = {
+    /**
+     * show session time
+     */
+    showPresentationTimes: (presentation: Presentation) => boolean;
+    /**
+     * show presentation end times
+     */
+    showPresentationEndTimes: () => boolean;
+    /**
+     * get presentation end time
+     */
+    getPresentationEndTime: (presentation: Presentation) => string;
+    /**
+     * get presentation link target
+     */
+    getPresentationLinkTarget: (presentation: Presentation) => string;
+    /**
+     * get Archive presentation link destination
+     */
+    getArchivePresentationLinkDestination: (presentation: Presentation) => string;
+    /**
+     * get presentation link destination
+     */
+    getLivePresentationLinkDestination: (presentation: Presentation, track: Track) => string;
+    /**
+     * show presentation description icon
+     */
+    showPresentationLinkIcon: () => boolean;
+    /**
+     * get presentation description link text
+     */
+    getPresentationLinkText: () => string;
+    /**
+     * show presentation Play icon
+     */
+    showPresentationPlayIcon: (presentation: Presentation) => boolean;
+    /**
+     * presentation has custom play icon
+     */
+    getPresentationCustomPlayIcon: (presentation: Presentation) => boolean | string;
+    /**
+     * Get presentation streaming text
+     */
+    getPresentationStreamingText: (presentation: Presentation) => string;
+    /**
+     * Presentation is live or mixed
+     */
+    presentationIsLiveOrMixed: (presentation: Presentation) => boolean;
+};
+export declare const usePresentation: (conference: Ref<Conference>) => UsePresentationMethods;

package/dist/runtime/composables/usePresentation.mjs

@@ -0,0 +1,98 @@
+import { addSeconds } from "date-fns";
+import {
+  ConferenceState
+} from "../models/conference";
+import { useDateFormat } from "./useDateFormat.mjs";
+import { useConferenceHelpers } from "./useConferenceHelpers.mjs";
+export const usePresentation = (conference) => {
+  const { formatTimezoneToLocal } = useDateFormat();
+  const { pagesConfigValue } = useTemplateConfigsStore();
+  const { conferenceIsMixed, getConferenceRegUrl } = useConferenceHelpers(conference);
+  const showPresentationTimes = (presentation) => {
+    return pagesConfigValue("agenda.session_times", true) && presentation.date_visible;
+  };
+  const showPresentationEndTimes = () => {
+    return pagesConfigValue("agenda.session_end_times", false);
+  };
+  const getPresentationEndTime = (presentation) => {
+    return formatTimezoneToLocal(
+      addSeconds(new Date(presentation.date), presentation.duration),
+      "h:m a",
+      conference.value.timezone
+    );
+  };
+  const getPresentationLinkTarget = (presentation) => {
+    return presentation.type === "link" ? "_blank" : "";
+  };
+  const getArchivePresentationLinkDestination = (presentation) => {
+    if (!conference.value.access && (!pagesConfigValue("archive_player.preview_enabled", false) || presentation.type === "link")) {
+      return getConferenceRegUrl();
+    } else if (presentation.type === "link") {
+      return presentation.video_url;
+    }
+    return `/archive/${presentation.id}`;
+  };
+  const getLivePresentationLinkDestination = (presentation, track) => {
+    if (conference.value.access) {
+      if (presentation.type === "link") {
+        return presentation.video_url;
+      }
+      if ((presentation.video_url || presentation.type === "embed") && conferenceIsMixed) {
+        return getArchivePresentationLinkDestination(presentation);
+      }
+      return `/upcoming-events/${conference.value.id}/webcast/${track.channel}`;
+    }
+    return getConferenceRegUrl();
+  };
+  const showPresentationLinkIcon = () => {
+    return pagesConfigValue("agenda.session_desc_link") === "icon";
+  };
+  const getPresentationLinkText = () => {
+    return pagesConfigValue("agenda.session_desc_link_text", "");
+  };
+  const showPresentationPlayIcon = (presentation) => {
+    if (presentation.type === "zoom") {
+      return pagesConfigValue("agenda.use_zoom_icon");
+    } else {
+      return pagesConfigValue("agenda.use_play_icon");
+    }
+  };
+  const getPresentationCustomPlayIcon = (presentation) => {
+    if (presentation.is_live) {
+      return pagesConfigValue("agenda.live_play_icon", false);
+    }
+    if (conference.value.state === ConferenceState.MIXED && (presentation.video_url || presentation.type === "embed")) {
+      return pagesConfigValue("agenda.pre_recorded_play_icon", false);
+    }
+    return false;
+  };
+  const getPresentationStreamingText = (presentation) => {
+    if (presentation.type === "zoom") {
+      return pagesConfigValue("agenda.zoom_text");
+    }
+    if (presentation.is_live) {
+      return pagesConfigValue("agenda.live_stream_text");
+    }
+    if (conference.value.state === ConferenceState.MIXED && (presentation.video_url || presentation.type === "embed")) {
+      return pagesConfigValue("agenda.pre_recorded_text");
+    }
+    return "";
+  };
+  const presentationIsLiveOrMixed = (presentation) => {
+    return presentation.is_live || conference.value.state === ConferenceState.MIXED && (presentation.video_url.length > 0 || presentation.type === "embed");
+  };
+  return {
+    showPresentationTimes,
+    showPresentationEndTimes,
+    getPresentationEndTime,
+    getPresentationLinkTarget,
+    getArchivePresentationLinkDestination,
+    getLivePresentationLinkDestination,
+    showPresentationLinkIcon,
+    getPresentationLinkText,
+    showPresentationPlayIcon,
+    getPresentationCustomPlayIcon,
+    getPresentationStreamingText,
+    presentationIsLiveOrMixed
+  };
+};

package/dist/runtime/composables/usePresenter.d.ts

@@ -0,0 +1,15 @@
+import { ComputedRef, Ref } from "nuxt/dist/app/compat/capi";
+import { Presenter } from "../models/conference";
+export declare type UsePresenterMethods = {
+    fullName: ComputedRef<string>;
+    titleCompany: ComputedRef<string>;
+    imageHeight: ComputedRef<string>;
+    presenterImageStyle: ComputedRef<{
+        [key: string]: string | number;
+    }>;
+    itemWidthStyle: ComputedRef<{
+        [key: string]: string;
+    }>;
+    isGrayScale: ComputedRef<boolean>;
+};
+export declare const usePresenter: (presenter: Ref<Presenter>) => UsePresenterMethods;

package/dist/runtime/composables/usePresenter.mjs

@@ -0,0 +1,67 @@
+export const usePresenter = (presenter) => {
+  const { pagesConfigValue, globalConfigValue } = useTemplateConfigsStore();
+  const imageStyle = ref(
+    pagesConfigValue("main.presenter_all_image_style", "default")
+  );
+  const imageWidth = ref(
+    pagesConfigValue("presenters.presenter_image_width", 0)
+  );
+  const itemWidth = ref(120);
+  if (!imageWidth.value > 0) {
+    imageWidth.value = pagesConfigValue("main.presenter_all_item_width");
+  }
+  const fullName = computed(() => {
+    let name = presenter.value.first_name + " " + presenter.value.last_name;
+    if (presenter.value.designations) {
+      name += ", " + presenter.value.designations;
+    }
+    return name;
+  });
+  const titleCompany = computed(() => {
+    if (presenter.value.title && !presenter.value.company) {
+      return presenter.value.title;
+    } else if (presenter.value.title && presenter.value.company) {
+      return presenter.value.title + ", " + presenter.value.company;
+    } else if (!presenter.value.title && presenter.value.company) {
+      return presenter.value.company;
+    } else {
+      return "";
+    }
+  });
+  const imageHeight = computed(() => {
+    return ["circle", "square"].includes(imageStyle.value) ? `${itemWidth.value}px` : "auto";
+  });
+  const presenterImageStyle = computed(() => {
+    let borderRadius = "0";
+    if (imageStyle.value === "circle") {
+      borderRadius = "50%";
+    }
+    if (imageStyle.value === "rounded") {
+      borderRadius = "6%";
+    }
+    const backgroundSize = ["circle", "square"].includes(imageStyle.value) ? "cover" : "contain";
+    return {
+      width: `${itemWidth.value}px`,
+      height: imageHeight.value,
+      "border-radius": borderRadius,
+      "background-position": "center",
+      "background-size": backgroundSize,
+      "background-repeat": "no-repeat",
+      "background-image": `url('${presenter.value.photo}')`
+    };
+  });
+  const itemWidthStyle = computed(() => {
+    return { width: `${itemWidth.value}px` };
+  });
+  const isGrayScale = computed(() => {
+    return globalConfigValue("presenter_icon_color_style") === "greyscale";
+  });
+  return {
+    fullName,
+    titleCompany,
+    imageHeight,
+    presenterImageStyle,
+    itemWidthStyle,
+    isGrayScale
+  };
+};

package/dist/runtime/composables/usePresenters.d.ts

@@ -0,0 +1,13 @@
+import { Ref } from "nuxt/dist/app/compat/capi";
+import { Conference, Presenter } from "../models/conference";
+export declare type UsePresentersMethods = {
+    /**
+     * get presenters label
+     */
+    getPresentersLabel(numberOfPresenters: number): string;
+    /**
+     * sort presenters
+     */
+    getSortedPresenters(presenters: Presenter[]): Presenter[];
+};
+export declare const usePresenters: (conference: Ref<Conference>) => UsePresentersMethods;

package/dist/runtime/composables/usePresenters.mjs

@@ -0,0 +1,21 @@
+import { sortBy } from "lodash";
+export const usePresenters = (conference) => {
+  const { pagesConfigValue } = useTemplateConfigsStore();
+  const getPresentersLabel = (numberOfPresenters) => {
+    let displayName = pagesConfigValue(
+      "main.presenter_all_alias",
+      "Presenters"
+    );
+    if (numberOfPresenters === 1 && displayName.endsWith("s") === true) {
+      displayName = displayName.substr(0, displayName.length - 1);
+    }
+    return displayName;
+  };
+  const getSortedPresenters = (presenters) => {
+    return sortBy(presenters, ["role", "last_name"]);
+  };
+  return {
+    getPresentersLabel,
+    getSortedPresenters
+  };
+};

package/dist/runtime/composables/useV3plusCommonModule.d.ts

@@ -0,0 +1,2 @@
+import type { V3plusCommonPlugin } from "../v3plusCommonPlugin";
+export declare const useV3plusCommonModule: () => V3plusCommonPlugin;

package/dist/runtime/composables/useV3plusCommonModule.mjs

@@ -0,0 +1,2 @@
+import { useNuxtApp } from "#imports";
+export const useV3plusCommonModule = () => useNuxtApp().$v3plusCommonModule;

package/dist/runtime/models/affiliate.d.ts

@@ -0,0 +1 @@
+export declare type Affiliate = {};