Forem: Bogdan Alexandru Militaru

How to find the size of a table in SQL?

Bogdan Alexandru Militaru — Tue, 08 Aug 2023 09:09:09 +0000

As a SQL developer or database administrator, it is essential to have a good understanding of the size of your database tables. Knowing the size of a table can help you optimize your database performance, plan for storage requirements, and troubleshoot issues related to database performance. In this blog post, we will guide you through the process of finding the size of a table in SQL.

Here’s how you can see the size table sizes for public schema

SELECT
    table_name,
    pg_size_pretty(pg_relation_size(quote_ident(table_name))),
    pg_relation_size(quote_ident(table_name))
FROM
    information_schema.tables
WHERE
    table_schema = 'public'
ORDER BY
    3 DESC;

See sizes of tables of all schemas:

SELECT
    schema_name,
    relname,
    pg_size_pretty(table_size) AS size,
    table_size
FROM (
    SELECT
        pg_catalog.pg_namespace.nspname AS schema_name,
        relname,
        pg_relation_size(pg_catalog.pg_class.oid) AS table_size
    FROM
        pg_catalog.pg_class
        JOIN pg_catalog.pg_namespace ON relnamespace = pg_catalog.pg_namespace.oid) t
WHERE
    schema_name NOT LIKE 'pg_%'
ORDER BY
    table_size DESC;

MongoDB Query date by _id field

Bogdan Alexandru Militaru — Tue, 08 Aug 2023 09:09:09 +0000

In order to make a query based on _id, comparing dates, you can use $convert function to extract the date from ObjectId.

Example:

$convert: { input: "$_id", to: "date" }

To query dates comparing between start and end time:

db.collection.find({
  "$expr":{
    "$and":[
      {"$gte":[{"$convert":{"input":"$_id","to":"date"}}, ISODate("2023-08-01T00:00:00.000Z")]},
      {"$lte":[{"$convert":{"input":"$_id","to":"date"}}, ISODate("2023-08-02T11:59:59.999Z")]}
    ]
  }
})

The shorthand version using $toDate function helps you achieve the same result:

db.collection.find({
  "$expr":{
    "$and":[
      {"$gte":[{"$toDate":"$_id"}, ISODate("2023-08-01T00:00:00.000Z")]},
      {"$lte":[{"$toDate":"$_id"},ISODate("2023-08-02T11:59:59.999Z")]}
    ]
  }
})

Source

Image by Vikash Kr Singh from Pixabay

Netopiajs library for nodejs

Bogdan Alexandru Militaru — Thu, 06 Apr 2023 09:09:09 +0000

Check the nodejs library module I wrote for the integration with Netopia Payments, an European Payment provider.

You can find the repository on Github boobo94/netopia-js

Initial setup

Copy the package to modules/netopia and install dependencies

  npm i ./modules/netopia-js

Set the environment variables

# or something else, for example local, staging
ENVIRONMENT=production
# your fallback url, after the payment is made the user will be redirected to this screen
NETOPIA_BASE_URL=http://localhost
 # your webhook url where Netopia sends confirmation messages
NETOPIA_WEBHOOK_URL=http://localhost:8000/api/v1/webhooks/netopia
# the seller account id found in Admin > Seller Accounts > in the table press edit near the seller account >
# > Security Settings (4th tab) > is under Seller account id having format XXXX-XXXX-XXXX-XXXX-XXXX
NETOPIA_SELLER_ID=123456789
# under seller account there is Digital Certificate Netopia Payments (the public key)
# download the certificate then copy an paste the certificate inside quotes
# for those who use dotenv library, you need at least v15
NETOPIA_PUBLIC_KEY="change_me"
# under the public key there is Seller Account Certificate (the private key)
# download the certificate then copy an paste the certificate inside quotes
NETOPIA_PRIVATE_KEY="change_me"
# If your implementation requires an user go to Admin > Users > Create a new one (you should talk with Netopia about your needs)
# but here you find the username and the password that you picked
NETOPIA_ACCOUNT_USERNAME=change_me
NETOPIA_ACCOUNT_PASSWORD=change_me
NETOPIA_CURRENCY=RON

To get the settings of account login into Netopia.

Usage

Import

import Netopia from '../../../modules/netopia'

IPN using Express

import Netopia from '../../../modules/netopia'
import { urlencoded } from 'express';

