biketrack-plainjs/functions.js

// needed for instantiation of ipfs
 const initIPFS = async (IPFS, ORBITDB) => {


}
initIPFS()
async function createDb(){
  const ipfs = await Ipfs.create({repo: 'ok' + Math.random()}); 

// Create database instance
 const orbitdb = await OrbitDB.createInstance(ipfs)

 const db = await orbitdb.keyvalue('routes')
                const address = db.address
                await db.put('2022-07-01T10:49:07', '49.41185089/8.67646861',{pin: true})
                await db.put('2022-07-01T10:49:12', '49.41166303/8.67652893')
                await db.put('2022-07-01T10:49:20','49.41123636/8.67652849')
                await db.put('2022-07-01T10:49:25','49.41084041/8.67651128')
                await db.put('2022-07-01T10:49:31','49.41049801/8.67656948')
                await db.put('2022-07-01T10:49:38','49.4102198/8.67658131')
                await db.put('2022-07-01T10:49:44','49.40982577/8.67668618')
                await db.put('2022-07-01T10:49:50','49.4095211/8.6767495')
                await db.put('0000','00/00');
                await db.put('2022-07-01T10:56:43','49.39117231/8.68814905')
                await db.put('2022-07-01T10:56:50','49.39076199/8.68818273')
                await db.put('2022-07-01T10:56:59','49.39058452/8.68776805')
                await db.put('2022-07-01T10:57:04','49.39048152/8.68746322')
                await db.put('2022-07-01T10:57:10','49.39009475/8.68742468')
                await db.put('2022-07-01T10:57:18','49.38966856/8.68741891')
                await db.put('2022-07-01T10:57:26','49.3896966/8.68683682')
                await db.put('2022-07-01T10:57:34','49.38985798/8.68647962')
                await db.put('2022-07-01T11:00:12','49.38983544/8.68654936')
                await db.put('2022-07-01T11:00:19','49.38982943/8.68686349')
                await db.put('2022-07-01T11:00:24','49.38988557/8.68711804')
                await db.put('2022-07-01T11:00:32','49.38975355/8.68742027')
                await db.put('2022-07-01T11:00:39','49.38968475/8.68789061')
                await db.put('2022-07-01T11:00:47','49.38968741/8.68864464')
                await db.put('2022-07-01T11:00:56','49.38981096/8.68935897')
                await db.put('2022-07-01T11:01:03','49.38991498/8.6898232')
                await db.put('2022-07-01T11:01:13','49.39008687/8.69005123')
                await db.put('2022-07-01T11:01:20','49.39012705/8.69004198')
                await db.put('2022-07-01T11:01:42','49.39012273/8.69044973')
                await db.put('2022-07-01T11:03:13','49.39020013/8.69013153')
                await db.put('2022-07-01T11:03:37','49.3902416/8.69011779')
                await db.put('2022-07-01T11:06:03','49.39010871/8.68987621')
                let csv = "./new.csv"
                const value = db.all
                console.log('database connected!')
                await db.close()
                return db
               }

               async function loadRoute(){
                const db = await createDb()
                await db.load()
                console.log("loadroute ausgeführt")
                const value = db.all 
                return value;
              }
              async function connectDB(){
                const ipfs = await Ipfs.create()
                const orbitdb = await OrbitDB.createInstance(ipfs)
                const db_route2 = await orbitdb.open('/orbitdb/zdpuApZ7pMKupZjmxPQk8xp34QdAEXHFFjmA3EPWuACN88DwB/coordinates');
                  return db_route2;
              }
              async function getCurrentCoordinate(){
                var db_conn = await createDb()
                const currentCoordinate = db_conn.all
                var latest_coord_string = (currentCoordinate[Object.keys(currentCoordinate)[Object.keys(currentCoordinate).length - 1]])
                var latest_coordinate_str = latest_coord_string.split("/")
                latest_coordinate_str[0] = parseFloat(latest_coordinate_str[0])
                latest_coordinate_str[1] = parseFloat(latest_coordinate_str[1]) 
              
                return latest_coordinate_str;
              }
              
              async function getCurrentTime(){
              
                var db_conn = await createDb()
                const currentCoordinate = db_conn.all
                var all_times = (Object.keys(currentCoordinate))
                var lasttime = all_times[(all_times.length-1)] 
                return lasttime;
              }
              async function getAllCoordinates(){
                var db2 = await createDb()
                const all_coordinates = db2.all
                // coordinates in this schema 49.123/8.2311
                var coordinates = Object.values(all_coordinates)
                // parse to string for split and then split by / 
                var coordinate_string = coordinates.toString()
                var between_string = coordinate_string.split("/")
                var final_string = between_string.toString()
                //comma string looks now like this : 49.1212,8.1231,49.1231, ...
                var comma_string = final_string.split(',')
                // create new Array and put string back in to array for using paths/polylines with leafleat
                var newArray =[];
                // use for loop for iterating over string and put it in the right order
                for (var i = 0; i < comma_string.length; i++) {
                
                   var increment = i+1;
                   newArray.push([comma_string[i], comma_string[increment]])
                   increment = increment+1
                   i = i+1
                }
                 // its only for converting the string array to a float array, because leaflethjs wants only a float array 
                (function(elem) {
                var callee = arguments.callee;
                  return elem instanceof Array ? elem.map(function(elem2) { return callee(elem2); })
                                               : parseFloat(elem);
                })
                newArray = newArray.map(function(elem) {
                  return elem.map(function(elem2) {
                      return parseFloat(elem2);
                  });
                });
                console.log(newArray)
                
                //console.log(newArray)
                return newArray;
                }
