vtb-appit 0.0.1

package/appit-base-transformer.js

@@ -0,0 +1,77 @@
+const https = require('https');
+const fs = require("fs");
+const pth = require("path");
+
+class AppitBaseTransformer {
+    constructor()
+    {
+        const data = fs.readFileSync(pth.join(__dirname, '../../assets/travelplan.json'), {encoding: 'utf8' });
+        this.travelplan = JSON.parse(data);
+    }
+
+    participants()
+    {
+        return false;
+    }
+
+    excursion()
+    {
+        return false;
+    }
+
+    places()
+    {
+        return false;
+    }
+
+    organizations()
+    {
+        return false;
+    }
+
+    travelInfo()
+    {
+        return false;
+    }
+
+    accommodations()
+    {
+        return false;
+    }
+
+    async mediaToBase64(media)
+    {
+        let promises = [];
+
+        promises.push(new Promise((resolve, reject) => {
+            for(let i = 0; i < media.length; i++) {
+                const req = https.request(media[i].url, res => {
+                    let chunks = [];
+                    res.on('data', chunk => {
+                        chunks.push(chunk);
+                    })
+                  
+                    res.on('end', () => {
+                        const buffer = Buffer.concat(chunks).toString('base64');
+                        let base64Data = 'data:' + res.headers['content-type'] + ';base64,';
+                        base64Data += buffer;
+                        
+                        let frags = media[i].url.split('/');
+    
+                        resolve({
+                            title: '',
+                            name: frags[frags.length - 1],
+                            content: base64Data
+                        });
+                    })
+                });
+    
+                req.end();
+            }
+        }));
+
+        return Promise.all(promises);
+    }
+}
+
+module.exports = { AppitBaseTransformer };

package/appit.js

