Notes

import React, { Component } from 'react';
import PropTypes from 'prop-types';
import { graphql, compose, withApollo } from 'react-apollo';
import { connect } from 'react-redux';

import StepComponent from './../../components/StepComponent';
import {
getStaticTemplateDataFromQuery,
getUDATemplateDataQuery
} from './EditTemplateQuery';
import {
setUDAData as setUDADataAction,
setMasterData as setMasterDataAction,
setOtherData as setOtherDataAction,
setTemplateId as setTemplateIdAction,
setAfterMapping,
setFieldsForRecordTypeList
} from '../../action';
import { getAppPageParams } from '../../../../login/reducer';
import { getMasterData } from '../../reducer';

export class EditTemplate extends Component {
constructor(props) {
super(props);
this.state = {
charEncodingFormatList: [],
product: [],
selectedProductType: '',
selectedSubProductType: '',
selectedFileType: '',
templateId: ''
};
props.setUDAData();
props.setMasterData();
props.setOtherData();
props.setTemplateId();
props.setAfterMapping();
props.setFieldsForRecordTypeList();
}

componentWillReceiveProps = (nextProps) => {
const tempId = nextProps.templateId;
if (tempId !== undefined) {
this.setState({
templateId: tempId
});
}
const reduxObjForFirstPage = nextProps.editData;
if (reduxObjForFirstPage !== undefined) {
let fileTypeLabel;
switch (reduxObjForFirstPage.fileType) {
case 'D':
fileTypeLabel = 'Delimited';
break;
case 'F':
fileTypeLabel = 'Fixed Length';
break;
default:
fileTypeLabel = 'Excel File';
}
this.setState({
selectedProductType: reduxObjForFirstPage.applicationId,
selectedSubProductType: reduxObjForFirstPage.appSubType,
selectedFileType: fileTypeLabel
});
}
this.setState({
stepIndex: nextProps.location.state
? nextProps.location.state.stepIndex
: 0
});
const {
getProductSubProductConfig,
getCharacterEncodingFormats,
getFileTypeValues,
getFieldSeparatorValues,
getFieldWrapperValues,
getHeaderRecordValues,
getTransactionRecordValues,
getRecordTypes,
getDateFormats
} = nextProps.getStaticTemplateData;

const { getUDATemplateData } = nextProps.getUDATempData;

const { productSubProductList } =
getProductSubProductConfig !== undefined && getProductSubProductConfig;
const { characterEncodingFormatList } =
getCharacterEncodingFormats !== undefined && getCharacterEncodingFormats;
const { fileTypeOptions } =
getFileTypeValues !== undefined && getFileTypeValues;
const { fieldSeparatorValuesList } =
getFieldSeparatorValues !== undefined && getFieldSeparatorValues;
const { fieldWrapperValuesList } =
getFieldWrapperValues !== undefined && getFieldWrapperValues;
const { headerRecordValueList } =
getHeaderRecordValues !== undefined && getHeaderRecordValues;
const { transactionRecordValueList } =
getTransactionRecordValues !== undefined && getTransactionRecordValues;
const { fileRecordTypesList } =
getRecordTypes !== undefined && getRecordTypes;
const { dateFormatList } = getDateFormats !== undefined && getDateFormats;

const udaData = [];
if (getUDATemplateData) {
const {
templateId,
recordMappingMasterResponse,
recordMappingOtherRecordsResponseList,
templateResponseHeaderList,
templateResponseDetailList,
templateResponseTrailerList,
templateResponseDetailForOtherRecordTypeList
} = getUDATemplateData;

if (templateId !== undefined) {
this.props.setTemplateId(templateId);
}
if (recordMappingMasterResponse !== undefined) {
this.props.setMasterData(recordMappingMasterResponse);
}
if (recordMappingOtherRecordsResponseList !== undefined) {
this.props.setOtherData(recordMappingOtherRecordsResponseList);
}
let recordType;
let recTypeLabel;
let headerObj = {};
let detailObj = {};
let trailerObj = {};
let recTypeSelection = '';
let obj2;
if (
(templateResponseHeaderList && templateResponseHeaderList.length) ||
(templateResponseDetailList && templateResponseDetailList.length) ||
(templateResponseTrailerList && templateResponseTrailerList.length)
) {
// if (templateResponseHeaderList && templateResponseHeaderList.length) {
// //recTypeSelection = templateResponseHeaderList[0].recType;
// } else if (
// templateResponseDetailList &&
// templateResponseDetailList.length
// ) {
// //recTypeSelection = templateResponseDetailList[0].recType;
// } else if (
// templateResponseTrailerList &&
// templateResponseTrailerList.length
// ) {
// //recTypeSelection = templateResponseTrailerList[0].recType;
// } else {
// recTypeSelection = '';
// }
recTypeLabel = templateResponseDetailList[0].recTypeLabel;
recordType = templateResponseDetailList[0].recType;

headerObj = this.getStructuredObject(
this.recIdentUpdate(
recordMappingOtherRecordsResponseList,
templateResponseHeaderList,
'Header'
),
'Header'
);
detailObj = this.getStructuredObject(
this.recIdentUpdate(
recordMappingOtherRecordsResponseList,
templateResponseDetailList,
recordType
),
recordType
);
trailerObj = this.getStructuredObject(
this.recIdentUpdate(
recordMappingOtherRecordsResponseList,
templateResponseTrailerList,
'Trailer'
),
'Trailer'
);

const obj1 = {
headerRecordList: headerObj,
detailRecordList: detailObj,
trailerRecordList: trailerObj,
recType: recordType,
recTypeLabel
};
udaData.push(obj1);
console.log(udaData, 'udaData udaData');
}

if (
templateResponseDetailForOtherRecordTypeList &&
templateResponseDetailForOtherRecordTypeList.length
) {
recordType = templateResponseDetailForOtherRecordTypeList[0].recType;

templateResponseDetailForOtherRecordTypeList.forEach((template) => {
detailObj = this.getStructuredObject(
this.recIdentUpdate(
recordMappingOtherRecordsResponseList,
template.templateRecordResponseList,
template.recType
),
template.recType
);
obj2 = {
recType: template.recType,
recTypeLabel: template.recTypeLabel,
detailRecordList: detailObj
};
udaData.push(obj2);
});
}

if (udaData && udaData.length > 0) {
this.props.setUDAData(udaData);
}
}

this.setState({
product: productSubProductList,
charEncodingFormatList: characterEncodingFormatList,
fileTypeOptions,
fieldSeparatorValuesList,
fieldWrapperValuesList,
headerRecordValueList,
transactionRecordValueList,
recordTypeList: fileRecordTypesList,
dateFormatList
});
};

recIdentUpdate = (
recordMappingOtherRecordsResponseList,
recIdent,
recType
) => {
let recValue = [];
recIdent.forEach((recIdentCheck) => {
recordMappingOtherRecordsResponseList.forEach((recItem) => {
if (recItem.recIdent && recItem.recType === recType) {
if (
parseInt(recItem.identPosition, 10) ===
recIdentCheck.fieldSequence &&
recIdentCheck.fieldName.includes('IDENTIFIER')
) {
return recValue.push({
...recIdentCheck,
fieldValueFromFile: recItem.recIdent
});
}
}
});
let found = false;
recValue.forEach((foundCheck) => {
if (foundCheck.fieldName === recIdentCheck.fieldName) {
found = true;
}
});
if (!found) {
return recValue.push(recIdentCheck);
}
});
return recValue;
};

getStructuredObject = (data, type) => {
const structuredRecordList = [];
let recordTypeLineNos = data.map((row) => row.recTypeLineNo);
recordTypeLineNos = recordTypeLineNos.filter(
(value, index, self) => self.indexOf(value) === index
);

const recordMappingArray = {
recordMappingConcatResponseList: 'recordMappingConcatRequestList',
recordMappingFormulaResponseList: 'recordMappingFormulaRequestList',
recordMappingDynamicOutputResponseList:
'recordMappingDynamicOutputRequestList',
recordMappingIfThenElseResponseList: 'recordMappingIfThenElseRequestList',
recordMappingSplitResponseList: 'recordMappingSplitRequestList',
recordMappingSubStringResponseList: 'recordMappingSubStringRequestList',
recordMappingTruncateResponseList: 'recordMappingTruncateRequestList',
dateOperation: 'dateOperation',
replaceStringResponse: 'replaceStringRequest',
startingPosition: 'startingPosition',
seqofoperations: 'seqofoperations',
base64Encode: 'base64Encode',
base64Decode: 'base64Decode',
swiftValidate: 'swiftValidate',
charEncodingConverter: 'charEncodingConverter',
prefixValue: 'prefixValue',
suffixValue: 'suffixValue'
};

for (let i = 0; i < recordTypeLineNos.length; i++) {
structuredRecordList[i] = [];
data.map((item) => {
if (recordTypeLineNos[i] === item.recTypeLineNo) {
const recordMappingInfoRequest = {};
if (item.recordMappingInfoResponse !== null) {
Object.keys(item.recordMappingInfoResponse).forEach(
(responseKey) => {
let removeTypeOfType =
item.recordMappingInfoResponse[responseKey];
if (
item.recordMappingInfoResponse[responseKey] &&
typeof item.recordMappingInfoResponse[responseKey] ===
'object' &&
item.recordMappingInfoResponse[responseKey].length
) {
removeTypeOfType = item.recordMappingInfoResponse[
responseKey
].map((mappingItem) => {
const { __typename, ...newitem } = mappingItem;
return newitem;
});
}

if (responseKey !== '__typename') {
recordMappingInfoRequest[
recordMappingArray[responseKey]
] = removeTypeOfType;
// item.recordMappingInfoResponse[responseKey];
}
}
);
}
structuredRecordList[i].push({
fieldName: item.fieldName,
recType: type,
recTypeLabel: item.recTypeLabel,
recTypeLineNo: item.recTypeLineNo,
fieldSequence: item.fieldSequence,
dataType: item.dataType,
fieldMaxLength: item.fieldMaxLength,
mandatory: item.mandatory,
length: item.length,
defaultValue: item.defaultValue,
dateFormat: item.dateFormat,
deleteFlag: item.deleteFlag,
fieldValueFromFile: item.fieldValueFromFile,
recordMappingInfoRequest
});
}
return true;
});
}
return structuredRecordList;
};

render() {
return (
<StepComponent
history={this.props.history}
isEditable
charEncodingList={this.state.charEncodingFormatList}
fileTypeOptions={this.state.fileTypeOptions}
fieldSeparatorListItems={this.state.fieldSeparatorValuesList}
fieldWrapperListItems={this.state.fieldWrapperValuesList}
headerTrailerListItems={this.state.headerRecordValueList}
transactionListItems={this.state.transactionRecordValueList}
productAndSubProductOptions={this.state.product}
recordTypeList={this.state.recordTypeList}
dateFormatList={this.state.dateFormatList}
stepIndex={this.state.stepIndex}
selectedProductType={this.state.selectedProductType}
selectedSubProductType={this.state.selectedSubProductType}
selectedFileType={this.state.selectedFileType}
templateId={this.state.templateId}
/>
);
}
}

