Merge branch 'dev' of http://git.ycjcjy.com/SpaceOfCheng/services into dev

controllers/cases/case.go

 
 // GetCaseByID 根据ID获取案场信息
 func (c *CaseController) GetCaseByID() {
-	caseid := c.GetString(":caseid")
+	caseid := c.GetString(":id")
 	info, err := c.dao.GetCaseByID(caseid)
 	if err != nil {
 		c.ResponseError(err)
 
 //DelCase 删除案场信息
 func (c *CaseController) DelCase() {
-	caseid := c.GetString(":caseid")
+	caseid := c.GetString(":id")
 	err := c.dao.DelCase(caseid)
 	if err != nil {
 		c.ResponseError(err)

models/cases/cases.go

 
 // AddCase 新增案场信息
 func (m *CaseDAO) AddCase(caseinfo model.SysCase) (*model.SysCase, error) {
+	caseinfo.CaseId = utils.GetGUID()
 	caseinfo.CreateDate = time.Now()
 	caseinfo.Status = models.STATUS_NORMAL
 	user := m.ctx.Get("user").(model.SysUser)

models/message/cmscase.go

 
 // SaveCmsCaseImg 保存项目专题对应的图片
 func (m *MessageDAO) SaveCmsCaseImg(img model.TaCmsCaseImage) error {
+	img.CmsCaseImageId = utils.GetGUID()
 	img.Status = models.STATUS_NORMAL
 	_, err := m.db.Insert(img)
 	return err

models/model/sys_user_case.go

 
 type SysUserCase struct {
 	UserId     string    `xorm:"not null pk VARCHAR(64)"`
-	CaseId     string    `xorm:"VARCHAR(64)"`
+	CaseId     string    `xorm:"not null pk VARCHAR(64)"`
 	CaseName   string    `xorm:"VARCHAR(100)"`
+	IsCreated  int       `xorm:"TINYINT(1)"`
 	IsBelong   int       `xorm:"TINYINT(1)"`
 	Status     int       `xorm:"SMALLINT(6)"`
 	CreateDate time.Time `xorm:"DATETIME"`

models/system/user.go

 	return err
 }
 
+// DelUserCase 删除用户的案场信息
+func (m *UserDAO) DelUserCase(userid string) error {
+	sql := "delete from sys_user_case where is_belong=0 and is_created=0 and user_id='" + userid + "'"
+	_, err := m.db.Exec(sql)
+	return err
+}
+
 // SaveUserCase 保存用户对应案场信息
 func (m *UserDAO) SaveUserCase(usercase model.SysUserCase) error {
 	usercase.CreateDate = time.Now()

service/cases/area.go

 	"spaceofcheng/services/models/cases"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service"
+
+	"github.com/astaxie/beego"
 )
 
 // GetCaseArea 获取案场区域
 	}
 	areas, err := s.dao.GetCaseArea(caseids, page, pageSize)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	total, err := s.dao.GetCaseAreaCount(caseids)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 
 func (s *CaseServ) GetAreaByCase(caseid string) ([]cases.AreaInfo, error) {
 	areas, err := s.dao.GetCaseAreaByCase(caseid)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	for index, area := range areas {
 		tables, err := s.dao.GetCaseTableByAreaID(area.AreaId)
 		if err != nil {
+			beego.Error(err)
 			return nil, err
 		}
 		areas[index].Tables = tables

service/cases/cases.go

 import (
 	"spaceofcheng/services/models/cases"
 	"spaceofcheng/services/models/model"
+	"spaceofcheng/services/models/system"
 	"spaceofcheng/services/service"
 	"spaceofcheng/services/utils"
+
+	"github.com/astaxie/beego"
 )
 
 // CaseServ 系统处理
 type CaseServ struct {
-	ctx *utils.Context
-	dao *cases.CaseDAO
+	ctx     *utils.Context
+	dao     *cases.CaseDAO
+	userdao *system.UserDAO
 }
 
 // NewCaseServ 初始化
 func NewCaseServ(ctx *utils.Context) *CaseServ {
 	return &CaseServ{
-		ctx: ctx,
-		dao: cases.NewCaseDAO(ctx),
+		ctx:     ctx,
+		dao:     cases.NewCaseDAO(ctx),
+		userdao: system.NewUserDAO(ctx),
 	}
 }
 
 	}
 	cases, err := s.dao.GetCaseList(caseids, casename, page, pageSize)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	total, err := s.dao.GetCaseCount(caseids, casename)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 
 	var err error
 	if caseinfo.CaseId == "" {
 		newInfo, err = s.dao.AddCase(caseinfo)
+		if err != nil {
+			return nil, err
+		}
+		// 新增之后保存用户对应案场
+		var userCase = model.SysUserCase{
+			CaseId:    newInfo.CaseId,
+			UserId:    newInfo.CreateUser,
+			CaseName:  newInfo.CaseName,
+			IsBelong:  0,
+			IsCreated: 1,
+		}
+		err = s.userdao.SaveUserCase(userCase)
 	} else {
 		err = s.dao.UpdateCase(caseinfo)
 		newInfo = &caseinfo

service/cases/equipment.go

 import (
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service"
+
+	"github.com/astaxie/beego"
 )
 
 // GetCaseEquipment 获取体检设备
 	}
 	specs, err := s.dao.GetEquipmentList(caseids, page, pageSize)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	total, err := s.dao.GetEquipmentCount(caseids)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 

service/cases/key.go

 	"spaceofcheng/services/service"
 	"spaceofcheng/services/utils"
 	"strconv"
+
+	"github.com/astaxie/beego"
 )
 
 // GetKeysByCase 根据案场获取钥匙信息
 
 	keys, err := s.dao.GetKeysByCase(caseid, num, page, pageSize)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 
 	total, err := s.dao.GetCaseCount(caseid, num)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 
 	for index, key := range keys {
 		use, err := s.dao.GetCurrentKey(key.KeyId)
 		if err != nil {
+			beego.Error(err)
 			return nil, err
 		}
 		keys[index].CustomerId = use.CustomerId

service/cases/table.go

 import (
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service"
+
+	"github.com/astaxie/beego"
 )
 
 // GetCaseTable 获取案场桌位
 	}
 	areas, err := s.dao.GetCaseTable(caseids, page, pageSize)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	total, err := s.dao.GetCaseTableCount(caseids)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 

service/cases/tag.go

 	"spaceofcheng/services/models/cases"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service"
+
+	"github.com/astaxie/beego"
 )
 
 // GetTagList 获取tag列表
 	}
 	tags, err := s.dao.GetTagList(caseids, page, pageSize)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	total, err := s.dao.GetTagCount(caseids)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 
 func (s *CaseServ) GetTagByID(tagid string) (*cases.Tag, error) {
 	tag, err := s.dao.GetTagByID(tagid)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	if tag != nil {
 		tagcases, err := s.dao.GetTagCaseByTagID(tagid)
 		if err != nil {
+			beego.Error(err)
 			return nil, err
 		}
 		tag.TagCases = tagcases
 		newInfo = &tag
 	}
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	err = s.dao.DelTagCase(newInfo.TagId)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	err = s.dao.SaveTagCase(newInfo.TagId, caseids)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	return newInfo, err

service/course/tag.go

 import (
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service"
+
+	"github.com/astaxie/beego"
 )
 
 // GetTagsList 获取标签列表
 	}
 	tags, err := s.dao.GetTagsList(orgid, page, pageSize)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	total, err := s.dao.GetTagsCount(orgid)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 

service/customer/customer.go

 	"spaceofcheng/services/service/events"
 	"spaceofcheng/services/utils"
 	"strconv"
+
+	"github.com/astaxie/beego"
 )
 
 // CustomerServ 系统处理
 func (s *CustomerServ) GetCustWithWXByID(custID string) (*customer.CustWithWX, error) {
 	cust, err := s.dao.GetCustWithWXByID(custID)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 
 func (s *CustomerServ) GetCustUserByID(userID string) (*UserProfile, error) {
 	user, err := s.dao.GetUserByID(userID)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 
 func (s *CustomerServ) BindWechatUser(userMap *model.TaUserMapping, phone string) (*model.TaCustomer, error) {
 	user, err := s.dao.GetUserByPhone(phone)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 
 
 	cust, err := s.dao.GetCustomerByPhone(phone)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 
 		wxInfo := wxInfoRaw.(map[string]interface{})
 		newCust, err := s.SaveNewCustomer(wxInfo, "", "", user.UserId)
 		if err != nil {
+			beego.Error(err)
 			return nil, err
 		}
 		cust = newCust
 func (s *CustomerServ) BindWechatCust(userMap *model.TaUserMapping, phone, caseID, userID string) (*model.TaCustomer, error) {
 	cust, err := s.dao.GetCustomerByPhone(phone)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 
 		wxInfo := wxInfoRaw.(map[string]interface{})
 		newCust, err := s.SaveNewCustomer(wxInfo, caseID, userID, "")
 		if err != nil {
+			beego.Error(err)
 			return nil, err
 		}
 
 	if caseID != "" {
 		cs, err := s.casedao.GetCaseByID(caseID)
 		if err != nil {
+			beego.Error(err)
 			return nil, err
 		}
 
 	if arID != "" {
 		ar, err := s.dao.GetUserByID(arID)
 		if err != nil {
+			beego.Error(err)
 			return nil, err
 		}
 
 	if userID != "" {
 		user, err := s.dao.GetUserByID(userID)
 		if err != nil {
+			beego.Error(err)
 			return nil, err
 		}
 
 
 	if err := s.dao.SaveCustomer(&cust); err != nil {
 		utils.LogError("更新客户信息失败: " + err.Error())
+		beego.Error(err)
 		return nil, errors.New("更新客户信息失败")
 	}
 

service/goods/spec.go

 	"errors"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service"
+
+	"github.com/astaxie/beego"
 )
 
 // GetGoodsSpec 获取商品规格
 	}
 	specs, err := s.dao.GetGoodsSpec(caseids, page, pageSize)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	total, err := s.dao.GetGoodsSpecCount(caseids)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 

service/goods/type.go

 	"errors"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service"
+
+	"github.com/astaxie/beego"
 )
 
 // GetGoodsType 获取商品类型
 	}
 	types, err := s.dao.GetGoodsType(caseids, page, pageSize)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	total, err := s.dao.GetGoodsTypeCount(caseids)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 

service/message/cmscase.go

 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service"
 	"strings"
+
+	"github.com/astaxie/beego"
 )
 
 // GetCmsCasesList 获取项目列表
 	}
 	infos, err := s.dao.GetCmsCaseList(name, orgid, page, pageSize)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	total, err := s.dao.GetCmsCaseListCount(name, orgid)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 
 	var err error
 	info, err = s.dao.GetCmsCaseByID(cmscaseid)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	var course []model.TaCourse
 		course, err = s.dao.GetCoursesByCmsCase(info.CmsCaseId)
 	}
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	info.Courses = course
 
 	imgs, err := s.dao.GetCmsCaseImgs(info.CmsCaseId)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	info.CmsCaseImgs = imgs
 		newInfo = &cmscase
 	}
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	err = s.dao.DelCmsCaseCourse(newInfo.CmsCaseId)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	if newInfo.IsAllCourse == 0 {
 		err = s.dao.SaveCmsCaseCourse(newInfo.CmsCaseId, courseids)
 		if err != nil {
+			beego.Error(err)
 			return nil, err
 		}
 	}
 	err = s.dao.DelCmsCaseImg(newInfo.CmsCaseId)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 
 		}
 		err = s.dao.SaveCmsCaseImg(CmsImg)
 		if err != nil {
+			beego.Error(err)
 			return nil, err
 		}
 	}
 		}
 		err = s.dao.SaveCmsCaseImg(CmsImg)
 		if err != nil {
+			beego.Error(err)
 			return nil, err
 		}
 	}

