仓库管理

controllers/secondary_order_api_contorller.go

 	"fmt"
 	"github.com/astaxie/beego"
 	"github.com/jinzhu/gorm"
+	"strings"
 	"time"
 )
 
 	beego.Router("/api/secondary/updatedrugout", &SecondaryOrderApiController{}, "get:UpdateDrugOut")               //更改药品自动出库仓库
 	beego.Router("/api/secondary/getusername", &SecondaryOrderApiController{}, "get:GetuserName")                   //获取仓库管理员信息
 	beego.Router("/api/secondary/byliinit", &SecondaryOrderApiController{}, "get:Byliinit")                         //初始化旧数据
+	beego.Router("/api/secondary/ttttt", &SecondaryOrderApiController{}, "get:TTTTT")
 
 }
 
+//ceshi
+func (this *SecondaryOrderApiController) TTTTT() {
+	orgid := this.GetAdminUserInfo().CurrentOrgId
+	err := service.GetDefaultStorehouse(orgid)
+	if err != nil {
+		utils.ErrorLog("创建默认仓库失败，原因为：", err)
+	}
+	this.ServeSuccessJSON(map[string]interface{}{
+		"list": err,
+	})
+	return
+}
+
 //获取仓库编码
 func (this *SecondaryOrderApiController) GetStoreCode() {
 	orgId := this.GetAdminUserInfo().CurrentOrgId
 //修改仓库状态
 func (this *SecondaryOrderApiController) UpdateStatus() {
 	orgId := this.GetAdminUserInfo().CurrentOrgId
-	orgId = 9675
+	//orgId = 9675
 	check := map[string][]string{
 		"id": {"must", "int", "id"},
 	}
 
 //分页
 func (this *SecondaryOrderApiController) StorehouseList() {
+	adminUserInfo := this.GetAdminUserInfo()
 	page, _ := this.GetInt64("page")   //页码
 	limit, _ := this.GetInt64("limit") //每一页查出来的条数
 	check := map[string][]string{
 	if err != nil {
 		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, err.Error())
 	}
+	namemap := make(map[int64]string)
+	//根据管理员id获取管理员
+	viewModels, _, _ := service.GetAdminUsersAndLoginInfo(adminUserInfo.CurrentOrgId, adminUserInfo.CurrentAppId, 1, 100)
+	for _, v := range viewModels {
+		namemap[int64(v.AdminUserId)] = v.UserName
+	}
+	slicekey := make([]int64, 0)
+	if len(keyword) > 0 {
+		for k, v := range namemap {
+			res := strings.Contains(v, keyword)
+			if res == true {
+				slicekey = append(slicekey, k)
+			}
+		}
+	}
 	//获取分页的数据
-	list, total, err := service.StorehouseList(page, limit, orgId, keyword)
+	list, total, err := service.StorehouseList(page, limit, orgId, keyword, slicekey)
+
+	//分页
+	type Storehouselist struct {
+		ID                  int64
+		StorehouseCode      string //仓库编号
+		StorehouseName      string //仓库名称
+		StorehouseAddress   string //仓库地址
+		StorehouseStatus    int64  //仓库状态
+		Status              int64  //数据状态
+		StorehouseAdminId   int64  //仓库管理员id
+		StorehouseAdminName string //仓库管理员名字
+		UserOrgId           int64
+	}
+	//初始化该结构体
+	tmplist := []*Storehouselist{}
+	for i := 0; i < len(list); i++ {
+		tlist := &Storehouselist{
+			list[i].ID,
+			list[i].StorehouseCode,
+			list[i].StorehouseName,
+			list[i].StorehouseAddress,
+			list[i].StorehouseStatus,
+			list[i].Status,
+			list[i].StorehouseAdminId,
+			"",
+			list[i].UserOrgId,
+		}
+		tmplist = append(tmplist, tlist)
+	}
+	for _, v := range tmplist {
+		if k, ok := namemap[v.StorehouseAdminId]; ok {
+			v.StorehouseAdminName = k
+		} else {
+			v.StorehouseAdminName = "超级管理员"
+		}
+	}
 	this.ServeSuccessJSON(map[string]interface{}{
-		"list":  list,
+		"list":  tmplist,
 		"total": total,
 	})
 }
 		return
 	}
 	var storehouse_status, admin_id int64
-	var admin_name string
 	tmpstatus := dataBody["storehouse_status"]
-	tmpid := dataBody["storehouse_admin_id"]
-	tmpname := dataBody["storehouse_admin_name"]
+	tmpid := dataBody["storehouse_admin_id"] //管理员id
 	if tmpstatus == nil {
 		storehouse_status = 1
 	} else {
 		storehouse_status = int64(dataBody["storehouse_status"].(float64)) //状态
 	}
 	if tmpid == nil {
-		admin_id = 0
+		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "管理员id不能为空")
+		return
 	} else {
 		admin_id = int64(dataBody["storehouse_admin_id"].(float64)) //管理员id
 	}
