{
+ const location = useLocation();
+ const navigate = useNavigate();
+ const dispatch = useDispatch();
+ const [isModal, setIsModal] = useState(false);
+ const [message, setMessage] = useState("Verifying SSO...");
+ const [isLoader, setIsLoader] = useState(false);
+ const [userDetails, setUserDetails] = useState({
+ name: "",
+ email: "",
+ phone: "",
+ Destination: "",
+ Company: ""
+ });
+
+ useEffect(() => {
+ linkUserWithSSO();
+ // eslint-disable-next-line
+ }, []);
+
+ // `linkUserWithSSO` is used to sign in or sign up a user using an SSO code and check if the user is present in the extended class
+ const linkUserWithSSO = async () => {
+ const param = new URLSearchParams(location.search);
+ const code = param?.get("code");
+ const state = param?.get("state");
+ try {
+ // The `ssosign` cloud function is used to sign in or sign up a user
+ const ssosign = await Parse.Cloud.run("ssosign", {
+ code: code,
+ email: state
+ });
+ localStorage.setItem("accesstoken", ssosign.sessiontoken);
+ // `checkExtUser` checks if the user is present in the extended class `contracts_Users` and if not, initiates the new user flow
+ await checkExtUser(ssosign);
+ } catch (err) {
+ setMessage("Error: " + err.message);
+ console.log("err", err.message);
+ }
+ };
+ const checkExtUser = async (ssosign) => {
+ const params = { email: ssosign?.email };
+ try {
+ // `isextenduser` checks if the current user is present in the extended class
+ const extRes = await Parse.Cloud.run("isextenduser", params);
+ if (extRes?.isUserExist) {
+ // `getUserDetails` retrieves the current user's details from the extended class
+ const extRes = await Parse.Cloud.run("getUserDetails", params);
+ if (ssosign && ssosign.sessiontoken) {
+ const LocalUserDetails = {
+ name: extRes.Name,
+ email: extRes.email,
+ phone: extRes?.get("Phone") || "",
+ company: extRes.get("Company")
+ };
+ localStorage.setItem("userDetails", JSON.stringify(LocalUserDetails));
+ thirdpartyLoginfn(ssosign.sessiontoken);
+ }
+ } else {
+ setIsModal(true);
+ setUserDetails((prev) => ({
+ ...prev,
+ name: ssosign.name,
+ email: ssosign.email,
+ phone: ssosign?.phone || ""
+ }));
+ }
+ } catch (err) {
+ console.log("Err in isextenduser or getuserdetails cloud function", err);
+ setMessage("Error: " + err.message);
+ }
+ };
+ // `handleSubmitbtn` is used to create a user in the extended class
+ const handleSubmitbtn = async (e) => {
+ e.preventDefault();
+ setIsLoader(true);
+ let phone;
+ if (userDetails?.phone) {
+ phone = validateInput(userDetails?.phone);
+ } else {
+ phone = true;
+ }
+ if (userDetails.Destination && userDetails.Company && phone) {
+ const payload = { sessionToken: localStorage.getItem("accesstoken") };
+ if (payload && payload.sessionToken) {
+ const params = {
+ userDetails: {
+ name: userDetails.name,
+ email: userDetails.email,
+ phone: userDetails?.phone || "",
+ role: "contracts_User",
+ company: userDetails.Company,
+ jobTitle: userDetails.Destination
+ }
+ };
+ try {
+ const userSignUp = await Parse.Cloud.run("usersignup", params);
+ if (userSignUp && userSignUp.sessionToken) {
+ const LocalUserDetails = params.userDetails;
+ localStorage.setItem(
+ "userDetails",
+ JSON.stringify(LocalUserDetails)
+ );
+ await thirdpartyLoginfn(userSignUp.sessionToken);
+ setIsLoader(false);
+ } else {
+ alert(userSignUp.message);
+ setIsLoader(false);
+ }
+ } catch (err) {
+ console.log("error in usersignup", err);
+ localStorage.removeItem("accesstoken");
+ alert("Something went wrong.");
+ setIsLoader(false);
+ }
+ } else {
+ localStorage.removeItem("accesstoken");
+ alert("Internal server error.");
+ setIsLoader(false);
+ }
+ } else {
+ alert("Please fill required details correctly.");
+ setIsLoader(false);
+ }
+ };
+ // `thirdpartyLoginfn` is used to save necessary parameters locally for the logged-in user
+ const thirdpartyLoginfn = async (sessionToken) => {
+ const baseUrl = localStorage.getItem("baseUrl");
+ const parseAppId = localStorage.getItem("parseAppId");
+ try {
+ const validUser = await Parse.User.become(sessionToken);
+ if (validUser) {
+ localStorage.setItem("accesstoken", sessionToken);
+ const _user = JSON.parse(JSON.stringify(validUser));
+ localStorage.setItem("UserInformation", JSON.stringify(_user));
+ if (_user.ProfilePic) {
+ localStorage.setItem("profileImg", _user.ProfilePic);
+ } else {
+ localStorage.setItem("profileImg", "");
+ }
+ // Check extended class user role and tenentId
+ try {
+ let userRoles = [];
+ const userSettings = appInfo.settings;
+ //Get Current user roles
+ const url = `${baseUrl}functions/UserGroups`;
+ const headers = {
+ "Content-Type": "application/json",
+ "X-Parse-Application-Id": parseAppId,
+ sessionToken: _user.sessionToken
+ };
+ const body = { appname: appInfo.appname };
+ const UserGroupsRes = await axios.post(url, JSON.stringify(body), {
+ headers: headers
+ });
+ userRoles = (UserGroupsRes.data && UserGroupsRes.data.result) || [];
+ if (userRoles) {
+ let _currentRole = "";
+ const excludeRoles = ["contracts_Guest", `contracts_appeditor`];
+ const filteredRole = userRoles.filter(
+ (x) => !excludeRoles.includes(x)
+ );
+ if (filteredRole?.length > 1) {
+ console.log("user has two roles");
+ // _currentRole = filteredRole.filter((x) => x === "contracts_User");
+ } else {
+ _currentRole = filteredRole?.[0] || "";
+ }
+ if (_currentRole) {
+ const roleSetting = userSettings?.find(
+ (setting) => setting.role === _currentRole
+ );
+ const redirectUrl =
+ location?.state?.from ||
+ `/${roleSetting.pageType}/${roleSetting.pageId}`;
+ const _role = _currentRole.replace(`${appInfo.appname}_`, "");
+ localStorage.setItem("_user_role", _role);
+ // Get TenentID from Extendend Class
+ localStorage.setItem(
+ "extended_class",
+ roleSetting.extended_class
+ );
+ try {
+ const extUser = await Parse.Cloud.run("getUserDetails", {
+ email: _user.email
+ });
+ if (extUser) {
+ const _extUser = JSON.parse(JSON.stringify(extUser));
+ localStorage.setItem("userEmail", _extUser.Email);
+ localStorage.setItem("username", _extUser.Name);
+ localStorage.setItem("scriptId", true);
+ let tenentInfo = [];
+ const results = [extUser];
+ if (results) {
+ let extendedInfo_stringify = JSON.stringify(results);
+ localStorage.setItem(
+ "Extand_Class",
+ extendedInfo_stringify
+ );
+ if (_extUser.TenantId) {
+ const obj = {
+ tenentId: _extUser.TenantId.objectId,
+ tenentName: _extUser.TenantId.TenantName || ""
+ };
+ localStorage.setItem("TenantId", obj.tenentId);
+ tenentInfo.push(obj);
+ dispatch(showTenant(obj.tenentName || ""));
+ localStorage.setItem("TenantName", obj.tenentName || "");
+ }
+ localStorage.setItem("PageLanding", roleSetting.pageId);
+ localStorage.setItem("defaultmenuid", roleSetting.menuId);
+ localStorage.setItem("pageType", roleSetting.pageType);
+ if (isEnableSubscription) {
+ const res = await fetchSubscription();
+ const plan = res.plan;
+ const billingDate = res.billingDate;
+ if (plan === "freeplan") {
+ navigate(redirectUrl);
+ } else if (billingDate) {
+ if (new Date(billingDate) > new Date()) {
+ localStorage.removeItem("userDetails");
+ navigate(redirectUrl);
+ } else {
+ navigate(`/subscription`, {
+ replace: true
+ });
+ }
+ } else {
+ navigate(`/subscription`, {
+ replace: true
+ });
+ }
+ } else {
+ navigate(redirectUrl);
+ }
+ }
+ }
+ } catch (err) {
+ alert("user not exist.");
+ setMessage("Error: User not exist.");
+ console.log("err in get extUser", err);
+ }
+ } else {
+ alert("Role does not exists.");
+ setMessage("Error: Role does not exists.");
+ }
+ } else {
+ alert("Role does not exists.");
+ setMessage("Error: Role does not exists.");
+ }
+ } catch (err) {
+ console.log("err in usergroups", err);
+ }
+ }
+ } catch (err) {
+ console.log("Err in become method", err);
+ }
+ };
+ // `handleCloseModal` is triggered when the user wants to close the new user flow modal
+ const handleCloseModal = () => {
+ setIsModal(false);
+ if (Parse?.User?.current()) {
+ Parse.User.logOut();
+ }
+ };
+
+ // `validateInput` is used to verify the phone pattern
+ function validateInput(input) {
+ if (input) {
+ const pattern = /^(?!.*\+.*\+)[\d+-]*$/;
+ return pattern.test(input);
+ } else {
+ return true;
+ }
+ }
+ return (
+
+
+ {message === "Verifying SSO..." && (
+
+ )}
+
{message}
+
+
+
+ {isLoader && (
+
+ )}
+
+
+
+ );
+};
+
+export default SSOVerify;
diff --git a/apps/OpenSignServer/auth/authadapter.js b/apps/OpenSignServer/auth/authadapter.js
new file mode 100644
index 000000000..1e12c7836
--- /dev/null
+++ b/apps/OpenSignServer/auth/authadapter.js
@@ -0,0 +1,28 @@
+import axios from 'axios';
+import dotenv from 'dotenv';
+dotenv.config();
+const ssoApiUrl = process.env.SSO_API_URL || 'https://sso.opensignlabs.com/api'; //'https://osl-jacksonv2.vercel.app/api';
+export const SSOAuth = {
+ // Returns a promise that fulfills if this user mail is valid.
+ validateAuthData: async authData => {
+ try {
+ const response = await axios.get(ssoApiUrl + '/oauth/userinfo', {
+ headers: {
+ Authorization: `Bearer ${authData.access_token}`,
+ },
+ });
+ if (response.data && response.data.id && response.data.email === authData.id) {
+ return;
+ }
+ throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'SSO auth is invalid for this user.');
+ } catch (error) {
+ console.log('error in sso adapter', error?.response);
+ throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'SSO auth is invalid for this user.');
+ }
+ },
+
+ // Returns a promise that fulfills if this app id is valid.
+ validateAppId: () => {
+ return Promise.resolve();
+ },
+};
diff --git a/apps/OpenSignServer/cloud/main.js b/apps/OpenSignServer/cloud/main.js
index 6de2c181a..59a903b1b 100644
--- a/apps/OpenSignServer/cloud/main.js
+++ b/apps/OpenSignServer/cloud/main.js
@@ -42,6 +42,8 @@ import linkContactToDoc from './parsefunction/linkContactToDoc.js';
import CreatePublicTemplate from './parsefunction/CreatePublicTemplate.js';
import GetPublicUserName from './parsefunction/GetPublicUserName.js';
import GetPublicTemplate from './parsefunction/GetPublicTemplate.js';
+import ssoSignin from './parsefunction/ssoSignin.js';
+import isextenduser from './parsefunction/isextenduser.js';
// This afterSave function triggers after an object is added or updated in the specified class, allowing for post-processing logic.
Parse.Cloud.afterSave('contracts_Document', DocumentAftersave);
@@ -94,3 +96,5 @@ Parse.Cloud.define('linkcontacttodoc', linkContactToDoc);
Parse.Cloud.define('createpublictemplate', CreatePublicTemplate);
Parse.Cloud.define('getpublicusername', GetPublicUserName);
Parse.Cloud.define('getpublictemplate', GetPublicTemplate);
+Parse.Cloud.define('ssosign', ssoSignin);
+Parse.Cloud.define('isextenduser', isextenduser);
diff --git a/apps/OpenSignServer/cloud/parsefunction/SendMailOTPv1.js b/apps/OpenSignServer/cloud/parsefunction/SendMailOTPv1.js
index 290ff0c3a..52054688b 100644
--- a/apps/OpenSignServer/cloud/parsefunction/SendMailOTPv1.js
+++ b/apps/OpenSignServer/cloud/parsefunction/SendMailOTPv1.js
@@ -39,7 +39,7 @@ async function sendMailOTPv1(request) {
code +
'