xiaoning
/
gj_erp
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

1.排产临时提交

Browse Source
master
董哲奇 1 year ago
parent 2da9eceff2
commit 47583b333b
29 changed files with 933 additions and 3 deletions
Show Stats Download Patch File Download Diff File

20
pom.xml
Unescape View File

@ -19,6 +19,21 @@
</properties>
<dependencies>
<dependency>
<groupId>cn.afterturn</groupId>
<artifactId>easypoi-base</artifactId>
<version>3.2.0</version>
</dependency>
<dependency>
<groupId>cn.afterturn</groupId>
<artifactId>easypoi-web</artifactId>
<version>3.2.0</version>
</dependency>
<dependency>
<groupId>cn.afterturn</groupId>
<artifactId>easypoi-annotation</artifactId>
<version>3.2.0</version>
</dependency>
<dependency>
<groupId>org.apache.pdfbox</groupId>
<artifactId>pdfbox</artifactId>
@ -254,6 +269,11 @@
<artifactId>mybatisplus-plus</artifactId>
<version>1.7.4-RELEASE</version>
</dependency>-->
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>21.0</version>
</dependency>
</dependencies>
<build>

6
src/main/java/com/dsic/gj_erp/bean/jcsj/DmBom.java
Unescape View File

@ -1,7 +1,9 @@
package com.dsic.gj_erp.bean.jcsj;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.dsic.gj_erp.pc.dto.资源;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
@ -217,7 +219,7 @@ public class DmBom implements Serializable {
// 反馈工时
private String fkgs;
@TableField(exist = false)
private 资源 所在资源;
}

4
src/main/java/com/dsic/gj_erp/bean/jhgk/DmSygdxq.java
Unescape View File

@ -3,12 +3,14 @@ package com.dsic.gj_erp.bean.jhgk;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.dsic.gj_erp.bean.jcsj.DmBom;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;
import java.util.List;
/**
* <p>
@ -90,5 +92,7 @@ public class DmSygdxq implements Serializable {
private String xqzt="0";
@TableField(exist = false)
private List<DmBom> bomList;
}

2
src/main/java/com/dsic/gj_erp/mapper/jhgk/DmSygdxqMapper.java
Unescape View File

@ -18,4 +18,6 @@ import java.util.List;
*/
public interface DmSygdxqMapper extends BaseMapper<DmSygdxq> {
List<DmSygdxq> getXqWithBom(String from,String to);
}

162
src/main/java/com/dsic/gj_erp/pc/Constant.java
Unescape View File

