Skip to content

A modern, self-hosted backup solution for secure, encrypted backups across local and cloud storage.

13.7 KB
Raw Blame
import classes from './PlanSettings.module.scss';
import { useState } from 'react';
import { NewPlanSettings, PlanScript } from '../../../@types/plans';
import Icon from '../../common/Icon/Icon';
import Toggle from '../../common/form/Toggle/Toggle';
import { secondsToMinutes } from '../../../utils/helpers';
import NumberInput from '../../common/form/NumberInput/NumberInput';

interface PlanScriptsSettingsProps {
   settings: NewPlanSettings['settings']['scripts'];
   onUpdate: (settings: NewPlanSettings['settings']['scripts']) => void;
   platform?: string;
}

type ScriptEventKey = 'onBackupStart' | 'onBackupEnd' | 'onBackupError' | 'onBackupFailure' | 'onBackupComplete';

const scriptEvents: Record<ScriptEventKey, { title: string; description: string }> = {
   onBackupStart: {
      title: 'Before Backup Start',
      description: 'Scripts that run before the backup starts.',
   },
   onBackupEnd: {
      title: 'After Backup End',
      description: 'Scripts that run after the backup ends.',
   },
   onBackupError: {
      title: 'On Backup Error',
      description: 'Scripts that run when there is a backup error.',
   },
   onBackupFailure: {
      title: 'On Backup Failure',
      description: 'Scripts that run when the backup fails.',
   },
   onBackupComplete: {
      title: 'On Backup Complete',
      description: 'Scripts that run when the backup completes.',
   },
};

