return false;

         }

         orgMapper.updateAssignments(org.getId(), contact.getId(),

         return true;

     }

 }

 package kr.itn.itnhub.org;

 /**

  * (부분 갱신이 아니다 - PUT 하나가 항상 현재 상태 전체를 반영한다).

  */

 public record AssignmentRequest(

         Long applicantContactId,

         Long mjContactId,

         Long lawyerContactId,

         String lawyerAssignedDate) {

 }

         OrgStatus status,

         Contact applicant,

         Contact mj,

         Contact lawyer,

         String lawyerAssignedDate,

         String channelIdMj,

                 org.getStatus(),

                 org.getApplicant(),

                 org.getMj(),

                 org.getLawyer(),

                 org.getLawyerAssignedDate(),

                 org.getChannelIdMj(),

     private String channelSlug;

     private Long applicantContactId;

     private Long mjContactId;

     private Long lawyerContactId;

     private String lawyerAssignedDate;

     private String channelIdMj;

     /** findAll/findById가 contact 테이블과 조인해 채워준다. 시드/upsert 경로에서는 비어 있다. */

     private Contact applicant;

     private Contact mj;

     private Contact lawyer;

     /**

     public Long getMjContactId() { return mjContactId; }

     public void setMjContactId(Long mjContactId) { this.mjContactId = mjContactId; }

     public Long getLawyerContactId() { return lawyerContactId; }

     public void setLawyerContactId(Long lawyerContactId) { this.lawyerContactId = lawyerContactId; }

     public Contact getMj() { return mj; }

     public void setMj(Contact mj) { this.mj = mj; }

     public Contact getLawyer() { return lawyer; }

     public void setLawyer(Contact lawyer) { this.lawyer = lawyer; }

 }

     int updateAssignments(@Param("id") Long id,

                           @Param("applicantContactId") Long applicantContactId,

                           @Param("mjContactId") Long mjContactId,

                           @Param("lawyerContactId") Long lawyerContactId,

                           @Param("lawyerAssignedDate") String lawyerAssignedDate);

     }

     /**

      * 배정일을 통째로 덮어쓴다(부분 갱신이 아니다).

      */

     @Transactional

         validateAssignment(request.applicantContactId(), "APPLICANT", "신청기관 담당자");

         validateAssignment(request.mjContactId(), "MJ", "문정원 담당자");

         validateAssignment(request.lawyerContactId(), "LAWYER", "담당 변호사");

         mapper.updateAssignments(id, request.applicantContactId(), request.mjContactId(),

         return OrgResponse.of(mapper.findById(id));

     }

         }

         mapper.updateAssignments(saved.getId(), contact.getId(),

     }

     private String key(String orgNo, String orgName) {

 <mapper namespace="kr.itn.itnhub.org.OrganizationMapper">

   <!--

   -->

   <resultMap id="organizationResultMap" type="kr.itn.itnhub.org.Organization">

     <id property="id" column="id"/>

     <result property="channelSlug" column="channel_slug"/>

     <result property="applicantContactId" column="applicant_contact_id"/>

     <result property="mjContactId" column="mj_contact_id"/>

     <result property="lawyerContactId" column="lawyer_contact_id"/>

     <result property="lawyerAssignedDate" column="lawyer_assigned_date"/>

     <result property="channelIdMj" column="channel_id_mj"/>

       <result property="email" column="mj_c_email"/>

     </association>

     <association property="lawyer" javaType="kr.itn.itnhub.contact.Contact">

       <id property="id" column="lawyer_c_id"/>

       <result property="category" column="lawyer_c_category"/>

   <sql id="joinedColumns">

     o.id, o.org_no, o.org_name, o.channel_slug,

     o.lawyer_assigned_date, o.channel_id_mj, o.channel_id_law,

     ac.id as applicant_id, ac.category as applicant_category, ac.name as applicant_name,

     ac.affiliation as applicant_affiliation, ac.dept_name as applicant_dept_name,

     mc.id as mj_c_id, mc.category as mj_c_category, mc.name as mj_c_name,

     mc.affiliation as mj_c_affiliation, mc.dept_name as mj_c_dept_name,

     mc.title as mj_c_title, mc.phone as mj_c_phone, mc.email as mj_c_email,

     lc.id as lawyer_c_id, lc.category as lawyer_c_category, lc.name as lawyer_c_name,

     lc.affiliation as lawyer_c_affiliation, lc.dept_name as lawyer_c_dept_name,

     lc.title as lawyer_c_title, lc.phone as lawyer_c_phone, lc.email as lawyer_c_email

     from organization o

     left join contact ac on ac.id = o.applicant_contact_id

     left join contact mc on mc.id = o.mj_contact_id

     left join contact lc on lc.id = o.lawyer_contact_id

   </sql>

     update organization set

       applicant_contact_id = #{applicantContactId},

       mj_contact_id         = #{mjContactId},

       lawyer_contact_id     = #{lawyerContactId},

       lawyer_assigned_date  = #{lawyerAssignedDate},

       updated_at            = now()

         org.setChannelSlug("001");

         orgMapper.upsertBySeed(org);

         Long orgId = orgMapper.findAll().get(0).getId();

         assertThat(orgMapper.findById(orgId).getStatus().name()).isEqualTo("READY");

     void 문정원_담당자와_변호사를_함께_배정하면_응답과_재조회에_모두_반영된다() throws Exception {

         Long applicantId = createContact("APPLICANT", "송민지");

         Long mjId = createContact("MJ", "김문정");

         Long lawyerId = createContact("LAWYER", "이변호");

         mvc.perform(put("/api/orgs/{id}/assignments", orgId)

                                 {

                                   "applicantContactId": %d,

                                   "mjContactId": %d,

                                   "lawyerContactId": %d,

                                   "lawyerAssignedDate": "2026-07-21"

                                 }

                 .andExpect(status().isOk())

                 .andExpect(jsonPath("$.mj.name").value("김문정"))

                 .andExpect(jsonPath("$.lawyer.name").value("이변호"))

                 .andExpect(jsonPath("$.lawyerAssignedDate").value("2026-07-21"));

         mvc.perform(get("/api/orgs"))

                 .andExpect(status().isOk())

                 .andExpect(jsonPath("$[0].mj.name").value("김문정"))

                 .andExpect(jsonPath("$[0].lawyer.name").value("이변호"));

     }

     @Test

     void 배정_해제는_null을_보내면_반영되어_정보대기로_돌아간다() throws Exception {

         Long applicantId = createContact("APPLICANT", "송민지");

         mvc.perform(put("/api/orgs/{id}/assignments", orgId)

                         .with(csrf())

                 .andExpect(status().isOk())

                 .andExpect(jsonPath("$.status").value("INFO_PENDING"))

                 .andExpect(jsonPath("$.applicant").value(nullValue()));

     }

     @Test

     @Test

     void 채널생성을_요청하면_결과를_돌려준다() throws Exception {

         Long applicantId = createContact("APPLICANT", "송민지");

         when(mattermost.findChannelIdByInternalName(anyString())).thenReturn(Optional.empty());

         when(mattermost.findChannelIdByDisplayName(anyString())).thenReturn(Optional.empty());

     @Test

     void 법률검토만_실패해도_200과_부분실패_결과를_돌려준다() throws Exception {

         Long applicantId = createContact("APPLICANT", "송민지");

         when(mattermost.findChannelIdByInternalName(anyString())).thenReturn(Optional.empty());

         when(mattermost.findChannelIdByDisplayName(anyString())).thenReturn(Optional.empty());

     void 채널ID를_한쪽만_저장할_수_있다() {

         mapper.upsertBySeed(seedRow("002", "세종학당재단"));

         Long id = mapper.findAll().get(0).getId();

         mapper.updateChannelIdMj(id, "only-mj");

     }

     @Test

         mapper.upsertBySeed(seedRow("003", "한국문학번역원"));

         Organization org = mapper.findAll().get(0);

         Long applicantId = insertContact("APPLICANT", "송민지");

         Long mjId = insertContact("MJ", "김문정");

         Long lawyerId = insertContact("LAWYER", "이변호");

         Organization after = mapper.findById(org.getId());

         assertThat(after.getApplicantContactId()).isEqualTo(applicantId);

         assertThat(after.getMjContactId()).isEqualTo(mjId);

         assertThat(after.getLawyerContactId()).isEqualTo(lawyerId);

         assertThat(after.getLawyerAssignedDate()).isEqualTo("2026-07-21");

         assertThat(after.getApplicant().getName()).isEqualTo("송민지");

         assertThat(after.getApplicant().getCategory()).isEqualTo("APPLICANT");

         assertThat(after.getMj().getName()).isEqualTo("김문정");

         assertThat(after.getLawyer().getName()).isEqualTo("이변호");

         assertThat(after.getStatus()).isEqualTo(OrgStatus.READY);

     }

         Organization org = mapper.findAll().get(0);

         Long applicantId = insertContact("APPLICANT", "담당자");

         Organization after = mapper.findById(org.getId());

         assertThat(after.getApplicant()).isNotNull();

         assertThat(after.getMj()).isNull();

         assertThat(after.getLawyer()).isNull();

     }

         Organization org = mapper.findAll().get(0);

         Long applicantId = insertContact("APPLICANT", "담당자");

         Organization after = mapper.findById(org.getId());

         assertThat(after.getApplicantContactId()).isNull();

         contact.setCategory("APPLICANT");

         contact.setName(name);

         contactMapper.insert(contact);

         return contact.getId();

     }

         manual.setCategory("APPLICANT");

         manual.setName("사람이 직접 배정한 담당자");

         contactMapper.insert(manual);

         seedService.seed(new ByteArrayInputStream(xlsx));