TradingClearingRegistryService in progress

clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/TradingClearingRegistryValidationConfig.java

@@ -0,0 +1,130 @@
+package ru.spcex.clearing.account.config.validation;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import ru.clearing.classes.statics.data.account.Account;
+import ru.clearing.classes.statics.data.company.Company;
+import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
+import ru.clearing.platform.dictionary.WorkflowStatusDictionary;
+import ru.spcex.clearing.account.errors.AccountError;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonDeleteRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.registry.TradingClearingRegistryNewRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.registry.TradingClearingRegistryUpdateRequest;
+import ru.spcex.clearing.validation.common.rules.DictionaryPresentRule;
+import ru.spcex.clearing.validation.common.rules.FieldRequiredRule;
+import ru.spcex.clearing.validation.common.rules.IdPresentRule;
+import ru.spcex.platform.classes.base.SpcexObjectBase;
+import ru.spcex.platform.enumeration.WorkflowStatus;
+import ru.spcex.platform.imdg.api.Imdg;
+import ru.spcex.platform.imdg.validation.ImdgValidationContext;
+import ru.spcex.platform.utils.validation.IValidator;
+import ru.spcex.platform.utils.validation.ValidatorImpl;
+
+import java.util.Map;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+@Configuration
+public class TradingClearingRegistryValidationConfig {
+    @Bean("tradingClearingRegistryNewRequest")
+    public Function<TradingClearingRegistryNewRequest, IValidator> tradingClearingRegistryNewRequestValidator(
+            Map<String, Imdg<? extends SpcexObjectBase>> imdgForValidation
+    ) {
+        return tradingClearingRegistryNewRequest -> {
+            ImdgValidationContext<TradingClearingRegistryNewRequest> context = new ImdgValidationContext<>();
+            context.setValidatedObject(tradingClearingRegistryNewRequest);
+            Consumer<String> addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s));
+            addImdg.accept(IMDGDistributedNames.Map_Company);
+            addImdg.accept(IMDGDistributedNames.Map_Account);
+            addImdg.accept(IMDGDistributedNames.Map_WorkflowStatusDictionary);
+            return new ValidatorImpl<>(context,
+                    IdPresentRule.instance("companyId",
+                            TradingClearingRegistryNewRequest::getCompanyId,
+                            IMDGDistributedNames.Map_Company,
+                            Company.class,
+                            AccountError.RequiredFieldEmpty,
+                            AccountError.CompanyNotFound),
+                    FieldRequiredRule.instance("moneyAccountId",
+                            TradingClearingRegistryNewRequest::getMoneyAccountId,
+                            AccountError.RequiredFieldEmpty,
+                            moneyAccountId -> {
+                                Imdg<Account> accountImdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class);
+                                Account account = accountImdg.getSingleObjectByID(moneyAccountId);
+                                if (account == null) return AccountError.AccountNotFound;
+                                return null;
+                            }),
+                    FieldRequiredRule.instance("depoAccountId",
+                            TradingClearingRegistryNewRequest::getDepoAccountId,
+                            AccountError.RequiredFieldEmpty,
+                            false,
+                            depoAccountId -> {
+                                Imdg<Account> accountImdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class);
+                                Account account = accountImdg.getSingleObjectByID(depoAccountId);
+                                if (account == null) return AccountError.AccountNotFound;
+                                return null;
+                            }),
+                    DictionaryPresentRule.instance("status",
+                            TradingClearingRegistryNewRequest::getStatus,
+                            IMDGDistributedNames.Map_WorkflowStatusDictionary,
+                            WorkflowStatusDictionary.class,
+                            AccountError.RequiredFieldEmpty,
+                            AccountError.WrongFieldValue,
+                            false,
+                            statusValue -> {
+                                String statusCode = statusValue.getCode();
+                                if (WorkflowStatus.Active.equalsByKey(statusCode)) return null;
+                                return AccountError.WrongFieldValue;
+                            })
+            );
+        };
+    }
+
+    @Bean("tradingClearingRegistryUpdateRequest")
+    public Function<TradingClearingRegistryUpdateRequest, IValidator> tradingClearingRegistryUpdateRequestValidator(
+            Map<String, Imdg<? extends SpcexObjectBase>> imdgForValidation
+    ) {
+        return tradingClearingRegistryUpdateRequest -> {
+            ImdgValidationContext<TradingClearingRegistryUpdateRequest> context = new ImdgValidationContext<>();
+            context.setValidatedObject(tradingClearingRegistryUpdateRequest);
+            Consumer<String> addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s));
+            addImdg.accept(IMDGDistributedNames.Map_WorkflowStatusDictionary);
+            addImdg.accept(IMDGDistributedNames.Map_TradingClearingRegistry);
+            return new ValidatorImpl<>(context,
+                    IdPresentRule.instance("id",
+                            TradingClearingRegistryUpdateRequest::getId,
+                            IMDGDistributedNames.Map_TradingClearingRegistry,
+                            TradingClearingRegistry.class,
+                            AccountError.RequiredFieldEmpty,
+                            AccountError.TradingClearingRegistryNotFound),
+                    DictionaryPresentRule.instance("status",
+                            TradingClearingRegistryUpdateRequest::getStatus,
+                            IMDGDistributedNames.Map_WorkflowStatusDictionary,
+                            WorkflowStatusDictionary.class,
+                            AccountError.RequiredFieldEmpty,
+                            AccountError.WrongFieldValue,
+                            false)
+            );
+        };
+    }
+
+    @Bean("tradingClearingRegistryBlockRequest")
+    public Function<CommonDeleteRequest, IValidator> tradingClearingRegistryBlockRequestValidator(
+            Map<String, Imdg<? extends SpcexObjectBase>> imdgForValidation
+    ) {
+        return tradingClearingRegistryBlockRequest -> {
+            ImdgValidationContext<CommonDeleteRequest> context = new ImdgValidationContext<>();
+            context.setValidatedObject(tradingClearingRegistryBlockRequest);
+            Consumer<String> addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s));
+            addImdg.accept(IMDGDistributedNames.Map_TradingClearingRegistry);
+            return new ValidatorImpl<>(context,
+                    IdPresentRule.instance("id",
+                            CommonDeleteRequest::getId,
+                            IMDGDistributedNames.Map_TradingClearingRegistry,
+                            TradingClearingRegistry.class,
+                            AccountError.RequiredFieldEmpty,
+                            AccountError.TradingClearingRegistryNotFound)
+            );
+        };
+    }
+}

clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/ValidationConfig.java

@@ -11,6 +11,7 @@ import ru.clearing.classes.statics.data.company.ClearingMemberCategory;
 import ru.clearing.classes.statics.data.company.Company;
 import ru.clearing.platform.dictionary.ClearingAccountTypeDictionary;
 import ru.clearing.platform.dictionary.CurrencyCodeDictionary;
+import ru.clearing.platform.dictionary.WorkflowStatusDictionary;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.validation.common.ValidationHelper;
 import ru.spcex.platform.classes.base.SpcexObjectBase;
@@ -39,6 +40,7 @@ public class ValidationConfig {
         addImdg.accept(IMDGDistributedNames.Map_BankAccount, BankAccount.class);
         addImdg.accept(IMDGDistributedNames.Map_CurrencyCodeDictionary, CurrencyCodeDictionary.class);
         addImdg.accept(IMDGDistributedNames.Map_ClearingAccount, ClearingAccount.class);
+        addImdg.accept(IMDGDistributedNames.Map_WorkflowStatusDictionary, WorkflowStatusDictionary.class);
 
         return imdg;
     }

clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/errors/AccountError.java

@@ -12,7 +12,8 @@ public enum AccountError implements IErrorEnumId {
     CompanyNotFound(5013L),
     CompanyNotActive(5014L),
     InfoAccountAlreadyExist(5015L),
-    ClearingCategoryNotFound(5019L)
+    ClearingCategoryNotFound(5019L),
+    TradingClearingRegistryNotFound(5022L),
     ;
 
     private final Long id;

clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/TradingClearingRegistryService.java

@@ -0,0 +1,179 @@
+package ru.spcex.clearing.account.service;
+
+import org.apache.kafka.clients.consumer.Consumer;
+import org.apache.kafka.clients.producer.Producer;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.InitializingBean;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.stereotype.Service;
+import ru.clearing.classes.statics.data.account.ClearingAccount;
+import ru.clearing.classes.statics.data.account.DepoAccount;
+import ru.clearing.classes.statics.data.company.Company;
+import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
+import ru.spcex.clearing.platform.messaging.domain.Consts;
+import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonDeleteRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.registry.TradingClearingRegistryNewRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.registry.TradingClearingRegistryUpdateRequest;
+import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
+import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate;
+import ru.spcex.clearing.util.security.UserRoleVerification;
+import ru.spcex.clearing.validation.common.ValidationHelper;
+import ru.spcex.platform.enumeration.TradingClearingRegistryPurpose;
+import ru.spcex.platform.enumeration.WorkflowStatus;
+import ru.spcex.platform.imdg.api.Imdg;
+import ru.spcex.platform.imdg.api.ImdgProvider;
+import ru.spcex.platform.utils.validation.IValidator;
+
+import java.time.Instant;
+import java.util.function.Function;
+
+@Service
+public class TradingClearingRegistryService extends QueueConsumer implements InitializingBean {
+    private final Logger log = LoggerFactory.getLogger(getClass());
+
+    private final ValidationHelper validationHelper;
+    private final UserRoleVerification userRoleVerification;
+
+    private final Imdg<TradingClearingRegistry> tradingClearingRegistryImdg;
+    private final Imdg<DepoAccount> depoAccountImdg;
+    private final Imdg<ClearingAccount> clearingAccountImdg;
+    private final Imdg<Company> companyImdg;
+
+    private final Function<TradingClearingRegistryUpdateRequest, IValidator> tradingClearingRegistryUpdateRequestValidator;
+    private final Function<TradingClearingRegistryNewRequest, IValidator> tradingClearingRegistryNewRequestValidator;
+    private final Function<CommonDeleteRequest, IValidator> tradingClearingRegistryBlockRequestValidator;
+
+    public TradingClearingRegistryService(Consumer<String, Object> kafkaQueue,
+                                          Producer<String, Object> kafkaProducer,
+                                          ImdgProvider imdgProvider,
+                                          ValidationHelper validationHelper,
+                                          UserRoleVerification userRoleVerification,
+                                          @Qualifier("tradingClearingRegistryNewRequest")
+                                                  Function<TradingClearingRegistryNewRequest, IValidator> tradingClearingRegistryNewRequestValidator,
+                                          @Qualifier("tradingClearingRegistryUpdateRequest")
+                                                  Function<TradingClearingRegistryUpdateRequest, IValidator> tradingClearingRegistryUpdateRequestValidator,
+                                          @Qualifier("tradingClearingRegistryBlockRequest")
+                                            Function<CommonDeleteRequest, IValidator> tradingClearingRegistryBlockRequestValidator) {
+        super(kafkaQueue, kafkaProducer);
+        this.validationHelper = validationHelper;
+        this.userRoleVerification = userRoleVerification;
+        this.tradingClearingRegistryNewRequestValidator = tradingClearingRegistryNewRequestValidator;
+        this.tradingClearingRegistryImdg = imdgProvider.getImdg(
+                IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class
+        );
+        this.depoAccountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_DepoAccount, DepoAccount.class);
+        this.clearingAccountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_ClearingAccount, ClearingAccount.class);
+        this.companyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class);
+        this.tradingClearingRegistryUpdateRequestValidator = tradingClearingRegistryUpdateRequestValidator;
+        this.tradingClearingRegistryBlockRequestValidator = tradingClearingRegistryBlockRequestValidator;
+    }
+
+    @Override
+    public void afterPropertiesSet() throws Exception {
+        init();
+        callback(TradingClearingRegistryNewRequest.class)
+                .setConsumer(this::tradingClearingRegistryNew)
+                .forDestination(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_NEW, callbacks::put);
+        callback(TradingClearingRegistryUpdateRequest.class)
+                .setConsumer(this::tradingClearingRegistryUpdate)
+                .forDestination(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_UPDATE, callbacks::put);
+        callback(CommonDeleteRequest.class)
+                .setConsumer(this::tradingClearingRegistryBlock)
+                .forDestination(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_BLOCK, callbacks::put);
+    }
+
+    public RequestInfoUpdate tradingClearingRegistryNew(BaseRequest<TradingClearingRegistryNewRequest> userRequest) {
+        log.debug("TradingClearingRegistryNewRequest received");
+        RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest);
+        if (requestInfoUpdate != null) return requestInfoUpdate;
+
+        requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, tradingClearingRegistryNewRequestValidator);
+        if (requestInfoUpdate != null) return requestInfoUpdate;
+
+        TradingClearingRegistryNewRequest req = userRequest.getRequestPayload();
+
+        Long id = tradingClearingRegistryImdg.nextIDSequenceFor();
+        TradingClearingRegistry tradingClearingRegistry = new TradingClearingRegistry();
+        tradingClearingRegistry.setId(id);
+        tradingClearingRegistry.setCompanyId(req.getCompanyId());
+        tradingClearingRegistry.setMoneyAccountId(req.getMoneyAccountId());
+        tradingClearingRegistry.setDepoAaccountId(req.getDepoAccountId());
+        tradingClearingRegistry.setStatus(WorkflowStatus.Active.getKey());
+
+        // todo tradingClearingRegistryType из соответствующего параметра очереди но в запросе он не фигурирует
+        //  пока оставил вычисление аналогичное автоматическому добавлению ТКР
+        String tradingRegistryType;
+        if (req.getDepoAccountId() != null) {
+            DepoAccount depoAccount = depoAccountImdg.getSingleObjectByID(req.getDepoAccountId());
+            tradingRegistryType = depoAccount.getDepoAccountType();
+        } else {
+            ClearingAccount clearingAccount = clearingAccountImdg.getSingleObjectByID(req.getMoneyAccountId());
+            tradingRegistryType = clearingAccount.getClearingAccountType();
+        }
+        tradingClearingRegistry.setTradingClearingRegistryType(tradingRegistryType);
+
+        TradingClearingRegistryPurpose registryPurpose;
+        if (req.getDepoAccountId() != null) registryPurpose = TradingClearingRegistryPurpose.C;
+        else registryPurpose = TradingClearingRegistryPurpose.M;
+        tradingClearingRegistry.setTradingClearingRegistryPurpose(registryPurpose.getKey());
+
+        Company company = companyImdg.getSingleObjectByID(req.getCompanyId());
+        String code =  company.getClearingCode() + registryPurpose.getKey() + registryPurpose;
+        if (registryPurpose == TradingClearingRegistryPurpose.C) code += tradingRegistryType + id;
+        else code += "AT" + id;
+        tradingClearingRegistry.setCode(code);
+
+        Instant now = Instant.now();
+        tradingClearingRegistry.setCreated(now);
+        tradingClearingRegistry.setUpdated(now);
+
+        tradingClearingRegistryImdg.insert(tradingClearingRegistry);
+
+        log.debug("successfully processed, id {}", id);
+        return null;
+    }
+
+    public RequestInfoUpdate tradingClearingRegistryUpdate(BaseRequest<TradingClearingRegistryUpdateRequest> userRequest) {
+        log.debug("TradingClearingRegistryUpdateRequest received");
+        RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest);
+        if (requestInfoUpdate != null) return requestInfoUpdate;
+
+        requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, tradingClearingRegistryUpdateRequestValidator);
+        if (requestInfoUpdate != null) return requestInfoUpdate;
+
+        TradingClearingRegistryUpdateRequest req = userRequest.getRequestPayload();
+        TradingClearingRegistry tradingClearingRegistry = tradingClearingRegistryImdg.getSingleObjectByID(req.getId());
+
+        if (req.getStatus() != null) tradingClearingRegistry.setStatus(req.getStatus());
+
+        Instant now = Instant.now();
+        tradingClearingRegistry.setUpdated(now);
+
+        tradingClearingRegistryImdg.update(tradingClearingRegistry);
+
+        log.debug("successfully processed, id {}", tradingClearingRegistry.getId());
+        return null;
+    }
+
+    public RequestInfoUpdate tradingClearingRegistryBlock(BaseRequest<CommonDeleteRequest> userRequest) {
+        log.debug("TradingClearingRegistryBlockRequest received");
+        RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest);
+        if (requestInfoUpdate != null) return requestInfoUpdate;
+
+        requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, tradingClearingRegistryBlockRequestValidator);
+        if (requestInfoUpdate != null) return requestInfoUpdate;
+
+        CommonDeleteRequest req = userRequest.getRequestPayload();
+        TradingClearingRegistry tradingClearingRegistry = tradingClearingRegistryImdg.getSingleObjectByID(req.getId());
+
+        tradingClearingRegistry.setStatus(WorkflowStatus.Blocked.getKey());
+
+        tradingClearingRegistryImdg.update(tradingClearingRegistry);
+
+        log.debug("successfully processed, id {}", tradingClearingRegistry.getId());
+        return null;
+    }
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/registry/TradingClearingRegistryController.java

