更新

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/AppInfoDao.java

@@ -0,0 +1,13 @@
+package com.zhongshu.iot.server.core.dao;
+
+import com.zhongshu.iot.server.core.domain.user.AppInfo;
+
+/**
+ * @author TRX
+ * @date 2024/3/21
+ */
+public interface AppInfoDao extends org.springframework.data.mongodb.repository.MongoRepository<AppInfo, String> {
+
+    AppInfo findTopByEntIdAndAppSecret(String entId, String appSecret);
+
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/CollectionIdDao.java

@@ -0,0 +1,7 @@
+package com.zhongshu.iot.server.core.dao;
+
+import com.zhongshu.iot.server.core.dao.extend.CollectionIdDaoExtend;
+import com.zhongshu.iot.server.core.domain.user.CollectionId;
+
+public interface CollectionIdDao extends CollectionIdDaoExtend, org.springframework.data.mongodb.repository.MongoRepository<CollectionId, String> {
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/DepartmentDao.java

@@ -0,0 +1,21 @@
+package com.zhongshu.iot.server.core.dao;
+
+import com.zhongshu.iot.server.core.domain.user.Department;
+
+import java.util.List;
+
+/**
+ * @author TRX
+ * @date 2024/3/21
+ */
+public interface DepartmentDao extends org.springframework.data.mongodb.repository.MongoRepository<Department, String> {
+
+    Department findTopById(String id);
+
+    Department findTopByCode(String code);
+
+    List<Department> findByIdIn(List<String> ids);
+
+    List<Department> findByParentId(String parentId);
+
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/RoleDao.java

@@ -0,0 +1,22 @@
+package com.zhongshu.iot.server.core.dao;
+
+import com.zhongshu.iot.server.core.dao.extend.RoleDaoExtend;
+import com.zhongshu.iot.server.core.domain.user.Role;
+
+import java.util.List;
+
+/**
+ * @author TRX
+ * @date 2024/3/21
+ */
+public interface RoleDao extends RoleDaoExtend, org.springframework.data.mongodb.repository.MongoRepository<Role, String> {
+
+    Role findTopById(String id);
+
+    Role findTopByName(String name);
+
+    Role findTopByCode(String code);
+
+    List<Role> findByIdIn(List<String> ids);
+
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/TokenLoginDao.java

@@ -0,0 +1,8 @@
+package com.zhongshu.iot.server.core.dao;
+
+import com.zhongshu.iot.server.core.domain.user.TokenLogin;
+import com.zhongshu.iot.server.core.domain.user.User;
+
+public interface TokenLoginDao extends org.springframework.data.mongodb.repository.MongoRepository<TokenLogin, String> {
+    TokenLogin findTopByUser(User user);
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/UserDao.java

@@ -0,0 +1,14 @@
+package com.zhongshu.iot.server.core.dao;
+
+import com.zhongshu.iot.server.core.dao.extend.UserDaoExtend;
+import com.zhongshu.iot.server.core.domain.user.User;
+
+public interface UserDao extends UserDaoExtend, org.springframework.data.mongodb.repository.MongoRepository<User, String> {
+
+    User findByLoginName(String loginName);
+
+    User findTopById(String id);
+
+
+
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/base/BaseImpl.java

@@ -0,0 +1,63 @@
+package com.zhongshu.iot.server.core.dao.base;
+
+import com.zhongshu.iot.client.model.baseParam.SuperSearchParam;
+import com.zhongshu.iot.server.core.util.CommonUtil;
+import org.apache.commons.lang3.ObjectUtils;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.mongodb.core.query.Criteria;
+
+/**
+ * @author TRX
+ * @date 2024/5/31
+ */
+public abstract class BaseImpl {
+
+    /**
+     * 通用创建搜索条件
+     *
+     * @param param
+     * @return
+     */
+    public Criteria buildCriteria(SuperSearchParam param) {
+        Criteria criteria = new Criteria();
+        criteria.and("isDelete").ne(Boolean.TRUE);
+        return criteria;
+    }
+
+    public Criteria buildCriteriaAboutTime(SuperSearchParam param) {
+        Criteria criteria = new Criteria();
+        criteria.and("isDelete").ne(Boolean.TRUE);
+        if (!CommonUtil.longIsEmpty(param.getStartTime()) && !CommonUtil.longIsEmpty(param.getEndTime())) {
+            criteria.and("createTime").gte(param.getStartTime()).lte(param.getEndTime());
+        } else if (!CommonUtil.longIsEmpty(param.getStartTime()) && CommonUtil.longIsEmpty(param.getEndTime())) {
+            criteria.and("createTime").gte(param.getStartTime());
+        } else if (CommonUtil.longIsEmpty(param.getStartTime()) && !CommonUtil.longIsEmpty(param.getEndTime())) {
+            criteria.and("createTime").lte(param.getEndTime());
+        }
+        return criteria;
+    }
+
+    /**
+     * 排序
+     *
+     * @param param
+     * @return
+     */
+    public Sort buildSort(SuperSearchParam param) {
+        Sort sort = param.getOrderSort();
+        if (sort == null && param.getIsSortDesc() != null) {
+            if (param.getIsSortDesc()) {
+                // 倒序
+                sort = Sort.by(Sort.Order.desc("sort"), Sort.Order.desc("createTime"));
+            } else {
+                // 升序
+                sort = Sort.by(Sort.Order.asc("sort"), Sort.Order.desc("createTime"));
+            }
+        }
+        if (ObjectUtils.isEmpty(sort)) {
+            sort = Sort.by(Sort.Order.desc("createTime"));
+        }
+        return sort;
+    }
+
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/docker/AkSkConfigTimeDao.java

@@ -0,0 +1,13 @@
+package com.zhongshu.iot.server.core.dao.docker;
+
+import com.zhongshu.iot.server.core.domain.docker.AkSkConfig;
+
+/**
+ * @author TRX
+ * @date 2024/3/21
+ */
+public interface AkSkConfigTimeDao extends org.springframework.data.mongodb.repository.MongoRepository<AkSkConfig, String> {
+
+    AkSkConfig findTopByAk(String ak);
+
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/docker/DockerMetaDao.java

@@ -0,0 +1,19 @@
+package com.zhongshu.iot.server.core.dao.docker;
+
+import com.zhongshu.iot.server.core.dao.docker.extend.DockerMetaDaoExtend;
+import com.zhongshu.iot.server.core.domain.docker.DockerMeta;
+
+import java.util.List;
+
+/**
+ * @author TRX
+ * @date 2024/3/21
+ */
+public interface DockerMetaDao extends DockerMetaDaoExtend, org.springframework.data.mongodb.repository.MongoRepository<DockerMeta, String> {
+
+    DockerMeta findTopById(String id);
+
+    DockerMeta findTopByGroupCodeAndName(String groupCode, String name);
+
+    List<DockerMeta> findByGroupCodeOrderByUpdateTimeDesc(String groupCode);
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/docker/DockerMetaLastTimeDao.java

@@ -0,0 +1,13 @@
+package com.zhongshu.iot.server.core.dao.docker;
+
+import com.zhongshu.iot.server.core.domain.docker.DockerMetaLastTime;
+
+/**
+ * @author TRX
+ * @date 2024/3/21
+ */
+public interface DockerMetaLastTimeDao extends org.springframework.data.mongodb.repository.MongoRepository<DockerMetaLastTime, String> {
+
+    DockerMetaLastTime findTopByGroupCode(String groupCode);
+
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/docker/extend/DockerMetaDaoExtend.java

@@ -0,0 +1,15 @@
+package com.zhongshu.iot.server.core.dao.docker.extend;
+
+import com.zhongshu.iot.server.core.domain.docker.DockerMeta;
+import com.zhongshu.iot.client.model.docker.DockerMetaSearch;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+
+/**
+ * @Author TRX
+ * @CreateDate: 2023/7/7
+ * @Version: 1.0
+ */
+public interface DockerMetaDaoExtend {
+    Page<DockerMeta> page(Pageable pageable, DockerMetaSearch param);
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/docker/impl/DockerMetaDaoImpl.java

@@ -0,0 +1,74 @@
+package com.zhongshu.iot.server.core.dao.docker.impl;
+
+import com.github.microservice.components.data.mongo.mongo.helper.DBHelper;
+import com.zhongshu.iot.client.model.docker.DockerMetaSearch;
+import com.zhongshu.iot.server.core.dao.base.BaseImpl;
+import com.zhongshu.iot.server.core.dao.docker.extend.DockerMetaDaoExtend;
+import com.zhongshu.iot.server.core.domain.docker.DockerMeta;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.util.CollectionUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Pattern;
+
+/**
+ * @Author TRX
+ * @CreateDate: 2023/4/12
+ * @Version: 1.0
+ */
+public class DockerMetaDaoImpl extends BaseImpl implements DockerMetaDaoExtend {
+
+    @Autowired
+    private MongoTemplate mongoTemplate;
+
+    @Autowired
+    private DBHelper dbHelper;
+
+    @Override
+    public Page<DockerMeta> page(Pageable pageable, DockerMetaSearch param) {
+        Criteria criteria = new Criteria();
+
+        if (StringUtils.isNotEmpty(param.getGroupCode())) {
+            criteria.and("groupCode").is(param.getGroupCode());
+        }
+
+        // 模糊搜索
+        List<Criteria> criterias = new ArrayList<>();
+        if (StringUtils.isNotEmpty(param.getName())) {
+            Pattern pattern = Pattern.compile("^.*" + param.getName() + ".*$");
+            criterias.add(Criteria.where("name").is(pattern));
+        }
+
+        if (StringUtils.isNotEmpty(param.getImage())) {
+            Pattern pattern = Pattern.compile("^.*" + param.getImage() + ".*$");
+            criterias.add(Criteria.where("image").is(pattern));
+        }
+
+        if (!CollectionUtils.isEmpty(criterias)) {
+            criteria.andOperator(criterias.toArray(new Criteria[]{}));
+        }
+
+//        if (StringUtils.isNotEmpty(param.getTitle())) {
+//            Pattern pattern = Pattern.compile("^.*" + param.getTitle() + ".*$");
+//            criteria.orOperator(
+//                    Criteria.where("name").regex(pattern),
+//                    Criteria.where("content").regex(pattern)
+//            );
+//        }
+
+        criteria.and("isDelete").is(Boolean.FALSE);
+        Sort sort = buildSort(param);
+        Query query = Query.query(criteria);
+        query.with(sort);
+        return dbHelper.pages(query, pageable, DockerMeta.class);
+    }
+
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/extend/CollectionIdDaoExtend.java

@@ -0,0 +1,7 @@
+package com.zhongshu.iot.server.core.dao.extend;
+
+public interface CollectionIdDaoExtend {
+    Long getNextId(String collectionName);
+
+    Long getNextId(String oid, String collectionName);
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/extend/RoleDaoExtend.java

@@ -0,0 +1,15 @@
+package com.zhongshu.iot.server.core.dao.extend;
+
+import com.zhongshu.iot.server.core.domain.user.Role;
+import com.zhongshu.iot.client.model.user.RoleSearchParam;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+
+/**
+ * @Author TRX
+ * @CreateDate: 2023/7/7
+ * @Version: 1.0
+ */
+public interface RoleDaoExtend {
+    Page<Role> page(Pageable pageable, RoleSearchParam param);
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/extend/UserDaoExtend.java

@@ -0,0 +1,15 @@
+package com.zhongshu.iot.server.core.dao.extend;
+
+import com.zhongshu.iot.server.core.domain.user.User;
+import com.zhongshu.iot.client.model.user.UserSearchParams;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+
+/**
+ * @Author TRX
+ * @CreateDate: 2023/7/7
+ * @Version: 1.0
+ */
+public interface UserDaoExtend {
+    Page<User> page(Pageable pageable, UserSearchParams param);
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/impl/CollectionIdDaoImpl.java

@@ -0,0 +1,41 @@
+package com.zhongshu.iot.server.core.dao.impl;
+
+import com.zhongshu.iot.server.core.dao.extend.CollectionIdDaoExtend;
+import com.zhongshu.iot.server.core.domain.user.CollectionId;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.mongodb.core.FindAndModifyOptions;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.data.mongodb.core.query.Update;
+
+public class CollectionIdDaoImpl implements CollectionIdDaoExtend {
+
+    @Autowired
+    private MongoTemplate mongoTemplate;
+
+    @Override
+    public Long getNextId(String collectionName) {
+        Query query = new Query(Criteria.where("collectionName").is(collectionName));
+        Update update = new Update();
+        update.inc("aid", 1);
+        FindAndModifyOptions options = new FindAndModifyOptions();
+        options.upsert(true);
+        options.returnNew(true);
+        CollectionId collectionId = mongoTemplate.findAndModify(query, update, options, CollectionId.class);
+        return collectionId.getAid();
+    }
+
+    @Override
+    public Long getNextId(String oid, String collectionName) {
+        Query query = new Query(Criteria.where("collectionName").is(collectionName).and("epId").is(oid));
+        Update update = new Update();
+        update.inc("aid", 1);
+        //update.set("epId",epId);
+        FindAndModifyOptions options = new FindAndModifyOptions();
+        options.upsert(true);
+        options.returnNew(true);
+        CollectionId collectionId = mongoTemplate.findAndModify(query, update, options, CollectionId.class);
+        return collectionId.getAid();
+    }
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/impl/RoleDaoImpl.java

@@ -0,0 +1,64 @@
+package com.zhongshu.iot.server.core.dao.impl;
+
+import com.zhongshu.iot.server.core.dao.base.BaseImpl;
+import com.zhongshu.iot.server.core.dao.extend.RoleDaoExtend;
+import com.zhongshu.iot.server.core.domain.user.Role;
+import com.github.microservice.components.data.mongo.mongo.helper.DBHelper;
+import com.zhongshu.iot.client.model.user.RoleSearchParam;
+import com.zhongshu.iot.server.core.util.CommonUtil;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.util.CollectionUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Pattern;
+
+/**
+ * @Author TRX
+ * @CreateDate: 2023/4/12
+ * @Version: 1.0
+ */
+public class RoleDaoImpl extends BaseImpl implements RoleDaoExtend {
+
+    @Autowired
+    private MongoTemplate mongoTemplate;
+
+    @Autowired
+    private DBHelper dbHelper;
+
+    @Override
+    public Page<Role> page(Pageable pageable, RoleSearchParam param) {
+        Criteria criteria = new Criteria();
+
+        if (!CommonUtil.longIsEmpty(param.getStartTime()) && !CommonUtil.longIsEmpty(param.getEndTime())) {
+            criteria.and("createTime").gte(param.getStartTime()).and("createTime").lte(param.getEndTime());
+        }
+
+        // 模糊搜索
+        List<Criteria> criterias = new ArrayList<>();
+        if (StringUtils.isNotEmpty(param.getName())) {
+            Pattern pattern = Pattern.compile("^.*" + param.getName() + ".*$");
+            criterias.add(Criteria.where("name").is(pattern));
+        }
+        if (StringUtils.isNotEmpty(param.getCode())) {
+            Pattern pattern = Pattern.compile("^.*" + param.getName() + ".*$");
+            criterias.add(Criteria.where("code").is(pattern));
+        }
+        if (!CollectionUtils.isEmpty(criterias)) {
+            criteria.andOperator(criterias.toArray(new Criteria[]{}));
+        }
+        criteria.and("isDelete").is(Boolean.FALSE);
+        Sort sort = buildSort(param);
+        Query query = Query.query(criteria);
+        query.with(sort);
+        return dbHelper.pages(query, pageable, Role.class);
+    }
+
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/impl/UserDaoImpl.java

@@ -0,0 +1,81 @@
+package com.zhongshu.iot.server.core.dao.impl;
+
+import com.zhongshu.iot.server.core.dao.base.BaseImpl;
+import com.zhongshu.iot.server.core.dao.extend.UserDaoExtend;
+import com.zhongshu.iot.server.core.domain.user.User;
+import com.github.microservice.components.data.mongo.mongo.helper.DBHelper;
+import com.zhongshu.iot.client.model.user.UserSearchParams;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.util.CollectionUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Pattern;
+
+/**
+ * @Author TRX
+ * @CreateDate: 2023/4/6
+ * @Version: 1.0
+ */
+public class UserDaoImpl extends BaseImpl implements UserDaoExtend {
+
+    @Autowired
+    private MongoTemplate mongoTemplate;
+
+    @Autowired
+    private DBHelper dbHelper;
+
+    @Override
+    public Page<User> page(Pageable pageable, UserSearchParams param) {
+        Criteria criteria = buildCriteria(param);
+
+        if (param.getUserType() != null) {
+            criteria.and("userType").is(param.getUserType());
+        }
+
+        // 用户状态
+        if (param.getUserState() != null) {
+            criteria.and("userState").is(param.getUserState());
+        }
+
+        // 模糊搜索
+        List<Criteria> criterias = new ArrayList<>();
+        if (StringUtils.isNotEmpty(param.getLoginName())) {
+            Pattern pattern = Pattern.compile("^.*" + param.getLoginName() + ".*$");
+            criterias.add(Criteria.where("loginName").is(pattern));
+        }
+        if (StringUtils.isNotEmpty(param.getUserName())) {
+            Pattern pattern = Pattern.compile("^.*" + param.getUserName() + ".*$");
+            criterias.add(Criteria.where("userName").is(pattern));
+        }
+        if (StringUtils.isNotEmpty(param.getPhone())) {
+            Pattern pattern = Pattern.compile("^.*" + param.getPhone() + ".*$");
+            criterias.add(Criteria.where("phone").is(pattern));
+        }
+        if (!CollectionUtils.isEmpty(criterias)) {
+            criteria.andOperator(criterias.toArray(new Criteria[]{}));
+        }
+
+        if (StringUtils.isNotEmpty(param.getKeyWord())) {
+            Pattern pattern = Pattern.compile("^.*" + param.getKeyWord() + ".*$");
+            criteria.orOperator(
+                    Criteria.where("userName").regex(pattern),
+                    Criteria.where("phone").regex(pattern)
+            );
+        }
+//        criteria.and("loginName").ne("admin");
+
+        Sort sort = buildSort(param);
+        Query query = Query.query(criteria);
+        query.with(sort);
+        return dbHelper.pages(query, pageable, User.class);
+    }
+
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/iot/IotDeviceDataDao.java

@@ -0,0 +1,16 @@
+package com.zhongshu.iot.server.core.dao.iot;
+
+import com.zhongshu.iot.server.core.domain.iot.IotDeviceData;
+import com.zhongshu.iot.server.core.domain.iot.IotMain;
+
+/**
+ * @author TRX
+ * @date 2024/3/21
+ */
+public interface IotDeviceDataDao extends org.springframework.data.mongodb.repository.MongoRepository<IotDeviceData, String> {
+
+    IotDeviceData findTopById(String id);
+
+    IotDeviceData findTopByIotMain(IotMain iotMain);
+
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/iot/IotMainDao.java

@@ -0,0 +1,31 @@
+package com.zhongshu.iot.server.core.dao.iot;
+
+import com.zhongshu.iot.client.type.FunctionType;
+import com.zhongshu.iot.client.type.IotDataType;
+import com.zhongshu.iot.server.core.dao.iot.extend.IotMainDaoExtend;
+import com.zhongshu.iot.server.core.domain.iot.IotMain;
+import com.zhongshu.iot.server.core.domain.iot.IotTemplate;
+
+import java.util.List;
+
+/**
+ * @author TRX
+ * @date 2024/3/21
+ */
+public interface IotMainDao extends IotMainDaoExtend, org.springframework.data.mongodb.repository.MongoRepository<IotMain, String> {
+
+    IotMain findTopById(String id);
+
+    IotMain findTopByNameAndIotTemplate(String name, IotTemplate iotTemplate);
+
+    IotMain findTopByIotTopicAndIotTemplate(String iotTopic, IotTemplate iotTemplate);
+
+    List<IotMain> findByIotTemplateOrderByCreateTimeAsc(IotTemplate iotTemplate);
+
+    List<IotMain> findByIotTemplateAndFunctionTypeOrderByCreateTimeAsc(IotTemplate iotTemplate, FunctionType functionType);
+
+    List<IotMain> findByRealIotTopicAndFunctionTypeOrderByCreateTimeAsc(String realIotTopic, FunctionType functionType);
+
+    List<IotMain> findByDeviceIdAndIdentifierAndIotDataType(String deviceId, String identifier, IotDataType iotData);
+
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/iot/IotTemplateDao.java

@@ -0,0 +1,24 @@
+package com.zhongshu.iot.server.core.dao.iot;
+
+import com.zhongshu.iot.client.type.IotDataType;
+import com.zhongshu.iot.server.core.dao.iot.extend.IotTemplateDaoExtend;
+import com.zhongshu.iot.server.core.domain.iot.IotTemplate;
+
+import java.util.List;
+
+/**
+ * @author TRX
+ * @date 2024/3/21
+ */
+public interface IotTemplateDao extends IotTemplateDaoExtend, org.springframework.data.mongodb.repository.MongoRepository<IotTemplate, String> {
+
+    IotTemplate findTopById(String id);
+
+    IotTemplate findTopByNameAndIotDataType(String name, IotDataType iotDataType);
+
+    IotTemplate findTopByNameAndDeviceIdAndIotDataType(String name, String deviceId, IotDataType iotDataType);
+
+    List<IotTemplate> findByDeviceIdAndIotDataTypeOrderByCreateTimeAsc(String deviceId, IotDataType iotDataType);
+
+    IotTemplate findTopByDeviceIdAndIotTemplateIdAndIotDataType(String deviceId, String iotTemplateId, IotDataType iotDataType);
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/iot/IotTopicDao.java

@@ -0,0 +1,17 @@
+package com.zhongshu.iot.server.core.dao.iot;
+
+import com.zhongshu.iot.server.core.dao.iot.extend.IotTopicDaoExtend;
+import com.zhongshu.iot.server.core.domain.iot.IotTemplate;
+import com.zhongshu.iot.server.core.domain.iot.IotTopic;
+
+/**
+ * @author TRX
+ * @date 2024/3/21
+ */
+public interface IotTopicDao extends IotTopicDaoExtend, org.springframework.data.mongodb.repository.MongoRepository<IotTopic, String> {
+
+    IotTopic findTopById(String id);
+
+    IotTopic findTopByTopicAndIotTemplate(String topic, IotTemplate iotTemplate);
+
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/iot/extend/IotMainDaoExtend.java

@@ -0,0 +1,15 @@
+package com.zhongshu.iot.server.core.dao.iot.extend;
+
+import com.zhongshu.iot.server.core.domain.iot.IotMain;
+import com.zhongshu.iot.client.model.iot.IotMainSearch;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+
+/**
+ * @Author TRX
+ * @CreateDate: 2023/7/7
+ * @Version: 1.0
+ */
+public interface IotMainDaoExtend {
+    Page<IotMain> page(Pageable pageable, IotMainSearch param);
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/iot/extend/IotTemplateDaoExtend.java

@@ -0,0 +1,15 @@
+package com.zhongshu.iot.server.core.dao.iot.extend;
+
+import com.zhongshu.iot.server.core.domain.iot.IotTemplate;
+import com.zhongshu.iot.client.model.iot.IotTemplateSearch;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+
+/**
+ * @Author TRX
+ * @CreateDate: 2023/7/7
+ * @Version: 1.0
+ */
+public interface IotTemplateDaoExtend {
+    Page<IotTemplate> page(Pageable pageable, IotTemplateSearch param);
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/iot/extend/IotTopicDaoExtend.java

@@ -0,0 +1,15 @@
+package com.zhongshu.iot.server.core.dao.iot.extend;
+
+import com.zhongshu.iot.server.core.domain.iot.IotTopic;
+import com.zhongshu.iot.client.model.iot.IotTopicSearch;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+
+/**
+ * @Author TRX
+ * @CreateDate: 2023/7/7
+ * @Version: 1.0
+ */
+public interface IotTopicDaoExtend {
+    Page<IotTopic> page(Pageable pageable, IotTopicSearch param);
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/iot/impl/IotMainDaoImpl.java

@@ -0,0 +1,87 @@
+package com.zhongshu.iot.server.core.dao.iot.impl;
+
+import com.zhongshu.iot.server.core.dao.base.BaseImpl;
+import com.zhongshu.iot.server.core.dao.iot.extend.IotMainDaoExtend;
+import com.zhongshu.iot.server.core.domain.iot.IotMain;
+import com.zhongshu.iot.server.core.domain.iot.IotTemplate;
+import com.github.microservice.components.data.mongo.mongo.helper.DBHelper;
+import com.zhongshu.iot.client.model.iot.IotMainSearch;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.util.CollectionUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Pattern;
+
+/**
+ * @Author TRX
+ * @CreateDate: 2023/4/12
+ * @Version: 1.0
+ */
+public class IotMainDaoImpl extends BaseImpl implements IotMainDaoExtend {
+
+    @Autowired
+    private MongoTemplate mongoTemplate;
+
+    @Autowired
+    private DBHelper dbHelper;
+
+    @Override
+    public Page<IotMain> page(Pageable pageable, IotMainSearch param) {
+        Criteria criteria = new Criteria();
+
+        if (StringUtils.isNotEmpty(param.getIotTemplateId())) {
+            criteria.and("iotTemplate").is(IotTemplate.build(param.getIotTemplateId()));
+        }
+
+        if (param.getFunctionType() != null) {
+            criteria.and("functionType").is(param.getFunctionType());
+        }
+
+        if (param.getDataType() != null) {
+            criteria.and("dataType").is(param.getDataType());
+        }
+
+        // 模糊搜索
+        List<Criteria> criterias = new ArrayList<>();
+        if (StringUtils.isNotEmpty(param.getName())) {
+            Pattern pattern = Pattern.compile("^.*" + param.getName() + ".*$");
+            criterias.add(Criteria.where("name").is(pattern));
+        }
+        if (StringUtils.isNotEmpty(param.getIdentifier())) {
+            Pattern pattern = Pattern.compile("^.*" + param.getIdentifier() + ".*$");
+            criterias.add(Criteria.where("identifier").is(pattern));
+        }
+        if (StringUtils.isNotEmpty(param.getIotTopic())) {
+            Pattern pattern = Pattern.compile("^.*" + param.getIotTopic() + ".*$");
+            criterias.add(Criteria.where("iotTopic").is(pattern));
+        }
+        if (!CollectionUtils.isEmpty(criterias)) {
+            criteria.andOperator(criterias.toArray(new Criteria[]{}));
+        }
+
+        // 关键字搜索
+        if (StringUtils.isNotEmpty(param.getKeyWord())) {
+            Pattern pattern = Pattern.compile("^.*" + param.getKeyWord() + ".*$");
+            criteria.orOperator(
+                    Criteria.where("name").regex(pattern),
+                    Criteria.where("identifier").regex(pattern),
+                    Criteria.where("iotTopic").regex(pattern)
+            );
+        }
+
+        criteria.and("isDelete").is(Boolean.FALSE);
+        Sort sort = buildSort(param);
+        Query query = Query.query(criteria);
+        query.with(sort);
+        return dbHelper.pages(query, pageable, IotMain.class);
+    }
+
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/iot/impl/IotTemplateDaoImpl.java

@@ -0,0 +1,65 @@
+package com.zhongshu.iot.server.core.dao.iot.impl;
+
+import com.zhongshu.iot.server.core.dao.base.BaseImpl;
+import com.zhongshu.iot.server.core.dao.iot.extend.IotTemplateDaoExtend;
+import com.zhongshu.iot.server.core.domain.iot.IotTemplate;
+import com.github.microservice.components.data.mongo.mongo.helper.DBHelper;
+import com.zhongshu.iot.client.model.iot.IotTemplateSearch;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.util.CollectionUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Pattern;
+
+/**
+ * @Author TRX
+ * @CreateDate: 2023/4/12
+ * @Version: 1.0
+ */
+public class IotTemplateDaoImpl extends BaseImpl implements IotTemplateDaoExtend {
+
+    @Autowired
+    private MongoTemplate mongoTemplate;
+
+    @Autowired
+    private DBHelper dbHelper;
+
+    @Override
+    public Page<IotTemplate> page(Pageable pageable, IotTemplateSearch param) {
+        Criteria criteria = new Criteria();
+
+        if (StringUtils.isNotEmpty(param.getEpId())) {
+            criteria.and("epId").is(param.getEpId());
+        }
+
+        // 类型：模型 还是物模型
+        if (param.getIotDataType() != null) {
+            criteria.and("iotDataType").is(param.getIotDataType());
+        }
+
+        // 模糊搜索
+        List<Criteria> criterias = new ArrayList<>();
+        if (StringUtils.isNotEmpty(param.getName())) {
+            Pattern pattern = Pattern.compile("^.*" + param.getName() + ".*$");
+            criterias.add(Criteria.where("name").is(pattern));
+        }
+        if (!CollectionUtils.isEmpty(criterias)) {
+            criteria.andOperator(criterias.toArray(new Criteria[]{}));
+        }
+
+        criteria.and("isDelete").is(Boolean.FALSE);
+        Sort sort = buildSort(param);
+        Query query = Query.query(criteria);
+        query.with(sort);
+        return dbHelper.pages(query, pageable, IotTemplate.class);
+    }
+
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/iot/impl/IotTopicDaoImpl.java

@@ -0,0 +1,65 @@
+package com.zhongshu.iot.server.core.dao.iot.impl;
+
+import com.zhongshu.iot.server.core.dao.base.BaseImpl;
+import com.zhongshu.iot.server.core.dao.iot.extend.IotTopicDaoExtend;
+import com.zhongshu.iot.server.core.domain.iot.IotTemplate;
+import com.zhongshu.iot.server.core.domain.iot.IotTopic;
+import com.github.microservice.components.data.mongo.mongo.helper.DBHelper;
+import com.zhongshu.iot.client.model.iot.IotTopicSearch;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.util.CollectionUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Pattern;
+
+/**
+ * @Author TRX
+ * @CreateDate: 2023/4/12
+ * @Version: 1.0
+ */
+public class IotTopicDaoImpl extends BaseImpl implements IotTopicDaoExtend {
+
+    @Autowired
+    private MongoTemplate mongoTemplate;
+
+    @Autowired
+    private DBHelper dbHelper;
+
+    @Override
+    public Page<IotTopic> page(Pageable pageable, IotTopicSearch param) {
+        Criteria criteria = new Criteria();
+
+        if (StringUtils.isNotEmpty(param.getEpId())) {
+            criteria.and("epId").is(param.getEpId());
+        }
+
+        if (StringUtils.isNotEmpty(param.getIotTemplateId())) {
+            criteria.and("iotTemplate").is(IotTemplate.build(param.getIotTemplateId()));
+        }
+
+        // 模糊搜索
+        List<Criteria> criterias = new ArrayList<>();
+        if (StringUtils.isNotEmpty(param.getTopic())) {
+            Pattern pattern = Pattern.compile("^.*" + param.getTopic() + ".*$");
+            criterias.add(Criteria.where("topic").is(pattern));
+        }
+        if (!CollectionUtils.isEmpty(criterias)) {
+            criteria.andOperator(criterias.toArray(new Criteria[]{}));
+        }
+
+        criteria.and("isDelete").is(Boolean.FALSE);
+        Sort sort = buildSort(param);
+        Query query = Query.query(criteria);
+        query.with(sort);
+        return dbHelper.pages(query, pageable, IotTopic.class);
+    }
+
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/mqtt/DeviceInfoDao.java

@@ -0,0 +1,21 @@
+package com.zhongshu.iot.server.core.dao.mqtt;
+
+import com.zhongshu.iot.server.core.dao.mqtt.extend.DeviceInfoDaoExtend;
+import com.zhongshu.iot.server.core.domain.iot.mqtt.DeviceInfo;
+
+import java.util.List;
+
+/**
+ * @author TRX
+ * @date 2024/3/21
+ */
+public interface DeviceInfoDao extends DeviceInfoDaoExtend, org.springframework.data.mongodb.repository.MongoRepository<DeviceInfo, String> {
+
+    DeviceInfo findTopById(String id);
+
+    DeviceInfo findTopByDeviceId(String deviceId);
+
+    DeviceInfo findTopByDeviceIdAndProjectInfoCode(String deviceId, String projectInfoCode);
+
+    List<DeviceInfo> findByDeviceIdIn(List<String> deviceIds);
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/mqtt/DevicePingInfoDao.java

@@ -0,0 +1,23 @@
+package com.zhongshu.iot.server.core.dao.mqtt;
+
+import com.zhongshu.iot.server.core.domain.iot.mqtt.DevicePingInfo;
+
+import java.util.List;
+
+/**
+ * @author TRX
+ * @date 2024/3/21
+ */
+public interface DevicePingInfoDao extends org.springframework.data.mongodb.repository.MongoRepository<DevicePingInfo, String> {
+
+    DevicePingInfo findTopById(String id);
+
+    DevicePingInfo findTopByDeviceIdAndGateWayId(String deviceId);
+
+    DevicePingInfo findTopByDeviceIdOrderByCreateTimeDesc(String deviceId);
+
+    List<DevicePingInfo> findTop5ByDeviceIdOrderByCreateTimeDesc(String deviceId);
+
+    List<DevicePingInfo> findTop5ByGateWayIdAndPingTypeOrderByCreateTimeDesc(String gateWayId, String pingType);
+
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/mqtt/GateWay2DeviceDao.java

@@ -0,0 +1,21 @@
+package com.zhongshu.iot.server.core.dao.mqtt;
+
+import com.zhongshu.iot.server.core.domain.iot.mqtt.DeviceInfo;
+import com.zhongshu.iot.server.core.domain.iot.mqtt.GateWay2Device;
+import com.zhongshu.iot.server.core.domain.iot.mqtt.GateWayInfo;
+
+import java.util.List;
+
+/**
+ * @author TRX
+ * @date 2024/3/21
+ */
+public interface GateWay2DeviceDao extends org.springframework.data.mongodb.repository.MongoRepository<GateWay2Device, String> {
+
+    GateWay2Device findTopByGateWayInfoAndDeviceInfo(GateWayInfo gateWayInfo, DeviceInfo deviceInfo);
+
+    // 根据设备查询绑定关系
+    List<GateWay2Device> findByDeviceInfo(DeviceInfo deviceInfo);
+
+    GateWay2Device findTopByDeviceInfoOrderByUpdateTimeDesc(DeviceInfo deviceInfo);
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/mqtt/GateWay2UserDao.java

@@ -0,0 +1,13 @@
+package com.zhongshu.iot.server.core.dao.mqtt;
+
+import com.zhongshu.iot.server.core.domain.iot.mqtt.GateWay2User;
+import com.zhongshu.iot.server.core.domain.iot.mqtt.GateWayUserInfo;
+
+/**
+ * @author TRX
+ * @date 2024/3/21
+ */
+public interface GateWay2UserDao extends org.springframework.data.mongodb.repository.MongoRepository<GateWay2User, String> {
+
+    GateWay2User findTopByGateWayUserInfo(GateWayUserInfo gateWayUserInfo);
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/mqtt/GateWayInfoDao.java

@@ -0,0 +1,19 @@
+package com.zhongshu.iot.server.core.dao.mqtt;
+
+import com.zhongshu.iot.server.core.dao.mqtt.extend.GateWayInfoDaoExtend;
+import com.zhongshu.iot.server.core.domain.iot.mqtt.GateWayInfo;
+
+import java.util.List;
+
+/**
+ * @author TRX
+ * @date 2024/3/21
+ */
+public interface GateWayInfoDao extends GateWayInfoDaoExtend, org.springframework.data.mongodb.repository.MongoRepository<GateWayInfo, String> {
+
+    GateWayInfo findTopById(String id);
+
+    GateWayInfo findTopByGateWayId(String gateWayId);
+
+    List<GateWayInfo> findByGateWayIdIn(List<String> gateWayIds);
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/mqtt/GateWayUserInfoDao.java

@@ -0,0 +1,15 @@
+package com.zhongshu.iot.server.core.dao.mqtt;
+
+import com.zhongshu.iot.server.core.dao.mqtt.extend.GateWayUserInfoDaoExtend;
+import com.zhongshu.iot.server.core.domain.iot.mqtt.GateWayUserInfo;
+
+/**
+ * @author TRX
+ * @date 2024/3/21
+ */
+public interface GateWayUserInfoDao extends GateWayUserInfoDaoExtend, org.springframework.data.mongodb.repository.MongoRepository<GateWayUserInfo, String> {
+
+    GateWayUserInfo findTopById(String id);
+
+    GateWayUserInfo findTopByUserName(String userName);
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/mqtt/Mqtt2UserDao.java

@@ -0,0 +1,24 @@
+package com.zhongshu.iot.server.core.dao.mqtt;
+
+import com.zhongshu.iot.server.core.domain.iot.mqtt.GateWayUserInfo;
+import com.zhongshu.iot.server.core.domain.iot.mqtt.Mqtt2User;
+import com.zhongshu.iot.server.core.domain.iot.mqtt.MqttInfo;
+
+/**
+ * @author TRX
+ * @date 2024/3/21
+ */
+public interface Mqtt2UserDao extends org.springframework.data.mongodb.repository.MongoRepository<Mqtt2User, String> {
+
+    Mqtt2User findTopByMqttInfoAndGateWayUserInfo(MqttInfo mqttInfo, GateWayUserInfo gateWayUserInfo);
+
+    /**
+     * 删除网关和角色的关系
+     *
+     * @param mqttInfo
+     * @param gateWayUserInfo
+     */
+    void deleteByMqttInfoAndGateWayUserInfo(MqttInfo mqttInfo, GateWayUserInfo gateWayUserInfo);
+
+    void deleteByMqttInfo(MqttInfo mqttInfo);
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/mqtt/MqttInfoDao.java

@@ -0,0 +1,13 @@
+package com.zhongshu.iot.server.core.dao.mqtt;
+
+import com.zhongshu.iot.server.core.domain.iot.mqtt.MqttInfo;
+
+/**
+ * @author TRX
+ * @date 2024/3/21
+ */
+public interface MqttInfoDao extends org.springframework.data.mongodb.repository.MongoRepository<MqttInfo, String> {
+    MqttInfo findTopByBrokerHost(String brokerHost);
+
+    MqttInfo findTopById(String id);
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/mqtt/OperationLogsDao.java

@@ -0,0 +1,14 @@
+package com.zhongshu.iot.server.core.dao.mqtt;
+
+import com.zhongshu.iot.server.core.dao.mqtt.extend.OperationLogsDaoExtend;
+import com.zhongshu.iot.server.core.domain.iot.mqtt.OperationLogs;
+
+/**
+ * @author TRX
+ * @date 2024/3/21
+ */
+public interface OperationLogsDao extends OperationLogsDaoExtend, org.springframework.data.mongodb.repository.MongoRepository<OperationLogs, String> {
+
+    OperationLogs findTopById(String id);
+
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/mqtt/OperationMessageDao.java

@@ -0,0 +1,20 @@
+package com.zhongshu.iot.server.core.dao.mqtt;
+
+import com.zhongshu.iot.server.core.dao.mqtt.extend.OperationMessageDaoExtend;
+import com.zhongshu.iot.server.core.domain.iot.mqtt.OperationMessage;
+
+/**
+ * @author TRX
+ * @date 2024/3/21
+ */
+public interface OperationMessageDao extends OperationMessageDaoExtend, org.springframework.data.mongodb.repository.MongoRepository<OperationMessage, String> {
+
+    OperationMessage findTopByMessageId(String messageId);
+
+    OperationMessage findTopById(String id);
+
+    OperationMessage findTopByDataId(String dataId);
+
+    // 业务数据是否存在
+    boolean existsByDataId(String dataId);
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/mqtt/OperationMessageResultDao.java

@@ -0,0 +1,14 @@
+package com.zhongshu.iot.server.core.dao.mqtt;
+
+import com.zhongshu.iot.server.core.dao.mqtt.extend.OperationMessageResultDaoExtend;
+import com.zhongshu.iot.server.core.domain.iot.mqtt.OperationMessageResult;
+
+/**
+ * @author TRX
+ * @date 2024/3/21
+ */
+public interface OperationMessageResultDao extends OperationMessageResultDaoExtend, org.springframework.data.mongodb.repository.MongoRepository<OperationMessageResult, String> {
+
+    OperationMessageResult findTopById(String id);
+
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/mqtt/ProjectInfoDao.java

@@ -0,0 +1,22 @@
+package com.zhongshu.iot.server.core.dao.mqtt;
+
+import com.github.microservice.models.type.CommonState;
+import com.zhongshu.iot.server.core.dao.mqtt.extend.ProjectInfoDaoExtend;
+import com.zhongshu.iot.server.core.domain.iot.mqtt.ProjectInfo;
+
+import java.util.List;
+
+/**
+ * @author TRX
+ * @date 2024/3/21
+ */
+public interface ProjectInfoDao extends ProjectInfoDaoExtend, org.springframework.data.mongodb.repository.MongoRepository<ProjectInfo, String> {
+
+    ProjectInfo findTopById(String id);
+
+    ProjectInfo findTopByCode(String code);
+
+    List<ProjectInfo> findByIdIn(List<String> ids);
+
+    List<ProjectInfo> findByStateOrderByCreateTimeDesc(CommonState state);
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/mqtt/extend/DeviceInfoDaoExtend.java

@@ -0,0 +1,15 @@
+package com.zhongshu.iot.server.core.dao.mqtt.extend;
+
+import com.zhongshu.iot.server.core.domain.iot.mqtt.DeviceInfo;
+import com.zhongshu.iot.client.model.mqtt.DeviceInfoSearchParam;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+
+/**
+ * @Author TRX
+ * @CreateDate: 2023/7/7
+ * @Version: 1.0
+ */
+public interface DeviceInfoDaoExtend {
+    Page<DeviceInfo> page(Pageable pageable, DeviceInfoSearchParam param);
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/mqtt/extend/GateWayInfoDaoExtend.java

@@ -0,0 +1,15 @@
+package com.zhongshu.iot.server.core.dao.mqtt.extend;
+
+import com.zhongshu.iot.server.core.domain.iot.mqtt.GateWayInfo;
+import com.zhongshu.iot.client.model.mqtt.GateWayInfoSearchParam;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+
+/**
+ * @Author TRX
+ * @CreateDate: 2023/7/7
+ * @Version: 1.0
+ */
+public interface GateWayInfoDaoExtend {
+    Page<GateWayInfo> page(Pageable pageable, GateWayInfoSearchParam param);
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/mqtt/extend/GateWayUserInfoDaoExtend.java

@@ -0,0 +1,15 @@
+package com.zhongshu.iot.server.core.dao.mqtt.extend;
+
+import com.zhongshu.iot.server.core.domain.iot.mqtt.GateWayUserInfo;
+import com.zhongshu.iot.client.model.mqtt.GateWayUserInfoSearchParam;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+
+/**
+ * @Author TRX
+ * @CreateDate: 2023/7/7
+ * @Version: 1.0
+ */
+public interface GateWayUserInfoDaoExtend {
+    Page<GateWayUserInfo> page(Pageable pageable, GateWayUserInfoSearchParam param);
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/mqtt/extend/OperationLogsDaoExtend.java

@@ -0,0 +1,15 @@
+package com.zhongshu.iot.server.core.dao.mqtt.extend;
+
+import com.zhongshu.iot.server.core.domain.iot.mqtt.OperationLogs;
+import com.zhongshu.iot.client.model.operLogs.OperationLogsSearchParam;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+
+/**
+ * @Author TRX
+ * @CreateDate: 2023/7/7
+ * @Version: 1.0
+ */
+public interface OperationLogsDaoExtend {
+    Page<OperationLogs> page(Pageable pageable, OperationLogsSearchParam param);
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/mqtt/extend/OperationMessageDaoExtend.java

@@ -0,0 +1,22 @@
+package com.zhongshu.iot.server.core.dao.mqtt.extend;
+
+import com.zhongshu.iot.server.core.domain.iot.mqtt.OperationMessage;
+import com.zhongshu.iot.client.model.artemis.OperationMessageSearchParam;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+
+/**
+ * @Author TRX
+ * @CreateDate: 2023/7/7
+ * @Version: 1.0
+ */
+public interface OperationMessageDaoExtend {
+    Page<OperationMessage> page(Pageable pageable, OperationMessageSearchParam param);
+
+    OperationMessage init(String dataId, String token);
+
+    String acquire(String dataId, Long expiration);
+
+    boolean release(String dataId);
+
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/mqtt/extend/OperationMessageResultDaoExtend.java

@@ -0,0 +1,16 @@
+package com.zhongshu.iot.server.core.dao.mqtt.extend;
+
+import com.zhongshu.iot.client.model.artemis.OperationMessageResultSearch;
+import com.zhongshu.iot.server.core.domain.iot.mqtt.OperationMessageResult;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+
+/**
+ * @Author TRX
+ * @CreateDate: 2023/7/7
+ * @Version: 1.0
+ */
+public interface OperationMessageResultDaoExtend {
+    Page<OperationMessageResult> page(Pageable pageable, OperationMessageResultSearch param);
+
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/mqtt/extend/ProjectInfoDaoExtend.java

@@ -0,0 +1,15 @@
+package com.zhongshu.iot.server.core.dao.mqtt.extend;
+
+import com.zhongshu.iot.client.model.mqtt.ProjectInfoSearchParam;
+import com.zhongshu.iot.server.core.domain.iot.mqtt.ProjectInfo;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+
+/**
+ * @Author TRX
+ * @CreateDate: 2023/7/7
+ * @Version: 1.0
+ */
+public interface ProjectInfoDaoExtend {
+    Page<ProjectInfo> page(Pageable pageable, ProjectInfoSearchParam param);
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/mqtt/impl/DeviceInfoDaoImpl.java

@@ -0,0 +1,71 @@
+package com.zhongshu.iot.server.core.dao.mqtt.impl;
+
+import com.zhongshu.iot.server.core.dao.base.BaseImpl;
+import com.zhongshu.iot.server.core.dao.mqtt.extend.DeviceInfoDaoExtend;
+import com.zhongshu.iot.server.core.domain.iot.mqtt.DeviceInfo;
+import com.github.microservice.components.data.mongo.mongo.helper.DBHelper;
+import com.zhongshu.iot.client.model.mqtt.DeviceInfoSearchParam;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.util.CollectionUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Pattern;
+
+/**
+ * @Author TRX
+ * @CreateDate: 2023/4/12
+ * @Version: 1.0
+ */
+public class DeviceInfoDaoImpl extends BaseImpl implements DeviceInfoDaoExtend {
+
+    @Autowired
+    private MongoTemplate mongoTemplate;
+
+    @Autowired
+    private DBHelper dbHelper;
+
+    @Override
+    public Page<DeviceInfo> page(Pageable pageable, DeviceInfoSearchParam param) {
+        Criteria criteria = new Criteria();
+
+        if (StringUtils.isNotEmpty(param.getDeviceId())) {
+            criteria.and("deviceId").is(param.getDeviceId());
+        }
+
+        if (StringUtils.isNotEmpty(param.getEpId())) {
+            criteria.and("epId").is(param.getEpId());
+        }
+
+        // 模糊搜索
+        List<Criteria> criterias = new ArrayList<>();
+        if (StringUtils.isNotEmpty(param.getDeviceName())) {
+            Pattern pattern = Pattern.compile("^.*" + param.getDeviceName() + ".*$");
+            criterias.add(Criteria.where("deviceName").is(pattern));
+        }
+        if (!CollectionUtils.isEmpty(criterias)) {
+            criteria.andOperator(criterias.toArray(new Criteria[]{}));
+        }
+//        if (StringUtils.isNotEmpty(param.getTitle())) {
+//            Pattern pattern = Pattern.compile("^.*" + param.getTitle() + ".*$");
+//            criteria.orOperator(
+//                    Criteria.where("name").regex(pattern),
+//                    Criteria.where("content").regex(pattern)
+//            );
+//        }
+
+        criteria.and("isDelete").is(Boolean.FALSE);
+        Sort sort = buildSort(param);
+        Query query = Query.query(criteria);
+        query.with(sort);
+        return dbHelper.pages(query, pageable, DeviceInfo.class);
+    }
+
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/mqtt/impl/GateWayInfoDaoImpl.java

@@ -0,0 +1,64 @@
+package com.zhongshu.iot.server.core.dao.mqtt.impl;
+
+import com.zhongshu.iot.server.core.dao.base.BaseImpl;
+import com.zhongshu.iot.server.core.dao.mqtt.extend.GateWayInfoDaoExtend;
+import com.zhongshu.iot.server.core.domain.iot.mqtt.GateWayInfo;
+import com.github.microservice.components.data.mongo.mongo.helper.DBHelper;
+import com.zhongshu.iot.client.model.mqtt.GateWayInfoSearchParam;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.util.CollectionUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Pattern;
+
+/**
+ * @Author TRX
+ * @CreateDate: 2023/4/12
+ * @Version: 1.0
+ */
+public class GateWayInfoDaoImpl extends BaseImpl implements GateWayInfoDaoExtend {
+
+    @Autowired
+    private MongoTemplate mongoTemplate;
+
+    @Autowired
+    private DBHelper dbHelper;
+
+    @Override
+    public Page<GateWayInfo> page(Pageable pageable, GateWayInfoSearchParam param) {
+        Criteria criteria = new Criteria();
+
+        if (StringUtils.isNotEmpty(param.getGateWayId())) {
+            criteria.and("gateWayId").is(param.getGateWayId());
+        }
+
+        if (StringUtils.isNotEmpty(param.getEpId())) {
+            criteria.and("epId").is(param.getEpId());
+        }
+
+        // 模糊搜索
+        List<Criteria> criterias = new ArrayList<>();
+        if (StringUtils.isNotEmpty(param.getGateWayName())) {
+            Pattern pattern = Pattern.compile("^.*" + param.getGateWayName() + ".*$");
+            criterias.add(Criteria.where("gateWayName").is(pattern));
+        }
+        if (!CollectionUtils.isEmpty(criterias)) {
+            criteria.andOperator(criterias.toArray(new Criteria[]{}));
+        }
+
+        criteria.and("isDelete").is(Boolean.FALSE);
+        Sort sort = buildSort(param);
+        Query query = Query.query(criteria);
+        query.with(sort);
+        return dbHelper.pages(query, pageable, GateWayInfo.class);
+    }
+
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/mqtt/impl/GateWayUserInfoDaoImpl.java

@@ -0,0 +1,69 @@
+package com.zhongshu.iot.server.core.dao.mqtt.impl;
+
+import com.zhongshu.iot.server.core.dao.base.BaseImpl;
+import com.zhongshu.iot.server.core.dao.mqtt.extend.GateWayUserInfoDaoExtend;
+import com.zhongshu.iot.server.core.domain.iot.mqtt.GateWayUserInfo;
+import com.github.microservice.components.data.mongo.mongo.helper.DBHelper;
+import com.zhongshu.iot.client.model.mqtt.GateWayUserInfoSearchParam;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.util.CollectionUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Pattern;
+
+/**
+ * @Author TRX
+ * @CreateDate: 2023/4/12
+ * @Version: 1.0
+ */
+public class GateWayUserInfoDaoImpl extends BaseImpl implements GateWayUserInfoDaoExtend {
+
+    @Autowired
+    private MongoTemplate mongoTemplate;
+
+    @Autowired
+    private DBHelper dbHelper;
+
+    @Override
+    public Page<GateWayUserInfo> page(Pageable pageable, GateWayUserInfoSearchParam param) {
+        Criteria criteria = new Criteria();
+
+        if (StringUtils.isNotEmpty(param.getId())) {
+            criteria.and("id").is(param.getId());
+        }
+
+        if (param.getState() != null) {
+            criteria.and("state").is(param.getState());
+        }
+
+        if (StringUtils.isNotEmpty(param.getEpId())) {
+            criteria.and("epId").is(param.getEpId());
+        }
+
+        // 模糊搜索
+        List<Criteria> criterias = new ArrayList<>();
+        if (StringUtils.isNotEmpty(param.getUserName())) {
+            Pattern pattern = Pattern.compile("^.*" + param.getUserName() + ".*$");
+            criterias.add(Criteria.where("userName").is(pattern));
+        }
+        if (!CollectionUtils.isEmpty(criterias)) {
+            criteria.andOperator(criterias.toArray(new Criteria[]{}));
+        }
+
+        criteria.and("isDelete").is(Boolean.FALSE);
+        Sort sort = buildSort(param);
+
+        Query query = Query.query(criteria);
+        query.with(sort);
+        return dbHelper.pages(query, pageable, GateWayUserInfo.class);
+    }
+
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/mqtt/impl/OperationLogsDaoImpl.java

@@ -0,0 +1,82 @@
+package com.zhongshu.iot.server.core.dao.mqtt.impl;
+
+import com.zhongshu.iot.server.core.dao.base.BaseImpl;
+import com.zhongshu.iot.server.core.dao.mqtt.extend.OperationLogsDaoExtend;
+import com.zhongshu.iot.server.core.domain.iot.mqtt.OperationLogs;
+import com.github.microservice.components.data.mongo.mongo.helper.DBHelper;
+import com.zhongshu.iot.client.model.operLogs.OperationLogsSearchParam;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.util.CollectionUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Pattern;
+
+/**
+ * @Author TRX
+ * @CreateDate: 2023/4/12
+ * @Version: 1.0
+ */
+public class OperationLogsDaoImpl extends BaseImpl implements OperationLogsDaoExtend {
+
+    @Autowired
+    private MongoTemplate mongoTemplate;
+
+    @Autowired
+    private DBHelper dbHelper;
+
+    @Override
+    public Page<OperationLogs> page(Pageable pageable, OperationLogsSearchParam param) {
+        Criteria criteria = new Criteria();
+
+        if (StringUtils.isNotEmpty(param.getUid())) {
+            criteria.and("uid").is(param.getUid());
+        }
+
+        if (StringUtils.isNotEmpty(param.getEpId())) {
+            criteria.and("epId").is(param.getEpId());
+        }
+
+        if (param.getLevel() != null) {
+            criteria.and("level").is(param.getLevel());
+        }
+
+        // 日志关联数据ID
+        if (StringUtils.isNotEmpty(param.getDataId())) {
+            criteria.and("dataId").is(param.getDataId());
+        }
+
+        if (param.getOperationLogType() != null) {
+            criteria.and("operationLogType").is(param.getOperationLogType());
+        }
+
+        // 模糊搜索
+        List<Criteria> criterias = new ArrayList<>();
+        if (StringUtils.isNotEmpty(param.getContent())) {
+            Pattern pattern = Pattern.compile("^.*" + param.getContent() + ".*$");
+            criterias.add(Criteria.where("content").is(pattern));
+        }
+        if (StringUtils.isNotEmpty(param.getIp())) {
+            Pattern pattern = Pattern.compile("^.*" + param.getIp() + ".*$");
+            criterias.add(Criteria.where("ip").is(pattern));
+        }
+        if (!CollectionUtils.isEmpty(criterias)) {
+            criteria.andOperator(criterias.toArray(new Criteria[]{}));
+        }
+
+        criteria.and("isDelete").is(Boolean.FALSE);
+        Sort sort = buildSort(param);
+
+        Query query = Query.query(criteria);
+        query.with(sort);
+        return dbHelper.pages(query, pageable, OperationLogs.class);
+    }
+
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/mqtt/impl/OperationMessageDaoImpl.java

@@ -0,0 +1,139 @@
+package com.zhongshu.iot.server.core.dao.mqtt.impl;
+
+import com.github.microservice.components.data.mongo.mongo.helper.DBHelper;
+import com.zhongshu.iot.client.model.artemis.OperationMessageSearchParam;
+import com.zhongshu.iot.server.core.dao.base.BaseImpl;
+import com.zhongshu.iot.server.core.dao.mqtt.extend.OperationMessageDaoExtend;
+import com.zhongshu.iot.server.core.domain.iot.mqtt.OperationMessage;
+import com.zhongshu.iot.server.core.util.CommonUtil;
+import com.zhongshu.iot.server.core.util.TokenUtil;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.mongodb.core.FindAndModifyOptions;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.data.mongodb.core.query.Update;
+import org.springframework.util.CollectionUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Pattern;
+
+/**
+ * @Author TRX
+ * @CreateDate: 2023/4/12
+ * @Version: 1.0
+ */
+public class OperationMessageDaoImpl extends BaseImpl implements OperationMessageDaoExtend {
+
+    private static final Logger log = LoggerFactory.getLogger(OperationMessageDaoImpl.class);
+    @Autowired
+    private MongoTemplate mongoTemplate;
+
+    @Autowired
+    private DBHelper dbHelper;
+
+    @Override
+    public Page<OperationMessage> page(Pageable pageable, OperationMessageSearchParam param) {
+        Criteria criteria = new Criteria();
+
+        if (StringUtils.isNotEmpty(param.getDeviceId())) {
+            criteria.and("deviceId").is(param.getDeviceId());
+        }
+
+        if (StringUtils.isNotEmpty(param.getEpId())) {
+            criteria.and("epId").is(param.getEpId());
+        }
+
+        if (StringUtils.isNotEmpty(param.getGateWayId())) {
+            criteria.and("gateWayId").is(param.getGateWayId());
+        }
+
+        if (param.getIsReceive() != null && param.getIsReceive()) {
+            criteria.and("isReceive").is(param.getIsReceive());
+        }
+
+        // 时间范围
+        if (!CommonUtil.longIsEmpty(param.getStartTime()) && !CommonUtil.longIsEmpty(param.getEndTime())) {
+            criteria.and("createTime").gte(param.getStartTime()).lte(param.getEndTime());
+        }
+
+        // 模糊搜索
+        List<Criteria> criterias = new ArrayList<>();
+        if (StringUtils.isNotEmpty(param.getTopic())) {
+            Pattern pattern = Pattern.compile("^.*" + param.getTopic() + ".*$");
+            criterias.add(Criteria.where("topic").is(pattern));
+        }
+        if (!CollectionUtils.isEmpty(criterias)) {
+            criteria.andOperator(criterias.toArray(new Criteria[]{}));
+        }
+        criteria.and("isDelete").is(Boolean.FALSE);
+
+        Sort sort = buildSort(param);
+        Query query = Query.query(criteria);
+        query.with(sort);
+        return dbHelper.pages(query, pageable, OperationMessage.class);
+    }
+
+    public OperationMessage init(String dataId, String token) {
+        OperationMessage doc = null;
+        try {
+            Query query = Query.query(Criteria.where("dataId").is(dataId).and("token").isNull());
+            Update update = new Update()
+                    .set("token", token)
+                    .set("createTime", System.currentTimeMillis());
+            FindAndModifyOptions options = new FindAndModifyOptions().upsert(true)
+                    .returnNew(true);
+            doc = mongoTemplate.findAndModify(query, update, options,
+                    OperationMessage.class);
+        } catch (Exception e) {
+            log.error("init {}", e.getMessage());
+        }
+        return doc;
+    }
+
+    public String acquire(String dataId, Long expiration) {
+        Query query = Query.query(Criteria.where("dataId").is(dataId).and("token").isNull());
+        String token = TokenUtil.create();
+        Update update = new Update()
+                .set("expireAt", System.currentTimeMillis() + expiration)
+                .set("token", token);
+
+        FindAndModifyOptions options = new FindAndModifyOptions().upsert(false)
+                .returnNew(true);
+
+        OperationMessage doc = mongoTemplate.findAndModify(query, update, options,
+                OperationMessage.class);
+
+        if (doc == null) {
+            OperationMessage lockObj = mongoTemplate.findOne(Query.query(Criteria.where("dataId").is(dataId)), OperationMessage.class);
+            doc = lockObj;
+        }
+        boolean locked = doc != null && doc.getToken() != null && doc.getToken().equals(token);
+        // 如果已过期
+        if (!locked && doc != null && doc.getExpireAt() < System.currentTimeMillis()) {
+            release(dataId);
+            // 成功释放锁， 再次尝试获取锁
+            return this.acquire(dataId, expiration);
+        }
+        return locked ? token : null;
+    }
+
+    public boolean release(String dataId) {
+        Query releaseQuery = Query.query(Criteria.where("dataId").is(dataId));
+        Update releaseUpdate = new Update().set("expireAt", null).set("token", null);
+
+        FindAndModifyOptions releaseOptions = new FindAndModifyOptions().upsert(true)
+                .returnNew(true);
+        OperationMessage flowDisposition = mongoTemplate.findAndModify(releaseQuery, releaseUpdate, releaseOptions,
+                OperationMessage.class);
+        return StringUtils.isEmpty(flowDisposition.getToken());
+    }
+
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/mqtt/impl/OperationMessageResultDaoImpl.java

@@ -0,0 +1,76 @@
+package com.zhongshu.iot.server.core.dao.mqtt.impl;
+
+import com.zhongshu.iot.server.core.dao.base.BaseImpl;
+import com.zhongshu.iot.server.core.dao.mqtt.extend.OperationMessageResultDaoExtend;
+import com.github.microservice.components.data.mongo.mongo.helper.DBHelper;
+import com.zhongshu.iot.client.model.artemis.OperationMessageResultSearch;
+import com.zhongshu.iot.server.core.domain.iot.mqtt.OperationMessageResult;
+import com.zhongshu.iot.server.core.util.CommonUtil;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.util.CollectionUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Pattern;
+
+/**
+ * @Author TRX
+ * @CreateDate: 2023/4/12
+ * @Version: 1.0
+ */
+public class OperationMessageResultDaoImpl extends BaseImpl implements OperationMessageResultDaoExtend {
+
+    private static final Logger log = LoggerFactory.getLogger(OperationMessageResultDaoImpl.class);
+    @Autowired
+    private MongoTemplate mongoTemplate;
+
+    @Autowired
+    private DBHelper dbHelper;
+
+    @Override
+    public Page<OperationMessageResult> page(Pageable pageable, OperationMessageResultSearch param) {
+        Criteria criteria = new Criteria();
+
+        if (StringUtils.isNotEmpty(param.getDeviceId())) {
+            criteria.and("deviceId").is(param.getDeviceId());
+        }
+
+        if (StringUtils.isNotEmpty(param.getEpId())) {
+            criteria.and("epId").is(param.getEpId());
+        }
+
+        if (StringUtils.isNotEmpty(param.getGateWayId())) {
+            criteria.and("gateWayId").is(param.getGateWayId());
+        }
+
+        // 时间范围
+        if (!CommonUtil.longIsEmpty(param.getStartTime()) && !CommonUtil.longIsEmpty(param.getEndTime())) {
+            criteria.and("createTime").gte(param.getStartTime()).lte(param.getEndTime());
+        }
+
+        // 模糊搜索
+        List<Criteria> criterias = new ArrayList<>();
+        if (StringUtils.isNotEmpty(param.getRealIotTopic())) {
+            Pattern pattern = Pattern.compile("^.*" + param.getRealIotTopic() + ".*$");
+            criterias.add(Criteria.where("realIotTopic").is(pattern));
+        }
+        if (!CollectionUtils.isEmpty(criterias)) {
+            criteria.andOperator(criterias.toArray(new Criteria[]{}));
+        }
+        criteria.and("isDelete").is(Boolean.FALSE);
+
+        Sort sort = buildSort(param);
+        Query query = Query.query(criteria);
+        query.with(sort);
+        return dbHelper.pages(query, pageable, OperationMessageResult.class);
+    }
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/mqtt/impl/ProjectInfoDaoImpl.java

@@ -0,0 +1,65 @@
+package com.zhongshu.iot.server.core.dao.mqtt.impl;
+
+import com.zhongshu.iot.server.core.dao.base.BaseImpl;
+import com.zhongshu.iot.server.core.dao.mqtt.extend.ProjectInfoDaoExtend;
+import com.zhongshu.iot.server.core.domain.iot.mqtt.ProjectInfo;
+import com.github.microservice.components.data.mongo.mongo.helper.DBHelper;
+import com.zhongshu.iot.client.model.mqtt.ProjectInfoSearchParam;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.util.CollectionUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Pattern;
+
+/**
+ * @Author TRX
+ * @CreateDate: 2023/4/12
+ * @Version: 1.0
+ */
+public class ProjectInfoDaoImpl extends BaseImpl implements ProjectInfoDaoExtend {
+
+    @Autowired
+    private MongoTemplate mongoTemplate;
+
+    @Autowired
+    private DBHelper dbHelper;
+
+    @Override
+    public Page<ProjectInfo> page(Pageable pageable, ProjectInfoSearchParam param) {
+        Criteria criteria = new Criteria();
+
+        if (param.getState() != null) {
+            criteria.and("state").is(param.getState());
+        }
+
+        // 模糊搜索
+        List<Criteria> criterias = new ArrayList<>();
+        if (StringUtils.isNotEmpty(param.getName())) {
+            Pattern pattern = Pattern.compile("^.*" + param.getName() + ".*$");
+            criterias.add(Criteria.where("name").is(pattern));
+        }
+        if (StringUtils.isNotEmpty(param.getCode())) {
+            Pattern pattern = Pattern.compile("^.*" + param.getCode() + ".*$");
+            criterias.add(Criteria.where("code").is(pattern));
+        }
+        if (!CollectionUtils.isEmpty(criterias)) {
+            criteria.andOperator(criterias.toArray(new Criteria[]{}));
+        }
+
+        criteria.and("isDelete").is(Boolean.FALSE);
+        Sort sort = buildSort(param);
+
+        Query query = Query.query(criteria);
+        query.with(sort);
+        return dbHelper.pages(query, pageable, ProjectInfo.class);
+    }
+
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/openApi/BlackListDao.java

@@ -0,0 +1,17 @@
+package com.zhongshu.iot.server.core.dao.openApi;
+
+import com.zhongshu.iot.server.core.dao.openApi.extend.BlackListDaoExtend;
+import com.zhongshu.iot.server.core.domain.openApi.BlackList;
+
+/**
+ * @author TRX
+ * @date 2024/3/21
+ */
+public interface BlackListDao extends BlackListDaoExtend, org.springframework.data.mongodb.repository.MongoRepository<BlackList, String> {
+
+    BlackList findTopById(String id);
+
+    BlackList findTopByIp(String ip);
+
+    boolean existsByIp(String ip);
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/openApi/OpenApiRequestLogDao.java

@@ -0,0 +1,14 @@
+package com.zhongshu.iot.server.core.dao.openApi;
+
+import com.zhongshu.iot.server.core.dao.openApi.extend.OpenApiRequestLogDaoExtend;
+import com.zhongshu.iot.server.core.domain.openApi.OpenApiRequestLog;
+
+/**
+ * @author TRX
+ * @date 2024/3/21
+ */
+public interface OpenApiRequestLogDao extends OpenApiRequestLogDaoExtend, org.springframework.data.mongodb.repository.MongoRepository<OpenApiRequestLog, String> {
+
+    OpenApiRequestLog findTopById(String id);
+
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/openApi/OpenApiSignInfoDao.java

@@ -0,0 +1,17 @@
+package com.zhongshu.iot.server.core.dao.openApi;
+
+import com.zhongshu.iot.server.core.dao.openApi.extend.OpenApiSignInfoDaoExtend;
+import com.zhongshu.iot.server.core.domain.openApi.OpenApiSignInfo;
+
+/**
+ * @author TRX
+ * @date 2024/3/21
+ */
+public interface OpenApiSignInfoDao extends OpenApiSignInfoDaoExtend, org.springframework.data.mongodb.repository.MongoRepository<OpenApiSignInfo, String> {
+
+    OpenApiSignInfo findTopById(String id);
+
+    OpenApiSignInfo findTopByName(String name);
+
+    OpenApiSignInfo findTopByAppId(String appId);
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/openApi/extend/BlackListDaoExtend.java

@@ -0,0 +1,15 @@
+package com.zhongshu.iot.server.core.dao.openApi.extend;
+
+import com.zhongshu.iot.server.core.domain.openApi.BlackList;
+import com.zhongshu.iot.client.model.openApi.blackList.BlackListSearch;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+
+/**
+ * @Author TRX
+ * @CreateDate: 2023/7/7
+ * @Version: 1.0
+ */
+public interface BlackListDaoExtend {
+    Page<BlackList> page(Pageable pageable, BlackListSearch param);
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/openApi/extend/OpenApiRequestLogDaoExtend.java

@@ -0,0 +1,15 @@
+package com.zhongshu.iot.server.core.dao.openApi.extend;
+
+import com.zhongshu.iot.server.core.domain.openApi.OpenApiRequestLog;
+import com.zhongshu.iot.client.model.openApi.requestLog.OpenApiRequestLogSearch;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+
+/**
+ * @Author TRX
+ * @CreateDate: 2023/7/7
+ * @Version: 1.0
+ */
+public interface OpenApiRequestLogDaoExtend {
+    Page<OpenApiRequestLog> page(Pageable pageable, OpenApiRequestLogSearch param);
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/openApi/extend/OpenApiSignInfoDaoExtend.java

@@ -0,0 +1,15 @@
+package com.zhongshu.iot.server.core.dao.openApi.extend;
+
+import com.zhongshu.iot.server.core.domain.openApi.OpenApiSignInfo;
+import com.zhongshu.iot.client.model.openApi.sign.OpenApiSignInfoSearch;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+
+/**
+ * @Author TRX
+ * @CreateDate: 2023/7/7
+ * @Version: 1.0
+ */
+public interface OpenApiSignInfoDaoExtend {
+    Page<OpenApiSignInfo> page(Pageable pageable, OpenApiSignInfoSearch param);
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/openApi/impl/BlackListDaoImpl.java

@@ -0,0 +1,56 @@
+package com.zhongshu.iot.server.core.dao.openApi.impl;
+
+import com.zhongshu.iot.server.core.dao.base.BaseImpl;
+import com.zhongshu.iot.server.core.dao.openApi.extend.BlackListDaoExtend;
+import com.zhongshu.iot.server.core.domain.openApi.BlackList;
+import com.github.microservice.components.data.mongo.mongo.helper.DBHelper;
+import com.zhongshu.iot.client.model.openApi.blackList.BlackListSearch;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.util.CollectionUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Pattern;
+
+/**
+ * @Author TRX
+ * @CreateDate: 2023/4/12
+ * @Version: 1.0
+ */
+public class BlackListDaoImpl extends BaseImpl implements BlackListDaoExtend {
+
+    @Autowired
+    private DBHelper dbHelper;
+
+    @Override
+    public Page<BlackList> page(Pageable pageable, BlackListSearch param) {
+        Criteria criteria = new Criteria();
+
+        // 模糊搜索
+        List<Criteria> criterias = new ArrayList<>();
+        if (StringUtils.isNotEmpty(param.getIp())) {
+            Pattern pattern = Pattern.compile("^.*" + param.getIp() + ".*$");
+            criterias.add(Criteria.where("ip").is(pattern));
+        }
+
+        if (StringUtils.isNotEmpty(param.getRemark())) {
+            Pattern pattern = Pattern.compile("^.*" + param.getRemark() + ".*$");
+            criterias.add(Criteria.where("remark").is(pattern));
+        }
+        if (!CollectionUtils.isEmpty(criterias)) {
+            criteria.andOperator(criterias.toArray(new Criteria[]{}));
+        }
+        criteria.and("isDelete").is(Boolean.FALSE);
+        Sort sort = buildSort(param);
+        Query query = Query.query(criteria);
+        query.with(sort);
+        return dbHelper.pages(query, pageable, BlackList.class);
+    }
+
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/openApi/impl/OpenApiRequestLogDaoImpl.java

@@ -0,0 +1,65 @@
+package com.zhongshu.iot.server.core.dao.openApi.impl;
+
+import com.zhongshu.iot.server.core.dao.base.BaseImpl;
+import com.zhongshu.iot.server.core.dao.openApi.extend.OpenApiRequestLogDaoExtend;
+import com.zhongshu.iot.server.core.domain.openApi.OpenApiRequestLog;
+import com.github.microservice.components.data.mongo.mongo.helper.DBHelper;
+import com.zhongshu.iot.client.model.openApi.requestLog.OpenApiRequestLogSearch;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.util.CollectionUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Pattern;
+
+/**
+ * @Author TRX
+ * @CreateDate: 2023/4/12
+ * @Version: 1.0
+ */
+public class OpenApiRequestLogDaoImpl extends BaseImpl implements OpenApiRequestLogDaoExtend {
+
+    @Autowired
+    private DBHelper dbHelper;
+
+    @Override
+    public Page<OpenApiRequestLog> page(Pageable pageable, OpenApiRequestLogSearch param) {
+        Criteria criteria = buildCriteriaAboutTime(param);
+
+        // 模糊搜索
+        List<Criteria> criterias = new ArrayList<>();
+        if (StringUtils.isNotEmpty(param.getAppId())) {
+            Pattern pattern = Pattern.compile("^.*" + param.getAppId() + ".*$");
+            criterias.add(Criteria.where("appId").is(pattern));
+        }
+
+        if (StringUtils.isNotEmpty(param.getIp())) {
+            Pattern pattern = Pattern.compile("^.*" + param.getIp() + ".*$");
+            criterias.add(Criteria.where("ip").is(pattern));
+        }
+        if (StringUtils.isNotEmpty(param.getUa())) {
+            Pattern pattern = Pattern.compile("^.*" + param.getUa() + ".*$");
+            criterias.add(Criteria.where("ua").is(pattern));
+        }
+        if (StringUtils.isNotEmpty(param.getUrl())) {
+            Pattern pattern = Pattern.compile("^.*" + param.getUrl() + ".*$");
+            criterias.add(Criteria.where("url").is(pattern));
+        }
+        if (!CollectionUtils.isEmpty(criterias)) {
+            criteria.andOperator(criterias.toArray(new Criteria[]{}));
+        }
+
+        criteria.and("isDelete").is(Boolean.FALSE);
+        Sort sort = buildSort(param);
+        Query query = Query.query(criteria);
+        query.with(sort);
+        return dbHelper.pages(query, pageable, OpenApiRequestLog.class);
+    }
+
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/openApi/impl/OpenApiSignInfoDaoImpl.java

@@ -0,0 +1,65 @@
+package com.zhongshu.iot.server.core.dao.openApi.impl;
+
+import com.zhongshu.iot.server.core.dao.base.BaseImpl;
+import com.zhongshu.iot.server.core.dao.openApi.extend.OpenApiSignInfoDaoExtend;
+import com.zhongshu.iot.server.core.domain.openApi.OpenApiSignInfo;
+import com.github.microservice.components.data.mongo.mongo.helper.DBHelper;
+import com.zhongshu.iot.client.model.openApi.sign.OpenApiSignInfoSearch;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.util.CollectionUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Pattern;
+
+/**
+ * @Author TRX
+ * @CreateDate: 2023/4/12
+ * @Version: 1.0
+ */
+public class OpenApiSignInfoDaoImpl extends BaseImpl implements OpenApiSignInfoDaoExtend {
+
+    @Autowired
+    private DBHelper dbHelper;
+
+    @Override
+    public Page<OpenApiSignInfo> page(Pageable pageable, OpenApiSignInfoSearch param) {
+        Criteria criteria = new Criteria();
+
+        if (param.getAppState() != null) {
+            criteria.and("appState").is(param.getAppState());
+        }
+
+        // 模糊搜索
+        List<Criteria> criterias = new ArrayList<>();
+        if (StringUtils.isNotEmpty(param.getAppId())) {
+            Pattern pattern = Pattern.compile("^.*" + param.getAppId() + ".*$");
+            criterias.add(Criteria.where("appId").is(pattern));
+        }
+
+        if (StringUtils.isNotEmpty(param.getName())) {
+            Pattern pattern = Pattern.compile("^.*" + param.getName() + ".*$");
+            criterias.add(Criteria.where("name").is(pattern));
+        }
+        if (StringUtils.isNotEmpty(param.getAppKey())) {
+            Pattern pattern = Pattern.compile("^.*" + param.getAppKey() + ".*$");
+            criterias.add(Criteria.where("appKey").is(pattern));
+        }
+        if (!CollectionUtils.isEmpty(criterias)) {
+            criteria.andOperator(criterias.toArray(new Criteria[]{}));
+        }
+
+        criteria.and("isDelete").is(Boolean.FALSE);
+        Sort sort = buildSort(param);
+        Query query = Query.query(criteria);
+        query.with(sort);
+        return dbHelper.pages(query, pageable, OpenApiSignInfo.class);
+    }
+
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/other/ExecuteMethodInfoDao.java

@@ -0,0 +1,13 @@
+package com.zhongshu.iot.server.core.dao.other;
+
+import com.zhongshu.iot.server.core.domain.other.ExecuteMethodInfo;
+
+/**
+ * @author TRX
+ * @date 2024/3/21
+ */
+public interface ExecuteMethodInfoDao extends org.springframework.data.mongodb.repository.MongoRepository<ExecuteMethodInfo, String> {
+
+    ExecuteMethodInfo findTopByEvent(String eventName);
+
+}

OneCardIotServer/src/main/java/com/zhongshu/iot/server/core/dao/payment/RequestInfoDao.java

@@ -0,0 +1,13 @@
+package com.zhongshu.iot.server.core.dao.payment;
+
+import com.zhongshu.iot.server.core.domain.payment.RequestInfo;
+
+/**
+ * @author TRX
+ * @date 2024/3/21
+ */
+public interface RequestInfoDao extends org.springframework.data.mongodb.repository.MongoRepository<RequestInfo, String> {
+
+    RequestInfo findTopById(String id);
+
+}