修改所有返回值

controllers/cases/case.go

 	"spaceofcheng/services/controllers"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service/cases"
+	"spaceofcheng/services/utils"
 )
 
 // CaseController 信息
 
 // GetOrgCases 获取机构案场
 func (c *CaseController) GetOrgCases() {
-	org := c.GetString("org")
+	org := c.GetString(":org")
 	if org == "" {
 		c.ResponseError(errors.New("未确定机构"))
 	}
-
+	org = utils.DecodeBase64NoTail(org)
 	res, err := c.dao.GetAllCasesAndSales(org)
 	if err != nil {
 		c.ResponseError(err)

log/common.log

 2018/09/06 08:59:42 [E] 获取课程信息失败: a pointer to a pointer is not allowed
 2018/09/06 08:59:42 [I] 远程请求结果:%!(EXTRA string={"access_token":"13_M_kvI_z4pOqAS1IOxrEBuww0pRQQc71V6Q1orhkJL7Nxt91N34sELesVttpgb575SNGF36NA08CfuEOxoxCbjL2ugqCle9NG4wdBdtjfa_YwOUJ2AD0g63LmRtcAAAbAAAJJJ","expires_in":7200})
 2018/09/06 08:59:42 [I] 接口返回结果: %!(EXTRA map[string]interface {}=map[expires_in:7200 access_token:13_M_kvI_z4pOqAS1IOxrEBuww0pRQQc71V6Q1orhkJL7Nxt91N34sELesVttpgb575SNGF36NA08CfuEOxoxCbjL2ugqCle9NG4wdBdtjfa_YwOUJ2AD0g63LmRtcAAAbAAAJJJ])
+2018/09/06 09:05:41 [I] 请求远程接口: %!(EXTRA string=https://api.weixin.qq.com/cgi-bin/token?appid=wx7320287e057bbeee&grant_type=client_credential&secret=6e844dc2ade439545c47569ba1707673)
+2018/09/06 09:05:41 [E] 获取课程信息失败: a pointer to a pointer is not allowed
+2018/09/06 09:05:42 [I] 远程请求结果:%!(EXTRA string={"access_token":"13_UNQ0aBgLhDAXD6GfeJGqZNcS6qNgg7xF5DV8Wx9XyxSbpSyeZXpGi_vZW2rPa0L0zNV5zfb9kuRA3ilLVoEvkb2PC-K4cTpVbhZfVLT4HWH7pcL1F80OPTSEniK6rwwxjoxKUZl2EYootW1KWQTaABAHBE","expires_in":7200})
+2018/09/06 09:05:42 [I] 接口返回结果: %!(EXTRA map[string]interface {}=map[access_token:13_UNQ0aBgLhDAXD6GfeJGqZNcS6qNgg7xF5DV8Wx9XyxSbpSyeZXpGi_vZW2rPa0L0zNV5zfb9kuRA3ilLVoEvkb2PC-K4cTpVbhZfVLT4HWH7pcL1F80OPTSEniK6rwwxjoxKUZl2EYootW1KWQTaABAHBE expires_in:7200])
+2018/09/06 09:44:57 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:44:57 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 09:44:57 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:44:57 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 09:44:57 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:44:57 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 09:44:57 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:44:57 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 09:44:57 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:44:57 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 09:54:25 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:54:25 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 09:54:25 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:54:25 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 09:54:25 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:54:25 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 09:54:25 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:54:25 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 09:54:25 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:54:25 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 09:54:32 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:54:32 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 09:54:32 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:54:32 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:54:32 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 09:54:32 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 09:54:34 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:54:34 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 09:54:34 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:54:34 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 09:54:34 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:54:34 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 09:54:34 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:54:34 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 09:54:34 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:54:34 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 09:55:40 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:55:40 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 09:55:40 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:55:40 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 09:55:40 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:55:40 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 09:55:40 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:55:40 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 09:55:40 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:55:40 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 09:55:43 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:55:43 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 09:55:43 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:55:43 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 09:55:43 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:55:43 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 09:55:46 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:55:46 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 09:55:46 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:55:46 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 09:55:46 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:55:46 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 09:55:46 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:55:46 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 09:55:46 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:55:46 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 09:55:47 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:55:47 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 09:55:48 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:55:48 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 09:55:49 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:55:49 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 09:55:50 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:55:50 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 09:55:58 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:55:58 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 09:55:58 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:55:58 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 09:55:58 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:55:58 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 09:55:58 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:55:58 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 09:55:58 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:55:58 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 09:56:00 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:56:00 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 09:56:04 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:56:04 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 09:56:04 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:56:04 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 09:56:04 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:56:04 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 09:56:04 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:56:04 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 09:56:04 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:56:04 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 09:56:07 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:56:07 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 09:56:09 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 09:56:09 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 10:01:10 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 10:01:10 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 10:01:20 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 10:01:20 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 10:34:46 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 10:34:46 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 10:34:46 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 10:34:46 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 10:34:46 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 10:34:46 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 10:34:46 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 10:34:46 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 10:34:47 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 10:34:47 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 10:35:26 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 10:35:26 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 10:35:26 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 10:35:26 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 10:35:26 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 10:35:26 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 10:35:26 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 10:35:26 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 10:35:26 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 10:35:26 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 10:35:26 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 10:35:26 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 10:35:27 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 10:35:27 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 10:35:27 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 10:35:27 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 10:35:27 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 10:35:27 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 10:35:27 [E] 解密 Base64 字串失败: illegal base64 data at input byte 1
+2018/09/06 10:35:27 [E] 获取组织信息失败: 没有查询到机构信息
+2018/09/06 14:30:04 [I] 请求远程接口: %!(EXTRA string=https://api.weixin.qq.com/cgi-bin/token?appid=wx7320287e057bbeee&grant_type=client_credential&secret=6e844dc2ade439545c47569ba1707673)
+2018/09/06 14:30:05 [I] 远程请求结果:%!(EXTRA string={"access_token":"13_oeXg7CEBu-D1zSyAtC04i233yiyA6yh1smV1fTd2jM0vCebT3O2FdXfrCA1cEFt2xgZX5Q4JRT7iCwc4iZoGy9tgtg_5hweK-E4iGEMIORSdl5qml-_P4jqq_C3PLnQ-u0kccj5Pt6v01cKSODLcACAUJR","expires_in":7200})
+2018/09/06 14:30:05 [I] 接口返回结果: %!(EXTRA map[string]interface {}=map[access_token:13_oeXg7CEBu-D1zSyAtC04i233yiyA6yh1smV1fTd2jM0vCebT3O2FdXfrCA1cEFt2xgZX5Q4JRT7iCwc4iZoGy9tgtg_5hweK-E4iGEMIORSdl5qml-_P4jqq_C3PLnQ-u0kccj5Pt6v01cKSODLcACAUJR expires_in:7200])
+2018/09/06 14:32:47 [I] 请求远程接口: %!(EXTRA string=https://api.weixin.qq.com/cgi-bin/token?appid=wx7320287e057bbeee&grant_type=client_credential&secret=6e844dc2ade439545c47569ba1707673)
+2018/09/06 14:32:47 [I] 远程请求结果:%!(EXTRA string={"access_token":"13_QY-DTLi748ylzUFIdDpPSHdpZ6_bBuGBfRZRDP0aUkFnD9vn9uws8fiK0MVDmD4Jw4TpsNQjP0zEj1cH_TEy_1OPScV85S5vVy7Hrh3VjwSAbVrHI_5H0CvCXKk8c41BJKknj5IBugelOyDMFRDjAFANZL","expires_in":7200})
+2018/09/06 14:32:47 [I] 接口返回结果: %!(EXTRA map[string]interface {}=map[access_token:13_QY-DTLi748ylzUFIdDpPSHdpZ6_bBuGBfRZRDP0aUkFnD9vn9uws8fiK0MVDmD4Jw4TpsNQjP0zEj1cH_TEy_1OPScV85S5vVy7Hrh3VjwSAbVrHI_5H0CvCXKk8c41BJKknj5IBugelOyDMFRDjAFANZL expires_in:7200])
+2018/09/06 14:33:07 [I] 请求远程接口: %!(EXTRA string=https://api.weixin.qq.com/cgi-bin/token?appid=wx7320287e057bbeee&grant_type=client_credential&secret=6e844dc2ade439545c47569ba1707673)
+2018/09/06 14:33:07 [I] 远程请求结果:%!(EXTRA string={"access_token":"13_nAsi2mvv4uhY5ybGC5l3Q-gCVVmfWeMuQL-5Ay2GkbMLAdgaU6nFCWp8xlr2nYubTDiXNsAG_Bwlqwk24zffGACQRjIwR0kOKpMXyEvQuJG-fZ3y1VsYGozFOxemI4skF0lhu7Mefx5S8jQWRYFfACABIP","expires_in":7200})
+2018/09/06 14:33:07 [I] 接口返回结果: %!(EXTRA map[string]interface {}=map[expires_in:7200 access_token:13_nAsi2mvv4uhY5ybGC5l3Q-gCVVmfWeMuQL-5Ay2GkbMLAdgaU6nFCWp8xlr2nYubTDiXNsAG_Bwlqwk24zffGACQRjIwR0kOKpMXyEvQuJG-fZ3y1VsYGozFOxemI4skF0lhu7Mefx5S8jQWRYFfACABIP])
+2018/09/06 14:34:01 [I] 请求远程接口: %!(EXTRA string=https://api.weixin.qq.com/cgi-bin/token?appid=wx7320287e057bbeee&grant_type=client_credential&secret=6e844dc2ade439545c47569ba1707673)
+2018/09/06 14:34:01 [I] 远程请求结果:%!(EXTRA string={"access_token":"13_eFvifYGXTdbkIU6Rn6Sm-liedNbNRUDD0lZuCVEUCavrRbp8q_DZD7PxeDT25TWPuzDlNq-43jw961aoAlRLRF9v8wumSXYXx7pHVL7CEwWOCo_Zpb--Cr-quZEWYJdAHAMOZ","expires_in":7200})
+2018/09/06 14:34:01 [I] 接口返回结果: %!(EXTRA map[string]interface {}=map[access_token:13_eFvifYGXTdbkIU6Rn6Sm-liedNbNRUDD0lZuCVEUCavrRbp8q_DZD7PxeDT25TWPuzDlNq-43jw961aoAlRLRF9v8wumSXYXx7pHVL7CEwWOCo_Zpb--Cr-quZEWYJdAHAMOZ expires_in:7200])
+2018/09/06 14:36:11 [I] 请求远程接口: %!(EXTRA string=https://api.weixin.qq.com/cgi-bin/token?appid=wx7320287e057bbeee&grant_type=client_credential&secret=6e844dc2ade439545c47569ba1707673)
+2018/09/06 14:36:11 [I] 远程请求结果:%!(EXTRA string={"access_token":"13_D5XjZhonbuG7Y4FH0yd2aut_EFTLarqBafPHq7GyEGPU2gyhJ64OFtLrstkpklPei72uGqZlsolSDnMIIBWvEGK3yXC0MHDzEtGhoqgdpWS4l04LwUNWv4jCfUnloFiB_97hTYu_OnzVBVMQRGPiABAYNW","expires_in":7200})
+2018/09/06 14:36:11 [I] 接口返回结果: %!(EXTRA map[string]interface {}=map[access_token:13_D5XjZhonbuG7Y4FH0yd2aut_EFTLarqBafPHq7GyEGPU2gyhJ64OFtLrstkpklPei72uGqZlsolSDnMIIBWvEGK3yXC0MHDzEtGhoqgdpWS4l04LwUNWv4jCfUnloFiB_97hTYu_OnzVBVMQRGPiABAYNW expires_in:7200])
+2018/09/06 14:44:34 [I] 请求远程接口: %!(EXTRA string=https://api.weixin.qq.com/cgi-bin/token?appid=wx7320287e057bbeee&grant_type=client_credential&secret=6e844dc2ade439545c47569ba1707673)
+2018/09/06 14:44:35 [I] 远程请求结果:%!(EXTRA string={"access_token":"13_VPpLdW13aBzGh9qkA09Q4vmAYpKSntF5IWXOmbNhp_-d3u9IsswL3pWTKiJliWg5WrnMTpFQPrxwpkFVL_UTXyhcNrhbVSsjmZjlyFeBo1FESZZeCJxhbgun5LRsSbmsj-DZgKFy_yo2gkxlUUXbAHABBE","expires_in":7200})
+2018/09/06 14:44:35 [I] 接口返回结果: %!(EXTRA map[string]interface {}=map[access_token:13_VPpLdW13aBzGh9qkA09Q4vmAYpKSntF5IWXOmbNhp_-d3u9IsswL3pWTKiJliWg5WrnMTpFQPrxwpkFVL_UTXyhcNrhbVSsjmZjlyFeBo1FESZZeCJxhbgun5LRsSbmsj-DZgKFy_yo2gkxlUUXbAHABBE expires_in:7200])
+2018/09/06 14:45:48 [I] 请求远程接口: %!(EXTRA string=https://api.weixin.qq.com/cgi-bin/token?appid=wx7320287e057bbeee&grant_type=client_credential&secret=6e844dc2ade439545c47569ba1707673)
+2018/09/06 14:45:49 [I] 远程请求结果:%!(EXTRA string={"access_token":"13_0VUw4-tWyi8por1OWBMNgMuHx4Y6f7UP5MD90NkiA7tOW88bBvf-L817bgwBlkzhATlK-ufeG0tMtbTX_sXvWqhaxGBYVSdRrJjCUvgOUVeShhmzznp8r_gwBVs3mHVgd7TY1WMi1fsirFoIZARdAIARSJ","expires_in":7200})
+2018/09/06 14:45:49 [I] 接口返回结果: %!(EXTRA map[string]interface {}=map[access_token:13_0VUw4-tWyi8por1OWBMNgMuHx4Y6f7UP5MD90NkiA7tOW88bBvf-L817bgwBlkzhATlK-ufeG0tMtbTX_sXvWqhaxGBYVSdRrJjCUvgOUVeShhmzznp8r_gwBVs3mHVgd7TY1WMi1fsirFoIZARdAIARSJ expires_in:7200])

models/cases/conf.go

+package cases
+
+import (
+	"spaceofcheng/services/models"
+	"spaceofcheng/services/models/model"
+	"spaceofcheng/services/utils"
+)
+
+// GetConfByCase 获取配置信息
+func (m *CaseDAO) GetConfByCase(caseid, conftype string) (*model.SysCaseConf, error) {
+	var conf = new(model.SysCaseConf)
+	conf.Status = models.STATUS_NORMAL
+	has, err := m.db.Where("case_id=?", caseid).And("conf_type=?", conftype).Get(&conf)
+	if err != nil {
+		return nil, err
+	}
+	if !has {
+		return nil, err
+	}
+	return conf, err
+}
+
+// SaveCaseConf 保存案场配置信息
+func (m *CaseDAO) SaveCaseConf(conf model.SysCaseConf) (*model.SysCaseConf, error) {
+	conf.ConfId = utils.GetGUID()
+	_, err := m.db.Insert(conf)
+	return &conf, err
+}
+
+// UpdateCaseConf 修改案场配置信息
+func (m *CaseDAO) UpdateCaseConf(conf model.SysCaseConf) error {
+	cols := []string{
+		"status",
+	}
+	_, err := m.db.Cols(cols...).Where("conf_id=?", conf.ConfId).Update(conf)
+	return err
+}

models/cases/record.go

+package cases
+
+import "spaceofcheng/services/models/model"
+
+// GetCaseRecord 获取案场月记录
+func (m *CaseDAO) GetCaseRecord(caseid string) ([]model.SysCaseRecord, error) {
+	var records []model.SysCaseRecord
+	err := m.db.Where("case_id=?", caseid).Find(&records)
+	return records, err
+}

models/model/sys_case_conf.go

+package model
+
+type SysCaseConf struct {
+	ConfId   string `xorm:"not null pk VARCHAR(64)"`
+	CaseId   string `xorm:"not null VARCHAR(64)"`
+	ConfType string `xorm:"VARCHAR(20)"`
+	Status   int    `xorm:"SMALLINT(6)"`
+}

models/model/sys_case_record.go

+package model
+
+import "time"
+
+type SysCaseRecord struct {
+	RecordId   string    `xorm:"not null pk VARCHAR(64)"`
+	CaseId     string    `xorm:"not null VARCHAR(64)"`
+	Month      string    `xorm:"VARCHAR(20)"`
+	Num        int       `xorm:"INT(11)"`
+	Status     int       `xorm:"SMALLINT(6)"`
+	CreateDate time.Time `xorm:"DATETIME"`
+}

service/cases/area.go

 package cases
 
 import (
+	"errors"
 	"spaceofcheng/services/models/cases"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service"
 	"spaceofcheng/services/utils"
-
-	"github.com/astaxie/beego"
 )
 
 // GetCaseArea 获取案场区域
 	}
 	areas, err := s.dao.GetCaseArea(caseids, page, pageSize)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取案场区域失败: " + err.Error())
+		return nil, errors.New("获取案场区域失败")
 	}
 	total, err := s.dao.GetCaseAreaCount(caseids)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取案场区域失败: " + err.Error())
+		return nil, errors.New("获取案场区域失败")
 	}
 
 	return map[string]interface{}{
 	} else {
 		err = s.dao.UpdateCaseArea(area)
 	}
+	if err != nil {
+		utils.LogError("保存案场区域失败: " + err.Error())
+		return nil, errors.New("保存案场区域失败")
+	}
 	return &area, err
 }
 
 // DelCaseArea 删除区域
 func (s *CaseServ) DelCaseArea(areaid string) error {
 	err := s.dao.DelCaseArea(areaid)
-	return err
+	if err != nil {
+		utils.LogError("删除案场区域失败: " + err.Error())
+		return errors.New("删除案场区域失败")
+	}
+	return nil
 }
 
 // GetAreaByCase 根据案场获取区域信息
 func (s *CaseServ) GetAreaByCase(caseid string) ([]cases.AreaInfo, error) {
 	areas, err := s.dao.GetCaseAreaByCase(caseid)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取案场区域失败: " + err.Error())
+		return nil, errors.New("获取案场区域失败")
 	}
 	for index, area := range areas {
 		tables, err := s.dao.GetCaseTableByAreaID(area.AreaId)
 		if err != nil {
-			beego.Error(err)
-			return nil, err
+			utils.LogError("获取案场区域失败: " + err.Error())
+			return nil, errors.New("获取案场区域失败")
 		}
 		areas[index].Tables = tables
 	}

service/cases/cases.go

 	"spaceofcheng/services/models/system"
 	"spaceofcheng/services/service"
 	"spaceofcheng/services/utils"
-
-	"github.com/astaxie/beego"
 )
 
 // CaseServ 系统处理
 	}
 }
 
+const (
+	CONFTYPE_COFFEE = "coffee"
+)
+
 // GetCases 获取案场列表
 func (s *CaseServ) GetCases(caseids, casename string, page, pageSize int) (map[string]interface{}, error) {
 	if pageSize == 0 {
 	}
 	cases, err := s.dao.GetCaseList(caseids, casename, page, pageSize)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取案场信息失败: " + err.Error())
+		return nil, errors.New("获取案场信息失败")
 	}
 	total, err := s.dao.GetCaseCount(caseids, casename)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取案场信息失败: " + err.Error())
+		return nil, errors.New("获取案场信息失败")
 	}
 
 	return map[string]interface{}{
 // GetCaseByID 根据案场id获取案场
 func (s *CaseServ) GetCaseByID(caseid string) (*model.SysCase, error) {
 	caseinfo, err := s.dao.GetCaseByID(caseid)
-	return caseinfo, err
+	if err != nil {
+		utils.LogError("获取案场信息失败: " + err.Error())
+		return nil, errors.New("获取案场信息失败")
+	}
+	return caseinfo, nil
 }
 
 // SaveCase 保存案场
 	var newInfo *model.SysCase
 	var err error
 	if caseinfo.CaseName == "" {
-		return nil, utils.LogError("案场名称不能为空！")
+		return nil, errors.New("案场名称不能为空！")
 	}
 	if caseinfo.Coordinate == "" {
-		return nil, utils.LogError("案场经纬度不能为空！")
+		return nil, errors.New("案场经纬度不能为空！")
 	}
 
 	if caseinfo.CaseId == "" {
 		newInfo, err = s.dao.AddCase(caseinfo)
 		if err != nil {
-			return nil, err
+			utils.LogError("保存案场信息失败: " + err.Error())
+			return nil, errors.New("保存案场信息失败")
 		}
 		// 新增之后保存用户对应案场
 		var userCase = model.SysUserCase{
 			IsCreated: 1,
 		}
 		err = s.userdao.SaveUserCase(userCase)
+		if err != nil {
+			utils.LogError("保存案场信息失败: " + err.Error())
+			return nil, errors.New("保存案场信息失败")
+		}
+		// 新增案场配置信息
+		var conf = model.SysCaseConf{
+			CaseId:   newInfo.CaseId,
+			ConfType: CONFTYPE_COFFEE,
+		}
+		_, err = s.dao.SaveCaseConf(conf)
 	} else {
 		err = s.dao.UpdateCase(caseinfo)
 		newInfo = &caseinfo
 	}
-	return newInfo, err
+	if err != nil {
+		utils.LogError("保存案场信息失败: " + err.Error())
+		return nil, errors.New("保存案场信息失败")
+	}
+	return newInfo, nil
 }
 
 // DelCase 删除案场
 func (s *CaseServ) DelCase(caseid string) error {
 	err := s.dao.DelCase(caseid)
-	return err
+	if err != nil {
+		utils.LogError("删除案场信息失败: " + err.Error())
+		return errors.New("删除案场信息失败")
+	}
+	return nil
 }
 
 // GetAllCasesAndSales 获取所有案场
 		"sales": users,
 	}, nil
 }