// ...

.post(
  '/api/v1/webhooks/netopia',
  urlencoded({ extended: false }),
  async (req, res) => {
    const ipnResponse = await Netopia.parseIPNResponse(req.body)

    // action = status only if the associated error code is zero
    if (ipnResponse.success) {
      switch (ipnResponse.decoded.order.mobilpay.action) {
        // every action has an error code and an error message
        case 'confirmed': {
          // confirmed actions means that the payment was successful and
          // the money was transferred from custtomers account to the merchant account and you can deliver the goods

          break
        }
        case 'confirmed_pending': {
          // confirmed pending action means that the transaction pending for antifraud validation
          // you should not deliver the goods to the customer until a confirmed or canceled action is received

          break
        }
        case 'paid_pending': {
          // confirmed paid pending action means that the transaction pending validation
          // you should not deliver the goods to the customer until a confirmed or canceled action is received

          break
        }
        case 'paid': {
          // paid action means that the transaction pre-authorized
          // you should not deliver the goods to the customer until a confirmed or canceled action is received

          break
        }
        case 'canceled': {
          // canceled action means that the payment was canceled
          // you should not deliver the goods to the customer

          break
        }
        case 'credit': {
          // credit action means that the payment was refund

          break
        }
        default:
          throw Error('action parameter is not supported')
      }
    } else {
      console.error('error ipn', ipnResponse.decoded.order.mobilpay.error)
    }

    return res.status(200).send(ipnResponse.response)
  }
)

