采砂许可证 非作业时间报警 和 进入告警区报警

backend/inz.common/src/main/java/com/beecode/inz/common/util/DateTimeUtils.java

@@ -2,6 +2,7 @@ package com.beecode.inz.common.util;
 
 import java.text.SimpleDateFormat;
 import java.time.LocalDateTime;
+import java.time.ZoneId;
 import java.time.temporal.ChronoUnit;
 import java.util.Calendar;
 import java.util.Date;
@@ -164,7 +165,7 @@ public class DateTimeUtils {
         LocalDateTime localDateTime = LocalDateTime.of(cal.get(Calendar.YEAR), cal.get(Calendar.MONTH) + 1,
                 cal.get(Calendar.DAY_OF_MONTH), cal.get(Calendar.HOUR_OF_DAY), cal.get(Calendar.MINUTE),
                 cal.get(Calendar.SECOND));
-
+//        LocalDateTime of = LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
         return localDateTime;
     }
 

backend/inz.common/src/main/java/com/beecode/inz/common/util/PtInPolyUtil.java

+package com.beecode.inz.common.util;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 判断高德地图上一个点是否在一个多边形内
+ * copy by https://www.cnblogs.com/qq376324789/p/9047396.html
+ * @author scol
+ *
+ * 使用射线法判断是否在多边形范围内
+ *以点P为端点，向左方作射线L，由于多边形是有界的，所以射线L的左端一定在多边形外，
+ * 考虑沿着L从无穷远处开始自左向右移动，遇到和多边形的第一个交点的时候，进入到了多边形的内部，遇到第二个交点的时候，离开了多边形，
+ * ……所以很容易看出当L和多边形的交点数目C是奇数的时候，P在多边形内，是偶数的话P在多边形外。
+ * 算法 描述 https://blog.csdn.net/yaningli/article/details/84987678
+ *
+ *
+ */
+public class PtInPolyUtil {
+
+    public static boolean isPtInPoly(double aLon, double aLat, List<Map<String, Double>> ps) {
+        int iSum, iCount, iIndex;
+        double dLon1, dLon2, dLat1, dLat2, dLon;
+        if (ps.size() < 3) {
+            return false;
+        }        //114.331951,30.64091#114.341049,30.610185#114.331436,30.588058#114.312038,30.56393#114.293498,30.558609#114.267922,30.563784#114.231185,30.57945#114.212303,30.601616#114.235649,30.626878#114.280624,30.646818#
+
+        iSum = 0;
+        iCount = ps.size();
+
+        for (iIndex = 0; iIndex < iCount; iIndex++) {
+            if (iIndex == iCount - 1) {
+                dLon1 = ps.get(iIndex).get("x");
+                dLat1 =  ps.get(iIndex).get("y");
+                dLon2= ps.get(0).get("x");
+                dLat2= ps.get(0).get("y");
+            } else {
+                dLon1 = ps.get(iIndex).get("x");
+                dLat1 =  ps.get(iIndex).get("y");
+                dLon2 = ps.get(iIndex+1).get("x");
+                dLat2 = ps.get(iIndex+1).get("y");
+            }
+            // 以下语句判断A点是否在边的两端点的水平平行线之间，在则可能有交点，开始判断交点是否在左射线上
+            boolean b = ((aLat >= dLat1) && (aLat < dLat2)) || ((aLat >= dLat2) && (aLat < dLat1));
+            if (b) {
+                if (Math.abs(dLat1 - dLat2) > 0) {
+                    //得到 A点向左射线与边的交点的x坐标：
+                    dLon = dLon1 - ((dLon1 - dLon2) * (dLat1 - aLat)) / (dLat1 - dLat2);
+                    // 如果交点在A点左侧（说明是做射线与 边的交点），则射线与边的全部交点数加一：
+                    if (dLon < aLon) {
+                        iSum++;
+                    }
+                }
+            }
+        }
+        return (iSum % 2) != 0;
+    }
+}
\ No newline at end of file

backend/inz.common/src/main/java/com/beecode/inz/common/util/TransUtil.java

+package com.beecode.inz.common.util;
+
+/**
+ * @author scol
+ * copy by https://blog.csdn.net/m0_38004177/article/details/93974126
+ * GPS坐标转高德地图，误差很小
+ */
+public class TransUtil {
+    //椭球参数
+    static double pi = 3.14159265358979324;
+    static double a = 6378245.0;
+    static double ee = 0.00669342162296594323;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="wgLat">GPS维度</param>
+    /// <param name="wgLon">GPS经度</param>
+    /// <param name="latlng">转化后的坐标</param>
+    public static double[] transform(double wgLat, double wgLon) {
+        double[] latlng = new double[2];//转化后的坐标
+        if (outOfChina(wgLat, wgLon)) {
+            latlng[0] = wgLat;
+            latlng[1] = wgLon;
+            return latlng;
+        }
+        double dLat = transformLat(wgLon - 105.0, wgLat - 35.0);
+        double dLon = transformLon(wgLon - 105.0, wgLat - 35.0);
+        double radLat = wgLat / 180.0 * pi;
+        double magic = Math.sin(radLat);
+        magic = 1 - ee * magic * magic;
+        double sqrtMagic = Math.sqrt(magic);
+        dLat = (dLat * 180.0) / ((a * (1 - ee)) / (magic * sqrtMagic) * pi);
+        dLon = (dLon * 180.0) / (a / sqrtMagic * Math.cos(radLat) * pi);
+        latlng[0] = wgLat + dLat;
+        latlng[1] = wgLon + dLon;
+        return latlng;
+    }
+
+    private static Boolean outOfChina(double lat, double lon) {
+        if (lon < 72.004 || lon > 137.8347) {
+            return true;
+        }
+        if (lat < 0.8293 || lat > 55.8271) {
+            return true;
+        }
+        return false;
+    }
+
+    private static double transformLat(double x, double y) {
+        double ret = -100.0 + 2.0 * x + 3.0 * y + 0.2 * y * y + 0.1 * x * y + 0.2 * Math.sqrt(Math.abs(x));
+        ret += (20.0 * Math.sin(6.0 * x * pi) + 20.0 * Math.sin(2.0 * x * pi)) * 2.0 / 3.0;
+        ret += (20.0 * Math.sin(y * pi) + 40.0 * Math.sin(y / 3.0 * pi)) * 2.0 / 3.0;
+        ret += (160.0 * Math.sin(y / 12.0 * pi) + 320 * Math.sin(y * pi / 30.0)) * 2.0 / 3.0;
+        return ret;
+    }
+
+    private static double transformLon(double x, double y) {
+        double ret = 300.0 + x + 2.0 * y + 0.1 * x * x + 0.1 * x * y + 0.1 * Math.sqrt(Math.abs(x));
+        ret += (20.0 * Math.sin(6.0 * x * pi) + 20.0 * Math.sin(2.0 * x * pi)) * 2.0 / 3.0;
+        ret += (20.0 * Math.sin(x * pi) + 40.0 * Math.sin(x / 3.0 * pi)) * 2.0 / 3.0;
+        ret += (150.0 * Math.sin(x / 12.0 * pi) + 300.0 * Math.sin(x / 30.0 * pi)) * 2.0 / 3.0;
+        return ret;
+    }
+}

