Coverage for src/couchers/servicers/api.py: 96%

1from datetime import timedelta 

2from urllib.parse import urlencode 

3 

4import grpc 

5from google.protobuf import empty_pb2 

6from sqlalchemy.orm import aliased 

7from sqlalchemy.sql import and_, delete, func, intersect, or_, union 

8 

9from couchers import errors, urls 

10from couchers.config import config 

11from couchers.crypto import b64encode, generate_hash_signature, random_hex 

12from couchers.db import session_scope 

13from couchers.models import ( 

14 FriendRelationship, 

15 FriendStatus, 

16 GroupChatSubscription, 

17 HostingStatus, 

18 HostRequest, 

19 InitiatedUpload, 

20 LanguageAbility, 

21 LanguageFluency, 

22 MeetupStatus, 

23 Message, 

24 ParkingDetails, 

25 Reference, 

26 RegionLived, 

27 RegionVisited, 

28 SleepingArrangement, 

29 SmokingLocation, 

30 User, 

31) 

32from couchers.notifications.notify import notify 

33from couchers.resources import language_is_allowed, region_is_allowed 

34from couchers.sql import couchers_select as select 

35from couchers.tasks import send_friend_request_accepted_email, send_friend_request_email 

36from couchers.utils import Timestamp_from_datetime, create_coordinate, is_valid_name, now 

37from proto import api_pb2, api_pb2_grpc, media_pb2 

38 

39hostingstatus2sql = { 

40 api_pb2.HOSTING_STATUS_UNKNOWN: None, 

41 api_pb2.HOSTING_STATUS_CAN_HOST: HostingStatus.can_host, 

42 api_pb2.HOSTING_STATUS_MAYBE: HostingStatus.maybe, 

43 api_pb2.HOSTING_STATUS_CANT_HOST: HostingStatus.cant_host, 

44} 

45 

46hostingstatus2api = { 

47 None: api_pb2.HOSTING_STATUS_UNKNOWN, 

48 HostingStatus.can_host: api_pb2.HOSTING_STATUS_CAN_HOST, 

49 HostingStatus.maybe: api_pb2.HOSTING_STATUS_MAYBE, 

50 HostingStatus.cant_host: api_pb2.HOSTING_STATUS_CANT_HOST, 

51} 

52 

53meetupstatus2sql = { 

54 api_pb2.MEETUP_STATUS_UNKNOWN: None, 

55 api_pb2.MEETUP_STATUS_WANTS_TO_MEETUP: MeetupStatus.wants_to_meetup, 

56 api_pb2.MEETUP_STATUS_OPEN_TO_MEETUP: MeetupStatus.open_to_meetup, 

57 api_pb2.MEETUP_STATUS_DOES_NOT_WANT_TO_MEETUP: MeetupStatus.does_not_want_to_meetup, 

58} 

59 

60meetupstatus2api = { 

61 None: api_pb2.MEETUP_STATUS_UNKNOWN, 

62 MeetupStatus.wants_to_meetup: api_pb2.MEETUP_STATUS_WANTS_TO_MEETUP, 

63 MeetupStatus.open_to_meetup: api_pb2.MEETUP_STATUS_OPEN_TO_MEETUP, 

64 MeetupStatus.does_not_want_to_meetup: api_pb2.MEETUP_STATUS_DOES_NOT_WANT_TO_MEETUP, 

65} 

66 

67smokinglocation2sql = { 

68 api_pb2.SMOKING_LOCATION_UNKNOWN: None, 

69 api_pb2.SMOKING_LOCATION_YES: SmokingLocation.yes, 

70 api_pb2.SMOKING_LOCATION_WINDOW: SmokingLocation.window, 

71 api_pb2.SMOKING_LOCATION_OUTSIDE: SmokingLocation.outside, 

72 api_pb2.SMOKING_LOCATION_NO: SmokingLocation.no, 

73} 

74 

