v.1.0.4 -> Add handling response cache in redis for outing, schedule, announcement API

docker-compose.yml

@@ -25,7 +25,8 @@ services:
       - CONSUL_INDEX_HEADER=${CONSUL_INDEX_HEADER}
       - SNS_TOPIC_ARN=${SNS_TOPIC_ARN}    # add in v.1.0.2
       - CHANGE_CONSUL_SQS_GATEWAY=${CHANGE_CONSUL_SQS_GATEWAY} # add in v.1.0.2
-      - DELETE_REDIS_TOPIC=${DELETE_REDIS_TOPIC} # add in v.1.0.3
+      - REDIS_DELETE_TOPIC=${REDIS_DELETE_TOPIC}  # add in v.1.0.3
+      - REDIS_SET_TOPIC=${REDIS_SET_TOPIC}        # add in v.1.0.4
     volumes:
       - log-data:/usr/share/filebeat/log/dms-sms
       - ./entity:/usr/share/gateway/entity

handler/default.go

@@ -24,28 +24,11 @@ type serviceName string
 type consulIndex string
 
 type _default struct {
-	authService interface {
-		authproto.AuthAdminService
-		authproto.AuthStudentService
-		authproto.AuthTeacherService
-		authproto.AuthParentService
-	}
-	clubService interface {
-		clubproto.ClubAdminService
-		clubproto.ClubStudentService
-		clubproto.ClubLeaderService
-	}
-	outingService interface {
-		outingproto.OutingStudentService
-		outingproto.OutingTeacherService
-		outingproto.OutingParentsService
-	}
-	scheduleService interface {
-		scheduleproto.ScheduleService
-	}
-	announcementService interface {
-		announcementproto.AnnouncementService
-	}
+	authService authproto.AuthServiceClient
+	clubService clubproto.ClubServiceClient
+	outingService outingproto.OutingServiceClient
+	scheduleService scheduleproto.ScheduleService
+	announcementService announcementproto.AnnouncementService
 
 	consulAgent     consul.Agent
 	logger          *logrus.Logger
@@ -96,48 +79,31 @@ func Default(setters ...FieldSetter) (h *_default) {
 
 type FieldSetter func(*_default)
 
-func AuthService(authService struct {
-	authproto.AuthAdminService
-	authproto.AuthStudentService
-	authproto.AuthTeacherService
-	authproto.AuthParentService
-}) FieldSetter {
+func AuthService(authService authproto.AuthServiceClient) FieldSetter {
 	return func(h *_default) {
 		h.authService = authService
 	}
 }
 
-func ClubService(clubService struct {
-	clubproto.ClubAdminService
-	clubproto.ClubStudentService
-	clubproto.ClubLeaderService
-}) FieldSetter {
+func ClubService(clubService clubproto.ClubServiceClient) FieldSetter {
 	return func(h *_default) {
 		h.clubService = clubService
 	}
 }
 
-func OutingService(outingService interface {
-	outingproto.OutingStudentService
-	outingproto.OutingTeacherService
-	outingproto.OutingParentsService
-}) FieldSetter {
+func OutingService(outingService outingproto.OutingServiceClient) FieldSetter {
 	return func(h *_default) {
 		h.outingService = outingService
 	}
 }
 
-func AnnouncementService(announcementService interface {
-	announcementproto.AnnouncementService
-}) FieldSetter {
+func AnnouncementService(announcementService announcementproto.AnnouncementService) FieldSetter {
 	return func(h *_default) {
 		h.announcementService = announcementService
 	}
 }
 
-func ScheduleService(scheduleService interface {
-	scheduleproto.ScheduleService
-}) FieldSetter {
+func ScheduleService(scheduleService scheduleproto.ScheduleService) FieldSetter {
 	return func(h *_default) {
 		h.scheduleService = scheduleService
 	}

handler/default_announcement.go

@@ -327,7 +327,7 @@ func (h *_default) GetAnnouncementDetail(c *gin.Context) {
 		msg := "succeed to get announcement detail inform with uuid"
 		sendResp := gin.H{"status": status, "code": _code, "message": msg, "date": rpcResp.Date, "title": rpcResp.Title,
 			"content": rpcResp.Content, "writer_name": rpcResp.WriterName, "target_grade": rpcResp.TargetGrade, "target_group": rpcResp.TargetGroup,
-			"next_title": rpcResp.NextTitle, "next_announcement_uuid": rpcResp.NextAnnouncementId,
+			"type": rpcResp.AnnouncementType, "next_title": rpcResp.NextTitle, "next_announcement_uuid": rpcResp.NextAnnouncementId,
 			"previous_title": rpcResp.PreviousTitle, "previous_announcement_uuid": rpcResp.PreviousAnnouncementId}
 		c.JSON(status, sendResp)
 		respBytes, _ := json.Marshal(sendResp)

handler/default_event_handle.go

@@ -5,43 +5,185 @@ package handler
 
 import (
 	"context"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"github.com/aws/aws-sdk-go/service/sqs"
+	"github.com/gin-gonic/gin"
 	"github.com/go-redis/redis/v8"
 	log "github.com/micro/go-micro/v2/logger"
+	"regexp"
+	"strings"
+	"time"
 )
 
-var ctx = context.Background()
+var (
+	ctx = context.Background()
+
+	// check if payload contains {} for param
+	paramStringRegex = regexp.MustCompile("{.*}")
+
+	// outing regex
+	studentOutingsRegex = regexp.MustCompile("^students.student-\\d{12}.outings$")
+	allStudentsOutingsRegex = regexp.MustCompile("^students.\\*.outings$")
+	outingsFilterRegex = regexp.MustCompile("^outings.filter$")
+	outingRegex = regexp.MustCompile("^outings.outing-\\d{12}$")
+	outingCardRegex = regexp.MustCompile("^outings.outing-\\d{12}.card$")
+
+	// schedule regex
+	schedulesRegex = regexp.MustCompile("^schedules$")
+	timetableRegex = regexp.MustCompile("^students.student-\\d{12}.timetable.years.\\d{4}.months.\\d{1,2}.days.\\d{1,2}$")
+
+	// announcement regex
+	announcementRegex = regexp.MustCompile("^announcements.announcement-\\d{12}$")
+	typeValueRegex = regexp.MustCompile("^school|club$")
+	announcementsRegex = regexp.MustCompile("^announcements.uuid.*.types.(school|club|\\*)$")
+	announcementCheckRegex = regexp.MustCompile("^students.*.announcement-check$")
+	myAnnouncementRegex = regexp.MustCompile("^writers.*.announcements$")
+
+	studentUUIDRegex = regexp.MustCompile("^student-\\d{12}$")
+)
 
 func (h *_default) ChangeConsulNodes(message *sqs.Message) (err error) {
 	err = h.consulAgent.ChangeAllServiceNodes()
 	log.Infof("change all service nodes!, err: %v", err)
 	return
 }
 
-func (h *_default) DeleteRedisKeyAssociatedWithResource(message *redis.Message) (err error) {
+// set response in redis key with response in message payload
+func (h *_default) SetRedisKeyWithResponse(msg *redis.Message) (err error) {
+	resp := gin.H{}
+	if err = json.Unmarshal([]byte(msg.Payload), &resp); err != nil {
+		err = errors.New(fmt.Sprintf("unable to unmarshal set redis key msg to golang struct, err: %v", err))
+		return
+	}
+
+	if _, ok := resp["redis.key"]; !ok {
+		err = errors.New("msg to set in redis have to include redis.key field")
+		return
+	}
+
+	key := resp["redis.key"].(string)
+	delete(resp, "redis.key")
+	respBytes, _ := json.Marshal(resp)
+
+	result, err := h.redisClient.Set(ctx, key, string(respBytes), time.Minute).Result()
+	if err != nil {
+		err = errors.New(fmt.Sprintf("unable to set response in redis key, err: %v", err))
+		return
+	}
+	log.Infof("succeed to set response in redis key!, key: %s, result: %s", key, result)
+
+	switch true {
+	case outingRegex.MatchString(key):
+		if _, ok := resp["student_uuid"]; !ok {
+			return
+		}
+		sid, ok := resp["student_uuid"].(string)
+		if !ok || !studentUUIDRegex.MatchString(sid) {
+			return
+		}
+		key = fmt.Sprintf("%s.student_uuid", key)
+		h.redisClient.Set(ctx, key, sid, 0)
+	case announcementRegex.MatchString(key):
+		if _, ok := resp["type"]; !ok {
+			return
+		}
+		_type, ok := resp["type"].(string)
+		if !ok || !typeValueRegex.MatchString(_type) {
+			return
+		}
+		key = fmt.Sprintf("%s.type", key)
+		h.redisClient.Set(ctx, key, _type, 0)
+	case timetableRegex.MatchString(key):
+		h.redisClient.Set(ctx, key, string(respBytes), 0)
+	}
+	return
+}
+
+// delete all redis key associated with message payload using regexp
+func (h *_default) DeleteAssociatedRedisKey(msg *redis.Message) (err error) {
+	var payload, pattern = msg.Payload, ""
+	payload = paramStringRegex.ReplaceAllStringFunc(payload, func(param string) string {
+		param = strings.TrimSuffix(strings.TrimPrefix(param, "{"), "}")
+		value, err := h.redisClient.Get(ctx, param).Result()
+		if err != nil {
+			return "*"
+		}
+		return value
+	})
+
+	switch true {
+	case studentOutingsRegex.MatchString(payload):
+		// ex) student.student-123412341234.outings -> "students.student-123412341234.outings.start.*.count.*"
+		pattern = fmt.Sprintf("%s.start.*.count.*", payload)
+
+	case allStudentsOutingsRegex.MatchString(payload):
+		// ex) student.*.outings -> "students.*.outings.start.*.count.*"
+		pattern = fmt.Sprintf("%s", "students.*.outings.start.*.count.*")
+
+	case outingsFilterRegex.MatchString(payload):
+		// ex) outings.filter -> outings.filter.start.*.count.*.status.*.grade.*.group.*.floor.*
+		pattern = fmt.Sprintf("%s.start.*.count.*.status.*.grade.*.group.*.floor.*", payload)
+
+	case outingRegex.MatchString(payload):
+		// ex) outings.outing-123412341234 -> outings.outing-123412341234
+		pattern = fmt.Sprintf("%s", payload)
+
+	case outingCardRegex.MatchString(payload):
+		// ex) outings.outing-123412341234.card -> outings.outing-123412341234.card
+		pattern = fmt.Sprintf("%s", payload)
+
+	case schedulesRegex.MatchString(payload):
+		// ex) schedules -> schedules*
+		pattern = fmt.Sprintf("%s*", payload)
+
+	case announcementRegex.MatchString(payload):
+		// ex) announcement.announcement-123412341234 -> ''
+		pattern = fmt.Sprintf("%s", payload)
+
+	case announcementsRegex.MatchString(payload):
+		// ex) announcements.types.club -> announcements.types.club*
+		pattern = fmt.Sprintf("%s*", payload)
+
+	case announcementCheckRegex.MatchString(payload):
+		// ex) students.student-123412341234.announcement-check -> ''
+		pattern = fmt.Sprintf("%s", payload)
+
+	case myAnnouncementRegex.MatchString(payload):
+		// ex) writers.student-123412341234.announcements -> ''
+		pattern = fmt.Sprintf("%s", payload)
+
+	default:
+		err = errors.New(fmt.Sprintf("message does not match any regular expressions, msg payload: %s", payload))
+		return
+	}
+
+	num, err := h.deleteRedisKeyWithPattern(pattern)
+	if err != nil {
+		err = errors.New(fmt.Sprintf("some error occurs while delete redis key with pattern, pattern: %s, err: %v", pattern, err))
+		return
+	}
+
+	log.Infof("delete all redis key with pattern!, msg payload: %s pattern: %s, matched key num: %d", payload, pattern, num)
 	return 
 }
 
 // delete all redis key with pattern sent from parameter
-func (h *_default) deleteRedisKeyWithPattern(pattern string) (err error) {
+func (h *_default) deleteRedisKeyWithPattern(pattern string) (num int, err error) {
 	keys, err := h.redisClient.Keys(ctx, pattern).Result()
 	if err != nil {
 		err = errors.New(fmt.Sprintf("unable to execute redis KEYS cmd, err: %v", err))
+		return
 	}
+	num = len(keys)
 
 	for _, key := range keys {
-		if _, err := h.redisClient.Del(ctx, key).Result(); err != nil {
+		if _, err = h.redisClient.Del(ctx, key).Result(); err != nil {
 			err = errors.New(fmt.Sprintf("unable to execute redis DEL cmd, key: %s, err: %v", key, err))
+			return
 		}
 	}
 
-	log.Infof("delete all redis key with pattern!, pattern: %s, matched key num: %d", pattern, len(keys))
 	return
 }
-
-// sey new redis key with key name & value sent from redis pub/sub
-//func (h *_default) SetNewRedisKey(msg *redis.Message) (err error) {
-//
-//}

handler/default_outing.go

@@ -230,23 +230,6 @@ func (h *_default) GetStudentOutings(c *gin.Context) {
 		c.JSON(status, sendResp)
 		respBytes, _ := json.Marshal(sendResp)
 		entry.WithFields(logrus.Fields{"status": status, "code": _code, "message": msg, "response": string(respBytes), "request": string(reqBytes)}).Info()
-
-		//byteArr, _ := json.Marshal(sendResp)
-		//fmt.Println(string(byteArr))
-		//test1 := gin.H{}
-		//fmt.Println(json.Unmarshal(byteArr, &test1))
-		//fmt.Println(test1)
-		//redisSpan := h.tracer.StartSpan("GetNextServiceNode", opentracing.ChildOf(topSpan.Context()))
-		//setResult := h.redisClient.Set(context.Background(), "test", string(byteArr), time.Minute)
-		//redisSpan.SetTag("X-Request-Id", reqID).LogFields(log.String("ResultString", setResult.String()), log.Error(setResult.Err()))
-		//redisSpan.Finish()
-		//
-		//getStr, err := h.redisClient.Get(context.Background(), "test").Result()
-		//fmt.Println(getStr, err)
-		//test := gin.H{}
-		//fmt.Println(test)
-		//fmt.Println(json.Unmarshal([]byte(getStr), &test))
-		//fmt.Println(sendResp)
 	case http.StatusRequestTimeout, http.StatusInternalServerError, http.StatusServiceUnavailable:
 		c.JSON(int(rpcResp.Status), gin.H{"status": rpcResp.Status, "code": rpcResp.Code, "message": rpcResp.Msg})
 		entry.WithFields(logrus.Fields{"status": rpcResp.Status, "code": rpcResp.Code, "message": rpcResp.Msg, "request": string(reqBytes)}).Error()
@@ -353,6 +336,7 @@ func (h *_default) GetOutingInform(c *gin.Context) {
 			"end_time":         rpcResp.EndTime,
 			"outing_situation": rpcResp.OutingSituation,
 			"outing_status":    rpcResp.OutingStatus,
+			"student_uuid":     rpcResp.StudentUuid,
 		}
 		c.JSON(status, sendResp)
 		respBytes, _ := json.Marshal(sendResp)