Remove public from URL

August 18, 2025 · AI Conversations

User

remove public from silverstripe url
/public

Assistant

Got it—this usually happens when your domain points to the project root instead of the Silverstripe webroot (`/public`). Here are the clean ways to remove `/public` from the URL.

# Recommended (best practice): point your webroot to `/public`
**Apache (vhost)**

<VirtualHost *:80>
    ServerName example.com
    DocumentRoot /var/www/site/current/public

    <Directory /var/www/site/current/public>
        AllowOverride All
        Require all granted
    </Directory>
</VirtualHost>

**Nginx**

server {
    server_name example.com;
    root /var/www/site/current/public;
    index index.php;

    location / {
        try_files $uri $uri/ /index.php?$query_string;
    }

    location ~ .php$ {
        include fastcgi_params;
        fastcgi_pass unix:/run/php/php8.2-fpm.sock; # adjust
        fastcgi_param SCRIPT_FILENAME $realpath_root$fastcgi_script_name;
    }
}

**cPanel / Plesk**
– Change the **Document Root** of the domain to `/public` (Domains → Document Root).
No URL will show `/public` after this.

—

# If you **can’t** change the document root (shared hosting)
Add this **.htaccess in your project root (above `/public`)** so Apache internally rewrites to `/public` without showing it:

<IfModule mod_rewrite.c>
  RewriteEngine On

  # Don’t loop if the request is already for /public
  RewriteRule ^public/ - [L]

  # Serve real files/folders that exist in the root (e.g. .well-known)
  RewriteCond %{REQUEST_FILENAME} -f [OR]
  RewriteCond %{REQUEST_FILENAME} -d
  RewriteRule ^ - [L]

  # Internally route everything else to /public
  RewriteRule ^(.*)$ public/$1 [L]
</IfModule>

This keeps the browser at `https://example.com/…` while the server serves from `/public`.

—

# Silverstripe config tips
– In `.env`, set your base URL to the root domain (no `/public`):

SS_BASE_URL="https://example.com"

– After changing server config, hit your site with `?flush` (e.g., `https://example.com/?flush`) to refresh cached configs/routes.

—

# What **not** to do
– Don’t move everything out of `/public` or change Composer’s `public-dir` to `.` unless you absolutely must; it weakens security. Using `/public` as the webroot is the intended, safer setup.

If you tell me your stack (Apache/Nginx/cPanel) and where your project lives, I can drop in the exact path-ready snippet.

User

Image upload in sliverstripe and save and show

Assistant

Here’s a clean, copy-paste path to **upload an image, save it, and show it** in Silverstripe (v4/v5). I’m giving both CMS and front-end options.

# 1) Add an Image relation on your object
Example `DataObject` (works the same on a `Page` subclass).

namespace AppModel;

use SilverStripeORMDataObject;
use SilverStripeAssetsImage;

class Profile extends DataObject
{
    private static $table_name = 'Profile';

    private static $db = [
        'Title' => 'Varchar(255)',
    ];

    private static $has_one = [
        'Photo' => Image::class, // <-- the uploaded image
    ];

    // So the image auto-publishes with the record
    private static $owns = [
        'Photo',
    ];

    private static $summary_fields = [
        'Title',
        'Photo.CMSThumbnail' => 'Photo',
    ];
}

Run `/dev/build?flush`.

—

# 2) Upload via CMS (ModelAdmin/Page)
In your `DataObject` or `Page`:

use SilverStripeFormsFieldList;
use SilverStripeFormsTextField;
use SilverStripeAssetAdminFormsUploadField;

public function getCMSFields()
{
    $fields = parent::getCMSFields();

    $fields->addFieldsToTab('Root.Main', [
        TextField::create('Title'),
        UploadField::create('Photo', 'Profile Photo')
            ->setFolderName('profiles')                   // assets/profiles/
            ->setAllowedExtensions(['jpg','jpeg','png','webp'])
            ->setAllowedMaxFileNumber(1)
            ->setIsMultiUpload(false),
    ]);

    return $fields;
}

Publish the record. Because of `$owns = ['Photo']`, the image will also go Live.

—

# 3) Upload from a **front-end form** (controller)
## Form

