TrackerBr

trackerbr

Motivation and Introduction As part of the software team at Nevados we are building an operations and monitoring platform for the Nevados All Terrain Tracker®. A solar tracker is a device that orients a solar panel toward the sun. Every solar tracker constantly sends status information and readings, such as the current angle, temperature, voltages, etc. to our platform and we need to store this information for analysis and visualization. If the tracker is configured to send data every 5 seconds, we have 17,280 data points per tracker per day, 518,400 data points per tracker per month. That sums up a lot of information. This kind of data is called "time-series data" and as for all complex problems in software, there are several solutions (Time Series Databases) for it. The most famous ones being InfluxDB and TimescaleDB. For our platform, we decided to work with , a relatively new product that is optimized for IoT applications and works with the SQL query language. TDEngine There were several arguments for this decision: TDEngine is open source is optimized for IoT applications uses SQL, which is a language we are familiar with is available as a managed service and we can focus on building our application is easy to run locally via Docker In this article, we'll go through the setup of a TDEngine database and tables and how to craft a GraphQL schema that allows us to query the data from various clients and applications. Getting started with TDEngine The easiest way to get started with TDEngine is to use their cloud service. Go to the and create an account. They have a few public databases we can use, which is great to put together a demo or experiment with queries. TDEngine If you want to run TDEngine locally, you can use the Docker image and to retrieve data from various sources and send them to the database, such as system information, ping statistics etc. Telegraf version: '3.9'

services:
  tdengine:
    restart: always
    image: tdengine/tdengine:latest
    hostname: tdengine
    container_name: tdengine

    ports:
      - 6030:6030
      - 6041:6041
      - 6043-6049:6043-6049
      - 6043-6049:6043-6049/udp
    volumes:
      - data:/var/lib/taos

  telegraf:
    image: telegraf:latest
    links:
      - tdengine
    env_file: .env
    volumes:
      - ./telegraf.conf:/etc/telegraf/telegraf.conf Check out the and the . In short, this would look something like this to connect to an MQTT topic: official documentation for the Telegraf configuration TDEngine documentation on Telegraf [agent]
  interval = "5s"
  round_interval = true
  omit_hostname = true

[[processors.printer]]

[[outputs.http]]
  url = "http://127.0.0.1:6041/influxdb/v1/write?db=telegraf"
  method = "POST"
  timeout = "5s"
  username = "root"
  password = "taosdata"
  data_format = "influx"

[[inputs.mqtt_consumer]]
  topics = [
    "devices/+/trackers",
  ] Instead of setting everything up locally and waiting for the database to fill with information, we'll use the public database for this article, which contains ship movements from the 5 major US ports. Using TDEngine with public ship movement data By default, the tables in TDEngine have an implicit schema, which means the schema adapts to the data that is written to the database. This is great for bootstrapping, but eventually, we want to switch to an explicit schema to avoid issues with incoming data. One thing that takes a little time to get used to is their concept of ("STable" for short). In TDEngine there are tags (keys) and columns (data). For each key combination, a "table" is created. All tables are grouped in the STable. Super Tables Looking at the database, they have one STable called which contains a lot of tables. Usually, we do not want to query on a per-table basis, but always use the STable to get accumulated data from all tables. vessel ais_data TDEngine has a function which allows us to inspect the schema of a table or STable. The has the following schema: DESCRIBE ais_data The STable has two keys and six data columns. The keys are the and the . We can use regular SQL statements to query the data: mmsi name SELECT ts, name, latitude, longitude FROM vessel.ais_data LIMIT 100;

ts                        name      latitude   longitude
2023-08-11T22:07:02.419Z  GERONIMO  37.921673 -122.40928
2023-08-11T22:21:48.985Z  GERONIMO  37.921688 -122.40926
2023-08-11T22:25:08.784Z  GERONIMO  37.92169  -122.40926
... Keep in mind that time-series data is usually very large, so we should always limit the resultset. There are a few time-series specific functions that we can use, like which groups results by key and is useful to get the latest update individual keys. For example: PARTITION BY SELECT last_row(ts, name, latitude, longitude) FROM vessel.ais_data PARTITION BY name;

ts                        name      latitude   longitude
2023-09-08T13:09:34.951Z  SAN SABA  29.375961 -94.86894
2023-09-07T18:05:01.230Z  SELENA  33.678585 -118.1954
2023-09-01T17:23:24.145Z  SOME TUESDAY  33.676563 -118.230606
... I recommend reading their for more examples. Before we move on, head to "Programming", "Node.js" and retrieve your and variables. SQL Documentation TDENGINE_CLOUD_URL TDENGINE_CLOUD_TOKEN GraphQL with Nexus.js, Fastify and Mercurius GraphQL is pretty well known these days and there are lots of good articles about it. We chose the technology as we collect and process information from different sources and GraphQL allows us to combine them into a single API transparently. We'll use the amazing framework (by now the default choice for Node.js applications) and the adapter. The teams of Mercurius and Fastify worked together for a seamless experience and it's a great choice GraphQL APIs with a focus on performance. is a tool to build/generate the schema and resolvers, so we do not have to write everything by hand. Fastify Mercurius GraphQL Nexus There's a bit of setup code etc. to be done, which I'll skip here. You can find a full example on . GitHub - tdengine-graphql-example I want to elaborate on two things in this article that are rather specific: the TDEngine Query library the GraphQL schema with Nexus TDEngine Query library TDEngine has a that allows us to query the database. This makes it easy to connect and send queries, unfortunately the responses are a little difficult to work with. So we wrote a little wrapper: Node.js library 'use strict'

import tdengine from '@tdengine/rest'
import { tdEngineToken, tdEngineUrl } from '../config.js'
import parseFields from 'graphql-parse-fields'

const { options: tdOptions, connect: tdConnect } = tdengine
tdOptions.query = { token: tdEngineToken }
tdOptions.url = tdEngineUrl

export default function TdEngine(log) {
  this.log = log
  const conn = tdConnect(tdOptions)
  this.cursor = conn.cursor()
}

