FolderCreator.Api

FolderCreator.Api is an ASP.NET Core REST service that prepares and manages production folders for the Mockup Workflow Platform.

The service creates standardized directory structures, manages workflow assets, and exposes REST endpoints for folder and file management used throughout the Mockup Workflow Platform.

The API accepts phrase records, groups them by batch and product type, sanitizes folder names, and prepares the input and output directories required by downstream Photoshop automation workflows.

Screenshots

Create Folders from JSON

The primary workflow accepts a JSON file containing batch records and creates the corresponding production directory structure.

Dashboard

The built-in landing page provides quick access to the API documentation and operational endpoints.

Swagger API Overview

The OpenAPI documentation provides an interactive interface for exploring and testing the REST endpoints.

Features

• Create batch-based production directories
• Organize assets by batch ID and product type
• Create one folder for each phrase record
• Sanitize phrase text for safe folder names
• Prepare input_folders and mockup_folders
• Support shared Docker volumes
• Validate incoming folder-creation requests
• Integrate with MockupWorkflow.Admin and supporting workflow services
• Provide Swagger/OpenAPI documentation during development

Role in the Platform

FolderCreator.Api is the file-system preparation service within the Mockup Workflow Platform.

Production Manifest
        |
        v
MockupWorkflow.Admin
        |
        v
FolderCreator.Api
        |
        v
/data/builds/{batchId}/{productType}/
        |
        +-- input_folders/
        |
        +-- mockup_folders/
        |
        v
Photoshop UXP Workflow

Before Photoshop processing begins, the service creates the predictable directory structure used by the platform’s APIs, administration dashboard, upload tools, and Photoshop UXP plug-in.

Directory Structure

A request for batch 1782398933192 and product type tshirt produces a structure similar to:

/data/builds/
└── 1782398933192/
    └── tshirt/
        ├── input_folders/
        │   ├── Coffee.Until.Further.Notice/
        │   └── Another.Phrase/
        └── mockup_folders/
            ├── Coffee.Until.Further.Notice/
            └── Another.Phrase/

The physical root directory is configured using the OUTPUT_ROOT environment variable.

Technology Stack

Technology	Purpose
.NET 10	Application runtime
ASP.NET Core Web API	REST endpoint hosting
C#	API and folder-processing logic
Docker	Containerized deployment
OpenAPI / Swagger	Interactive API documentation
Shared Docker volumes	File exchange between workflow services

REST API

Method	Endpoint
GET	/dashboard
POST	/api/files/upload/{*path}
GET	/folders
GET	/folders/status
GET	/folders/{name}
POST	/folders/create
POST	/folders/create-from-file
PUT	/folders/{name}
DELETE	/folders/{name}
GET	/folders/{name}/files
POST	/folders/{name}/files
GET	/folders/{name}/files/{fileName}
DELETE	/folders/{name}/files/{fileName}

Request File

The uploaded JSON file contains an array of phrase records:

[
  {
    "phrase": "Coffee Until Further Notice",
    "batchId": "1782398933192",
    "productType": "tshirt"
  },
  {
    "phrase": "Another Phrase",
    "batchId": "1782398933192",
    "productType": "tshirt"
  }
]

A sample request is available at:

examples/create-folders-request.json

cURL Example

The following example uploads the JSON file using the multipart upload endpoint.

curl -X POST \
  "http://localhost:27020/folders/create-from-file" \
  -H "accept: application/json" \
  -F "file=@examples/create-folders-request.json"

PowerShell JSON Request

The repository includes a reusable PowerShell script that reads the sample request file and sends it as a JSON request body to the POST /folders/create endpoint.

scripts/test-create-folders.ps1

Run it from the repository root:

.\scripts\test-create-folders.ps1

The script uses the sample request file in:

examples/create-folders-request.json

to demonstrate creating the production folder structure using the JSON request endpoint.

Running Locally

Prerequisites

• .NET 10 SDK
• PowerShell, cURL, or another HTTP client
• Docker Desktop for containerized execution

Start the API

From the repository root:

dotnet restore
dotnet run

The console output will show the local addresses assigned to the application.

When the application is running, Swagger is available at:

For example:

http://localhost:<port>/swagger

Configuration

OUTPUT_ROOT

FolderCreator.Api reads the target build directory from the OUTPUT_ROOT environment variable.

Example Windows configuration:

$env:OUTPUT_ROOT = "C:\MockupWorkflow\Builds"
dotnet run

Example Docker configuration:

environment:
  - OUTPUT_ROOT=/data/builds

The configured directory must be writable by the application.

Docker

Build the image from the repository root:

docker build -t foldercreator-api .

Run the container with a local directory mounted as the build root:

docker run --rm `
  -p 27020:8080 `
  -e OUTPUT_ROOT=/data/builds `
  -v foldercreator-builds:/data/builds `
  foldercreator-api

The service can then be accessed at:

http://localhost:27020

Docker Compose

Within the Mockup Workflow Platform, FolderCreator.Api shares a named volume with the other file-processing services:

services:
  foldercreator-api:
    build:
      context: .
    ports:
      - "27020:8080"
    environment:
      - OUTPUT_ROOT=/data/builds
    volumes:
      - build-directories:/data/builds

volumes:
  build-directories:

This allows FolderCreator.Api, PNGAPI, MockupWorkflow.Admin, and related services to work with the same production files.

Repository Structure

FolderCreator.API/
├── examples/
│   └── create-folders-request.json
├── scripts/
│   └── test-create-folders.ps1
├── Properties/
├── .gitignore
├── Dockerfile
├── FolderCreatorApi.csproj
├── Program.cs
└── README.md

The exact source layout may expand as endpoint, service, validation, and test classes are separated into dedicated directories.

Folder-Name Handling

Phrase text may contain characters that are unsuitable for directory names.

FolderCreator.Api normalizes phrase values before using them as folder names. This provides:

• Predictable directory paths
• Reduced risk from invalid path characters
• Consistent naming across workflow services
• Separation between configured root paths and user-provided values

The configured OUTPUT_ROOT remains the authority for where files may be created.

What This Project Demonstrates

This repository demonstrates experience with:

• ASP.NET Core Web API development
• REST API design
• Multipart file uploads
• JSON request processing
• File-system automation
• Input validation
• Safe path construction
• Docker containerization
• Shared-volume architecture
• Distributed workflow integration

Related Projects

MockupWorkflow.Platform

The umbrella repository containing platform architecture, documentation, and orchestration resources.

MockupWorkflow.Admin

The Blazor administration application that imports workflow data and invokes supporting services.

PhotoshopAutomation.Api

The central workflow orchestration API responsible for batches, processing state, and workflow records.

PNGAPI

The storage service used to upload and retrieve source images and generated mockups.

Photoshop UXP Batch Mockup Plugin

The Photoshop execution engine that consumes prepared batch directories and generates production assets.

MockupWorkflow.BuildUploader

A command-line utility for uploading prepared input and mockup folders into the shared build structure.

Project Status

Active development

The core folder-generation workflow is operational and integrated with the Mockup Workflow Platform.

Current portfolio work focuses on:

• Improving API documentation
• Adding verified request and response examples
• Expanding automated tests
• Documenting security and validation behavior
• Maintaining consistent presentation across platform repositories

License

See the repository’s LICENSE file for licensing information.