+
+// GetCaseConf 获取案场配置信息
+func (s *CaseServ) GetCaseConf(caseid, conftype string) (*model.SysCaseConf, error) {
+	conf, err := s.dao.GetConfByCase(caseid, conftype)
+	if err != nil {
+		utils.LogError("获取配置信息失败: " + err.Error())
+		return nil, errors.New("获取配置信息失败")
+	}
+	return conf, nil
+}

service/cases/caseuser.go

 package cases
 
 import (
+	"errors"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service"
 	"spaceofcheng/services/utils"
-
-	"github.com/astaxie/beego"
 )
 
 // GetCaseUserByCase 根据案场id获取案场相关人员信息
 	}
 	caseusers, err := s.dao.GetCaseUserByCase(caseid, page, pageSize)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取案场人员失败: " + err.Error())
+		return nil, errors.New("获取案场人员失败")
 	}
 	total, err := s.dao.GetCaseUserCount(caseid)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取案场人员失败: " + err.Error())
+		return nil, errors.New("获取案场人员失败")
 	}
 
 	return map[string]interface{}{
 		"pagesize": pageSize,
 		"pagenum":  total,
 		"page":     page,
-	}, err
+	}, nil
 }
 
 // GetCaseUserByType 根据类型获取人员
 func (s *CaseServ) GetCaseUserByType(caseid, usertype string) ([]model.SysCaseUser, error) {
 	caseusers, err := s.dao.GetCaseUserByUserType(caseid, usertype)
+	if err != nil {
+		utils.LogError("获取案场人员失败: " + err.Error())
+		return nil, errors.New("获取案场人员失败")
+	}
 	return caseusers, err
 }
 
 // GetCaseUserByID 根据ID获取人员
 func (s *CaseServ) GetCaseUserByID(userid string) (*model.SysCaseUser, error) {
 	caseuser, err := s.dao.GetCaseUserByID(userid)
-	return caseuser, err
+	if err != nil {
+		utils.LogError("获取案场人员失败: " + err.Error())
+		return nil, errors.New("获取案场人员失败")
+	}
+	return caseuser, nil
 }
 
 // SaveCaseUser 保存人员信息
 		err = s.dao.UpdateCaseUser(caseuser)
 		newInfo = &caseuser
 	}
