Merge remote-tracking branch 'origin/dev' into feature/pipeline-run-dag

Author: htahir1

global.d.ts

@@ -39,6 +39,8 @@ interface TUser {
   email: string;
   organizationId: TId;
   userName: string;
+  email_opted_in: any;
+  emailOptedIn: any;
 }
 
 interface TOrganization {

src/api/endpoints.ts

@@ -1,6 +1,7 @@
 export const endpoints = {
   login: '/login',
   signup: (username: string): string => `/users/${username}/activate`,
+  userEmail: (userId: string): string => `/users/${userId}/email-opt-in`,
   forgot: '/login/email/resetpassword',
   version: '/version',
   users: {

src/api/session/saveUserEmail.ts

@@ -0,0 +1,27 @@
+import { fetchApiWithAuthRequest } from '../fetchApi';
+import { endpoints } from '../endpoints';
+import { httpMethods } from '../constants';
+import { apiUrl } from '../apiUrl';
+
+const SaveUserEmail = ({
+  userId,
+  email,
+  email_opted_in,
+  authenticationToken,
+}: {
+  userId: string,
+  email: string,
+  email_opted_in: any,
+  authenticationToken: string,
+}): Promise<TUser> =>
+  fetchApiWithAuthRequest({
+    url: apiUrl(endpoints.userEmail(userId)),
+    method: httpMethods.put,
+    authenticationToken,
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    data: { email, email_opted_in },
+  });
+
+export default SaveUserEmail;

src/redux/actionTypes/constants.ts

@@ -10,6 +10,7 @@ const userActionTypes = {
   USERS_GET_MY_USER: 'USERS_GET_MY_USER',
   USERS_GET_USER_FOR_ID: 'USERS_GET_USER_FOR_ID',
   UPDATE_USER_EMAIL: 'UPDATE_USER_EMAIL',
+  SAVE_USER_EMAIL: 'SAVE_USER_EMAIL'
 };
 
 const organizationActionTypes = {

src/redux/actionTypes/users.ts

@@ -5,4 +5,5 @@ export const userActionTypes = {
   getMyUser: generateApiActionsTypes(actionTypes.USERS_GET_MY_USER),
   getUserForId: generateApiActionsTypes(actionTypes.USERS_GET_USER_FOR_ID),
   updateUserEmail: generateApiActionsTypes(actionTypes.UPDATE_USER_EMAIL),
+  saveUserEmail: generateApiActionsTypes(actionTypes.SAVE_USER_EMAIL),
 };

src/redux/actions/users/saveUserEmailAction.ts

@@ -0,0 +1,27 @@
+import { userActionTypes } from '../../actionTypes';
+import saveUserEmailApi from '../../../api/session/saveUserEmail';
+
+export const SaveUserEmailAction = ({
+  userId,
+  email,
+  email_opted_in,
+  onSuccess,
+  onFailure,
+}: {
+  userId: TId;
+  email: string;
+  email_opted_in: any;
+  onSuccess?: () => void;
+  onFailure?: () => void;
+}): TRequestAction => ({
+  type: userActionTypes.saveUserEmail.request,
+  payload: {
+    apiMethod: saveUserEmailApi,
+    isAuthenticated: true,
+    failureActionType: userActionTypes.saveUserEmail.failure,
+    successActionType: userActionTypes.saveUserEmail.success,
+    params: { email, email_opted_in, userId },
+    onSuccess,
+    onFailure,
+  },
+});

src/routes/appRoutesConfig.tsx

@@ -5,6 +5,7 @@ import {
 } from './RouteVisibility';
 import Login from '../ui/layouts/session/Login';
 import Signup from '../ui/layouts/session/Signup';
+import UserEmail from '../ui/layouts/session/UserEmail';
 import ForgotPassword from '../ui/layouts/session/ForgotPassword';
 import Home from '../ui/layouts/Home';
 
@@ -40,6 +41,13 @@ const routes = [
       authentication: RouteVisibilityAuthentication.unauthenticatedOnly,
     },
   },
+  {
+    path: routePaths.userEmail,
+    Component: UserEmail,
+    visibility: {
+      authentication: RouteVisibilityAuthentication.authenticatedOnly,
+    },
+  },
   {
     path: routePaths.forgot,
     Component: ForgotPassword,

src/routes/index.tsx

@@ -14,6 +14,7 @@ import {
   useSelector,
   useLocationPath,
   useGetSearchParam,
+  useDispatch
 } from '../ui/hooks';
 
 import { sessionSelectors } from '../redux/selectors/session';
@@ -26,17 +27,28 @@ import { WaitToEnter } from '../ui/components';
 
 import { isRouteFound } from './utils/isRouteFound';
 import { NotFound } from '../ui/layouts/NotFound';
+import { userSelectors } from '../redux/selectors';
+import {
+  userActions,
+} from '../redux/actions';
+
 
 const useReplaceRouteIfNeeded = ({
   currentLocation,
   setNotFound,
 }: any): void => {
   const { replaceRoute } = useReplaceRoute();
 
+  const user = useSelector(userSelectors.myUser);
   const routeFromSearchParam = useGetSearchParam('route');
 
   const isAuthenticated = useSelector(sessionSelectors.authenticationToken);
 
+  // const dispatch = useDispatch();
+  // React.useEffect(() => {
+  //    dispatch(userActions.getMy({}));    
+  // }, [dispatch, userActions, isAuthenticated])
+
   React.useEffect(() => {
     setNotFound(
       isRouteFound({
@@ -47,12 +59,13 @@ const useReplaceRouteIfNeeded = ({
 
   React.useEffect(() => {
     replaceRouteIfNeeded({
+      user,
       currentLocation,
       isAuthenticated,
       replaceRoute,
       routeFromSearchParam,
     });
-  }, [currentLocation, isAuthenticated, replaceRoute]);
+  }, [user, currentLocation, isAuthenticated, replaceRoute]);
 };
 
 export const AppRoute = ({ path, component, exact }: any): JSX.Element => {

src/routes/routePaths.tsx

@@ -1,6 +1,8 @@
 export const routePaths = {
   login: '/login',
   signup: '/signup',
+  // userEmail: (userId: TId): string => `/user-email/${userId}`,
+  userEmail: `/user-email`,
   forgot: '/forgot-password',
   home: '/',
   pipelines: {

src/routes/utils/replaceRouteIfNeeded.ts

@@ -2,7 +2,7 @@ import {
   RouteInterface,
   RouteVisibilityAuthentication,
 } from '../RouteVisibility';
-import { loggedOutRoute, loggedInRoute } from '../../constants';
+import { loggedOutRoute } from '../../constants';
 
 const isUnauthenticatedOrMissingRoute = (
   currentLocation: RouteInterface | undefined,
@@ -25,19 +25,23 @@ const isAuthenticatedOrMissingRoute = (
 let timeout = null as any;
 
 export const replaceRouteIfNeeded = ({
+  user,
   isAuthenticated,
   currentLocation,
   replaceRoute,
   routeFromSearchParam,
 }: {
+  user: any;
   isAuthenticated: any;
   currentLocation: RouteInterface | undefined;
   replaceRoute: (arg1: string) => void;
   routeFromSearchParam: null | string;
 }): void => {
   clearTimeout(timeout);
+  
   const routeToReplace = () => {
-    return isAuthenticated ? loggedInRoute : loggedOutRoute;
+    const logRoute = user?.email === '' ? `/user-email` : '/'
+    return isAuthenticated ? logRoute : loggedOutRoute;
   };
   const replaceToLoggedInRoute =
     isAuthenticated && isUnauthenticatedOrMissingRoute(currentLocation);