(#ipn-response)

IPN response example

{
  "decoded": {
    "order": {
      "$": {
        "id": "l1or6vvj25sw9uxlae0g",
        "timestamp": "1649321087455",
        "type": "card"
      },
      "signature": "87Y7-EA62-UDK4-8EW2-4PQE",
      "url": {
        "return": "http://localhost:8000",
        "confirm": "http://localhost:8000/api/v1/webhooks/netopia"
      },
      "invoice": {
        "$": {
          "currency": "RON",
          "amount": "1"
        },
        "details": "test plata",
        "contact_info": {
          "billing": {
            "$": {
              "type": "person"
            },
            "first_name": "John",
            "last_name": "Doe",
            "address": "my street",
            "email": "contact@cmevo.com",
            "mobile_phone": "071034782"
          },
          "shipping": {
            "$": {
              "type": "person"
            },
            "first_name": "John",
            "last_name": "Doe",
            "address": "my street",
            "email": "contact@cmevo.com",
            "mobile_phone": "071034782"
          }
        }
      },
      "mobilpay": {
        "$": {
          "timestamp": "20220407115352",
          "crc": "536ef5f26486b6071161bc0ad4a2263b"
        },
        "action": "paid",
        "customer": {
          "$": {
            "type": "person"
          },
          "first_name": "John",
          "last_name": "Doe",
          "address": "my+street",
          "email": "contact%40cmevo.com",
          "mobile_phone": "071034782"
        },
        "purchase": "1334168",
        "original_amount": "1.00",
        "processed_amount": "1.00",
        "current_payment_count": "1",
        "pan_masked": "9 **** 5098",
        "rrn": "9991649",
        "payment_instrument_id": "41679",
        "token_id": "MTUyOTI0OsFnpdPjsR3KzdyA1KKC5BHlVdHDrqbizsPYR39SlVuRrVbR6sBfr0tQPx5YxImCEIrIPShZ8nKcdsw/TFQR86c=",
        "token_expiration_date": "2024-04-07 11:53:52",
        "error": {
          "_": "Tranzactie aprobata",
          "$": {
            "code": "0"
          }
        }
      }
    }
  },
  "response": "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n<crc>success</crc>",
  "success": true
}

Use IPN webhook from localhost

In order to connect Netopia with your local API, you need to expose your server running locally to the internat. To do that you can simply use SSH tunneling. Connect localhost to the internet is an article which describes how to do that.

If you’re hurry use localhost.run, documentation here by simply:

ssh -R 80:localhost:8000 nokey@localhost.run

Pay attention which port your server is running, in my example the server is running on port 8000. Just change with your port and hit the ENTER button to get something like this in the console:

de3a810e7aa2b9.lhrtunnel.link tunneled with tls termination, https://de3a810e7aa2b9.lhrtunnel.link

Just copy that base url and set the environment variable NETOPIA_WEBHOOK_URL, now it should looks like NETOPIA_WEBHOOK_URL=https://de3a810e7aa2b9.lhrtunnel.link/api/v1/webhooks/netopia.

NOTE!!!

Very important to know, after few minutes/hour the ssh tunnel url is changed, you need to copy paste the url again.

How to create a simple payment or add the card in Netopia

To create simple payments where the user insert the card. This method returns an html form that submits automatically, simulating the redirect to Netopia’s payment page, where the customer has to fill the card details.

const response = await Netopia.createSimplePayment(
  "10", // the price in RON, in string format
  {
    type: 'person', // optional, options: 'person' or 'company', default = 'person'
    firstName: 'John', // required
    lastName: 'Doe', // required
    address: "my street", // required
    email: "contact@cmevo.com", // required
    phone: "071034782", // required
    description: "the product or service description", // required
  },
  {
    // pass custom params that will be returned to you on IPN later
    "userId": 1,
    "internalPaymentId": "3sad3",
    "foo": "bar"
  }
);

This method can be used to register a card using the alias registerCard(amount, billing, params). Is the same function. Create a symbolic transaction of 1 RON. If your seller account has an user which is activated for token usage, you’ll receive on IPN a token. Save it for further payments. Very important , if your account is set with pre-authorization, when the IPN response confirm the card addition you should capture that transaction of 1 RON.

await Netopia.capture(ipnResponse.decoded.order.$.id,1)

Save the token for further payments

The token can be saved from the IPN response from path decoded.order.mobilpay.token_id.

Create payment based on tokens or authorize a payment

If your seller account doesn’t have pre-authorization active, by default all payments are captured instantly.

const response = await Netopia.captureWithoutAuthorization(
  "10", // the price in RON, in string format
  "the token stored previously",
  {
    type: 'person', // optional, options: 'person' or 'company', default = 'person'
    firstName: 'John', // required
    lastName: 'Doe', // required
    address: "my street", // required
    email: "contact@cmevo.com", // required
    phone: "071034782", // required
    description: "the product or service description", // required
    country: "Romania", // optional, default = 'Romania'
    county: "Bucharest", // optional, default = 'Bucharest'
    city: "Bucharest", // optional, default = 'Bucharest'
    postalCode: "123456", // optional, default = '123456'
  },
  {
    // pass custom params that will be returned to you on IPN later
    "userId": 1,
    "internalPaymentId": "3sad3",
    "foo": "bar"
  });

I created an alias of this function for pre-authorization (if your seller account supports), only to be easier for you with the name. Instead of captureWithoutAuthorization(...) use authorize(...). Pre-authorization means the money are locked in the customer’s account, but are not transferred to your account until you don’t execute the capture method. If you use have pre-authorization, save for later the order id created from response.order.id.

Capture a pre-authorized payment

Execute this function to transfer the money from customer to your account.

const response = await Netopia.capture(
  "previous order id pre-authorized", // response.order.id, where response = Netopia.authorize(...), in string format
  "5", // the price in RON, in string format
  )

You can capture the pre-authorize value or a smaller amount and the difference will remain in the customer. Is not a refund, because the money didn’t leave his account yet. You only capture partially. You cannot capture more than the pre-authorized value.

Netopia has a limitation when you have pre-authorization active on you seller account and you need to do both payments with pre-authorizations and instant capture. The are unable to do it using a single customer account. I implemented this functionality using an workaround by doing authorize and capture. Use function authorizeAndCapture(amount, token, billing, params).

Cancel pre-authorized payment

If you decide at any moment to cancel a payment, use:

const response = await Netopia.cancel(
  "previous order id pre-authorized", // response.order.id, where response = Netopia.authorize(...), in string format
)

Refund payment

If you decide to refund a payment

const response = await Netopia.refund(
  "previous order id pre-authorized", // response.order.id, where response = Netopia.authorize(...), in string format
  "5", // the price in RON, in string format
  )

The amount you refund can be different that the value you captured. For example if you captured 5 lei, you can refund only 2, maximum 5.

Delete card by removing the token

To delete a card and make the token inactive for further payments do:

const response = await Netopia.deleteCard(
  "the token stored previously",
)

How to check the SOAP documentation

Install Wizdler browser extension and check https://secure.mobilpay.ro/api/payment2/?wsdl There you’ll find all methods available.

Testing

You can find a simple payment example and Netopia’s Github.

Cards

9900004810225098 - card accepted, CVV = 111

9900541631437790 - card expired

9900518572831942 - insufficinet funds

9900827979991500 - CVV2/CCV incorect

9900576270414197 - transaction declined

9900334791085173 - high risk card (for example is a stolen card)

9900130597497640 - error from the bank (connection with the bank cannot be established)

Managerflota idea validation

Bogdan Alexandru Militaru — Sat, 25 Mar 2023 09:09:09 +0000

Managerflota.ro idea validation thread

Manage the car hailing business in one web app.

Features:

instant payment reports
employee management
financial management
car management

Simple, clean and safe!

Recently I figure out that the car hailing fleet managers in Romania spend a lot of time with the administration part of their business.

The idea: create a simple app that manage their money, expensive, presenting weekly payment reports for each individual driver First thing first I need to validate this idea.

So is very important to make it official and looks very professional. Create a simple landing page which describes the app. After I talk with the potential client, I can share with him the link.

Look here (yes it’s in Romanian only)

Manager Flotă pentru Transport Alternativ - Cmevo Digital Singura platformă web de administrare a flotelor de transport alternativ. Poți gestiona șoferii, plățile săptămânale, contracte de închiriere mașini și https://cmevo.com/ro/manager-flota-pentru-transport-alternativ/ For easier understanding of the platform, created some mock-ups using diagrams.net

The flow of the app is complete. This helped me to understand what is the initial proposal and get some initial screens of the app (presented in the landing page as well) http://diagrams.net Next I need to contact potential customers.

Where can I find them?

Easy.. let’s search and see.

Options:

Ads websites who post job offers
An Romanian authority who manage and regulate this industry

First option seems very hard to follow so I decided to go with second. I searched if there’s any place where I can find all the authorized fleets, and surprise .. they exists and is even public information. One issue, I need the contact info of each fleet.

There are many pages with tables with name of the company and authorization number.

If you click on the row of the table, a new page is opened and there are many info like: phone number, company name, number of drivers But the public info cannot be downloaded.

I can do manual work, and yes I don’t do it, because I’m an engineer and I want an automated way to handle it.

So I used webscraper .io, spend 1-2h to figure out how to figure out how to configure it with the website, but I succeed. Now I have all the details about companies. Open the spreadsheet, sort descending by number of drivers and let’s go!

Prepared the message that will be sent to each fleet. I don’t want to call each one because is very time consuming, sms is not an option. But people use WhatsApp a lot here, so guess what I did?!

Use the api.whatsapp .com?phone=the-number-here&mesaage=your-message-url-encoded Place the message in spreadsheet and use a concatenation formula between previous url and message

repeat formula for all lines in the table and that’s all..

we have a full prefilled list of messages All I have to do is to click on each link and then the WhatsApp will automatically open

I just have to press the “send” button

WIP 🚧 How I organized to send messages.

Create the excel, put all the api messages in trellis checklist.

From phone, with the first click I open the WhatsApp, the message is already prefilled so I only need to send the message. The third click complete checkbox in trellis list. Sent 14 WhatsApp messages to fleet managers today, Just to test.

Only 3 were interested to quick reply at 3 questions.

Only 2 replied as interested. I had a phone call with one of them who provided a lot of very useful informations.

They already use an excel template and was trying to find someone and build a custom solution.

This was very helpful to hear. I don’t want to hear “I have a problem, didn’t tried a solutions yet This first batch was only to see how they respond to the idea and how interact with my message.

Next I’ll sent more messages

2 out of 14 means 14% interest, which is satisfying

This week I have to contact most of them and next one decide if the dev starts or drop the idea. New day, new updates

Today I contacted more fleet managers and it seems a promising app.

Here’s a big pain, many of them don’t want to go to work each Monday, because that’s the day when they have to do manual work and prepare the payments for their drivers. This means my app is exactly what they need.

The interest percentage dropped to 13, but I’m still satisfied. There’s no market here so they don’t have a comparative solution.

I’m pretty sure more will want after they see a real demo. I found some interesting perspective and ideas shared.

Some of them already tried to develop apps for internal use, but without full support for all requirements. This means a proper validation to me. But I continue to ask them.

I have 160 more to ask, because is a validation and a presale round as well.

I want to find at least 20 customers at least. The market share is around 6900 companies. But only 200 have a minimum of 20 employees (drivers). And they are the relevant audience. I had even a partnership proposal.

A big company tried to create a similar app, but only for internal use.

They didn’t completed with all the necessary features and proposed me to work together and do this app. Currently we have an open proposal, but probably is better to wait until I talk with more potential customers.

This company was very control freaked, tried a similar partnership, and block it because the other side wanted to have full ownership. Partners are good, but I have already most of the features on the table, I have all the contacts, they don’t offer anything too much.

They want only to use the app and build it around their own requirements. I contacted fleet managers to validate my idea

• more than 100 contacted • 9 were interested to buy • 4 wants to try a demo • 7 unfinished discussion • 5 not interested at all • 40 seen

I have 70 more to contact. They hate Mondays, because they have to do all the maths.

It sounds like a good idea after all and probably many will come later, after the app is released.

One came today to ask me if the platform is available. So probably they talk between themselves. Today I had a look over the weekly payment reports, csv export, of car-hailing platforms: Uber, Bolt, Splash. I need to figure out how much time should be invested to aggregate all the data. Uber seems pretty messy and error-prone. Bolt and Splash are ok for the moment. Each driver can have accounts on multiple platforms and their weekly activity has to be aggregated in one place (the manager flota app that I want to build). The only unique identifier found is the name. Is not the best option, because I already know that existing fleets have more drivers with the same name.

Not all carhailing platforms offer the phone number in their exports, so this was a better option. Is pretty insane that some people are so happy to share info with you. And spent time explaining what problems they have, how they can be solved, and many more. Even one of them shared with me their Excel, to present how they automated the calculus with Excel, the structure, and all the needed info. Another great discovery was that a few of them had the idea of building this app, for internal use or exactly the same product I want to build.

Is this proper validation?

Generate hexagons in JS based on center coordinates and radius

Bogdan Alexandru Militaru — Fri, 17 Mar 2023 09:09:09 +0000

How to generate hexagons in javascript based on the center point coordinates and radius length

function drawHexagon (centerPointLatitude, centerPointLongitude, radiusLength) {
  const radius = radiusLength / 6371

  const angle = 2 * Math.PI / 6 // 2PI (360 degree) divded by 6 points of the hexagon shape

  const hexagon = []
  for (var i = 0; i < 6; i++) {
    const longitude = centerPointLongitude + (radius * Math.cos(angle * i))
    const latitude = centerPointLatitude + (radius * Math.sin(angle * i))

    hexagon.push([longitude, latitude])
  }

  // close the polygon adding the initial point
  hexagon.push(hexagon[0])

  return hexagon
}

drawHexagon(44.4268, 26.1024, 10)

Image credits Pixabay

Get your Jenkins Passwords from secrets

Bogdan Alexandru Militaru — Wed, 14 Sep 2022 09:09:09 +0000

Demo

Check SEO meta: https://metadescriptiontool.com/

First of all, if you have access to your Jenkins server the credentials are stored at:

vi /var/lib/jenkins/credentials.xml

In order tot get your credentials go to http://YOUR\_IP:8080/script and copy and paste the content below the hit RUN.

com.cloudbees.plugins.credentials.SystemCredentialsProvider.getInstance().getCredentials().forEach{
  it.properties.each { prop, val ->
    if (prop == "secretBytes") {
      println(prop + "=>\n" + new String(com.cloudbees.plugins.credentials.SecretBytes.fromString("${val}").getPlainData()) + "\n")
    } else {
      println(prop + ' = "' + val + '"')
    }
  }
  println("-----------------------")
}

Source: https://devops.stackexchange.com/questions/2191/how-to-decrypt-jenkins-passwords-from-credentials-xml/8692#8692?newreg=9197ac19da1b457fb643798bcfa94e05

Linode Object Storage usage in NodeJS

Bogdan Alexandru Militaru — Mon, 15 Nov 2021 09:09:09 +0000

Simple use case of Linode Object storage in NodeJS with AWS-SDK for S3. Learn how to handle Linode Objects in plain Javascript.

import { Credentials } from 'aws-sdk';
import S3 from 'aws-sdk/clients/s3';

const s3Client = new S3({
  region: process.env.LINODE_OBJECT_STORAGE_REGION,
  endpoint: process.env.LINODE_OBJECT_STORAGE_ENDPOINT,
  sslEnabled: true,
  s3ForcePathStyle: false,
  credentials: new Credentials({
    accessKeyId: process.env.LINODE_OBJECT_STORAGE_ACCESS_KEY_ID,
    secretAccessKey: process.env.LINODE_OBJECT_STORAGE_SECRET_ACCESS_KEY,
  }),
});

export async function uploadFileToObjectStorage(base64Data, path, fileName, fileType, extension) {
  const params = {
    Bucket: process.env.LINODE_OBJECT_BUCKET,
    Key: `${path}/${fileName}`,
    Body: base64Data,
    ACL: 'public-read',
    ContentEncoding: 'base64',
    ContentType: `${fileType}/${extension}`,
  };

  // see: http://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/S3.html#upload-property
  const { Location } = await s3Client.upload(params).promise();
  return Location;
}

export async function deleteFileFromObjectStorage(url) {
  const Key = url.split(`${process.env.LINODE_OBJECT_STORAGE_ENDPOINT}/`)[1];
  const params = {
    Bucket: process.env.LINODE_OBJECT_BUCKET,
    Key,
  };

  // see: https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/S3.html#deleteObject-property
  // eslint-disable-next-line consistent-return
  return s3Client.deleteObject(params).promise();
}

Hosting providers - free & paid

Bogdan Alexandru Militaru — Mon, 01 Nov 2021 09:09:09 +0000

Freemium Resources

Heroku
Netlify
Vercel
Firebase
Surge
Render
Hostman - free for frontend always, pay only for backend apps.
Glitch
Fly
Fleek
Begin
Stormkit
Deta
Commonshot - Static web hosting and CDN.
Heliohost - PHP, Ruby on rails, perl, django, java(jsp)
Fast
kintohub - supports the static site, web app, backend apps.
Torus.host
Bip - Static web hosting provider
Cloudflare pages - Static web hosting provider
GitHub Pages - Static web hosting provider
GitLab Pages - Static web hosting provider

Paid providers

Sources:

Unserialize php in Javascript Nodejs

Bogdan Alexandru Militaru — Thu, 28 Oct 2021 09:09:09 +0000

import PhpUnserialize from 'php-unserialize';

const serialized = 'a:0:{}'
const jsObject = PhpUnserialize.unserialize(serialized);
console.log(jsObject) // {}

NPM Library: https://www.npmjs.com/package/php-unserialize

What happens if your serialized string contains special characters ? yeah, it fails!

In order to solve that we can use

import encoding from 'encoding';

export function convertToUtf8Win1252(str) {
  return encoding.convert(str, 'WINDOWS-1252').toString();
}

So mixing both functions:

export function unserializePhp(str) {
  return PhpUnserialize
    .unserialize(convertToUtf8Win1252(str));
}

NPM Library: https://www.npmjs.com/package/encoding

Create kml/kmz files in Nodejs

Bogdan Alexandru Militaru — Thu, 28 Oct 2021 09:09:09 +0000

Libraries used:

Create kml file - https://www.npmjs.com/package/@maphubs/tokml Create geojson - https://www.npmjs.com/package/geojson Create kmz using zip - https://www.npmjs.com/package/jszip

Create KML File


const points = [
    {latitude: 39.984, longitude: -75.343},
    {latitude: 39.284, longitude: -75.833},
    {latitude: 39.123, longitude: -74.534},
    {line: [[102.0, 0.0], [103.0, 1.0], [104.0, 0.0], [105.0, 1.0]],}
]

const geojsonObject = geojson.parse(points, {
    Point: ['latitude', 'longitude'],
    LineString: 'line',
}), {
    documentName: 'Document Name',
    documentDescription: 'KML Export'
}

  const response = tokml(geojsonObject);

Content-type for kml:

'Content-Type': 'application/vnd.google-earth.kml+xml',

Create KMZ File

  const zip = new JSZip();
  zip.file('doc.kml', kmlFile);

  return zip.generateAsync({ type: 'nodebuffer' });

Content-type for kml:

'Content-Type': 'application/vnd.google-earth.kmz',

Free ideas for the next startup

Bogdan Alexandru Militaru — Wed, 08 Sep 2021 09:09:09 +0000

I would like to share with you boys some places where you can find ideas, share ideas and why not validate ideas.

PS: This would be updated

Twilio Proxy for masked phone numbers in Node.js

Bogdan Alexandru Militaru — Fri, 02 Jul 2021 09:09:09 +0000

Twilio Proxy for masked phone numbers in Node.js

Twilio offers a service called Proxy to allow masked phone numbers. What that means? You know when you call an Uber and the number shown to you is not the phone number of your driver?! Exactly that means masked phone number.

The Proxy API connects two parties together, allowing them to communicate and keep personal information private.

How to make a call in Node.js

Let’s get to the point. I’ve made a twilio-service.js

import Twilio from 'twilio'

const TWILIO_SERVICE_ID = 'YOUR_SERVICE_ID' // create a service here: https://console.twilio.com/us1/develop/proxy/services
const TWILIO_ACCOUNT_SID= 'YOUR_ACCOUNT_ID'
const TWILIO_AUTH_TOKEN = 'YOUR_AUTH_TOKEN'

const twilioService = function () {
  let client
  if (!client) {
    client = new Twilio(TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN, {
      logLevel: 'debug'
    })
    delete client.constructor
  }

  return {
    _client: client,

    /**
     * Creates new session to prepare a call
     * docs: https://www.twilio.com/docs/proxy/api/session
     * @returns
     */
    createSession: async function () {
      return client.proxy.services(TWILIO_SERVICE_ID).sessions.create({
        mode: 'voice-only'
      })
    },

    /**
     * Delete a call sesion
     * @param {string} sessionId The id of session
     * docs: https://www.twilio.com/docs/proxy/api/session#delete-a-session-resource
     * @returns
     */
    deleteSession: async function (sessionId) {
      return client
        .proxy
        .services(TWILIO_SERVICE_ID)
        .sessions(sessionId)
        .remove()
    },

    /**
     * Add new participant to the call
     * Maximum 2 participants per call are allowed
     * docs: https://www.twilio.com/docs/proxy/api/participant
     *
     * @param {string} sessionId The id of session
     * @param {string} phoneNumber The phone number of participant to call
     * @returns
     */
    addParticipantToSession: async function (sessionId, phoneNumber) {
      return client
        .proxy
        .services(TWILIO_SERVICE_ID)
        .sessions(sessionId)
        .participants
        .create({
          identifier: phoneNumber
        })
    }

  }
}

export default twilioService()

To make a call only need 3 steps:

Create a new proxy session
Add participants to the session created previously. We have two participants. Each of them has a property identifier (their real phone number) and has assigned a new property proxyIdentifier (the masked phone number).
Now each of them can call their own proxyIdentifier, Twilio match their masked number with the masked number of the recipient, and call then the real number of the recipient.

  import TwilioService from '../services/twilio';

  const participant1Number = '+14156789012';
  const participant2Number = '+17012345678';

  const session = await TwilioService.createSession()
  // session = {
  // ...
  // "sid": "KCaa270143d7a1ef87f743313a07d4069d",
  // ...
  // }
  const participantFrom = await TwilioService.addParticipantToSession(session.sid,participant1Number)
  // participantFrom = {
  // "sid": "KPa4947c3d7b8ca7b0138dbc8181f12e16",
  // "sessionSid": "KCaa270143d7a1ef87f743313a07d4069d",
  // "identifier": "+14156789012",
  // "proxyIdentifier": "+14153749231",
  // }
  const participantTo = await TwilioService.addParticipantToSession(session.sid, participant2Number)  
  participantTo = {
  // "sid": "KP48f197284b3f50c5b31891ecc8377c20",
  // "sessionSid": "KCaa270143d7a1ef87f743313a07d4069d",
  // "identifier": "+17012345678",
  // "proxyIdentifier": "+40371246711",
  // }

What is next?

Let’s say you are +14156789012 and you need to connect with +17012345678. You’ve run the previous code, now Twilio created a proxy between these two numbers. But you don’t know the number of +17012345678.

Take your phone, make a call to your proxyIdentifier, +14153749231 , Twilio identifies your identity and match your masked phone number with the other paticipant, and call their real name +17012345678 , but you never know which is the real number of your companion speaker. To make the call from the other side, do the same.

Do you wanna cancel the proxy between two of them?

 await TwilioService.deleteSession(session.sid);

That is all boys. For further questions send me an email or message on Twitter. Do you like the article? Share it!