vtb-appit 0.1.6 → 0.1.8

package/appit.js

@@ -27,7 +27,7 @@ class Appit {
 
     history()
     {
-        const defaultHistory = {
+        this.history = {
             excursionId: null,
             members: {},
             ships: {},
@@ -42,112 +42,64 @@ class Appit {
             destinations: {},
             flights: {},
             flightImages: {},
-            notifications: {},
-            status: 'pending',
-            errors: [],
-            lastSaved: null
+            notifications: {}
         };
 
         try {
             const historyFile = fs.readFileSync(this.historyPath, {encoding: 'utf8'});
-            this.history = { ...defaultHistory, ...JSON.parse(historyFile) };
-            this.log('info', 'History loaded from file');
+            this.history = JSON.parse(historyFile);
         } catch(e) {
-            this.history = defaultHistory;
-            this.log('info', 'Starting with fresh history');
+            
         }
     }
 
     async exec()
     {
-        this.log('info', 'Starting sync process');
-        const errors = [];
-        
-        try {
-            if(!await this.login()) {
-                this.log('error', 'Login failed');
-                return false;
-            }
-            this.log('info', 'Login successful');
-
-            this.transformer.profile = await this.fetchProfile();
-            this.log('info', 'Profile fetched successfully');
-
-            if(this.options && this.options.tsData) {
-                try {
-                    this.transformer.tsData = await this.transformer.tsGetData();
-                    this.log('info', 'TS data loaded successfully');
-                } catch(e) {
-                    this.log('error', 'Failed to load TS data', e.message);
-                    errors.push({ step: 'tsData', error: e.message });
-                }
-            }
+        if(!await this.login()) return false;
+
+        this.transformer.profile = await this.fetchProfile();
+
+        if(this.options && this.options.tsData) {
+            try {
+                this.transformer.tsData = await this.transformer.tsGetData();
+            } catch(e) {
 
-            if(this.options && this.options.tsDocuments) {
-                try {
-                    this.transformer.tsDocuments = await this.transformer.tsGetDocuments();
-                    this.log('info', 'TS documents loaded successfully');
-                } catch(e) {
-                    this.log('error', 'Failed to load TS documents', e.message);
-                    errors.push({ step: 'tsDocuments', error: e.message });
-                }
-            }
-            
-            const steps = [
-                { name: 'excursion', fn: () => this.excursion() },
-                { name: 'labels', fn: () => this.labels() },
-                { name: 'ships', fn: () => this.ships() },
-                { name: 'places', fn: () => this.places() },
-                { name: 'organizations', fn: () => this.organizations() },
-                { name: 'members', fn: () => this.members() },
-                { name: 'travelInfo', fn: () => this.travelInfo() },
-                { name: 'accommodations', fn: () => this.accommodations() },
-                { name: 'destinations', fn: () => this.destinations() },
-                { name: 'schemes', fn: () => this.schemes() },
-                { name: 'flights', fn: () => this.flights() },
-                { name: 'flightImages', fn: () => this.flightImages() },
-                { name: 'contacts', fn: () => this.contacts() },
-                { name: 'documents', fn: () => this.documents() },
-                { name: 'homescreen', fn: () => this.homescreen() },
-                { name: 'menu', fn: () => this.menu() },
-                { name: 'settings', fn: () => this.settings() },
-                { name: 'notifications', fn: () => this.notifications() }
-            ];
-
-            for(const step of steps) {
-                try {
-                    this.log('info', `Processing ${step.name}...`);
-                    await step.fn();
-                    this.log('info', `✓ ${step.name} completed successfully`);
-                } catch(error) {
-                    this.log('error', `✗ ${step.name} failed`, error.message);
-                    errors.push({ step: step.name, error: error.message });
-                    // Continue with next step instead of failing entirely
-                }
             }
+        }
 
-            this.history.updatedAt = new Date().getTime();
-            this.history.status = errors.length === 0 ? 'completed' : 'completed_with_errors';
-            this.history.errors = errors;
+        if(this.options && this.options.tsDocuments) {
+            try {
+                this.transformer.tsDocuments = await this.transformer.tsGetDocuments();
+            } catch(e) {
 
-            fs.writeFileSync(this.historyPath, JSON.stringify(this.history, null, 2));
-            
-            if(errors.length === 0) {
-                this.log('info', 'Sync completed successfully');
-                return true;
-            } else {
-                this.log('warn', `Sync completed with ${errors.length} errors`, errors);
-                return true; // Still return true as we completed what we could
             }
-            
-        } catch(error) {
-            this.log('error', 'Critical error during sync', error);
-            this.history.status = 'failed';
-            this.history.criticalError = error.message;
-            this.history.updatedAt = new Date().getTime();
-            this.saveHistoryIncremental();
-            return false;
         }
+        
+        await this.excursion();
+        await this.labels();
+        await this.explores();
+        await this.ships();
+        await this.places();
+        await this.organizations();
+        await this.members();
+        await this.travelInfo();
+        await this.accommodations();
+        await this.destinations();
+        await this.schemes();
+        await this.flights();
+        await this.flightImages();
+        await this.contacts();
+        await this.documents();
+        await this.homescreen();
+        await this.menu();
+        await this.settings();
+        await this.notifications();
+
+        this.history.updatedAt = new Date().getTime();
+
+        fs.writeFileSync(this.historyPath, JSON.stringify(this.history));
+
+        return true;
     }
 
     async labels()
@@ -193,6 +145,14 @@ class Appit {
         }
     }
 
+    async explores()
+    {
+        let explores = this.transformer.explores()
+        if(explores) {
+            await this.saveExplores(this.transformer.workspace_id, explores);
+        }
+    }
+
     async settings()
     {
         let settings = this.transformer.settings()
@@ -222,78 +182,37 @@ class Appit {
     {
         let placesHistory = {};
         const places = this.transformer.places();
-        if(!places || !places.length) {
-            this.log('info', 'No places to process');
-            return;
-        }
-
-        this.log('info', `Processing ${places.length} places`);
-        
-        for(let i = 0; i < places.length; i++) {
-            try {
-                this.log('debug', `Processing place ${i + 1}/${places.length}: ${places[i].object_id}`);
-                
+        if(places && places.length) {
+            for(let i = 0; i < places.length; i++) {
                 let place = this.clean(JSON.parse(JSON.stringify(places[i])));
 
-                const images = (place.images && place.images.length) ? await this.getImages(place.images, 'original/lg') : {};
+                const images = (place.images.length) ? await this.getImages(place.images, 'original/lg') : {};
                 delete place.images;
 
                 if(place.category_id && typeof place.category_id === 'string') {
                     place.category_id = await this.findOrCreateCategory(place.category_id);
                 }
 
-                const placeData = {...place, ...images, excursion_id: this.history.excursionId};
                 let id = this.findId('places', places[i].object_id);
-                
                 if(!id) {
-                    const model = await this.retryOperation(() => this.createPlace(placeData));
-                    if(model && model.data && model.data.id) {
-                        placesHistory[places[i].object_id] = model.data.id;
-                        this.history.places[places[i].object_id] = model.data.id;
-                        this.saveHistoryIncremental();
-                        this.log('debug', `✓ Created place: ${places[i].object_id}`);
-                    }
+                    let model = await this.createPlace({...place, ...images, excursion_id: this.history.excursionId});
+                    console.log('place', model);
+                    placesHistory[places[i].object_id] = model.data.id;
                 } else {
-                    const model = await this.retryOperation(() => this.updatePlace(id, placeData));
-                    if(model && model.data && model.data.id) {
-                        placesHistory[places[i].object_id] = model.data.id;
-                        this.history.places[places[i].object_id] = model.data.id;
-                        this.saveHistoryIncremental();
-                        this.log('debug', `✓ Updated place: ${places[i].object_id}`);
-                    }
+                    let model = await this.updatePlace(id, {...place, ...images, excursion_id: this.history.excursionId});
+                    placesHistory[places[i].object_id] = model.data.id;
                 }
-            } catch(error) {
-                this.log('error', `Failed to process place ${places[i].object_id}`, error.message);
-                this.saveErrorToHistory('places', places[i].object_id, error.message);
-                // Continue with next place instead of failing entirely
             }
         }
-
-        // Clean up deleted places
-        const currentPlaceIds = Object.values(this.history.places || {});
-        const newPlaceIds = Object.values(placesHistory);
-        const nonExisting = this.difference(currentPlaceIds, newPlaceIds);
-        
-        if(nonExisting.length > 0) {
-            this.log('info', `Deleting ${nonExisting.length} removed places`);
-            for(let i = 0; i < nonExisting.length; i++) {
-                try {
-                    await this.retryOperation(() => this.deletePlace(nonExisting[i]));
-                    // Remove from history after successful deletion
-                    for(const [key, value] of Object.entries(this.history.places || {})) {
-                        if(value === nonExisting[i]) {
-                            delete this.history.places[key];
-                            this.saveHistoryIncremental();
-                            this.log('debug', `✓ Deleted place: ${key}`);
-                            break;
-                        }
-                    }
-                } catch(error) {
-                    this.log('error', `Failed to delete place ${nonExisting[i]}`, error.message);
-                    this.saveErrorToHistory('places', `delete-${nonExisting[i]}`, error.message);
-                }
-            }
+        console.log(Object.values(this.history.places));
+        console.log(Object.values(placesHistory));
+        let nonExisting = this.difference(Object.values(this.history.places), Object.values(placesHistory));
+        console.log(nonExisting);
+        for(let i = 0; i < nonExisting.length; i++) {
+            await this.deletePlace(nonExisting[i]);
         }
+
+        this.history.places = placesHistory;
     }
 
    
@@ -323,74 +242,32 @@ class Appit {
     async ships()
     {
         const ships = this.transformer.ships();
-        if(!ships || !ships.length) {
-            this.log('info', 'No ships to process');
-            return;
-        }
-
-        this.log('info', `Processing ${ships.length} ships`);
         let shipsHistory = {};
-        
-        for(let i = 0; i < ships.length; i++) {
-            try {
-                this.log('debug', `Processing ship ${i + 1}/${ships.length}: ${ships[i].object_id}`);
-                
+        if(ships && ships.length) {
+            for(let i = 0; i < ships.length; i++) {
                 let ship = this.clean(JSON.parse(JSON.stringify(ships[i])));
 
-                const images = (ship.images && ship.images.length) ? await this.getImages(ship.images, 'original/lg') : {};
+                const images = (ship.images.length) ? await this.getImages(ship.images, 'original/lg') : {};
                 delete ship.images;
 
-                const shipData = {...ship, ...images, excursion_id: this.history.excursionId};
                 let id = this.findId('ships', ships[i].object_id);
-                
                 if(!id) {
-                    const model = await this.retryOperation(() => this.createShip(shipData));
-                    if(model && model.data && model.data.id) {
-                        shipsHistory[ships[i].object_id] = model.data.id;
-                        this.history.ships[ships[i].object_id] = model.data.id;
-                        this.saveHistoryIncremental();
-                        this.log('debug', `✓ Created ship: ${ships[i].object_id}`);
-                    }
+                    let model = await this.createShip({...ship, ...images, excursion_id: this.history.excursionId});
+                    shipsHistory[ships[i].object_id] = model.data.id;
                 } else {
-                    const model = await this.retryOperation(() => this.updateShip(id, shipData));
-                    if(model && model.data && model.data.id) {
-                        shipsHistory[ships[i].object_id] = model.data.id;
-                        this.history.ships[ships[i].object_id] = model.data.id;
-                        this.saveHistoryIncremental();
-                        this.log('debug', `✓ Updated ship: ${ships[i].object_id}`);
-                    }
+                    let model = await this.updateShip(id, {...ship, ...images, excursion_id: this.history.excursionId});
+                    shipsHistory[ships[i].object_id] = model.data.id;
                 }
-            } catch(error) {
-                this.log('error', `Failed to process ship ${ships[i].object_id}`, error.message);
-                this.saveErrorToHistory('ships', ships[i].object_id, error.message);
-                // Continue with next ship instead of failing entirely
             }
         }
 
-        // Clean up deleted ships
-        const currentShipIds = Object.values(this.history.ships || {});
-        const newShipIds = Object.values(shipsHistory);
-        const nonExisting = this.difference(currentShipIds, newShipIds);
-        
-        if(nonExisting.length > 0) {
-            this.log('info', `Deleting ${nonExisting.length} removed ships`);
-            for(let i = 0; i < nonExisting.length; i++) {
-                try {
-                    await this.retryOperation(() => this.deleteShip(nonExisting[i]));
-                    // Remove from history after successful deletion
-                    for(const [key, value] of Object.entries(this.history.ships || {})) {
-                        if(value === nonExisting[i]) {
-                            delete this.history.ships[key];
-                            this.saveHistoryIncremental();
-                            this.log('debug', `✓ Deleted ship: ${key}`);
-                            break;
-                        }
-                    }
-                } catch(error) {
-                    this.log('error', `Failed to delete ship ${nonExisting[i]}`, error.message);
-                    this.saveErrorToHistory('ships', `delete-${nonExisting[i]}`, error.message);
-                }
-            }
+        if(this.history.hasOwnProperty('ships')) {
+          let nonExisting = this.difference(Object.values(this.history.ships), Object.values(shipsHistory));
+          for(let i = 0; i < nonExisting.length; i++) {
+              await this.deleteShips(nonExisting[i]);
+          }
+
+          this.history.ships = shipsHistory;
         }
     }
 
@@ -398,71 +275,28 @@ class Appit {
     async flights()
     {
         const flights = this.transformer.flights();
-        if(!flights || !flights.length) {
-            this.log('info', 'No flights to process');
-            return;
-        }
-
-        this.log('info', `Processing ${flights.length} flights`);
         let flightsHistory = {};
-        
-        for(let i = 0; i < flights.length; i++) {
-            try {
-                this.log('debug', `Processing flight ${i + 1}/${flights.length}: ${flights[i].object_id}`);
-                
+        if(flights && flights.length) {
+            for(let i = 0; i < flights.length; i++) {
                 let flight = this.clean(JSON.parse(JSON.stringify(flights[i])));
-                const flightData = {...flight, excursion_id: this.history.excursionId};
+
                 let id = this.findId('flights', flights[i].object_id);
-                
                 if(!id) {
-                    const model = await this.retryOperation(() => this.createFlight(flightData));
-                    if(model && model.data && model.data.id) {
-                        flightsHistory[flights[i].object_id] = model.data.id;
-                        this.history.flights[flights[i].object_id] = model.data.id;
-                        this.saveHistoryIncremental();
-                        this.log('debug', `✓ Created flight: ${flights[i].object_id}`);
-                    }
+                    let model = await this.createFlight({...flight, excursion_id: this.history.excursionId});
+                    flightsHistory[flights[i].object_id] = model.data.id;
                 } else {
-                    const model = await this.retryOperation(() => this.updateFlight(id, flightData));
-                    if(model && model.data && model.data.id) {
-                        flightsHistory[flights[i].object_id] = model.data.id;
-                        this.history.flights[flights[i].object_id] = model.data.id;
-                        this.saveHistoryIncremental();
-                        this.log('debug', `✓ Updated flight: ${flights[i].object_id}`);
-                    }
+                    let model = await this.updateFlight(id, {...flight, excursion_id: this.history.excursionId});
+                    flightsHistory[flights[i].object_id] = model.data.id;
                 }
-            } catch(error) {
-                this.log('error', `Failed to process flight ${flights[i].object_id}`, error.message);
-                this.saveErrorToHistory('flights', flights[i].object_id, error.message);
-                // Continue with next flight instead of failing entirely
             }
         }
 
-        // Clean up deleted flights
-        const currentFlightIds = Object.values(this.history.flights || {});
-        const newFlightIds = Object.values(flightsHistory);
-        const nonExisting = this.difference(currentFlightIds, newFlightIds);
-        
-        if(nonExisting.length > 0) {
-            this.log('info', `Deleting ${nonExisting.length} removed flights`);
-            for(let i = 0; i < nonExisting.length; i++) {
-                try {
-                    await this.retryOperation(() => this.deleteFlight(nonExisting[i]));
-                    // Remove from history after successful deletion
-                    for(const [key, value] of Object.entries(this.history.flights || {})) {
-                        if(value === nonExisting[i]) {
-                            delete this.history.flights[key];
-                            this.saveHistoryIncremental();
-                            this.log('debug', `✓ Deleted flight: ${key}`);
-                            break;
-                        }
-                    }
-                } catch(error) {
-                    this.log('error', `Failed to delete flight ${nonExisting[i]}`, error.message);
-                    this.saveErrorToHistory('flights', `delete-${nonExisting[i]}`, error.message);
-                }
-            }
+        let nonExisting = this.difference(Object.values(this.history.flights), Object.values(flightsHistory));
+        for(let i = 0; i < nonExisting.length; i++) {
+            await this.deleteFlight(nonExisting[i]);
         }
+
+        this.history.flights = flightsHistory;
     }
 
     async flightImages()
@@ -484,616 +318,258 @@ class Appit {
 
     async organizations()
     {
-        const organizations = this.transformer.organizations();
-        if(!organizations || !organizations.length) {
-            this.log('info', 'No organizations to process');
-            return;
-        }
-
-        this.log('info', `Processing ${organizations.length} organizations`);
         let organizationsHistory = {};
-        
-        for(let i = 0; i < organizations.length; i++) {
-            try {
-                this.log('debug', `Processing organization ${i + 1}/${organizations.length}: ${organizations[i].object_id}`);
-                
-                const orgData = {...organizations[i], excursion_id: this.history.excursionId};
+        const organizations = this.transformer.organizations();
+        if(organizations) {
+            for(let i = 0; i < organizations.length; i++) {
+                organizations[i].excursion_id = this.history.excursionId;
                 let id = this.findId('organizations', organizations[i].object_id);
-                
                 if(!id) {
-                    const model = await this.retryOperation(() => this.createOrganization(orgData));
-                    if(model && model.data && model.data.id) {
-                        organizationsHistory[organizations[i].object_id] = model.data.id;
-                        this.history.organizations[organizations[i].object_id] = model.data.id;
-                        this.saveHistoryIncremental();
-                        this.log('debug', `✓ Created organization: ${organizations[i].object_id}`);
-                    }
+                    let model = await this.createOrganization(organizations[i]);
+                    console.log('organization', model);
+                    organizationsHistory[organizations[i].object_id] = model.data.id;
                 } else {
-                    const model = await this.retryOperation(() => this.updateOrganization(id, orgData));
-                    if(model && model.data && model.data.id) {
-                        organizationsHistory[organizations[i].object_id] = model.data.id;
-                        this.history.organizations[organizations[i].object_id] = model.data.id;
-                        this.saveHistoryIncremental();
-                        this.log('debug', `✓ Updated organization: ${organizations[i].object_id}`);
-                    }
+                    let model = await this.updateOrganization(id, organizations[i]);
+                    organizationsHistory[organizations[i].object_id] = model.data.id;
                 }
-            } catch(error) {
-                this.log('error', `Failed to process organization ${organizations[i].object_id}`, error.message);
-                this.saveErrorToHistory('organizations', organizations[i].object_id, error.message);
-                // Continue with next organization instead of failing entirely
             }
         }
 
-        // Clean up deleted organizations
-        const currentOrgIds = Object.values(this.history.organizations || {});
-        const newOrgIds = Object.values(organizationsHistory);
-        const nonExisting = this.difference(currentOrgIds, newOrgIds);
-        
-        if(nonExisting.length > 0) {
-            this.log('info', `Deleting ${nonExisting.length} removed organizations`);
-            for(let i = 0; i < nonExisting.length; i++) {
-                try {
-                    await this.retryOperation(() => this.deleteOrganization(nonExisting[i]));
-                    // Remove from history after successful deletion
-                    for(const [key, value] of Object.entries(this.history.organizations || {})) {
-                        if(value === nonExisting[i]) {
-                            delete this.history.organizations[key];
-                            this.saveHistoryIncremental();
-                            this.log('debug', `✓ Deleted organization: ${key}`);
-                            break;
-                        }
-                    }
-                } catch(error) {
-                    this.log('error', `Failed to delete organization ${nonExisting[i]}`, error.message);
-                    this.saveErrorToHistory('organizations', `delete-${nonExisting[i]}`, error.message);
-                }
-            }
+        let nonExisting = this.difference(Object.values(this.history.organizations), Object.values(organizationsHistory));
+        for(let i = 0; i < nonExisting.length; i++) {
+            await this.deleteOrganization(nonExisting[i]);
         }
+
+        this.history.organizations = organizationsHistory;
     }
 
     async notifications()
     {
         const notifications = this.transformer.notifications();
-        if(!notifications || !notifications.length) {
-            this.log('info', 'No notifications to process');
-            return;
-        }
-
-        this.log('info', `Processing ${notifications.length} notifications`);
-        
-        for(let i = 0; i < notifications.length; i++) {
-            try {
-                this.log('debug', `Processing notification ${i + 1}/${notifications.length}: ${notifications[i].object_id}`);
-                
+        if(notifications) {
+            for(let i = 0; i < notifications.length; i++) {
                 let notification = this.clean(JSON.parse(JSON.stringify(notifications[i])));
-                const notificationData = {...notification, excursion_id: this.history.excursionId};
+                notification.excursion_id = this.history.excursionId;
+
                 let id = this.findId('notifications', notifications[i].object_id);
-                
                 if(!id) {
-                    const model = await this.retryOperation(() => this.createNotification(notificationData));
-                    if(model && model.data && model.data.id) {
-                        if(!this.history.hasOwnProperty('notifications')) this.history.notifications = {};
-                        this.history.notifications[notifications[i].object_id] = model.data.id;
-                        this.saveHistoryIncremental();
-                        this.log('debug', `✓ Created notification: ${notifications[i].object_id}`);
-                    }
+                    let model = await this.createNotification(notification);
+                    if(!this.history.hasOwnProperty('notifications')) this.history.notifications = {};
+                    this.history.notifications[notifications[i].object_id] = model.data.id;
                 } else {
-                    const model = await this.retryOperation(() => this.updateNotification(id, notificationData));
-                    if(model && model.data && model.data.id) {
-                        this.history.notifications[notifications[i].object_id] = model.data.id;
-                        this.saveHistoryIncremental();
-                        this.log('debug', `✓ Updated notification: ${notifications[i].object_id}`);
-                    }
+                    await this.updateNotification(id, notification);
                 }
-            } catch(error) {
-                this.log('error', `Failed to process notification ${notifications[i].object_id}`, error.message);
-                this.saveErrorToHistory('notifications', notifications[i].object_id, error.message);
-                // Continue with next notification instead of failing entirely
             }
         }
     }
 
     async members()
     {
-        const participants = this.transformer.participants();
-        if(!participants || !participants.length) {
-            this.log('info', 'No members to process');
-            return;
-        }
-
-        this.log('info', `Processing ${participants.length} members`);
         let memberHistory = {};
-        
-        for(let i = 0; i < participants.length; i++) {
-            try {
-                this.log('debug', `Processing member ${i + 1}/${participants.length}: ${participants[i].id}`);
-                
+        const participants = this.transformer.participants();
+        if(participants && participants.length) {
+            for(let i = 0; i < participants.length; i++) {
                 let participant = this.clean(JSON.parse(JSON.stringify(participants[i])));
-                const memberData = {...participant, excursion_id: this.history.excursionId};
+
                 let id = this.findId('members', participants[i].id);
-                
                 if(!id) {
-                    const model = await this.retryOperation(() => this.createMember(memberData));
-                    if(model && model.data && model.data.id) {
-                        memberHistory[participants[i].id] = model.data.id;
-                        this.history.members[participants[i].id] = model.data.id;
-                        this.saveHistoryIncremental();
-                        this.log('debug', `✓ Created member: ${participants[i].id}`);
-                    }
+                    let model = await this.createMember({...participant, excursion_id: this.history.excursionId});
+                    console.log('member', model);
+                    memberHistory[participants[i].id] = model.data.id;
                 } else {
-                    const model = await this.retryOperation(() => this.updateMember(id, memberData));
-                    if(model && model.data && model.data.id) {
-                        memberHistory[participants[i].id] = model.data.id;
-                        this.history.members[participants[i].id] = model.data.id;
-                        this.saveHistoryIncremental();
-                        this.log('debug', `✓ Updated member: ${participants[i].id}`);
-                    }
+                    let model = await this.updateMember(id, {...participant, excursion_id: this.history.excursionId});
+                    memberHistory[participants[i].id] = model.data.id;
                 }
-            } catch(error) {
-                this.log('error', `Failed to process member ${participants[i].id}`, error.message);
-                this.saveErrorToHistory('members', participants[i].id, error.message);
-                // Continue with next member instead of failing entirely
             }
         }
 
-        // Clean up deleted members
-        const currentMemberIds = Object.values(this.history.members || {});
-        const newMemberIds = Object.values(memberHistory);
-        const nonExisting = this.difference(currentMemberIds, newMemberIds);
-        
-        if(nonExisting.length > 0) {
-            this.log('info', `Deleting ${nonExisting.length} removed members`);
-            for(let i = 0; i < nonExisting.length; i++) {
-                try {
-                    await this.retryOperation(() => this.deleteMember(nonExisting[i]));
-                    // Remove from history after successful deletion
-                    for(const [key, value] of Object.entries(this.history.members || {})) {
-                        if(value === nonExisting[i]) {
-                            delete this.history.members[key];
-                            this.saveHistoryIncremental();
-                            this.log('debug', `✓ Deleted member: ${key}`);
-                            break;
-                        }
-                    }
-                } catch(error) {
-                    this.log('error', `Failed to delete member ${nonExisting[i]}`, error.message);
-                    this.saveErrorToHistory('members', `delete-${nonExisting[i]}`, error.message);
-                }
-            }
+        let nonExisting = this.difference(Object.values(this.history.members), Object.values(memberHistory));
+        for(let i = 0; i < nonExisting.length; i++) {
+            await this.deleteMember(nonExisting[i]);
         }
+
+        this.history.members = memberHistory;
     }
 
     async travelInfo()
     {
-        const travelInfo = this.transformer.travelInfo();
-        if(!travelInfo || !travelInfo.length) {
-            this.log('info', 'No travel info to process');
-            return;
-        }
-
-        this.log('info', `Processing ${travelInfo.length} travel info items`);
         let travelInfoHistory = {};
-        
-        for(let i = 0; i < travelInfo.length; i++) {
-            try {
-                this.log('debug', `Processing travel info ${i + 1}/${travelInfo.length}: ${travelInfo[i].object_id}`);
-                
+        const travelInfo = this.transformer.travelInfo();
+        if(travelInfo && travelInfo.length) {
+            for(let i = 0; i < travelInfo.length; i++) {
                 let info = this.clean(JSON.parse(JSON.stringify(travelInfo[i])));
+
+                let id = this.findId('travels', travelInfo[i].object_id);
                 
                 if(info.category_id && typeof info.category_id === 'string') {
                     info.category_id = await this.findOrCreateCategory(info.category_id);
                 }
 
-                const travelData = {...info, excursion_id: this.history.excursionId};
-                let id = this.findId('travels', travelInfo[i].object_id);
-                
                 if(!id) {
-                    const model = await this.retryOperation(() => this.createTravel(travelData));
-                    if(model && model.data && model.data.id) {
-                        travelInfoHistory[travelInfo[i].object_id] = model.data.id;
-                        this.history.travels[travelInfo[i].object_id] = model.data.id;
-                        this.saveHistoryIncremental();
-                        this.log('debug', `✓ Created travel info: ${travelInfo[i].object_id}`);
-                    }
+                    let model = await this.createTravel({...info, excursion_id: this.history.excursionId});
+                    console.log('travelInfo', model);
+                    travelInfoHistory[travelInfo[i].object_id] = model.data.id;
                 } else {
-                    const model = await this.retryOperation(() => this.updateTravel(id, travelData));
-                    if(model && model.data && model.data.id) {
-                        travelInfoHistory[travelInfo[i].object_id] = model.data.id;
-                        this.history.travels[travelInfo[i].object_id] = model.data.id;
-                        this.saveHistoryIncremental();
-                        this.log('debug', `✓ Updated travel info: ${travelInfo[i].object_id}`);
-                    }
+                    let model = await this.updateTravel(id, {...info, excursion_id: this.history.excursionId});
+                    travelInfoHistory[travelInfo[i].object_id] = model.data.id;
                 }
-            } catch(error) {
-                this.log('error', `Failed to process travel info ${travelInfo[i].object_id}`, error.message);
-                this.saveErrorToHistory('travelInfo', travelInfo[i].object_id, error.message);
-                // Continue with next travel info instead of failing entirely
             }
         }
 
-        // Clean up deleted travel info
-        const currentTravelIds = Object.values(this.history.travels || {});
-        const newTravelIds = Object.values(travelInfoHistory);
-        const nonExisting = this.difference(currentTravelIds, newTravelIds);
-        
-        if(nonExisting.length > 0) {
-            this.log('info', `Deleting ${nonExisting.length} removed travel info items`);
-            for(let i = 0; i < nonExisting.length; i++) {
-                try {
-                    await this.retryOperation(() => this.deleteTravel(nonExisting[i]));
-                    // Remove from history after successful deletion
-                    for(const [key, value] of Object.entries(this.history.travels || {})) {
-                        if(value === nonExisting[i]) {
-                            delete this.history.travels[key];
-                            this.saveHistoryIncremental();
-                            this.log('debug', `✓ Deleted travel info: ${key}`);
-                            break;
-                        }
-                    }
-                } catch(error) {
-                    this.log('error', `Failed to delete travel info ${nonExisting[i]}`, error.message);
-                    this.saveErrorToHistory('travelInfo', `delete-${nonExisting[i]}`, error.message);
-                }
-            }
+        let nonExisting = this.difference(Object.values(this.history.travels), Object.values(travelInfoHistory));
+        for(let i = 0; i < nonExisting.length; i++) {
+            await this.deleteTravel(nonExisting[i]);
         }
+
+        this.history.travels = travelInfoHistory;
     }
     
     async documents()
     {
         const documents = this.transformer.documents();
-        if(!documents || !documents.length) {
-            this.log('info', 'No documents to process');
-            return;
-        }
-
-        this.log('info', `Processing ${documents.length} documents`);
         let documentHistory = {};
-        
-        for(let i = 0; i < documents.length; i++) {
-            try {
-                this.log('debug', `Processing document ${i + 1}/${documents.length}: ${documents[i].object_id}`);
-                
-                const documentData = {...documents[i], excursion_id: this.history.excursionId};
+        if(documents) {
+            for(let i = 0; i < documents.length; i++) {
+                documents[i].excursion_id = this.history.excursionId;
                 let id = this.findId('documents', documents[i].object_id);
-                
                 if(!id) {
-                    const model = await this.retryOperation(() => this.createDocument(documentData));
-                    if(model && typeof model === 'object' && model.data && model.data.id) {
-                        documentHistory[documents[i].object_id] = model.data.id;
-                        this.history.documents[documents[i].object_id] = model.data.id;
-                        this.saveHistoryIncremental();
-                        this.log('debug', `✓ Created document: ${documents[i].object_id}`);
-                    }
+                    let model = await this.createDocument(documents[i]);
+                    console.log('documents', model);
+                    if(typeof model === 'object' && model.data && model.data.id)
+                      documentHistory[documents[i].object_id] = model.data.id;
                 } else {
                     documentHistory[documents[i].object_id] = id;
-                    this.history.documents[documents[i].object_id] = id;
-                    this.saveHistoryIncremental();
-                    this.log('debug', `✓ Document already exists: ${documents[i].object_id}`);
                 }
-            } catch(error) {
-                this.log('error', `Failed to process document ${documents[i].object_id}`, error.message);
-                this.saveErrorToHistory('documents', documents[i].object_id, error.message);
-                // Continue with next document instead of failing entirely
             }
         }
 
-        // Clean up deleted documents
-        const currentDocumentIds = Object.values(this.history.documents || {});
-        const newDocumentIds = Object.values(documentHistory);
-        const nonExisting = this.difference(currentDocumentIds, newDocumentIds);
-        
-        if(nonExisting.length > 0) {
-            this.log('info', `Deleting ${nonExisting.length} removed documents`);
-            for(let i = 0; i < nonExisting.length; i++) {
-                try {
-                    await this.retryOperation(() => this.deleteDocuments(nonExisting[i]));
-                    // Remove from history after successful deletion
-                    for(const [key, value] of Object.entries(this.history.documents || {})) {
-                        if(value === nonExisting[i]) {
-                            delete this.history.documents[key];
-                            this.saveHistoryIncremental();
-                            this.log('debug', `✓ Deleted document: ${key}`);
-                            break;
-                        }
-                    }
-                } catch(error) {
-                    this.log('error', `Failed to delete document ${nonExisting[i]}`, error.message);
-                    this.saveErrorToHistory('documents', `delete-${nonExisting[i]}`, error.message);
-                }
-            }
+        let nonExisting = this.difference(Object.values(this.history.documents), Object.values(documentHistory));
+        for(let i = 0; i < nonExisting.length; i++) {
+            await this.deleteDocuments(nonExisting[i]);
         }
+
+        this.history.documents = documentHistory;
     }
 
     async accommodations()
     {
-        const accommodations = this.transformer.accommodations();
-        if(!accommodations || !accommodations.length) {
-            this.log('info', 'No accommodations to process');
-            return;
-        }
-
-        this.log('info', `Processing ${accommodations.length} accommodations`);
         let accommodationHistory = {};
-        
-        for(let i = 0; i < accommodations.length; i++) {
-            try {
-                this.log('debug', `Processing accommodation ${i + 1}/${accommodations.length}: ${accommodations[i].object_id}`);
-                
+        const accommodations = this.transformer.accommodations();
+        if(accommodations && accommodations.length) {
+            for(let i = 0; i < accommodations.length; i++) {
                 let accommodation = this.clean(JSON.parse(JSON.stringify(accommodations[i])));
                 let labels = this.getLabels(accommodations[i]);
 
-                const images = (accommodation.images && accommodation.images.length) ? await this.getImages(accommodation.images, 'original/lg') : {};
+                const images = (accommodation.images.length) ? await this.getImages(accommodation.images, 'original/lg') : {};
                 delete accommodation.images;
 
-                const accommodationData = {...accommodation, ...images, labels: labels, excursion_id: this.history.excursionId};
                 let id = this.findId('accommodations', accommodations[i].object_id);
-                
                 if(!id) {
-                    const model = await this.retryOperation(() => this.createAccommodation(accommodationData));
-                    if(model && model.data && model.data.id) {
-                        accommodationHistory[accommodations[i].object_id] = model.data.id;
-                        this.history.accommodations[accommodations[i].object_id] = model.data.id;
-                        this.saveHistoryIncremental();
-                        this.log('debug', `✓ Created accommodation: ${accommodations[i].object_id}`);
-                    }
+                    let model = await this.createAccommodation({...accommodation, ...images, labels: labels, excursion_id: this.history.excursionId});
+                    console.log('accommodations', model);
+                    accommodationHistory[accommodations[i].object_id] = model.data.id;
                 } else {
-                    const model = await this.retryOperation(() => this.updateAccommodation(id, accommodationData));
-                    if(model && model.data && model.data.id) {
-                        accommodationHistory[accommodations[i].object_id] = model.data.id;
-                        this.history.accommodations[accommodations[i].object_id] = model.data.id;
-                        this.saveHistoryIncremental();
-                        this.log('debug', `✓ Updated accommodation: ${accommodations[i].object_id}`);
-                    }
+                    let model = await this.updateAccommodation(id, {...accommodation, ...images, labels: labels, excursion_id: this.history.excursionId});
+                    accommodationHistory[accommodations[i].object_id] = model.data.id;
                 }
-            } catch(error) {
-                this.log('error', `Failed to process accommodation ${accommodations[i].object_id}`, error.message);
-                this.saveErrorToHistory('accommodations', accommodations[i].object_id, error.message);
-                // Continue with next accommodation instead of failing entirely
             }
         }
 
-        // Clean up deleted accommodations
-        const currentAccommodationIds = Object.values(this.history.accommodations || {});
-        const newAccommodationIds = Object.values(accommodationHistory);
-        const nonExisting = this.difference(currentAccommodationIds, newAccommodationIds);
-        
-        if(nonExisting.length > 0) {
-            this.log('info', `Deleting ${nonExisting.length} removed accommodations`);
-            for(let i = 0; i < nonExisting.length; i++) {
-                try {
-                    await this.retryOperation(() => this.deleteAccommodation(nonExisting[i]));
-                    // Remove from history after successful deletion
-                    for(const [key, value] of Object.entries(this.history.accommodations || {})) {
-                        if(value === nonExisting[i]) {
-                            delete this.history.accommodations[key];
-                            this.saveHistoryIncremental();
-                            this.log('debug', `✓ Deleted accommodation: ${key}`);
-                            break;
-                        }
-                    }
-                } catch(error) {
-                    this.log('error', `Failed to delete accommodation ${nonExisting[i]}`, error.message);
-                    this.saveErrorToHistory('accommodations', `delete-${nonExisting[i]}`, error.message);
-                }
-            }
+        let nonExisting = this.difference(Object.values(this.history.accommodations), Object.values(accommodationHistory));
+        for(let i = 0; i < nonExisting.length; i++) {
+            await this.deleteAccommodation(nonExisting[i]);
         }
+
+        this.history.accommodations = accommodationHistory;
     }
 
     async destinations()
     {
-        const destinations = await this.transformer.destinations();
-        if(!destinations || !destinations.length) {
-            this.log('info', 'No destinations to process');
-            return;
-        }
-
-        this.log('info', `Processing ${destinations.length} destinations`);
         let destinationHistory = {};
-        
-        for(let i = 0; i < destinations.length; i++) {
-            try {
-                this.log('debug', `Processing destination ${i + 1}/${destinations.length}: ${destinations[i].object_id}`);
-                
+        const destinations = await this.transformer.destinations();
+        if(destinations && destinations.length) {
+            for(let i = 0; i < destinations.length; i++) {
                 let destination = this.clean(JSON.parse(JSON.stringify(destinations[i])));
                 let labels = this.getLabels(destinations[i]);
 
                 const images = (destination.images && destination.images.length) ? await this.getImages(destination.images, 'original/lg') : {};
                 delete destination.images;
 
-                const destinationData = {...destination, ...images, labels: labels, excursion_id: this.history.excursionId};
                 let id = this.findId('destinations', destinations[i].object_id);
-                
                 if(!id) {
-                    const model = await this.retryOperation(() => this.createDestination(destinationData));
-                    if(model && model.data && model.data.id) {
-                        destinationHistory[destinations[i].object_id] = model.data.id;
-                        this.history.destinations[destinations[i].object_id] = model.data.id;
-                        this.saveHistoryIncremental();
-                        this.log('debug', `✓ Created destination: ${destinations[i].object_id}`);
-                    }
+                    let model = await this.createDestination({...destination, ...images, labels: labels, excursion_id: this.history.excursionId});
+                    console.log('destination', model);
+                    destinationHistory[destinations[i].object_id] = model.data.id;
                 } else {
-                    const model = await this.retryOperation(() => this.updateDestination(id, destinationData));
-                    if(model && model.data && model.data.id) {
-                        destinationHistory[destinations[i].object_id] = model.data.id;
-                        this.history.destinations[destinations[i].object_id] = model.data.id;
-                        this.saveHistoryIncremental();
-                        this.log('debug', `✓ Updated destination: ${destinations[i].object_id}`);
-                    }
+                    let model = await this.updateDestination(id, {...destination, ...images, labels: labels, excursion_id: this.history.excursionId});
+                    destinationHistory[destinations[i].object_id] = model.data.id;
                 }
-            } catch(error) {
-                this.log('error', `Failed to process destination ${destinations[i].object_id}`, error.message);
-                this.saveErrorToHistory('destinations', destinations[i].object_id, error.message);
-                // Continue with next destination instead of failing entirely
             }
         }
 
-        // Clean up deleted destinations
-        const currentDestinationIds = Object.values(this.history.destinations || {});
-        const newDestinationIds = Object.values(destinationHistory);
-        const nonExisting = this.difference(currentDestinationIds, newDestinationIds);
-        
-        if(nonExisting.length > 0) {
-            this.log('info', `Deleting ${nonExisting.length} removed destinations`);
-            for(let i = 0; i < nonExisting.length; i++) {
-                try {
-                    await this.retryOperation(() => this.deleteDestination(nonExisting[i]));
-                    // Remove from history after successful deletion
-                    for(const [key, value] of Object.entries(this.history.destinations || {})) {
-                        if(value === nonExisting[i]) {
-                            delete this.history.destinations[key];
-                            this.saveHistoryIncremental();
-                            this.log('debug', `✓ Deleted destination: ${key}`);
-                            break;
-                        }
-                    }
-                } catch(error) {
-                    this.log('error', `Failed to delete destination ${nonExisting[i]}`, error.message);
-                    this.saveErrorToHistory('destinations', `delete-${nonExisting[i]}`, error.message);
-                }
-            }
+        let nonExisting = this.difference(Object.values(this.history.destinations), Object.values(destinationHistory));
+        for(let i = 0; i < nonExisting.length; i++) {
+            await this.deleteDestination(nonExisting[i]);
         }
+
+        this.history.destinations = destinationHistory;
     }
 
     async schemes()
     {
-        const schemes = this.transformer.schemes(this.history);
-        if(!schemes || !schemes.length) {
-            this.log('info', 'No schemes to process');
-            return;
-        }
-
-        this.log('info', `Processing ${schemes.length} schemes`);
         const schemeHistory = {};
-        
-        for(let i = 0; i < schemes.length; i++) {
-            try {
-                this.log('debug', `Processing scheme ${i + 1}/${schemes.length}: ${schemes[i].object_id}`);
-                
+        const schemes = this.transformer.schemes(this.history);
+        if(schemes && schemes.length) {
+            for(let i = 0; i < schemes.length; i++) {
                 let scheme = this.clean(JSON.parse(JSON.stringify(schemes[i])));
                 let labels = this.getLabels(schemes[i]);
 
-                const schemeData = {...scheme, labels: labels, excursion_id: this.history.excursionId};
                 let id = this.findId('schemes', schemes[i].object_id);
-                
                 if(!id) {
-                    const model = await this.retryOperation(() => this.createScheme(schemeData));
-                    if(model && model.data && model.data.id) {
-                        schemeHistory[schemes[i].object_id] = model.data.id;
-                        this.history.schemes[schemes[i].object_id] = model.data.id;
-                        this.saveHistoryIncremental();
-                        this.log('debug', `✓ Created scheme: ${schemes[i].object_id}`);
-                    }
+                    let model = await this.createScheme({...scheme, labels: labels, excursion_id: this.history.excursionId});
+                    console.log('schemes', model);
+                    schemeHistory[schemes[i].object_id] = model.data.id;
                 } else {
-                    const model = await this.retryOperation(() => this.updateScheme(id, schemeData));
-                    if(model && model.data && model.data.id) {
-                        schemeHistory[schemes[i].object_id] = model.data.id;
-                        this.history.schemes[schemes[i].object_id] = model.data.id;
-                        this.saveHistoryIncremental();
-                        this.log('debug', `✓ Updated scheme: ${schemes[i].object_id}`);
-                    }
+                    let model = await this.updateScheme(id, {...scheme, labels: labels, excursion_id: this.history.excursionId});
+                    schemeHistory[schemes[i].object_id] = model.data.id;
                 }
-            } catch(error) {
-                this.log('error', `Failed to process scheme ${schemes[i].object_id}`, error.message);
-                this.saveErrorToHistory('schemes', schemes[i].object_id, error.message);
-                // Continue with next scheme instead of failing entirely
             }
         }
 
-        // Clean up deleted schemes
-        const currentSchemeIds = Object.values(this.history.schemes || {});
-        const newSchemeIds = Object.values(schemeHistory);
-        const nonExisting = this.difference(currentSchemeIds, newSchemeIds);
-        
-        if(nonExisting.length > 0) {
-            this.log('info', `Deleting ${nonExisting.length} removed schemes`);
-            for(let i = 0; i < nonExisting.length; i++) {
-                try {
-                    await this.retryOperation(() => this.deleteScheme(nonExisting[i]));
-                    // Remove from history after successful deletion
-                    for(const [key, value] of Object.entries(this.history.schemes || {})) {
-                        if(value === nonExisting[i]) {
-                            delete this.history.schemes[key];
-                            this.saveHistoryIncremental();
-                            this.log('debug', `✓ Deleted scheme: ${key}`);
-                            break;
-                        }
-                    }
-                } catch(error) {
-                    this.log('error', `Failed to delete scheme ${nonExisting[i]}`, error.message);
-                    this.saveErrorToHistory('schemes', `delete-${nonExisting[i]}`, error.message);
-                }
-            }
+        let nonExisting = this.difference(Object.values(this.history.schemes), Object.values(schemeHistory));
+        for(let i = 0; i < nonExisting.length; i++) {
+            await this.deleteScheme(nonExisting[i]);
         }
+
+        this.history.schemes = schemeHistory;
     }
 
     async contacts()
     {
-        const contacts = this.transformer.contacts();
-        if(!contacts || !contacts.length) {
-            this.log('info', 'No contacts to process');
-            return;
-        }
-
-        this.log('info', `Processing ${contacts.length} contacts`);
         let contactHistory = {};
-        
-        for(let i = 0; i < contacts.length; i++) {
-            try {
-                this.log('debug', `Processing contact ${i + 1}/${contacts.length}: ${contacts[i].object_id}`);
-                
+        const contacts = this.transformer.contacts();
+        if(contacts && contacts.length) {
+            for(let i = 0; i < contacts.length; i++) {
                 let contact = this.clean(JSON.parse(JSON.stringify(contacts[i])));
-                const contactData = {...contact, excursion_id: this.history.excursionId};
+
                 let id = this.findId('contacts', contacts[i].object_id);
-                
                 if(!id) {
-                    const model = await this.retryOperation(() => this.createContact(contactData));
-                    if(model && model.data && model.data.id) {
-                        contactHistory[contacts[i].object_id] = model.data.id;
-                        this.history.contacts[contacts[i].object_id] = model.data.id;
-                        this.saveHistoryIncremental();
-                        this.log('debug', `✓ Created contact: ${contacts[i].object_id}`);
-                    }
+                    let model = await this.createContact({...contact, excursion_id: this.history.excursionId});
+                    console.log('contacts', model);
+                    contactHistory[contacts[i].object_id] = model.data.id;
                 } else {
-                    const model = await this.retryOperation(() => this.updateContact(id, contactData));
-                    if(model && model.data && model.data.id) {
-                        contactHistory[contacts[i].object_id] = model.data.id;
-                        this.history.contacts[contacts[i].object_id] = model.data.id;
-                        this.saveHistoryIncremental();
-                        this.log('debug', `✓ Updated contact: ${contacts[i].object_id}`);
-                    }
+                    let model = await this.updateContact(id, {...contact, excursion_id: this.history.excursionId});
+                    contactHistory[contacts[i].object_id] = model.data.id;
                 }
-            } catch(error) {
-                this.log('error', `Failed to process contact ${contacts[i].object_id}`, error.message);
-                this.saveErrorToHistory('contacts', contacts[i].object_id, error.message);
-                // Continue with next contact instead of failing entirely
             }
         }
 
-        // Clean up deleted contacts
-        const currentContactIds = Object.values(this.history.contacts || {});
-        const newContactIds = Object.values(contactHistory);
-        const nonExisting = this.difference(currentContactIds, newContactIds);
-        
-        if(nonExisting.length > 0) {
-            this.log('info', `Deleting ${nonExisting.length} removed contacts`);
-            for(let i = 0; i < nonExisting.length; i++) {
-                try {
-                    await this.retryOperation(() => this.deleteContact(nonExisting[i]));
-                    // Remove from history after successful deletion
-                    for(const [key, value] of Object.entries(this.history.contacts || {})) {
-                        if(value === nonExisting[i]) {
-                            delete this.history.contacts[key];
-                            this.saveHistoryIncremental();
-                            this.log('debug', `✓ Deleted contact: ${key}`);
-                            break;
-                        }
-                    }
-                } catch(error) {
-                    this.log('error', `Failed to delete contact ${nonExisting[i]}`, error.message);
-                    this.saveErrorToHistory('contacts', `delete-${nonExisting[i]}`, error.message);
-                }
-            }
+        let nonExisting = this.difference(Object.values(this.history.contacts), Object.values(contactHistory));
+        for(let i = 0; i < nonExisting.length; i++) {
+            await this.deleteContact(nonExisting[i]);
         }
+
+        this.history.contacts = contactHistory;
     }
 
     getLabels(object)
@@ -1243,8 +719,6 @@ class Appit {
                 options.headers.Authorization = `Bearer ${this.token}`;
             }
 
-            this.log('debug', `${method} request to ${path}`);
-
             const req = https.request(options, res => {
                 let result = '';
                 res.on('data', chunk => {
@@ -1253,26 +727,24 @@ class Appit {
               
                 res.on('end', () => {
                     try {
-                        const parsedResult = JSON.parse(result);
-                        if(res.statusCode >= 400) {
-                            this.log('warn', `HTTP ${res.statusCode} response from ${method} ${path}`, parsedResult);
-                            reject(new Error(`HTTP ${res.statusCode}: ${parsedResult.message || result}`));
-                        } else {
-                            this.log('debug', `✓ ${method} ${path} successful`);
-                            resolve(parsedResult);
-                        }
-                    } catch(parseError) {
-                        this.log('error', `Failed to parse response from ${method} ${path}`, result);
-                        reject(new Error(`Invalid JSON response: ${result}`));
+                        resolve(JSON.parse(result))
+                    } catch {
+                        console.log('ERROR');
+                        console.log(result);
+                        reject(false);
                     }
+                    
                 })
             });
 
             req.on('error', error => {
-                this.log('error', `Network error for ${method} ${path}`, error.message);
-                reject(error);
+                console.error('***** ERROR *****');
+                console.error(error);
+
+                reject(false);
             });
 
+
             if(payload) {
                 req.write(payload)
             }
@@ -1732,88 +1204,13 @@ class Appit {
         return await this.request('PUT', `workspaces/${workspace_id}/excursions/${this.history.excursionId}/settings`, data);
     }
 
-    sleep(delay) {
-        return new Promise((resolve) => setTimeout(resolve, delay))
-    }
-
-    log(level, message, data = null) {
-        const timestamp = new Date().toISOString();
-        const logEntry = {
-            timestamp,
-            level,
-            message,
-            ...(data && { data })
-        };
-        
-        const logString = `[${timestamp}] ${level.toUpperCase()}: ${message}`;
-        
-        switch(level) {
-            case 'error':
-                console.error(logString, data || '');
-                break;
-            case 'warn':
-                console.warn(logString, data || '');
-                break;
-            case 'info':
-                console.log(logString, data || '');
-                break;
-            case 'debug':
-                if(this.options && this.options.debug) {
-                    console.log(logString, data || '');
-                }
-                break;
-        }
-    }
-
-    saveHistoryIncremental() {
-        try {
-            this.history.lastSaved = new Date().getTime();
-            fs.writeFileSync(this.historyPath, JSON.stringify(this.history, null, 2));
-            this.log('debug', 'History saved incrementally');
-        } catch(error) {
-            this.log('error', 'Failed to save history incrementally', error);
-        }
-    }
-
-    saveErrorToHistory(step, objectId, errorMessage) {
-        if (!this.history.errors) {
-            this.history.errors = [];
-        }
-        
-        const errorEntry = {
-            step: step,
-            objectId: objectId,
-            error: errorMessage,
-            timestamp: new Date().toISOString()
-        };
-        
-        this.history.errors.push(errorEntry);
-        this.saveHistoryIncremental();
-        this.log('debug', `Error saved to history: ${step} - ${objectId}`);
+    async saveExplores(workspace_id, data)
+    {
+        return await this.request('POST', `workspaces/${workspace_id}/excursions/${this.history.excursionId}/explores`, data);
     }
 
-    async retryOperation(operation, maxRetries = 3, baseDelay = 1000) {
-        for(let attempt = 1; attempt <= maxRetries; attempt++) {
-            try {
-                const result = await operation();
-                if(attempt > 1) {
-                    this.log('info', `Operation succeeded on attempt ${attempt}`);
-                }
-                return result;
-            } catch(error) {
-                this.log('warn', `Operation failed on attempt ${attempt}/${maxRetries}`, error.message);
-                
-                if(attempt === maxRetries) {
-                    this.log('error', `Operation failed after ${maxRetries} attempts`, error);
-                    throw error;
-                }
-                
-                // Exponential backoff: 1s, 2s, 4s
-                const delay = baseDelay * Math.pow(2, attempt - 1) + Math.random() * 1000;
-                this.log('debug', `Retrying in ${Math.round(delay)}ms`);
-                await this.sleep(delay);
-            }
-        }
+    sleep(delay) {
+        return new Promise((resolve) => setTimeout(resolve, delay))
     }
 }