@ -0,0 +1,162 @@
package com.dsic.gj_erp.pc;
import com.dsic.gj_erp.bean.jcsj.EmSbjbb;
import com.dsic.gj_erp.pc.dto.sb.设备01上料;
import com.dsic.gj_erp.pc.dto.sb.设备02抛丸;
import com.dsic.gj_erp.pc.dto.设备;
import com.google.common.collect.ImmutableMap;
import lombok.AllArgsConstructor;
import lombok.Getter;
import java.util.Map;
public interface Constant {
//手动配置,后期可根据设备进行计算(计算方式根据所有设备的产能合并后的结果,设备维护时不计入产能,休息日产能默认为0)
ImmutableMap<工序, Double> 工序产能 = ImmutableMap.<工序, Double>builder()
.put(工序.上料, 200.0)
.put(工序.抛丸, 200.0)
.put(工序.理料, 200.0)
.put(工序.划线, 200.0)
.put(工序.一跨龙门切割, 200.0)
.put(工序.一跨数控切割, 200.0)
.put(工序.二跨数控切割, 200.0)
.put(工序.三跨数控切割, 200.0)
.put(工序.三跨平铁切割, 200.0)
.put(工序.手工切割, 200.0)
.put(工序.坡口, 200.0)
.put(工序.型材面板, 200.0)
.put(工序.曲加工, 200.0)
.put(工序.平铁打磨, 200.0)
.put(工序.手工打磨, 200.0)
.put(工序.预配盘, 200.0)
.put(工序.光电结束, 200.0)
.build();
//相对于钢料需求期
ImmutableMap<工序, Integer> 工序CD = ImmutableMap.<工序, Integer>builder()
.put(工序.上料, -10)
.put(工序.抛丸, -8)
.put(工序.理料, -8)
.put(工序.划线, -5)
.put(工序.一跨龙门切割, -5)
.put(工序.一跨数控切割, -5)
.put(工序.二跨数控切割, -5)
.put(工序.三跨数控切割, -5)
.put(工序.三跨平铁切割, -5)
.put(工序.手工切割, -5)
.put(工序.坡口, -3)
.put(工序.型材面板, -2)
.put(工序.曲加工, -5)
.put(工序.平铁打磨, -5)
.put(工序.手工打磨, -5)
.put(工序.预配盘, 0)
.put(工序.光电结束, -3)
.put(工序.配送, 0)
.build();
//来源数据库
// ImmutableMap<String, 工序> 套料图工序对应关系 = ImmutableMap.of();
// .<String, 工序>builder()
//二跨超长超宽曲板小组
// .put("10101019", 工序.上料)
// .put("10101020", 工序.抛丸)
// .put("10101021", 工序.理料)
// .put("10101004", 工序.二跨数控切割)
// .put("10101008", 工序.坡口)
// .put("10101018", 工序.曲加工)
//二跨超长超宽曲板中大组
// .put("10111019", 工序.上料)
// .put("10111020", 工序.抛丸)
// .put("10111021", 工序.理料)
// .put("10111004", 工序.二跨数控切割)
// .put("10111008", 工序.坡口)
// .put("10111018", 工序.曲加工)
// .build();
//来源数据库
ImmutableMap<工序, Map<String, 设备>> 工序设备对应关系 = ImmutableMap.<工序, Map<String, 设备>>builder()
//二跨超长超宽曲板小组
.put(工序.上料, ImmutableMap.<String, 设备>builder()
.put("",new 设备01上料())
.build())
.put(工序.抛丸, ImmutableMap.<String, 设备>builder()
.put("",new 设备02抛丸())
.build())
// .put(工序.抛丸, new EmSbjbb[]{new EmSbjbb(), new EmSbjbb()})
// .put(工序.理料, new EmSbjbb[]{new EmSbjbb(), new EmSbjbb()})
// .put(工序.划线, new EmSbjbb[]{new EmSbjbb(), new EmSbjbb()})
//
// .put(工序.一跨龙门切割, new EmSbjbb[]{new EmSbjbb(), new EmSbjbb()})
// .put(工序.一跨数控切割, new EmSbjbb[]{new EmSbjbb(), new EmSbjbb()})
// .put(工序.二跨数控切割, new EmSbjbb[]{new EmSbjbb(), new EmSbjbb()})
// .put(工序.三跨数控切割, new EmSbjbb[]{new EmSbjbb(), new EmSbjbb()})
// .put(工序.三跨平铁切割, new EmSbjbb[]{new EmSbjbb(), new EmSbjbb()})
//
// .put(工序.坡口, new EmSbjbb[]{new EmSbjbb(), new EmSbjbb()})
// .put(工序.型材面板, new EmSbjbb[]{new EmSbjbb(), new EmSbjbb()})
// .put(工序.曲加工, new EmSbjbb[]{new EmSbjbb(), new EmSbjbb()})
// .put(工序.平铁打磨, new EmSbjbb[]{new EmSbjbb(), new EmSbjbb()})
// .put(工序.手工打磨, new EmSbjbb[]{new EmSbjbb(), new EmSbjbb()})
// .put(工序.预配盘, new EmSbjbb[]{new EmSbjbb(), new EmSbjbb()})
// .put(工序.光电结束, new EmSbjbb[]{new EmSbjbb(), new EmSbjbb()})
// .put(工序.配送, new EmSbjbb[]{new EmSbjbb(), new EmSbjbb()})
.build();
@Getter
@AllArgsConstructor
enum 设备产能{
SLSB01(工序.上料,"","",0,0,200.0,200.0,400),
PWSB01(工序.抛丸,"","",0,0,240.0,286.0,526.0),
LM01(工序.一跨龙门切割,"","",2.4,3.6,9.6,15.6,25.2),
火焰01(工序.一跨数控切割,"","",0.3,11.5,2.0,0,2.0),
数控01(工序.一跨数控切割,"","",1.5,3.0,0,8.5,25.5),
;
public 工序 _工序;
public String 设备编号;
public String 设备名称;
public double 单台效率;
public double 单台产能;
public double 白班设备产能;
public double 二班设备产能;
public double 双班合计产能;
}
@AllArgsConstructor
enum 工序{
NULL(""),
上料("19"),
抛丸("20"),
理料("21"),
划线("01"),
一跨龙门切割("03"),一跨数控切割("04"),二跨数控切割("04"),三跨数控切割("04"),三跨平铁切割("05"),手工切割("06"),
坡口("08"),
型材面板("17"),
曲加工("18"),
平铁打磨("13"),手工打磨("16"),
预配盘(""),
光电结束(""),
配送(""),
;
@Getter
private String code;
//通过code获取工序
public static 工序 getGxByCode(String code) {
for (工序 gx : 工序.values()) {
if (gx.getCode().equals(code)) {
return gx;
}
}
return 工序.NULL;
}
//判断工序是否时NULL的
public static boolean isNull(工序 gx) {
return gx==工序.NULL;
}
}
}

