Merge branch 'master' of ssh://xmgit.ixm5.cn:10022/xiamai-test/xm-sportstest

module/polar/数据中心.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">
+<suite name="数据中心场景case"> <!--  起一个好听且唯一的名字-->
+
+    <test name="数据中心模块测试" preserve-order="true" verbose="3"> <!--  再起一个听且唯一的名字 -->
+        <packages>
+            <package name="com.xiaomai.cases.polar.data.*"></package> <!-- 添加自己想要集成测试的case 范围自己定  -->
+        </packages>
+    </test>
+    <listeners>
+        <listener class-name="com.xiaomai.client.RetryListener" />
+        <listener class-name="com.xiaomai.client.TestListener" />
+        <listener class-name="com.xiaomai.client.ExtentTestNGIReporterListener"/>
+    </listeners>
+</suite>
\ No newline at end of file

src/main/java/com/xiaomai/cases/polar/data/financeData/FinanceDataTools.java

+package com.xiaomai.cases.polar.data.financeData;
+
+import com.alibaba.fastjson.JSONObject;
+import com.xiaomai.client.DataUserInfo;
+import com.xiaomai.enums.ApiModule;
+import com.xiaomai.enums.RequestType;
+import com.xiaomai.enums.Terminal;
+import com.xiaomai.utils.TimeUtils;
+import com.xiaomai.utils.XMBaseTest;
+
+public class FinanceDataTools extends XMBaseTest {
+
+    /**
+     * @param
+     * @description:获取数据中心-财务数据-订单数据
+     * @param dateType：时间类型：[ DAY, WEEK, MONTH, QUARTER, YEAR ]
+     * @param startTime：开始时间
+     * @param endTime:结束时间  注意：使用这个方法只能搜按天和按月，因为参数类型这里写的long 其他几个不是long型，会用不了
+     * @author: yangfangfang
+     **/
+    public JSONObject getOrderData(String dateType,long startTime, long endTime,  DataUserInfo...dataUserInfos){
+
+        dataApi.setApiModule(ApiModule.Polar_Data)
+                .setApiName("API_getOrderData")
+                .setTerminal(Terminal.B);
+        super.beforeDataRequest(dataUserInfos);
+
+        JSONObject getOrderData=new JSONObject();
+        getOrderData.put("dateType",dateType);
+        getOrderData.put("endTime",endTime );
+        getOrderData.put("startTime",startTime);
+        getOrderData.put("brandId",xmAppApi.getLoginInfo().getBrandId());
+        getOrderData.put("studioId",xmAppApi.getLoginInfo().getStudioId());
+        getOrderData.put("operatorId",xmAppApi.getLoginInfo().getAdminId());
+
+        dataApi.doRequest(RequestType.JSON, dataparams, getOrderData.toJSONString(), dataheadrs).assetsSuccess(true);
+        JSONObject response=dataApi.getBodyInJSON();
+        return response;
+    }
+
+
+    /**
+     * @param
+     * @description:获取数据中心-财务数据-订单趋势图
+     * @param dateType：时间类型：[ DAY, WEEK, MONTH, QUARTER, YEAR ]
+     * @param metric：[ "订单应收金额", "订单实收金额", "欠费金额", "实退金额" ]指标[ ORDER_RECEIVABLE_AMOUNT, ORDER_ACTUAL_AMOUNT, ORDER_UNPAID_AMOUNT, ORDER_REFUND_AMOUNT ]
+     * @param startTime：开始时间
+     * @param endTime:结束时间  注意：使用这个方法只能搜按天和按月，因为参数类型这里写的long 其他几个不是long型，会用不了
+     * @author: yangfangfang
+     **/
+    public JSONObject getOrderTrend(String dateType,String metric,long endTime,long startTime, DataUserInfo...dataUserInfos){
+
+        dataApi.setApiModule(ApiModule.Polar_Data)
+                .setApiName("API_getOrderTrend")
+                .setTerminal(Terminal.B);
+        super.beforeDataRequest(dataUserInfos);
+
+        JSONObject trend=new JSONObject();
+        trend.put("dateType",dateType);
+        trend.put("endTime", endTime);
+        trend.put("startTime", startTime);
+        trend.put("metric",metric);
+        trend.put("brandId",xmAppApi.getLoginInfo().getBrandId());
+        trend.put("studioId",xmAppApi.getLoginInfo().getStudioId());
+        trend.put("operatorId",xmAppApi.getLoginInfo().getAdminId());
+
+        dataApi.doRequest(RequestType.JSON, dataparams, trend.toJSONString(), dataheadrs).assetsSuccess(true);
+        JSONObject response=dataApi.getBodyInJSON();
+        return response;
+    }
+
+}

src/main/java/com/xiaomai/cases/polar/data/financeData/TestGetOrderData.java

