treshenkov/clearing
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

http://jira.mfd.msk:8088/browse/CLS-258

Browse source 
Добавил CouponPeriodService валидацию и тесты к нему.
This commit is contained in:
psemenkov 2023-04-05 19:56:57 +03:00
parent 15a477e8ce
commit edff45ebae
12 changed files with 431 additions and 17 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/errors/SecuritiesError.java
View file

@ -8,6 +8,8 @@ public enum SecuritiesError implements IErrorEnumId {
InstrumentAlreadyExists(1010L),
InstrumentNotFound(1011L),
InstrumentNotActive(1012L),
CouponPeriodAlreadyExists(1013L),
CouponPeriodNotFound(1014L),
CurrencyAlreadyExists(1015L),
CurrencyNotFound(1016L),

89
clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/service/cud/CouponPeriodService.java Normal file
View file

@ -0,0 +1,89 @@
package ru.spcex.clearing.securities.service.cud;
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.Autowired;
import org.springframework.stereotype.Service;
import ru.clearing.classes.statics.data.instrument.issue.CouponPeriod;
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.securitites.CouponPeriodNewRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.securitites.CouponPeriodUpdateRequest;
import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate;
import ru.spcex.clearing.securities.validation.ValidationProvider;
import ru.spcex.clearing.validation.common.ValidationHelper;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgId;
import ru.spcex.platform.imdg.api.ImdgProvider;
@Service
public class CouponPeriodService extends QueueConsumer implements InitializingBean {
private final Logger log = LoggerFactory.getLogger(getClass());
private final Imdg<CouponPeriod> couponPeriodImdg;
private final ImdgProvider imdgProvider;
private final ImdgId idGenerator;
private final ValidationProvider validation;
private final ValidationHelper validationHelper;
@Autowired
public CouponPeriodService(Consumer<String, Object> kafkaQueue,
Producer<String, Object> kafkaProducer,
ImdgProvider imdgProvider,
ValidationProvider validation,
ValidationHelper validationHelper) {
super(kafkaQueue, kafkaProducer);
this.validation = validation;
this.couponPeriodImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_CouponPeriod, CouponPeriod.class);
this.imdgProvider = imdgProvider;
this.idGenerator = imdgProvider.getImdgIdGenerator();
this.validationHelper = validationHelper;
}
@Override
public void afterPropertiesSet() {
callback(CouponPeriodNewRequest.class)
.setFunction(this::newCouponPeriod)
.forDestination(Consts.DESTINATION_COUPON_PERIOD_NEW, callbacks::put);
callback(CouponPeriodUpdateRequest.class)
.setFunction(this::updateCouponPeriod)
.forDestination(Consts.DESTINATION_COUPON_PERIOD_UPDATE, callbacks::put);
imdgProvider.waitAvailable();
init();
}
private RequestInfoUpdate newCouponPeriod(BaseRequest<CouponPeriodNewRequest> userRequest) {
CouponPeriodNewRequest req = userRequest.getRequestPayload();
RequestInfoUpdate requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, validation.couponPeriodNewValidator());
if (requestInfoUpdate != null) return requestInfoUpdate;
log.debug("newCurrency received");
CouponPeriod couponPeriod = new CouponPeriod();
couponPeriod.setId(idGenerator.nextId());
couponPeriod.setSecurityId(req.getSecurityId());
couponPeriod.setPeriodEndDate(req.getPeriodEndDate());
couponPeriod.setPeriodStartDate(req.getPeriodStartDate());
couponPeriodImdg.insert(couponPeriod);
log.debug("successfully processed, request id {}, new object id {}", userRequest.getId(), couponPeriod.getId());
return null; // default success
}
private RequestInfoUpdate updateCouponPeriod(BaseRequest<CouponPeriodUpdateRequest> userRequest) {
CouponPeriodUpdateRequest req = userRequest.getRequestPayload();
log.debug("updateCurrency received id = {}", req.getId());
RequestInfoUpdate requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, validation.couponPeriodUpdateValidator());
if (requestInfoUpdate != null) return requestInfoUpdate;
CouponPeriod couponPeriod = couponPeriodImdg.getSingleObjectBySQL(String.format("securityId = %s", req.getSecurityId()));
couponPeriod.setPeriodEndDate(req.getPeriodEndDate());
couponPeriod.setPeriodStartDate(req.getPeriodStartDate());
couponPeriodImdg.update(couponPeriod);
return null;
}
}

