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

TaskManage update

Browse source
This commit is contained in:
aalehin 2023-02-02 20:04:53 +03:00
parent 0156a498a7
commit 31cf15d289
4 changed files with 215 additions and 45 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

27
clearing-parent/classes/src/main/java/ru/clearing/classes/statics/data/scheduler/PlannerAllToday.java
View file

@ -24,6 +24,32 @@ public class PlannerAllToday extends SpcexObjectBase {
private String parent;
private Long parentId;
public static PlannerAllToday makePlannerAllTodayFromPlanner(Planner planner, Long parentId) {
PlannerAllToday res = new PlannerAllToday();
res.setTask(planner.getTask());
res.setTaskTime(planner.getTaskTime());
res.setClearingDate(planner.getClearingDate());
res.setMarket(planner.getMarket());
res.setTaskStatus(planner.getTaskStatus());
res.setCompanyId(planner.getCompanyId());
res.setSecurityId(planner.getSecurityId());
res.setParent("PLNR");
res.setParentId(parentId);
return res;
}
public static PlannerAllToday makePlannerAllTodayFromPlannerTemplate(PlannerTemplate plannerTemplate, Long parentId) {
PlannerAllToday res = new PlannerAllToday();
res.setTask(plannerTemplate.getTask());
res.setTaskTime(plannerTemplate.getTaskTime());
res.setTaskStatus(plannerTemplate.getTaskStatus());
res.setCompanyId(plannerTemplate.getCompanyId());
res.setSecurityId(plannerTemplate.getSecurityId());
res.setParent("TMPL");
res.setParentId(parentId);
return res;
}
public String getTask() {
return task;
}
@ -95,4 +121,5 @@ public class PlannerAllToday extends SpcexObjectBase {
public void setCompanyId(Long companyId) {
this.companyId = companyId;
}
}

32
clearing-parent/scheduler-service/src/main/java/ru/spcex/clearing/scheduler/enums/TaskEnum.java Normal file
View file

@ -0,0 +1,32 @@
package ru.spcex.clearing.scheduler.enums;
public enum TaskEnum {
PLANNER_NEW("PLANNER_NEW"),
PLANNER_UPDATE("PLANNER_UPDATE"),
PLANNER_DELETE("PLANNER_DELETE"),
PLANNER_TEMPLATE_NEW("PLANNER_TEMPLATE_NEW"),
PLANNER_TEMPLATE_UPDATE("PLANNER_TEMPLATE_UPDATE"),
PLANNER_TEMPLATE_DELETE("PLANNER_TEMPLATE_DELETE"),
CLEARING_CALENDAR_NEW("CLEARING_CALENDAR_NEW"),
CLEARING_CALENDAR_UPDATE("CLEARING_CALENDAR_UPDATE"),
CLEARING_CALENDAR_DELETE("CLEARING_CALENDAR_DELETE");
private final String text;
TaskEnum(String text) {
this.text = text;
}
public static TaskEnum fromString(String text) {
for (TaskEnum b : TaskEnum.values()) {
if (b.text.equalsIgnoreCase(text)) {
return b;
}
}
return null;
}
public String getText() {
return this.text;
}
}

158
clearing-parent/scheduler-service/src/main/java/ru/spcex/clearing/scheduler/service/TaskManager.java
View file

@ -8,10 +8,13 @@ import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.lang.NonNull;
import org.springframework.scheduling.TaskScheduler;
import org.springframework.stereotype.Service;
import ru.clearing.classes.statics.data.scheduler.ClearingCalendar;
import ru.clearing.classes.statics.data.scheduler.Planner;
import ru.clearing.classes.statics.data.scheduler.PlannerAllToday;
import ru.clearing.classes.statics.data.scheduler.PlannerTemplate;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
import ru.spcex.clearing.platform.messaging.domain.Consts;
@ -19,26 +22,23 @@ import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonDeleteReques
import ru.spcex.clearing.platform.messaging.domain.cud.schedule.*;
import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate;
import ru.spcex.clearing.scheduler.enums.TaskEnum;
import ru.spcex.platform.enumeration.DayStatus;
import ru.spcex.platform.enumeration.Status;
import ru.spcex.platform.enumeration.Task;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.api.ImdgProvider;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.ZoneId;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Objects;
import java.util.Optional;
import java.time.*;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.ScheduledFuture;
import java.util.stream.Collectors;
import static ru.clearing.classes.statics.data.scheduler.PlannerAllToday.makePlannerAllTodayFromPlanner;
import static ru.clearing.classes.statics.data.scheduler.PlannerAllToday.makePlannerAllTodayFromPlannerTemplate;
import static ru.spcex.clearing.platform.messaging.domain.Consts.LAUNCHER_NEW;
import static ru.spcex.platform.enumeration.Status.*;
import static ru.spcex.platform.utils.enumeration.IEnumKey.getEnumByKey;
@ -53,10 +53,12 @@ public class TaskManager extends QueueConsumer implements InitializingBean {
private final TaskScheduler taskScheduler;
private final ImdgProvider imdgProvider;
private final Producer<String, Object> kafkaProducer;
private Imdg<PlannerAllToday> plannerAllTodayMap;
private Imdg<ClearingCalendar> clearingCalendarMap;
private Imdg<Planner> plannerMap;
private Imdg<PlannerTemplate> plannerTemplateMap;
private ConcurrentHashMap<LocalTime, ScheduledFuture> scheduledJobs;
private Producer<String, Object> kafkaProducer;
@Autowired
public TaskManager(TaskScheduler taskScheduler,
@ -69,43 +71,95 @@ public class TaskManager extends QueueConsumer implements InitializingBean {
this.kafkaProducer = kafkaProducer;
}
@Override
public void afterPropertiesSet() throws Exception {
plannerAllTodayMap = imdgProvider.getImdg(IMDGDistributedNames.Map_PlannerAllToday, PlannerAllToday.class);
clearingCalendarMap = imdgProvider.getImdg(IMDGDistributedNames.Map_ClearingMemberCategory, ClearingCalendar.class);
plannerMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Planner, Planner.class);
plannerTemplateMap = imdgProvider.getImdg(IMDGDistributedNames.Map_PlannerTemplate, PlannerTemplate.class);
scheduledJobs = new ConcurrentHashMap<>();
updateScheduler();
callback(PlannerNewRequest.class)
.setFunction(this::newPlanner)
callback(TaskManagerRequest.class)
.setFunction(this::processTask)
.forDestination(Consts.DESTINATION_PLANNER_NEW, callbacks::put);//fixme
callback(PlannerUpdateRequest.class)
.setFunction(this::updatePlanner)
.forDestination(Consts.DESTINATION_PLANNER_UPDATE, callbacks::put);//fixme
callback(CommonDeleteRequest.class)
.setFunction(this::deletePlanner)
.forDestination(Consts.DESTINATION_PLANNER_DELETE, callbacks::put);//fixme
callback(PlannerTemplateNewRequest.class)
.setFunction(this::newPlannerTemplate)
.forDestination(Consts.DESTINATION_PLANNER_TEMPLATE_NEW, callbacks::put);
callback(PlannerTemplateUpdateRequest.class)
.setFunction(this::updatePlannerTemplate)
.forDestination(Consts.DESTINATION_PLANNER_TEMPLATE_UPDATE, callbacks::put);
callback(CommonDeleteRequest.class)
.setFunction(this::deletePlannerTemplate)
.forDestination(Consts.DESTINATION_PLANNER_TEMPLATE_DELETE, callbacks::put);
callback(ClearingCalendarNewRequest.class)
.setFunction(this::newClearingCalendar)
.forDestination(Consts.DESTINATION_CLEARING_CALENDAR_NEW, callbacks::put);
callback(ClearingCalendarUpdateRequest.class)
.setFunction(this::updateClearingCalendar)
.forDestination(Consts.DESTINATION_CLEARING_CALENDAR_UPDATE, callbacks::put);
callback(CommonDeleteRequest.class)
.setFunction(this::deleteClearingCalendar)
.forDestination(Consts.DESTINATION_CLEARING_CALENDAR_DELETE, callbacks::put);
init();
}
private Object processTask(BaseRequest<TaskManagerRequest> taskManagerRequestBaseRequest) {
LocalDate currentDate = LocalDate.now();
TaskManagerRequest taskManagerRequest = taskManagerRequestBaseRequest.getRequestPayload();
switch (Objects.requireNonNull(TaskEnum.fromString(taskManagerRequest.getAction()))) {
case PLANNER_NEW -> {
Planner planner = getPlannerById(taskManagerRequest.parentId);
PlannerAllToday plannerAllToday = makePlannerAllTodayFromPlanner(planner, taskManagerRequest.parentId);
createTask(plannerAllToday);
}
case PLANNER_UPDATE -> {
Planner planner = getPlannerById(taskManagerRequest.parentId);
PlannerAllToday plannerAllToday = makePlannerAllTodayFromPlanner(planner, taskManagerRequest.parentId);
updateTask(plannerAllToday);
}
case PLANNER_DELETE -> {
deleteTask(taskManagerRequest.task, taskManagerRequest.taskTime);
}
case PLANNER_TEMPLATE_NEW -> {
PlannerTemplate template = getPlannerTemplateById(taskManagerRequest.parentId);
PlannerAllToday plannerAllToday = makePlannerAllTodayFromPlannerTemplate(template, taskManagerRequest.parentId);
boolean weekend = Arrays.asList(DayOfWeek.SATURDAY, DayOfWeek.SUNDAY).contains(LocalDate.now().getDayOfWeek());
if (clearingCalendarMap == null || clearingCalendarMap.getAllValues().isEmpty()) {
if (!weekend && plannerAllToday.getTaskTime().equals(currentDate)) {
createTask(plannerAllToday);
}
} else {
Optional<ClearingCalendar> clearingCalendarOptional = clearingCalendarMap.getAllValues().stream()
.filter((calendar) -> calendar.getClearingDate().isEqual(currentDate))
.findFirst();
if (clearingCalendarOptional.isPresent()) {
ClearingCalendar calendar = clearingCalendarOptional.get();
if (calendar.getDayStatus().equalsIgnoreCase(DayStatus.Workday.getKey())) {
if (calendar.getCompanyId() != null && calendar.getCompanyId() != 0) {
createTask(plannerAllToday);
}
}
}
}
}
case PLANNER_TEMPLATE_UPDATE -> {
PlannerTemplate template = getPlannerTemplateById(taskManagerRequest.parentId);
PlannerAllToday plannerAllToday = makePlannerAllTodayFromPlannerTemplate(template, taskManagerRequest.parentId);
updateTask(plannerAllToday);
}
case PLANNER_TEMPLATE_DELETE -> {
//todo
}
case CLEARING_CALENDAR_NEW -> {
//todo
}
case CLEARING_CALENDAR_UPDATE -> {
}
case CLEARING_CALENDAR_DELETE -> {
}
}
return new Object();
}
private void createTask(PlannerAllToday task) {
}
private void updateTask(PlannerAllToday task) {
}
private void deleteTask(String task, LocalTime taskTime) {
}
// --- Планирование задач ---
protected void updateScheduler() {
Collection<PlannerAllToday> schedulerAllTodays = plannerAllTodayMap.getAllValues();
@ -117,6 +171,20 @@ public class TaskManager extends QueueConsumer implements InitializingBean {
}
}
@NonNull
public Planner getPlannerById(Long id) {
return plannerMap.getSingleObjectByID(id);
}
@NonNull
public PlannerTemplate getPlannerTemplateById(Long id) {
return plannerTemplateMap.getSingleObjectByID(id);
}
@NonNull
public ClearingCalendar getClearingCalendarById(Long id) {
return clearingCalendarMap.getSingleObjectByID(id);
}
public RequestInfoUpdate newPlanner(BaseRequest<PlannerNewRequest> userRequest) {
RequestInfoUpdate requestInfoUpdate = new RequestInfoUpdate();
@ -200,10 +268,7 @@ public class TaskManager extends QueueConsumer implements InitializingBean {
if (calendar.getDayStatus().equalsIgnoreCase(DayStatus.Workday.getKey())) {
if (calendar.getCompanyId() != null && calendar.getCompanyId() != 0) {
Optional<PlannerAllToday> plannerAllTodayOptional = plannerAllTodayMap.getAllValues().stream().filter((x) -> {
if (x.getTaskTime().equals(request.getTaskTime()) && x.getTask().equalsIgnoreCase(request.getTask())) {
return true;
}
return false;
return x.getTaskTime().equals(request.getTaskTime()) && x.getTask().equalsIgnoreCase(request.getTask());
}).findFirst();
PlannerAllToday planner;
if (plannerAllTodayOptional.isPresent()) {
@ -246,6 +311,7 @@ public class TaskManager extends QueueConsumer implements InitializingBean {
removeTask(plannerAllToday.getTask(), plannerAllToday.getTaskTime());
}
//при создании новой энтри
private void newEntry(PlannerAllToday task) {
Task taskType = getEnumByKey(Task.class, task.getTask());
if (taskType == null) {
@ -258,6 +324,8 @@ public class TaskManager extends QueueConsumer implements InitializingBean {
plannerAllTodayMap.insert(task);
}
//при добавлении Entry
private void updateEntry(PlannerAllToday plannerAllToday) {
PlannerAllToday task = plannerAllToday;
PlannerAllToday oldTask;
@ -265,11 +333,7 @@ public class TaskManager extends QueueConsumer implements InitializingBean {
if (!x.getTaskTime().equals(task.getTaskTime())) {
return false;
}
if (!x.getTask().equalsIgnoreCase(task.getTask())) {
return false;
}
return true;
return x.getTask().equalsIgnoreCase(task.getTask());
}).findFirst();
if (!optionalOldTask.isPresent()) {
@ -303,6 +367,7 @@ public class TaskManager extends QueueConsumer implements InitializingBean {
}
//востановить таск, который был удален из запланированных
private void restorePreviouslyRemovedTask(LocalTime oldTime, PlannerAllToday oldTask) {
ScheduledFuture cancelledFuture = scheduledJobs.get(oldTime);
if (cancelledFuture != null && cancelledFuture.isCancelled()) {
@ -315,6 +380,7 @@ public class TaskManager extends QueueConsumer implements InitializingBean {
}
}
// убрать таск из очереди plannerAllToday
private void removePlannerAllToday(String task, LocalTime taskTime) {
for (PlannerAllToday x : plannerAllTodayMap.getAllValues()) {
if (x.getTaskTime().equals(taskTime) && x.getTask().equalsIgnoreCase(task)) {
@ -324,6 +390,7 @@ public class TaskManager extends QueueConsumer implements InitializingBean {
}
}
// убрать таск из запланированных и очереди plannerAllToday
private boolean removeTask(String task, LocalTime taskTime) {
removePlannerAllToday(task, taskTime);
ScheduledFuture future = scheduledJobs.remove(taskTime);
@ -334,6 +401,7 @@ public class TaskManager extends QueueConsumer implements InitializingBean {
return future.cancel(false);
}
// выполнение работы
protected void doJob(PlannerAllToday task) {
Task taskE = getEnumByKey(Task.class, task.getTask());
if (taskE != null) {

43
platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/schedule/TaskManagerRequest.java Normal file
View file

@ -0,0 +1,43 @@
package ru.spcex.clearing.platform.messaging.domain.cud.schedule;
import com.fasterxml.jackson.annotation.JsonProperty;
import java.time.LocalTime;
public class TaskManagerRequest {
@JsonProperty
public Long parentId;
@JsonProperty
public String action; //new update delete
@JsonProperty
public String parent;
@JsonProperty
public String task;
@JsonProperty
public LocalTime taskTime;
public Long getParentId() {
return parentId;
}
public void setParentId(Long parentId) {
this.parentId = parentId;
}
public String getAction() {
return action;
}
public void setAction(String action) {
this.action = action;
}
public String getParent() {
return parent;
}
public void setParent(String parent) {
this.parent = parent;
}
}