-	return newInfo, err
+	if err != nil {
+		utils.LogError("保存人员信息失败: " + err.Error())
+		return nil, errors.New("保存人员信息失败")
+	}
+	return newInfo, nil
 }
 
 // DelCaseUser 删除人员信息
 func (s *CaseServ) DelCaseUser(userid string) error {
 	err := s.dao.DelCaseUser(userid)
-	return err
+	if err != nil {
+		utils.LogError("删除人员信息失败: " + err.Error())
+		return errors.New("删除人员信息失败")
+	}
+	return nil
 }
 
 // GetUserType 获取相关人员类型
 func (s *CaseServ) GetUserType(orgid string) ([]model.SysCaseUserType, error) {
 	types, err := s.dao.GetUserType(orgid)
-	return types, err
+	if err != nil {
+		utils.LogError("获取相关人员类型信息失败: " + err.Error())
+		return nil, errors.New("获取相关人员类型信息失败")
+	}
+	return types, nil
 }

service/cases/equipment.go

 package cases
 
 import (
+	"errors"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service"
 	"spaceofcheng/services/utils"
-
-	"github.com/astaxie/beego"
 )
 
 // GetCaseEquipment 获取体检设备
 	}
 	specs, err := s.dao.GetEquipmentList(caseids, page, pageSize)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取体检设备信息失败: " + err.Error())
+		return nil, errors.New("获取体检设备信息失败")
 	}
 	total, err := s.dao.GetEquipmentCount(caseids)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取体检设备信息失败: " + err.Error())
+		return nil, errors.New("获取体检设备信息失败")
 	}
 
 	return map[string]interface{}{
 		"pagesize": pageSize,
 		"pagenum":  total,
 		"page":     page,
-	}, err
+	}, nil
 }
 
 // GetCaseEquipmentByID 根据ID获取体检设备
 func (s *CaseServ) GetCaseEquipmentByID(equipmentid string) (*model.SysCaseEquipment, error) {
 	equipment, err := s.dao.GetCaseEquipmentByID(equipmentid)
-	return equipment, err
+	if err != nil {
+		utils.LogError("获取体检设备信息失败: " + err.Error())
+		return nil, errors.New("获取体检设备信息失败")
+	}
+	return equipment, nil
 }
 
 // SaveCaseEquipment 保存体检设备
 	} else {
 		err = s.dao.UpdateCaseEquipment(equipment)
 	}
-	return &equipment, err
+	if err != nil {
+		utils.LogError("保存体检设备信息失败: " + err.Error())
+		return nil, errors.New("保存体检设备信息失败")
+	}
+	return &equipment, nil
 }
 
 // DelCaseEquipment 删除体检设备
 func (s *CaseServ) DelCaseEquipment(equipmentid string) error {
 	err := s.dao.DelCaseEquipment(equipmentid)
-	return err
+	if err != nil {
+		utils.LogError("删除体检设备信息失败: " + err.Error())
+		return errors.New("删除体检设备信息失败")
+	}
+	return nil
 }

service/cases/key.go

 package cases
 
 import (
+	"errors"
 	"spaceofcheng/services/models/cases"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service"
 	"spaceofcheng/services/utils"
 	"strconv"
 	"time"
-
-	"github.com/astaxie/beego"
 )
 
 // GetKeysByCase 根据案场获取钥匙信息
 
 	keys, err := s.dao.GetKeysByCase(caseid, num, page, pageSize)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取钥匙信息失败: " + err.Error())
+		return nil, errors.New("获取钥匙信息失败")
 	}
 
 	total, err := s.dao.GetKeysCountByCase(caseid, num)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取钥匙信息失败: " + err.Error())
+		return nil, errors.New("获取钥匙信息失败")
 	}
 
 	for index, key := range keys {
 		use, err := s.dao.GetCurrentKey(key.KeyId)
 		if err != nil {
-			beego.Error(err)
-			return nil, err
+			utils.LogError("获取钥匙信息失败: " + err.Error())
+			return nil, errors.New("获取钥匙信息失败")
 		}
 		if use != nil {
 			keys[index].CustomerId = use.CustomerId
 		"pagesize": pageSize,
 		"pagenum":  total,
 		"page":     page,
-	}, err
+	}, nil
 }
 
 // AddKeys 保存钥匙
 
 	keys, err := s.dao.GetKeyByNum(caseid, beginnum, endnum)
 	if err != nil {
-		return err
+		utils.LogError("保存钥匙信息失败: " + err.Error())
+		return errors.New("保存钥匙信息失败")
 	}
 	if len(keys) > 0 {
 		return utils.LogError("锁柜编号存在重复！请检查后再试！")
 		}
 		_, err := s.dao.AddKey(key)
 		if err != nil {
-			return err
+			utils.LogError("保存钥匙信息失败: " + err.Error())
+			return errors.New("保存钥匙信息失败")
 		}
 	}
 	return nil
 // UnLockKey 解锁
 func (s *CaseServ) UnLockKey(keyid string) error {
 	err := s.dao.UnLockKey(keyid)
-	return err
+	if err != nil {
+		utils.LogError("解锁钥匙失败: " + err.Error())
+		return errors.New("解锁钥匙失败")
+	}
+	return nil
 }
 
 // DelKey 刪除
 func (s *CaseServ) DelKey(keyid string) error {
 	use, err := s.dao.GetCurrentKey(keyid)
 	if err != nil {
-		return err
+		utils.LogError("刪除钥匙失败: " + err.Error())
+		return errors.New("刪除钥匙失败")
 	}
 
 	if use != nil {
 	}
 
 	err = s.dao.DelKey(keyid)
-	return err
+	return nil
 }

service/cases/table.go

 package cases
 
 import (
+	"errors"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service"
 	"spaceofcheng/services/utils"
-
-	"github.com/astaxie/beego"
 )
 
 // GetCaseTable 获取案场桌位
 	}
 	areas, err := s.dao.GetCaseTable(caseids, page, pageSize)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取案场桌位信息失败: " + err.Error())
+		return nil, errors.New("获取案场桌位信息失败")
 	}
 	total, err := s.dao.GetCaseTableCount(caseids)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取案场桌位信息失败: " + err.Error())
+		return nil, errors.New("获取案场桌位信息失败")
 	}
 
 	return map[string]interface{}{
 		"pagesize": pageSize,
 		"pagenum":  total,
 		"page":     page,
-	}, err
+	}, nil
 }
 
 // GetCaseTableByID 根据桌位ID获取桌位
 func (s *CaseServ) GetCaseTableByID(tableid string) (*model.SysCaseTable, error) {
 	areas, err := s.dao.GetCaseTableByID(tableid)
-	return areas, err
+	if err != nil {
+		utils.LogError("获取案场桌位信息失败: " + err.Error())
+		return nil, errors.New("获取案场桌位信息失败")
+	}
+	return areas, nil
 }
 
 // SaveCaseTable 保存桌位
 	} else {
 		err = s.dao.UpdateCaseTable(table)
 	}
-	return &table, err
+	if err != nil {
+		utils.LogError("保存案场桌位信息失败: " + err.Error())
+		return nil, errors.New("保存案场桌位信息失败")
+	}
+	return &table, nil
 }
 
 // DelCaseTable 删除桌位
 func (s *CaseServ) DelCaseTable(tableid string) error {
 	err := s.dao.DelCaseTable(tableid)
-	return err
+	if err != nil {
+		utils.LogError("删除案场桌位信息失败: " + err.Error())
+		return errors.New("删除案场桌位信息失败")
+	}
+	return nil
 }