+package com.xiaomai.cases.polar.data.financeData;
+
+import com.alibaba.fastjson.JSONObject;
+import com.xiaomai.cases.polar.finance.order.OrderTools;
+import com.xiaomai.cases.polar.member.Tools;
+import com.xiaomai.cases.polar.memberCard.CardTools;
+import com.xiaomai.enums.ApiModule;
+import com.xiaomai.enums.LoginAccount;
+import com.xiaomai.enums.RequestType;
+import com.xiaomai.enums.Terminal;
+import com.xiaomai.utils.RandomStringUtil;
+import com.xiaomai.utils.TimeUtils;
+import com.xiaomai.utils.XMBaseTest;
+import org.testng.Assert;
+import org.testng.annotations.BeforeMethod;
+import org.testng.annotations.Test;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+
+public class TestGetOrderData extends XMBaseTest {
+
+    OrderTools orderTools = new OrderTools();
+    Tools tools = new Tools();
+
+    CardTools cardTools=new CardTools();
+
+    FinanceDataTools financeDataTools=new FinanceDataTools();
+
+    String memberId;
+    String cardId;
+
+
+    @BeforeMethod
+    public void beforeTest(){
+        xmAppApi.setApiModule(ApiModule.Polar_Data)
+                .setApiName("API_getOrderData")
+                .setLoginUser(LoginAccount.GYM_PROD)
+                .setTerminal(Terminal.B);
+
+        dal.setCase_owner("yff")
+                .setCase_name(Thread.currentThread().getStackTrace()[1].getFileName().split("\\.")[0]);
+        super.beforeTest();
+    }
+
+    @Test(description = "获取数据中心-财务数据-订单数据")
+    public void testGetOrderData(){
+
+
+
+        //先查一下数据中心-财务数据-订单数据汇总
+        JSONObject beforeGetOrderData=financeDataTools.getOrderData("DAY",TimeUtils.getTodayTime(),TimeUtils.getTodayEndTime());
+        BigDecimal beforeActualAmount=new BigDecimal(beforeGetOrderData.getJSONObject("result").getString("actualAmount"));//实收金额
+        BigDecimal beforeReceivableAmount=new BigDecimal(beforeGetOrderData.getJSONObject("result").getString("receivableAmount"));//应收金额
+        BigDecimal beforeRefundAmount=new BigDecimal(beforeGetOrderData.getJSONObject("result").getString("refundAmount"));//退款金额
+        BigDecimal beforeUnpaidAmount=new BigDecimal(beforeGetOrderData.getJSONObject("result").getString("unpaidAmount"));//欠费金额
+
+        try {
+            Thread.sleep(3000);
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+
+        //①创建部分支付订单，订单应收金额、订单实收金额和欠费金额应增加对应的数据
+        //造订单相关数据
+        String name = "创建订单潜在会员"+ RandomStringUtil.randomString(3);
+        String phone = RandomStringUtil.randomMobile("666");
+
+        //获取会员ID,没有则新建一个
+        int memberTotal = Integer.parseInt(tools.search("NORMAL","NORMAL").getJSONObject("result").getString("total"));
+        if (memberTotal == 0) {
+            memberId = tools.create(name,phone).getString("result");
+        }
+        memberId=tools.search("NORMAL","NORMAL").getJSONObject("result").getJSONArray("records").getJSONObject(0).getString("id");
+
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+
+        //获取会员卡信息
+        //获取会员卡列表,没有则新建一个
+        int cardTotal = Integer.parseInt(orderTools.fetchPageOfMemberCard("次卡").getJSONObject("result").getString("total"));
+        if (cardTotal == 0) {
+            cardId = cardTools.memberCardCreate("次卡-创建订单会员卡"+TimeUtils.getCurrentTime()).getString("result");
+        }
+        JSONObject memberCard=orderTools.fetchPageOfMemberCard("次卡");
+        cardId=memberCard.getJSONObject("result").getJSONArray("records").getJSONObject(0).getString("id");
+        BigDecimal quantity= new BigDecimal(memberCard.getJSONObject("result").getJSONArray("records").getJSONObject(0).getString("balance"));
+        float price= Float.parseFloat(memberCard.getJSONObject("result").getJSONArray("records").getJSONObject(0).getString("price"));
+        int validPeriod= Integer.parseInt(memberCard.getJSONObject("result").getJSONArray("records").getJSONObject(0).getString("validPeriod"));
+
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+
+        //获取签单要用的卡快照id
+        String latestSnapshotId=orderTools.fetchDetailById(cardId,xmAppApi.getLoginInfo().getBrandId(),xmAppApi.getLoginInfo().getStudioId(),xmAppApi.getLoginInfo().getAdminId()).getJSONObject("result").getString("latestSnapshotId");
+
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+
+        //检查会员对该卡是否超出购买上限
+        boolean limitResult=orderTools.checkAllowPurchase("MEMBER_CARD",cardId,memberId,"1",xmAppApi.getLoginInfo().getBrandId(),xmAppApi.getLoginInfo().getStudioId(),xmAppApi.getLoginInfo().getAdminId()).getBoolean("success");
+
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+
+        if(limitResult == true) {
+
+            //创建部分支付订单
+            JSONObject orderResult = orderTools.signOrder(cardId, latestSnapshotId, quantity, price, validPeriod, latestSnapshotId, 0, "PURCHASE",
+                    "MEMBER_CARD", memberId, price, price / 2, "1");
+            String getDetailId = orderResult.getString("result");
+
+            try {
+                Thread.sleep(1000);
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            }
+
+            //获取订单详情
+            JSONObject getDetailResult = orderTools.getDetail(getDetailId);
+            BigDecimal receivableAmount = new BigDecimal(getDetailResult.getJSONObject("result").getString("receivableAmount"));//应收金额
+            BigDecimal paidAmount = new BigDecimal(getDetailResult.getJSONObject("result").getString("paidAmount"));//已支付金额
+            BigDecimal unpaidAmount = new BigDecimal(getDetailResult.getJSONObject("result").getString("unpaidAmount"));//欠费金额
+
+
+            try {
+                Thread.sleep(3000);
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            }
+
+
+            JSONObject getOrderData = new JSONObject();
+            getOrderData.put("dateType", "DAY");
+            getOrderData.put("endTime", TimeUtils.getTodayEndTime());
+            getOrderData.put("startTime", TimeUtils.getTodayTime());
+            getOrderData.put("brandId", xmAppApi.getLoginInfo().getBrandId());
+            getOrderData.put("studioId", xmAppApi.getLoginInfo().getStudioId());
+            getOrderData.put("operatorId", xmAppApi.getLoginInfo().getAdminId());
+
+            xmAppApi.doRequest(RequestType.JSON, params, getOrderData.toJSONString(), headers).assetsSuccess(true);
+            JSONObject getOrderDataResult = xmAppApi.getBodyInJSON();
+            BigDecimal afterActualAmount=new BigDecimal(getOrderDataResult.getJSONObject("result").getString("actualAmount"));//实收金额
+            BigDecimal afterReceivableAmount=new BigDecimal(getOrderDataResult.getJSONObject("result").getString("receivableAmount"));//应收金额
+            BigDecimal afterRefundAmount=new BigDecimal(getOrderDataResult.getJSONObject("result").getString("refundAmount"));//退款金额
+            BigDecimal afterUnpaidAmount=new BigDecimal(getOrderDataResult.getJSONObject("result").getString("unpaidAmount"));//欠费金额
+            Assert.assertEquals(getOrderDataResult.getString("success"), "true", "获取销售数据-数据分析-汇总失败");
+
+            //校验新增部分支付订单之后，订单应收金额、订单实收金额、欠费金额有没有增加
+            Assert.assertEquals(afterReceivableAmount, beforeReceivableAmount.add(receivableAmount.setScale(2, RoundingMode.HALF_UP)),"创建部分支付订单，数据中心-订单数据汇总没有增加对应的应收金额");
+            Assert.assertEquals(afterActualAmount,beforeActualAmount.add(paidAmount.setScale(2,RoundingMode.HALF_UP)),"创建部分支付订单，数据中心-订单数据汇总没有增加对应的实收金额");
+            Assert.assertEquals(afterUnpaidAmount, beforeUnpaidAmount.add(unpaidAmount.setScale(2,RoundingMode.HALF_UP)),"创建部分支付订单，数据中心-订单数据汇总没有增加对应的欠费金额");
+
+
+
+            //②创建部分支付订单，订单实收金额应增加继续收款金额，欠费金额应减少继续收款金额
+            //继续收款
+            JSONObject pay=orderTools.pay(unpaidAmount,"1",getDetailId);
+
+            //获取订单详情
+            JSONObject getDetailResult1 = orderTools.getDetail(getDetailId);
+            BigDecimal receivableAmount1 = new BigDecimal(getDetailResult1.getJSONObject("result").getString("receivableAmount"));//应收金额
+            BigDecimal paidAmount1 = new BigDecimal(getDetailResult1.getJSONObject("result").getString("paidAmount"));//已支付金额
+
+
+            try {
+                Thread.sleep(3000);
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            }
+
+            //校验继续收款后欠费金额-继续收款支付金额，实收金额+继续收款支付金额
+            JSONObject afterGetOrderData1=financeDataTools.getOrderData("DAY",TimeUtils.getTodayTime(),TimeUtils.getTodayEndTime());
+            BigDecimal afterActualAmount1=new BigDecimal(afterGetOrderData1.getJSONObject("result").getString("actualAmount"));//实收金额
+            BigDecimal afterReceivableAmount1=new BigDecimal(afterGetOrderData1.getJSONObject("result").getString("receivableAmount"));//应收金额
+            BigDecimal afterRefundAmount1=new BigDecimal(afterGetOrderData1.getJSONObject("result").getString("refundAmount"));//退款金额
+            BigDecimal afterUnpaidAmount1=new BigDecimal(afterGetOrderData1.getJSONObject("result").getString("unpaidAmount"));//欠费金额
+
+            Assert.assertEquals(afterActualAmount1,afterActualAmount.add(unpaidAmount.setScale(2,RoundingMode.HALF_UP)),"继续收款后，订单实收金额未增加继续收款支付金额");
+            Assert.assertEquals(afterUnpaidAmount1,afterUnpaidAmount.subtract(unpaidAmount.setScale(2,RoundingMode.HALF_UP)),"继续收款后，欠费金额未减少继续收款支付金额");
+
+
+
+            //③退单之后，退款金额应增加实退金额，其余金额不变
+            //退单
+            //查询要退的卡id 从listUserRefundableCard-查询用户可退的会员卡列表中获取
+
+            JSONObject listUserRefundableCardResult=orderTools.listUserRefundableCard("MEMBER","",memberId);
+            String listUserRefundableId=listUserRefundableCardResult.getJSONArray("result").getJSONObject(0).getString("id");
+
+
+            //查询订单或者收支可退流水金额（包含乐动收银状态信息）
+            boolean checkRefundableAmountResult=orderTools.checkRefundableAmount(getDetailId,price - price / 2).getBoolean("success");
+
+            try {
+                Thread.sleep(3000);
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            }
+
+            if(checkRefundableAmountResult == true) {
+
+                //退单-会员卡
+                JSONObject refundOrderResult = orderTools.refundOrder(0, listUserRefundableId, quantity, price , "MEMBER_CARD",
+                        memberId, price, price , "1");
+                String refundOrderGetDetailId = refundOrderResult.getString("result");//退单订单ID
+
+                try {
+                    Thread.sleep(3000);
+                } catch (InterruptedException e) {
+                    throw new RuntimeException(e);
+                }
+
+                //获取退单订单详情
+                JSONObject refundOrderGetDetailResult = orderTools.getDetail(refundOrderGetDetailId);
+                BigDecimal refundOrderReceivableAmount = new BigDecimal(refundOrderGetDetailResult.getJSONObject("result").getString("receivableAmount"));//退单订单的应退金额
+                BigDecimal refundOrderPaidAmount = new BigDecimal(refundOrderGetDetailResult.getJSONObject("result").getString("paidAmount"));//退单订单的实退金额
+
+                try {
+                    Thread.sleep(3000);
+                } catch (InterruptedException e) {
+                    throw new RuntimeException(e);
+                }
+
+                //校验退单之后，退款金额+实退金额，其余金额不变
+                //获取财务中心-订单数据-汇总
+                JSONObject afterGetOrderData2=financeDataTools.getOrderData("DAY",TimeUtils.getTodayTime(),TimeUtils.getTodayEndTime());
+                BigDecimal afterActualAmount2=new BigDecimal(afterGetOrderData2.getJSONObject("result").getString("actualAmount"));//实收金额
+                BigDecimal afterReceivableAmount2=new BigDecimal(afterGetOrderData2.getJSONObject("result").getString("receivableAmount"));//应收金额
+                BigDecimal afterRefundAmount2=new BigDecimal(afterGetOrderData2.getJSONObject("result").getString("refundAmount"));//退款金额
+                BigDecimal afterUnpaidAmount2=new BigDecimal(afterGetOrderData2.getJSONObject("result").getString("unpaidAmount"));//欠费金额
+
+                Assert.assertEquals(afterActualAmount2,afterActualAmount1,"退单后，订单实收金额应不变");
+                Assert.assertEquals(afterReceivableAmount2,afterReceivableAmount1,"退单后，订单应收金额应不变");
+                Assert.assertEquals(afterRefundAmount2,afterRefundAmount1.add(refundOrderPaidAmount.setScale(2,RoundingMode.HALF_UP)),"退单后，退款金额未增加");
+                Assert.assertEquals(afterUnpaidAmount2,afterUnpaidAmount1,"退单后，欠费金额应不变");
+
+
+
+                //④退单订单作废-退款金额减掉实退金额，其余金额不变
+                //退单订单作废
+                //校验是否可以作废退单订单
+                boolean checkDiscardRefundVoucherResult = orderTools.checkDiscardVoucher(refundOrderGetDetailId).getBoolean("success");
+
+                try {
+                    Thread.sleep(1000);
+                } catch (InterruptedException e) {
+                    throw new RuntimeException(e);
+                }
+
+                if (checkDiscardRefundVoucherResult == true) {
+                    //作废退单订单
+                    JSONObject refundDiscardResult = orderTools.discard(refundOrderGetDetailId, "重复录入", "已作废退单订单" + RandomStringUtil.randomString(10));
+
+
+                    //获取财务中心-订单数据-汇总
+                    JSONObject afterGetOrderData3 = financeDataTools.getOrderData("DAY", TimeUtils.getTodayTime(), TimeUtils.getTodayEndTime());
+                    BigDecimal afterActualAmount3 = new BigDecimal(afterGetOrderData3.getJSONObject("result").getString("actualAmount"));//实收金额
+                    BigDecimal afterReceivableAmount3 = new BigDecimal(afterGetOrderData3.getJSONObject("result").getString("receivableAmount"));//应收金额
+                    BigDecimal afterRefundAmount3 = new BigDecimal(afterGetOrderData3.getJSONObject("result").getString("refundAmount"));//退款金额
+                    BigDecimal afterUnpaidAmount3 = new BigDecimal(afterGetOrderData3.getJSONObject("result").getString("unpaidAmount"));//欠费金额
+
+                    //校验：
+                    Assert.assertEquals(afterActualAmount3, afterActualAmount2, "退单订单作废后，订单实收金额应不变");
+                    Assert.assertEquals(afterReceivableAmount3, afterReceivableAmount2, "退单订单作废后，订单应收金额应不变");
+                    Assert.assertEquals(afterRefundAmount3, afterRefundAmount2.subtract(refundOrderPaidAmount.setScale(2, RoundingMode.HALF_UP)), "退单订单作废后，退款金额未减少");
+                    Assert.assertEquals(afterUnpaidAmount3, afterUnpaidAmount2, "退单订单作废后，欠费金额应不变");
+
+
+                    //⑤签单订单作废，订单应收金额和订单实收金额应减少，其余金额不变
+                    //签单订单作废
+                    //校验是否可以作废签单订单
+                    boolean checkDiscardSignVoucherResult = orderTools.checkDiscardVoucher(getDetailId).getBoolean("success");
+
+                    try {
+                        Thread.sleep(1000);
+                    } catch (InterruptedException e) {
+                        throw new RuntimeException(e);
+                    }
+
+                    if (checkDiscardSignVoucherResult == true) {
+
+                        //作废签单订单
+                        JSONObject discardResult = orderTools.discard(getDetailId, "重复录入", "已作废签单订单" + RandomStringUtil.randomString(10));
+                    }
+                    try {
+                        Thread.sleep(3000);
+                    } catch (InterruptedException e) {
+                        throw new RuntimeException(e);
+                    }
+
+
+                    //获取财务中心-订单数据-汇总
+                    JSONObject afterGetOrderData4 = financeDataTools.getOrderData("DAY", TimeUtils.getTodayTime(), TimeUtils.getTodayEndTime());
+                    BigDecimal afterActualAmount4 = new BigDecimal(afterGetOrderData4.getJSONObject("result").getString("actualAmount"));//实收金额
+                    BigDecimal afterReceivableAmount4 = new BigDecimal(afterGetOrderData4.getJSONObject("result").getString("receivableAmount"));//应收金额
+                    BigDecimal afterRefundAmount4 = new BigDecimal(afterGetOrderData4.getJSONObject("result").getString("refundAmount"));//退款金额
+                    BigDecimal afterUnpaidAmount4 = new BigDecimal(afterGetOrderData4.getJSONObject("result").getString("unpaidAmount"));//欠费金额
+
+                    //校验：
+                    Assert.assertEquals(afterActualAmount4, afterActualAmount3.subtract(paidAmount1.setScale(2,RoundingMode.HALF_UP)), "签单订单作废后，订单实收金额未减少");
+                    Assert.assertEquals(afterReceivableAmount4, afterReceivableAmount3.subtract(receivableAmount1.setScale(2,RoundingMode.HALF_UP)), "签单订单作废后，订单应收金额未减少");
+                    Assert.assertEquals(afterRefundAmount4, afterRefundAmount3, "签单订单作废后，退款金额应不变");
+                    Assert.assertEquals(afterUnpaidAmount4, afterUnpaidAmount3, "签单订单作废后，欠费金额应不变");
+
+
+                }
+            }
+        }
+    }
+}

src/main/java/com/xiaomai/cases/polar/data/financeData/TestGetOrderTrend.java

+package com.xiaomai.cases.polar.data.financeData;
+
+import com.alibaba.fastjson.JSONObject;
+import com.xiaomai.enums.ApiModule;
+import com.xiaomai.enums.LoginAccount;
+import com.xiaomai.enums.RequestType;
+import com.xiaomai.enums.Terminal;
+import com.xiaomai.utils.TimeUtils;
+import com.xiaomai.utils.XMBaseTest;
+import org.testng.Assert;
+import org.testng.annotations.BeforeMethod;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+public class TestGetOrderTrend extends XMBaseTest {
+
+    @BeforeMethod
+    public void beforeTest(){
+        xmAppApi.setApiModule(ApiModule.Polar_Data)
+                .setApiName("API_getOrderTrend")
+                .setLoginUser(LoginAccount.GYM_PROD)
+                .setTerminal(Terminal.B);
+
+        dal.setCase_owner("yff")
+                .setCase_name(Thread.currentThread().getStackTrace()[1].getFileName().split("\\.")[0]);
+        super.beforeTest();
+    }
+
+    @DataProvider
+    public Object[][] dataProvider(){
+        return new Object[][]{
+
+                {"DAY","ORDER_RECEIVABLE_AMOUNT", TimeUtils.getTodayEndTime(),TimeUtils.getTodayTime()},//订单应收金额,今天
+                {"MONTH","ORDER_ACTUAL_AMOUNT",TimeUtils.getMonthLastDay(),TimeUtils.getMonthFristDay()},//订单实收金额,本月
+                {"DAY","ORDER_REFUND_AMOUNT", TimeUtils.getTodayEndTime(),TimeUtils.getTodayTime()},//退款金额,今天
+                {"MONTH","ORDER_UNPAID_AMOUNT",TimeUtils.getMonthLastDay(),TimeUtils.getMonthFristDay()},//欠费金额,本月
+
+        };
+    }
+
+    @Test(description = "数据中心-财务数据-订单趋势图",dataProvider = "dataProvider")
+    public void testGetOrderTrend(String dateType,String metric,long endTime,long startTime){
+
+
+        JSONObject trend=new JSONObject();
+        trend.put("dateType",dateType);
+        trend.put("endTime", endTime);
+        trend.put("startTime", startTime);
+        trend.put("metric",metric);
+        trend.put("brandId",xmAppApi.getLoginInfo().getBrandId());
+        trend.put("studioId",xmAppApi.getLoginInfo().getStudioId());
+        trend.put("operatorId",xmAppApi.getLoginInfo().getAdminId());
+
+
+        xmAppApi.doRequest(RequestType.JSON,params,trend.toJSONString(),headers).assetsSuccess(true);
+        String trendResult=xmAppApi.getBodyInJSON().getString("success");
+        Assert.assertEquals(trendResult,"true","获取财务数据-订单趋势图失败");
+
+    }
+
+
+    @DataProvider
+    public Object[][] dataProvider1(){
+        return new Object[][]{
+                {"WEEK","ORDER_RECEIVABLE_AMOUNT",TimeUtils.getWeekLastTime(),TimeUtils.getWeekFirstTime()},//订单应收金额，本周
+                {"WEEK","ORDER_ACTUAL_AMOUNT",TimeUtils.getWeekLastTime(),TimeUtils.getWeekFirstTime()},//订单实收金额，本周
+                {"WEEK","ORDER_REFUND_AMOUNT",TimeUtils.getWeekLastTime(),TimeUtils.getWeekFirstTime()},//退款金额，本周
+                {"WEEK","ORDER_UNPAID_AMOUNT",TimeUtils.getWeekLastTime(),TimeUtils.getWeekFirstTime()},//欠费金额，本周
+
+        };
+    }
+
+
+    @Test(description = "数据中心-财务数据-订单趋势图",dataProvider = "dataProvider1")
+    public void testGetOrderTrend1(String dateType,String metric,String endTime,String startTime){
+
+
+        JSONObject trend=new JSONObject();
+        trend.put("dateType",dateType);
+        trend.put("endTime", endTime);
+        trend.put("startTime", startTime);
+        trend.put("metric",metric);
+        trend.put("brandId",xmAppApi.getLoginInfo().getBrandId());
+        trend.put("studioId",xmAppApi.getLoginInfo().getStudioId());
+        trend.put("operatorId",xmAppApi.getLoginInfo().getAdminId());
+
+
+        xmAppApi.doRequest(RequestType.JSON,params,trend.toJSONString(),headers).assetsSuccess(true);
+        String trendResult=xmAppApi.getBodyInJSON().getString("success");
+        Assert.assertEquals(trendResult,"true","获取财务数据-订单趋势图失败");
+
+    }
+
+
+
+}

src/main/java/com/xiaomai/cases/polar/data/salesData/SalesDataTools.java

+package com.xiaomai.cases.polar.data.salesData;
+
+import com.alibaba.fastjson.JSONObject;
+import com.xiaomai.client.DataUserInfo;
+import com.xiaomai.enums.ApiModule;
+import com.xiaomai.enums.RequestType;
+import com.xiaomai.enums.Terminal;
+import com.xiaomai.utils.XMBaseTest;
+
+import java.math.BigDecimal;
+import java.util.Date;
+
+public class SalesDataTools extends XMBaseTest {
+    /**
+     * @param
+     * @description:销售数据-数据分析-汇总
+     * @param dateType：时间类型：[ DAY, WEEK, MONTH, QUARTER, YEAR ]
+     * @param endTime:结束时间
+     * @param startTime:开始时间
+     * @author: yangfangfang
+     **/
+    public JSONObject centerData(String dateType, long endTime, long startTime, DataUserInfo...dataUserInfos){
+
+        dataApi.setApiModule(ApiModule.Polar_Data)
+                .setApiName("API_centerData")
+                .setTerminal(Terminal.B);
+        super.beforeDataRequest(dataUserInfos);
+
+
+        JSONObject analysis=new JSONObject();
+        analysis.put("dateType",dateType);
+        analysis.put("endTime", endTime);
+        analysis.put("startTime",startTime);
+        analysis.put("brandId",xmAppApi.getLoginInfo().getBrandId());
+        analysis.put("studioId",xmAppApi.getLoginInfo().getStudioId());
+        analysis.put("operatorId",xmAppApi.getLoginInfo().getAdminId());
+
+        dataApi.doRequest(RequestType.JSON, dataparams, analysis.toJSONString(), dataheadrs).assetsSuccess(true);
+        JSONObject response=dataApi.getBodyInJSON();
+        return response;
+    }
+
+
+    /**
+     * @param
+     * @description:销售数据-趋势图
+     * @param dateType：时间类型：[ DAY, WEEK, MONTH, QUARTER, YEAR ]
+     * @param metric：类型：[ "新增会员数", "签单实收金额" ][ NEW_MEMBER_COUNT, SIGN_ORDER_ACTUAL_AMOUNT ]
+     * @param endTime:结束时间  注意：使用这个方法只能搜按天和按月，因为参数类型这里写的long 其他几个不是long型，会用不了
+     * @param startTime:开始时间
+     * @author: yangfangfang
+     **/
+    public JSONObject trend(String dateType, String metric,long endTime, long startTime, DataUserInfo...dataUserInfos){
+
+        dataApi.setApiModule(ApiModule.Polar_Data)
+                .setApiName("API_saleDataTrend")
+                .setTerminal(Terminal.B);
+        super.beforeDataRequest(dataUserInfos);
+
+        JSONObject trend=new JSONObject();
+        trend.put("dateType",dateType);
+        trend.put("endTime", endTime);
+        trend.put("startTime", startTime);
+        trend.put("metric",metric);
+        trend.put("brandId",xmAppApi.getLoginInfo().getBrandId());
+        trend.put("studioId",xmAppApi.getLoginInfo().getStudioId());
+        trend.put("operatorId",xmAppApi.getLoginInfo().getAdminId());
+
+        dataApi.doRequest(RequestType.JSON, dataparams, trend.toJSONString(), dataheadrs).assetsSuccess(true);
+        JSONObject response=dataApi.getBodyInJSON();
+        return response;
+    }
+
+
+    /**
+     * @param
+     * @description:销售数据-按来源筛选数据明细
+     * @param startTime：开始时间
+     * @param endTime:结束时间  注意：使用这个方法只能搜按天和按月，因为参数类型这里写的long 其他几个不是long型，会用不了
+     * @param resourceId：来源   -1：无
+     * @param dateType：时间类型：[ DAY, WEEK, MONTH, QUARTER, YEAR ]
+     * @param sort：[ "新增会员数正序", "新增会员数倒序", "签单实收金额正序", "签单实收金额倒序" ]排序 [ NEW_MEMBER_COUNT_ASC, NEW_MEMBER_COUNT_DESC, ACTUAL_AMOUNT_ASC, ACTUAL_AMOUNT_DESC ]
+     * @author: yangfangfang
+     **/
+    public JSONObject resourceDataDetail(long startTime,long endTime,String resourceId,String dateType, String sort, DataUserInfo...dataUserInfos){
+
+        dataApi.setApiModule(ApiModule.Polar_Data)
+                .setApiName("API_resourceDataDetail")
+                .setTerminal(Terminal.B);
+        super.beforeDataRequest(dataUserInfos);
+
+        JSONObject resourceDataDetail=new JSONObject();
+        resourceDataDetail.put("current",0);
+        resourceDataDetail.put("size", 20);
+        resourceDataDetail.put("startTime", startTime);
+        resourceDataDetail.put("endTime", endTime);
+        resourceDataDetail.put("creatorId","");
+        resourceDataDetail.put("saleId", "");
+        resourceDataDetail.put("resourceId",resourceId);
+        resourceDataDetail.put("consumeType","GROUP_CLASS");
+        resourceDataDetail.put("dateType",dateType);
+        resourceDataDetail.put("sort",sort);
+        resourceDataDetail.put("brandId",xmAppApi.getLoginInfo().getBrandId());
+        resourceDataDetail.put("studioId",xmAppApi.getLoginInfo().getStudioId());
+        resourceDataDetail.put("operatorId",xmAppApi.getLoginInfo().getAdminId());
+
+        dataApi.doRequest(RequestType.JSON, dataparams, resourceDataDetail.toJSONString(), dataheadrs).assetsSuccess(true);
+        JSONObject response=dataApi.getBodyInJSON();
+        return response;
+    }
+
+
+
+    /**
+     * @param
+     * @description:销售数据-按添加人筛选数据明细
+     * @param startTime：开始时间
+     * @param endTime:结束时间  注意：使用这个方法只能搜按天和按月，因为参数类型这里写的long 其他几个不是long型，会用不了
+     * @param creatorId：会员的添加人
+     * @param dateType：时间类型：[ DAY, WEEK, MONTH, QUARTER, YEAR ]
+     * @param sort：[ "新增会员数正序", "新增会员数倒序", "签单实收金额正序", "签单实收金额倒序" ]排序 [ NEW_MEMBER_COUNT_ASC, NEW_MEMBER_COUNT_DESC, ACTUAL_AMOUNT_ASC, ACTUAL_AMOUNT_DESC ]
+     * @author: yangfangfang
+     **/
+    public JSONObject creatorDataDetail(long startTime,long endTime,String creatorId,String dateType, String sort, DataUserInfo...dataUserInfos){
+
+        dataApi.setApiModule(ApiModule.Polar_Data)
+                .setApiName("API_creatorDataDetail")
+                .setTerminal(Terminal.B);
+        super.beforeDataRequest(dataUserInfos);
+
+        JSONObject resourceDataDetail=new JSONObject();
+        resourceDataDetail.put("current",0);
+        resourceDataDetail.put("size", 20);
+        resourceDataDetail.put("startTime", startTime);
+        resourceDataDetail.put("endTime", endTime);
+        resourceDataDetail.put("creatorId",creatorId);
+        resourceDataDetail.put("saleId", "");
+        resourceDataDetail.put("resourceId",null);
+        resourceDataDetail.put("consumeType","GROUP_CLASS");
+        resourceDataDetail.put("dateType",dateType);
+        resourceDataDetail.put("sort",sort);
+        resourceDataDetail.put("brandId",xmAppApi.getLoginInfo().getBrandId());
+        resourceDataDetail.put("studioId",xmAppApi.getLoginInfo().getStudioId());
+        resourceDataDetail.put("operatorId",xmAppApi.getLoginInfo().getAdminId());
+
+        dataApi.doRequest(RequestType.JSON, dataparams, resourceDataDetail.toJSONString(), dataheadrs).assetsSuccess(true);
+        JSONObject response=dataApi.getBodyInJSON();
+        return response;
+    }
+
+
+    /**
+     * @param
+     * @description:销售数据-按跟进销售筛选数据明细
+     * @param startTime：开始时间
+     * @param endTime:结束时间  注意：使用这个方法只能搜按天和按月，因为参数类型这里写的long 其他几个不是long型，会用不了
+     * @param saleId：会员的跟进销售
+     * @param dateType：时间类型：[ DAY, WEEK, MONTH, QUARTER, YEAR ]
+     * @param sort：[ "新增会员数正序", "新增会员数倒序", "签单实收金额正序", "签单实收金额倒序" ]排序 [ NEW_MEMBER_COUNT_ASC, NEW_MEMBER_COUNT_DESC, ACTUAL_AMOUNT_ASC, ACTUAL_AMOUNT_DESC ]
+     * @author: yangfangfang
+     **/
+    public JSONObject salesDataDetail(long startTime,long endTime,String saleId,String dateType, String sort, DataUserInfo...dataUserInfos){
+
+        dataApi.setApiModule(ApiModule.Polar_Data)
+                .setApiName("API_salesDataDetail")
+                .setTerminal(Terminal.B);
+        super.beforeDataRequest(dataUserInfos);
+
+        JSONObject resourceDataDetail=new JSONObject();
+        resourceDataDetail.put("current",0);
+        resourceDataDetail.put("size", 20);
+        resourceDataDetail.put("startTime", startTime);
+        resourceDataDetail.put("endTime", endTime);
+        resourceDataDetail.put("creatorId",null);
+        resourceDataDetail.put("saleId", saleId);
+        resourceDataDetail.put("resourceId",null);
+        resourceDataDetail.put("consumeType","GROUP_CLASS");
+        resourceDataDetail.put("dateType",dateType);
+        resourceDataDetail.put("sort",sort);
+        resourceDataDetail.put("brandId",xmAppApi.getLoginInfo().getBrandId());
+        resourceDataDetail.put("studioId",xmAppApi.getLoginInfo().getStudioId());
+        resourceDataDetail.put("operatorId",xmAppApi.getLoginInfo().getAdminId());
+
+        dataApi.doRequest(RequestType.JSON, dataparams, resourceDataDetail.toJSONString(), dataheadrs).assetsSuccess(true);
+        JSONObject response=dataApi.getBodyInJSON();
+        return response;
+    }
+
+}

src/main/java/com/xiaomai/cases/polar/data/salesData/TestCenterData.java

+package com.xiaomai.cases.polar.data.salesData;
+
+import com.alibaba.fastjson.JSONObject;
+import com.xiaomai.cases.polar.clue.MemberTools;
+import com.xiaomai.cases.polar.finance.order.OrderTools;
+import com.xiaomai.cases.polar.member.Tools;
+import com.xiaomai.cases.polar.memberCard.CardTools;
+import com.xiaomai.enums.ApiModule;
+import com.xiaomai.enums.LoginAccount;
+import com.xiaomai.enums.RequestType;
+import com.xiaomai.enums.Terminal;
+import com.xiaomai.utils.RandomStringUtil;
+import com.xiaomai.utils.TimeUtils;
+import com.xiaomai.utils.XMBaseTest;
+import org.testng.Assert;
+import org.testng.annotations.BeforeMethod;
+import org.testng.annotations.Test;
+
+import java.math.BigDecimal;
+
+public class TestCenterData extends XMBaseTest {
+
+    Tools tools=new Tools();
+
+    OrderTools orderTools=new OrderTools();
+
+    CardTools cardTools=new CardTools();
+
+    SalesDataTools salesDataTools=new SalesDataTools();
+
+    String memberId;
+
+    String cardId;
+
+    String getDetailId;
+
+    float paidAmount;
+
+    @BeforeMethod
+    public void beforeTest(){
+        xmAppApi.setApiModule(ApiModule.Polar_Data)
+                .setApiName("API_centerData")
+                .setLoginUser(LoginAccount.GYM_PROD)
+                .setTerminal(Terminal.B);
+
+        dal.setCase_owner("yff")
+                .setCase_name(Thread.currentThread().getStackTrace()[1].getFileName().split("\\.")[0]);
+        super.beforeTest();
+    }
+
+    @Test(description = "销售数据-数据分析-汇总")
+    public void testCenterData(){
+
+        //先查一下当前今天的销售数据-数据分析-汇总
+        JSONObject beforeAnalysis=salesDataTools.centerData("DAY",TimeUtils.getTodayEndTime(),TimeUtils.getTodayTime());
+        int beforeNewMemberCount=Integer.parseInt(beforeAnalysis.getJSONObject("result").getString("newMemberCount"));//新增会员数
+        BigDecimal beforeActualAmount=new BigDecimal(beforeAnalysis.getJSONObject("result").getString("actualAmount"));//签单实收金额
+
+
+        //先查一下当前今天的销售数据-按照来源是无筛选数据明细的数据
+        JSONObject beforeResourceDataDetail=salesDataTools.resourceDataDetail(TimeUtils.getTodayTime(),TimeUtils.getTodayEndTime(),"-1","DAY","NEW_MEMBER_COUNT_DESC");
+        int beforeResourceDataDetailNewMemberCount=Integer.parseInt(beforeResourceDataDetail.getJSONObject("result").getJSONArray("records").getJSONObject(0).getString("newMemberCount"));
+        BigDecimal beforeResourceDataDetailActualAmount=new BigDecimal(beforeResourceDataDetail.getJSONObject("result").getJSONArray("records").getJSONObject(0).getString("actualAmount"));
+
+
+        //先查一下当前今天的销售数据-按照添加人是当前人筛选数据明细的数据
+        JSONObject beforeCreatorDataDetail=salesDataTools.creatorDataDetail(TimeUtils.getTodayTime(),TimeUtils.getTodayEndTime(),xmAppApi.getLoginInfo().getAdminId(),"DAY","NEW_MEMBER_COUNT_DESC");
+        int beforeCreatorDataDetailNewMemberCount=Integer.parseInt(beforeCreatorDataDetail.getJSONObject("result").getJSONArray("records").getJSONObject(0).getString("newMemberCount"));
+        BigDecimal beforeCreatorDataDetailActualAmount=new BigDecimal(beforeCreatorDataDetail.getJSONObject("result").getJSONArray("records").getJSONObject(0).getString("actualAmount"));
+
+
+        //先查一下当前今天的销售数据-按照跟进销售是无筛选数据明细的数据
+        JSONObject beforeSalesDataDetail=salesDataTools.salesDataDetail(TimeUtils.getTodayTime(),TimeUtils.getTodayEndTime(),"-1","DAY","NEW_MEMBER_COUNT_DESC");
+        int beforeSalesDataDetailNewMemberCount=Integer.parseInt(beforeSalesDataDetail.getJSONObject("result").getJSONArray("records").getJSONObject(0).getString("newMemberCount"));
+        BigDecimal beforeSalesDataDetailActualAmount=new BigDecimal(beforeSalesDataDetail.getJSONObject("result").getJSONArray("records").getJSONObject(0).getString("actualAmount"));
+
+
+
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+
+
+        //①新增会员，并签单完成之后，校验新增会员数和签单实收金额增加
+
+        String name = "创建数据中心潜在会员"+ RandomStringUtil.randomString(3);
+        String phone = RandomStringUtil.randomMobile("111");
+        //添加线索
+        memberId = tools.create(name,phone).getString("result");
+
+        //获取会员卡信息
+        //获取会员卡列表,没有则新建一个
+        int cardTotal = Integer.parseInt(orderTools.fetchPageOfMemberCard("次卡").getJSONObject("result").getString("total"));
+        if (cardTotal == 0) {
+            cardId = cardTools.memberCardCreate("次卡-创建订单会员卡"+TimeUtils.getCurrentTime()).getString("result");
+        }
+        JSONObject memberCard=orderTools.fetchPageOfMemberCard("次卡");
+        cardId=memberCard.getJSONObject("result").getJSONArray("records").getJSONObject(0).getString("id");
+        BigDecimal quantity= new BigDecimal(memberCard.getJSONObject("result").getJSONArray("records").getJSONObject(0).getString("balance"));
+        float price= Float.parseFloat(memberCard.getJSONObject("result").getJSONArray("records").getJSONObject(0).getString("price"));
+        int validPeriod= Integer.parseInt(memberCard.getJSONObject("result").getJSONArray("records").getJSONObject(0).getString("validPeriod"));
+
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+
+        //获取签单要用的卡快照id
+        String latestSnapshotId=orderTools.fetchDetailById(cardId,xmAppApi.getLoginInfo().getBrandId(),xmAppApi.getLoginInfo().getStudioId(),xmAppApi.getLoginInfo().getAdminId()).getJSONObject("result").getString("latestSnapshotId");
+
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+
+        //检查会员对该卡是否超出购买上限
+        boolean limitResult=orderTools.checkAllowPurchase("MEMBER_CARD",cardId,memberId,"1",xmAppApi.getLoginInfo().getBrandId(),xmAppApi.getLoginInfo().getStudioId(),xmAppApi.getLoginInfo().getAdminId()).getBoolean("success");
+
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+
+        if(limitResult == true) {
+
+            //创建订单
+            JSONObject orderResult = orderTools.signOrder(cardId, latestSnapshotId, quantity, price, validPeriod, latestSnapshotId, price / 2, "PURCHASE",
+                    "MEMBER_CARD", memberId, price - price / 2, price - price / 2, "1");
+            getDetailId = orderResult.getString("result");
+
+            try {
+                Thread.sleep(1000);
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            }
+
+            //获取订单详情的实收金额
+            JSONObject getDetailResult=orderTools.getDetail(getDetailId);
+            paidAmount = Float.parseFloat(getDetailResult.getJSONObject("result").getString("paidAmount"));//实收金额
+
+        }
+
+
+        JSONObject analysis=new JSONObject();
+        analysis.put("dateType","DAY");
+        analysis.put("endTime", TimeUtils.getTodayEndTime());
+        analysis.put("startTime", TimeUtils.getTodayTime());
+        analysis.put("brandId",xmAppApi.getLoginInfo().getBrandId());
+        analysis.put("studioId",xmAppApi.getLoginInfo().getStudioId());
+        analysis.put("operatorId",xmAppApi.getLoginInfo().getAdminId());
+
+        xmAppApi.doRequest(RequestType.JSON,params,analysis.toJSONString(),headers).assetsSuccess(true);
+        JSONObject analysisResult=xmAppApi.getBodyInJSON();
+        Assert.assertEquals(analysisResult.getString("success"),"true","获取销售数据-数据分析-汇总失败");
+        int newMemberCount=Integer.parseInt(analysisResult.getJSONObject("result").getString("newMemberCount"));//新增会员数
+        BigDecimal actualAmount=new BigDecimal(analysisResult.getJSONObject("result").getString("actualAmount"));//签单实收金额
+//        BigDecimal qoqOfActualAmount=new BigDecimal(analysisResult.getJSONObject("result").getString("qoqOfActualAmount"));//签单实收金额环比
+//        BigDecimal qoqOfNewMemberCount=new BigDecimal(analysisResult.getJSONObject("result").getString("qoqOfNewMemberCount"));//新增会员数环比
+//        BigDecimal yoyOfActualAmount=new BigDecimal(analysisResult.getJSONObject("result").getString("yoyOfActualAmount"));//签单实收金额同比
+//        BigDecimal yoyOfNewMemberCount=new BigDecimal(analysisResult.getJSONObject("result").getString("yoyOfNewMemberCount"));//新增会员数同比
+
+        try {
+            Thread.sleep(3000);
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+
+
+        //校验：
+        //1.校验新增一个会员和签单之后销售数据-数据分析汇总的新增会员数与签单实收金额
+        Assert.assertEquals(newMemberCount,beforeNewMemberCount+1,"新建一个线索之后数据分析的新增会员数未加1");
+        Assert.assertEquals(actualAmount,beforeActualAmount.add(BigDecimal.valueOf(paidAmount)),"签单完成之后，销售数据数据分析的签单实收金额未增加对应的签单实收金额");
+
+
+        //2.校验销售数据-趋势图的签单实收金额(注意：暂时无法在这里直接校验新增会员数的趋势图，因为beforeNewMemberCount是int型，而趋势图返回的value这个接口他定义的是BigDecimal类型，如果都改了BigDecimal上面接口比较的时候又要用int)
+        JSONObject trendResult=salesDataTools.trend("DAY","SIGN_ORDER_ACTUAL_AMOUNT",TimeUtils.getTodayEndTime(),TimeUtils.getTodayTime());
+        BigDecimal value=new BigDecimal(trendResult.getJSONArray("result").getJSONObject(0).getJSONArray("items").getJSONObject(0).getString("value"));
+        Assert.assertEquals(value,beforeActualAmount.add(BigDecimal.valueOf(paidAmount)),"签单完成之后，销售数据趋势图的签单实收金额未增加对应的签单实收金额");
+
+
+        //3.校验销售数据-按照来源为无筛选数据明细-有无上述新增会员数和签单实收金额
+        JSONObject resourceDataDetail=salesDataTools.resourceDataDetail(TimeUtils.getTodayTime(),TimeUtils.getTodayEndTime(),"-1","DAY","NEW_MEMBER_COUNT_DESC");
+        int resourceDataDetailNewMemberCount=Integer.parseInt(resourceDataDetail.getJSONObject("result").getJSONArray("records").getJSONObject(0).getString("newMemberCount"));
+        BigDecimal resourceDataDetailActualAmount=new BigDecimal(resourceDataDetail.getJSONObject("result").getJSONArray("records").getJSONObject(0).getString("actualAmount"));
+        Assert.assertEquals(resourceDataDetailNewMemberCount,beforeResourceDataDetailNewMemberCount+1,"新建一个来源为无的线索之后，销售数据明细筛选来源为无的新增会员数未加1");
+        Assert.assertEquals(resourceDataDetailActualAmount,beforeResourceDataDetailActualAmount.add(BigDecimal.valueOf(paidAmount)),"签单完成之后，销售数据明细来源为无的签单实收金额未增加对应的签单实收金额");
+
+
+        //4.校验销售数据-按照添加人是当前人筛选数据明细-有无上述新增会员数和签单实收金额
+
+        JSONObject creatorDataDetail=salesDataTools.creatorDataDetail(TimeUtils.getTodayTime(),TimeUtils.getTodayEndTime(),xmAppApi.getLoginInfo().getAdminId(),"DAY","NEW_MEMBER_COUNT_DESC");
+        int creatorDataDetailNewMemberCount=Integer.parseInt(creatorDataDetail.getJSONObject("result").getJSONArray("records").getJSONObject(0).getString("newMemberCount"));
+        BigDecimal creatorDataDetailActualAmount=new BigDecimal(creatorDataDetail.getJSONObject("result").getJSONArray("records").getJSONObject(0).getString("actualAmount"));
+        Assert.assertEquals(creatorDataDetailNewMemberCount,beforeCreatorDataDetailNewMemberCount+1,"新建一个线索之后，销售数据明细筛选添加人是当前人的新增会员数未加1");
+        Assert.assertEquals(creatorDataDetailActualAmount,beforeCreatorDataDetailActualAmount.add(BigDecimal.valueOf(paidAmount)),"签单完成之后，销售数据明细筛选添加人是当前人的签单实收金额未增加对应的签单实收金额");
+
+
+
+        //5.校验销售数据-按照跟进销售为无筛选数据明细-有无上述新增会员数和签单实收金额
+        JSONObject salesDataDetail=salesDataTools.salesDataDetail(TimeUtils.getTodayTime(),TimeUtils.getTodayEndTime(),"-1","DAY","NEW_MEMBER_COUNT_DESC");
+        int salesDataDetailNewMemberCount=Integer.parseInt(salesDataDetail.getJSONObject("result").getJSONArray("records").getJSONObject(0).getString("newMemberCount"));
+        BigDecimal salesDataDetailActualAmount=new BigDecimal(salesDataDetail.getJSONObject("result").getJSONArray("records").getJSONObject(0).getString("actualAmount"));
+        Assert.assertEquals(salesDataDetailNewMemberCount,beforeSalesDataDetailNewMemberCount+1,"新建一个线索之后，销售数据明细筛选跟进销售为无的新增会员数未加1");
+        Assert.assertEquals(salesDataDetailActualAmount,beforeSalesDataDetailActualAmount.add(BigDecimal.valueOf(paidAmount)),"签单完成之后，销售数据明细筛选跟进销售为无的签单实收金额未增加对应的签单实收金额");
+
+
+        try {
+            Thread.sleep(3000);
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+
+
+
+        //②退单--校验签单实收金额不变
+
+
+        //创建退单订单
+        //查询要退的卡id 从listUserRefundableCard-查询用户可退的会员卡列表中获取
+        JSONObject listUserRefundableCardResult=orderTools.listUserRefundableCard("MEMBER","",memberId);
+        String listUserRefundableId=listUserRefundableCardResult.getJSONArray("result").getJSONObject(0).getString("id");
+
+        //查询订单或者收支可退流水金额（包含乐动收银状态信息）
+        boolean checkRefundableAmountResult=orderTools.checkRefundableAmount(getDetailId,price - price / 2).getBoolean("success");
+
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+
+        if(checkRefundableAmountResult == true) {
+            //退单-会员卡
+            JSONObject refundOrderResult = orderTools.refundOrder(0, listUserRefundableId, quantity, price - price / 2, "MEMBER_CARD",
+                    memberId, price - price / 2, price - price / 2, "1");
+            String refundOrderGetDetailId = refundOrderResult.getString("result");
+
+            try {
+                Thread.sleep(3000);
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            }
+
+
+            //校验：
+            //1.校验退单之后销售数据-数据分析汇总的签单实收金额应不变
+            JSONObject afterAnalysis1 = salesDataTools.centerData("DAY", TimeUtils.getTodayEndTime(), TimeUtils.getTodayTime());
+            BigDecimal afterActualAmount1 = new BigDecimal(afterAnalysis1.getJSONObject("result").getString("actualAmount"));//签单实收金额
+            Assert.assertEquals(afterActualAmount1, actualAmount, "退单订单之后，销售数据数据分析的签单实收金额不应有变动");
+
+
+            //2.校验销售数据-趋势图的签单实收金额应不变
+            JSONObject afterTrendResult1 = salesDataTools.trend("DAY", "SIGN_ORDER_ACTUAL_AMOUNT", TimeUtils.getTodayEndTime(), TimeUtils.getTodayTime());
+            BigDecimal afterValue1 = new BigDecimal(afterTrendResult1.getJSONArray("result").getJSONObject(0).getJSONArray("items").getJSONObject(0).getString("value"));
+            Assert.assertEquals(afterValue1, actualAmount, "退单订单之后，销售数据趋势图的签单实收金额不应有变动");
+
+
+            //3.校验销售数据-按照来源为无筛选数据明细-上述签单实收金额应不变
+            JSONObject afterResourceDataDetail1 = salesDataTools.resourceDataDetail(TimeUtils.getTodayTime(), TimeUtils.getTodayEndTime(), "-1", "DAY", "NEW_MEMBER_COUNT_DESC");
+            BigDecimal afterResourceDataDetailActualAmount1 = new BigDecimal(afterResourceDataDetail1.getJSONObject("result").getJSONArray("records").getJSONObject(0).getString("actualAmount"));
+            Assert.assertEquals(afterResourceDataDetailActualAmount1, actualAmount, "退单订单之后，销售数据明细来源为无的签单实收金额不应有变动");
+
+
+            //4.校验销售数据-按照添加人是当前人筛选数据明细-上述签单实收金额应不变
+
+            JSONObject afterCreatorDataDetail1 = salesDataTools.creatorDataDetail(TimeUtils.getTodayTime(), TimeUtils.getTodayEndTime(), xmAppApi.getLoginInfo().getAdminId(), "DAY", "NEW_MEMBER_COUNT_DESC");
+            BigDecimal afterCreatorDataDetailActualAmount1 = new BigDecimal(afterCreatorDataDetail1.getJSONObject("result").getJSONArray("records").getJSONObject(0).getString("actualAmount"));
+            Assert.assertEquals(afterCreatorDataDetailActualAmount1, actualAmount, "退单订单之后，销售数据明细筛选添加人是当前人的签单实收金额不应有变动");
+
+
+            //5.校验销售数据-按照跟进销售为无筛选数据明细-上述签单实收金额应不变
+            JSONObject afterSalesDataDetail1 = salesDataTools.salesDataDetail(TimeUtils.getTodayTime(), TimeUtils.getTodayEndTime(), "-1", "DAY", "NEW_MEMBER_COUNT_DESC");
+            BigDecimal afterSalesDataDetailActualAmount1 = new BigDecimal(afterSalesDataDetail1.getJSONObject("result").getJSONArray("records").getJSONObject(0).getString("actualAmount"));
+            Assert.assertEquals(afterSalesDataDetailActualAmount1, actualAmount, "退单订单之后，销售数据明细筛选跟进销售为无的签单实收金额不应有变动");
+
+
+
+
+            //作废退单订单，为了下述流程可以作废签单订单
+            //校验是否可以作废退单订单
+            boolean checkDiscardRefundVoucherResult = orderTools.checkDiscardVoucher(refundOrderGetDetailId).getBoolean("success");
+
+            try {
+                Thread.sleep(1000);
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            }
+
+            if (checkDiscardRefundVoucherResult == true) {
+                //作废订单
+                JSONObject refundDiscardResult = orderTools.discard(refundOrderGetDetailId, "重复录入", "已作废退单订单" + RandomStringUtil.randomString(10));
+
+            }
+        }
+
+
+
+
+        //③作废签单--校验签单实收金额减少
+
+        //校验是否可以作废签单订单
+        boolean checkDiscardSignVoucherResult = orderTools.checkDiscardVoucher(getDetailId).getBoolean("success");
+
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+
+        if (checkDiscardSignVoucherResult == true) {
+
+            //作废签单订单
+            JSONObject discardResult = orderTools.discard(getDetailId, "重复录入", "已作废签单订单" + RandomStringUtil.randomString(10));
+
+            try {
+                Thread.sleep(3000);
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            }
+
+            //校验：
+            //1.校验作废签单订单之后销售数据-数据分析汇总的签单实收金额是否减少
+            JSONObject afterAnalysis=salesDataTools.centerData("DAY",TimeUtils.getTodayEndTime(),TimeUtils.getTodayTime());
+            BigDecimal afterActualAmount=new BigDecimal(afterAnalysis.getJSONObject("result").getString("actualAmount"));//签单实收金额
+            Assert.assertEquals(afterActualAmount,actualAmount.subtract(BigDecimal.valueOf(paidAmount)),"作废签单订单之后，销售数据数据分析的签单实收金额未减少对应的签单实收金额");
+
+
+            //2.校验销售数据-趋势图的签单实收金额是否减少
+            JSONObject afterTrendResult=salesDataTools.trend("DAY","SIGN_ORDER_ACTUAL_AMOUNT",TimeUtils.getTodayEndTime(),TimeUtils.getTodayTime());
+            BigDecimal afterValue=new BigDecimal(afterTrendResult.getJSONArray("result").getJSONObject(0).getJSONArray("items").getJSONObject(0).getString("value"));
+            Assert.assertEquals(afterValue,actualAmount.subtract(BigDecimal.valueOf(paidAmount)),"作废签单订单之后，销售数据趋势图的签单实收金额未减少对应的签单实收金额");
+
+
+
+            //3.校验销售数据-按照来源为无筛选数据明细-上述签单实收金额是否减少
+            JSONObject afterResourceDataDetail=salesDataTools.resourceDataDetail(TimeUtils.getTodayTime(),TimeUtils.getTodayEndTime(),"-1","DAY","NEW_MEMBER_COUNT_DESC");
+            BigDecimal afterResourceDataDetailActualAmount=new BigDecimal(afterResourceDataDetail.getJSONObject("result").getJSONArray("records").getJSONObject(0).getString("actualAmount"));
+            Assert.assertEquals(afterResourceDataDetailActualAmount,actualAmount.subtract(BigDecimal.valueOf(paidAmount)),"作废签单订单之后，销售数据明细来源为无的签单实收金额未减少对应的签单实收金额");
+
+
+            //4.校验销售数据-按照添加人是当前人筛选数据明细-上述签单实收金额是否减少
+
+            JSONObject afterCreatorDataDetail=salesDataTools.creatorDataDetail(TimeUtils.getTodayTime(),TimeUtils.getTodayEndTime(),xmAppApi.getLoginInfo().getAdminId(),"DAY","NEW_MEMBER_COUNT_DESC");
+            BigDecimal afterCreatorDataDetailActualAmount=new BigDecimal(afterCreatorDataDetail.getJSONObject("result").getJSONArray("records").getJSONObject(0).getString("actualAmount"));
+            Assert.assertEquals(afterCreatorDataDetailActualAmount,actualAmount.subtract(BigDecimal.valueOf(paidAmount)),"作废签单订单之后，销售数据明细筛选添加人是当前人的签单实收金额未减少对应的签单实收金额");
+
+
+
+            //5.校验销售数据-按照跟进销售为无筛选数据明细-上述签单实收金额是否减少
+            JSONObject afterSalesDataDetail=salesDataTools.salesDataDetail(TimeUtils.getTodayTime(),TimeUtils.getTodayEndTime(),"-1","DAY","NEW_MEMBER_COUNT_DESC");
+            BigDecimal afterSalesDataDetailActualAmount=new BigDecimal(afterSalesDataDetail.getJSONObject("result").getJSONArray("records").getJSONObject(0).getString("actualAmount"));
+            Assert.assertEquals(afterSalesDataDetailActualAmount,actualAmount.subtract(BigDecimal.valueOf(paidAmount)),"作废签单订单之后，销售数据明细筛选跟进销售为无的签单实收金额未减少对应的签单实收金额");
+
+        }
+    }
+}

src/main/java/com/xiaomai/cases/polar/data/salesData/TestTrend.java

+package com.xiaomai.cases.polar.data.salesData;
+
+import com.alibaba.fastjson.JSONObject;
+import com.xiaomai.enums.ApiModule;
+import com.xiaomai.enums.LoginAccount;
+import com.xiaomai.enums.RequestType;
+import com.xiaomai.enums.Terminal;
+import com.xiaomai.utils.TimeUtils;
+import com.xiaomai.utils.XMBaseTest;
+import org.testng.Assert;
+import org.testng.annotations.BeforeMethod;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+
+public class TestTrend extends XMBaseTest {
+    @BeforeMethod
+    public void beforeTest(){
+        xmAppApi.setApiModule(ApiModule.Polar_Data)
+                .setApiName("API_saleDataTrend")
+                .setLoginUser(LoginAccount.GYM_PROD)
+                .setTerminal(Terminal.B);
+
+        dal.setCase_owner("yff")
+                .setCase_name(Thread.currentThread().getStackTrace()[1].getFileName().split("\\.")[0]);
+        super.beforeTest();
+    }
+    @DataProvider
+    public Object[][] dataProvider(){
+        return new Object[][]{
+
+                {"DAY","NEW_MEMBER_COUNT",TimeUtils.getTodayEndTime(),TimeUtils.getTodayTime()},//新增会员数,今天
+                {"MONTH","SIGN_ORDER_ACTUAL_AMOUNT",TimeUtils.getMonthLastDay(),TimeUtils.getMonthFristDay()},//签单实收金额,本月
+
+        };
+    }
+
+    @Test(description = "销售数据-趋势图",dataProvider = "dataProvider")
+    public void testTrend(String dateType,String metric,long endTime,long startTime){
+
+        JSONObject trend=new JSONObject();
+        trend.put("dateType",dateType);
+        trend.put("endTime", endTime);
+        trend.put("startTime", startTime);
+        trend.put("metric",metric);
+        trend.put("brandId",xmAppApi.getLoginInfo().getBrandId());
+        trend.put("studioId",xmAppApi.getLoginInfo().getStudioId());
+        trend.put("operatorId",xmAppApi.getLoginInfo().getAdminId());
+
+        xmAppApi.doRequest(RequestType.JSON,params,trend.toJSONString(),headers).assetsSuccess(true);
+        String trendResult=xmAppApi.getBodyInJSON().getString("success");
+        Assert.assertEquals(trendResult,"true","获取销售数据-趋势图失败");
+
+
+    }
+
+    @DataProvider
+    public Object[][] dataProvider1(){
+        return new Object[][]{
+                {"WEEK","NEW_MEMBER_COUNT",TimeUtils.getWeekLastTime(),TimeUtils.getWeekFirstTime()},//新增会员数，本周
+                {"WEEK","SIGN_ORDER_ACTUAL_AMOUNT",TimeUtils.getWeekLastTime(),TimeUtils.getWeekFirstTime()},//签单实收金额，本周
+        };
+    }
+
+    @Test(description = "销售数据-趋势图",dataProvider = "dataProvider1")
+    public void testTrend1(String dateType, String metric, String endTime, String startTime){
+
+        JSONObject trend=new JSONObject();
+        trend.put("dateType",dateType);
+        trend.put("endTime", endTime);
+        trend.put("startTime", startTime);
+        trend.put("metric",metric);
+        trend.put("brandId",xmAppApi.getLoginInfo().getBrandId());
+        trend.put("studioId",xmAppApi.getLoginInfo().getStudioId());
+        trend.put("operatorId",xmAppApi.getLoginInfo().getAdminId());
+
+        xmAppApi.doRequest(RequestType.JSON,params,trend.toJSONString(),headers).assetsSuccess(true);
+        String trendResult=xmAppApi.getBodyInJSON().getString("success");
+        Assert.assertEquals(trendResult,"true","获取销售数据-趋势图失败");
+
+
+    }
+}

src/main/java/com/xiaomai/cases/polar/finance/order/OrderTools.java

@@ -704,7 +704,7 @@ public class OrderTools extends XMBaseTest {
      * @param paymentWay:支付方式 1-线下微信 2 3
      * @author: yangfangfang
      **/
-    public JSONObject pay(float unpaidAmount,String paymentWay,String getDetailId, DataUserInfo...dataUserInfos){
+    public JSONObject pay(BigDecimal unpaidAmount,String paymentWay,String getDetailId, DataUserInfo...dataUserInfos){
 
         dataApi.setApiModule(ApiModule.Polar_Finance)
                 .setApiName("API_pay")

src/main/java/com/xiaomai/cases/polar/member/TestFindDetailById.java

@@ -9,6 +9,7 @@ import com.xiaomai.utils.XMBaseTest;
 import com.xiaomai.utils.XMJSONPath;
 import org.testng.Assert;
 import org.testng.annotations.BeforeMethod;
+import org.testng.annotations.DataProvider;
 import org.testng.annotations.Test;
 
 public class TestFindDetailById extends XMBaseTest {
@@ -26,12 +27,20 @@ public class TestFindDetailById extends XMBaseTest {
         super.beforeTest();
     }
 
+    @DataProvider
+    public  Object[][] dataProvider(){
+        return new Object[][]{
+                {"NORMAL","NORMAL"},
+                {"HISTORY","HISTORY"}
+        };
+    }
 
-    @Test(description = "获取会员详情以及更多资料")
-    public void testFindDetailById(){
+    //编辑会员资料前调用的会员详情，非点击会员之后的会员详情findStudioMemberDetail，点击之后的正式会员详情和流失会员详情已在TestForceUpdate中覆盖，这里就不再冗余了
+    @Test(description = "编辑会员资料调用的会员详情",dataProvider = "dataProvider")
+    public void testFindDetailById(String searchType,String status){
 
-        //获取正式会员列表
-        JSONObject memberResult=tools.search("NORMAL","NORMAL");
+        //获取正式/流失会员列表
+        JSONObject memberResult=tools.search(searchType,status);
         String id=memberResult.getJSONObject("result").getJSONArray("records").getJSONObject(0).getString("id");
 
         JSONObject jsonObject=new JSONObject();
@@ -44,14 +53,15 @@ public class TestFindDetailById extends XMBaseTest {
         xmAppApi.doRequest(RequestType.JSON,params,jsonObject.toJSONString(),headers).assetsSuccess(true);
         JSONObject response=xmAppApi.getBodyInJSON();
         String success=response.getString("success");
-        Assert.assertEquals(success,"true","获取会员详情以及更多资料失败");
+        Assert.assertEquals(success,"true","获取正式/流失会员详情以及更多资料失败");
 
     }
-    @Test(description = "获取会员详情以及更多资料-会员id不能为空")
-    public void testFindDetailById_1(){
 
-        //获取正式会员列表
-        JSONObject memberResult=tools.search("NORMAL","NORMAL");
+    @Test(description = "编辑会员资料调用的会员详情-会员id不能为空",dataProvider = "dataProvider")
+    public void testFindDetailById_1(String searchType,String status){
+
+        //获取正式/流失会员列表
+        JSONObject memberResult=tools.search(searchType,status);
         String id=memberResult.getJSONObject("result").getJSONArray("records").getJSONObject(0).getString("id");
 
         JSONObject jsonObject1=new JSONObject();

src/main/java/com/xiaomai/cases/polar/member/TestForceUpdate.java

@@ -23,13 +23,15 @@ import java.math.BigDecimal;
 public class TestForceUpdate extends XMBaseTest {
     String cardId;
 
-    OrderTools orderTools=new OrderTools();
+    String getDetailId;
 
-    RevenueAndExpenditureTools revenueAndExpenditureTools=new RevenueAndExpenditureTools();
+    OrderTools orderTools=new OrderTools();
 
     CardTools cardTools=new CardTools();
     Tools tools= new Tools();
 
+    MemberTools memberTools=new MemberTools();
+
 
     @BeforeMethod
     public void beforeTest(){
@@ -43,26 +45,29 @@ public class TestForceUpdate extends XMBaseTest {
         super.beforeTest();
     }
 
-    @Test(description = "编辑正式会员信息")
+    @Test(description = "编辑正式会员/流失会员信息")
     public void  testForceUpdate() {
 
 
-        JSONObject create=tools.create("编辑正式会员"+RandomStringUtil.randomString(3),RandomStringUtil.randomMobile("88"));
-        String memberId=create.getString("result");
+        //编辑正式会员信息
 
-        //创建订单转成正式会员
+        //创建潜在会员
+        JSONObject create = tools.create("潜在会员" + RandomStringUtil.randomString(3), RandomStringUtil.randomMobile("88"));
+        String memberId = create.getString("result");
+
+        //创建订单线索会员转正式会员（状态流转：线索转正式）
 
         //获取会员卡信息
         //获取会员卡列表,没有则新建一个
         int cardTotal = Integer.parseInt(orderTools.fetchPageOfMemberCard("次卡").getJSONObject("result").getString("total"));
         if (cardTotal == 0) {
-            cardId = cardTools.memberCardCreate("创建订单会员卡"+TimeUtils.getCurrentTime()).getString("result");
+            cardId = cardTools.memberCardCreate("创建订单会员卡" + TimeUtils.getCurrentTime()).getString("result");
         }
-        JSONObject memberCard=orderTools.fetchPageOfMemberCard("次卡");
-        cardId=memberCard.getJSONObject("result").getJSONArray("records").getJSONObject(0).getString("id");
-        BigDecimal quantity= new BigDecimal(memberCard.getJSONObject("result").getJSONArray("records").getJSONObject(0).getString("balance"));
-        float price= Float.parseFloat(memberCard.getJSONObject("result").getJSONArray("records").getJSONObject(0).getString("price"));
-        int validPeriod= Integer.parseInt(memberCard.getJSONObject("result").getJSONArray("records").getJSONObject(0).getString("validPeriod"));
+        JSONObject memberCard = orderTools.fetchPageOfMemberCard("次卡");
+        cardId = memberCard.getJSONObject("result").getJSONArray("records").getJSONObject(0).getString("id");
+        BigDecimal quantity = new BigDecimal(memberCard.getJSONObject("result").getJSONArray("records").getJSONObject(0).getString("balance"));
+        float price = Float.parseFloat(memberCard.getJSONObject("result").getJSONArray("records").getJSONObject(0).getString("price"));
+        int validPeriod = Integer.parseInt(memberCard.getJSONObject("result").getJSONArray("records").getJSONObject(0).getString("validPeriod"));
 
         try {
             Thread.sleep(1000);
@@ -71,7 +76,7 @@ public class TestForceUpdate extends XMBaseTest {
         }
 
         //获取签单要用的卡快照id
-        String latestSnapshotId=orderTools.fetchDetailById(cardId,xmAppApi.getLoginInfo().getBrandId(),xmAppApi.getLoginInfo().getStudioId(),xmAppApi.getLoginInfo().getAdminId()).getJSONObject("result").getString("latestSnapshotId");
+        String latestSnapshotId = orderTools.fetchDetailById(cardId, xmAppApi.getLoginInfo().getBrandId(), xmAppApi.getLoginInfo().getStudioId(), xmAppApi.getLoginInfo().getAdminId()).getJSONObject("result").getString("latestSnapshotId");
 
         try {
             Thread.sleep(1000);
@@ -80,7 +85,7 @@ public class TestForceUpdate extends XMBaseTest {
         }
 
         //检查会员对该卡是否超出购买上限
-        boolean limitResult=orderTools.checkAllowPurchase("MEMBER_CARD",cardId,memberId,"1",xmAppApi.getLoginInfo().getBrandId(),xmAppApi.getLoginInfo().getStudioId(),xmAppApi.getLoginInfo().getAdminId()).getBoolean("success");
+        boolean limitResult = orderTools.checkAllowPurchase("MEMBER_CARD", cardId, memberId, "1", xmAppApi.getLoginInfo().getBrandId(), xmAppApi.getLoginInfo().getStudioId(), xmAppApi.getLoginInfo().getAdminId()).getBoolean("success");
 
         try {
             Thread.sleep(1000);
@@ -88,12 +93,12 @@ public class TestForceUpdate extends XMBaseTest {
             throw new RuntimeException(e);
         }
 
-        if(limitResult == true) {
+        if (limitResult == true) {
 
             //创建订单
             JSONObject orderResult = orderTools.signOrder(cardId, latestSnapshotId, quantity, price, validPeriod, latestSnapshotId, price / 2, "PURCHASE",
                     "MEMBER_CARD", memberId, price - price / 2, price - price / 2, "1");
-            String getDetailId = orderResult.getString("result");
+            getDetailId = orderResult.getString("result");
 
             try {
                 Thread.sleep(3000);
@@ -104,24 +109,24 @@ public class TestForceUpdate extends XMBaseTest {
         }
 
         //获取正式会员列表
-        JSONObject memberResult=tools.search("NORMAL","NORMAL");
+        JSONObject memberResult = tools.search("NORMAL", "NORMAL");
 
-        int memberResultPages=Integer.parseInt(memberResult.getJSONObject("result").getString("pages"));
-        int memberResultTotal=Integer.parseInt(memberResult.getJSONObject("result").getString("total"));
+        int memberResultPages = Integer.parseInt(memberResult.getJSONObject("result").getString("pages"));
+        int memberResultTotal = Integer.parseInt(memberResult.getJSONObject("result").getString("total"));
 
 
-        for(int k=0; k == memberResultPages+1; k++){
-            int n =k==memberResultPages ? (memberResultTotal%10==0 ? 10 : memberResultTotal%10) : 10;
-            JSONArray records=memberResult.getJSONObject("result").getJSONArray("records");
-            boolean flag=true;
-            for(int i=0; i<n; i++){
-                String memberResultId=records.getJSONObject(i).getString("id");
-                if(memberResultId.equals(memberId)){
+        for (int k = 0; k == memberResultPages + 1; k++) {
+            int n = k == memberResultPages ? (memberResultTotal % 10 == 0 ? 10 : memberResultTotal % 10) : 10;
+            JSONArray records = memberResult.getJSONObject("result").getJSONArray("records");
+            boolean flag = true;
+            for (int i = 0; i < n; i++) {
+                String memberResultId = records.getJSONObject(i).getString("id");
+                if (memberResultId.equals(memberId)) {
                     flag = true;
                     break;
                 }
             }
-            Assert.assertEquals(true,flag,"潜在会员购买订单已完成,但会员状态转成正式会员失败");
+            Assert.assertEquals(true, flag, "潜在会员购买订单已完成,但潜在会员转正式会员失败");
         }
 
         try {
@@ -130,12 +135,13 @@ public class TestForceUpdate extends XMBaseTest {
             throw new RuntimeException(e);
         }
 
-        //编辑
+
+        //编辑正式会员
         JSONObject jsonObject = new JSONObject();
         jsonObject.put("brandId", xmAppApi.getLoginInfo().getBrandId());
         jsonObject.put("studioId", xmAppApi.getLoginInfo().getStudioId());
         jsonObject.put("operatorId", xmAppApi.getLoginInfo().getAdminId());
-        jsonObject.put("status", "POTENTIAL");
+        jsonObject.put("status", "NORMAL");
         jsonObject.put("name", "自动化正式会员" + RandomStringUtil.randomString(2));
         jsonObject.put("phone", RandomStringUtil.randomMobile("22"));
         jsonObject.put("gender", "WOMEN");
@@ -145,21 +151,146 @@ public class TestForceUpdate extends XMBaseTest {
         jsonObject.put("idCardCode", "411421199808080225");
         jsonObject.put("height", "186");
         jsonObject.put("weight", "76");
-        jsonObject.put("trainTarget", "塑形"+RandomStringUtil.randomString(2));
-        jsonObject.put("profession", "金融"+RandomStringUtil.randomString(2));
-        jsonObject.put("incomeLevel", "亿万富翁"+RandomStringUtil.randomString(2));
-        jsonObject.put("address", "地址"+RandomStringUtil.randomString(6));
+        jsonObject.put("trainTarget", "塑形");
+        jsonObject.put("profession", "金融");
+        jsonObject.put("incomeLevel", "亿万富翁");
+        jsonObject.put("address", "地址");
         jsonObject.put("emergencyContactPerson", RandomStringUtil.randomString(3));
         jsonObject.put("emergencyContactPhone", RandomStringUtil.randomMobile("66"));
         jsonObject.put("resourceId", "1");
         jsonObject.put("intention", "HIGH");
         jsonObject.put("creatorId", xmAppApi.getLoginInfo().getAdminId());
-        jsonObject.put("remark", "备注"+RandomStringUtil.randomString(12));
+        jsonObject.put("remark", "备注备注备注备注备注备注备注备注");
         jsonObject.put("memberId", memberId);
 
 
         xmAppApi.doRequest(RequestType.JSON, params, jsonObject.toJSONString(), headers).assetsSuccess(true);
-        Assert.assertEquals(XMJSONPath.readPath(xmAppApi.getBodyInJSON(),"$success"),"true","编辑正式会员信息失败");
+        Assert.assertEquals(XMJSONPath.readPath(xmAppApi.getBodyInJSON(), "$success"), "true", "编辑正式会员信息失败");
+
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+
+        //校验编辑正式会员信息
+        //获取正式会员详情
+        JSONObject result = memberTools.findStudioMemberDetail(memberId).getJSONObject("result");
+        Assert.assertEquals(result.getString("status"), "NORMAL", "订单购买成功后，潜在学员未转成正式会员");
+        Assert.assertEquals(result.getString("gender"), "WOMEN", "编辑之后，性别编辑失败");
+        Assert.assertEquals(result.getString("idCardType"), "IDENTITY", "编辑之后，证件类型编辑失败");
+        Assert.assertEquals(result.getString("idCardCode"), "411421199808080225", "编辑之后，身份证号编辑失败");
+        Assert.assertEquals(result.getString("height"), "186", "编辑之后，身高编辑失败");
+        Assert.assertEquals(result.getString("weight"), "76", "编辑之后，体重编辑失败");
+        Assert.assertEquals(result.getString("trainTarget"), "塑形", "编辑之后，训练目标编辑失败");
+        Assert.assertEquals(result.getString("profession"), "金融", "编辑之后，职业编辑失败");
+        Assert.assertEquals(result.getString("incomeLevel"), "亿万富翁", "编辑之后，收入水平编辑失败");
+        Assert.assertEquals(result.getString("address"), "地址", "编辑之后，地址编辑失败");
+        Assert.assertEquals(result.getString("resourceId"), "1", "编辑之后，来源编辑失败");
+        Assert.assertEquals(result.getString("remark"), "备注备注备注备注备注备注备注备注", "编辑之后，备注编辑失败");
+
+
+        //编辑流失会员信息
+
+
+        //退单正式会员转流失会员（状态流转：正式转流失）
+
+        //退单
+        //创建退单订单
+        //查询要退的卡id 从listUserRefundableCard-查询用户可退的会员卡列表中获取
+        JSONObject listUserRefundableCardResult = orderTools.listUserRefundableCard("MEMBER", "", memberId);
+        String listUserRefundableId = listUserRefundableCardResult.getJSONArray("result").getJSONObject(0).getString("id");
+
+        //查询订单或者收支可退流水金额（包含乐动收银状态信息）
+        boolean checkRefundableAmountResult = orderTools.checkRefundableAmount(getDetailId, price - price / 2).getBoolean("success");
+
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+
+        if (checkRefundableAmountResult == true) {
+            //退单-会员卡
+            JSONObject refundOrderResult = orderTools.refundOrder(0, listUserRefundableId, quantity, price - price / 2, "MEMBER_CARD",
+                    memberId, price - price / 2, price - price / 2, "1");
+            try {
+                Thread.sleep(3000);
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            }
+
+        }
+
+        //获取流失会员列表
+        JSONObject historyResult = tools.search("HISTORY", "HISTORY").getJSONObject("result");
+        String historyId = historyResult.getJSONArray("records").getJSONObject(0).getString("id");
+        String historyStatus = historyResult.getJSONArray("records").getJSONObject(0).getString("status");
+        Assert.assertEquals(historyId, memberId, "列表中的流失会员非上述正式转流失的会员");
+        Assert.assertEquals(historyStatus, "HISTORY", "正式会员转流失会员失败");
+
+        //获取会员详情
+        JSONObject historyDetailResult = memberTools.findStudioMemberDetail(memberId).getJSONObject("result");
+        String historyDetailStatus = historyDetailResult.getString("status");
+        Assert.assertEquals(historyDetailStatus, "HISTORY", "正式会员退单已完成,正式会员转流失会员失败");
+
+        try {
+            Thread.sleep(3000);
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+
+        //编辑流失会员
+        JSONObject object = new JSONObject();
+        object.put("brandId", xmAppApi.getLoginInfo().getBrandId());
+        object.put("studioId", xmAppApi.getLoginInfo().getStudioId());
+        object.put("operatorId", xmAppApi.getLoginInfo().getAdminId());
+        object.put("status", "HISTORY");
+        object.put("name", "自动化流失会员" + RandomStringUtil.randomString(2));
+        object.put("phone", RandomStringUtil.randomMobile("22"));
+        object.put("gender", "MAN");
+        object.put("wechat", RandomStringUtil.randomMobile("66"));
+        object.put("birthday", TimeUtils.getBeforeDayDate(10));
+        object.put("idCardType", "IDENTITY");
+        object.put("idCardCode", "411421199808080888");
+        object.put("height", "196");
+        object.put("weight", "86");
+        object.put("trainTarget", "爵士");
+        object.put("profession", "公务员");
+        object.put("incomeLevel", "千万富翁");
+        object.put("address", "河南省郑州市");
+        object.put("emergencyContactPerson", RandomStringUtil.randomString(3));
+        object.put("emergencyContactPhone", RandomStringUtil.randomMobile("66"));
+        object.put("resourceId", "2");
+        object.put("intention", "HIGH");
+        object.put("creatorId", xmAppApi.getLoginInfo().getAdminId());
+        object.put("remark", "备注");
+        object.put("memberId", memberId);
+
+        xmAppApi.doRequest(RequestType.JSON, params, object.toJSONString(), headers).assetsSuccess(true);
+        Assert.assertEquals(XMJSONPath.readPath(xmAppApi.getBodyInJSON(), "$success"), "true", "编辑流失会员信息失败");
+
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+
+        //校验编辑流失会员信息
+        //获取流失会员详情
+        JSONObject historyDetailResult1 = memberTools.findStudioMemberDetail(memberId).getJSONObject("result");
+        Assert.assertEquals(historyDetailResult1.getString("status"), "HISTORY", "退单成功后，正式学员未转成流失会员");
+        Assert.assertEquals(historyDetailResult1.getString("gender"), "MAN", "编辑之后，性别编辑失败");
+        Assert.assertEquals(historyDetailResult1.getString("idCardType"), "IDENTITY", "编辑之后，证件类型编辑失败");
+        Assert.assertEquals(historyDetailResult1.getString("idCardCode"), "411421199808080888", "编辑之后，身份证号编辑失败");
+        Assert.assertEquals(historyDetailResult1.getString("height"), "196", "编辑之后，身高编辑失败");
+        Assert.assertEquals(historyDetailResult1.getString("weight"), "86", "编辑之后，体重编辑失败");
+        Assert.assertEquals(historyDetailResult1.getString("trainTarget"), "爵士", "编辑之后，训练目标编辑失败");
+        Assert.assertEquals(historyDetailResult1.getString("profession"), "公务员", "编辑之后，职业编辑失败");
+        Assert.assertEquals(historyDetailResult1.getString("incomeLevel"), "千万富翁", "编辑之后，收入水平编辑失败");
+        Assert.assertEquals(historyDetailResult1.getString("address"), "河南省郑州市", "编辑之后，地址编辑失败");
+        Assert.assertEquals(historyDetailResult1.getString("resourceId"), "2", "编辑之后，来源编辑失败");
+        Assert.assertEquals(historyDetailResult1.getString("remark"), "备注", "编辑之后，备注编辑失败");
 
 
     }