private static int DoMigrate(OSGeo.MapGuide.MaestroAPI.IServerConnection source, OSGeo.MapGuide.MaestroAPI.IServerConnection target, CopyMoveToServerDialog migrate)
{
var diag = new ProgressDialog();
diag.CancelAbortsThread = true;
var method = new ProgressDialog.DoBackgroundWork((worker, e, args) =>
{
var src = (IServerConnection)args[0];
var dst = (IServerConnection)args[1];
var ids = (string[])args[2];
var folder = (string)args[3];
var overwrite = (bool)args[4];
var act = (MigrationAction)args[5];
var cb = new LengthyOperationProgressCallBack((sender, cbe) =>
{
worker.ReportProgress(cbe.Progress, cbe.StatusMessage);
});
var migrator = new ResourceMigrator(source, target);
int affected = 0;
switch (act)
{
case MigrationAction.Copy:
affected = migrator.CopyResources(ids, folder, overwrite, cb);
break;
case MigrationAction.Move:
affected = migrator.MoveResources(ids, folder, overwrite, cb);
break;
}
return affected;
});
return (int)diag.RunOperationAsync(Workbench.Instance, method, source, target, migrate.SourceResourceIds, migrate.TargetFolder, migrate.OverwriteResources, migrate.SelectedAction);
}
public override void Run()
{
var wb = Workbench.Instance;
var siteExp = wb.ActiveSiteExplorer;
var connMgr = ServiceRegistry.GetService<ServerConnectionManager>();
var conn = connMgr.GetConnection(wb.ActiveSiteExplorer.ConnectionName);
var items = siteExp.SelectedItems;
var prg = new ProgressDialog();
var results = (ICollection<string>)prg.RunOperationAsync(wb, DoBackgroundWorker, items, conn);
var list = new List<string>(results);
list.Sort();
new ResourceDependencyListDialog(list).Show(wb);
}
static void CreateLayers(IServerConnection conn, string featureSource, string targetFolder, string[] featureClasses)
{
var wb = Workbench.Instance;
List<ClassDefinition> classes = new List<ClassDefinition>();
foreach (var clsName in featureClasses)
{
classes.Add(conn.FeatureService.GetClassDefinition(featureSource, clsName));
}
var prg = new ProgressDialog();
var results = (ICollection<string>)prg.RunOperationAsync(wb, DoBackgroundWorker, classes, conn, featureSource, targetFolder);
var exp = wb.ActiveSiteExplorer;
if (exp != null)
{
exp.RefreshModel(exp.ConnectionName, targetFolder);
exp.ExpandNode(exp.ConnectionName, targetFolder);
}
}
public override void Run()
{
var wb = Workbench.Instance;
var items = wb.ActiveSiteExplorer.SelectedItems;
var connMgr = ServiceRegistry.GetService<ServerConnectionManager>();
_conn = connMgr.GetConnection(wb.ActiveSiteExplorer.ConnectionName);
if (items.Length > 0)
{
var pdlg = new ProgressDialog();
pdlg.CancelAbortsThread = true;
string[] args = new string[items.Length];
for (int i = 0; i < items.Length; i++)
{
args[i] = items[i].ResourceId;
}
var issues = (ValidationIssue[])pdlg.RunOperationAsync(wb, new ProgressDialog.DoBackgroundWork(BackgroundValidate), args);
CollectAndDisplayIssues(issues);
}
}
private void DoMigrate(IServerConnection source, IServerConnection target, string resourceId, string[] dependentResourceIds, bool overwrite)
{
var diag = new ProgressDialog();
diag.CancelAbortsThread = true;
var method = new ProgressDialog.DoBackgroundWork((worker, e, args) =>
{
var src = (IServerConnection)args[0];
var dst = (IServerConnection)args[1];
var resId = (string)args[2];
var dependents = (string[])args[3];
var overwriteExisting = (bool)args[4];
var cb = new LengthyOperationProgressCallBack((sender, cbe) =>
{
worker.ReportProgress(cbe.Progress, cbe.StatusMessage);
});
var migrator = new ResourceMigrator(source, target);
migrator.MigrateResource(resId, dependentResourceIds, overwriteExisting, cb);
return true;
});
diag.RunOperationAsync(Workbench.Instance, method, source, target, resourceId, dependentResourceIds, overwrite);
}
private void DoUpdateConfiguration(string[] toAdd, string[] toRemove, bool isAlias)
{
if (_conf == null)
BuildDefaultDocument();
var pdlg = new ProgressDialog();
pdlg.CancelAbortsThread = true;
var worker = new ProgressDialog.DoBackgroundWork(UpdateConfigurationDocument);
var result = (UpdateConfigResult)pdlg.RunOperationAsync(null, worker, _conf, _fs.CurrentConnection, toAdd, toRemove, isAlias);
if (result.Added.Count > 0 || result.Removed.Count > 0)
{
_fs.SetConfigurationContent(_conf.ToXml());
List<ListViewItem> remove = new List<ListViewItem>();
foreach (ListViewItem lvi in lstView.Items)
{
if (result.Removed.Contains(lvi.Text))
remove.Add(lvi);
}
foreach (var added in result.Added)
{
string dir = null;
string fileName = null;
if (isAlias)
{
dir = added.Substring(0, added.LastIndexOf("\\")); //NOXLATE
fileName = added.Substring(added.LastIndexOf("\\") + 1); //NOXLATE
}
else
{
dir = Path.GetDirectoryName(added);
fileName = Path.GetFileName(added);
}
foreach (var loc in _conf.RasterLocations)
{
if (loc.Location == dir)
{
foreach (var item in loc.Items)
{
if (item.FileName == fileName)
{
AddRasterItem(dir, item);
}
}
}
}
}
OnResourceChanged();
}
}
private static void DoRepointResource(Workbench wb, IServerConnection conn, ResourceIdentifier resId)
{
var diag = new RepointerDialog(resId, conn.ResourceService);
if (diag.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
string srcId = diag.Source;
string dstId = diag.Target;
var deps = diag.Dependents;
ProgressDialog.DoBackgroundWork worker = (wk, e, args) =>
{
int updated = 0;
int total = deps.Count;
wk.ReportProgress(0, Strings.ProgressUpdatingReferences);
foreach (var dep in deps)
{
using (var stream = conn.ResourceService.GetResourceXmlData(dep))
{
XmlDocument doc = new XmlDocument();
doc.Load(stream);
bool changed = Utility.ReplaceResourceIds(doc, srcId, dstId);
if (changed)
{
using (var ms = new MemoryStream())
{
doc.Save(ms);
ms.Position = 0L; //Rewind
conn.ResourceService.SetResourceXmlData(dep, ms);
}
updated++;
wk.ReportProgress((updated / total) * 100);
}
}
}
return updated;
};
var prd = new ProgressDialog();
int result = (int)prd.RunOperationAsync(wb, worker);
MessageService.ShowMessage(string.Format(Strings.ResourcesRepointed, result, dstId));
}
}
private string[] MoveResourcesWithinConnection(string connectionName, ICollection<string> resIds, string folderId)
{
var wb = Workbench.Instance;
var notMovedToTarget = new List<string>();
var notMovedFromSource = new List<string>();
var omgr = ServiceRegistry.GetService<OpenResourceManager>();
var conn = _connManager.GetConnection(connectionName);
var dlg = new ProgressDialog();
var worker = new ProgressDialog.DoBackgroundWork((w, e, args) =>
{
LengthyOperationProgressCallBack cb = (sender, cbe) =>
{
w.ReportProgress(cbe.Progress, cbe.StatusMessage);
};
var f = (string)args[0];
var resourceIds = (ICollection<string>)args[1];
foreach (var r in resourceIds)
{
if (ResourceIdentifier.IsFolderResource(r))
{
//IMPORTANT: We need to tweak the target resource id
//otherwise the content *inside* the source folder is
//moved instead of the folder itself!
var rid = new ResourceIdentifier(r);
var target = folderId + rid.Name + "/"; //NOXLATE
conn.ResourceService.MoveResourceWithReferences(r, target, null, cb);
}
else
{
var rid = new ResourceIdentifier(r);
var target = folderId + rid.Name + "." + rid.Extension; //NOXLATE
if (omgr.IsOpen(r, conn))
{
notMovedFromSource.Add(r);
continue;
}
if (!omgr.IsOpen(target, conn))
conn.ResourceService.MoveResourceWithReferences(r, target, null, cb);
else
notMovedToTarget.Add(r);
}
}
//Collect affected folders and refresh them
Dictionary<string, string> folders = new Dictionary<string, string>();
folders.Add(folderId, folderId);
foreach (var n in resourceIds)
{
var ri = new ResourceIdentifier(n);
var parent = ri.ParentFolder;
if (parent != null && !folders.ContainsKey(parent))
folders.Add(parent, parent);
}
return folders.Keys;
});
var affectedFolders = (IEnumerable<string>)dlg.RunOperationAsync(wb, worker, folderId, resIds);
if (notMovedToTarget.Count > 0 || notMovedFromSource.Count > 0)
{
MessageService.ShowMessage(string.Format(
Strings.NotCopiedOrMovedDueToOpenEditors,
Environment.NewLine + string.Join(Environment.NewLine, notMovedToTarget.ToArray()) + Environment.NewLine,
Environment.NewLine + string.Join(Environment.NewLine, notMovedFromSource.ToArray()) + Environment.NewLine));
}
return new List<string>(affectedFolders).ToArray();
}
internal string[] CopyResourcesToFolder(RepositoryHandle[] data, string targetConnectionName, string folderId)
{
string rootSourceParent = GetCommonParent(data);
//There is an implicit assumption here that all items dropped come from the same connection
var sourceConn = data.First().Connection;
var targetConn = _connManager.GetConnection(targetConnectionName);
var migrator = new ResourceMigrator(sourceConn, targetConn);
//Collect all source ids
var sourceIds = new List<string>();
foreach (var resId in data.Select(x => x.ResourceId.ToString()))
{
if (ResourceIdentifier.IsFolderResource(resId))
sourceIds.AddRange(GetFullResourceList(sourceConn, resId));
else
sourceIds.Add(resId);
}
var targets = new List<string>();
foreach (var resId in sourceIds)
{
var dstId = resId.Replace(rootSourceParent, folderId);
System.Diagnostics.Trace.TraceInformation("{0} => {1}", resId, dstId); //NOXLATE
targets.Add(dstId);
}
bool overwrite = true;
var existing = new List<string>();
foreach (var resId in targets)
{
if (targetConn.ResourceService.ResourceExists(resId))
{
existing.Add(resId);
}
}
if (existing.Count > 0)
overwrite = MessageService.AskQuestion(string.Format(Strings.PromptOverwriteOnTargetConnection, existing.Count));
var wb = Workbench.Instance;
var dlg = new ProgressDialog();
var worker = new ProgressDialog.DoBackgroundWork((w, evt, args) =>
{
LengthyOperationProgressCallBack cb = (s, cbe) =>
{
w.ReportProgress(cbe.Progress, cbe.StatusMessage);
};
return migrator.CopyResources(sourceIds.ToArray(), targets.ToArray(), overwrite, new RebaseOptions(rootSourceParent, folderId), cb);
});
var result = (string[])dlg.RunOperationAsync(wb, worker);
RefreshModel(targetConn.DisplayName, folderId);
ExpandNode(targetConn.DisplayName, folderId);
return result;
}
private void DoDelete(Workbench wb, OSGeo.MapGuide.MaestroAPI.Services.IResourceService resSvc, RepositoryItem[] items)
{
var pdlg = new ProgressDialog();
pdlg.CancelAbortsThread = true;
string[] args = new string[items.Length];
for (int i = 0; i < items.Length; i++)
{
args[i] = items[i].ResourceId;
}
var work = new Maestro.Shared.UI.ProgressDialog.DoBackgroundWork((worker, e, target) =>
{
int deleted = 0;
if (target == null || target.Length == 0)
return deleted;
int step = 100 / target.Length;
int current = 0;
foreach (RepositoryItem item in target)
{
if (worker.CancellationPending || e.Cancel)
return deleted;
current += step;
if (item.IsRoot) //Wait a minute...!
{
continue;
}
else
{
resSvc.DeleteResource(item.ResourceId);
deleted++;
worker.ReportProgress(current, item.ResourceId);
}
}
//collect affected parents and update the model
foreach (RepositoryItem item in target)
{
var parent = item.Parent;
if (parent != null)
{
parent.RemoveChild(item);
}
}
return deleted;
});
pdlg.RunOperationAsync(wb, work, items);
}
public override void Run()
{
var wb = Workbench.Instance;
var items = wb.ActiveSiteExplorer.SelectedItems;
var connMgr = ServiceRegistry.GetService<ServerConnectionManager>();
_conn = connMgr.GetConnection(wb.ActiveSiteExplorer.ConnectionName);
if (items.Length > 0)
{
var diag = new TestResourceCompatibilityDialog();
if (diag.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
_checkVersion = diag.SelectedVersion;
var pdlg = new ProgressDialog();
pdlg.CancelAbortsThread = true;
var args = new HashSet<string>();
for (int i = 0; i < items.Length; i++)
{
args.Add(items[i].ResourceId);
}
var incompatibleItems = (string[])pdlg.RunOperationAsync(wb, new ProgressDialog.DoBackgroundWork(BackgroundCheckResources), args.ToArray());
if (incompatibleItems.Length > 0)
{
new IncompatibleResourcesDialog(_checkVersion, incompatibleItems).ShowDialog();
}
else
{
System.Windows.Forms.MessageBox.Show(string.Format(Strings.ResourcesCompatibleWithSelectedVersion, _checkVersion));
}
}
}
}
public override void Run()
{
var wb = Workbench.Instance;
var ed = wb.ActiveEditor;
if (ed != null)
{
_conn = ed.EditorService.GetEditedResource().CurrentConnection;
var xed = ed as XmlEditor;
if (xed != null)
{
xed.EditorService.UpdateResourceContent(xed.GetXmlContent());
}
else
{
ed.EditorService.SyncSessionCopy();
}
var pdlg = new ProgressDialog();
pdlg.CancelAbortsThread = true;
var issues = (ValidationIssue[])pdlg.RunOperationAsync(wb, new ProgressDialog.DoBackgroundWork(BackgroundValidate), ed.EditorService.EditedResourceID);
CollectAndDisplayIssues(issues);
}
}
private void btnExplodeTheme_Click(object sender, EventArgs e)
{
var ed = m_owner.EditorService;
var layer = ed.GetEditedResource() as ILayerDefinition;
var style = m_point as IVectorStyle ?? m_line as IVectorStyle ?? m_area as IVectorStyle;
var diag = new ExplodeThemeDialog(ed, m_parent, style, layer);
if (diag.ShowDialog() == DialogResult.OK)
{
var options = new ExplodeThemeOptions()
{
ActiveStyle = style,
FolderId = diag.CreateInFolder,
Layer = layer,
LayerNameFormat = diag.LayerNameFormat,
LayerPrefix = diag.LayerPrefix,
Range = m_parent
};
var progress = new ProgressDialog();
var worker = new BackgroundWorker();
worker.WorkerReportsProgress = true;
progress.RunOperationAsync(null, ExplodeThemeWorker, options);
}
}
void OnExecute(object sender, EventArgs e)
{
var pdlg = new ProgressDialog();
pdlg.CancelAbortsThread = true;
var worker = new ProgressDialog.DoBackgroundWork(ExecuteLoadProcedure);
try
{
_ed.SyncSessionCopy();
var result = pdlg.RunOperationAsync(this.ParentForm, worker, _ed, _lp);
MessageBox.Show(Strings.OperationCompleted);
_ed.RequestRefresh(_lp.SubType.RootPath);
//Load procedure may have modified this resource as part of executioin
_ed.SyncSessionCopy();
//HACK: Force dirty state as successful execution writes some extra XML content to the resource
_ed.MarkDirty();
}
catch (CancelException)
{
MessageBox.Show(Strings.OperationCancelled);
}
}
private void btnValidate_Click(object sender, EventArgs e)
{
var wb = Workbench.Instance;
var items = wb.ActiveSiteExplorer.SelectedItems;
var connMgr = ServiceRegistry.GetService<ServerConnectionManager>();
var conn = connMgr.GetConnection(wb.ActiveSiteExplorer.ConnectionName);
if (items.Length > 0)
{
var pdlg = new ProgressDialog();
pdlg.CancelAbortsThread = true;
object[] args = new object[items.Length + 1];
args[0] = conn;
for (int i = 0; i < items.Length; i++)
{
args[i+1] = items[i].ResourceId;
}
var issues = (ValidationIssue[])pdlg.RunOperationAsync(wb, new ProgressDialog.DoBackgroundWork(BackgroundValidate), args);
CollectAndDisplayIssues(issues);
}
}
public override void Run()
{
var wb = Workbench.Instance;
var exp = wb.ActiveSiteExplorer;
var omgr = ServiceRegistry.GetService<OpenResourceManager>();
var connMgr = ServiceRegistry.GetService<ServerConnectionManager>();
var conn = connMgr.GetConnection(exp.ConnectionName);
if (exp.SelectedItems.Length == 1)
{
var current = exp.SelectedItems[0];
var parent = current.Parent;
List<string> names = new List<string>();
foreach (var item in parent.Children)
{
if (item != exp.SelectedItems[0])
{
names.Add(item.Name);
}
}
if (!current.IsFolder && omgr.IsOpen(current.ResourceId, conn))
{
MessageService.ShowMessage(Strings.CannotRenameAlreadyOpenedResource);
return;
}
var dlg = new RenameItemDialog(current.Name, names);
if (dlg.ShowDialog(wb) == System.Windows.Forms.DialogResult.OK)
{
string oldid = string.Empty;
string newid = string.Empty;
if (current.IsFolder)
{
oldid = parent.ResourceId + current.Name + "/"; //NOXLATE
newid = parent.ResourceId + dlg.NewName + "/"; //NOXLATE
}
else
{
oldid = parent.ResourceId + current.Name + "." + current.ResourceType; //NOXLATE
newid = parent.ResourceId + dlg.NewName + "." + current.ResourceType; //NOXLATE
}
if (omgr.IsOpen(newid, conn))
{
MessageService.ShowMessage(string.Format(Strings.CannotRenameToResourceAlreadyOpened, newid));
return;
}
var prog = new ProgressDialog();
prog.RunOperationAsync(wb, (worker, e, args) =>
{
LengthyOperationProgressCallBack cb = (s, cbArgs) =>
{
worker.ReportProgress(cbArgs.Progress, cbArgs.StatusMessage);
};
//Perform the operation
if (dlg.UpdateReferences)
conn.ResourceService.MoveResourceWithReferences(oldid, newid, null, cb);
else
conn.ResourceService.MoveResource(oldid, newid, dlg.Overwrite);
/*
if (current.IsFolder)
{
if (dlg.UpdateReferences)
conn.ResourceService.MoveFolderWithReferences(oldid, newid, null, cb);
else
conn.ResourceService.MoveFolder(oldid, newid, dlg.Overwrite);
}
else
{
if (dlg.UpdateReferences)
{
conn.ResourceService.MoveResourceWithReferences(oldid, newid, null, cb);
}
else
conn.ResourceService.MoveResource(oldid, newid, dlg.Overwrite);
}*/
current.Name = dlg.NewName;
if (dlg.Overwrite)
parent.RemoveChild(parent[dlg.NewName]);
return true;
});
//Need to refresh the model because it still is called by the old name
var rid = new OSGeo.MapGuide.MaestroAPI.Resource.ResourceIdentifier(oldid);
var folder = rid.ParentFolder;
exp.RefreshModel(conn.DisplayName, folder);
}
}
}