TdEngine.prototype.fetchData = async function fetchData(sql) {
  this.log.debug('fetchData()')
  this.log.debug(sql)

  const result = await this.cursor.query(sql)
  const data = result.getData()
  const errorCode = result.getErrCode()
  const columns = result.getMeta()

  if (errorCode !== 0) {
    this.log.error(`fetchData() error: ${result.getErrStr()}`)
    throw new Error(result.getErrStr())
  }

  return data.map((r) => {
    const res = {}
    r.forEach((c, idx) => {
      const columnName = columns[idx].columnName
        .replace(/`/g, '')
        .replace('last_row(', '')
        .replace(')', '')
      if (c !== null) {
        res[columnName] = c
      }
    })
    return res
  })
} This returns a TDEngine object that can be passed into GraphQL context. We'll primarily be using the function where we can pass in a SQL query and get the results back as an array of objects. TDEngine returns the metadata (columns), errors and data separately. We'll use the metadata to map the columns into a regular list of objects. A special case here is the function. The columns are returned as , etc. and we want to remove the part so the attribute maps 1:1 to the GraphQL schema. This is done in the part. fetchData last_row last_row(ts) last_row(name) last_row columnName.replace GraphQL Schema Unfortunately there is no schema generator like for TDEngine and we don't want to write and maintain a pure GraphQL schema, so we'll use Nexus.js to help us with that. We'll start with two basic types: and (which is a scalar type). and are two different types to display the date as a timestamp or as a date string. This is useful for the client application (and during development), as it can decide which format to use. allows us to use the type as a function in the schema. We can resolve the right here in the type definition to use the original timestamp value. Postgraphile VesselMovement Timestamp Timestamp TDDate asNexusMethod VesselMovement TDDate ts import { scalarType, objectType } from 'nexus'

export const Timestamp = scalarType({
  name: 'Timestamp',
  asNexusMethod: 'ts',
  description: 'TDEngine Timestamp',
  serialize(value) {
    return new Date(value).getTime()
  }
})

export const TDDate = scalarType({
  name: 'TDDate',
  asNexusMethod: 'tdDate',
  description: 'TDEngine Timestamp as Date',
  serialize(value) {
    return new Date(value).toJSON()
  }
})

export const VesselMovement = objectType({
  name: 'VesselMovement',
  definition(t) {
    t.ts('ts')
    t.tdDate('date', { resolve: (root) => root.ts })
    t.string('mmsi')
    t.string('name')
    t.float('latitude')
    t.float('longitude')
    t.float('speed')
    t.float('heading')
    t.int('nav_status')
  }
}) For time-series types, we use the or suffix for a clear separation of relational and time-series types in the interface. Movement Series Now we can define the Query. We'll start with a simple query to get the latest movements from TDEngine: import { objectType } from 'nexus'

export const GenericQueries = objectType({
  name: 'Query',
  definition(t) {
    t.list.field('latestMovements', {
      type: 'VesselMovement',
      resolve: async (root, args, { tdEngine }, info) => {
        const fields = filterFields(info)
        return tdEngine.fetchData(
          `select last_row(${fields}) from vessel.ais_data partition by mmsi;`
        )
      }
    })
  }
}) is a great tool to test the API and explore the schema, you can enable it by passing in Mercurius. With the query, we can see the latest movements of vessels grouped by . Let's go a little further though. One of the biggest advantages of GraphQL is that is is a transparent layer to the client or application. We can fetch data from multiple sources and combine them into the same schema. GraphiQL graphiql.enabled = true mmsi Unfortunately, I wasn't able to find an easy/free API with extensive vessel information. There is , but they only provide the , and in their Vessel response (which we already have in TDEngine). For the sake of the example, we assume we do not have the in our database and we need to retrieve it from Sinay. With the we could also query CO2 emissions for a vessel or another API could be used to retrieve an image, the flag or other information, all of which can be combined in the type. Sinay name mmsi imo name imo Vessel export const Vessel = objectType({
  name: 'Vessel',
  definition(t) {
    t.string('mmsi')
    t.string('name')
    t.nullable.string('imo')
    t.list.field('movements', { type: 'VesselMovement' })
  }
}) As you can see here, we can include a list field with the time-series data from TDEngine. We'll add another query to fetch the vessel information and the resolver allows us to combine the data from TDEngine and Sinay: movements t.field('vessel', {
  type: 'Vessel',
  args: {
    mmsi: 'String'
  },
  resolve: async (root, args, { tdEngine }, info) => {
    const waiting = [
      getVesselInformation(args.mmsi),
      tdEngine.fetchData(
        `select * from vessel.ais_data where mmsi = '${args.mmsi}' order by ts desc limit 10;`
      )
    ]

    const results = await Promise.all(waiting)
    return {
      ...results[0][0],
      movements: results[1]
    }
  }
}) 🎉 and here we have a working GraphQL API returning rows from TDEngine for a specific vessel we requested. is a simple wrapper to fetch data from Sinay. We'll add the TDEngine results into the attribute and GraphQL will take care of the rest and map everything to the schema. getVesselInformation() movements Note: SQL Injection As with any SQL database, we need to be careful with user input. In the example above we use the input directly, which makes this query vulnerable to SQL injections. For the sake of the example, we'll ignore this for now, but in "real world" applications, we should always sanitize user input. There are several small libraries around to sanitize strings, in most cases we only rely on numbers (pagination, limit etc.) and enums (sort order), which GraphQL checks for us. mmsi Thanks to Dmitry Zaets for pointing this out! Optimizations There are a few things that go beyond the scope of this article, but I want to mention them briefly: Pothos as spiritual successor to Nexus.js When we started the project, Nexus.js was the best choice to generate our GraphQL schema. Although stable and , it lacks maintenance and updates. There is a plugin-based GraphQL schema builder called which is a bit more modern and actively maintained. If you're starting a new project, I probably recommend using Pothos instead of Nexus.js. somewhat feature-complete Pothos Thanks to Mo Sattler for pointing this out! Field Resolvers As you can see in the resolver above, both data sources are immediately fetched and processed. This means if the query is only for the , we still fetch the for the response. And if the query is for the only, we still fetch the name from Sinay and potentially pay for the request. Vessel name movements movements That's a GraphQL anti-pattern and we can improve the performance by using the field information to only fetch the data that is requested. Resolvers have the field information as the fourth argument, but they're pretty difficult to work with. Instead, we can use to get a simple object of the requested fields and adjust the resolver logic. graphql-parse-fields SQL Query Optimizations In our example queries, we use to fetch all columns from the database even if they're not needed. This is obviously pretty bad and we can use the same field parser to optimize the sql queries: select * export function filterFields(info, context) {
  const invalidFields = ['__typename', 'date']
  const parsedFields = parseFields(info)
  const fields = context ? parsedFields[context] : parsedFields
  const filteredFields = Object.keys(fields).filter(
    (f) => !invalidFields.includes(f)
  )
  return filteredFields.join(',')
} This function returns a comma-separated list of fields from the GraphQL info. const fields = filterFields(info)
return tdEngine.fetchData(
  `select last_row(${fields}) from vessel.ais_data partition by mmsi;`
) If we request , and , the query would look like this: ts latitude longitude select last_row(ts, latitude, longitude) from vessel.ais_data partition by mmsi; With only a few columns in this table this might not matter much, but with more tables and complex queries, this can make a huge difference in application performance. Time Series functions TDEngine has some time-series specific extensions that should be used to improve performance. For example, to retrieve the latest entry, a traditional SQL query: SELECT ts, name, latitude, longitude FROM vessel.ais_data order by ts desc limit 1; Takes 653ms to execute, while the "TDEngine" query takes only 145ms: SELECT last_row(ts, name, latitude, longitude) FROM vessel.ais_data; There are configuration options for each table to optimize for last_row/first_row functions and other cache settings. I recommend reading the . TDEngine documentation Conclusion The simple version: In this article, we've set up a TDEngine time-series database and defined a GraphQL schema to allow client applications to connect & query data. There's a lot more to it. We have a boilerplate project to combine complex time-series data with relational data in a transparent interface. At Nevados, we're using PostgreSQL as a primary database and retrieve time-series data the same way as in the example above. This is a great way to combine data from multiple sources in a single API. Another benefit is that the data is only fetched when requested, which adds a lot of flexibility to the client application. Last but not least, the GraphQL Schema works as a documentation and contract, so we can easily tick the "API Documentation" box. movement , please or . If you have any questions or comments reach out on BlueSky join the discussion on GitHub Also published . here

Creating a Time Series Database With TDEngine and GraphQL

TDEngine এবং GraphQL দিয়ে একটি টাইম সিরিজ ডেটাবেস তৈরি করা

Erstellen einer Zeitreihendatenbank mit TDEngine und GraphQL

Creación de una base de datos de series temporales con TDEngine y GraphQL

Création d'une base de données de séries chronologiques avec TDEngine et GraphQL

TDEngine और GraphQL के साथ एक टाइम सीरीज़ डेटाबेस बनाना

TDEngine と GraphQL を使用した時系列データベースの作成

TDEngine 및 GraphQL을 사용하여 시계열 데이터베이스 생성

Criando um banco de dados de série temporal com TDEngine e GraphQL

Создание базы данных временных рядов с помощью TDEngine и GraphQL

TDEngine ve GraphQL ile Zaman Serisi Veritabanı Oluşturma

Tạo cơ sở dữ liệu chuỗi thời gian với TDEngine và GraphQL

使用 TDEngine 和 GraphQL 创建时间序列数据库

Optimize Data Migration in MongoDB: Resharding Techniques for Speed and Scalability

মঙ্গোডিবিতে ডেটা মাইগ্রেশন অপ্টিমাইজ করুন: গতি এবং স্কেলেবিলিটির জন্য রিশার্ডিং টেকনিক

Optimieren Sie die Datenmigration in MongoDB: Resharding-Techniken für Geschwindigkeit und Skalierbarkeit

Optimice la migración de datos en MongoDB: técnicas de fragmentación para velocidad y escalabilidad

Optimiser la migration des données dans MongoDB : techniques de repartitionnement pour la vitesse et l'évolutivité

MongoDB में डेटा माइग्रेशन को ऑप्टिमाइज़ करें: स्पीड और स्केलेबिलिटी के लिए रीशेयरिंग तकनीक

MongoDB でのデータ移行の最適化: 速度とスケーラビリティのためのリシャーディング手法

MongoDB에서 데이터 마이그레이션 최적화: 속도와 확장성을 위한 리샤딩 기술

Otimize a migração de dados no MongoDB: técnicas de resharding para velocidade e escalabilidade

MongoDB'de Veri Geçişini Optimize Edin: Hız ve Ölçeklenebilirlik için Yeniden Paylaşım Teknikleri

Tối ưu hóa quá trình di chuyển dữ liệu trong MongoDB: Kỹ thuật chia lại cấu trúc cho tốc độ và khả năng mở rộng

优化 MongoDB 中的数据迁移：用于速度和可扩展性的重新分片技术

Tracking my habits has become an integral part of my personal growth journey. It helps me build better habits and stick to them consistently. As a product creator, I love creating micro tools like Personal Finance Tracker to increase my productivity for life + work. In this post, I’ll walk you through a step-by-step tutorial on how I create a Notion tracker to track my daily habits. I’ll also provide a free Notion template (available on my personal website) so you can try it out and see how it works. 1. Plan out your daily habits First, think about what personal habits matter to you and what you would like to do consistently every day. Pro Tip: From my experience, I’ve learned that it’s optimal to focus on 5 to 7 habits each year. More than that can become overwhelming and difficult to maintain. Here are some habits to consider Morning routines: Wake up early, Meditate, Exercise, Healthy breakfast, Write, Go outdoor
Learning Habits: Read, Listen to podcasts, Learn a skill/course
Self-care habits: Journal, Skincare, Hydrate, Take breaks
Evening routines: Unplug from devices, Reflect on your day, Plan for tomorrow, Sleep early 2. Set up your Habit Tracker database Now that you have a list of habits you want to track, it’s time to create your habit tracker database in Notion. (1) Create a database Open Notion and create a new page. Within this page, type “/” and select the “Inline Database” option to create a new database.
Name your database, for example, “My Habit” or something similar. (2) Add a Date property Click on the “+” sign on the database table to add a new property.
Select “Date” as the property type. (3) Add properties for each habit you want to track Click on the “+” sign next to the Date column to add a new property.
Select “Checkbox” as the property type and rename the Checkbox column with the habit you want to track. Repeat this process for each habit. For example, if you have 6 habits, create 6 checkboxes, each labeled with a different habit.
Your database should now have columns for each habit you want to track, 3. Calculate your habit progress Next, you’ll need to create custom formulas in Notion to calculate the progress of your habits. Here’s how you can set this up: (1) On your Habit Tracker Database Click on the “+” sign next to the Habit column to add a new property.
Select “Formula” as the property type. We’ll create 3 columns with Formula properties. Make sure to name them accordingly: Total Checked
Progress Number
Progress Bar % Click on each of these Formula columns (Total Checked, Progress Number, Progress Bar %) to edit their formulas, (2.1) Customize Notion formula (Total Checked) toNumber(Wake 6am ☀️ ) + toNumber(Journal 📕 ) + toNumber(Exercise 💪 ) + toNumber(Read 15min 📚 ) + toNumber(Go outdoor 🌳 ) + toNumber(Sleep 11pm 😴 ) (2.2) Customize Notion formula (Progress Number) Consider the following example: If you have 6 habits, use the formula below. If you have 10 habits, simply change the number 6 to match your total number of habits. round((Total Checked / 6) * 100) (2.3) Customize Notion formula (Progress Bar %) Progress Number/100 (3) Test the Notion formula Click on each checkbox to see if your formulas are calculating correctly, (4) Format the “Progress Bar %” column Click on the “Progress Bar %” column.
Edit the property settings.
Set the number format to “Percent” and choose “Bar” under “Show as.” 4. Customize your habit tracker Before that, let’s start by adding your first habit record. Log your first habit record Name Column: Enter today’s day in this column (e.g., Sunday).
Date Column: Enter today’s date in this column (e.g., Jul 21, 2024).
Check Off Boxes: Mark the checkboxes for the habits you’ve completed for the day. Once you’ve built out the necessary columns in your database, you can enhance its visual appeal by changing the view. Add a Calendar View Click on the “+” sign next to the “Table” tab to add a new view. Select “Calendar” from the available view options.
Hover over the top right corner of your new Calendar view and click on the three dots icon (“…”).
Then, select “Properties” Customize your Calendar display in Properties Toggle on the “Eye” icon to display the properties you want.
You might want to show “Date,” “Habit 1,” “Habit 2,” “Habit 3,” “Habit 4…. and “Progress Bar %.”
Hide any properties you don’t want to display in the calendar view. 5. Create your habit reports Next, you can set up a separate view in a weekly format to better analyze and review your habit progress. Here’s how: Add a New Table View Next to the Calendar view tab, click on the “+” sign to add a new view.
Select “Table” from the view options. Configure the Grouping On the top right corner of your database, click on the three dots (…) to open the menu.
Select “Group.”
Choose “Date” as the property to group by.
Set the Date by grouping to “Week.” Here’s what it looks like after breaking down the table by Weekly view: Calculate the Average In your table view, hover next to the date’s toggle. You’ll see a “Count all” label, click on it.
Select “More Options” -> “Average” -> “Progress Bar %”
This will calculate the average progress for each week! Get The Notion Habit Tracker Template 🌟🌟 You can download the template on my personal website: https://whizzoe.com/#tools Tracking my habits has become an integral part of my personal growth journey. It helps me build better habits and stick to them consistently. As a product creator, I love creating micro tools like Personal Finance Tracker to increase my productivity for life + work. Personal Finance Tracker Personal Finance Tracker In this post, I’ll walk you through a step-by-step tutorial on how I create a Notion tracker to track my daily habits. I’ll also provide a free Notion template ( available on my personal website ) so you can try it out and see how it works. free Notion template available on my personal website 1. Plan out your daily habits First, think about what personal habits matter to you and what you would like to do consistently every day. Pro Tip: From my experience, I’ve learned that it’s optimal to focus on 5 to 7 habits each year. More than that can become overwhelming and difficult to maintain. Pro Tip: Here are some habits to consider Here are some habits to consider Morning routines: Wake up early, Meditate, Exercise, Healthy breakfast, Write, Go outdoor Learning Habits: Read, Listen to podcasts, Learn a skill/course Self-care habits: Journal, Skincare, Hydrate, Take breaks Evening routines: Unplug from devices, Reflect on your day, Plan for tomorrow, Sleep early Morning routines: Wake up early, Meditate, Exercise, Healthy breakfast, Write, Go outdoor Morning routines: Learning Habits: Read, Listen to podcasts, Learn a skill/course Learning Habits: Self-care habits: Journal, Skincare, Hydrate, Take breaks Self-care habits: Evening routines: Unplug from devices, Reflect on your day, Plan for tomorrow, Sleep early Evening routines: 2. Set up your Habit Tracker database Now that you have a list of habits you want to track, it’s time to create your habit tracker database in Notion. (1) Create a database Open Notion and create a new page. Within this page, type “/” and select the “Inline Database” option to create a new database. Name your database, for example, “My Habit” or something similar. Open Notion and create a new page . Within this page, type “/” and select the “Inline Database” option to create a new database. new page “/” “Inline Database” Name your database, for example, “My Habit” or something similar. “My Habit” (2) Add a Date property Date property Click on the “+” sign on the database table to add a new property. Select “Date” as the property type. Click on the “+” sign on the database table to add a new property. “+” sign Select “Date” as the property type. “Date” (3) Add properties for each habit you want to track (3) Add properties for each habit you want to track Click on the “+” sign next to the Date column to add a new property. Select “Checkbox” as the property type and rename the Checkbox column with the habit you want to track. Click on the “+” sign next to the Date column to add a new property. “+” Date column Date column Select “Checkbox” as the property type and rename the Checkbox column with the habit you want to track. “Checkbox” Repeat this process for each habit. For example, if you have 6 habits, create 6 checkboxes, each labeled with a different habit. Your database should now have columns for each habit you want to track, Repeat this process for each habit. For example, if you have 6 habits, create 6 checkboxes, each labeled with a different habit. each labeled Your database should now have columns for each habit you want to track, 3. Calculate your habit progress Next, you’ll need to create custom formulas in Notion to calculate the progress of your habits. Here’s how you can set this up: (1) On your Habit Tracker Database (1) On your Habit Tracker Database Click on the “+” sign next to the Habit column to add a new property. Select “Formula” as the property type. Click on the “+” sign next to the Habit column to add a new property. “+” sign Select “Formula” as the property type. “Formula” We’ll create 3 columns with Formula properties. Make sure to name them accordingly: We’ll create 3 columns with Formula properties. Make sure to name them accordingly: Total Checked Progress Number Progress Bar % Total Checked Progress Number Progress Bar % Click on each of these Formula columns (Total Checked, Progress Number, Progress Bar %) to edit their formulas, Click on each of these Formula columns (Total Checked, Progress Number, Progress Bar %) to edit their formulas, Formula columns edit (2.1) Customize Notion formula (Total Checked) toNumber(Wake 6am ☀️ ) + toNumber(Journal 📕 ) + toNumber(Exercise 💪 ) + toNumber(Read 15min 📚 ) + toNumber(Go outdoor 🌳 ) + toNumber(Sleep 11pm 😴 ) toNumber(Wake 6am ☀️ ) + toNumber(Journal 📕 ) + toNumber(Exercise 💪 ) + toNumber(Read 15min 📚 ) + toNumber(Go outdoor 🌳 ) + toNumber(Sleep 11pm 😴 ) (2.2) Customize Notion formula (Progress Number) Consider the following example: If you have 6 habits, use the formula below. If you have 10 habits, simply change the number 6 to match your total number of habits. simply change the number 6 round((Total Checked / 6) * 100) round((Total Checked / 6) * 100) (2.3) Customize Notion formula (Progress Bar %) Progress Number/100 Progress Number/100 (3) Test the Notion formula Click on each checkbox to see if your formulas are calculating correctly, Click on each checkbox to see if your formulas are calculating correctly, checkbox (4) Format the “Progress Bar %” column (4) Format the “Progress Bar %” column Click on the “Progress Bar %” column. Edit the property settings. Set the number format to “Percent” and choose “Bar” under “Show as.” Click on the “Progress Bar %” column. “Progress Bar %” Edit the property settings. Edit the property Set the number format to “Percent” and choose “Bar” under “Show as.” “Percent” “Bar” 4. Customize your habit tracker Before that, let’s start by adding your first habit record. Log your first habit record Log your first habit record Name Column: Enter today’s day in this column (e.g., Sunday). Date Column: Enter today’s date in this column (e.g., Jul 21, 2024). Check Off Boxes: Mark the checkboxes for the habits you’ve completed for the day. Name Column: Enter today’s day in this column (e.g., Sunday). Name Column: Date Column: Enter today’s date in this column (e.g., Jul 21, 2024). Date Column: Check Off Boxes: Mark the checkboxes for the habits you’ve completed for the day. Check Off Boxes: Once you’ve built out the necessary columns in your database, you can enhance its visual appeal by changing the view. Add a Calendar View Add a Calendar View Click on the “+” sign next to the “Table” tab to add a new view. Select “Calendar” from the available view options. Hover over the top right corner of your new Calendar view and click on the three dots icon (“…”). Then, select “Properties” Click on the “+” sign next to the “Table” tab to add a new view. Select “Calendar” from the available view options. “+” “Table” tab Hover over the top right corner of your new Calendar view and click on the three dots icon (“…”) . three dots icon (“…”) Then, select “Properties” “Properties” Customize your Calendar display in Properties Customize your Calendar display in Properties Toggle on the “Eye” icon to display the properties you want. You might want to show “Date,” “Habit 1,” “Habit 2,” “Habit 3,” “Habit 4…. and “Progress Bar %.” Hide any properties you don’t want to display in the calendar view. Toggle on the “Eye” icon to display the properties you want. “Eye” icon You might want to show “Date,” “Habit 1,” “Habit 2,” “Habit 3,” “Habit 4…. and “Progress Bar %.” Hide any properties you don’t want to display in the calendar view. 5. Create your habit reports Next, you can set up a separate view in a weekly format to better analyze and review your habit progress. Here’s how: Add a New Table View Add a New Table View Next to the Calendar view tab, click on the “+” sign to add a new view. Select “Table” from the view options. Next to the Calendar view tab, click on the “+” sign to add a new view. Select “Table” from the view options. “Table” Configure the Grouping On the top right corner of your database, click on the three dots (…) to open the menu. Select “Group.” Choose “Date” as the property to group by. Set the Date by grouping to “Week.” On the top right corner of your database, click on the three dots (…) to open the menu. three dots (…) Select “Group.” “Group.” Choose “Date” as the property to group by. “Date” Set the Date by grouping to “Week.” “Week.” Here’s what it looks like after breaking down the table by Weekly view: Here’s what it looks like after breaking down the table by Weekly view: Calculate the Average In your table view, hover next to the date’s toggle. You’ll see a “Count all” label, click on it. Select “More Options” -> “Average” -> “Progress Bar %” This will calculate the average progress for each week! In your table view, hover next to the date’s toggle. You’ll see a “Count all” label, click on it. “Count all” Select “More Options” -> “Average” -> “Progress Bar %” “More Options” “Average” “Progress Bar %” This will calculate the average progress for each week! Get The Notion Habit Tracker Template 🌟🌟 Get The Notion Habit Tracker Template Get The Notion Habit Tracker Template You can download the template on my personal website: https://whizzoe.com/#tools https://whizzoe.com/#tools

How I Built a Habit Tracker in Notion (with Template)

In a world where technology is constantly evolving, the Pebble Tracker by IoTeX stands out as a remarkable innovation. Recently, I had the opportunity to experience this blockchain-powered gadget firsthand, and I must say that it has exceeded my expectations. It was relatively easy to set up, and if you are a geek like me and are into data visualization and management, it is fun to use. It also clearly holds a lot of potential for business applications in the emerging spaces of web3 and decentralized physical infrastructure networks (DePin). What is Pebble Tracker? Pebble Tracker is a state-of-the-art IoT (Internet of Things) device developed by IoTeX. This small yet powerful piece of technology is designed to capture real-world data in real time, making it an ideal tool for tracking various environmental and locational parameters. Whether you're monitoring the climate, tracking movement, or verifying location data, the Pebble Tracker has you covered. Seamless Registration and Integration One of the standout features of the Pebble Tracker is its ease of use. Upon receiving my device, I quickly registered it and joined the MachineFi ecosystem, a decentralized network that allows users to monetize their data. The registration process was straightforward, and within minutes, my device was up and running, ready to capture and share data. However, it's important to note that the Pebble Tracker requires a separate SIM card to operate, which adds an additional step to the setup process. Capturing Real-World Data The Pebble Tracker's capabilities are impressive. It offers verifiable data on GPS location, climate conditions, motion, and light levels. This data is crucial for various applications, from logistics and supply chain management to personal fitness and environmental monitoring. The real-time data capture ensures that you always have the most current information at your fingertips. Why I Love Pebble Tracker Blockchain-Powered Security: The integration of blockchain technology ensures that the data captured by the Pebble Tracker is secure and verifiable. This added layer of security is particularly important for applications that require trustworthy data.
Real-Time Data: The ability to capture and analyze data in real-time opens up numerous possibilities for applications that depend on timely information. Whether it's tracking the movement of goods in a supply chain or monitoring environmental conditions, the Pebble Tracker delivers accurate and timely data.
Data Monetization: By joining the MachineFi ecosystem, I can earn rewards for the data my device captures. This innovative approach not only incentivizes data sharing but also ensures that users retain control over their data.
Versatility: The Pebble Tracker's ability to capture various types of data—GPS, climate, motion, and light—makes it a versatile tool for a wide range of applications. From personal use to industrial applications, the possibilities are endless. Practical Applications The practical applications of the Pebble Tracker are vast. Here are a few examples of how this device can be utilized: Logistics and Supply Chain Management: Track the location and condition of goods in transit, ensuring they reach their destination in optimal condition. This capability can improve efficiency, reduce losses, and enhance transparency in supply chain operations.
Environmental Monitoring: Monitor climate conditions in real time, providing valuable data for weather forecasting, environmental research, and disaster management. Such data can be crucial for understanding climate patterns and making informed decisions to mitigate environmental impacts.
Personal Fitness: Track your movements and activities, gaining insights into your fitness routines and progress. The Pebble Tracker can help users monitor their health metrics, set fitness goals, and track their achievements over time.
Security and Surveillance: Use the device to monitor and secure sensitive areas, ensuring that any unauthorized movements are detected and recorded. This application can be vital for enhancing security in homes, offices, and public spaces.
Asset Tracking: Beyond logistics, the Pebble Tracker can be used to track valuable assets, whether they are stationary or in transit. This can be particularly useful for industries like construction, where equipment and tools need to be monitored continuously. Final Thoughts I believe that the Pebble Tracker by IoTeX is a game-changer in the world of IoT devices. Its integration of blockchain technology for secure data capture, combined with its real-time data capabilities and versatility, makes it a must-have for anyone looking to harness the power of real-world data. Whether you're a tech enthusiast, a business owner, or someone looking to explore the possibilities of IoT, the Pebble Tracker is something to explore. Moreover, the device's potential extends beyond individual applications. As IoT and blockchain technologies continue to converge, tools like the Pebble Tracker are paving the way for more decentralized, secure, and efficient data ecosystems. This not only enhances individual capabilities but also contributes to broader technological advancements and innovation. For more information about the Pebble Tracker, its setup, and where to purchase a compatible SIM card, check out these links: Pebble Tracker Information
Pebble Tracker Setup Guide
Compatible SIM Card Purchase In a world where technology is constantly evolving, the Pebble Tracker by IoTeX stands out as a remarkable innovation. Recently, I had the opportunity to experience this blockchain-powered gadget firsthand, and I must say that it has exceeded my expectations. It was relatively easy to set up, and if you are a geek like me and are into data visualization and management, it is fun to use. It also clearly holds a lot of potential for business applications in the emerging spaces of web3 and decentralized physical infrastructure networks (DePin). web3 decentralized physical infrastructure networks What is Pebble Tracker? Pebble Tracker is a state-of-the-art IoT (Internet of Things) device developed by IoTeX. This small yet powerful piece of technology is designed to capture real-world data in real time, making it an ideal tool for tracking various environmental and locational parameters. Whether you're monitoring the climate, tracking movement, or verifying location data, the Pebble Tracker has you covered. Seamless Registration and Integration One of the standout features of the Pebble Tracker is its ease of use. Upon receiving my device, I quickly registered it and joined the MachineFi ecosystem, a decentralized network that allows users to monetize their data. The registration process was straightforward, and within minutes, my device was up and running, ready to capture and share data. However, it's important to note that the Pebble Tracker requires a separate SIM card to operate, which adds an additional step to the setup process. Capturing Real-World Data The Pebble Tracker's capabilities are impressive. It offers verifiable data on GPS location, climate conditions, motion, and light levels. This data is crucial for various applications, from logistics and supply chain management to personal fitness and environmental monitoring. The real-time data capture ensures that you always have the most current information at your fingertips. Why I Love Pebble Tracker Blockchain-Powered Security: The integration of blockchain technology ensures that the data captured by the Pebble Tracker is secure and verifiable. This added layer of security is particularly important for applications that require trustworthy data. Real-Time Data: The ability to capture and analyze data in real-time opens up numerous possibilities for applications that depend on timely information. Whether it's tracking the movement of goods in a supply chain or monitoring environmental conditions, the Pebble Tracker delivers accurate and timely data. Data Monetization: By joining the MachineFi ecosystem, I can earn rewards for the data my device captures. This innovative approach not only incentivizes data sharing but also ensures that users retain control over their data. Versatility: The Pebble Tracker's ability to capture various types of data—GPS, climate, motion, and light—makes it a versatile tool for a wide range of applications. From personal use to industrial applications, the possibilities are endless. Blockchain-Powered Security: The integration of blockchain technology ensures that the data captured by the Pebble Tracker is secure and verifiable. This added layer of security is particularly important for applications that require trustworthy data. Blockchain-Powered Security: Real-Time Data: The ability to capture and analyze data in real-time opens up numerous possibilities for applications that depend on timely information. Whether it's tracking the movement of goods in a supply chain or monitoring environmental conditions, the Pebble Tracker delivers accurate and timely data. Real-Time Data: Data Monetization: By joining the MachineFi ecosystem, I can earn rewards for the data my device captures. This innovative approach not only incentivizes data sharing but also ensures that users retain control over their data. Data Monetization: Versatility: The Pebble Tracker's ability to capture various types of data—GPS, climate, motion, and light—makes it a versatile tool for a wide range of applications. From personal use to industrial applications, the possibilities are endless. Versatility: Practical Applications The practical applications of the Pebble Tracker are vast. Here are a few examples of how this device can be utilized: Logistics and Supply Chain Management: Track the location and condition of goods in transit, ensuring they reach their destination in optimal condition. This capability can improve efficiency, reduce losses, and enhance transparency in supply chain operations. Environmental Monitoring: Monitor climate conditions in real time, providing valuable data for weather forecasting, environmental research, and disaster management. Such data can be crucial for understanding climate patterns and making informed decisions to mitigate environmental impacts. Personal Fitness: Track your movements and activities, gaining insights into your fitness routines and progress. The Pebble Tracker can help users monitor their health metrics, set fitness goals, and track their achievements over time. Security and Surveillance: Use the device to monitor and secure sensitive areas, ensuring that any unauthorized movements are detected and recorded. This application can be vital for enhancing security in homes, offices, and public spaces. Asset Tracking: Beyond logistics, the Pebble Tracker can be used to track valuable assets, whether they are stationary or in transit. This can be particularly useful for industries like construction, where equipment and tools need to be monitored continuously. Logistics and Supply Chain Management: Track the location and condition of goods in transit, ensuring they reach their destination in optimal condition. This capability can improve efficiency, reduce losses, and enhance transparency in supply chain operations. Logistics and Supply Chain Management: Environmental Monitoring: Monitor climate conditions in real time, providing valuable data for weather forecasting, environmental research, and disaster management. Such data can be crucial for understanding climate patterns and making informed decisions to mitigate environmental impacts. Environmental Monitoring: Personal Fitness: Track your movements and activities, gaining insights into your fitness routines and progress. The Pebble Tracker can help users monitor their health metrics, set fitness goals, and track their achievements over time. Personal Fitness: Security and Surveillance: Use the device to monitor and secure sensitive areas, ensuring that any unauthorized movements are detected and recorded. This application can be vital for enhancing security in homes, offices, and public spaces. Security and Surveillance: Asset Tracking: Beyond logistics, the Pebble Tracker can be used to track valuable assets, whether they are stationary or in transit. This can be particularly useful for industries like construction, where equipment and tools need to be monitored continuously. Asset Tracking: Final Thoughts I believe that the Pebble Tracker by IoTeX is a game-changer in the world of IoT devices. Its integration of blockchain technology for secure data capture, combined with its real-time data capabilities and versatility, makes it a must-have for anyone looking to harness the power of real-world data. Whether you're a tech enthusiast, a business owner, or someone looking to explore the possibilities of IoT, the Pebble Tracker is something to explore. Moreover, the device's potential extends beyond individual applications. As IoT and blockchain technologies continue to converge, tools like the Pebble Tracker are paving the way for more decentralized, secure, and efficient data ecosystems. This not only enhances individual capabilities but also contributes to broader technological advancements and innovation. For more information about the Pebble Tracker, its setup, and where to purchase a compatible SIM card, check out these links: Pebble Tracker Information Pebble Tracker Setup Guide Compatible SIM Card Purchase Pebble Tracker Information Pebble Tracker Information Pebble Tracker Setup Guide Pebble Tracker Setup Guide Compatible SIM Card Purchase Compatible SIM Card Purchase

Discovering the Capabilities of IoTeX's Pebble Tracker

Build a Real-Time Crypto Tracker with CoinGecko API and React.js

Hello World! In this blog, I would like to share my experience in creating a simple battery tracker that alerts the user when the battery level is low. For this, I have used and some basic Linux commands. Python Where do I get data? Our code is going to track the status of the battery, that is, how much percentage of charge the battery currently contains. So, where can I get the data on the battery status? Let’s see. Open the terminal Move to the directory by typing the below command /sys/class/power_supply/BAT1 cd /sys/class/power_supply/BAT1 In some devices, the directory BAT1 may have a different name, like BAT0. List the files in the directory using the “ls” command. You could see some files like capacity, model_name, manufacturer, status, etc. The two files that we require are , which has the percentage of charge the battery currently has, and , which tells us whether the battery is in the charging state or in the discharging state capacity status We can use the cat command to print the capacity and status in the terminal. cat capacity
cat status This will print the current charge in percentage and status in the terminal. You can refer to the below screenshot. A screenshot of the terminal showing the charge and status of the battery So, now we’ve got the data source. Next, how to get this data in Python, and how to track it? Let’s see. The Coding part Here, we are going to use Python for getting the data and alerting the user when the charge is low. In Python, we can read the content of the file using the functions open() and readline(). The open function will open the specified file, and the readline function will read the file contents. For example, if we want to read the status of the battery from the status file, the code will be charge_state = open(“/sys/class/power_supply/BAT1/status”,”r”).readline().strip() The open function has 2 parameters. The first parameter denotes the file path, and the second parameter denotes the mode. Here, in our example, we have set the mode to read(r) since we only read data from the file. The strip() function removes the trailing blank spaces from the data. As a result, the variable will hold the status of the battery. That is either of the two values, “Charging” or “Discharging”. charge_state So now, let us get into the logic. When should we alert the user? We have to alert when the charge goes below 30% and the charger is not plugged in. The logic is: Alert_User when capacity ≤ 30 and status==”Discharging” Now we have found the logic; how to alert the user? The answer is the dialog box. A dialog box is nothing but a pop-up window used to interrupt the user to display some message or prompt the user to enter any additional information. For displaying info in the dialog box, we use a Python library called . Using this library, we can create a dialog box. Below is the source code for our Battery Tracker. Tkinter #!/usr/bin/python

import Tkinter as tk
import tkMessageBox
root = tk.Tk()
root.withdraw()

def powerFunction():
current_stat=open("/sys/class/power_supply/BAT1/capacity","r").readline().strip()
return current_stat

def chargeState():
charge_state=open("/sys/class/power_supply/BAT1/status","r").readline().strip()
return charge_state
powerStat = 100
print powerStat
tkMessageBox.showinfo("Running!","Battry Status Tracker is now running on machine")
while int(powerStat)>=30:
powerStat = powerFunction()
chargeStat = chargeState()
print "Battery Tracking"
if int(powerStat)<=30 and chargeStat == "Discharging":
tkMessageBox.showwarning("Alert!","Battery Low!\nCharging Required!\nYour Battery Status:"+powerStat+"% ("+chargeStat+")")
break We can save this code with the .py extension anywhere in the system, let’s say Desktop. I have now saved the Python file with the file name on the desktop. Now we have to run this python file. How to do that? Let’s see power.py Open the terminal Move to the directory to where the Python file is saved. In my case, it is the Desktop. So, I’m moving to the Desktop using the cd command. cd Desktop There are two versions of Python, namely and The above code is written in Python 2. The command to run Python 2 files is python < >. If it is in the case of Python 3, then the command is python3 < >. Since our code is written in Python 2, the command to execute is Python 2.X Python 3.X. Filename.py Filename.py python power.py This will start executing our Python code in the terminal. What next? Now, the code is ready. But whenever we turn on our computer, we have to open the terminal move to the desktop, and execute the python file. The terminal will also keep on running until the charge comes down to 30%. This is quite annoying, right? To avoid these steps, we can create a ‘Desktop Entry’ that will allow us to run the Python code with just a double click. Desktop Entry The Desktop Entry is nothing but a desktop shortcut created for easy access to files/executables. Let us see how to create a desktop entry in Linux. Open any editor (like Gedit). Copy-paste the code below. [Desktop Entry] 
Type=Application
Exec=python /home/sriram/Desktop/power.py 
Icon=/home/sriram/Desktop/Desktop_sub/battery.png 
Name=Power Tracker 
Terminal=false Here, ‘ ’ holds the command that we type in the terminal to execute the Python code. ‘ ’ holds an image file path that is to be set as an icon for our desktop entry. ‘ ’ holds the name for our desktop entry, which is the name displayed on the screen. In ‘ ,’ we can decide on whether to show the terminal while executing. As I said earlier, it will be annoying if we show the terminal. So, I have set this to false so that the code runs in the background. Now we can save this file with the ‘.desktop’ extension. Exec Icon Name Terminal This is how the desktop entry will look like. Now, to make our desktop entry execute our Python code with a double click, we need to do one more thing. Right-click on our desktop entry and properties and move to the ‘Permissions’ tab. Check the checkbox. This will make our desktop entry an executable. Allow executing file as a program Making the desktop entry executable Now, let’s run the “Power Tracker” by just double-clicking on it. A dialog box will appear to acknowledge that the Power Tracker is running. Once the battery reaches 30% charge and is not plugged in for charging the Alert dialog box will appear with a warning message. This is how it works. Dialog box to acknowledge to the user that the code is running The alert dialog box when the battery level comes down to 30% This works only with machines running the Linux operating system. You can find the full source in this GitHub repo: https://github.com/sriram23/Battery-Tracker Looking forward to your valuable feedback and suggestions. Thank you! Also published . here

Building a Simple Battery Tracker with Python: A Step-by-Step Guide

Introduction Embarking on the journey of building a Project Time Tracker Management React App has been both challenging and rewarding. This blog post serves as a reflection on the trials, learnings, struggles, and accomplishments encountered throughout the development process. It's essential to document these details, not only for personal reference but also to effectively communicate the expertise gained to potential employers in the future. Project Overview The idea behind the Project Time Tracker Management React App was to create a tool that simplifies and streamlines the process of tracking time for various projects. The app aimed to provide a user-friendly interface, allowing users to log and manage their time efficiently. Planning and Research Prior to diving into the development, thorough planning and research were conducted. This included defining the project scope, outlining features, and selecting the technology stack. React was chosen as the frontend library for its component-based architecture and ease of development. Development Challenges 1. State Management Implementing an efficient state management system in React posed a significant challenge. Choosing between local state, Context API, or a state management library like Redux required careful consideration. Balancing simplicity with scalability was a key decision point. 2. User Authentication Incorporating user authentication to ensure secure access to the time-tracking data demanded a deep dive into authentication mechanisms. Implementing features like user sign-up, sign-in, and secure route navigation added complexity to the project. 3. UI/UX Design Creating an intuitive and aesthetically pleasing user interface was an ongoing challenge. Striking the right balance between a clean design and a feature-rich dashboard required continuous iteration and feedback. Accomplishments 1. Responsive Design Achieving a responsive design that seamlessly adapts to various screen sizes was a notable accomplishment. Utilizing CSS media queries and flexbox/grid layouts contributed to a consistent user experience across devices. 2. Time Logging Functionality Successfully implementing the core time logging functionality allowed users to log and view their project hours. Adding features like project categorization and task descriptions enhanced the app's usability. 3. Integration With Backend Connecting the React app with the backend, which presumably handles database interactions and business logic, marked a crucial milestone. Utilizing asynchronous requests (e.g., with Axios) facilitated smooth communication between the frontend and backend. Future Considerations Reflecting on the project journey, there are areas for future enhancement: Incorporating features for in-depth project analytics and performance metrics. Advanced Analytics: Introducing collaboration features for team-based project tracking. Collaboration Tools: Conclusion Building the Project Time Tracker Management React App has been an invaluable experience. From planning and research to overcoming development challenges, each phase has contributed to personal and professional growth. This project not only demonstrates technical skills but also highlights the ability to solve real-world problems through software solutions. As I look forward to potential future projects and employment opportunities, this blog post will serve as a comprehensive reflection and reference point, ensuring that the expertise gained during this project is effectively communicated.

My Journey of Building a Project Time Tracker Management React App

Blockchain technology has sparked the emergence of a whole new industry widely known as “Web3”, a new frontier in the digital economy where decentralization, interoperability and user empowerment are put front and center. As part of the Web3 dawning, multiple new asset classes are becoming available to the masses. Cryptocurrencies such as Bitcoin and Ethereum are a well-known staple of web3 assets, but since the rise of Decentralized Finance and NFT’s the variety of blockchain-based asset classes is rapidly increasing. With this increased complexity in Web3-assets users are looking for convenient ways to keep track of their assets across blockchains and Web3 protocols. Enter the , a convenient platform that connects to a Web3-wall and provides a comprehensive overview of its balances and positions: Portfolio Tracker et In this article we will provide a step-by-step walkthrough for web3 and web3-curious developers to build their own portfolio tracking feature, using the free-to-use . DeCommas’ Mission Control API What is DeCommas “Mission Control API”? DeCommas’ API is a developer-friendly API providing fast and convenient access to structured blockchain data. On developers can get access to free API-keys in a matter of seconds, providing access to one of the fastest cross-chain Web3 API’s out there. https://build.decommas.io/ As a developer you can access and query the data stored on multiple blockchains with blazing fast response times of below 150ms, free of charge. There’s no need to duplicate multiple API-calls either, as the API response is cross-chain by default. Recently the DeCommas team has doubled down on the OP Stack, adding support for opBNB and Base L2’s as well. In case you are curious about the API, full documentation is available . here Tutorial: Building a Portfolio Tracker using Mission Control API For this tutorial we’ll help you on your way building a Portfolio Tracking feature. We’ll use Mission Control API, and make use of endpoints to fetch ERC20-balances, NFT holdings and even Protocol Positions. In this tutorial, we’ll: Show you how to get your Mission Control API key Set up Mission Control API in your environment Learn about the API call and it’s response Create fundamental features for your portfolio tracker Let’s dive in! Get your personal Mission Control API key DeCommas Mission Control API is required for completing this tutorial. It’s free to use, supports cross-chain queries by default and achieves extremely high response times. Gaining access is simple: Head to https://build.decommas.io/ Click “Get Started” Enter your email address Check your email and click the link to sing in You will now be able to access , which contains your API keys https://dashboard.decommas.io/ You will need your API keys for completing this tutorial, so go ahead and copy paste these to some place where they are easy to find for you, but securely stored. For this tutorial, DeCommas documentation will also come in handy: https://docs.decommas.io/ Setting up Mission Control API in your environment Depending on your preferences, you can interact with the API either via a raw HTTPS request or in JavaScript using our SDK. In case you go with the first route, the call would look like this: https://datalayer.decommas.net/datalayer/api/v1/tokens/{address}?api-key={YOUR-API-KEY} For this tutorial however, we’ll be using the JavaScript SDK that’s provided, and we’ll be using the Quick Start guide to get Mission Control API initiated in your environment. DeCommas SDK: https://github.com/DeCommas/decommas-sdk Install the Mission Control API application in your Javascript environment npm install @decommas/sdk 2.After installing the app you can import and use the SDK: import { Decommas } from '@decommas/sdk';

// Allows to use SDK in DEV-ONLY mode
const decommas = new Decommas();

const getVitalikERC20Balances = async () => {
const address = '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045'; // any address

const tokens = await decommas.address.getTokens({ address });
console.log(tokens);
}; You are now all set, and are ready to call the API! Building fundamental Portfolio Tracker features Now you are familiar with the and can access the API, let’s build some real world features! SDK A good Portfolio Tracker needs to provide insights in ERC-20 holdings, the value of these holdings and a user's transaction history. We’ll give you a primer on all 3 of these! 1. Fetch current ERC-20 balances for a wallet In order for a user to know what and how many  ERC-20 tokens they possess, we’ll be using the once more. ERC-20 tokens endpoint By providing the user's wallet address to the API call, the API returns an overview of ERC-20 tokens across all supported networks. In this case, for wallet address 0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045 the API will return an array of tokens together with their corresponding balances. The API will respond with a clean array containing tokens, the chains they’re on and their respective balances. You can use this data to provide an overview in your Portfolio Tracker, for example by showing a list of tokens a user holds, sorted by the total amount of each token. {
  "count": 2,
  "status": 200,
  "result": [
    {
      "chain_name": "mainnet",
      "chain_id": 1,
      "address": "0x228ba514309ffdf03a81a205a6d040e429d6e80c",
      "name": "Global Social Chain",
      "decimals": 18,
      "symbol": "GSC",
      "logo_url": "https://assets.coingecko.com/coins/images/4304/large/global-social-chain.png?1547742843",
      "actual_price": "0.00147295",
      "is_verified": true,
      "is_stable": false,
      "amount": "20000000000000000000"
    },
    {
      "chain_name": "mainnet",
      "chain_id": 1,
      "address": "0x38e4adb44ef08f22f5b5b76a8f0c2d0dcbe7dca1",
      "name": "Concentrated Voting Power",
      "decimals": 18,
      "symbol": "CVP",
      "logo_url": "https://assets.coingecko.com/coins/images/12266/large/Powerpool.jpg?1598621373",
      "actual_price": "0.433299",
      "is_verified": true,
      "is_stable": false,
      "amount": "42130000000000000000"
    }
  ]
} 2. Report value of ERC-20 tokens in USDC While knowing how much of a token a user possesses is valuable information, many users would like to see the value of their holdings expressed in USD. Let’s take another look at the response from the ERC-20 Tokens endpoint: {
  "count": 2,
  "status": 200,
  "result": [
    {
      "chain_name": "mainnet",
      "chain_id": 1,
      "address": "0x228ba514309ffdf03a81a205a6d040e429d6e80c",
      "name": "Global Social Chain",
      "decimals": 18,
      "symbol": "GSC",
      "logo_url": "https://assets.coingecko.com/coins/images/4304/large/global-social-chain.png?1547742843",
      "actual_price": "0.00147295",
      "is_verified": true,
      "is_stable": false,
      "amount": "20000000000000000000"
    },
    {
      "chain_name": "mainnet",
      "chain_id": 1,
      "address": "0x38e4adb44ef08f22f5b5b76a8f0c2d0dcbe7dca1",
      "name": "Concentrated Voting Power",
      "decimals": 18,
      "symbol": "CVP",
      "logo_url": "https://assets.coingecko.com/coins/images/12266/large/Powerpool.jpg?1598621373",
      "actual_price": "0.433299",
      "is_verified": true,
      "is_stable": false,
      "amount": "42130000000000000000"
    }
  ]
} Using the variable “actual_price”, you can show the user the sum of their holdings expressed in USD.  Depending on what you have in mind for your Portfolio Tracker, you could consider showing the amount of tokens by token, combined with a total USDC value the user has in that token. For this you can use “Name”, “Symbol”, “Amount” and “Actual Price”. Wrapping up - Your first steps to building your web3 Portfolio Tracker This is of course just a start for building your Portfolio Tracker. Want to learn more about expanding your Portfolio Tracker? Keep an eye out on DeCommas’ , as new web3 tutorials are posted frequently! HackerNoon Getting started in web3 development might feel daunting, but by using DeCommas’ Mission Control API you can speed up the process tremendously. Utilizing just a few straightforward API calls already gets you access to heaps of blockchain-stored data, free of charge. Enjoyed this Tutorial and want to learn more? Give DeCommas a follow on , where we regularly post Web3 Development tutorials just like this one! Already know all that you need and want to build on? Head out to and use Mission Control API to your advantage! HackerNoon build.decommas.io Also published . here

Creating a Web3 Portfolio Tracker with DeCommas API

Creación de un rastreador de cartera Web3 con la API DeCommas

Création d'un suivi de portefeuille Web3 avec l'API DeCommas

DeCommas API के साथ एक Web3 पोर्टफोलियो ट्रैकर बनाना

DeCommas API を使用した Web3 ポートフォリオ トラッカーの作成

Criando um rastreador de portfólio Web3 com API DeCommas

Tạo Trình theo dõi danh mục đầu tư Web3 bằng API DeCommas

使用 DeCommas API 创建 Web3 投资组合跟踪器

“Keep a food diary, and you’ll know how much sh*t you’re eating”, says your fitness trainer. While it’s good advice, doctors and fitness gurus rarely (if ever) show you how to build a sustainable habit to keep track of your food. Not even mention how to make it all fun. You can go with the traditional paper approach or download yet to your already stuffed home screen. another app But there’s a better way to track your calories: it’s Notion. When it comes to project management, . Its capabilities, however, stretch way beyond your workplace or your business. Notion is often the go-to tool Read on to find out how to create your food diary in Notion and learn how to track your calories while having fun with it. Why Would You Want to Keep a Food Diary? A food log is helpful for at least three reasons: It helps you understand your eating habits: When you start to keep track of what you eat (and even what you drink if you’re sipping a lot of soda), you will be more aware of how much you eat. It helps you track your calories: Counting your calories can be intimidating and boring, but at the end of the day, this is what shows you exactly how you’re doing. It may help you choose your food more wisely. It helps you create a mindset shift: Sometimes, the biggest obstacle people have is their minds. To create lasting habits, you need to create a mindset shift. And keeping a food log can help you with this one, too. You may not want to track your food forever. Maybe all you need is to keep track of what you eat for a couple of months until you change your eating habits. Whatever the reason, Notion is a great way to get you started on your fitness journey. Why Use Notion to Create a Food Diary? Notion has been among the pioneers of the all-in-one tools, and not without a reason. Here’s why Notion is a superior choice for creating a food diary: Notion is a non-coding, fluid environment. In Notion, everything is a block, and you can put together these blocks as you want. Flexibility: Over time, you’ll have a large dataset to analyze. You can export your data into a single spreadsheet anytime. You own your data: if you’re a visual type of person, you’ll enjoy keeping a food log in Notion. Visualization: There’re a ton of ways to easily find and surface information in Notion. You can use all kinds of sorters, filters, rollups, and relations in Notion databases to surface what you need, when you need it, even from different databases. Surfacing information: Let’s see your food diary in action. My Notion Food Diary No surprises here; my Notion food diary leverages relational databases, rollups, and linked databases. There’re three core databases in my food diary: Nutrition database Daily tracking database Weekly review database Let’s figure out how they work together. Nutrition Database I use this database to gather information about the foods I eat. Here’re the properties of my database: This is the not-so-fancy name for what you eat. Food: This is a number property showing how many calories the food contains. kcal: This is a number property indicating how satiating the food is—the higher the number, the more filled-up you feel when you eat that type of food. Satiety index: This property simply shows the fat content of the food item. Fat: The protein content of the food. Protein: The carb content of the food. Carb: This is a lot of data, but you don’t have to reinvent the wheel. You can upload data from an or ask for reference numbers from your dietitian. established nutrition database Alternatively, you can only use the kcal property to keep track of your calorie intake as a composite indicator. (That’s exactly what I do.) Daily Tracking Database (Food Log) This is where the rubber meets the road. Your daily tracking database is the place where you track your calories. My daily tracking may differ from yours. I keep track of all my habits that are not yet established. Once I happen to establish a habit, I no longer want to keep track of that. Taking the stairs every day, walking 40 minutes, or writing for two hours is no longer on my list because they’re rock-solid routines now. They’re my identities. I’m no longer a man who walks 40 minutes a day; I’m a walker. You may want to track your food until you find peace and meet your target. Let’s discuss the properties of the daily tracking database: This is a date property showing the actual date. Date: This is a relation property that connects your nutrition database with your actual food log. Food log: : This is a number property indicating the maximum number of calories you should eat a day (if you have that number). Target : This is a formula property measuring how much you can eat until you reach your target calorie value. (Can be both motivating and stressful; display it if you want to.) You can find 17 different progress bar designs along with the formulas on . Progress Red Gregory’s website This is a rollup property, which pulls and sums up calories from your nutrition database. kcal: This is a formula property, which pulls up the value from the kcal property. As you can’t make a rollup from a rollup in Notion, you can technically make this happen only by creating a simple property from your rollup (kcal) that can be later summed up in your weekly review. Calories (Sum): This relation property makes it possible to pull my numbers into my weekly review. Weekly review: Weekly Review Database is the perfect time to see how well you’re doing, what’s working, and how you can prepare for the next week. The weekly review Selected properties of my weekly review database: This property simply shows the calendar week of the year. Week: This date property displays the period with an end date. (Helpful if you want to display your week on a calendar or a timeline.) Date: This relation property connects my weekly review database with my actual food log (daily tracking). Days: This rollup property pulls up my calories from the food log and shows the average daily calorie intake for the week. Calories (avg): How to Feature Your Food Diary in a Notion Dashboard Notion folks are very creative with their dashboards. At a minimum, you can create a dedicated page where you feature your most important metrics, projects, and habits. To feature your food diary in a Notion dashboard, follow these steps: Navigate to your daily tracking database (food log), and . Step 1. copy the page link (Ctrl + L) Paste this link (Ctrl + V) into your dashboard page, and select . Step 2. Create linked view of database showing the current date and yesterday only. (I prefer to showcase Step 3. Create a filter yesterday, too because sometimes I forget to add evening meals to my food log.) This way, you’ll have a focused view that helps you track what you eat without navigating to the parent database. You can play around with what you want to display and the order you want properties to appear on your screen. Find a setting that’s aesthetic and easy to use. Get Notion to open your dashboard whenever you launch the application. Pro tip: Move your dashboard page to the top page in the sidebar, then open > , find and select . Settings My Notifications & Settings Open on start, Top page in the sidebar A Word on Portion Size The only drawback of my Notion food diary is that you can only select discrete, individual items from the nutrition database. This means that you should create individual entries for each food in your nutrition database for different-sized servings or packaging. For example, if you eat the same food twice a day, you can’t pick up the same entry from your nutrition database twice. That means your calorie measures will be flawed. You should therefore create a “two-serving” version of your favorite foods or snacks for proper measuring. Final Words Don’t be hard on yourself. In his book, behavioral scientist that having a flexible routine helps keep you on track. Allow yourself one or two days of eating what you want and skip tracking your calories. Katy Milkman argues Also, you can keep track of your mood or energy levels in your daily tracking database which may help you establish a relationship with what you eat. And remember, keep things simple and fun; you can always tweak your Notion system downstream. Cover photo by on Cristiano Pinto Unsplash

How to Create a Food Diary in Notion (With Calorie Tracker)

Introduction is a Backend-as-a-Service (BaaS) solution that provides a range of services like authentication, database management, and cloud storage. With Supabase, developers can easily build and scale web and mobile applications without having to manage the infrastructure themselves. Supabase In this guide, you'll learn how to create an MVVM .NET MAUI app (Books Tracker) that connects with a Supabase database using the Model-View-ViewModel (MVVM) architecture. Here’s a quick demo of the app: To continue this guide, you will need the following development tools installed: Visual Studio 2022 with the .NET Multi-platform App UI development workload. .NET 7 SDK. Creating a Supabase account and database To get started, you need to create an account on . You can sign up by linking your GitHub account or using your email address. Supabase Once you are signed in, click and select in the drop-down that appears. New project New Organization Create a new organization by typing a preferred organization name, selecting the type of organization and clicking . Create Organization You will be prompted with a form for creating a new project. Fill up the form and click . Create new project Once the project setup process is complete, you will be directed to a Dashboard. Navigate to and Click . Table Editor Create a new table A flyout, for creating tables and columns, appears from the right. Type the table name, uncheck “Enable Row Level Security” and add table columns. The id column and created_at column have been added to the table automatically. The id column serves as the primary key, while the created_at column generates a timestamp for each row upon insertion.  You can add a new column by clicking at the bottom left of the flyout. Add Column Click to create the new table. Save Navigate to and copy your project URL and public API key to somewhere secure. Settings -> API Creating a .NET MAUI app that works with Supabase Open Visual Studio 2022 and create a new .NET MAUI App project with the following details. Project name: BooksTracker. Solution name: BooksTrackerApp. Location: Choose your preferred project location. After opening the project, delete the default that was created. MainPage Add the following NuGet Packages: : .NET MVVM helper library. CommunityToolkit.Mvvm : To use the .NET MAUI Community Toolkit, follow the instructions in the ReadMe file that appears in Visual Studio after installing it. CommunityToolkit.Maui : Supabase's C# library. To learn more, you can check the . supabase-csharp documentation Create the following folders in your project: Models ViewModels Views Services Models In Models folder, add a new class file named with properties as shown in the following code: Book.cs https://gist.github.com/ZadokJoshua/1d04c2d3f4d2d60bd7ee4d32b891b1f4?embedable=true This class inherits the provided by Postgrest library, which is included in the Supabase client. The table attribute is the same as the name of the table we created in Supabase. Also, every column attribute is the same as its corresponding table column name. BaseModel Add a new class file named to the Models folder.  In , define a static class with two fields to store the Supabase URL and key you copied initially. AppConfig.cs AppConfig.cs https://gist.github.com/ZadokJoshua/14e6c9d405235104da82dfd5d53daf77?embedable=true (For demo purposes, we are hardcoding the API key and URL in our code. However, please use more secure methods such as storing them in a configuration file to avoid sharing your credentials.) Services Add an interface named to the Services folder. IDataService.cs https://gist.github.com/ZadokJoshua/c8e7d025cb0c41d87e364992e2edade0?embedable=true This interface will be implemented by a new class called in the Services folder. The interface methods are modified to perform CRUD operations with the books table in Supabase. DataService https://gist.github.com/ZadokJoshua/16e73629e2476064ab111ebd409d07f3?embedable=true ViewModels In the ViewModels folder, Add a class file named . BooksListingViewModel.cs https://gist.github.com/ZadokJoshua/88271bc6522950d41f8ebed87ca7e7f7?embedable=true Add a new class file named AddBookViewModel.cs. https://gist.github.com/ZadokJoshua/4fe0abaa320c896dfa6022c8edd1998d?embedable=true The last ViewModel to be created is . UpdateBookViewModel.cs https://gist.github.com/ZadokJoshua/ac8caa801d0bbcf956e5b06b533a3acd?embedable=true Views Create three content pages in the Views folder with the following names and corresponding XAML markups: AddBookPage - This is the main view of the application. It features a CollectionView for displaying books from the database and uses two items from the .NET MAUI Community Toolkit - BoolToObjectConverter and EventToCommandBehavior. BooksListingPage UpdateBookPage https://gist.github.com/ZadokJoshua/419bef7c2fee56333d50978387b23aa1?embedable=true To enable data binding, inject the viewmodels into the constructors of the pages in the code-behind and set their BindingContext. https://gist.github.com/ZadokJoshua/66f68ae75332195f9870fd2448f3bb08?embedable=true Register Routes In , define the BooksListingPage route on a ShellContent object and register other pages in . AppShell.xaml AppShell.xaml.cs https://gist.github.com/ZadokJoshua/3a8e1d4f132b8f2a96375a8857abdd75?embedable=true Register Services and Dependencies in MauiProgram.cs In , configure and register services, pages, viewmodels and Supabase Client in the Dependency Injection (DI) container. MauiProgram.cs https://gist.github.com/ZadokJoshua/0da084463d7f7a21aaa079de457692d7?embedable=true Build and run the application. Project source code https://github.com/ZadokJoshua/supabase-maui-demo/tree/master?embedable=true Thank you for Reading! Hope you found this guide helpful.

Creating a Books Tracker App with .NET MAUI and Supabase

Stories, News & Mentions about TRACKERBR

Trackerbr’s Stories on HackerNoon