364 lines
13 KiB
JavaScript
364 lines
13 KiB
JavaScript
import React from 'react';
|
|
import './App.css';
|
|
import Box from './components/UI/Box/Box';
|
|
import Configuration from './containers/Configuration/Configuration';
|
|
import {connect} from 'react-redux';
|
|
import DependencyList from './components/DependencyList/DependencyList';
|
|
import DownloadProgress from './components/DownloadProgress/DownloadProgress';
|
|
import {extractFileNameFromURL} from './utils';
|
|
import ErrorDetails from './components/ErrorDetails/ErrorDetails';
|
|
import Grid from './components/UI/Grid/Grid';
|
|
import IPCContainer from './containers/IPCContainer/IPCContainer';
|
|
import Loading from './components/UI/Loading/Loading';
|
|
import Modal from './components/UI/Modal/Modal';
|
|
import MountItems from './containers/MountItems/MountItems';
|
|
import {notifyError} from './redux/actions/error_actions';
|
|
import ReleaseVersionDisplay from './components/ReleaseVersionDisplay/ReleaseVersionDisplay';
|
|
import {setProviderState} from './redux/actions/mount_actions';
|
|
import Text from './components/UI/Text/Text';
|
|
import UpgradeIcon from './components/UpgradeIcon/UpgradeIcon';
|
|
import UpgradeUI from './components/UpgradeUI/UpgradeUI';
|
|
import {
|
|
downloadItem,
|
|
setAllowDownload
|
|
} from './redux/actions/download_actions';
|
|
import {
|
|
checkInstalled,
|
|
installDependency,
|
|
installRelease,
|
|
installUpgrade
|
|
} from './redux/actions/install_actions';
|
|
import {
|
|
detectUIUpgrade,
|
|
loadReleases,
|
|
setActiveRelease,
|
|
setDismissUIUpgrade,
|
|
setInstalledVersion,
|
|
setReleaseUpgradeAvailable
|
|
} from './redux/actions/release_version_actions';
|
|
|
|
const Constants = require('./constants');
|
|
const Scheduler = require('node-schedule');
|
|
|
|
class App extends IPCContainer {
|
|
checkVersionInstalled = () => {
|
|
this.props.setAllowDownload(false);
|
|
const selectedVersion = this.getSelectedVersion();
|
|
if (selectedVersion !== 'unavailable') {
|
|
let dependencies = [];
|
|
if (this.props.LocationsLookup[selectedVersion] && this.props.LocationsLookup[selectedVersion].dependencies) {
|
|
dependencies = this.props.LocationsLookup[selectedVersion].dependencies;
|
|
}
|
|
|
|
this.props.checkInstalled(dependencies, selectedVersion);
|
|
} else {
|
|
this.props.setInstalledVersion('none');
|
|
}
|
|
};
|
|
|
|
_isMounted = false;
|
|
|
|
componentDidMount() {
|
|
this._isMounted = true;
|
|
this.scheduledUpdateJob = Scheduler.scheduleJob('23 11 * * *', this.updateCheckScheduledJob);
|
|
this.detectUpgrades();
|
|
}
|
|
|
|
componentDidUpdate(prevProps) {
|
|
if ((prevProps.Release !== this.props.Release) ||
|
|
(prevProps.ReleaseVersion !== this.props.ReleaseVersion) ||
|
|
(prevProps.VersionLookup !== this.props.VersionLookup)) {
|
|
this.saveState();
|
|
this.checkVersionInstalled();
|
|
} else if (Object.keys(this.props.ProviderState).filter(k=> {
|
|
return this.props.ProviderState[k] !== prevProps.ProviderState[k];
|
|
}).length > 0) {
|
|
this.saveState();
|
|
}
|
|
}
|
|
|
|
componentWillUnmount() {
|
|
this._isMounted = false;
|
|
Scheduler.cancelJob(this.scheduledUpdateJob);
|
|
super.componentWillUnmount();
|
|
}
|
|
|
|
createModalConditionally = (condition, jsx, critical) => {
|
|
const modalProps = {critical: critical};
|
|
return condition ? (<Modal {...modalProps}>{jsx}</Modal>) : null;
|
|
};
|
|
|
|
detectUpgrades = () => {
|
|
if (this.props.AppPlatform !== 'unknown') {
|
|
this.props.loadReleases();
|
|
this.props.detectUIUpgrade();
|
|
}
|
|
};
|
|
|
|
getSelectedVersion = () => {
|
|
return (this.props.ReleaseVersion === -1) ?
|
|
'unavailable' :
|
|
this.props.VersionLookup[Constants.RELEASE_TYPES[this.props.Release]][this.props.ReleaseVersion];
|
|
};
|
|
|
|
handleDownloadDependency = url => {
|
|
this.props.downloadItem(extractFileNameFromURL(url), Constants.INSTALL_TYPES.Dependency, url, this.onDownloadFileComplete);
|
|
};
|
|
|
|
handleDownloadRelease = () => {
|
|
const selectedVersion = this.getSelectedVersion();
|
|
const fileName = selectedVersion + '.zip';
|
|
this.props.downloadItem(fileName, Constants.INSTALL_TYPES.Release, this.props.LocationsLookup[selectedVersion].urls[0], this.onDownloadFileComplete);
|
|
};
|
|
|
|
handleDownloadUpgrade = () => {
|
|
const url = this.props.UpgradeData.urls[0];
|
|
const name = this.props.Platform === 'win32' ? 'upgrade.exe' : extractFileNameFromURL(url);
|
|
this.props.downloadItem(name, Constants.INSTALL_TYPES.Upgrade, url, this.onDownloadFileComplete);
|
|
};
|
|
|
|
installDependency = result => {
|
|
if (result.Success) {
|
|
this.props.installDependency(result.Destination, result.URL, this.onInstallDependencyComplete);
|
|
}
|
|
};
|
|
|
|
installRelease = result => {
|
|
if (result.Success) {
|
|
const selectedVersion = this.getSelectedVersion();
|
|
this.props.installRelease(result.Destination, selectedVersion, () => {
|
|
if (this._isMounted) {
|
|
this.checkVersionInstalled();
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
installUpgrade = result => {
|
|
if (result.Success) {
|
|
const info = this.props.LocationsLookup[this.props.AppPlatform][this.props.VersionLookup[this.props.AppPlatform][0]];
|
|
const sha256 = info.sha256;
|
|
const signature = info.sig;
|
|
this.props.installUpgrade(result.Destination, sha256, signature, !!result.SkipVerification, this.onInstallUpgradeComplete);
|
|
}
|
|
};
|
|
|
|
onDownloadFileComplete = (name, type, url, result) => {
|
|
if (this._isMounted) {
|
|
switch (type) {
|
|
case Constants.INSTALL_TYPES.Dependency:
|
|
this.installDependency(result);
|
|
break;
|
|
case Constants.INSTALL_TYPES.Release:
|
|
this.installRelease(result);
|
|
break;
|
|
case Constants.INSTALL_TYPES.Upgrade:
|
|
this.installUpgrade(result);
|
|
break;
|
|
default:
|
|
this.props.notifyError('Unknown download type: ' + type);
|
|
break;
|
|
}
|
|
}
|
|
};
|
|
|
|
onInstallDependencyComplete = () => {
|
|
if (this._isMounted) {
|
|
this.checkVersionInstalled();
|
|
}
|
|
};
|
|
|
|
onInstallUpgradeComplete = (source, result) => {
|
|
if (this._isMounted && !result.Success) {
|
|
this.props.notifyError(result.Error, false,() => {
|
|
if (this._isMounted) {
|
|
// TODO Prompt to verify
|
|
if (result.AllowSkipVerification) {
|
|
this.installUpgrade({
|
|
SkipVerification: true,
|
|
Source: source,
|
|
Success: true,
|
|
});
|
|
}
|
|
}
|
|
}, false);
|
|
}
|
|
};
|
|
|
|
saveState = () => {
|
|
if (this.props.AppReady) {
|
|
let state = {
|
|
Release: this.props.Release,
|
|
Version: this.props.ReleaseVersion,
|
|
};
|
|
|
|
for (const provider of Constants.PROVIDER_LIST) {
|
|
state[provider] = this.props.ProviderState[provider];
|
|
}
|
|
|
|
this.sendRequest(Constants.IPC_Save_State, {
|
|
State: state
|
|
});
|
|
}
|
|
};
|
|
|
|
updateCheckScheduledJob = () => {
|
|
if (this.props.AppPlatform !== 'unknown') {
|
|
this.detectUpgrades();
|
|
}
|
|
};
|
|
|
|
render() {
|
|
const selectedVersion = this.getSelectedVersion();
|
|
|
|
const downloadEnabled = this.props.AllowDownload &&
|
|
!this.props.MountsBusy &&
|
|
!this.props.DownloadActive &&
|
|
(selectedVersion !== 'unavailable') &&
|
|
(selectedVersion !== this.props.InstalledVersion);
|
|
|
|
const missingDependencies = (this.props.MissingDependencies.length > 0);
|
|
const allowMount = this.props.InstalledVersion !== 'none' &&
|
|
!missingDependencies &&
|
|
!this.props.InstallActive;
|
|
|
|
const allowConfig = this.props.LocationsLookup[selectedVersion] &&
|
|
this.props.LocationsLookup[selectedVersion].config_support;
|
|
|
|
const allowSiaPrime = this.props.LocationsLookup[selectedVersion] &&
|
|
this.props.LocationsLookup[selectedVersion].siaprime_support;
|
|
|
|
const noConsoleSupported = this.props.LocationsLookup[selectedVersion] &&
|
|
this.props.LocationsLookup[selectedVersion].no_console_supported;
|
|
|
|
const showConfig = !missingDependencies &&
|
|
this.props.DisplayConfiguration &&
|
|
allowConfig;
|
|
|
|
const showUpgrade = this.props.UpgradeAvailable &&
|
|
!this.props.DisplayError &&
|
|
!showConfig &&
|
|
!this.props.DownloadActive &&
|
|
!this.props.UpgradeDismissed;
|
|
|
|
const showDependencies = !showUpgrade &&
|
|
missingDependencies &&
|
|
!this.props.DownloadActive;
|
|
|
|
const configDisplay = this.createModalConditionally(showConfig, <Configuration version={selectedVersion} />);
|
|
const dependencyDisplay = this.createModalConditionally(showDependencies, <DependencyList onDownload={this.handleDownloadDependency}/>);
|
|
const downloadDisplay = this.createModalConditionally(this.props.DownloadActive, <DownloadProgress/>);
|
|
const errorDisplay = this.createModalConditionally(this.props.DisplayError, <ErrorDetails/>, true);
|
|
const upgradeDisplay = this.createModalConditionally(showUpgrade, <UpgradeUI upgrade={this.handleDownloadUpgrade}/>);
|
|
|
|
let mainContent = [];
|
|
if (this.props.AppReady) {
|
|
let key = 0;
|
|
mainContent.push((
|
|
<div key={'rvd_' + key++}
|
|
style={{height: '32%'}}>
|
|
<ReleaseVersionDisplay downloadClicked={this.handleDownloadRelease}
|
|
downloadDisabled={!downloadEnabled}/>
|
|
</div>
|
|
));
|
|
|
|
if (allowMount) {
|
|
mainContent.push((
|
|
<div key={'md_' + key++}>
|
|
<MountItems allowConfig={allowConfig}
|
|
allowSiaPrime={allowSiaPrime}
|
|
noConsoleSupported={noConsoleSupported}/>
|
|
</div>
|
|
));
|
|
}
|
|
} else {
|
|
mainContent = <Loading/>
|
|
}
|
|
|
|
return (
|
|
<div className={'App'}>
|
|
{errorDisplay}
|
|
{dependencyDisplay}
|
|
{upgradeDisplay}
|
|
{downloadDisplay}
|
|
{configDisplay}
|
|
<div className={'AppContainer'}>
|
|
<div className={'AppHeader'}>
|
|
<Box>
|
|
<Grid>
|
|
<Text col={0}
|
|
colSpan={'remain'}
|
|
row={0}
|
|
rowSpan={'remain'}
|
|
text={'Repertory UI v' + this.props.Version}
|
|
textAlign={'center'}
|
|
type={'Heading1'}/>
|
|
<UpgradeIcon
|
|
available={this.props.UpgradeAvailable}
|
|
clicked={()=>this.props.setDismissUIUpgrade(false)}
|
|
col={dimensions => dimensions.columns - 6}
|
|
colSpan={5}
|
|
row={1}
|
|
rowSpan={remain=>remain - 1}/>
|
|
</Grid>
|
|
</Box>
|
|
</div>
|
|
<div className={'AppContent'}>
|
|
<Box dxStyle={{padding: '8px 8px 0px 8px'}}>
|
|
{mainContent}
|
|
</Box>
|
|
</div>
|
|
</div>
|
|
</div>
|
|
);
|
|
}
|
|
}
|
|
|
|
const mapStateToProps = state => {
|
|
return {
|
|
AllowDownload: state.download.AllowDownload,
|
|
AppPlatform: state.common.AppPlatform,
|
|
AppReady: state.common.AppReady,
|
|
DisplayConfiguration: state.mounts.DisplayConfiguration,
|
|
DisplayError: state.error.DisplayError,
|
|
DownloadActive: state.download.DownloadActive,
|
|
DownloadType: state.download.DownloadType,
|
|
InstallActive: state.install.InstallActive,
|
|
InstallType: state.install.InstallType,
|
|
InstalledVersion: state.relver.InstalledVersion,
|
|
LocationsLookup: state.relver.LocationsLookup,
|
|
MissingDependencies: state.install.MissingDependencies,
|
|
MountsBusy: state.mounts.MountsBusy,
|
|
Platform: state.common.Platform,
|
|
ProviderState: state.mounts.ProviderState,
|
|
Release: state.relver.Release,
|
|
ReleaseVersion: state.relver.Version,
|
|
UpgradeAvailable: state.relver.UpgradeAvailable,
|
|
UpgradeData: state.relver.UpgradeData,
|
|
UpgradeDismissed: state.relver.UpgradeDismissed,
|
|
Version: state.common.Version,
|
|
VersionLookup: state.relver.VersionLookup,
|
|
};
|
|
};
|
|
|
|
const mapDispatchToProps = dispatch => {
|
|
return {
|
|
checkInstalled: (dependencies, version) => dispatch(checkInstalled(dependencies, version)),
|
|
detectUIUpgrade: () => dispatch(detectUIUpgrade()),
|
|
downloadItem: (name, type, url, completedCallback) => dispatch(downloadItem(name, type, url, completedCallback)),
|
|
installDependency: (source, url, completedCallback) => dispatch(installDependency(source, url, completedCallback)),
|
|
installRelease: (source, version, completedCallback) => dispatch(installRelease(source, version, completedCallback)),
|
|
installUpgrade: (source, sha256, signature, skipVerification, completedCallback) => dispatch(installUpgrade(source, sha256, signature, skipVerification, completedCallback)),
|
|
loadReleases: ()=> dispatch(loadReleases()),
|
|
notifyError: (msg, critical, callback) => dispatch(notifyError(msg, critical, callback)),
|
|
setActiveRelease: (release, version) => dispatch(setActiveRelease(release, version)),
|
|
setAllowDownload: allow => dispatch(setAllowDownload(allow)),
|
|
setDismissUIUpgrade: dismiss => dispatch(setDismissUIUpgrade(dismiss)),
|
|
setInstalledVersion: version => dispatch(setInstalledVersion(version)),
|
|
setProviderState: (provider, state) => dispatch(setProviderState(provider, state)),
|
|
setReleaseUpgradeAvailable: available => dispatch(setReleaseUpgradeAvailable(available)),
|
|
};
|
|
};
|
|
|
|
export default connect(mapStateToProps, mapDispatchToProps)(App);
|