@capillarytech/creatives-library 8.0.136-alpha.4 → 8.0.136-beta.3

package/containers/Assets/Gallery/sagas.js

@@ -0,0 +1,80 @@
+import { call, put, takeLatest, all } from 'redux-saga/effects';
+import * as Api from '../../../services/api';
+import * as types from './constants';
+
+export function* getAllAssets({assetType , queryParams}) {
+  try {
+    const result = yield call(Api.getAllAssets, {assetType, queryParams});
+    yield put({ type: types.GET_ALL_ASSETS_SUCCESS, data: result?.response, isReset: queryParams.page === 1 });
+  } catch (error) {
+    yield put({ type: types.GET_ALL_ASSETS_FAILURE, error });
+  }
+}
+
+export function* uploadAsset(file, assetType, fileParams) {
+  try {
+    const result = yield call(Api.uploadFile, file, assetType, fileParams);
+    yield put({ type: types.UPLOAD_ASSET_SUCCESS, data: result.response.asset, statusCode: result.status ? result.status.code : '' });
+  } catch (error) {
+    yield put({ type: types.UPLOAD_ASSET_FAILURE, error });
+  }
+}
+
+export function* deleteAssetById(assetId, assetType) {
+  try {
+    const result = yield call(Api.deleteAssetById, assetId, assetType);
+    
+    yield put({ type: types.DELETE_ASSET_SUCCESS, data: result.response });
+  } catch (error) {
+    yield put({ type: types.DELETE_ASSET_FAILURE, error });
+  }
+}
+
+export function* fetchUserList() {
+  try {
+    const result = yield call(Api.getUserList);
+    yield put({
+      type: types.GET_USER_LIST_SUCCESS,
+      data: result?.data?.result,
+    });
+  } catch (error) {
+    yield put({
+      type: types.GET_USER_LIST_FAILURE,
+      data: error,
+    });
+  }
+}
+
+
+function* watchGetAllAssets() {
+  yield takeLatest(types.GET_ALL_ASSETS_REQUEST, getAllAssets);
+}
+
+function* watchDeleteAssetById() {
+  yield takeLatest(types.DELETE_ASSET_REQUEST, deleteAssetById);
+}
+
+function* watchUploadAsset() {
+  yield takeLatest(types.UPLOAD_ASSET_REQUEST, uploadAsset);
+}
+
+function* watchGetUserList() {
+  yield takeLatest(types.GET_USER_LIST_REQUEST, fetchUserList);
+}
+
+// All sagas to be loaded
+export default [
+  watchGetAllAssets,
+  watchUploadAsset,
+  watchDeleteAssetById,
+  watchGetUserList,
+];
+
+export function* gallerySaga() {
+  yield all([
+    watchGetAllAssets(),
+    watchUploadAsset(),
+    watchDeleteAssetById(),
+    watchGetUserList(),
+  ]);
+}

package/containers/Assets/Gallery/selectors.js

@@ -0,0 +1,25 @@
+import { createSelector } from 'reselect';
+
+/**
+ * Direct selector to the gallery state domain
+ */
+const selectGalleryDomain = () => (state) => state.get('gallery');
+
+/**
+ * Other specific selectors
+ */
+
+
+/**
+ * Default selector used by Gallery
+ */
+
+const makeSelectGallery = () => createSelector(
+  selectGalleryDomain(),
+  (substate) => substate.toJS()
+);
+
+export default makeSelectGallery;
+export {
+  selectGalleryDomain,
+};

package/containers/Assets/Gallery/tests/__snapshots__/reducer.test.js.snap

@@ -0,0 +1,9 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[` 1`] = `
+Immutable.Map {
+  "assetList": Immutable.List [],
+  "assetUploading": false,
+  "fetchingAllAssets": false,
+}
+`;

package/containers/Assets/Gallery/tests/actions.test.js

@@ -0,0 +1,25 @@
+import * as actions from '../actions';
+import * as types from '../constants';
+
+describe('Gallery actions', () => {
+  describe('uploadAsset', () => {
+    test.concurrent('has a type of UPLOAD_ASSET_REQUEST', () => {
+      const expected = {
+        type: types.UPLOAD_ASSET_REQUEST,
+        file: 'test',
+        assetType: 'IMAGE',
+      };
+      expect(actions.uploadAsset('test', 'IMAGE')).toEqual(expected);
+    });
+  });
+
+  describe('getAllAssets', () => {
+    test.concurrent('has a type of GET_ALL_ASSETS_REQUEST', () => {
+      const expected = {
+        type: types.GET_ALL_ASSETS_REQUEST,
+        assetType: 'IMAGE',
+      };
+      expect(actions.getAllAssets('IMAGE')).toEqual(expected);
+    });
+  });
+});

