1116PM

controllers/component.go

 package controllers
 
 import (
+	"bytes"
 	"encoding/base64"
 	"encoding/json"
-	"encoding/xml"
 	"io/ioutil"
 	"net/http"
-	"strconv"
 	"wechat-conf/models"
 	"wechat-conf/models/model"
 	"wechat-conf/service/autoreply"
 
 	"github.com/kinisky564477/wechat/component"
 
-	"github.com/zjxpcyc/wechat/core"
+	"github.com/kinisky564477/wechat/core"
 )
 
 // WechatController 用户
 		replay, err = c.serv.GetAutoReplayByAppID(appid, content)
 		break
 	case "event":
-		if val["Event"] == "subscribe" {
+		beego.Error(val)
+		switch val["Event"] {
+		case "subscribe":
 			replay, err = c.serv.GetSubscribeByAppID(appid)
+			break
+		case "LICK":
+			// 点击事件
+
 		}
+
 		break
 	}
 	if err != nil {
 		c.ResponseRaw([]byte(""))
 	}
 	openID := val["FromUserName"]
-	signature := c.GetString("msg_signature")
-	nonce := c.GetString("nonce")
-	timestamp, _ := strconv.Atoi(c.GetString("timestamp"))
-	beego.Error("signature:", signature, ",nonce：", nonce, ",timestamp:", timestamp)
-	message, err := c.getReplayMessage(replay, openID, AESKey, wechat)
+	message, err := c.getReplayMessage(replay, openID, wechat)
 	if err != nil {
 		utils.LogError("转换回复信息失败: " + err.Error())
 		c.ResponseRaw([]byte(""))
 	}
-	// message, err = utils.AesEncrypt(message, AESKey)
-	// if err != nil {
-	// 	utils.LogError("加密失败：", err)
-	// 	c.ResponseRaw([]byte(""))
-	// }
-	// beego.Error(string(message))
-	// data := PassiveMessage{
-	// 	Encrypt:      component.CDATA{string(message)},
-	// 	MsgSignature: component.CDATA{signature},
-	// 	TimeStamp:    int64(timestamp),
-	// 	Nonce:        component.CDATA{nonce},
-	// }
-	// beego.Error(data)
-	// res, err := xml.Marshal(data)
-	// beego.Error(err)
-	// beego.Error(string(res))
-	c.ResponseRaw(message)
-	c.DestroyContext()
-	c.StopRun()
-}
 
-// PassiveMessage 加密后的返回信息
-type PassiveMessage struct {
-	XMLName      xml.Name        `xml:"xml"`
-	Encrypt      component.CDATA `xml:"Encrypt"`
-	MsgSignature component.CDATA `xml:"MsgSignature"`
-	TimeStamp    int64           `xml:"TimeStamp"`
-	Nonce        component.CDATA `xml:"Nonce"`
+	cipher, err := core.NewCipher(utils.Component.GetToken(), EncodingAESKey, appid)
+	if err != nil {
+		utils.LogError("获取解密失败: " + err.Error())
+		c.ResponseRaw([]byte(""))
+	}
+
+	dt := bytes.NewBuffer([]byte{})
+	cipher.Encrypt(dt, []byte(message))
+	beego.Error("=========>", dt)
+
+	c.ResponseRaw(dt.Bytes())
+	// c.ResponseRaw([]byte("success"))
 }
 
