to download the backup.
'
: ''
}`,
onSuccess() {
downloadBackup(backup, file);
},
});
}
async function downloadBackup(backup, file) {
// file: database, public, or private
if (backup.offsite) {
site.getBackupDownloadLink.submit(
{ backup: backup.name, file },
{
onSuccess(r) {
// TODO: fix this in documentResource, it should return message directly
if (r.message) {
window.open(r.message);
}
},
},
);
} else {
const url =
file == 'config'
? backup.config_file_url
: backup[file + '_url'];
const domainRegex = /^(https?:\/\/)?([^/]+)\/?/;
const newUrl = url.replace(
domainRegex,
`$1${site.pg.host_name}/`,
);
window.open(newUrl);
}
}
return [
{
group: 'Details',
items: [
{
label: 'View Job',
onClick() {
router.push({
name: 'Site Job',
params: { name: site.name, id: row.job },
});
},
},
],
},
{
group: 'Download',
condition: () => !row.physical,
items: [
{
label: 'Download Database',
onClick() {
return confirmDownload(row, 'database');
},
},
{
label: 'Download Public',
onClick() {
return confirmDownload(row, 'public');
},
condition: () => row.public_url,
},
{
label: 'Download Private',
onClick() {
return confirmDownload(row, 'private');
},
condition: () => row.private_url,
},
{
label: 'Download Config',
onClick() {
return confirmDownload(row, 'config');
},
condition: () => row.config_file_url,
},
],
},
{
group: 'Restore',
condition: () => row.offsite || row.physical,
items: [
{
label: 'Restore Backup',
condition: () => site.pg.status !== 'Archived',
onClick() {
if (row.physical && row.ready_to_restore) {
toast.error(
'Physical Snapshot is not ready to restore. Try again after 10 minutes.',
);
return;
}
if (row.physical) {
confirmDialog({
title: 'Restore Physical Backup',
message: `Are you sure you want to restore your site's database from physical backup taken on
${dayjs(
row.creation,
).format('lll')} ?`,
onSuccess({ hide }) {
toast.promise(
site.restoreSiteFromPhysicalBackup.submit({
backup: row.name,
}),
{
loading:
'Scheduling physical backup restore...',
success: () => {
hide();
router.push({
name: 'Site Jobs',
params: {
name: site.name,
},
});
return 'Backup restore scheduled successfully.';
},
error: (e) => getToastErrorMessage(e),
},
);
},
});
} else {
confirmDialog({
title: 'Restore Backup',
message: `Are you sure you want to restore your site to this offsite backup from
${dayjs(
row.creation,
).format('lll')} ?`,
onSuccess({ hide }) {
toast.promise(
site.restoreSiteFromFiles.submit({
files: {
database: row.remote_database_file,
public: row.remote_public_file,
private: row.remote_private_file,
config: row.remote_config_file,
},
}),
{
loading: 'Scheduling backup restore...',
success: (jobId) => {
hide();
router.push({
name: 'Site Job',
params: {
name: site.name,
id: jobId,
},
});
return 'Backup restore scheduled successfully.';
},
error: (e) => getToastErrorMessage(e),
},
);
},
});
}
},
},
{
label: 'Restore Backup on another Site',
condition: () => !row.physical,
onClick() {
let SelectSiteForRestore = defineAsyncComponent(
() =>
import('../components/site/SelectSiteForRestore.vue'),
);
renderDialog(
h(SelectSiteForRestore, {
site: site.name,
database_backup_exists: Boolean(
row.remote_database_file,
),
public_backup_exists: Boolean(row.remote_public_file),
private_backup_exists: Boolean(
row.remote_private_file,
),
config_backup_exists: Boolean(row.remote_config_file),
onRestore({
selectedSite,
restoreDatabase,
restorePublic,
restorePrivate,
restoreConfig,
}) {
const restoreSite = createResource({
url: 'press.api.site.restore',
});
let payload = {
name: selectedSite,
files: {},
};
if (restoreDatabase) {
payload.files.database = row.remote_database_file;
}
if (restorePublic) {
payload.files.public = row.remote_public_file;
}
if (restorePrivate) {
payload.files.private = row.remote_private_file;
}
if (restoreConfig) {
payload.files.config = row.remote_config_file;
}
// check if any file is selected
if (Object.keys(payload.files).length === 0) {
toast.error(
'Please select at least one file to restore.',
);
return;
}
return toast.promise(restoreSite.submit(payload), {
loading: 'Scheduling backup restore...',
success: (jobId) => {
router.push({
name: 'Site Job',
params: { name: selectedSite, id: jobId },
});
return 'Backup restore scheduled successfully.';
},
error: (e) => getToastErrorMessage(e),
});
},
}),
);
},
},
],
},
].filter((d) => (d.condition ? d.condition() : true));
},
primaryAction({ listResource: backups, documentResource: site }) {
return {
label: 'Schedule Backup',
slots: {
prefix: icon('upload-cloud'),
},
loading: site.backup.loading,
onClick() {
renderDialog(
h(
defineAsyncComponent(
() => import('../components/site/SiteScheduleBackup.vue'),
),
{
site: site.name,
onScheduleBackupSuccess: () => backups.reload(),
},
),
);
},
};
},
banner({ documentResource: site, listResource: backups }) {
if (site.pg?.status === 'Archived') {
if (backups?.data && backups.data.length > 0) {
return {
title: 'Need help with restoring your archived site.',
dismissable: true,
id: site.pg.name,
type: 'gray',
button: {
label: 'Contact Support',
variant: 'outline',
onClick() {
window.open('https://jcloud.jingrow.com/support', '_blank');
},
},
};
}
return;
}
return getUpsellBanner(
site,
'Your site is currently on a shared bench group. Upgrade plan for offsite backups and
more.',
);
},
},
},
{
label: 'Site Config',
icon: icon('settings'),
route: 'site-config',
type: 'list',
condition: (site) => {
return site.pg?.status !== 'Archived';
},
list: {
doctype: 'Site Config',
filters: (site) => {
return { parent: site.pg?.name, parenttype: 'Site' };
},
fields: ['name'],
pageLength: 999,
orderBy: 'creation desc',
columns: [
{
label: 'Config Name',
fieldname: 'key',
width: 1,
format(value, row) {
if (row.title) {
return `${row.title} (${row.key})`;
}
return row.key;
},
},
{
label: 'Config Value',
fieldname: 'value',
class: 'font-mono',
width: 2,
},
{
label: 'Type',
fieldname: 'type',
type: 'Badge',
width: '100px',
},
],
primaryAction({ listResource: configs, documentResource: site }) {
return {
label: 'Add Config',
slots: {
prefix: icon('plus'),
},
onClick() {
let ConfigEditorDialog = defineAsyncComponent(
() => import('../components/ConfigEditorDialog.vue'),
);
renderDialog(
h(ConfigEditorDialog, {
site: site.pg?.name,
onSuccess() {
configs.reload();
},
}),
);
},
};
},
secondaryAction({ listResource: configs }) {
return {
label: 'Preview',
slots: {
prefix: icon('eye'),
},
onClick() {
let ConfigPreviewDialog = defineAsyncComponent(
() => import('../components/ConfigPreviewDialog.vue'),
);
renderDialog(
h(ConfigPreviewDialog, {
configs: configs.data,
}),
);
},
};
},
rowActions({ row, listResource: configs, documentResource: site }) {
return [
{
label: 'Edit',
onClick() {
let ConfigEditorDialog = defineAsyncComponent(
() => import('../components/ConfigEditorDialog.vue'),
);
renderDialog(
h(ConfigEditorDialog, {
site: site.pg?.name,
config: row,
onSuccess() {
configs.reload();
},
}),
);
},
},
{
label: 'Delete',
onClick() {
confirmDialog({
title: 'Delete Config',
message: `Are you sure you want to delete the config
${row.key}?`,
onSuccess({ hide }) {
if (site.deleteConfig.loading) return;
toast.promise(
site.deleteConfig.submit(
{ key: row.key },
{
onSuccess: () => {
configs.reload();
hide();
},
},
),
{
loading: 'Deleting config...',
success: () => `Config ${row.key} removed`,
error: (e) => getToastErrorMessage(e),
},
);
},
});
},
},
];
},
},
},
{
label: 'Actions',
icon: icon('sliders'),
route: 'actions',
type: 'Component',
condition: (site) => {
return site.pg?.status !== 'Archived';
},
component: SiteActions,
props: (site) => {
return { site: site.pg?.name };
},
},
{
label: 'Updates',
icon: icon('arrow-up-circle'),
route: 'updates',
type: 'list',
condition: (site) => {
return site.pg?.status !== 'Archived';
},
childrenRoutes: ['Site Update'],
list: {
doctype: 'Site Update',
filters: (site) => {
return { site: site.pg?.name };
},
orderBy: 'creation',
fields: [
'difference',
'update_job.end as updated_on',
'update_job',
'backup_type',
'recover_job',
],
columns: [
{
label: 'Type',
fieldname: 'deploy_type',
width: 0.3,
},
{
label: 'Status',
fieldname: 'status',
type: 'Badge',
width: 0.5,
},
// {
// label: 'Backup',
// width: 0.4,
// type: 'Component',
// component({ row }) {
// return h(
// 'div',
// {
// class: 'truncate text-base',
// },
// row.skipped_backups
// ? 'Skipped'
// : row.backup_type || 'Logical',
// );
// },
// },
{
label: 'Created By',
fieldname: 'owner',
},
{
label: 'Scheduled At',
fieldname: 'scheduled_time',
format(value) {
return date(value, 'lll');
},
},
{
label: 'Updated On',
fieldname: 'updated_on',
format(value) {
return date(value, 'lll');
},
},
],
rowActions({ row, documentResource: site }) {
return [
{
label: 'Edit',
condition: () => row.status === 'Scheduled',
onClick() {
let SiteUpdateDialog = defineAsyncComponent(
() => import('../components/SiteUpdateDialog.vue'),
);
renderDialog(
h(SiteUpdateDialog, {
site: site.pg?.name,
existingUpdate: row.name,
}),
);
},
},
{
label: 'Cancel',
condition: () => row.status === 'Scheduled',
onClick() {
confirmDialog({
title: 'Cancel Update',
message: `Are you sure you want to cancel the scheduled update?`,
onSuccess({ hide }) {
if (site.cancelUpdate.loading) return;
toast.promise(
site.cancelUpdate.submit({ site_update: row.name }),
{
loading: 'Cancelling update...',
success: () => {
hide();
site.reload();
return 'Update cancelled';
},
error: (e) => getToastErrorMessage(e),
},
);
},
});
},
},
{
label: 'View Job',
condition: () =>
!['Scheduled', 'Cancelled'].includes(row.status),
onClick() {
router.push({
name: 'Site Update',
params: { id: row.name },
});
},
},
{
label: 'Update Now',
condition: () => row.status === 'Scheduled',
onClick() {
let siteUpdate = getDocResource({
doctype: 'Site Update',
name: row.name,
whitelistedMethods: {
updateNow: 'start',
},
});
toast.promise(siteUpdate.updateNow.submit(), {
loading: 'Updating site...',
success: () => {
router.push({
name: 'Site Update',
params: { id: row.name },
});
return 'Site update started';
},
error: 'Failed to update site',
});
},
},
{
label: 'View App Changes',
onClick() {
createListResource({
doctype: 'Deploy Candidate Difference App',
fields: [
'difference.github_diff_url as diff_url',
'difference.source_hash as source_hash',
'difference.destination_hash as destination_hash',
'app.title as app',
],
filters: {
parenttype: 'Deploy Candidate Difference',
parent: row.difference,
},
auto: true,
pageLength: 99,
onSuccess(data) {
if (data?.length) {
renderDialog(
h(
GenericDialog,
{
options: {
title: 'App Changes',
size: '2xl',
},
},
{
default: () =>
h(ObjectList, {
options: {
data: () => data,
columns: [
{
label: 'App',
fieldname: 'app',
},
{
label: 'From',
fieldname: 'source_hash',
type: 'Button',
Button({ row }) {
return {
label:
row.source_tag ||
row.source_hash.slice(0, 7),
variant: 'ghost',
class: 'font-mono',
link: `${
row.diff_url.split('/compare')[0]
}/commit/${row.source_hash}`,
};
},
},
{
label: 'To',
fieldname: 'destination_hash',
type: 'Button',
Button({ row }) {
return {
label:
row.destination_tag ||
row.destination_hash.slice(0, 7),
variant: 'ghost',
class: 'font-mono',
link: `${
row.diff_url.split('/compare')[0]
}/commit/${row.destination_hash}`,
};
},
},
{
label: 'App Changes',
fieldname: 'diff_url',
align: 'right',
type: 'Button',
Button({ row }) {
return {
label: 'View',
variant: 'ghost',
slots: {
prefix: icon('external-link'),
},
link: row.diff_url,
};
},
},
],
},
}),
},
),
);
} else toast.error('No app changes found');
},
});
},
},
];
},
actions({ documentResource: site }) {
if (site.pg.group_public) return [];
return [
{
label: 'Configure',
slots: {
prefix: icon('settings'),
},
onClick() {
let ConfigureAutoUpdateDialog = defineAsyncComponent(
() =>
import(
'../components/site/ConfigureAutoUpdateDialog.vue'
),
);
renderDialog(
h(ConfigureAutoUpdateDialog, {
site: site.pg?.name,
}),
);
},
},
];
},
banner({ documentResource: site }) {
const bannerTitle =
'Your site is currently on a shared bench group. Upgrade to a private bench group to configure auto updates and
more.';
return getUpsellBanner(site, bannerTitle);
},
},
},
{
label: 'Activity',
icon: icon('activity'),
route: 'activity',
type: 'list',
condition: (site) => site.pg?.status !== 'Archived',
list: {
doctype: 'Site Activity',
filters: (site) => {
return { site: site.pg?.name };
},
fields: ['owner', 'job'],
orderBy: 'creation desc',
route(row) {
if (!row.job) return {};
return {
name: 'Site Job',
params: { id: row.job },
};
},
columns: [
{
label: 'Action',
fieldname: 'action',
format(value, row) {
let action = row.action;
if (action == 'Create') {
action = 'Site created';
}
return `${action} by ${row.owner}`;
},
},
{
label: 'Description',
fieldname: 'reason',
class: 'text-gray-600',
},
{
label: '',
fieldname: 'creation',
type: 'Timestamp',
align: 'right',
},
],
filterControls() {
return [
{
type: 'select',
label: 'Action',
fieldname: 'action',
class: !isMobile() ? 'w-52' : '',
options: [
'',
'Activate Site',
'Add Domain',
'Archive',
'Backup',
'Create',
'Clear Cache',
'Deactivate Site',
'Disable Database Access',
'Drop Offsite Backups',
'Enable Database Access',
'Install App',
'Login as Administrator',
'Migrate',
'Reinstall',
'Restore',
'Suspend Site',
'Uninstall App',
'Unsuspend Site',
'Update',
'Update Configuration',
],
},
];
},
},
},
],
actions(context) {
let { documentResource: site } = context;
let $team = getTeam();
let runningJobs = getRunningJobs({ site: site.pg?.name });
return [
{
label: 'Jobs in progress',
slots: {
prefix: () => h(LoadingIndicator, { class: 'w-4 h-4' }),
},
condition() {
return (
runningJobs.filter((job) =>
['Pending', 'Running'].includes(job.status),
).length > 0
);
},
onClick() {
router.push({
name: 'Site Jobs',
params: { name: site.name },
});
},
},
{
label: 'Update Available',
variant: site.pg?.setup_wizard_complete ? 'solid' : 'subtle',
slots: {
prefix: icon('alert-circle'),
},
condition() {
return (
!site.pg?.has_scheduled_updates &&
site.pg.update_information?.update_available &&
['Active', 'Inactive', 'Suspended', 'Broken'].includes(
site.pg.status,
)
);
},
onClick() {
let SiteUpdateDialog = defineAsyncComponent(
() => import('../components/SiteUpdateDialog.vue'),
);
renderDialog(h(SiteUpdateDialog, { site: site.pg?.name }));
},
},
{
label: 'Update Scheduled',
slots: {
prefix: icon('calendar'),
},
condition: () => site.pg?.has_scheduled_updates,
onClick() {
router.push({
name: 'Site Detail Updates',
params: { name: site.name },
});
},
},
{
label: 'Enable Monitoring',
slots: {
prefix: icon('activity'),
},
condition: () => site.pg?.is_monitoring_disabled,
onClick() {
let SiteEnableMonitoringDialog = defineAsyncComponent(
() => import('../components/site/SiteEnableMonitoringDialog.vue'),
);
renderDialog(
h(SiteEnableMonitoringDialog, { site: site.pg?.name }),
);
},
},
{
label: 'Impersonate Site Owner',
title: 'Impersonate Site Owner', // for label to pop-up on hover
slots: {
icon: icon(LucideVenetianMask),
},
condition: () =>
$team.pg?.is_desk_user && site.pg.team !== $team.name,
onClick() {
switchToTeam(site.pg.team);
},
},
{
label: 'Visit Site',
slots: {
prefix: icon('external-link'),
},
condition: () =>
site.pg.status !== 'Archived' && site.pg?.setup_wizard_complete,
onClick() {
let siteURL = `https://${site.name}`;
if (
site.pg.version === 'Nightly' ||
Number(site.pg.version.split(' ')[1]) >= 15
)
siteURL += '/apps';
window.open(siteURL, '_blank');
},
},
{
label: 'Setup Site',
slots: {
prefix: icon('external-link'),
},
variant: 'solid',
loading: site.loginAsAdmin.loading || site.loginAsTeam.loading,
condition: () =>
site.pg.status === 'Active' && !site.pg?.setup_wizard_complete,
onClick() {
if (site.pg.additional_system_user_created) {
site.loginAsTeam
.submit({ reason: '' })
.then((url) => window.open(url, '_blank'));
} else {
site.loginAsAdmin
.submit({ reason: '' })
.then((url) => window.open(url, '_blank'));
}
},
},
{
label: 'Options',
context,
options: [
{
label: 'View in Desk',
icon: 'external-link',
condition: () => $team.pg?.is_desk_user,
onClick: () => {
window.open(
`${window.location.protocol}//${window.location.host}/app/site/${site.name}`,
'_blank',
);
},
},
{
label: 'Login As Administrator',
icon: 'external-link',
condition: () => ['Active', 'Broken'].includes(site.pg.status),
onClick: () => {
confirmDialog({
title: 'Login as Administrator',
message: `Are you sure you want to login as administrator on the site
${site.pg?.name}?`,
fields:
$team.name !== site.pg.team || $team.pg.is_desk_user
? [
{
label: 'Reason',
type: 'textarea',
fieldname: 'reason',
},
]
: [],
onSuccess: ({ hide, values }) => {
if (
!values.reason &&
($team.name !== site.pg.team || $team.pg.is_desk_user)
) {
throw new Error('Reason is required');
}
return site.loginAsAdmin
.submit({ reason: values.reason })
.then((result) => {
let url = result;
window.open(url, '_blank');
hide();
});
},
});
},
},
],
},
];
},
},
routes: [
{
name: 'Site Update',
path: 'updates/:id',
component: () => import('../pages/SiteUpdate.vue'),
},
],
};