evo/EvoCalculator
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

move apollo to client | fix convert ents to opts

Browse Source
This commit is contained in:
Владислав Чикалкин 2020-11-10 12:59:47 +03:00
parent 7a043aae3a
commit c6c31d1f3e
20 changed files with 166 additions and 847 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
package.json
View File

@ -21,6 +21,7 @@
"craco-less": "^1.17.0",
"cross-fetch": "^3.0.6",
"express": "^4.17.1",
"express-http-proxy": "^1.6.2",
"graphql": "^15.4.0",
"helmet": "^4.1.0",
"http-errors": "^1.8.0",
@ -54,12 +55,13 @@
"@types/cookie-parser": "^1.4.2",
"@types/cors": "^2.8.7",
"@types/express": "^4.17.7",
"@types/express-http-proxy": "^1.6.1",
"@types/faker": "^5.1.0",
"@types/jest": "^26.0.15",
"@types/lodash": "^4.14.159",
"@types/luxon": "^1.25.0",
"@types/morgan": "^1.9.1",
"@types/node": "^14.6.0",
"@types/node": "^14.14.6",
"@types/pluralize": "^0.0.29",
"@types/react-router-dom": "^5.1.5",
"@types/styled-components": "^5.1.2",

2
src/client/Containers/Calculation/index.jsx
View File