service/cases/tag.go

 package cases
 
 import (
+	"errors"
 	"spaceofcheng/services/models/cases"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service"
 	"spaceofcheng/services/utils"
-
-	"github.com/astaxie/beego"
 )
 
 // GetTagList 获取tag列表
 	}
 	tags, err := s.dao.GetTagList(caseid, caseids, page, pageSize)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取案场标签信息失败: " + err.Error())
+		return nil, errors.New("获取案场标签信息失败")
 	}
 	total, err := s.dao.GetTagCount(caseid, caseids)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取案场标签信息失败: " + err.Error())
+		return nil, errors.New("获取案场标签信息失败")
 	}
 
 	return map[string]interface{}{
 func (s *CaseServ) GetTagByID(tagid string) (*cases.Tag, error) {
 	tag, err := s.dao.GetTagByID(tagid)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取案场标签信息失败: " + err.Error())
+		return nil, errors.New("获取案场标签信息失败")
 	}
 	if tag != nil {
 		tagcases, err := s.dao.GetTagCaseByTagID(tagid)
 		if err != nil {
-			beego.Error(err)
-			return nil, err
+			utils.LogError("获取案场标签信息失败: " + err.Error())
+			return nil, errors.New("获取案场标签信息失败")
 		}
 		tag.TagCases = tagcases
 	}
 		newInfo = &tag
 	}
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("保存标签信息失败: " + err.Error())
+		return nil, errors.New("保存标签信息失败")
 	}
 	err = s.dao.DelTagCase(newInfo.TagId)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("保存标签信息失败: " + err.Error())
+		return nil, errors.New("保存标签信息失败")
 	}
 	err = s.dao.SaveTagCase(newInfo.TagId, caseids)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("保存标签信息失败: " + err.Error())
+		return nil, errors.New("保存标签信息失败")
 	}
 	return newInfo, err
 }
 // DelTag 删除标签
 func (s *CaseServ) DelTag(tagid string) error {
 	err := s.dao.DeleteTag(tagid)
+	if err != nil {
+		utils.LogError("删除标签失败: " + err.Error())
+		return errors.New("删除标签失败")
+	}
 	return err
 }

service/channel/channel.go

 package channel
 
 import (
+	"errors"
 	"spaceofcheng/services/models/channel"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service"
 	}
 	channels, err := s.dao.GetChannels(caseid, page, pageSize)
 	if err != nil {
-		return nil, err
+		utils.LogError("获取渠道列表失败: " + err.Error())
+		return nil, errors.New("获取渠道列表失败")
 	}
 	total, err := s.dao.GetChannelsCount(caseid)
 	if err != nil {
-		return nil, err
+		utils.LogError("获取渠道列表失败: " + err.Error())
+		return nil, errors.New("获取渠道列表失败")
 	}
 	return map[string]interface{}{
 		"list":     channels,
 		"pageSize": pageSize,
 		"pagenum":  total,
 		"page":     page,
-	}, err
+	}, nil
 }
 
 // GetChannelById 根据渠道id获取渠道
 func (s *ChannelServ) GetChannelById(channelId string) (*model.TaChannel, error) {
 	channel, err := s.dao.GetChannelById(channelId)
-	return channel, err
+	if err != nil {
+		utils.LogError("获取渠道信息失败: " + err.Error())
+		return nil, errors.New("获取渠道信息失败")
+	}
+	return channel, nil
 }
 
 // SaveChannel 保存渠道
 		err = s.dao.UpdateChannel(channel)
 		newChannel = &channel
 	}
-	return newChannel, err
+	if err != nil {
+		utils.LogError("保存渠道信息失败: " + err.Error())
+		return nil, errors.New("保存渠道信息失败")
+	}
+	return newChannel, nil
 }
 
 // DeleteChannel 删除渠道
 func (s *ChannelServ) DeleteChannel(caseid string) error {
 	err := s.dao.DeleteChannel(caseid)
+	if err != nil {
+		utils.LogError("删除渠道信息失败: " + err.Error())
+		return errors.New("删除渠道信息失败")
+	}
 	return err
 }

service/course/course.go

 package course
 
 import (
+	"errors"
 	"spaceofcheng/services/models"
 	"spaceofcheng/services/models/cases"
 	"spaceofcheng/services/models/course"
 	"spaceofcheng/services/service"
 	"spaceofcheng/services/utils"
 	"strings"
-
-	"github.com/astaxie/beego"
 )
 
 // CourseServ 系统处理
 	}
 	list, err := s.dao.GetCourseList(caseids, name, typeid, page, pageSize)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取课程信息失败: " + err.Error())
+		return nil, errors.New("获取课程信息失败")
 	}
 	total, err := s.dao.GetCourseCount(caseids, name, typeid)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取课程信息失败: " + err.Error())
+		return nil, errors.New("获取课程信息失败")
 	}
 
 	return map[string]interface{}{
 		"pagesize": pageSize,
 		"pagenum":  total,
 		"page":     page,
-	}, err
+	}, nil
 }
 
 // GetCourseByID 获取课程明细
 	}
 	info, err := s.dao.GetCourseInfo(courseid)
 	if err != nil {
-		return nil, err
+		utils.LogError("获取课程信息失败: " + err.Error())
+		return nil, errors.New("获取课程信息失败")
 	}
 	if info == nil {
 		return nil, utils.LogError("不存在课程信息！")
 
 	tags, err := s.dao.GetCourseTag(courseid)
 	if err != nil {
-		return nil, err
+		utils.LogError("获取课程标签信息失败: " + err.Error())
+		return nil, errors.New("获取课程信息失败")
 	}
 	info.CourseTags = tags
 	details, err := s.dao.GetCourseDetail(courseid)
 	if err != nil {
-		return nil, err
+		utils.LogError("获取课程明细信息失败: " + err.Error())
+		return nil, errors.New("获取课程信息失败")
 	}
 	info.CourseDetail = details
 	imgs, err := s.dao.GetCourseImgs(courseid)
 	if err != nil {
-		return nil, err
+		utils.LogError("获取课程图片信息失败: " + err.Error())
+		return nil, errors.New("获取课程信息失败")
 	}
 	info.CourseImgs = imgs
 	caseinfo, err := s.casedao.GetCaseByID(info.CaseId)
 	if err != nil {
-		return nil, err
+		utils.LogError("获取课程案场信息失败: " + err.Error())
+		return nil, errors.New("获取课程信息失败")
 	}
 	info.CaseInfo = caseinfo
 	return info, nil
 	if course.CourseId == "" {
 		newInfo, err = s.dao.AddCourse(course)
 		if err != nil {
-			return nil, err
+			utils.LogError("保存课程信息失败: " + err.Error())
+			return nil, errors.New("保存课程信息失败")
 		}
 	} else {
 		err = s.dao.UpdateCourse(course)
 		if err != nil {
-			return nil, err
+			utils.LogError("保存课程信息失败: " + err.Error())
+			return nil, errors.New("保存课程信息失败")
 		}
 		newInfo = &course
 		err = s.dao.DelCourseTag(course.CourseId)
 		if err != nil {
-			return nil, err
+			utils.LogError("保存课程信息失败: " + err.Error())
+			return nil, errors.New("保存课程信息失败")
 		}
 	}
 
 			}
 			newtag, err := s.dao.AddCourseTag(taginfo)
 			if err != nil {
-				return nil, err
+				utils.LogError("保存课程信息失败: " + err.Error())
+				return nil, errors.New("保存课程信息失败")
 			}
 			tagid = newtag.TagId
 		}
 
 	if len(courseTags) > 0 {
 		err = s.dao.SaveCourseTag(courseTags)
-		return nil, err
+		if err != nil {
+			utils.LogError("保存课程信息失败: " + err.Error())
+			return nil, errors.New("保存课程信息失败")
+		}
 	}
 	return newInfo, nil
 }
 	}
 	courseinfo, err := s.dao.GetCourseByID(courseid)
 	if err != nil {
-		return err
+		utils.LogError("刪除课程信息失败: " + err.Error())
+		return errors.New("刪除课程信息失败")
 	}
 	if courseinfo.Status != course.STATUS_UNPUBLISH {
 		return utils.LogError("课程状态异常！不允许删除！")
 	}
 	err = s.dao.DelCourse(courseid)
 	if err != nil {
-		return err
+		utils.LogError("刪除课程信息失败: " + err.Error())
+		return errors.New("刪除课程信息失败")
 	}
 	err = s.dao.DeleteScheduleByCourse(courseid)
 	return err
 	}
 	info, err := s.dao.GetCourseByID(courseid)
 	if err != nil {
-		return err
+		utils.LogError("课程发布失败: " + err.Error())
+		return errors.New("课程发布失败")
 	}
 	if info.Status != course.STATUS_UNPUBLISH {
 		return utils.LogError("当前课程状态异常！请刷新后重试！")
 	}
 	err = s.dao.CoursePublic(courseid)
-	return err
+	if err != nil {
+		utils.LogError("课程发布失败: " + err.Error())
+		return errors.New("课程发布失败")
+	}
+	return nil
 }
 
 // CourseUnPublic 课程取消发布
 	}
 	info, err := s.dao.GetCourseByID(courseid)
 	if err != nil {
-		return err
+		utils.LogError("课程取消发布失败: " + err.Error())
+		return errors.New("课程取消发布失败")
 	}
 	if info.Status != models.STATUS_NORMAL {
 		return utils.LogError("当前课程状态异常！请刷新后重试！")
 	}
 	err = s.dao.CourseUnPublic(courseid)
-	return err
+	if err != nil {
+		utils.LogError("课程发布失败: " + err.Error())
+		return errors.New("课程发布失败")
+	}
+	return nil
 }
 
 // GetCourseImgs 获取课程图片
 		return nil, utils.LogError("没有对应的课程！")
 	}
 	imgs, err := s.dao.GetCourseImgs(courseid)
-	return imgs, err
+	if err != nil {
+		utils.LogError("获取课程图片失败: " + err.Error())
+		return nil, errors.New("获取课程图片失败")
+	}
+	return imgs, nil
 }
 
 // SaveCourseImg 保存课程图片
 		newinfo = &img
 		err = s.dao.UpdateCourseImg(img)
 	}
+	if err != nil {
+		utils.LogError("保存课程图片失败: " + err.Error())
+		return nil, errors.New("保存课程图片失败")
+	}
 	return newinfo, err
 }
 
 		return utils.LogError("没有需要删除的内容！")
 	}
 	err := s.dao.DelCourseImg(imgid)
+	if err != nil {
+		utils.LogError("删除课程图片失败: " + err.Error())
+		return errors.New("删除课程图片失败")
+	}
 	return err
 }
 
 	}
 	list, err := s.dao.GetCourseSchedule(name, caseids, date, page, pageSize)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取课程排期失败: " + err.Error())