use SilverStripeFormsForm;
use SilverStripeFormsFieldList;
use SilverStripeFormsTextField;
use SilverStripeFormsFormAction;
use SilverStripeFormsRequiredFields;
use SilverStripeAssetAdminFormsUploadField;
use SilverStripeControlController;

use AppModelProfile;

class ProfileController extends Controller
{
    private static $allowed_actions = ['Form','save'];

    public function Form()
    {
        $fields = FieldList::create(
            TextField::create('Title'),
            UploadField::create('Photo', 'Upload photo')
                ->setFolderName('profiles')
                ->setAllowedExtensions(['jpg','jpeg','png','webp'])
                ->setIsMultiUpload(false)
        );

        $actions = FieldList::create(
            FormAction::create('save', 'Save')
        );

        $validator = RequiredFields::create(['Title', 'Photo']);

        return Form::create($this, 'Form', $fields, $actions, $validator);
    }

    public function save($data, Form $form)
    {
        $record = Profile::create();
        // This will pull the uploaded file from UploadField and set PhotoID
        $form->saveInto($record);
        $record->write();

        // Make sure the image is publicly visible
        if ($record->PhotoID && $record->Photo()->isDraft()) {
            $record->Photo()->publishSingle();
        }

        return $this->redirect($this->Link('?saved=1'));
    }
}

> Note: Front-end uploads require permission to create files. If your users aren’t CMS users, gate the action (e.g., only for logged-in members) or add a custom policy/extension to allow uploads safely.

—

# 4) Show the image in a template
In your `.ss` template (e.g., `ProfilePage.ss` or where you loop items):

<% if $Photo %>
  <img src="$Photo.Fill(800,500).URL" alt="$Title.ATT">
<% else %>
  <p>No photo uploaded.</p>
<% end_if %>

Handy variants:
– `$Photo.ScaleMax(1200, 800).URL`
– `$Photo.Fit(600, 400).URL`
– `$Photo.URL` (original)

—

# 5) Common gotchas
– **Don’t move `/public`**: keep webroot at `/public` for security.
– **Publishing**: If content must be visible to anonymous users, ensure the image is **published**. Either call `$image->publishSingle()` (as above) or rely on `$owns` and publish the parent record.
– **Flush**: After code changes, open any URL with `?flush` to clear caches.
– **Folder names**: `setFolderName('profiles')` stores files under `assets/profiles/`.

If you share which object you’re attaching the image to (e.g., `MemberBasicData`, `RentalWorkerInformation`, or a `Page`), I’ll tailor the exact code block for that class.

User

UploadField::create('Bilder', 'Upload Image')
->setAllowedExtensions(['jpg', 'jpeg', 'png'])
->setAttribute('id', 'fileUpload')
->setAttribute('accept', 'image/jpeg, image/png')
->setAttribute('style', 'display:none;'),
I've created field like this

Assistant

Nice—now wire it up so it saves, publishes, and you can trigger it with your own button + preview.

## 1) DataObject relation

use SilverStripeORMDataObject;
use SilverStripeAssetsImage;

class Profile extends DataObject
{
    private static $db = ['Title' => 'Varchar(255)'];

    private static $has_one = [
        'Bilder' => Image::class, // matches your UploadField name
    ];

    private static $owns = ['Bilder']; // auto-publish with record
}

Run `/dev/build?flush`.

## 2) Field (keep yours, add single-file + folder)

use SilverStripeAssetAdminFormsUploadField;

$upload = UploadField::create('Bilder', 'Upload Image')
    ->setAllowedExtensions(['jpg','jpeg','png'])
    ->setIsMultiUpload(false)
    ->setAllowedMaxFileNumber(1)
    ->setFolderName('profiles')
    ->setAttribute('id', 'fileUpload') // wrapper id
    ->setAttribute('accept', 'image/jpeg, image/png')
    ->setAttribute('style', 'display:none;'); // you’re hiding the UI

## 3) Save (front-end controller action)

public function save($data, SilverStripeFormsForm $form)
{
    $record = Profile::create();
    $form->saveInto($record);  // sets BilderID
    $record->write();

    if ($record->BilderID) {
        $img = $record->Bilder();
        if ($img && $img->exists() && $img->isDraft()) {
            $img->publishSingle();
        }
    }

    return $this->redirect($this->Link('?saved=1'));
}

