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

securities-service рефакторинг обработки запросов.

Browse source
This commit is contained in:
AKurakin 2023-06-21 11:45:53 +03:00
parent 058c5ec1b4
commit fa17164d81
10 changed files with 387 additions and 303 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
clearing-parent/clearing-validation/src/main/java/ru/spcex/clearing/validation/common/ValidationHelper.java
View file

@ -7,6 +7,7 @@ import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate;
import ru.spcex.clearing.platform.messaging.service.Status; import ru.spcex.clearing.platform.messaging.service.Status;
import ru.spcex.platform.utils.enumeration.EnumMessage; import ru.spcex.platform.utils.enumeration.EnumMessage;
import ru.spcex.platform.utils.enumeration.IMessageResolver; import ru.spcex.platform.utils.enumeration.IMessageResolver;
import ru.spcex.platform.utils.error.ValidationException;
import ru.spcex.platform.utils.validation.IValidator; import ru.spcex.platform.utils.validation.IValidator;
import java.util.Objects; import java.util.Objects;
@ -30,7 +31,7 @@ public class ValidationHelper {
* @return null если ошибок нет * @return null если ошибок нет
*/ */
public <R> RequestInfoUpdate validateTillFirstError(BaseRequest<R> userRequest, public <R> RequestInfoUpdate validateTillFirstError(BaseRequest<R> userRequest,
Function<R, IValidator> validatorBuilder) { Function<R, IValidator> validatorBuilder) {
if (validatorBuilder != null) { if (validatorBuilder != null) {
R req = userRequest.getRequestPayload(); R req = userRequest.getRequestPayload();
IValidator validator = validatorBuilder.apply(req); IValidator validator = validatorBuilder.apply(req);
@ -47,6 +48,15 @@ public class ValidationHelper {
return null; return null;
} }
public <R> void validateTillFirstErrorAndThrow(R req,
Function<R, IValidator> validatorBuilder) throws ValidationException {
IValidator validator = validatorBuilder.apply(req);
Optional<EnumMessage> validationError = validator.tillFirstError();
if (validationError.isPresent()) {
throw new ValidationException(validationError.get());
}
}
public IMessageResolver getMessageResolver() { public IMessageResolver getMessageResolver() {
return messageResolver; return messageResolver;

6
clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/config/ErrorResolverConfig.java
View file

@ -16,4 +16,10 @@ public class ErrorResolverConfig {
public IMessageResolver messageResolver(ImdgProvider imdgProvider) { public IMessageResolver messageResolver(ImdgProvider imdgProvider) {
return new IMDGMessageResolver(imdgProvider); return new IMDGMessageResolver(imdgProvider);
} }
@Bean
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
public RequestHelper requestHelper(IMessageResolver messageResolver) {
return new RequestHelper(messageResolver, SecuritiesError.GeneralError);
}
} }

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

@ -17,10 +17,12 @@ import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate; import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate;
import ru.spcex.clearing.securities.validation.ValidationProvider; import ru.spcex.clearing.securities.validation.ValidationProvider;
import ru.spcex.clearing.util.security.UserRoleVerification; import ru.spcex.clearing.util.security.UserRoleVerification;
import ru.spcex.clearing.util.services.RequestHelper;
import ru.spcex.clearing.validation.common.ValidationHelper; import ru.spcex.clearing.validation.common.ValidationHelper;
import ru.spcex.platform.imdg.api.Imdg; import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgId; import ru.spcex.platform.imdg.api.ImdgId;
import ru.spcex.platform.imdg.api.ImdgProvider; import ru.spcex.platform.imdg.api.ImdgProvider;
import ru.spcex.platform.utils.error.ValidationException;
@Service @Service
public class CouponPeriodService extends QueueConsumer implements InitializingBean { public class CouponPeriodService extends QueueConsumer implements InitializingBean {
@ -31,6 +33,7 @@ public class CouponPeriodService extends QueueConsumer implements InitializingBe
private final ValidationProvider validation; private final ValidationProvider validation;
private final ValidationHelper validationHelper; private final ValidationHelper validationHelper;
private final UserRoleVerification userRoleVerification; private final UserRoleVerification userRoleVerification;
private final RequestHelper requestHelper;
@Autowired @Autowired
public CouponPeriodService(Consumer<String, Object> kafkaQueue, public CouponPeriodService(Consumer<String, Object> kafkaQueue,
@ -38,7 +41,8 @@ public class CouponPeriodService extends QueueConsumer implements InitializingBe
ImdgProvider imdgProvider, ImdgProvider imdgProvider,
ValidationProvider validation, ValidationProvider validation,
UserRoleVerification userRoleVerification, UserRoleVerification userRoleVerification,
ValidationHelper validationHelper) { ValidationHelper validationHelper,
RequestHelper requestHelper) {
super(kafkaQueue, kafkaProducer); super(kafkaQueue, kafkaProducer);
this.validation = validation; this.validation = validation;
this.couponPeriodImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_CouponPeriod, CouponPeriod.class); this.couponPeriodImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_CouponPeriod, CouponPeriod.class);
@ -46,6 +50,7 @@ public class CouponPeriodService extends QueueConsumer implements InitializingBe
this.idGenerator = imdgProvider.getImdgIdGenerator(); this.idGenerator = imdgProvider.getImdgIdGenerator();
this.userRoleVerification = userRoleVerification; this.userRoleVerification = userRoleVerification;
this.validationHelper = validationHelper; this.validationHelper = validationHelper;
this.requestHelper = requestHelper;
} }
@Override @Override
@ -60,13 +65,20 @@ public class CouponPeriodService extends QueueConsumer implements InitializingBe
init(); init();
} }
public synchronized RequestInfoUpdate newCouponPeriod(BaseRequest<CouponPeriodNewRequest> userRequest) { public RequestInfoUpdate newCouponPeriod(BaseRequest<CouponPeriodNewRequest> userRequest) {
CouponPeriodNewRequest req = userRequest.getRequestPayload(); log.debug("CouponPeriodNewRequest received id = {}", userRequest.getId());
try {
userRoleVerification.validateRoleAndThrow(userRequest);
CouponPeriod couponPeriod = newCouponPeriod0(userRequest.getRequestPayload());
log.debug("successfully processed, request id {}, new object id {}", userRequest.getId(), couponPeriod.getId());
return null;
} catch (ValidationException e) {
return requestHelper.makeErrorResponse(userRequest, e.getEnumMsg());
}
}
RequestInfoUpdate requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, validation.couponPeriodNewValidator()); public synchronized CouponPeriod newCouponPeriod0(CouponPeriodNewRequest req) throws ValidationException {
if (requestInfoUpdate != null) return requestInfoUpdate; validationHelper.validateTillFirstErrorAndThrow(req, validation.couponPeriodNewValidator());
log.debug("newCurrency received");
CouponPeriod couponPeriod = new CouponPeriod(); CouponPeriod couponPeriod = new CouponPeriod();
couponPeriod.setId(idGenerator.nextId()); couponPeriod.setId(idGenerator.nextId());
couponPeriod.setSecurityId(req.getSecurityId()); couponPeriod.setSecurityId(req.getSecurityId());
@ -75,19 +87,23 @@ public class CouponPeriodService extends QueueConsumer implements InitializingBe
couponPeriod.setPeriodEndDate(req.getPeriodEndDate()); couponPeriod.setPeriodEndDate(req.getPeriodEndDate());
couponPeriod.setPeriodStartDate(req.getPeriodStartDate()); couponPeriod.setPeriodStartDate(req.getPeriodStartDate());
couponPeriodImdg.insert(couponPeriod); couponPeriodImdg.insert(couponPeriod);
log.debug("successfully processed, request id {}, new object id {}", userRequest.getId(), couponPeriod.getId()); return couponPeriod;
return null; // default success
} }
public synchronized RequestInfoUpdate updateCouponPeriod(BaseRequest<CouponPeriodUpdateRequest> userRequest) { public RequestInfoUpdate updateCouponPeriod(BaseRequest<CouponPeriodUpdateRequest> userRequest) {
CouponPeriodUpdateRequest req = userRequest.getRequestPayload(); log.debug("CouponPeriodUpdateRequest received id = {}", userRequest.getId());
log.debug("updateCurrency received id = {}", req.getId()); try {
userRoleVerification.validateRoleAndThrow(userRequest);
CouponPeriod couponPeriod = updateCouponPeriod0(userRequest.getRequestPayload());
log.debug("successfully processed, request id {}, new object id {}", userRequest.getId(), couponPeriod.getId());
return null;
} catch (ValidationException e) {
return requestHelper.makeErrorResponse(userRequest, e.getEnumMsg());
}
}
RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest); public synchronized CouponPeriod updateCouponPeriod0(CouponPeriodUpdateRequest req) throws ValidationException {
if (requestInfoUpdate != null) return requestInfoUpdate; validationHelper.validateTillFirstErrorAndThrow(req, validation.couponPeriodUpdateValidator());
requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, validation.couponPeriodUpdateValidator());
if (requestInfoUpdate != null) return requestInfoUpdate;
CouponPeriod couponPeriod = couponPeriodImdg.getSingleObjectByID(req.getId()); CouponPeriod couponPeriod = couponPeriodImdg.getSingleObjectByID(req.getId());
if (req.getCouponRate() != null) couponPeriod.setCouponRate(req.getCouponRate()); if (req.getCouponRate() != null) couponPeriod.setCouponRate(req.getCouponRate());
@ -95,6 +111,6 @@ public class CouponPeriodService extends QueueConsumer implements InitializingBe
if (req.getPeriodEndDate() != null) couponPeriod.setPeriodEndDate(req.getPeriodEndDate()); if (req.getPeriodEndDate() != null) couponPeriod.setPeriodEndDate(req.getPeriodEndDate());
if (req.getPeriodStartDate() != null) couponPeriod.setPeriodStartDate(req.getPeriodStartDate()); if (req.getPeriodStartDate() != null) couponPeriod.setPeriodStartDate(req.getPeriodStartDate());
couponPeriodImdg.update(couponPeriod); couponPeriodImdg.update(couponPeriod);
return null; return couponPeriod;
} }
} }

112
clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/service/cud/EquitySecurityService.java
View file

