micord/ervu-secret
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

make right dir name

Browse source
This commit is contained in:
kochetkov 2024-09-25 08:57:25 +03:00
parent 36ace281ec
commit d109deed13
33 changed files with 140 additions and 130 deletions
Download patch file Download diff file Expand all files Collapse all files

38
config-data-executor/.gitignore vendored Normal file
View file

@ -0,0 +1,38 @@
target/
!.mvn/wrapper/maven-wrapper.jar
!**/src/main/**/target/
!**/src/test/**/target/
### IntelliJ IDEA ###
.idea/modules.xml
.idea/jarRepositories.xml
.idea/compiler.xml
.idea/libraries/
*.iws
*.iml
*.ipr
### Eclipse ###
.apt_generated
.classpath
.factorypath
.project
.settings
.springBeans
.sts4-cache
### NetBeans ###
/nbproject/private/
/nbbuild/
/dist/
/nbdist/
/.nb-gradle/
build/
!**/src/main/**/build/
!**/src/test/**/build/
### VS Code ###
.vscode/
### Mac OS ###
.DS_Store

4
config-data-executor/Dockerfile Normal file
View file

@ -0,0 +1,4 @@
FROM bellsoft/liberica-openjdk-alpine:17-cds
COPY target/*.jar app.jar
CMD ["java", "-jar", "app.jar"]

96
config-data-executor/config-examples/arangorequest.xml Normal file
View file

@ -0,0 +1,96 @@
<Requests>
<AqlRequest>
<RequestArgument>
<Id>edges</Id>
<AqlCollectionReads>
<AqlCollectionRead>applications</AqlCollectionRead>
<AqlCollectionRead>subject</AqlCollectionRead>
<AqlCollectionRead>history</AqlCollectionRead>
<AqlCollectionRead>edges</AqlCollectionRead>
</AqlCollectionReads>
</RequestArgument>
<AqlConnectionParams>
<Host>localhost</Host>
<Port>8529</Port>
<Username>userAQL1</Username>
<Password>passwordAQL1</Password>
<Database>databaseAQL1</Database>
</AqlConnectionParams>
</AqlRequest>
<AqlRequest>
<RequestArgument>
<Id>applications</Id>
<AqlCollectionReads>
<AqlCollectionRead>applications</AqlCollectionRead>
<AqlCollectionRead>subject</AqlCollectionRead>
<AqlCollectionRead>history</AqlCollectionRead>
<AqlCollectionRead>edges</AqlCollectionRead>
</AqlCollectionReads>
</RequestArgument>
<AqlConnectionParams>
<Host>localhost</Host>
<Port>8529</Port>
<Username>userAQL1</Username>
<Password>passwordAQL1</Password>
<Database>databaseAQL1</Database>
</AqlConnectionParams>
</AqlRequest>
<AqlRequest>
<RequestArgument>
<Id>subject</Id>
<AqlCollectionReads>
<AqlCollectionRead>applications</AqlCollectionRead>
<AqlCollectionRead>subject</AqlCollectionRead>
<AqlCollectionRead>history</AqlCollectionRead>
<AqlCollectionRead>edges</AqlCollectionRead>
</AqlCollectionReads>
</RequestArgument>
<AqlConnectionParams>
<Host>localhost</Host>
<Port>8529</Port>
<Username>userAQL1</Username>
<Password>passwordAQL1</Password>
<Database>databaseAQL1</Database>
</AqlConnectionParams>
</AqlRequest>
<AqlRequest>
<RequestArgument>
<Id>history</Id>
<AqlCollectionReads>
<AqlCollectionRead>applications</AqlCollectionRead>
<AqlCollectionRead>subject</AqlCollectionRead>
<AqlCollectionRead>history</AqlCollectionRead>
<AqlCollectionRead>edges</AqlCollectionRead>
</AqlCollectionReads>
</RequestArgument>
<AqlConnectionParams>
<Host>localhost</Host>
<Port>8529</Port>
<Username>userAQL1</Username>
<Password>passwordAQL1</Password>
<Database>databaseAQL1</Database>
</AqlConnectionParams>
</AqlRequest>
<AqlRequest>
<RequestArgument>
<Id>interdepreq</Id>
<AqlCollectionReads>
<AqlCollectionRead>applications</AqlCollectionRead>
<AqlCollectionRead>subject</AqlCollectionRead>
<AqlCollectionRead>history</AqlCollectionRead>
<AqlCollectionRead>edges</AqlCollectionRead>
</AqlCollectionReads>
</RequestArgument>
<AqlConnectionParams>
<Host>localhost</Host>
<Port>8529</Port>
<Username>userAQL1</Username>
<Password>passwordAQL1</Password>
<Database>databaseAQL1</Database>
</AqlConnectionParams>
</AqlRequest>
</Requests>

163
config-data-executor/config-examples/block.xml Normal file
View file

@ -0,0 +1,163 @@
<Requests>
<SqlRequest>
<RequestURL>
<![CDATA[
DO
$$
begin
update recruits
set current_recruitment_id = 'ИДЕНТИФИКАТОР ТЕСТОВОГО ВК'
,target_recruitment_id = 'ИДЕНТИФИКАТОР ТЕСТОВОГО ВК'
,department_id_old = 'ИДЕНТИФИКАТОР ТЕСТОВОГО ВК'
,system_pgs_status = '13'
,extra_info = jsonb_set(coalesce(extra_info,'{}'::jsonb), '{blocked}',
('{"cur":'|| coalesce('"'||current_recruitment_id::text||'"','null')||
',"trg":'|| coalesce('"'||target_recruitment_id::text||'"','null')||
',"dio":'|| coalesce('"'||department_id_old::text||'"','null')||
',"st":'|| coalesce('"'||system_pgs_status::text||'"','null')||'}')::jsonb
)
where id in ${endpointArguments} ${extraConditions};
end
$$;
]]>
</RequestURL>
<SqlConnectionParams>
<JdbcHost>localhost</JdbcHost>
<JdbcPort>5432</JdbcPort>
<JdbcUsername>sqlUser</JdbcUsername>
<JdbcPassword>sqlPassword</JdbcPassword>
<JdbcDriverClassName>org.postgresql.Driver</JdbcDriverClassName>
<JdbcXaDataSourceClassName>org.postgresql.xa.PGXADataSource</JdbcXaDataSourceClassName>
<JdbcXaDataSourcePoolSize>15</JdbcXaDataSourcePoolSize>
<JdbcDatabase>mainDatabase</JdbcDatabase>
</SqlConnectionParams>
</SqlRequest>
<SqlRequest>
<RequestURL>
<![CDATA[
DO
$$
BEGIN
DELETE FROM subpoena_history where subpoena_id in (select id FROM subpoena where recruit_id in ${endpointArguments} ${extraConditions};
DELETE FROM subpoena_appearance where subpoena_id in (select id FROM subpoena where recruit_id in ${endpointArguments} ${extraConditions}));
DELETE FROM subpoena_send_info where subpoena_id in (select id FROM subpoena where recruit_id in ${endpointArguments} ${extraConditions}));
DELETE FROM notification_item where restriction_document_item_id in (
select id from restriction_document_item where restriction_document_create_id in (
select id FROM restriction_document where subpoena_id in (select id FROM subpoena where recruit_id in ${endpointArguments} ${extraConditions}))));
DELETE FROM notification_item where restriction_document_item_id in (
select id from restriction_document_item where restriction_document_cancel_id in (
select id FROM restriction_document where subpoena_id in (select id FROM subpoena where recruit_id in ${endpointArguments} ${extraConditions}))));
DELETE FROM restriction_document_item where restriction_document_create_id in (
select id FROM restriction_document where subpoena_id in (select id FROM subpoena where recruit_id in ${endpointArguments} ${extraConditions})));
DELETE FROM restriction_document_item where restriction_document_cancel_id in (
select id FROM restriction_document where subpoena_id in (select id FROM subpoena where recruit_id in ${endpointArguments} ${extraConditions})));
DELETE FROM restriction_document where subpoena_id in (select id FROM subpoena where recruit_id in ${endpointArguments} ${extraConditions}));
DELETE FROM subpoena where recruit_id in ${endpointArguments} ${extraConditions};
END
$$;
]]>
</RequestURL>
<SqlConnectionParams>
<JdbcHost>localhost</JdbcHost>
<JdbcPort>5432</JdbcPort>
<JdbcUsername>sqlUser</JdbcUsername>
<JdbcPassword>sqlPassword</JdbcPassword>
<JdbcDriverClassName>org.postgresql.Driver</JdbcDriverClassName>
<JdbcXaDataSourceClassName>org.postgresql.xa.PGXADataSource</JdbcXaDataSourceClassName>
<JdbcXaDataSourcePoolSize>15</JdbcXaDataSourcePoolSize>
<JdbcDatabase>mainDatabase</JdbcDatabase>
</SqlConnectionParams>
</SqlRequest>
<SqlRequest>
<RequestURL>
<![CDATA[
DO
$$
BEGIN
DELETE
FROM incident_history
where incident_id in (select id from incident where recruit_id in ${endpointArguments} ${extraConditions}));
DELETE FROM incident where recruit_id in ${endpointArguments} ${extraConditions};
END
$$;
]]>
</RequestURL>
<SqlConnectionParams>
<JdbcHost>localhost</JdbcHost>
<JdbcPort>5432</JdbcPort>
<JdbcUsername>sqlUser</JdbcUsername>
<JdbcPassword>sqlPassword</JdbcPassword>
<JdbcDriverClassName>org.postgresql.Driver</JdbcDriverClassName>
<JdbcXaDataSourceClassName>org.postgresql.xa.PGXADataSource</JdbcXaDataSourceClassName>
<JdbcXaDataSourcePoolSize>15</JdbcXaDataSourcePoolSize>
<JdbcDatabase>mainDatabase</JdbcDatabase>
</SqlConnectionParams>
</SqlRequest>
<SqlRequest>
<RequestURL>
<![CDATA[
DO
$$
BEGIN
DELETE FROM notifications where recruit_id in ${endpointArguments} ${extraConditions};
END
$$;
]]>
</RequestURL>
<SqlConnectionParams>
<JdbcHost>localhost</JdbcHost>
<JdbcPort>5432</JdbcPort>
<JdbcUsername>sqlUser</JdbcUsername>
<JdbcPassword>sqlPassword</JdbcPassword>
<JdbcDriverClassName>org.postgresql.Driver</JdbcDriverClassName>
<JdbcXaDataSourceClassName>org.postgresql.xa.PGXADataSource</JdbcXaDataSourceClassName>
<JdbcXaDataSourcePoolSize>15</JdbcXaDataSourcePoolSize>
<JdbcDatabase>mainDatabase</JdbcDatabase>
</SqlConnectionParams>
</SqlRequest>
<SqlRequest>
<RequestURL>
<![CDATA[
DO
$$
DECLARE
recruitIds uuid[] := '{${endpointArguments}}';
importIds uuid[] := ARRAY(SELECT import_id
FROM import_results
WHERE recruit_id = ANY (recruitIds));
BEGIN
WITH ImportDeletes AS (DELETE FROM import_journal_start WHERE import_id = ANY (importIds) RETURNING journal_id)
DELETE
FROM journal
WHERE id IN (SELECT journal_id FROM ImportDeletes);
DELETE FROM import_journal_finish WHERE import_id = ANY (importIds);
DELETE FROM import_events_journal WHERE import_id = ANY (importIds);
DELETE FROM import_validation_errors WHERE import_id = ANY (importIds);
DELETE FROM import_results WHERE import_id = ANY (importIds);
DELETE FROM uploaded_files WHERE extra_info ->> 'importId' = ANY (importIds::text[]);
DELETE FROM object_history WHERE object_id = ANY (recruitIds);
DELETE FROM object_versions WHERE object_id = ANY (recruitIds);
END
$$;
]]>
</RequestURL>
<SqlConnectionParams>
<JdbcHost>localhost</JdbcHost>
<JdbcPort>5432</JdbcPort>
<JdbcUsername>sqlUser</JdbcUsername>
<JdbcPassword>sqlPassword</JdbcPassword>
<JdbcDriverClassName>org.postgresql.Driver</JdbcDriverClassName>
<JdbcXaDataSourceClassName>org.postgresql.xa.PGXADataSource</JdbcXaDataSourceClassName>
<JdbcXaDataSourcePoolSize>15</JdbcXaDataSourcePoolSize>
<JdbcDatabase>mainDatabase</JdbcDatabase>
</SqlConnectionParams>
</SqlRequest>
</Requests>

87
config-data-executor/config-examples/removeFromCallList.xml Normal file
View file

@ -0,0 +1,87 @@
<Requests>
<SqlRequest>
<RequestURL>DELETE FROM summoned_list where recruit_id in ${endpointArguments} ${extraConditions}</RequestURL>
<SqlConnectionParams>
<JdbcHost>10.10.31.118</JdbcHost>
<JdbcPort>5432</JdbcPort>
<JdbcUsername>ervu</JdbcUsername>
<JdbcPassword>ervu</JdbcPassword>
<JdbcDriverClassName>org.postgresql.Driver</JdbcDriverClassName>
<JdbcXaDataSourceClassName>org.postgresql.xa.PGXADataSource</JdbcXaDataSourceClassName>
<JdbcXaDataSourcePoolSize>15</JdbcXaDataSourcePoolSize>
<JdbcDatabase>summon-list-registry</JdbcDatabase>
</SqlConnectionParams>
</SqlRequest>
<SqlRequest>
<RequestURL>DELETE FROM documents where recruit_id in ${endpointArguments} ${extraConditions}</RequestURL>
<SqlConnectionParams>
<JdbcHost>10.10.31.118</JdbcHost>
<JdbcPort>5432</JdbcPort>
<JdbcUsername>ervu</JdbcUsername>
<JdbcPassword>ervu</JdbcPassword>
<JdbcDriverClassName>org.postgresql.Driver</JdbcDriverClassName>
<JdbcXaDataSourceClassName>org.postgresql.xa.PGXADataSource</JdbcXaDataSourceClassName>
<JdbcXaDataSourcePoolSize>15</JdbcXaDataSourcePoolSize>
<JdbcDatabase>summon-list-registry</JdbcDatabase>
</SqlConnectionParams>
</SqlRequest>
<SqlRequest>
<RequestURL>DELETE FROM subpoena where recruit_id in ${endpointArguments} ${extraConditions}</RequestURL>
<SqlConnectionParams>
<JdbcHost>10.10.31.118</JdbcHost>
<JdbcPort>5432</JdbcPort>
<JdbcUsername>ervu</JdbcUsername>
<JdbcPassword>ervu</JdbcPassword>
<JdbcDriverClassName>org.postgresql.Driver</JdbcDriverClassName>
<JdbcXaDataSourceClassName>org.postgresql.xa.PGXADataSource</JdbcXaDataSourceClassName>
<JdbcXaDataSourcePoolSize>15</JdbcXaDataSourcePoolSize>
<JdbcDatabase>summon-list-registry</JdbcDatabase>
</SqlConnectionParams>
</SqlRequest>
<SqlRequest>
<RequestURL>DELETE FROM recruit_active_list where recruit_id in ${endpointArguments} ${extraConditions}</RequestURL>
<SqlConnectionParams>
<JdbcHost>10.10.31.118</JdbcHost>
<JdbcPort>5432</JdbcPort>
<JdbcUsername>ervu</JdbcUsername>
<JdbcPassword>ervu</JdbcPassword>
<JdbcDriverClassName>org.postgresql.Driver</JdbcDriverClassName>
<JdbcXaDataSourceClassName>org.postgresql.xa.PGXADataSource</JdbcXaDataSourceClassName>
<JdbcXaDataSourcePoolSize>15</JdbcXaDataSourcePoolSize>
<JdbcDatabase>summon-list-registry</JdbcDatabase>
</SqlConnectionParams>
</SqlRequest>
<SqlRequest>
<RequestURL>
<![CDATA[
DO
$$
begin
update recruits
set current_recruitment_id = jsonb_extract_path_text(extra_info,'blocked','cur')::uuid
,target_recruitment_id = jsonb_extract_path_text(extra_info,'blocked','trg')::uuid
,department_id_old = jsonb_extract_path_text(extra_info,'blocked','dio')::uuid
,system_pgs_status = '1.2'
,conscription = null
,extra_info = extra_info - ('blocked')
where id in ${endpointArguments} ${extraConditions};
end
$$;
]]>
</RequestURL>
<SqlConnectionParams>
<JdbcHost>10.10.31.118</JdbcHost>
<JdbcPort>5432</JdbcPort>
<JdbcUsername>ervu</JdbcUsername>
<JdbcPassword>ervu</JdbcPassword>
<JdbcDriverClassName>org.postgresql.Driver</JdbcDriverClassName>
<JdbcXaDataSourceClassName>org.postgresql.xa.PGXADataSource</JdbcXaDataSourceClassName>
<JdbcXaDataSourcePoolSize>15</JdbcXaDataSourcePoolSize>
<JdbcDatabase>person_registry</JdbcDatabase>
</SqlConnectionParams>
</SqlRequest>
</Requests>

381
config-data-executor/config-examples/removeFromSystem.xml Normal file
View file

@ -0,0 +1,381 @@
<Requests>
<SqlRequest>
<RequestURL>
<![CDATA[
DO
$$
BEGIN
DELETE FROM subpoena_history where subpoena_id in (select id FROM subpoena where recruit_id in ${endpointArguments} ${extraConditions});
DELETE FROM subpoena_appearance where subpoena_id in (select id FROM subpoena where recruit_id in ${endpointArguments} ${extraConditions});
DELETE FROM subpoena_send_info where subpoena_id in (select id FROM subpoena where recruit_id in ${endpointArguments} ${extraConditions});
DELETE FROM notification_item where restriction_document_item_id in (
select id from restriction_document_item where restriction_document_create_id in (
select id FROM restriction_document where subpoena_id in (select id FROM subpoena where recruit_id in ${endpointArguments} ${extraConditions})));
DELETE FROM notification_item where restriction_document_item_id in (
select id from restriction_document_item where restriction_document_cancel_id in (
select id FROM restriction_document where subpoena_id in (select id FROM subpoena where recruit_id in ${endpointArguments} ${extraConditions})));
DELETE FROM restriction_document_item_history WHERE recruit_id in ${endpointArguments} ${extraConditions};
DELETE FROM restriction_document_item where restriction_document_create_id in (
select id FROM restriction_document where subpoena_id in (select id FROM subpoena where recruit_id in ${endpointArguments} ${extraConditions}));
DELETE FROM restriction_document_item where restriction_document_cancel_id in (
select id FROM restriction_document where subpoena_id in (select id FROM subpoena where recruit_id in ${endpointArguments} ${extraConditions}));
DELETE FROM restriction_document where subpoena_id in (select id FROM subpoena where recruit_id in ${endpointArguments} ${extraConditions});
DELETE FROM subpoena where recruit_id in ${endpointArguments} ${extraConditions};
END
$$;
]]>
</RequestURL>
<SqlConnectionParams>
<JdbcHost>localhost</JdbcHost>
<JdbcPort>5432</JdbcPort>
<JdbcUsername>sqlUser</JdbcUsername>
<JdbcPassword>sqlPassword</JdbcPassword>
<JdbcDriverClassName>org.postgresql.Driver</JdbcDriverClassName>
<JdbcXaDataSourceClassName>org.postgresql.xa.PGXADataSource</JdbcXaDataSourceClassName>
<JdbcXaDataSourcePoolSize>15</JdbcXaDataSourcePoolSize>
<JdbcDatabase>mainDatabase</JdbcDatabase>
</SqlConnectionParams>
</SqlRequest>
<!-- last sql from 002_2-ervu_subpoena_registry_delete_all_with_recruit -->
<SqlRequest>
<RequestURL>
<![CDATA[
DO
$$
BEGIN
DELETE FROM recruits WHERE id in ${endpointArguments} ${extraConditions};
END
$$;
]]>
</RequestURL>
<SqlConnectionParams>
<JdbcHost>localhost</JdbcHost>
<JdbcPort>5432</JdbcPort>
<JdbcUsername>sqlUser</JdbcUsername>
<JdbcPassword>sqlPassword</JdbcPassword>
<JdbcDriverClassName>org.postgresql.Driver</JdbcDriverClassName>
<JdbcXaDataSourceClassName>org.postgresql.xa.PGXADataSource</JdbcXaDataSourceClassName>
<JdbcXaDataSourcePoolSize>15</JdbcXaDataSourcePoolSize>
<JdbcDatabase>mainDatabase</JdbcDatabase>
</SqlConnectionParams>
</SqlRequest>
<SqlRequest>
<RequestURL>
<![CDATA[
DO
$$
BEGIN
DELETE FROM decision where recruit_id in ${endpointArguments} ${extraConditions};
DELETE FROM foreign_decision where recruit_id in ${endpointArguments} ${extraConditions};
DELETE FROM infringement where recruit_id in ${endpointArguments} ${extraConditions};
DELETE FROM system_document where attachment_id in (SELECT id FROM attachment where recruit_id in ${endpointArguments} ${extraConditions}) ;
DELETE FROM attachment where recruit_id in ${endpointArguments} ${extraConditions};
END
$$;
]]>
</RequestURL>
<SqlConnectionParams>
<JdbcHost>localhost</JdbcHost>
<JdbcPort>5432</JdbcPort>
<JdbcUsername>sqlUser</JdbcUsername>
<JdbcPassword>sqlPassword</JdbcPassword>
<JdbcDriverClassName>org.postgresql.Driver</JdbcDriverClassName>
<JdbcXaDataSourceClassName>org.postgresql.xa.PGXADataSource</JdbcXaDataSourceClassName>
<JdbcXaDataSourcePoolSize>15</JdbcXaDataSourcePoolSize>
<JdbcDatabase>mainDatabase</JdbcDatabase>
</SqlConnectionParams>
</SqlRequest>
<!-- last sql from 005-ervu_decision_document-delete-recruit -->
<SqlRequest>
<RequestURL>
<![CDATA[
DO
$$
BEGIN
DELETE FROM recruit where id in ${endpointArguments} ${extraConditions};
END
$$;
]]>
</RequestURL>
<SqlConnectionParams>
<JdbcHost>localhost</JdbcHost>
<JdbcPort>5432</JdbcPort>
<JdbcUsername>sqlUser</JdbcUsername>
<JdbcPassword>sqlPassword</JdbcPassword>
<JdbcDriverClassName>org.postgresql.Driver</JdbcDriverClassName>
<JdbcXaDataSourceClassName>org.postgresql.xa.PGXADataSource</JdbcXaDataSourceClassName>
<JdbcXaDataSourcePoolSize>15</JdbcXaDataSourcePoolSize>
<JdbcDatabase>mainDatabase</JdbcDatabase>
</SqlConnectionParams>
</SqlRequest>
<SqlRequest>
<RequestURL>
<![CDATA[
DO
$$
DECLARE
recruitIds uuid[] := '{${endpointArguments}}';
importIds uuid[] := ARRAY(SELECT import_id
FROM import_results
WHERE recruit_id = ANY (recruitIds));
BEGIN
WITH ImportDeletes AS (DELETE FROM import_journal_start WHERE import_id = ANY (importIds) RETURNING journal_id)
DELETE
FROM journal
WHERE id IN (SELECT journal_id FROM ImportDeletes);
DELETE FROM import_journal_finish WHERE import_id = ANY (importIds);
DELETE FROM import_events_journal WHERE import_id = ANY (importIds);
DELETE FROM import_validation_errors WHERE import_id = ANY (importIds);
DELETE FROM import_results WHERE import_id = ANY (importIds);
DELETE FROM uploaded_files WHERE extra_info ->> 'importId' = ANY (importIds::text[]);
DELETE FROM object_history WHERE object_id = ANY (recruitIds);
DELETE FROM object_versions WHERE object_id = ANY (recruitIds);
END
$$;
]]>
</RequestURL>
<SqlConnectionParams>
<JdbcHost>localhost</JdbcHost>
<JdbcPort>5432</JdbcPort>
<JdbcUsername>sqlUser</JdbcUsername>
<JdbcPassword>sqlPassword</JdbcPassword>
<JdbcDriverClassName>org.postgresql.Driver</JdbcDriverClassName>
<JdbcXaDataSourceClassName>org.postgresql.xa.PGXADataSource</JdbcXaDataSourceClassName>
<JdbcXaDataSourcePoolSize>15</JdbcXaDataSourcePoolSize>
<JdbcDatabase>mainDatabase</JdbcDatabase>
</SqlConnectionParams>
</SqlRequest>
<SqlRequest>
<RequestURL>
<![CDATA[
DO
$$
BEGIN
DELETE FROM notifications where recruit_id in ${endpointArguments} ${extraConditions};
END
$$;
]]>
</RequestURL>
<SqlConnectionParams>
<JdbcHost>localhost</JdbcHost>
<JdbcPort>5432</JdbcPort>
<JdbcUsername>sqlUser</JdbcUsername>
<JdbcPassword>sqlPassword</JdbcPassword>
<JdbcDriverClassName>org.postgresql.Driver</JdbcDriverClassName>
<JdbcXaDataSourceClassName>org.postgresql.xa.PGXADataSource</JdbcXaDataSourceClassName>
<JdbcXaDataSourcePoolSize>15</JdbcXaDataSourcePoolSize>
<JdbcDatabase>mainDatabase</JdbcDatabase>
</SqlConnectionParams>
</SqlRequest>
<SqlRequest>
<RequestURL>
<![CDATA[
DO
$$
BEGIN
DELETE
FROM incident_history
where incident_id in (select id from incident where recruit_id in ${endpointArguments} ${extraConditions});
DELETE FROM incident where recruit_id in ${endpointArguments} ${extraConditions};
END
$$;
]]>
</RequestURL>
<SqlConnectionParams>
<JdbcHost>localhost</JdbcHost>
<JdbcPort>5432</JdbcPort>
<JdbcUsername>sqlUser</JdbcUsername>
<JdbcPassword>sqlPassword</JdbcPassword>
<JdbcDriverClassName>org.postgresql.Driver</JdbcDriverClassName>
<JdbcXaDataSourceClassName>org.postgresql.xa.PGXADataSource</JdbcXaDataSourceClassName>
<JdbcXaDataSourcePoolSize>15</JdbcXaDataSourcePoolSize>
<JdbcDatabase>mainDatabase</JdbcDatabase>
</SqlConnectionParams>
</SqlRequest>
<!-- last sql from 007_2-ervu_incidents-delete-all_of_recruit -->
<SqlRequest>
<RequestURL>
<![CDATA[
DO
$$
BEGIN
DELETE FROM recruits where id in ${endpointArguments} ${extraConditions};
END
$$;
]]>
</RequestURL>
<SqlConnectionParams>
<JdbcHost>localhost</JdbcHost>
<JdbcPort>5432</JdbcPort>
<JdbcUsername>sqlUser</JdbcUsername>
<JdbcPassword>sqlPassword</JdbcPassword>
<JdbcDriverClassName>org.postgresql.Driver</JdbcDriverClassName>
<JdbcXaDataSourceClassName>org.postgresql.xa.PGXADataSource</JdbcXaDataSourceClassName>
<JdbcXaDataSourcePoolSize>15</JdbcXaDataSourcePoolSize>
<JdbcDatabase>mainDatabase</JdbcDatabase>
</SqlConnectionParams>
</SqlRequest>
<SqlRequest>
<RequestURL>
<![CDATA[
DO
$$
BEGIN
DELETE FROM recruits_info where recruit_id in ${endpointArguments} ${extraConditions};
DELETE FROM recruit_xml_data where recruit_id in ${endpointArguments} ${extraConditions};
DELETE FROM recruits_history where recruit_id in ${endpointArguments} ${extraConditions};
DELETE FROM application where recruit_id in ${endpointArguments} ${extraConditions};
DELETE FROM department_history where recruit_id in ${endpointArguments} ${extraConditions};
DELETE FROM documents where recruit_id in ${endpointArguments} ${extraConditions};
DELETE FROM decision where recruit_id in ${endpointArguments} ${extraConditions};
DELETE FROM personal_documents where recruit_id in ${endpointArguments} ${extraConditions};
DELETE FROM recruit_private_file where recruit_id in ${endpointArguments} ${extraConditions};
DELETE FROM system_documents where recruit_id in ${endpointArguments} ${extraConditions};
DELETE FROM system_document_dto where recruit_id in ${endpointArguments} ${extraConditions};
DELETE FROM subpoena_dto where recruit_id in ${endpointArguments} ${extraConditions};
DELETE FROM attachments where recruit_id in ${endpointArguments} ${extraConditions};
DELETE FROM summoned_list where recruit_id in ${endpointArguments} ${extraConditions};
END
$$;
]]>
</RequestURL>
<SqlConnectionParams>
<JdbcHost>localhost</JdbcHost>
<JdbcPort>5432</JdbcPort>
<JdbcUsername>sqlUser</JdbcUsername>
<JdbcPassword>sqlPassword</JdbcPassword>
<JdbcDriverClassName>org.postgresql.Driver</JdbcDriverClassName>
<JdbcXaDataSourceClassName>org.postgresql.xa.PGXADataSource</JdbcXaDataSourceClassName>
<JdbcXaDataSourcePoolSize>15</JdbcXaDataSourcePoolSize>
<JdbcDatabase>mainDatabase</JdbcDatabase>
</SqlConnectionParams>
</SqlRequest>
<!-- last sql from 001-ervu_person_registry-delete-recruit -->
<SqlRequest>
<RequestURL>
<![CDATA[
DO
$$
BEGIN
DELETE FROM recruits where id in ${endpointArguments} ${extraConditions};
END
$$;
]]>
</RequestURL>
<SqlConnectionParams>
<JdbcHost>localhost</JdbcHost>
<JdbcPort>5432</JdbcPort>
<JdbcUsername>sqlUser</JdbcUsername>
<JdbcPassword>sqlPassword</JdbcPassword>
<JdbcDriverClassName>org.postgresql.Driver</JdbcDriverClassName>
<JdbcXaDataSourceClassName>org.postgresql.xa.PGXADataSource</JdbcXaDataSourceClassName>
<JdbcXaDataSourcePoolSize>15</JdbcXaDataSourcePoolSize>
<JdbcDatabase>mainDatabase</JdbcDatabase>
</SqlConnectionParams>
</SqlRequest>
<SqlRequest>
<RequestURL>
<![CDATA[
DO
$$
BEGIN
DELETE FROM appeal_document where recruit_id in ${endpointArguments} ${extraConditions};
END
$$;
]]>
</RequestURL>
<SqlConnectionParams>
<JdbcHost>localhost</JdbcHost>
<JdbcPort>5432</JdbcPort>
<JdbcUsername>sqlUser</JdbcUsername>
<JdbcPassword>sqlPassword</JdbcPassword>
<JdbcDriverClassName>org.postgresql.Driver</JdbcDriverClassName>
<JdbcXaDataSourceClassName>org.postgresql.xa.PGXADataSource</JdbcXaDataSourceClassName>
<JdbcXaDataSourcePoolSize>15</JdbcXaDataSourcePoolSize>
<JdbcDatabase>mainDatabase</JdbcDatabase>
</SqlConnectionParams>
</SqlRequest>
<!-- last sql from 009_1-ervu_appeal_document-delete-appeal-with-recruit -->
<SqlRequest>
<RequestURL>
<![CDATA[
DO
$$
BEGIN
DELETE FROM recruit where id in ${endpointArguments} ${extraConditions};
END
$$;
]]>
</RequestURL>
<SqlConnectionParams>
<JdbcHost>localhost</JdbcHost>
<JdbcPort>5432</JdbcPort>
<JdbcUsername>sqlUser</JdbcUsername>
<JdbcPassword>sqlPassword</JdbcPassword>
<JdbcDriverClassName>org.postgresql.Driver</JdbcDriverClassName>
<JdbcXaDataSourceClassName>org.postgresql.xa.PGXADataSource</JdbcXaDataSourceClassName>
<JdbcXaDataSourcePoolSize>15</JdbcXaDataSourcePoolSize>
<JdbcDatabase>mainDatabase</JdbcDatabase>
</SqlConnectionParams>
</SqlRequest>
<SqlRequest>
<RequestURL>
<![CDATA[
DO
$$
BEGIN
delete from cruit_extract where recruit_id in ${endpointArguments} ${extraConditions};
END
$$;
]]>
</RequestURL>
<SqlConnectionParams>
<JdbcHost>localhost</JdbcHost>
<JdbcPort>5432</JdbcPort>
<JdbcUsername>sqlUser</JdbcUsername>
<JdbcPassword>sqlPassword</JdbcPassword>
<JdbcDriverClassName>org.postgresql.Driver</JdbcDriverClassName>
<JdbcXaDataSourceClassName>org.postgresql.xa.PGXADataSource</JdbcXaDataSourceClassName>
<JdbcXaDataSourcePoolSize>15</JdbcXaDataSourcePoolSize>
<JdbcDatabase>mainDatabase</JdbcDatabase>
</SqlConnectionParams>
</SqlRequest>
<SqlRequest>
<RequestURL>
<![CDATA[
DO
$$
BEGIN
delete from application_info where recruit_id in ${endpointArguments} ${extraConditions};
END
$$;
]]>
</RequestURL>
<SqlConnectionParams>
<JdbcHost>localhost</JdbcHost>
<JdbcPort>5432</JdbcPort>
<JdbcUsername>sqlUser</JdbcUsername>
<JdbcPassword>sqlPassword</JdbcPassword>
<JdbcDriverClassName>org.postgresql.Driver</JdbcDriverClassName>
<JdbcXaDataSourceClassName>org.postgresql.xa.PGXADataSource</JdbcXaDataSourceClassName>
<JdbcXaDataSourcePoolSize>15</JdbcXaDataSourcePoolSize>
<JdbcDatabase>mainDatabase</JdbcDatabase>
</SqlConnectionParams>
</SqlRequest>
</Requests>

13
config-data-executor/config-examples/s3request.xml Normal file
View file

@ -0,0 +1,13 @@
<Requests>
<S3Request>
<S3ConnectionParams>
<S3Key>minioadmin</S3Key>
<S3Secret>minioadmin</S3Secret>
<Host>127.0.0.1</Host>
<Port>9000</Port>
<ContentType>application/octet-stream</ContentType>
<Method>DELETE</Method>
<Body></Body>
</S3ConnectionParams>
</S3Request>
</Requests>

32
config-data-executor/config-examples/unblock.xml Normal file
View file

@ -0,0 +1,32 @@
<Requests>
<SqlRequest>
<RequestURL>
<![CDATA[
DO
$$
begin
update recruits
set current_recruitment_id = jsonb_extract_path_text(extra_info,'blocked','cur')::uuid
,target_recruitment_id = jsonb_extract_path_text(extra_info,'blocked','trg')::uuid
,department_id_old = jsonb_extract_path_text(extra_info,'blocked','dio')::uuid
,system_pgs_status = '1.2'
,conscription = null
,extra_info = extra_info - ('blocked')
where id in ${endpointArguments} ${extraConditions};
end
$$;
]]>
</RequestURL>
<SqlConnectionParams>
<JdbcHost>localhost</JdbcHost>
<JdbcPort>5432</JdbcPort>
<JdbcUsername>sqlUser</JdbcUsername>
<JdbcPassword>sqlPassword</JdbcPassword>
<JdbcDriverClassName>org.postgresql.Driver</JdbcDriverClassName>
<JdbcXaDataSourceClassName>org.postgresql.xa.PGXADataSource</JdbcXaDataSourceClassName>
<JdbcXaDataSourcePoolSize>15</JdbcXaDataSourcePoolSize>
<JdbcDatabase>mainDatabase</JdbcDatabase>
</SqlConnectionParams>
</SqlRequest>
</Requests>

132
config-data-executor/pom.xml Normal file
View file

@ -0,0 +1,132 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.micord</groupId>
<artifactId>config-data-executor</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>war</packaging>
<properties>
<maven.compiler.source>17</maven.compiler.source>
<maven.compiler.target>17</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>com.amazonaws</groupId>
<artifactId>aws-java-sdk-bom</artifactId>
<version>1.12.770</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-framework-bom</artifactId>
<version>6.1.12</version>
<scope>import</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>3.3.3</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<exclusions>
<exclusion>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
</dependency>
<dependency>
<groupId>com.atomikos</groupId>
<artifactId>transactions-jta</artifactId>
<version>6.0.0</version>
<classifier>jakarta</classifier>
</dependency>
<dependency>
<groupId>com.atomikos</groupId>
<artifactId>transactions-jdbc</artifactId>
<version>6.0.0</version>
<classifier>jakarta</classifier>
</dependency>
<dependency>
<groupId>jakarta.transaction</groupId>
<artifactId>jakarta.transaction-api</artifactId>
</dependency>
<dependency>
<groupId>org.postgresql</groupId>
<artifactId>postgresql</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<scope>provided</scope>
<version>1.18.34</version>
</dependency>
<dependency>
<groupId>javax.xml.bind</groupId>
<artifactId>jaxb-api</artifactId>
<version>2.3.1</version>
</dependency>
<dependency>
<groupId>org.glassfish.jaxb</groupId>
<artifactId>jaxb-runtime</artifactId>
<version>2.3.1</version>
</dependency>
<dependency>
<groupId>com.arangodb</groupId>
<artifactId>arangodb-java-driver</artifactId>
<version>7.7.1</version>
</dependency>
<dependency>
<groupId>com.amazonaws</groupId>
<artifactId>aws-java-sdk-s3</artifactId>
</dependency>
</dependencies>
<repositories>
<repository>
<id>maven_central</id>
<name>Maven Central</name>
<url>https://repo.maven.apache.org/maven2/</url>
</repository>
</repositories>
<build>
<finalName>${artifactId}</finalName>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<version>3.3.3</version>
<configuration>
<mainClass>org.micord.Main</mainClass>
</configuration>
<executions>
<execution>
<goals>
<goal>repackage</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>

15
config-data-executor/src/main/java/org/micord/Main.java Normal file
View file

@ -0,0 +1,15 @@
package org.micord;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
/**
* @author Maksim Tereshin
*/
@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})
public class Main {
public static void main(String[] args) {
SpringApplication.run(Main.class, args);
}
}