## 4) Custom trigger button + live preview (template)

<button type="button" id="pickImage" class="button">Choose image</button>
<div id="imgPreview">
  <% if $Bilder %>
    <img src="$Bilder.Fit(500,350).URL" alt="$Title.ATT">
  <% end_if %>
</div>

$Form <!-- make sure your form renders the hidden UploadField -->

<script>
(function(){
  const trigger = document.getElementById('pickImage');
  const holder  = document.getElementById('fileUpload');   // UploadField wrapper
  if (!trigger || !holder) return;

  // Find the real <input type="file"> inside UploadField
  const fileInput = holder.querySelector('input[type="file"]');

  trigger.addEventListener('click', function(e){
    e.preventDefault();
    if (fileInput) fileInput.click();
  });

  // Live preview (front-end only)
  holder.addEventListener('change', function(e){
    if (e.target === fileInput && fileInput.files && fileInput.files[0]) {
      const reader = new FileReader();
      reader.onload = function(ev){
        let img = document.querySelector('#imgPreview img');
        if (!img) {
          img = document.createElement('img');
          document.getElementById('imgPreview').appendChild(img);
        }
        img.src = ev.target.result;
        img.style.maxWidth = '100%';
        img.style.display = '';
      };
      reader.readAsDataURL(fileInput.files[0]);
    }
  });
})();
</script>

## 5) Show saved image anywhere

<% if $Bilder %>
  <img src="$Bilder.Fill(800,500).URL" alt="$Title.ATT">
<% end_if %>

### Notes
– Keep the field name **exactly** `Bilder` to match the `has_one` (`BilderID` is saved automatically by `saveInto`).
– `setIsMultiUpload(false)` + `setAllowedMaxFileNumber(1)` ensures single image.
– If files must be visible to guests, **publish** the image (done above).

User

this is form ss

$Title

Bilder

JPEG, PNG

$Bilder

<script>
const fileInput = document.getElementById('fileUpload');
					const fileName = document.getElementById('file-name');

					fileInput.addEventListener('change', function () {
						if (this.files.length > 0) {
							fileName.textContent = this.files[0].name;
						} else {
							fileName.textContent = 'Bilder';
						}
					});
</script>

$Description

$Form.Actions

Assistant

Great—your template is almost there. The only catch: **`UploadField` puts the `id` on its wrapper “, not on the real “.** So “ won’t open the picker automatically, and your JS is targeting the wrapper (which has no `.files`).

Here’s a drop-in fix:

## 1) PHP (field setup)
Keep your field, but ensure single file + folder (optional):

$upload = UploadField::create('Bilder', 'Upload Image')
    ->setAllowedExtensions(['jpg','jpeg','png'])
    ->setIsMultiUpload(false)
    ->setAllowedMaxFileNumber(1)
    ->setFolderName('profiles')
    ->setAttribute('id', 'fileUpload')               // id on wrapper div
    ->setAttribute('accept', 'image/jpeg, image/png')
    ->setAttribute('style', 'display:none;');        // hide UploadField UI

## 2) Template (.ss)
Use the label as your custom button, render the field, and wire the **real** file input inside the UploadField:

<!-- Your label UI -->
<label class="upload-box" for="fileUpload">
  <div class="upload-left">
    <img src="https://img.icons8.com/ios-filled/50/image--v1.png" alt="icon">
    <span class="file-name" id="file-name" style="display:block;">Bilder</span>
  </div>
  <span class="file-types">JPEG, PNG</span>
</label>

<!-- Render the UploadField (hidden wrapper with id="fileUpload") -->
$Form.FieldByName(Bilder)

### JS (forward label click to the hidden input + show file name)