package/containers/Assets/Gallery/tests/reducer.test.js

@@ -0,0 +1,96 @@
+
+import { fromJS } from 'immutable';
+import galleryReducer from '../reducer';
+import * as types from '../constants';
+import * as actions from '../actions';
+
+describe('galleryReducer', () => {
+  describe('Initial State should match snapshot', () => {
+    it.concurrent('returns the initial state', () => {
+      expect(galleryReducer(undefined, {})).toMatchSnapshot();
+    });
+  });
+
+  describe('Request for all assets', () => {
+    const initialState = fromJS({
+      assetList: [],
+      fetchingAllAssets: false,
+      fetchAllAssetSuccess: false,
+    });
+    const requestAction = actions.getAllAssets('IMAGE');
+    const stateOnRequest = galleryReducer(initialState, requestAction);
+    const successStateExpected = {
+      assetList: [
+        {
+          _id: '5678fdghfh',
+        },
+        {
+          _id: '5678fdghfh5',
+        },
+      ],
+      fetchingAllAssets: false,
+      fetchAllAssetSuccess: true,
+    };
+    const successAction = {
+      type: types.GET_ALL_ASSETS_SUCCESS,
+      data: {
+        assets: [
+          {
+            _id: '5678fdghfh',
+          },
+          {
+            _id: '5678fdghfh5',
+          },
+        ],
+      },
+    };
+    const stateOnSuccess = galleryReducer(initialState, successAction);
+    const failureAction = {
+      type: types.GET_ALL_ASSETS_FAILURE,
+      error: 'Some error Occurred',
+    };
+    const stateOnFailure = galleryReducer(initialState, failureAction);
+    it.concurrent('should set fetching_schedule_message to true on request', () => {
+      expect(stateOnRequest.toJS()).toEqual({ assetList: [], fetchingAllAssets: true, fetchAllAssetSuccess: false });
+    });
+
+    it.concurrent('should set assetList from response on success', () => {
+      expect(stateOnSuccess.toJS()).toEqual(successStateExpected);
+    });
+    it.concurrent('should set fetching_schedule_message to false on GET_ALL_ASSETS_FAILURE', () => {
+      expect(stateOnFailure.toJS()).toEqual({assetList: [], fetchingAllAssets: false, fetchAllAssetSuccess: false});
+    });
+  });
+
+  describe('Upload Assets', () => {
+    const initialState = fromJS({
+      assetUploading: false,
+    });
+    const requestAction = actions.uploadAsset({}, 'IMAGE', {});
+    const stateOnRequest = galleryReducer(initialState, requestAction);
+    const successStateExpected = {
+      assetUploading: false,
+      uploadAssetSuccess: false,
+      uploadedAssetData: undefined,
+    };
+    const successAction = {
+      type: types.UPLOAD_ASSET_SUCCESS,
+    };
+    const stateOnSuccess = galleryReducer(initialState, successAction);
+    const failureAction = {
+      type: types.UPLOAD_ASSET_FAILURE,
+      error: 'Some error Occurred',
+    };
+    const stateOnFailure = galleryReducer(initialState, failureAction);
+    it.concurrent('should set assetUploading to true and uploadAssetSuccess to false on request', () => {
+      expect(stateOnRequest.toJS()).toEqual({ uploadAssetSuccess: false, assetUploading: true });
+    });
+
+    it.concurrent('should set assetUploading to false and uploadAssetSuccess to true on success', () => {
+      expect(stateOnSuccess.toJS()).toEqual(successStateExpected);
+    });
+    it.concurrent('should set assetUploading to false and uploadAssetSuccess to false on UPLOAD_ASSET_FAILURE', () => {
+      expect(stateOnFailure.toJS()).toEqual({ uploadAssetSuccess: false, assetUploading: false });
+    });
+  });
+});

package/containers/Assets/Gallery/tests/saga.test.js