8
config-data-executor/src/main/java/org/micord/SpringBootTomcatApplication.java Normal file
View file

@ -0,0 +1,8 @@
package org.micord;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
@SpringBootApplication
public class SpringBootTomcatApplication extends SpringBootServletInitializer {
}

34
config-data-executor/src/main/java/org/micord/config/ArangoDBConnection.java Normal file
View file

@ -0,0 +1,34 @@
package org.micord.config;
import com.arangodb.ArangoDB;
import com.arangodb.ArangoDBException;
import com.arangodb.ArangoDatabase;
import org.micord.models.AqlConnectionParams;
/**
* @author Maksim Tereshin
*/
public class ArangoDBConnection {
public static ArangoDatabase getConnection(AqlConnectionParams params) {
try {
ArangoDB arangoDB = new ArangoDB.Builder()
.host(params.getHost(), params.getPort())
.user(params.getUsername())
.password(params.getPassword())
.build();
ArangoDatabase db = arangoDB.db(params.getDatabase());
if (!db.exists()) {
throw new ArangoDBException("Database does not exist: " + params.getDatabase());
}
return db;
} catch (ArangoDBException e) {
throw new RuntimeException("Failed to connect to ArangoDB", e);
}
}
}

39
config-data-executor/src/main/java/org/micord/config/AtomikosConfig.java Normal file
View file