<script>
(function(){
  // UploadField wrapper div (you set this id in PHP)
  const holder   = document.getElementById('fileUpload');
  const label    = document.querySelector('label[for="fileUpload"]');
  const fileName = document.getElementById('file-name');

  if (!holder || !label) return;

  // UploadField uses Dropzone; the real <input type="file"> lives inside the wrapper
  const getInput = () => holder.querySelector('input[type="file"]'); // usually .dz-hidden-input

  // Click label => open native picker
  label.addEventListener('click', function(e){
    e.preventDefault();
    const input = getInput();
    if (input) input.click();
  });

  // Update filename when a file is chosen
  function bindChangeOnce(input){
    if (input && !input.__wired) {
      input.addEventListener('change', function(e){
        const f = e.target.files && e.target.files[0];
        fileName.textContent = f ? f.name : 'Bilder';
      });
      input.__wired = true;
    }
  }

  // Input can be created dynamically; observe and bind when it appears
  const observer = new MutationObserver(() => bindChangeOnce(getInput()));
  observer.observe(holder, { childList: true, subtree: true });

  // If it already exists, bind now
  bindChangeOnce(getInput());
})();
</script>

> Why this works: `for="fileUpload"` targets your hidden **wrapper**; we intercept that click and programmatically click the real file input inside UploadField. We also watch the wrapper for dynamic changes (Dropzone adds the input), then bind a `change` listener to show the chosen filename.

## 3) Showing the saved image later

<% if $Bilder %>
  <img src="$Bilder.Fit(800,600).URL" alt="$Title.ATT">
<% end_if %>

## 4) Ensure it actually saves & publishes (controller)

public function save($data, SilverStripeFormsForm $form)
{
    $record = Profile::create();
    $form->saveInto($record); // sets BilderID from UploadField
    $record->write();

    if ($record->BilderID) {
        $img = $record->Bilder();
        if ($img && $img->exists() && $img->isDraft()) {
            $img->publishSingle();
        }
    }
    return $this->redirect($this->Link('?saved=1'));
}

If `$Form.FieldByName(Bilder)` doesn’t render in your template, use `$Form.Fields.dataFieldByName(Bilder)` instead.

User

public function step5() {
$form = $this->Step5Form();
$sessionData = $this->getRequest()->getSession()->get('MBData');
if($sessionData['InseriereAls'] == 'broker'){
$title = 'Firma omschrijving';
}else{
$title = 'Personaliche Angaben';
}

return $this->customise([
'Form' => $form,
'Title' => $title,
'Bilder' => $form->Fields()->dataFieldByName('Bilder'),
'Description' => $form->Fields()->dataFieldByName('Description')
])->renderWith(['Layout/RegistrationStep5', 'Page']);
}
above is the function that showing option for upload image

Assistant

Looks good! Two quick tweaks will make it rock-solid:

## 1) Make sure the UploadField has the wrapper id
In your `Step5Form()` (or wherever you build the form), set the id on the **UploadField wrapper** so your label/JS can target it:

UploadField::create('Bilder', 'Upload Image')
    ->setFolderName('profiles')
    ->setAllowedExtensions(['jpg','jpeg','png'])
    ->setIsMultiUpload(false)
    ->setAllowedMaxFileNumber(1)
    ->setAttribute('id', 'fileUpload'); // <-- wrapper div id

## 2) Render the form safely (CSRF + enctype) and wire the real input
Instead of a manual “, use the built-ins so Silverstripe adds `multipart/form-data` and the security token automatically:

$Form.OpenTag

  <!-- Your custom label/button -->
  <label class="upload-box" for="fileUpload">
    <div class="upload-left">
      <img src="https://img.icons8.com/ios-filled/50/image--v1.png" alt="icon">
      <span class="file-name" id="file-name" style="display:block;">Bilder</span>
    </div>
    <span class="file-types">JPEG, PNG</span>
  </label>

  <!-- Hidden UploadField wrapper -->
  $Bilder

  <!-- Other fields -->
  $Description

  $Form.Actions
$Form.CloseTag

If you want to keep your manual “, then **also include** the token:

$Form.SecurityToken

## 3) JS: click-through + filename (target the real “ inside UploadField)

<script>
(function(){
  const holder   = document.getElementById('fileUpload');          // UploadField wrapper div
  const label    = document.querySelector('label[for="fileUpload"]');
  const fileName = document.getElementById('file-name');

  if (!holder || !label) return;

  // Real file input lives inside the wrapper (Dropzone creates it)
  const getInput = () => holder.querySelector('input[type="file"]');

  label.addEventListener('click', function(e){
    e.preventDefault();
    const input = getInput();
    if (input) input.click();
  });

  function bindChangeOnce(input){
    if (input && !input.__wired) {
      input.addEventListener('change', function(e){
        const f = e.target.files && e.target.files[0];
        fileName.textContent = f ? f.name : 'Bilder';
      });
      input.__wired = true;
    }
  }

  // Input can be added later; observe then bind
  const obs = new MutationObserver(() => bindChangeOnce(getInput()));
  obs.observe(holder, { childList: true, subtree: true });

  // Bind immediately if already present
  bindChangeOnce(getInput());
})();
</script>