-func (c *WechatController) getReplayMessage(replay *model.TaAutoReply, openid string, Aeskey []byte, wx *component.WxClient) ([]byte, error) {
+func (c *WechatController) getReplayMessage(replay *model.TaAutoReply, openid string, wx *component.WxClient) ([]byte, error) {
 	switch replay.MessageType {
 	case models.MESSAGE_TYPE_PARAGRAPH:
 		msg, err := wx.ResponseMessageText(openid, replay.MessageParagraph)
 }
 
 // GetWechatMenuByAppID 获取菜单
-func (c *WechatController) GetWechatMenuByAppID() {
+func (c *WechatController) GetMaterialByAppID() {
 	appid := c.GetString(":appid")
 	wxclient, err := utils.Component.GetWxClient(appid)
 	if err != nil {
 		utils.LogError("获取微信信息失败: " + err.Error())
 		c.ResponseError(err)
 	}
-	menus, err := wxclient.GetMenu()
+	var data = map[string]string{}
+	data["offset"] = "0"
+	data["type"] = "image"
+	data["count"] = "10"
+
+	menus, err := wxclient.GetMaterialList(data)
 	if err != nil {
 		utils.LogError("获取微信详情失败: " + err.Error())
 		c.ResponseError(err)

controllers/wechatimg/uploadImg.go

+package wechatimg
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"io"
+	"io/ioutil"
+	"mime/multipart"
+	"net/http"
+	"os"
+	"path/filepath"
+	"time"
+	"wechat-conf/utils"
+
+	"github.com/astaxie/beego"
+)
+
+const (
+	WechatUploadMediaAPI = "https://api.weixin.qq.com/cgi-bin/material/add_material"
+)
+
+var (
+	HttpRequstTimeOut time.Duration
+)
+
+type MediaUpload struct {
+	ErrCode   int    `json:"errcode"`
+	ErrMgs    string `json:"errmsg"`
+	Type      string `json:"type"`
+	MediaID   string `json:"media_id"`
+	CreatedAt string `json:"created_at"`
+}
+
+func init() {
+	HttpRequstTimeOut, _ = time.ParseDuration("5s")
+}
+
+func UploaImage(token, imagePath string) (mediaid string, err error) {
+	file, err := os.Open(imagePath)
+	if err != nil {
+		beego.Error(err)
+		utils.LogError("上传图片失败:", err)
+		return
+	}
+	defer file.Close()
+	body := &bytes.Buffer{}
+	writer := multipart.NewWriter(body)
+	part, err := writer.CreateFormFile("media", filepath.Base(imagePath))
+	if err != nil {
+		beego.Error(err)
+		utils.LogError("上传图片失败:", err)
+		return
+	}
+	_, err = io.Copy(part, file)
+	err = writer.Close()
+	if err != nil {
+		beego.Error(err)
+		utils.LogError("上传图片失败:", err)
+		return
+	}
+
+	req, err := http.NewRequest("POST", WechatUploadMediaAPI, body)
+	req.Header.Add("Content-Type", writer.FormDataContentType())
+	urlQuery := req.URL.Query()
+	if err != nil {
+		beego.Error(err)
+		utils.LogError("上传图片失败:", err)
+		return
+	}
+	urlQuery.Add("access_token", token)
+	urlQuery.Add("type", "image")
+
+	req.URL.RawQuery = urlQuery.Encode()
+	client := http.Client{}
+	res, err := client.Do(req)
+	if err != nil {
+		beego.Error(err)
+		utils.LogError("上传图片失败:", err)
+		return
+	}
+	defer res.Body.Close()
+	jsonbody, _ := ioutil.ReadAll(res.Body)
+	media := MediaUpload{}
+	err = json.Unmarshal(jsonbody, &media)
+	if err != nil {
+		beego.Error(media.ErrMgs)
+		utils.LogError("上传图片失败:", media.ErrMgs)
+		return
+	}
+	if media.MediaID == "" {
+		beego.Error(media.ErrMgs)
+		err = errors.New(media.ErrMgs)
+		utils.LogError("上传图片失败:", media.ErrMgs)
+	}
+	mediaid = media.MediaID
+	return
+}

controllers/wechatimg/wechatimt.go

 package wechatimg
 
 import (
-	"mime/multipart"
+	"fmt"
+	"io"
+	"os"
 	"strconv"
 	"time"
-	"unsafe"
 	"wechat-conf/controllers"
 	"wechat-conf/models/model"
 	"wechat-conf/service/sysuser"
 	"wechat-conf/service/wechatimg"
 	"wechat-conf/utils"
+
+	"github.com/astaxie/beego"
 )
 
 // WechatImgController 信息
 	c.sdao = sysuser.NewSysuserServ(c.Context)
 }
 
+func (c *WechatImgController) GetWechatImgCount() {
+	user := c.Context.Get("user").(*model.SysUser)
+	appid, err := c.sdao.GetAppIdByOrgId(user.OrgId)
+	if err != nil {
+		c.ResponseError(err)
+	}
+	// appid := c.GetString(":appid")
+	wxclient, err := utils.Component.GetWxClient(appid)
+	if err != nil {
+		utils.LogError("获取微信信息失败: " + err.Error())
+		c.ResponseError(err)
+	}
+
+	count, err := wxclient.GetMaterialCount()
+	if err != nil {
+		utils.LogError("获取微信详情失败: " + err.Error())
+		c.ResponseError(err)
+	}
+	matype := c.GetString(":type")
+	c.ResponseJSON(count[matype+"_count"])
+}
+
 func (c *WechatImgController) GetWechatImgList() {
 	user := c.Context.Get("user").(*model.SysUser)
-	appId, err := c.sdao.GetAppIdByOrgId(user.OrgId)
+	appid, err := c.sdao.GetAppIdByOrgId(user.OrgId)
 	if err != nil {
 		c.ResponseError(err)
 	}
-	client, err := utils.Component.GetWxClient(appId)
+	// appid := c.GetString(":appid")
+	wxclient, err := utils.Component.GetWxClient(appid)
 	if err != nil {
+		utils.LogError("获取微信信息失败: " + err.Error())
 		c.ResponseError(err)
 	}
-	page, _ := c.GetInt("page")
-	pageSize, _ := c.GetInt("pagesize")
-	offset := page * (pageSize - 1)
-	var data map[string]string
-	data["offset"] = strconv.Itoa(offset)
-	data["type"] = "image"
-	data["count"] = strconv.Itoa(pageSize)
-	wechatImg, err := client.GetMaterialList(data)
+	var data = map[string]string{}
+	data["offset"] = "0"
+	data["type"] = c.GetString(":type")
+	data["count"] = "10"
+
+	wechatImgs, err := wxclient.GetMaterialList(data)
 	if err != nil {
+		utils.LogError("获取微信详情失败: " + err.Error())
 		c.ResponseError(err)
 	}
-	c.ResponseJSON(wechatImg)
+	c.ResponseJSON(wechatImgs)
 }
+
 func (c *WechatImgController) SyncWechatImg() {
 	user := c.Context.Get("user").(*model.SysUser)
 	appId, err := c.sdao.GetAppIdByOrgId(user.OrgId)
 	if err != nil {
 		c.ResponseError(err)
 	}
+	// appId := c.GetString(":appid")
 	client, err := utils.Component.GetWxClient(appId)
 	if err != nil {
 		c.ResponseError(err)
 	}
-	for i := 0; i < 200; i++ {
-		var data map[string]string
+
+	count, err := client.GetMaterialCount()
+	if err != nil {
+		c.ResponseError(err)
+	}
+
+	imgcount := count["image_count"].(float64)
+	page := int(imgcount)/20 + 1
+	for i := 0; i < page; i++ {
+		var data = map[string]string{}
 		offset := i * 20
 		data["offset"] = strconv.Itoa(offset)
 		data["type"] = "image"
 			break
 		}
 		err = c.dao.SyncWechatImg(wechatImg, user.OrgId)
-
 		if err != nil {
 			c.ResponseError(err)
 		}
 	}
 	c.ResponseJSON("同步成功")
 }
+
 func (c *WechatImgController) AddNewImg() {
+	file, head, err := c.Ctx.Request.FormFile("media")
+	if err != nil {
+		beego.Error(err)
+		c.ResponseError(err)
+	}
+	defer file.Close()
+
+	imgurl := "./upload/" + head.Filename
+	//创建文件
+	fW, err := os.Create(imgurl)
+	if err != nil {
+		fmt.Println("文件创建失败")
+		return
+	}
+	defer fW.Close()
+	_, err = io.Copy(fW, file)
+	if err != nil {
+		fmt.Println("文件保存失败")
+		return
+	}
+
 	user := c.Context.Get("user").(*model.SysUser)
-	fromFront := c.GetString("fromFront")
-	req := c.Ctx.Request
-	file, fh, err := req.FormFile(fromFront)
+
 	appId, err := c.sdao.GetAppIdByOrgId(user.OrgId)
 	if err != nil {
 		c.ResponseError(err)
 	if err != nil {
 		c.ResponseError(err)
 	}
-	token := utils.Component.GetToken()
-	type wechatMatrial struct {
-		access_token string
-		media        multipart.File
-	}
-	var media = wechatMatrial{
-		access_token: token,
-		media:        file,
-	}
-	byteDate := *(*[]byte)(unsafe.Pointer(&media))
-	data, err := client.AddMaterial(byteDate, "image")
+
+	id, err := UploaImage(client.GetToken(), imgurl)
+
 	var img = model.TaWechatImg{
-		MediaId:    data["media_id"].(string),
-		Url:        data["url"].(string),
-		Name:       fh.Filename,
+		MediaId:    id,
+		Url:        imgurl,
+		Name:       head.Filename,
 		UpdateTime: time.Now(),
+		OrgId:      user.OrgId,
 	}
 	err = c.dao.AddWechatImg(img)
 	if err != nil {
 
 }
 func (c *WechatImgController) DeleteImg() {
-	mediaId := c.GetString("mediaId")
-	err := c.dao.DeleteImg(mediaId)
+	user := c.Context.Get("user").(*model.SysUser)
+	appId, err := c.sdao.GetAppIdByOrgId(user.OrgId)
+	if err != nil {
+		c.ResponseError(err)
+	}
+	// appId := c.GetString(":appid")
+	client, err := utils.Component.GetWxClient(appId)
+	if err != nil {
+		c.ResponseError(err)
+	}
+
+	mediaId := c.GetString(":mediaId")
+	err = c.dao.DeleteImg(mediaId)
+	if err != nil {
+		c.ResponseError(err)
+	}
+	_, err = client.DelMaterial(mediaId)
 	if err != nil {
 		c.ResponseError(err)
 	}

controllers/wechatmenu/wechatmenu.go

 	"wechat-conf/service/sysuser"
 	"wechat-conf/service/wechatmenu"
 	"wechat-conf/utils"
-
-	"github.com/astaxie/beego"
 )
 
 // MenuController 信息
 	if err != nil {
 		c.ResponseError(err)
 	}
-	beego.Error(appId)
 	client, err := utils.Component.GetWxClient(appId)
 	if err != nil {
 		c.ResponseError(err)
 	}
 	menu, err := client.GetMenu()
-	var code string = err.Error()
 	if err != nil {
+		var code string = err.Error()
 		if strings.Contains(code, "46003") {
 			c.ResponseJSON(menu)
 		} else {

models/model/ta_wechat_img.go

 
 type TaWechatImg struct {
 	MediaId    string    `xorm:"not null pk VARCHAR(64)"`
-	Name       string    `xorm:"VARCHAR(32)"`
+	Name       string    `xorm:"VARCHAR(100)"`
 	UpdateTime time.Time `xorm:"DATETIME"`
 	Url        string    `xorm:"TEXT"`
 	OrgId      string    `xorm:"VARCHAR(64)"`

models/wechatimg/wechatimg.go

 	_, err := m.db.Insert(img)
 	return err
 }
+
+func (m *WechatImgDAO) AddWechatImgs(imgs []model.TaWechatImg) error {
+	_, err := m.db.Insert(imgs)
+	return err
+}
+
 func (m *WechatImgDAO) DeleteWechatImg(mediaId string) error {
 	_, err := m.db.Delete(&model.TaWechatImg{MediaId: mediaId})
 	return err

routers/router.go

 			beego.NSRouter("/autoreply/:autoreplyId", &autoreply.AutoreplyController{}, "delete:DeleteAutoReply"),
 			beego.NSRouter("/autoreply/isUse/:autoType/:isUse", &autoreply.AutoreplyController{}, "put:ChangeIsUse"),
 			// 图片资源
-			beego.NSRouter("/wechatimg", &wechatimg.WechatImgController{}, "get:GetWechatImgList"),
-			beego.NSRouter("/wechatimg/sync", &wechatimg.WechatImgController{}, "put:SyncWechatImg"),
-			beego.NSRouter("/wechatimg", &wechatimg.WechatImgController{}, "post:AddNewImg"),
-			beego.NSRouter("/wechatimg/:mediaId", &wechatimg.WechatImgController{}, "delete:DeleteImg"),
+			// beego.NSRouter("/wechatimg", &wechatimg.WechatImgController{}, "get:GetWechatImgList"),
+			// beego.NSRouter("/wechatimg/sync", &wechatimg.WechatImgController{}, "put:SyncWechatImg"),
+			// beego.NSRouter("/wechatimg", &wechatimg.WechatImgController{}, "post:AddNewImg"),
+			// beego.NSRouter("/wechatimg/:mediaId", &wechatimg.WechatImgController{}, "delete:DeleteImg"),
+
+			beego.NSRouter("/material/:type/count", &wechatimg.WechatImgController{}, "get:GetWechatImgCount"),
+			beego.NSRouter("/material/:type", &wechatimg.WechatImgController{}, "get:GetWechatImgList"),
+			beego.NSRouter("/material/:type/sync", &wechatimg.WechatImgController{}, "post:SyncWechatImg"),
+			beego.NSRouter("/material/image/save", &wechatimg.WechatImgController{}, "post:AddNewImg"),
+			beego.NSRouter("/material/:mediaId", &wechatimg.WechatImgController{}, "delete:DeleteImg"),
+
 			// 用户管理
 			beego.NSRouter("/sysuser", &sysuser.SysuserController{}, "get:GetUserList"),
 			beego.NSRouter("/sysuser/:userId", &sysuser.SysuserController{}, "get:GetUserById"),
 		beego.NSRouter("/ticket", &controllers.WechatController{}, "get:ComponentPush"),
 		beego.NSRouter("/:appid/callback", &controllers.WechatController{}, "get:WxReceive"),
 		beego.NSRouter("/:appid/callback", &controllers.WechatController{}, "post:WxReceive"),
-		// beego.NSRouter("/wechatinfo/:appid", &controllers.WechatController{}, "get:GetWechatInfoByAppID"),
-		beego.NSRouter("/menu/:appid", &controllers.WechatController{}, "get:GetWechatMenuByAppID"),
 	)
 
 	beego.AddNamespace(ns)

service/wechatimg/wechatimg.go

 import (
 	"errors"
 	"time"
+	"wechat-conf/models"
 	"wechat-conf/models/model"
 	"wechat-conf/models/wechatimg"
 	"wechat-conf/utils"
 		utils.LogError("同步图片失败: " + err.Error())
 		return errors.New("同步图片失败")
 	}
-	type wechatimg struct {
-		media_id    string
-		name        string
-		update_time time.Time
-		url         string
-	}
-	img := data.([]wechatimg)
-	for _, val := range img {
-		beego.Error(val)
-		var wechat model.TaWechatImg
-		wechat.MediaId = val.media_id
-		wechat.Name = val.name
+
+	imgs := data.([]interface{})
+	var wechatimgs []model.TaWechatImg
+	for _, img := range imgs {
+		beego.Error(img)
+		val := img.(map[string]interface{})
+		var wechat = model.TaWechatImg{}
+		wechat.MediaId = val["media_id"].(string)
+		wechat.Name = val["name"].(string)
 		wechat.OrgId = orgId
-		wechat.Url = val.url
-		wechat.UpdateTime = val.update_time
-		err := s.dao.AddWechatImg(wechat)
-		if err != nil {
-			utils.LogError("同步图片失败: " + err.Error())
-			return errors.New("同步图片失败")
-		}
+		wechat.Url = val["url"].(string)
+		// wechat.UpdateTime = val["update_time"]
+		wechat.Status = models.STATUS_NORMAL
+		wechat.CreateDate = time.Now()
+		wechatimgs = append(wechatimgs, wechat)
+	}
+
+	err = s.dao.AddWechatImgs(wechatimgs)
+	if err != nil {
+		utils.LogError("同步图片失败: " + err.Error())
+		return errors.New("同步图片失败")
 	}
 	return nil
 }