@ -0,0 +1,39 @@
package org.micord.config;
import com.atomikos.icatch.jta.UserTransactionImp;
import com.atomikos.icatch.jta.UserTransactionManager;
import jakarta.transaction.TransactionManager;
import jakarta.transaction.UserTransaction;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import org.springframework.transaction.jta.JtaTransactionManager;
/**
* @author Maksim Tereshin
*/
@Configuration
@EnableTransactionManagement
public class AtomikosConfig {
@Bean
public UserTransaction userTransaction() throws Throwable {
UserTransactionImp userTransactionImp = new UserTransactionImp();
userTransactionImp.setTransactionTimeout(300);
return userTransactionImp;
}
@Bean
public TransactionManager atomikosTransactionManager() throws Throwable {
UserTransactionManager userTransactionManager = new UserTransactionManager();
userTransactionManager.setForceShutdown(true);
return userTransactionManager;
}
@Bean
public JtaTransactionManager transactionManager() throws Throwable {
return new JtaTransactionManager(userTransaction(), atomikosTransactionManager());
}
}

63
config-data-executor/src/main/java/org/micord/config/DatabaseConnection.java Normal file
View file

@ -0,0 +1,63 @@
package org.micord.config;
import com.atomikos.jdbc.AtomikosDataSourceBean;
import org.micord.models.SqlConnectionParams;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
/**
* @author Maksim Tereshin
*/
public class DatabaseConnection {
private static final Map<String, DataSource> dataSources = new HashMap<>();
public static Connection getConnection(SqlConnectionParams params) throws SQLException {
try {
Class.forName(params.getJdbcDriverClassName());
} catch (ClassNotFoundException e) {
throw new SQLException("Unable to load the JDBC driver class", e);
}
return getXaDataSource(params).getConnection();
}
public static DataSource getXaDataSource(SqlConnectionParams params) {
String database = params.getJdbcDatabase();
if (!dataSources.containsKey(database)) {
AtomikosDataSourceBean xaDataSource = new AtomikosDataSourceBean();
xaDataSource.setUniqueResourceName("jdbcDatasource_" + database);
xaDataSource.setXaDataSourceClassName(params.getJdbcXaDataSourceClassName());
xaDataSource.setPoolSize(Integer.parseInt(params.getJdbcXaDataSourcePoolSize()));
Properties xaProperties = loadDatabaseProperties(params);
xaDataSource.setXaProperties(xaProperties);
dataSources.put(database, xaDataSource);
}
return dataSources.get(database);
}
private static Properties loadDatabaseProperties(SqlConnectionParams params) {
Properties xaProperties = new Properties();
try {
xaProperties.setProperty("user", params.getJdbcUsername());
xaProperties.setProperty("password", params.getJdbcPassword());
xaProperties.setProperty("serverName", params.getJdbcHost());
xaProperties.setProperty("portNumber", String.valueOf(params.getJdbcPort()));
xaProperties.setProperty("databaseName", params.getJdbcDatabase());
} catch (Exception e) {
throw new RuntimeException("Failed to load database properties", e);
}
return xaProperties;
}
}