179
src/main/java/com/dsic/gj_erp/pc/DataFactory.java
Unescape View File

@ -0,0 +1,179 @@
package com.dsic.gj_erp.pc;
import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.ObjUtil;
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.dsic.gj_erp.bean.SpringContextHolder;
import com.dsic.gj_erp.bean.jcsj.EmGcrl;
import com.dsic.gj_erp.bean.jcsj.EmSbcnp;
import com.dsic.gj_erp.bean.jcsj.EmSbjbb;
import com.dsic.gj_erp.bean.jhgk.DmSygdxq;
import com.dsic.gj_erp.pc.dto.gx.*;
import com.dsic.gj_erp.pc.dto.工序产能;
import com.dsic.gj_erp.pc.dto.排产结果;
import com.dsic.gj_erp.pc.dto.设备;
import com.dsic.gj_erp.pc.dto.资源;
import com.dsic.gj_erp.service.jcsj.EmGcrlService;
import com.dsic.gj_erp.service.jcsj.EmSbcnpService;
import com.dsic.gj_erp.service.jcsj.EmSbjbbService;
import com.dsic.gj_erp.service.jhgk.DmSygdxqService;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.util.*;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.stream.Collectors;
import static com.dsic.gj_erp.pc.Constant.工序CD;
import static com.dsic.gj_erp.pc.Manager.*;
public class DataFactory {
public static void 排产(){
套料图所占工序的资源.clear();
List<排产结果> list = 排产.list;
list.clear();
List<DmSygdxq> xqWithBom = getBean(DmSygdxqService.class).getXqWithBom(from, to);
xqWithBom.forEach(xq->{
xq.getBomList().forEach(bom->{
Arrays.stream(Constant.工序.values()).forEach(gx->{
if (StrUtil.isEmpty(gx.getCode()))return;
if (ObjUtil.isNotEmpty(套料图工序对应关系.get(bom.getKw()+bom.getZl()+"_"+gx.getCode()))){
Integer cd = 工序CD.get(gx);
DateTime parse = DateUtil.parse(xq.getXzglxq(), "yyyy/MM/dd");
DateTime dateTime = DateUtil.offsetDay(parse, cd);
资源 _资源 = 提取资源(dateTime);
Optional.of(_资源).ifPresent(it->{
工序产能 工序产能=null;
资源 资源 = 套料图所占工序的资源.get(bom.getTzbh());
if (资源!=null){
工序产能 = 套料图所占工序的资源.get(bom.getTzbh()).get工序产能MAP().get(gx);
}
if (工序产能!=null&&工序产能.get资源占用图纸表().contains(bom.getTzbh())){
bom.set所在资源(_资源);
}else{
工序产能 = it.get工序产能MAP().get(gx);
//直接占用资源
工序产能.占用资源(bom.getTzbh(), bom.getTlsl().doubleValue());
bom.set所在资源(_资源);
套料图所占工序的资源.put(bom.getTzbh(),_资源);
}
});
}
});
});
});
System.out.println(111);
}
public static 资源 提取资源(Date date){
资源 资源 = 资源池.get(DateUtil.format(date, "yyyy/MM/dd"));
if (资源==null){
return 提取资源(DateUtil.offsetDay(date,-1));
}
return 资源;
}
public static void 创建产能资源池(){
资源池.clear();
Map<Constant.工序, 工序产能> map=new HashMap<>();
Arrays.stream(Constant.工序.values()).forEach(item->{
if (StrUtil.isNotEmpty(item.getCode())){
map.put(item,工序产能工厂(item));
}
});
工厂日历.stream().filter(item -> "1".equals(item.getXxr()))
.forEach(item -> 资源池.put(item.getGl(),资源.of(item.getGl(), map)));
}
public static 工序产能 工序产能工厂(Constant.工序 _工序){
Map<String, 设备> _设备 = Constant.工序设备对应关系.get(_工序);
switch (_工序){
case 上料:
return new 工序01上料(_工序,_设备);
case 抛丸:
return new 工序02抛丸(_工序,_设备);
case 理料:
return new 工序03理料(_工序,_设备);
case 划线:
return new 工序04划线(_工序,_设备);
case 一跨龙门切割:
case 一跨数控切割:
case 二跨数控切割:
case 三跨数控切割:
case 三跨平铁切割:
case 手工切割:
return new 工序05切割(_工序,_设备);
case 坡口:
return new 工序07坡口(_工序,_设备);
case 型材面板:
return new 工序10型材(_工序,_设备);
case 曲加工:
return new 工序08曲面(_工序,_设备);
case 平铁打磨:
case 手工打磨:
return new 工序09打磨(_工序,_设备);
// case 预配盘:
// return new 工序01上料(_工序,_设备);
// case 光电结束:
// return new 工序01上料(_工序,_设备);
// case 配送:
// return new 工序01上料(_工序,_设备);
default:
return new 工序99未知(_工序,_设备);
}
}
public static void 加载工厂日历(){
List<EmGcrl> list = getBean(EmGcrlService.class).getList(new JSONObject());
工厂日历.clear();
工厂日历.addAll(list);
}
public static void 加载套料图工序对应关系(){
套料图工序对应关系.clear();
List<EmSbcnp> list = getBean(EmSbcnpService.class).list();
Map<String, List<EmSbcnp>> map = list.stream().collect(Collectors.groupingBy(l -> l.getTzbh() + l.getZl()+"_"+l.getGx()));
map.keySet().forEach(key->{
String gxCode=key.split("_")[1];
套料图工序对应关系.put(key,Constant.工序.getGxByCode(gxCode));
});
}
public static void 加载设备信息(){
List<EmSbjbb> deviceList = getBean(EmSbjbbService.class).list(Wrappers.<EmSbjbb>lambdaQuery().like(EmSbjbb::getScbs, "1"));
设备列表.clear();
设备列表.addAll(deviceList);
}
public static void 加载工序设备对应关系(){
工序设备对应关系.clear();
Arrays.stream(Constant.工序.values()).forEach(gx->{
if (StrUtil.isNotEmpty(gx.getCode())){
工序设备对应关系.putIfAbsent(gx, 设备列表.stream().filter(d->d.getGx().equals(gx.getCode())).collect(Collectors.toList()));
}
});
}
public static void 输出排产结果到EXCEL(OutputStream stream){
}
public static void 输出排产结果到EXCEL(String fileName){
try(FileOutputStream fos=new FileOutputStream(fileName)) {
输出排产结果到EXCEL(fos);
}catch (Exception e){
e.printStackTrace();
}
}
private static <T> T getBean(Class<T> clazz) {
return SpringContextHolder.getBean(clazz);
}
private DataFactory(){}
}