@@ -10,9 +10,9 @@ import org.springframework.stereotype.Controller;
 import org.springframework.web.bind.annotation.*;
 import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
 import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController;
+import ru.spcex.clearing.backendapi.controller.request.cud.common.CommonDeleteAction;
 import ru.spcex.clearing.backendapi.controller.request.cud.registry.TradingClearingRegistryNewAction;
 import ru.spcex.clearing.backendapi.controller.request.cud.registry.TradingClearingRegistryUpdateAction;
-import ru.spcex.clearing.backendapi.controller.request.cud.common.CommonDeleteAction;
 import ru.spcex.clearing.backendapi.controller.response.BasicSpcexResponse;
 import ru.spcex.clearing.backendapi.controller.response.cud.CudResponse;
 import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse;
@@ -69,7 +69,7 @@ public class TradingClearingRegistryController extends AbstractQueueController {
                               @PathVariable("id") Long id) throws ExecutionException, InterruptedException {
         CommonDeleteAction deleteAction = new CommonDeleteAction();
         deleteAction.setId(id);
-        return processRequest(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_DELETE, deleteAction);
+        return processRequest(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_BLOCK, deleteAction);
     }
 
     @ApiOperation(value = "get TradingClearingRegistry by id.")

clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/controller/queue/registry/TradingClearingRegistryControllerTest.java