19
config-data-executor/src/main/java/org/micord/config/HttpClientConfig.java Normal file
View file

@ -0,0 +1,19 @@
package org.micord.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.net.http.HttpClient;
/**
* @author Maksim Tereshin
*/
@Configuration
public class HttpClientConfig {
@Bean
public HttpClient httpClient() {
return HttpClient.newHttpClient();
}
}

77
config-data-executor/src/main/java/org/micord/config/S3HttpConnection.java Normal file
View file

@ -0,0 +1,77 @@
package org.micord.config;
import org.micord.models.S3ConnectionParams;
import org.micord.models.S3Request;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.net.URI;
import java.net.http.HttpRequest;
import java.nio.charset.StandardCharsets;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Base64;
/**
* @author Maksim Tereshin
*/
public class S3HttpConnection {
public static HttpRequest buildHttpRequest(S3Request request, String file) throws Exception {
S3ConnectionParams connectionParams = request.getS3ConnectionParams();
String host = connectionParams.getHost() + ":" + connectionParams.getPort();
String s3Key = connectionParams.getS3Key();
String s3Secret = connectionParams.getS3Secret();
String method = connectionParams.getMethod().toUpperCase();
String body = connectionParams.getBody();
String resource = "/" + file;
String contentType = connectionParams.getContentType();
String date = ZonedDateTime.now().format(DateTimeFormatter.RFC_1123_DATE_TIME);
String signature = generateSignature(method, contentType, date, resource, s3Secret);
HttpRequest.Builder requestBuilder = HttpRequest.newBuilder()
.uri(URI.create("https://" + host + resource))
.header("Host", host)
.header("Date", date)
.header("Content-Type", contentType)
.header("Authorization", "AWS " + s3Key + ":" + signature);
switch (method) {
case "DELETE":
requestBuilder.DELETE();
break;
case "GET":
requestBuilder.GET();
break;
case "PUT":
requestBuilder.PUT(HttpRequest.BodyPublishers.ofString(body != null ? body : ""));
break;
case "POST":
requestBuilder.POST(HttpRequest.BodyPublishers.ofString(body != null ? body : ""));
break;
default:
throw new IllegalArgumentException("Unsupported HTTP method: " + method);
}
return requestBuilder.build();
}
private static String generateSignature(String method, String contentType, String date, String resource, String s3Secret) throws Exception {
String stringToSign = method + "\n" +
"\n" + // MD5 - not used for DELETE requests
contentType + "\n" +
date + "\n" +
resource;
Mac mac = Mac.getInstance("HmacSHA1");
SecretKeySpec secretKey = new SecretKeySpec(s3Secret.getBytes(StandardCharsets.UTF_8), "HmacSHA1");
mac.init(secretKey);
byte[] hash = mac.doFinal(stringToSign.getBytes(StandardCharsets.UTF_8));
return Base64.getEncoder().encodeToString(hash);
}
}