26
src/main/java/com/dsic/gj_erp/pc/Manager.java
Unescape View File

@ -0,0 +1,26 @@
package com.dsic.gj_erp.pc;
import com.dsic.gj_erp.bean.jcsj.EmGcrl;
import com.dsic.gj_erp.bean.jcsj.EmSbjbb;
import com.dsic.gj_erp.pc.dto.资源;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
public class Manager {
public static String from;
public static String to;
public static 排产 排产;
public static final List<EmGcrl> 工厂日历=new ArrayList<>();
public static final Map<String,资源> 资源池= new ConcurrentHashMap<>();
//key=tlth+"_"+工序名称
public static final Map<String,资源> 套料图所占工序的资源= new ConcurrentHashMap<>();
public static final Map<String, Constant.工序> 套料图工序对应关系 = new ConcurrentHashMap<>();
public static final List<EmSbjbb> 设备列表= new ArrayList<>();
//实时加载
public static final Map<Constant.工序, List<EmSbjbb>> 工序设备对应关系 = new ConcurrentHashMap<>();
private Manager(){}
}

22
src/main/java/com/dsic/gj_erp/pc/dto/gx/工序01上料.java
Unescape View File

@ -0,0 +1,22 @@
package com.dsic.gj_erp.pc.dto.gx;
import com.dsic.gj_erp.pc.Constant;
import com.dsic.gj_erp.pc.dto.工序产能;
import com.dsic.gj_erp.pc.dto.设备;
import lombok.Getter;
import lombok.Setter;
import java.util.Map;
@Getter
@Setter
public class 工序01上料 extends 工序产能 {
public 工序01上料(Constant.工序 工序, Map<String, 设备> _设备) {
super(工序,_设备);
}
@Override
public void 占用资源(double 所需产能) {
super.占用资源(1.0);
}
}

22
src/main/java/com/dsic/gj_erp/pc/dto/gx/工序02抛丸.java
Unescape View File

@ -0,0 +1,22 @@
package com.dsic.gj_erp.pc.dto.gx;
import com.dsic.gj_erp.pc.Constant;
import com.dsic.gj_erp.pc.dto.工序产能;
import com.dsic.gj_erp.pc.dto.设备;
import lombok.Getter;
import lombok.Setter;
import java.util.Map;
@Getter
@Setter
public class 工序02抛丸 extends 工序产能 {
public 工序02抛丸(Constant.工序 工序, Map<String, 设备> _设备) {
super(工序,_设备);
}
@Override
public void 占用资源(double 所需产能) {
super.占用资源(1.0);
}
}

