@flower-city-online/itinerary-lib 0.0.9 → 0.0.10

package/src/lib/itinerary-app/_models/Itinerary.ts

@@ -0,0 +1,24 @@
+import { LocationModel } from '@naniteninja/ionic-lib';
+import { ItineraryLocation } from './itinerary-location';
+import { ItineraryStats } from './Itinerary-stats';
+import { AppUser } from './app-user';
+
+export interface Itinerary {
+  id: string;
+  name: string;
+  description?: string;
+  distance?: string;
+  distanceValue?: string;
+  startLocation?: LocationModel;
+  endLocation?: LocationModel;
+  routeTypes?: string[];
+  routeRadius?: number;
+  createdAt: string;
+  visitingPlaces?: ItineraryLocation[];
+  isCompleted: boolean;
+  stats?: ItineraryStats;
+  statsId?: string;
+  user?: AppUser;
+  isDraft?: boolean;
+  image?:  string;
+}

package/src/lib/itinerary-app/_models/app-user.ts

@@ -0,0 +1,6 @@
+export interface AppUser {
+  id: string;
+  name: string;
+  email: string;
+  image?: string;
+}

package/src/lib/itinerary-app/_models/favorite-itinerary.ts

@@ -0,0 +1,5 @@
+export interface FavouriteItinerary {
+  id: string;
+  itineraryId: string;
+  memberId: string;
+}

package/src/lib/itinerary-app/_models/itinerary-location.ts

@@ -0,0 +1,17 @@
+import { SelectOption } from '@naniteninja/ionic-lib';
+import { IItineraryMember } from './itineraryMember';
+import { LocationReview } from './location-review';
+import { PositionModel } from './position-model';
+
+export interface ItineraryLocation {
+  id: string;
+  title: string;
+  description: string;
+  type: string;
+  review: LocationReview;
+  position: PositionModel;
+  interests: SelectOption<string>[]; 
+  members: IItineraryMember[];
+  numberOfPlaces: number;
+  timeToSpend: string;
+}

package/src/lib/itinerary-app/_models/itineraryMember.ts

@@ -0,0 +1,6 @@
+export interface IItineraryMember {
+  memberName: string;
+  memberEmail: string;
+  memberPic: string;
+  added: boolean;
+}

package/src/lib/itinerary-app/_models/location-review.ts

@@ -0,0 +1,9 @@
+import { Place } from '@naniteninja/ionic-lib';
+
+export interface LocationReview {
+  id: string;
+  review: string;
+  rating: number;
+  placeId: string;
+  place?: Place;
+}

package/src/lib/itinerary-app/_models/matching-clients.ts

@@ -0,0 +1,9 @@
+export interface MatchingClients {
+    memberName: string;
+    clientName: string;
+    memberEmail: string;
+    clientEmail: string;
+    memberPic: string;
+    clientPic: string;
+    matchPercentage: number;
+}

package/src/lib/itinerary-app/_models/position-model.ts

@@ -0,0 +1,5 @@
+export interface PositionModel {
+    lat: number,
+    lon: number,
+    address: string,
+}

package/src/lib/itinerary-app/_pipes/votes.pipe.ts

@@ -0,0 +1,16 @@
+import { Pipe, PipeTransform } from '@angular/core';
+
+@Pipe({
+  name: 'votes',
+})
+export class VotesPipe implements PipeTransform {
+  transform(value: number): string {
+    if (value >= 1_000_000) {
+      return (value / 1_000_000).toFixed(1).replace(/\.0$/, '') + 'M';
+    } else if (value >= 1_000) {
+      return (value / 1_000).toFixed(1).replace(/\.0$/, '') + 'K';
+    } else {
+      return value.toString();
+    }
+  }
+}

package/src/lib/itinerary-app/_services/api.service.ts