51
config-data-executor/src/main/java/org/micord/controller/ApiController.java Normal file
View file

@ -0,0 +1,51 @@
package org.micord.controller;
import java.io.FileNotFoundException;
import java.util.List;
import org.micord.service.ApiService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* REST Controller for API operations.
*/
@RestController
@RequestMapping("/api")
public class ApiController {
@Autowired
private ApiService apiService;
@PostMapping("/block")
public ResponseEntity<?> block(@RequestBody List<String> ids) throws FileNotFoundException {
apiService.process("block", ids);
return ResponseEntity.ok("");
}
@PostMapping("/unblock")
public ResponseEntity<?> unblock(@RequestBody List<String> ids) throws FileNotFoundException {
apiService.process("unblock", ids);
return ResponseEntity.ok("");
}
@PostMapping("/removeFromSystem")
public ResponseEntity<?> removeFromSystem(@RequestBody List<String> ids)
throws FileNotFoundException {
apiService.process("removeFromSystem", ids);
return ResponseEntity.ok("");
}
@PostMapping("/removeFromCallList")
public ResponseEntity<?> removeFromCallList(@RequestBody List<String> ids)
throws FileNotFoundException {
apiService.process("removeFromCallList", ids);
return ResponseEntity.ok("");
}
}

50
config-data-executor/src/main/java/org/micord/models/AqlConnectionParams.java Normal file
View file

