创建应用的后端代码流程

参数配置首先需要创建应用
应用创建成功，前端还需要查询应用
一个查询某商户下面的应用列表
根据应用的ID查询应用

支付参数配置
1.创建应用
2.为应用绑定服务类型
3.配置支付渠道参数

package com.shanjupay.merchant.controller;

import com.shanjupay.merchant.api.AppService;
import com.shanjupay.merchant.api.dto.AppDTO;
import com.shanjupay.merchant.common.util.SecurityUtil;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.apache.dubbo.config.annotation.Reference;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**

• @author Administrator
• @version 1.0
  **/

@Api(value = “商户平台-应用管理”, tags = “商户平台-应用相关”, description = “商户平台-应用相关”)
@RestController
public class AppController {

@Reference
AppService appService;


@ApiOperation("商户创建应用")
@ApiImplicitParams({
        @ApiImplicitParam(name = "app", value = "应用信息", required = true, dataType = "AppDTO", paramType = "body")})
@PostMapping(value = "/my/apps")
public AppDTO createApp(@RequestBody AppDTO app){
    //得到商户id
    Long merchantId = SecurityUtil.getMerchantId();

   return  appService.createApp(merchantId,app);
}

@ApiOperation("查询商户下的应用列表")
@GetMapping(value = "/my/apps")
public List<AppDTO> queryMyApps() {
    //商户id
    Long merchantId = SecurityUtil.getMerchantId();
    return appService.queryAppByMerchant(merchantId);
}
@ApiOperation("根据应用id查询应用信息")
@ApiImplicitParam(value = "应用id",name = "appId",dataType = "String",paramType = "path")
@GetMapping(value = "/my/apps/{appId}")
public AppDTO getApp(@PathVariable("appId") String appId){
    return appService.getAppById(appId);
}

}

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.shanjupay.common.domain.BusinessException;
import com.shanjupay.common.domain.CommonErrorCode;
import com.shanjupay.merchant.api.AppService;
import com.shanjupay.merchant.api.dto.AppDTO;
import com.shanjupay.merchant.convert.AppCovert;
import com.shanjupay.merchant.entity.App;
import com.shanjupay.merchant.entity.Merchant;
import com.shanjupay.merchant.mapper.AppMapper;
import com.shanjupay.merchant.mapper.MerchantMapper;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;

import java.util.List;
import java.util.UUID;

/**

• @author Administrator

• @version 1.0
  **/
  @org.apache.dubbo.config.annotation.Service
  public class AppServiceImpl implements AppService {

  @Autowired
  AppMapper appMapper;

  @Autowired
  MerchantMapper merchantMapper;
  /**

  • 创建应用

  • @param merchantId 商户id

  • @param appDTO 应用信息

  • @return 创建成功的应用信息

  • @throws BusinessException
    */
    @Override
    public AppDTO createApp(Long merchantId, AppDTO appDTO) throws BusinessException {

    if(merchantIdnull || appDTO null || StringUtils.isBlank(appDTO.getAppName())){
    throw new BusinessException(CommonErrorCode.E_300009);
    }
    // 1）校验商户是否通过资质审核
    Merchant merchant = merchantMapper.selectById(merchantId);
    if(merchant == null){
    throw new BusinessException(CommonErrorCode.E_200002);
    }
    //取出商户资质申请状态
    String auditStatus = merchant.getAuditStatus();
    if(!“2”.equals(auditStatus)){
    throw new BusinessException(CommonErrorCode.E_200003);
    }

    // 应用名称需要校验唯一性
    //传入的应用名称
    String appName = appDTO.getAppName();
    Boolean existAppName = isExistAppName(appName);
    if (existAppName){
    throw new BusinessException(CommonErrorCode.E_200004);
    }

    //2）生成应用ID
    String appId = UUID.randomUUID().toString();

    App entity = AppCovert.INSTANCE.dto2entity(appDTO);
    entity.setAppId(appId);//应用id
    entity.setMerchantId(merchantId);//商户id

    //调用 appMapper向app表插入数据
    appMapper.insert(entity);

    return AppCovert.INSTANCE.entity2dto(entity);
    }

  /**

  • 根据商户id查询应用列表
  • @param merchantId
  • @return
  • @throws BusinessException
    */
    @Override
    public List queryAppByMerchant(Long merchantId) throws BusinessException {
    List apps = appMapper.selectList(new LambdaQueryWrapper().eq(App::getMerchantId, merchantId));
    return AppCovert.INSTANCE.listentity2dto(apps);
    }

  /**

  • 根据应用id查询应用信息
  • @param appId
  • @return
  • @throws BusinessException
    */
    @Override
    public AppDTO getAppById(String appId) throws BusinessException {
    App app = appMapper.selectOne(new LambdaQueryWrapper().eq(App::getAppId, appId));
    return AppCovert.INSTANCE.entity2dto(app);
    }

  //判断应用名称是否存在
  private Boolean isExistAppName(String appName){
  Integer count = appMapper.selectCount(new LambdaQueryWrapper().eq(App::getAppName, appName));
  return count >0;
  }
  }