-	if tmpname == nil {
-		admin_name = "admin"
-	} else {
-		admin_name = dataBody["storehouse_admin_name"].(string) //管理员名称
-	}
-
 	switch {
 	case dataBody["storehouse_code"] == nil:
 		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "仓库编号不能为空")
 		return
 	}
 
-	//storehouse_admin := int64(dataBody["storehouse_admin"].(float64))//仓库管理员，暂时不用管
 	storehouse := models.Storehouse{
-		StorehouseCode:      code,
-		StorehouseName:      name,
-		StorehouseAddress:   address,
-		StorehouseStatus:    storehouse_status,
-		UserOrgId:           orgId,
-		Status:              1,
-		StorehouseAdminId:   admin_id,
-		StorehouseAdminName: admin_name,
-		Ctime:               time.Now().Unix(),
+		StorehouseCode:    code,
+		StorehouseName:    name,
+		StorehouseAddress: address,
+		StorehouseStatus:  storehouse_status,
+		UserOrgId:         orgId,
+		Status:            1,
+		StorehouseAdminId: admin_id,
+		Ctime:             time.Now().Unix(),
 	}
 	err = service.AddStroehouse(storehouse)
 	if err != nil {
 //修改仓库
 func (this *SecondaryOrderApiController) UpdateStorehouse() {
 	dataBody := make(map[string]interface{}, 0)
+	//orgId := this.GetAdminUserInfo().CurrentOrgId
 	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
 	if err != nil {
 		utils.ErrorLog(err.Error())
 		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
 		return
 	}
-	var storehouse_status int64
+	var storehouse_status, admin_id int64
 	tmpstatus := dataBody["storehouse_status"]
+	tmpid := dataBody["storehouse_admin_id"]
 	if tmpstatus == nil {
 		storehouse_status = 1
 	} else {
 		storehouse_status = int64(dataBody["storehouse_status"].(float64)) //状态
 	}
+	if tmpid == nil {
+		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "管理员id不能为空")
+		return
+	} else {
+		admin_id = int64(dataBody["storehouse_admin_id"].(float64)) //管理员id
+	}
 
 	switch {
 	case dataBody["id"] == nil:
 	name := dataBody["storehouse_name"].(string)       //仓库名称
 	address := dataBody["storehouse_address"].(string) //地址
 
-	//storehouse_admin := int64(dataBody["storehouse_admin"].(float64))//仓库管理员，暂时不用管
 	storehouse := models.Storehouse{
 		ID:                id,
 		StorehouseName:    name,
 		StorehouseAddress: address,
 		StorehouseStatus:  storehouse_status,
+		StorehouseAdminId: admin_id,
 		Mtime:             time.Now().Unix(),
 	}
 	err = service.UpdateStroehouse(storehouse)
 
 //查询机构所属管理员
 func (this *SecondaryOrderApiController) GetuserName() {
-	orgId := this.GetAdminUserInfo().CurrentOrgId
-	username, err := service.GetuserName(orgId)
-	if err != nil {
-		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, err.Error())
-		return
-	}
+	adminUserInfo := this.GetAdminUserInfo()
+	viewModels, _, _ := service.GetAdminUsersAndLoginInfo(adminUserInfo.CurrentOrgId, adminUserInfo.CurrentAppId, 1, 100)
 	this.ServeSuccessJSON(map[string]interface{}{
-		"list": username,
+		"list": viewModels,
 	})
 
 }

models/secondary_models.go

 
 //二级仓库
 type Storehouse struct {
-	ID                  int64  `gorm:"column:id" json:"id" form:"id"`
-	StorehouseCode      string `gorm:"column:storehouse_code" json:"storehouse_code" form:"storehouse_code"`                 //仓库编号
-	StorehouseName      string `gorm:"column:storehouse_name" json:"storehouse_name" form:"storehouse_name"`                 //仓库名称
-	StorehouseAddress   string `gorm:"column:storehouse_address" json:"storehouse_address" form:"storehouse_address"`        //仓库地址
-	StorehouseStatus    int64  `gorm:"column:storehouse_status" json:"storehouse_status" form:"storehouse_status"`           //仓库状态
-	Status              int64  `gorm:"column:status" json:"status" form:"status"`                                            //数据状态
-	StorehouseAdminId   int64  `gorm:"column:storehouse_admin_id" json:"storehouse_admin_id" form:"storehouse_admin_id"`     //仓库管理员id
-	StorehouseAdminName string `gorm:"column:storehouse_admin_name" json:"storehouse_admin_name" form:"storehouse_admin_id"` //仓库管理员名字
-	UserOrgId           int64  `gorm:"column:user_org_id" json:"user_org_id" form:"user_org_id"`
-	Ctime               int64  `gorm:"column:ctime" json:"ctime" form:"ctime"`
-	Mtime               int64  `gorm:"column:mtime" json:"mtime" form:"mtime"`
+	ID                int64  `gorm:"column:id" json:"id" form:"id"`
+	StorehouseCode    string `gorm:"column:storehouse_code" json:"storehouse_code" form:"storehouse_code"`             //仓库编号
+	StorehouseName    string `gorm:"column:storehouse_name" json:"storehouse_name" form:"storehouse_name"`             //仓库名称
+	StorehouseAddress string `gorm:"column:storehouse_address" json:"storehouse_address" form:"storehouse_address"`    //仓库地址
+	StorehouseStatus  int64  `gorm:"column:storehouse_status" json:"storehouse_status" form:"storehouse_status"`       //仓库状态
+	Status            int64  `gorm:"column:status" json:"status" form:"status"`                                        //数据状态
+	StorehouseAdminId int64  `gorm:"column:storehouse_admin_id" json:"storehouse_admin_id" form:"storehouse_admin_id"` //仓库管理员id
+	UserOrgId         int64  `gorm:"column:user_org_id" json:"user_org_id" form:"user_org_id"`
+	Ctime             int64  `gorm:"column:ctime" json:"ctime" form:"ctime"`
+	Mtime             int64  `gorm:"column:mtime" json:"mtime" form:"mtime"`
 }
 
 func (Storehouse) TableName() string {
 }
 
 type App_Role_byli struct {
-	Id       int64  `gorm:"PRIMARY_KEY;AUTO_INCREMENT" json:"id"`
-	OrgId    int64  `gorm:"column:org_id" json:"org_id"`
-	UserName string `gorm:"column:user_name" json:"user_name"` // 用户名称
+	Id          int64  `gorm:"PRIMARY_KEY;AUTO_INCREMENT" json:"id"`
+	OrgId       int64  `gorm:"column:org_id" json:"org_id"`
+	AdminUserId int64  `gorm:"column:admin_user_id" json:"admin_user_id" form:"admin_user_id"`
+	UserName    string `gorm:"column:user_name" json:"user_name"` // 用户名称
 }
 
 func (App_Role_byli) TableName() string {
 	return "sgj_users.sgj_user_admin_role"
 }
+
+type UserOrg struct {
+	Id      int64 `gorm:"PRIMARY_KEY;AUTO_INCREMENT" json:"id"`
+	Creator int64 `gorm:"column:creator" json:"creator"`
+}
+
+func (UserOrg) TableName() string {
+	return "sgj_users.sgj_user_org"
+}
+
+//分页
+type Storehouselist struct {
+	ID                  int64  `gorm:"column:id" json:"id" form:"id"`
+	StorehouseCode      string `gorm:"column:storehouse_code" json:"storehouse_code" form:"storehouse_code"`                 //仓库编号
+	StorehouseName      string `gorm:"column:storehouse_name" json:"storehouse_name" form:"storehouse_name"`                 //仓库名称
+	StorehouseAddress   string `gorm:"column:storehouse_address" json:"storehouse_address" form:"storehouse_address"`        //仓库地址
+	StorehouseStatus    int64  `gorm:"column:storehouse_status" json:"storehouse_status" form:"storehouse_status"`           //仓库状态
+	Status              int64  `gorm:"column:status" json:"status" form:"status"`                                            //数据状态
+	StorehouseAdminId   int64  `gorm:"column:storehouse_admin_id" json:"storehouse_admin_id" form:"storehouse_admin_id"`     //仓库管理员id
+	StorehouseAdminName string `gorm:"column:storehouse_admin_name" json:"storehouse_admin_name" form:"storehouse_admin_id"` //仓库管理员名字
+	UserOrgId           int64  `gorm:"column:user_org_id" json:"user_org_id" form:"user_org_id"`
+	Ctime               int64  `gorm:"column:ctime" json:"ctime" form:"ctime"`
+	Mtime               int64  `gorm:"column:mtime" json:"mtime" form:"mtime"`
+}

service/secondary_service.go

 	"fmt"
 	"github.com/jinzhu/gorm"
 	"math/rand"
+	"strconv"
 	"time"
 )
 
 func UpdateStroehouse(storehouse models.Storehouse) error {
 	err := XTWriteDB().Model(&models.Storehouse{}).Where("id = ? and status = 1", storehouse.ID).Updates(
 		map[string]interface{}{
-			"storehouse_name":    storehouse.StorehouseName,
-			"storehouse_address": storehouse.StorehouseAddress,
-			"storehouse_status":  storehouse.StorehouseStatus,
-			"mtime":              storehouse.Mtime,
+			"storehouse_name":     storehouse.StorehouseName,
+			"storehouse_address":  storehouse.StorehouseAddress,
+			"storehouse_status":   storehouse.StorehouseStatus,
+			"storehouse_admin_id": storehouse.StorehouseAdminId,
+			"mtime":               storehouse.Mtime,
 		}).Error
 	return err
 }
 }
 
 //分页