+		return nil, errors.New("获取课程排期失败")
 	}
 	total, err := s.dao.GetCourseScheduleCount(name, caseids, date)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取课程排期失败: " + err.Error())
+		return nil, errors.New("获取课程排期失败")
 	}
 
 	return map[string]interface{}{
 		"pagesize": pageSize,
 		"pagenum":  total,
 		"page":     page,
-	}, err
+	}, nil
 }
 
 // GetDetails 获取所有排课
 		return nil, utils.LogError("请选择需要查看的月份！")
 	}
 	details, err := s.dao.GetDetails(caseid, date)
-	return details, err
+	if err != nil {
+		utils.LogError("获取排期信息失败: " + err.Error())
+		return nil, errors.New("获取排期信息失败")
+	}
+	return details, nil
 }
 
 // GetDetailByID 获取单个排课信息
 		return nil, utils.LogError("没有对应的排课信息！")
 	}
 	detail, err := s.dao.GetDetailByID(detailid)
-	return detail, err
+	if err != nil {
+		utils.LogError("获取排期信息失败: " + err.Error())
+		return nil, errors.New("获取排期信息失败")
+	}
+	return detail, nil
 }
 
 // SaveDetail 保存排课信息
 	}
 	courseinfo, err := s.dao.GetCourseByID(detail.CourseId)
 	if err != nil {
-		return nil, err
+		utils.LogError("获取排期信息失败: " + err.Error())
+		return nil, errors.New("保存排课信息失败")
 	}
 	if courseinfo.Status != course.STATUS_UNPUBLISH {
 		return nil, utils.LogError("课程状态异常！不允许排课！请刷新后重试！")
 		detail.CaseId = courseinfo.CaseId
 		newinfo, err = s.dao.AddCourseDetail(detail)
 		if err != nil {
-			return nil, err
+			utils.LogError("保存排课信息失败: " + err.Error())
+			return nil, errors.New("保存排课信息失败")
 		}
 		num, err := s.dao.GetCourseDetailCount(courseinfo.CourseId)
 		if err != nil {
-			return nil, err
+			utils.LogError("保存排课信息失败: " + err.Error())
+			return nil, errors.New("保存排课信息失败")
 		}
 		err = s.dao.UpdateCourseScheduleNum(courseinfo.CourseId, num)
 		if err != nil {
-			return nil, err
+			utils.LogError("保存排课信息失败: " + err.Error())
+			return nil, errors.New("保存排课信息失败")
 		}
 	} else {
 		err := s.dao.UpdateCourseDetail(detail)
 		if err != nil {
-			return nil, err
+			utils.LogError("保存排课信息失败: " + err.Error())
+			return nil, errors.New("保存排课信息失败")
 		}
 		newinfo = &detail
 	}
 	}
 	detail, err := s.dao.GetDetailByID(detailid)
 	if err != nil {
-		return err
+		utils.LogError("删除排课信息失败: " + err.Error())
+		return errors.New("删除排课信息失败")
 	}
 	courseinfo, err := s.dao.GetCourseByID(detail.CourseId)
 	if err != nil {
-		return err
+		utils.LogError("删除排课信息失败: " + err.Error())
+		return errors.New("删除排课信息失败")
 	}
 	if courseinfo.Status != course.STATUS_UNPUBLISH {
 		return utils.LogError("课程状态异常！不允许删除！")
 	}
 	err = s.dao.DelCourseDetail(detailid)
 	if err != nil {
-		return err
+		utils.LogError("删除排课信息失败: " + err.Error())
+		return errors.New("删除排课信息失败")
 	}
 	num, err := s.dao.GetCourseDetailCount(courseinfo.CourseId)
 	if err != nil {
-		return err
+		utils.LogError("删除排课信息失败: " + err.Error())
+		return errors.New("删除排课信息失败")
 	}
 	err = s.dao.UpdateCourseScheduleNum(courseinfo.CourseId, num)
 	if err != nil {
-		return err
+		utils.LogError("删除排课信息失败: " + err.Error())
+		return errors.New("删除排课信息失败")
 	}
 	return nil
 }
 	}
 	list, err := s.dao.GetSelectCourseList(orgid)
 	if err != nil {
-		return nil, err
+		utils.LogError("获取课程信息失败: " + err.Error())
+		return nil, errors.New("获取课程信息失败")
 	}
 	for i, v := range list {
 		caseinfo, err := s.casedao.GetCaseByID(v.CaseId)
 		if err != nil {
-			return nil, err
+			utils.LogError("获取课程信息失败: " + err.Error())
+			return nil, errors.New("获取课程信息失败")
 		}
 		list[i].CaseInfo = caseinfo
 	}
 	}
 	list, err := s.dao.GetCourseByLocation(orgid, locationid)
 	if err != nil {
-		return nil, err
+		utils.LogError("获取课程信息失败: " + err.Error())
+		return nil, errors.New("获取课程信息失败")
 	}
 	for i, v := range list {
 		caseinfo, err := s.casedao.GetCaseByID(v.CaseId)
 		if err != nil {
-			return nil, err
+			utils.LogError("获取课程信息失败: " + err.Error())
+			return nil, errors.New("获取课程信息失败")
 		}
 		list[i].CaseInfo = caseinfo
 	}

service/course/tag.go

 package course
 
 import (
+	"errors"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service"
-
-	"github.com/astaxie/beego"
+	"spaceofcheng/services/utils"
 )
 
 // GetTagsList 获取标签列表
 	}
 	tags, err := s.dao.GetTagsList(orgid, page, pageSize)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取标签信息失败: " + err.Error())
+		return nil, errors.New("获取标签信息失败")
 	}
 	total, err := s.dao.GetTagsCount(orgid)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取标签信息失败: " + err.Error())
+		return nil, errors.New("获取标签信息失败")
 	}
 
 	return map[string]interface{}{
 		"pagesize": pageSize,
 		"pagenum":  total,
 		"page":     page,
-	}, err
+	}, nil
 }
 
 // GetCourseTags 获取课程标签
 func (s *CourseServ) GetCourseTags(orgid string) ([]model.TdCourseTag, error) {
 	tags, err := s.dao.GetTagsList(orgid, 0, 10000)
+	if err != nil {
+		utils.LogError("获取标签信息失败: " + err.Error())
+		return nil, errors.New("获取标签信息失败")
+	}
 	return tags, err
 }

service/goods/spec.go

 	"errors"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service"
-
-	"github.com/astaxie/beego"
+	"spaceofcheng/services/utils"
 )
 
 // GetGoodsSpec 获取商品规格
 	}
 	specs, err := s.dao.GetGoodsSpec(caseids, page, pageSize)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取商品规格失败: " + err.Error())
+		return nil, errors.New("获取商品规格失败")
 	}
 	total, err := s.dao.GetGoodsSpecCount(caseids)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取商品规格失败: " + err.Error())
+		return nil, errors.New("获取商品规格失败")
 	}
 
 	return map[string]interface{}{
 		"pagesize": pageSize,
 		"pagenum":  total,
 		"page":     page,
-	}, err
+	}, nil
 }
 
 // GetGoodsSpecByID 根据商品类型ID获取商品类型
 func (s *GoodsServ) GetGoodsSpecByID(specid string) (*model.TdSpec, error) {
 	goodsSpec, err := s.dao.GetGoodsSpecByID(specid)
-	return goodsSpec, err
+	if err != nil {
+		utils.LogError("获取商品规格失败: " + err.Error())
+		return nil, errors.New("获取商品规格失败")
+	}
+	return goodsSpec, nil
 }
 
 // SaveGoodsSpec 保存商品类型
 	} else {
 		err = s.dao.UpdateGoodsSpec(goodsSpec)
 	}
-	return &goodsSpec, err
+	if err != nil {
+		utils.LogError("保存商品规格失败: " + err.Error())
+		return nil, errors.New("保存商品规格失败")
+	}
+	return &goodsSpec, nil
 }
 
 // DelGoodsSpec 删除商品类型
 func (s *GoodsServ) DelGoodsSpec(specid string) error {
 	err := s.dao.DelGoodsSpec(specid)
-	return err
+	if err != nil {
+		utils.LogError("删除商品规格失败: " + err.Error())
+		return errors.New("删除商品规格失败")
+	}
+	return nil
 }

service/goods/type.go

 	"errors"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service"
-
-	"github.com/astaxie/beego"
+	"spaceofcheng/services/utils"
 )
 
 // GetGoodsType 获取商品类型
 	}
 	types, err := s.dao.GetGoodsType(caseids, page, pageSize)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取商品类型失败: " + err.Error())
+		return nil, errors.New("获取商品类型失败")
 	}
 	total, err := s.dao.GetGoodsTypeCount(caseids)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取商品类型失败: " + err.Error())
+		return nil, errors.New("获取商品类型失败")
 	}
 
 	return map[string]interface{}{
 		"pagesize": pageSize,
 		"pagenum":  total,
 		"page":     page,
-	}, err
+	}, nil
 }
 
 // GetGoodsTypeByID 根据商品类型ID获取商品类型
 func (s *GoodsServ) GetGoodsTypeByID(typeid string) (*model.TdGoodsType, error) {
 	goodsType, err := s.dao.GetGoodsTypeByID(typeid)
-	return goodsType, err
+	if err != nil {
+		utils.LogError("获取商品类型失败: " + err.Error())
+		return nil, errors.New("获取商品类型失败")
+	}
+	return goodsType, nil
 }
 
 // SaveGoodsType 保存商品类型
 	} else {
 		err = s.dao.UpdateGoodsType(&goodsType)
 	}
-	return &goodsType, err
+	if err != nil {
+		utils.LogError("保存商品类型失败: " + err.Error())
+		return nil, errors.New("保存商品类型失败")
+	}
+	return &goodsType, nil
 }
 
 // DelGoodsType 删除商品类型
 func (s *GoodsServ) DelGoodsType(typeid string) error {
 	err := s.dao.DelGoodsType(typeid)
+	if err != nil {
+		utils.LogError("删除商品类型失败: " + err.Error())
+		return errors.New("删除商品类型失败")
+	}
 	return err
 }

service/marketing/marketing.go

 package marketing
 
-import(
+import (
 	"spaceofcheng/services/models/marketing"
-	"spaceofcheng/services/utils"
-	"spaceofcheng/services/service"
 	"spaceofcheng/services/models/model"
+	"spaceofcheng/services/service"
+	"spaceofcheng/services/utils"
+
 	"github.com/astaxie/beego"
 )
 
 // MarketingServ 系统处理
 type MarketingServ struct {
-	ctx     *utils.Context
-	dao     *marketing.MarketingDAO
-	wdao    *marketing.WorkDAO
+	ctx  *utils.Context
+	dao  *marketing.MarketingDAO
+	wdao *marketing.WorkDAO
 }
 
 // NewMarketingServ 初始化
 func NewMarketingServ(ctx *utils.Context) *MarketingServ {
 	return &MarketingServ{
-		ctx:     ctx,
-		dao:     marketing.NewMarketingDAO(ctx),
+		ctx: ctx,
+		dao: marketing.NewMarketingDAO(ctx),
 	}
 }
 
 		page = 1
 	}
 