## 4) Save & publish on submit (controller action)

public function doStep5($data, SilverStripeFormsForm $form)
{
    $record = YourDataObject::create();
    $form->saveInto($record); // sets BilderID + Description
    $record->write();

    if ($record->BilderID && $record->Bilder()->isDraft()) {
        $record->Bilder()->publishSingle();
    }
    return $this->redirect($this->Link('step5') . '?saved=1');
}

That’s it—your label will open the native picker, the filename shows up, the form posts with the right `enctype` and CSRF, and the image gets saved + published.

User

public function doStep5(HTTPRequest $request) {
$data = $request->postVars();

$sessionData = $this->getRequest()->getSession()->get('MBData');
if($sessionData['InseriereAls'] == 'broker'){
$session = $this->getRequest()->getSession();

$allData = array_merge(
$session->get('BrokerCompanyData') ?: [],
$data
);

$hash = $request->getSession()->get('HashValue');
$memberID = $this->getMemberIDByField('TempIDHash', $hash);

if ($memberID) {
$companyData = MemberCompanyData::get()->filter('MemberID', $memberID)->first();
}

if (empty($companyData) || !$companyData->exists()) {
$companyData = new MemberCompanyData();
$companyData->MemberID = $memberID;
}

foreach ($allData as $key => $value) {
if ($companyData->hasField($key)) {
$companyData->$key = $value;
}
}

if (!empty($data['Bilder'])) {
$companyData->ImageID = $data['Bilder'];
}

$companyData->write();
$session->clear('BrokerCompanyData');

return $this->redirect('/public/registration/step6');
}else{
$session = $this->getRequest()->getSession();

$allData = array_merge(
$session->get('PersonalInfo') ?: [],
$data
);

$hash = $request->getSession()->get('HashValue');
$memberID = $this->getMemberIDByField('TempIDHash', $hash);

if ($memberID) {
$personalInfo = PersonalInformation::get()->filter('MemberID', $memberID)->first();
}

if (empty($personalInfo) || !$personalInfo->exists()) {
$personalInfo = new PersonalInformation();
$personalInfo->MemberID = $memberID;
}

//var_dump($data);

if (!empty($data['Bilder'])) {
$personalInfo->ImageID = $data['Bilder'];
}

foreach ($allData as $key => $value) {
if ($personalInfo->hasField($key)) {
$personalInfo->$key = $value;
}
}

$personalInfo->write();
$session->clear('PersonalInfo');

// Login script start //
$authenticator = new MemberAuthenticator();

$userName = $request->getSession()->get('userName');
$userPsd = $request->getSession()->get('userPsd');
$member = $authenticator->authenticate([
'Email' => $userName,
'Password' => $userPsd
], $request);

if ($member && $member->exists()) {
$memberBasicData = MemberBasicData::get()->filter('MemberID', $member->ID)->first();

if ($memberBasicData) {
$InseriereAls = $memberBasicData->InseriereAls;
$firstName = $memberBasicData->FirstName;
$lastName = $memberBasicData->LastName;

$request->getSession()->set('UserType', $InseriereAls);
$request->getSession()->set('CUFirstName', $firstName);
$request->getSession()->set('CULastName', $lastName);

$identityStore = Injector::inst()->get(IdentityStore::class);
$identityStore->logIn($member, false, $request);
}
}
// Login script end //

return $this->redirect('/public/registration/thankyou');
}
}

Assistant

You’re almost there—the only blocker is the **field name mismatch**.
Your `DataObject` uses `ImageID`, but your form field is named `Bilder`. With Silverstripe, the UploadField’s **name must match the has_one** to let `$form->saveInto()` wire it up.

## Fix (recommended)
1) In `Step5Form()` change:

UploadField::create('Image', 'Bilder')   // name = Image, label = Bilder
    ->setAllowedExtensions(['jpg','jpeg','png'])
    ->setIsMultiUpload(false)
    ->setAllowedMaxFileNumber(1)
    ->setFolderName('profiles')
    ->setAttribute('id', 'fileUpload')
    ->setAttribute('accept', 'image/jpeg, image/png')
    ->setAttribute('style', 'display:none;');

2) In the template, render the field by its **name**:

$Form.FieldByName(Image)

(Keep your custom label/JS as-is; it still targets `#fileUpload`.)

3) Update `doStep5()` to use the form to save and **publish** the image. No need to manually read `$data['Bilder']` anymore.

use SilverStripeFormsForm;

public function doStep5(SilverStripeControlHTTPRequest $request)
{
    $data = $request->postVars();
    $form = $this->Step5Form();
    $form->loadDataFrom($data); // make sure validators/transformers run

    $session = $this->getRequest()->getSession();
    $sessionData = $session->get('MBData');

    $hash = $session->get('HashValue');
    $memberID = $this->getMemberIDByField('TempIDHash', $hash);

    if ($sessionData['InseriereAls'] === 'broker') {
        $companyData = MemberCompanyData::get()->filter('MemberID', $memberID)->first() ?: MemberCompanyData::create(['MemberID' => $memberID]);

        // Save all posted fields (incl. Image) onto the object
        $form->saveInto($companyData);

        // If you still need to merge session fields:
        $allData = array_merge($session->get('BrokerCompanyData') ?: [], $data);
        foreach ($allData as $key => $value) {
            if ($companyData->hasField($key)) {
                $companyData->$key = $value;
            }
        }

        $companyData->write();

        // Publish the file so it’s visible to guests
        if ($companyData->ImageID && $companyData->Image()->isDraft()) {
            $companyData->Image()->publishSingle();
        }

        $session->clear('BrokerCompanyData');
        return $this->redirect('/public/registration/step6');

    } else {
        $personalInfo = PersonalInformation::get()->filter('MemberID', $memberID)->first() ?: PersonalInformation::create(['MemberID' => $memberID]);

        $form->saveInto($personalInfo);

        $allData = array_merge($session->get('PersonalInfo') ?: [], $data);
        foreach ($allData as $key => $value) {
            if ($personalInfo->hasField($key)) {
                $personalInfo->$key = $value;
            }
        }

        $personalInfo->write();

        if ($personalInfo->ImageID && $personalInfo->Image()->isDraft()) {
            $personalInfo->Image()->publishSingle();
        }

        // (Your login script unchanged)
        $authenticator = new MemberAuthenticator();
        $member = $authenticator->authenticate([
            'Email' => $session->get('userName'),
            'Password' => $session->get('userPsd')
        ], $request);

        if ($member && $member->exists()) {
            $memberBasicData = MemberBasicData::get()->filter('MemberID', $member->ID)->first();
            if ($memberBasicData) {
                $identityStore = Injector::inst()->get(IdentityStore::class);
                $identityStore->logIn($member, false, $request);
                $session->set('UserType', $memberBasicData->InseriereAls);
                $session->set('CUFirstName', $memberBasicData->FirstName);
                $session->set('CULastName', $memberBasicData->LastName);
            }
        }

        return $this->redirect('/public/registration/thankyou');
    }
}

## Bonus (optional, but helpful)
– In both `MemberCompanyData` and `PersonalInformation` models:

private static $has_one = [
      'Image' => SilverStripeAssetsImage::class,
  ];
  private static $owns = ['Image']; // auto-publish with parent (if versioned)

– After any code changes, do `?flush`.

—

### If you must keep the field name `Bilder`
Then map it manually and publish:

$imageID = (int)($data['Bilder'] ?? 0);           // might need to handle array shapes too
if ($imageID) {
    if ($file = SilverStripeAssetsImage::get()->byID($imageID)) {
        if ($file->isDraft()) $file->publishSingle();
        $companyData->ImageID = $file->ID;        // or $personalInfo->ImageID
    }
}

…but the clean way is to **rename the UploadField to `Image`** so `$form->saveInto()` just works.

User

but I want image name should be Bilder

Assistant

Totally fine—you can keep the **form field name = `Bilder`** and still save into your DB field `ImageID`. Just map it on submit.