-func StorehouseList(page, limit, orgid int64, keyword string) (storehouse []models.Storehouse, total int64, err error) {
+func StorehouseList(page, limit, orgid int64, keyword string, slicekey []int64) (storehouse []models.Storehouse, total int64, err error) {
 	db := XTReadDB().Model(&storehouse).Where("status = 1 and user_org_id = ?", orgid)
 	offset := (page - 1) * limit
 	if len(keyword) > 0 {
+		var adminid string = "storehouse_code like ? or storehouse_name like ? or storehouse_address like ? "
+		if len(slicekey) > 0 {
+			for i := 0; i < len(slicekey); i++ {
+				adminid = adminid + " or storehouse_admin_id =" + strconv.FormatInt(slicekey[i], 10)
+			}
+		}
 		keyword = "%" + keyword + "%"
-		db = db.Where("storehouse_code like ? or storehouse_name like ? or storehouse_address like ? or storehouse_admin_name like ?", keyword, keyword, keyword, keyword)
+		db = db.Where(adminid, keyword, keyword, keyword)
 	}
 	err = db.Count(&total).Offset(offset).Order("id").Limit(limit).Find(&storehouse).Error
 	return storehouse, total, err
 			a = false
 		}
 	}
+	createid, err := Getcreateid(orgid)
+	if err != nil {
+		return err
+	}
 	storehouse := models.Storehouse{
-		StorehouseCode:      code,
-		StorehouseName:      "默认仓库",
-		StorehouseAddress:   "",
-		StorehouseStatus:    1,
-		UserOrgId:           orgid,
-		StorehouseAdminName: "admin",
-		Status:              1,
-		Ctime:               time.Now().Unix(),
-	}
-	err := AddStroehouse(storehouse)
+		StorehouseCode:    code,
+		StorehouseName:    "默认仓库",
+		StorehouseAddress: "",
+		StorehouseStatus:  1,
+		UserOrgId:         orgid,
+		StorehouseAdminId: createid.Creator,
+		Status:            1,
+		Ctime:             time.Now().Unix(),
+	}
+	err = AddStroehouse(storehouse)
 	return err
 }
 
 			tx.Commit()
 		}
 	}()
