Merge pull request '完成满意度统计功能开发' (#1) from develop into master

Reviewed-on: http://101.201.121.115:3000/leo/SSW_WebPlatform/pulls/1

demo.go

@@ -1,10 +0,0 @@
-/******************************************************************************
- * @Function Name      :
- *-----------------------------------------------------------------------------
- * @Description        :
- * @Function Parameters:
- * @Return Value       :
- * @Author             : Zhang Xin
- * @Date               : 2021/3/3 11:02
- ******************************************************************************/
- package main

utils/utils.go

@@ -393,4 +393,6 @@ func Round(num float64) int {
 	num += 0.5
 	num = math.Floor(num)
 	return int(num)
-}
+}
+
+

utils/value.go

@@ -1,6 +1,7 @@
 package utils
 
 import (
+	"fmt"
 	"reflect"
 	"strconv"
 	"time"
@@ -352,4 +353,13 @@ func IDsToString(ids []int) string {
 		str = str + "')"
 	}
 	return str
+}
+
+func Decimal(value float64,length int) float64 {
+	if length <= 0{
+		length = 2
+	}
+	format := "%."+strconv.Itoa(length)+"f"
+	value, _ = strconv.ParseFloat(fmt.Sprintf(format, value), 64)
+	return value
 }

web/controllers/c_surveysheet_controller.go

@@ -194,3 +194,23 @@ func SelectArrCSurveysheet(ctx iris.Context) {
 	}
 	supports.Ok(ctx, supports.OptionSuccess, result)
 }
+
+
+func StatisticData(ctx iris.Context) {
+	user, ok := jwts.ParseToken(ctx)
+	utils.TrimStruct(user, *user)
+	if !ok {
+		supports.Error(ctx, iris.StatusBadRequest, supports.ParseParamsFailur, nil)
+		return
+	}
+	me := new(models.CSurveysheetResult)
+	selectType := ctx.URLParam("selectType")
+	me.Cid = user.Pid
+	result, err := me.Statistic(selectType)
+	if err != nil {
+
+		supports.Error(ctx, iris.StatusBadRequest, err.Error(), nil)
+		return
+	}
+	supports.Ok(ctx, supports.OptionSuccess, result)
+}

web/models/buildingtab.go