75smokinglocation2api = { 

76 None: api_pb2.SMOKING_LOCATION_UNKNOWN, 

77 SmokingLocation.yes: api_pb2.SMOKING_LOCATION_YES, 

78 SmokingLocation.window: api_pb2.SMOKING_LOCATION_WINDOW, 

79 SmokingLocation.outside: api_pb2.SMOKING_LOCATION_OUTSIDE, 

80 SmokingLocation.no: api_pb2.SMOKING_LOCATION_NO, 

81} 

82 

83sleepingarrangement2sql = { 

84 api_pb2.SLEEPING_ARRANGEMENT_UNKNOWN: None, 

85 api_pb2.SLEEPING_ARRANGEMENT_PRIVATE: SleepingArrangement.private, 

86 api_pb2.SLEEPING_ARRANGEMENT_COMMON: SleepingArrangement.common, 

87 api_pb2.SLEEPING_ARRANGEMENT_SHARED_ROOM: SleepingArrangement.shared_room, 

88 api_pb2.SLEEPING_ARRANGEMENT_SHARED_SPACE: SleepingArrangement.shared_space, 

89} 

90 

91sleepingarrangement2api = { 

92 None: api_pb2.SLEEPING_ARRANGEMENT_UNKNOWN, 

93 SleepingArrangement.private: api_pb2.SLEEPING_ARRANGEMENT_PRIVATE, 

94 SleepingArrangement.common: api_pb2.SLEEPING_ARRANGEMENT_COMMON, 

95 SleepingArrangement.shared_room: api_pb2.SLEEPING_ARRANGEMENT_SHARED_ROOM, 

96 SleepingArrangement.shared_space: api_pb2.SLEEPING_ARRANGEMENT_SHARED_SPACE, 

97} 

98 

99parkingdetails2sql = { 

100 api_pb2.PARKING_DETAILS_UNKNOWN: None, 

101 api_pb2.PARKING_DETAILS_FREE_ONSITE: ParkingDetails.free_onsite, 

102 api_pb2.PARKING_DETAILS_FREE_OFFSITE: ParkingDetails.free_offsite, 

103 api_pb2.PARKING_DETAILS_PAID_ONSITE: ParkingDetails.paid_onsite, 

104 api_pb2.PARKING_DETAILS_PAID_OFFSITE: ParkingDetails.paid_offsite, 

105} 

106 

107parkingdetails2api = { 

108 None: api_pb2.PARKING_DETAILS_UNKNOWN, 

109 ParkingDetails.free_onsite: api_pb2.PARKING_DETAILS_FREE_ONSITE, 

110 ParkingDetails.free_offsite: api_pb2.PARKING_DETAILS_FREE_OFFSITE, 

111 ParkingDetails.paid_onsite: api_pb2.PARKING_DETAILS_PAID_ONSITE, 

112 ParkingDetails.paid_offsite: api_pb2.PARKING_DETAILS_PAID_OFFSITE, 

113} 

114 

115fluency2sql = { 

116 api_pb2.LanguageAbility.Fluency.FLUENCY_UNKNOWN: None, 

117 api_pb2.LanguageAbility.Fluency.FLUENCY_BEGINNER: LanguageFluency.beginner, 

118 api_pb2.LanguageAbility.Fluency.FLUENCY_CONVERSATIONAL: LanguageFluency.conversational, 

119 api_pb2.LanguageAbility.Fluency.FLUENCY_FLUENT: LanguageFluency.fluent, 

120} 

121 

122fluency2api = { 

123 None: api_pb2.LanguageAbility.Fluency.FLUENCY_UNKNOWN, 

124 LanguageFluency.beginner: api_pb2.LanguageAbility.Fluency.FLUENCY_BEGINNER, 

125 LanguageFluency.conversational: api_pb2.LanguageAbility.Fluency.FLUENCY_CONVERSATIONAL, 

126 LanguageFluency.fluent: api_pb2.LanguageAbility.Fluency.FLUENCY_FLUENT, 

127} 

128 

129 

130class API(api_pb2_grpc.APIServicer): 

131 def Ping(self, request, context): 

132 with session_scope() as session: 

133 # auth ought to make sure the user exists 

134 user = session.execute(select(User).where(User.id == context.user_id)).scalar_one() 

135 

136 # gets only the max message by self-joining messages which have a greater id 

137 # if it doesn't have a greater id, it's the biggest 

138 message_2 = aliased(Message) 

139 unseen_sent_host_request_count = session.execute( 

140 select(func.count()) 

141 .select_from(Message) 

142 .join(HostRequest, Message.conversation_id == HostRequest.conversation_id) 

143 .outerjoin( 

144 message_2, and_(Message.conversation_id == message_2.conversation_id, Message.id < message_2.id) 

145 ) 

146 .where(HostRequest.surfer_user_id == context.user_id) 

147 .where_users_column_visible(context, HostRequest.host_user_id) 

148 .where(message_2.id == None) 

149 .where(HostRequest.surfer_last_seen_message_id < Message.id) 

150 ).scalar_one() 

151 

152 unseen_received_host_request_count = session.execute( 

153 select(func.count()) 

154 .select_from(Message) 

155 .join(HostRequest, Message.conversation_id == HostRequest.conversation_id) 

156 .outerjoin( 

157 message_2, and_(Message.conversation_id == message_2.conversation_id, Message.id < message_2.id) 

158 ) 

159 .where_users_column_visible(context, HostRequest.surfer_user_id) 

160 .where(HostRequest.host_user_id == context.user_id) 

161 .where(message_2.id == None) 

162 .where(HostRequest.host_last_seen_message_id < Message.id) 

163 ).scalar_one() 

164 

165 unseen_message_count = session.execute( 

166 select(func.count()) 

167 .select_from(Message) 

168 .outerjoin(GroupChatSubscription, GroupChatSubscription.group_chat_id == Message.conversation_id) 

169 .where(GroupChatSubscription.user_id == context.user_id) 

170 .where(Message.time >= GroupChatSubscription.joined) 

171 .where(or_(Message.time <= GroupChatSubscription.left, GroupChatSubscription.left == None)) 

172 .where(Message.id > GroupChatSubscription.last_seen_message_id) 

173 ).scalar_one() 

174 

175 pending_friend_request_count = session.execute( 

176 select(func.count()) 

177 .select_from(FriendRelationship) 

178 .where(FriendRelationship.to_user_id == context.user_id) 

179 .where_users_column_visible(context, FriendRelationship.from_user_id) 

180 .where(FriendRelationship.status == FriendStatus.pending) 

181 ).scalar_one() 

182 

183 return api_pb2.PingRes( 

184 user=user_model_to_pb(user, session, context), 

185 unseen_message_count=unseen_message_count, 

186 unseen_sent_host_request_count=unseen_sent_host_request_count, 

187 unseen_received_host_request_count=unseen_received_host_request_count, 

188 pending_friend_request_count=pending_friend_request_count, 

189 ) 

190 

191 def GetUser(self, request, context): 

192 with session_scope() as session: 

193 user = session.execute( 

194 select(User).where_users_visible(context).where_username_or_id(request.user) 

195 ).scalar_one_or_none() 

196 

197 if not user: 

198 context.abort(grpc.StatusCode.NOT_FOUND, errors.USER_NOT_FOUND) 

199 

200 return user_model_to_pb(user, session, context) 

201 

202 def UpdateProfile(self, request, context): 

203 with session_scope() as session: 

204 user = session.execute(select(User).where(User.id == context.user_id)).scalar_one() 

205 

206 if request.HasField("name"): 

207 if not is_valid_name(request.name.value): 

208 context.abort(grpc.StatusCode.INVALID_ARGUMENT, errors.INVALID_NAME) 

209 user.name = request.name.value 

210 

211 if request.HasField("city"): 

212 user.city = request.city.value 

213 

214 if request.HasField("hometown"): 

215 if request.hometown.is_null: 

216 user.hometown = None 

217 else: 

218 user.hometown = request.hometown.value 

219 

220 if request.HasField("lat") and request.HasField("lng"): 

221 if request.lat.value == 0 and request.lng.value == 0: 

222 context.abort(grpc.StatusCode.INVALID_ARGUMENT, errors.INVALID_COORDINATE) 

223 user.geom = create_coordinate(request.lat.value, request.lng.value) 

224 

225 if request.HasField("radius"): 

226 user.geom_radius = request.radius.value 

227 

228 if request.HasField("avatar_key"): 

229 if request.avatar_key.is_null: 

230 user.avatar_key = None 

231 else: 

232 user.avatar_key = request.avatar_key.value 

233 

234 # if request.HasField("gender"): 

235 # user.gender = request.gender.value 

236 

237 if request.HasField("pronouns"): 

238 if request.pronouns.is_null: 

239 user.pronouns = None 

240 else: 

241 user.pronouns = request.pronouns.value 

242 

243 if request.HasField("occupation"): 

244 if request.occupation.is_null: 

245 user.occupation = None 

246 else: 

247 user.occupation = request.occupation.value 

248 

249 if request.HasField("education"): 

250 if request.education.is_null: 

251 user.education = None 

252 else: 

253 user.education = request.education.value 

254 

255 if request.HasField("about_me"): 

256 if request.about_me.is_null: 

257 user.about_me = None 

258 else: 

259 user.about_me = request.about_me.value 

260 

261 if request.HasField("my_travels"): 

262 if request.my_travels.is_null: 

263 user.my_travels = None 

264 else: 

265 user.my_travels = request.my_travels.value 

266 

267 if request.HasField("things_i_like"): 

268 if request.things_i_like.is_null: 

269 user.things_i_like = None 

270 else: 

271 user.things_i_like = request.things_i_like.value 

272 

273 if request.HasField("about_place"): 

274 if request.about_place.is_null: 

275 user.about_place = None 

276 else: 

277 user.about_place = request.about_place.value 

278 

279 if request.hosting_status != api_pb2.HOSTING_STATUS_UNSPECIFIED: 

280 user.hosting_status = hostingstatus2sql[request.hosting_status] 

281 

282 if request.meetup_status != api_pb2.MEETUP_STATUS_UNSPECIFIED: 

283 user.meetup_status = meetupstatus2sql[request.meetup_status] 

284 

285 if request.HasField("language_abilities"): 

286 # delete all existing abilities 

287 for ability in user.language_abilities: 

288 session.delete(ability) 

289 session.flush() 

290 

291 # add the new ones 

292 for language_ability in request.language_abilities.value: 

293 if not language_is_allowed(language_ability.code): 

294 context.abort(grpc.StatusCode.INVALID_ARGUMENT, errors.INVALID_LANGUAGE) 

295 session.add( 

296 LanguageAbility( 

297 user=user, 

298 language_code=language_ability.code, 

299 fluency=fluency2sql[language_ability.fluency], 

300 ) 

301 ) 

302 

303 if request.HasField("regions_visited"): 

304 session.execute(delete(RegionVisited).where(RegionVisited.user_id == context.user_id)) 

305 

306 for region in request.regions_visited.value: 

307 if not region_is_allowed(region): 

308 context.abort(grpc.StatusCode.INVALID_ARGUMENT, errors.INVALID_REGION) 

309 session.add( 

310 RegionVisited( 

311 user_id=user.id, 

312 region_code=region, 

313 ) 

314 ) 

315 

316 if request.HasField("regions_lived"): 

317 session.execute(delete(RegionLived).where(RegionLived.user_id == context.user_id)) 

318 

319 for region in request.regions_lived.value: 

320 if not region_is_allowed(region): 

321 context.abort(grpc.StatusCode.INVALID_ARGUMENT, errors.INVALID_REGION) 

322 session.add( 

323 RegionLived( 

324 user_id=user.id, 

325 region_code=region, 

326 ) 

327 ) 

328 

329 if request.HasField("additional_information"): 

330 if request.additional_information.is_null: 

331 user.additional_information = None 

332 else: 

333 user.additional_information = request.additional_information.value 

334 

335 if request.HasField("max_guests"): 

336 if request.max_guests.is_null: 

337 user.max_guests = None 

338 else: 

339 user.max_guests = request.max_guests.value 

340 

341 if request.HasField("last_minute"): 

342 if request.last_minute.is_null: 

343 user.last_minute = None 

344 else: 

345 user.last_minute = request.last_minute.value 

346 

347 if request.HasField("has_pets"): 

348 if request.has_pets.is_null: 

349 user.has_pets = None 

350 else: 

351 user.has_pets = request.has_pets.value 

352 

353 if request.HasField("accepts_pets"): 

354 if request.accepts_pets.is_null: 

355 user.accepts_pets = None 

356 else: 

357 user.accepts_pets = request.accepts_pets.value 

358 

359 if request.HasField("pet_details"): 

360 if request.pet_details.is_null: 

361 user.pet_details = None 

362 else: 

363 user.pet_details = request.pet_details.value 

364 

365 if request.HasField("has_kids"): 

366 if request.has_kids.is_null: 

367 user.has_kids = None 

368 else: 

369 user.has_kids = request.has_kids.value 

370 

371 if request.HasField("accepts_kids"): 

372 if request.accepts_kids.is_null: 

373 user.accepts_kids = None 

374 else: 

375 user.accepts_kids = request.accepts_kids.value 

376 

377 if request.HasField("kid_details"): 

378 if request.kid_details.is_null: 

379 user.kid_details = None 

380 else: 

381 user.kid_details = request.kid_details.value 

382 

383 if request.HasField("has_housemates"): 

384 if request.has_housemates.is_null: 

385 user.has_housemates = None 

386 else: 

387 user.has_housemates = request.has_housemates.value 

388 

389 if request.HasField("housemate_details"): 

390 if request.housemate_details.is_null: 

391 user.housemate_details = None 

392 else: 

393 user.housemate_details = request.housemate_details.value 

394 

395 if request.HasField("wheelchair_accessible"): 

396 if request.wheelchair_accessible.is_null: 

397 user.wheelchair_accessible = None 

398 else: 

399 user.wheelchair_accessible = request.wheelchair_accessible.value 

400 

401 if request.smoking_allowed != api_pb2.SMOKING_LOCATION_UNSPECIFIED: 

402 user.smoking_allowed = smokinglocation2sql[request.smoking_allowed] 

403 

404 if request.HasField("smokes_at_home"): 

405 if request.smokes_at_home.is_null: 

406 user.smokes_at_home = None 

407 else: 

408 user.smokes_at_home = request.smokes_at_home.value 

409 

410 if request.HasField("drinking_allowed"): 

411 if request.drinking_allowed.is_null: 

412 user.drinking_allowed = None 

413 else: 

414 user.drinking_allowed = request.drinking_allowed.value 

415 

416 if request.HasField("drinks_at_home"): 

417 if request.drinks_at_home.is_null: 

418 user.drinks_at_home = None 

419 else: 

420 user.drinks_at_home = request.drinks_at_home.value 

421 

422 if request.HasField("other_host_info"): 

423 if request.other_host_info.is_null: 

424 user.other_host_info = None 

425 else: 

426 user.other_host_info = request.other_host_info.value 

427 

428 if request.sleeping_arrangement != api_pb2.SLEEPING_ARRANGEMENT_UNSPECIFIED: 

429 user.sleeping_arrangement = sleepingarrangement2sql[request.sleeping_arrangement] 

430 

431 if request.HasField("sleeping_details"): 

432 if request.sleeping_details.is_null: 

433 user.sleeping_details = None 

434 else: 

435 user.sleeping_details = request.sleeping_details.value 

436 

437 if request.HasField("area"): 

438 if request.area.is_null: 

439 user.area = None 

440 else: 

441 user.area = request.area.value 

442 

443 if request.HasField("house_rules"): 

444 if request.house_rules.is_null: 

445 user.house_rules = None 

446 else: 

447 user.house_rules = request.house_rules.value 

448 

449 if request.HasField("parking"): 

450 if request.parking.is_null: 

451 user.parking = None 

452 else: 

453 user.parking = request.parking.value 

454 

455 if request.parking_details != api_pb2.PARKING_DETAILS_UNSPECIFIED: 

456 user.parking_details = parkingdetails2sql[request.parking_details] 

457 

458 if request.HasField("camping_ok"): 

459 if request.camping_ok.is_null: 

460 user.camping_ok = None 

461 else: 

462 user.camping_ok = request.camping_ok.value 

463 

464 # save updates 

465 session.commit() 

466 

467 return empty_pb2.Empty() 

468 

469 def ListFriends(self, request, context): 

470 with session_scope() as session: 

471 rels = ( 

472 session.execute( 

473 select(FriendRelationship) 

474 .where_users_column_visible(context, FriendRelationship.from_user_id) 

475 .where_users_column_visible(context, FriendRelationship.to_user_id) 

476 .where( 

477 or_( 

478 FriendRelationship.from_user_id == context.user_id, 

479 FriendRelationship.to_user_id == context.user_id, 

480 ) 

481 ) 

482 .where(FriendRelationship.status == FriendStatus.accepted) 

483 ) 

484 .scalars() 

485 .all() 

486 ) 

487 return api_pb2.ListFriendsRes( 

488 user_ids=[rel.from_user.id if rel.from_user.id != context.user_id else rel.to_user.id for rel in rels], 

489 ) 

490 

491 def ListMutualFriends(self, request, context): 

492 if context.user_id == request.user_id: 

493 return api_pb2.ListMutualFriendsRes(mutual_friends=[]) 

494 

495 with session_scope() as session: 

496 user = session.execute( 

497 select(User).where_users_visible(context).where(User.id == request.user_id) 

498 ).scalar_one_or_none() 

499 

500 if not user: 

501 context.abort(grpc.StatusCode.NOT_FOUND, errors.USER_NOT_FOUND) 

502 

503 q1 = ( 

504 select(FriendRelationship.from_user_id.label("user_id")) 

505 .where(FriendRelationship.to_user_id == context.user_id) 

506 .where(FriendRelationship.from_user_id != request.user_id) 

507 .where(FriendRelationship.status == FriendStatus.accepted) 

508 ) 

509 

510 q2 = ( 

511 select(FriendRelationship.to_user_id.label("user_id")) 

512 .where(FriendRelationship.from_user_id == context.user_id) 

513 .where(FriendRelationship.to_user_id != request.user_id) 

514 .where(FriendRelationship.status == FriendStatus.accepted) 

515 ) 

516 

517 q3 = ( 

518 select(FriendRelationship.from_user_id.label("user_id")) 

519 .where(FriendRelationship.to_user_id == request.user_id) 

520 .where(FriendRelationship.from_user_id != context.user_id) 

521 .where(FriendRelationship.status == FriendStatus.accepted) 

522 ) 

523 

524 q4 = ( 

525 select(FriendRelationship.to_user_id.label("user_id")) 

526 .where(FriendRelationship.from_user_id == request.user_id) 

527 .where(FriendRelationship.to_user_id != context.user_id) 

528 .where(FriendRelationship.status == FriendStatus.accepted) 

529 ) 

530 

531 mutual = select(intersect(union(q1, q2), union(q3, q4)).subquery()) 

532 

533 mutual_friends = ( 

534 session.execute(select(User).where_users_visible(context).where(User.id.in_(mutual))).scalars().all() 

535 ) 

536 

537 return api_pb2.ListMutualFriendsRes( 

538 mutual_friends=[ 

539 api_pb2.MutualFriend( 

540 user_id=mutual_friend.id, username=mutual_friend.username, name=mutual_friend.name 

541 ) 

542 for mutual_friend in mutual_friends 

543 ] 

544 ) 

545 

546 def SendFriendRequest(self, request, context): 

547 if context.user_id == request.user_id: 

548 context.abort(grpc.StatusCode.FAILED_PRECONDITION, errors.CANT_FRIEND_SELF) 

549 

550 with session_scope() as session: 

551 user = session.execute(select(User).where(User.id == context.user_id)).scalar_one() 

552 to_user = session.execute( 

553 select(User).where_users_visible(context).where(User.id == request.user_id) 

554 ).scalar_one_or_none() 

555 

556 if not to_user: 

557 context.abort(grpc.StatusCode.NOT_FOUND, errors.USER_NOT_FOUND) 

558 

559 if ( 

560 session.execute( 

561 select(FriendRelationship) 

562 .where( 

563 or_( 

564 and_( 

565 FriendRelationship.from_user_id == context.user_id, 

566 FriendRelationship.to_user_id == request.user_id, 

567 ), 

568 and_( 

569 FriendRelationship.from_user_id == request.user_id, 

570 FriendRelationship.to_user_id == context.user_id, 

571 ), 

572 ) 

573 ) 

574 .where( 

575 or_( 

576 FriendRelationship.status == FriendStatus.accepted, 

577 FriendRelationship.status == FriendStatus.pending, 

578 ) 

579 ) 

580 ).scalar_one_or_none() 

581 is not None 

582 ): 

583 context.abort(grpc.StatusCode.FAILED_PRECONDITION, errors.FRIENDS_ALREADY_OR_PENDING) 

584 

585 # TODO: Race condition where we can create two friend reqs, needs db constraint! See comment in table 

586 

587 friend_relationship = FriendRelationship(from_user=user, to_user=to_user, status=FriendStatus.pending) 

588 session.add(friend_relationship) 

589 session.commit() 

590 

591 send_friend_request_email(friend_relationship) 

592 

593 notify( 

594 user_id=friend_relationship.to_user_id, 

595 topic="friend_request", 

596 key=str(friend_relationship.from_user_id), 

597 action="send", 

598 avatar_key=user.avatar.thumbnail_url if user.avatar else None, 

599 icon="person", 

600 title=f"**{user.name}** sent you a friend request", 

601 link=urls.friend_requests_link(), 

602 ) 

603 

604 return empty_pb2.Empty() 

605 

606 def ListFriendRequests(self, request, context): 

607 # both sent and received 

608 with session_scope() as session: 

609 sent_requests = ( 

610 session.execute( 

611 select(FriendRelationship) 

612 .where_users_column_visible(context, FriendRelationship.to_user_id) 

613 .where(FriendRelationship.from_user_id == context.user_id) 

614 .where(FriendRelationship.status == FriendStatus.pending) 

615 ) 

616 .scalars() 

617 .all() 

618 ) 

619 

620 received_requests = ( 

621 session.execute( 

622 select(FriendRelationship) 

623 .where_users_column_visible(context, FriendRelationship.from_user_id) 

624 .where(FriendRelationship.to_user_id == context.user_id) 

625 .where(FriendRelationship.status == FriendStatus.pending) 

626 ) 

627 .scalars() 

628 .all() 

629 ) 

630 

631 return api_pb2.ListFriendRequestsRes( 

632 sent=[ 

633 api_pb2.FriendRequest( 

634 friend_request_id=friend_request.id, 

635 state=api_pb2.FriendRequest.FriendRequestStatus.PENDING, 

636 user_id=friend_request.to_user.id, 

637 sent=True, 

638 ) 

639 for friend_request in sent_requests 

640 ], 

641 received=[ 

642 api_pb2.FriendRequest( 

643 friend_request_id=friend_request.id, 

644 state=api_pb2.FriendRequest.FriendRequestStatus.PENDING, 

645 user_id=friend_request.from_user.id, 

646 sent=False, 

647 ) 

648 for friend_request in received_requests 

649 ], 

650 ) 

651 

652 def RespondFriendRequest(self, request, context): 

653 with session_scope() as session: 

654 friend_request = session.execute( 

655 select(FriendRelationship) 

656 .where_users_column_visible(context, FriendRelationship.from_user_id) 

657 .where(FriendRelationship.to_user_id == context.user_id) 

658 .where(FriendRelationship.status == FriendStatus.pending) 

659 .where(FriendRelationship.id == request.friend_request_id) 

660 ).scalar_one_or_none() 

661 

662 if not friend_request: 

663 context.abort(grpc.StatusCode.NOT_FOUND, errors.FRIEND_REQUEST_NOT_FOUND) 

664 

665 friend_request.status = FriendStatus.accepted if request.accept else FriendStatus.rejected 

666 friend_request.time_responded = func.now() 

667 

668 if friend_request.status == FriendStatus.accepted: 

669 send_friend_request_accepted_email(friend_request) 

670 

671 session.commit() 

672 

673 if friend_request.status == FriendStatus.accepted: 

674 notify( 

675 user_id=friend_request.from_user_id, 

676 topic="friend_request", 

677 key=str(friend_request.to_user_id), 

678 action="accept", 

679 avatar_key=friend_request.to_user.avatar.thumbnail_url if friend_request.to_user.avatar else None, 

680 icon="person", 

681 title=f"**{friend_request.from_user.name}** accepted your friend request", 

682 link=urls.user_link(username=friend_request.to_user.username), 

683 ) 

684 

685 return empty_pb2.Empty() 

686 

687 def CancelFriendRequest(self, request, context): 

688 with session_scope() as session: 

689 friend_request = session.execute( 

690 select(FriendRelationship) 

691 .where_users_column_visible(context, FriendRelationship.to_user_id) 

692 .where(FriendRelationship.from_user_id == context.user_id) 

693 .where(FriendRelationship.status == FriendStatus.pending) 

694 .where(FriendRelationship.id == request.friend_request_id) 

695 ).scalar_one_or_none() 

696 

697 if not friend_request: 

698 context.abort(grpc.StatusCode.NOT_FOUND, errors.FRIEND_REQUEST_NOT_FOUND) 

699 

700 friend_request.status = FriendStatus.cancelled 

701 friend_request.time_responded = func.now() 

702 

703 # note no notifications 

704 

705 session.commit() 

706 

707 return empty_pb2.Empty() 

708 

709 def InitiateMediaUpload(self, request, context): 

710 key = random_hex() 

711 

712 created = now() 

713 expiry = created + timedelta(minutes=20) 

714 

715 with session_scope() as session: 

716 upload = InitiatedUpload(key=key, created=created, expiry=expiry, initiator_user_id=context.user_id) 

717 session.add(upload) 

718 session.commit() 

719 

720 req = media_pb2.UploadRequest( 

721 key=upload.key, 

722 type=media_pb2.UploadRequest.UploadType.IMAGE, 

723 created=Timestamp_from_datetime(upload.created), 

724 expiry=Timestamp_from_datetime(upload.expiry), 

725 max_width=2000, 

726 max_height=1600, 

727 ).SerializeToString() 

728 

729 data = b64encode(req) 

730 sig = b64encode(generate_hash_signature(req, config["MEDIA_SERVER_SECRET_KEY"])) 

731 

732 path = "upload?" + urlencode({"data": data, "sig": sig}) 

733 

734 return api_pb2.InitiateMediaUploadRes( 

735 upload_url=urls.media_upload_url(path=path), 

736 expiry=Timestamp_from_datetime(expiry), 

737 ) 

738 

739 

740def user_model_to_pb(db_user, session, context): 

741 num_references = session.execute( 

742 select(func.count()) 

743 .select_from(Reference) 

744 .join(User, User.id == Reference.from_user_id) 

745 .where(User.is_visible) 

746 .where(Reference.to_user_id == db_user.id) 

747 ).scalar_one() 

748 

749 # returns (lat, lng) 

750 # we put people without coords on null island 

751 # https://en.wikipedia.org/wiki/Null_Island 

752 lat, lng = db_user.coordinates or (0, 0)