@zohodesk/permissions

Restriction validation for your app

Creating Restriction Rules/ Read only messages for your app

import { READ_ONLY, SHOW, HIDE }  from '@zohodesk/permissions'

const restrictionRules = {
  <group-name>: {
    <features>: {
      <feature-action-1>: [SHOW, READ_ONLY],  //In array 1th position meant can we show ?, 2st position meant to can we readOnly ?
      <feature-action-2>: [SHOW, READ_ONLY],
      <feature-action-3>: [HIDE]
      }
    }
  }
};

const readyOnlyMessages = {
  <group-name>: {
    <features>: {
      <feature-action-1>: message ,
      <feature-action-2>: message ,
      <feature-action-3>: message
    }
  }
};

Restriction Rules

const restrictionRules = {
  tickets: {
    isSpam: {
      secondaryContact: [SHOW, READ_ONLY],
      timeline: [HIDE],
      mergeTicket: [SHOW, READ_ONLY],
       edit : [SHOW]
      }
    },
    bluePrintApplied: {
      status: [SHOW, READ_ONLY],
      move: [HIDE],
      edit : [HIDE]
    }
  },
  contacts: {
    anonymous_users : {
      edit: [HIDE],
      follow: [HIDE],
      add_tickets: [SHOW, READ_ONLY],
      add_products: [SHOW]
      }
    }
  }
  
};

Read Only Messages

const readOnlyMessages = {
  contacts: {
    anonymous_users: {
      edit: 'support.contacts.edit.field.locked',
      add_tickets: 'support.add_tickets.field.locked',
      add_products: 'support.add_products.field.locked'
    }
};

Permissions for your app

	const permission = {
		"tickets" : {
			create: true,
			delete: true,
			edit: true,
			export: true,
			import: true,
			view: true
		}
		
	}
	

license for your app

	const license = {
		agentAllowed: true,
		agentMaxCount: "100",
		manualTimeTrackingAllowed: true,
		ticketTemplateAllowed: true,
		timeTrackingAllowed: true,
		twilioAllowed: true,
		webFormsAllowed: true
	}
	

How to use in app

import { PermissionProvider }  from '@zohodesk/permissions'
<PermissionProvider
	{permission} 
	{license}
	{restrictionRules}
	{lockMessages}
>
{component}
</PermissionProvider>

Restriction handling into your app using util methods

How to use the it.

import { restrictionProviderUtils }  from '@zohodesk/permissions';
restrictionProviderUtils.getRestriction(features=[...], group-name , feature-action-1);

restrictionProviderUtils.getRestriction(['isSpam','bluePrintApplied'],'tickets','edit')
restrictionProviderUtils.getRestriction('isSpam','tickets','edit')

Restriction handling into your app using components

How to use the it.

import { RestrictionValidator }  from '@zohodesk/permissions';

<RestrictionValidator module={group-name}
    features={features [] or feature string} 
    action={feature or action}>
      
      {({isReadOnly,readOnlyMessage})=>{
      
      	return (<span>
	      <Icon name='ZD-addNew' iconClass={iconClass} /> Add product
	    </span>)
      
      }}
	   
</RestrictionValidator>

YourComponent - we will add few props based on the restriction values - ReadOnly, readOnlyMessage isShow : false - By default, we will return null. In this case children won't be rendered.

<RestrictionValidator module={group-name}
        features={features [] or feature string} 
        action={feature or action}>
        
      <YourComponent />
      
  </RestrictionValidator>
  

handleShowHide - you can handle the show/hide 'isShow' into you component, simply passing props handleShowHide={false}

<RestrictionValidator module={group-name} handleShowHide={false}
        features={features [] or feature string} 
        action={feature or action}>
        
       {({isShow,isReadOnly,readOnlyMessage})=>{
      
      	if(!isShow){
      		return (<span>Add Contact</span>)
      	}
      	
      	return (<span>
	      <Icon name='ZD-addNew' iconClass={iconClass} /> Add product
	    </span>)
      
      }}
      
  </RestrictionValidator>

License and Permission validation for your app

import {  licensePermissionCheckHOC }  from '@zohodesk/permissions';

licensePermissionCheckHOC({
	validation : {
		license : ... ,
		permission : ...
	},
	
	customValdation : {...},
	
	Fallback : func..
})(YourComponent);

license - used to verify with user license. * , Any other permission - used to verify with user permissions. * , Any other * - Means all.

License Permission validation in connected components

import { connect } from 'react-redux';
import { compose } from 'redux';
import { getPermission } from 'provider';
import { ALL , licensePermissionCheckHOC }  from '@zohodesk/permissions';

export defult compose(connect(...),
licensePermissionCheckHOC({
	validation : {
		license : ALL,
		permission : getPermission("tickets", "create")
	},
	
	customValdation : {...},
	
	Fallback : func..

})
)(YourComponent);

License Permission validation in connected components AND OR Operations ==> && , ||

import { connect } from 'react-redux';
import { compose } from 'redux';
import { getPermission } from 'provider';
import { ALL , licensePermissionCheckHOC }  from '@zohodesk/permissions';

export defult compose(connect(...),
licensePermissionCheckHOC({
	validation : {
		license : ALL,
		permission : getPermission("tickets", "create") + "&&"+ getPermission("tickets", "edit")
	},
	
	customValdation : {...},
	
	Fallback : func..

})
)(YourComponent);

License Permission validation with custom permission checks.

let YourComponentNew =  licensePermissionCheckHOC({

	validation : {
		license : ALL,
		permission : ALL
	},
	
	customValdation : {
		canMove :(props)=>{
			
			let { module , checkMoveOption } = props;
			
			let permission = `${module}_view`;
			if(crossDepartmentsMove){
				permission += `&&${module}_crossDepartmentMove`
			}
			
			return {
				permission ,
				obj : true,
				falseObj : false
			}
			
		}
		
	},
	
	Fallback : func..

})(YourComponent);

<YourComponentNew  module="tickets" checkMoveOption={true} />
<YourComponentNew  module="tasks" checkMoveOption={true} />

License Permission validation with your app using util methods

import { licensePermissionProviderUtils } from '@zohodesk/permissions';

let {licenseSuccess, permissionSuccess, permissionProps, failedCases} = licensePermissionProviderUtils.getLicensePermissionCheck({
    license : ALL,
    permission : ALL
});

if(licenseSuccess && permissionSuccess){  
  return <Component />
}

License Permission validation with LicensePermissionHandler direct handling.

import { LicensePermissionHandler } from '@zohodesk/permissions';

<LicensePermissionHandler 
    SuccessComponent={YourComponent}
    FallbackComponent={null}
    validationProps={{
        license : ALL,
        permission : ALL
    }}
/>