@ -17,17 +17,17 @@ import ru.spcex.clearing.platform.messaging.domain.cud.securitites.EquitySecurit
import ru.spcex.clearing.platform.messaging.domain.cud.securitites.EquitySecurityUpdateRequest; import ru.spcex.clearing.platform.messaging.domain.cud.securitites.EquitySecurityUpdateRequest;
import ru.spcex.clearing.platform.messaging.service.QueueConsumer; import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate; 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.securities.validation.ValidationProvider;
import ru.spcex.clearing.util.security.UserRoleVerification; import ru.spcex.clearing.util.security.UserRoleVerification;
import ru.spcex.clearing.util.services.RequestHelper;
import ru.spcex.clearing.validation.common.ValidationHelper; import ru.spcex.clearing.validation.common.ValidationHelper;
import ru.spcex.platform.enumeration.Market;
import ru.spcex.platform.enumeration.UserRole; import ru.spcex.platform.enumeration.UserRole;
import ru.spcex.platform.enumeration.WorkflowStatus; import ru.spcex.platform.enumeration.WorkflowStatus;
import ru.spcex.platform.imdg.api.Imdg; import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgId; import ru.spcex.platform.imdg.api.ImdgId;
import ru.spcex.platform.imdg.api.ImdgProvider; import ru.spcex.platform.imdg.api.ImdgProvider;
import ru.spcex.platform.imdg.api.ImdgTransaction; import ru.spcex.platform.imdg.api.ImdgTransaction;
import ru.spcex.platform.utils.error.ValidationException;
import java.time.Instant; import java.time.Instant;
@ -35,12 +35,12 @@ import java.time.Instant;
public class EquitySecurityService extends QueueConsumer implements InitializingBean { public class EquitySecurityService extends QueueConsumer implements InitializingBean {
private final Logger log = LoggerFactory.getLogger(getClass()); private final Logger log = LoggerFactory.getLogger(getClass());
private final Imdg<EquitySecurity> equitySecurityImdg; private final Imdg<EquitySecurity> equitySecurityImdg;
private final Imdg<Listing> listingImdg;
private final ImdgProvider imdgProvider; private final ImdgProvider imdgProvider;
private final ImdgId idGenerator; private final ImdgId idGenerator;
private final ValidationProvider validation; private final ValidationProvider validation;
private final UserRoleVerification userRoleVerification; private final UserRoleVerification userRoleVerification;
private final ValidationHelper validationHelper; private final ValidationHelper validationHelper;
private final RequestHelper requestHelper;
@Autowired @Autowired
public EquitySecurityService(Consumer<String, Object> kafkaQueue, public EquitySecurityService(Consumer<String, Object> kafkaQueue,
@ -48,15 +48,16 @@ public class EquitySecurityService extends QueueConsumer implements Initializing
ImdgProvider imdgProvider, ImdgProvider imdgProvider,
UserRoleVerification userRoleVerification, UserRoleVerification userRoleVerification,
ValidationProvider validation, ValidationProvider validation,
ValidationHelper validationHelper) { ValidationHelper validationHelper,
RequestHelper requestHelper) {
super(kafkaQueue, kafkaProducer); super(kafkaQueue, kafkaProducer);
this.validation = validation; this.validation = validation;
this.equitySecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_EquitySecurity, EquitySecurity.class); this.equitySecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_EquitySecurity, EquitySecurity.class);
this.listingImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Listing, Listing.class);
this.imdgProvider = imdgProvider; this.imdgProvider = imdgProvider;
this.idGenerator = imdgProvider.getImdgIdGenerator(); this.idGenerator = imdgProvider.getImdgIdGenerator();
this.userRoleVerification = userRoleVerification.setRoleForVerification(UserRole.Admin); this.userRoleVerification = userRoleVerification.setRoleForVerification(UserRole.Admin);
this.validationHelper = validationHelper; this.validationHelper = validationHelper;
this.requestHelper = requestHelper;
} }
@Override @Override
@ -74,12 +75,22 @@ public class EquitySecurityService extends QueueConsumer implements Initializing
init(); init();
} }
protected synchronized RequestInfoUpdate newEquity(BaseRequest<EquitySecurityNewRequest> userRequest) { protected RequestInfoUpdate newEquity(BaseRequest<EquitySecurityNewRequest> userRequest) {
ImdgTransaction transaction = imdgProvider.newTransaction(); log.debug("EquitySecurityNewRequest received, id={}", userRequest.getId());
EquitySecurityNewRequest req = userRequest.getRequestPayload(); try {
userRoleVerification.validateRoleAndThrow(userRequest);
EquitySecurity equitySecurity = newEquity0(userRequest.getRequestPayload());
log.debug("successfully processed, request id {}, new object id {}", userRequest.getId(), equitySecurity.getId());
return null;
} catch (ValidationException e) {
return requestHelper.makeErrorResponse(userRequest, e.getEnumMsg());
}
}
RequestInfoUpdate requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, validation.equityNewValidator()); protected synchronized EquitySecurity newEquity0(EquitySecurityNewRequest req) throws ValidationException {
if (requestInfoUpdate != null) return requestInfoUpdate; ImdgTransaction transaction = imdgProvider.newTransaction();
validationHelper.validateTillFirstErrorAndThrow(req, validation.equityNewValidator());
log.debug("EquitySecurityNewRequest received"); log.debug("EquitySecurityNewRequest received");
EquitySecurity equity = new EquitySecurity(); EquitySecurity equity = new EquitySecurity();
@ -105,33 +116,28 @@ public class EquitySecurityService extends QueueConsumer implements Initializing
try { try {
transaction.beginTransaction(); transaction.beginTransaction();
Imdg<EquitySecurity> equityImdg = transaction.getImdg(IMDGDistributedNames.Map_EquitySecurity, EquitySecurity.class); Imdg<EquitySecurity> equityImdg = transaction.getImdg(IMDGDistributedNames.Map_EquitySecurity, EquitySecurity.class);
// Imdg<Listing> listingMap = transaction.getImdg(IMDGDistributedNames.Map_Listing, Listing.class);
//одним скопом выполняем реквест
equityImdg.insert(equity); equityImdg.insert(equity);
// Listing listing = ListingBuilder.builder()
// .append(equity).append(req).build();
// listingMap.insert(listing);
//и сохраняем обновленный
// reqInfoMap.insert(reqInfo);
transaction.commitTransaction(); transaction.commitTransaction();
} catch (Throwable e) { } catch (Throwable e) {
transaction.rollbackTransaction(); transaction.rollbackTransaction();
// RequestInfo.update(reqInfo, Status.Error, ExceptionUtils.getStackTrace(e));
// requestInfoImdg.insert(reqInfo);
} }
log.debug("successfully processed, request id {}, new object id {}", userRequest.getId(), equity.getId()); return equity;
return null; // default success
} }
protected synchronized RequestInfoUpdate updateEquity(BaseRequest<EquitySecurityUpdateRequest> userRequest) { protected RequestInfoUpdate updateEquity(BaseRequest<EquitySecurityUpdateRequest> userRequest) {
EquitySecurityUpdateRequest req = userRequest.getRequestPayload(); log.debug("EquitySecurityUpdateRequest received, id={}", userRequest.getId());
log.debug("MoneyMarketSecurityUpdateRequest received id = {}", req.getId()); try {
userRoleVerification.validateRoleAndThrow(userRequest);
EquitySecurity equitySecurity = updateEquity0(userRequest.getRequestPayload());
log.debug("successfully processed, request id {}, updated object id {}", userRequest.getId(), equitySecurity.getId());
return null;
} catch (ValidationException e) {
return requestHelper.makeErrorResponse(userRequest, e.getEnumMsg());
}
}
RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest); protected synchronized EquitySecurity updateEquity0(EquitySecurityUpdateRequest req) throws ValidationException {
if (requestInfoUpdate != null) return requestInfoUpdate; validationHelper.validateTillFirstErrorAndThrow(req, validation.equityUpdateValidator());
requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, validation.equityUpdateValidator());
if (requestInfoUpdate != null) return requestInfoUpdate;
EquitySecurity equity = equitySecurityImdg.getSingleObjectByID(req.getId()); EquitySecurity equity = equitySecurityImdg.getSingleObjectByID(req.getId());
Instant updateTime = Instant.now(); Instant updateTime = Instant.now();
@ -151,25 +157,23 @@ public class EquitySecurityService extends QueueConsumer implements Initializing
equity.setInstrumentType(req.getInstrumentType()); equity.setInstrumentType(req.getInstrumentType());
equitySecurityImdg.update(equity); equitySecurityImdg.update(equity);
// Listing listing = listingImdg.getSingleObjectByFieldValues(Map.of("securityId", equity.getId())); return equity;
// if (listing == null) {
// log.error("MoneyMarketSecurityUpdateRequest id {} couldn't find listing with securityId {}", req.getId(), equity.getId());
// return null;
// }
// listing = updateListingByEquity(equity, listing);
// listingImdg.update(listing);
return null;
} }
private RequestInfoUpdate deleteEquity(BaseRequest<CommonDeleteRequest> userRequest) { private RequestInfoUpdate deleteEquity(BaseRequest<CommonDeleteRequest> userRequest) {
CommonDeleteRequest req = userRequest.getRequestPayload(); log.debug("CommonDeleteRequest received id = {}", userRequest.getId());
log.debug("CommonDeleteRequest received id = {}", req.getId()); try {
userRoleVerification.validateRoleAndThrow(userRequest);
Long equityId = deleteEquity0(userRequest.getRequestPayload());
log.debug("successfully processed, request id {}, delete object id {}", userRequest.getId(), equityId);
return null;
} catch (ValidationException e) {
return requestHelper.makeErrorResponse(userRequest, e.getEnumMsg());
}
}
RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest); protected synchronized Long deleteEquity0(CommonDeleteRequest req) throws ValidationException {
if (requestInfoUpdate != null) return requestInfoUpdate; validationHelper.validateTillFirstErrorAndThrow(req, validation.equityDeleteValidator());
requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, validation.equityDeleteValidator());
if (requestInfoUpdate != null) return requestInfoUpdate;
Instant updateTime = Instant.now(); Instant updateTime = Instant.now();
EquitySecurity equity = equitySecurityImdg.getSingleObjectByID(req.getId()); EquitySecurity equity = equitySecurityImdg.getSingleObjectByID(req.getId());
@ -177,25 +181,7 @@ public class EquitySecurityService extends QueueConsumer implements Initializing
equity.setUpdated(updateTime); equity.setUpdated(updateTime);
equitySecurityImdg.update(equity); equitySecurityImdg.update(equity);
// Listing listing = listingImdg.getSingleObjectByFieldValues(Map.of("securityId", equity.getId())); return equity.getId();
// if (listing == null) {
// log.error("CommonDeleteRequest id {} couldn't find listing with securityId {}", req.getId(), equity.getId());
// return null;
// }
// listing.setWorkflowStatus(ru.spcex.platform.enumeration.Status.Blocked.getKey());
// listing.setUpdated(updateTime);
// listingImdg.update(listing);
return null;
} }
public Listing updateListingByEquity(EquitySecurity equitySecurity, Listing listing) {
listing.setSecurityId(equitySecurity.getId());
listing.setSymbolCode(equitySecurity.getSecuritySymbol());
listing.setSymbolName(equitySecurity.getFullName());
listing.setWorkflowStatus(equitySecurity.getWorkflowStatus());
listing.setMarket(Market.mkrs.getKey());
listing.setLotSize(equitySecurity.getLotSize());
listing.setUpdated(equitySecurity.getUpdated());
return listing;
}
} }