22
src/main/java/com/dsic/gj_erp/pc/dto/gx/工序03理料.java
Unescape View File

@ -0,0 +1,22 @@
package com.dsic.gj_erp.pc.dto.gx;
import com.dsic.gj_erp.pc.Constant;
import com.dsic.gj_erp.pc.dto.工序产能;
import com.dsic.gj_erp.pc.dto.设备;
import lombok.Getter;
import lombok.Setter;
import java.util.Map;
@Getter
@Setter
public class 工序03理料 extends 工序产能 {
public 工序03理料(Constant.工序 工序, Map<String, 设备> _设备) {
super(工序,_设备);
}
@Override
public void 占用资源(double 所需产能) {
super.占用资源(所需产能);
}
}

23
src/main/java/com/dsic/gj_erp/pc/dto/gx/工序04划线.java
Unescape View File

@ -0,0 +1,23 @@
package com.dsic.gj_erp.pc.dto.gx;
import com.dsic.gj_erp.bean.jcsj.EmSbjbb;
import com.dsic.gj_erp.pc.Constant;
import com.dsic.gj_erp.pc.dto.工序产能;
import com.dsic.gj_erp.pc.dto.设备;
import lombok.Getter;
import lombok.Setter;
import java.util.Map;
@Getter
@Setter
public class 工序04划线 extends 工序产能 {
public 工序04划线(Constant.工序 工序, Map<String, 设备> _设备) {
super(工序,_设备);
}
@Override
public void 占用资源(double 所需产能) {
super.占用资源(所需产能);
}
}

23
src/main/java/com/dsic/gj_erp/pc/dto/gx/工序05切割.java
Unescape View File

@ -0,0 +1,23 @@
package com.dsic.gj_erp.pc.dto.gx;
import com.dsic.gj_erp.bean.jcsj.EmSbjbb;
import com.dsic.gj_erp.pc.Constant;
import com.dsic.gj_erp.pc.dto.工序产能;
import com.dsic.gj_erp.pc.dto.设备;
import lombok.Getter;
import lombok.Setter;
import java.util.Map;
@Getter
@Setter
public class 工序05切割 extends 工序产能 {
public 工序05切割(Constant.工序 工序, Map<String, 设备> _设备) {
super(工序,_设备);
}
@Override
public void 占用资源(double 所需产能) {
super.占用资源(所需产能);
}
}

23
src/main/java/com/dsic/gj_erp/pc/dto/gx/工序07坡口.java
Unescape View File

@ -0,0 +1,23 @@
package com.dsic.gj_erp.pc.dto.gx;
import com.dsic.gj_erp.bean.jcsj.EmSbjbb;
import com.dsic.gj_erp.pc.Constant;
import com.dsic.gj_erp.pc.dto.工序产能;
import com.dsic.gj_erp.pc.dto.设备;
import lombok.Getter;
import lombok.Setter;
import java.util.Map;
@Getter
@Setter
public class 工序07坡口 extends 工序产能 {
public 工序07坡口(Constant.工序 工序, Map<String, 设备> _设备) {
super(工序,_设备);
}
@Override
public void 占用资源(double 所需产能) {
super.占用资源(所需产能);
}
}

23
src/main/java/com/dsic/gj_erp/pc/dto/gx/工序08曲面.java
Unescape View File

@ -0,0 +1,23 @@
package com.dsic.gj_erp.pc.dto.gx;
import com.dsic.gj_erp.bean.jcsj.EmSbjbb;
import com.dsic.gj_erp.pc.Constant;
import com.dsic.gj_erp.pc.dto.工序产能;
import com.dsic.gj_erp.pc.dto.设备;
import lombok.Getter;
import lombok.Setter;
import java.util.Map;
@Getter
@Setter
public class 工序08曲面 extends 工序产能 {
public 工序08曲面(Constant.工序 工序, Map<String, 设备> _设备) {
super(工序,_设备);
}
@Override
public void 占用资源(double 所需产能) {
super.占用资源(所需产能);
}
}

23
src/main/java/com/dsic/gj_erp/pc/dto/gx/工序09打磨.java
Unescape View File

@ -0,0 +1,23 @@
package com.dsic.gj_erp.pc.dto.gx;
import com.dsic.gj_erp.bean.jcsj.EmSbjbb;
import com.dsic.gj_erp.pc.Constant;
import com.dsic.gj_erp.pc.dto.工序产能;
import com.dsic.gj_erp.pc.dto.设备;
import lombok.Getter;
import lombok.Setter;
import java.util.Map;
@Getter
@Setter
public class 工序09打磨 extends 工序产能 {
public 工序09打磨(Constant.工序 工序, Map<String, 设备> _设备) {
super(工序,_设备);
}
@Override
public void 占用资源(double 所需产能) {
super.占用资源(所需产能);
}
}