backend/xyst.dinas.biz/src/main/java/com/xyst/dinas/biz/constant/SandMiningAreaConstant.java

@@ -10,9 +10,15 @@ public interface SandMiningAreaConstant {
 	
 	/**************采砂预警**************/
 	
-	/** 预警计算器*/
+	/** 超采预警计算器*/
 	String warnCalculator = "com.xyst.dinas.production.processor.SandAreaDinasCountWarningCalculator";
 
+	/** 进入告警区计算器*/
+	String ENTER_WARNING_AREA_WARN_CALCULATOR = "com.xyst.dinas.production.processor.EnterWarningAreaWarnCalculator";
+
+	/** 非作业时间进入采砂区计算器*/
+	String TARGET_NO_OPERATING_HOURS_WARN_CALCULATOR = "com.xyst.dinas.production.processor.NoOperatingHoursWarnCalculator";
+
     /**
      * 超采预警类型
      */

backend/xyst.dinas.biz/src/main/java/com/xyst/dinas/biz/dao/SandMiningAreaDao.java

@@ -13,6 +13,8 @@ public interface SandMiningAreaDao extends BaseDao {
 
     Page<KObject> listSandMiningAreaInfoPaging(Page<KObject> page, Integer sandMiningAreaStatus);
 
+    List<KObject> listByRegionalCompanyIdsAndSandMiningAreaTypes(List<UUID> regionalCompanyIds, Integer... sandMiningAreaTypes);
+
     UUID create(KObject kObject);
 
     int selectCountByName(String sandMiningAreaName);

backend/xyst.dinas.biz/src/main/java/com/xyst/dinas/biz/internal/dao/SandMiningAreaDaoImpl.java

@@ -20,9 +20,8 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.orm.hibernate5.HibernateTemplate;
 import org.springframework.util.CollectionUtils;
 
-import java.util.Date;
-import java.util.List;
-import java.util.UUID;
+import java.util.*;
+import java.util.stream.Collectors;
 
 public class SandMiningAreaDaoImpl extends AbstractBaseDao implements SandMiningAreaDao, SandMiningAreaConstant {
 
@@ -32,10 +31,11 @@ public class SandMiningAreaDaoImpl extends AbstractBaseDao implements SandMining
 
     @Autowired
     private DinasTypeDao dinasTypeDao;
-	@Override
-	public KObject load(UUID id) {
-		return (KObject) template.load(ENTITY, id);
-	}
+
+    @Override
+    public KObject load(UUID id) {
+        return (KObject) template.load(ENTITY, id);
+    }
 
     @Override
     public Page<KObject> listSandMiningAreaInfoPaging(Page<KObject> page, Integer sandMiningAreaStatus) {
@@ -43,7 +43,7 @@ public class SandMiningAreaDaoImpl extends AbstractBaseDao implements SandMining
         DetachedCriteria detachedCriteria = DetachedCriteria.forEntityName(bean.getName());
 //        detachedCriteria.add(Restrictions.eq("department.id", departmentId));
         detachedCriteria.add(Restrictions.eq("del", false));
-        if(null!=sandMiningAreaStatus){
+        if (null != sandMiningAreaStatus) {
             detachedCriteria.add(Restrictions.eq("status", sandMiningAreaStatus));
         }
         dinasTypeDao.addRegionalCompanyFilter(detachedCriteria);
@@ -51,7 +51,7 @@ public class SandMiningAreaDaoImpl extends AbstractBaseDao implements SandMining
         detachedCriteria.addOrder(Order.desc("sortOrder"));
         int offset = page.getPageSize() * (page.getPageNo() - 1);
         page.setTotal(template.findByCriteria(detachedCriteria).size());
-        List<KObject> list = (List<KObject>) template.findByCriteria(detachedCriteria,offset,page.getPageSize());
+        List<KObject> list = (List<KObject>) template.findByCriteria(detachedCriteria, offset, page.getPageSize());
         page.setDatas(list);
         return page;
     }
@@ -63,11 +63,11 @@ public class SandMiningAreaDaoImpl extends AbstractBaseDao implements SandMining
         KClass bean = Amino.getStaticMetadataContext().getBean(SandMiningAreaConstant.ENTITY, KClass.class);
         DetachedCriteria detachedCriteria = DetachedCriteria.forEntityName(bean.getName());
 
-                dinasTypeDao.addRegionalCompanyFilter(detachedCriteria);
+        dinasTypeDao.addRegionalCompanyFilter(detachedCriteria);
 
         detachedCriteria.add(Restrictions.eq("del", false));
         detachedCriteria.add(Restrictions.eq("sandMiningAreaName", name));
-        if(id!=null){
+        if (id != null) {
             detachedCriteria.add(Restrictions.ne("id", id));
         }
 
@@ -77,13 +77,13 @@ public class SandMiningAreaDaoImpl extends AbstractBaseDao implements SandMining
     @Override
     public void modify(KObject kobject) {
         KObject id = load(kobject.getUuid("id"));
-        kobject.set(BaseConstants.CREATOR,id.get(BaseConstants.CREATOR));
-        kobject.set(BaseConstants.CREATE_TIME,id.getDate(BaseConstants.CREATE_TIME));
+        kobject.set(BaseConstants.CREATOR, id.get(BaseConstants.CREATOR));
+        kobject.set(BaseConstants.CREATE_TIME, id.getDate(BaseConstants.CREATE_TIME));
         KObject staff = AminoContextHolder.getContext().getStaff();
         kobject.set("regionalCompany", dinasTypeDao.getCurrentLoginRegionalCompany());
-        kobject.set(BaseConstants.MODIFY_TIME,new Date());
-        kobject.set(BaseConstants.DEL,false);
-        kobject.set(BaseConstants.MODIFIER,staff);
+        kobject.set(BaseConstants.MODIFY_TIME, new Date());
+        kobject.set(BaseConstants.DEL, false);
+        kobject.set(BaseConstants.MODIFIER, staff);
         template.merge(kobject);
         //生成采区预警设置信息
     }
@@ -94,35 +94,47 @@ public class SandMiningAreaDaoImpl extends AbstractBaseDao implements SandMining
         detachedCriteria.add(Restrictions.eq("del", false));
         detachedCriteria.add(Restrictions.eq("status", 2));
         detachedCriteria.setProjection(Projections.projectionList()
-                .add(Projections.alias(Projections.sum("sandMiningQuantity"),"sandMiningQuantity"))
-                .add(Projections.alias(Projections.groupProperty("regionalCompany.id"),"regionalCompany")));
+                .add(Projections.alias(Projections.sum("sandMiningQuantity"), "sandMiningQuantity"))
+                .add(Projections.alias(Projections.groupProperty("regionalCompany.id"), "regionalCompany")));
         detachedCriteria.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
         return template.findByCriteria(detachedCriteria);
     }
 
     @Override
     public List<KObject> listByRegionalCompanyIds(List<UUID> regionalCompanyIds, Boolean isInclude) {
+
+        Integer[] status1 = new Integer[]{
+                SandMiningAreaTypeEnum.ABANDONED_MINE_SAND.getValue(),
+                SandMiningAreaTypeEnum.CAN_MINE_SAND.getValue(),
+                SandMiningAreaTypeEnum.PRESERVE.getValue()};
+        if (isInclude) {
+            status1 = (Integer[]) Arrays.stream(SandMiningAreaTypeEnum.values()).map(SandMiningAreaTypeEnum::getValue).toArray();
+        }
+        return listByRegionalCompanyIdsAndSandMiningAreaTypes(regionalCompanyIds, status1);
+    }
+    @Override
+    public List<KObject> listByRegionalCompanyIdsAndSandMiningAreaTypes(List<UUID> regionalCompanyIds, Integer... sandMiningAreaTypes) {
+        List<Integer> integers = Arrays.asList(sandMiningAreaTypes);
         DetachedCriteria detachedCriteria = getDetachedCriteria(regionalCompanyIds);
         detachedCriteria.add(Restrictions.eq("del", false));
         detachedCriteria.add(Restrictions.eq("status", 2));
-        if(!CollectionUtils.isEmpty(regionalCompanyIds)){
+        if (!CollectionUtils.isEmpty(regionalCompanyIds)) {
             detachedCriteria.add(Restrictions.in("regionalCompany.id", regionalCompanyIds));
         }
-        if(!isInclude){
+        if (!CollectionUtils.isEmpty(integers)) {
             detachedCriteria.add(Restrictions.in("sandMiningAreaType",
-                    SandMiningAreaTypeEnum.ABANDONED_MINE_SAND.getValue(),
-                    SandMiningAreaTypeEnum.CAN_MINE_SAND.getValue(),
-                    SandMiningAreaTypeEnum.PRESERVE.getValue()));
+                    integers));
         }
 
         detachedCriteria.addOrder(Order.desc("sortOrder"));
-        return (List<KObject>)template.findByCriteria(detachedCriteria);
+        return (List<KObject>) template.findByCriteria(detachedCriteria);
     }
 
+
     private DetachedCriteria getDetachedCriteria(List<UUID> regionalCompanyIds) {
         KClass bean = Amino.getStaticMetadataContext().getBean(SandMiningAreaConstant.ENTITY, KClass.class);
         DetachedCriteria detachedCriteria = DetachedCriteria.forEntityName(bean.getName());
-        if(!CollectionUtils.isEmpty(regionalCompanyIds)){
+        if (!CollectionUtils.isEmpty(regionalCompanyIds)) {
             detachedCriteria.add(Restrictions.in("regionalCompany.id", regionalCompanyIds));
         }
         return detachedCriteria;
@@ -133,13 +145,13 @@ public class SandMiningAreaDaoImpl extends AbstractBaseDao implements SandMining
     public UUID create(KObject kObject) {
         KObject staff = AminoContextHolder.getContext().getStaff();
 
-        if(null==kObject.getUuid("id")){
-            kObject.set("id",UUID.randomUUID());
+        if (null == kObject.getUuid("id")) {
+            kObject.set("id", UUID.randomUUID());
         }
         kObject.set("regionalCompany", dinasTypeDao.getCurrentLoginRegionalCompany());
-        kObject.set(BaseConstants.CREATOR,staff);
+        kObject.set(BaseConstants.CREATOR, staff);
         kObject.set(BaseConstants.CREATE_TIME, new Date());
-        kObject.set(BaseConstants.DEL,false);
+        kObject.set(BaseConstants.DEL, false);
         UUID save = (UUID) template.save(kObject);
         return save;
     }
@@ -154,9 +166,9 @@ public class SandMiningAreaDaoImpl extends AbstractBaseDao implements SandMining
     public void deleteById(UUID id) {
         KObject staff = AminoContextHolder.getContext().getStaff();
         KObject kobject = (KObject) template.load(ENTITY, id);
-        kobject.set(BaseConstants.MODIFY_TIME,new Date());
-        kobject.set(BaseConstants.MODIFIER,staff);
-        kobject.set(BaseConstants.DEL,true);
+        kobject.set(BaseConstants.MODIFY_TIME, new Date());
+        kobject.set(BaseConstants.MODIFIER, staff);
+        kobject.set(BaseConstants.DEL, true);
         template.update(kobject);
     }
 

backend/xyst.dinas.production/src/main/java/com/xyst/dinas/production/config/SandMiningConfiguration.java

 package com.xyst.dinas.production.config;
 
+import com.xyst.dinas.production.processor.EnterWarningAreaWarnCalculator;
+import com.xyst.dinas.production.processor.NoOperatingHoursWarnCalculator;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.context.annotation.Bean;
@@ -88,4 +90,15 @@ public class SandMiningConfiguration {
     	return new SandAreaDinasCountWarningCalculator();
     }
 
+    @Bean("com.xyst.dinas.production.processor.EnterWarningAreaWarnCalculator")
+    public EnterWarningAreaWarnCalculator enterWarningAreaWarnCalculator() {
+    	return new EnterWarningAreaWarnCalculator();
+    }
+
+    @Bean("com.xyst.dinas.production.processor.NoOperatingHoursWarnCalculator")
+    public NoOperatingHoursWarnCalculator noOperatingHoursWarnCalculator() {
+    	return new NoOperatingHoursWarnCalculator();
+    }
+
+
 }

backend/xyst.dinas.production/src/main/java/com/xyst/dinas/production/constant/SandMiningConstant.java

@@ -11,4 +11,13 @@ public interface SandMiningConstant {
 	 */
 	String STATION_DETAIL_ENTITY = "com.xyst.dinas.production.datamodel.SandMiningAssociatedSandMiningStationDetail";
 
+
+
+
+    /** 进入告警区计算器*/
+    String ENTER_WARNING_AREA_WARN_CALCULATOR = "com.xyst.dinas.production.processor.EnterWarningAreaWarnCalculator";
+
+    /** 非作业时间进入采砂区计算器*/
+    String TARGET_NO_OPERATING_HOURS_WARN_CALCULATOR = "com.xyst.dinas.production.processor.TargetNoOperatingHoursWarnCalculator";
+
 }

backend/xyst.dinas.production/src/main/java/com/xyst/dinas/production/internal/service/SandMiningServiceImpl.java

 package com.xyst.dinas.production.internal.service;
 
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.UUID;
-
-import org.apache.commons.collections.CollectionUtils;
-import org.json.JSONObject;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.transaction.annotation.Transactional;
-
 import com.beecode.bap.attachment.common.Page;
 import com.beecode.bcp.type.KObject;
+import com.beecode.inz.common.BaseConstants;
+import com.beecode.inz.common.util.GpsOOUtil;
+import com.beecode.inz.common.util.PtInPolyUtil;
+import com.beecode.inz.common.util.TransUtil;
 import com.xyst.dinas.biz.constant.SandMiningAreaConstant;
+import com.xyst.dinas.biz.dao.SandMiningAreaDao;
+import com.xyst.dinas.biz.enumeration.SandMiningAreaTypeEnum;
+import com.xyst.dinas.biz.warn.BaseBusinessWarn;
 import com.xyst.dinas.biz.warn.WarnSetting;
 import com.xyst.dinas.biz.warn.WarnSettingEntity;
+import com.xyst.dinas.biz.warn.WarnTargetTypeEnum;
 import com.xyst.dinas.biz.warn.service.WarningService;
 import com.xyst.dinas.production.dao.SandMiningDao;
+import com.xyst.dinas.production.processor.EnterWarningAreaWarnCalculate;
+import com.xyst.dinas.production.processor.NoOperatingHoursWarnCalculate;
 import com.xyst.dinas.production.service.SandMiningService;
+import net.sf.json.JSONArray;
+import org.apache.commons.collections.CollectionUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.json.JSONObject;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.time.ZoneId;
+import java.util.*;
 
 @Transactional(rollbackFor = Exception.class)
 public class SandMiningServiceImpl implements SandMiningService {
 
-	@Autowired
-	private SandMiningDao sandMiningDao;
+    @Autowired
+    private SandMiningDao sandMiningDao;
+    @Autowired
+    private SandMiningAreaDao sandMiningAreaDao;
 
-	@Autowired
-	private WarningService warningSettingService;
+    @Autowired
+    private WarningService warningSettingService;
 
     @Override
     public Page<KObject> queryByPaging(Page<KObject> page, Integer sandMiningStatus) throws Exception {
-        if(page.getPageNo()==0||page.getPageSize()==0) {
+        if (page.getPageNo() == 0 || page.getPageSize() == 0) {
             throw new Exception("pageSize or offset is null");
         }
-        return sandMiningDao.listSandMiningInfoPaging(page,sandMiningStatus);
+        return sandMiningDao.listSandMiningInfoPaging(page, sandMiningStatus);
     }
 
     @Override
@@ -46,7 +59,7 @@ public class SandMiningServiceImpl implements SandMiningService {
         warnSetting.setTarget(SandMiningAreaConstant.SAND_SHIP_WARN_TARGET_ENTER_WARNING_AREA);
         warnSetting.setOpen(true);
         warnSetting.setMemo(getSandShipInfo(kObject));
-        warnSetting.setWarnCalculator(SandMiningAreaConstant.warnCalculator);
+        warnSetting.setWarnCalculator(SandMiningAreaConstant.ENTER_WARNING_AREA_WARN_CALCULATOR);
         warningSettingService.insertWarnSetting(warnSetting);
 
         WarnSettingEntity warnSetting1 = new WarnSettingEntity();
@@ -54,8 +67,9 @@ public class SandMiningServiceImpl implements SandMiningService {
         warnSetting1.setBillId(uuid);
         warnSetting1.setTarget(SandMiningAreaConstant.SAND_SHIP_WARN_TARGET_NO_OPERATING_HOURS);
         warnSetting1.setOpen(true);
+        warnSetting1.setTargetType(WarnTargetTypeEnum.TIME_TYPE.getName());
         warnSetting1.setMemo(getSandShipInfo(kObject));
-        warnSetting1.setWarnCalculator(SandMiningAreaConstant.warnCalculator);
+        warnSetting1.setWarnCalculator(SandMiningAreaConstant.TARGET_NO_OPERATING_HOURS_WARN_CALCULATOR);
         warningSettingService.insertWarnSetting(warnSetting1);
 
         return uuid;
@@ -74,8 +88,8 @@ public class SandMiningServiceImpl implements SandMiningService {
 
     @Override
     public KObject getByCodeNum(String name, UUID id) {
-        List<KObject> kObjects = sandMiningDao.getByCodeNum(name,id);
-        if(CollectionUtils.isEmpty(kObjects)){
+        List<KObject> kObjects = sandMiningDao.getByCodeNum(name, id);
+        if (CollectionUtils.isEmpty(kObjects)) {
             return null;
         }
         return kObjects.get(0);
@@ -94,12 +108,12 @@ public class SandMiningServiceImpl implements SandMiningService {
 
         //进入告警区的
         WarnSetting warnSetting = warningSettingService.getWarnSetting(SandMiningAreaConstant.SAND_SHIP_WARN_BILL_TYPE, id, SandMiningAreaConstant.SAND_SHIP_WARN_TARGET_ENTER_WARNING_AREA);
-        if(null!=warnSetting){
+        if (null != warnSetting) {
             warningSettingService.deleteWarnSetting(warnSetting.getSettingId());
         }
         //非作业时间采砂的
         WarnSetting warnSetting1 = warningSettingService.getWarnSetting(SandMiningAreaConstant.SAND_SHIP_WARN_BILL_TYPE, id, SandMiningAreaConstant.SAND_SHIP_WARN_TARGET_NO_OPERATING_HOURS);
-        if(null!=warnSetting1){
+        if (null != warnSetting1) {
             warningSettingService.deleteWarnSetting(warnSetting1.getSettingId());
         }
     }
@@ -113,26 +127,192 @@ public class SandMiningServiceImpl implements SandMiningService {
     public void updateIsEnterWarningArea() {
         //获取所有采砂许可证的船只
         HashMap<String, Object> stringObjectHashMap = new HashMap<String, Object>();
-        stringObjectHashMap.put("status",1);
-        stringObjectHashMap.put("del",false);
+        stringObjectHashMap.put("status", 1);
+        stringObjectHashMap.put("del", false);
         List<KObject> kObjects = sandMiningDao.listByAttributes(stringObjectHashMap);
-        //判断船只是否在工作时间内
+        //判断船只是否跑到别的采区
+        HashMap<UUID, List<Map<String, Object>>> regionalCompanySandMining = new HashMap<>(12);
         for (KObject kObject : kObjects) {
-            kObject.getDate("");
+            //获取所在区域公司的采区和坐标点
+            UUID regionalCompany = kObject.get("regionalCompany").getUuid(BaseConstants.ID);
+            String permitCode = kObject.getString("permitCode");
+            setRegionalCompanySandMing(regionalCompanySandMining, regionalCompany);
             KObject ship = kObject.get("ship");
+            UUID uuid = kObject.getUuid(BaseConstants.ID);
+
+            if (null != ship && !ship.isNull()) {
+                EnterWarningAreaWarnCalculate enterWarningAreaWarnCalculate;
+                Map<String, Object> warnIngSandMiningArea = null;
+                try {
+                    List<Map<String, Object>> list = regionalCompanySandMining.get(regionalCompany);
+                    warnIngSandMiningArea = getInSandMiningArea(list, kObject.get("sandMiningArea"), ship);
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+                if (warnIngSandMiningArea != null) {
+                    enterWarningAreaWarnCalculate = new EnterWarningAreaWarnCalculate(true, warnIngSandMiningArea.get("name").toString(), permitCode, ship.getString("shipName"));
+                } else {
+                    enterWarningAreaWarnCalculate = new EnterWarningAreaWarnCalculate(false, null, permitCode, null);
+                }
+                BaseBusinessWarn businessWarn = warningSettingService.createWarn(SandMiningAreaConstant.SAND_SHIP_WARN_BILL_TYPE, uuid, SandMiningAreaConstant.SAND_SHIP_WARN_TARGET_ENTER_WARNING_AREA);
+                businessWarn.setWarningCalculate(enterWarningAreaWarnCalculate);
+                businessWarn.warn();
+            }
         }
 
     }
 
     @Override
+    public Map<String, Object> getInSandMiningArea(List<Map<String, Object>> list, KObject sandMiningArea, KObject shipInfo) throws Exception {
+        //获取当前船只的GPS设备
+        String account = shipInfo.getString("account");
+        String password = shipInfo.getString("accountPassword");
+        String deviceNumber = shipInfo.getString("deviceNumber");
+        if (StringUtils.isEmpty(account) || StringUtils.isEmpty(password) || StringUtils.isEmpty(deviceNumber)) {
+            //没有安装设备是否预警??
+            return null;
+        }
+        //获取当前船只的位置
+        List<Map<String, Object>> tracking = GpsOOUtil.tracking(account, password, deviceNumber, null);
+        if (CollectionUtils.isEmpty(tracking)) {
+            return null;
+        }
+        Map<String, Object> stringObjectMap1 = tracking.get(0);
+        double lng = (double) stringObjectMap1.get("lng");
+        double lat = (double) stringObjectMap1.get("lat");
+
+        //转换经纬度
+        double[] transform = TransUtil.transform(lat, lng);
+        lng = transform[1];
+        lat = transform[0];
+        for (Map<String, Object> stringObjectMap : list) {
+            //获取船只所在的区域公司的采区,排除当前船只应该所在的采区
+            if (sandMiningArea != null&&stringObjectMap.get("id").toString().equals(sandMiningArea.getUuid(BaseConstants.ID).toString())) {
+                    continue;
+            }
+            //判断船只所在的地点是否在[禁采区,可采区]范围内
+            List<Map<String, Double>> coordinates = (List<Map<String, Double>>) stringObjectMap.get("coordinate");
+            boolean ptInPoly = PtInPolyUtil.isPtInPoly(lng, lat, coordinates);
+            if (ptInPoly) {
+                //在范围内报警,不管有几个采区,只要有一个触发则报警
+                return stringObjectMap;
+            }
+        }
+        return null;
+    }
+
+
+    @Override
+    public void setRegionalCompanySandMing(HashMap<UUID, List<Map<String, Object>>> regionalCompanySandMining, UUID regionalCompany) {
+        List<Map<String, Object>> sandMiningList;
+        if (!regionalCompanySandMining.containsKey(regionalCompany)) {
+            sandMiningList = new ArrayList<>(12);
+            regionalCompanySandMining.put(regionalCompany, sandMiningList);
+            ArrayList<UUID> uuids = new ArrayList<>();
+            uuids.add(regionalCompany);
+            List<KObject> sandMiningAreas = sandMiningAreaDao.listByRegionalCompanyIdsAndSandMiningAreaTypes(uuids, SandMiningAreaTypeEnum.CAN_MINE_SAND.getValue(), SandMiningAreaTypeEnum.NO_MINE_SAND.getValue());
+            for (KObject sandMiningArea : sandMiningAreas) {
+                HashMap<String, Object> stringObjectHashMap = setAreaMap(sandMiningArea);
+                if (stringObjectHashMap != null) {
+                    sandMiningList.add(stringObjectHashMap);
+                }
+            }
+        }
+    }
+
+    @Override
+    public HashMap<String, Object> setAreaMap(KObject sandMiningArea) {
+        HashMap<String, Object> sandMiningMap;
+        List<Map<String, Double>> coordinate;
+        String stationCoordinate = sandMiningArea.getString("stationCoordinate");
+        sandMiningMap = new HashMap<>();
+        if (StringUtils.isEmpty(stationCoordinate)) {
+            return null;
+        }
+
+        sandMiningMap.put("name", sandMiningArea.getString("sandMiningAreaName"));
+        sandMiningMap.put("id", sandMiningArea.getUuid(BaseConstants.ID));
+//                    [[112.146463,32.039989],[112.147751,32.036205],[112.154017,32.037951],[112.148352,32.043263]]
+        JSONArray jsonArray = JSONArray.fromObject(stationCoordinate);
+        coordinate = new ArrayList<>();
+        for (int i = 0; i < jsonArray.size(); i++) {
+            JSONArray jsonArray1 = jsonArray.getJSONArray(i);
+            HashMap<String, Double> stringDoubleHashMap = new HashMap<>();
+            stringDoubleHashMap.put("x", jsonArray1.getDouble(0));
+            stringDoubleHashMap.put("y", jsonArray1.getDouble(1));
+            coordinate.add(stringDoubleHashMap);
+
+        }
+        sandMiningMap.put("coordinate", coordinate);
+        return sandMiningMap;
+    }
+
+    @Override
     public List<Map<String, Object>> queryByShip(List<Map<String, Object>> shipsTracking) {
         for (Map<String, Object> stringObjectMap : shipsTracking) {
             Object shipInfoId = stringObjectMap.get("shipInfoId");
             List<KObject> sandMin = sandMiningDao.queryByShipId(UUID.fromString(shipInfoId.toString()));
-            stringObjectMap.put("sandMiningInfo",sandMin);
+            stringObjectMap.put("sandMiningInfo", sandMin);
         }
         return shipsTracking;
     }
 
+    @Override
+    public void updateNoOperatingHoursWarn() {
+        //获取所有采砂许可证的船只
+        HashMap<String, Object> stringObjectHashMap = new HashMap<String, Object>();
+        stringObjectHashMap.put("status", 1);
+        stringObjectHashMap.put("del", false);
+        List<KObject> kObjects = sandMiningDao.listByAttributes(stringObjectHashMap);
+        //判断船只是否在工作时间内进入非自己的采区
+
+        for (KObject kObject : kObjects) {
+            //判断是否在可采时间内
+            //当前时间
+            Date workStartTime = kObject.getDate("workStartTime");
+            Date workEndTime = kObject.getDate("workEndTime");
+            LocalTime now = LocalTime.now(ZoneId.systemDefault());
+            LocalTime startTime = LocalDateTime.ofInstant(workStartTime.toInstant(), ZoneId.systemDefault()).toLocalTime();
+            LocalTime endTime = LocalDateTime.ofInstant(workEndTime.toInstant(), ZoneId.systemDefault()).toLocalTime();
+
+            boolean before = now.isBefore(startTime);
+            boolean after = now.isAfter(endTime);
+            //如果在可采时间外,则不应该在采区里边呆着
+            if (!before && !after) {
+                continue;
+            }
+            KObject sandMiningArea = kObject.get("sandMiningArea");
+            Map<String, Object> sandMiningAreaMap = setAreaMap(sandMiningArea);
+            if (sandMiningAreaMap == null) {
+                continue;
+            }
+            ArrayList<Map<String, Object>> hashMaps = new ArrayList<>();
+            hashMaps.add(sandMiningAreaMap);
+
+            //获取所在区域公司的采区和坐标点
+            String permitCode = kObject.getString("permitCode");
+            KObject ship = kObject.get("ship");
+            UUID uuid = kObject.getUuid(BaseConstants.ID);
+
+            if (null != ship && !ship.isNull()) {
+                NoOperatingHoursWarnCalculate operatingHoursWarnCalculate;
+                Map<String, Object> warnIngSandMiningArea = null;
+                try {
+                    warnIngSandMiningArea = getInSandMiningArea(hashMaps, null, ship);
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+                if (warnIngSandMiningArea != null) {
+                    operatingHoursWarnCalculate = new NoOperatingHoursWarnCalculate(true, warnIngSandMiningArea.get("name").toString(), permitCode, ship.getString("shipName"), now);
+                } else {
+                    operatingHoursWarnCalculate = new NoOperatingHoursWarnCalculate(false, null, permitCode, null, now);
+                }
+                BaseBusinessWarn businessWarn = warningSettingService.createWarn(SandMiningAreaConstant.SAND_SHIP_WARN_BILL_TYPE, uuid, SandMiningAreaConstant.SAND_SHIP_WARN_TARGET_NO_OPERATING_HOURS);
+                businessWarn.setWarningCalculate(operatingHoursWarnCalculate);
+                businessWarn.warn();
+            }
+        }
+    }
+
 
 }

backend/xyst.dinas.production/src/main/java/com/xyst/dinas/production/processor/EnterWarningAreaWarnCalculate.java

+package com.xyst.dinas.production.processor;
+
+import com.xyst.dinas.biz.warn.IWarningCalculator;
+import com.xyst.dinas.biz.warn.WarnSetting;
+
+/**
+ * 进入告警区
+ *
+ * @author 
+ * @date 2021年4月1日
+ */
+public class EnterWarningAreaWarnCalculate implements IWarningCalculator{
+
+
+	private String warnMessage;
+
+	private Boolean isWarning;
+
+	private String sandMingAreaName;
+
+	private String sandMiningCode;
+	private String shipName;
+
+	public EnterWarningAreaWarnCalculate(boolean isWarning, String sandAreaName,String code,String shipName) {
+		this.isWarning = isWarning;
+		this.sandMingAreaName = sandAreaName;
+		this.sandMiningCode = code;
+		this.shipName = shipName;
+	}
+
+
+	@Override
+	public boolean isWarning(WarnSetting warnSetting) {
+
+		//业务数据与设置的阀值做比较,计算是否报警
+		if (isWarning) {
+			warnMessage = "采砂许可证["+sandMiningCode+"]下船只["+shipName+"] 进入["+sandMingAreaName+
+                    "],此采区非采砂许可证上采区,发生报警";
+			return true;
+		}
+		return false;
+	}
+
+
+    public String getWarnMessage() {
+        return warnMessage;
+    }
+
+    public void setWarnMessage(String warnMessage) {
+        this.warnMessage = warnMessage;
+    }
+
+    public String getSandMingAreaName() {
+        return sandMingAreaName;
+    }
+
+    public void setSandMingAreaName(String sandMingAreaName) {
+        this.sandMingAreaName = sandMingAreaName;
+    }
+
+    public String getSandMiningCode() {
+        return sandMiningCode;
+    }
+
+    public void setSandMiningCode(String sandMiningCode) {
+        this.sandMiningCode = sandMiningCode;
+    }
+
+    public String getShipName() {
+        return shipName;
+    }
+
+    public void setShipName(String shipName) {
+        this.shipName = shipName;
+    }
+
+    @Override
+	public String warnMessage() {
+		return warnMessage;
+	}
+
+
+	@Override
+	public String getActualValue() {
+		return isWarning?sandMingAreaName:"";
+	}
+
+
+}

backend/xyst.dinas.production/src/main/java/com/xyst/dinas/production/processor/EnterWarningAreaWarnCalculator.java

+package com.xyst.dinas.production.processor;
+
+import com.beecode.bcp.type.KObject;
+import com.beecode.inz.common.BaseConstants;
+import com.xyst.dinas.biz.warn.IWarningCalculator;
+import com.xyst.dinas.biz.warn.WarnSetting;
+import com.xyst.dinas.production.service.SandMiningService;
+import org.springframework.beans.factory.annotation.Autowired;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+/**
+ * 进入告警区
+ *
+ * @author 
+ * @date 2021年4月1日
+ */
+public class EnterWarningAreaWarnCalculator implements IWarningCalculator{
+
+	private String warnMessage;
+
+
+    @Autowired
+    private SandMiningService sandMiningService;
+
+	@Override
+	public boolean isWarning(WarnSetting warnSetting) {
+
+        HashMap<UUID, List<Map<String, Object>>> uuidListHashMap = new HashMap<>();
+        KObject sandMining = sandMiningService.getById(warnSetting.getBillId());
+        KObject regionalCompany = sandMining.get("regionalCompany");
+        UUID regionalCompanyId = regionalCompany.getUuid(BaseConstants.ID);
+        sandMiningService.setRegionalCompanySandMing(uuidListHashMap,regionalCompanyId);
+        KObject ship = sandMining.get("ship");
+        try {
+            Map<String, Object> warnIngSandMiningArea = sandMiningService.getInSandMiningArea(uuidListHashMap.get(regionalCompanyId), sandMining.get("sandMiningArea"), ship);
+            if(warnIngSandMiningArea!=null){
+
+                warnMessage = "采砂许可证["+sandMining.getString("permitCode")+
+                        "]下船只["+ship.getString("shipName")+"] 进入["
+                        +warnIngSandMiningArea.get("name")+
+                        "],此采区非采砂许可证上采区,发生报警";
+                return true;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+		return false;
+	}
+
+	@Override
+	public String warnMessage() {
+		return warnMessage;
+	}
+
+
+	@Override
+	public String getActualValue() {
+		return "";
+	}
+
+
+}

backend/xyst.dinas.production/src/main/java/com/xyst/dinas/production/processor/NoOperatingHoursWarnCalculate.java

+package com.xyst.dinas.production.processor;
+
+import com.xyst.dinas.biz.warn.IWarningCalculator;
+import com.xyst.dinas.biz.warn.WarnSetting;
+
+import java.time.LocalTime;
+import java.time.format.DateTimeFormatter;
+
+/**
+ * 非作业时间进入采砂区计算器
+ *
+ * @author 
+ * @date 2021年4月1日
+ */
+public class NoOperatingHoursWarnCalculate implements IWarningCalculator{
+
+
+	private String warnMessage;
+
+	private Boolean isWarning;
+
+	private String sandMingAreaName;
+
+	private String sandMiningCode;
+	private String shipName;
+	private LocalTime time;
+
+	public NoOperatingHoursWarnCalculate(boolean isWarning, String sandAreaName, String code, String shipName, LocalTime localTime) {
+		this.isWarning = isWarning;
+		this.sandMingAreaName = sandAreaName;
+		this.sandMiningCode = code;
+		this.shipName = shipName;
+		this.time = localTime;
+	}
+
+
+	@Override
+	public boolean isWarning(WarnSetting warnSetting) {
+
+		//业务数据与设置的阀值做比较,计算是否报警
+		if (isWarning) {
+			warnMessage = "采砂许可证["+sandMiningCode+"]下船只["+shipName+"]于 ["+time.format(DateTimeFormatter.ofPattern("HH时mm分"))+"] 进入采区["+sandMingAreaName+
+                    "],此时段非工作时段,产生报警";
+			return true;
+		}
+		return false;
+	}
+
+
+    public String getWarnMessage() {
+        return warnMessage;
+    }
+
+    public void setWarnMessage(String warnMessage) {
+        this.warnMessage = warnMessage;
+    }
+
+    public String getSandMingAreaName() {
+        return sandMingAreaName;
+    }
+
+    public void setSandMingAreaName(String sandMingAreaName) {
+        this.sandMingAreaName = sandMingAreaName;
+    }
+
+    public String getSandMiningCode() {
+        return sandMiningCode;
+    }
+
+    public void setSandMiningCode(String sandMiningCode) {
+        this.sandMiningCode = sandMiningCode;
+    }
+
+    public String getShipName() {
+        return shipName;
+    }
+
+    public void setShipName(String shipName) {
+        this.shipName = shipName;
+    }
+
+    @Override
+	public String warnMessage() {
+		return warnMessage;
+	}
+
+
+	@Override
+	public String getActualValue() {
+		return isWarning?sandMingAreaName:"";
+	}
+
+
+}

backend/xyst.dinas.production/src/main/java/com/xyst/dinas/production/processor/NoOperatingHoursWarnCalculator.java

+package com.xyst.dinas.production.processor;
+
+import com.beecode.bcp.type.KObject;
+import com.xyst.dinas.biz.warn.IWarningCalculator;
+import com.xyst.dinas.biz.warn.WarnSetting;
+import com.xyst.dinas.production.service.SandMiningService;
+import org.springframework.beans.factory.annotation.Autowired;
+
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.time.ZoneId;
+import java.time.format.DateTimeFormatter;
+import java.util.*;
+
+/**
+ * 非作业时间进入采砂区计算器
+ *
+ * @author 
+ * @date 2021年4月1日
+ */
+public class NoOperatingHoursWarnCalculator implements IWarningCalculator{
+
+	private String warnMessage;
+
+
+    @Autowired
+    private SandMiningService sandMiningService;
+
+	@Override
+	public boolean isWarning(WarnSetting warnSetting) {
+
+
+        KObject sandMining = sandMiningService.getById(warnSetting.getBillId());
+        Date workStartTime = sandMining.getDate("workStartTime");
+        Date workEndTime = sandMining.getDate("workEndTime");
+        LocalTime now = LocalTime.now(ZoneId.systemDefault());
+        LocalTime startTime = LocalDateTime.ofInstant(workStartTime.toInstant(), ZoneId.systemDefault()).toLocalTime();
+        LocalTime endTime = LocalDateTime.ofInstant(workEndTime.toInstant(), ZoneId.systemDefault()).toLocalTime();
+
+        boolean before = now.isBefore(startTime);
+        boolean after = now.isAfter(endTime);
+        //如果在可采时间外,则不应该在采区里边呆着
+        if(!before&&!after){
+            return false;
+        }
+        KObject sandMiningArea = sandMining.get("sandMiningArea");
+        Map<String, Object> sandMiningAreaMap = sandMiningService.setAreaMap(sandMiningArea);
+        if(sandMiningAreaMap==null){
+            return false;
+        }
+        ArrayList<Map<String, Object>> hashMaps = new ArrayList<>();
+        hashMaps.add(sandMiningAreaMap);
+        KObject ship = sandMining.get("ship");
+        try {
+            Map<String, Object> warnIngSandMiningArea = sandMiningService.getInSandMiningArea(hashMaps, null, ship);
+
+            if(warnIngSandMiningArea!=null){
+                warnMessage = "采砂许可证["+sandMining.getString("permitCode")+
+                        "]下船只["+ship.getString("shipName")+"]于 ["+now.format(DateTimeFormatter.ofPattern("HH时mm分"))+"]  进入["
+                        +warnIngSandMiningArea.get("name")+
+                        "],此时段非工作时段,发生报警";
+                return true;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+		return false;
+	}
+
+	@Override
+	public String warnMessage() {
+		return warnMessage;
+	}
+
+
+	@Override
+	public String getActualValue() {
+		return "";
+	}
+
+
+}

backend/xyst.dinas.production/src/main/java/com/xyst/dinas/production/service/SandMiningService.java

@@ -3,6 +3,7 @@ package com.xyst.dinas.production.service;
 import com.beecode.bap.attachment.common.Page;
 import com.beecode.bcp.type.KObject;
 
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.UUID;
@@ -26,6 +27,14 @@ public interface SandMiningService {
 
     void updateIsEnterWarningArea();
 
+    Map<String, Object> getInSandMiningArea(List<Map<String, Object>> list, KObject sandMining, KObject shipInfo) throws Exception;
+
+    void setRegionalCompanySandMing(HashMap<UUID, List<Map<String, Object>>> regionalCompanySandMining, UUID regionalCompany);
+
     List<Map<String, Object>> queryByShip(List<Map<String, Object>> shipsTracking);
 
+    void updateNoOperatingHoursWarn();
+
+
+    Map<String, Object> setAreaMap(KObject sandMiningArea);
 }

backend/xyst.dinas.production/src/main/java/com/xyst/dinas/production/task/SandMiningShipEnterWarningAreaTask.java

@@ -19,12 +19,12 @@ public class SandMiningShipEnterWarningAreaTask implements Task {
 
     @Override
     public void execute(TaskContext taskContext) {
-        logger.info("开始判断是否进度非自己的采砂区");
+        logger.info("开始判断是否进入非自己的采砂区");
 
         if(sandMiningService==null){
             sandMiningService = Amino.getApplicationContext().getBean(SandMiningService.class);
         }
         sandMiningService.updateIsEnterWarningArea();
-        logger.info("结束判断是否进度非自己的采砂区");
+        logger.info("结束判断是否进入非自己的采砂区");
     }
 }

backend/xyst.dinas.production/src/main/java/com/xyst/dinas/production/task/SandMiningShipNoOperatingHoursTask.java

@@ -18,10 +18,10 @@ public class SandMiningShipNoOperatingHoursTask implements Task {
 
     @Override
     public void execute(TaskContext taskContext) {
-        logger.info("开始修改采砂许可证状态");
+        logger.info("开始判断是否非工作时间在采区内");
 
-        sandMiningService.updateSandMiningStatus();
-        logger.info("修改采砂许可证状态结束");
+        sandMiningService.updateNoOperatingHoursWarn();
+        logger.info("结束判断是否非工作时间在采区内");
 
     }
 }