50
clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/service/cud/FixedIncomeCashFlowService.java
View file

@ -16,10 +16,12 @@ import ru.spcex.clearing.platform.messaging.domain.cud.securitites.FixedIncomeCa
import ru.spcex.clearing.platform.messaging.service.QueueConsumer; import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate; import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate;
import ru.spcex.clearing.util.security.UserRoleVerification; import ru.spcex.clearing.util.security.UserRoleVerification;
import ru.spcex.clearing.util.services.RequestHelper;
import ru.spcex.clearing.validation.common.ValidationHelper; import ru.spcex.clearing.validation.common.ValidationHelper;
import ru.spcex.platform.enumeration.UserRole; import ru.spcex.platform.enumeration.UserRole;
import ru.spcex.platform.imdg.api.Imdg; import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgProvider; import ru.spcex.platform.imdg.api.ImdgProvider;
import ru.spcex.platform.utils.error.ValidationException;
import ru.spcex.platform.utils.validation.IValidator; import ru.spcex.platform.utils.validation.IValidator;
import java.util.function.Function; import java.util.function.Function;
@ -31,6 +33,7 @@ public class FixedIncomeCashFlowService extends QueueConsumer implements Initial
private final ImdgProvider imdgProvider; private final ImdgProvider imdgProvider;
private final UserRoleVerification userRoleVerification; private final UserRoleVerification userRoleVerification;
private final ValidationHelper validationHelper; private final ValidationHelper validationHelper;
private final RequestHelper requestHelper;
private final Function<FixedIncomeCashFlowNewRequest, IValidator> fixedIncomeCashFlowNewRequestValidator; private final Function<FixedIncomeCashFlowNewRequest, IValidator> fixedIncomeCashFlowNewRequestValidator;
private final Function<FixedIncomeCashFlowUpdateRequest, IValidator> fixedIncomeCashFlowUpdateRequestValidator; private final Function<FixedIncomeCashFlowUpdateRequest, IValidator> fixedIncomeCashFlowUpdateRequestValidator;
@ -40,12 +43,14 @@ public class FixedIncomeCashFlowService extends QueueConsumer implements Initial
ImdgProvider imdgProvider, ImdgProvider imdgProvider,
UserRoleVerification userRoleVerification, UserRoleVerification userRoleVerification,
ValidationHelper validationHelper, ValidationHelper validationHelper,
RequestHelper requestHelper,
@Qualifier("fixedIncomeCashFlowNewRequestValidator") Function<FixedIncomeCashFlowNewRequest, IValidator> fixedIncomeCashFlowNewRequestValidator, @Qualifier("fixedIncomeCashFlowNewRequestValidator") Function<FixedIncomeCashFlowNewRequest, IValidator> fixedIncomeCashFlowNewRequestValidator,
@Qualifier("fixedIncomeCashFlowUpdateRequestValidator") Function<FixedIncomeCashFlowUpdateRequest, IValidator> fixedIncomeCashFlowUpdateRequestValidator) { @Qualifier("fixedIncomeCashFlowUpdateRequestValidator") Function<FixedIncomeCashFlowUpdateRequest, IValidator> fixedIncomeCashFlowUpdateRequestValidator) {
super(kafkaQueue, kafkaResponseQueue); super(kafkaQueue, kafkaResponseQueue);
this.imdgProvider = imdgProvider; this.imdgProvider = imdgProvider;
this.userRoleVerification = userRoleVerification.setRoleForVerification(UserRole.Admin); this.userRoleVerification = userRoleVerification.setRoleForVerification(UserRole.Admin);
this.validationHelper = validationHelper; this.validationHelper = validationHelper;
this.requestHelper = requestHelper;
this.fixedIncomeCashFlowNewRequestValidator = fixedIncomeCashFlowNewRequestValidator; this.fixedIncomeCashFlowNewRequestValidator = fixedIncomeCashFlowNewRequestValidator;
this.fixedIncomeCashFlowUpdateRequestValidator = fixedIncomeCashFlowUpdateRequestValidator; this.fixedIncomeCashFlowUpdateRequestValidator = fixedIncomeCashFlowUpdateRequestValidator;
this.fixedIncomeCashFlowImdg = imdgProvider.getImdg( this.fixedIncomeCashFlowImdg = imdgProvider.getImdg(
@ -65,13 +70,21 @@ public class FixedIncomeCashFlowService extends QueueConsumer implements Initial
init(); init();
} }
public synchronized RequestInfoUpdate fixedIncomeCashFlowNew(BaseRequest<FixedIncomeCashFlowNewRequest> userRequest) { public RequestInfoUpdate fixedIncomeCashFlowNew(BaseRequest<FixedIncomeCashFlowNewRequest> userRequest) {
log.debug("FixedIncomeCashFlowNewRequest received {}", userRequest.getId()); log.debug("FixedIncomeCashFlowNewRequest received id = {}", userRequest.getId());
try {
userRoleVerification.validateRoleAndThrow(userRequest);
FixedIncomeCashFlow fixedIncomeCashFlow = fixedIncomeCashFlowNew0(userRequest.getRequestPayload());
log.debug("successfully processed, request id {}, new object id {}", userRequest.getId(), fixedIncomeCashFlow.getId());
return null;
} catch (ValidationException e) {
return requestHelper.makeErrorResponse(userRequest, e.getEnumMsg());
}
}
RequestInfoUpdate requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, fixedIncomeCashFlowNewRequestValidator); public synchronized FixedIncomeCashFlow fixedIncomeCashFlowNew0(FixedIncomeCashFlowNewRequest req) throws ValidationException {
if (requestInfoUpdate != null) return requestInfoUpdate; validationHelper.validateTillFirstErrorAndThrow(req, fixedIncomeCashFlowNewRequestValidator);
FixedIncomeCashFlowNewRequest req = userRequest.getRequestPayload();
FixedIncomeCashFlow fixedIncomeCashFlow = new FixedIncomeCashFlow(); FixedIncomeCashFlow fixedIncomeCashFlow = new FixedIncomeCashFlow();
fixedIncomeCashFlow.setSecurityId(Long.valueOf(req.getSecuritySymbol())); fixedIncomeCashFlow.setSecurityId(Long.valueOf(req.getSecuritySymbol()));
fixedIncomeCashFlow.setAccruedCoupon(req.getAccruedCoupon()); fixedIncomeCashFlow.setAccruedCoupon(req.getAccruedCoupon());
@ -80,21 +93,24 @@ public class FixedIncomeCashFlowService extends QueueConsumer implements Initial
fixedIncomeCashFlow.setValueDate(req.getValueDate()); fixedIncomeCashFlow.setValueDate(req.getValueDate());
Long id = fixedIncomeCashFlowImdg.insert(fixedIncomeCashFlow); Long id = fixedIncomeCashFlowImdg.insert(fixedIncomeCashFlow);
log.debug("successfully processed, id {}", id); return fixedIncomeCashFlow;
return null;
} }
public synchronized RequestInfoUpdate fixedIncomeCashFlowUpdate(BaseRequest<FixedIncomeCashFlowUpdateRequest> userRequest) { public RequestInfoUpdate fixedIncomeCashFlowUpdate(BaseRequest<FixedIncomeCashFlowUpdateRequest> userRequest) {
log.debug("FixedIncomeCashFlowUpdateRequest received {}", userRequest.getId()); log.debug("FixedIncomeCashFlowUpdateRequest received id = {}", userRequest.getId());
try {
userRoleVerification.validateRoleAndThrow(userRequest);
FixedIncomeCashFlow fixedIncomeCashFlow = fixedIncomeCashFlowUpdate0(userRequest.getRequestPayload());
log.debug("successfully processed, request id {}, update object id {}", userRequest.getId(), fixedIncomeCashFlow.getId());
return null;
} catch (ValidationException e) {
return requestHelper.makeErrorResponse(userRequest, e.getEnumMsg());
}
}
RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest); public synchronized FixedIncomeCashFlow fixedIncomeCashFlowUpdate0(FixedIncomeCashFlowUpdateRequest req) throws ValidationException {
if (requestInfoUpdate != null) return requestInfoUpdate; validationHelper.validateTillFirstErrorAndThrow(req, fixedIncomeCashFlowUpdateRequestValidator);
requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, fixedIncomeCashFlowUpdateRequestValidator);
if (requestInfoUpdate != null) return requestInfoUpdate;
FixedIncomeCashFlowUpdateRequest req = userRequest.getRequestPayload();
FixedIncomeCashFlow fixedIncomeCashFlow = fixedIncomeCashFlowImdg.getSingleObjectByID(req.getId()); FixedIncomeCashFlow fixedIncomeCashFlow = fixedIncomeCashFlowImdg.getSingleObjectByID(req.getId());
if (req.getAccruedCoupon() != null) fixedIncomeCashFlow.setAccruedCoupon(req.getAccruedCoupon()); if (req.getAccruedCoupon() != null) fixedIncomeCashFlow.setAccruedCoupon(req.getAccruedCoupon());
@ -105,7 +121,7 @@ public class FixedIncomeCashFlowService extends QueueConsumer implements Initial
fixedIncomeCashFlowImdg.update(fixedIncomeCashFlow); fixedIncomeCashFlowImdg.update(fixedIncomeCashFlow);
log.debug("successfully processed, id {}", fixedIncomeCashFlow.getId()); log.debug("successfully processed, id {}", fixedIncomeCashFlow.getId());
return null; return fixedIncomeCashFlow;
} }
} }