@@ -0,0 +1,370 @@
+const fs = require("fs");
+const pth = require("path");
+const https = require('https');
+
+class Appit {
+
+    constructor(transformer)
+    {
+        this.transformer = transformer;
+        
+        this.historyPath = pth.join(__dirname, '../../assets/history.json');
+
+        this.hostname = 'portal.appit4travel.com';
+        this.pathPrefix = '/api/v1/';
+        this.token;
+        
+        this.history();
+    }
+
+    history()
+    {
+        this.history = {
+            excursionId: 861,//todo: delete this!
+            members: {},
+            organizations: {},
+            travels: {},
+            places: {},
+            accommodation: {}
+        };
+
+        try {
+            const historyFile = fs.readFileSync(this.historyPath, {encoding: 'utf8'});
+            history = JSON.parse(historyFile);
+        } catch(e) {
+            console.log(e);
+        }
+    }
+
+    async exec()
+    {
+        if(!await this.login()) return false;
+
+        await this.excursion();
+        await this.places();
+        await this.organizations();
+        await this.members();
+        await this.travelInfo();
+        await this.accommodations();
+
+        fs.writeFileSync(this.historyPath, JSON.stringify(this.history));
+    }
+
+    async excursion()
+    {
+        const excursion = this.transformer.excursion();
+        const images = await this.getImages(excursion.images, 'original/lg');
+        delete excursion.images;
+
+        if(!this.history.excursionId) {
+            let model = await this.createExcursion({...excursion, ...images, workspace_id: this.transformer.workspace_id});
+            this.history.excursionId = model.id;
+        } else {
+            await this.updateExcursion(this.history.excursionId, {...excursion, ...images, workspace_id: this.transformer.workspace_id});
+        }
+    }
+
+    async places()
+    {
+        const places = this.transformer.places();
+        if(places && places.length) {
+            const formattedPlaces = await this.formatPlaces(places);
+            for(let i = 0; i < formattedPlaces.length; i++) {
+                let formattedPlace = JSON.parse(JSON.stringify(formattedPlaces[i]));
+                delete formattedPlace.vtb_object_id;
+
+                let id = this.findId('places', formattedPlaces[i].vtb_object_id);
+                if(!id) {
+                    let model = await this.createPlace({...formattedPlace, excursion_id: this.history.excursionId});
+                    this.history.places[formattedPlaces[i].vtb_object_id] = model.data.id;
+                } else {
+                    await this.updatePlace(id, {...formattedPlace, excursion_id: this.history.excursionId});
+                }
+            }
+        }
+    }
+
+    async organizations()
+    {
+        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].vtb_object_id);
+                if(!id) {
+                    let model = await this.createOrganization(organizations[i]);
+                    this.history.organizations[organizations[i].vtb_object_id] = model.data.id;
+                } else {
+                    await this.updateOrganization(id, organizations[i]);
+                }
+            }
+        }
+    }
+
+    async members()
+    {
+        const participants = this.transformer.participants();
+        if(participants && participants.length) {
+            for(let i = 0; i < participants.length; i++) {
+                let participant = JSON.parse(JSON.stringify(participants[i]));
+                delete participant.id;
+
+                let id = this.findId('members', participants[i].id);
+                if(!id) {
+                    let model = await this.createMember({...participant, excursion_id: this.history.excursionId});
+                    this.history.members[participants[i].id] = model.data.id;
+                } else {
+                    await this.updateMember(id, {...participant, excursion_id: this.history.excursionId});
+                }
+            }
+        }
+    }
+
+    async travelInfo()
+    {
+        const travelInfo = this.transformer.travelInfo();
+        if(travelInfo && travelInfo.length) {
+            for(let i = 0; i < travelInfo.length; i++) {
+                let info = JSON.parse(JSON.stringify(travelInfo[i]));
+                delete info.vtbObjectId;
+
+                let id = this.findId('travels', travelInfo[i].vtb_object_id);
+                if(!id) {
+                    let model = await this.createTravel({...info, excursion_id: this.history.excursionId});
+                    this.history.travels[travelInfo[i].vtb_object_id] = model.data.id;
+                } else {
+                    await this.updateTravel(id, {...info, excursion_id: this.history.excursionId});
+                }
+            }
+        }
+    }
+
+    async accommodations()
+    {
+        const accommodations = this.transformer.accommodations();
+        console.log(accommodations);
+        console.log('abc');
+        // if(accommodations && accommodations.length) {
+        //     for(let i = 0; i < accommodations.length; i++) {
+        //         let accommodation = JSON.parse(JSON.stringify(accommodations[i]));
+        //         delete accommodation.vtbObjectId;
+
+        //         let id = this.findId('accommodations', accommodations[i].vtb_object_id);
+        //         if(!id) {
+        //             let model = await appit.createAccommodation({...accommodation, excursion_id: this.history.excursionId});
+        //             this.history.accommodations[accommodations[i].vtb_object_id] = model.data.id;
+        //         } else {
+        //             await appit.updateAccommodation(id, {...accommodation, excursion_id: history.excursionId});
+        //         }
+        //     }
+        // }
+    }
+
+    async formatPlaces(places)
+    {
+        let result = [];
+
+        for(let i = 0; i < places.length; i++) {
+            let images = {};
+
+            if(places[i].media.length)
+                images = await this.getImages(places[i].media, 'original/lg');
+
+            result.push({
+                title : this.encode(places[i].title),
+                content : this.encode(places[i].additionalText),
+                category_id : places[i].category_id,
+                vtb_object_id : places[i].vtbObjectId,
+                ...images
+            });
+        };
+
+        return result;
+    }
+
+    getImages(media, crop)
+    {
+        const result = {
+            file_size: [],
+            file_mime_type: [],
+            file_name: [],
+            file_path: [],
+            file_active: [],
+            file_type: []
+        };
+        
+        return new Promise((resolve, reject) => {
+            media.forEach(image => {
+                const regex = (image.url.match(/amazonaws\.com/)) ? /\.com\/(.*?)\/((?:.*?)\/(?:.*?))\//g : /\.(?:nl|com|travel|io)\.?\/((?:.*?)\/(?:.*?))\//g;
+                const match = regex.exec(image.url);
+    
+                if(match) {
+                    let replace = (match.length == 3) ? match[2] : match[1];
+                    image.url = image.url.replace(replace, crop);
+                }
+        
+                const req = https.request(image.url, res => {
+                    let body = '';
+                    res.on('data', chunk => {
+                        body += chunk;
+                    })
+                  
+                    res.on('end', () => {
+                        const frags = image.url.split('/');
+                        result.file_name.push(frags[frags.length - 1]);
+                        result.file_path.push(image.url);
+                        result.file_mime_type.push(res.headers['content-type']);
+                        result.file_size.push(res.headers['content-length']);
+                        result.file_active.push(1)
+                        result.file_type.push(1);
+
+                        resolve(result);
+                    })
+                });
+                req.end();
+            });
+        })
+    }
+
+    request(method, path, data)
+    {
+        const payload = (data) ? JSON.stringify(data) : false;
+
+        return new Promise((resolve, reject) => {
+            const options = {
+                hostname: this.hostname,
+                path: pth.join(this.pathPrefix, path),
+                method: method,
+            }
+
+            if(payload) {
+                options.headers = {
+                    'Content-Type': 'application/json',
+                    'Content-Length': payload.length
+                };
+            }
+            
+            if(this.token) {
+                options.headers.Authorization = `Bearer ${this.token}`;
+            }
+
+            const req = https.request(options, res => {
+                let result = '';
+                res.on('data', chunk => {
+                    result += chunk;
+                })
+              
+                res.on('end', () => {
+                    resolve(JSON.parse(result))
+                })
+            });
+
+            req.on('error', error => {
+                console.error(error);
+
+                reject(false);
+            });
+
+
+            if(payload) {
+                req.write(payload)
+            }
+            
+            req.end();
+        });
+    }
+
+    findId(key, id) {
+        if(this.history.hasOwnProperty(key) && this.history[key].hasOwnProperty(id)) {
+            return this.history[key][id];
+        }
+    
+        return false;
+    }
+
+    encode(text)
+    {
+        if(!text) return '';
+
+        return text.replace('ë', '&euml;').replace('é', '&eacute;').replace('ï', '&iuml;').replace('ñ', '&ntilde;').replace('±', '&plusmn;');
+    }
+
+    async login()
+    {
+        let crediantials = await this.request('POST', 'login', {
+            email: this.transformer.email,
+            password: this.transformer.password
+        });
+
+        if(!crediantials || !crediantials.data) {
+            console.log('***** Incorrect login credentials *****');
+            return false;
+        }
+
+        this.token = crediantials.data.token;
+
+        return true;
+    }
+
+    async createOrganization(data)
+    {
+        return await this.request('POST', `organizations`, data);
+    }
+
+    async updateOrganization(id, data)
+    {
+        return await this.request('PUT', `organizations/${id}`, data);
+    }
+
+    async createMember(data)
+    {
+        return await this.request('POST', `members`, data);
+    }
+
+    async updateMember(id, data)
+    {
+        return await this.request('PUT', `members/${id}`, data);
+    }
+
+    async createExcursion(data)
+    {
+        return await this.request('POST', `excursions`, data);
+    }
+
+    async updateExcursion(id, data)
+    {
+        return await this.request('PUT', `excursions/${id}`, data);
+    }
+
+    async createTravel(data)
+    {
+        return await this.request('POST', `travels`, data);
+    }
+
+    async updateTravel(id, data)
+    {
+        return await this.request('PUT', `travels/${id}`, data);
+    }
+
+    async createAccommodation(data)
+    {
+        return await this.request('POST', `accommodations`, data);
+    }
+
+    async updateAccommodation(id, data)
+    {
+        return await this.request('PUT', `accommodations/${id}`, data);
+    }
+
+    async createPlace(data)
+    {
+        return await this.request('POST', `places`, data);
+    }
+
+    async updatePlace(id, data)
+    {
+        return await this.request('PUT', `places/${id}`, data);
+    }
+}
+
+module.exports = { Appit };

package/index.js

@@ -0,0 +1,2 @@
+exports.Appit = require('./appit').Appit;
+exports.AppitBaseTransformer = require('./appit-base-transformer').AppitBaseTransformer;

package/package.json

@@ -0,0 +1,14 @@
+{
+    "name": "vtb-appit",
+    "version": "0.0.1",
+    "description": "",
+    "main": "index.js",
+    "scripts": {
+    },
+    "author": "",
+    "license": "ISC",
+    "dependencies": {
+      
+    }
+  }
+