23
src/main/java/com/dsic/gj_erp/pc/dto/gx/工序10型材.java
Unescape View File

@ -0,0 +1,23 @@
package com.dsic.gj_erp.pc.dto.gx;
import com.dsic.gj_erp.bean.jcsj.EmSbjbb;
import com.dsic.gj_erp.pc.Constant;
import com.dsic.gj_erp.pc.dto.工序产能;
import com.dsic.gj_erp.pc.dto.设备;
import lombok.Getter;
import lombok.Setter;
import java.util.Map;
@Getter
@Setter
public class 工序10型材 extends 工序产能 {
public 工序10型材(Constant.工序 工序, Map<String, 设备> _设备) {
super(工序,_设备);
}
@Override
public void 占用资源(double 所需产能) {
super.占用资源(所需产能);
}
}

22
src/main/java/com/dsic/gj_erp/pc/dto/gx/工序99未知.java
Unescape View File

@ -0,0 +1,22 @@
package com.dsic.gj_erp.pc.dto.gx;
import com.dsic.gj_erp.pc.Constant;
import com.dsic.gj_erp.pc.dto.工序产能;
import com.dsic.gj_erp.pc.dto.设备;
import lombok.Getter;
import lombok.Setter;
import java.util.Map;
@Getter
@Setter
public class 工序99未知 extends 工序产能 {
public 工序99未知(Constant.工序 工序, Map<String, 设备> _设备) {
super(工序,_设备);
}
@Override
public void 占用资源(double 所需产能) {
super.占用资源(所需产能);
}
}

8
src/main/java/com/dsic/gj_erp/pc/dto/sb/设备01上料.java
Unescape View File

@ -0,0 +1,8 @@
package com.dsic.gj_erp.pc.dto.sb;
import com.dsic.gj_erp.bean.jcsj.EmSbjbb;
import com.dsic.gj_erp.pc.dto.设备;
public class 设备01上料 extends 设备 {
}

7
src/main/java/com/dsic/gj_erp/pc/dto/sb/设备02抛丸.java
Unescape View File

@ -0,0 +1,7 @@
package com.dsic.gj_erp.pc.dto.sb;
import com.dsic.gj_erp.pc.dto.设备;
public class 设备02抛丸 extends 设备 {
}

83
src/main/java/com/dsic/gj_erp/pc/dto/工序产能.java
Unescape View File

@ -0,0 +1,83 @@
package com.dsic.gj_erp.pc.dto;
import com.dsic.gj_erp.pc.Constant;
import com.dsic.gj_erp.pc.service.工序排产处理接口;
import lombok.Getter;
import lombok.Setter;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;
@Getter
@Setter
public abstract class 工序产能 implements 工序排产处理接口 {
protected Constant.工序 工序;
protected double 白班时长;
protected double 二班时长;
protected double 产能;
protected double 占用=0.0;
protected int cd;
protected Constant.工序 CD所对应的工序;//需要根据对应工序进行计算cd
protected Map<String,设备> 设备;
protected List<String> 资源占用图纸表;
/**
* 默认构造
*/
public 工序产能(Constant.工序 工序, Map<String,设备> 设备){
this.工序=工序;
this.设备=设备;
this.白班时长=7;
this.产能=0;
设备.values().forEach(item->{
this.产能+=item.白班设备产能*this.白班时长+item.二班设备产能*this.二班时长;
});
this.产能=Constant.工序产能.get(工序);
this.cd=Constant.工序CD.get(工序);
资源占用图纸表=new ArrayList<>();
}
public 工序产能(Constant.工序 工序, Map<String,设备> 设备,double 白班时长,double 二班时长){
this.工序=工序;
this.设备=设备;
this.白班时长=白班时长;
this.二班时长=二班时长;
this.产能=0;
设备.values().forEach(item->{
this.产能+=item.白班设备产能*this.白班时长+item.二班设备产能*this.二班时长;
});
this.cd=Constant.工序CD.get(工序);
资源占用图纸表=new ArrayList<>();
}
public 设备 获取可占用设备(double 所需产能){
return this.设备.values().stream()
.filter(item -> this.判断设备是否可以占用(item.设备编号, 所需产能)).findFirst().orElse(null);
}
public boolean 判断设备是否可以占用(String 设备编号,double 所需产能){
设备 _设备 = 设备.get(设备编号);
return _设备.占用+所需产能<=_设备.产能;
}
public boolean 判断是否可以占用(double 所需产能){
return this.占用+所需产能<=this.产能;
}
public void 占用资源(double 所需产能){
this.占用=this.占用+所需产能;
}
public void 占用资源(String 占用源){
this.资源占用图纸表.add(占用源);
}
@Override
public void 占用设备(String 设备编号,String 占用源) {
设备 _设备 = 设备.get(设备编号);
_设备.资源占用图纸表.add(占用源);
}
}

