mirror of
https://github.com/datahub-project/datahub.git
synced 2025-07-08 01:31:55 +00:00
390 lines
14 KiB
JavaScript
390 lines
14 KiB
JavaScript
import Ember from 'ember';
|
|
import isTrackingHeaderField from 'wherehows-web/utils/validators/tracking-headers';
|
|
|
|
const { Component, computed, set, get, isBlank, setProperties, getWithDefault, String: { htmlSafe } } = Ember;
|
|
|
|
// TODO: DSS-6671 Extract to constants module
|
|
const missingTypes = 'Looks like some fields may contain privacy data but do not have a specified `Field Format`?';
|
|
const successUpdating = 'Your changes have been successfully saved!';
|
|
const failedUpdating = 'Oops! We are having trouble updating this dataset at the moment.';
|
|
const hiddenTrackingFieldsMsg = htmlSafe(
|
|
'<p>Hey! Just a heads up that some fields in this dataset have been hidden from the table(s) below. ' +
|
|
"These are tracking fields for which we've been able to predetermine the compliance classification.</p>" +
|
|
'<p>For example: <code>header.memberId</code>, <code>requestHeader</code>. ' +
|
|
'Hopefully, this saves you some scrolling!</p>'
|
|
);
|
|
|
|
const complianceListKey = 'privacyCompliancePolicy.compliancePurgeEntities';
|
|
// TODO: DSS-6671 Extract to constants module
|
|
const logicalTypes = ['ID', 'URN', 'REVERSED_URN', 'COMPOSITE_URN'];
|
|
/**
|
|
* Duplicate check using every to short-circuit iteration
|
|
* @param {Array} names = [] the list to check for dupes
|
|
* @return {Boolean} true is unique, false otherwise
|
|
*/
|
|
const fieldNamesAreUnique = (names = []) => names.every((name, index) => names.indexOf(name) === index);
|
|
|
|
/**
|
|
* Returns a computed macro based on a provided type will return a list of
|
|
* Compliance fields that are of that identifierType or have no type
|
|
* @param {String} type string to match against identifierType
|
|
*/
|
|
const complianceEntitiesMatchingType = type =>
|
|
computed('complianceDataFieldsSansHiddenTracking.[]', function() {
|
|
const fieldRegex = new RegExp(`${type}`, 'i');
|
|
|
|
return get(this, 'complianceDataFieldsSansHiddenTracking').filter(({ identifierType }) => {
|
|
return fieldRegex.test(identifierType) || isBlank(identifierType);
|
|
});
|
|
});
|
|
|
|
export default Component.extend({
|
|
sortColumnWithName: 'identifierField',
|
|
filterBy: 'identifierField',
|
|
sortDirection: 'asc',
|
|
searchTerm: '',
|
|
hiddenTrackingFields: hiddenTrackingFieldsMsg,
|
|
|
|
/**
|
|
* Map of radio Group state values
|
|
* Each initially has an indeterminate state, as the user
|
|
* progresses through the prompts
|
|
* @type {Object.<Boolean, null>}
|
|
*/
|
|
userIndicatesDatasetHas: {
|
|
member: null,
|
|
org: null,
|
|
group: null
|
|
},
|
|
|
|
didReceiveAttrs() {
|
|
this._super(...arguments);
|
|
// Perform validation step on the received component attributes
|
|
this.validateAttrs();
|
|
},
|
|
|
|
/**
|
|
* Ensure that props received from on this component
|
|
* are valid, otherwise flag
|
|
*/
|
|
validateAttrs() {
|
|
const fieldNames = getWithDefault(this, 'schemaFieldNamesMappedToDataTypes', []).mapBy('fieldName');
|
|
|
|
if (fieldNamesAreUnique(fieldNames.sort())) {
|
|
return set(this, '_hasBadData', false);
|
|
}
|
|
|
|
// Flag this component's data as problematic
|
|
set(this, '_hasBadData', true);
|
|
},
|
|
|
|
// Map logicalTypes to options consumable by ui
|
|
logicalTypes: ['', ...logicalTypes].map(value => ({
|
|
value,
|
|
label: value ? value.replace('_', ' ').toLowerCase().capitalize() : 'Please Select'
|
|
})),
|
|
|
|
/**
|
|
* @type {Boolean} cached boolean flag indicating that fields do contain a `kafka type`
|
|
* tracking header.
|
|
* Used to indicate to viewer that these fields are hidden.
|
|
*/
|
|
containsHiddenTrackingFields: computed('complianceDataFieldsSansHiddenTracking.length', function() {
|
|
// If their is a diff in complianceDataFields and complianceDataFieldsSansHiddenTracking,
|
|
// then we have hidden tracking fields
|
|
return get(this, 'complianceDataFieldsSansHiddenTracking.length') !== get(this, 'complianceDataFields.length');
|
|
}),
|
|
|
|
/**
|
|
* @type {Array.<Object>} Filters the mapped compliance data fields without `kafka type`
|
|
* tracking headers
|
|
*/
|
|
complianceDataFieldsSansHiddenTracking: computed('complianceDataFields.[]', function() {
|
|
return get(this, 'complianceDataFields').filter(({ identifierField }) => !isTrackingHeaderField(identifierField));
|
|
}),
|
|
|
|
/**
|
|
* Lists all dataset fields found in the `columns` performs an intersection
|
|
* of fields with the currently persisted and/or updated
|
|
* privacyCompliancePolicy.compliancePurgeEntities.
|
|
* The returned list is a map of fields with current or default privacy properties
|
|
*/
|
|
complianceDataFields: computed(
|
|
`${complianceListKey}.@each.identifierType`,
|
|
`${complianceListKey}.[]`,
|
|
'schemaFieldNamesMappedToDataTypes',
|
|
function() {
|
|
const sourceEntities = getWithDefault(this, complianceListKey, []);
|
|
const complianceFieldNames = sourceEntities.mapBy('identifierField');
|
|
|
|
const getAttributeOnField = (attribute, fieldName) => {
|
|
const sourceField = getWithDefault(this, complianceListKey, []).find(
|
|
({ identifierField }) => identifierField === fieldName
|
|
);
|
|
return sourceField ? sourceField[attribute] : null;
|
|
};
|
|
|
|
/**
|
|
* Get value for a list of attributes
|
|
* @param {Array} attributes list of attribute keys to pull from
|
|
* sourceField
|
|
* @param {String} fieldName name of the field to lookup
|
|
* @return {Array} list of attribute values
|
|
*/
|
|
const getAttributesOnField = (attributes = [], fieldName) =>
|
|
attributes.map(attr => getAttributeOnField(attr, fieldName));
|
|
|
|
// Set default or if already in policy, retrieve current values from
|
|
// privacyCompliancePolicy.compliancePurgeEntities
|
|
return getWithDefault(
|
|
this,
|
|
'schemaFieldNamesMappedToDataTypes',
|
|
[]
|
|
).map(({ fieldName: identifierField, dataType }) => {
|
|
const hasPrivacyData = complianceFieldNames.includes(identifierField);
|
|
const [identifierType, isSubject, logicalType] = getAttributesOnField(
|
|
['identifierType', 'isSubject', 'logicalType'],
|
|
identifierField
|
|
);
|
|
|
|
return {
|
|
dataType,
|
|
identifierField,
|
|
identifierType,
|
|
isSubject,
|
|
logicalType,
|
|
hasPrivacyData
|
|
};
|
|
});
|
|
}
|
|
),
|
|
|
|
// Compliance entities filtered for each identifierType
|
|
memberComplianceEntities: complianceEntitiesMatchingType('member'),
|
|
orgComplianceEntities: complianceEntitiesMatchingType('organization'),
|
|
groupComplianceEntities: complianceEntitiesMatchingType('group'),
|
|
|
|
/**
|
|
* Changes the logicalType on a field.
|
|
* Ensures that the logicalType / format is applicable to the specified field
|
|
* @param {String} fieldName the fieldName identifying the field to be updated
|
|
* @param {String} format logicalType or format te field is in
|
|
* @return {String| void}
|
|
*/
|
|
changeFieldLogicalType(fieldName, format) {
|
|
const sourceField = get(this, complianceListKey).findBy('identifierField', fieldName);
|
|
|
|
if (sourceField && logicalTypes.includes(format)) {
|
|
return set(sourceField, 'logicalType', String(format).toUpperCase());
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Adds or removes a field onto the
|
|
* privacyCompliancePolicy.compliancePurgeEntities list.
|
|
* @param {Object} props initial props for the field to be added
|
|
* @prop {String} props.identifierField
|
|
* @prop {String} props.dataType
|
|
* @param {String} identifierType the type of the field to toggle
|
|
* @param {('add'|'remove')} toggle operation to perform, can either be
|
|
* add or remove
|
|
* @return {Ember.Array|*}
|
|
*/
|
|
toggleFieldOnComplianceList(props, identifierType, toggle) {
|
|
const { identifierField, logicalType } = props;
|
|
const sourceEntities = get(this, complianceListKey);
|
|
|
|
if (!['add', 'remove'].includes(toggle)) {
|
|
throw new Error(`Unsupported toggle operation ${toggle}`);
|
|
}
|
|
|
|
return {
|
|
add() {
|
|
// Ensure that we don't currently have this field present on the
|
|
// privacyCompliancePolicy.compliancePurgeEntities list
|
|
if (!sourceEntities.findBy('identifierField', identifierField)) {
|
|
const addPurgeEntity = {
|
|
identifierType,
|
|
identifierField,
|
|
logicalType
|
|
};
|
|
|
|
return sourceEntities.setObjects([addPurgeEntity, ...sourceEntities]);
|
|
}
|
|
},
|
|
|
|
remove() {
|
|
// Remove the identifierType since we are removing it from the
|
|
// privacyCompliancePolicy.compliancePurgeEntities in case it
|
|
// is added back during the session
|
|
set(props, 'identifierType', null);
|
|
return sourceEntities.setObjects(sourceEntities.filter(item => item.identifierField !== identifierField));
|
|
}
|
|
}[toggle]();
|
|
},
|
|
|
|
/**
|
|
* Checks that each privacyCompliancePolicy.compliancePurgeEntities has
|
|
* a valid identifierType
|
|
* @param {Ember.Array} sourceEntities compliancePurgeEntities
|
|
* @return {Boolean} has or does not
|
|
*/
|
|
ensureTypeContainsFormat: sourceEntities =>
|
|
sourceEntities.every(entity => ['member', 'organization', 'group'].includes(get(entity, 'identifierType'))),
|
|
|
|
/**
|
|
* Checks that each privacyCompliancePolicy.compliancePurgeEntities has
|
|
* a valid logicalType
|
|
* @param {Ember.Array}sourceEntities compliancePurgeEntities
|
|
* @return {Boolean|*} Contains or does not
|
|
*/
|
|
ensureTypeContainsLogicalType: sourceEntities => {
|
|
const logicalTypesInUppercase = logicalTypes.map(type => type.toUpperCase());
|
|
|
|
return sourceEntities.every(entity => logicalTypesInUppercase.includes(get(entity, 'logicalType')));
|
|
},
|
|
|
|
/**
|
|
* TODO:DSS-6719 refactor into mixin
|
|
* Clears recently shown user messages
|
|
*/
|
|
clearMessages() {
|
|
return setProperties(this, {
|
|
_message: '',
|
|
_alertType: ''
|
|
});
|
|
},
|
|
|
|
/**
|
|
* TODO: DSS-6672 Extract to notifications service
|
|
* Helper method to update user when an async server update to the
|
|
* security specification is handled.
|
|
* @param {XMLHttpRequest|Promise|jqXHR|*} request the server request
|
|
* @param {String} [successMessage] optional _message for successful response
|
|
*/
|
|
whenRequestCompletes(request, { successMessage } = {}) {
|
|
Promise.resolve(request)
|
|
.then(({ status = 'error' }) => {
|
|
// The server api currently responds with an object containing
|
|
// a status when complete
|
|
return status === 'ok'
|
|
? setProperties(this, {
|
|
_message: successMessage || successUpdating,
|
|
_alertType: 'success'
|
|
})
|
|
: Promise.reject(new Error(`Reason code for this is ${status}`));
|
|
})
|
|
.catch(err => {
|
|
let _message = `${failedUpdating} \n ${err}`;
|
|
let _alertType = 'danger';
|
|
|
|
if (get(this, 'isNewPrivacyCompliancePolicy')) {
|
|
_message = 'This dataset does not have any previously saved fields with a identifying information.';
|
|
_alertType = 'info';
|
|
}
|
|
|
|
setProperties(this, {
|
|
_message,
|
|
_alertType
|
|
});
|
|
});
|
|
},
|
|
|
|
actions: {
|
|
/**
|
|
*
|
|
* @param {String} identifierField id for the field to update
|
|
* @param {String} logicalType updated format to apply to the field
|
|
* @return {*|String|void} logicalType or void
|
|
*/
|
|
onFieldFormatChange({ identifierField }, { value: logicalType }) {
|
|
// TODO:DSS-6719 refactor into mixin
|
|
this.clearMessages();
|
|
return this.changeFieldLogicalType(identifierField, logicalType);
|
|
},
|
|
|
|
/**
|
|
* Toggles a field on / off the compliance list
|
|
* @param {String} identifierType the type of the field to be toggled on
|
|
* the privacyCompliancePolicy.compliancePurgeEntities list
|
|
* @param {Object|Ember.Object} props containing the props to be added
|
|
* @prop {Boolean} props.hasPrivacyData checked or not checked
|
|
* @return {*}
|
|
*/
|
|
onFieldPrivacyChange(identifierType, props) {
|
|
// If checked, add, otherwise remove
|
|
const { hasPrivacyData } = props;
|
|
const toggle = !hasPrivacyData ? 'add' : 'remove';
|
|
|
|
// TODO:DSS-6719 refactor into mixin
|
|
this.clearMessages();
|
|
|
|
return this.toggleFieldOnComplianceList(props, identifierType, toggle);
|
|
},
|
|
|
|
/**
|
|
* Toggles the isSubject property of a member identifiable field
|
|
* @param {Object} props the props on the member field to update
|
|
* @prop {Boolean} isSubject flag indicating this field as a subject owner
|
|
* when true
|
|
* @prop {String} identifierField unique field to update isSubject property
|
|
*/
|
|
onMemberFieldSubjectChange(props) {
|
|
const { isSubject, identifierField: name } = props;
|
|
|
|
// TODO:DSS-6719 refactor into mixin
|
|
this.clearMessages();
|
|
|
|
// Ensure that a flag isSubject is present on the props
|
|
if (props && 'isSubject' in props) {
|
|
const sourceField = get(this, complianceListKey).find(({ identifierField }) => identifierField === name);
|
|
|
|
set(sourceField, 'isSubject', !isSubject);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Updates the state flags that transition the prompts from one to the next
|
|
* @param {String} sectionName name of the section that was changed
|
|
* @param {Boolean} isPrivacyIdentifiable flag indicating that a section has
|
|
* or does not have privacy identifier
|
|
*/
|
|
didChangePrivacyIdentifiable(sectionName, isPrivacyIdentifiable) {
|
|
const section = {
|
|
'has-group': 'group',
|
|
'has-org': 'org',
|
|
'has-member': 'member'
|
|
}[sectionName];
|
|
|
|
return set(this, `userIndicatesDatasetHas.${section}`, isPrivacyIdentifiable);
|
|
},
|
|
|
|
/**
|
|
* If all validity checks are passed, invoke onSave action on controller
|
|
*/
|
|
saveCompliance() {
|
|
const complianceList = get(this, complianceListKey);
|
|
const allEntitiesHaveValidFormat = this.ensureTypeContainsFormat(complianceList);
|
|
const allEntitiesHaveValidLogicalType = this.ensureTypeContainsLogicalType(complianceList);
|
|
|
|
if (allEntitiesHaveValidFormat && allEntitiesHaveValidLogicalType) {
|
|
return this.whenRequestCompletes(this.get('onSave')());
|
|
} else {
|
|
setProperties(this, {
|
|
_message: missingTypes,
|
|
_alertType: 'danger'
|
|
});
|
|
}
|
|
},
|
|
|
|
// Rolls back changes made to the compliance spec to current
|
|
// server state
|
|
resetCompliance() {
|
|
const options = {
|
|
successMessage: 'Field classification has been reset to the previously saved state.'
|
|
};
|
|
this.whenRequestCompletes(get(this, 'onReset')(), options);
|
|
}
|
|
}
|
|
});
|