8
clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/service/cud/CurrencyService.java
View file

@ -15,13 +15,11 @@ import ru.spcex.clearing.platform.messaging.domain.cud.securitites.CurrencyNewRe
import ru.spcex.clearing.platform.messaging.domain.cud.securitites.CurrencyUpdateRequest;
import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate;
import ru.spcex.clearing.securities.component.ListingBuilder;
import ru.spcex.clearing.securities.validation.ValidationProvider;
import ru.spcex.clearing.validation.common.ValidationHelper;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgId;
import ru.spcex.platform.imdg.api.ImdgProvider;
import ru.spcex.platform.imdg.api.ImdgTransaction;
@Service
public class CurrencyService extends QueueConsumer implements InitializingBean {
@ -31,7 +29,6 @@ public class CurrencyService extends QueueConsumer implements InitializingBean {
private final ImdgId idGenerator;
private final ValidationProvider validation;
private final ValidationHelper validationHelper;
private final ListingBuilder listingBuilder = new ListingBuilder();
@Autowired
public CurrencyService(Consumer<String, Object> kafkaQueue,
@ -51,16 +48,15 @@ public class CurrencyService extends QueueConsumer implements InitializingBean {
public void afterPropertiesSet() {
callback(CurrencyNewRequest.class)
.setFunction(this::newCurrency)
.forDestination(Consts.DESTINATION_СURRENCY_NEW, callbacks::put);
.forDestination(Consts.DESTINATION_CURRENCY_NEW, callbacks::put);
callback(CurrencyUpdateRequest.class)
.setFunction(this::updateCurrency)
.forDestination(Consts.DESTINATION_СURRENCY_UPDATE, callbacks::put);
.forDestination(Consts.DESTINATION_CURRENCY_UPDATE, callbacks::put);
imdgProvider.waitAvailable();
init();
}
private RequestInfoUpdate newCurrency(BaseRequest<CurrencyNewRequest> userRequest) {
ImdgTransaction transaction = imdgProvider.newTransaction();
CurrencyNewRequest req = userRequest.getRequestPayload();
RequestInfoUpdate requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, validation.currencyNewValidator());

24
clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/validation/ValidationProvider.java
View file

@ -29,6 +29,7 @@ public class ValidationProvider {
private final Imdg<SpcexObjectBase> bondTypeDictionaryImdg;
private final Imdg<SpcexObjectBase> companyImdg;
private final Imdg<SpcexObjectBase> currencyImdg;
private final Imdg<SpcexObjectBase> couponPeriodImdg;
public ValidationProvider(ImdgProvider imdgProvider) {
@ -43,6 +44,7 @@ public class ValidationProvider {
this.bondTypeDictionaryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_BondTypeDictionary, SpcexObjectBase.class);
this.companyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, SpcexObjectBase.class);
this.currencyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Currency, SpcexObjectBase.class);
this.couponPeriodImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_CouponPeriod, SpcexObjectBase.class);
}
public Function<MoneyMarketSecurityNewRequest, IValidator> mmsNewValidator() {
@ -241,4 +243,26 @@ public class ValidationProvider {
);
};
}
public Function<CouponPeriodNewRequest, IValidator> couponPeriodNewValidator() {
return currencyRequest -> {
ImdgValidationContext<CouponPeriodNewRequest> context = new ImdgValidationContext<>();
context.setValidatedObject(currencyRequest);
context.addImdg(IMDGDistributedNames.Map_CouponPeriod, couponPeriodImdg);
return new ValidatorImpl<>(context,
CouponPeriodNewValidationRule.CouponPeriodNotExists
);
};
}
public Function<CouponPeriodUpdateRequest, IValidator> couponPeriodUpdateValidator() {
return currencyRequest -> {
ImdgValidationContext<CouponPeriodUpdateRequest> context = new ImdgValidationContext<>();
context.setValidatedObject(currencyRequest);
context.addImdg(IMDGDistributedNames.Map_CouponPeriod, couponPeriodImdg);
return new ValidatorImpl<>(context,
CouponPeriodUpdateValidationRule.CouponPeriodExists
);
};
}
}

48
clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/validation/rule/CouponPeriodNewValidationRule.java Normal file
View file