@ -19,7 +19,6 @@ const Calculation = () => {
Promise.all([
CalculationService.getEntities({
queries: initialOptions,
toOptions: true,
}),
CalculationService.getEntities({
queries: staticEntitiesList,
@ -34,7 +33,6 @@ const Calculation = () => {
many: true,
},
],
toOptions: true,
}),
])
.then(

1
src/client/common/constants.js Normal file
View File

@ -0,0 +1 @@
export const API_HOSTNAME = window.location.hostname;

105
src/client/services/CalculationService.ts
View File

@ -1,22 +1,111 @@
import axios from 'axios';
import CalculationStore from 'client/stores/CalculationStore';
import { ApolloClient, gql, HttpLink, InMemoryCache } from '@apollo/client';
import { API_HOSTNAME } from 'client/common/constants';
import { CRM_GRAPHQL_PROXY_URL, CRM_GRAPHQL_URL } from 'core/constants/urls';
import { convertEntityToOption } from 'core/tools/entities';
import { convertJSONToGQLQuery } from 'core/tools/query';
import { IGetEntitiesRequest } from 'core/types/Calculation/Requests';
import { IGetEntitiesResponse } from 'core/types/Calculation/Responses';
import { IBaseOption } from 'core/types/Calculation/Store/options';
import { TCRMEntity } from 'core/types/Entities/crmEntities';
import {
CRMEntityAliases,
TEntities,
CRMEntityNames,
} from 'core/types/Entities/crmEntityNames';
import { isPlural, singular } from 'pluralize';
const client = new ApolloClient({
uri: CRM_GRAPHQL_URL,
cache: new InMemoryCache(),
link: new HttpLink({
uri:
process.env.NODE_ENV !== 'development'
? String.prototype.concat('/proxy', CRM_GRAPHQL_PROXY_URL)
: String.prototype.concat(
`http://${API_HOSTNAME}:3001`,
'/proxy',
CRM_GRAPHQL_PROXY_URL,
),
fetch,
}),
defaultOptions: {
query: {
fetchPolicy: 'no-cache',
errorPolicy: 'all',
},
},
});
class CalculationService {
static getEntities = ({
queries,
toOptions,
}: IGetEntitiesRequest): Promise<IGetEntitiesResponse> =>
new Promise((resolve, reject) => {
axios
.post('/api/calculation/getCRMEntities', { queries, toOptions })
// remove queries with invalid where
queries = queries.filter(query => {
return Object.values(query.where).some(
x => x !== null && x !== undefined,
);
});
const convertedQuery = convertJSONToGQLQuery(queries);
client
.query({
query: gql`
${convertedQuery}
`,
})
.then(res => {
resolve(res.data);
const toOptions = queries
.filter(x => x.toOption)
.map(x => x.alias || x.entityName);
let resEntities: TEntities<TCRMEntity | TCRMEntity[]> = res.data;
Object.keys(resEntities).forEach(targetName => {
//@ts-ignore
const targetEnt: TCRMEntity | TCRMEntity[] =
//@ts-ignore
resEntities[targetName];
//@ts-ignore
if (toOptions.includes(targetName)) {
if (Array.isArray(targetEnt)) {
let optionatedEntities: (TCRMEntity & IBaseOption)[] = [];
for (let entity of targetEnt) {
const entityOption = convertEntityToOption(
entity,
entity.__typename,
);
if (entityOption) {
optionatedEntities.push(entityOption);
}
}
//@ts-ignore
resEntities[
//@ts-ignore
!CRMEntityAliases.includes(targetName) && isPlural(targetName)
? singular(targetName)
: targetName
] = optionatedEntities;
} else {
const entityOption = convertEntityToOption(
targetEnt,
targetEnt.__typename,
);
//@ts-ignore
resEntities[
//@ts-ignore
!CRMEntityAliases.includes(targetName) && isPlural(targetName)
? singular(targetName)
: targetName
] = entityOption;
}
}
});
resolve({ entities: resEntities });
})
.catch(err => {
CalculationStore.showModal(err);
// reject(err);
reject(err);
});
});
}

0
src/server/controllers/CalculationController/prepareData.ts → src/client/services/prepareData.ts
View File

11
src/client/stores/CalculationStore/Effects/reaction.ts
View File

@ -22,10 +22,6 @@ const reactionEffects: IReactionEffect[] = [
const lead = calculationStore.options.selectLead?.find(
x => x.leadid === leadId,
);
console.log(
'calculationStore.options.selectLead',
calculationStore.options.selectLead,
);
if (lead) {
CalculationService.getEntities({
@ -34,39 +30,44 @@ const reactionEffects: IReactionEffect[] = [
entityName: 'opportunity',
where: { opportunityid: lead.evo_opportunityid },
fields: ['opportunityid', 'name'],
toOption: true,
},
{
entityName: 'quote',
where: { evo_leadid: leadId },
fields: ['quoteid', 'name', 'quotenumber'],
many: true,
toOption: true,
},
{
alias: 'agent',
entityName: 'account',
where: { accountid: lead.evo_agent_accountid },
fields: ['accountid', 'name'],
toOption: true,
},
{
alias: 'double_agent',
entityName: 'account',
where: { accountid: lead.evo_double_agent_accountid },
fields: ['accountid', 'name'],
toOption: true,
},
{
alias: 'broker',
entityName: 'account',
where: { accountid: lead.evo_broker_accountid },
fields: ['accountid', 'name'],
toOption: true,
},
{
alias: 'findepartment',
entityName: 'account',
where: { accountid: lead.evo_fin_department_accountid },
fields: ['accountid', 'name'],
toOption: true,
},
],
toOptions: true,
}).then(({ entities }) => {
if (entities.opportunity && !Array.isArray(entities.opportunity)) {
calculationStore.setOptions('selectOpportunity', [

16
src/core/Data/initialOptions.ts
View File

@ -1,7 +1,7 @@
import { TEntityQuery } from 'core/types/Entities/query';
import { DateTime } from 'luxon';
const currentDate = DateTime.local().toUTC().toJSDate();
const currentDate = DateTime.local().toUTC().toJSDate().toDateString();
const initialOptions: TEntityQuery[] = [
{
@ -18,6 +18,7 @@ const initialOptions: TEntityQuery[] = [
],
where: { statecode: 0 },
many: true,
toOption: true,
},
{
alias: 'selectOpportunity',
@ -31,6 +32,7 @@ const initialOptions: TEntityQuery[] = [
],
where: { statecode: 0 },
many: true,
toOption: true,
},
{
alias: 'selectSupplier',
@ -42,6 +44,7 @@ const initialOptions: TEntityQuery[] = [
},
fields: ['accountid', 'name'],
many: true,
toOption: true,
},
{
alias: 'selectSupplierCurrency',
@ -51,6 +54,7 @@ const initialOptions: TEntityQuery[] = [
},
fields: ['transactioncurrencyid', 'isocurrencycode'],
many: true,
toOption: true,
},
{
alias: 'selectClientRisk',
@ -60,6 +64,7 @@ const initialOptions: TEntityQuery[] = [
},
fields: ['statecode', 'evo_name', 'evo_client_riskid'],
many: true,
toOption: true,
},
{
alias: 'selectClientType',
@ -69,6 +74,7 @@ const initialOptions: TEntityQuery[] = [
},
fields: ['evo_name', 'evo_client_typeid'],
many: true,
toOption: true,
},
{
alias: 'selectDealer',
@ -80,6 +86,7 @@ const initialOptions: TEntityQuery[] = [
},
fields: ['accountid', 'name'],
many: true,
toOption: true,
},
{
alias: 'selectGPSBrand',
@ -89,6 +96,7 @@ const initialOptions: TEntityQuery[] = [
},
fields: ['evo_gps_brandid', 'evo_name'],
many: true,
toOption: true,
},
{
alias: 'selectRegionRegistration',
@ -98,6 +106,7 @@ const initialOptions: TEntityQuery[] = [
},
fields: ['evo_name', 'evo_regionid'],
many: true,
toOption: true,
},
{
@ -109,6 +118,7 @@ const initialOptions: TEntityQuery[] = [
},
fields: ['accountid', 'name', 'evo_client_riskid'],
many: true,
toOption: true,
},
{
alias: 'selectBrand',
@ -123,6 +133,7 @@ const initialOptions: TEntityQuery[] = [
'evo_importer_reward_rub',
],
many: true,
toOption: true,
},
{
alias: 'selectProduct',
@ -153,6 +164,7 @@ const initialOptions: TEntityQuery[] = [
},
],
many: true,
toOption: true,
},
{
alias: 'selectRegistration',
@ -171,6 +183,7 @@ const initialOptions: TEntityQuery[] = [
},
fields: ['evo_addproduct_typeid', 'evo_name'],
many: true,
toOption: true,
},
{
alias: 'selectInsNSIB',
@ -189,6 +202,7 @@ const initialOptions: TEntityQuery[] = [
},
fields: ['evo_addproduct_typeid', 'evo_name'],
many: true,
toOption: true,
},
];

3
src/core/constants/urls.ts
View File

@ -1,2 +1,3 @@
export const API_PORT = 3001;
export const CRM_SERVICE_URL = 'http://crmgraphql-dev.evoleasing.ru';
export const CRM_GRAPHQL_URL = 'http://crmgraphql-dev.evoleasing.ru';
export const CRM_GRAPHQL_PROXY_URL = '/crmgraphql';

682
src/core/fakeData/entityFakes.ts
View File

@ -1,682 +0,0 @@
import { IOption } from 'core/types/Calculation/Store/options';
import { TEntities } from 'core/types/Entities/crmEntityNames';
import faker from 'faker';
/**
* Fake Consts
*/
const ACCOUNT_1_ID = faker.random.uuid();
const ACCOUNT_2_ID = faker.random.uuid();
const ACCOUNT_3_ID = faker.random.uuid();
const ACCOUNT_4_ID = faker.random.uuid();
const ACCOUNT_5_ID = faker.random.uuid();
const ACCOUNT_6_ID = faker.random.uuid();
const ACCOUNT_7_ID = faker.random.uuid();
const ACCOUNT_8_ID = faker.random.uuid();
const ACCOUNT_9_ID = faker.random.uuid();
const ACCOUNT_10_ID = faker.random.uuid();
const ACCOUNT_11_ID = faker.random.uuid();
const ACCOUNT_12_ID = faker.random.uuid();
const ACCOUNT_13_ID = faker.random.uuid();
const ACCOUNT_14_ID = faker.random.uuid();
const ACCOUNT_15_ID = faker.random.uuid();
const ACCOUNT_16_ID = faker.random.uuid();
const LEAD_1_ID = faker.random.uuid();
const LEAD_2_ID = faker.random.uuid();
const LEAD_3_ID = faker.random.uuid();
const OPPORTUNITY_1_ID = faker.random.uuid();
const OPPORTUNITY_2_ID = faker.random.uuid();
const OPPORTUNITY_3_ID = faker.random.uuid();
const QUOTE_1_ID = faker.random.uuid();
const QUOTE_2_ID = faker.random.uuid();
const QUOTE_3_ID = faker.random.uuid();
const QUOTE_4_ID = faker.random.uuid();
const TRANSACTION_CURRENTCY_1_ID = faker.random.uuid();
const TRANSACTION_CURRENTCY_2_ID = faker.random.uuid();
const TRANSACTION_CURRENTCY_3_ID = faker.random.uuid();
const EVO_CLIENT_1_ID = faker.random.uuid();
const EVO_CLIENT_2_ID = faker.random.uuid();
const EVO_CLIENT_RISK_1_ID = faker.random.uuid();
const EVO_CLIENT_RISK_2_ID = faker.random.uuid();
const GPS_BRAND_1_ID = faker.random.uuid();
const GPS_BRAND_2_ID = faker.random.uuid();
const GPS_BRAND_3_ID = faker.random.uuid();
const GPS_MODEL_1_ID = faker.random.uuid();
const GPS_MODEL_2_ID = faker.random.uuid();
const GPS_MODEL_3_ID = faker.random.uuid();
const GPS_MODEL_4_ID = faker.random.uuid();
const REGION_1_ID = faker.random.uuid();
const REGION_2_ID = faker.random.uuid();
const REGION_3_ID = faker.random.uuid();
const REGION_4_ID = faker.random.uuid();
const TOWN_1_ID = faker.random.uuid();
const TOWN_2_ID = faker.random.uuid();
const TOWN_3_ID = faker.random.uuid();
const TOWN_4_ID = faker.random.uuid();
const REWARD_CONDITION_1_ID = faker.random.uuid();
const REWARD_CONDITION_2_ID = faker.random.uuid();
const REWARD_CONDITION_3_ID = faker.random.uuid();
const REWARD_CONDITION_4_ID = faker.random.uuid();
const REWARD_CONDITION_5_ID = faker.random.uuid();
const REWARD_CONDITION_6_ID = faker.random.uuid();
const REWARD_CONDITION_7_ID = faker.random.uuid();
const REWARD_CONDITION_8_ID = faker.random.uuid();
const REWARD_CONDITION_9_ID = faker.random.uuid();
const REWARD_CONDITION_10_ID = faker.random.uuid();
const EVO_CONNECTION_ROLE_1_ID = faker.random.uuid();
const EVO_CONNECTION_ROLE_2_ID = faker.random.uuid();
const EVO_CONNECTION_ROLE_3_ID = faker.random.uuid();
const CONNECTION_1_ID = faker.random.uuid();
const CONNECTION_2_ID = faker.random.uuid();
const CONNECTION_3_ID = faker.random.uuid();
const CONNECTION_4_ID = faker.random.uuid();
const CONNECTION_5_ID = faker.random.uuid();
const CONNECTION_6_ID = faker.random.uuid();
const EVO_BRAND_ID = Array.from({ length: 10 }, () => faker.random.uuid());
const EVO_MODEL_ID = Array.from({ length: 10 }, () => faker.random.uuid());
const EVO_EQUIPMENT_ID = Array.from({ length: 10 }, () => faker.random.uuid());
const EVO_IMPAIRMENT_GROUP_ID = Array.from({ length: 10 }, () =>
faker.random.uuid(),
);
const EVO_CURRENCY_CHANGE_ID = Array.from({ length: 5 }, () =>
faker.random.uuid(),
);
const EVO_STATUSCODE_ID = Array.from({ length: 5 }, () => faker.random.uuid());
/**
* Fake Consts
*/
const entityFakeData: TEntities<IOption[]> = {
account: [
{
accountid: ACCOUNT_1_ID,
name: 'Салон 1',
evo_account_type: 100000001,
evo_supplier_type: 100000000,
statecode: 0,
evo_fin_department_accountid: ACCOUNT_4_ID,
evo_broker_accountid: ACCOUNT_11_ID,
},
{
accountid: ACCOUNT_2_ID,
name: 'Салон 2',
evo_account_type: 100000001,
evo_supplier_type: 100000000,
statecode: 0,
evo_fin_department_accountid: ACCOUNT_5_ID,
evo_broker_accountid: ACCOUNT_12_ID,
},
{
accountid: ACCOUNT_3_ID,
name: 'Салон 3',
evo_account_type: 100000001,
evo_supplier_type: 100000000,
statecode: 0,
// evo_broker_accountid: ACCOUNT_13_ID,
},
{
accountid: ACCOUNT_4_ID,
name: 'Брокер',
evo_account_type: 100000005,
evo_supplier_type: 100000000,
statecode: 0,
},
{
accountid: ACCOUNT_5_ID,
name: 'Финотдел2',
evo_account_type: 100000005,
evo_supplier_type: 100000000,
statecode: 0,
evo_client_riskid: EVO_CLIENT_RISK_1_ID,
},
{
accountid: ACCOUNT_6_ID,
name: 'Агент1',
evo_account_type: 100000005,
evo_legal_form: 100000004,
statecode: 0,
},
{
accountid: ACCOUNT_7_ID,
name: 'Агент2',
evo_account_type: 100000005,
evo_legal_form: 100000004,
statecode: 0,
},
{
accountid: ACCOUNT_8_ID,
name: 'Агент3',
evo_account_type: 100000005,
evo_legal_form: 100000004,
statecode: 0,
},
{
accountid: ACCOUNT_9_ID,
name: 'Агент4',
evo_account_type: 100000005,
evo_legal_form: 100000004,
statecode: 0,
},
{
accountid: ACCOUNT_10_ID,
name: 'Клиент 1',
evo_account_type: 100000000,
evo_client_riskid: EVO_CLIENT_RISK_2_ID,
statecode: 0,
},
{
name: 'ЮЛ поставщика 1',
accountid: ACCOUNT_11_ID,
evo_supplier_type: 100000001,
statecode: 0,
evo_broker_accountid: ACCOUNT_4_ID,
},
{
name: 'ЮЛ поставщика 2',
accountid: ACCOUNT_12_ID,
evo_supplier_type: 100000001,
statecode: 0,
},
{
name: 'ЮЛ поставщика 3',
accountid: ACCOUNT_13_ID,
evo_supplier_type: 100000001,
statecode: 0,
},
{
name: 'ВСК',
accountid: ACCOUNT_14_ID,
evo_account_type: 100000002,
statecode: 0,
},
{
name: 'РЕСО',
accountid: ACCOUNT_15_ID,
evo_account_type: 100000002,
statecode: 0,
},
{
name: 'Ингосстрах',
accountid: ACCOUNT_16_ID,
evo_account_type: 100000002,
statecode: 0,
},
],
transactioncurrency: [
{
transactioncurrencyid: TRANSACTION_CURRENTCY_1_ID,
isocurrencycode: 'RUB',
statecode: 0,
},
{
transactioncurrencyid: TRANSACTION_CURRENTCY_2_ID,
isocurrencycode: 'USD',
statecode: 0,
},
{
transactioncurrencyid: TRANSACTION_CURRENTCY_3_ID,
isocurrencycode: 'EUR',
statecode: 0,
},
],
evo_client_type: [
{
evo_client_typeid: EVO_CLIENT_1_ID,
evo_name: 'Новый',
statecode: 0,
},
{
evo_client_typeid: EVO_CLIENT_2_ID,
evo_name: 'Повторный',
statecode: 0,
},
],
evo_client_risk: [
{
evo_client_riskid: EVO_CLIENT_RISK_1_ID,
evo_name: 'Низкий',
statecode: 0,
},
{
evo_client_riskid: EVO_CLIENT_RISK_2_ID,
evo_name: 'Высокий',
statecode: 0,
},
],
lead: [
{
fullname: '100_ООО "с агентами ФЛ',
leadid: LEAD_1_ID,
evo_opportunityid: OPPORTUNITY_1_ID,
evo_agent_accountid: ACCOUNT_6_ID,
evo_double_agent_accountid: ACCOUNT_7_ID,
},
{
fullname: '150_ООО "с брокером',
leadid: LEAD_2_ID,
evo_opportunityid: OPPORTUNITY_2_ID,
evo_broker_accountid: ACCOUNT_4_ID,
},
{
fullname: '176_ООО "С финотделом',
leadid: LEAD_3_ID,
// evo_opportunityid: OPPORTUNITY_3_ID,
evo_fin_department_accountid: ACCOUNT_5_ID,
account: ACCOUNT_5_ID,
},
],
opportunity: [
{
name: '112345_ООО "с агентами ФЛ с риском',
opportunityid: OPPORTUNITY_1_ID,
evo_client_riskid: EVO_CLIENT_RISK_1_ID,
evo_leadid: LEAD_1_ID,
},
{
name: '145678_ООО "с брокером и риском в клиенте',
opportunityid: OPPORTUNITY_2_ID,
evo_accountid: ACCOUNT_10_ID,
// evo_client_riskid: EVO_CLIENT_RISK_2_ID,
evo_leadid: LEAD_2_ID,
},
{
name: '346343_ООО "с брокером и риском в интересе',
opportunityid: OPPORTUNITY_3_ID,
evo_accountid: ACCOUNT_9_ID,
evo_leadid: LEAD_3_ID,
},
],
quote: [
{
name: '2345_ООО "с агентами ФЛ"',
quoteid: QUOTE_1_ID,
evo_leadid: LEAD_1_ID,
evo_recalc_limit: 2,
evo_statuscodeid: EVO_STATUSCODE_ID[0],
evo_approved_first_payment: 25,
},
{
name: '6789_ООО "с брокером"',
quoteid: QUOTE_2_ID,
evo_leadid: LEAD_2_ID,
},
{
name: '4567_ООО "с агентами ФЛ"',
quoteid: QUOTE_3_ID,
evo_leadid: LEAD_1_ID,
evo_recalc_limit: 1,
evo_statuscodeid: EVO_STATUSCODE_ID[1],
},
{
name: '5678_ООО "с агентами ФЛ"',
quoteid: QUOTE_4_ID,
evo_leadid: LEAD_1_ID,
evo_broker_accountid: ACCOUNT_5_ID,
evo_recalc_limit: 0,
evo_statuscodeid: EVO_STATUSCODE_ID[0],
},
],
evo_gps_brand: [
{
evo_name: 'Цезарь',
evo_gps_brandid: GPS_BRAND_1_ID,
statecode: 0,
},
{
evo_name: 'Аркан',
evo_gps_brandid: GPS_BRAND_2_ID,
statecode: 0,
},
{
evo_name: 'КОбраКоннекс',
evo_gps_brandid: GPS_BRAND_3_ID,
statecode: 0,
},
],
evo_gps_model: [
{
evo_name: 'OmegaX',
evo_gps_modelid: GPS_MODEL_1_ID,
statecode: 0,
evo_gps_brandid: GPS_BRAND_1_ID,
},
{
evo_name: 'Platinum',
evo_gps_modelid: GPS_MODEL_2_ID,
statecode: 0,
evo_gps_brandid: GPS_BRAND_1_ID,
},
{
evo_name: 'Premium',
evo_gps_modelid: GPS_MODEL_3_ID,
statecode: 0,
evo_gps_brandid: GPS_BRAND_2_ID,
},
{
evo_name: 'AutoConnex',
evo_gps_modelid: GPS_MODEL_4_ID,
statecode: 0,
evo_gps_brandid: GPS_BRAND_2_ID,
},
],
evo_region: [
{
evo_name: 'Москвоская',
evo_regionid: REGION_1_ID,
statecode: 0,
},
{
evo_name: 'Калининградская',
evo_regionid: REGION_2_ID,
statecode: 0,
},
{
evo_name: 'Красноярская',
evo_regionid: REGION_3_ID,
statecode: 0,
},
{
evo_name: 'Иркутская',
evo_regionid: REGION_4_ID,
statecode: 0,
},
],
evo_town: [
{
evo_name: 'Одинцово',
evo_townid: TOWN_1_ID,
statecode: 0,
},
{
evo_name: 'Калининград',
evo_townid: TOWN_2_ID,
statecode: 0,
},
{
evo_name: 'Липецк',
evo_townid: TOWN_3_ID,
statecode: 0,
},
{
evo_name: 'Серпухов',
evo_townid: TOWN_4_ID,
statecode: 0,
},
],
evo_reward_condition: [
{
statecode: 0,
evo_agent_accountid: ACCOUNT_6_ID,
evo_reward_conditionid: REWARD_CONDITION_1_ID,
evo_name: '1.5%',
evo_reward_summ: 1.5,
evo_double_agent_accountid: ACCOUNT_7_ID,
},
{
statecode: 0,
evo_agent_accountid: ACCOUNT_6_ID,
evo_reward_conditionid: REWARD_CONDITION_2_ID,
evo_name: 'Не более 2%',
evo_reward_summ: 2,
evo_reduce_reward: true,
},
{
statecode: 0,
evo_agent_accountid: ACCOUNT_7_ID,
evo_reward_conditionid: REWARD_CONDITION_3_ID,
evo_name: '5%',
evo_reward_summ: 5,
},
{
statecode: 0,
evo_agent_accountid: ACCOUNT_7_ID,
evo_reward_conditionid: REWARD_CONDITION_4_ID,
evo_name: 'Не более 10%',
evo_reward_summ: 10,
evo_reduce_reward: true,
},
{
statecode: 0,
evo_agent_accountid: ACCOUNT_5_ID,
evo_reward_conditionid: REWARD_CONDITION_5_ID,
evo_name: '7%',
evo_reward_summ: 7,
},
{
statecode: 0,
evo_agent_accountid: ACCOUNT_5_ID,
evo_reward_conditionid: REWARD_CONDITION_6_ID,
evo_name: 'Не более 8%',
evo_reward_summ: 8,
evo_reduce_reward: true,
},
{
statecode: 0,
evo_agent_accountid: ACCOUNT_4_ID,
evo_reward_conditionid: REWARD_CONDITION_7_ID,
evo_name: '3%',
evo_reward_summ: 3,
},
{
statecode: 0,
evo_agent_accountid: ACCOUNT_4_ID,
evo_reward_conditionid: REWARD_CONDITION_8_ID,
evo_name: 'Не более 4%',
evo_reward_summ: 4,
evo_reduce_reward: true,
},
{
statecode: 0,
evo_agent_accountid: ACCOUNT_11_ID,
evo_reward_conditionid: REWARD_CONDITION_9_ID,
evo_name: '3%',
evo_reward_summ: 3,
},
{
statecode: 0,
evo_agent_accountid: ACCOUNT_11_ID,
evo_reward_conditionid: REWARD_CONDITION_10_ID,
evo_name: 'Не более 6%',
evo_reward_summ: 6,
evo_reduce_reward: true,
},
],
connection: [
{
connectionid: CONNECTION_1_ID,
record1id: ACCOUNT_1_ID,
record2roleid: EVO_CONNECTION_ROLE_1_ID,
record2id: ACCOUNT_11_ID,
statecode: 0,
},
{
connectionid: CONNECTION_2_ID,
record1id: ACCOUNT_12_ID,
record2roleid: EVO_CONNECTION_ROLE_2_ID,
record2id: ACCOUNT_1_ID,
statecode: 0,
},
{
connectionid: CONNECTION_3_ID,
record1id: ACCOUNT_2_ID,
record2roleid: EVO_CONNECTION_ROLE_1_ID,
record2id: ACCOUNT_13_ID,
statecode: 0,
},
// {
// connectionid: CONNECTION_4_ID,
// statecode: 0,
// },
// {
// connectionid: CONNECTION_5_ID,
// statecode: 0,
// },
// {
// connectionid: CONNECTION_6_ID,
// statecode: 0,
// },
],
evo_connection_role: [
{
evo_name: `ЮЛ Поставщика`,
statecode: 0,
evo_connection_roleid: EVO_CONNECTION_ROLE_1_ID,
},
{
evo_name: `Салон`,
statecode: 0,
evo_connection_roleid: EVO_CONNECTION_ROLE_2_ID,
},
{
evo_name: `Агент`,
statecode: 0,
evo_connection_roleid: EVO_CONNECTION_ROLE_3_ID,
},
],
evo_brand: [
{
evo_brandid: EVO_BRAND_ID[0],
evo_name: 'AUDI',
evo_importer_reward_perc: 2,
evo_importer_reward_rub: 5000,
statecode: 0,
},
{
evo_brandid: EVO_BRAND_ID[1],
evo_name: 'BMW',
statecode: 0,
},
],
evo_model: [
{
evo_modelid: EVO_MODEL_ID[0],
evo_name: 'A1',
evo_brandid: EVO_BRAND_ID[0],
statecode: 0,
},
{
evo_modelid: EVO_MODEL_ID[1],
evo_name: 'A5',
evo_brandid: EVO_BRAND_ID[0],
statecode: 0,
},
{
evo_modelid: EVO_MODEL_ID[2],
evo_name: 'Q7',
evo_importer_reward_perc: 5,
evo_importer_reward_rub: 10000,
evo_brandid: EVO_BRAND_ID[0],
statecode: 0,
},
{
evo_modelid: EVO_MODEL_ID[3],
evo_name: '320i',
evo_brandid: EVO_BRAND_ID[1],
statecode: 0,
},
{
evo_modelid: EVO_MODEL_ID[4],
evo_name: 'X1',
evo_brandid: EVO_BRAND_ID[1],
statecode: 0,
},
{
evo_modelid: EVO_MODEL_ID[5],
evo_name: 'X5',
evo_brandid: EVO_BRAND_ID[1],
statecode: 0,
evo_impairment_groupid: EVO_IMPAIRMENT_GROUP_ID[0],
evo_leasingobject_risk: 100000000,
},
],
evo_equipment: [
{
evo_equipmentid: EVO_EQUIPMENT_ID[0],
evo_modelid: EVO_MODEL_ID[2],
evo_name: 'Exclusive',
statecode: 0,
},
{
evo_equipmentid: EVO_EQUIPMENT_ID[1],
evo_modelid: EVO_MODEL_ID[2],
evo_name: 'Business',
statecode: 0,
},
{
evo_equipmentid: EVO_EQUIPMENT_ID[2],
evo_modelid: EVO_MODEL_ID[5],
evo_name: 'Super',
statecode: 0,
evo_impairment_groupid: EVO_IMPAIRMENT_GROUP_ID[1],
evo_leasingobject_risk: 100000001,
},
{
evo_equipmentid: EVO_EQUIPMENT_ID[3],
evo_modelid: EVO_MODEL_ID[5],
evo_name: 'Basic',
statecode: 0,
},
],
evo_impairment_group: [
{
evo_name: 'Группа #1',
evo_impairment_groupid: EVO_IMPAIRMENT_GROUP_ID[0],
statecode: 0,
},
{
evo_name: 'Группа #2',
evo_impairment_groupid: EVO_IMPAIRMENT_GROUP_ID[1],
statecode: 0,
},
],
evo_currencychange: [
{
evo_currencychangeid: EVO_CURRENCY_CHANGE_ID[0],
evo_name: 'Доллар на сегодня',
evo_ref_transactioncurrency: TRANSACTION_CURRENTCY_2_ID,
evo_currencychange: 100,
// evo_coursedate: new Date(),
statecode: 0,
},
{
evo_currencychangeid: EVO_CURRENCY_CHANGE_ID[1],
evo_name: 'Евро на сегодня',
evo_ref_transactioncurrency: TRANSACTION_CURRENTCY_3_ID,
evo_currencychange: 200,
// evo_coursedate: new Date(),
statecode: 0,
},
],
evo_statuscode: [
{
evo_statuscodeid: EVO_STATUSCODE_ID[0],
evo_id: '2.3',
evo_name: 'Положительное решение',
statecode: 0,
},
{
evo_statuscodeid: EVO_STATUSCODE_ID[1],
evo_id: '2.2',
evo_name: 'Одобрено клиентом',
statecode: 0,
},
],
};
export default entityFakeData;

6
src/core/tools/entities.ts
View File

@ -5,8 +5,12 @@ import { CRMEntityNames } from '../types/Entities/crmEntityNames';
export function convertEntityToOption(
entity: TCRMEntity,
entityName: CRMEntityNames,
entityName?: CRMEntityNames,
): (TCRMEntity & IBaseOption) | undefined {
if (!entityName) {
throw new Error('entityName is missing');
}
if (!entity || !propsMap || !propsMap[entityName]) {
throw new Error(`${entityName} not found in propsMap!`);
}

1
src/core/types/Calculation/Requests.ts
View File

@ -4,7 +4,6 @@ import { TValue, TValues } from './Store/values';
export interface IGetEntitiesRequest {
queries: TEntityQuery[];
toOptions?: boolean;
}
export interface IGetCalculationRequest {

1
src/core/types/Entities/query.ts
View File

@ -26,4 +26,5 @@ export type TBaseEntityQuery = {
export type TEntityQuery = TBaseEntityQuery & {
where: TWhere<any | any[]>;
whereCmp?: TWhere<ComparisonOperators>;
toOption?: boolean;
};

7
src/index.tsx
View File

@ -5,11 +5,10 @@ import App from './client/App';
import './index.css';
import * as serviceWorker from './client/serviceWorker';
import { API_PORT } from './core/constants/urls';
import { API_HOSTNAME } from 'client/common/constants';
const isDevelopmentMode = process.env.NODE_ENV === 'development';
if (isDevelopmentMode) {
axios.defaults.baseURL = `http://${window.location.hostname}:${API_PORT}`;
if (process.env.NODE_ENV === 'development') {
axios.defaults.baseURL = `http://${API_HOSTNAME}:${API_PORT}`;
}
ReactDOM.render(

18
src/server/controllers/CalculationController.ts Normal file
View File

@ -0,0 +1,18 @@
import { Response } from 'express';
import { IGetCalculationResponse } from '../../core/types/Calculation/Responses';
import { IGetCalculationRequest } from '../../core/types/Calculation/Requests';
class CalculationController {
static calculate = async (
req: { body: IGetCalculationRequest },
res: Response<IGetCalculationResponse>,
): Promise<void> => {
/**
* prepare Data
* send to core
* send to client
*/
};
}
export default CalculationController;

33
src/server/controllers/CalculationController/crmManager.test.ts
View File

@ -1,33 +0,0 @@
import { getEntities } from './crmManager';
test('getEntities', async () => {
const entities = await getEntities([
{
entityName: 'evo_baseproduct',
where: { statecode: 0, evo_account_type: [123123132] },
whereCmp: {
evo_datefrom: {
gte: new Date().toString(),
lte: 55,
},
},
fields: ['evo_id', 'evo_name'],
relatedEntities: [
{
entityName: 'evo_leasingobject_type',
fields: ['evo_id', 'evo_name'],
},
],
},
{
entityName: 'account',
where: {
accountid: 'fdf1db27-a0e3-ea11-af4b-00155d020202',
},
fields: ['accountid', 'name'],
},
]);
console.log(entities);
expect(entities).not.toBeUndefined();
});

33
src/server/controllers/CalculationController/crmManager.ts
View File

@ -1,33 +0,0 @@
import { ApolloClient, gql, HttpLink, InMemoryCache } from '@apollo/client';
import { TEntities } from 'core/types/Entities/crmEntityNames';
import fetch from 'cross-fetch';
import { CRM_SERVICE_URL } from '../../../core/constants/urls';
import { convertJSONToGQLQuery } from '../../../core/tools/query';
import { TEntityQuery } from '../../../core/types/Entities/query';
import { TCRMEntity } from '../../../core/types/Entities/crmEntities';
const client = new ApolloClient({
uri: CRM_SERVICE_URL,
cache: new InMemoryCache(),
link: new HttpLink({ uri: CRM_SERVICE_URL, fetch }),
});
export const getEntities = (
queries: TEntityQuery[],
): Promise<TEntities<TCRMEntity[] | TCRMEntity>> => {
const convertedQuery = convertJSONToGQLQuery(queries);
return client
.query({
query: gql`
${convertedQuery}
`,
})
.then(res => {
return res.data;
})
.catch(err => {
throw err;
});
// Convert
// Request to GQL
};

73
src/server/controllers/CalculationController/index.ts
View File

@ -1,73 +0,0 @@
import { TCRMEntity } from './../../../core/types/Entities/crmEntities';
import { IBaseOption } from 'core/types/Calculation/Store/options';
import { NextFunction, Request, Response } from 'express';
import { convertEntityToOption } from '../../../core/tools/entities';
import {
IGetCalculationResponse,
IGetEntitiesResponse,
} from '../../../core/types/Calculation/Responses';
import {
IGetCalculationRequest,
IGetEntitiesRequest,
} from './../../../core/types/Calculation/Requests';
import {
CRMEntityNames,
TEntities,
CRMEntityAliases,
} from '../../../core/types/Entities/crmEntityNames';
import { getEntities } from './crmManager';
import { singular, isPlural } from 'pluralize';
class CalculationController {
static getCRMEntities = async (
req: Request,
res: Response,
next: NextFunction,
): Promise<any> => {
let { queries, toOptions } = req.body as IGetEntitiesRequest;
queries = queries.filter(query => {
return Object.values(query.where).some(
x => x !== null && x !== undefined,
);
});
let resEntities = await getEntities(queries);
if (toOptions) {
let entitiesWithOptions: TEntities<TCRMEntity & IBaseOption> = {};
Object.keys(resEntities).forEach(name => {
const targetEntities: TCRMEntity[] = resEntities[name];
let optionatedOptions = [];
for (let entity of targetEntities) {
optionatedOptions.push(
//@ts-ignore
//TODO
convertEntityToOption(entity, entity.__typename),
);
}
entitiesWithOptions[
//@ts-ignore
!CRMEntityAliases.includes(name) && isPlural(name)
? singular(name)
: name
] = optionatedOptions;
});
res.send({ entities: entitiesWithOptions });
return;
}
res.send({ entities: resEntities });
};
static calculate = async (
req: { body: IGetCalculationRequest },
res: Response<IGetCalculationResponse>,
): Promise<void> => {
/**
* prepare Data
* send to core
* send to client
*/
};
}
export default CalculationController;

3
src/server/routes/calculation.ts
View File

@ -1,9 +1,8 @@
import CalculationController from '../controllers/CalculationController';
import { Router } from 'express';
import CalculationController from '../controllers/CalculationController';
const router = Router();
router.post('/getCRMEntities', CalculationController.getCRMEntities);
router.post('/calculate', CalculationController.calculate);
export default router;

2
src/server/routes/index.ts
View File

@ -2,11 +2,13 @@ import { Router } from 'express';
import values from './values';
import users from './users';
import calculation from './calculation';
import proxy from './proxy';
const routes = Router();
routes.use('/api/values', values);
routes.use('/api/users', users);
routes.use('/api/calculation', calculation);
routes.use('/proxy', proxy);
export default routes;

12
src/server/routes/proxy.ts Normal file
View File

@ -0,0 +1,12 @@
import { Router } from 'express';
import proxy from 'express-http-proxy';
import {
CRM_GRAPHQL_PROXY_URL,
CRM_GRAPHQL_URL,
} from '../../core/constants/urls';
const router = Router();
router.use(CRM_GRAPHQL_PROXY_URL, proxy(CRM_GRAPHQL_URL));
export default router;