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.platform.utils.enumeration.EnumMessage;
import ru.spcex.platform.utils.enumeration.IMessageResolver;
import ru.spcex.platform.utils.error.ValidationException;
import ru.spcex.platform.utils.validation.IValidator;
import java.util.Objects;
@ -30,7 +31,7 @@ public class ValidationHelper {
* @return null если ошибок нет
*/
public <R> RequestInfoUpdate validateTillFirstError(BaseRequest<R> userRequest,
Function<R, IValidator> validatorBuilder) {
Function<R, IValidator> validatorBuilder) {
if (validatorBuilder != null) {
R req = userRequest.getRequestPayload();
IValidator validator = validatorBuilder.apply(req);
@ -47,6 +48,15 @@ public class ValidationHelper {
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() {
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) {
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.securities.validation.ValidationProvider;
import ru.spcex.clearing.util.security.UserRoleVerification;
import ru.spcex.clearing.util.services.RequestHelper;
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.utils.error.ValidationException;
@Service
public class CouponPeriodService extends QueueConsumer implements InitializingBean {
@ -31,6 +33,7 @@ public class CouponPeriodService extends QueueConsumer implements InitializingBe
private final ValidationProvider validation;
private final ValidationHelper validationHelper;
private final UserRoleVerification userRoleVerification;
private final RequestHelper requestHelper;
@Autowired
public CouponPeriodService(Consumer<String, Object> kafkaQueue,
@ -38,7 +41,8 @@ public class CouponPeriodService extends QueueConsumer implements InitializingBe
ImdgProvider imdgProvider,
ValidationProvider validation,
UserRoleVerification userRoleVerification,
ValidationHelper validationHelper) {
ValidationHelper validationHelper,
RequestHelper requestHelper) {
super(kafkaQueue, kafkaProducer);
this.validation = validation;
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.userRoleVerification = userRoleVerification;
this.validationHelper = validationHelper;
this.requestHelper = requestHelper;
}
@Override
@ -60,13 +65,20 @@ public class CouponPeriodService extends QueueConsumer implements InitializingBe
init();
}
public synchronized RequestInfoUpdate newCouponPeriod(BaseRequest<CouponPeriodNewRequest> userRequest) {
CouponPeriodNewRequest req = userRequest.getRequestPayload();
public RequestInfoUpdate newCouponPeriod(BaseRequest<CouponPeriodNewRequest> userRequest) {
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());
if (requestInfoUpdate != null) return requestInfoUpdate;
log.debug("newCurrency received");
public synchronized CouponPeriod newCouponPeriod0(CouponPeriodNewRequest req) throws ValidationException {
validationHelper.validateTillFirstErrorAndThrow(req, validation.couponPeriodNewValidator());
CouponPeriod couponPeriod = new CouponPeriod();
couponPeriod.setId(idGenerator.nextId());
couponPeriod.setSecurityId(req.getSecurityId());
@ -75,19 +87,23 @@ public class CouponPeriodService extends QueueConsumer implements InitializingBe
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
return couponPeriod;
}
public synchronized RequestInfoUpdate updateCouponPeriod(BaseRequest<CouponPeriodUpdateRequest> userRequest) {
CouponPeriodUpdateRequest req = userRequest.getRequestPayload();
log.debug("updateCurrency received id = {}", req.getId());
public RequestInfoUpdate updateCouponPeriod(BaseRequest<CouponPeriodUpdateRequest> userRequest) {
log.debug("CouponPeriodUpdateRequest received id = {}", userRequest.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);
if (requestInfoUpdate != null) return requestInfoUpdate;
requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, validation.couponPeriodUpdateValidator());
if (requestInfoUpdate != null) return requestInfoUpdate;
public synchronized CouponPeriod updateCouponPeriod0(CouponPeriodUpdateRequest req) throws ValidationException {
validationHelper.validateTillFirstErrorAndThrow(req, validation.couponPeriodUpdateValidator());
CouponPeriod couponPeriod = couponPeriodImdg.getSingleObjectByID(req.getId());
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.getPeriodStartDate() != null) couponPeriod.setPeriodStartDate(req.getPeriodStartDate());
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.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.util.security.UserRoleVerification;
import ru.spcex.clearing.util.services.RequestHelper;
import ru.spcex.clearing.validation.common.ValidationHelper;
import ru.spcex.platform.enumeration.Market;
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.ImdgId;
import ru.spcex.platform.imdg.api.ImdgProvider;
import ru.spcex.platform.imdg.api.ImdgTransaction;
import ru.spcex.platform.utils.error.ValidationException;
import java.time.Instant;
@ -35,12 +35,12 @@ import java.time.Instant;
public class EquitySecurityService extends QueueConsumer implements InitializingBean {
private final Logger log = LoggerFactory.getLogger(getClass());
private final Imdg<EquitySecurity> equitySecurityImdg;
private final Imdg<Listing> listingImdg;
private final ImdgProvider imdgProvider;
private final ImdgId idGenerator;
private final ValidationProvider validation;
private final UserRoleVerification userRoleVerification;
private final ValidationHelper validationHelper;
private final RequestHelper requestHelper;
@Autowired
public EquitySecurityService(Consumer<String, Object> kafkaQueue,
@ -48,15 +48,16 @@ public class EquitySecurityService extends QueueConsumer implements Initializing
ImdgProvider imdgProvider,
UserRoleVerification userRoleVerification,
ValidationProvider validation,
ValidationHelper validationHelper) {
ValidationHelper validationHelper,
RequestHelper requestHelper) {
super(kafkaQueue, kafkaProducer);
this.validation = validation;
this.equitySecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_EquitySecurity, EquitySecurity.class);
this.listingImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Listing, Listing.class);
this.imdgProvider = imdgProvider;
this.idGenerator = imdgProvider.getImdgIdGenerator();
this.userRoleVerification = userRoleVerification.setRoleForVerification(UserRole.Admin);
this.validationHelper = validationHelper;
this.requestHelper = requestHelper;
}
@Override
@ -74,12 +75,22 @@ public class EquitySecurityService extends QueueConsumer implements Initializing
init();
}
protected synchronized RequestInfoUpdate newEquity(BaseRequest<EquitySecurityNewRequest> userRequest) {
ImdgTransaction transaction = imdgProvider.newTransaction();
EquitySecurityNewRequest req = userRequest.getRequestPayload();
protected RequestInfoUpdate newEquity(BaseRequest<EquitySecurityNewRequest> userRequest) {
log.debug("EquitySecurityNewRequest received, id={}", userRequest.getId());
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());
if (requestInfoUpdate != null) return requestInfoUpdate;
protected synchronized EquitySecurity newEquity0(EquitySecurityNewRequest req) throws ValidationException {
ImdgTransaction transaction = imdgProvider.newTransaction();
validationHelper.validateTillFirstErrorAndThrow(req, validation.equityNewValidator());
log.debug("EquitySecurityNewRequest received");
EquitySecurity equity = new EquitySecurity();
@ -105,33 +116,28 @@ public class EquitySecurityService extends QueueConsumer implements Initializing
try {
transaction.beginTransaction();
Imdg<EquitySecurity> equityImdg = transaction.getImdg(IMDGDistributedNames.Map_EquitySecurity, EquitySecurity.class);
// Imdg<Listing> listingMap = transaction.getImdg(IMDGDistributedNames.Map_Listing, Listing.class);
//одним скопом выполняем реквест
equityImdg.insert(equity);
// Listing listing = ListingBuilder.builder()
// .append(equity).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(), equity.getId());
return null; // default success
return equity;
}
protected synchronized RequestInfoUpdate updateEquity(BaseRequest<EquitySecurityUpdateRequest> userRequest) {
EquitySecurityUpdateRequest req = userRequest.getRequestPayload();
log.debug("MoneyMarketSecurityUpdateRequest received id = {}", req.getId());
protected RequestInfoUpdate updateEquity(BaseRequest<EquitySecurityUpdateRequest> userRequest) {
log.debug("EquitySecurityUpdateRequest received, id={}", userRequest.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);
if (requestInfoUpdate != null) return requestInfoUpdate;
requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, validation.equityUpdateValidator());
if (requestInfoUpdate != null) return requestInfoUpdate;
protected synchronized EquitySecurity updateEquity0(EquitySecurityUpdateRequest req) throws ValidationException {
validationHelper.validateTillFirstErrorAndThrow(req, validation.equityUpdateValidator());
EquitySecurity equity = equitySecurityImdg.getSingleObjectByID(req.getId());
Instant updateTime = Instant.now();
@ -151,25 +157,23 @@ public class EquitySecurityService extends QueueConsumer implements Initializing
equity.setInstrumentType(req.getInstrumentType());
equitySecurityImdg.update(equity);
// Listing listing = listingImdg.getSingleObjectByFieldValues(Map.of("securityId", equity.getId()));
// 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;
return equity;
}
private RequestInfoUpdate deleteEquity(BaseRequest<CommonDeleteRequest> userRequest) {
CommonDeleteRequest req = userRequest.getRequestPayload();
log.debug("CommonDeleteRequest received id = {}", req.getId());
log.debug("CommonDeleteRequest received id = {}", userRequest.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);
if (requestInfoUpdate != null) return requestInfoUpdate;
requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, validation.equityDeleteValidator());
if (requestInfoUpdate != null) return requestInfoUpdate;
protected synchronized Long deleteEquity0(CommonDeleteRequest req) throws ValidationException {
validationHelper.validateTillFirstErrorAndThrow(req, validation.equityDeleteValidator());
Instant updateTime = Instant.now();
EquitySecurity equity = equitySecurityImdg.getSingleObjectByID(req.getId());
@ -177,25 +181,7 @@ public class EquitySecurityService extends QueueConsumer implements Initializing
equity.setUpdated(updateTime);
equitySecurityImdg.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 equity.getId();
}
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.RequestInfoUpdate;
import ru.spcex.clearing.util.security.UserRoleVerification;
import ru.spcex.clearing.util.services.RequestHelper;
import ru.spcex.clearing.validation.common.ValidationHelper;
import ru.spcex.platform.enumeration.UserRole;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgProvider;
import ru.spcex.platform.utils.error.ValidationException;
import ru.spcex.platform.utils.validation.IValidator;
import java.util.function.Function;
@ -31,6 +33,7 @@ public class FixedIncomeCashFlowService extends QueueConsumer implements Initial
private final ImdgProvider imdgProvider;
private final UserRoleVerification userRoleVerification;
private final ValidationHelper validationHelper;
private final RequestHelper requestHelper;
private final Function<FixedIncomeCashFlowNewRequest, IValidator> fixedIncomeCashFlowNewRequestValidator;
private final Function<FixedIncomeCashFlowUpdateRequest, IValidator> fixedIncomeCashFlowUpdateRequestValidator;
@ -40,12 +43,14 @@ public class FixedIncomeCashFlowService extends QueueConsumer implements Initial
ImdgProvider imdgProvider,
UserRoleVerification userRoleVerification,
ValidationHelper validationHelper,
RequestHelper requestHelper,
@Qualifier("fixedIncomeCashFlowNewRequestValidator") Function<FixedIncomeCashFlowNewRequest, IValidator> fixedIncomeCashFlowNewRequestValidator,
@Qualifier("fixedIncomeCashFlowUpdateRequestValidator") Function<FixedIncomeCashFlowUpdateRequest, IValidator> fixedIncomeCashFlowUpdateRequestValidator) {
super(kafkaQueue, kafkaResponseQueue);
this.imdgProvider = imdgProvider;
this.userRoleVerification = userRoleVerification.setRoleForVerification(UserRole.Admin);
this.validationHelper = validationHelper;
this.requestHelper = requestHelper;
this.fixedIncomeCashFlowNewRequestValidator = fixedIncomeCashFlowNewRequestValidator;
this.fixedIncomeCashFlowUpdateRequestValidator = fixedIncomeCashFlowUpdateRequestValidator;
this.fixedIncomeCashFlowImdg = imdgProvider.getImdg(
@ -65,13 +70,21 @@ public class FixedIncomeCashFlowService extends QueueConsumer implements Initial
init();
}
public synchronized RequestInfoUpdate fixedIncomeCashFlowNew(BaseRequest<FixedIncomeCashFlowNewRequest> userRequest) {
log.debug("FixedIncomeCashFlowNewRequest received {}", userRequest.getId());
public RequestInfoUpdate fixedIncomeCashFlowNew(BaseRequest<FixedIncomeCashFlowNewRequest> userRequest) {
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);
if (requestInfoUpdate != null) return requestInfoUpdate;
public synchronized FixedIncomeCashFlow fixedIncomeCashFlowNew0(FixedIncomeCashFlowNewRequest req) throws ValidationException {
validationHelper.validateTillFirstErrorAndThrow(req, fixedIncomeCashFlowNewRequestValidator);
FixedIncomeCashFlowNewRequest req = userRequest.getRequestPayload();
FixedIncomeCashFlow fixedIncomeCashFlow = new FixedIncomeCashFlow();
fixedIncomeCashFlow.setSecurityId(Long.valueOf(req.getSecuritySymbol()));
fixedIncomeCashFlow.setAccruedCoupon(req.getAccruedCoupon());
@ -80,21 +93,24 @@ public class FixedIncomeCashFlowService extends QueueConsumer implements Initial
fixedIncomeCashFlow.setValueDate(req.getValueDate());
Long id = fixedIncomeCashFlowImdg.insert(fixedIncomeCashFlow);
log.debug("successfully processed, id {}", id);
return null;
return fixedIncomeCashFlow;
}
public synchronized RequestInfoUpdate fixedIncomeCashFlowUpdate(BaseRequest<FixedIncomeCashFlowUpdateRequest> userRequest) {
log.debug("FixedIncomeCashFlowUpdateRequest received {}", userRequest.getId());
public RequestInfoUpdate fixedIncomeCashFlowUpdate(BaseRequest<FixedIncomeCashFlowUpdateRequest> userRequest) {
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);
if (requestInfoUpdate != null) return requestInfoUpdate;
public synchronized FixedIncomeCashFlow fixedIncomeCashFlowUpdate0(FixedIncomeCashFlowUpdateRequest req) throws ValidationException {
validationHelper.validateTillFirstErrorAndThrow(req, fixedIncomeCashFlowUpdateRequestValidator);
requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, fixedIncomeCashFlowUpdateRequestValidator);
if (requestInfoUpdate != null) return requestInfoUpdate;
FixedIncomeCashFlowUpdateRequest req = userRequest.getRequestPayload();
FixedIncomeCashFlow fixedIncomeCashFlow = fixedIncomeCashFlowImdg.getSingleObjectByID(req.getId());
if (req.getAccruedCoupon() != null) fixedIncomeCashFlow.setAccruedCoupon(req.getAccruedCoupon());
@ -105,7 +121,7 @@ public class FixedIncomeCashFlowService extends QueueConsumer implements Initial
fixedIncomeCashFlowImdg.update(fixedIncomeCashFlow);
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.validation.ValidationProvider;
import ru.spcex.clearing.util.security.UserRoleVerification;
import ru.spcex.clearing.util.services.RequestHelper;
import ru.spcex.clearing.validation.common.ValidationHelper;
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.ImdgId;
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.util.Optional;
@Service
public class FixedIncomeSecurityService extends QueueConsumer implements InitializingBean {
private final Logger log = LoggerFactory.getLogger(getClass());
private final Imdg<FixedIncomeSecurity> fixedIncomeSecurityImdg;
private final Imdg<Listing> listingImdg;
private final ImdgProvider imdgProvider;
private final ImdgId idGenerator;
private final ValidationProvider validation;
private final UserRoleVerification userRoleVerification;
private final ValidationHelper validationHelper;
private final RequestHelper requestHelper;
@Autowired
public FixedIncomeSecurityService(Consumer<String, Object> kafkaQueue,
@ -47,15 +51,16 @@ public class FixedIncomeSecurityService extends QueueConsumer implements Initial
ImdgProvider imdgProvider,
ValidationProvider validation,
UserRoleVerification userRoleVerification,
ValidationHelper validationHelper) {
ValidationHelper validationHelper,
RequestHelper requestHelper) {
super(kafkaQueue, kafkaProducer);
this.validation = validation;
this.fixedIncomeSecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_FixedIncomeSecurity, FixedIncomeSecurity.class);
this.listingImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Listing, Listing.class);
this.imdgProvider = imdgProvider;
this.idGenerator = imdgProvider.getImdgIdGenerator();
this.userRoleVerification = userRoleVerification.setRoleForVerification(UserRole.Admin);
this.validationHelper = validationHelper;
this.requestHelper = requestHelper.setLogger(log);
}
@Override
@ -73,14 +78,28 @@ public class FixedIncomeSecurityService extends QueueConsumer implements Initial
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;
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();
fixedIncome.setId(idGenerator.nextId());
fixedIncome.setSecuritySymbol(req.getSecuritySymbol());
@ -106,37 +125,23 @@ public class FixedIncomeSecurityService extends QueueConsumer implements Initial
fixedIncome.setSecurityId(fixedIncome.getId());
fixedIncome.setCreated(Instant.now());
fixedIncome.setUpdated(fixedIncome.getCreated());
try {
transaction.beginTransaction();
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
fixedIncomeSecurityImdg.insert(fixedIncome);
return fixedIncome;
}
protected synchronized RequestInfoUpdate updateFixedIncome(BaseRequest<FixedIncomeSecurityUpdateRequest> userRequest) {
FixedIncomeSecurityUpdateRequest req = userRequest.getRequestPayload();
log.debug("updateFixedIncome received id = {}", req.getId());
RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest);
if (requestInfoUpdate != null) return requestInfoUpdate;
requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, validation.fixedIncomeUpdateValidator());
if (requestInfoUpdate != null) return requestInfoUpdate;
protected RequestInfoUpdate updateFixedIncome(BaseRequest<FixedIncomeSecurityUpdateRequest> userRequest) {
log.debug("FixedIncomeSecurityUpdateRequest received id = {} (update object id={})", userRequest.getId(), userRequest.getRequestPayload() == null ? null : userRequest.getRequestPayload().getId());
try {
userRoleVerification.validateRoleAndThrow(userRequest);
FixedIncomeSecurity fixedIncome = updateFixedIncome0(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 updateFixedIncome0(FixedIncomeSecurityUpdateRequest req) throws ValidationException {
FixedIncomeSecurity fixedIncome = fixedIncomeSecurityImdg.getSingleObjectByID(req.getId());
Instant updateTime = Instant.now();
fixedIncome.setUpdated(updateTime);
@ -161,25 +166,23 @@ public class FixedIncomeSecurityService extends QueueConsumer implements Initial
fixedIncome.setSecurityId(fixedIncome.getId());
fixedIncomeSecurityImdg.update(fixedIncome);
// Listing listing = listingImdg.getSingleObjectByFieldValues(Map.of("securityId", fixedIncome.getId()));
// 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;
return fixedIncome;
}
private RequestInfoUpdate deleteFixedIncome(BaseRequest<CommonDeleteRequest> userRequest) {
CommonDeleteRequest req = userRequest.getRequestPayload();
log.debug("CommonDeleteRequest received id = {}", req.getId());
protected RequestInfoUpdate deleteFixedIncome(BaseRequest<CommonDeleteRequest> userRequest) {
log.debug("CommonDeleteRequest received id = {} (object id={})", userRequest.getId(), userRequest.getRequestPayload() == null ? null : userRequest.getRequestPayload().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);
if (requestInfoUpdate != null) return requestInfoUpdate;
requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, validation.fixedIncomeDeleteValidator());
if (requestInfoUpdate != null) return requestInfoUpdate;
protected synchronized Long deleteFixedIncome0(CommonDeleteRequest req) throws ValidationException {
validationHelper.validateTillFirstErrorAndThrow(req, validation.fixedIncomeDeleteValidator());
Instant updateTime = Instant.now();
FixedIncomeSecurity equity = fixedIncomeSecurityImdg.getSingleObjectByID(req.getId());
@ -187,25 +190,7 @@ public class FixedIncomeSecurityService extends QueueConsumer implements Initial
equity.setUpdated(updateTime);
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;
}
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.annotation.Autowired;
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.instrument.issue.CouponPeriod;
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.securities.validation.ValidationProvider;
import ru.spcex.clearing.util.security.UserRoleVerification;
import ru.spcex.clearing.util.services.RequestHelper;
import ru.spcex.clearing.validation.common.ValidationHelper;
import ru.spcex.platform.enumeration.CompanySymbol;
import ru.spcex.platform.enumeration.InstrumentType;
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.ImdgId;
import ru.spcex.platform.imdg.api.ImdgProvider;
import ru.spcex.platform.utils.error.ValidationException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.*;
@Service
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<FixedIncomeCashFlow> fixedIncomeCashFlowImdg;
private final Imdg<CompanySymbols> companySymbolsImdg;
private final Imdg<Company> companyImdg;
private final ImdgProvider imdgProvider;
private final ImdgId idGenerator;
final FixedIncomeSecurityService fixedIncomeSecurityService;
final EquitySecurityService equitySecurityService;
final ListingService listingService;
final CouponPeriodService couponPeriodService;
final FixedIncomeCashFlowService fixedIncomeCashFlowService;
private final FixedIncomeSecurityService fixedIncomeSecurityService;
private final EquitySecurityService equitySecurityService;
private final ListingService listingService;
private final CouponPeriodService couponPeriodService;
private final FixedIncomeCashFlowService fixedIncomeCashFlowService;
private final ValidationProvider validation;
private final UserRoleVerification userRoleVerification;
private final ValidationHelper validationHelper;
private final RequestHelper requestHelper;
@Autowired
public GatewaySecurityService(Consumer<String, Object> kafkaQueue,
@ -67,6 +70,7 @@ public class GatewaySecurityService extends QueueConsumer implements Initializin
ValidationProvider validation,
UserRoleVerification userRoleVerification,
ValidationHelper validationHelper,
RequestHelper requestHelper,
FixedIncomeSecurityService fixedIncomeSecurityService,
EquitySecurityService equitySecurityService,
@ -81,10 +85,12 @@ public class GatewaySecurityService extends QueueConsumer implements Initializin
this.couponPeriodImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_CouponPeriod, CouponPeriod.class);
this.fixedIncomeCashFlowImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_FixedIncomeCashFlow, FixedIncomeCashFlow.class);
this.companySymbolsImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_CompanySymbols, CompanySymbols.class);
this.companyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class);
this.imdgProvider = imdgProvider;
this.idGenerator = imdgProvider.getImdgIdGenerator();
this.userRoleVerification = userRoleVerification.setRoleForVerification(UserRole.Admin);
this.validationHelper = validationHelper;
this.requestHelper = requestHelper;
this.fixedIncomeSecurityService = fixedIncomeSecurityService;
this.equitySecurityService = equitySecurityService;
@ -123,7 +129,10 @@ public class GatewaySecurityService extends QueueConsumer implements Initializin
// Проверяем, что в базе помимо реквизита есть компания
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;
}
@ -156,39 +165,39 @@ public class GatewaySecurityService extends QueueConsumer implements Initializin
// ImdgTransaction transaction = imdgProvider.newTransaction(); todo transaction
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) {
RequestInfoUpdate resp = fixedIncomeSecurityService.newFixedIncome(wrapRequest(baseRequest, fixedIncomeRequest, null));
validateReply(companyId, "newFixedIncome", resp);
try {
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);
} 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) {
RequestInfoUpdate resp = equitySecurityService.newEquity(wrapRequest(baseRequest, equityRequest, null));
validateReply(companyId, "newFixedIncome", resp);
security = findSecurityBySecuritySymbol(equitySecurityImdg, securitySymbol);
} else {
EquitySecurityUpdateRequest updateRequest = toUpdateRequest(security, equityRequest);
RequestInfoUpdate resp = equitySecurityService.updateEquity(wrapRequest(baseRequest, updateRequest, ActionType.UPDATE));
validateReply(companyId, "newFixedIncome", resp);
if (security == null) {
security = fixedIncomeSecurityService.newFixedIncome0(fixedIncomeRequest);
} else {
FixedIncomeSecurityUpdateRequest updateRequest = toUpdateRequest(security, fixedIncomeRequest);
security = fixedIncomeSecurityService.updateFixedIncome0(updateRequest);
}
}
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;
@ -207,50 +216,63 @@ public class GatewaySecurityService extends QueueConsumer implements Initializin
if (req.getFixedIncomesCashFlow() == null)
req.setFixedIncomesCashFlow(new ArrayList<>());
for (Object partRequestO : req.getListing()) {
ListingNewRequest partRequest = (ListingNewRequest) partRequestO;
partRequest.setSecurityId(securityId);
Listing existListing = findListing(partRequest);
if (existListing == null) {
log.trace("For company[{}] do new Listing", companyId);
RequestInfoUpdate replyI = listingService.newListing(wrapRequest(baseRequest, partRequest, ActionType.NEW));
validateReply(companyId, "ListingNew", replyI);
} else {
log.trace("For company[{}] do update Listing[{}]", companyId, existListing.getId());
ListingUpdateRequest partUpdateRequest = toUpdateRequest(existListing, partRequest);
RequestInfoUpdate replyI = listingService.updateListing(wrapRequest(baseRequest, partUpdateRequest, ActionType.UPDATE));
validateReply(companyId, "ListingUpdate", replyI);
try {
for (Object partRequestO : req.getListing()) {
ListingNewRequest partRequest = (ListingNewRequest) partRequestO;
partRequest.setSecurityId(securityId);
Listing existListing = findListing(partRequest);
if (existListing == null) {
log.trace("For company[{}] do new Listing", companyId);
Listing listing = listingService.newListing0(partRequest);
log.debug("New listing.id={}", listing.getId());
} else {
log.trace("For company[{}] do update Listing[{}]", companyId, existListing.getId());
ListingUpdateRequest partUpdateRequest = toUpdateRequest(existListing, partRequest);
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()) {
CouponPeriodNewRequest partRequest = (CouponPeriodNewRequest) partRequestO;
partRequest.setSecurityId(securityId);
CouponPeriod existCouponPeriod = findCouponPeriod(partRequest);
if (existCouponPeriod == null) {
log.trace("For company[{}] do new CouponPeriod", companyId);
RequestInfoUpdate replyI = couponPeriodService.newCouponPeriod(wrapRequest(baseRequest, partRequest, ActionType.NEW));
validateReply(companyId, "CouponPeriodNew", replyI);
} else {
log.trace("For company[{}] do update CouponPeriod[{}]", companyId, existCouponPeriod.getId());
CouponPeriodUpdateRequest partUpdateRequest = toUpdateRequest(existCouponPeriod, partRequest);
RequestInfoUpdate replyI = couponPeriodService.updateCouponPeriod(wrapRequest(baseRequest, partUpdateRequest, ActionType.UPDATE));
validateReply(companyId, "CouponPeriodUpdate", replyI);
try {
for (CouponPeriodNewRequest partRequest : (List<CouponPeriodNewRequest>)req.getCouponPeriods()) {
partRequest.setSecurityId(securityId);
CouponPeriod existCouponPeriod = findCouponPeriod(partRequest);
if (existCouponPeriod == null) {
log.trace("For company[{}] do new CouponPeriod", companyId);
CouponPeriod couponPeriod = couponPeriodService.newCouponPeriod0(partRequest);
log.debug("Has updated couponPeriod.id={}", couponPeriod.getId());
} else {
log.trace("For company[{}] do update CouponPeriod[{}]", companyId, existCouponPeriod.getId());
CouponPeriodUpdateRequest partUpdateRequest = toUpdateRequest(existCouponPeriod, partRequest);
CouponPeriod couponPeriod = couponPeriodService.updateCouponPeriod0(partUpdateRequest);
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()) {
FixedIncomeCashFlowNewRequest partRequest = (FixedIncomeCashFlowNewRequest) partRequestO;
partRequest.setSecuritySymbol(String.valueOf(securityId)); // не getSecuritySymbol
FixedIncomeCashFlow existFixedIncomeCashFlow = findFixedIncomeCashFlow(partRequest);
if (existFixedIncomeCashFlow == null) {
log.trace("For company[{}] do new FixedIncomeCashFlow", companyId);
RequestInfoUpdate replyI = fixedIncomeCashFlowService.fixedIncomeCashFlowNew(wrapRequest(baseRequest, partRequest, ActionType.NEW));
validateReply(companyId, "FixedIncomeCashFlowNew", replyI);
} else {
log.trace("For company[{}] do update FixedIncomeCashFlow[{}]", companyId, existFixedIncomeCashFlow.getId());
FixedIncomeCashFlowUpdateRequest partUpdateRequest = toUpdateRequest(existFixedIncomeCashFlow, partRequest);
RequestInfoUpdate replyI = fixedIncomeCashFlowService.fixedIncomeCashFlowUpdate(wrapRequest(baseRequest, partUpdateRequest, ActionType.UPDATE));
validateReply(companyId, "FixedIncomeCashFlowUpdate", replyI);
try {
for (FixedIncomeCashFlowNewRequest partRequest : (List<FixedIncomeCashFlowNewRequest>)req.getFixedIncomesCashFlow()) {
partRequest.setSecuritySymbol(String.valueOf(securityId)); // не getSecuritySymbol
FixedIncomeCashFlow existFixedIncomeCashFlow = findFixedIncomeCashFlow(partRequest);
if (existFixedIncomeCashFlow == null) {
log.trace("For company[{}] do new FixedIncomeCashFlow", companyId);
FixedIncomeCashFlow fixedIncomeCashFlow = fixedIncomeCashFlowService.fixedIncomeCashFlowNew0(partRequest);
log.debug("Has update fixedIncomeCashFlow.id={}", fixedIncomeCashFlow.getId());
} else {
log.trace("For company[{}] do update FixedIncomeCashFlow[{}]", companyId, existFixedIncomeCashFlow.getId());
FixedIncomeCashFlowUpdateRequest partUpdateRequest = toUpdateRequest(existFixedIncomeCashFlow, partRequest);
FixedIncomeCashFlow fixedIncomeCashFlow = fixedIncomeCashFlowService.fixedIncomeCashFlowUpdate0(partUpdateRequest);
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());

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.securities.validation.ListingValidationProvider;
import ru.spcex.clearing.util.security.UserRoleVerification;
import ru.spcex.clearing.util.services.RequestHelper;
import ru.spcex.clearing.validation.common.ValidationHelper;
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.ImdgId;
import ru.spcex.platform.imdg.api.ImdgProvider;
import ru.spcex.platform.utils.error.ValidationException;
import java.time.Instant;
@ -41,6 +43,7 @@ public class ListingService extends QueueConsumer implements InitializingBean {
private final UserRoleVerification userRoleVerification;
private final ValidationHelper validationHelper;
private final SecuritySelector securitySelector;
private final RequestHelper requestHelper;
@Autowired
public ListingService(Consumer<String, Object> kafkaQueue,
@ -49,7 +52,8 @@ public class ListingService extends QueueConsumer implements InitializingBean {
ListingValidationProvider validation,
UserRoleVerification userRoleVerification,
ValidationHelper validationHelper,
SecuritySelector securitySelector) {
SecuritySelector securitySelector,
RequestHelper requestHelper) {
super(kafkaQueue, kafkaProducer);
this.validation = validation;
this.securitySelector = securitySelector;
@ -58,6 +62,7 @@ public class ListingService extends QueueConsumer implements InitializingBean {
this.idGenerator = imdgProvider.getImdgIdGenerator();
this.userRoleVerification = userRoleVerification.setRoleForVerification(UserRole.Admin);
this.validationHelper = validationHelper;
this.requestHelper = requestHelper;
}
@Override
@ -75,14 +80,20 @@ public class ListingService extends QueueConsumer implements InitializingBean {
init();
}
public synchronized RequestInfoUpdate newListing(BaseRequest<ListingNewRequest> userRequest) {
ListingNewRequest req = userRequest.getRequestPayload();
log.debug("newListing received, id={}", userRequest.getId());
public RequestInfoUpdate newListing(BaseRequest<ListingNewRequest> userRequest) {
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);
if (requestInfoUpdate != null) return requestInfoUpdate;
requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, validation.listingNewValidator());
if (requestInfoUpdate != null) return requestInfoUpdate;
public synchronized Listing newListing0(ListingNewRequest req) throws ValidationException {
validationHelper.validateTillFirstErrorAndThrow(req, validation.listingNewValidator());
Security security = securitySelector.selectSecurityById(req.getSecurityId());
if (security == null) { // never
@ -106,19 +117,23 @@ public class ListingService extends QueueConsumer implements InitializingBean {
}
listingImdg.insert(listing);
log.debug("successfully processed, request id {}, new object id {}", userRequest.getId(), listing.getId());
return null; // default success
return listing;
}
public synchronized RequestInfoUpdate updateListing(BaseRequest<ListingUpdateRequest> userRequest) {
ListingUpdateRequest req = userRequest.getRequestPayload();
log.debug("updateListing received id = {}", req.getId());
public RequestInfoUpdate updateListing(BaseRequest<ListingUpdateRequest> userRequest) {
log.debug("ListingUpdateRequest received id = {}", userRequest.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());
}
}
RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest);
if (requestInfoUpdate != null) return requestInfoUpdate;
requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, validation.listingUpdateValidator());
if (requestInfoUpdate != null) return requestInfoUpdate;
public synchronized Listing updateListing0(ListingUpdateRequest req) throws ValidationException {
validationHelper.validateTillFirstErrorAndThrow(req, validation.listingUpdateValidator());
Listing listing = listingImdg.getSingleObjectByID(req.getId());
@ -140,17 +155,23 @@ public class ListingService extends QueueConsumer implements InitializingBean {
}
listingImdg.update(listing);
return null;
return listing;
}
private synchronized RequestInfoUpdate deleteListing(BaseRequest<CommonDeleteRequest> userRequest) {
CommonDeleteRequest req = userRequest.getRequestPayload();
log.debug("CommonDeleteRequest received id = {}", req.getId());
private RequestInfoUpdate deleteListing(BaseRequest<CommonDeleteRequest> userRequest) {
log.debug("CommonDeleteRequest received id = {}", userRequest.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);
if (requestInfoUpdate != null) return requestInfoUpdate;
requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, validation.listingDeleteValidator());
if (requestInfoUpdate != null) return requestInfoUpdate;
protected synchronized Long deleteListing0(CommonDeleteRequest req) throws ValidationException {
validationHelper.validateTillFirstErrorAndThrow(req, validation.listingDeleteValidator());
Instant updateTime = Instant.now();
Listing listing = listingImdg.getSingleObjectByID(req.getId());
@ -158,7 +179,7 @@ public class ListingService extends QueueConsumer implements InitializingBean {
listing.setUpdated(updateTime);
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.service.cud.EquitySecurityService;
import ru.spcex.clearing.test.MatcherFactory;
import ru.spcex.platform.enumeration.Market;
import javax.annotation.PostConstruct;
import java.math.BigDecimal;
@ -69,6 +70,17 @@ public class EquitySecurityServiceTest extends AbstractServiceTest {
// 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 EquitySecurity} в Hazelcast при передаче из Apache Kafka.<br>
@ -86,9 +98,9 @@ public class EquitySecurityServiceTest extends AbstractServiceTest {
equityPrediction.setFullName(fullName);
equityPrediction.setLotSize(BigDecimal.valueOf(updateLotSize));
final EquitySecurityUpdateRequest request = getEquitySecurityUpdateRequest(equityPrediction);
Listing listingPrediction = new Listing();
listingPrediction = equitySecurityService.updateListingByEquity(equityPrediction, listingPrediction);
listingImdg.insert(listingPrediction);
// Listing listingPrediction = new Listing();
// listingPrediction = equitySecurityService.updateListingByEquity(equityPrediction, listingPrediction);
// listingImdg.insert(listingPrediction);
//ACT
String jsonString = getJsonStringForUpdate(request, ID);
@ -103,10 +115,10 @@ public class EquitySecurityServiceTest extends AbstractServiceTest {
equityPrediction.setSecurityId(equityResult.getSecurityId());
EQUITY_SECURITY_MATCHER.assertMatch(equityResult, equityPrediction);
Listing listingResult = listingImdg.getSingleObjectByFieldValues(Map.of("securityId", equityPrediction.getId()));
listingPrediction.setId(listingResult.getId());
listingPrediction.setSecurityId(listingResult.getSecurityId());
LISTING_MATCHER.assertMatch(listingResult, listingPrediction);
// Listing listingResult = listingImdg.getSingleObjectByFieldValues(Map.of("securityId", equityPrediction.getId()));
// listingPrediction.setId(listingResult.getId());
// listingPrediction.setSecurityId(listingResult.getSecurityId());
// LISTING_MATCHER.assertMatch(listingResult, listingPrediction);
}
/**
@ -125,9 +137,9 @@ public class EquitySecurityServiceTest extends AbstractServiceTest {
equityPrediction.setWorkflowStatus(ru.spcex.platform.enumeration.Status.Blocked.getKey());
Listing listingPrediction = new Listing();
listingPrediction = equitySecurityService.updateListingByEquity(equityPrediction, listingPrediction);
listingImdg.insert(listingPrediction);
listingPrediction.setWorkflowStatus(ru.spcex.platform.enumeration.Status.Blocked.getKey());
// listingPrediction = equitySecurityService.updateListingByEquity(equityPrediction, listingPrediction);
// listingImdg.insert(listingPrediction);
// listingPrediction.setWorkflowStatus(ru.spcex.platform.enumeration.Status.Blocked.getKey());
CommonDeleteRequest commonDeleteRequest = new CommonDeleteRequest();
commonDeleteRequest.setId(ID);
@ -145,10 +157,10 @@ public class EquitySecurityServiceTest extends AbstractServiceTest {
equityPrediction.setSecurityId(equityResult.getSecurityId());
EQUITY_SECURITY_MATCHER.assertMatch(equityResult, equityPrediction);
Listing listingResult = listingImdg.getSingleObjectByFieldValues(Map.of("securityId", equityPrediction.getId()));
listingPrediction.setId(listingResult.getId());
listingPrediction.setSecurityId(listingResult.getSecurityId());
LISTING_MATCHER.assertMatch(listingResult, listingPrediction);
// Listing listingResult = listingImdg.getSingleObjectByFieldValues(Map.of("securityId", equityPrediction.getId()));
// listingPrediction.setId(listingResult.getId());
// listingPrediction.setSecurityId(listingResult.getSecurityId());
// LISTING_MATCHER.assertMatch(listingResult, listingPrediction);
}
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);
}
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 FixedIncomeSecurity} в Hazelcast при передаче из Apache Kafka.<br>
@ -88,9 +98,9 @@ public class FixedIncomeSecurityServiceTest extends AbstractServiceTest {
fixedIncomePrediction.setFullName(fullName);
fixedIncomePrediction.setLotSize(BigDecimal.valueOf(updateLotSize));
final FixedIncomeSecurityUpdateRequest request = getFixedIncomeSecurityUpdateRequest(fixedIncomePrediction);
Listing listingPrediction = new Listing();
listingPrediction = fixedIncomeSecurityService.updateListingByFixedIncome(fixedIncomePrediction, listingPrediction);
listingImdg.insert(listingPrediction);
// Listing listingPrediction = new Listing();
// listingPrediction = fixedIncomeSecurityService.updateListingByFixedIncome(fixedIncomePrediction, listingPrediction);
// listingImdg.insert(listingPrediction);
//ACT
String jsonString = getJsonStringForUpdate(request, ID);
@ -105,10 +115,10 @@ public class FixedIncomeSecurityServiceTest extends AbstractServiceTest {
fixedIncomePrediction.setSecurityId(equityResult.getSecurityId());
FIXED_INCOME_SECURITY_MATCHER.assertMatch(equityResult, fixedIncomePrediction);
Listing listingResult = listingImdg.getSingleObjectByFieldValues(Map.of("securityId", fixedIncomePrediction.getId()));
listingPrediction.setId(listingResult.getId());
listingPrediction.setSecurityId(listingResult.getSecurityId());
LISTING_MATCHER.assertMatch(listingResult, listingPrediction);
// Listing listingResult = listingImdg.getSingleObjectByFieldValues(Map.of("securityId", fixedIncomePrediction.getId()));
// listingPrediction.setId(listingResult.getId());
// listingPrediction.setSecurityId(listingResult.getSecurityId());
// LISTING_MATCHER.assertMatch(listingResult, listingPrediction);
}
/**
@ -127,9 +137,9 @@ public class FixedIncomeSecurityServiceTest extends AbstractServiceTest {
fixedIncomePrediction.setWorkflowStatus(ru.spcex.platform.enumeration.Status.Blocked.getKey());
Listing listingPrediction = new Listing();
listingPrediction = fixedIncomeSecurityService.updateListingByFixedIncome(fixedIncomePrediction, listingPrediction);
listingImdg.insert(listingPrediction);
listingPrediction.setWorkflowStatus(ru.spcex.platform.enumeration.Status.Blocked.getKey());
// listingPrediction = fixedIncomeSecurityService.updateListingByFixedIncome(fixedIncomePrediction, listingPrediction);
// listingImdg.insert(listingPrediction);
// listingPrediction.setWorkflowStatus(ru.spcex.platform.enumeration.Status.Blocked.getKey());
CommonDeleteRequest commonDeleteRequest = new CommonDeleteRequest();
commonDeleteRequest.setId(ID);
@ -147,10 +157,10 @@ public class FixedIncomeSecurityServiceTest extends AbstractServiceTest {
fixedIncomePrediction.setSecurityId(equityResult.getSecurityId());
FIXED_INCOME_SECURITY_MATCHER.assertMatch(equityResult, fixedIncomePrediction);
Listing listingResult = listingImdg.getSingleObjectByFieldValues(Map.of("securityId", fixedIncomePrediction.getId()));
listingPrediction.setId(listingResult.getId());
listingPrediction.setSecurityId(listingResult.getSecurityId());
LISTING_MATCHER.assertMatch(listingResult, listingPrediction);
// Listing listingResult = listingImdg.getSingleObjectByFieldValues(Map.of("securityId", fixedIncomePrediction.getId()));
// listingPrediction.setId(listingResult.getId());
// listingPrediction.setSecurityId(listingResult.getSecurityId());
// LISTING_MATCHER.assertMatch(listingResult, listingPrediction);
}
private FixedIncomeSecurity getFixedIncomeSecurity() {