@ -0,0 +1,48 @@
package ru.spcex.clearing.securities.validation.rule;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.platform.messaging.domain.cud.securitites.CouponPeriodNewRequest;
import ru.spcex.clearing.securities.errors.SecuritiesError;
import ru.spcex.platform.classes.base.SpcexObjectBase;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.validation.ImdgValidationContext;
import ru.spcex.platform.utils.enumeration.EnumMessage;
import ru.spcex.platform.utils.validation.IValidationRule;
import java.util.Map;
import java.util.Optional;
public enum CouponPeriodNewValidationRule implements IValidationRule<ImdgValidationContext<CouponPeriodNewRequest>> {
CouponPeriodNotExists() {
@Override
public Optional<EnumMessage> validate(ImdgValidationContext<CouponPeriodNewRequest> context) {
CouponPeriodNewRequest action = context.getValidatedObject();
if (action.getSecurityId() == null) {
return of(SecuritiesError.RequiredFieldIsEmpty, "securityId");
}
Imdg<SpcexObjectBase> imdgDictionary = context.obtainMap(IMDGDistributedNames.Map_CouponPeriod, SpcexObjectBase.class);
SpcexObjectBase couponPeriod = imdgDictionary.getSingleObjectByFieldValues(Map.of(
"securityId", action.getSecurityId()));
if (couponPeriod != null) {
return of(SecuritiesError.CouponPeriodAlreadyExists, "securityId");
}
if (action.getPeriodEndDate() == null && action.getPeriodStartDate() == null) {
return of(SecuritiesError.RequiredFieldIsEmpty, "periodEndDate", "periodStartDate");
}
if (action.getPeriodEndDate() == null || action.getPeriodStartDate() == null) {
if (action.getPeriodStartDate() == null)
return of(SecuritiesError.RequiredFieldIsEmpty, "periodStartDate");
return of(SecuritiesError.RequiredFieldIsEmpty, "periodEndDate");
}
if (action.getPeriodEndDate().isBefore(action.getPeriodStartDate())) {
return of(SecuritiesError.WrongFieldValue, "periodEndDate", "periodStartDate");
}
return empty();
}
};
@Override
public String ruleName() {
return "MmsNewValidationRule." + name();
}
}

48
clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/validation/rule/CouponPeriodUpdateValidationRule.java Normal file
View file

@ -0,0 +1,48 @@
package ru.spcex.clearing.securities.validation.rule;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.platform.messaging.domain.cud.securitites.CouponPeriodUpdateRequest;
import ru.spcex.clearing.securities.errors.SecuritiesError;
import ru.spcex.platform.classes.base.SpcexObjectBase;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.validation.ImdgValidationContext;
import ru.spcex.platform.utils.enumeration.EnumMessage;
import ru.spcex.platform.utils.validation.IValidationRule;
import java.util.Map;
import java.util.Optional;
public enum CouponPeriodUpdateValidationRule implements IValidationRule<ImdgValidationContext<CouponPeriodUpdateRequest>> {
CouponPeriodExists() {
@Override
public Optional<EnumMessage> validate(ImdgValidationContext<CouponPeriodUpdateRequest> context) {
CouponPeriodUpdateRequest action = context.getValidatedObject();
if (action.getSecurityId() == null) {
return of(SecuritiesError.RequiredFieldIsEmpty, "securityId");
}
Imdg<SpcexObjectBase> imdgDictionary = context.obtainMap(IMDGDistributedNames.Map_CouponPeriod, SpcexObjectBase.class);
SpcexObjectBase currency = imdgDictionary.getSingleObjectByFieldValues(Map.of(
"securityId", action.getSecurityId()));
if (currency == null) {
return of(SecuritiesError.CouponPeriodNotFound, "securityId");
}
if (action.getPeriodEndDate() == null && action.getPeriodStartDate() == null) {
return of(SecuritiesError.RequiredFieldIsEmpty, "periodEndDate", "periodStartDate");
}
if (action.getPeriodEndDate() == null || action.getPeriodStartDate() == null) {
if (action.getPeriodStartDate() == null)
return of(SecuritiesError.RequiredFieldIsEmpty, "periodStartDate");
return of(SecuritiesError.RequiredFieldIsEmpty, "periodEndDate");
}
if (action.getPeriodEndDate().isBefore(action.getPeriodStartDate())) {
return of(SecuritiesError.WrongFieldValue, "periodEndDate", "periodStartDate");
}
return empty();
}
};
@Override
public String ruleName() {
return "MmsNewValidationRule." + name();
}
}

