Fixing missed ride organized if empty/self-refference in AI preview

Author: feedbee

src/__tests__/commands/ai-ride-command-handler.test.js

@@ -38,7 +38,11 @@ describe.each(['en', 'ru'])('AiRideCommandHandler (%s)', (language) => {
     mockRideService = {
       getRide: jest.fn(),
       createRideFromParams: jest.fn(),
-      updateRideFromParams: jest.fn()
+      updateRideFromParams: jest.fn(),
+      resolveCreateOrganizer: jest.fn((organizer, profile) => {
+        if (organizer === 'Bob') return organizer;
+        return `${profile.firstName} ${profile.lastName} (@${profile.username})`;
+      })
     };
 
     mockMessageFormatter = {
@@ -607,6 +611,47 @@ describe.each(['en', 'ru'])('AiRideCommandHandler (%s)', (language) => {
     });
   });
 
+  describe('preview organizer', () => {
+    const setupAndProcess = async (params) => {
+      mockAiRideService.parseRideText.mockResolvedValue({ params, error: null });
+      mockCtx.message = { text: 'some text', message_id: 5 };
+      handler.states.set('42:100', {
+        mode: 'create', rideId: null, ride: null,
+        userMessages: [], messageCount: 0, lastParams: null,
+        previewMessageId: null, botMessageIds: [],
+        routeInfoCache: {}
+      });
+
+      await handler.handleTextInput(mockCtx);
+
+      return mockMessageFormatter.formatRidePreview.mock.calls[0]?.[0];
+    };
+
+    it('shows the creator as organizer in create preview when organizer is empty', async () => {
+      const preview = await setupAndProcess({ title: 'Ride', when: 'tomorrow' });
+
+      expect(preview.organizer).toBe('Alice Smith (@alice)');
+      expect(mockRideService.resolveCreateOrganizer).toHaveBeenCalledWith(
+        undefined,
+        expect.objectContaining({ userId: 42, username: 'alice', firstName: 'Alice', lastName: 'Smith' }),
+        { language }
+      );
+    });
+
+    it('shows the creator as organizer in create preview when organizer refers to self', async () => {
+      const selfOrganizer = language === 'ru' ? 'я' : 'me';
+      const preview = await setupAndProcess({ title: 'Ride', when: 'tomorrow', organizer: selfOrganizer });
+
+      expect(preview.organizer).toBe('Alice Smith (@alice)');
+    });
+
+    it('keeps explicit organizer in create preview when organizer is someone else', async () => {
+      const preview = await setupAndProcess({ title: 'Ride', when: 'tomorrow', organizer: 'Bob' });
+
+      expect(preview.organizer).toBe('Bob');
+    });
+  });
+
   // ─── route info enrichment in preview ───────────────────────────────────────
 
   describe('route info enrichment in preview', () => {

src/__tests__/services/ride-service.test.js

@@ -717,6 +717,19 @@ describe('RideService', () => {
       expect(result.ride.organizer).toBe('me');
     });
 
+    it('should resolve create organizer consistently for preview and persistence', () => {
+      const user = new UserProfile({
+        userId: 789,
+        firstName: 'Test',
+        lastName: 'User',
+        username: 'testuser'
+      });
+
+      expect(rideService.resolveCreateOrganizer(undefined, user, { language: 'ru' })).toBe('Test User (@testuser)');
+      expect(rideService.resolveCreateOrganizer('я', user, { language: 'ru' })).toBe('Test User (@testuser)');
+      expect(rideService.resolveCreateOrganizer('Bob', user, { language: 'ru' })).toBe('Bob');
+    });
+
     it('should handle organizer field when updating a ride', async () => {
       // First create a ride
       const ride = await rideService.createRide(testRide);

src/commands/AiRideCommandHandler.js

@@ -231,7 +231,11 @@ export class AiRideCommandHandler extends BaseCommandHandler {
     // state.lastParams stays as pure AI output; RideService re-parses on confirm.
     const previewParams = await this._enrichWithRouteInfo(params, state);
 
-    const previewObj = this._buildPreviewObject(previewParams, state);
+    const creatorProfile = UserProfile.fromTelegramUser(ctx.from);
+    const previewObj = this._buildPreviewObject(previewParams, state, {
+      creatorProfile,
+      language: ctx.lang
+    });
     const previewText = this.messageFormatter.formatRidePreview(previewObj, ctx.lang);
     const atLimit = state.messageCount >= MAX_DIALOG_MESSAGES;
     const fullText = atLimit
@@ -338,8 +342,9 @@ export class AiRideCommandHandler extends BaseCommandHandler {
    * reflects the full final state (existing + changes).
    * @param {Object} params - AI-extracted params
    * @param {Object|null} state - handler state (used to access existing ride in update mode)
+   * @param {{creatorProfile?: UserProfile|null, language?: string}} options
    */
-  _buildPreviewObject(params, state = null) {
+  _buildPreviewObject(params, state = null, options = {}) {
     const existingRide = state?.mode === 'update' ? state.ride : null;
     const routeInputs = params.routes ?? (params.route ? [params.route] : null);
     const clearsRoutes = Array.isArray(routeInputs) && routeInputs.length === 1 && routeInputs[0] === '-';
@@ -351,7 +356,7 @@ export class AiRideCommandHandler extends BaseCommandHandler {
       title:        params.title     || existingRide?.title       || null,
       date:         null,
       category:     null,
-      organizer:    params.organizer || existingRide?.organizer   || null,
+      organizer:    this._resolvePreviewOrganizer(params, state, options),
       meetingPoint: params.meet      || existingRide?.meetingPoint || null,
       routes:       clearsRoutes ? [] : (routeInputs ? (parsedPreviewRoutes || null) : getRideRoutes(existingRide)),
       distance:     params.dist      ? parseFloat(params.dist)
@@ -407,6 +412,26 @@ export class AiRideCommandHandler extends BaseCommandHandler {
     return preview;
   }
 
+  /**
+   * Resolve organizer for preview using the same creator fallback as ride creation.
+   * @param {Object} params
+   * @param {Object|null} state
+   * @param {{creatorProfile?: UserProfile|null, language?: string}} options
+   * @returns {string|null}
+   */
+  _resolvePreviewOrganizer(params, state = null, options = {}) {
+    const existingRide = state?.mode === 'update' ? state.ride : null;
+    if (existingRide) {
+      return params.organizer || existingRide.organizer || null;
+    }
+
+    return this.rideService.resolveCreateOrganizer(
+      params.organizer,
+      options.creatorProfile || null,
+      { language: options.language }
+    ) || null;
+  }
+
   async _executeRideOperation(ctx, stateKey, state) {
     const options = { language: ctx.lang };
     const creatorProfile = UserProfile.fromTelegramUser(ctx.from);

src/services/RideService.js

@@ -206,12 +206,7 @@ export class RideService {
       };
 
       // Set organizer name - use provided value or default to creator's name
-      if (this.isSelfOrganizerReference(rideData.organizer, language)) {
-        rideData.organizer = '';
-      }
-      if (!rideData.organizer && creatorProfile) {
-        rideData.organizer = this.getDefaultOrganizer(creatorProfile);
-      }
+      rideData.organizer = this.resolveCreateOrganizer(rideData.organizer, creatorProfile, { language });
 
       const ride = await this.createRide(rideData, creatorProfile);
       return { ride, error: null };
@@ -244,27 +239,32 @@ export class RideService {
   }
 
   /**
-   * Detect organizer values that mean "the creator".
+   * Resolve organizer value for a newly created ride.
    * @param {string} organizer
-   * @param {string} language
-   * @returns {boolean}
+   * @param {UserProfile|null} creatorProfile
+   * @param {{language?: string}} options
+   * @returns {string}
    */
-  isSelfOrganizerReference(organizer, language) {
-    if (typeof organizer !== 'string') return false;
-
+  resolveCreateOrganizer(organizer, creatorProfile, options = {}) {
     const references = t(
-      language || config.i18n.defaultLanguage,
+      options.language || config.i18n.defaultLanguage,
       'services.ride.selfOrganizerReferences',
       {},
       {
         fallbackLanguage: config.i18n.fallbackLanguage,
         withMissingMarker: false
       }
     );
-    if (!Array.isArray(references)) return false;
+    const normalized = typeof organizer === 'string'
+      ? organizer.trim().toLowerCase().replace(/[.!?]+$/g, '')
+      : '';
+    const refersToCreator = Array.isArray(references) && references.includes(normalized);
+
+    if (!organizer || refersToCreator) {
+      return creatorProfile ? this.getDefaultOrganizer(creatorProfile) : '';
+    }
 
-    const normalized = organizer.trim().toLowerCase().replace(/[.!?]+$/g, '');
-    return references.includes(normalized);
+    return organizer;
   }
 
   /**