team/tyapi-server
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

f

Browse Source
This commit is contained in:
liangzai
2026-07-08 21:28:08 +08:00
parent 352ee9eaf2
commit 9f985ea8c7
12 changed files with 2504 additions and 39 deletions
Download Patch File Download Diff File Expand all files Collapse all files

471
internal/domains/api/services/processors/dwbg/dwbg6a2c_judicial.go Normal file
View File

@@ -0,0 +1,471 @@
package dwbg
import (
"fmt"
"strings"
)
// buildJudicialLeaseReport maps FLXG7E8F to Sinan judicialLeaseReport.
func buildJudicialLeaseReport(apiData map[string]interface{}) map[string]interface{} {
report := emptyJudicialLeaseReport()
flxg := flxg7e8fMap(apiData)
if flxg == nil {
return report
}
judicialData := asMap(flxg["judicial_data"])
if judicialData == nil {
return report
}
lawsuitStat := asMap(judicialData["lawsuitStat"])
courtInfo, newMult := judicialCourtMaps(report)
if courtInfo == nil || newMult == nil {
return report
}
if lawsuitStat != nil {
courtInfo["civilCasesCount"] = lawsuitCasesCount(lawsuitStat, "civil")
courtInfo["criminalCasesCount"] = lawsuitCasesCount(lawsuitStat, "criminal")
courtInfo["administrativeCasesCount"] = lawsuitCasesCount(lawsuitStat, "administrative")
courtInfo["preservationCasesCount"] = lawsuitPreservationCount(lawsuitStat)
courtInfo["enforcementCasesCount"] = lawsuitCasesCount(lawsuitStat, "implement")
courtInfo["bankruptcyCasesCount"] = lawsuitCasesCount(lawsuitStat, "bankrupt")
if cases := convertSinanCaseList(lawsuitStat, "civil"); len(cases) > 0 {
newMult["civilCases"] = cases
}
if cases := convertSinanCaseList(lawsuitStat, "criminal"); len(cases) > 0 {
newMult["criminalCases"] = cases
}
if cases := convertSinanCaseList(lawsuitStat, "administrative"); len(cases) > 0 {
newMult["administrativeCases"] = cases
}
if cases := convertSinanCaseList(lawsuitStat, "preservation"); len(cases) > 0 {
newMult["preservationCases"] = cases
}
if cases := convertSinanCaseList(lawsuitStat, "implement"); len(cases) > 0 {
newMult["enforcementCases"] = cases
}
if cases := convertSinanCaseList(lawsuitStat, "bankrupt"); len(cases) > 0 {
newMult["bankruptcyCases"] = cases
}
if globalCount := asMap(lawsuitStat["count"]); globalCount != nil {
newMult["caseCounts"] = convertFLXGCountToSinan(globalCount)
}
for _, pair := range []struct {
flxgKey string
sinanKey string
}{
{"civil", "civilCaseCounts"},
{"criminal", "criminalCaseCounts"},
{"administrative", "administrativeCaseCounts"},
{"preservation", "preservationCaseCounts"},
{"implement", "enforcementCaseCounts"},
{"bankrupt", "bankruptcyCaseCounts"},
} {
if bucket := asMap(lawsuitStat[pair.flxgKey]); bucket != nil {
if count := asMap(bucket["count"]); count != nil {
newMult[pair.sinanKey] = convertFLXGCountToSinan(count)
}
}
}
}
if breachList, ok := judicialData["breachCaseList"].([]interface{}); ok && len(breachList) > 0 {
disinCases := make([]interface{}, 0, len(breachList))
for _, item := range breachList {
if caseMap, ok := item.(map[string]interface{}); ok {
if converted := convertSinanDisinCase(caseMap); converted != nil {
disinCases = append(disinCases, converted)
}
}
}
if len(disinCases) > 0 {
newMult["disinCases"] = disinCases
}
}
if limitList, ok := judicialData["consumptionRestrictionList"].([]interface{}); ok && len(limitList) > 0 {
limitCases := make([]interface{}, 0, len(limitList))
for _, item := range limitList {
if caseMap, ok := item.(map[string]interface{}); ok {
if converted := convertSinanLimitCase(caseMap); converted != nil {
limitCases = append(limitCases, converted)
}
}
}
if len(limitCases) > 0 {
newMult["limitCases"] = limitCases
}
}
report["caseOverviewInfo"] = buildCaseOverviewInfo(lawsuitStat, judicialData, courtInfo)
return report
}
func judicialCourtMaps(report map[string]interface{}) (courtInfo, newMult map[string]interface{}) {
ci, ok := report["courtInfo"].(map[string]interface{})
if !ok || ci == nil {
return nil, nil
}
nm, ok := ci["newMultCourtInfo"].(map[string]interface{})
if !ok || nm == nil {
return nil, nil
}
return ci, nm
}
func lawsuitCasesCount(lawsuitStat map[string]interface{}, key string) int {
bucket := asMap(lawsuitStat[key])
if bucket == nil {
return 0
}
if cases, ok := bucket["cases"].([]interface{}); ok && len(cases) > 0 {
return len(cases)
}
if count := asMap(bucket["count"]); count != nil {
return parseIntValue(count["count_total"])
}
return 0
}
func lawsuitPreservationCount(lawsuitStat map[string]interface{}) int {
bucket := asMap(lawsuitStat["preservation"])
if bucket == nil {
return 0
}
if count := asMap(bucket["count"]); count != nil {
if total := parseIntValue(count["count_total"]); total > 0 {
return total
}
}
return lawsuitCasesCount(lawsuitStat, "preservation")
}
func convertSinanCaseList(lawsuitStat map[string]interface{}, key string) []interface{} {
bucket := asMap(lawsuitStat[key])
if bucket == nil {
return nil
}
cases, ok := bucket["cases"].([]interface{})
if !ok || len(cases) == 0 {
return nil
}
out := make([]interface{}, 0, len(cases))
for _, item := range cases {
caseMap, ok := item.(map[string]interface{})
if !ok {
continue
}
if converted := convertSinanLegalCase(caseMap); converted != nil {
out = append(out, converted)
}
}
return out
}
func convertSinanLegalCase(caseMap map[string]interface{}) map[string]interface{} {
caseNumber := xypString(caseMap, "c_ah")
if caseNumber == "" {
return nil
}
info := map[string]interface{}{
"caseNumber": caseNumber,
"nssdw": xypString(caseMap, "n_ssdw"),
"caseStatus": xypString(caseMap, "n_ajjzjd"),
"najlx": xypString(caseMap, "n_ajlx"),
"cdsrxx": formatCdsrxx(caseMap["c_dsrxx"]),
"nslcx": xypString(caseMap, "n_slcx"),
"zxfy": xypString(caseMap, "n_jbfy"),
"njbfy": xypString(caseMap, "n_jbfy"),
"dlarq": xypString(caseMap, "d_larq"),
"djarq": xypString(caseMap, "d_jarq"),
"njafs": xypString(caseMap, "n_jafs"),
"nqsbdje": formatNumericValue(caseMap["n_qsbdje"]),
"njabdje": formatNumericValue(caseMap["n_jabdje"]),
"nsqzxbdje": formatNumericValue(caseMap["n_sqzxbdje"]),
"nsjdwje": formatNumericValue(caseMap["n_sjdwje"]),
"nwzxje": formatNumericValue(caseMap["n_wzxje"]),
"npjVictory": xypString(caseMap, "n_pj_victory"),
"cgkwsDsr": xypString(caseMap, "c_gkws_dsr"),
"cgkwsPjjg": xypString(caseMap, "c_gkws_pjjg"),
"najbs": xypString(caseMap, "n_ajbs"),
"nlaayTree": firstNonEmpty(xypString(caseMap, "n_laay_tree"), xypString(caseMap, "n_jaay_tree")),
"nfzje": formatNumericValue(caseMap["n_fzje"]),
"npcpcje": formatNumericValue(caseMap["n_pcpcje"]),
"nccxzxje": formatNumericValue(caseMap["n_ccxzxje"]),
"cahHx": "",
"cahHxBs": "",
}
if cAhHx := xypString(caseMap, "c_ah_hx"); cAhHx != "" {
parts := strings.SplitN(cAhHx, ":", 2)
info["cahHx"] = strings.TrimSpace(parts[0])
if len(parts) == 2 {
info["cahHxBs"] = strings.TrimSpace(parts[1])
}
}
return info
}
func formatCdsrxx(raw interface{}) string {
list, ok := raw.([]interface{})
if !ok || len(list) == 0 {
return ""
}
parts := make([]string, 0, len(list))
for _, item := range list {
m, ok := item.(map[string]interface{})
if !ok {
continue
}
role := xypString(m, "n_ssdw")
name := xypString(m, "c_mc")
typ := xypString(m, "n_dsrlx")
if name == "" {
continue
}
parts = append(parts, fmt.Sprintf("%s%s\u3010%s\u3011", role, name, typ))
}
return strings.Join(parts, "\uff1b")
}
func convertFLXGCountToSinan(count map[string]interface{}) map[string]interface{} {
out := emptyCaseCounts()
out["totalCasesCounts"] = countToString(count["count_total"])
out["totalJieCaseCounts"] = countToString(count["count_jie_total"])
out["totalWeiCaseCounts"] = countToString(count["count_wei_total"])
out["totalCaseAmounts"] = countToString(count["money_total"])
out["totalJieAmountCases"] = countToString(count["money_jie_total"])
out["totalWeiAmountCases"] = countToString(count["money_wei_total"])
out["beigaoTotalCasesCounts"] = countToString(count["count_beigao"])
out["beigaoTotalJieCaseCounts"] = countToString(count["count_jie_beigao"])
out["beigaoTotalWeiCaseCounts"] = countToString(count["count_wei_beigao"])
out["beigaoTotalCaseAmounts"] = countToString(count["money_beigao"])
out["beigaoTotalJieAmountCases"] = countToString(count["money_jie_beigao"])
out["beigaoTotalWeiAmountCases"] = countToString(count["money_wei_beigao"])
out["yuangaoTotalCasesCounts"] = countToString(count["count_yuangao"])
out["yuangaoTotalJieCaseCounts"] = countToString(count["count_jie_yuangao"])
out["yuangaoTotalWeiCaseCounts"] = countToString(count["count_wei_yuangao"])
out["yuangaoTotalCaseAmounts"] = countToString(count["money_yuangao"])
out["yuangaoTotalJieAmountCases"] = countToString(count["money_jie_yuangao"])
out["yuangaoTotalWeiAmountCases"] = countToString(count["money_wei_yuangao"])
out["otherTotalCasesCounts"] = countToString(count["count_other"])
out["otherTotalJieCaseCounts"] = countToString(count["count_jie_other"])
out["otherTotalWeiCaseCounts"] = countToString(count["count_wei_other"])
out["otherTotalCaseAmounts"] = countToString(count["money_other"])
out["otherTotalJieAmountCases"] = countToString(count["money_jie_other"])
out["otherTotalWeiAmountCases"] = countToString(count["money_wei_other"])
out["caseActionDistribution"] = statOrDash(count["ay_stat"])
out["localDistribution"] = statOrDash(count["area_stat"])
out["timeDistribution"] = statOrDash(count["larq_stat"])
out["caseCloselDistribution"] = statOrDash(count["jafs_stat"])
return out
}
func countToString(val interface{}) string {
if val == nil {
return "0"
}
switch v := val.(type) {
case string:
if strings.TrimSpace(v) == "" {
return "0"
}
return v
case float64:
return formatNumericValue(v)
case int:
return formatNumericValue(v)
case int64:
return formatNumericValue(v)
default:
return "0"
}
}
func statOrDash(val interface{}) string {
s := strings.TrimSpace(fmt.Sprint(val))
if s == "" || s == "<nil>" {
return "-"
}
return s
}
func buildCaseOverviewInfo(lawsuitStat map[string]interface{}, judicialData map[string]interface{}, courtInfo map[string]interface{}) map[string]interface{} {
overview := emptyCaseOverviewInfo()
if lawsuitStat != nil {
if globalCount := asMap(lawsuitStat["count"]); globalCount != nil {
overview["beigaoTotalCasesCounts"] = parseIntValue(globalCount["count_beigao"])
overview["beigaoTotalWeiCaseCounts"] = parseIntValue(globalCount["count_wei_beigao"])
overview["beigaoTotalCaseAmounts"] = parseIntValue(globalCount["money_beigao"])
overview["leastCaseTime"] = extractLatestCaseTime(statOrDash(globalCount["larq_stat"]))
}
}
overview["executionCaseCounts"] = courtInfo["enforcementCasesCount"]
if breachList, ok := judicialData["breachCaseList"].([]interface{}); ok && len(breachList) > 0 {
overview["disinCaseCounts"] = 1
}
if limitList, ok := judicialData["consumptionRestrictionList"].([]interface{}); ok && len(limitList) > 0 {
overview["limitCaseCounts"] = 1
}
return overview
}
func extractLatestCaseTime(stat string) string {
if stat == "" || stat == "-" {
return ""
}
parts := strings.Split(stat, ",")
if len(parts) == 0 {
return ""
}
return strings.TrimSpace(parts[len(parts)-1])
}
func convertSinanDisinCase(caseMap map[string]interface{}) map[string]interface{} {
caseNumber := xypString(caseMap, "caseNumber")
if caseNumber == "" {
return nil
}
return map[string]interface{}{
"caseNumber": caseNumber,
"court": xypString(caseMap, "executiveCourt"),
"filingTime": xypString(caseMap, "fileDate"),
"caseStatus": xypString(caseMap, "fulfillStatus"),
}
}
func convertSinanLimitCase(caseMap map[string]interface{}) map[string]interface{} {
caseNumber := xypString(caseMap, "caseNumber")
if caseNumber == "" {
return nil
}
return map[string]interface{}{
"caseNumber": caseNumber,
"court": xypString(caseMap, "executiveCourt"),
"filingTime": xypString(caseMap, "fileDate"),
}
}
func firstNonEmpty(values ...string) string {
for _, v := range values {
if strings.TrimSpace(v) != "" {
return v
}
}
return ""
}
func hasJudicialCases(apiData map[string]interface{}) bool {
flxg := flxg7e8fMap(apiData)
if flxg == nil {
return false
}
judicialData := asMap(flxg["judicial_data"])
if judicialData == nil {
return false
}
lawsuitStat := asMap(judicialData["lawsuitStat"])
if lawsuitStat != nil {
for _, key := range []string{"civil", "criminal", "administrative", "preservation", "implement", "bankrupt"} {
if lawsuitCasesCount(lawsuitStat, key) > 0 {
return true
}
}
}
if list, ok := judicialData["breachCaseList"].([]interface{}); ok && len(list) > 0 {
return true
}
if list, ok := judicialData["consumptionRestrictionList"].([]interface{}); ok && len(list) > 0 {
return true
}
return false
}
func hasPreservationCases(apiData map[string]interface{}) bool {
flxg := flxg7e8fMap(apiData)
if flxg == nil {
return false
}
judicialData := asMap(flxg["judicial_data"])
if judicialData == nil {
return false
}
lawsuitStat := asMap(judicialData["lawsuitStat"])
if lawsuitStat == nil {
return false
}
return lawsuitPreservationCount(lawsuitStat) > 0
}
func hasLegalCases(apiData map[string]interface{}) bool {
flxg := flxg7e8fMap(apiData)
if flxg == nil {
return false
}
judicialData := asMap(flxg["judicial_data"])
if judicialData == nil {
return false
}
lawsuitStat := asMap(judicialData["lawsuitStat"])
if lawsuitStat == nil {
return false
}
for _, key := range []string{"civil", "criminal", "administrative"} {
if lawsuitCasesCount(lawsuitStat, key) > 0 {
return true
}
}
return false
}
func hasExecutionCases(apiData map[string]interface{}) bool {
flxg := flxg7e8fMap(apiData)
if flxg == nil {
return false
}
judicialData := asMap(flxg["judicial_data"])
if judicialData == nil {
return false
}
lawsuitStat := asMap(judicialData["lawsuitStat"])
if lawsuitStat == nil {
return false
}
return lawsuitCasesCount(lawsuitStat, "implement") > 0
}
func hasDisinCases(apiData map[string]interface{}) bool {
flxg := flxg7e8fMap(apiData)
if flxg == nil {
return false
}
judicialData := asMap(flxg["judicial_data"])
if judicialData == nil {
return false
}
list, ok := judicialData["breachCaseList"].([]interface{})
return ok && len(list) > 0
}
func hasLimitCases(apiData map[string]interface{}) bool {
flxg := flxg7e8fMap(apiData)
if flxg == nil {
return false
}
judicialData := asMap(flxg["judicial_data"])
if judicialData == nil {
return false
}
list, ok := judicialData["consumptionRestrictionList"].([]interface{})
return ok && len(list) > 0
}
func hasCourtViolator(apiData map[string]interface{}) bool {
return hasExecutionCases(apiData) || hasDisinCases(apiData)
}