EditTemplate.propTypes = {
history: PropTypes.shape({}),
/** location property of component */
location: PropTypes.shape({
/** holds the state of location */
state: PropTypes.shape({
/** holds the stepIndex of state */
stepIndex: PropTypes.number
})
}),
getStaticTemplateData: PropTypes.object,
getUDATempData: PropTypes.object,
setTemplateId: PropTypes.func,
setMasterData: PropTypes.func,
setOtherData: PropTypes.func,
setUDAData: PropTypes.func,
setAfterMapping: PropTypes.func,
setFieldsForRecordTypeList: PropTypes.func,
templateId: PropTypes.string,
editData: PropTypes.object
};

const mapStateToProps = (state) => ({
templateId: getAppPageParams(state),
editData: getMasterData(state)
});

const mapDispatchToProps = (dispatch) => ({
setUDAData: (udaData) => {
setUDADataAction(udaData, dispatch);
},
setMasterData: (masterData) => {
setMasterDataAction(masterData, dispatch);
},
setOtherData: (otherData) => {
setOtherDataAction(otherData, dispatch);
},
setTemplateId: (templateId) => {
setTemplateIdAction(templateId, dispatch);
},
setAfterMapping: (data) => {
setAfterMapping(data, dispatch);
},
setFieldsForRecordTypeList: (fieldsForRecordTypeList) => {
setFieldsForRecordTypeList(fieldsForRecordTypeList, dispatch);
}
});

const reduxWrapper = connect(
mapStateToProps,
mapDispatchToProps
);

export default compose(
reduxWrapper,
graphql(getStaticTemplateDataFromQuery, { name: 'getStaticTemplateData' }),
graphql(getUDATemplateDataQuery, {
name: 'getUDATempData',
options: (ownProps) => ({
fetchPolicy: 'network-only',
variables: {
getUDATemplateDataRequest: {
templateId: 'EFERE'
}
}
})
})
)(withApollo(EditTemplate));