23
src/main/java/com/dsic/gj_erp/pc/dto/排产结果.java
Unescape View File

@ -0,0 +1,23 @@
package com.dsic.gj_erp.pc.dto;
import com.dsic.gj_erp.bean.jhgk.DmSygdxq;
import lombok.Getter;
import lombok.Setter;
import java.util.List;
@Getter
@Setter
public class 排产结果 {
private String date;
private Double bbsc=7.0;//白班时长
private Double ybsc=0.0;//夜班时长
private String gx;//工序;上料,抛丸,切割...
private String gw;//工位;几跨什么
private Double gxde;//工序定额
private String sbbh;//设备编码
private String sbmc;//设备名称
private String degs;//设备定额
List<DmSygdxq> sygdxqList;//钢料需求
}

23
src/main/java/com/dsic/gj_erp/pc/dto/设备.java
Unescape View File

@ -0,0 +1,23 @@
package com.dsic.gj_erp.pc.dto;
import com.dsic.gj_erp.pc.Constant;
import lombok.Getter;
import lombok.Setter;
import java.util.List;
@Getter
@Setter
public abstract class 设备 {
protected String 设备编号;
protected String 设备名称;
protected double 白班设备产能;
protected double 二班设备产能;
protected double 产能;
protected double 占用=0.0;
protected List<String> 资源占用图纸表;
public 设备(Constant.设备产能 _设备产能){
}
}

33
src/main/java/com/dsic/gj_erp/pc/dto/资源.java
Unescape View File

@ -0,0 +1,33 @@
package com.dsic.gj_erp.pc.dto;
import com.dsic.gj_erp.pc.Constant;
import lombok.Getter;
import lombok.Setter;
import java.util.Map;
import java.util.Optional;
@Getter
@Setter
public class 资源 {
private String date;
private Map<Constant.工序,工序产能> 工序产能MAP;
public void 占用资源(Constant.工序 工序,String 套料图号,double 产能消耗){
工序产能 工序产能 = 工序产能MAP.get(工序);
Optional.of(工序产能).ifPresent(it->{
if (it.判断是否可以占用(产能消耗)){
it.占用资源(套料图号,产能消耗);
}
});
}
public static 资源 of(String date,Map<Constant.工序,工序产能> 工序产能MAP){
资源 资源 = new 资源();
资源.date=date;
资源.工序产能MAP=工序产能MAP;
return 资源;
}
private 资源(){}
}

20
src/main/java/com/dsic/gj_erp/pc/service/工序排产处理接口.java
Unescape View File

@ -0,0 +1,20 @@
package com.dsic.gj_erp.pc.service;
public interface 工序排产处理接口 {
default void 占用资源(String 设备编号,String 图纸,double 所需产能){
占用资源(图纸,所需产能);
占用设备(设备编号,图纸);
}
default void 占用资源(String 图纸,double 所需产能){
占用资源(所需产能);
占用资源(图纸);
}
void 占用设备(String 设备编号,String 占用源);
void 占用资源(double 所需产能);
void 占用资源(String 占用源);
}

58
src/main/java/com/dsic/gj_erp/pc/排产.java
Unescape View File

@ -0,0 +1,58 @@
package com.dsic.gj_erp.pc;
import com.dsic.gj_erp.pc.dto.排产结果;
import lombok.Getter;
import lombok.Setter;
import javax.validation.constraints.NotNull;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Semaphore;
@Getter
@Setter
public class 排产 {
private String from;
private String to;
private boolean complete;
List<排产结果> list;
private static Semaphore semaphore = new Semaphore(1);
public static void execute(@NotNull String from, @NotNull String to) {
排产 _排产=null;
try {
semaphore.acquire();
_排产 = 排产.of(from,to);
DataFactory.排产();
}catch (Exception e){
e.printStackTrace();
}finally {
if (_排产!=null){
_排产.complete = true;
}
semaphore.release();
}
}
private static 排产 of(@NotNull String from, @NotNull String to){
if (!from.equals(Manager.from)||!to.equals(Manager.to)){
排产 排产 = new 排产();
排产.from=from;
排产.to=to;
排产.complete=false;
排产.list=new ArrayList<>();
Manager.排产=排产;
Manager.from = from;
Manager.to = to;
DataFactory.加载工厂日历();
DataFactory.加载套料图工序对应关系();
DataFactory.加载设备信息();
DataFactory.加载工序设备对应关系();
DataFactory.创建产能资源池();
}
return Manager.排产;
}
private 排产(){}
}