-	list,err := s.dao.GetMarketingList(page,pageSize)
+	list, err := s.dao.GetMarketingList(page, pageSize)
 	if err != nil {
 		beego.Error(err)
 		return nil, err
 
 // 保存 营销活动
 /**
-	* resource_desc 活动描述
-	*/
-func (s *MarketingServ) SaveMarketing(activity model.SysActivity,resourceDesc string) (*model.SysActivity,*model.SysActivityAction, error) {
+* resource_desc 活动描述
+ */
+func (s *MarketingServ) SaveMarketing(activity model.SysActivity, resourceDesc string) (*model.SysActivity, *model.SysActivityAction, error) {
 
 	var newInfo *model.SysActivity
 	var newWoke *model.SysActivityAction
 
 	var err error
 	// 存储 营销活动
-	newInfo,err = s.dao.AddMarketing(&activity)
+	newInfo, err = s.dao.AddMarketing(&activity)
 	if err != nil {
-		return nil,nil, err
+		return nil, nil, err
 	}
-	
+
 	woke := model.SysActivityAction{}
 	woke.ActivityId = newInfo.ActivityId
 	woke.ActiveType = newInfo.ActivityType
 	woke.ResourceDesc = resourceDesc
 
 	// 存储 活动动作
-	newWoke,err = s.wdao.AddWork(&woke)
+	newWoke, err = s.wdao.AddWork(&woke)
 	if err != nil {
-		return nil,nil, err
+		return nil, nil, err
 	}
 
-	return newInfo,newWoke,err
+	return newInfo, newWoke, err
 
 }
 
 // GetMarketingById 根据ID查询数据
-func (s *MarketingServ) GetMarketingById(activityId string) (*model.SysActivity,error){
+func (s *MarketingServ) GetMarketingById(activityId string) (*model.SysActivity, error) {
 
 	if activityId == "" {
-		return nil,utils.LogError("不存在营销信息!")
+		return nil, utils.LogError("不存在营销信息!")
 	}
 
-	info,err:= s.dao.GetMarketingById(activityId)
+	info, err := s.dao.GetMarketingById(activityId)
 	if err != nil {
 		return nil, err
 	}
 	if info == nil {
-		return nil,utils.LogError("不存在营销信息!")
+		return nil, utils.LogError("不存在营销信息!")
 	}
 	if info.Status == marketing.DELETE {
 		return nil, utils.LogError("营销信息已被删除！")
 	}
 
-	return info,err
+	return info, err
 
 }
 
 		return utils.LogError("没有对应的营销活动")
 	}
 
-	info,err := s.dao.GetMarketingById(activityId)
+	info, err := s.dao.GetMarketingById(activityId)
 	if err != nil {
 		return err
 	}
 	if info.Status == marketing.DELETE {
 		return utils.LogError("营销状态异常")
 	}
-	err = s.dao.DelMarketing(activityId,marketing.DELETE)
-	return err;
+	err = s.dao.DelMarketing(activityId, marketing.DELETE)
+	return err
 
 }
 
 		return utils.LogError("没有对应的营销活动")
 	}
 
-	info,err := s.dao.GetMarketingById(activityId)
+	info, err := s.dao.GetMarketingById(activityId)
 	if err != nil {
 		return err
 	}
 	if info.Status == marketing.NORMAL {
 		return utils.LogError("营销状态异常")
 	}
-	err = s.dao.DelMarketing(activityId,marketing.NORMAL)
-	return err;
+	err = s.dao.DelMarketing(activityId, marketing.NORMAL)
+	return err
 
 }
 
 		return utils.LogError("没有对应的营销活动")
 	}
 
-	info,err := s.dao.GetMarketingById(activityId)
+	info, err := s.dao.GetMarketingById(activityId)
 	if err != nil {
 		return err
 	}
 	if info.Status == marketing.DISABLE {
 		return utils.LogError("营销状态异常")
 	}
-	err = s.dao.DelMarketing(activityId,marketing.DISABLE)
-	return err;
+	err = s.dao.DelMarketing(activityId, marketing.DISABLE)
+	return err
 
 }
 
-
 // UpdateMarketing 修改 营销活动
 func (s *MarketingServ) UpdateMarketing(activity model.SysActivity) error {
 	if activity.ActivityId == "" {
 	err := s.dao.UpdateMarketing(activity)
 	return err
 }
-
-
-
-

service/message/cmscase.go

 package message
 
 import (
+	"errors"
 	"spaceofcheng/services/models"
 	"spaceofcheng/services/models/course"
 	"spaceofcheng/services/models/message"
 	"spaceofcheng/services/service"
 	"spaceofcheng/services/utils"
 	"strings"
-
-	"github.com/astaxie/beego"
 )
 
 // GetCmsCasesList 获取项目列表
 	}
 	infos, err := s.dao.GetCmsCaseList(name, caseids, page, pageSize)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取项目列表失败: " + err.Error())
+		return nil, errors.New("获取项目列表失败")
 	}
 	total, err := s.dao.GetCmsCaseListCount(name, caseids)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取项目列表失败: " + err.Error())
+		return nil, errors.New("获取项目列表失败")
 	}
 
 	return map[string]interface{}{
 func (s *MessageServ) GetCmsCaseByOrg(orgid string) ([]message.CmsCase, error) {
 	list, err := s.dao.GetCmsCaseByOrg(orgid)
 	if err != nil {
-		return nil, err
+		utils.LogError("获取项目列表失败: " + err.Error())
+		return nil, errors.New("获取项目列表失败")
 	}
 	for i, c := range list {
 		imgs, err := s.dao.GetCmsCaseImgs(c.CmsCaseId)
 		if err != nil {
-			return nil, err
+			utils.LogError("获取项目列表失败: " + err.Error())
+			return nil, errors.New("获取项目列表失败")
 		}
 		list[i].CmsCaseImgs = imgs
 	}
 	var err error
 	info, err = s.dao.GetCmsCaseByID(cmscaseid)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取项目信息失败: " + err.Error())
+		return nil, errors.New("获取项目信息失败")
 	}
 	if info != nil {
 		var courses []course.CourseDetail
 			courses, err = s.dao.GetCoursesByCmsCase(info.CmsCaseId)
 		}
 		if err != nil {
-			beego.Error(err)
-			return nil, err
+			utils.LogError("获取项目信息失败: " + err.Error())
+			return nil, errors.New("获取项目信息失败")
 		}
 
 		for inx, course := range courses {
 			tags, err := s.coursedao.GetCourseTag(course.CourseId)
 			if err != nil {
-				return nil, err
+				utils.LogError("获取项目信息失败: " + err.Error())
+				return nil, errors.New("获取项目信息失败")
 			}
 			courses[inx].CourseTags = tags
 			details, err := s.coursedao.GetCourseDetail(course.CourseId)
 			if err != nil {
-				return nil, err
+				utils.LogError("获取项目信息失败: " + err.Error())
+				return nil, errors.New("获取项目信息失败")
 			}
 			courses[inx].CourseDetail = details
 			imgs, err := s.coursedao.GetCourseImgs(course.CourseId)
 			if err != nil {
-				return nil, err
+				utils.LogError("获取项目信息失败: " + err.Error())
+				return nil, errors.New("获取项目信息失败")
 			}
 			courses[inx].CourseImgs = imgs
 		}
 
 		imgs, err := s.dao.GetCmsCaseImgs(info.CmsCaseId)
 		if err != nil {
-			beego.Error(err)
-			return nil, err
+			utils.LogError("获取项目信息失败: " + err.Error())
+			return nil, errors.New("获取项目信息失败")
 		}
 		info.CmsCaseImgs = imgs
 	}
 		newInfo = &cmscase
 	}
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("保存项目信息失败: " + err.Error())
+		return nil, errors.New("保存项目信息失败")
 	}
 	err = s.dao.DelCmsCaseCourse(newInfo.CmsCaseId)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("保存项目信息失败: " + err.Error())
+		return nil, errors.New("保存项目信息失败")
 	}
 	if newInfo.IsAllCourse == 0 {
 		err = s.dao.SaveCmsCaseCourse(newInfo.CmsCaseId, courseids)
 		if err != nil {
-			beego.Error(err)
-			return nil, err
+			utils.LogError("保存项目信息失败: " + err.Error())
+			return nil, errors.New("保存项目信息失败")
 		}
 	}
 	err = s.dao.DelCmsCaseImg(newInfo.CmsCaseId)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("保存项目信息失败: " + err.Error())
+		return nil, errors.New("保存项目信息失败")
 	}
 
 	if imgs != "" {
 			}
 			err = s.dao.SaveCmsCaseImg(CmsImg)
 			if err != nil {
-				beego.Error(err)
-				return nil, err
+				utils.LogError("保存项目信息失败: " + err.Error())
+				return nil, errors.New("保存项目信息失败")
 			}
 		}
 	}
 			}
 			err = s.dao.SaveCmsCaseImg(CmsImg)
 			if err != nil {
-				beego.Error(err)
-				return nil, err
+				utils.LogError("保存项目信息失败: " + err.Error())
+				return nil, errors.New("保存项目信息失败")
 			}
 		}
 	}
 // DelCmsCase 刪除项目信息
 func (s *MessageServ) DelCmsCase(cmscaseid string) error {
 	err := s.dao.DelCmsCase(cmscaseid)
-	return err
+	if err != nil {
+		utils.LogError("删除项目信息失败: " + err.Error())
+		return errors.New("删除项目信息失败")
+	}
+	return nil
 }
 
 // CmsCaseShow 前台展示
 func (s *MessageServ) CmsCaseShow(cmscaseid string) error {
 	err := s.dao.CmsCaseShow(cmscaseid)
+	if err != nil {
+		utils.LogError("修改项目信息失败: " + err.Error())
+		return errors.New("修改项目信息失败")
+	}
 	return err
 }
 
 // CmsCaseHide 前台隐藏
 func (s *MessageServ) CmsCaseHide(cmscaseid string) error {
 	err := s.dao.CmsCaseHide(cmscaseid)
+	if err != nil {
+		utils.LogError("修改项目信息失败: " + err.Error())
+		return errors.New("修改项目信息失败")
+	}
 	return err
 }

