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.
The primary workflow accepts a JSON file containing batch records and creates the corresponding production directory structure.
The built-in landing page provides quick access to the API documentation and operational endpoints.
The OpenAPI documentation provides an interactive interface for exploring and testing the REST endpoints.
- 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_foldersandmockup_folders - Support shared Docker volumes
- Validate incoming folder-creation requests
- Integrate with MockupWorkflow.Admin and supporting workflow services
- Provide Swagger/OpenAPI documentation during development
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.
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 | 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 |
| 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} |
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
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"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.ps1The script uses the sample request file in:
examples/create-folders-request.json
to demonstrate creating the production folder structure using the JSON request endpoint.
- .NET 10 SDK
- PowerShell, cURL, or another HTTP client
- Docker Desktop for containerized execution
From the repository root:
dotnet restore
dotnet runThe 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
FolderCreator.Api reads the target build directory from the OUTPUT_ROOT environment variable.
Example Windows configuration:
$env:OUTPUT_ROOT="C:\MockupWorkflow\Builds"
dotnet runExample Docker configuration:
environment:
- OUTPUT_ROOT=/data/buildsThe configured directory must be writable by the application.
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-apiThe service can then be accessed at:
http://localhost:27020
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/buildsvolumes:
- build-directories:/data/buildsvolumes:
build-directories:This allows FolderCreator.Api, PNGAPI, MockupWorkflow.Admin, and related services to work with the same production files.
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.
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.
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
The umbrella repository containing platform architecture, documentation, and orchestration resources.
The Blazor administration application that imports workflow data and invokes supporting services.
The central workflow orchestration API responsible for batches, processing state, and workflow records.
The storage service used to upload and retrieve source images and generated mockups.
The Photoshop execution engine that consumes prepared batch directories and generates production assets.
A command-line utility for uploading prepared input and mockup folders into the shared build structure.
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
See the repository’s LICENSE file for licensing information.