127
clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/service/cud/FixedIncomeSecurityService.java
View file

@ -20,26 +20,30 @@ import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate;
import ru.spcex.clearing.securities.component.ListingBuilder; import ru.spcex.clearing.securities.component.ListingBuilder;
import ru.spcex.clearing.securities.validation.ValidationProvider; import ru.spcex.clearing.securities.validation.ValidationProvider;
import ru.spcex.clearing.util.security.UserRoleVerification; import ru.spcex.clearing.util.security.UserRoleVerification;
import ru.spcex.clearing.util.services.RequestHelper;
import ru.spcex.clearing.validation.common.ValidationHelper; import ru.spcex.clearing.validation.common.ValidationHelper;
import ru.spcex.platform.enumeration.UserRole; import ru.spcex.platform.enumeration.UserRole;
import ru.spcex.platform.enumeration.WorkflowStatus; import ru.spcex.platform.enumeration.WorkflowStatus;
import ru.spcex.platform.imdg.api.Imdg; import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgId; import ru.spcex.platform.imdg.api.ImdgId;
import ru.spcex.platform.imdg.api.ImdgProvider; import ru.spcex.platform.imdg.api.ImdgProvider;
import ru.spcex.platform.imdg.api.ImdgTransaction; import ru.spcex.platform.utils.enumeration.EnumMessage;
import ru.spcex.platform.utils.error.ValidationException;
import ru.spcex.platform.utils.validation.IValidator;
import java.time.Instant; import java.time.Instant;
import java.util.Optional;
@Service @Service
public class FixedIncomeSecurityService extends QueueConsumer implements InitializingBean { public class FixedIncomeSecurityService extends QueueConsumer implements InitializingBean {
private final Logger log = LoggerFactory.getLogger(getClass()); private final Logger log = LoggerFactory.getLogger(getClass());
private final Imdg<FixedIncomeSecurity> fixedIncomeSecurityImdg; private final Imdg<FixedIncomeSecurity> fixedIncomeSecurityImdg;
private final Imdg<Listing> listingImdg;
private final ImdgProvider imdgProvider; private final ImdgProvider imdgProvider;
private final ImdgId idGenerator; private final ImdgId idGenerator;
private final ValidationProvider validation; private final ValidationProvider validation;
private final UserRoleVerification userRoleVerification; private final UserRoleVerification userRoleVerification;
private final ValidationHelper validationHelper; private final ValidationHelper validationHelper;
private final RequestHelper requestHelper;
@Autowired @Autowired
public FixedIncomeSecurityService(Consumer<String, Object> kafkaQueue, public FixedIncomeSecurityService(Consumer<String, Object> kafkaQueue,
@ -47,15 +51,16 @@ public class FixedIncomeSecurityService extends QueueConsumer implements Initial
ImdgProvider imdgProvider, ImdgProvider imdgProvider,
ValidationProvider validation, ValidationProvider validation,
UserRoleVerification userRoleVerification, UserRoleVerification userRoleVerification,
ValidationHelper validationHelper) { ValidationHelper validationHelper,
RequestHelper requestHelper) {
super(kafkaQueue, kafkaProducer); super(kafkaQueue, kafkaProducer);
this.validation = validation; this.validation = validation;
this.fixedIncomeSecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_FixedIncomeSecurity, FixedIncomeSecurity.class); this.fixedIncomeSecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_FixedIncomeSecurity, FixedIncomeSecurity.class);
this.listingImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Listing, Listing.class);
this.imdgProvider = imdgProvider; this.imdgProvider = imdgProvider;
this.idGenerator = imdgProvider.getImdgIdGenerator(); this.idGenerator = imdgProvider.getImdgIdGenerator();
this.userRoleVerification = userRoleVerification.setRoleForVerification(UserRole.Admin); this.userRoleVerification = userRoleVerification.setRoleForVerification(UserRole.Admin);
this.validationHelper = validationHelper; this.validationHelper = validationHelper;
this.requestHelper = requestHelper.setLogger(log);
} }
@Override @Override
@ -73,14 +78,28 @@ public class FixedIncomeSecurityService extends QueueConsumer implements Initial
init(); init();
} }
protected synchronized RequestInfoUpdate newFixedIncome(BaseRequest<FixedIncomeSecurityNewRequest> userRequest) {
ImdgTransaction transaction = imdgProvider.newTransaction();
FixedIncomeSecurityNewRequest req = userRequest.getRequestPayload();
RequestInfoUpdate requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, validation.fixedIncomeNewValidator()); protected RequestInfoUpdate newFixedIncome(BaseRequest<FixedIncomeSecurityNewRequest> userRequest) {
log.debug("FixedIncomeSecurityNewRequest received, id={}", userRequest.getId());
RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest);
if (requestInfoUpdate != null) return requestInfoUpdate; if (requestInfoUpdate != null) return requestInfoUpdate;
FixedIncomeSecurity fixedIncome = null;
try {
fixedIncome = newFixedIncome0(userRequest.getRequestPayload());
log.debug("successfully processed, request id {}, new object id {}", userRequest.getId(), fixedIncome.getId());
return null;
} catch (ValidationException e) {
return requestHelper.makeErrorResponse(userRequest, e.getEnumMsg());
}
}
protected synchronized FixedIncomeSecurity newFixedIncome0(FixedIncomeSecurityNewRequest req) throws ValidationException {
IValidator validator = validation.fixedIncomeNewValidator().apply(req);
Optional<EnumMessage> validationError = validator.tillFirstError();
if (validationError.isPresent()) {
throw new ValidationException(validationError.get());
}
log.debug("newFixedIncome received");
FixedIncomeSecurity fixedIncome = new FixedIncomeSecurity(); FixedIncomeSecurity fixedIncome = new FixedIncomeSecurity();
fixedIncome.setId(idGenerator.nextId()); fixedIncome.setId(idGenerator.nextId());
fixedIncome.setSecuritySymbol(req.getSecuritySymbol()); fixedIncome.setSecuritySymbol(req.getSecuritySymbol());
@ -106,37 +125,23 @@ public class FixedIncomeSecurityService extends QueueConsumer implements Initial
fixedIncome.setSecurityId(fixedIncome.getId()); fixedIncome.setSecurityId(fixedIncome.getId());
fixedIncome.setCreated(Instant.now()); fixedIncome.setCreated(Instant.now());
fixedIncome.setUpdated(fixedIncome.getCreated()); fixedIncome.setUpdated(fixedIncome.getCreated());
try { fixedIncomeSecurityImdg.insert(fixedIncome);
transaction.beginTransaction(); return fixedIncome;
Imdg<FixedIncomeSecurity> fixedIncomeImdg = transaction.getImdg(IMDGDistributedNames.Map_FixedIncomeSecurity, FixedIncomeSecurity.class);
// Imdg<Listing> listingMap = transaction.getImdg(IMDGDistributedNames.Map_Listing, Listing.class);
//одним скопом выполняем реквест
fixedIncomeImdg.insert(fixedIncome);
// Listing listing = ListingBuilder.builder()
// .append(fixedIncome).append(req).build();
// listingMap.insert(listing);
//и сохраняем обновленный
// reqInfoMap.insert(reqInfo);
transaction.commitTransaction();
} catch (Throwable e) {
transaction.rollbackTransaction();
// RequestInfo.update(reqInfo, Status.Error, ExceptionUtils.getStackTrace(e));
// requestInfoImdg.insert(reqInfo);
}
log.debug("successfully processed, request id {}, new object id {}", userRequest.getId(), fixedIncome.getId());
return null; // default success
} }
protected synchronized RequestInfoUpdate updateFixedIncome(BaseRequest<FixedIncomeSecurityUpdateRequest> userRequest) { protected RequestInfoUpdate updateFixedIncome(BaseRequest<FixedIncomeSecurityUpdateRequest> userRequest) {
FixedIncomeSecurityUpdateRequest req = userRequest.getRequestPayload(); log.debug("FixedIncomeSecurityUpdateRequest received id = {} (update object id={})", userRequest.getId(), userRequest.getRequestPayload() == null ? null : userRequest.getRequestPayload().getId());
log.debug("updateFixedIncome received id = {}", req.getId()); try {
userRoleVerification.validateRoleAndThrow(userRequest);
RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest); FixedIncomeSecurity fixedIncome = updateFixedIncome0(userRequest.getRequestPayload());
if (requestInfoUpdate != null) return requestInfoUpdate; log.debug("successfully processed, request id {}, new object id {}", userRequest.getId(), fixedIncome.getId());
return null;
requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, validation.fixedIncomeUpdateValidator()); } catch (ValidationException e) {
if (requestInfoUpdate != null) return requestInfoUpdate; return requestHelper.makeErrorResponse(userRequest, e.getEnumMsg());
}
}
protected synchronized FixedIncomeSecurity updateFixedIncome0(FixedIncomeSecurityUpdateRequest req) throws ValidationException {
FixedIncomeSecurity fixedIncome = fixedIncomeSecurityImdg.getSingleObjectByID(req.getId()); FixedIncomeSecurity fixedIncome = fixedIncomeSecurityImdg.getSingleObjectByID(req.getId());
Instant updateTime = Instant.now(); Instant updateTime = Instant.now();
fixedIncome.setUpdated(updateTime); fixedIncome.setUpdated(updateTime);
@ -161,25 +166,23 @@ public class FixedIncomeSecurityService extends QueueConsumer implements Initial
fixedIncome.setSecurityId(fixedIncome.getId()); fixedIncome.setSecurityId(fixedIncome.getId());
fixedIncomeSecurityImdg.update(fixedIncome); fixedIncomeSecurityImdg.update(fixedIncome);
// Listing listing = listingImdg.getSingleObjectByFieldValues(Map.of("securityId", fixedIncome.getId())); return fixedIncome;
// if (listing == null) {
// log.error("updateFixedIncome id {} couldn't find listing with securityId {}", req.getId(), fixedIncome.getId());
// return null;
// }
// listing = updateListingByFixedIncome(fixedIncome, listing);
// listingImdg.update(listing);
return null;
} }
private RequestInfoUpdate deleteFixedIncome(BaseRequest<CommonDeleteRequest> userRequest) { protected RequestInfoUpdate deleteFixedIncome(BaseRequest<CommonDeleteRequest> userRequest) {
CommonDeleteRequest req = userRequest.getRequestPayload(); log.debug("CommonDeleteRequest received id = {} (object id={})", userRequest.getId(), userRequest.getRequestPayload() == null ? null : userRequest.getRequestPayload().getId());
log.debug("CommonDeleteRequest received id = {}", req.getId()); try {
userRoleVerification.validateRoleAndThrow(userRequest);
Long id = deleteFixedIncome0(userRequest.getRequestPayload());
log.debug("successfully processed, request id {}, delete object id {}", userRequest.getId(), id);
return null;
} catch (ValidationException e) {
return requestHelper.makeErrorResponse(userRequest, e.getEnumMsg());
}
}
RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest); protected synchronized Long deleteFixedIncome0(CommonDeleteRequest req) throws ValidationException {
if (requestInfoUpdate != null) return requestInfoUpdate; validationHelper.validateTillFirstErrorAndThrow(req, validation.fixedIncomeDeleteValidator());
requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, validation.fixedIncomeDeleteValidator());
if (requestInfoUpdate != null) return requestInfoUpdate;
Instant updateTime = Instant.now(); Instant updateTime = Instant.now();
FixedIncomeSecurity equity = fixedIncomeSecurityImdg.getSingleObjectByID(req.getId()); FixedIncomeSecurity equity = fixedIncomeSecurityImdg.getSingleObjectByID(req.getId());
@ -187,25 +190,7 @@ public class FixedIncomeSecurityService extends QueueConsumer implements Initial
equity.setUpdated(updateTime); equity.setUpdated(updateTime);
fixedIncomeSecurityImdg.update(equity); fixedIncomeSecurityImdg.update(equity);
// Listing listing = listingImdg.getSingleObjectByFieldValues(Map.of("securityId", equity.getId()));
// if (listing == null) {
// log.error("CommonDeleteRequest id {} couldn't find listing with securityId {}", req.getId(), equity.getId());
// return null;
// }
// listing.setWorkflowStatus(ru.spcex.platform.enumeration.Status.Blocked.getKey());
// listing.setUpdated(updateTime);
// listingImdg.update(listing);
return null; return null;
} }
public Listing updateListingByFixedIncome(FixedIncomeSecurity fixedIncomeSecurity, Listing listing) {
listing.setSecurityId(fixedIncomeSecurity.getId());
listing.setSymbolCode(fixedIncomeSecurity.getSecuritySymbol());
listing.setSymbolName(fixedIncomeSecurity.getFullName());
listing.setTradingCurrency(fixedIncomeSecurity.getNominalCurrency());
listing.setWorkflowStatus(fixedIncomeSecurity.getWorkflowStatus());
listing.setLotSize(fixedIncomeSecurity.getLotSize());
listing.setUpdated(fixedIncomeSecurity.getUpdated());
return listing;
}
} }