//array to store routes absolute
var Absolute_Route = [];                
async function getAllRoutes(){
  var buffer_for_i = 0;
  var db2 = await createDb()
  const current_route = db2.all
  // coordinates in this schema 49.123/8.2311
  var coordinates = Object.values(current_route)
  // parse to string for split and then split by / 
  var coordinate_string = coordinates.toString()
  var between_string = coordinate_string.split("/")
  var final_string = between_string.toString()
  //comma string looks now like this : 49.1212,8.1231,49.1231, ...
  const comma_string = final_string.split(',')
  // create new Array and put string back in to array for using paths/polylines with leafleat
  var route0 =[];
  var route1 = []
  // use for loop for iterating over string and put it in the right order
  //route 0
  for (var i = 0; i < comma_string.length; i++) {
    //console.log(comma_string[i])
    if (comma_string[i] == "00"){
      console.log("00 gefunden")
      buffer_for_i = i +2;
      //console.log(buffer_for_i)
      break;
    }
    route0.push([comma_string[i], comma_string[i+1]])
    i = i+1       
  }
   // its only for converting the string array to a float array, because leaflethjs wants only a float array 
  (function(elem) {
  var callee = arguments.callee;
    return elem instanceof Array ? elem.map(function(elem2) { return callee(elem2); })
                                 : parseFloat(elem);
  })
  route0 = route0.map(function(elem) {
    return elem.map(function(elem2) {
        return parseFloat(elem2);
    });
  });
  for (var i = buffer_for_i; i < comma_string.length; i++) {
    console.log(buffer_for_i)
    if (comma_string[i] == "00"){
      break;
    }else if(comma_string[i] == "11"){
      noroutes = 1;
    }
    route1.push([comma_string[i], comma_string[i+1]])
    i = i+1        
  }
  (function(elem) {
  var callee = arguments.callee;
    return elem instanceof Array ? elem.map(function(elem2) { return callee(elem2); })
                                 : parseFloat(elem);
  })
  route1 = route1.map(function(elem) {
    return elem.map(function(elem2) {
        return parseFloat(elem2);
    });
  });
  // maybe in loop?
  Absolute_Route[0] = route0;
  Absolute_Route[1] = route1;
  console.log("routes written in buffer")
  return [route0, route1];
}

async function createRouteObject(){              
              var currentime = await getCurrentTime()
              var myBtn = document.createElement("p");
              myBtn.innerHTML = "<ul><li><div><h4 >Last traveled Route</h4><div><p>" +currentime+"</p></div></div></li></ul>";
              document.ul.appendChild(myBtn); 
}           
async function createlistitem() {
    var currentime = await getCurrentTime();
    var ul = document.getElementById("list");
    var li = document.createElement("li");
    li.appendChild(document.createTextNode("Last travelled route on: "   +currentime+""));
    ul.appendChild(li);
}
async function clearMap() {
  console.log("clearing map")
  for(i in map._layers) {
      if(map._layers[i]._path != undefined) {
          try {
              map.removeLayer(map._layers[i]);
          }
          catch(e) {
              console.log("problem with " + e + map._layers[i]);
          }
      }
  }

}
async function allRoutes(number_of_the_route) {
  
  //color theming
  var color = ["blue","red","green","purple","gray","yellow"];
  var i = Math.floor(Math.random() * 5) ;
  console.log("calling prepare")
  let current = await prepare();
  const current_route = current[number_of_the_route];
  
  clearMap();
  polyline = L.polyline(current_route, {color: color[i]}).addTo(map);
  var currentime = await getCurrentTime();
  var ul = document.getElementById("list");
  var li = document.createElement("li");
  li.appendChild(document.createTextNode("Route "+ (number_of_the_route + 1) + " was travelled on: " + currentime + "" ));
  ul.appendChild(li);
  
 //important for maps
  map.fitBounds(polyline.getBounds());
  map.fitBounds(polyline.getBounds());

  return currentime;
}
async function singleRoute(route_nr){
  const current_route = Absolute_Route[route_nr];
  console.log(Absolute_Route[route_nr]);
  var color = ["blue","red","green","purple","gray","yellow"];
  var i = Math.floor(Math.random() * 5) ;
  clearMap();
  console.log("painting map");
  polyline = L.polyline(current_route, {color: color[i]}).addTo(map);
  //var currentime = await getCurrentTime();
  var ul = document.getElementById("list");
  var li = document.createElement("li");
  ul.appendChild(li);
  
 //important for maps
  map.fitBounds(polyline.getBounds());
  map.fitBounds(polyline.getBounds());
  console.log("finished singelRoute()");
}
async function showRoutes(){
  console.log("Calling getAllRoutes")
  var len_of_Routes = await getAllRoutes();
  var len = len_of_Routes.length ;
  console.log("Gotten all routes");

  var i = 0;
  
  console.log("creating buttons")
    let btn0 = document.createElement("button");
    btn0.innerHTML = ("Route 1");
    btn0.onclick = function () {  
      singleRoute(0);
    };
    let btn1 = document.createElement("button");
    btn1.innerHTML = ("Route 2");
    btn1.onclick = function () {  
      singleRoute(1);
    };
 
    i = i + 1;
    document.body.appendChild(btn0);
    document.body.appendChild(document.createElement('br'));
    document.body.appendChild(btn1);
    console.log("Finsihed showing routes")
}