func (c Console) Relation() revel.Result {
sessionId := global.GetSessionId()
global.SetGlobalAttr(sessionId, "userId", c.Session["userId"])
global.SetGlobalAttr(sessionId, "adminUserId", c.Session["adminUserId"])
defer global.CloseSession(sessionId)
selectorId := c.Params.Get("selectorId")
id := c.Params.Get("id")
templateManager := TemplateManager{}
relationLi := []map[string]interface{}{
map[string]interface{}{
"selectorId": selectorId,
"relationId": id,
},
}
relationBo := templateManager.GetRelationBo(sessionId, relationLi)
var result interface{} = nil
var url interface{} = nil
if relationBo[selectorId] != nil {
selRelationBo := relationBo[selectorId].(map[string]interface{})
if selRelationBo[id] != nil {
result = selRelationBo[id]
url = selRelationBo["url"]
}
}
c.Response.ContentType = "application/json; charset=utf-8"
return c.RenderJson(map[string]interface{}{
"result": result,
"url": url,
})
}
func (c BaseDataAction) RCopyDataCommon() ModelRenderVO {
sessionId := global.GetSessionId()
global.SetGlobalAttr(sessionId, "userId", c.Session["userId"])
global.SetGlobalAttr(sessionId, "adminUserId", c.Session["adminUserId"])
defer global.CloseSession(sessionId)
defer c.RRollbackTxn(sessionId)
userId, err := strconv.Atoi(c.Session["userId"])
if err != nil {
panic(err)
}
dataSourceModelId := c.Params.Get("dataSourceModelId")
formTemplateId := c.Params.Get("formTemplateId")
strId := c.Params.Get("id")
id, err := strconv.Atoi(strId)
if err != nil {
panic(err)
}
querySupport := QuerySupport{}
queryMap := map[string]interface{}{
"_id": id,
}
templateManager := TemplateManager{}
formTemplate := templateManager.GetFormTemplate(formTemplateId)
permissionSupport := PermissionSupport{}
permissionQueryDict := permissionSupport.GetPermissionQueryDict(sessionId, formTemplate.Security)
for k, v := range permissionQueryDict {
queryMap[k] = v
}
modelTemplateFactory := ModelTemplateFactory{}
dataSource := modelTemplateFactory.GetDataSource(dataSourceModelId)
collectionName := modelTemplateFactory.GetCollectionName(dataSource)
srcBo, found := querySupport.FindByMap(collectionName, queryMap)
if !found {
panic("CopyData, dataSouceModelId=" + dataSourceModelId + ", id=" + strId + " not found")
}
modelTemplateFactory.ConvertDataType(dataSource, &srcBo)
c.RActionSupport.RBeforeCopyData(sessionId, dataSource, formTemplate, srcBo)
dataSource, bo := modelTemplateFactory.GetCopyInstance(dataSourceModelId, srcBo)
c.RActionSupport.RAfterCopyData(sessionId, dataSource, formTemplate, &bo)
columnModelData := templateManager.GetColumnModelDataForFormTemplate(sessionId, formTemplate, bo)
bo = columnModelData["bo"].(map[string]interface{})
relationBo := columnModelData["relationBo"].(map[string]interface{})
modelTemplateFactory.ClearReverseRelation(&dataSource)
c.CommitTxn(sessionId)
return ModelRenderVO{
UserId: userId,
Bo: bo,
RelationBo: relationBo,
DataSource: dataSource,
FormTemplate: formTemplate,
}
}
// 管理员查看页面,设置session.userId,以查看数据,
func (c Console) BbsPostAdminReplySchema() revel.Result {
// 取一下bbsPostId
sessionId := global.GetSessionId()
global.SetGlobalAttr(sessionId, "userId", c.Session["userId"])
global.SetGlobalAttr(sessionId, "adminUserId", c.Session["adminUserId"])
defer global.CloseSession(sessionId)
defer c.RRollbackTxn(sessionId)
schemaName := c.Params.Get("@name")
templateManager := TemplateManager{}
listTemplate := templateManager.GetListTemplate(schemaName)
isFromList := true
result := c.listSelectorCommon(&listTemplate, true, isFromList)
bbsPostIdStr := c.Params.Get("bbsPostId")
bbsPostId, err := strconv.Atoi(bbsPostIdStr)
if err != nil {
panic(err)
}
c.addOrUpdateBbsPostRead(sessionId, bbsPostId)
c.CommitTxn(sessionId)
format := c.Params.Get("format")
if strings.ToLower(format) == "json" {
callback := c.Params.Get("callback")
if callback == "" {
dataBo := result["dataBo"]
c.Response.ContentType = "application/json; charset=utf-8"
return c.RenderJson(&dataBo)
}
dataBoText := result["dataBoText"].(string)
c.Response.ContentType = "text/javascript; charset=utf-8"
return c.RenderText(callback + "(" + dataBoText + ");")
} else {
//c.Response.ContentType = "text/html; charset=utf-8"
c.RenderArgs["result"] = result
return c.RenderTemplate(listTemplate.ViewTemplate.View)
// return c.Render(result)
}
}
func (c BaseDataAction) RNewDataCommon() ModelRenderVO {
sessionId := global.GetSessionId()
global.SetGlobalAttr(sessionId, "userId", c.Session["userId"])
global.SetGlobalAttr(sessionId, "adminUserId", c.Session["adminUserId"])
defer global.CloseSession(sessionId)
defer c.RRollbackTxn(sessionId)
userId, err := strconv.Atoi(c.Session["userId"])
if err != nil {
panic(err)
}
dataSourceModelId := c.Params.Get("dataSourceModelId")
formTemplateId := c.Params.Get("formTemplateId")
modelTemplateFactory := ModelTemplateFactory{}
dataSource := modelTemplateFactory.GetDataSource(dataSourceModelId)
templateManager := TemplateManager{}
formTemplate := templateManager.GetFormTemplate(formTemplateId)
c.RActionSupport.RBeforeNewData(sessionId, dataSource, formTemplate)
bo := modelTemplateFactory.GetInstanceByDS(dataSource)
c.RActionSupport.RAfterNewData(sessionId, dataSource, formTemplate, &bo)
columnModelData := templateManager.GetColumnModelDataForFormTemplate(sessionId, formTemplate, bo)
bo = columnModelData["bo"].(map[string]interface{})
relationBo := columnModelData["relationBo"].(map[string]interface{})
modelTemplateFactory.ClearReverseRelation(&dataSource)
c.CommitTxn(sessionId)
return ModelRenderVO{
UserId: userId,
Bo: bo,
RelationBo: relationBo,
DataSource: dataSource,
FormTemplate: formTemplate,
}
}
func (c BaseDataAction) RSaveCommon() ModelRenderVO {
sessionId := global.GetSessionId()
global.SetGlobalAttr(sessionId, "userId", c.Session["userId"])
global.SetGlobalAttr(sessionId, "adminUserId", c.Session["adminUserId"])
defer global.CloseSession(sessionId)
defer c.RRollbackTxn(sessionId)
userId, err := strconv.Atoi(c.Session["userId"])
if err != nil {
panic(err)
}
dataSourceModelId := c.Params.Form.Get("dataSourceModelId")
formTemplateId := c.Params.Get("formTemplateId")
jsonBo := c.Params.Form.Get("jsonData")
bo := map[string]interface{}{}
err = json.Unmarshal([]byte(jsonBo), &bo)
if err != nil {
panic(err)
}
modelTemplateFactory := ModelTemplateFactory{}
dataSource := modelTemplateFactory.GetDataSource(dataSourceModelId)
templateManager := TemplateManager{}
formTemplate := templateManager.GetFormTemplate(formTemplateId)
modelTemplateFactory.ConvertDataType(dataSource, &bo)
strId := modelTemplateFactory.GetStrId(bo)
if strId == "" || strId == "0" {
c.RSetCreateFixFieldValue(sessionId, dataSource, &bo)
} else {
c.RSetModifyFixFieldValue(sessionId, dataSource, &bo)
editMessage, isValid := c.RActionSupport.REditValidate(sessionId, dataSource, formTemplate, bo)
if !isValid {
panic(editMessage)
}
}
c.RActionSupport.RBeforeSaveData(sessionId, dataSource, formTemplate, &bo)
financeService := FinanceService{}
diffDataRowLi := financeService.SaveData(sessionId, dataSource, &bo)
c.RActionSupport.RAfterSaveData(sessionId, dataSource, formTemplate, &bo, diffDataRowLi)
querySupport := QuerySupport{}
queryMap := map[string]interface{}{
"_id": bo["id"],
}
permissionSupport := PermissionSupport{}
permissionQueryDict := permissionSupport.GetPermissionQueryDict(sessionId, formTemplate.Security)
for k, v := range permissionQueryDict {
queryMap[k] = v
}
collectionName := modelTemplateFactory.GetCollectionName(dataSource)
bo, _ = querySupport.FindByMap(collectionName, queryMap)
usedCheck := UsedCheck{}
usedCheckBo := usedCheck.GetFormUsedCheck(sessionId, dataSource, bo)
columnModelData := templateManager.GetColumnModelDataForFormTemplate(sessionId, formTemplate, bo)
bo = columnModelData["bo"].(map[string]interface{})
relationBo := columnModelData["relationBo"].(map[string]interface{})
modelTemplateFactory.ClearReverseRelation(&dataSource)
c.CommitTxn(sessionId)
return ModelRenderVO{
UserId: userId,
Bo: bo,
RelationBo: relationBo,
UsedCheckBo: usedCheckBo,
DataSource: dataSource,
FormTemplate: formTemplate,
}
}
func (c CashAccountInit) RSaveCommon() ModelRenderVO {
sessionId := global.GetSessionId()
global.SetGlobalAttr(sessionId, "userId", c.Session["userId"])
global.SetGlobalAttr(sessionId, "adminUserId", c.Session["adminUserId"])
defer global.CloseSession(sessionId)
defer c.RRollbackTxn(sessionId)
userId, err := strconv.Atoi(c.Session["userId"])
if err != nil {
panic(err)
}
// 自己拆,再循环保存
// dataSourceModelId := c.Params.Form.Get("dataSourceModelId")
dataSourceModelId := "AccountInit"
formTemplateId := c.Params.Get("formTemplateId")
jsonBo := c.Params.Form.Get("jsonData")
bo := map[string]interface{}{}
err = json.Unmarshal([]byte(jsonBo), &bo)
if err != nil {
panic(err)
}
continueAnyAll := "false"
if bo["continueAnyAll"] != nil && fmt.Sprint(bo["continueAnyAll"]) != "" {
continueAnyAll = bo["continueAnyAll"].(string)
}
modelTemplateFactory := ModelTemplateFactory{}
dataSource := modelTemplateFactory.GetDataSource(dataSourceModelId)
templateManager := TemplateManager{}
formTemplate := templateManager.GetFormTemplate(formTemplateId)
// modelTemplateFactory.ConvertDataType(dataSource, &bo)
cashAccountInitLi := []map[string]interface{}{}
bDataSetLi := bo["B"].([]interface{})
nowIdLi := []int{}
for _, item := range bDataSetLi {
mapItem := item.(map[string]interface{})
line := map[string]interface{}{
"A": mapItem,
}
if mapItem["id"] != nil {
line["id"] = mapItem["id"]
line["_id"] = mapItem["id"]
} else {
line["id"] = ""
line["_id"] = ""
}
modelTemplateFactory.ConvertDataType(dataSource, &line)
strId := fmt.Sprint(line["id"])
if strId != "" {
intId, _ := strconv.Atoi(strId)
nowIdLi = append(nowIdLi, intId)
}
cashAccountInitLi = append(cashAccountInitLi, line)
}
queryData := bo["A"].(map[string]interface{})
strAccountId := fmt.Sprint(queryData["accountId"])
// 先处理删除的数据,并弄到差异数据中
diffDataRowAllLi := []DiffDataRow{}
toDeleteLi := c.dealDelete(sessionId, dataSource, formTemplate, queryData, nowIdLi)
modelIterator := ModelIterator{}
for _, item := range toDeleteLi {
var result interface{} = ""
modelIterator.IterateDataBo(dataSource, &item, &result, func(fieldGroupLi []FieldGroup, data *map[string]interface{}, rowIndex int, result *interface{}) {
diffDataRow := DiffDataRow{
FieldGroupLi: fieldGroupLi,
SrcData: *data,
SrcBo: item,
}
diffDataRowAllLi = append(diffDataRowAllLi, diffDataRow)
})
}
bo = map[string]interface{}{
"_id": 0,
"id": 0,
"A": map[string]interface{}{
"id": 0,
"accountId": strAccountId,
},
}
bDataSetLi = []interface{}{}
for i, _ := range cashAccountInitLi {
cashAccountInit := &cashAccountInitLi[i]
strId := modelTemplateFactory.GetStrId(*cashAccountInit)
if strId == "" || strId == "0" {
c.RSetCreateFixFieldValue(sessionId, dataSource, cashAccountInit)
} else {
c.RSetModifyFixFieldValue(sessionId, dataSource, cashAccountInit)
editMessage, isValid := c.RActionSupport.REditValidate(sessionId, dataSource, formTemplate, *cashAccountInit)
if !isValid {
panic(editMessage)
}
}
// 这样只会是新增和修改的数据
c.RActionSupport.RBeforeSaveData(sessionId, dataSource, formTemplate, cashAccountInit)
financeService := FinanceService{}
diffDataRowLi := financeService.SaveData(sessionId, dataSource, cashAccountInit)
c.RActionSupport.RAfterSaveData(sessionId, dataSource, formTemplate, cashAccountInit, diffDataRowLi)
bDataSetLi = append(bDataSetLi, (*cashAccountInit)["A"])
for _, diffDataRowItem := range *diffDataRowLi {
diffDataRowAllLi = append(diffDataRowAllLi, diffDataRowItem)
}
}
cashAccountInitSupport := c.RActionSupport.(CashAccountInitSupport)
cashAccountInitSupport.checkLimitsControl(sessionId, diffDataRowAllLi, continueAnyAll)
bo["B"] = bDataSetLi
usedCheckBo := map[string]interface{}{}
columnModelData := templateManager.GetColumnModelDataForFormTemplate(sessionId, formTemplate, bo)
bo = columnModelData["bo"].(map[string]interface{})
relationBo := columnModelData["relationBo"].(map[string]interface{})
modelTemplateFactory.ClearReverseRelation(&dataSource)
c.CommitTxn(sessionId)
return ModelRenderVO{
UserId: userId,
Bo: bo,
RelationBo: relationBo,
UsedCheckBo: usedCheckBo,
DataSource: dataSource,
}
}
func (c CashAccountInit) RRefreshDataCommon() ModelRenderVO {
sessionId := global.GetSessionId()
global.SetGlobalAttr(sessionId, "userId", c.Session["userId"])
global.SetGlobalAttr(sessionId, "adminUserId", c.Session["adminUserId"])
defer global.CloseSession(sessionId)
defer c.RRollbackTxn(sessionId)
userId, err := strconv.Atoi(c.Session["userId"])
if err != nil {
panic(err)
}
// dataSourceModelId := c.Params.Get("dataSourceModelId")
dataSourceModelId := "AccountInit"
formTemplateId := c.Params.Get("formTemplateId")
queryDataStr := c.Params.Get("queryData")
queryData := map[string]interface{}{}
err = json.Unmarshal([]byte(queryDataStr), &queryData)
if err != nil {
panic(err)
}
strAccountId := fmt.Sprint(queryData["accountId"])
// strId := c.Params.Get("id")
// id, err := strconv.Atoi(strId)
// if err != nil {
// panic(err)
// }
session, _ := global.GetConnection(sessionId)
querySupport := QuerySupport{}
queryMap := map[string]interface{}{
"A.accountType": 1,
}
templateManager := TemplateManager{}
formTemplate := templateManager.GetFormTemplate(formTemplateId)
permissionSupport := PermissionSupport{}
permissionQueryDict := permissionSupport.GetPermissionQueryDict(sessionId, formTemplate.Security)
for k, v := range permissionQueryDict {
queryMap[k] = v
}
if strAccountId != "" && strAccountId != "0" {
accountIdLi := []int{}
for _, item := range strings.Split(strAccountId, ",") {
accountId, err := strconv.Atoi(item)
if err != nil {
panic(err)
}
accountIdLi = append(accountIdLi, accountId)
}
queryMap["A.accountId"] = map[string]interface{}{
"$in": accountIdLi,
}
}
modelTemplateFactory := ModelTemplateFactory{}
dataSource := modelTemplateFactory.GetDataSource(dataSourceModelId)
collectionName := modelTemplateFactory.GetCollectionName(dataSource)
// 需要进行循环处理,再转回来,
pageNo := 1
pageSize := 1000
orderBy := ""
result := querySupport.IndexWithSession(session, collectionName, queryMap, pageNo, pageSize, orderBy)
items := result["items"].([]interface{})
dataSetLi := []interface{}{}
for _, item := range items {
line := item.(map[string]interface{})
bo := map[string]interface{}{
"_id": line["id"],
"id": line["id"],
"A": line["A"],
}
modelTemplateFactory.ConvertDataType(dataSource, &bo)
c.RActionSupport.RBeforeRefreshData(sessionId, dataSource, formTemplate, &bo)
c.RActionSupport.RAfterRefreshData(sessionId, dataSource, formTemplate, &bo)
dataSetLi = append(dataSetLi, bo["A"])
}
bo := map[string]interface{}{
"_id": 0,
"id": 0,
"A": map[string]interface{}{
"id": 0,
"accountId": strAccountId,
},
"B": dataSetLi,
}
// usedCheck := UsedCheck{}
// usedCheckBo := usedCheck.GetFormUsedCheck(sessionId, dataSource, bo)
usedCheckBo := map[string]interface{}{}
columnModelData := templateManager.GetColumnModelDataForFormTemplate(sessionId, formTemplate, bo)
bo = columnModelData["bo"].(map[string]interface{})
relationBo := columnModelData["relationBo"].(map[string]interface{})
modelTemplateFactory.ClearReverseRelation(&dataSource)
c.CommitTxn(sessionId)
return ModelRenderVO{
UserId: userId,
Bo: bo,
RelationBo: relationBo,
UsedCheckBo: usedCheckBo,
DataSource: dataSource,
}
}
func (c CashAccountInit) RGetDataCommon() ModelRenderVO {
sessionId := global.GetSessionId()
global.SetGlobalAttr(sessionId, "userId", c.Session["userId"])
global.SetGlobalAttr(sessionId, "adminUserId", c.Session["adminUserId"])
defer global.CloseSession(sessionId)
defer c.RRollbackTxn(sessionId)
userId, err := strconv.Atoi(c.Session["userId"])
if err != nil {
panic(err)
}
// dataSourceModelId := c.Params.Get("dataSourceModelId")
dataSourceModelId := "AccountInit"
formTemplateId := c.Params.Get("formTemplateId")
session, _ := global.GetConnection(sessionId)
querySupport := QuerySupport{}
queryMap := map[string]interface{}{
"A.accountType": 1,
}
templateManager := TemplateManager{}
formTemplate := templateManager.GetFormTemplate(formTemplateId)
permissionSupport := PermissionSupport{}
permissionQueryDict := permissionSupport.GetPermissionQueryDict(sessionId, formTemplate.Security)
for k, v := range permissionQueryDict {
queryMap[k] = v
}
modelTemplateFactory := ModelTemplateFactory{}
dataSource := modelTemplateFactory.GetDataSource(dataSourceModelId)
collectionName := modelTemplateFactory.GetCollectionName(dataSource)
c.RActionSupport.RBeforeGetData(sessionId, dataSource, formTemplate)
// 需要进行循环处理,再转回来,
pageNo := 1
pageSize := 1000
orderBy := ""
queryMapByte, err := json.MarshalIndent(&queryMap, "", "\t")
if err != nil {
panic(err)
}
log.Println("dealDelete,collectionName:" + collectionName + ", query:" + string(queryMapByte))
result := querySupport.IndexWithSession(session, collectionName, queryMap, pageNo, pageSize, orderBy)
items := result["items"].([]interface{})
dataSetLi := []interface{}{}
for _, item := range items {
line := item.(map[string]interface{})
bo := map[string]interface{}{
"_id": line["id"],
"id": line["id"],
"A": line["A"],
}
modelTemplateFactory.ConvertDataType(dataSource, &bo)
c.RActionSupport.RAfterGetData(sessionId, dataSource, formTemplate, &bo)
dataSetLi = append(dataSetLi, bo["A"])
}
bo := map[string]interface{}{
"_id": 0,
"id": 0,
"A": map[string]interface{}{
"id": 0,
"accountId": 0,
},
"B": dataSetLi,
}
// usedCheck := UsedCheck{}
// usedCheckBo := usedCheck.GetFormUsedCheck(sessionId, dataSource, bo)
usedCheckBo := map[string]interface{}{}
columnModelData := templateManager.GetColumnModelDataForFormTemplate(sessionId, formTemplate, bo)
bo = columnModelData["bo"].(map[string]interface{})
relationBo := columnModelData["relationBo"].(map[string]interface{})
// modelTemplateFactory.ConvertDataType(dataSource, &bo)
modelTemplateFactory.ClearReverseRelation(&dataSource)
return ModelRenderVO{
UserId: userId,
Bo: bo,
RelationBo: relationBo,
UsedCheckBo: usedCheckBo,
DataSource: dataSource,
}
}
func (c Console) Refretor() revel.Result {
sessionId := global.GetSessionId()
global.SetGlobalAttr(sessionId, "userId", c.Session["userId"])
global.SetGlobalAttr(sessionId, "adminUserId", c.Session["adminUserId"])
defer global.CloseSession(sessionId)
refretorType := c.Params.Get("type")
templateManager := TemplateManager{}
formTemplate := templateManager.GetFormTemplate("Console")
if refretorType == "Component" {
listTemplateInfoLi := templateManager.RefretorListTemplateInfo()
items := getSummaryListTemplateInfoLi(listTemplateInfoLi)
for _, item := range formTemplate.FormElemLi {
if item.XMLName.Local == "column-model" && item.ColumnModel.Name == "Component" {
itemsDict := templateManager.GetColumnModelDataForColumnModel(sessionId, item.ColumnModel, items)
items = itemsDict["items"].([]interface{})
break
}
}
dataBo := map[string]interface{}{
"items": items,
}
c.Response.ContentType = "application/json; charset=utf-8"
return c.RenderJson(&dataBo)
}
if refretorType == "Selector" {
selectorTemplateInfoLi := templateManager.RefretorSelectorTemplateInfo()
items := getSummarySelectorTemplateInfoLi(selectorTemplateInfoLi)
for _, item := range formTemplate.FormElemLi {
if item.XMLName.Local == "column-model" && item.ColumnModel.Name == "Selector" {
itemsDict := templateManager.GetColumnModelDataForColumnModel(sessionId, item.ColumnModel, items)
items = itemsDict["items"].([]interface{})
break
}
}
dataBo := map[string]interface{}{
"items": items,
}
c.Response.ContentType = "application/json; charset=utf-8"
return c.RenderJson(&dataBo)
}
if refretorType == "Form" {
formTemplateInfoLi := templateManager.RefretorFormTemplateInfo()
items := getSummaryFormTemplateInfoLi(formTemplateInfoLi)
for _, item := range formTemplate.FormElemLi {
if item.XMLName.Local == "column-model" && item.ColumnModel.Name == "Form" {
itemsDict := templateManager.GetColumnModelDataForColumnModel(sessionId, item.ColumnModel, items)
items = itemsDict["items"].([]interface{})
break
}
}
dataBo := map[string]interface{}{
"items": items,
}
c.Response.ContentType = "application/json; charset=utf-8"
return c.RenderJson(&dataBo)
}
if refretorType == "DataSource" {
modelTemplateFactory := ModelTemplateFactory{}
dataSourceTemplateInfoLi := modelTemplateFactory.RefretorDataSourceInfo()
items := getSummaryDataSourceInfoLi(dataSourceTemplateInfoLi)
for _, item := range formTemplate.FormElemLi {
if item.XMLName.Local == "column-model" && item.ColumnModel.Name == "DataSource" {
itemsDict := templateManager.GetColumnModelDataForColumnModel(sessionId, item.ColumnModel, items)
items = itemsDict["items"].([]interface{})
break
}
}
dataBo := map[string]interface{}{
"items": items,
}
c.Response.ContentType = "application/json; charset=utf-8"
return c.RenderJson(&dataBo)
}
c.Response.ContentType = "application/json; charset=utf-8"
return c.RenderJson(map[string]interface{}{
"message": "可能传入了错误的refretorType:" + refretorType,
})
}
func (c BillAction) RUnCancelDataCommon() ModelRenderVO {
sessionId := global.GetSessionId()
global.SetGlobalAttr(sessionId, "userId", c.Session["userId"])
global.SetGlobalAttr(sessionId, "adminUserId", c.Session["adminUserId"])
defer global.CloseSession(sessionId)
defer c.RRollbackTxn(sessionId)
userId, err := strconv.Atoi(c.Session["userId"])
if err != nil {
panic(err)
}
dataSourceModelId := c.Params.Get("dataSourceModelId")
formTemplateId := c.Params.Get("formTemplateId")
strId := c.Params.Get("id")
id, err := strconv.Atoi(strId)
if err != nil {
panic(err)
}
querySupport := QuerySupport{}
queryMap := map[string]interface{}{
"_id": id,
}
templateManager := TemplateManager{}
formTemplate := templateManager.GetFormTemplate(formTemplateId)
permissionSupport := PermissionSupport{}
permissionQueryDict := permissionSupport.GetPermissionQueryDict(sessionId, formTemplate.Security)
for k, v := range permissionQueryDict {
queryMap[k] = v
}
modelTemplateFactory := ModelTemplateFactory{}
dataSource := modelTemplateFactory.GetDataSource(dataSourceModelId)
collectionName := modelTemplateFactory.GetCollectionName(dataSource)
bo, found := querySupport.FindByMap(collectionName, queryMap)
if !found {
panic("UnCancelData, dataSouceModelId=" + dataSourceModelId + ", id=" + strId + " not found")
}
c.setRequestParameterToBo(&bo)
modelTemplateFactory.ConvertDataType(dataSource, &bo)
c.RSetModifyFixFieldValue(sessionId, dataSource, &bo)
c.RActionSupport.RBeforeUnCancelData(sessionId, dataSource, formTemplate, &bo)
mainData := bo["A"].(map[string]interface{})
if fmt.Sprint(mainData["billStatus"]) == "1" {
panic(BusinessError{Message: "单据已经反作废，不可再次反作废"})
}
mainData["billStatus"] = 1
_, db := global.GetConnection(sessionId)
txnManager := TxnManager{db}
txnId := global.GetTxnId(sessionId)
_, updateResult := txnManager.Update(txnId, dataSourceModelId, bo)
if !updateResult {
panic("反作废失败")
}
c.RActionSupport.RAfterUnCancelData(sessionId, dataSource, formTemplate, &bo)
bo, _ = querySupport.FindByMap(collectionName, queryMap)
usedCheck := UsedCheck{}
usedCheckBo := usedCheck.GetFormUsedCheck(sessionId, dataSource, bo)
columnModelData := templateManager.GetColumnModelDataForFormTemplate(sessionId, formTemplate, bo)
bo = columnModelData["bo"].(map[string]interface{})
relationBo := columnModelData["relationBo"].(map[string]interface{})
modelTemplateFactory.ClearReverseRelation(&dataSource)
c.CommitTxn(sessionId)
return ModelRenderVO{
UserId: userId,
Bo: bo,
RelationBo: relationBo,
UsedCheckBo: usedCheckBo,
DataSource: dataSource,
FormTemplate: formTemplate,
}
}
// TODO,by test
func (c Console) FormSchema() revel.Result {
sessionId := global.GetSessionId()
global.SetGlobalAttr(sessionId, "userId", c.Session["userId"])
global.SetGlobalAttr(sessionId, "adminUserId", c.Session["adminUserId"])
defer global.CloseSession(sessionId)
schemaName := c.Params.Get("@name")
strId := c.Params.Get("id")
formStatus := c.Params.Get("formStatus")
copyFlag := c.Params.Get("copyFlag")
templateManager := TemplateManager{}
formTemplate := templateManager.GetFormTemplate(schemaName)
result := map[string]interface{}{
"formTemplate": formTemplate,
"id": strId,
"formStatus": formStatus,
"copyFlag": copyFlag,
}
if formTemplate.DataSourceModelId != "" {
// 光有formTemplate不行,还要有model的内容,才可以渲染数据
modelTemplateFactory := ModelTemplateFactory{}
dataSource := modelTemplateFactory.GetDataSource(formTemplate.DataSourceModelId)
modelTemplateFactory.ClearReverseRelation(&dataSource)
dataSourceByte, err := json.Marshal(&dataSource)
if err != nil {
panic(err)
}
result["dataSource"] = dataSource
commonUtil := CommonUtil{}
dataSourceJson := string(dataSourceByte)
dataSourceJson = commonUtil.FilterJsonEmptyAttr(dataSourceJson)
result["dataSourceJson"] = template.JS(dataSourceJson)
}
//toolbarBo
toolbarBo := map[string]interface{}{}
for i, item := range formTemplate.FormElemLi {
if item.XMLName.Local == "toolbar" {
toolbarBo[item.Toolbar.Name] = templateManager.GetToolbarBo(item.Toolbar)
}
// 加入主数据集tag,页面渲染用
if item.XMLName.Local == "column-model" && item.ColumnModel.DataSetId == "A" {
formTemplate.FormElemLi[i].RenderTag = item.ColumnModel.DataSetId + "_" + fmt.Sprint(i)
}
}
result["toolbarBo"] = toolbarBo
dataBo := map[string]interface{}{}
relationBo := map[string]interface{}{}
result["dataBo"] = dataBo
result["relationBo"] = relationBo
relationBoByte, err := json.Marshal(&relationBo)
if err != nil {
panic(err)
}
// 主数据集的后台渲染
result["masterRenderLi"] = c.getMasterRenderLi(formTemplate)
formTemplateJsonDataArray, err := json.Marshal(&formTemplate)
if err != nil {
panic(err)
}
dataBoByte, err := json.Marshal(&dataBo)
if err != nil {
panic(err)
}
layerBo := templateManager.GetLayerForFormTemplate(sessionId, formTemplate)
iLayerBo := layerBo["layerBo"]
layerBoByte, err := json.Marshal(&iLayerBo)
if err != nil {
panic(err)
}
iLayerBoLi := layerBo["layerBoLi"]
layerBoLiByte, err := json.Marshal(&iLayerBoLi)
if err != nil {
panic(err)
}
commonUtil := CommonUtil{}
userId := commonUtil.GetIntFromString(c.Session["userId"])
sysParam := c.getSysParam(sessionId, userId)
sysParamJson, err := json.Marshal(&sysParam)
if err != nil {
panic(err)
}
result["sysParamJson"] = template.JS(string(sysParamJson))
formTemplateJsonData := string(formTemplateJsonDataArray)
formTemplateJsonData = commonUtil.FilterJsonEmptyAttr(formTemplateJsonData)
result["formTemplateJsonData"] = template.JS(formTemplateJsonData)
dataBoJson := string(dataBoByte)
dataBoJson = commonUtil.FilterJsonEmptyAttr(dataBoJson)
result["dataBoJson"] = template.JS(dataBoJson)
layerBoJson := string(layerBoByte)
layerBoJson = commonUtil.FilterJsonEmptyAttr(layerBoJson)
result["layerBoJson"] = template.JS(layerBoJson)
layerBoLiJson := string(layerBoLiByte)
layerBoLiJson = commonUtil.FilterJsonEmptyAttr(layerBoLiJson)
result["layerBoLiJson"] = template.JS(layerBoLiJson)
relationBoJson := string(relationBoByte)
relationBoJson = commonUtil.FilterJsonEmptyAttr(relationBoJson)
result["relationBoJson"] = template.JS(relationBoJson)
viewPath := revel.Config.StringDefault("REVEL_VIEW_PATH", "")
file, err := os.Open(viewPath + "/" + formTemplate.ViewTemplate.View)
defer file.Close()
if err != nil {
panic(err)
}
fileContent, err := ioutil.ReadAll(file)
if err != nil {
panic(err)
}
funcMap := map[string]interface{}{
"eq": func(a, b interface{}) bool {
return a == b
},
}
//c.Response.ContentType = "text/html; charset=utf-8"
tmpl, err := template.New("formSchema").Funcs(funcMap).Parse(string(fileContent))
if err != nil {
panic(err)
}
tmplResult := map[string]interface{}{
"result": result,
"flash": c.Flash.Out,
"session": c.Session,
}
tmpl.Execute(c.Response.Out, tmplResult)
return nil
}
func (c Console) listSelectorCommon(listTemplate *ListTemplate, isGetBo bool, isFromList bool) map[string]interface{} {
sessionId := global.GetSessionId()
global.SetGlobalAttr(sessionId, "userId", c.Session["userId"])
global.SetGlobalAttr(sessionId, "adminUserId", c.Session["adminUserId"])
defer global.CloseSession(sessionId)
// 1.toolbar bo
templateManager := TemplateManager{}
//templateManager.ApplyDictionaryForQueryParameter(listTemplate)
//templateManager.ApplyTreeForQueryParameter(listTemplate)
toolbarBo := templateManager.GetToolbarForListTemplate(*listTemplate)
paramMap := map[string]string{}
defaultBo := templateManager.GetQueryDefaultValue(*listTemplate)
defaultBoByte, err := json.Marshal(&defaultBo)
if err != nil {
panic(err)
}
for key, value := range defaultBo {
paramMap[key] = value
}
paramMap, _ = c.getCookieDataAndParamMap(sessionId, *listTemplate, isFromList, paramMap)
formDataByte, err := json.Marshal(¶mMap)
if err != nil {
panic(err)
}
// }
pageNo := 1
pageSize := 10
if listTemplate.DataProvider.Size != "" {
pageSizeInt, err := strconv.Atoi(listTemplate.DataProvider.Size)
if err != nil {
panic(err)
}
pageSize = pageSizeInt
}
if c.Params.Get("pageNo") != "" {
pageNoInt, _ := strconv.ParseInt(c.Params.Get("pageNo"), 10, 0)
if pageNoInt > 1 {
pageNo = int(pageNoInt)
}
}
if c.Params.Get("pageSize") != "" {
pageSizeInt, _ := strconv.ParseInt(c.Params.Get("pageSize"), 10, 0)
if pageSizeInt >= 10 {
pageSize = int(pageSizeInt)
}
}
dataBo := map[string]interface{}{
"totalResults": 0,
"items": []interface{}{},
}
relationBo := map[string]interface{}{}
usedCheckBo := map[string]interface{}{}
//if c.Params.Get("@entrance") != "true" {
if isGetBo {
dataBo = templateManager.GetBoForListTemplate(sessionId, listTemplate, paramMap, pageNo, pageSize)
relationBo = dataBo["relationBo"].(map[string]interface{})
//delete(dataBo, "relationBo")
// usedCheck的修改,
if listTemplate.DataSourceModelId != "" {
modelTemplateFactory := ModelTemplateFactory{}
dataSource := modelTemplateFactory.GetDataSource(listTemplate.DataSourceModelId)
items := dataBo["items"].([]interface{})
usedCheck := UsedCheck{}
usedCheckBo = usedCheck.GetListUsedCheck(sessionId, dataSource, items, listTemplate.ColumnModel.DataSetId)
}
}
dataBo["usedCheckBo"] = usedCheckBo
dataBoByte, err := json.Marshal(&dataBo)
if err != nil {
panic(err)
}
relationBoByte, err := json.Marshal(&relationBo)
if err != nil {
panic(err)
}
listTemplateByte, err := json.Marshal(listTemplate)
if err != nil {
panic(err)
}
usedCheckByte, err := json.Marshal(&usedCheckBo)
if err != nil {
panic(err)
}
// 系统参数的获取
commonUtil := CommonUtil{}
userId := commonUtil.GetIntFromString(c.Session["userId"])
sysParam := c.getSysParam(sessionId, userId)
sysParamJson, err := json.Marshal(&sysParam)
if err != nil {
panic(err)
}
queryParameterRenderLi := c.getQueryParameterRenderLi(*listTemplate)
//showParameterLi := templateManager.GetShowParameterLiForListTemplate(listTemplate)
showParameterLi := []QueryParameter{}
hiddenParameterLi := templateManager.GetHiddenParameterLiForListTemplate(listTemplate)
layerBo := templateManager.GetLayerForListTemplate(sessionId, *listTemplate)
iLayerBo := layerBo["layerBo"]
layerBoByte, err := json.Marshal(&iLayerBo)
if err != nil {
panic(err)
}
iLayerBoLi := layerBo["layerBoLi"]
layerBoLiByte, err := json.Marshal(&iLayerBoLi)
if err != nil {
panic(err)
}
layerBoJson := string(layerBoByte)
layerBoJson = commonUtil.FilterJsonEmptyAttr(layerBoJson)
layerBoLiJson := string(layerBoLiByte)
layerBoLiJson = commonUtil.FilterJsonEmptyAttr(layerBoLiJson)
result := map[string]interface{}{
"pageSize": pageSize,
"listTemplate": listTemplate,
"toolbarBo": toolbarBo,
"showParameterLi": showParameterLi,
"hiddenParameterLi": hiddenParameterLi,
"queryParameterRenderLi": queryParameterRenderLi,
"dataBo": dataBo,
// "columns": columns,
"dataBoText": string(dataBoByte),
"dataBoJson": template.JS(string(dataBoByte)),
"relationBoJson": template.JS(string(relationBoByte)),
"listTemplateJson": template.JS(string(listTemplateByte)),
"layerBoJson": template.JS(layerBoJson),
"layerBoLiJson": template.JS(layerBoLiJson),
"defaultBoJson": template.JS(string(defaultBoByte)),
"formDataJson": template.JS(string(formDataByte)),
"usedCheckJson": template.JS(string(usedCheckByte)),
"sysParamJson": template.JS(string(sysParamJson)),
// "columnsJson": string(columnsByte),
}
return result
}
func (c Console) SelectorSchema() revel.Result {
sessionId := global.GetSessionId()
global.SetGlobalAttr(sessionId, "userId", c.Session["userId"])
global.SetGlobalAttr(sessionId, "adminUserId", c.Session["adminUserId"])
defer global.CloseSession(sessionId)
schemaName := c.Params.Get("@name")
templateManager := TemplateManager{}
listTemplate := templateManager.GetSelectorTemplate(schemaName)
c.setSelectionMode(&listTemplate)
c.setDisplayField(&listTemplate)
isGetBo := false
if c.Params.Get("format") != "" {
isGetBo = true
}
isFromList := false
result := c.listSelectorCommon(&listTemplate, isGetBo, isFromList)
selectionBo := map[string]interface{}{
"url": templateManager.GetViewUrl(listTemplate),
"Description": listTemplate.Description,
}
ids := c.Params.Get("@id")
if ids != "" {
relationLi := []map[string]interface{}{}
strIdLi := strings.Split(ids, ",")
selectorId := listTemplate.SelectorId
if selectorId == "" {
selectorId = listTemplate.Id
}
for _, item := range strIdLi {
if item != "" {
id, err := strconv.Atoi(item)
if err != nil {
panic(err)
}
relationLi = append(relationLi, map[string]interface{}{
"relationId": id,
"selectorId": selectorId,
})
}
}
templateManager := TemplateManager{}
relationBo := templateManager.GetRelationBo(sessionId, relationLi)
if relationBo[selectorId] != nil {
selectionBo = relationBo[selectorId].(map[string]interface{})
}
}
selectionBoByte, err := json.Marshal(&selectionBo)
if err != nil {
panic(err)
}
commonUtil := CommonUtil{}
selectionBoJson := string(selectionBoByte)
selectionBoJson = commonUtil.FilterJsonEmptyAttr(selectionBoJson)
result["selectionBoJson"] = template.JS(selectionBoJson)
format := c.Params.Get("format")
if strings.ToLower(format) == "json" {
callback := c.Params.Get("callback")
if callback == "" {
dataBo := result["dataBo"]
c.Response.ContentType = "application/json; charset=utf-8"
return c.RenderJson(&dataBo)
}
dataBoText := result["dataBoText"].(string)
c.Response.ContentType = "text/javascript; charset=utf-8"
return c.RenderText(callback + "(" + dataBoText + ");")
} else {
// return c.Render(result)
//c.Response.ContentType = "text/html; charset=utf-8"
c.RenderArgs["result"] = result
return c.RenderTemplate(listTemplate.ViewTemplate.SelectorView)
}
}
func (c Console) Summary() revel.Result {
println("session is:", c.Session["userId"])
sessionId := global.GetSessionId()
global.SetGlobalAttr(sessionId, "userId", c.Session["userId"])
global.SetGlobalAttr(sessionId, "adminUserId", c.Session["adminUserId"])
defer global.CloseSession(sessionId)
templateManager := TemplateManager{}
formTemplate := templateManager.GetFormTemplate("Console")
// if true {
// xmlDataArray, err := xml.Marshal(&formTemplate)
// if err != nil {
// panic(err)
// }
// return c.RenderXml(&formTemplate)
// }
formTemplateJsonDataArray, err := json.Marshal(&formTemplate)
if err != nil {
panic(err)
}
toolbarBo := map[string]interface{}{}
dataBo := map[string]interface{}{}
{
listTemplateInfoLi := templateManager.GetListTemplateInfoLi()
dataBo["Component"] = getSummaryListTemplateInfoLi(listTemplateInfoLi)
}
{
selectorTemplateInfoLi := templateManager.GetSelectorTemplateInfoLi()
dataBo["Selector"] = getSummarySelectorTemplateInfoLi(selectorTemplateInfoLi)
}
{
formTemplateInfoLi := templateManager.GetFormTemplateInfoLi()
dataBo["Form"] = getSummaryFormTemplateInfoLi(formTemplateInfoLi)
}
{
modelTemplateFactory := ModelTemplateFactory{}
dataSourceInfoLi := modelTemplateFactory.GetDataSourceInfoLi()
dataBo["DataSource"] = getSummaryDataSourceInfoLi(dataSourceInfoLi)
}
for _, item := range formTemplate.FormElemLi {
if item.XMLName.Local == "column-model" {
if dataBo[item.ColumnModel.Name] == nil {
dataBo[item.ColumnModel.Name] = []interface{}{}
}
items := dataBo[item.ColumnModel.Name].([]interface{})
itemsDict := templateManager.GetColumnModelDataForColumnModel(sessionId, item.ColumnModel, items)
items = itemsDict["items"].([]interface{})
dataBo[item.ColumnModel.Name] = items
} else if item.XMLName.Local == "toolbar" {
toolbarBo[item.Toolbar.Name] = templateManager.GetToolbarBo(item.Toolbar)
}
}
dataBoByte, err := json.Marshal(dataBo)
if err != nil {
panic(err)
}
// c.Response.Status = http.StatusOK
// c.Response.ContentType = "text/plain; charset=utf-8"
result := map[string]interface{}{
"formTemplate": formTemplate,
"toolbarBo": toolbarBo,
"dataBo": dataBo,
"formTemplateJsonData": template.JS(string(formTemplateJsonDataArray)),
"dataBoJson": template.JS(string(dataBoByte)),
}
// formTemplate.ViewTemplate.View
// RenderText(text string, objs ...interface{}) Result
viewPath := revel.Config.StringDefault("REVEL_VIEW_PATH", "")
file, err := os.Open(viewPath + "/" + formTemplate.ViewTemplate.View)
defer file.Close()
if err != nil {
panic(err)
}
fileContent, err := ioutil.ReadAll(file)
if err != nil {
panic(err)
}
// c.Response.Out
// return c.RenderTemplate(string(fileContent))
funcMap := map[string]interface{}{
"eq": func(a, b interface{}) bool {
return a == b
},
}
//c.Response.ContentType = "text/html; charset=utf-8"
tmpl, err := template.New("summary").Funcs(funcMap).Parse(string(fileContent))
if err != nil {
panic(err)
}
tmplResult := map[string]interface{}{
"result": result,
}
//tmpl.Execute(c.Response.Out, result)
tmpl.Execute(c.Response.Out, tmplResult)
return nil
// return c.Render(string(fileContent), result)
}
func (c BaseDataAction) RDeleteDataCommon() ModelRenderVO {
sessionId := global.GetSessionId()
global.SetGlobalAttr(sessionId, "userId", c.Session["userId"])
global.SetGlobalAttr(sessionId, "adminUserId", c.Session["adminUserId"])
defer global.CloseSession(sessionId)
defer c.RRollbackTxn(sessionId)
userId, err := strconv.Atoi(c.Session["userId"])
if err != nil {
panic(err)
}
dataSourceModelId := c.Params.Get("dataSourceModelId")
formTemplateId := c.Params.Get("formTemplateId")
strId := c.Params.Get("id")
id, err := strconv.Atoi(strId)
if err != nil {
panic(err)
}
_, db := global.GetConnection(sessionId)
querySupport := QuerySupport{}
queryMap := map[string]interface{}{
"_id": id,
}
formTemplate := FormTemplate{}
if formTemplateId != "" {
templateManager := TemplateManager{}
formTemplate = templateManager.GetFormTemplate(formTemplateId)
}
permissionSupport := PermissionSupport{}
permissionQueryDict := permissionSupport.GetPermissionQueryDict(sessionId, formTemplate.Security)
for k, v := range permissionQueryDict {
queryMap[k] = v
}
modelTemplateFactory := ModelTemplateFactory{}
dataSource := modelTemplateFactory.GetDataSource(dataSourceModelId)
// 列表页也调用这个删除方法,但是列表页又没有传递formTemplateId,只有 gatheringBill等要做赤字判断,走与form相同的逻辑,才会传 formTemplateId,
collectionName := modelTemplateFactory.GetCollectionName(dataSource)
bo, found := querySupport.FindByMap(collectionName, queryMap)
if !found {
panic("DeleteData, dataSouceModelId=" + dataSourceModelId + ", id=" + strId + " not found")
}
// 将客户端传入的各种参数写入,程序在业务方法before,after中有可能会用到
c.setRequestParameterToBo(&bo)
modelTemplateFactory.ConvertDataType(dataSource, &bo)
c.RActionSupport.RBeforeDeleteData(sessionId, dataSource, formTemplate, &bo)
usedCheck := UsedCheck{}
if usedCheck.CheckUsed(sessionId, dataSource, bo) {
panic(BusinessError{Message: "已被用，不能删除"})
}
modelIterator := ModelIterator{}
var result interface{} = ""
modelIterator.IterateDataBo(dataSource, &bo, &result, func(fieldGroupLi []FieldGroup, data *map[string]interface{}, rowIndex int, result *interface{}) {
// if fieldGroupLi[0].IsMasterField() {
usedCheck.DeleteAll(sessionId, fieldGroupLi, *data)
// }
})
txnManager := TxnManager{db}
txnId := global.GetTxnId(sessionId)
_, removeResult := txnManager.Remove(txnId, dataSourceModelId, bo)
if !removeResult {
panic("删除失败")
}
c.RActionSupport.RAfterDeleteData(sessionId, dataSource, formTemplate, &bo)
// 列表页也调用这个删除方法,但是列表页又没有传递formTemplateId
relationBo := map[string]interface{}{}
if formTemplateId != "" {
templateManager := TemplateManager{}
columnModelData := templateManager.GetColumnModelDataForFormTemplate(sessionId, formTemplate, bo)
bo = columnModelData["bo"].(map[string]interface{})
relationBo = columnModelData["relationBo"].(map[string]interface{})
}
modelTemplateFactory.ClearReverseRelation(&dataSource)
c.CommitTxn(sessionId)
return ModelRenderVO{
UserId: userId,
Bo: bo,
RelationBo: relationBo,
DataSource: dataSource,
FormTemplate: formTemplate,
}
}
func (c AccountInOutDisplay) RGetDataCommon() ModelRenderVO {
sessionId := global.GetSessionId()
global.SetGlobalAttr(sessionId, "userId", c.Session["userId"])
global.SetGlobalAttr(sessionId, "adminUserId", c.Session["adminUserId"])
defer global.CloseSession(sessionId)
defer c.RRollbackTxn(sessionId)
userId, err := strconv.Atoi(c.Session["userId"])
if err != nil {
panic(err)
}
dataSourceModelId := c.Params.Get("dataSourceModelId")
formTemplateId := c.Params.Get("formTemplateId")
jsonData := c.Params.Get("jsonData")
jsonMap := map[string]interface{}{}
err = json.Unmarshal([]byte(jsonData), &jsonMap)
if err != nil {
panic(err)
}
queryMap := jsonMap["A"].(map[string]interface{})
modelTemplateFactory := ModelTemplateFactory{}
dataSource := modelTemplateFactory.GetDataSource(dataSourceModelId)
templateManager := TemplateManager{}
formTemplate := templateManager.GetFormTemplate(formTemplateId)
accountLi := c.getAccountList(sessionId, formTemplate, queryMap)
origBalanceLi := c.getOrigBalanceList(sessionId, formTemplate, queryMap)
increaseReduceBalanceLi := c.getIncreaseReduceBalanceList(sessionId, formTemplate, queryMap)
dataSetLi := c.mergeAndCalceFinalBalance(accountLi, origBalanceLi, increaseReduceBalanceLi)
dataSetLi = c.filterEmpty(dataSetLi, queryMap)
bo := map[string]interface{}{
"_id": 0,
"id": 0,
"A": map[string]interface{}{
"id": 0,
},
"B": dataSetLi,
}
// usedCheck := UsedCheck{}
// usedCheckBo := usedCheck.GetFormUsedCheck(sessionId, dataSource, bo)
usedCheckBo := map[string]interface{}{}
columnModelData := templateManager.GetColumnModelDataForFormTemplate(sessionId, formTemplate, bo)
bo = columnModelData["bo"].(map[string]interface{})
relationBo := columnModelData["relationBo"].(map[string]interface{})
modelTemplateFactory.ConvertDataType(dataSource, &bo)
modelTemplateFactory.ClearReverseRelation(&dataSource)
return ModelRenderVO{
UserId: userId,
Bo: bo,
RelationBo: relationBo,
UsedCheckBo: usedCheckBo,
DataSource: dataSource,
}
}
func (c AccountingPeriod) renderCommon(modelRenderVO ModelRenderVO) revel.Result {
bo := modelRenderVO.Bo
relationBo := modelRenderVO.RelationBo
dataSource := modelRenderVO.DataSource
usedCheckBo := modelRenderVO.UsedCheckBo
// 重新修改usedCheckBo,改为查询单据,只要在会计期内存在单据,则视为被用
modelTemplateFactory := ModelTemplateFactory{}
strId := modelTemplateFactory.GetStrId(bo)
if strId != "" && strId != "0" {
bDataSetLi := bo["B"].([]interface{})
firstLineData := bDataSetLi[0].(map[string]interface{})
lastLineData := bDataSetLi[len(bDataSetLi)-1].(map[string]interface{})
commonUtil := CommonUtil{}
firstStartDate := commonUtil.GetIntFromMap(firstLineData, "startDate")
lastEndDate := commonUtil.GetIntFromMap(lastLineData, "endDate")
qb := QuerySupport{}
//GatheringBill,PayBill
sessionId := global.GetSessionId()
global.SetGlobalAttr(sessionId, "userId", fmt.Sprint(modelRenderVO.UserId))
defer global.CloseSession(sessionId)
session, _ := global.GetConnection(sessionId)
queryMap := map[string]interface{}{
"A.billDate": map[string]interface{}{
"$gte": firstStartDate,
"$lt": lastEndDate,
},
}
permissionSupport := PermissionSupport{}
permissionQueryDict := permissionSupport.GetPermissionQueryDict(sessionId, modelRenderVO.FormTemplate.Security)
for k, v := range permissionQueryDict {
queryMap[k] = v
}
dataSourceIdLi := []string{"GatheringBill", "PayBill"}
for _, dataSourceId := range dataSourceIdLi {
tmpDataSource := modelTemplateFactory.GetDataSource(dataSourceId)
collectionName := modelTemplateFactory.GetCollectionName(tmpDataSource)
_, found := qb.FindByMapWithSession(session, collectionName, queryMap)
if found {
// 主数据集设置被用标记
if usedCheckBo["A"] == nil {
usedCheckBo["A"] = map[string]interface{}{}
}
masterUsedCheck := usedCheckBo["A"].(map[string]interface{})
usedCheckBo["A"] = masterUsedCheck
masterUsedCheck[strId] = true
// 分录数据集设置被用标记
if usedCheckBo["B"] == nil {
usedCheckBo["B"] = map[string]interface{}{}
}
detailUsedCheck := usedCheckBo["B"].(map[string]interface{})
usedCheckBo["B"] = usedCheckBo["B"]
for _, detailData := range bDataSetLi {
detailDataDict := detailData.(map[string]interface{})
detailUsedCheck[fmt.Sprint(detailDataDict["id"])] = true
}
break
}
}
}
modelIterator := ModelIterator{}
var result interface{} = ""
modelIterator.IterateAllFieldBo(dataSource, &bo, &result, func(fieldGroup FieldGroup, data *map[string]interface{}, rowIndex int, result *interface{}) {
if (*data)[fieldGroup.Id] != nil {
(*data)[fieldGroup.Id] = fmt.Sprint((*data)[fieldGroup.Id])
}
})
format := c.Params.Get("format")
if strings.ToLower(format) == "json" {
c.Response.ContentType = "application/json; charset=utf-8"
return c.RenderJson(map[string]interface{}{
"bo": bo,
"relationBo": relationBo,
"usedCheckBo": usedCheckBo,
//"dataSource": dataSource,
})
}
//c.Response.ContentType = "text/html; charset=utf-8"
return c.Render()
}