11
clearing-parent/securities-service/src/test/java/ru/spcex/clearing/securities/service/AbstractServiceTest.java
View file

@ -11,6 +11,7 @@ import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import ru.clearing.classes.statics.data.company.Company;
import ru.clearing.classes.statics.data.instrument.issue.CouponPeriod;
import ru.clearing.classes.statics.data.instrument.issue.EquitySecurity;
import ru.clearing.classes.statics.data.instrument.issue.FixedIncomeSecurity;
import ru.clearing.classes.statics.data.misc.Currency;
@ -23,10 +24,7 @@ import ru.spcex.clearing.securities.config.ErrorResolverConfig;
import ru.spcex.clearing.securities.config.ImdgTestConfig;
import ru.spcex.clearing.securities.config.KafkaTestConfig;
import ru.spcex.clearing.securities.config.ValidationConfig;
import ru.spcex.clearing.securities.service.cud.CurrencyService;
import ru.spcex.clearing.securities.service.cud.EquitySecurityService;
import ru.spcex.clearing.securities.service.cud.FixedIncomeSecurityService;
import ru.spcex.clearing.securities.service.cud.MoneyMarketSecurityService;
import ru.spcex.clearing.securities.service.cud.*;
import ru.spcex.clearing.securities.utils.MatcherFactory;
import ru.spcex.clearing.securities.utils.TestUtils;
import ru.spcex.clearing.securities.validation.ValidationProvider;
@ -41,10 +39,11 @@ import static ru.spcex.clearing.securities.utils.MatcherFactory.usingIgnoringFie
@ExtendWith(SpringExtension.class)
@ContextConfiguration(classes = {
CouponPeriodService.class,
CurrencyService.class,
EquitySecurityService.class,
FixedIncomeSecurityService.class,
MoneyMarketSecurityService.class,
CurrencyService.class,
ImdgTestConfig.class,
KafkaTestConfig.class,
ValidationProvider.class,
@ -65,6 +64,7 @@ public abstract class AbstractServiceTest {
protected Imdg<BondTypeDictionary> bondTypeDictionaryImdg;
protected Imdg<Company> companyImdg;
protected Imdg<Currency> currencyImdg;
protected Imdg<CouponPeriod> couponPeriodImdg;
public static String RATE = "RATE";
protected String EQTY = "EQTY";
@ -97,6 +97,7 @@ public abstract class AbstractServiceTest {
this.bondTypeDictionaryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_BondTypeDictionary, BondTypeDictionary.class);
this.companyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class);
this.currencyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Currency, Currency.class);
this.couponPeriodImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_CouponPeriod, CouponPeriod.class);
InstrumentTypeDictionary instrumentTypeDictionary = new InstrumentTypeDictionary();
instrumentTypeDictionary.setId(1L);

100
clearing-parent/securities-service/src/test/java/ru/spcex/clearing/securities/service/CouponPeriodServiceTest.java Normal file
View file