178
clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/service/cud/GatewaySecurityService.java
View file

@ -7,6 +7,7 @@ import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.InitializingBean; import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import ru.clearing.classes.statics.data.company.Company;
import ru.clearing.classes.statics.data.company.CompanySymbols; import ru.clearing.classes.statics.data.company.CompanySymbols;
import ru.clearing.classes.statics.data.instrument.issue.CouponPeriod; 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.EquitySecurity;
@ -24,18 +25,18 @@ import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate; import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate;
import ru.spcex.clearing.securities.validation.ValidationProvider; import ru.spcex.clearing.securities.validation.ValidationProvider;
import ru.spcex.clearing.util.security.UserRoleVerification; import ru.spcex.clearing.util.security.UserRoleVerification;
import ru.spcex.clearing.util.services.RequestHelper;
import ru.spcex.clearing.validation.common.ValidationHelper; import ru.spcex.clearing.validation.common.ValidationHelper;
import ru.spcex.platform.enumeration.CompanySymbol; import ru.spcex.platform.enumeration.CompanySymbol;
import ru.spcex.platform.enumeration.InstrumentType; import ru.spcex.platform.enumeration.InstrumentType;
import ru.spcex.platform.enumeration.UserRole; import ru.spcex.platform.enumeration.UserRole;
import ru.spcex.platform.enumeration.WorkflowStatus;
import ru.spcex.platform.imdg.api.Imdg; import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgId; import ru.spcex.platform.imdg.api.ImdgId;
import ru.spcex.platform.imdg.api.ImdgProvider; import ru.spcex.platform.imdg.api.ImdgProvider;
import ru.spcex.platform.utils.error.ValidationException;
import java.util.ArrayList; import java.util.*;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
@Service @Service
public class GatewaySecurityService extends QueueConsumer implements InitializingBean { public class GatewaySecurityService extends QueueConsumer implements InitializingBean {
@ -47,18 +48,20 @@ public class GatewaySecurityService extends QueueConsumer implements Initializin
private final Imdg<CouponPeriod> couponPeriodImdg; private final Imdg<CouponPeriod> couponPeriodImdg;
private final Imdg<FixedIncomeCashFlow> fixedIncomeCashFlowImdg; private final Imdg<FixedIncomeCashFlow> fixedIncomeCashFlowImdg;
private final Imdg<CompanySymbols> companySymbolsImdg; private final Imdg<CompanySymbols> companySymbolsImdg;
private final Imdg<Company> companyImdg;
private final ImdgProvider imdgProvider; private final ImdgProvider imdgProvider;
private final ImdgId idGenerator; private final ImdgId idGenerator;
final FixedIncomeSecurityService fixedIncomeSecurityService; private final FixedIncomeSecurityService fixedIncomeSecurityService;
final EquitySecurityService equitySecurityService; private final EquitySecurityService equitySecurityService;
final ListingService listingService; private final ListingService listingService;
final CouponPeriodService couponPeriodService; private final CouponPeriodService couponPeriodService;
final FixedIncomeCashFlowService fixedIncomeCashFlowService; private final FixedIncomeCashFlowService fixedIncomeCashFlowService;
private final ValidationProvider validation; private final ValidationProvider validation;
private final UserRoleVerification userRoleVerification; private final UserRoleVerification userRoleVerification;
private final ValidationHelper validationHelper; private final ValidationHelper validationHelper;
private final RequestHelper requestHelper;
@Autowired @Autowired
public GatewaySecurityService(Consumer<String, Object> kafkaQueue, public GatewaySecurityService(Consumer<String, Object> kafkaQueue,
@ -67,6 +70,7 @@ public class GatewaySecurityService extends QueueConsumer implements Initializin
ValidationProvider validation, ValidationProvider validation,
UserRoleVerification userRoleVerification, UserRoleVerification userRoleVerification,
ValidationHelper validationHelper, ValidationHelper validationHelper,
RequestHelper requestHelper,
FixedIncomeSecurityService fixedIncomeSecurityService, FixedIncomeSecurityService fixedIncomeSecurityService,
EquitySecurityService equitySecurityService, EquitySecurityService equitySecurityService,
@ -81,10 +85,12 @@ public class GatewaySecurityService extends QueueConsumer implements Initializin
this.couponPeriodImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_CouponPeriod, CouponPeriod.class); this.couponPeriodImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_CouponPeriod, CouponPeriod.class);
this.fixedIncomeCashFlowImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_FixedIncomeCashFlow, FixedIncomeCashFlow.class); this.fixedIncomeCashFlowImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_FixedIncomeCashFlow, FixedIncomeCashFlow.class);
this.companySymbolsImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_CompanySymbols, CompanySymbols.class); this.companySymbolsImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_CompanySymbols, CompanySymbols.class);
this.companyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class);
this.imdgProvider = imdgProvider; this.imdgProvider = imdgProvider;
this.idGenerator = imdgProvider.getImdgIdGenerator(); this.idGenerator = imdgProvider.getImdgIdGenerator();
this.userRoleVerification = userRoleVerification.setRoleForVerification(UserRole.Admin); this.userRoleVerification = userRoleVerification.setRoleForVerification(UserRole.Admin);
this.validationHelper = validationHelper; this.validationHelper = validationHelper;
this.requestHelper = requestHelper;
this.fixedIncomeSecurityService = fixedIncomeSecurityService; this.fixedIncomeSecurityService = fixedIncomeSecurityService;
this.equitySecurityService = equitySecurityService; this.equitySecurityService = equitySecurityService;
@ -123,7 +129,10 @@ public class GatewaySecurityService extends QueueConsumer implements Initializin
// Проверяем, что в базе помимо реквизита есть компания // Проверяем, что в базе помимо реквизита есть компания
Long companyId = companySymbols.iterator().next().getCompanyId(); Long companyId = companySymbols.iterator().next().getCompanyId();
// Company company = companyImdg.getSingleObjectByID(companyId); Company company = companyImdg.getSingleObjectByID(companyId);
if (company == null || !WorkflowStatus.Active.equalsByKey(company.getWorkflowStatus())) {
log.info("Found companySymbols UUID {}, company.id={} not exist or disabled", byUuid, companyId);
}
return companyId; return companyId;
} }
@ -156,39 +165,39 @@ public class GatewaySecurityService extends QueueConsumer implements Initializin
// ImdgTransaction transaction = imdgProvider.newTransaction(); todo transaction // ImdgTransaction transaction = imdgProvider.newTransaction(); todo transaction
Security security = null; Security security = null;
if (req.getSecurity() != null && InstrumentType.BOND.equalsByKey(req.getSecurityType())) {
FixedIncomeSecurityNewRequest fixedIncomeRequest = (FixedIncomeSecurityNewRequest) req.getSecurity();
fixedIncomeRequest.setIssuerId(companyId);
log.trace("FixedIncomeSecurityNewRequest - BOND");
String securitySymbol = fixedIncomeRequest.getSecuritySymbol();
security = findSecurityBySecuritySymbol(fixedIncomeSecurityImdg, securitySymbol);
if (security == null) { try {
RequestInfoUpdate resp = fixedIncomeSecurityService.newFixedIncome(wrapRequest(baseRequest, fixedIncomeRequest, null)); if (req.getSecurity() != null && InstrumentType.BOND.equalsByKey(req.getSecurityType())) {
validateReply(companyId, "newFixedIncome", resp); FixedIncomeSecurityNewRequest fixedIncomeRequest = (FixedIncomeSecurityNewRequest) req.getSecurity();
fixedIncomeRequest.setIssuerId(companyId);
log.trace("FixedIncomeSecurityNewRequest - BOND");
String securitySymbol = fixedIncomeRequest.getSecuritySymbol();
security = findSecurityBySecuritySymbol(fixedIncomeSecurityImdg, securitySymbol); security = findSecurityBySecuritySymbol(fixedIncomeSecurityImdg, securitySymbol);
} else {
FixedIncomeSecurityUpdateRequest updateRequest = toUpdateRequest(security, fixedIncomeRequest);
RequestInfoUpdate resp = fixedIncomeSecurityService.updateFixedIncome(wrapRequest(baseRequest, updateRequest, ActionType.UPDATE));
validateReply(companyId, "newFixedIncome", resp);
}
}
if (req.getSecurity() != null && InstrumentType.EQTY.equalsByKey(req.getSecurityType())) {
EquitySecurityNewRequest equityRequest = (EquitySecurityNewRequest) req.getSecurity();
equityRequest.setIssuerId(companyId);
log.trace("EquitySecurityNewRequest - FOND");
String securitySymbol = equityRequest.getSecuritySymbol();
security = findSecurityBySecuritySymbol(equitySecurityImdg, securitySymbol);
if (security == null) { if (security == null) {
RequestInfoUpdate resp = equitySecurityService.newEquity(wrapRequest(baseRequest, equityRequest, null)); security = fixedIncomeSecurityService.newFixedIncome0(fixedIncomeRequest);
validateReply(companyId, "newFixedIncome", resp); } else {
security = findSecurityBySecuritySymbol(equitySecurityImdg, securitySymbol); FixedIncomeSecurityUpdateRequest updateRequest = toUpdateRequest(security, fixedIncomeRequest);
} else { security = fixedIncomeSecurityService.updateFixedIncome0(updateRequest);
EquitySecurityUpdateRequest updateRequest = toUpdateRequest(security, equityRequest); }
RequestInfoUpdate resp = equitySecurityService.updateEquity(wrapRequest(baseRequest, updateRequest, ActionType.UPDATE));
validateReply(companyId, "newFixedIncome", resp);
} }
if (req.getSecurity() != null && InstrumentType.EQTY.equalsByKey(req.getSecurityType())) {
EquitySecurityNewRequest equityRequest = (EquitySecurityNewRequest) req.getSecurity();
equityRequest.setIssuerId(companyId);
log.trace("EquitySecurityNewRequest - FOND");
String securitySymbol = equityRequest.getSecuritySymbol();
security = findSecurityBySecuritySymbol(equitySecurityImdg, securitySymbol);
if (security == null) {
security = equitySecurityService.newEquity0(equityRequest);
} else {
EquitySecurityUpdateRequest updateRequest = toUpdateRequest(security, equityRequest);
security = equitySecurityService.updateEquity0(updateRequest);
}
}
} catch (ValidationException expected) {
log.warn("Error create or update issue: {}", expected.toString());
return requestHelper.makeErrorResponse(baseRequest, expected.getEnumMsg());
} }
Long securityId; Long securityId;
@ -207,50 +216,63 @@ public class GatewaySecurityService extends QueueConsumer implements Initializin
if (req.getFixedIncomesCashFlow() == null) if (req.getFixedIncomesCashFlow() == null)
req.setFixedIncomesCashFlow(new ArrayList<>()); req.setFixedIncomesCashFlow(new ArrayList<>());
for (Object partRequestO : req.getListing()) { try {
ListingNewRequest partRequest = (ListingNewRequest) partRequestO; for (Object partRequestO : req.getListing()) {
partRequest.setSecurityId(securityId); ListingNewRequest partRequest = (ListingNewRequest) partRequestO;
Listing existListing = findListing(partRequest); partRequest.setSecurityId(securityId);
if (existListing == null) { Listing existListing = findListing(partRequest);
log.trace("For company[{}] do new Listing", companyId); if (existListing == null) {
RequestInfoUpdate replyI = listingService.newListing(wrapRequest(baseRequest, partRequest, ActionType.NEW)); log.trace("For company[{}] do new Listing", companyId);
validateReply(companyId, "ListingNew", replyI); Listing listing = listingService.newListing0(partRequest);
} else { log.debug("New listing.id={}", listing.getId());
log.trace("For company[{}] do update Listing[{}]", companyId, existListing.getId()); } else {
ListingUpdateRequest partUpdateRequest = toUpdateRequest(existListing, partRequest); log.trace("For company[{}] do update Listing[{}]", companyId, existListing.getId());
RequestInfoUpdate replyI = listingService.updateListing(wrapRequest(baseRequest, partUpdateRequest, ActionType.UPDATE)); ListingUpdateRequest partUpdateRequest = toUpdateRequest(existListing, partRequest);
validateReply(companyId, "ListingUpdate", replyI); Listing listing = listingService.updateListing0(partUpdateRequest);
log.debug("Has updated listing.id={}", listing.getId());
}
} }
} catch (ValidationException expected) {
log.warn("Error create or update listing: {}", expected.toString());
return requestHelper.makeErrorResponse(baseRequest, expected.getEnumMsg());
} }
for (Object partRequestO : req.getCouponPeriods()) { try {
CouponPeriodNewRequest partRequest = (CouponPeriodNewRequest) partRequestO; for (CouponPeriodNewRequest partRequest : (List<CouponPeriodNewRequest>)req.getCouponPeriods()) {
partRequest.setSecurityId(securityId); partRequest.setSecurityId(securityId);
CouponPeriod existCouponPeriod = findCouponPeriod(partRequest); CouponPeriod existCouponPeriod = findCouponPeriod(partRequest);
if (existCouponPeriod == null) { if (existCouponPeriod == null) {
log.trace("For company[{}] do new CouponPeriod", companyId); log.trace("For company[{}] do new CouponPeriod", companyId);
RequestInfoUpdate replyI = couponPeriodService.newCouponPeriod(wrapRequest(baseRequest, partRequest, ActionType.NEW)); CouponPeriod couponPeriod = couponPeriodService.newCouponPeriod0(partRequest);
validateReply(companyId, "CouponPeriodNew", replyI); log.debug("Has updated couponPeriod.id={}", couponPeriod.getId());
} else { } else {
log.trace("For company[{}] do update CouponPeriod[{}]", companyId, existCouponPeriod.getId()); log.trace("For company[{}] do update CouponPeriod[{}]", companyId, existCouponPeriod.getId());
CouponPeriodUpdateRequest partUpdateRequest = toUpdateRequest(existCouponPeriod, partRequest); CouponPeriodUpdateRequest partUpdateRequest = toUpdateRequest(existCouponPeriod, partRequest);
RequestInfoUpdate replyI = couponPeriodService.updateCouponPeriod(wrapRequest(baseRequest, partUpdateRequest, ActionType.UPDATE)); CouponPeriod couponPeriod = couponPeriodService.updateCouponPeriod0(partUpdateRequest);
validateReply(companyId, "CouponPeriodUpdate", replyI); log.debug("Has update couponPeriod.id={}", couponPeriod.getId());
}
} }
} catch (ValidationException expected) {
log.warn("Error create or update couponPeriod: {}", expected.toString());
return requestHelper.makeErrorResponse(baseRequest, expected.getEnumMsg());
} }
for (Object partRequestO : req.getFixedIncomesCashFlow()) { try {
FixedIncomeCashFlowNewRequest partRequest = (FixedIncomeCashFlowNewRequest) partRequestO; for (FixedIncomeCashFlowNewRequest partRequest : (List<FixedIncomeCashFlowNewRequest>)req.getFixedIncomesCashFlow()) {
partRequest.setSecuritySymbol(String.valueOf(securityId)); // не getSecuritySymbol partRequest.setSecuritySymbol(String.valueOf(securityId)); // не getSecuritySymbol
FixedIncomeCashFlow existFixedIncomeCashFlow = findFixedIncomeCashFlow(partRequest); FixedIncomeCashFlow existFixedIncomeCashFlow = findFixedIncomeCashFlow(partRequest);
if (existFixedIncomeCashFlow == null) { if (existFixedIncomeCashFlow == null) {
log.trace("For company[{}] do new FixedIncomeCashFlow", companyId); log.trace("For company[{}] do new FixedIncomeCashFlow", companyId);
RequestInfoUpdate replyI = fixedIncomeCashFlowService.fixedIncomeCashFlowNew(wrapRequest(baseRequest, partRequest, ActionType.NEW)); FixedIncomeCashFlow fixedIncomeCashFlow = fixedIncomeCashFlowService.fixedIncomeCashFlowNew0(partRequest);
validateReply(companyId, "FixedIncomeCashFlowNew", replyI); log.debug("Has update fixedIncomeCashFlow.id={}", fixedIncomeCashFlow.getId());
} else { } else {
log.trace("For company[{}] do update FixedIncomeCashFlow[{}]", companyId, existFixedIncomeCashFlow.getId()); log.trace("For company[{}] do update FixedIncomeCashFlow[{}]", companyId, existFixedIncomeCashFlow.getId());
FixedIncomeCashFlowUpdateRequest partUpdateRequest = toUpdateRequest(existFixedIncomeCashFlow, partRequest); FixedIncomeCashFlowUpdateRequest partUpdateRequest = toUpdateRequest(existFixedIncomeCashFlow, partRequest);
RequestInfoUpdate replyI = fixedIncomeCashFlowService.fixedIncomeCashFlowUpdate(wrapRequest(baseRequest, partUpdateRequest, ActionType.UPDATE)); FixedIncomeCashFlow fixedIncomeCashFlow = fixedIncomeCashFlowService.fixedIncomeCashFlowUpdate0(partUpdateRequest);
validateReply(companyId, "FixedIncomeCashFlowUpdate", replyI); log.debug("Has update fixedIncomeCashFlow.id={}", fixedIncomeCashFlow.getId());
}
} }
} catch (ValidationException expected) {
log.warn("Error create or update fixedIncomeCashFlow: {}", expected.toString());
return requestHelper.makeErrorResponse(baseRequest, expected.getEnumMsg());
} }
log.debug("successfully processed, request id {}", baseRequest.getId()); log.debug("successfully processed, request id {}", baseRequest.getId());