@@ -0,0 +1,28 @@
+import { HttpClient, HttpParams } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class ApiService {
+  private readonly baseUrl = '';
+
+  constructor(private http: HttpClient) {}
+
+  get<T>(endpoint: string, params?: HttpParams): Observable<T> {
+    return this.http.get<T>(`${this.baseUrl}${endpoint}`, { params });
+  }
+
+  post<T>(endpoint: string, body: any, options?: {}): Observable<T> {
+    return this.http.post<T>(`${this.baseUrl}${endpoint}`, body, options);
+  }
+
+  put<T>(endpoint: string, body: any, options?: {}): Observable<T> {
+    return this.http.put<T>(`${this.baseUrl}${endpoint}`, body, options);
+  }
+
+  delete<T>(endpoint: string, options?: {}): Observable<T> {
+    return this.http.delete<T>(`${this.baseUrl}${endpoint}`, options);
+  }
+}

package/src/lib/itinerary-app/_services/assets.service.ts

@@ -0,0 +1,38 @@
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { Observable } from 'rxjs'; 
+import { INotification } from '../_interface/notification';
+import { ISearchPopup } from '../_interface/search-popup';
+import { IItineraryMember } from '../_models/itineraryMember';
+import { MatchingClients } from '../_models/matching-clients';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class AssetsService {
+  constructor(private http: HttpClient) {}
+
+  getMembers(): Observable<IItineraryMember[]> {
+    return this.http.get<IItineraryMember[]>('/assets/totalMembers.json');
+  }
+
+  getGlobalSearch(): Observable<ISearchPopup[]> { 
+    return this.http.get<ISearchPopup[]>('/assets/globalSearch.json');
+  }
+
+  getNotifications(): Observable<INotification[]> {
+    return this.http.get<INotification[]>('/assets/notifications.json');
+  }
+
+  getTranslation(fileName: 'en' | 'es' | 'fr'): Observable<any> {
+    return this.http.get(`/assets/i18n/${fileName}.json`);
+  }
+
+  getMatchingClients(): Observable<MatchingClients[]> {
+    return this.http.get<MatchingClients[]>('/assets/matchingClients.json');
+  }
+
+  clearSearchHistory(): Observable<void> {
+    return this.http.delete<void>('/assets/matchingClients.json', {});
+  }
+}

package/src/lib/itinerary-app/_services/bottom-navigation.service.ts

@@ -0,0 +1,92 @@
+import { Injectable } from '@angular/core'; 
+import { ItinerariesRoutesEnum } from '../_enums/ItenariesRoutes.enum';
+import { IBottomNavigationList } from '../_interface/bottomNavigationList';
+import { Iicon } from '../_interface/icon';
+import { ICONS } from '../_constants/constants';
+import { Router } from '@angular/router';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class BottomNavigationService {
+  public isShowNavigation: boolean = false;
+  ICONS: Iicon = ICONS;
+  bottomNavList = [
+    {
+      id: 1,
+      label: 'Home',
+      iconPath: ICONS['home'],
+      clickedIconPath: ICONS['homeRed'],
+      routerLink: ItinerariesRoutesEnum.ITINERARY_EXPLORE,
+      cssClass: '',
+      height: '16',
+      width: '17',
+      selected: false,
+    },
+    {
+      id: 2,
+      label: 'Requests',
+      iconPath: ICONS['favorite'],
+      clickedIconPath: ICONS['favorite'],
+      routerLink: ItinerariesRoutesEnum.REQUESTS,
+      cssClass: '',
+      height: '19',
+      width: '19',
+      selected: false,
+    },
+    {
+      id: 3,
+      label: 'Info',
+      iconPath: ICONS['chat'],
+      clickedIconPath: ICONS['chatRed'],
+      routerLink: ItinerariesRoutesEnum.INFO,
+      cssClass: '',
+      height: '16',
+      width: '17',
+      selected: false,
+    },
+    {
+      id: 4,
+      label: 'Itineraries',
+      iconPath: ICONS['itineraries'],
+      clickedIconPath: ICONS['itinerariesRed'],
+      routerLink: ItinerariesRoutesEnum.ITINERARY_BUILDER,
+      cssClass: '',
+      height: '16',
+      width: '17',
+      selected: false,
+    },
+    {
+      id: 5,
+      label: 'Profile',
+      iconPath: ICONS['user'],
+      clickedIconPath: ICONS['userRed'],
+      routerLink: ItinerariesRoutesEnum.PROFILE,
+      cssClass: '',
+      height: '16',
+      width: '17',
+      selected: false,
+    },
+  ];
+  constructor(private readonly router: Router) {
+    
+  }
+
+  onNavigationChange(
+    data: IBottomNavigationList[],
+    nav: IBottomNavigationList,
+  ): void {
+    if(data) {
+      this.router.navigate([nav.routerLink]);
+    }
+  }
+
+  setActive(nav: IBottomNavigationList): void {
+    this.bottomNavList.forEach((element: IBottomNavigationList) => {
+      element.cssClass = '';
+      if(nav.id === element.id) {
+        element.cssClass = 'active';
+      }
+    });
+  }
+}