@ -0,0 +1,50 @@
package org.micord.models;
import lombok.Setter;
import javax.xml.bind.annotation.XmlElement;
/**
* @author Maksim Tereshin
*/
@Setter
public class AqlConnectionParams {
private String host;
private int port;
private String username;
private String password;
private String database;
private String collection;
@XmlElement(name = "Host")
public String getHost() {
return host;
}
@XmlElement(name = "Port")
public int getPort() {
return port;
}
@XmlElement(name = "Username")
public String getUsername() {
return username;
}
@XmlElement(name = "Password")
public String getPassword() {
return password;
}
@XmlElement(name = "Database")
public String getDatabase() {
return database;
}
@XmlElement(name = "Collection")
public String getCollection() {
return collection;
}
}

20
config-data-executor/src/main/java/org/micord/models/AqlRequest.java Normal file
View file

@ -0,0 +1,20 @@
package org.micord.models;
import lombok.Setter;
import javax.xml.bind.annotation.XmlElement;
/**
* @author Maksim Tereshin
*/
@Setter
public class AqlRequest extends Request {
private AqlConnectionParams aqlConnectionParams;
@XmlElement(name = "AqlConnectionParams")
public AqlConnectionParams getAqlConnectionParams() {
return aqlConnectionParams;
}
}

21
config-data-executor/src/main/java/org/micord/models/CachedConfig.java Normal file
View file

@ -0,0 +1,21 @@
package org.micord.models;
import java.nio.file.attribute.FileTime;
public class CachedConfig {
private final Requests config;
private final FileTime modifiedTime;
public CachedConfig(Requests config, FileTime modifiedTime) {
this.config = config;
this.modifiedTime = modifiedTime;
}
public Requests getConfig() {
return config;
}
public FileTime getModifiedTime() {
return modifiedTime;
}
}

29
config-data-executor/src/main/java/org/micord/models/Request.java Normal file
View file

@ -0,0 +1,29 @@
package org.micord.models;
import lombok.Setter;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlSeeAlso;
import java.util.List;
/**
* @author Maksim Tereshin
*/
@Setter
@XmlSeeAlso({SqlRequest.class, S3Request.class})
public abstract class Request {
private List<RequestArgument> requestArguments;
private String requestURL;
@XmlElement(name = "RequestArgument")
public List<RequestArgument> getRequestArguments() {
return requestArguments;
}
@XmlElement(name = "RequestURL")
public String getRequestURL() {
return requestURL;
}
}

43
config-data-executor/src/main/java/org/micord/models/RequestArgument.java Normal file
View file

@ -0,0 +1,43 @@
package org.micord.models;
import lombok.Setter;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlElementWrapper;
import javax.xml.bind.annotation.XmlRootElement;
import java.util.List;
/**
* @author Maksim Tereshin
*/
@Setter
@XmlRootElement(name = "RequestArgument")
public class RequestArgument {
private String id;
private List<String> aqlCollectionRead;
private String requestURL;
private SqlConnectionParams sqlConnectionParams;
@XmlElement(name = "SqlConnectionParams")
public SqlConnectionParams getSqlConnectionParams() {
return sqlConnectionParams;
}
@XmlElement(name = "Id")
public String getId() {
return id;
}
@XmlElementWrapper(name = "AqlCollectionReads")
@XmlElement(name = "AqlCollectionRead")
public List<String> getAqlCollectionRead() {
return aqlCollectionRead;
}
@XmlElement(name = "RequestURL")
public String getRequestURL() {
return requestURL;
}
}