@ -0,0 +1,100 @@
package ru.spcex.clearing.securities.service;
import org.apache.kafka.clients.consumer.MockConsumer;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import ru.clearing.classes.statics.data.instrument.issue.CouponPeriod;
import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
import ru.spcex.clearing.platform.messaging.domain.Consts;
import ru.spcex.clearing.platform.messaging.domain.cud.securitites.CouponPeriodNewRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.securitites.CouponPeriodUpdateRequest;
import ru.spcex.clearing.securities.service.cud.CouponPeriodService;
import ru.spcex.clearing.securities.utils.MatcherFactory;
import javax.annotation.PostConstruct;
import java.time.LocalDate;
import static ru.spcex.clearing.securities.utils.MatcherFactory.usingIgnoringFieldsComparator;
import static ru.spcex.clearing.securities.utils.TestUtils.*;
public class CouponPeriodServiceTest extends AbstractServiceTest {
private static final MatcherFactory.Matcher<CouponPeriod> COUPON_PERIOD_MATCHER = usingIgnoringFieldsComparator();
private final long ID = currentId.getAndIncrement();
private final long securityId = 3123L;
private final int PARTITION = 0;
private final String countryCode = "countryCode";
private final String currencyCode = "currencyCode";
@Autowired
private CouponPeriodService couponPeriodService;
@PostConstruct
protected void init() {
super.init();
}
/**
* {@link CouponPeriodService#newCouponPeriod(BaseRequest)}<br>
* Тест проверяет генерацию сущности {@link CouponPeriod} в Hazelcast при передаче из Apache Kafka.<br>
* Входной запрос {@link CouponPeriodNewRequest}:<br>
*/
@Test
public void testNewCurrency() {
clearAllInImdg(couponPeriodImdg);
final String TOPIC = Consts.DESTINATION_COUPON_PERIOD_NEW;
final CouponPeriod currencyPrediction = new CouponPeriod();
currencyPrediction.setSecurityId(securityId);
currencyPrediction.setPeriodEndDate(LocalDate.now());
currencyPrediction.setPeriodStartDate(LocalDate.ofEpochDay(0));
final CouponPeriodNewRequest request = new CouponPeriodNewRequest();
request.setSecurityId(securityId);
request.setPeriodEndDate(LocalDate.now());
request.setPeriodStartDate(LocalDate.ofEpochDay(0));
//ACT
String jsonString = getJsonStringForNew(request, ID);
addRecordToKafka((MockConsumer) couponPeriodService.getConsumer(), TOPIC, PARTITION, 0, jsonString);
//ASSERT
waitingWhenAddedRecordAndCheckIt(ID, mockProducer, producerRecord);
CouponPeriod result = couponPeriodImdg.getSingleObjectBySQL(String.format("securityId = %s", currencyPrediction.getSecurityId()));
currencyPrediction.setId(result.getId());
COUPON_PERIOD_MATCHER.assertMatch(result, currencyPrediction);
}
/**
* {@link CouponPeriodService#updateCouponPeriod(BaseRequest)}
* Тест проверяет обновление сущности {@link CouponPeriod} в Hazelcast при передаче из Apache Kafka.<br>
* Входной запрос {@link CouponPeriodUpdateRequest}:<br>
*/
@Test
public void testUpdateCurrency() {
clearAllInImdg(couponPeriodImdg);
final String TOPIC = Consts.DESTINATION_COUPON_PERIOD_UPDATE;
final CouponPeriod currencyPrediction = new CouponPeriod();
currencyPrediction.setSecurityId(securityId);
currencyPrediction.setPeriodEndDate(LocalDate.ofEpochDay(0));
currencyPrediction.setPeriodStartDate(LocalDate.ofEpochDay(0));
couponPeriodImdg.insert(currencyPrediction);
final CouponPeriodNewRequest request = new CouponPeriodNewRequest();
currencyPrediction.setPeriodEndDate(LocalDate.now());
request.setSecurityId(securityId);
request.setPeriodEndDate(LocalDate.now());
request.setPeriodStartDate(LocalDate.ofEpochDay(0));
//ACT
String jsonString = getJsonStringForUPDATE(request, ID);
addRecordToKafka((MockConsumer) couponPeriodService.getConsumer(), TOPIC, PARTITION, 0, jsonString);
//ASSERT
waitingWhenAddedRecordAndCheckIt(ID, mockProducer, producerRecord);
CouponPeriod result = couponPeriodImdg.getSingleObjectBySQL(String.format("securityId = %s", currencyPrediction.getSecurityId()));
currencyPrediction.setId(result.getId());
COUPON_PERIOD_MATCHER.assertMatch(result, currencyPrediction);
}
}

6
clearing-parent/securities-service/src/test/java/ru/spcex/clearing/securities/service/CurrencyServiceTest.java
View file