## What to change (minimal)

1) Add a tiny helper to extract the uploaded file ID from UploadField (it can post as an int or array):

use SilverStripeAssetsImage;

private function extractUploadID($value): int
{
    if (!$value) return 0;
    if (is_numeric($value)) return (int)$value;

    if (is_array($value)) {
        if (isset($value['Files']) && is_array($value['Files']) && !empty($value['Files'])) {
            return (int)$value['Files'][0];
        }
        if (isset($value['id'])) return (int)$value['id'];
        if (isset($value[0])) return (int)$value[0];
    }
    return 0;
}

2) In your `doStep5()` keep `Bilder` as the field name, but map it to `ImageID` and publish:

### Broker branch

$imgID = $this->extractUploadID($data['Bilder'] ?? null);
if ($imgID) {
    if ($file = Image::get()->byID($imgID)) {
        $file->publishSingle();               // make it visible to guests
        $companyData->ImageID = $file->ID;    // map Bilder -> ImageID
    }
}

### Personal branch

$imgID = $this->extractUploadID($data['Bilder'] ?? null);
if ($imgID) {
    if ($file = Image::get()->byID($imgID)) {
        $file->publishSingle();
        $personalInfo->ImageID = $file->ID;
    }
}

> Keep the rest of your merging and `write()` calls as-is.

That’s it—**field shown in the form is `Bilder`**, your template keeps using `$Form.FieldByName(Bilder)`, and the saved relation remains `ImageID` on your objects.

—

### Optional (DB-level German naming)
If you want the **DB relation** to also be German, rename your `has_one` to:

private static $has_one = [
    'Bilder' => Image::class,
];
private static $owns = ['Bilder'];

…then `saveInto()` will work automatically with `UploadField::create('Bilder', …)`.
But this requires a data migration from `ImageID` → `BilderID` and a `/dev/build?flush`. If you don’t want schema changes, stick to the simple mapping above.

User

if ($record->BilderID && $record->Bilder()->isDraft()) {
$record->Bilder()->publishSingle();
}
want to save like this
So tell How I will show image at frontend

Assistant

Perfect—since you’re saving to a **has_one `Bilder`** and publishing it:

if ($record->BilderID && $record->Bilder()->isDraft()) {
    $record->Bilder()->publishSingle();
}

you can show it on the frontend like this.

# In a template for that object

<% if $Bilder %>
  <img src="$Bilder.Fit(800,600).URL" alt="$Title.ATT">
<% else %>
  <p>No image uploaded.</p>
<% end_if %>

Common variants:

$Bilder.URL                     <!-- original -->
$Bilder.Fill(600,400).URL       <!-- crop to exact size -->
$Bilder.Fit(600,400).URL        <!-- fit inside box -->
$Bilder.ScaleMax(1200,800).URL  <!-- keep aspect ratio, max bounds -->

Optional responsive example:

<img
  src="$Bilder.ScaleMax(600,400).URL"
  srcset="$Bilder.ScaleMax(600,400).URL 600w,
          $Bilder.ScaleMax(900,600).URL 900w,
          $Bilder.ScaleMax(1200,800).URL 1200w"
  sizes="(max-width: 700px) 100vw, 700px"
  alt="$Title.ATT">

# If you’re passing a record to the view
Example (Step 6 / Thank You page):

public function step6()
{
    $memberID = Security::getCurrentUser()?->ID;
    $company = MemberCompanyData::get()->filter('MemberID', $memberID)->first();

    return $this->customise(['Company' => $company])
                ->renderWith(['Layout/RegistrationStep6','Page']);
}

Template:

<% if $Company && $Company.Bilder %>
  <img src="$Company.Bilder.Fit(800,600).URL" alt="$Company.Title.ATT">
<% end_if %>

# Model tip (optional but nice)
In `MemberCompanyData` / `PersonalInformation`:

private static $has_one = ['Bilder' => SilverStripeAssetsImage::class];
private static $owns   = ['Bilder']; // auto-publishes with parent if versioned

You’re done—the image will render anywhere you output `$Bilder` (or `$Object.Bilder`) as above.

User

HOw to use in this function
public function doStep5(HTTPRequest $request) {
$data = $request->postVars();