小商品零售平台+后台管理系统（day9~）

加油加油，坚持打卡！！！

springboot+thymeleaf+mybatis

今日完成的部分：

想法：

首先根据入库表和出库表，查询出库商品的名称、所属分类、供应商、进货价格、出售价格、出售个数、单个成本，然后通过一系列的代码来完成对销售产品的各项数据计算。

（在销售统计页面不能人为的随意对销售数据进行修改是根据由商品零售平台出售商品，导致商品出入库的情况进行变动从而对销售情况进行的销量统计）

删除按钮是给管理员使用，强制删除一些错误的记录。

也就是说，销售统计管理页面的数据根据入库表、出库表的变动而变动（出库表、入库表的数据变化、通过计算更新，本页面的数据也会发生变化）

一、销售统计管理

    <!--联表查询所有卖出去的东西的详细信息（商品入库表、商品出库表）-->
    <select id="selectTwoCommodity" parameterType="CommodityOut" resultType="CommodityOut">
        SELECT DISTINCT a.name,a.type,a.number,a.supplier,b.price,b.money
        FROM commodityout AS a JOIN commodity AS b
                                    ON a.name = b.name
    </select>

联表查询出来的数据是只根据入库表、出库表中存在的不重复的商品名称来查询的，相同的商品名称、供应商的数据会存在多条数据，就需要在后台的代码里将这些按照商品名称来查询出来的数据归类，每种商品，跟库存管理一样，只显示一条数据。

 后台代码;

package com.blbl.xy.controller.items;

import com.blbl.xy.pojo.items.*;
import com.blbl.xy.service.CommodityOutService;
import com.blbl.xy.service.CommodityService;
import com.blbl.xy.service.SalesService;
import com.blbl.xy.service.SupplierService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

import java.util.List;

/**
 * 销售统计Controller
 *
 * @author yxy
 * @date 2023/4/27
 */
@Controller
public class SalesController {

    @Autowired
    private SalesService salesService;

    @Autowired
    private CommodityService commodityService;

    @Autowired
    private SupplierService supplierService;

    @Autowired
    private CommodityOutService commodityOutService;