package com.shanjupay.merchant.api.dto;

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

import java.io.Serializable;

@Data
@ApiModel(value=“AppDTO”, description="")
public class AppDTO implements Serializable {

private static final long serialVersionUID = 1L;

private String appId;

@ApiModelProperty(value = "商店名称")
private String appName;

@ApiModelProperty(value = "所属商户")
private Long merchantId;

@ApiModelProperty(value = "应用公钥(RSAWithSHA256)")
private String publicKey;

@ApiModelProperty(value = "授权回调地址")
private String notifyUrl;

}

package com.shanjupay.merchant.common.util;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.shanjupay.common.util.EncryptUtil;
import com.shanjupay.merchant.api.MerchantService;
import com.shanjupay.merchant.api.dto.MerchantDTO;
import org.springframework.util.StringUtils;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.util.Map;

/***

• 获取当前登录用户信息

• 前端配置token，后续每次请求并通过Header方式发送至后端
  */
  public class SecurityUtil {

  //测试使用
  // public static Long getMerchantId() {
  // HttpServletRequest request = ((ServletRequestAttributes) (RequestContextHolder.currentRequestAttributes()))
  // .getRequest();
  // String jsonToken = request.getHeader(“authorization”);
  // if (StringUtils.isEmpty(jsonToken) || !jsonToken.startsWith("Bearer ")) {
  // throw new RuntimeException(“token is not as expected”);
  // }
  // jsonToken = jsonToken.substring(7);
  // jsonToken = EncryptUtil.decodeUTF8StringBase64(jsonToken);
  // JSONObject jsonObject = JSON.parseObject(jsonToken);
  // return jsonObject.getLong(“merchantId”);
  // }

  public static LoginUser getUser() {
  ServletRequestAttributes servletRequestAttributes = (ServletRequestAttributes) RequestContextHolder
  .getRequestAttributes();

   if (servletRequestAttributes != null) {
   	HttpServletRequest request = servletRequestAttributes.getRequest();
  
   	Object jwt = request.getAttribute("jsonToken");
   	if (jwt instanceof LoginUser) {
   		return (LoginUser) jwt;
   	}
   }
   return new LoginUser();
  

  }

  public static Long getMerchantId(){
  MerchantService merchantService = ApplicationContextHelper.getBean(MerchantService.class);
  MerchantDTO merchant = merchantService.queryMerchantByTenantId(getUser().getTenantId());
  Long merchantId = null;
  if(merchant!=null){
  merchantId = merchant.getId();
  }
  return merchantId;
  }

  /**

  • 转换明文jsonToken为用户对象
  • @param token
  • @return
    */
    public static LoginUser convertTokenToLoginUser(String token) {
    token = EncryptUtil.decodeUTF8StringBase64(token);
    LoginUser user = new LoginUser();
    JSONObject jsonObject = JSON.parseObject(token);
    String payload = jsonObject.getString(“payload”);
    Map<String, Object> payloadMap = JSON.parseObject(payload, Map.class);
    user.setPayload(payloadMap);
    user.setClientId(jsonObject.getString(“client_id”));
    user.setMobile(jsonObject.getString(“mobile”));
    user.setUsername(jsonObject.getString(“user_name”));
    return user;
    }

}