2
src/main/java/com/dsic/gj_erp/service/jhgk/DmSygdxqService.java
Unescape View File

@ -17,4 +17,6 @@ import java.util.List;
public interface DmSygdxqService extends IService<DmSygdxq> {
void saveXzList(List<DmSygdxq> list, String username, String day);
void saveDzList(List<DmSygdxq> list, String username, String day);
List<DmSygdxq> getXqWithBom(String from, String to);
}

5
src/main/java/com/dsic/gj_erp/service/jhgk/impl/DmSygdxqServiceImpl.java
Unescape View File

@ -127,6 +127,11 @@ public class DmSygdxqServiceImpl extends ServiceImpl<DmSygdxqMapper, DmSygdxq> i
}
@Override
public List<DmSygdxq> getXqWithBom(String from, String to) {
return baseMapper.getXqWithBom(from,to);
}
//零件信息
public void correctSygdmx(String ch,String pl,String fd,String xqsj){
//根据：本次导入的三月需求期 提取BOM 生成三月需求零件信息

47
src/main/resources/mappers/jhgk/DmSygdxqMapper.xml
Unescape View File

@ -2,6 +2,53 @@
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.dsic.gj_erp.mapper.jhgk.DmSygdxqMapper">
<resultMap id="sqgdxqVo" type="dmSygdxq">
<id column="id" property="id" jdbcType="VARCHAR" />
<result column="dc_ch" property="dcCh" jdbcType="VARCHAR" />
<result column="dc_pl" property="dcPl" jdbcType="VARCHAR" />
<result column="dc_fd" property="dcFd" jdbcType="VARCHAR" />
<result column="zdh" property="zdh" jdbcType="VARCHAR" />
<result column="xzglxq" property="xzglxq" jdbcType="VARCHAR" />
<collection property="bomList" ofType="dmBom" javaType="java.util.ArrayList" columnPrefix="bom_" >
<id column="id" property="id" jdbcType="INTEGER" />
<result column="dcch" property="dcch" jdbcType="VARCHAR" />
<result column="pl" property="pl" jdbcType="VARCHAR" />
<result column="fd" property="fd" jdbcType="VARCHAR" />
<result column="kw" property="kw" jdbcType="VARCHAR" />
<result column="zl" property="zl" jdbcType="VARCHAR" />
<result column="tzbh" property="tzbh" jdbcType="VARCHAR" />
<result column="wpgg" property="wpgg" jdbcType="VARCHAR" />
<result column="wpcz" property="wpcz" jdbcType="VARCHAR" />
<result column="ljsl" property="ljsl" jdbcType="DOUBLE" />
<result column="fkgs" property="fkgs" jdbcType="VARCHAR" />
<result column="tlsl" property="tlsl" jdbcType="VARCHAR" />
</collection>
</resultMap>
<select id="getXqWithBom" resultMap="sqgdxqVo">
select
xq.id,
xq.dc_ch,
xq.dc_pl,
xq.dc_fd,
xq.xzglxq,
bom.id as bom_id,
bom.dcch as bom_dcch,
bom.pl as bom_pl,
bom.fd as bom_fd,
bom.kw as bom_kw,
bom.zl as bom_zl,
bom.tzbh as bom_tzbh,
bom.wpgg as bom_wpgg,
bom.wpcz as bom_wpcz,
bom.ljsl as bom_ljsl,
bom.fkgs as bom_fkgs,
bom.tlsl as bom_tlsl
from
dm_sygdxq xq left join dm_bom bom on bom.dcch = xq.DC_CH and bom.pl = xq.DC_PL and bom.fd = xq.DC_FD
where
xq.xzglxq between #{from} and #{to}
order by xq.xzglxq
</select>
</mapper>

2
src/main/resources/mappers/xiaochi/CutPlanMapper.xml
Unescape View File

@ -12,7 +12,7 @@
a.nest_cut_ho as 'nest_cut_ho'
FROM tbl_nest_mast a
WHERE
isnull(a.nest_ext_c02,'') != '' and a.nest_kakuyaku_date between #{st} and #{ed}
isnull(a.nest_ext_c02,'') != '' and a.nest_kakuyaku_date between #{st} and #{ed} and nest_cut_lengs>0
and not EXISTS(
select b.czbh as nest_ext_c02,b.kw as nest_ext_c03 ,b.pl as nest_ext_c04
from pgd_qgjh b

Write Preview
Loading…
Cancel
Save