func PostApplyScoreData(teamName string, ApplyScore *PostApplyScore) (*Status, error) {
	l.PutInfo(l.I_M_PostPage, teamName, ApplyScore)

	//更新情報をGlobal変数に格納する
	defer SetPlayerCol(ApplyScore.UserIds)

	AUserIdInTheTeam := teams[teamName].UserIds[0]
	if players[AUserIdInTheTeam].Apply != 0 {
		l.Output(
			logrus.Fields{
				"User Apply": l.Sprintf(players[AUserIdInTheTeam].Apply),
			},
			"Apply score is already registered",
			l.Debug,
		)
		return &Status{"already registered"}, nil
	}
	for playerIndex, userId := range ApplyScore.UserIds {

		findQuery := bson.M{"userid": userId}
		setQuery := bson.M{"$set": bson.M{"apply": ApplyScore.Apply[playerIndex]}}
		if err = UpdateMongoData("player", findQuery, setQuery); err != nil {
			l.PutErr(err, l.Trace(), l.E_M_Update, ApplyScore.Apply[playerIndex])
			return &Status{"failed"}, err
		}
	}

	return &Status{"success"}, nil
}
func RegisterThreadImg(r *RequestTakePictureStatus) (*RequestTakePictureStatus, error) {
	l.PutInfo(l.I_M_RegisterCol, r, nil)

	defer SetPlayerCol([]string{r.UserId})

	if len(r.ThreadId) == 0 {
		return nil, errors.New("there is not thread id")
	}

	if len(r.PhotoUrl) == 0 {
		return nil, errors.New("there is not pthoto url ")
	}

	threadFindQuery := bson.M{"threadid": r.ThreadId}
	threadSetQuery := bson.M{"$set": bson.M{"imgurl": r.PhotoUrl}}
	if err = UpdateMongoData("thread", threadFindQuery, threadSetQuery); err != nil {
		l.PutErr(err, l.Trace(), l.E_M_Update, r.PhotoUrl)
		return &RequestTakePictureStatus{Status: "failed"}, err
	}

	var photoKey string
	if r.Positive {
		photoKey = "positivephotourl"
	} else {
		photoKey = "negativephotourl"
	}
	playerFindQuery := bson.M{"userid": r.UserId}
	playerSetQuery := bson.M{"$set": bson.M{photoKey: r.PhotoUrl}}

	if err = UpdateMongoData("player", playerFindQuery, playerSetQuery); err != nil {
		l.PutErr(err, l.Trace(), l.E_M_Update, r.PhotoUrl)
		return &RequestTakePictureStatus{Status: "failed"}, err
	}

	SetAllThreadCol()
	thread := &Thread{
		ThreadId:  r.ThreadId,
		UserId:    threads[r.ThreadId].UserId,
		UserName:  threads[r.ThreadId].UserName,
		Msg:       threads[r.ThreadId].Msg,
		ImgUrl:    threads[r.ThreadId].ImgUrl,
		ColorCode: threads[r.ThreadId].ColorCode,
		Positive:  threads[r.ThreadId].Positive,
		CreatedAt: threads[r.ThreadId].CreatedAt,
	}

	ThreadChan <- thread

	requestTakePictureStatus, err := RequestTakePicture(r.TeamUserIds)
	if err != nil {
		return nil, err
	}

	if len(requestTakePictureStatus.ThreadId) != 0 {
		return requestTakePictureStatus, nil
	}

	return &RequestTakePictureStatus{Status: "success"}, nil

}
func RegisterFieldColData(date string, fieldCols []FieldCol) (*Status, error) {
	l.PutInfo(l.I_M_RegisterCol, date, fieldCols)

	defer SetAllFieldCol()

	db, session := mongoConn()
	fieldC := db.C("field")
	defer session.Close()

	var createCnt, updateCnt int
	for _, fieldCol := range fieldCols {
		if fieldCol.Hole > 18 || fieldCol.Hole < 0 {
			l.PutErr(nil, l.Trace(), l.E_WrongData, fieldCol.Hole)
			return &Status{"this is not hole number"}, err
		}

		fieldCol.Ignore = false
		fieldCol.Date = date
		findQuery := bson.M{"hole": fieldCol.Hole}

		change, err := fieldC.Upsert(findQuery, fieldCol)
		if err != nil {
			l.PutErr(err, l.Trace(), l.E_M_Upsert, fieldCol.Hole)
			return &Status{"can not upsert"}, err
		}
		if change.Updated == 0 {
			createCnt += 1
		} else {
			updateCnt += 1
		}
	}

	return &Status{"success"}, nil
}
func GetScoreEntrySheetPageData(teamName string, holeString string) (*ScoreEntrySheet, error) {
	l.PutInfo(l.I_M_GetPage, teamName, holeString)

	if len(holeString) == 0 {
		l.PutErr(nil, l.Trace(), l.E_Nil, teamName)
		return nil, errors.New("hole string is nil")
	}
	holeNum, _ := strconv.Atoi(holeString)
	holeIndex := holeNum - 1

	field := fields[holeNum]

	userIds := teams[teamName].UserIds
	member := make([]string, len(userIds))
	total := make([]int, len(userIds))
	putt := make([]int, len(userIds))
	for i, userId := range userIds {
		member[i] = users[userId].Name
		total[i] = players[userId].Score[holeIndex]["total"].(int)
		putt[i] = players[userId].Score[holeIndex]["putt"].(int)
	}

	scoreEntrySheet := ScoreEntrySheet{
		Team:    teamName,
		Hole:    holeNum,
		Member:  member,
		UserIds: userIds,
		Par:     field.Par,
		Yard:    field.Yard,
		Total:   total,
		Putt:    putt,
		Excnt:   excnt[teamName][holeNum],
	}
	return &scoreEntrySheet, nil
}
func GetLeadersBoardPageData() (*LeadersBoard, error) {
	l.PutInfo(l.I_M_GetPage, nil, nil)

	var leadersBoard LeadersBoard
	var userScore UserScore

	for _, player := range players {
		var totalPar, totalScore, passedHoleCnt int
		for holeIndex, playerScore := range player.Score {
			holeNum := holeIndex + 1
			if playerScore["total"].(int) != 0 {
				totalPar += fields[holeNum].Par
				total, _ := playerScore["total"].(int)
				totalScore += total
				passedHoleCnt += 1
			}
		}
		userScore = UserScore{
			Score: totalScore - totalPar,
			Total: totalScore,
			Name:  users[player.UserId].Name,
			Hole:  passedHoleCnt,
		}
		leadersBoard.Ranking = append(leadersBoard.Ranking, userScore)
	}
	sort.Sort(sortByScore(leadersBoard.Ranking))

	return &leadersBoard, nil
}
func UpsertNewTimeLine(thread *Thread) error {
	l.PutInfo(l.I_M_PostPage, thread, nil)

	//更新情報をGlobal変数に格納する
	defer SetAllThreadCol()

	defaultColor := "#c0c0c0"

	if len(thread.ThreadId) != 0 {
		l.PutErr(nil, l.Trace(), l.E_WrongData, thread)
		return errors.New("thread id exists")
	}

	db, session := mongoConn()
	threadCol := db.C("thread")
	defer session.Close()

	thread.ThreadId = make20lengthHashString()
	thread.CreatedAt = time.Now().Format(c.DatetimeFormat)
	thread.ColorCode = defaultColor
	if err = threadCol.Insert(thread); err != nil {
		l.PutErr(err, l.Trace(), l.E_M_Insert, thread)
		return err
	}

	ThreadChan <- thread

	return nil
}
func RegisterTeamColData(date string, teamCols []TeamCol) (*Status, error) {
	l.PutInfo(l.I_M_RegisterCol, date, teamCols)

	defer SetAllPlayerCol()
	defer SetAllTeamCol()

	db, session := mongoConn()
	playerC := db.C("player")
	teamC := db.C("team")
	defer session.Close()

	var OneBeforebyteOfA byte = 64
	alphabet := make([]byte, 1)
	alphabet[0] = OneBeforebyteOfA

	totalHoleNum := 18

	for _, teamCol := range teamCols {
		if len(teamCol.UserIds) == 0 {
			l.PutErr(nil, l.Trace(), l.E_Nil, teamCol)
			return &Status{"this team do not have user id"}, nil
		}

		alphabet[0] += 1
		teamCol.Name = string(alphabet)
		teamCol.Defined = false
		teamCol.Date = date

		if err := teamC.Insert(teamCol); err != nil {
			l.PutErr(err, l.Trace(), l.E_M_Insert, teamCol)
			return &Status{"can not insert"}, err
		}

		for _, userId := range teamCol.UserIds {
			scores := []bson.M{}
			for holeNum := 1; holeNum <= totalHoleNum; holeNum++ {
				score := bson.M{
					"hole":  holeNum,
					"putt":  0,
					"total": 0,
				}
				scores = append(scores, score)

			}

			player := PlayerCol{
				UserId: userId,
				Score:  scores,
				Date:   date,
			}
			if err := playerC.Insert(player); err != nil {
				l.PutErr(err, l.Trace(), l.E_M_Insert, player)
				return &Status{"can not insert"}, err
			}
		}
	}
	return &Status{"success"}, nil
}
func PostScoreEntrySheetPageData(teamName string, holeString string, teamScore *PostTeamScore) (*RequestTakePictureStatus, error) {
	l.PutInfo(l.I_M_PostPage, teamName, teamScore)

	userIds := teams[teamName].UserIds
	//更新情報をGlobal変数に格納する
	defer SetPlayerCol(userIds)

	if len(holeString) == 0 {
		l.PutErr(nil, l.Trace(), l.E_Nil, teamName)
		return &RequestTakePictureStatus{Status: "failed"}, errors.New("hole is not string")
	}

	holeNum, _ := strconv.Atoi(holeString)
	holeIndex := holeNum - 1
	holeIndexString := strconv.Itoa(holeIndex)

	if teamScore.Excnt != excnt[teamName][holeNum] {
		return &RequestTakePictureStatus{Status: "other updated"}, nil
	} else {
		excnt[teamName][holeNum]++
	}

	for playerIndex, userId := range teamScore.UserIds {
		total, putt := teamScore.Total[playerIndex], teamScore.Putt[playerIndex]

		findQuery := bson.M{"userid": userId}
		setQuery := bson.M{
			"$set": bson.M{
				"score." + holeIndexString + ".total": total,
				"score." + holeIndexString + ".putt":  putt,
			},
		}
		if err = UpdateMongoData("player", findQuery, setQuery); err != nil {
			l.PutErr(err, l.Trace(), l.E_M_Update, userId)
			return &RequestTakePictureStatus{Status: "failed update score"}, err
		}
	}
	//	Thread登録
	if err := RegisterThreadOfScore(holeString, teamScore); err != nil {
		l.PutErr(err, l.Trace(), l.E_M_RegisterThread, teamScore)
		return nil, err
	}

	//	チーム内に写真リクエストがあるか確認する
	requestTakePictureStatus, err := RequestTakePicture(userIds)
	if err != nil {
		l.PutErr(err, l.Trace(), l.E_M_SearchPhotoTask, userIds)
		return nil, err
	}

	return requestTakePictureStatus, nil
}
func PostLoginPageData(loginInfo *PostLogin) (*LoginStatus, error) {

	l.PutInfo(l.I_M_PostPage, loginInfo, nil)

	var admin bool
	_, ok := users[loginInfo.UserId]
	if ok {
		var teamName string
		for _, team := range teams {
			for _, userid := range team.UserIds {
				if userid == loginInfo.UserId {
					teamName = team.Name
				}
			}
		}

		l.Output(
			logrus.Fields{
				"User ID":   loginInfo.UserId,
				"User Name": users[loginInfo.UserId].Name,
			},
			"login success",
			l.Debug,
		)

		if players[loginInfo.UserId].Admin == true {
			admin = true
		} else {
			admin = false
		}
		loginStatus := &LoginStatus{
			Status:   "success",
			UserId:   loginInfo.UserId,
			UserName: users[loginInfo.UserId].Name,
			Team:     teamName,
			Admin:    admin,
		}
		return loginStatus, nil
	} else {
		l.Output(
			logrus.Fields{
				"User ID": loginInfo.UserId,
			},
			"login faild",
			l.Debug,
		)
		return &LoginStatus{Status: "failed"}, nil
	}
}
func GetIndexPageData() (*Index, error) {
	l.PutInfo(l.I_M_GetPage, nil, nil)

	var teamArray []string
	for name, _ := range teams {
		teamArray = append(teamArray, name)
	}

	sort.Strings(teamArray)
	index := &Index{
		Team:   teamArray,
		Length: len(teams),
	}
	return index, nil
}
func PostScoreViewSheetPageData(teamName string, definedTeam *PostDefinedTeam) (*Status, error) {
	l.PutInfo(l.I_M_PostPage, teamName, definedTeam)

	//更新情報をGlobal変数に格納する
	defer SetTeamCol(teamName)

	findQuery := bson.M{"name": teamName}
	setQuery := bson.M{"$set": bson.M{"defined": true}}
	if err = UpdateMongoData("team", findQuery, setQuery); err != nil {
		l.PutErr(err, l.Trace(), l.E_M_Update, teamName)
		return &Status{"failed"}, err
	}

	return &Status{"success"}, nil
}
func GetTimeLinePageData() (*TimeLine, error) {
	l.PutInfo(l.I_M_GetPage, nil, nil)

	var timeLine TimeLine
	var tmpThreads []Thread

	threadsKeys := sortByDate{}
	for k, v := range threads {
		t := ThreadDate{k, v.CreatedAt}
		threadsKeys = append(threadsKeys, t)
	}

	sort.Sort(threadsKeys)

	for _, threadKey := range threadsKeys {
		var tmpThread Thread
		var tmpReactions []Reaction
		threadId := threadKey.ThreadId
		if len(threads[threadId].ImgUrl) == 0 {
			continue
		}
		for _, reaction := range threads[threadId].Reactions {
			var tmpReaction Reaction
			tmpReaction.UserId = reaction["userid"].(string)
			tmpReaction.UserName = reaction["username"].(string)
			tmpReaction.ContentType = reaction["contenttype"].(int)
			tmpReaction.Content = reaction["content"].(string)
			tmpReaction.DateTime = reaction["datetime"].(string)
			tmpReactions = append(tmpReactions, tmpReaction)
		}
		tmpThread.ThreadId = threadId
		tmpThread.UserId = threads[threadId].UserId
		tmpThread.UserName = threads[threadId].UserName
		tmpThread.Msg = threads[threadId].Msg
		tmpThread.ImgUrl = threads[threadId].ImgUrl
		tmpThread.ColorCode = threads[threadId].ColorCode
		tmpThread.Positive = threads[threadId].Positive
		tmpThread.CreatedAt = threads[threadId].CreatedAt
		tmpThread.Reactions = tmpReactions
		tmpThreads = append(tmpThreads, tmpThread)
	}

	timeLine.Threads = tmpThreads

	return &timeLine, nil
}
func RegisterUserColData(userCols []UserCol) (*Status, error) {
	l.PutInfo(l.I_M_RegisterCol, userCols, nil)

	defer SetAllUserCol()

	db, session := mongoConn()
	col := db.C("user")
	defer session.Close()

	var createCnt, updateCnt int

	for _, userCol := range userCols {
		if len(userCol.Name) == 0 {
			l.PutErr(nil, l.Trace(), l.E_Nil, userCol.Name)
			return &Status{"this user do not have name"}, nil
		}
		if len(userCol.UserId) == 0 {
			userCol.UserId = make20lengthHashString()
		}
		if len(userCol.CreatedAt) == 0 {
			userCol.CreatedAt = time.Now().Format(c.DatetimeFormat)
		}
		findQuery := bson.M{"userid": userCol.UserId}
		change, err := col.Upsert(findQuery, userCol)
		if err != nil {
			l.PutErr(err, l.Trace(), l.E_M_Upsert, userCol.UserId)
			return &Status{"can not upsert"}, err
		}
		if change.Updated == 0 {
			createCnt += 1
		} else {
			updateCnt += 1
		}
	}

	return &Status{"success"}, nil
}
func GetScoreViewSheetPageData(teamName string) (*ScoreViewSheet, error) {
	l.PutInfo(l.I_M_GetPage, teamName, nil)

	userIds := teams[teamName].UserIds
	member := make([]string, len(userIds))
	apply := make([]int, len(userIds))
	totalScore := make([]int, len(userIds))
	totalPutt := make([]int, len(userIds))
	outTotalScore := make([]int, len(userIds))
	outTotalPutt := make([]int, len(userIds))
	inTotalScore := make([]int, len(userIds))
	inTotalPutt := make([]int, len(userIds))
	holes := make([]Hole, len(fields))

	var totalPar int
	var outTotalPar int
	var inTotalPar int
	for holeNum, field := range fields {
		holeIndex := holeNum - 1

		totalPar += field.Par
		if holeNum < 10 {
			outTotalPar += field.Par
		} else {
			inTotalPar += field.Par
		}
		score := make([]int, len(userIds))
		for playerIndex, userId := range userIds {
			scoreAHole := players[userId].Score[holeIndex]["total"].(int)
			puttAHole := players[userId].Score[holeIndex]["putt"].(int)

			score[playerIndex] = scoreAHole
			if holeNum < 10 {
				outTotalScore[playerIndex] += scoreAHole
				outTotalPutt[playerIndex] += puttAHole
			} else {
				inTotalScore[playerIndex] += scoreAHole
				inTotalPutt[playerIndex] += puttAHole
			}
			totalScore[playerIndex] += scoreAHole
			totalPutt[playerIndex] += puttAHole
			if holeIndex == 0 {
				member[playerIndex] = users[userId].Name
				apply[playerIndex] = players[userId].Apply
			}
		}
		holes[holeIndex] = Hole{
			Hole:  holeNum,
			Par:   field.Par,
			Yard:  field.Yard,
			Score: score,
		}
	}
	outSum := Sum{
		Par:   outTotalPar,
		Score: outTotalScore,
		Putt:  outTotalPutt,
	}
	inSum := Sum{
		Par:   inTotalPar,
		Score: inTotalScore,
		Putt:  inTotalPutt,
	}
	sum := Sum{
		Par:   totalPar,
		Score: totalScore,
		Putt:  totalPutt,
	}
	scoreViewSheet := ScoreViewSheet{
		Team:    teamName,
		Member:  member,
		UserIds: userIds,
		Apply:   apply,
		Hole:    holes,
		OutSum:  outSum,
		InSum:   inSum,
		Sum:     sum,
		Defined: teams[teamName].Defined,
	}

	return &scoreViewSheet, nil
}
func GetEntireScorePageData() (*EntireScore, error) {
	l.PutInfo(l.I_M_GetPage, nil, nil)

	//rows[*][0] ホール rows[*][1] パー rows[*][2->n] PlayerName
	//rows[0] チーム名
	//rows[1] プレーヤー名
	//rows[2] IN
	//rows[3] ホール1
	//rows[4] ホール2
	//rows[5] ホール3
	//rows[6] ホール4
	//rows[7] ホール5
	//rows[8] ホール6
	//rows[9] ホール7
	//rows[10] ホール8
	//rows[11] ホール9
	//rows[12] OUT
	//rows[13] ホール1
	//rows[14] ホール2
	//rows[15] ホール3
	//rows[16] ホール4
	//rows[17] ホール5
	//rows[18] ホール6
	//rows[19] ホール7
	//rows[20] ホール8
	//rows[21] ホール9
	//rows[22] Gross
	//rows[23] Net
	//rows[24] 申請
	//rows[25] スコア差
	//rows[26] 順位
	rowSize := 27
	columnSize := len(players) + 2

	rows := make([][]string, rowSize)
	for i := 0; i < rowSize; i++ {
		if i == 0 {
			rows[i] = make([]string, len(teams)*2)
		} else {
			rows[i] = make([]string, columnSize)
		}
	}

	rows[1][0], rows[1][1] = "ホール", "パー"
	rows[2][0], rows[2][1] = "OUT", "ー"
	rows[12][0], rows[12][1] = "IN", "ー"
	rows[22][0], rows[22][1] = "Gross", "ー"
	rows[23][0], rows[23][1] = "Net", "ー"
	rows[24][0], rows[24][1] = "申請", "ー"
	rows[25][0], rows[25][1] = "スコア差", "ー"
	rows[26][0], rows[26][1] = "順位", "ー"

	var passedPlayerNum int
	var teamIndex int
	var headingColumnNum = 2
	var inColumNum = 1
	var outColumNum = 1
	var userIdArrayOrder []string

	var keys []string
	for k := range teams {
		keys = append(keys, k)
	}
	sort.Strings(keys)

	finalRankings := []FinalRanking{}
	for _, teamName := range keys {
		rows[0][teamIndex*2] = strconv.Itoa(len(teams[teamName].UserIds))
		rows[0][teamIndex*2+1] = "TEAM " + teamName
		userIds := teams[teamName].UserIds
		for playerIndex, userId := range userIds {
			userIdArrayOrder = append(userIdArrayOrder, userId)
			var gross int
			var net int
			userDataIndex := playerIndex + passedPlayerNum + headingColumnNum
			rows[1][userDataIndex] = users[userId].Name

			for holeNum, field := range fields {
				holeIndex := holeNum - 1
				halfHoleNum := len(fields) / 2
				holeRowNum := holeIndex + headingColumnNum + inColumNum
				inOutBorderline := headingColumnNum + inColumNum + halfHoleNum
				if holeRowNum >= inOutBorderline {
					holeRowNum = holeRowNum + outColumNum
				}
				if playerIndex == 0 {
					if holeNum > halfHoleNum {
						holeNum = holeNum - halfHoleNum
					}
					if field.Ignore {
						rows[holeRowNum][0] = "-i" + strconv.Itoa(holeNum)
					}
					rows[holeRowNum][0] = strconv.Itoa(holeNum)
					rows[holeRowNum][1] = strconv.Itoa(field.Par)
				}
				playerTotal := players[userId].Score[holeIndex]["total"].(int)
				gross += playerTotal
				if field.Ignore {
					net += field.Par
				} else {
					net += playerTotal
				}
				rows[holeRowNum][userDataIndex] = strconv.Itoa(playerTotal)
			}
			rows[22][userDataIndex] = strconv.Itoa(gross)
			rows[23][userDataIndex] = strconv.Itoa(net)
			rows[24][userDataIndex] = strconv.Itoa(players[userId].Apply)
			scoreDiff := players[userId].Apply - net
			if scoreDiff < 0 {
				scoreDiff = scoreDiff * -1
			}
			rows[25][userDataIndex] = strconv.Itoa(scoreDiff)
			finalRanking := FinalRanking{
				UserId:    userId,
				ScoreDiff: scoreDiff,
				Gross:     gross,
			}
			finalRankings = append(finalRankings, finalRanking)
		}
		passedPlayerNum += len(userIds)
		teamIndex++
	}

	sort.Sort(sortByRank(finalRankings))
	for userIdIndex, userId := range userIdArrayOrder {
		userDataIndex := userIdIndex + 2
		for rankingIndex, ranking := range finalRankings {
			if userId != ranking.UserId {
				continue
			}
			rows[26][userDataIndex] = strconv.Itoa(rankingIndex + 1)
		}
	}

	EntireScore := EntireScore{
		Rows: rows,
	}

	return &EntireScore, nil
}
func UpdateExistingTimeLine(thread *Thread) (*Thread, error) {
	l.PutInfo(l.I_M_PostPage, thread, nil)

	targetThreadId := thread.ThreadId
	//更新情報をGlobal変数に格納する
	defer SetAllThreadCol()

	colorFeeling := make(map[string]string)
	colorFeeling["default"] = "#c0c0c0"
	colorFeeling["angry"] = "#ff7f7f"
	colorFeeling["great"] = "#ffff7f"
	colorFeeling["sad"] = "#7fbfff"
	colorFeeling["vexing"] = "#7fff7f"

	if len(targetThreadId) == 0 {
		l.PutErr(nil, l.Trace(), l.E_Nil, thread)
		return nil, errors.New("thread id do not exist")
	}

	if len(thread.ColorCode) == 0 {
		l.PutErr(err, l.Trace(), l.E_Nil, thread.ColorCode)
		return nil, errors.New("current colorCode do not contain in posted thread")
	}
	if len(thread.Reactions) > 1 {
		l.PutErr(err, l.Trace(), l.E_TooManyData, thread.Reactions)
		return nil, errors.New("reactions is not 1")
	}

	currentFeeling := ""
	currentColor := threads[targetThreadId].ColorCode
	postedFeeling := getFeelingFromAWSUrl(thread.Reactions[0].Content)
	postedColor := colorFeeling[postedFeeling]

	for feeling, code := range colorFeeling {
		if currentColor == code {
			currentFeeling = feeling
		}
	}

	thread.Reactions[0].DateTime = time.Now().Format(c.DatetimeFormat)
	findQuery := bson.M{"threadid": targetThreadId}
	pushQuery := bson.M{"$push": bson.M{"reactions": thread.Reactions[0]}}
	if err = UpdateMongoData("thread", findQuery, pushQuery); err != nil {
		l.PutErr(err, l.Trace(), l.E_M_Update, thread.Reactions[0])
		return nil, err
	}

	//投稿された感情と、現在の感情に相違がある場合
	if currentFeeling != postedFeeling {
		var setColor string
		var currentFeelingCount, postedFeelingCount int

		if currentColor == colorFeeling["default"] {
			setColor = postedColor
		} else {

			//直前の更新を反映させる
			SetAllThreadCol()

			for _, r := range threads[targetThreadId].Reactions {
				switch getFeelingFromAWSUrl(r["content"].(string)) {
				case currentFeeling:
					currentFeelingCount++
				case postedFeeling:
					postedFeelingCount++
				}
			}

			if currentFeelingCount >= postedFeelingCount {
				setColor = currentColor
			} else {
				setColor = postedColor
			}
		}

		setQuery := bson.M{"$set": bson.M{"colorcode": setColor}}

		if err = UpdateMongoData("thread", findQuery, setQuery); err != nil {
			l.PutErr(err, l.Trace(), l.E_M_Update, setColor)
			return nil, err
		}
		thread.ColorCode = setColor
	}
	return thread, nil
}