@ -17,7 +17,7 @@ import static ru.spcex.clearing.securities.utils.MatcherFactory.usingIgnoringFie
import static ru.spcex.clearing.securities.utils.TestUtils.*;
public class CurrencyServiceTest extends AbstractServiceTest {
private static final MatcherFactory.Matcher<Currency> CURRENCY_MATCHER = usingIgnoringFieldsComparator("created", "updated");
private static final MatcherFactory.Matcher<Currency> CURRENCY_MATCHER = usingIgnoringFieldsComparator();
private final long ID = currentId.getAndIncrement();
private final int PARTITION = 0;
private final String countryCode = "countryCode";
@ -38,7 +38,7 @@ public class CurrencyServiceTest extends AbstractServiceTest {
@Test
public void testNewCurrency() {
clearAllInImdg(currencyImdg);
final String TOPIC = Consts.DESTINATION_СURRENCY_NEW;
final String TOPIC = Consts.DESTINATION_CURRENCY_NEW;
final Currency currencyPrediction = new Currency();
currencyPrediction.setCountryCode(countryCode);
@ -68,7 +68,7 @@ public class CurrencyServiceTest extends AbstractServiceTest {
@Test
public void testUpdateCurrency() {
clearAllInImdg(currencyImdg);
final String TOPIC = Consts.DESTINATION_СURRENCY_UPDATE;
final String TOPIC = Consts.DESTINATION_CURRENCY_UPDATE;
final Currency currencyPrediction = new Currency();
currencyPrediction.setId(ID);
currencyPrediction.setCountryCode("ExistsCountryCode");

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

@ -13,9 +13,10 @@ public interface Consts {
String DESTINATION_FIXED_INCOME_SECURITY_UPDATE = "fixed-income-security-update";
String DESTINATION_FIXED_INCOME_SECURITY_DELETE = "fixed-income-security-delete";
String DESTINATION_СURRENCY_NEW = "currency-new";
String DESTINATION_СURRENCY_UPDATE = "currency-update";
String DESTINATION_СURRENCY_DELETE = "currency-delete";
String DESTINATION_CURRENCY_NEW = "currency-new";
String DESTINATION_CURRENCY_UPDATE = "currency-update";
String DESTINATION_COUPON_PERIOD_NEW = "coupon_period-new";
String DESTINATION_COUPON_PERIOD_UPDATE = "coupon_period-update";
String DESTINATION_KEY_RATE_NEW = "key-rate-new";
String DESTINATION_KEY_RATE_UPDATE = "key-rate-update";

46
platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/securitites/CouponPeriodNewRequest.java Normal file
View file

@ -0,0 +1,46 @@
package ru.spcex.clearing.platform.messaging.domain.cud.securitites;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import ru.spcex.clearing.platform.messaging.domain.json.deserialize.LocalDateDeserializer;
import ru.spcex.clearing.platform.messaging.domain.json.serialize.LocalDateSerializer;
import java.time.LocalDate;
public class CouponPeriodNewRequest {
@JsonProperty
public Long securityId;
@JsonProperty
@JsonSerialize(using = LocalDateSerializer.class)
@JsonDeserialize(using = LocalDateDeserializer.class)
public LocalDate periodEndDate;
@JsonProperty
@JsonSerialize(using = LocalDateSerializer.class)
@JsonDeserialize(using = LocalDateDeserializer.class)
public LocalDate periodStartDate;
public Long getSecurityId() {
return securityId;
}
public void setSecurityId(Long securityId) {
this.securityId = securityId;
}
public LocalDate getPeriodEndDate() {
return periodEndDate;
}
public void setPeriodEndDate(LocalDate periodEndDate) {
this.periodEndDate = periodEndDate;
}
public LocalDate getPeriodStartDate() {
return periodStartDate;
}
public void setPeriodStartDate(LocalDate periodStartDate) {
this.periodStartDate = periodStartDate;
}
}

59
platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/securitites/CouponPeriodUpdateRequest.java Normal file
View file

@ -0,0 +1,59 @@
package ru.spcex.clearing.platform.messaging.domain.cud.securitites;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import ru.spcex.clearing.platform.messaging.domain.json.deserialize.LocalDateDeserializer;
import ru.spcex.clearing.platform.messaging.domain.json.serialize.LocalDateSerializer;
import ru.spcex.platform.classes.base.interfaces.WithId;
import java.time.LocalDate;
public class CouponPeriodUpdateRequest implements WithId {
@JsonProperty
public Long id;
@JsonProperty
public Long securityId;
@JsonProperty
@JsonSerialize(using = LocalDateSerializer.class)
@JsonDeserialize(using = LocalDateDeserializer.class)
public LocalDate periodEndDate;
@JsonProperty
@JsonSerialize(using = LocalDateSerializer.class)
@JsonDeserialize(using = LocalDateDeserializer.class)
public LocalDate periodStartDate;
@Override
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public Long getSecurityId() {
return securityId;
}
public void setSecurityId(Long securityId) {
this.securityId = securityId;
}
public LocalDate getPeriodEndDate() {
return periodEndDate;
}
public void setPeriodEndDate(LocalDate periodEndDate) {
this.periodEndDate = periodEndDate;
}
public LocalDate getPeriodStartDate() {
return periodStartDate;
}
public void setPeriodStartDate(LocalDate periodStartDate) {
this.periodStartDate = periodStartDate;
}
}