service/message/image.go

 	"errors"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service"
-
-	"github.com/astaxie/beego"
+	"spaceofcheng/services/utils"
 )
 
 const (
 	}
 	infos, err := s.dao.GetImgList(orgid, page, pageSize)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取图片信息失败: " + err.Error())
+		return nil, errors.New("获取图片信息失败")
 	}
 	total, err := s.dao.GetImgListCount(orgid)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取图片信息失败: " + err.Error())
+		return nil, errors.New("获取图片信息失败")
 	}
 
 	return map[string]interface{}{
 		"pagesize": pageSize,
 		"pagenum":  total,
 		"page":     page,
-	}, err
+	}, nil
 }
 
 // GetImgByLocation 根据位置获取图片
 func (s *MessageServ) GetImgByLocation(locationid, orgid string) ([]model.TaCmsImages, error) {
 	imgs, err := s.dao.GetImgByLocation(locationid, orgid)
-	return imgs, err
+	if err != nil {
+		utils.LogError("获取图片信息失败: " + err.Error())
+		return nil, errors.New("获取图片信息失败")
+	}
+	return imgs, nil
 }
 
 // GetImgByID 获取单条图片信息
 func (s *MessageServ) GetImgByID(imgid string) (*model.TaCmsImages, error) {
 	img, err := s.dao.GetImgByID(imgid)
-	return img, err
+	if err != nil {
+		utils.LogError("获取图片信息失败: " + err.Error())
+		return nil, errors.New("获取图片信息失败")
+	}
+	return img, nil
 }
 
 // SaveImg 保存轮播图信息
 
 	if imginfo.ImageId == "" {
 		newinfo, err := s.dao.AddCmsImg(imginfo)
+		if err != nil {
+			utils.LogError("保存图片信息失败: " + err.Error())
+			return nil, errors.New("保存图片信息失败")
+		}
 		return newinfo, err
 	}
 	err := s.dao.UpdateCmsImg(imginfo)
+	if err != nil {
+		utils.LogError("保存图片信息失败: " + err.Error())
+		return nil, errors.New("保存图片信息失败")
+	}
 	return &imginfo, err
 }
 
 // DelImg 删除轮播图
 func (s *MessageServ) DelImg(imgid string) error {
 	err := s.dao.DelCmsImg(imgid)
-	return err
+	if err != nil {
+		utils.LogError("删除图片信息失败: " + err.Error())
+		return errors.New("删除图片信息失败")
+	}
+	return nil
 }

service/message/location.go

 package message
 
 import (
+	"errors"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/utils"
 	"strings"
-
-	"github.com/astaxie/beego"
 )
 
 // GetLocationList 获取列表
 func (s *MessageServ) GetLocationList(issys, orgid string) ([]model.TdCmsImageLocation, error) {
 	list, err := s.dao.GetLocationList(issys, orgid)
-	return list, err
+	if err != nil {
+		utils.LogError("获取列表失败: " + err.Error())
+		return nil, errors.New("获取列表失败")
+	}
+	return list, nil
 }
 
 // GetLocationByID 获取详细信息
 func (s *MessageServ) GetLocationByID(id string) (*model.TdCmsImageLocation, error) {
 	location, err := s.dao.GetLocationById(id)
+	if err != nil {
+		utils.LogError("获取信息失败: " + err.Error())
+		return nil, errors.New("获取信息失败")
+	}
 	return location, err
 }
 
 	if location.LocationId == "" {
 		sort, err := s.dao.GetLocationMaxSort("0", location.OrgId)
 		if err != nil {
-			beego.Error(err)
-			return nil, err
+			utils.LogError("保存信息失败: " + err.Error())
+			return nil, errors.New("保存信息失败")
 		}
 		location.OrderNo = sort + 1
 		newlocation, err := s.dao.AddLocation(location)
 		return newlocation, err
 	}
 	err := s.dao.UpdateLocation(location)
+	if err != nil {
+		utils.LogError("保存信息失败: " + err.Error())
+		return nil, errors.New("保存信息失败")
+	}
 	return &location, err
 }
 
 func (s *MessageServ) DelLocation(locationID string) error {
 	loc, err := s.dao.GetLocationById(locationID)
 	if err != nil {
-		return err
+		utils.LogError("删除信息失败: " + err.Error())
+		return errors.New("删除信息失败")
 	}
 	err = s.dao.UpdateLocationSortByID(loc.OrderNo)
 	if err != nil {
-		return err
+		utils.LogError("删除信息失败: " + err.Error())
+		return errors.New("删除信息失败")
 	}
 	err = s.dao.DelLocation(locationID)
-	return err
+	if err != nil {
+		utils.LogError("删除信息失败: " + err.Error())
+		return errors.New("删除信息失败")
+	}
+	return nil
 }
 
 // UpdateLocationSort 更新顺序
 		}
 		err := s.dao.UpdateLocationSort(loc)
 		if err != nil {
-			return err
+			utils.LogError("更新失败: " + err.Error())
+			return errors.New("更新失败")
 		}
 	}
 	return nil

service/message/message.go

 package message
 
 import (
+	"errors"
 	"spaceofcheng/services/models/course"
 	"spaceofcheng/services/models/message"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service"
 	"spaceofcheng/services/utils"
-
-	"github.com/astaxie/beego"
 )
 
 // MessageServ 系统处理
 	}
 	infos, err := s.dao.GetCmsInfoList(title, orgid, page, pageSize)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取列表失败: " + err.Error())
+		return nil, errors.New("获取列表失败")
 	}
 	total, err := s.dao.GetCmsInfoListCount(title, orgid)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取列表失败: " + err.Error())
+		return nil, errors.New("获取列表失败")
 	}
 
 	return map[string]interface{}{
 // GetCmsInfoByLocation 根据位置ID获取消息列表
 func (s *MessageServ) GetCmsInfoByLocation(locationid, orgid string) ([]model.TaCmsInfo, error) {
 	infos, err := s.dao.GetCmsInfoByLocation(locationid, orgid)
+	if err != nil {
+		utils.LogError("获取列表失败: " + err.Error())
+		return nil, errors.New("获取列表失败")
+	}
 	return infos, err
 }
 
 // GetCmsInfoByID 获取单条消息信息
 func (s *MessageServ) GetCmsInfoByID(id string) (*model.TaCmsInfo, error) {
 	info, err := s.dao.GetCmsInfoByID(id)
+	if err != nil {
+		utils.LogError("获取信息失败: " + err.Error())
+		return nil, errors.New("获取信息失败")
+	}
 	return info, err
 }
 
 func (s *MessageServ) SaveCmsInfo(cmsinfo model.TaCmsInfo) (*model.TaCmsInfo, error) {
 	if cmsinfo.InfoId == "" {
 		newcmsinfo, err := s.dao.AddCmsInfo(cmsinfo)
-		return newcmsinfo, err
+		if err != nil {
+			utils.LogError("保存信息失败: " + err.Error())
+			return nil, errors.New("保存信息失败")
+		}
+		return newcmsinfo, nil
 	}
 	err := s.dao.UpdateCmsInfo(cmsinfo)
-	return &cmsinfo, err
+	if err != nil {
+		utils.LogError("保存信息失败: " + err.Error())
+		return nil, errors.New("保存信息失败")
+	}
+	return &cmsinfo, nil
 }
 
 // DelCmsInfo 删除消息信息
 func (s *MessageServ) DelCmsInfo(infoid string) error {
 	err := s.dao.DelCmsInfo(infoid)
+	if err != nil {
+		utils.LogError("刪除信息失败: " + err.Error())
+		return errors.New("刪除信息失败")
+	}
 	return err
 }

service/message/news.go

 	"spaceofcheng/services/models/message"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service"
-
-	"github.com/astaxie/beego"
+	"spaceofcheng/services/utils"
 )
 
 // GetNewsList 获取咨询列表
 	}
 	infos, err := s.dao.GetNewsList(locationid, title, orgid, page, pageSize)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取列表失败: " + err.Error())
+		return nil, errors.New("获取列表失败")
 	}
 	total, err := s.dao.GetNewsListCount(locationid, title, orgid)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取列表失败: " + err.Error())
+		return nil, errors.New("获取列表失败")
 	}
 
 	return map[string]interface{}{
 // GetNewsByLocation 根据位置id获取咨询信息
 func (s *MessageServ) GetNewsByLocation(locationid, orgid string) ([]model.TaCmsNews, error) {
 	news, err := s.dao.GetNewsByLocation(locationid, orgid)
+	if err != nil {
+		utils.LogError("获取列表失败: " + err.Error())
+		return nil, errors.New("获取列表失败")
+	}
 	return news, err
 }
 
 func (s *MessageServ) GetNewsByID(newsid string) (*message.CmsNews, error) {
 	info, err := s.dao.GetNewsByID(newsid)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取咨询信息失败: " + err.Error())
+		return nil, errors.New("获取咨询信息失败")
 	}
 	newslocation, err := s.dao.GetNewsLocationByID(newsid)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取咨询信息失败: " + err.Error())
+		return nil, errors.New("获取咨询信息失败")
 	}
 	info.NewsLocations = newslocation
 	return info, nil
 		newInfo = &news
 	}
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("保存咨询信息失败: " + err.Error())
+		return nil, errors.New("保存咨询信息失败")
 	}
 	err = s.dao.DelNewsLocation(newInfo.NewsId)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("保存咨询信息失败: " + err.Error())
+		return nil, errors.New("保存咨询信息失败")
 	}
 	err = s.dao.SaveNewsLocation(newInfo.NewsId, locationids)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("保存咨询信息失败: " + err.Error())
+		return nil, errors.New("保存咨询信息失败")
 	}
 	return newInfo, err
 }
 // DelNews 刪除咨询信息
 func (s *MessageServ) DelNews(newsid string) error {
 	err := s.dao.DelNews(newsid)
+	if err != nil {
+		utils.LogError("删除咨询信息失败: " + err.Error())
+		return errors.New("删除咨询信息失败")
+	}
 	return err
 }

service/system/role.go

 package system
 
 import (
+	"errors"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/models/system"
 	"spaceofcheng/services/service"
 	"spaceofcheng/services/utils"
-
-	"github.com/astaxie/beego"
 )
 
 // RoleServ 系统处理
 	}
 	roles, err := s.dao.GetRoleList(caseids, name, caseid, page, pageSize)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取角色列表失败: " + err.Error())
+		return nil, errors.New("获取角色列表失败")
 	}
 	total, err := s.dao.GetRoleCount(caseids, name, caseid)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取角色列表失败: " + err.Error())
