A modern, self-hosted backup solution for secure, encrypted backups across local and cloud storage.
import { useEffect, useMemo, useState } from 'react';
import { toast } from 'react-toastify';
import classes from './AddStorage.module.scss';
import Icon from '../../common/Icon/Icon';
import { useAddStorage, useGetAvailableStorages } from '../../../services/storage';
import SidePanel from '../../common/SidePanel/SidePanel';
import TagsInput from '../../common/form/TagsInput/TagsInput';
import { storageOptionField } from '../../../@types/storages';
import StorageSettings from '../StorageSettings/StorageSettings';
// import { useGetDevice } from '../../../services/devices';
import { matchesAuthType, shouldDisplayStorageField } from '../../../utils/helpers';
import StorageAuthSettings from '../StorageAuthSettings/StorageAuthSettings';
import StorageProviderSelect from '../../common/form/StorageProviderSelect/StorageProviderSelect';
type AddStorageProps = {
close: () => void;
};
const AddStorage = ({ close }: AddStorageProps) => {
const [inputError, setInputError] = useState<Record<string, string>>({});
const [storageTitle, setStorageTitle] = useState('');
const [storageType, setStorageType] = useState('');
const [currentAuthType, setCurrentAuthType] = useState<string>('');
const [showAdvanced, setShowAdvanced] = useState(false);
const [storageCredentials, setStorageCredentials] = useState<Record<string, string | number | boolean>>({});
const [storageSettings, setStorageSettings] = useState<Record<string, string | number | boolean>>({});
const [storageTags, setStorageTags] = useState<string[]>([]);
const addStorageMutation = useAddStorage();
const { data } = useGetAvailableStorages();
// const { data: deviceData } = useGetDevice('main', true);
// const mainDeviceIsServer =
// deviceData?.result?.os && deviceData?.result?.platform ? isServerEdition(deviceData.result.os, deviceData.result.platform) : false;
const storageProviders = data?.result || {};
console.log('storageProviders :', storageProviders);
const providersOptions = useMemo(() => {
return Object.keys(storageProviders)
.map((k) => ({
label: storageProviders[k as keyof typeof storageProviders].name,
value: k,
doc: storageProviders[k as keyof typeof storageProviders].doc,
image: <img src={`providers/${k}.png`} />,
}))
.sort((a, b) => a.label.localeCompare(b.label));
}, [storageProviders]);
const storageFields = useMemo(() => {
const allFields: storageOptionField[] = storageProviders[storageType as keyof typeof storageProviders]?.settings || [];
const groupedFields = { required: [], optional: [], authFields: { fields: [], types: [] } } as {
required: storageOptionField[];
optional: storageOptionField[];
authFields: { fields: storageOptionField[]; types: string[] };
};
allFields.forEach((field: storageOptionField) => {
if (field.required) {
(groupedFields.required as storageOptionField[]).push(field);
} else {
if (!field.authFieldType) {
(groupedFields.optional as storageOptionField[]).push(field);
}
}
});
const types: string[] = storageProviders[storageType as keyof typeof storageProviders]?.authTypes;
const authFields = allFields.filter((f) => f.authFieldType);
groupedFields.authFields = { fields: authFields, types };
return groupedFields;
}, [storageProviders, storageType]);
// Initialize credentials when storage type changes
useEffect(() => {
if (storageType) {
const storageCreds: Record<string, string> = {};
storageFields.required.forEach((field: storageOptionField) => {
storageCreds[field.value] = '';
});
setStorageCredentials(storageCreds);
}
}, [storageType, storageFields]);
useEffect(() => {
if (storageTitle) {
setInputError((currentState) => {
const data = { ...currentState };
delete data['title'];
return data;
});
}
if (storageType) {
setInputError((currentState) => {
const data = { ...currentState };
delete data['storageType'];
return data;
});
}
Object.entries(storageCredentials).forEach(([key, value]) => {
if (value) {
setInputError((currentState) => {
const data = { ...currentState };
delete data[key];
return data;
});
}
});
}, [storageTitle, storageType, storageCredentials]);
const addStorage = () => {
setInputError({});
const errors: Record<string, string> = {};
// Get all fields for the selected storage type
const allFields: storageOptionField[] = storageProviders[storageType as keyof typeof storageProviders]?.settings || [];
// Validate required fields that are visible AND relevant to current auth type
allFields.forEach((fieldDef) => {
if (!fieldDef.required) return;
// Check if this field should be displayed based on conditions
if (!shouldDisplayStorageField(fieldDef, storageSettings, allFields)) return;
// Check if this field is relevant to the current auth type
const isAuthField = !!fieldDef.authFieldType;
const isRelevantAuthField = !isAuthField || matchesAuthType(fieldDef, currentAuthType);
if (!isRelevantAuthField) return;
// Get the field value from the appropriate state object
const fieldValue = isAuthField ? storageCredentials[fieldDef.value] : storageSettings[fieldDef.value];
// Check if the value is empty
const isEmpty = fieldValue === undefined || fieldValue === null || fieldValue === '';
if (isEmpty) {
errors[fieldDef.value] = 'Required';
}
});
if (!storageTitle) {
errors['title'] = 'Required';
}
if (!storageType) {
errors['storageType'] = 'Required';
}
console.log('storageType :', storageType, currentAuthType, storageCredentials);
console.log('errors :', errors);
if (Object.keys(errors).length === 0) {
const storagePayload = {
name: storageTitle,
type: storageType,
settings: storageSettings,
credentials: storageCredentials,
authType: currentAuthType,
tags: storageTags,
};
console.log('payload :', storagePayload);
addStorageMutation.mutate(storagePayload, {
onError: (error: Error) => {
console.log('error :', error?.message);
toast.error(error.message || `Error Adding Storage!`);
},
onSuccess: (data: any) => {
console.log('Success :', data);
toast.success(`Successfully Added Storage!`, { autoClose: 5000 });
close();
},
});
} else {
setInputError(errors);
}
};
return (
<SidePanel
title="Add New Remote Storage"
icon={<Icon type={'storages'} size={18} />}
close={close}
footer={
<>
<div className={classes.footerLeft}>
<div className={classes.summary}></div>
</div>
<div className={classes.footerRight}>
<button className={classes.createButton} onClick={() => addStorage()}>
<Icon type="check" size={12} /> Add Storage
</button>
</div>
</>
}
>
<div className={classes.addStorageContent}>
{addStorageMutation.isPending && (
<div className={classes.loader}>
<Icon size={36} type="loading" />
</div>
)}
<div className={classes.field}>
<label className={classes.label}>
Storage Name*
<i data-tooltip-id="hintTooltip" data-tooltip-content={'Storage name cannot be changed in future'} data-tooltip-place="top">
<Icon type="help" size={13} />
</i>
</label>
{inputError['title'] && <span className={classes.fieldErrorLabel}>{inputError['title']}</span>}
<input
className={`${classes.input} ${inputError['title'] ? classes.inputHasError : ''}`}
type="text"
placeholder="Give your Storage a Name"
value={storageTitle || ''}
required
onChange={(e) => setStorageTitle(e.target.value)}
/>
</div>
<div className={classes.field}>
<label className={classes.label}>Storage Type*</label>
{inputError['storageType'] && <span className={classes.fieldErrorLabel}>{inputError['storageType']}</span>}
<div className={classes.selectField}>
<StorageProviderSelect
options={[...providersOptions]}
fieldValue={storageType}
full={true}
onUpdate={(val: string) => {
setCurrentAuthType('');
setStorageCredentials({});
setStorageSettings({});
setStorageType(val);
const fields = storageProviders[val as keyof typeof storageProviders]?.fields || [];
const newCredentials = fields.reduce(
(acc: any, field: { value: any }) => ({
...acc,
[field.value]: '',
}),
{},
);
setStorageCredentials(newCredentials);
}}
error={inputError['storageType']}
/>
</div>
</div>
{storageType && storageFields.authFields.fields.length > 0 && (
<StorageAuthSettings
storageType={storageType}
fields={storageFields.authFields.fields}
authTypes={storageFields.authFields.types}
settings={storageCredentials}
onUpdate={(newSettings) => setStorageCredentials(newSettings)}
errors={inputError}
currentAuthType={currentAuthType}
onAuthTypeChange={setCurrentAuthType}
/>
)}
{Object.keys(storageFields.optional).length > 0 && (
<div
className={`${classes.advancedButton} ${showAdvanced ? classes.advancedButtonActive : ''}`}
onClick={() => setShowAdvanced(!showAdvanced)}
>
<Icon type={'settings'} />
<span>Advanced Options</span>
<Icon type={showAdvanced ? 'caret-up' : 'caret-down'} />
</div>
)}
{showAdvanced && Object.keys(storageFields.optional).length > 0 && (
<div className={classes.advancedOptions}>
<StorageSettings
fields={storageFields.optional}
settings={storageSettings}
onUpdate={(newSettings) => setStorageSettings(newSettings)}
/>
<div className={classes.field}>
<label className={classes.label}>Tags</label>
<TagsInput fieldValue={storageTags} onUpdate={(val) => setStorageTags(val)} />
</div>
</div>
)}
</div>
</SidePanel>
);
};
export default AddStorage;