    //销售统计列表
    @RequestMapping("/items/sales/index")
    public String index(Model model,Sales sales){
        //1、联表查询出库表和入库表，查询一条商品的  名称、类型、供应商、进货价格、销售价格、销售总数量、销售总金额=（销售数量*销售价格），总利润=（销售总金额-（销售数量*进货价格））
        //2、进行判断，统计列表中是否存在该商品，不存在则新增一条记录
        //3、用数组存储根据商品名称、供应商来存储不重复的商品名称和供应商
        //4、根据不重复的商品名称、供应商来遍历累加销售总量、销售总额、总利润、总成本

        //联表查询出来当前卖出去东西的信息list
        List<CommodityOut> commodities = salesService.selectTwoCommodity();

        String [] str = new String[commodities.size()];//入库商品名称数组
        String [] str1 = new String[commodities.size()];//入库供应商数组
       int len= commodities.size();
        for(int i=0;i<len;i++){//因为查询出来卖出去的东西肯定不止一条记录
            //判断销售统计表中是否有这条记录
            Sales sales2 = new Sales();//实例化销售统计表
            sales2.setName(commodities.get(i).getName());//商品名称
            sales2.setSupplier(commodities.get(i).getSupplier());//供应商
            List<Sales> list1 = salesService.selectSalesList(sales2);//根据商品名称、供应商来进行查询。（根库存总表一样，同样的名称、供应商的商品，在销售统计中只能存在一条记录）
            if(list1.size()==0){//如果数据库中查询不到这条记录
                sales2.setType(commodities.get(i).getType());//新增商品分类
                 salesService.insertSales(sales2);//新增一条记录

                String oldName = "";//上一个商品名称
                oldName = i==0?commodities.get(i).getName():commodities.get(i-1).getName();//如果i==0就是刚刚开始遍历，那么我的上一个商品名称就是等于当前遍历到的商品名称
                //如果i==0，那么就将当前遍历到的商品名称写入数组   否则则进行判断与上一个商品名称是否相同，相同则不保存，不想同则保存
                str[i] = i==0?commodities.get(i).getName():(oldName==commodities.get(i).getName()?"":commodities.get(i).getName());

                String oldSupplier = "";//获取上一个供应商名称
                oldSupplier = i==0 ?commodities.get(i).getSupplier():commodities.get(i-1).getSupplier();
                str1[i] = i==0?commodities.get(i).getSupplier():(oldSupplier==commodities.get(i).getSupplier()?"":commodities.get(i).getSupplier());

                //判断list循环是否已经到了最后一次了
                if(i==(len-1)){
                    for(int k =0;k<str.length;k++){
                        if(!"".equals(str[k])){//将商品名称数组中所有的""剔除
                            for (int h = 0;h<str1.length;h++){
                                if(!"".equals(str1[h])){//将商品名称中所有的""剔除
                                    //联表查询，查询出来所有出库的信息
                                    CommodityOut commodityOut = new CommodityOut();
                                    commodityOut.setName(str[k]);
                                    commodityOut.setSupplier(str1[h]);
                                    //查询商品详细
                                    List<CommodityOut> list = salesService.selectList(commodityOut);
                                    if(list.size()!=0){
                                        String [] total = getSum(list);//获取计算到所有数值的数组
                                       Sales sales3 = new Sales();
                                       sales3.setName(list.get(0).getName());
                                       sales3.setSupplier(list.get(0).getSupplier());
                                        Sales sales1 = salesService.findID(sales3);
                                        sales3.setId(sales1.getId());
                                        //总销量
                                        sales3.setNumber(Integer.parseInt(total[0]));
                                        //总销售金额
                                        sales3.setMoney(total[1]);
                                        //总利润
                                        sales3.setProfit(total[2]);
                                        //总成本
                                        sales3.setCost(total[3]);
                                        salesService.updateSales(sales3);
                                    }
                                }
                            }
                        }
                    }
                }
            }else{
                String oldName = "";//上一个商品名称
                oldName = i==0?commodities.get(i).getName():commodities.get(i-1).getName();//如果i==0就是刚刚开始遍历，那么我的上一个商品名称就是等于当前遍历到的商品名称
                //如果i==0，那么就将当前遍历到的商品名称写入数组   否则则进行判断与上一个商品名称是否相同，相同则不保存，不想同则保存
                str[i] = i==0?commodities.get(i).getName():(oldName==commodities.get(i).getName()?"":commodities.get(i).getName());

                String oldSupplier = "";//获取上一个供应商名称
                oldSupplier = i==0 ?commodities.get(i).getSupplier():commodities.get(i-1).getSupplier();
                str1[i] = i==0?commodities.get(i).getSupplier():(oldSupplier==commodities.get(i).getSupplier()?"":commodities.get(i).getSupplier());

                //判断list循环是否已经到了最后一次了
                if(i==(len-1)){
                    for(int k =0;k<str.length;k++){
                        if(!"".equals(str[k])){//将商品名称数组中所有的""剔除
                            for (int h = 0;h<str1.length;h++){
                                if(!"".equals(str1[h])){//将商品名称中所有的""剔除
                                    //联表查询，查询出来所有出库的信息
                                    CommodityOut commodityOut = new CommodityOut();
                                    commodityOut.setName(str[k]);
                                    commodityOut.setSupplier(str1[h]);
                                    //查询商品详细
                                    List<CommodityOut> list = salesService.selectList(commodityOut);
                                    if(list.size()!=0){
                                        String [] total = getSum(list);//获取计算到所有数值的数组
                                        Sales sales3 = new Sales();
                                        sales3.setName(list.get(0).getName());
                                        sales3.setSupplier(list.get(0).getSupplier());
                                        Sales s2 = new Sales();
                                        List<Sales> s1 = salesService.selectSalesList(sales3);
                                        for(int m=0;m<s1.size();m++){//判断是否需要修改商品销量统计表中的数据（如果不同就修改，相同就不改了）
                                            if(s1.get(m).getNumber()!=Integer.parseInt(total[0])||s1.get(m).getMoney()!=total[1]||s1.get(m).getProfit()!=total[2]||s1.get(m).getCost()!=total[3]){
                                                Sales sales1 = salesService.findID(sales3);
                                                sales3.setId(sales1.getId());
                                                //总销量
                                                sales3.setNumber(Integer.parseInt(total[0]));
                                                //总销售金额
                                                sales3.setMoney(total[1]);
                                                //总利润
                                                sales3.setProfit(total[2]);
                                                //总成本
                                                sales3.setCost(total[3]);

                                                salesService.updateSales(sales3);
                                                //极端的条件下，卖出去东西又全部退回了，但是我的销售管理表里面已经记录了这条信息，但是目前因为退货的原因，这件商品一件都没有卖出去，
                                                //那么我的销量统计表中应该将这条数据删除，保证销量统计的正确性。（全部退货，一件都没有卖出去的情况下，不应该将退货之前进行统计的商品销量计入！）
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        Sales s1 = new Sales();
        List<Sales> sales1 = salesService.selectSalesList(s1);//初始化显示所有数据
        model.addAttribute("sales",sales1);
        //获取入库表中所有的商品类型（后期可能会将商品类型单独拎出来做一张表！）
        Commodity commodity = new Commodity();
        model.addAttribute("commodity",(commodityService.getLimit(commodity)));
        Supplier supplier1 = new Supplier();
        model.addAttribute("supplier",(supplierService.selectSupplierList(supplier1)));
        return "/items/sales/index";
    }

    //计算销售总数量、销售总金额，销售总利润、总成本
    public String[] getSum(List<CommodityOut> str){//!!注意注意，累加的时候区分字符串相加和数值类型相加的区别：1+1=2,"1"+"1"="11"!!!!!
    //可以返回一个数组，str[4],str[0]=销售总数量，str[1]=销售总金额，str[2]=销售总利润,str[3]=总成本
        int sum = 0;//总销量
        double moneySum = 0;//总成本
        double profitSum = 0;//总利润
        double priceSum = 0;//总销售金额
        for(int i=0;i<str.size();i++){
            //累加总销量
            sum+=Integer.parseInt(str.get(i).getNumber());
            //累计总成本
            moneySum+=Double.parseDouble(str.get(i).getMoney());
            //累计总销售金额
            priceSum+=Double.parseDouble(str.get(i).getPrice());
            if(i==str.size()-1){//遍历完成
                //计算总利润
                profitSum = sum*priceSum-sum*moneySum;
            }
        }
        String [] str1 = new String[4];
        str1[0] = String.valueOf(sum);
        str1[1] = String.valueOf(priceSum);
        str1[2] = String.valueOf(profitSum);
        str1[3] = String.valueOf(moneySum);
        return str1;
    }

    //根据前端输入条件进行搜索
    @RequestMapping("/selectSales")
    public String selectSales(@RequestParam(value = "name",required = false) String name, @RequestParam(value = "type",required = false) String type,
                                     @RequestParam(value = "supplier",required = false) String supplier, Model model){
        Sales sales = new Sales();
        sales.setName(name);
        sales.setType(type);
        sales.setSupplier(supplier);
        List<Sales> sales1 = salesService.selectSalesList(sales);
        model.addAttribute("sales",sales1);

        Commodity commodity = new Commodity();
        model.addAttribute("commodity",(commodityService.getLimit(commodity)));
        Supplier supplier1 = new Supplier();
        model.addAttribute("supplier",(supplierService.selectSupplierList(supplier1)));
        return "/items/sales/index";
    }

    //管理员强制删除销量统计信息！（销量统计表中的数据是联表根据数据计算得出来，然后修改填入的，正常的网站运营不会用到删除来保证销售统计表的正常显示）
    //但是，有的时候，可能因为恶意修改录入信息获取卖出后又退货，导致这边数据不对，所以需要管理员来强制删除！
    @RequestMapping("/deleteSales")
    public String deleteSales(int id){
        salesService.deleteSaless(String.valueOf(id));
        return "/items/sales/index";
    }
}