+		return nil, errors.New("获取角色列表失败")
 	}
 
 	return map[string]interface{}{
 		"pagesize": pageSize,
 		"pagenum":  total,
 		"page":     page,
-	}, err
+	}, nil
 }
 
 // GetRoleByID 根据ID获取角色
 func (s *RoleServ) GetRoleByID(roleid string) (*model.SysRole, error) {
 	role, err := s.dao.GetRoleByID(roleid)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取角色信息失败: " + err.Error())
+		return nil, errors.New("获取角色信息失败")
 	}
 	// if role != nil {
 	// 	menus, err := s.dao.GetRoleMenuByRoleID(roleid)
 	// 	}
 	// 	role.RoleMenu = menus
 	// }
-	return role, err
+	return role, nil
 }
 
 // GetRoleMeneByID 根据ID获取角色菜单
 func (s *RoleServ) GetRoleMeneByID(roleid string) ([]model.SysMenu, error) {
 	menus, err := s.dao.GetRoleMenuByRoleID(roleid)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取角色菜单失败: " + err.Error())
+		return nil, errors.New("获取角色菜单失败")
 	}
 	return menus, nil
 }
 		newInfo = &role
 	}
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("保存角色信息失败: " + err.Error())
+		return nil, errors.New("保存角色信息失败")
 	}
 
 	return newInfo, err
 	var err error
 	err = s.dao.DelRoleMenu(roleid)
 	if err != nil {
-		beego.Error(err)
-		return err
+		utils.LogError("保存角色菜单失败: " + err.Error())
+		return errors.New("保存角色菜单失败")
 	}
 	err = s.dao.SaveRoleMenu(roleid, menuids)
 	if err != nil {
-		beego.Error(err)
-		return err
+		utils.LogError("保存角色菜单失败: " + err.Error())
+		return errors.New("保存角色菜单失败")
 	}
 	err = s.dao.DelUserMenusByRole(roleid)
 	if err != nil {
-		beego.Error(err)
-		return err
+		utils.LogError("保存角色菜单失败: " + err.Error())
+		return errors.New("保存角色菜单失败")
 	}
 	err = s.dao.SaveUserMenus(roleid)
-	return err
+	if err != nil {
+		utils.LogError("保存角色菜单失败: " + err.Error())
+		return errors.New("保存角色菜单失败")
+	}
+	return nil
 }
 
 // DelRole 删除角色
 func (s *RoleServ) DelRole(Roleid string) error {
 	err := s.dao.DeleteRole(Roleid)
+	if err != nil {
+		utils.LogError("删除角色信息失败: " + err.Error())
+		return errors.New("删除角色信息失败")
+	}
 	return err
 }

service/verify/verify.go

 package verify
 
 import (
+	"errors"
 	"spaceofcheng/services/models"
 	"spaceofcheng/services/models/customer"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service"
 	"spaceofcheng/services/utils"
 	"time"
-
-	"github.com/astaxie/beego"
 )
 
 // CaseServ 系统处理
 	}
 	customerDetail, err := s.dao.GetCustomerCourseList(id, caseid, page, pageSize)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取列表失败: " + err.Error())
+		return nil, errors.New("获取列表失败")
 	}
 	customerId := customerDetail[0].CustomerId
 	total, err := s.dao.GetCustomerCourseListCount(id, caseid)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取列表失败: " + err.Error())
+		return nil, errors.New("获取列表失败")
 	}
-	beego.Error(customerId)
+
 	customer, err := s.cdao.GetCustomerByID(customerId)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取列表失败: " + err.Error())
+		return nil, errors.New("获取列表失败")
 	}
 	return map[string]interface{}{
 		"list":         customerDetail,
 		"pagenum":      total,
 		"page":         page,
 		"customerInfo": customer,
-	}, err
+	}, nil
 }
 
 // GetCustomerCourseDetailByTel根据电话号码获取当日可核销课程
 	}
 	customerDetail, err := s.dao.GetCustomerCourseListByTel(tel, caseid, page, pageSize)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取列表失败: " + err.Error())
+		return nil, errors.New("获取列表失败")
 	}
 	customerId := customerDetail[0].CustomerId
 	total, err := s.dao.GetCustomerCourseListByTelCount(tel, caseid)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取列表失败: " + err.Error())
+		return nil, errors.New("获取列表失败")
 	}
 	customer, err := s.cdao.GetCustomerByID(customerId)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取列表失败: " + err.Error())
+		return nil, errors.New("获取列表失败")
 	}
 	return map[string]interface{}{
 		"list":         customerDetail,
 		"pagenum":      total,
 		"page":         page,
 		"customerInfo": customer,
-	}, err
+	}, nil
 
 }
 func (s *VerifyServ) GetCustomerCourseDetailByDetailId(id string) (*model.TaCustomerCourseDetail, error) {
 	customerDetail, err := s.dao.GetCustomerCourseDetailById(id)
+	if err != nil {
+		utils.LogError("获取核销记录失败: " + err.Error())
+		return nil, errors.New("获取核销记录失败")
+	}
 	return customerDetail, err
 }
 
 		customerDetail.VerifyStatus = "used"
 	}
 	err = s.dao.UpdateCustomerCourseDetail(customerDetail)
+	if err != nil {
+		utils.LogError("更新核销记录失败: " + err.Error())
+		return errors.New("更新核销记录失败")
+	}
 	return err
 }
 
 	var err error
 	customerCard.VerifyDate = time.Now()
 	err = s.dao.UpdateCustomerCard(customerCard)
-	return err
+	if err != nil {
+		utils.LogError("更新记录失败: " + err.Error())
+		return errors.New("更新记录失败")
+	}
+	return nil
 
 }
 
 		customerCourse.IsDone = models.BOOL_TRUE
 	}
 	err = s.dao.UpdateCustomerCourse(customerCourse)
+	if err != nil {
+		utils.LogError("更新记录失败: " + err.Error())
+		return errors.New("更新记录失败")
+	}
 	return err
 
 }
 func (s *VerifyServ) GetCustomerCardByDetailId(detailId string) (*model.TaCustomerCard, error) {
 	customerCard, err := s.dao.GetCustomerCardByDetailId(detailId)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取体验卡信息失败: " + err.Error())
+		return nil, errors.New("获取体验卡信息失败")
 	}
 	return customerCard, err
 }
 func (s *VerifyServ) GetCustomerCourseByDetailId(detailId string) (*model.TaCustomerCourse, error) {
 	customerCourse, err := s.dao.GetCustomerCourseByDetailId(detailId)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取课程信息失败: " + err.Error())
+		return nil, errors.New("获取课程信息失败")
 	}
 	return customerCourse, err
 }

service/vipcard/vipcard.go

 package vipcard
 
 import (
+	"errors"
 	"spaceofcheng/services/models"
 	"spaceofcheng/services/models/customer"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/models/vipcard"
 	"spaceofcheng/services/service"
 	"spaceofcheng/services/utils"
-
-	"github.com/astaxie/beego"
 )
 
 // CaseServ 系统处理
 	}
 	vipchild, err := s.dao.GetVipCardList(caseid, page, pageSize)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取VIP卡信息失败: " + err.Error())
+		return nil, errors.New("获取VIP卡信息失败")
 	}
 	total, err := s.dao.GetCardCount(caseid)
 	if err != nil {
-		beego.Error(err)
-		return nil, err
+		utils.LogError("获取VIP卡信息失败: " + err.Error())
+		return nil, errors.New("获取VIP卡信息失败")
 	}
 	return map[string]interface{}{
 		"list":     vipchild,
 // 根据code获取vip子卡
 func (s *VipcardServ) GetVipChildByCode(vipChildId string) (*model.TaVipCardChild, error) {
 	vipCardChild, err := s.dao.GetVipChildByCode(vipChildId)
+	if err != nil {
+		utils.LogError("获取VIP卡信息失败: " + err.Error())
+		return nil, errors.New("获取VIP卡信息失败")
+	}
 	return vipCardChild, err
 }
 
 func (s *VipcardServ) UpdateVipChild(vipChild *model.TaVipCardChild) error {
 	var err error
 	err = s.dao.UpdateVipChild(vipChild)
+	if err != nil {
+		utils.LogError("获取VIP卡信息失败: " + err.Error())
+		return errors.New("获取VIP卡信息失败")
+	}
 	return err
 }
 
 func (s *VipcardServ) AddVipCard(vipCard model.TaVipCard) (*model.TaVipCard, error) {
 	vipcard, err := s.dao.AddVipCard(vipCard)
 	if err != nil {
-		return nil, err
+		utils.LogError("创建VIP卡失败: " + err.Error())
+		return nil, errors.New("创建VIP卡失败")
 	}
 	for a := 0; a < vipcard.TotalCount; a++ {
 		var vipChild model.TaVipCardChild
 		vipChild.VipCardChildCode = s.dao.GenerateChildCode()
 		_, err := s.dao.AddVipChildCard(vipChild)
 		if err != nil {
-			return nil, err
+			utils.LogError("创建VIP卡失败: " + err.Error())
+			return nil, errors.New("创建VIP卡失败")
 		}
-
 	}
-	return nil, nil
+	return vipcard, nil
 }
 
 func (s *VipcardServ) FindCustomerByTel(tel string) (*model.TaCustomer, error) {
 	customer, err := s.cdao.GetCustomerByPhone(tel)
 	if err != nil {
-		return nil, err
+		utils.LogError("获取信息失败: " + err.Error())
+		return nil, errors.New("获取信息失败")
 	}
 	return customer, err
 }
 func (s *VipcardServ) CustomerCharge(vipchild *model.TaVipCardChild, createUser model.SysUser) error {
 	customer, err := s.cdao.GetCustomerByPhone(vipchild.CustomerTel)
 	if err != nil {
-		return err
+		utils.LogError("充值失败: " + err.Error())
+		return errors.New("充值失败")
 	}
 	customerId := customer.CustomerId
 	account, err := s.cdao.GetAccountByCust(customerId)
 	if err != nil {
-		return err
+		utils.LogError("充值失败: " + err.Error())
+		return errors.New("充值失败")
 	}
 	vipcard, err := s.dao.GetVipCardById(vipchild.VipCardId)
 	if err != nil {
-		return err
+		utils.LogError("充值失败: " + err.Error())
+		return errors.New("充值失败")
 	}
 	var record model.TaAccountChange
 	record.CustomerId = customerId
 	record.CreateUser = createUser.UserId
 	record.FloatType = models.ACCOUNT_INCOME
 	record.AccountId = account.AccountId
-	return s.cdao.InsertAccountRecords(&record)
-
+	err = s.cdao.InsertAccountRecords(&record)
+	if err != nil {
+		utils.LogError("充值失败: " + err.Error())
+		return errors.New("充值失败")
+	}
+	return nil
 }