75
clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/service/cud/ListingService.java
View file

@ -21,12 +21,14 @@ import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate;
import ru.spcex.clearing.util.security.SecuritySelector; import ru.spcex.clearing.util.security.SecuritySelector;
import ru.spcex.clearing.securities.validation.ListingValidationProvider; import ru.spcex.clearing.securities.validation.ListingValidationProvider;
import ru.spcex.clearing.util.security.UserRoleVerification; import ru.spcex.clearing.util.security.UserRoleVerification;
import ru.spcex.clearing.util.services.RequestHelper;
import ru.spcex.clearing.validation.common.ValidationHelper; import ru.spcex.clearing.validation.common.ValidationHelper;
import ru.spcex.platform.enumeration.UserRole; import ru.spcex.platform.enumeration.UserRole;
import ru.spcex.platform.enumeration.WorkflowStatus; import ru.spcex.platform.enumeration.WorkflowStatus;
import ru.spcex.platform.imdg.api.Imdg; import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgId; import ru.spcex.platform.imdg.api.ImdgId;
import ru.spcex.platform.imdg.api.ImdgProvider; import ru.spcex.platform.imdg.api.ImdgProvider;
import ru.spcex.platform.utils.error.ValidationException;
import java.time.Instant; import java.time.Instant;
@ -41,6 +43,7 @@ public class ListingService extends QueueConsumer implements InitializingBean {
private final UserRoleVerification userRoleVerification; private final UserRoleVerification userRoleVerification;
private final ValidationHelper validationHelper; private final ValidationHelper validationHelper;
private final SecuritySelector securitySelector; private final SecuritySelector securitySelector;
private final RequestHelper requestHelper;
@Autowired @Autowired
public ListingService(Consumer<String, Object> kafkaQueue, public ListingService(Consumer<String, Object> kafkaQueue,
@ -49,7 +52,8 @@ public class ListingService extends QueueConsumer implements InitializingBean {
ListingValidationProvider validation, ListingValidationProvider validation,
UserRoleVerification userRoleVerification, UserRoleVerification userRoleVerification,
ValidationHelper validationHelper, ValidationHelper validationHelper,
SecuritySelector securitySelector) { SecuritySelector securitySelector,
RequestHelper requestHelper) {
super(kafkaQueue, kafkaProducer); super(kafkaQueue, kafkaProducer);
this.validation = validation; this.validation = validation;
this.securitySelector = securitySelector; this.securitySelector = securitySelector;
@ -58,6 +62,7 @@ public class ListingService extends QueueConsumer implements InitializingBean {
this.idGenerator = imdgProvider.getImdgIdGenerator(); this.idGenerator = imdgProvider.getImdgIdGenerator();
this.userRoleVerification = userRoleVerification.setRoleForVerification(UserRole.Admin); this.userRoleVerification = userRoleVerification.setRoleForVerification(UserRole.Admin);
this.validationHelper = validationHelper; this.validationHelper = validationHelper;
this.requestHelper = requestHelper;
} }
@Override @Override
@ -75,14 +80,20 @@ public class ListingService extends QueueConsumer implements InitializingBean {
init(); init();
} }
public synchronized RequestInfoUpdate newListing(BaseRequest<ListingNewRequest> userRequest) { public RequestInfoUpdate newListing(BaseRequest<ListingNewRequest> userRequest) {
ListingNewRequest req = userRequest.getRequestPayload(); log.debug("newListing received id = {}", userRequest.getId());
log.debug("newListing received, id={}", userRequest.getId()); try {
userRoleVerification.validateRoleAndThrow(userRequest);
Listing listing = newListing0(userRequest.getRequestPayload());
log.debug("successfully processed, request id {}, new object id {}", userRequest.getId(), listing.getId());
return null;
} catch (ValidationException e) {
return requestHelper.makeErrorResponse(userRequest, e.getEnumMsg());
}
}
RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest); public synchronized Listing newListing0(ListingNewRequest req) throws ValidationException {
if (requestInfoUpdate != null) return requestInfoUpdate; validationHelper.validateTillFirstErrorAndThrow(req, validation.listingNewValidator());
requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, validation.listingNewValidator());
if (requestInfoUpdate != null) return requestInfoUpdate;
Security security = securitySelector.selectSecurityById(req.getSecurityId()); Security security = securitySelector.selectSecurityById(req.getSecurityId());
if (security == null) { // never if (security == null) { // never
@ -106,19 +117,23 @@ public class ListingService extends QueueConsumer implements InitializingBean {
} }
listingImdg.insert(listing); listingImdg.insert(listing);
log.debug("successfully processed, request id {}, new object id {}", userRequest.getId(), listing.getId()); return listing;
return null; // default success
} }
public synchronized RequestInfoUpdate updateListing(BaseRequest<ListingUpdateRequest> userRequest) { public RequestInfoUpdate updateListing(BaseRequest<ListingUpdateRequest> userRequest) {
ListingUpdateRequest req = userRequest.getRequestPayload(); log.debug("ListingUpdateRequest received id = {}", userRequest.getId());
log.debug("updateListing received id = {}", req.getId()); try {
userRoleVerification.validateRoleAndThrow(userRequest);
Listing listing = updateListing0(userRequest.getRequestPayload());
log.debug("successfully processed, request id {}, update object id {}", userRequest.getId(), listing.getId());
return null;
} catch (ValidationException e) {
return requestHelper.makeErrorResponse(userRequest, e.getEnumMsg());
}
}
public synchronized Listing updateListing0(ListingUpdateRequest req) throws ValidationException {
RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest); validationHelper.validateTillFirstErrorAndThrow(req, validation.listingUpdateValidator());
if (requestInfoUpdate != null) return requestInfoUpdate;
requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, validation.listingUpdateValidator());
if (requestInfoUpdate != null) return requestInfoUpdate;
Listing listing = listingImdg.getSingleObjectByID(req.getId()); Listing listing = listingImdg.getSingleObjectByID(req.getId());
@ -140,17 +155,23 @@ public class ListingService extends QueueConsumer implements InitializingBean {
} }
listingImdg.update(listing); listingImdg.update(listing);
return null; return listing;
} }
private synchronized RequestInfoUpdate deleteListing(BaseRequest<CommonDeleteRequest> userRequest) { private RequestInfoUpdate deleteListing(BaseRequest<CommonDeleteRequest> userRequest) {
CommonDeleteRequest req = userRequest.getRequestPayload(); log.debug("CommonDeleteRequest received id = {}", userRequest.getId());
log.debug("CommonDeleteRequest received id = {}", req.getId()); try {
userRoleVerification.validateRoleAndThrow(userRequest);
Long equityId = deleteListing0(userRequest.getRequestPayload());
log.debug("successfully processed, request id {}, delete object id {}", userRequest.getId(), equityId);
return null;
} catch (ValidationException e) {
return requestHelper.makeErrorResponse(userRequest, e.getEnumMsg());
}
}
RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest); protected synchronized Long deleteListing0(CommonDeleteRequest req) throws ValidationException {
if (requestInfoUpdate != null) return requestInfoUpdate; validationHelper.validateTillFirstErrorAndThrow(req, validation.listingDeleteValidator());
requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, validation.listingDeleteValidator());
if (requestInfoUpdate != null) return requestInfoUpdate;
Instant updateTime = Instant.now(); Instant updateTime = Instant.now();
Listing listing = listingImdg.getSingleObjectByID(req.getId()); Listing listing = listingImdg.getSingleObjectByID(req.getId());
@ -158,7 +179,7 @@ public class ListingService extends QueueConsumer implements InitializingBean {
listing.setUpdated(updateTime); listing.setUpdated(updateTime);
listingImdg.update(listing); listingImdg.update(listing);
return null; return listing.getId();
} }
} }