@@ -0,0 +1,112 @@
+package models
+
+import (
+	"SSW_WebPlatform/db"
+	"SSW_WebPlatform/utils"
+	"errors"
+	"xorm.io/core"
+)
+
+type Buildingtab struct {
+	Cid              int     `json:"cid" xorm:"not null pk INT(4)"`
+	Buildingid       string  `json:"buildingid" xorm:"not null pk VARCHAR(100)"`
+	Descr            string  `json:"descr" xorm:"VARCHAR(255)"`
+	Address          string  `json:"address" xorm:"VARCHAR(255)"`
+	Constructionarea float64 `json:"constructionarea" xorm:"DECIMAL(10,2)"`
+	Totalhouseholds  int     `json:"totalhouseholds" xorm:"INT(4)"`
+	Propertytypeid   string  `json:"propertytypeid" xorm:"VARCHAR(100)"`
+	Createtime       string  `json:"createtime" xorm:"VARCHAR(14)"`
+	Lastmodifytime   string  `json:"lastmodifytime" xorm:"VARCHAR(14)"`
+	Lastmodifyby     string  `json:"lastmodifyby" xorm:"VARCHAR(40)"`
+}
+
+func (t *Buildingtab) TableName() string {
+	return "buildingtab"
+}
+
+// 清除string字段的右侧空格
+func (t *Buildingtab) Clipped() {
+	utils.TrimStruct(t, *t)
+}
+
+//增
+func (t *Buildingtab) Add() error {
+	e := db.MasterEngine()
+	countrole := new(Buildingtab)
+	affw, err := e.Table("buildingtab").ID(core.PK{t.Cid, t.Buildingid}).Count(countrole)
+	if err != nil {
+		return err
+	}
+	if affw > 0 {
+		return errors.New("数据已经存在！")
+	}
+	_, err = e.Table("buildingtab").Insert(t)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+//删
+func (t *Buildingtab) Del() bool {
+	e := db.MasterEngine()
+	_, err := e.ID(core.PK{t.Cid, t.Buildingid}).Delete(&Buildingtab{})
+	if err != nil {
+		return false
+	}
+	return true
+}
+
+//改
+func (t *Buildingtab) Update() bool {
+	e := db.MasterEngine()
+	_, err := e.ID(core.PK{t.Cid, t.Buildingid}).Update(t)
+	if err != nil {
+		return false
+	}
+	return true
+}
+
+//查
+func (t *Buildingtab) SelectOne() (Buildingtab, error) {
+	e := db.MasterEngine()
+	var data Buildingtab
+	_, err := e.ID(core.PK{t.Cid, t.Buildingid}).Get(&data)
+	if err != nil {
+		return data, err
+	}
+	return data, nil
+}
+
+//分页
+func (t *Buildingtab) GetPage(pageSize int, pageIndex int) ([]Buildingtab, int, error) {
+	data := make([]Buildingtab, 0)
+	e := db.MasterEngine()
+	query := e.Table("buildingtab").Where("cid = ? ", t.Cid)
+	table := e.Table("buildingtab").Where("cid = ? ", t.Cid)
+	if !utils.ValueIsEmpty(t.Descr) {
+		descr := "%" + t.Descr + "%"
+		query = query.And("descr like ?", descr)
+		table = query.And("descr like ?", descr)
+	}
+	Offset := (pageIndex - 1) * pageSize
+	err := query.Limit(pageSize,Offset).Desc("createtime").Find(&data)
+	pcount := new(Buildingtab)
+	count, err := table.Count(pcount)
+	if err != nil {
+		return data, 0, err
+	}
+	return data, int(count), nil
+}
+
+//查询所有
+func (t *Buildingtab) SelectAll() ([]*Buildingtab, error) {
+	e := db.MasterEngine()
+	data := make([]*Buildingtab, 0)
+
+	err := e.Where("cid = ?", t.Cid).Find(&data)
+	if err != nil {
+		return data, err
+	}
+	return data, nil
+}

web/models/c_surveysheet_result.go

@@ -4,6 +4,7 @@ import (
 	"SSW_WebPlatform/db"
 	"SSW_WebPlatform/utils"
 	"SSW_WebPlatform/web/middleware/glog"
+	"fmt"
 	"sort"
 	"strings"
 	"time"
@@ -28,13 +29,13 @@ type CSurveysheetResult struct {
 	Status              int    `json:"status" xorm:"not null comment('状态') INT(11)"`
 	Remark              string `json:"remark" xorm:"default 'NULL' comment('备注') VARCHAR(255)"`
 	// 被访问者性别 male 和female
-	Sex        string `json:"sex" xorm:"VARCHAR(10)"`
+	Sex string `json:"sex" xorm:"VARCHAR(10)"`
 	// 被访问者类型 业主1 租户2
-	PersonType int    `json:"persontype" xorm:"'persontype' INT(1)"`
+	PersonType int `json:"persontype" xorm:"'persontype' INT(1)"`
 	// 被访问者年龄 1-22岁以下 2-22到59岁 3-60岁以上
-	Age        int    `json:"age" xorm:"INT(1)"`
+	Age int `json:"age" xorm:"INT(1)"`
 	// 被访问者居住时间 1-1年以内 2-1到3年 2-3到5年 3-5年以上
-	LiveTime   int    `json:"livetime" xorm:"'livetime' INT(1)"`
+	LiveTime int `json:"livetime" xorm:"'livetime' INT(1)"`
 	// 被访问者姓名
 	PersonName string `json:"personname" xorm:"'personname' VARCHAR(40)"`
 	//// 调查日期
@@ -465,3 +466,743 @@ func (t *CSurveysheetResult) SatisfactionMultipleTotal(search SearchConditions)
 	}
 	return total, nil
 }
+
+type SingleSubjectInfo struct {
+	SubjectName string `json:"subjectName"`
+	Count       int    `json:"count"`
+}
+
+type JoinResult struct {
+	CSurveysheetResult     `xorm:"extends"`
+	CSurveysheetResultlst  `xorm:"extends"`
+	CSurveysheetSubjectlst `xorm:"extends"`
+	Buildingtab            `xorm:"extends"`
+}
+
+// 满意度统计
+func (c *CSurveysheetResult) Statistic(selectType string) (result StatisticData, err error) {
+	engine := db.MasterEngine()
+	engine.ShowSQL(true)
+	query := engine.Table("c_surveysheet_resultlst").Join("LEFT", "c_surveysheet_result", "c_surveysheet_resultlst.cid = c_surveysheet_result.cid and c_surveysheet_resultlst.surveynr = c_surveysheet_result.surveynr")
+	query = query.Join("LEFT", "c_surveysheet_subjectlst", "c_surveysheet_resultlst.cid = c_surveysheet_subjectlst.cid and c_surveysheet_resultlst.subjectid = c_surveysheet_subjectlst.subjectid")
+	query = query.Join("LEFT", "buildingtab", "c_surveysheet_result.cid = buildingtab.cid and c_surveysheet_result.buildingid = buildingtab.buildingid")
+	query = query.Where("c_surveysheet_resultlst.cid = ? and c_surveysheet_resultlst.assessmentvalue != 0", c.Cid)
+	joinResultLi := make([]JoinResult, 0)
+	err = query.Find(&joinResultLi)
+	if err != nil {
+		return result, err
+	}
+	cateMap := make(map[string][]JoinResult)
+	for _, joinResult := range joinResultLi {
+		cate := joinResult.CSurveysheetSubjectlst.SubjectCategoryid
+		if cate == "整体满意程度" {
+			continue
+		}
+		_, exist := cateMap[cate]
+		if !exist {
+			cateMap[cate] = make([]JoinResult, 0)
+			cateMap[cate] = append(cateMap[cate], joinResult)
+		} else {
+			cateMap[cate] = append(cateMap[cate], joinResult)
+		}
+	}
+	cateStatisticDataLi := make([]CateStatisticData, 0)
+	for cate, joinResultLi := range cateMap {
+		var cateStatisticData CateStatisticData
+		cateStatisticData.Cate = cate
+		cateStatisticData.SubjectStaticDataLi = make([]SubjectStaticData, 0)
+		tempSubjectMap := make(map[string]SubjectStaticData)
+		for _, joinResult := range joinResultLi {
+			cateStatisticData.Count++
+			var tempSubjectStatisticData SubjectStaticData
+
+			subjectId := joinResult.CSurveysheetResultlst.Subjectid
+			_, exist := tempSubjectMap[subjectId]
+			if !exist {
+				tempSubjectMap[subjectId] = SubjectStaticData{}
+				tempSubjectStatisticData = tempSubjectMap[subjectId]
+				tempSubjectStatisticData.CateId = cate
+				tempSubjectStatisticData.Pos = joinResult.CSurveysheetSubjectlst.Pos
+			} else {
+				tempSubjectStatisticData = tempSubjectMap[subjectId]
+			}
+			tempSubjectStatisticData.SubjectName = joinResult.CSurveysheetSubjectlst.Subjecttext
+			switch joinResult.CSurveysheetResultlst.SelectedOptions {
+			case "A":
+				tempSubjectStatisticData.ASum++
+				cateStatisticData.ASum++
+			case "B":
+				tempSubjectStatisticData.BSum++
+				cateStatisticData.BSum++
+			case "C":
+				tempSubjectStatisticData.CSum++
+				cateStatisticData.CSum++
+			case "D":
+				tempSubjectStatisticData.DSum++
+				cateStatisticData.DSum++
+			case "E":
+				tempSubjectStatisticData.ESum++
+				cateStatisticData.ESum++
+			}
+			tempSubjectStatisticData.Count++
+			tempSubjectMap[subjectId] = tempSubjectStatisticData
+		}
+		for _, data := range tempSubjectMap {
+			if data.Count == 0 {
+				data.APercent = 0
+				data.BPercent = 0
+				data.CPercent = 0
+				data.DPercent = 0
+				data.EPercent = 0
+			} else {
+				data.APercent = utils.Decimal(float64(data.ASum)/float64(data.Count), 3)
+				data.BPercent = utils.Decimal(float64(data.BSum)/float64(data.Count), 3)
+				data.CPercent = utils.Decimal(float64(data.CSum)/float64(data.Count), 3)
+				data.DPercent = utils.Decimal(float64(data.DSum)/float64(data.Count), 3)
+				data.EPercent = utils.Decimal(float64(data.ESum)/float64(data.Count), 3)
+			}
+			cateStatisticData.SubjectStaticDataLi = append(cateStatisticData.SubjectStaticDataLi, data)
+		}
+		cateStatisticDataLi = append(cateStatisticDataLi, cateStatisticData)
+	}
+	var totalData TotalStatisticData
+	timeStatisticDataLi := make([]TimeStatisticData, 0)
+	recentYearLi := make([]RecentYear, 0)
+
+	tempYearMap := make(map[string]RecentYear)
+	tempTimeMap := make(map[string]TimeStatisticData)
+	tempYearOutMap := make(map[string]YearStatisticData)
+	yearStatisticDataLi := make([]YearStatisticData, 0)
+	for _, joinResult := range joinResultLi {
+		datetimeStr := joinResult.CSurveysheetResult.Actenddate
+		date, err := time.Parse("2006-01-02 15:04:05", datetimeStr)
+		if err != nil {
+			return result, err
+		}
+		year := date.Year()
+		month := int(date.Month())
+		var innerTimeType string
+		if month > 6 {
+			innerTimeType = "年末"
+		} else {
+			innerTimeType = "年中"
+		}
+		descr := fmt.Sprintf("%d%s", year, innerTimeType)
+		if joinResult.CSurveysheetSubjectlst.SubjectCategoryid != "整体满意程度" {
+			var yearData YearStatisticData
+			var cateData SingleCateData
+			_, exist := tempYearOutMap[descr]
+			if exist {
+				yearData = tempYearOutMap[descr]
+			} else {
+				tempYearOutMap[descr] = YearStatisticData{}
+				yearData = tempYearOutMap[descr]
+				yearData.TimeDescr = descr
+				yearData.Year = year
+				yearData.Type = innerTimeType
+				yearData.CateData = make([]SingleCateData, 0)
+				yearData.CateMap = make(map[string]SingleCateData)
+			}
+			cateId := joinResult.CSurveysheetSubjectlst.SubjectCategoryid
+			_, exist = yearData.CateMap[cateId]
+			if exist {
+				cateData = yearData.CateMap[cateId]
+			} else {
+				yearData.CateMap[cateId] = SingleCateData{}
+				cateData = yearData.CateMap[cateId]
+				cateData.CateId = cateId
+			}
+			switch joinResult.CSurveysheetResultlst.SelectedOptions {
+			case "A":
+				cateData.ASum++
+			case "B":
+				cateData.BSum++
+			case "C":
+				cateData.CSum++
+			case "D":
+				cateData.DSum++
+			case "E":
+				cateData.ESum++
+			}
+			cateData.Count++
+			yearData.CateMap[cateId] = cateData
+			tempYearOutMap[descr] = yearData
+			continue
+		}
+
+		// 处理 按年份的统计数据
+		{
+			var recentYear RecentYear
+			_, exist := tempYearMap[descr]
+			if exist {
+				recentYear = tempYearMap[descr]
+			} else {
+				tempYearMap[descr] = RecentYear{}
+				recentYear = tempYearMap[descr]
+				recentYear.TimeDescr = descr
+				recentYear.Year = year
+				if innerTimeType == "年中" {
+					recentYear.Type = 0
+				} else {
+					recentYear.Type = 1
+				}
+			}
+			recentYear.Count++
+			switch joinResult.CSurveysheetResultlst.SelectedOptions {
+			case "A":
+				recentYear.ASum++
+			case "B":
+				recentYear.BSum++
+			case "C":
+				recentYear.CSum++
+			case "D":
+				recentYear.DSum++
+			case "E":
+				recentYear.ESum++
+			}
+			tempYearMap[descr] = recentYear
+		}
+		// 处理 按年份 按居住时间的统计数据
+		{
+			var timeData TimeStatisticData
+			_, exist := tempTimeMap[descr]
+			if exist {
+				timeData = tempTimeMap[descr]
+			} else {
+				tempTimeMap[descr] = TimeStatisticData{}
+				timeData = tempTimeMap[descr]
+				timeData.TimeDescr = descr
+				timeData.Year = year
+				if innerTimeType == "年中" {
+					timeData.Type = 0
+				} else {
+					timeData.Type = 1
+				}
+			}
+			switch joinResult.CSurveysheetResult.LiveTime {
+			case 1:
+				timeData.BreakingInPeriodCount++
+				switch joinResult.CSurveysheetResultlst.SelectedOptions {
+				case "A":
+					timeData.BreakingInPeriodASum++
+				case "B":
+					timeData.BreakingInPeriodBSum++
+				case "C":
+					timeData.BreakingInPeriodCSum++
+				case "D":
+					timeData.BreakingInPeriodDSum++
+				case "E":
+					timeData.BreakingInPeriodESum++
+				}
+			case 2:
+				timeData.BreakingInPeriodCount++
+				switch joinResult.CSurveysheetResultlst.SelectedOptions {
+				case "A":
+					timeData.BreakingInPeriodASum++
+				case "B":
+					timeData.BreakingInPeriodBSum++
+				case "C":
+					timeData.BreakingInPeriodCSum++
+				case "D":
+					timeData.BreakingInPeriodDSum++
+				case "E":
+					timeData.BreakingInPeriodESum++
+				}
+			case 3:
+				timeData.StablePeriodCount++
+				switch joinResult.CSurveysheetResultlst.SelectedOptions {
+				case "A":
+					timeData.StablePeriodASum++
+				case "B":
+					timeData.StablePeriodBSum++
+				case "C":
+					timeData.StablePeriodCSum++
+				case "D":
+					timeData.StablePeriodDSum++
+				case "E":
+					timeData.StablePeriodESum++
+				}
+			case 4:
+				timeData.AcquaintanceCount++
+				switch joinResult.CSurveysheetResultlst.SelectedOptions {
+				case "A":
+					timeData.AcquaintanceASum++
+				case "B":
+					timeData.AcquaintanceBSum++
+				case "C":
+					timeData.AcquaintanceCSum++
+				case "D":
+					timeData.AcquaintanceDSum++
+				case "E":
+					timeData.AcquaintanceESum++
+				}
+			}
+			timeData.Count++
+			tempTimeMap[descr] = timeData
+
+		}
+		// 处理 整体满意度
+		{
+			totalData.Count++
+			switch joinResult.CSurveysheetResultlst.SelectedOptions {
+			case "A":
+				totalData.ASum++
+			case "B":
+				totalData.BSum++
+			case "C":
+				totalData.CSum++
+			case "D":
+				totalData.DSum++
+			case "E":
+				totalData.ESum++
+			}
+		}
+
+	}
+	for _, data := range tempYearOutMap {
+		for _, singleData := range data.CateMap {
+			data.CateData = append(data.CateData, singleData)
+		}
+		yearStatisticDataLi = append(yearStatisticDataLi, data)
+	}
+
+	if totalData.Count == 0 {
+		totalData.APercent = 0
+		totalData.BPercent = 0
+		totalData.CPercent = 0
+		totalData.DPercent = 0
+		totalData.EPercent = 0
+	} else {
+		totalData.APercent = utils.Decimal(float64(totalData.ASum)/float64(totalData.Count), 3)
+		totalData.BPercent = utils.Decimal(float64(totalData.BSum)/float64(totalData.Count), 3)
+		totalData.CPercent = utils.Decimal(float64(totalData.CSum)/float64(totalData.Count), 3)
+		totalData.DPercent = utils.Decimal(float64(totalData.DSum)/float64(totalData.Count), 3)
+		totalData.EPercent = utils.Decimal(float64(totalData.ESum)/float64(totalData.Count), 3)
+	}
+	for _, data := range tempYearMap {
+		recentYearLi = append(recentYearLi, data)
+	}
+	for _, data := range tempTimeMap {
+		timeStatisticDataLi = append(timeStatisticDataLi, data)
+	}
+	var buildingData BuildingData
+	buildingData.BuildingStaticDataLi = make([]BuildingStaticData, 0)
+	tempBuildMap := make(map[string]BuildingStaticData)
+	buildMap := make(map[string][]JoinResult, 0)
+	for _, joinResult := range joinResultLi {
+		buildingDescr := joinResult.Buildingtab.Descr
+		if buildingDescr == "" {
+			buildingDescr = "未知"
+		}
+		{
+			_, exist := buildMap[buildingDescr]
+			if exist {
+				buildMap[buildingDescr] = append(buildMap[buildingDescr], joinResult)
+			} else {
+				buildMap[buildingDescr] = make([]JoinResult, 0)
+				buildMap[buildingDescr] = append(buildMap[buildingDescr], joinResult)
+			}
+		}
+		{
+			if joinResult.CSurveysheetSubjectlst.SubjectCategoryid == "整体满意程度" {
+				var tempBuildData BuildingStaticData
+				_, exist := tempBuildMap[buildingDescr]
+				if exist {
+					tempBuildData = tempBuildMap[buildingDescr]
+				} else {
+					tempBuildMap[buildingDescr] = BuildingStaticData{}
+					tempBuildData = tempBuildMap[buildingDescr]
+					tempBuildData.BuildingRooms = joinResult.Buildingtab.Totalhouseholds
+					buildingData.Rooms += tempBuildData.BuildingRooms
+					tempBuildData.BuildingDescr = joinResult.Buildingtab.Descr
+					if tempBuildData.BuildingDescr == "" {
+						tempBuildData.BuildingDescr = "未知"
+					}
+					tempBuildData.BuildingId = joinResult.Buildingtab.Buildingid
+				}
+				switch joinResult.CSurveysheetResultlst.SelectedOptions {
+				case "A":
+					tempBuildData.ASum++
+					buildingData.ASum++
+				case "B":
+					tempBuildData.BSum++
+					buildingData.BSum++
+				case "C":
+					tempBuildData.CSum++
+					buildingData.CSum++
+				case "D":
+					tempBuildData.DSum++
+					buildingData.DSum++
+				case "E":
+					tempBuildData.ESum++
+					buildingData.ESum++
+				}
+				tempBuildData.BuildingSamples++
+				buildingData.Count++
+				tempBuildMap[buildingDescr] = tempBuildData
+			}
+
+		}
+
+	}
+	buildingCateLi := make([]BuildingCate, 0)
+	for buildingDescr, li := range buildMap {
+		var buildingCate BuildingCate
+		buildingCate.BuildingDescr = buildingDescr
+		buildingCate.CateData = make([]SingleCateData, 0)
+		cateBuildMap := make(map[string]SingleCateData)
+		for _, joinResult := range li {
+			if joinResult.CSurveysheetSubjectlst.SubjectCategoryid == "整体满意程度" {
+				buildingCate.Samples++
+			}
+			cateId := joinResult.CSurveysheetSubjectlst.SubjectCategoryid
+			var cateData SingleCateData
+			_, exist := cateBuildMap[cateId]
+			if exist {
+				cateData = cateBuildMap[cateId]
+			} else {
+				cateBuildMap[cateId] = SingleCateData{}
+				cateData.CateId = cateId
+				cateData.BuildingDescr = buildingDescr
+			}
+			cateData.Count++
+			switch joinResult.CSurveysheetResultlst.SelectedOptions {
+			case "A":
+				cateData.ASum++
+			case "B":
+				cateData.BSum++
+			case "C":
+				cateData.CSum++
+			case "D":
+				cateData.DSum++
+			case "E":
+				cateData.ESum++
+			}
+			cateBuildMap[cateId] = cateData
+		}
+		for _, data := range cateBuildMap {
+			buildingCate.CateData = append(buildingCate.CateData, data)
+		}
+		buildingCateLi = append(buildingCateLi, buildingCate)
+	}
+
+	for _, data := range tempBuildMap {
+		if data.BuildingRooms == 0 {
+			data.SampleBuildingPercent = 0
+		} else {
+			data.SampleBuildingPercent = utils.Decimal(float64(data.BuildingSamples)/float64(data.BuildingRooms), 3)
+		}
+		buildingData.BuildingStaticDataLi = append(buildingData.BuildingStaticDataLi, data)
+	}
+
+	// recentYear 排序
+	li := make([]ICompare, 0, len(recentYearLi))
+	for _, recentYear := range recentYearLi {
+		li = append(li, recentYear)
+	}
+	li = BubbleSort(li)
+	result.RecentYears = make([]RecentYear, 0, len(li))
+	for _, data := range li {
+		result.RecentYears = append(result.RecentYears, data.(RecentYear))
+	}
+
+	// timeStatisticData 排序
+	li = make([]ICompare, 0, len(timeStatisticDataLi))
+	for _, timeStatisticData := range timeStatisticDataLi {
+		li = append(li, timeStatisticData)
+	}
+	li = BubbleSort(li)
+	result.Time = make([]TimeStatisticData, 0, len(timeStatisticDataLi))
+	for _, data := range li {
+		result.Time = append(result.Time, data.(TimeStatisticData))
+	}
+
+	// cateSatisticData排序
+	li = make([]ICompare, 0, len(cateStatisticDataLi))
+	for _, cateStatisticData := range cateStatisticDataLi {
+		li = append(li, cateStatisticData)
+	}
+	li = BubbleSort(li)
+	result.Cate = make([]CateStatisticData, 0, len(cateStatisticDataLi))
+	for _, data := range li {
+		result.Cate = append(result.Cate, data.(CateStatisticData))
+	}
+	// building data 排序
+	buildingLi := buildingData.BuildingStaticDataLi
+	li = make([]ICompare, 0, len(buildingLi))
+	for _, building := range buildingLi {
+		li = append(li, building)
+	}
+	li = BubbleSort(li)
+	buildingData.BuildingStaticDataLi = make([]BuildingStaticData, 0, len(buildingLi))
+	for _, data := range li {
+		buildingData.BuildingStaticDataLi = append(buildingData.BuildingStaticDataLi, data.(BuildingStaticData))
+	}
+	result.Building = buildingData
+	// cateSatisticData排序
+	li = make([]ICompare, 0, len(yearStatisticDataLi))
+	for _, yearData := range yearStatisticDataLi {
+		li = append(li, yearData)
+	}
+	li = BubbleSort(li)
+	result.YearCate = make([]YearStatisticData, 0, len(yearStatisticDataLi))
+	for _, data := range li {
+		result.YearCate = append(result.YearCate, data.(YearStatisticData))
+	}
+	// building cate 排序 cate
+	for index, buildingCateData := range buildingCateLi {
+		tempDataLi := buildingCateData.CateData
+		li = make([]ICompare, 0, len(buildingCateData.CateData))
+		buildingCateData.CateData = make([]SingleCateData, 0, len(buildingCateData.CateData))
+		for _, data := range tempDataLi {
+			li = append(li, data)
+		}
+		li = BubbleSort(li)
+		for _, data := range li {
+			buildingCateData.CateData = append(buildingCateData.CateData, data.(SingleCateData))
+		}
+		buildingCateLi[index] = buildingCateData
+	}
+	//str, _ := json.MarshalIndent(buildingCateLi, "", "  ")
+	//fmt.Println(string(str))
+	// 将各个分类统计的值赋值到result
+	result.Total = totalData
+	result.PicTotal = PicTotal{}
+	result.BuildingCate = buildingCateLi
+
+	if selectType == "ratio" {
+		// 处理整体满意度的表格
+		result.Total.SatisfactionPercent = result.Total.APercent + result.Total.BPercent
+		// 处理饼图数据
+		result.PicTotal.Row = []string{"非常满意", "满意", "一般", "不满意", "非常不满意"}
+		result.PicTotal.ValueLi = []float64{totalData.APercent, totalData.BPercent, totalData.CPercent, totalData.DPercent, totalData.EPercent}
+		// 处理每个年不同时期的满意度调查
+		for index, recentYear := range result.RecentYears {
+			if recentYear.Count == 0 {
+				recentYear.SatisfactionPercent = 0
+			} else {
+				recentYear.SatisfactionPercent = utils.Decimal(float64(recentYear.ASum+recentYear.BSum)/float64(recentYear.Count), 3)
+			}
+			result.RecentYears[index] = recentYear
+		}
+		// 处理每个年不同时期 不同居住时间的满意度调查
+		for index, data := range result.Time {
+			if data.BreakingInPeriodCount == 0 {
+				data.BreakingInPeriodPercent = 0
+			} else {
+				data.BreakingInPeriodPercent = utils.Decimal(float64(data.BreakingInPeriodASum+data.BreakingInPeriodBSum)/float64(data.BreakingInPeriodCount), 3)
+			}
+			if data.StablePeriodCount == 0 {
+				data.StablePeriodPercent = 0
+			} else {
+				data.StablePeriodPercent = utils.Decimal(float64(data.StablePeriodASum+data.StablePeriodBSum)/float64(data.StablePeriodCount), 3)
+			}
+			if data.AcquaintanceCount == 0 {
+				data.AcquaintancePercent = 0
+			} else {
+				data.AcquaintancePercent = utils.Decimal(float64(data.AcquaintanceASum+data.AcquaintanceBSum)/float64(data.AcquaintanceCount), 3)
+			}
+			result.Time[index] = data
+		}
+		// 处理不同subject的满意度调差
+		for index, data := range result.Cate {
+			for innerIndex, subjectData := range data.SubjectStaticDataLi {
+				if subjectData.Count == 0 {
+					subjectData.SatisfactionPercent = 0
+				} else {
+					subjectData.SatisfactionPercent = subjectData.APercent + subjectData.BPercent
+				}
+				data.SubjectStaticDataLi[innerIndex] = subjectData
+			}
+			if data.Count == 0 {
+				data.SatisfactionPercent = 0
+			} else {
+				data.SatisfactionPercent = utils.Decimal(float64(data.ASum+data.BSum)/float64(data.Count), 3)
+			}
+			result.Cate[index] = data
+		}
+		// 处理楼栋的满意度统计
+		if result.Building.Count == 0 {
+			result.Building.SatisfactionPercent = 0
+		} else {
+			result.Building.SatisfactionPercent = utils.Decimal(float64(result.Building.ASum+result.Building.BSum)/float64(result.Building.Count), 3)
+		}
+		if result.Building.Rooms == 0 {
+			result.Building.SampleBuildingPercent = 0
+		} else {
+			result.Building.SampleBuildingPercent = utils.Decimal(float64(result.Building.Count)/float64(result.Building.Rooms), 3)
+		}
+		result.Building.SampleAllPercent = 1
+		for index, data := range result.Building.BuildingStaticDataLi {
+			if data.BuildingSamples == 0 {
+				data.SatisfactionPercent = 0
+			} else {
+				data.SatisfactionPercent = utils.Decimal(float64(data.ASum+data.BSum)/float64(data.BuildingSamples), 3)
+			}
+			data.DifferencePercent = utils.Decimal(1-data.SatisfactionPercent, 3)
+			if result.Building.Count == 0 {
+				data.SampleAllPercent = 0
+			} else {
+				data.SampleAllPercent = utils.Decimal(float64(data.BuildingSamples)/float64(result.Building.Count), 3)
+			}
+			result.Building.BuildingStaticDataLi[index] = data
+		}
+		// 处理楼栋分类满意度统计
+		for index, buildingCate := range result.BuildingCate {
+			for innerIndex, cate := range buildingCate.CateData {
+				if cate.Count == 0 {
+					cate.SatisfactionPercent = 0
+				} else {
+					cate.SatisfactionPercent = utils.Decimal(float64(cate.ASum+cate.BSum)/float64(cate.Count), 3)
+				}
+				buildingCate.CateData[innerIndex] = cate
+			}
+			result.BuildingCate[index] = buildingCate
+		}
+		// 处理年份分类满意度
+		for index, yearData := range result.YearCate {
+			for innerIndex, cateData := range yearData.CateData {
+				if cateData.Count == 0 {
+					cateData.SatisfactionPercent = 0
+				} else {
+					cateData.SatisfactionPercent = utils.Decimal(float64(cateData.ASum+cateData.BSum)/float64(cateData.Count), 3)
+
+				}
+				yearData.CateData[innerIndex] = cateData
+			}
+			yearData.CateMap = nil
+			result.YearCate[index] = yearData
+		}
+	} else {
+		// 处理整体满意度的表格
+		result.Total.SatisfactionPercent = utils.Decimal(float64(totalData.ASum*5+totalData.BSum*4+totalData.CSum*3+totalData.DSum*2+totalData.ESum*1)/float64(5*totalData.Count), 3)
+		// 处理饼图数据
+		result.PicTotal.Row = []string{"非常满意", "满意", "一般", "不满意", "非常不满意"}
+		result.PicTotal.ValueLi = []float64{totalData.APercent, totalData.BPercent, totalData.CPercent, totalData.DPercent, totalData.EPercent}
+		// 处理每个年不同时期的满意度调查
+		for index, recentYear := range result.RecentYears {
+			if recentYear.Count == 0 {
+				recentYear.SatisfactionPercent = 0
+			} else {
+				recentYear.SatisfactionPercent = utils.Decimal(float64(recentYear.ASum*5+recentYear.BSum*4+recentYear.CSum*3+recentYear.DSum*2+recentYear.ESum*1)/float64(5*recentYear.Count), 3)
+			}
+			result.RecentYears[index] = recentYear
+		}
+		// 处理每个年不同时期 不同居住时间的满意度调查
+		for index, data := range result.Time {
+			if data.BreakingInPeriodCount == 0 {
+				data.BreakingInPeriodPercent = 0
+			} else {
+				data.BreakingInPeriodPercent = utils.Decimal(float64(data.BreakingInPeriodASum*5+data.BreakingInPeriodBSum*4+data.BreakingInPeriodCSum*3+data.BreakingInPeriodDSum*2+data.BreakingInPeriodESum*1)/float64(5*data.BreakingInPeriodCount), 3)
+			}
+			if data.StablePeriodCount == 0 {
+				data.StablePeriodPercent = 0
+			} else {
+				data.StablePeriodPercent = utils.Decimal(float64(data.StablePeriodASum*5+data.StablePeriodBSum*4+data.StablePeriodCSum*3+data.StablePeriodDSum*2+data.StablePeriodESum*1)/float64(5*data.StablePeriodCount), 3)
+			}
+			if data.AcquaintanceCount == 0 {
+				data.AcquaintancePercent = 0
+			} else {
+				data.AcquaintancePercent = utils.Decimal(float64(data.AcquaintanceASum*5+data.AcquaintanceBSum*4+data.AcquaintanceCSum*3+data.AcquaintanceDSum*2+data.AcquaintanceESum*1)/float64(5*data.AcquaintanceCount), 3)
+			}
+			result.Time[index] = data
+		}
+		// 处理不同subject的满意度调差
+		for index, data := range result.Cate {
+			for innerIndex, subjectData := range data.SubjectStaticDataLi {
+				if subjectData.Count == 0 {
+					subjectData.SatisfactionPercent = 0
+				} else {
+					subjectData.SatisfactionPercent = utils.Decimal(float64(subjectData.ASum*5+subjectData.BSum*4+subjectData.CSum*3+subjectData.DSum*2+subjectData.ESum*1)/float64(subjectData.Count*5), 3)
+				}
+				data.SubjectStaticDataLi[innerIndex] = subjectData
+			}
+			if data.Count == 0 {
+				data.SatisfactionPercent = 0
+			} else {
+				data.SatisfactionPercent = utils.Decimal(float64(data.ASum*5+data.BSum*4+data.CSum*3+data.DSum*2+data.ESum*1)/float64(data.Count*5), 3)
+			}
+			result.Cate[index] = data
+		}
+
+		// 处理楼栋的满意度统计
+		if result.Building.Count == 0 {
+			result.Building.SatisfactionPercent = 0
+
+		} else {
+			result.Building.SatisfactionPercent = utils.Decimal(float64(result.Building.ASum*5+result.Building.BSum*4+result.Building.CSum*3+result.Building.BSum*2+result.Building.ESum*1)/float64(result.Building.Count*5), 3)
+			result.Building.DifferencePercent = utils.Decimal(1-result.Building.SatisfactionPercent, 3)
+		}
+		if result.Building.Rooms == 0 {
+			result.Building.SampleBuildingPercent = 0
+		} else {
+			result.Building.SampleBuildingPercent = utils.Decimal(float64(result.Building.Count)/float64(result.Building.Rooms), 3)
+		}
+		result.Building.SampleAllPercent = 1
+		for index, data := range result.Building.BuildingStaticDataLi {
+
+			if data.BuildingSamples == 0 {
+				data.SatisfactionPercent = 0
+			} else {
+				data.SatisfactionPercent = utils.Decimal(float64(data.ASum*5+data.BSum*4+data.CSum*3+data.DSum*2+data.ESum*1)/float64(data.BuildingSamples*5), 3)
+			}
+			data.DifferencePercent = utils.Decimal(1-data.SatisfactionPercent, 3)
+			if result.Building.Count == 0 {
+				data.SampleAllPercent = 0
+			} else {
+				data.SampleAllPercent = utils.Decimal(float64(data.BuildingSamples)/float64(result.Building.Count), 3)
+			}
+			result.Building.BuildingStaticDataLi[index] = data
+		}
+
+		// 处理楼栋分类满意度统计
+		for index, buildingCate := range result.BuildingCate {
+			for innerIndex, cate := range buildingCate.CateData {
+				if cate.Count == 0 {
+					cate.SatisfactionPercent = 0
+				} else {
+					cate.SatisfactionPercent = utils.Decimal(float64(cate.ASum*5+cate.BSum*4+cate.CSum*3+cate.DSum*2+cate.ESum)/float64(cate.Count*5), 3)
+				}
+				buildingCate.CateData[innerIndex] = cate
+			}
+			result.BuildingCate[index] = buildingCate
+		}
+
+		// 处理年份分类满意度
+		for index, yearData := range result.YearCate {
+			for innerIndex, cateData := range yearData.CateData {
+				if cateData.Count == 0 {
+					cateData.SatisfactionPercent = 0
+				} else {
+					cateData.SatisfactionPercent = utils.Decimal(float64(cateData.ASum*5+cateData.BSum*4+cateData.CSum*3+cateData.DSum*2+cateData.ESum)/float64(cateData.Count*5), 3)
+				}
+				yearData.CateData[innerIndex] = cateData
+			}
+			yearData.CateMap = nil
+			result.YearCate[index] = yearData
+		}
+	}
+	// 处理buildCate 处理成map
+	for index, buildCate := range result.BuildingCate {
+		buildCate.CateMap = make([]map[string]float64, 0)
+		for _, cateData := range buildCate.CateData {
+			tempMap := make(map[string]float64,0)
+			tempMap[cateData.CateId] = cateData.SatisfactionPercent
+			buildCate.CateMap = append(buildCate.CateMap, tempMap)
+		}
+		result.BuildingCate[index] = buildCate
+	}
+
+	// building cate data 排序
+	buildingCateLi = result.BuildingCate
+	li = make([]ICompare, 0, len(buildingCateLi))
+	for _, buildingCate := range buildingCateLi {
+		li = append(li, buildingCate)
+	}
+	li = BubbleSort(li)
+	result.BuildingCate = make([]BuildingCate, 0, len(buildingCateLi))
+	for _, data := range li {
+		result.BuildingCate = append(result.BuildingCate, data.(BuildingCate))
+	}
+	return result, nil
+}

web/models/statistic.go

@@ -0,0 +1,338 @@
+package models
+
+// 比较大小的接口
+type ICompare interface {
+	Compare(interface{}) int
+}
+
+// 年份的统计数据
+type RecentYear struct {
+	TimeDescr           string  `json:"timeDescr"`
+	Year                int     `json:"year"`
+	Type                int     `json:"type"`
+	ASum                int     `json:"aSum"`
+	BSum                int     `json:"bSum"`
+	CSum                int     `json:"cSum"`
+	DSum                int     `json:"dSum"`
+	ESum                int     `json:"eSum"`
+	Count               int     `json:"count"`
+	SatisfactionPercent float64 `json:"satisfactionPercent"`
+}
+
+func (r RecentYear) Compare(iData interface{}) int {
+	data, ok := iData.(RecentYear)
+	if !ok {
+		return -2
+	}
+	if r.Year > data.Year {
+		return 1
+	}
+	if r.Year == data.Year {
+		if r.Type > data.Type {
+			return 1
+		} else {
+			return 0
+		}
+	}
+	return -1
+}
+
+// 年份 不同时间的统计数据
+type TimeStatisticData struct {
+	TimeDescr               string  `json:"timeDescr"`
+	Year                    int     `json:"year"`
+	Type                    int     `json:"type"`
+	Count                   int     `json:"count"`
+	BreakingInPeriodASum    int     `json:"breakingInPeriodASum"`
+	BreakingInPeriodBSum    int     `json:"breakingInPeriodBSum"`
+	BreakingInPeriodCSum    int     `json:"breakingInPeriodCSum"`
+	BreakingInPeriodDSum    int     `json:"breakingInPeriodDSum"`
+	BreakingInPeriodESum    int     `json:"breakingInPeriodESum"`
+	BreakingInPeriodCount   int     `json:"breakingInPeriodCount"`
+	BreakingInPeriodPercent float64 `json:"breakingInPeriodPercent"`
+	StablePeriodASum        int     `json:"stablePeriodASum"`
+	StablePeriodBSum        int     `json:"stablePeriodBSum"`
+	StablePeriodCSum        int     `json:"stablePeriodCSum"`
+	StablePeriodDSum        int     `json:"stablePeriodDSum"`
+	StablePeriodESum        int     `json:"stablePeriodESum"`
+	StablePeriodCount       int     `json:"stablePeriodCount"`
+	StablePeriodPercent     float64 `json:"stablePeriodPercent"`
+	AcquaintanceASum        int     `json:"acquaintanceASum"`
+	AcquaintanceBSum        int     `json:"acquaintanceBSum"`
+	AcquaintanceCSum        int     `json:"acquaintanceCSum"`
+	AcquaintanceDSum        int     `json:"acquaintanceDSum"`
+	AcquaintanceESum        int     `json:"acquaintanceESum"`
+	AcquaintanceCount       int     `json:"acquaintanceCount"`
+	AcquaintancePercent     float64 `json:"acquaintancePercent"`
+}
+
+func (t TimeStatisticData) Compare(iData interface{}) int {
+	data, ok := iData.(TimeStatisticData)
+	if !ok {
+		return -2
+	}
+	if t.Year > data.Year {
+		return 1
+	}
+	if t.Year == data.Year {
+		if t.Type > data.Type {
+			return 1
+		} else {
+			return 0
+		}
+	}
+	return -1
+}
+
+// 年份 分模块统计数据
+type YearStatisticData struct {
+	TimeDescr string                    `json:"timeDescr"`
+	Year      int                       `json:"year"`
+	Type      string                    `json:"type"`
+	CateData  []SingleCateData          `json:"cate"`
+	CateMap   map[string]SingleCateData `json:"cateMap"`
+}
+
+func (r YearStatisticData) Compare(iData interface{}) int {
+	data, ok := iData.(YearStatisticData)
+	if !ok {
+		return -2
+	}
+	if r.Year > data.Year {
+		return 1
+	}
+	if r.Year == data.Year {
+		if r.Type > data.Type {
+			return 1
+		} else {
+			return 0
+		}
+	}
+	return -1
+}
+
+// 问题统计数据
+type SubjectStaticData struct {
+	CateId              string  `json:"subject_categoryid"`
+	SubjectName         string  `json:"subject_name"`
+	Pos                 int     `json:"pos"`
+	ASum                int     `json:"asum"`
+	APercent            float64 `json:"aper"`
+	BSum                int     `json:"bsum"`
+	BPercent            float64 `json:"bper"`
+	CSum                int     `json:"csum"`
+	CPercent            float64 `json:"cper"`
+	DSum                int     `json:"dsum"`
+	DPercent            float64 `json:"dper"`
+	ESum                int     `json:"esum"`
+	EPercent            float64 `json:"eper"`
+	SatisfactionPercent float64 `json:"satisfaction_per"`
+	Count               int     `json:"count"`
+}
+
+func (s SubjectStaticData) Compare(iData interface{}) int {
+	data, ok := iData.(SubjectStaticData)
+	if !ok {
+		return -2
+	}
+	if s.Pos > data.Pos {
+		return 1
+	} else if s.Pos == data.Pos {
+		return 0
+	} else {
+		return -1
+	}
+}
+
+// 分类模块统计数据
+type CateStatisticData struct {
+	SubjectStaticDataLi []SubjectStaticData `json:"subjectStaticDataLi"`
+	Count               int                 `json:"count"`
+	Cate                string              `json:"subject_categoryid"`
+	ASum                int                 `json:"aSum"`
+	BSum                int                 `json:"bSum"`
+	CSum                int                 `json:"cSum"`
+	DSum                int                 `json:"dSum"`
+	ESum                int                 `json:"eSum"`
+	SatisfactionPercent float64             `json:"per_total"`
+}
+
+func (c CateStatisticData) Compare(iData interface{}) int {
+	data, ok := iData.(CateStatisticData)
+	if !ok {
+		return -2
+	}
+	if data.Cate == "整体满意度" {
+		return -1
+	}
+	if c.Cate == "整体满意度" {
+		return 1
+	}
+	if c.Cate > data.Cate {
+		return 1
+	} else if c.Cate == data.Cate {
+		return 0
+	} else {
+		return -1
+	}
+}
+
+// 楼栋统计数据
+type BuildingStaticData struct {
+	BuildingRooms         int     `json:"buildingRooms"`
+	BuildingSamples       int     `json:"buildingSamples"`
+	SampleBuildingPercent float64 `json:"sampleBuildingPercent"`
+	SampleAllPercent      float64 `json:"sampleAllPercent"`
+	SatisfactionPercent   float64 `json:"satisfactionPercent"`
+	DifferencePercent     float64 `json:"differencePercent"`
+	ASum                  int     `json:"aSum"`
+	BSum                  int     `json:"bSum"`
+	CSum                  int     `json:"cSum"`
+	DSum                  int     `json:"dSum"`
+	ESum                  int     `json:"eSum"`
+	BuildingId            string  `json:"buildingId"`
+	BuildingDescr         string  `json:"buildingDescr"`
+}
+
+func (b BuildingStaticData) Compare(iData interface{}) int {
+	data, ok := iData.(BuildingStaticData)
+	if !ok {
+		return -2
+	}
+	if b.BuildingId > data.BuildingId {
+		return 1
+	} else if b.BuildingId == data.BuildingId {
+		return 0
+	} else {
+		return -1
+	}
+}
+
+// 单项模块数据统计
+type SingleCateData struct {
+	CateId              string  `json:"cateId"`
+	BuildingDescr       string  `json:"buildingDescr"`
+	ASum                int     `json:"aSum"`
+	BSum                int     `json:"bSum"`
+	CSum                int     `json:"cSum"`
+	DSum                int     `json:"dSum"`
+	ESum                int     `json:"eSum"`
+	Count               int     `json:"count"`
+	SatisfactionPercent float64 `json:"satisfactionPercent"`
+}
+
+func (s SingleCateData) Compare(iData interface{}) int {
+	data, ok := iData.(SingleCateData)
+	if !ok {
+		return -2
+	}
+	if data.CateId == "整体满意程度" {
+		return 1
+	}
+	if s.CateId == "整体满意程度" {
+		return -1
+	}
+	if s.CateId > data.CateId {
+		return 1
+	} else if s.CateId == data.CateId {
+		return 0
+	} else {
+		return -1
+	}
+}
+
+// 楼栋分类统计
+type BuildingCate struct {
+	BuildingDescr string               `json:"buildingDescr"`
+	Samples       int                  `json:"samples"`
+	CateData      []SingleCateData     `json:"cateData"`
+	CateMap       []map[string]float64 `json:"cateMap"`
+}
+
+func (b BuildingCate) Compare(iData interface{}) int {
+	data, ok := iData.(BuildingCate)
+	if !ok {
+		return -2
+	}
+	var innerData float64
+	var outData float64
+	var exist bool
+	for _, dataMap := range b.CateMap {
+		innerData, exist = dataMap["整体满意程度"]
+		if exist {
+			break
+		}
+	}
+	for _, dataMap := range data.CateMap {
+		outData, exist = dataMap["整体满意程度"]
+		if exist {
+			break
+		}
+	}
+	if innerData > outData {
+		return -1
+	} else if innerData == outData {
+		return 0
+	} else {
+		return 1
+	}
+}
+
+type BuildingData struct {
+	BuildingStaticDataLi  []BuildingStaticData `json:"buildingStaticDataLi"`
+	ASum                  int                  `json:"aSum"`
+	BSum                  int                  `json:"bSum"`
+	CSum                  int                  `json:"cSum"`
+	DSum                  int                  `json:"dSum"`
+	ESum                  int                  `json:"eSum"`
+	Count                 int                  `json:"count"`
+	SatisfactionPercent   float64              `json:"satisfactionPercent"`
+	DifferencePercent     float64              `json:"differencePercent"`
+	Rooms                 int                  `json:"rooms"`
+	SampleBuildingPercent float64              `json:"sampleBuildingPercent"`
+	SampleAllPercent      float64              `json:"sampleAllPercent"`
+}
+
+type PicTotal struct {
+	Row     []string  `json:"row"`
+	ValueLi []float64 `json:"valueLi"`
+}
+
+type StatisticData struct {
+	Total        TotalStatisticData  `json:"total"`
+	PicTotal     PicTotal            `json:"picTotal"`
+	RecentYears  []RecentYear        `json:"recentYears"`
+	Time         []TimeStatisticData `json:"time"`
+	Cate         []CateStatisticData `json:"cate"`
+	Building     BuildingData        `json:"building"`
+	BuildingCate []BuildingCate      `json:"buildingCate"`
+	YearCate     []YearStatisticData `json:"yearCate"`
+}
+
+type TotalStatisticData struct {
+	ASum                int     `json:"aSum"`
+	APercent            float64 `json:"aPercent"`
+	BSum                int     `json:"bSum"`
+	BPercent            float64 `json:"bPercent"`
+	CSum                int     `json:"cSum"`
+	CPercent            float64 `json:"cPercent"`
+	DSum                int     `json:"dSum"`
+	DPercent            float64 `json:"dPercent"`
+	ESum                int     `json:"eSum"`
+	EPercent            float64 `json:"ePercent"`
+	Count               int     `json:"count"`
+	SatisfactionPercent float64 `json:"satisfactionPercent"`
+}
+
+func BubbleSort(list []ICompare) []ICompare {
+	for i := 0; i < len(list); i++ {
+		for j := 1; j < len(list)-i; j++ {
+			result := list[j].Compare(list[j-1])
+			if result == -1 {
+				//交换
+				list[j], list[j-1] = list[j-1], list[j]
+			}
+		}
+	}
+	return list
+}

web/routes/routes.go

@@ -150,6 +150,7 @@ func Hub(app *iris.Application) {
 		c_surveysheet_result.Get("/total", controllers.TotalCSurveysheetResult)
 		c_surveysheet_result.Get("/totalmultiple", controllers.TotalMultipleCSurveysheetResult)
 		c_surveysheet_result.Get("/selectarr", controllers.SelectArrCSurveysheet)
+		c_surveysheet_result.Get("/statistic", controllers.StatisticData)
 
 	}