アンケート対象者&管理者のグループ管理

controller/adapter.go

@@ -68,7 +68,7 @@ func convertResSharedTo(resSharedTo string) openapi.ResShareType {
 func createUsersAndGroups(users []string, groups uuid.UUIDs) openapi.UsersAndGroups {
 	res := openapi.UsersAndGroups{
 		Users:  users,
-		Groups: groups.Strings(),
+		Groups: groups,
 	}
 	return res
 }
@@ -157,21 +157,14 @@ func convertQuestions(questions []model.Questions) ([]openapi.Question, error) {
 	return res, nil
 }
 
-// func convertRespondents(respondents []model.Respondents) []string {
-// 	res := []string{}
-// 	for _, respondent := range respondents {
-// 		res = append(res, respondent.UserTraqid)
-// 	}
-// 	return res
-// }
-
-func questionnaire2QuestionnaireDetail(questionnaires model.Questionnaires, adminUsers []string, adminGroups []uuid.UUID, targetUsers []string, targetGroups []uuid.UUID, respondents []string) (openapi.QuestionnaireDetail, error) {
+func questionnaire2QuestionnaireDetail(questionnaires model.Questionnaires, admins []string, adminUsers []string, adminGroups []uuid.UUID, targets []string, targetUsers []string, targetGroups []uuid.UUID, respondents []string) (openapi.QuestionnaireDetail, error) {
 	questions, err := convertQuestions(questionnaires.Questions)
 	if err != nil {
 		return openapi.QuestionnaireDetail{}, err
 	}
 	res := openapi.QuestionnaireDetail{
-		Admins:                   createUsersAndGroups(adminUsers, adminGroups),
+		Admin:                    createUsersAndGroups(adminUsers, adminGroups),
+		Admins:                   admins,
 		CreatedAt:                questionnaires.CreatedAt,
 		Description:              questionnaires.Description,
 		IsDuplicateAnswerAllowed: questionnaires.IsDuplicateAnswerAllowed,
@@ -183,7 +176,8 @@ func questionnaire2QuestionnaireDetail(questionnaires model.Questionnaires, admi
 		Respondents:              respondents,
 		ResponseDueDateTime:      &questionnaires.ResTimeLimit.Time,
 		ResponseViewableBy:       convertResSharedTo(questionnaires.ResSharedTo),
-		Targets:                  createUsersAndGroups(targetUsers, targetGroups),
+		Target:                   createUsersAndGroups(targetUsers, targetGroups),
+		Targets:                  targets,
 		Title:                    questionnaires.Title,
 	}
 	return res, nil
@@ -238,7 +232,7 @@ func respondentDetail2Response(ctx echo.Context, respondentDetail model.Responde
 		case "MultipleChoice":
 			if r.Body.Valid {
 				answer := []int{}
-				questionnaire, _, _, _, _, _, err := model.NewQuestionnaire().GetQuestionnaireInfo(ctx.Request().Context(), r.QuestionID)
+				questionnaire, _, _, _, _, _, _, _, err := model.NewQuestionnaire().GetQuestionnaireInfo(ctx.Request().Context(), r.QuestionID)
 				if err != nil {
 					ctx.Logger().Errorf("failed to get questionnaire info: %+v", err)
 					return openapi.Response{}, err
@@ -262,7 +256,7 @@ func respondentDetail2Response(ctx echo.Context, respondentDetail model.Responde
 			}
 		case "Checkbox":
 			if r.Body.Valid {
-				questionnaire, _, _, _, _, _, err := model.NewQuestionnaire().GetQuestionnaireInfo(ctx.Request().Context(), r.QuestionID)
+				questionnaire, _, _, _, _, _, _, _, err := model.NewQuestionnaire().GetQuestionnaireInfo(ctx.Request().Context(), r.QuestionID)
 				if err != nil {
 					ctx.Logger().Errorf("failed to get questionnaire info: %+v", err)
 					return openapi.Response{}, err

controller/middleware.go

@@ -137,7 +137,7 @@ func (m Middleware) QuestionnaireReadAuthenticate(next echo.HandlerFunc) echo.Ha
 		}
 
 		// 公開されたらOK
-		questionnaire, _, _, _, _, _, err := m.IQuestionnaire.GetQuestionnaireInfo(c.Request().Context(), questionnaireID)
+		questionnaire, _, _, _, _, _, _, _, err := m.IQuestionnaire.GetQuestionnaireInfo(c.Request().Context(), questionnaireID)
 		if errors.Is(err, model.ErrRecordNotFound) {
 			c.Logger().Infof("questionnaire not found: %+v", err)
 			return echo.NewHTTPError(http.StatusNotFound, fmt.Errorf("questionnaire not found:%d", questionnaireID))

controller/questionnaire.go

@@ -22,38 +22,53 @@
 	model.IQuestionnaire
 	model.ITarget
 	model.ITargetGroup
+	model.ITargetUser
 	model.IAdministrator
 	model.IAdministratorGroup
+	model.IAdministratorUser
 	model.IQuestion
 	model.IOption
 	model.IScaleLabel
 	model.IValidation
 	model.ITransaction
+	model.IRespondent
 	traq.IWebhook
-	Response
+	*Response
 }
 
 func NewQuestionnaire(
 	questionnaire model.IQuestionnaire,
 	target model.ITarget,
+	targetGroup model.ITargetGroup,
+	targetUser model.ITargetUser,
 	administrator model.IAdministrator,
+	administratorGroup model.IAdministratorGroup,
+	administratorUser model.IAdministratorUser,
 	question model.IQuestion,
 	option model.IOption,
 	scaleLabel model.IScaleLabel,
 	validation model.IValidation,
 	transaction model.ITransaction,
+	respodent model.IRespondent,
 	webhook traq.IWebhook,
+	response *Response,
 ) *Questionnaire {
 	return &Questionnaire{
-		IQuestionnaire: questionnaire,
-		ITarget:        target,
-		IAdministrator: administrator,
-		IQuestion:      question,
-		IOption:        option,
-		IScaleLabel:    scaleLabel,
-		IValidation:    validation,
-		ITransaction:   transaction,
-		IWebhook:       webhook,
+		IQuestionnaire:      questionnaire,
+		ITarget:             target,
+		ITargetGroup:        targetGroup,
+		ITargetUser:         targetUser,
+		IAdministrator:      administrator,
+		IAdministratorGroup: administratorGroup,
+		IAdministratorUser:  administratorUser,
+		IQuestion:           question,
+		IOption:             option,
+		IScaleLabel:         scaleLabel,
+		IValidation:         validation,
+		ITransaction:        transaction,
+		IRespondent:         respodent,
+		IWebhook:            webhook,
+		Response:            response,
 	}
 }
 
@@ -93,7 +108,7 @@
 		hasMyResponse := false
 		respondendDateTimeByMe := null.Time{}
 
 		myRespondents, err := q.GetRespondentInfos(ctx.Request().Context(), userID, questionnaire.ID)
 		if err != nil {
 			return res, err
 		}
@@ -132,47 +147,57 @@
 	questionnaireID := 0
 
 	err := q.ITransaction.Do(c.Request().Context(), nil, func(ctx context.Context) error {
 		questionnaireID, err := q.InsertQuestionnaire(ctx, params.Title, params.Description, responseDueDateTime, convertResponseViewableBy(params.ResponseViewableBy), params.IsPublished, params.IsAnonymous, params.IsDuplicateAnswerAllowed)
 		if err != nil {
 			c.Logger().Errorf("failed to insert questionnaire: %+v", err)
 			return err
 		}
-		allTargetUsers, err := rollOutUsersAndGroups(params.Targets.Users, params.Targets.Groups)
+		allTargetUsers, err := rollOutUsersAndGroups(params.Target.Users, params.Target.Groups)
 		if err != nil {
 			c.Logger().Errorf("failed to roll out users and groups: %+v", err)
 			return err
 		}
-		targetGroupNames, err := uuid2GroupNames(params.Targets.Groups)
+		targetGroupNames, err := uuid2GroupNames(params.Target.Groups)
 		if err != nil {
 			c.Logger().Errorf("failed to get group names: %+v", err)
 			return err
 		}
 		err = q.InsertTargets(ctx, questionnaireID, allTargetUsers)
 		if err != nil {
 			c.Logger().Errorf("failed to insert targets: %+v", err)
 			return err
 		}
-		err = q.InsertTargetGroups(ctx, questionnaireID, params.Targets.Groups)
+		err = q.InsertTargetUsers(ctx, questionnaireID, params.Target.Users)
 		if err != nil {
 			c.Logger().Errorf("failed to insert target groups: %+v", err)
 			return err
 		}
-		allAdminUsers, err := rollOutUsersAndGroups(params.Admins.Users, params.Admins.Groups)
+		err = q.InsertTargetGroups(ctx, questionnaireID, params.Target.Groups)
+		if err != nil {
+			c.Logger().Errorf("failed to insert target groups: %+v", err)
+			return err
+		}
+		allAdminUsers, err := rollOutUsersAndGroups(params.Admin.Users, params.Admin.Groups)
 		if err != nil {
 			c.Logger().Errorf("failed to roll out administrators: %+v", err)
 			return err
 		}
-		adminGroupNames, err := uuid2GroupNames(params.Admins.Groups)
+		adminGroupNames, err := uuid2GroupNames(params.Admin.Groups)
 		if err != nil {
 			c.Logger().Errorf("failed to get group names: %+v", err)
 			return err
 		}
 		err = q.InsertAdministrators(ctx, questionnaireID, allAdminUsers)
 		if err != nil {
 			c.Logger().Errorf("failed to insert administrators: %+v", err)
 			return err
 		}
-		err = q.InsertAdministratorGroups(ctx, questionnaireID, params.Admins.Groups)
+		err = q.InsertAdministratorUsers(ctx, questionnaireID, params.Admin.Users)
+		if err != nil {
+			c.Logger().Errorf("failed to insert administrator users: %+v", err)
+			return err
+		}
+		err = q.InsertAdministratorGroups(ctx, questionnaireID, params.Admin.Groups)
 		if err != nil {
 			c.Logger().Errorf("failed to insert administrator groups: %+v", err)
 			return err
@@ -190,7 +215,7 @@
 				return err
 			}
 			questionType := questionParsed["question_type"].(string)
 			_, err = q.InsertQuestion(ctx, questionnaireID, 1, questoinNum+1, questionType, question.Body, question.IsRequired)
 			if err != nil {
 				c.Logger().Errorf("failed to insert question: %+v", err)
 				return err
@@ -327,25 +352,25 @@
 		}
 	}
 
-	questionnaireInfo, targets, targetGroups, admins, adminGroups, respondents, err := q.GetQuestionnaireInfo(c.Request().Context(), questionnaireID)
+	questionnaireInfo, targets, targetUsers, targetGroups, admins, adminUsers, adminGroups, respondents, err := q.GetQuestionnaireInfo(c.Request().Context(), questionnaireID)
 	if err != nil {
 		c.Logger().Errorf("failed to get questionnaire info: %+v", err)
 		return openapi.QuestionnaireDetail{}, echo.NewHTTPError(http.StatusInternalServerError, "failed to get questionnaire info")
 	}
 
-	questionnaireDetail, err := questionnaire2QuestionnaireDetail(*questionnaireInfo, admins, adminGroups, targets, targetGroups, respondents)
+	questionnaireDetail, err := questionnaire2QuestionnaireDetail(*questionnaireInfo, admins, adminUsers, adminGroups, targets, targetUsers, targetGroups, respondents)
 	if err != nil {
 		c.Logger().Errorf("failed to convert questionnaire to questionnaire detail: %+v", err)
 		return openapi.QuestionnaireDetail{}, echo.NewHTTPError(http.StatusInternalServerError, "failed to convert questionnaire to questionnaire detail")
 	}
 	return questionnaireDetail, nil
 }
 func (q Questionnaire) GetQuestionnaire(ctx echo.Context, questionnaireID int) (openapi.QuestionnaireDetail, error) {
-	questionnaireInfo, targets, targetGroups, admins, adminGroups, respondents, err := q.GetQuestionnaireInfo(ctx.Request().Context(), questionnaireID)
+	questionnaireInfo, targets, targetUsers, targetGroups, admins, adminUsers, adminGroups, respondents, err := q.GetQuestionnaireInfo(ctx.Request().Context(), questionnaireID)
 	if err != nil {
 		return openapi.QuestionnaireDetail{}, err
 	}
-	questionnaireDetail, err := questionnaire2QuestionnaireDetail(*questionnaireInfo, admins, adminGroups, targets, targetGroups, respondents)
+	questionnaireDetail, err := questionnaire2QuestionnaireDetail(*questionnaireInfo, admins, adminUsers, adminGroups, targets, targetUsers, targetGroups, respondents)
 	if err != nil {
 		ctx.Logger().Errorf("failed to convert questionnaire to questionnaire detail: %+v", err)
 		return openapi.QuestionnaireDetail{}, echo.NewHTTPError(http.StatusInternalServerError, "failed to convert questionnaire to questionnaire detail")
@@ -376,55 +401,69 @@
 			c.Logger().Errorf("failed to update questionnaire: %+v", err)
 			return err
 		}
-		err = q.DeleteTargets(ctx, questionnaireID)
-		if err != nil {
-			c.Logger().Errorf("failed to delete targets: %+v", err)
-			return err
-		}
-		err = q.DeleteTargetGroups(ctx, questionnaireID)
-		if err != nil {
-			c.Logger().Errorf("failed to delete target groups: %+v", err)
-			return err
-		}
-		allTargetUsers, err := rollOutUsersAndGroups(params.Targets.Users, params.Targets.Groups)
-		if err != nil {
-			c.Logger().Errorf("failed to roll out users and groups: %+v", err)
-			return err
-		}
-		err = q.InsertTargets(ctx, questionnaireID, allTargetUsers)
-		if err != nil {
-			c.Logger().Errorf("failed to insert targets: %+v", err)
-			return err
-		}
-		err = q.InsertTargetGroups(ctx, questionnaireID, params.Targets.Groups)
-		if err != nil {
-			c.Logger().Errorf("failed to insert target groups: %+v", err)
-			return err
-		}
-		err = q.DeleteAdministrators(ctx, questionnaireID)
-		if err != nil {
-			c.Logger().Errorf("failed to delete administrators: %+v", err)
-			return err
-		}
-		err = q.DeleteAdministratorGroups(ctx, questionnaireID)
-		if err != nil {
-			c.Logger().Errorf("failed to delete administrator groups: %+v", err)
-			return err
-		}
-		allAdminUsers, err := rollOutUsersAndGroups(params.Admins.Users, params.Admins.Groups)
-		if err != nil {
-			c.Logger().Errorf("failed to roll out administrators: %+v", err)
-			return err
-		}
-		err = q.InsertAdministrators(ctx, questionnaireID, allAdminUsers)
-		if err != nil {
-			c.Logger().Errorf("failed to insert administrators: %+v", err)
-			return err
+		if params.Target != nil {
+			err = q.DeleteTargets(ctx, questionnaireID)
+			if err != nil {
+				c.Logger().Errorf("failed to delete targets: %+v", err)
+				return err
+			}
+			err = q.DeleteTargetGroups(ctx, questionnaireID)
+			if err != nil {
+				c.Logger().Errorf("failed to delete target groups: %+v", err)
+				return err
+			}
+			allTargetUsers, err := rollOutUsersAndGroups((*params.Target).Users, params.Target.Groups)
+			if err != nil {
+				c.Logger().Errorf("failed to roll out users and groups: %+v", err)
+				return err
+			}
+			err = q.InsertTargets(ctx, questionnaireID, allTargetUsers)
+			if err != nil {
+				c.Logger().Errorf("failed to insert targets: %+v", err)
+				return err
+			}
+			err = q.InsertTargetUsers(ctx, questionnaireID, params.Target.Users)
+			if err != nil {
+				c.Logger().Errorf("failed to insert target users: %+v", err)
+				return err
+			}
+			err = q.InsertTargetGroups(ctx, questionnaireID, params.Target.Groups)
+			if err != nil {
+				c.Logger().Errorf("failed to insert target groups: %+v", err)
+				return err
+			}
 		}
-		err = q.InsertAdministratorGroups(ctx, questionnaireID, params.Admins.Groups)
-		if err != nil {
-			c.Logger().Errorf("failed to insert administrator groups: %+v", err)
-			return err
+		if params.Admin != nil {
+			err = q.DeleteAdministrators(ctx, questionnaireID)
+			if err != nil {
+				c.Logger().Errorf("failed to delete administrators: %+v", err)
+				return err
+			}
+			err = q.DeleteAdministratorGroups(ctx, questionnaireID)
+			if err != nil {
+				c.Logger().Errorf("failed to delete administrator groups: %+v", err)
+				return err
+			}
+			allAdminUsers, err := rollOutUsersAndGroups(params.Admin.Users, params.Admin.Groups)
+			if err != nil {
+				c.Logger().Errorf("failed to roll out administrators: %+v", err)
+				return err
+			}
+			err = q.InsertAdministrators(ctx, questionnaireID, allAdminUsers)
+			if err != nil {
+				c.Logger().Errorf("failed to insert administrators: %+v", err)
+				return err
+			}
+			err = q.InsertAdministratorUsers(ctx, questionnaireID, params.Admin.Users)
+			if err != nil {
+				c.Logger().Errorf("failed to insert administrator users: %+v", err)
+				return err
+			}
+			err = q.InsertAdministratorGroups(ctx, questionnaireID, params.Admin.Groups)
+			if err != nil {
+				c.Logger().Errorf("failed to insert administrator groups: %+v", err)
+				return err
+			}
 		}
 		for questoinNum, question := range params.Questions {
 			b, err := question.MarshalJSON()
@@ -648,7 +687,7 @@
 			return nil
 		}
 
-		questionnaire, _, _, _, _, _, err := q.GetQuestionnaireInfo(c.Request().Context(), questionnaireID)
+		questionnaire, _, _, _, _, _, _, _, err := q.GetQuestionnaireInfo(c.Request().Context(), questionnaireID)
 		if err != nil {
 			if errors.Is(err, model.ErrRecordNotFound) {
 				c.Logger().Info("questionnaire not found")

controller/reminder.go

@@ -101,7 +101,7 @@ func (jq *JobQueue) CheckRemindStatus(questionnaireID int) (bool, error) {
 func reminderAction(questionnaireID int, leftTimeText string) error {
 	ctx := context.Background()
 	q := model.Questionnaire{}
-	questionnaire, _, _, administrators, _, respondants, err := q.GetQuestionnaireInfo(ctx, questionnaireID)
+	questionnaire, _, _, _, administrators, _, _, respondants, err := q.GetQuestionnaireInfo(ctx, questionnaireID)
 	if err != nil {
 		return err
 	}

controller/response.go

@@ -59,7 +59,7 @@ func (r Response) GetMyResponses(ctx echo.Context, params openapi.GetMyResponses
 			return openapi.ResponsesWithQuestionnaireInfo{}, echo.NewHTTPError(http.StatusInternalServerError, fmt.Errorf("failed to get respondent detail: %w", err))
 		}
 
-		questionnaire, _, _, _, _, _, err := r.IQuestionnaire.GetQuestionnaireInfo(ctx.Request().Context(), responseDetail.QuestionnaireID)
+		questionnaire, _, _, _, _, _, _, _, err := r.IQuestionnaire.GetQuestionnaireInfo(ctx.Request().Context(), responseDetail.QuestionnaireID)
 		if err != nil {
 			ctx.Logger().Errorf("failed to get questionnaire info: %+v", err)
 			return openapi.ResponsesWithQuestionnaireInfo{}, echo.NewHTTPError(http.StatusInternalServerError, fmt.Errorf("failed to get questionnaire info: %w", err))