@@ -0,0 +1,157 @@
+import { expectSaga } from 'redux-saga-test-plan';
+import { call } from 'redux-saga/effects';
+import { throwError } from 'redux-saga-test-plan/providers';
+import * as Api from '../../../../services/api';
+import * as types from '../constants';
+import * as sagas from '../sagas';
+
+describe('Asset and User Management Sagas', () => {
+  jest.setTimeout(1000);
+
+  describe('getAllAssets Saga', () => {
+    const mockAssets = [{ id: 1, url: 'http://example.com/asset.jpg' }];
+    const mockError = new Error('Fetch failed');
+    const assetType = 'image';
+    const queryParams = { page: 1 };
+
+    it.concurrent('handles fetching all assets successfully', () => {
+      const result = {
+        response: { data: { data: mockAssets } },
+      };
+      return expectSaga(sagas.getAllAssets, { assetType, queryParams })
+        .provide([
+          [call(Api.getAllAssets, { assetType, queryParams }), result],
+        ])
+        .put({
+          type: 'app/Gallery/GET_ALL_ASSETS_SUCCESS',
+          data: { data: { data: mockAssets } },
+          isReset: true,
+        })
+        .run(500);
+    });
+
+    it.concurrent('handles failure in fetching all assets', () => expectSaga(sagas.getAllAssets, { assetType, queryParams })
+      .provide([
+        [call(Api.getAllAssets, { assetType, queryParams }), throwError(mockError)],
+      ])
+      .put({
+        type: 'app/Gallery/GET_ALL_ASSETS_FAILURE',
+        error: mockError,
+      })
+      .run(500));
+  });
+
+  describe('uploadAsset Saga', () => {
+    const file = new Blob();
+    const assetType = 'image';
+    const fileParams = { param1: 'value1' };
+
+    it.concurrent('handles successful asset upload', () => {
+      const fakeResponse = {
+        response: { asset: { id: 1, url: 'http://example.com/asset.jpg' } },
+        status: { code: 200 },
+      };
+
+      return expectSaga(sagas.uploadAsset, file, assetType, fileParams)
+        .provide([
+          [call(Api.uploadFile, file, assetType, fileParams), fakeResponse],
+        ])
+        .put({
+          type: types.UPLOAD_ASSET_SUCCESS,
+          data: fakeResponse.response.asset,
+          statusCode: 200,
+        })
+        .run();
+    });
+
+    it.concurrent('handles failure in asset upload', () => {
+      const error = new Error('Failed to upload asset');
+
+      return expectSaga(sagas.uploadAsset, file, assetType, fileParams)
+        .provide([
+          [call(Api.uploadFile, file, assetType, fileParams), throwError(error)],
+        ])
+        .put({
+          type: types.UPLOAD_ASSET_FAILURE,
+          error,
+        })
+        .run();
+    });
+  });
+
+  describe('deleteAssetById Saga', () => {
+    const assetId = '123';
+    const assetType = 'image';
+
+    it.concurrent('handles deleting an asset successfully', () => {
+      const fakeResponse = {
+        response: 'Asset deleted successfully',
+      };
+
+      return expectSaga(sagas.deleteAssetById, assetId, assetType)
+        .provide([
+          [call(Api.deleteAssetById, assetId, assetType), fakeResponse],
+        ])
+        .put({
+          type: types.DELETE_ASSET_SUCCESS,
+          data: fakeResponse.response,
+        })
+        .run();
+    });
+
+    it.concurrent('handles failure in deleting an asset', () => {
+      const error = new Error('Deletion failed');
+
+      return expectSaga(sagas.deleteAssetById, assetId, assetType)
+        .provide([
+          [call(Api.deleteAssetById, assetId, assetType), throwError(error)]
+        ])
+        .put({
+          type: types.DELETE_ASSET_FAILURE,
+          error,
+        })
+        .run();
+    });
+  });
+
+  describe('fetchUserList Saga', () => {
+    it.concurrent('handles fetching user list successfully', () => {
+      const fakeResponse = {
+        data: {
+          result: [{ id: 1, name: 'User One' }],
+        },
+      };
+
+      return expectSaga(sagas.fetchUserList)
+        .provide([
+          [call(Api.getUserList), fakeResponse],
+        ])
+        .put({
+          type: types.GET_USER_LIST_SUCCESS,
+          data: fakeResponse.data.result,
+        })
+        .run();
+    });
+
+    it.concurrent('handles failure in fetching user list', () => {
+      const error = new Error('Fetch failed');
+
+      return expectSaga(sagas.fetchUserList)
+        .provide([
+          [call(Api.getUserList), throwError(error)],
+        ])
+        .put({
+          type: types.GET_USER_LIST_FAILURE,
+          data: error,
+        })
+        .run();
+    });
+  });
+
+
+  // Test combined saga
+  describe('Combined gallerySaga', () => {
+    it.concurrent('should initialize all gallery-related watcher sagas without error', () => expectSaga(sagas.gallerySaga)
+      .run());
+  });
+});