@@ -6,9 +6,9 @@ import org.springframework.http.MediaType;
 import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
 import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
 import ru.spcex.clearing.backendapi.controller.queue.AbstractControllerTest;
+import ru.spcex.clearing.backendapi.controller.request.cud.common.CommonDeleteAction;
 import ru.spcex.clearing.backendapi.controller.request.cud.registry.TradingClearingRegistryNewAction;
 import ru.spcex.clearing.backendapi.controller.request.cud.registry.TradingClearingRegistryUpdateAction;
-import ru.spcex.clearing.backendapi.controller.request.cud.common.CommonDeleteAction;
 import ru.spcex.clearing.backendapi.controller.response.entity.registry.TradingClearingRegistryBackendGetById;
 import ru.spcex.clearing.backendapi.controller.response.entity.registry.TradingClearingRegistryBackendGetFields;
 import ru.spcex.clearing.backendapi.domain.actions.IAction;
@@ -97,7 +97,7 @@ class TradingClearingRegistryControllerTest extends AbstractControllerTest {
         deleteAction.setId(id);
         //ACT and ASSERT
         checkDeletingByRestApi(REST_URL, id);
-        checkSendedMessegeFromKafka(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_DELETE, deleteAction);
+        checkSendedMessegeFromKafka(Consts.DESTINATION_TRADING_CLEARING_REGISTRY_BLOCK, deleteAction);
     }
 
     /**

clearing-parent/classes/src/main/java/ru/clearing/classes/statics/data/registry/TradingClearingRegistry.java

@@ -15,6 +15,7 @@ public class TradingClearingRegistry extends BusinessObject {
     private Long companyId;
     private String code;
     private Long moneyAccountId;
+    // todo fix typo
     private Long depoAaccountId;
     private String tradingClearingRegistryType;
     private String tradingClearingRegistryLevel;

platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/TradingClearingRegistryPurpose.java

@@ -0,0 +1,20 @@
+package ru.spcex.platform.enumeration;
+
+import ru.spcex.platform.utils.enumeration.IEnumKey;
+
+public enum TradingClearingRegistryPurpose implements IEnumKey {
+    M("M"),
+    C("C"),
+    ;
+
+    private final String key;
+
+    TradingClearingRegistryPurpose(String key) {
+        this.key = key;
+    }
+
+    @Override
+    public String getKey() {
+        return key;
+    }
+}

platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/Consts.java

@@ -83,7 +83,7 @@ public interface Consts {
 
     String DESTINATION_TRADING_CLEARING_REGISTRY_NEW = "trading-clearing-registry-new";
     String DESTINATION_TRADING_CLEARING_REGISTRY_UPDATE = "trading-clearing-registry-update";
-    String DESTINATION_TRADING_CLEARING_REGISTRY_DELETE = "trading-clearing-registry-delete";
+    String DESTINATION_TRADING_CLEARING_REGISTRY_BLOCK = "trading-clearing-registry-block";
 
     String DESTINATION_SDF08_NEW = "s-df-08-new";
     String DESTINATION_SDF02_NEW = "s-df-02-new";