35
config-data-executor/src/main/java/org/micord/models/Requests.java Normal file
View file

@ -0,0 +1,35 @@
package org.micord.models;
import lombok.Setter;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import java.util.List;
/**
* @author Maksim Tereshin
*/
@Setter
@XmlRootElement(name = "Requests")
public class Requests {
private List<SqlRequest> sqlRequests;
private List<AqlRequest> aqlRequests;
private List<S3Request> s3Requests;
@XmlElement(name = "SqlRequest")
public List<SqlRequest> getSqlRequests() {
return sqlRequests;
}
@XmlElement(name = "AqlRequest")
public List<AqlRequest> getAqlRequests() {
return aqlRequests;
}
@XmlElement(name = "S3Request")
public List<S3Request> getS3Requests() {
return s3Requests;
}
}

56
config-data-executor/src/main/java/org/micord/models/S3ConnectionParams.java Normal file
View file

@ -0,0 +1,56 @@
package org.micord.models;
import lombok.Setter;
import javax.xml.bind.annotation.XmlElement;
/**
* @author Maksim Tereshin
*/
@Setter
public class S3ConnectionParams {
private String s3Key;
private String s3Secret;
private String host;
private String port;
private String contentType;
private String method;
private String body;
@XmlElement(name = "S3Key")
public String getS3Key() {
return s3Key;
}
@XmlElement(name = "S3Secret")
public String getS3Secret() {
return s3Secret;
}
@XmlElement(name = "Host")
public String getHost() {
return host;
}
@XmlElement(name = "Port")
public String getPort() {
return port;
}
@XmlElement(name = "ContentType")
public String getContentType() {
return contentType;
}
@XmlElement(name = "Method")
public String getMethod() {
return method;
}
@XmlElement(name = "Body")
public String getBody() {
return body;
}
}

20
config-data-executor/src/main/java/org/micord/models/S3Request.java Normal file
View file

@ -0,0 +1,20 @@
package org.micord.models;
import lombok.Setter;
import javax.xml.bind.annotation.XmlElement;
/**
* @author Maksim Tereshin
*/
@Setter
public class S3Request extends Request {
private S3ConnectionParams s3ConnectionParams;
@XmlElement(name = "S3ConnectionParams")
public S3ConnectionParams getS3ConnectionParams() {
return s3ConnectionParams;
}
}

59
config-data-executor/src/main/java/org/micord/models/SqlConnectionParams.java Normal file
View file

@ -0,0 +1,59 @@
package org.micord.models;
import lombok.Setter;
import javax.xml.bind.annotation.XmlElement;
@Setter
public class SqlConnectionParams {
private String jdbcHost;
private String jdbcPort;
private String jdbcUsername;
private String jdbcPassword;
private String jdbcDriverClassName;
private String jdbcXaDataSourceClassName;
private String jdbcXaDataSourcePoolSize;
private String jdbcDatabase;
@XmlElement(name = "JdbcXaDataSourcePoolSize")
public String getJdbcXaDataSourcePoolSize() {
return jdbcXaDataSourcePoolSize;
}
@XmlElement(name = "JdbcHost")
public String getJdbcHost() {
return jdbcHost;
}
@XmlElement(name = "JdbcPort")
public String getJdbcPort() {
return jdbcPort;
}
@XmlElement(name = "JdbcUsername")
public String getJdbcUsername() {
return jdbcUsername;
}
@XmlElement(name = "JdbcPassword")
public String getJdbcPassword() {
return jdbcPassword;
}
@XmlElement(name = "JdbcDriverClassName")
public String getJdbcDriverClassName() {
return jdbcDriverClassName;
}
@XmlElement(name = "JdbcXaDataSourceClassName")
public String getJdbcXaDataSourceClassName() {
return jdbcXaDataSourceClassName;
}
@XmlElement(name = "JdbcDatabase")
public String getJdbcDatabase() {
return jdbcDatabase;
}
}

20
config-data-executor/src/main/java/org/micord/models/SqlRequest.java Normal file
View file

@ -0,0 +1,20 @@
package org.micord.models;
import lombok.Setter;
import javax.xml.bind.annotation.XmlElement;
/**
* @author Maksim Tereshin
*/
@Setter
public class SqlRequest extends Request {
private SqlConnectionParams sqlConnectionParams;
@XmlElement(name = "SqlConnectionParams")
public SqlConnectionParams getSqlConnectionParams() {
return sqlConnectionParams;
}
}

29
config-data-executor/src/main/java/org/micord/service/ApiService.java Normal file
View file

@ -0,0 +1,29 @@
package org.micord.service;
import org.micord.models.*;
import org.micord.utils.ConfigLoader;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.io.FileNotFoundException;
import java.util.*;
@Service
public class ApiService {
@Autowired
private ConfigLoader configLoader;
@Autowired
private RequestService sqlAndAqlService;
public void process(String methodName, List<String> ids) throws FileNotFoundException {
Optional<Requests> optionalConfig = configLoader.loadConfigIfModified(methodName);
if (optionalConfig.isEmpty()) {
throw new FileNotFoundException("Configuration for method " + methodName + " could not be loaded.");
}
Requests config = optionalConfig.get();
sqlAndAqlService.processSqlAndAqlRequests(config, ids);
}
}

310
config-data-executor/src/main/java/org/micord/service/RequestService.java Normal file
View file

