Skip to content
zhenyi

gitdata-core

0
Clone

HTTPS

SSH

SSH needs a key in your settings.

Download ZIP

fix(pulls): write pull events in the business transaction

ZhenYi committed
parent 41ab240 commit 25f6a03 Browse files

9 files changed

+401 −218

File tree 9
Modified lib/pulls/src/services/assignees.rs View lib/pulls/src/services/assignees.rs
@@ -1,7 +1,9 @@
11use export::users::UserDto;
22use models::pull_request::{pull_request_assignee, pull_requests};
33use sea_orm::ActiveValue::Set;
4use sea_orm::{ActiveModelTrait, ColumnTrait, EntityTrait, QueryFilter, QueryOrder};
4use sea_orm::{
5 ActiveModelTrait, ColumnTrait, EntityTrait, QueryFilter, QueryOrder, TransactionTrait,
6};
57use serde::{Deserialize, Serialize};
68use time::OffsetDateTime;
79use utoipa::ToSchema;
@@ -61,22 +63,32 @@
6163 .one(self.db_read())
6264 .await?;
6365 if existing.is_none() {
64 pull_request_assignee::ActiveModel {
65 id: Set(Uuid::now_v7()),
66 pull_request_id: Set(pull.id),
67 user_id: Set(uid),
68 created_at: Set(OffsetDateTime::now_utc()),
69 }
70 .insert(self.db_write())
71 .await?;
72 self.record_event(
73 pull,
74 Some(caller),
75 EVENT_ASSIGNED,
76 None,
77 Some(uid.to_string()),
78 )
79 .await?;
66 let event_pull = pull.clone();
67 let this = self.clone();
68 self.db_write()
69 .transaction::<_, (), PullError>(move |tx| {
70 Box::pin(async move {
71 pull_request_assignee::ActiveModel {
72 id: Set(Uuid::now_v7()),
73 pull_request_id: Set(event_pull.id),
74 user_id: Set(uid),
75 created_at: Set(OffsetDateTime::now_utc()),
76 }
77 .insert(tx)
78 .await?;
79 this.record_event_with(
80 tx,
81 &event_pull,
82 Some(caller),
83 EVENT_ASSIGNED,
84 None,
85 Some(uid.to_string()),
86 )
87 .await?;
88 Ok(())
89 })
90 })
91 .await?;
8092 }
8193 self.list_assignees(pull.id).await
8294 }
@@ -89,21 +101,31 @@
89101 ) -> Result<Vec<PullAssigneeDto>, PullError> {
90102 authz::require_unlocked(pull)?;
91103 let uid = self.actors.resolve(reference).await?;
92 let deleted = pull_request_assignee::Entity::delete_many()
93 .filter(pull_request_assignee::Column::PullRequestId.eq(pull.id))
94 .filter(pull_request_assignee::Column::UserId.eq(uid))
95 .exec(self.db_write())
96 .await?;
97 if deleted.rows_affected > 0 {
98 self.record_event(
99 pull,
100 Some(caller),
101 EVENT_UNASSIGNED,
102 None,
103 Some(uid.to_string()),
104 )
104 let event_pull = pull.clone();
105 let this = self.clone();
106 self.db_write()
107 .transaction::<_, (), PullError>(move |tx| {
108 Box::pin(async move {
109 let deleted = pull_request_assignee::Entity::delete_many()
110 .filter(pull_request_assignee::Column::PullRequestId.eq(event_pull.id))
111 .filter(pull_request_assignee::Column::UserId.eq(uid))
112 .exec(tx)
113 .await?;
114 if deleted.rows_affected > 0 {
115 this.record_event_with(
116 tx,
117 &event_pull,
118 Some(caller),
119 EVENT_UNASSIGNED,
120 None,
121 Some(uid.to_string()),
122 )
123 .await?;
124 }
125 Ok(())
126 })
127 })
105128 .await?;
106 }
107129 self.list_assignees(pull.id).await
108130 }
109131}
Modified lib/pulls/src/services/changes.rs View lib/pulls/src/services/changes.rs
@@ -1,12 +1,12 @@
11use git::facade::{ChangedPathDiffDto, DiffOptionsDto, GitContext, MergeCommitDto, MergePlanDto};
22use models::pull_request::pull_requests;
33use sea_orm::ActiveValue::Set;
4use sea_orm::{ActiveModelTrait, IntoActiveModel};
4use sea_orm::{ActiveModelTrait, IntoActiveModel, TransactionTrait};
55use serde::{Deserialize, Serialize};
66use time::OffsetDateTime;
77
88use crate::errors::PullError;
9use crate::services::events::{EVENT_HEAD_UPDATED, write_event};
9use crate::services::events::EVENT_HEAD_UPDATED;
1010use crate::services::service::PullService;
1111
1212#[derive(Debug, Clone, Serialize, Deserialize, utoipa::ToSchema)]
@@ -122,18 +122,27 @@
122122 if moved {
123123 model.updated_at = Set(Some(OffsetDateTime::now_utc()));
124124 }
125 let updated = model.update(self.db_write()).await?;
126 if moved {
127 write_event(
128 self.db_write(),
129 &updated,
130 actor,
131 EVENT_HEAD_UPDATED,
132 Some(head.clone()),
133 None,
134 )
125 let this = self.clone();
126 let updated = self
127 .db_write()
128 .transaction::<_, _, PullError>(move |tx| {
129 Box::pin(async move {
130 let updated = model.update(tx).await?;
131 if moved {
132 this.record_event_with(
133 tx,
134 &updated,
135 actor,
136 EVENT_HEAD_UPDATED,
137 Some(head),
138 None,
139 )
140 .await?;
141 }
142 Ok(updated)
143 })
144 })
135145 .await?;
136 }
137146 Ok((
138147 updated,
139148 PullSummaryDto {
Modified lib/pulls/src/services/comments.rs View lib/pulls/src/services/comments.rs
@@ -5,7 +5,7 @@
55use sea_orm::ActiveValue::Set;
66use sea_orm::{
77 ActiveModelTrait, ColumnTrait, Condition, EntityTrait, PaginatorTrait, QueryFilter, QueryOrder,
8 QuerySelect,
8 QuerySelect, TransactionTrait,
99};
1010use serde::{Deserialize, Serialize};
1111use std::collections::HashMap;
@@ -130,31 +130,48 @@
130130 {
131131 return Err(PullError::BadRequest("review not found".to_string()));
132132 }
133 let row = pull_request_comment::ActiveModel {
134 id: Set(Uuid::now_v7()),
135 pull_request_id: Set(pull.id),
136 user_id: Set(caller),
137 review_id: Set(cmd.review_id),
138 parent_comment_id: Set(cmd.parent_comment_id),
139 commit_sha: Set(commit_sha.clone()),
140 original_commit_sha: Set(commit_sha.clone()),
141 path: Set(if inline { cmd.path.clone() } else { None }),
142 side: Set(if inline {
143 Some(cmd.side.clone().unwrap_or_else(|| "right".to_string()))
144 } else {
145 None
146 }),
147 line: Set(if inline { cmd.line } else { None }),
148 original_line: Set(if inline { cmd.line } else { None }),
149 body: Set(cmd.body.clone()),
150 resolved_at: Set(None),
151 resolved_by: Set(None),
152 created_at: Set(OffsetDateTime::now_utc()),
153 updated_at: Set(None),
154 }
155 .insert(self.db_write())
156 .await?;
157 self.record_event(pull, Some(caller), EVENT_COMMENTED, commit_sha, None)
133 let event_pull = pull.clone();
134 let this = self.clone();
135 let row = self
136 .db_write()
137 .transaction::<_, _, PullError>(move |tx| {
138 Box::pin(async move {
139 let row = pull_request_comment::ActiveModel {
140 id: Set(Uuid::now_v7()),
141 pull_request_id: Set(event_pull.id),
142 user_id: Set(caller),
143 review_id: Set(cmd.review_id),
144 parent_comment_id: Set(cmd.parent_comment_id),
145 commit_sha: Set(commit_sha.clone()),
146 original_commit_sha: Set(commit_sha.clone()),
147 path: Set(if inline { cmd.path.clone() } else { None }),
148 side: Set(if inline {
149 Some(cmd.side.clone().unwrap_or_else(|| "right".to_string()))
150 } else {
151 None
152 }),
153 line: Set(if inline { cmd.line } else { None }),
154 original_line: Set(if inline { cmd.line } else { None }),
155 body: Set(cmd.body.clone()),
156 resolved_at: Set(None),
157 resolved_by: Set(None),
158 created_at: Set(OffsetDateTime::now_utc()),
159 updated_at: Set(None),
160 }
161 .insert(tx)
162 .await?;
163 this.record_event_with(
164 tx,
165 &event_pull,
166 Some(caller),
167 EVENT_COMMENTED,
168 commit_sha,
169 None,
170 )
171 .await?;
172 Ok(row)
173 })
174 })
158175 .await?;
159176 let _ = ctx;
160177 Ok(row)
Modified lib/pulls/src/services/events.rs View lib/pulls/src/services/events.rs
@@ -149,7 +149,7 @@
149149 commit_sha: Option<String>,
150150 content: Option<String>,
151151 ) -> Result<(), PullError> {
152 write_event(
152 self.record_event_with(
153153 self.db_write(),
154154 pull,
155155 actor,
@@ -157,7 +157,19 @@
157157 commit_sha,
158158 content,
159159 )
160 .await?;
160 .await
161 }
162
163 pub(crate) async fn record_event_with(
164 &self,
165 conn: &impl ConnectionTrait,
166 pull: &pull_requests::Model,
167 actor: Option<i64>,
168 event_type: &str,
169 commit_sha: Option<String>,
170 content: Option<String>,
171 ) -> Result<(), PullError> {
172 write_event(conn, pull, actor, event_type, commit_sha, content).await?;
161173 Ok(())
162174 }
163175
Modified lib/pulls/src/services/labels.rs View lib/pulls/src/services/labels.rs
@@ -1,6 +1,8 @@
11use models::pull_request::{pull_request_label, pull_requests};
22use sea_orm::ActiveValue::Set;
3use sea_orm::{ActiveModelTrait, ColumnTrait, EntityTrait, QueryFilter, QueryOrder};
3use sea_orm::{
4 ActiveModelTrait, ColumnTrait, EntityTrait, QueryFilter, QueryOrder, TransactionTrait,
5};
46use serde::Deserialize;
57use utoipa::ToSchema;
68use uuid::Uuid;
@@ -64,22 +66,32 @@
6466 .one(self.db_read())
6567 .await?;
6668 if existing.is_none() {
67 pull_request_label::ActiveModel {
68 id: Set(Uuid::now_v7()),
69 pull_request_id: Set(pull.id),
70 label_id: Set(label.id),
71 created_at: Set(OffsetDateTime::now_utc()),
72 }
73 .insert(self.db_write())
74 .await?;
75 self.record_event(
76 pull,
77 Some(caller),
78 EVENT_LABELED,
79 None,
80 Some(label.name.clone()),
81 )
82 .await?;
69 let event_pull = pull.clone();
70 let this = self.clone();
71 self.db_write()
72 .transaction::<_, (), PullError>(move |tx| {
73 Box::pin(async move {
74 pull_request_label::ActiveModel {
75 id: Set(Uuid::now_v7()),
76 pull_request_id: Set(event_pull.id),
77 label_id: Set(label.id),
78 created_at: Set(OffsetDateTime::now_utc()),
79 }
80 .insert(tx)
81 .await?;
82 this.record_event_with(
83 tx,
84 &event_pull,
85 Some(caller),
86 EVENT_LABELED,
87 None,
88 Some(label.name),
89 )
90 .await?;
91 Ok(())
92 })
93 })
94 .await?;
8395 }
8496 self.list_labels(pull.id).await
8597 }
@@ -93,21 +105,31 @@
93105 ) -> Result<Vec<issues::services::labels::LabelDto>, PullError> {
94106 authz::require_unlocked(pull)?;
95107 let label = self.resolve_label(dir_id, label_ref).await?;
96 let deleted = pull_request_label::Entity::delete_many()
97 .filter(pull_request_label::Column::PullRequestId.eq(pull.id))
98 .filter(pull_request_label::Column::LabelId.eq(label.id))
99 .exec(self.db_write())
100 .await?;
101 if deleted.rows_affected > 0 {
102 self.record_event(
103 pull,
104 Some(caller),
105 EVENT_UNLABELED,
106 None,
107 Some(label.name.clone()),
108 )
108 let event_pull = pull.clone();
109 let this = self.clone();
110 self.db_write()
111 .transaction::<_, (), PullError>(move |tx| {
112 Box::pin(async move {
113 let deleted = pull_request_label::Entity::delete_many()
114 .filter(pull_request_label::Column::PullRequestId.eq(event_pull.id))
115 .filter(pull_request_label::Column::LabelId.eq(label.id))
116 .exec(tx)
117 .await?;
118 if deleted.rows_affected > 0 {
119 this.record_event_with(
120 tx,
121 &event_pull,
122 Some(caller),
123 EVENT_UNLABELED,
124 None,
125 Some(label.name),
126 )
127 .await?;
128 }
129 Ok(())
130 })
131 })
109132 .await?;
110 }
111133 self.list_labels(pull.id).await
112134 }
113135}
Modified lib/pulls/src/services/merge.rs View lib/pulls/src/services/merge.rs
@@ -2,7 +2,7 @@
22use models::pull_request::pull_requests;
33use models::pull_request::pull_requests::MergeMethod;
44use sea_orm::ActiveValue::Set;
5use sea_orm::{ActiveModelTrait, IntoActiveModel};
5use sea_orm::{ActiveModelTrait, IntoActiveModel, TransactionTrait};
66use serde::{Deserialize, Serialize};
77use utoipa::ToSchema;
88
@@ -205,15 +205,25 @@
205205 let mut model = current.into_active_model();
206206 model.head_sha = Set(head_sha.clone());
207207 model.updated_at = Set(Some(time::OffsetDateTime::now_utc()));
208 let updated = model.update(self.db_write()).await?;
209 self.record_event(
210 &updated,
211 Some(caller),
212 crate::services::events::EVENT_HEAD_UPDATED,
213 Some(head_sha),
214 Some("base branch merged into head".to_string()),
215 )
216 .await?;
208 let this = self.clone();
209 let updated = self
210 .db_write()
211 .transaction::<_, _, PullError>(move |tx| {
212 Box::pin(async move {
213 let updated = model.update(tx).await?;
214 this.record_event_with(
215 tx,
216 &updated,
217 Some(caller),
218 crate::services::events::EVENT_HEAD_UPDATED,
219 Some(head_sha),
220 Some("base branch merged into head".to_string()),
221 )
222 .await?;
223 Ok(updated)
224 })
225 })
226 .await?;
217227 Ok((updated, result))
218228 }
219229}
Modified lib/pulls/src/services/pulls.rs View lib/pulls/src/services/pulls.rs
@@ -477,8 +477,17 @@
477477 return Ok(pull.clone());
478478 }
479479 model.updated_at = Set(Some(OffsetDateTime::now_utc()));
480 let updated = model.update(self.db_write()).await?;
481 self.record_event(&updated, Some(caller), EVENT_UPDATED, None, None)
480 let this = self.clone();
481 let updated = self
482 .db_write()
483 .transaction::<_, _, PullError>(move |tx| {
484 Box::pin(async move {
485 let updated = model.update(tx).await?;
486 this.record_event_with(tx, &updated, Some(caller), EVENT_UPDATED, None, None)
487 .await?;
488 Ok(updated)
489 })
490 })
482491 .await?;
483492 let _ = (space_name, repo_name);
484493 Ok(updated)
@@ -508,15 +517,25 @@
508517 None
509518 });
510519 model.updated_at = Set(Some(OffsetDateTime::now_utc()));
511 let updated = model.update(self.db_write()).await?;
512 self.record_event(
513 &updated,
514 Some(caller),
515 if closed { EVENT_CLOSED } else { EVENT_REOPENED },
516 None,
517 None,
518 )
519 .await?;
520 let this = self.clone();
521 let updated = self
522 .db_write()
523 .transaction::<_, _, PullError>(move |tx| {
524 Box::pin(async move {
525 let updated = model.update(tx).await?;
526 this.record_event_with(
527 tx,
528 &updated,
529 Some(caller),
530 if closed { EVENT_CLOSED } else { EVENT_REOPENED },
531 None,
532 None,
533 )
534 .await?;
535 Ok(updated)
536 })
537 })
538 .await?;
520539 self.recount_open(updated.repo_id).await?;
521540 Ok(updated)
522541 }
@@ -628,8 +647,24 @@
628647 model.merged_commit_sha = Set(Some(merged_sha.clone()));
629648 model.auto_merge = Set(false);
630649 model.updated_at = Set(Some(OffsetDateTime::now_utc()));
631 let updated = model.update(self.db_write()).await?;
632 self.record_event(&updated, Some(caller), EVENT_MERGED, Some(merged_sha), None)
650 let this = self.clone();
651 let updated = self
652 .db_write()
653 .transaction::<_, _, PullError>(move |tx| {
654 Box::pin(async move {
655 let updated = model.update(tx).await?;
656 this.record_event_with(
657 tx,
658 &updated,
659 Some(caller),
660 EVENT_MERGED,
661 Some(merged_sha),
662 None,
663 )
664 .await?;
665 Ok(updated)
666 })
667 })
633668 .await?;
634669 self.recount_open(updated.repo_id).await?;
635670 Ok(updated)
@@ -649,19 +684,29 @@
649684 let mut model: pull_requests::ActiveModel = pull.clone().into();
650685 model.is_locked = Set(locked);
651686 model.updated_at = Set(Some(OffsetDateTime::now_utc()));
652 let updated = model.update(self.db_write()).await?;
653 self.record_event(
654 &updated,
655 Some(caller),
656 if locked {
657 crate::services::events::EVENT_LOCKED
658 } else {
659 crate::services::events::EVENT_UNLOCKED
660 },
661 None,
662 None,
663 )
664 .await?;
687 let this = self.clone();
688 let updated = self
689 .db_write()
690 .transaction::<_, _, PullError>(move |tx| {
691 Box::pin(async move {
692 let updated = model.update(tx).await?;
693 this.record_event_with(
694 tx,
695 &updated,
696 Some(caller),
697 if locked {
698 crate::services::events::EVENT_LOCKED
699 } else {
700 crate::services::events::EVENT_UNLOCKED
701 },
702 None,
703 None,
704 )
705 .await?;
706 Ok(updated)
707 })
708 })
709 .await?;
665710 Ok(updated)
666711 }
667712}
Modified lib/pulls/src/services/reviewers.rs View lib/pulls/src/services/reviewers.rs
@@ -1,16 +1,16 @@
11use export::users::UserDto;
22use models::pull_request::{pull_request_review, pull_request_reviewer, pull_requests};
33use sea_orm::ActiveValue::Set;
4use sea_orm::{ActiveModelTrait, ColumnTrait, EntityTrait, QueryFilter, QueryOrder};
4use sea_orm::{
5 ActiveModelTrait, ColumnTrait, EntityTrait, QueryFilter, QueryOrder, TransactionTrait,
6};
57use serde::{Deserialize, Serialize};
68use time::OffsetDateTime;
79use utoipa::ToSchema;
810use uuid::Uuid;
911
1012use crate::errors::PullError;
11use crate::services::events::{
12 EVENT_REVIEW_REQUEST_CANCELLED, EVENT_REVIEW_REQUESTED, write_event,
13};
13use crate::services::events::{EVENT_REVIEW_REQUEST_CANCELLED, EVENT_REVIEW_REQUESTED};
1414use crate::services::reviews;
1515use crate::services::service::PullService;
1616use crate::share::authz;
@@ -93,55 +93,67 @@
9393 return Err(PullError::BadRequest(
9494 "the pull request author cannot be a requested reviewer".to_string(),
9595 ));
96 }
97 let existing = pull_request_reviewer::Entity::find()
98 .filter(pull_request_reviewer::Column::PullRequestId.eq(pull.id))
99 .filter(pull_request_reviewer::Column::UserId.eq(uid))
100 .one(self.db_read())
101 .await?;
102 match existing {
103 Some(row) => {
104 let mut model: pull_request_reviewer::ActiveModel = row.into();
105 model.state = Set(ReviewerState::Requested);
106 model.required = Set(cmd.required);
107 model.requested_by_id = Set(caller);
108 model.review_id = Set(None);
109 model.updated_at = Set(Some(OffsetDateTime::now_utc()));
110 model.update(self.db_write()).await?;
111 }
112 None => {
113 pull_request_reviewer::ActiveModel {
114 id: Set(Uuid::now_v7()),
115 pull_request_id: Set(pull.id),
116 user_id: Set(uid),
117 state: Set(ReviewerState::Requested),
118 required: Set(cmd.required),
119 review_id: Set(None),
120 requested_by_id: Set(caller),
121 created_at: Set(OffsetDateTime::now_utc()),
122 updated_at: Set(None),
123 }
124 .insert(self.db_write())
125 .await?;
126 }
12796 }
12897 added.push(uid);
12998 }
130 write_event(
131 self.db_write(),
132 pull,
133 Some(caller),
134 EVENT_REVIEW_REQUESTED,
135 None,
136 Some(
137 added
138 .iter()
139 .map(|id| id.to_string())
140 .collect::<Vec<_>>()
141 .join(","),
142 ),
143 )
144 .await?;
99 let required = cmd.required;
100 let event_pull = pull.clone();
101 let this = self.clone();
102 self.db_write()
103 .transaction::<_, (), PullError>(move |tx| {
104 Box::pin(async move {
105 for uid in &added {
106 let existing = pull_request_reviewer::Entity::find()
107 .filter(pull_request_reviewer::Column::PullRequestId.eq(event_pull.id))
108 .filter(pull_request_reviewer::Column::UserId.eq(*uid))
109 .one(tx)
110 .await?;
111 match existing {
112 Some(row) => {
113 let mut model: pull_request_reviewer::ActiveModel = row.into();
114 model.state = Set(ReviewerState::Requested);
115 model.required = Set(required);
116 model.requested_by_id = Set(caller);
117 model.review_id = Set(None);
118 model.updated_at = Set(Some(OffsetDateTime::now_utc()));
119 model.update(tx).await?;
120 }
121 None => {
122 pull_request_reviewer::ActiveModel {
123 id: Set(Uuid::now_v7()),
124 pull_request_id: Set(event_pull.id),
125 user_id: Set(*uid),
126 state: Set(ReviewerState::Requested),
127 required: Set(required),
128 review_id: Set(None),
129 requested_by_id: Set(caller),
130 created_at: Set(OffsetDateTime::now_utc()),
131 updated_at: Set(None),
132 }
133 .insert(tx)
134 .await?;
135 }
136 }
137 }
138 this.record_event_with(
139 tx,
140 &event_pull,
141 Some(caller),
142 EVENT_REVIEW_REQUESTED,
143 None,
144 Some(
145 added
146 .iter()
147 .map(|id| id.to_string())
148 .collect::<Vec<_>>()
149 .join(","),
150 ),
151 )
152 .await?;
153 Ok(())
154 })
155 })
156 .await?;
145157 self.list_reviewers(pull.id).await
146158 }
147159
@@ -157,18 +169,27 @@
157169 .one(self.db_read())
158170 .await?
159171 .ok_or(PullError::NotFound)?;
160 pull_request_reviewer::Entity::delete_by_id(row.id)
161 .exec(self.db_write())
172 let event_pull = pull.clone();
173 let this = self.clone();
174 self.db_write()
175 .transaction::<_, (), PullError>(move |tx| {
176 Box::pin(async move {
177 pull_request_reviewer::Entity::delete_by_id(row.id)
178 .exec(tx)
179 .await?;
180 this.record_event_with(
181 tx,
182 &event_pull,
183 Some(caller),
184 EVENT_REVIEW_REQUEST_CANCELLED,
185 None,
186 Some(reviewer_id.to_string()),
187 )
188 .await?;
189 Ok(())
190 })
191 })
162192 .await?;
163 write_event(
164 self.db_write(),
165 pull,
166 Some(caller),
167 EVENT_REVIEW_REQUEST_CANCELLED,
168 None,
169 Some(reviewer_id.to_string()),
170 )
171 .await?;
172193 self.list_reviewers(pull.id).await
173194 }
174195
Modified lib/pulls/src/services/reviews.rs View lib/pulls/src/services/reviews.rs
@@ -196,15 +196,27 @@
196196 model.content = AmSet(cmd.body.clone());
197197 }
198198 model.updated_at = Set(Some(OffsetDateTime::now_utc()));
199 let updated = model.update(self.db_write()).await?;
200 self.record_event(
201 pull,
202 Some(caller),
203 EVENT_REVIEW_SUBMITTED,
204 Some(review.commit_sha.clone()),
205 Some(format!("{target:?}")),
206 )
207 .await?;
199 let commit_sha = review.commit_sha.clone();
200 let event_pull = pull.clone();
201 let this = self.clone();
202 let updated = self
203 .db_write()
204 .transaction::<_, _, PullError>(move |tx| {
205 Box::pin(async move {
206 let updated = model.update(tx).await?;
207 this.record_event_with(
208 tx,
209 &event_pull,
210 Some(caller),
211 EVENT_REVIEW_SUBMITTED,
212 Some(commit_sha),
213 Some(format!("{target:?}")),
214 )
215 .await?;
216 Ok(updated)
217 })
218 })
219 .await?;
208220 self.sync_reviewer(pull.id, caller, ReviewerOutcome::from_state(target))
209221 .await?;
210222 Ok(updated)
@@ -228,15 +240,28 @@
228240 model.state = Set(ReviewState::Dismissed);
229241 model.official = Set(false);
230242 model.updated_at = Set(Some(OffsetDateTime::now_utc()));
231 let updated = model.update(self.db_write()).await?;
232 self.record_event(
233 pull,
234 Some(caller),
235 EVENT_REVIEW_DISMISSED,
236 Some(review.commit_sha.clone()),
237 Some(format!("dismissed review of {:?}", review.user_id)),
238 )
239 .await?;
243 let commit_sha = review.commit_sha.clone();
244 let user_id = review.user_id;
245 let event_pull = pull.clone();
246 let this = self.clone();
247 let updated = self
248 .db_write()
249 .transaction::<_, _, PullError>(move |tx| {
250 Box::pin(async move {
251 let updated = model.update(tx).await?;
252 this.record_event_with(
253 tx,
254 &event_pull,
255 Some(caller),
256 EVENT_REVIEW_DISMISSED,
257 Some(commit_sha),
258 Some(format!("dismissed review of {user_id:?}")),
259 )
260 .await?;
261 Ok(updated)
262 })
263 })
264 .await?;
240265 self.sync_reviewer(pull.id, review.user_id, ReviewerOutcome::Dismissed)
241266 .await?;
242267 Ok(updated)