service/message/image.go

 	"errors"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service"
+
+	"github.com/astaxie/beego"
 )
 
 const (
 	}
 	infos, err := s.dao.GetImgList(orgid, page, pageSize)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	total, err := s.dao.GetImgListCount(orgid)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 

service/message/message.go

 	"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
 	}
 	total, err := s.dao.GetCmsInfoListCount(title, orgid)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 

service/message/news.go

 	"spaceofcheng/services/models/message"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service"
+
+	"github.com/astaxie/beego"
 )
 
 // GetNewsList 获取咨询列表
 	}
 	infos, err := s.dao.GetNewsList(locationid, orgid, page, pageSize)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	total, err := s.dao.GetNewsListCount(locationid, orgid)
 	if err != nil {
+		beego.Error(err)
 		return nil, 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
 	}
 	newslocation, err := s.dao.GetNewsLocationByID(newsid)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	info.NewsLocations = newslocation
 		newInfo = &news
 	}
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	err = s.dao.DelNewsLocation(newInfo.NewsId)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	err = s.dao.SaveNewsLocation(newInfo.NewsId, locationids)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	return newInfo, err

service/sys.go

 	"spaceofcheng/services/models"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/utils"
+
+	"github.com/astaxie/beego"
 )
 
 const (
 
 	accountRaw, err := json.Marshal(user)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	account := string(accountRaw)
 	// 查询数据库是否存在已有映射
 	userMapList, err := s.dao.GetUserMappingByOpenID(openID)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 
 	// 更新数据库内容, 没有的话则插入
 	err = s.dao.UpdateUserMapping(&userMapping)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 

service/system/role.go

 	"spaceofcheng/services/models/system"
 	"spaceofcheng/services/service"
 	"spaceofcheng/services/utils"
+
+	"github.com/astaxie/beego"
 )
 
 // RoleServ 系统处理
 	}
 	roles, err := s.dao.GetRoleList(caseids, page, pageSize)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	total, err := s.dao.GetRoleCount(caseids)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 
 func (s *RoleServ) GetRoleByID(roleid string) (*system.Role, error) {
 	role, err := s.dao.GetRoleByID(roleid)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	if role != nil {
 		menus, err := s.dao.GetRoleMenuByRoleID(roleid)
 		if err != nil {
+			beego.Error(err)
 			return nil, err
 		}
 		role.RoleMenu = menus
 		newInfo = &role
 	}
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	err = s.dao.DelRoleMenu(newInfo.RoleId)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	err = s.dao.SaveRoleMenu(newInfo.RoleId, menuids)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	return newInfo, err

service/user.go

 	"spaceofcheng/services/models/system"
 	"spaceofcheng/services/utils"
 
+	"github.com/astaxie/beego"
 	"github.com/yl10/kit/encrypt"
 )
 
 	}
 	userList, err := s.dao.GetUserList(username, typeid, caseids, page, pageSize)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	total, err := s.dao.GetUserCount(username, typeid, caseids)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 
 	// 当前用户角色
 	roles, err := s.dao.GetUserRole(user.UserId)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	// 当前用户菜单
 	menus, err := s.dao.GetUserMenu(user.UserId)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 
 func (s *UserServ) GetUserByID(userid string) (*system.UserInfo, error) {
 	userinfo, err := s.dao.GetUserByID(userid)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	userinfo.Pwd = ""
 	usertype, err := s.dao.GetUserType(userid)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	userinfo.UserType = usertype
 
 	usertag, err := s.dao.GetUserTag(userid)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	userinfo.UserTag = usertag
 
 	usercase, err := s.dao.GetUserCase(userid)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	userinfo.UserCase = usercase
 	if user.UserId != "" {
 		err = s.dao.UpdateUser(userInfo)
 		if err != nil {
+			beego.Error(err)
 			return nil, err
 		}
 		// 删除用户对应的标签、用户类型及所属案场
 		err = s.dao.DelUserTag(user.UserId)
 		if err != nil {
+			beego.Error(err)
 			return nil, err
 		}
 		err = s.dao.DelUserType(user.UserId)
 		if err != nil {
+			beego.Error(err)
 			return nil, err
 		}
 		err = s.dao.DelUserBelongCase(user.UserId)
 		if err != nil {
+			beego.Error(err)
 			return nil, err
 		}
 		newUSer = &userInfo
 	} else {
 		newUSer, err = s.dao.AddUser(userInfo)
 		if err != nil {
+			beego.Error(err)
 			return nil, err
 		}
 	}
 	// 保存用户的标签、用户类型及所属案场
 	err = s.dao.SaveUserTag(newUSer.UserId, user.TagIds)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	err = s.dao.SaveUserType(newUSer.UserId, user.TypeId)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	caseInfo, err := s.casedao.GetCaseByID(user.BelongCaseId)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	if caseInfo == nil {
 	userCase.UserId = newUSer.UserId
 	err = s.dao.SaveUserCase(userCase)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	newUSer.Pwd = ""
 func (s *UserServ) CheckUserSignIn(userName, userPassword string) (*model.SysUser, error) {
 	user, err := s.dao.GetUserByName(userName)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}