const PlanScriptsSettings = ({
   settings = {
      onBackupStart: [],
      onBackupEnd: [],
      onBackupError: [],
      onBackupFailure: [],
      onBackupComplete: [],
   },
   platform = '',
   onUpdate,
}: PlanScriptsSettingsProps) => {
   const [showTimeoutSettings, setShowTimeoutSettings] = useState<string | false>(false);
   const [activeTabs, setActiveTabs] = useState({
      onBackupStart: false,
      onBackupEnd: false,
      onBackupError: false,
      onBackupFailure: false,
      onBackupComplete: false,
   });

   const showRootOption = platform.toLowerCase().includes('linux');
   // const showRootOption = true;

   const updateScriptBool = (eventKey: ScriptEventKey, index: number, key: keyof PlanScript, value: boolean) => {
      const updatedScripts = [...(settings[eventKey] || [])];
      updatedScripts[index] = {
         ...updatedScripts[index],
         [key]: value,
      };
      onUpdate({ ...settings, [eventKey]: updatedScripts });
   };

   return (
      <div className={classes.eventTabs}>
         {Object.entries(scriptEvents).map(([eventKey, { title, description }]) => {
            const key = eventKey as ScriptEventKey;
            const scripts = settings[key] || [];
            const isActive = activeTabs[key];
            return (
               <div className={classes.eventTab} key={eventKey}>
                  <div className={classes.eventTabHead}>
                     <div>
                        <span className={classes.eventTabHeadTitle} onClick={() => setActiveTabs({ ...activeTabs, [eventKey]: !isActive })}>
                           {title} ({scripts.length || 0})
                        </span>
                        <button
                           onClick={() => {
                              const newScript = {
                                 id: Math.random().toString(36).substring(2, 15),
                                 type: 'script',
                                 enabled: true,
                                 scriptPath: '',
                                 logOutput: false,
                                 abortOnError: false,
                              };
                              if (!activeTabs[key]) {
                                 setActiveTabs({ ...activeTabs, [eventKey]: true });
                              }
                              onUpdate({ ...settings, [eventKey]: [...(scripts || []), newScript] });
                           }}
                           className={classes.addScriptButton}
                        >
                           +
                        </button>
                     </div>
                     <div>
                        <span
                           className={classes.eventTabHeadDescription}
                           data-tooltip-id="hintTooltip"
                           data-tooltip-place="top"
                           data-tooltip-content={description}
                        >
                           <Icon type="help" size={13} />
                        </span>

                        <button onClick={() => setActiveTabs({ ...activeTabs, [eventKey]: !isActive })}>
                           <Icon type={isActive ? 'caret-up' : 'caret-down'} size={14} />
                        </button>
                     </div>
                  </div>
                  {isActive && (
                     <div className={classes.eventTabContent}>
                        {scripts?.length === 0 && (
                           <div className={classes.noScriptsMessage}>
                              <span>No scripts configured for this event.</span>
                           </div>
                        )}
                        {scripts?.map((script, index) => (
                           <div key={script.id} className={classes.scriptItem}>
                              <div className={classes.scriptHeader}>
                                 <span className={classes.scriptTitle}>
                                    <Icon type="cli" size={13} /> Script {index + 1}
                                 </span>
                                 {scripts.length > 1 && (
                                    <div className={classes.scriptPositionControls}>
                                       <button
                                          title="Move Up"
                                          disabled={index === 0}
                                          onClick={() => {
                                             const updatedScripts = [...(scripts || [])];
                                             const [movedScript] = updatedScripts.splice(index, 1);
                                             updatedScripts.splice(index - 1, 0, movedScript);
                                             onUpdate({ ...settings, [eventKey]: updatedScripts });
                                          }}
                                       >
                                          <Icon type={'caret-up'} size={14} />
                                       </button>
                                       <button
                                          title="Move Down"
                                          disabled={index === scripts.length - 1}
                                          onClick={() => {
                                             const updatedScripts = [...(scripts || [])];
                                             const [movedScript] = updatedScripts.splice(index, 1);
                                             updatedScripts.splice(index + 1, 0, movedScript);
                                             onUpdate({ ...settings, [eventKey]: updatedScripts });
                                          }}
                                       >
                                          <Icon type={'caret-down'} size={14} />
                                       </button>
                                    </div>
                                 )}
                              </div>

                              <input
                                 type="text"
                                 className={classes.scriptPathInput}
                                 value={script?.scriptPath || ''}
                                 placeholder="Enter absolute path to script file (e.g. /opt/scripts/pre-backup.sh)"
                                 onChange={(e) => {
                                    const updatedScripts = [...(scripts || [])];
                                    updatedScripts[index] = {
                                       ...updatedScripts[index],
                                       scriptPath: e.target.value,
                                    };
                                    onUpdate({ ...settings, [eventKey]: updatedScripts });
                                 }}
                              />
                              <div className={classes.scriptFooter}>
                                 <div className={classes.scriptOptions}>
                                    <div className={classes.scriptOptionCheckbox}>
                                       <Toggle
                                          // label="Enabled"
                                          fieldValue={script?.enabled || false}
                                          inline={true}
                                          onUpdate={(checked: boolean) => updateScriptBool(key, index, 'enabled', checked)}
                                       />
                                       <span>Enabled</span>
                                    </div>
                                    {/* <div className={classes.scriptOptionCheckbox}>
                                       <Toggle
                                          fieldValue={script?.logOutput || false}
                                          inline={true}
                                          onUpdate={(checked: boolean) => updateScriptBool(key, index, 'logOutput', checked)}
                                       />
                                       <span>Log Output</span>
                                    </div> */}
                                    <div className={classes.scriptOptionCheckbox}>
                                       <Toggle
                                          fieldValue={script?.abortOnError || false}
                                          inline={true}
                                          onUpdate={(checked: boolean) => updateScriptBool(key, index, 'abortOnError', checked)}
                                       />
                                       <span>Abort on Error</span>
                                    </div>
                                    {showRootOption && (
                                       <div className={classes.scriptOptionCheckbox}>
                                          <Toggle
                                             fieldValue={script?.runAsRoot || false}
                                             inline={true}
                                             onUpdate={(checked: boolean) => updateScriptBool(key, index, 'runAsRoot', checked)}
                                          />
                                          <span>Run as Root</span>
                                       </div>
                                    )}
                                    <i className="pipe">|</i>
                                    <div
                                       title="Timeout Settings"
                                       className={`${classes.scriptOptionTimeout} ${script.id === showTimeoutSettings ? classes.hasTimeOutSettings : ''}`}
                                    >
                                       <button
                                          onClick={() => setShowTimeoutSettings(script.id === showTimeoutSettings ? false : script.id)}
                                          className={classes.timeoutButton}
                                       >
                                          <Icon type="clock" size={13} /> {(script?.timeout && secondsToMinutes(script.timeout)) || 'Off'}
                                       </button>
                                       {showTimeoutSettings === script.id && (
                                          <div className={classes.timeoutSettings}>
                                             <NumberInput
                                                label="Timeout (seconds)"
                                                inline={true}
                                                fieldValue={script?.timeout || 0}
                                                onUpdate={(value) => {
                                                   const updatedScripts = [...(scripts || [])];
                                                   updatedScripts[index] = {
                                                      ...updatedScripts[index],
                                                      timeout: value,
                                                   };
                                                   onUpdate({ ...settings, [eventKey]: updatedScripts });
                                                }}
                                                min={0}
                                                max={3600} // 1 hour
                                             />
                                          </div>
                                       )}
                                    </div>
                                 </div>
                                 <div className={classes.scriptRemove}>
                                    <button
                                       className={classes.removeScriptButton}
                                       onClick={() => {
                                          const updatedScripts = [...(scripts || [])];
                                          updatedScripts.splice(index, 1);
                                          onUpdate({ ...settings, [eventKey]: updatedScripts });
                                       }}
                                    >
                                       <Icon type="trash" size={18} />
                                    </button>
                                 </div>
                              </div>
                           </div>
                        ))}
                     </div>
                  )}
               </div>
            );
         })}
      </div>
   );
};

export default PlanScriptsSettings;