package/src/lib/itinerary-app/_services/comment-image.service.ts

@@ -0,0 +1,11 @@
+import { Injectable } from '@angular/core';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class CommentImageService {
+  constructor() {}
+
+  image: string[] = [];
+  index: number = 0;
+}

package/src/lib/itinerary-app/_services/constants.service.ts

@@ -0,0 +1,8 @@
+import { Injectable } from '@angular/core';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class ConstantsService {
+  readonly SPECIAL_VALUE = 9;
+}

package/src/lib/itinerary-app/_services/custom-dropdown-menu.service.ts

@@ -0,0 +1,260 @@
+import { Injectable } from '@angular/core';
+import { Router } from '@angular/router';
+import { TranslateService } from '@ngx-translate/core';
+import { LibMenuItem } from '@naniteninja/ionic-lib';
+import { ModalService } from './modal.service'; 
+import { Iicon } from '../_interface/icon';
+import { ICONS } from '../_constants/constants';
+import { ModalSendClientService } from './modal.sendclient.service';
+import { ModalShareUrlClientService } from './modal.shareurlservice';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class CustomDropdownMenuService {
+  cssClasses = ['custom-modal-class'];
+  ICONS: Iicon = ICONS;
+  itemList: LibMenuItem[] = [
+    {
+      title: 'EDIT_ITINERARY',
+      iconUrl: ICONS['edit'],
+    },
+    {
+      title: 'ARCHIVE',
+      iconUrl: ICONS['archiveWhite'],
+    },
+    {
+      title: 'UNPUBLISH',
+      iconUrl: ICONS['unpublish'],
+    },
+    {
+      title: 'ASSIGN_TO_CLIENT',
+      iconUrl: ICONS['headphone'],
+      command: () => {
+        this.openSendClientModal();
+      }
+    },
+    {
+      title: 'ADD_TO_FAVORITES',
+      iconUrl: ICONS['heartWhite'],
+    },
+    {
+      title: 'REMOVE_FROM_FAVORITES',
+      iconUrl: ICONS['heartFillRed'],
+    },
+    {
+      title: 'SHARE_ITINERARY',
+      iconUrl: ICONS['share'],
+      command: () => {
+        this.openUrlShareModal();
+      }
+    },
+    {
+      title: 'BRANCH_THE_ITINERARY',
+      iconUrl: ICONS['branch'],
+    },
+    {
+      title: 'REPORT',
+      iconUrl: ICONS['report'],
+      command: () => {
+        this.openReportModal();
+      },
+    },
+    {
+      title: 'RESTORE_ITINERARY',
+      iconUrl: ICONS['restore'],
+    },
+    {
+      title: 'DELETE_FOREVER',
+      iconUrl: ICONS['deleteCross'],
+      command: () => {
+        this.openModal();
+      },
+    },
+    {
+      title: 'EDIT_COMMENT',
+      iconUrl: ICONS['edit'],
+      command: () => {},
+    },
+    {
+      title: 'REMOVE_FEATURE',
+      iconUrl: ICONS['removeFeature'],
+    },
+    {
+      title: 'DELETE_COMMENT',
+      iconUrl: ICONS['deleteCross'],
+    },
+    {
+      title: 'Details',
+      iconUrl: ICONS['userDetail'],
+    },
+    {
+      title: 'Remove',
+      iconUrl: ICONS['binWhite'],
+    },
+  ];
+
+  pageList = [
+    {
+      pageName: 'itineraries',
+      itemList: [
+        {
+          title: 'ASSIGN_TO_CLIENT',
+        },
+        {
+          title: 'ADD_TO_FAVORITES',
+        },
+        {
+          title: 'SHARE_ITINERARY',
+        },
+        {
+          title: 'BRANCH_THE_ITINERARY',
+        },
+        {
+          title: 'REPORT',
+          command: () => {
+            this.openReportModal();
+          },
+        },
+      ],
+    },
+    {
+      pageName: 'builder',
+      itemList: [
+        {
+          title: 'EDIT_ITINERARY',
+        },
+        {
+          title: 'UNPUBLISH',
+        },
+        {
+          title: 'ARCHIVE',
+        },
+        {
+          title: 'ADD_TO_FAVORITES',
+        },
+        {
+          title: 'SHARE_ITINERARY',
+        },
+      ],
+    },
+    {
+      pageName: 'archives',
+      itemList: [
+        {
+          title: 'RESTORE_ITINERARY',
+        },
+        {
+          title: 'DELETE_FOREVER',
+        },
+      ],
+    },
+    {
+      pageName: 'favourite',
+      itemList: [
+        {
+          title: 'REMOVE_FROM_FAVORITES',
+        },
+        {
+          title: 'SHARE_ITINERARY',
+        },
+        {
+          title: 'REPORT',
+        },
+      ],
+    },
+    {
+      pageName: 'stories',
+      itemList: [
+        {
+          title: 'EDIT_COMMENT',
+        },
+        {
+          title: 'REMOVE_FEATURE',
+        },
+        {
+          title: 'DELETE_COMMENT',
+        },
+        {
+          title: 'REPORT',
+        },
+      ],
+    },
+    {
+      pageName: 'comment-replies',
+      itemList: [
+        {
+          title: 'REMOVE_FEATURE',
+        },
+        {
+          title: 'DELETE_COMMENT',
+        },
+        {
+          title: 'REPORT',
+        },
+      ],
+    },
+    {
+      pageName: 'create-itinerary-user-search',
+      itemList: [
+        {
+          title: 'Details',
+        },
+        {
+          title: 'Remove',
+        },
+      ],
+    },
+  ];
+
+  constructor(
+    public router: Router,
+    public modalService: ModalService,
+    public translateService: TranslateService,
+    public clientSendModalService: ModalSendClientService,
+    public urlShareModalService: ModalShareUrlClientService
+  ) {}
+
+  openUrlShareModal() {
+    this.urlShareModalService.toggleModal = !this.urlShareModalService.toggleModal;
+  }
+
+  getMenuList(pageName: string): LibMenuItem[] {
+    // Find the pageList entry with matching pageName
+    const page = this.pageList.find((page) => page.pageName === pageName);
+    if (!page) {
+      return []; // Return an empty array if pageName is not found
+    }
+
+    // Filter the itemList to include only items whose titles are in page.itemList
+    const filteredList = this.itemList.filter((item) =>
+      page.itemList.some((pageItem) => pageItem.title === item.title),
+    );
+
+    filteredList.forEach((item) => {
+      item.title = item.title
+        ? this.translateService.instant(item.title)
+        : item.title;
+    });
+    page.itemList.forEach((item) => {
+      item.title = this.translateService.instant(item.title);
+    });
+    return filteredList;
+  }
+
+  openSendClientModal(): void {
+    this.clientSendModalService.toggleModal = !this.clientSendModalService.toggleModal;
+  }
+
+  openModal(): void {
+    this.modalService.toggleModal = !this.modalService.toggleModal;
+  }
+  openReportModal(): void {
+    this.modalService.toggleModal = !this.modalService.toggleModal;
+  }
+  navigateToRoute(path: string): void {
+    this.router.navigate([path], {
+      queryParams: { mode: 'edit' },
+    });
+  }
+}

package/src/lib/itinerary-app/_services/itinerary.drawmode.transfer.ts

@@ -0,0 +1,33 @@
+import { Injectable } from '@angular/core';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class ItineraryDrawModeTransferService {
+  polygonCoords: Array<{ lat: number; lng: number }> = [];
+  places: google.maps.places.PlaceResult[] = [];
+  selectedPlaces: google.maps.places.PlaceResult[] = [];
+  location!: { lat: number, lng: number };
+
+  setPolygon(coords: { lat: number; lng: number }[]) {
+    this.polygonCoords = coords;
+  }
+
+  setPlaces(places: google.maps.places.PlaceResult[]) {
+    this.places = places;
+  }
+
+  setSelectedPlaces(places: google.maps.places.PlaceResult[]) {
+    this.selectedPlaces = places;
+  }
+
+  setCurrentLocation(location: { lat: number, lng: number }) {
+    this.location = location;
+  }
+
+  clear() {
+    this.polygonCoords = [];
+    this.selectedPlaces = [];
+    this.places = [];
+  }
+}

package/src/lib/itinerary-app/_services/itinerary.service.ts

@@ -0,0 +1,64 @@
+import { Injectable } from "@angular/core";
+import { Itinerary } from "../_models/Itinerary";
+import { MatchingClients } from "../_models/matching-clients";
+import { HttpClient } from "@angular/common/http";
+import { delay, Observable } from "rxjs";
+
+@Injectable({
+  providedIn: 'root',
+})
+export class ItineraryService {
+  constructor(private http: HttpClient) {
+
+  }
+
+  private _itineraries: Itinerary[] = [];
+
+  getAll(): Itinerary[] {
+    return this._itineraries;
+  }
+
+  getById(id: string): Itinerary | undefined {
+    return this._itineraries.find(itinerary => itinerary.id === id);
+  }
+
+  createOrUpdate(itinerary: Itinerary): void {
+    const index = this._itineraries.findIndex(i => i.id === itinerary.id);
+    if (index !== -1) {
+      this._itineraries[index] = itinerary;
+    } else {
+      this._itineraries.push(itinerary);
+    }
+  }
+
+  sendItenaryToClients(itinerary: Itinerary, clients: MatchingClients[]): {
+    itinerary: Itinerary,
+    clients: MatchingClients[]
+  } {
+    return {
+      itinerary,
+      clients
+    };
+  }
+
+  getItinerariesByUserId(): Observable<Itinerary[]> {
+    return this.http.get<Itinerary[]>('/assets/itineraries.json').pipe(delay(1000));
+  }
+
+  getAllItinararies(): Observable<Itinerary[]> {
+    return this.http.get<Itinerary[]>('/assets/itineraries.json').pipe(delay(1000));
+  }
+
+  getArchivedItinerariesByUserId(): Observable<Itinerary[]> {
+    return this.http.get<Itinerary[]>('/assets/itinerariesArchived.json').pipe(delay(1000));
+  }
+
+  deleteItineraryArchived(): boolean {
+    return true;
+  }
+
+  deleteItinerary(id: string): Observable<Itinerary[]> {
+    console.log("Delete id", id);
+    return this.http.get<Itinerary[]>('/assets/itinerariesArchived.json').pipe(delay(1000));
+  }
+}

package/src/lib/itinerary-app/_services/location.service.ts

@@ -0,0 +1,28 @@
+import { Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class LocationService {
+  getCurrentLocation(): Observable<{ lat: number; long: number }> {
+    return new Observable((observer) => {
+      if (navigator.geolocation) {
+        navigator.geolocation.getCurrentPosition(
+          (position) => {
+            observer.next({
+              lat: position.coords.latitude,
+              long: position.coords.longitude,
+            });
+            observer.complete();
+          },
+          (error) => {
+            observer.error(`Geolocation error: ${error.message}`);
+          },
+        );
+      } else {
+        observer.error('Geolocation is not supported by this browser.');
+      }
+    });
+  }
+}

package/src/lib/itinerary-app/_services/modal.clearhistory.service.ts

@@ -0,0 +1,12 @@
+import { Injectable } from '@angular/core';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class ModalClearHistoryService {
+  public toggleModal: boolean = false;
+  public bottomToggleModal: boolean = false;
+  public toggleGlobalSearch: boolean = false;
+
+  constructor() { }
+}