+	err = initsgj_user_admin(tx)
+	if err != nil && err.Error() != "record not found" {
+		return
+	}
 	err = StoreReduceOrg(tx)
 	if err != nil && err.Error() != "record not found" {
 		return
 	return
 }
 
+//初始化管理员名字
+func initsgj_user_admin(tx *gorm.DB) (err error) {
+	err = tx.Exec("update sgj_users.sgj_user_admin set name = \"超级管理员\" where name is null or name = \"\"").Error
+	return
+}
+
 //根据xt_gobal_template 获取的机构id减去仓库表存在的机构id，把结果插入到仓库表
 func StoreReduceOrg(tx *gorm.DB) (err error) {
 	err = tx.Exec("INSERT INTO sgj_xt.xt_storehouse(storehouse_code,storehouse_name,user_org_id,ctime)" +
 	return
 }
 
-//初始化 xt_storehouse（）把插入管理员的名字
+//初始化 xt_storehouse 管理员的名字
 func initxt_storehouse(tx *gorm.DB) (err error) {
 	err = tx.Exec("UPDATE sgj_xt.xt_storehouse as t," +
-		"(SELECT o.id,o.creator,u.name from sgj_users.sgj_user_org as o,sgj_users.sgj_user_admin as u," +
+		"(SELECT o.id,o.creator from sgj_users.sgj_user_org as o," +
 		"(SELECT DISTINCT org_id from sgj_xt.xt_gobal_template)as t " +
-		"WHERE o.creator = u.id AND t.org_id = o.id )tmp " +
-		"SET t.storehouse_admin_id = tmp.creator,t.storehouse_admin_name = tmp.name,t.mtime = UNIX_TIMESTAMP()" +
+		"WHERE t.org_id = o.id )tmp " +
+		"SET t.storehouse_admin_id = tmp.creator,t.mtime = UNIX_TIMESTAMP()" +
 		"WHERE t.status = 1 and t.user_org_id = tmp.id").Error
 	return
 }
 	return
 }
 
-//查询机构下的所有用户名
-func GetuserName(orgid int64) (username []models.App_Role_byli, err error) {
-	err = XTReadDB().Select("id,org_id,user_name").Where("org_id = ?", orgid).Find(&username).Error
+//查询机构创建者的id
+func Getcreateid(orgid int64) (createid models.UserOrg, err error) {
+	err = XTReadDB().Select("id,creator").Where("id = ? and status = 1", orgid).Find(&createid).Error
 	return
 }