Commit f8e72e57 authored by “yiyousong”'s avatar “yiyousong”
parents 34d95c51 3ba734db
package com.mortals.xhx.common.pdu.device;
import com.alibaba.fastjson.JSON;
import lombok.Data;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Date;
@Data
public class DeviceMsgReqPdu implements Serializable {
/**
* 设备编码
*/
private String deviceCode;
private String productCode;
private Long siteid;
/**
* 消息类型
*/
private String messageType;
/**
* 时间戳(毫秒)
*/
private Long timestamp;
/**
* 消息内容
*/
private String data;
public static void main(String[] args) {
ArrayList<DeviceMsgReqPdu> deq = new ArrayList<>();
DeviceMsgReqPdu deviceMsgReq = new DeviceMsgReqPdu();
deviceMsgReq.setDeviceCode("a1");
deviceMsgReq.setMessageType("heart_beat");
deviceMsgReq.setData("{xxxx}");
deviceMsgReq.setTimestamp(new Date().getTime());
deq.add(deviceMsgReq);
deviceMsgReq = new DeviceMsgReqPdu();
deviceMsgReq.setDeviceCode("a2");
deviceMsgReq.setMessageType("heart_beat");
deviceMsgReq.setData("{bbbbbb}");
deviceMsgReq.setTimestamp(new Date().getTime());
deq.add(deviceMsgReq);
System.out.println(JSON.toJSONString(deq));
}
}
package com.mortals.xhx.common.pdu.skin;
import java.util.Date;
import java.util.List;
import com.mortals.framework.model.BaseEntityLong;
import lombok.Data;
/**
* 系统基础皮肤Pdu对象
*
* @author zxfei
* @date 2023-04-03
*/
@Data
public class SkinBasePdu extends BaseEntityLong {
private static final long serialVersionUID = 1L;
/**
* 所属种类,来源种类
*/
private Long categoryId;
/**
* 产品id
*/
private Long productId;
/**
* 产品名称
*/
private String productName;
/**
* css模板合成后文件地址
*/
private String cssFilePath;
/**
* 排序编号
*/
private Integer sortNum;
/**
* 产品皮肤名称,唯一且不为空
*/
private String name;
/**
* 分辨率 (1.1920*1080,2.1080*1920,3.1280*1280)
*/
private String imageResolution;
/**
* 预览图片
*/
private String previewImagePath;
public void initAttrValue(){
this.categoryId = null;
this.productId = null;
this.productName = "";
this.cssFilePath = "";
this.sortNum = null;
this.name = "";
this.imageResolution = "1";
this.previewImagePath = "";
}
}
\ No newline at end of file
package com.mortals.xhx.feign.device;
import com.mortals.framework.common.Rest;
import com.mortals.xhx.common.pdu.RespData;
import com.mortals.xhx.common.pdu.device.DeviceMsgReqPdu;
import com.mortals.xhx.common.pdu.device.DevicePdu;
import com.mortals.xhx.feign.IFeign;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
* 设备 消息 Feign接口
*
* @author zxfei
* @date 2023-02-25
*/
@FeignClient(name = "device-manager", path = "/m", fallbackFactory = DeviceFeignFallbackFactory.class)
public interface IDeviceMessageFeign extends IFeign {
/**
* 设备消息通知
*
* @param devicePdu
* @return
*/
@PostMapping(value = "/api/callbackByProduct")
Rest<String> callbackByProduct(@RequestBody DeviceMsgReqPdu devicePdu);
}
@Slf4j
@Component
class DeviceMessageFeignFallbackFactory implements FallbackFactory<IDeviceMessageFeign> {
@Override
public IDeviceMessageFeign create(Throwable t) {
return new IDeviceMessageFeign() {
@Override
public Rest<String> callbackByProduct(DeviceMsgReqPdu devicePdu) {
return Rest.fail("发送消息失败,请稍后再试!");
}
};
}
}
package com.mortals.xhx.feign.skin;
import com.mortals.xhx.common.pdu.RespData;
import com.mortals.xhx.common.pdu.skin.SkinBasePdu;
import com.alibaba.fastjson.JSON;
import com.mortals.framework.common.Rest;
import com.mortals.xhx.feign.IFeign;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
* 系统基础皮肤 Feign接口
* @author zxfei
* @date 2023-04-03
*/
@FeignClient(name = "base-manager", path = "/base", fallbackFactory = SkinBaseFeignFallbackFactory.class)
public interface ISkinBaseFeign extends IFeign {
/**
* 查看系统基础皮肤列表
*
* @param skinBasePdu
* @return
*/
@PostMapping(value = "/skin/base/list")
Rest<RespData<List<SkinBasePdu>>> list(@RequestBody SkinBasePdu skinBasePdu);
/**
* 查看系统基础皮肤
*
* @param id
* @return
*/
@GetMapping(value = "/skin/base/info")
Rest<SkinBasePdu> info(@RequestParam(value = "id") Long id);
/**
* 删除系统基础皮肤
*
* @param ids
* @return
*/
@GetMapping(value = "/skin/base/delete")
Rest<Void> delete(Long[] ids,@RequestHeader("Authorization") String authorization);
/**
* 系统基础皮肤保存更新
*
* @param skinBasePdu
* @return
*/
@PostMapping(value = "/skin/base/save")
Rest<RespData<SkinBasePdu>> save(@RequestBody SkinBasePdu skinBasePdu,@RequestHeader("Authorization") String authorization);
}
@Slf4j
@Component
class SkinBaseFeignFallbackFactory implements FallbackFactory<ISkinBaseFeign> {
@Override
public ISkinBaseFeign create(Throwable t) {
return new ISkinBaseFeign() {
@Override
public Rest<RespData<List<SkinBasePdu>>> list(SkinBasePdu skinBasePdu) {
return Rest.fail("暂时无法获取系统基础皮肤列表,请稍后再试!");
}
@Override
public Rest<SkinBasePdu> info(Long id) {
return Rest.fail("暂时无法获取系统基础皮肤详细,请稍后再试!");
}
@Override
public Rest<Void> delete(Long[] ids, String authorization) {
return Rest.fail("暂时无法删除系统基础皮肤,请稍后再试!");
}
@Override
public Rest<RespData<SkinBasePdu>> save(SkinBasePdu skinBasePdu, String authorization) {
return Rest.fail("暂时无法保存系统基础皮肤,请稍后再试!");
}
};
}
}
......@@ -2805,3 +2805,179 @@ msg|String|消息|-
}
```
## 皮肤
### 查询皮肤列表
**请求URL:** skin/list
**请求方式:** POST
**内容类型:** application/json;charset=utf-8
**简要描述:** 查询皮肤
**请求参数:**
参数名称|类型|必填|描述
:---|:---|:---|:------
page|Integer|否|当前页
size|Integer|否|每页条数,值为-1,查询所有记录
userd|Integer|否|是否使用
**请求样例:**
```
{
"page":1,
"size":10,
"used":1
}
```
**响应参数:**
| 参数名称 | 参数类型 | 描述 |
|:-----------------------------|:--------|:------------------------------------------|
| code | Integer | 结果码(-1.失败,1.成功) |
| msg | String | 消息 |
| data | object | 数据对象 |
| &emsp;per_page | Integer | 每页条数 |
| &emsp;total | Integer | 总条数 |
| &emsp;last_page | Integer | 总页数 |
| &emsp;current_page | Integer | 当前页 |
| &emsp;data | array | 结果集列表 |数组
| &emsp;&emsp;id | Long | 序号,主键,自增长 |
| &emsp;&emsp;categoryId | Long | 所属种类,来源种类 |
| &emsp;&emsp;productId | Long | 产品id |
| &emsp;&emsp;productName | String | 产品名称 |
| &emsp;&emsp;cssFilePath | String | css模板合成后文件地址 |
| &emsp;&emsp;name | String | 产品皮肤名称,唯一且不为空 |
| &emsp;&emsp;imageResolution | String | 分辨率 (1.1920*1080,2.1080*1920,3.1280*1280) |
| &emsp;&emsp;previewImagePath | String | 预览图片 |
| &emsp;&emsp;sortNum | Integer | 排序编号 |
| &emsp;&emsp;used | Integer | 是否使用 |
| &emsp;&emsp;createTime | Date | 创建时间 |
| &emsp;&emsp;createUserId | Long | 创建用户 |
| &emsp;&emsp;updateTime | Date | 修改时间 |
| dict | object | 字典对象 |
| &emsp;imageResolution | object | 字典属性对象,详见附录 |
**响应消息样例:**
```
{
"code":1,
"data":{
}
}
```
### 查看皮肤
**请求URL:** skin/info
**请求方式:** GET
**内容类型:** application/json;charset=utf-8
**简要描述:** 查看皮肤,返回实例详细信息
**请求参数:**
参数名称|类型|必填|描述
:---|:---|:---|:------
id|Long|是|ID
**请求样例:**
```
http://localhost/skin/info?id=549
```
**响应参数:**
| 参数名称 | 参数类型 | 描述 |
|:-----------------------|:--------|:------------------------------------------|
| code | Integer | 结果码(-1.失败,1.成功) |
| msg | String | 消息 |
| data | object | 数据对象 |
| &emsp;id | Long | 序号,主键,自增长 |
| &emsp;categoryId | Long | 所属种类,来源种类 |
| &emsp;productId | Long | 产品id |
| &emsp;productName | String | 产品名称 |
| &emsp;cssFilePath | String | css模板合成后文件地址 |
| &emsp;name | String | 产品皮肤名称,唯一且不为空 |
| &emsp;imageResolution | String | 分辨率 (1.1920*1080,2.1080*1920,3.1280*1280) |
| &emsp;previewImagePath | String | 预览图片 |
| &emsp;sortNum | Integer | 排序编号 |
| &emsp;used | Integer | 是否使用 |
| &emsp;createTime | Date | 创建时间 |
| &emsp;createUserId | Long | 创建用户 |
| &emsp;updateTime | Date | 修改时间 |
| dict | object | 字典对象 |
| &emsp;imageResolution | object | 字典属性对象,详见附录 |
**响应消息样例:**
```
{
"code": 1,
"data": {
"id":8838,
"categoryId":483,
"productId":3204,
"productName":"cknp6t",
"cssFilePath":"ajehtm",
"name":"z8305x",
"imageResolution":"ud4cyj",
"previewImagePath":"d9yes7",
"sortNum":2831,
"used":4791,
"createTime":"2023-04-03",
"createUserId":4247,
"updateTime":"2023-04-03"
}
}
```
### 使用皮肤
**请求URL:** skin/save
**请求方式:** POST
**内容类型:** application/json;charset=utf-8
**简要描述:** 使用皮肤
**请求参数:**
| 参数名称 | 类型 | 必填 | 描述 |
|:-------|:--------|:----|:--------------|
| id | Long | 是 | 皮肤id |
| siteId | Long | 是 | 站点id |
| used | Integer | 是 | 是否使用(0.否,1.是) |
**请求样例:**
```
{
"id":1,
"siteId":1,
"used":1,
}
```
**响应参数:**
参数名称 |参数类型|描述
:---|:---|:------
code|Integer|结果码(-1.失败,1.成功)
msg|String|消息
data|object|数据对象
**响应消息样例:**
```
{
"msg":"模块成功",
"code":1,
"data":{}
}
}
```
\ No newline at end of file
......@@ -11,16 +11,21 @@ import com.mortals.xhx.common.pdu.RespData;
import com.mortals.xhx.common.pdu.device.DevicePdu;
import com.mortals.xhx.common.pdu.site.SiteMatterPdu;
import com.mortals.xhx.common.pdu.site.SitePdu;
import com.mortals.xhx.common.pdu.skin.SkinBasePdu;
import com.mortals.xhx.common.utils.BeanUtil;
import com.mortals.xhx.feign.device.IDeviceFeign;
import com.mortals.xhx.feign.site.ISiteFeign;
import com.mortals.xhx.feign.site.ISiteMatterFeign;
import com.mortals.xhx.feign.skin.ISkinBaseFeign;
import com.mortals.xhx.module.device.model.DeviceEntity;
import com.mortals.xhx.module.device.model.DeviceQuery;
import com.mortals.xhx.module.device.service.DeviceService;
import com.mortals.xhx.module.sheet.model.SheetMatterEntity;
import com.mortals.xhx.module.sheet.model.SheetMatterQuery;
import com.mortals.xhx.module.sheet.service.SheetMatterService;
import com.mortals.xhx.module.skin.model.SkinEntity;
import com.mortals.xhx.module.skin.model.SkinQuery;
import com.mortals.xhx.module.skin.service.SkinService;
import lombok.extern.slf4j.Slf4j;
import org.checkerframework.checker.units.qual.A;
import org.springframework.beans.BeanUtils;
......@@ -46,10 +51,23 @@ public class SyncSiteDeviceTaskImpl implements ITaskExcuteService {
private IDeviceFeign deviceFeign;
@Autowired
private DeviceService deviceService;
@Autowired
private SkinService skinService;
@Autowired
private ISkinBaseFeign skinBaseFeign;
@Override
public void excuteTask(ITask task) throws AppException {
log.info("开始同步设备列表!");
syncDevice();
log.info("结束同步设备列表!");
log.info("开始同步皮肤列表!");
syncSkin();
log.info("结束同步皮肤列表!");
}
private void syncDevice() {
SitePdu sitePdu = new SitePdu();
sitePdu.setId(1L);
Rest<List<SitePdu>> siteRest = siteFeign.getFlatSitesBySiteId(sitePdu);
......@@ -79,13 +97,14 @@ public class SyncSiteDeviceTaskImpl implements ITaskExcuteService {
if (oldDeviceMap.containsKey(item.getDeviceCode())) {
item.setId(oldDeviceMap.get(item.getDeviceCode()).getId());
item.setDeviceId(item.getId());
item.setProductCode(oldDeviceMap.get(item.getDeviceCode()).getProductCode());
item.setProductName(oldDeviceMap.get(item.getDeviceCode()).getProductName());
item.setUpdateTime(new Date());
return item;
}
return null;
}).filter(f -> f != null).collect(Collectors.toList());
List<DeviceEntity> saveDeviceList = newDeviceList.stream().map(item -> {
if (!oldDeviceMap.containsKey(item.getDeviceCode())) {
item.setDeviceId(item.getId());
......@@ -116,6 +135,61 @@ public class SyncSiteDeviceTaskImpl implements ITaskExcuteService {
}
}
private void syncSkin() {
SkinBasePdu skinBasePdu = new SkinBasePdu();
skinBasePdu.setProductName("样表机");
skinBasePdu.setSize(-1);
Rest<RespData<List<SkinBasePdu>>> skinBaseRest = skinBaseFeign.list(skinBasePdu);
if (skinBaseRest.getCode() == YesNoEnum.YES.getValue()) {
List<SkinBasePdu> skinBasePduList = skinBaseRest.getData().getData();
log.info("样表机皮肤总数量:{}", skinBasePduList.size());
if (!ObjectUtils.isEmpty(skinBasePduList)) {
List<SkinEntity> newSkinList = skinBasePduList.stream().map(newSkin -> {
SkinEntity skinEntity = new SkinEntity();
skinEntity.initAttrValue();
BeanUtils.copyProperties(newSkin, skinEntity, BeanUtil.getNullPropertyNames(newSkin));
return skinEntity;
}).collect(Collectors.toList());
List<SkinEntity> oldSkinList = skinService.find(new SkinQuery());
Map<Long, SkinEntity> oldSkinMap = oldSkinList.stream().collect(Collectors.toMap(x -> x.getId(), y -> y, (o, n) -> n));
List<SkinEntity> updateSkinLsit = newSkinList.stream().map(item -> {
if (oldSkinMap.containsKey(item.getId())) {
item.setUsed(oldSkinMap.get(item.getId()).getUsed());
item.setUpdateTime(new Date());
return item;
}
return null;
}).filter(f -> f != null).collect(Collectors.toList());
List<SkinEntity> saveSkinList = newSkinList.stream().map(item -> {
if (!oldSkinMap.containsKey(item.getId())) {
item.setCreateUserId(1L);
item.setCreateUserName("系统管理员");
item.setCreateTime(new Date());
return item;
}
return null;
}).filter(f -> f != null).collect(Collectors.toList());
if (!ObjectUtils.isEmpty(updateSkinLsit)) {
log.info("皮肤更新,size:{}", updateSkinLsit.size());
skinService.update(updateSkinLsit);
}
if (!ObjectUtils.isEmpty(saveSkinList)) {
log.info("皮肤新增,size:{}", saveSkinList.size());
skinService.save(saveSkinList);
}
}
}
}
@Override
public void stopTask(ITask task) throws AppException {
......
package com.mortals.xhx.module.skin.dao;
import com.mortals.framework.dao.ICRUDDao;
import com.mortals.xhx.module.skin.model.SkinEntity;
import java.util.List;
/**
* 皮肤Dao
* 皮肤 DAO接口
*
* @author zxfei
* @date 2023-04-03
*/
public interface SkinDao extends ICRUDDao<SkinEntity,Long>{
}
package com.mortals.xhx.module.skin.dao.ibatis;
import org.springframework.stereotype.Repository;
import com.mortals.xhx.module.skin.dao.SkinDao;
import com.mortals.xhx.module.skin.model.SkinEntity;
import java.util.Date;
import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis;
import java.util.List;
/**
* 皮肤DaoImpl DAO接口
*
* @author zxfei
* @date 2023-04-03
*/
@Repository("skinDao")
public class SkinDaoImpl extends BaseCRUDDaoMybatis<SkinEntity,Long> implements SkinDao {
}
package com.mortals.xhx.module.skin.model;
import java.util.List;
import java.util.ArrayList;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.mortals.framework.annotation.Excel;
import com.mortals.framework.model.BaseEntityLong;
import com.mortals.xhx.module.skin.model.vo.SkinVo;
/**
* 皮肤实体对象
*
* @author zxfei
* @date 2023-04-03
*/
public class SkinEntity extends SkinVo {
private static final long serialVersionUID = 1L;
/**
* 所属种类,来源种类
*/
private Long categoryId;
/**
* 产品id
*/
private Long productId;
/**
* 产品名称
*/
private String productName;
/**
* css模板合成后文件地址
*/
private String cssFilePath;
/**
* 产品皮肤名称,唯一且不为空
*/
private String name;
/**
* 分辨率 (1.1920*1080,2.1080*1920,3.1280*1280)
*/
private String imageResolution;
/**
* 预览图片
*/
private String previewImagePath;
/**
* 排序编号
*/
private Integer sortNum;
/**
* 是否使用
*/
private Integer used;
public SkinEntity(){}
/**
* 获取 所属种类,来源种类
* @return Long
*/
public Long getCategoryId(){
return categoryId;
}
/**
* 设置 所属种类,来源种类
* @param categoryId
*/
public void setCategoryId(Long categoryId){
this.categoryId = categoryId;
}
/**
* 获取 产品id
* @return Long
*/
public Long getProductId(){
return productId;
}
/**
* 设置 产品id
* @param productId
*/
public void setProductId(Long productId){
this.productId = productId;
}
/**
* 获取 产品名称
* @return String
*/
public String getProductName(){
return productName;
}
/**
* 设置 产品名称
* @param productName
*/
public void setProductName(String productName){
this.productName = productName;
}
/**
* 获取 css模板合成后文件地址
* @return String
*/
public String getCssFilePath(){
return cssFilePath;
}
/**
* 设置 css模板合成后文件地址
* @param cssFilePath
*/
public void setCssFilePath(String cssFilePath){
this.cssFilePath = cssFilePath;
}
/**
* 获取 产品皮肤名称,唯一且不为空
* @return String
*/
public String getName(){
return name;
}
/**
* 设置 产品皮肤名称,唯一且不为空
* @param name
*/
public void setName(String name){
this.name = name;
}
/**
* 获取 分辨率 (1.1920*1080,2.1080*1920,3.1280*1280)
* @return String
*/
public String getImageResolution(){
return imageResolution;
}
/**
* 设置 分辨率 (1.1920*1080,2.1080*1920,3.1280*1280)
* @param imageResolution
*/
public void setImageResolution(String imageResolution){
this.imageResolution = imageResolution;
}
/**
* 获取 预览图片
* @return String
*/
public String getPreviewImagePath(){
return previewImagePath;
}
/**
* 设置 预览图片
* @param previewImagePath
*/
public void setPreviewImagePath(String previewImagePath){
this.previewImagePath = previewImagePath;
}
/**
* 获取 排序编号
* @return Integer
*/
public Integer getSortNum(){
return sortNum;
}
/**
* 设置 排序编号
* @param sortNum
*/
public void setSortNum(Integer sortNum){
this.sortNum = sortNum;
}
/**
* 获取 是否使用
* @return Integer
*/
public Integer getUsed(){
return used;
}
/**
* 设置 是否使用
* @param used
*/
public void setUsed(Integer used){
this.used = used;
}
@Override
public int hashCode() {
return this.getId().hashCode();
}
@Override
public boolean equals(Object obj) {
if (obj == null) return false;
if (obj instanceof SkinEntity) {
SkinEntity tmp = (SkinEntity) obj;
if (this.getId() == tmp.getId()) {
return true;
}
}
return false;
}
public String toString(){
StringBuilder sb = new StringBuilder("");
sb.append(",categoryId:").append(getCategoryId());
sb.append(",productId:").append(getProductId());
sb.append(",productName:").append(getProductName());
sb.append(",cssFilePath:").append(getCssFilePath());
sb.append(",name:").append(getName());
sb.append(",imageResolution:").append(getImageResolution());
sb.append(",previewImagePath:").append(getPreviewImagePath());
sb.append(",sortNum:").append(getSortNum());
sb.append(",used:").append(getUsed());
return sb.toString();
}
public void initAttrValue(){
this.categoryId = null;
this.productId = null;
this.productName = null;
this.cssFilePath = null;
this.name = null;
this.imageResolution = null;
this.previewImagePath = null;
this.sortNum = null;
this.used = 0;
}
}
\ No newline at end of file
package com.mortals.xhx.module.skin.model.vo;
import com.mortals.framework.model.BaseEntityLong;
import com.mortals.xhx.module.skin.model.SkinEntity;
import java.util.ArrayList;
import java.util.List;
import lombok.Data;
/**
* 皮肤视图对象
*
* @author zxfei
* @date 2023-04-03
*/
@Data
public class SkinVo extends BaseEntityLong {
private Long siteId;
}
\ No newline at end of file
package com.mortals.xhx.module.skin.service;
import com.mortals.framework.service.ICRUDService;
import com.mortals.xhx.module.skin.model.SkinEntity;
/**
* SkinService
*
* 皮肤 service接口
*
* @author zxfei
* @date 2023-04-03
*/
public interface SkinService extends ICRUDService<SkinEntity,Long>{
}
\ No newline at end of file
package com.mortals.xhx.module.skin.service.impl;
import com.alibaba.fastjson.JSON;
import com.fasterxml.jackson.annotation.JsonAlias;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.mortals.framework.common.Rest;
import com.mortals.xhx.common.code.YesNoEnum;
import com.mortals.xhx.common.pdu.device.DeviceMsgReqPdu;
import com.mortals.xhx.feign.device.IDeviceMessageFeign;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.mortals.framework.service.impl.AbstractCRUDServiceImpl;
import com.mortals.framework.exception.AppException;
import com.mortals.framework.model.Context;
import com.mortals.xhx.module.skin.dao.SkinDao;
import com.mortals.xhx.module.skin.model.SkinEntity;
import com.mortals.xhx.module.skin.service.SkinService;
/**
* SkinService
* 皮肤 service实现
*
* @author zxfei
* @date 2023-04-03
*/
@Service("skinService")
@Slf4j
public class SkinServiceImpl extends AbstractCRUDServiceImpl<SkinDao, SkinEntity, Long> implements SkinService {
@Autowired
private IDeviceMessageFeign deviceMessageFeign;
@Override
protected void updateBefore(SkinEntity entity, Context context) throws AppException {
super.updateBefore(entity, context);
if(YesNoEnum.YES.getValue()==entity.getUsed()){
//修改非当前皮肤都未未使用
SkinEntity skinEntity = new SkinEntity();
skinEntity.setUsed(YesNoEnum.NO.getValue());
SkinEntity condition = new SkinEntity();
condition.setUsed(YesNoEnum.YES.getValue());
this.updateBatch(skinEntity,condition,context);
}
}
@Override
protected void updateAfter(SkinEntity entity, Context context) throws AppException {
super.updateAfter(entity, context);
//推送皮肤更新消息
DeviceMsgReqPdu deviceMsgReqPdu = new DeviceMsgReqPdu();
deviceMsgReqPdu.setSiteid(entity.getSiteId());
deviceMsgReqPdu.setProductCode("ybj");
deviceMsgReqPdu.setMessageType("edition");
deviceMsgReqPdu.setData("W10=");
deviceMsgReqPdu.setTimestamp(System.currentTimeMillis());
Rest<String> rest = deviceMessageFeign.callbackByProduct(deviceMsgReqPdu);
log.info("send device message==>{}", JSON.toJSONString(rest));
}
}
\ No newline at end of file
package com.mortals.xhx.module.skin.web;
import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
import com.mortals.xhx.base.system.param.service.ParamService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.*;
import com.mortals.framework.model.Context;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
import com.mortals.xhx.module.skin.model.SkinEntity;
import com.mortals.xhx.module.skin.service.SkinService;
import org.apache.commons.lang3.ArrayUtils;
import com.mortals.framework.util.StringUtils;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import com.alibaba.fastjson.JSONObject;
import java.util.Arrays;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import static com.mortals.framework.ap.SysConstains.*;
/**
*
* 皮肤
*
* @author zxfei
* @date 2023-04-03
*/
@RestController
@RequestMapping("skin")
public class SkinController extends BaseCRUDJsonBodyMappingController<SkinService,SkinEntity,Long> {
@Autowired
private ParamService paramService;
public SkinController(){
super.setModuleDesc( "皮肤");
}
@Override
protected void init(Map<String, Object> model, Context context) {
this.addDict(model, "imageResolution", paramService.getParamBySecondOrganize("Skin","imageResolution"));
this.addDict(model, "used", paramService.getParamBySecondOrganize("Skin","used"));
super.init(model, context);
}
}
\ No newline at end of file
###登录
POST {{baseUrl}}/login/login
Content-Type: application/json
{
"loginName":"admin",
"password":"admin",
"securityCode":"8888"
}
> {%
client.global.set("SmsSet_id", JSON.parse(response.body).data.id);
client.global.set("authToken", JSON.parse(response.body).data.token);
%}
###皮肤列表
POST {{baseUrl}}/skin/list
Authorization: {{authToken}}
Content-Type: application/json
{
"page":1,
"size":10
}
###皮肤更新与保存
POST {{baseUrl}}/skin/save
Authorization: {{authToken}}
Content-Type: application/json
{
"categoryId":569,
"productId":235,
"productName":"uoas3g",
"cssFilePath":"tbxisl",
"name":"u7z7wf",
"imageResolution":"x7x69v",
"previewImagePath":"4mjx38",
"sortNum":925,
"used":0,
}
> {%
client.global.set("Skin_id", JSON.parse(response.body).data.id);
%}
###皮肤查看
GET {{baseUrl}}/skin/info?id={{Skin_id}}
Authorization: {{authToken}}
Accept: application/json
###皮肤编辑
GET {{baseUrl}}/skin/edit?id={{Skin_id}}
Authorization: {{authToken}}
Accept: application/json
###皮肤删除
GET {{baseUrl}}/skin/delete?id={{Skin_id}}
Authorization: {{authToken}}
Accept: application/json
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment