Merge branch 'user_locations' into main

Author: Léo Guillaume

api/app/Controllers/Http/UserLocationsController.ts

@@ -0,0 +1,15 @@
+import BaseController from 'App/Controllers/Http/BaseController'
+import UserLocationService from 'App/Services/UserLocationService'
+import { HttpContextContract } from '@ioc:Adonis/Core/HttpContext'
+import UserLocationValidator from 'App/Validators/UserLocationValidator'
+
+export default class UserLocationsController extends BaseController {
+  public async getAllByUserId() {
+    return await UserLocationService.getAllByUserId()
+  }
+
+  public async update({ request }: HttpContextContract) {
+    const { locations } = await request.validate(UserLocationValidator)
+    return await UserLocationService.update(locations)
+  }
+}

api/app/Models/Property.ts

@@ -11,6 +11,7 @@ export interface TravelTimes {
   driving: number
   walking: number
   transit: number
+  bicycling: number
 }
 
 export default class Property extends BaseModel {
@@ -114,6 +115,7 @@ export default class Property extends BaseModel {
       driving: travelTimes.driving || 0,
       walking: travelTimes.walking || 0,
       transit: travelTimes.transit || 0,
+      bicycling: travelTimes.bicycling || 0,
     }
   }
 

api/app/Models/Search.ts

@@ -2,7 +2,6 @@ import { DateTime } from 'luxon'
 import { column, BaseModel, belongsTo, manyToMany } from '@ioc:Adonis/Lucid/Orm'
 import type { BelongsTo, ManyToMany } from '@ioc:Adonis/Lucid/Orm'
 import User from 'App/Models/User'
-import Location from 'App/Models/Location'
 
 export default class Search extends BaseModel {
   @column({ isPrimary: true })
@@ -11,17 +10,9 @@ export default class Search extends BaseModel {
   @column()
   public name: string
 
-  @column()
-  public location_id: number
-
   @column()
   public creator_id: number
 
-  @belongsTo(() => Location, {
-    foreignKey: 'location_id',
-  })
-  public location: BelongsTo<typeof Location>
-
   @belongsTo(() => User, {
     foreignKey: 'creator_id',
     serializeAs: null,

api/app/Models/UserLocation.ts

@@ -0,0 +1,35 @@
+import { DateTime } from 'luxon'
+import { BaseModel, belongsTo, column } from '@ioc:Adonis/Lucid/Orm'
+import type { BelongsTo } from '@ioc:Adonis/Lucid/Orm'
+import User from 'App/Models/User'
+import Location from 'App/Models/Location'
+
+export default class UserLocation extends BaseModel {
+  @column({ isPrimary: true })
+  public id: number
+
+  @column()
+  public name: string | null
+
+  @column()
+  public user_id: number
+
+  @column()
+  public location_id: number
+
+  @belongsTo(() => User, {
+    foreignKey: 'user_id',
+  })
+  public user: BelongsTo<typeof User>
+
+  @belongsTo(() => Location, {
+    foreignKey: 'location_id',
+  })
+  public location: BelongsTo<typeof Location>
+
+  @column.dateTime({ autoCreate: true })
+  public createdAt: DateTime
+
+  @column.dateTime({ autoCreate: true, autoUpdate: true })
+  public updatedAt: DateTime
+}

api/app/Services/GoogleMapsService.ts

@@ -1,15 +1,27 @@
 import { Client, TravelMode } from '@googlemaps/google-maps-services-js'
 import Env from '@ioc:Adonis/Core/Env'
 
+type GoogleTransit = {
+  driving?: number
+  walking?: number
+  transit?: number
+  bicycling?: number
+}
+
 export class GoogleMapsService {
   private static client = new Client({})
 
   public static async getTravelTimes(
     origin: { lat: number; lng: number },
     destination: { lat: number; lng: number }
-  ): Promise<{ driving?: number; walking?: number; transit?: number }> {
-    const result: { driving?: number; walking?: number; transit?: number } = {}
-    const modes: TravelMode[] = [TravelMode.driving, TravelMode.walking, TravelMode.transit]
+  ): Promise<GoogleTransit> {
+    const result: GoogleTransit = {}
+    const modes: TravelMode[] = [
+      TravelMode.driving,
+      TravelMode.walking,
+      TravelMode.transit,
+      TravelMode.bicycling,
+    ]
     for (const mode of modes) {
       const response = await this.client.directions({
         params: {

api/app/Services/PropertyService.ts

@@ -4,52 +4,59 @@ import Property, { TravelTimes } from 'App/Models/Property'
 import PropertyValidator from 'App/Validators/PropertyValidator'
 import SearchService from 'App/Services/SearchService'
 import type { PropertyRatingWithUser } from 'App/Models/PropertyRating'
+import UserLocationService from 'App/Services/UserLocationService'
+import UserLocation from 'App/Models/UserLocation'
 
 interface ServiceProperty extends Omit<Property, 'ratings'> {
-  travelTimes: TravelTimes
   average_ratings?: number
   ratings: PropertyRatingWithUser[]
 }
 
+type UserLocationWithTravelTime = {
+  userLocation: UserLocation
+  travelTimes: TravelTimes
+}
+
+interface ServicePropertyWithLocations extends ServiceProperty {
+  locations: Array<UserLocationWithTravelTime>
+}
+
 export default class PropertyService extends BaseService {
-  public static async getSearchProperties(searchId: number): Promise<ServiceProperty[] | null> {
+  public static async getSearchProperties(searchId: number): Promise<Property[] | null> {
     const search = await SearchService.getById(searchId)
     if (!search) return null
 
-    const properties = await Property.query()
+    return await Property.query()
       .where('search_id', search?.id)
       .where('is_deleted', false)
       .preload('location')
       .preload('ratings')
       .orderBy('created_at', 'desc')
       .exec()
-
-    return await Promise.all(
-      properties.map(async (property) => {
-        let travelTimes = { driving: 0, transit: 0, walking: 0 }
-        try {
-          travelTimes = await property.getTravelTimes({
-            lat: search.location.lat,
-            lng: search.location.lng,
-          })
-        } catch (e) {
-          console.log(e)
-        }
-        return { ...property.toJSON(), travelTimes } as ServiceProperty
-      })
-    )
   }
 
   public static async findById(id: number, searchId: number) {
     const property = await this.getById(id, searchId)
 
-    const search = await SearchService.getById(searchId)
-    if (!search || !property) return super.response.notFound()
+    const userLocations = await UserLocationService.getAllByUserId()
+    if (!property) return super.response.notFound()
 
-    const travelTimes = await property.getTravelTimes({
-      lat: search.location.lat,
-      lng: search.location.lng,
-    })
+    let locations: Array<UserLocationWithTravelTime> = []
+
+    if (userLocations) {
+      locations = await Promise.all(
+        userLocations.map(async (location) => {
+          const travelTimes = await property.getTravelTimes({
+            lat: location.location.lat,
+            lng: location.location.lng,
+          })
+          return {
+            userLocation: location,
+            travelTimes,
+          }
+        })
+      )
+    }
 
     const propertyObj: Property = property.toJSON() as Property
 
@@ -59,10 +66,10 @@ export default class PropertyService extends BaseService {
 
     return {
       ...propertyObj,
-      travelTimes,
+      locations,
       ratings,
       average_ratings: property.averageRating,
-    } as ServiceProperty
+    } as ServicePropertyWithLocations
   }
 
   public static async getById(id: number, searchId: number) {

api/app/Services/SearchService.ts

@@ -3,7 +3,6 @@ import Search from 'App/Models/Search'
 import SearchValidator from 'App/Validators/SearchValidator'
 import AuthService from 'App/Services/AuthService'
 import SearchUser from 'App/Models/SearchUser'
-import LocationService from 'App/Services/LocationService'
 import User from 'App/Models/User'
 import merge from 'lodash/merge'
 
@@ -21,7 +20,6 @@ export default class SearchService extends BaseService {
   public static async getById(id: number) {
     const search = await Search.query()
       .preload('users')
-      .preload('location')
       .preload('creator')
       .where('id', id)
       .firstOrFail()
@@ -42,11 +40,9 @@ export default class SearchService extends BaseService {
       AuthService.unauthorized()
       return
     }
-    const location = await LocationService.create(data.location)
     const search = await Search.create({
       ...data,
       creator_id: super.auth.user?.id,
-      location_id: location.id,
     })
     await super.sendPrivateSuccessNotification(`Votre recherche a été créée avec succès !`)
     return await this.getById(search.id)
@@ -69,7 +65,6 @@ export default class SearchService extends BaseService {
         query.where('user_id', user.id)
       })
       .orWhere('creator_id', user.id)
-      .preload('location')
       .preload('creator')
       .preload('users')
       .orderBy('created_at', 'desc')

api/app/Services/UserLocationService.ts

@@ -0,0 +1,60 @@
+import BaseService from 'App/Services/BaseService'
+import UserLocation from 'App/Models/UserLocation'
+import AuthService from 'App/Services/AuthService'
+import LocationService from 'App/Services/LocationService'
+import type { LocationCommand } from 'App/Services/LocationService'
+
+interface UserLocationData {
+  name?: string
+  location: LocationCommand
+}
+
+export default class UserLocationService extends BaseService {
+  public static async update(data: UserLocationData[]) {
+    const userId = super.auth.user?.id
+    if (!userId) {
+      AuthService.unauthorized()
+      return
+    }
+
+    // Get current user_locations
+    const currentUserLocations = await this.getAllByUserId()
+
+    // Create new locations and user locations
+    for (const dataItem of data) {
+      // Create or find location
+      const location = await LocationService.create(dataItem.location)
+
+      // Create new user location
+      await UserLocation.create({
+        name: dataItem.name ?? null,
+        location_id: location.id,
+        user_id: userId,
+      })
+    }
+
+    // If new locations were created successfully, delete old ones
+    if (currentUserLocations) {
+      for (const oldLocation of currentUserLocations) {
+        await oldLocation.delete()
+      }
+    }
+
+    await super.sendPrivateSuccessNotification('Les lieux ont été mis à jour !')
+
+    return this.getAllByUserId()
+  }
+
+  public static async getAllByUserId() {
+    const user = super.auth.user
+    if (!user) {
+      AuthService.unauthorized()
+      return
+    }
+    return await UserLocation.query()
+      .where('user_id', user.id)
+      .preload('location')
+      .orderBy('created_at', 'desc')
+      .exec()
+  }
+}

api/app/Validators/SearchValidator.ts

@@ -1,11 +1,9 @@
 import { schema } from '@ioc:Adonis/Core/Validator'
 import { HttpContextContract } from '@ioc:Adonis/Core/HttpContext'
-import { locationSchema } from 'App/Validators/LocationValidator'
 
 export default class SearchValidator {
   constructor(protected ctx: HttpContextContract) {}
   public schema = schema.create({
     name: schema.string({ trim: true }),
-    location: schema.object().members(locationSchema),
   })
 }

api/app/Validators/UserLocationValidator.ts

@@ -0,0 +1,15 @@
+import { schema } from '@ioc:Adonis/Core/Validator'
+import { HttpContextContract } from '@ioc:Adonis/Core/HttpContext'
+import { locationSchema } from 'App/Validators/LocationValidator'
+
+export default class UserLocationValidator {
+  constructor(protected ctx: HttpContextContract) {}
+  public schema = schema.create({
+    locations: schema.array().members(
+      schema.object().members({
+        name: schema.string.optional({ trim: true }),
+        location: schema.object().members(locationSchema),
+      })
+    ),
+  })
+}