@ -0,0 +1,310 @@
package org.micord.service;
import java.net.HttpURLConnection;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.*;
import java.util.concurrent.CompletableFuture;
import java.util.stream.Collectors;
import com.arangodb.ArangoCursor;
import com.arangodb.ArangoDBException;
import com.arangodb.ArangoDatabase;
import com.arangodb.entity.StreamTransactionEntity;
import com.arangodb.model.AqlQueryOptions;
import com.arangodb.model.StreamTransactionOptions;
import org.micord.config.ArangoDBConnection;
import org.micord.config.DatabaseConnection;
import org.micord.config.S3HttpConnection;
import org.micord.models.AqlRequest;
import org.micord.models.RequestArgument;
import org.micord.models.Requests;
import org.micord.models.S3Request;
import org.micord.models.SqlRequest;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
/**
* @author Maksim Tereshin
*/
@Service
public class RequestService {
private static final Logger logger = LoggerFactory.getLogger(RequestService.class);
@Autowired
private HttpClient httpClient;
public void processS3Requests(List<S3Request> s3Requests, List<String> ids) {
if (s3Requests != null) {
s3Requests.forEach(request -> {
List<CompletableFuture<Void>> futures = ids.stream()
.map(id -> CompletableFuture.runAsync(() -> processS3Request(request, id)))
.toList();
CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]))
.thenRun(() -> logger.info("Successfully processed all S3 requests."))
.exceptionally(ex -> {
logger.error("Failed to process S3 requests", ex);
return null;
});
});
}
}
private void processS3Request(S3Request request, String id) {
try {
List<String> files = new ArrayList<>();
if (request.getRequestArguments() != null && !request.getRequestArguments().isEmpty()) {
for (RequestArgument argument : request.getRequestArguments()) {
try (Connection connection = DatabaseConnection.getConnection(
argument.getSqlConnectionParams())) {
String query = argument.getRequestURL();
List<String> result = fetchFileListFromDatabaseSQL(connection, query);
if (result != null && !result.isEmpty()) {
files.addAll(result);
}
}
catch (SQLException e) {
logger.error("Failed to execute query for RequestArgument", e);
}
}
}
files.forEach(file -> {
HttpRequest httpRequest;
try {
httpRequest = S3HttpConnection.buildHttpRequest(request, file);
}
catch (Exception e) {
throw new RuntimeException(e);
}
httpClient.sendAsync(httpRequest, HttpResponse.BodyHandlers.ofString())
.thenAccept(response -> {
if (response.statusCode() == HttpURLConnection.HTTP_NO_CONTENT
|| response.statusCode() == HttpURLConnection.HTTP_OK) {
logger.info("Successfully deleted object for ID {}", id);
}
else {
logger.error("Failed to delete object for ID {}. Response code: {}", id,
response.statusCode()
);
}
})
.exceptionally(ex -> {
logger.error("Failed to delete object for ID {}", id, ex);
return null;
});
});
}
catch (Exception e) {
logger.error("Failed to process S3 request for id: {}", id, e);
}
}
@Transactional
public void processSqlAndAqlRequests(Requests config, List<String> ids) {
if (config.getSqlRequests() != null) {
for (SqlRequest request : config.getSqlRequests()) {
processSqlRequests(request, ids);
}
}
if (config.getAqlRequests() != null) {
for (AqlRequest request : config.getAqlRequests()) {
processAqlRequests(request, ids);
}
}
processS3Requests(config.getS3Requests(), ids);
}
private void processSqlRequests(SqlRequest request, List<String> ids) {
String query = null;
try (Connection connection = DatabaseConnection.getConnection(
request.getSqlConnectionParams())) {
query = buildSqlQuery(request, String.join(",", ids));
int rowsAffected = executeSqlQuery(connection, query);
logger.info("Successfully deleted {} rows for IDs: {} in query: {}", rowsAffected, String.join(", ", ids), query);
}
catch (SQLException e) {
logger.error("SQL execution failed for query: {}", query, e);
}
}
private String buildSqlQuery(SqlRequest request, String ids) {
StringBuilder extraConditionsBuilder = new StringBuilder();
String endpointArguments = " (" + Arrays.stream(ids.split(","))
.map(id -> "'" + id.trim() + "'")
.collect(Collectors.joining(", ")) + ")";
if (request.getRequestArguments() != null && !request.getRequestArguments().isEmpty()) {
for (RequestArgument argument : request.getRequestArguments()) {
if (argument.getSqlConnectionParams() != null) {
try (Connection connection = DatabaseConnection.getConnection(
argument.getSqlConnectionParams())) {
String query = argument.getRequestURL();
List<String> result = fetchFileListFromDatabaseSQL(connection, query);
if (result != null && !result.isEmpty()) {
String resultSet = String.join(", ", result.stream()
.map(s -> "'" + s + "'")
.toArray(String[]::new));
extraConditionsBuilder.append(" OR ")
.append(argument.getId())
.append(" IN (")
.append(resultSet)
.append(")");
}
}
catch (SQLException e) {
logger.error("Failed to execute query for RequestArgument", e);
}
}
}
}
String extraConditions = extraConditionsBuilder.toString();
return request.getRequestURL()
.replace("${DB}", request.getSqlConnectionParams().getJdbcDatabase())
.replace("${extraConditions}", extraConditions)
.replace("${endpointArguments}", endpointArguments);
}
private int executeSqlQuery(Connection connection, String query) throws SQLException {
try (PreparedStatement stmt = connection.prepareStatement(query)) {
return stmt.executeUpdate();
}
}
public List<String> fetchFileListFromDatabaseSQL(Connection connection, String query)
throws SQLException {
List<String> results = new ArrayList<>();
try (PreparedStatement stmt = connection.prepareStatement(query);
ResultSet rs = stmt.executeQuery()) {
while (rs.next()) {
results.add(rs.getString(1)); // Fetch the first column
}
}
return results;
}
private void processAqlRequests(AqlRequest request, List<String> ids) {
ArangoDatabase arangoDb = ArangoDBConnection.getConnection(request.getAqlConnectionParams());
RequestArgument requestArgument = request.getRequestArguments().get(0);
List<String> aqlCollectionRead = requestArgument.getAqlCollectionRead();
String aqlCollectionWrite = requestArgument.getId();
StreamTransactionEntity tx = null;
try {
StreamTransactionOptions options = new StreamTransactionOptions()
.writeCollections(aqlCollectionWrite)
.readCollections(aqlCollectionRead.toArray(new String[0]));
tx = arangoDb.beginStreamTransaction(options);
String transactionId = tx.getId();
logger.info("Stream transaction started with ID: {}", transactionId);
List<String> entities = executeSelectAqlRequest(arangoDb, request.getRequestArguments(), ids,
transactionId
);
executeMainAqlRequest(arangoDb, request, entities, transactionId);
arangoDb.commitStreamTransaction(transactionId);
logger.info("Stream transaction with ID {} committed successfully", transactionId);
}
catch (ArangoDBException e) {
if (tx != null) {
arangoDb.abortStreamTransaction(tx.getId());
logger.error("Stream transaction with ID {} aborted due to an error", tx.getId(), e);
}
throw new RuntimeException("Failed to execute AQL request within a stream transaction", e);
}
logger.info("Successfully executed AQL request");
}
private List<String> executeSelectAqlRequest(ArangoDatabase arangoDb,
List<RequestArgument> requestArguments,
List<String> ids, String transactionId) {
List<String> entityIdList = new ArrayList<>();
RequestArgument argument = requestArguments.get(0);
String query = argument.getRequestURL();
String entityType = argument.getId();
Map<String, Object> bindVars = new HashMap<>();
bindVars.put("ids", ids);
AqlQueryOptions aqlQueryOptions = new AqlQueryOptions().streamTransactionId(transactionId);
try (ArangoCursor<Map> cursor = arangoDb.query(query, Map.class, bindVars, aqlQueryOptions)) {
while (cursor.hasNext()) {
Map result = cursor.next();
switch (entityType) {
case "applicationId":
entityIdList.add((String) result.get("applicationId"));
break;
case "edgesId":
entityIdList.addAll((List<String>) result.get("edgesId"));
break;
case "subjectId":
entityIdList.addAll((List<String>) result.get("subjectId"));
break;
case "historyId":
entityIdList.addAll((List<String>) result.get("historyId"));
break;
case "interdepreqId":
entityIdList.addAll((List<String>) result.get("interdepreqId"));
break;
default:
throw new IllegalArgumentException("Invalid requestArgumentId: " + entityType);
}
}
}
catch (Exception e) {
logger.error("Failed to execute AQL query", e);
}
return entityIdList;
}
private void executeMainAqlRequest(ArangoDatabase arangoDb, AqlRequest request,
List<String> entityIdList, String transactionId) {
if (entityIdList == null || entityIdList.isEmpty()) {
logger.warn("No entities found for main AQL request.");
return;
}
String entity = request.getRequestArguments().get(0).getId();
Map<String, Object> bindVars = new HashMap<>();
bindVars.put("ids", entityIdList);
String finalQuery = request.getRequestURL()
.replace("${entity}", entity);
AqlQueryOptions aqlQueryOptions = new AqlQueryOptions().streamTransactionId(transactionId);
arangoDb.query(finalQuery, null, bindVars, aqlQueryOptions);
logger.info("Successfully removed {}: {}", entity, entityIdList);
}
}

70
config-data-executor/src/main/java/org/micord/utils/ConfigLoader.java Normal file
View file

@ -0,0 +1,70 @@
package org.micord.utils;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.attribute.FileTime;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Unmarshaller;
import org.micord.models.CachedConfig;
import org.micord.models.Requests;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
/**
* @author Maksim Tereshin
*/
@Component
public class ConfigLoader {
private static final Logger LOGGER = Logger.getLogger(ConfigLoader.class.getName());
private static final Map<String, CachedConfig> cachedConfigs = new ConcurrentHashMap<>();
@Value("${configDirectory}")
private String configDirectory;
public Optional<Requests> loadConfigIfModified(String methodName) {
String fileName = methodName + ".xml";
if (configDirectory == null) {
LOGGER.log(Level.SEVERE, "No configuration directory found for method: " + methodName);
return Optional.empty();
}
try {
File configFile = new File(configDirectory + File.separator + fileName);
Path configFilePath = configFile.toPath();
FileTime currentModifiedTime = Files.getLastModifiedTime(configFilePath);
CachedConfig cachedConfig = cachedConfigs.getOrDefault(methodName, null);
if (cachedConfig == null || !currentModifiedTime.equals(cachedConfig.getModifiedTime())) {
// Load the updated configuration
JAXBContext jaxbContext = JAXBContext.newInstance(Requests.class);
Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
Requests loadedConfig = (Requests) unmarshaller.unmarshal(configFile);
cachedConfigs.put(methodName, new CachedConfig(loadedConfig, currentModifiedTime));
return Optional.of(loadedConfig);
}
else {
return Optional.of(cachedConfigs.get(methodName).getConfig());
}
}
catch (IOException e) {
LOGGER.log(Level.SEVERE, "Failed to load configuration file: " + fileName, e);
return Optional.empty(); // Return empty if there is an IO error
}
catch (JAXBException e) {
LOGGER.log(Level.SEVERE, "Failed to unmarshal configuration file: " + fileName, e);
return Optional.empty(); // Return empty if unmarshalling fails
}
}
}

3
config-data-executor/src/main/resources/application.yml Normal file
View file

@ -0,0 +1,3 @@
configDirectory: C:\work\ervu-secret\сonfig-data-executor\config-examples
server:
port: 8090