40
clearing-parent/securities-service/src/test/java/ru/spcex/clearing/securities/service/EquitySecurityServiceTest.java
View file

@ -14,6 +14,7 @@ import ru.spcex.clearing.platform.messaging.domain.cud.securitites.EquitySecurit
import ru.spcex.clearing.securities.component.ListingBuilder; import ru.spcex.clearing.securities.component.ListingBuilder;
import ru.spcex.clearing.securities.service.cud.EquitySecurityService; import ru.spcex.clearing.securities.service.cud.EquitySecurityService;
import ru.spcex.clearing.test.MatcherFactory; import ru.spcex.clearing.test.MatcherFactory;
import ru.spcex.platform.enumeration.Market;
import javax.annotation.PostConstruct; import javax.annotation.PostConstruct;
import java.math.BigDecimal; import java.math.BigDecimal;
@ -69,6 +70,17 @@ public class EquitySecurityServiceTest extends AbstractServiceTest {
// LISTING_MATCHER.assertMatch(listingResult, listingPrediction); // LISTING_MATCHER.assertMatch(listingResult, listingPrediction);
} }
public Listing updateListingByEquity(EquitySecurity equitySecurity, Listing listing) {
listing.setSecurityId(equitySecurity.getId());
listing.setSymbolCode(equitySecurity.getSecuritySymbol());
listing.setSymbolName(equitySecurity.getFullName());
listing.setWorkflowStatus(equitySecurity.getWorkflowStatus());
listing.setMarket(Market.mkrs.getKey());
listing.setLotSize(equitySecurity.getLotSize());
listing.setUpdated(equitySecurity.getUpdated());
return listing;
}
/** /**
* {@link EquitySecurityService#updateEquity(BaseRequest)} * {@link EquitySecurityService#updateEquity(BaseRequest)}
* Тест проверяет обновление сущности {@link EquitySecurity} в Hazelcast при передаче из Apache Kafka.<br> * Тест проверяет обновление сущности {@link EquitySecurity} в Hazelcast при передаче из Apache Kafka.<br>
@ -86,9 +98,9 @@ public class EquitySecurityServiceTest extends AbstractServiceTest {
equityPrediction.setFullName(fullName); equityPrediction.setFullName(fullName);
equityPrediction.setLotSize(BigDecimal.valueOf(updateLotSize)); equityPrediction.setLotSize(BigDecimal.valueOf(updateLotSize));
final EquitySecurityUpdateRequest request = getEquitySecurityUpdateRequest(equityPrediction); final EquitySecurityUpdateRequest request = getEquitySecurityUpdateRequest(equityPrediction);
Listing listingPrediction = new Listing(); // Listing listingPrediction = new Listing();
listingPrediction = equitySecurityService.updateListingByEquity(equityPrediction, listingPrediction); // listingPrediction = equitySecurityService.updateListingByEquity(equityPrediction, listingPrediction);
listingImdg.insert(listingPrediction); // listingImdg.insert(listingPrediction);
//ACT //ACT
String jsonString = getJsonStringForUpdate(request, ID); String jsonString = getJsonStringForUpdate(request, ID);
@ -103,10 +115,10 @@ public class EquitySecurityServiceTest extends AbstractServiceTest {
equityPrediction.setSecurityId(equityResult.getSecurityId()); equityPrediction.setSecurityId(equityResult.getSecurityId());
EQUITY_SECURITY_MATCHER.assertMatch(equityResult, equityPrediction); EQUITY_SECURITY_MATCHER.assertMatch(equityResult, equityPrediction);
Listing listingResult = listingImdg.getSingleObjectByFieldValues(Map.of("securityId", equityPrediction.getId())); // Listing listingResult = listingImdg.getSingleObjectByFieldValues(Map.of("securityId", equityPrediction.getId()));
listingPrediction.setId(listingResult.getId()); // listingPrediction.setId(listingResult.getId());
listingPrediction.setSecurityId(listingResult.getSecurityId()); // listingPrediction.setSecurityId(listingResult.getSecurityId());
LISTING_MATCHER.assertMatch(listingResult, listingPrediction); // LISTING_MATCHER.assertMatch(listingResult, listingPrediction);
} }
/** /**
@ -125,9 +137,9 @@ public class EquitySecurityServiceTest extends AbstractServiceTest {
equityPrediction.setWorkflowStatus(ru.spcex.platform.enumeration.Status.Blocked.getKey()); equityPrediction.setWorkflowStatus(ru.spcex.platform.enumeration.Status.Blocked.getKey());
Listing listingPrediction = new Listing(); Listing listingPrediction = new Listing();
listingPrediction = equitySecurityService.updateListingByEquity(equityPrediction, listingPrediction); // listingPrediction = equitySecurityService.updateListingByEquity(equityPrediction, listingPrediction);
listingImdg.insert(listingPrediction); // listingImdg.insert(listingPrediction);
listingPrediction.setWorkflowStatus(ru.spcex.platform.enumeration.Status.Blocked.getKey()); // listingPrediction.setWorkflowStatus(ru.spcex.platform.enumeration.Status.Blocked.getKey());
CommonDeleteRequest commonDeleteRequest = new CommonDeleteRequest(); CommonDeleteRequest commonDeleteRequest = new CommonDeleteRequest();
commonDeleteRequest.setId(ID); commonDeleteRequest.setId(ID);
@ -145,10 +157,10 @@ public class EquitySecurityServiceTest extends AbstractServiceTest {
equityPrediction.setSecurityId(equityResult.getSecurityId()); equityPrediction.setSecurityId(equityResult.getSecurityId());
EQUITY_SECURITY_MATCHER.assertMatch(equityResult, equityPrediction); EQUITY_SECURITY_MATCHER.assertMatch(equityResult, equityPrediction);
Listing listingResult = listingImdg.getSingleObjectByFieldValues(Map.of("securityId", equityPrediction.getId())); // Listing listingResult = listingImdg.getSingleObjectByFieldValues(Map.of("securityId", equityPrediction.getId()));
listingPrediction.setId(listingResult.getId()); // listingPrediction.setId(listingResult.getId());
listingPrediction.setSecurityId(listingResult.getSecurityId()); // listingPrediction.setSecurityId(listingResult.getSecurityId());
LISTING_MATCHER.assertMatch(listingResult, listingPrediction); // LISTING_MATCHER.assertMatch(listingResult, listingPrediction);
} }
private EquitySecurity getEquitySecurity() { private EquitySecurity getEquitySecurity() {

38
clearing-parent/securities-service/src/test/java/ru/spcex/clearing/securities/service/FixedIncomeSecurityServiceTest.java
View file

@ -70,6 +70,16 @@ public class FixedIncomeSecurityServiceTest extends AbstractServiceTest {
// LISTING_MATCHER.assertMatch(listingResult, listingPrediction); // LISTING_MATCHER.assertMatch(listingResult, listingPrediction);
} }
public Listing updateListingByFixedIncome(FixedIncomeSecurity fixedIncomeSecurity, Listing listing) {
listing.setSecurityId(fixedIncomeSecurity.getId());
listing.setSymbolCode(fixedIncomeSecurity.getSecuritySymbol());
listing.setSymbolName(fixedIncomeSecurity.getFullName());
listing.setTradingCurrency(fixedIncomeSecurity.getNominalCurrency());
listing.setWorkflowStatus(fixedIncomeSecurity.getWorkflowStatus());
listing.setLotSize(fixedIncomeSecurity.getLotSize());
listing.setUpdated(fixedIncomeSecurity.getUpdated());
return listing;
}
/** /**
* {@link FixedIncomeSecurityService#updateFixedIncome(BaseRequest)} * {@link FixedIncomeSecurityService#updateFixedIncome(BaseRequest)}
* Тест проверяет обновление сущности {@link FixedIncomeSecurity} в Hazelcast при передаче из Apache Kafka.<br> * Тест проверяет обновление сущности {@link FixedIncomeSecurity} в Hazelcast при передаче из Apache Kafka.<br>
@ -88,9 +98,9 @@ public class FixedIncomeSecurityServiceTest extends AbstractServiceTest {
fixedIncomePrediction.setFullName(fullName); fixedIncomePrediction.setFullName(fullName);
fixedIncomePrediction.setLotSize(BigDecimal.valueOf(updateLotSize)); fixedIncomePrediction.setLotSize(BigDecimal.valueOf(updateLotSize));
final FixedIncomeSecurityUpdateRequest request = getFixedIncomeSecurityUpdateRequest(fixedIncomePrediction); final FixedIncomeSecurityUpdateRequest request = getFixedIncomeSecurityUpdateRequest(fixedIncomePrediction);
Listing listingPrediction = new Listing(); // Listing listingPrediction = new Listing();
listingPrediction = fixedIncomeSecurityService.updateListingByFixedIncome(fixedIncomePrediction, listingPrediction); // listingPrediction = fixedIncomeSecurityService.updateListingByFixedIncome(fixedIncomePrediction, listingPrediction);
listingImdg.insert(listingPrediction); // listingImdg.insert(listingPrediction);
//ACT //ACT
String jsonString = getJsonStringForUpdate(request, ID); String jsonString = getJsonStringForUpdate(request, ID);
@ -105,10 +115,10 @@ public class FixedIncomeSecurityServiceTest extends AbstractServiceTest {
fixedIncomePrediction.setSecurityId(equityResult.getSecurityId()); fixedIncomePrediction.setSecurityId(equityResult.getSecurityId());
FIXED_INCOME_SECURITY_MATCHER.assertMatch(equityResult, fixedIncomePrediction); FIXED_INCOME_SECURITY_MATCHER.assertMatch(equityResult, fixedIncomePrediction);
Listing listingResult = listingImdg.getSingleObjectByFieldValues(Map.of("securityId", fixedIncomePrediction.getId())); // Listing listingResult = listingImdg.getSingleObjectByFieldValues(Map.of("securityId", fixedIncomePrediction.getId()));
listingPrediction.setId(listingResult.getId()); // listingPrediction.setId(listingResult.getId());
listingPrediction.setSecurityId(listingResult.getSecurityId()); // listingPrediction.setSecurityId(listingResult.getSecurityId());
LISTING_MATCHER.assertMatch(listingResult, listingPrediction); // LISTING_MATCHER.assertMatch(listingResult, listingPrediction);
} }
/** /**
@ -127,9 +137,9 @@ public class FixedIncomeSecurityServiceTest extends AbstractServiceTest {
fixedIncomePrediction.setWorkflowStatus(ru.spcex.platform.enumeration.Status.Blocked.getKey()); fixedIncomePrediction.setWorkflowStatus(ru.spcex.platform.enumeration.Status.Blocked.getKey());
Listing listingPrediction = new Listing(); Listing listingPrediction = new Listing();
listingPrediction = fixedIncomeSecurityService.updateListingByFixedIncome(fixedIncomePrediction, listingPrediction); // listingPrediction = fixedIncomeSecurityService.updateListingByFixedIncome(fixedIncomePrediction, listingPrediction);
listingImdg.insert(listingPrediction); // listingImdg.insert(listingPrediction);
listingPrediction.setWorkflowStatus(ru.spcex.platform.enumeration.Status.Blocked.getKey()); // listingPrediction.setWorkflowStatus(ru.spcex.platform.enumeration.Status.Blocked.getKey());
CommonDeleteRequest commonDeleteRequest = new CommonDeleteRequest(); CommonDeleteRequest commonDeleteRequest = new CommonDeleteRequest();
commonDeleteRequest.setId(ID); commonDeleteRequest.setId(ID);
@ -147,10 +157,10 @@ public class FixedIncomeSecurityServiceTest extends AbstractServiceTest {
fixedIncomePrediction.setSecurityId(equityResult.getSecurityId()); fixedIncomePrediction.setSecurityId(equityResult.getSecurityId());
FIXED_INCOME_SECURITY_MATCHER.assertMatch(equityResult, fixedIncomePrediction); FIXED_INCOME_SECURITY_MATCHER.assertMatch(equityResult, fixedIncomePrediction);
Listing listingResult = listingImdg.getSingleObjectByFieldValues(Map.of("securityId", fixedIncomePrediction.getId())); // Listing listingResult = listingImdg.getSingleObjectByFieldValues(Map.of("securityId", fixedIncomePrediction.getId()));
listingPrediction.setId(listingResult.getId()); // listingPrediction.setId(listingResult.getId());
listingPrediction.setSecurityId(listingResult.getSecurityId()); // listingPrediction.setSecurityId(listingResult.getSecurityId());
LISTING_MATCHER.assertMatch(listingResult, listingPrediction); // LISTING_MATCHER.assertMatch(listingResult, listingPrediction);
} }
private FixedIncomeSecurity getFixedIncomeSecurity() { private FixedIncomeSecurity getFixedIncomeSecurity() {