package/containers/Cap/actions.js

@@ -0,0 +1,66 @@
+/**
+ * Created by vivek on 22/5/17.
+ */
+import * as types from './constants';
+
+export function authenticate(user) {
+  return {
+    type: types.LOGIN_REQUEST,
+    user,
+  };
+}
+
+export function logout() {
+  return {
+    type: types.LOGOUT_REQUEST,
+  };
+}
+
+export function changeOrg(orgID) {
+  return {
+    type: types.SWITCH_ORG_REQUEST,
+    orgID,
+  };
+}
+
+export function addMessageToQueue(message) {
+  
+  return {
+    type: types.ADD_MESSAGE,
+    message,
+  };
+}
+
+export function removeMessageFromQueue(messageIndex) {
+  return {
+    type: types.REMOVE_MESSAGE,
+    messageIndex,
+  };
+}
+
+export function getUserData(callback) {
+  return {
+    type: types.GET_USER_DATA_REQUEST,
+    callback,
+  };
+}
+
+export function fetchSchemaForEntity(queryParams) {
+  
+  return {
+    type: types.GET_SCHEMA_FOR_ENTITY_REQUEST, queryParams,
+  };
+}
+
+export function removeEntitySchema() {
+  return {
+    type: types.ROMOVE_ENTITY_SCHEMA,
+  };
+}
+
+export function setInjectedTags(injectedTags) {
+  return {
+    type: types.SET_INJECTED_TAGS, injectedTags,
+  };
+}
+

package/containers/Cap/constants.js

@@ -0,0 +1,25 @@
+export const DEFAULT_LOCALE = 'en';
+export const SWITCH_ORG_REQUEST = 'cap/SWITCH_ORG_REQUEST';
+export const SWITCH_ORG_SUCCESS = 'cap/SWITCH_ORG_SUCCESS';
+export const SWITCH_ORG_FAILURE = 'cap/SWITCH_ORG_FAILURE';
+export const LOGIN_REQUEST = 'cap/LOGIN_REQUEST';
+export const LOGIN_SUCCESS = 'cap/LOGIN_SUCCESS';
+export const LOGIN_FAILURE = 'cap/LOGIN_FAILURE';
+
+export const LOGOUT_REQUEST = 'cap/LOGOUT_REQUEST';
+export const LOGOUT_SUCCESS = 'cap/LOGOUT_SUCCESS';
+export const LOGOUT_FAILURE = 'cap/LOGOUT_FAILURE';
+export const ADD_MESSAGE = 'cap/ADD_MESSAGE';
+export const REMOVE_MESSAGE = 'cap/REMOVE_MESSAGE';
+export const GET_USER_DATA_REQUEST = 'cap/GET_USER_DATA_REQUEST';
+export const GET_USER_DATA_SUCCESS = 'cap/GET_USER_DATA_SUCCESS';
+export const GET_USER_DATA_FAILURE = 'cap/GET_USER_DATA_FAILURE';
+
+export const GET_SCHEMA_FOR_ENTITY_FAILURE = 'cap/GET_SCHEMA_FOR_ENTITY_FAILURE';
+export const GET_SCHEMA_FOR_ENTITY_REQUEST = 'cap/GET_SCHEMA_FOR_ENTITY_REQUEST';
+export const GET_SCHEMA_FOR_ENTITY_SUCCESS = 'cap/GET_SCHEMA_FOR_ENTITY_SUCCESS';
+export const ROMOVE_ENTITY_SCHEMA = 'cap/ROMOVE_ENTITY_SCHEMA';
+export const CLEAR_META_ENTITIES = 'cap/CLEAR_META_ENTITIES';
+export const HIDE_TAGS = 'cap/HIDE_TAGS';
+
+export const SET_INJECTED_TAGS = 'cap/SET_INJECTED_TAGS';