Skip to main content
SimilarExport ZIP
100%

Fork of Create *LICKEYFILE from ADDLICKEY commands

✓ Published0🌍 Public
AAlisonB319
Last edited May 7, 2021
Created on May 7, 2021

This example shows a client-side HTML form that generates an IBM i *LICKEYFILE from pasted ADDLICKEY commands. It parses command parameters using JavaScript regular expressions, validates fields like product ID and license key, then formats each record into a downloadable file. No data is transmitted to another computer, relying on the browser’s textarea and button event handlers to process input locally.

AI-generated description

It is possible to add multiple license keys to an IBM i system, either through the HMC chlickey or an ADDLICKEY LICKEYINP(*LICKEYFILE) command, with a specially formatted text file. One way to generate this file is on IBM i with the DSPLICKEY OUTPUT(*LICKEYFILE) command, but this requires that you already have your keys in a license key repository. So what are you to do if you only have a bunch of ADDLICKEY LICKEYINP(*PROMPT) style commands?

This form will assist in building a *LICKEYFILE from a series of ADDLICKEY commands. Just paste the commands into the textarea, click the Download button, and save the generated file to your PC. From there, you can FTP it as text to your IBM i or HMC, ready to add to your partition(s).

No data is sent by this form to any other computer.

MIT Licensed

Similar vizzes

Loading thumbnail…

Create *LICKEYFILE from ADDLICKEY commands

This example shows a web form that converts a pasted series of IBM i ADDLICKEY commands into a *LICKEYFILE text file for download. It uses the DOM API to capture the textarea content, parse each command with regular expressions, validate parameters like PRDID, serial numbers, and license keys, then formats the output. The JavaScript generates the file client-side, with an alert confirming no data is sent to any server. The rendered HTML and CSS create a minimal interface with a textarea and a button.

JJacob Berner
92% match
Loading thumbnail…

lanker一句话后门客户端3.0

This example shows a PHP backdoor client interface that executes commands on a remote server through a web-based control panel. It uses an HTML form with JavaScript to send requests, manipulating form fields and submitting via `frm.submit()` to run commands like `phpinfo()` or `system()` on the target. The interface includes a dropdown menu for selecting functions such as reading directories, executing SQL statements, or uploading files, and it dynamically updates the page content using `innerHTML` and the `showDiv()` function. The code relies on standard browser APIs and form submission, with no external JavaScript libraries.

AAntonio24
47% match
Loading thumbnail…

Fork You

Fork You renders a blank HTML page whose only content is an embedded YouTube video. The visualization itself is absent from the code, which contains no data, drawing, or interaction logic. The page loads a bare-bones document structure with a title and an iframe pointing to a video player. No charting or graphics libraries appear; the example relies solely on the browser’s native rendering of the embedded player.

IImagineAZ
45% match
Loading thumbnail…

Gist 46310a031af739a3b3941d63cd6cb33c

This visualization demonstrates the process of generating and displaying an SSH key, showing step-by-step terminal commands and their outputs. The code uses vanilla JavaScript and HTML/CSS to render a structured guide with command examples, including `ssh-keygen` variations and `cat` commands for viewing public keys. It presents the data as a static, text-based instructional card, with syntax highlighting applied to differentiate commands from comments and output. The interface relies on simple DOM manipulation and CSS styling rather than charting or mapping libraries.

MMistyBlunch
45% match
Loading thumbnail…

Gist 7232670

This example demonstrates how a single-page application skeleton is transformed from a static document into an interactive, AJAX-driven experience. The visualization shows a list of user-submitted code entries, with each entry dynamically loaded and rendered without a full page refresh. The implementation uses jQuery’s `$.ajax` method to fetch the `lucky_ajax.md` file and other resources, then updates the DOM with the retrieved content. The code also relies on JavaScript’s `Promise` API for handling asynchronous responses, and highlights the use of `XMLHttpRequest` for network communication. The data source is the downloaded application skeleton, whose structure is revealed through the fetched files. The example focuses on the interaction between client-side scripting and server responses.

EElaineYu
44% match
Loading thumbnail…

Fork of Fork of HTML Starter

This example displays a minimal web page showing the static text "Hello HTML" in large, centered type, alongside a console message "Hello JavaScript!" logged via the browser’s developer tools. The page structure is basic HTML with inline CSS controlling the font size and alignment, and a single JavaScript script element. It does not use any data visualization libraries or APIs; instead, it serves as a simple static HTML starter template, demonstrating fundamental page markup and client-side scripting without dynamic data or rendering.

Hhukbk
44% match
Loading thumbnail…

Fork you

This example, titled “Fork you,” presents a blank HTML page that immediately loads an embedded YouTube video. It shows a playful, minimal interface where the sole content is a video player, demonstrating how a bare-bones HTML document can integrate external media. The code uses a standard `<iframe>` with YouTube’s embed URL and parameters for autoplay and fullscreen access, while the rest of the page remains empty. No JavaScript libraries or data visualization APIs are present; the rendering approach relies solely on the browser’s native handling of the iframe and YouTube’s player.

Ssamuelsimkai
44% match
Loading thumbnail…

Fork of ICE5

This example displays metadata for a laptops dataset, showing the file size, row count, and column count on a webpage with a laptop background image. The page presents this summary in large, bold text under a title and a link to the dataset. The code uses D3 v7’s `d3.csv` and `d3.csvFormat` functions to fetch the CSV from a GitHub gist, calculate the character length in kilobytes, and extract the number of rows and columns, then injects the result into the DOM via `textContent`. The layout is styled with CSS for the background and centered typography.

Hhm0421
44% match