diff --git a/demo.go b/demo.go deleted file mode 100644 index 655fbba..0000000 --- a/demo.go +++ /dev/null @@ -1,10 +0,0 @@ -/****************************************************************************** - * @Function Name : - *----------------------------------------------------------------------------- - * @Description : - * @Function Parameters: - * @Return Value : - * @Author : Zhang Xin - * @Date : 2021/3/3 11:02 - ******************************************************************************/ - package main \ No newline at end of file diff --git a/utils/utils.go b/utils/utils.go index e3bed07..37bac17 100644 --- a/utils/utils.go +++ b/utils/utils.go @@ -393,4 +393,6 @@ func Round(num float64) int { num += 0.5 num = math.Floor(num) return int(num) -} \ No newline at end of file +} + + diff --git a/utils/value.go b/utils/value.go index 0734cdb..3b19f1a 100644 --- a/utils/value.go +++ b/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 } \ No newline at end of file diff --git a/web/controllers/c_surveysheet_controller.go b/web/controllers/c_surveysheet_controller.go index 7c6522b..609ccdf 100644 --- a/web/controllers/c_surveysheet_controller.go +++ b/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) +} diff --git a/web/models/buildingtab.go b/web/models/buildingtab.go new file mode 100644 index 0000000..3f33fc7 --- /dev/null +++ b/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 +} diff --git a/web/models/c_surveysheet_result.go b/web/models/c_surveysheet_result.go index 8c57ea8..08ded1c 100644 --- a/web/models/c_surveysheet_result.go +++ b/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 +} diff --git a/web/models/statistic.go b/web/models/statistic.go new file mode 100644 index 0000000..44eb399 --- /dev/null +++ b/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 +} diff --git a/web/routes/routes.go b/web/routes/routes.go index cc45373..9e8ddaa 100644 --- a/web/routes/routes.go +++ b/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) }