private void DoChanged(GCAction action)
{
//Does it still exist?
if (!FileOrDirectoryExists(action.Path))
{
return; // can happen when creating a new folder that immediately gets a different name
}
if (ThisIsFromMe(action))
{
return;
}
// We should already have this file in DB if not then it could be a new folder thats being renamed (it fires a change event as well)
Object o = FindDiskItem(action);
if (o == null)
{
return;
}
if (o is DiskItem)
{
DiskItem item = (DiskItem)o;
// anything changed? (it may be a parent folder)
if (item.Folder)
{
return;
}
}
// we don't do anything for workspaces
}
/// <summary>
/// Show play list dialog to make some action
/// </summary>
/// <param name="item">Disk item - audio or video file</param>
/// <param name="action">What to do - 0 is Add, 1 Remove</param>
public PlaylistDialog(DiskItem item, int action = 0)
{
_diskItem = item;
InitializeComponent();
if (action == 0)
{
Title = $"Add '{_diskItem.DisplayName}' to playlist";
PrimaryButtonText = "Add";
PlayLists = DataProvider.Instance.GetPlaylists(true)
.Where(l => l.DiskItems.FirstOrDefault(i => i.Equals(_diskItem)) == null)
.ToList();
}
else if (action == 1)
{
PrimaryButtonText = "Remove";
PlayLists = DataProvider.Instance.GetPlaylists(true)
.Where(l => l.DiskItems.FirstOrDefault(i => i.Equals(_diskItem)) != null)
.ToList();
if (PlayLists.Count == 0)
{
Title = Title = $"'{_diskItem.DisplayName}' does not belong to any of playlists";
}
else
{
Title = $"Remove '{_diskItem.DisplayName}' from playlist";
}
}
}
public static string Run(Window parent, DiskItem item)
{
var dialog = new RenameDialog(item) { Owner = parent };
if (!dialog.ShowDialog())
return null;
return dialog.FullName;
}
private void UpdateDiskItem(DiskItem i)
{
DiskItem original = db.Find <DiskItem>(i.Id);
DeleteDiskItem(original);
NewFileAdded(i);
}
public async Task <bool> DeleteItem(DiskItem diskItem, Action <DiskItem> action = null)
{
if (diskItem == null)
{
return(false);
}
var dialog = new ContentDialog()
{
Title = "Delete disk item?",
Content = $"Are you sure you want to delete '{diskItem.DisplayName}'?",
CloseButtonText = "No",
PrimaryButtonText = "Delete"
};
var dialogResult = await dialog.ShowAsync();
if (dialogResult != ContentDialogResult.Primary)
{
return(false);
}
var result = await Client.Delete(diskItem.Path);
if (result != null && result.IsError())
{
return(false);
}
if (action != null)
{
await Task.Factory.StartNew(() => action(diskItem), CancellationToken.None, TaskCreationOptions.None, Client.Sync);
}
return(true);
}
private void doDelete(GCAction action)
{
// find DiskItem
var rs = from d in db.Table <DiskItem>()
where d.Path.Equals(action.Path)
select d;
if (rs.Count() == 0)
{
Console.Error.Write("No matching Diskitem when deleting ?", action.Path);
return;
}
DiskItem item = rs.FirstOrDefault();
var request = newReq("/rest/sync/delete");
SetUpRequest(request);
request.AddParameter("docId", action.DiskItemId);
request.AddParameter("folder", item.Folder);
var response = client.Execute <DeleteFileMeta>(request);
if (response.ResponseStatus == ResponseStatus.Completed)
{
DeleteFileMeta meta = response.Data;
if (meta.success)
{
// what do if anything?
}
}
}
public DiskItemViewModel(Disk disk, DiskItem diskItem)
{
DiskItem = diskItem;
Name = Path.GetFileName(DiskItem.FullPath);
IsDirectory = DiskItem.Kind == DiskItemKind.Directory;
SetSizeAndUnits();
TotalPercent = 100.0f * diskItem.SizeBytes / disk.TotalSizeBytes;
}
public static ItemTestResult[] ExecuteTests(DiskItem[] items, ITest[] tests)
{
var results = new List<ItemTestResult>(items.Length);
ExecuteTests(items, tests, results.Add);
return results.ToArray();
}
public static void ExecuteTests(DiskItem[] items, ITest[] tests, Action<ItemTestResult> resultCallback)
{
foreach (var item in items)
{
var result = new ItemTestResult(item, new TestResultCollection(tests.Select(x => x.Execute(item, items)).ToList()));
resultCallback(result);
}
}
public TestResult Execute(DiskItem contextItem, DiskItem[] allItems)
{
if (contextItem.Item.Versions.Count > 0)
{
return(new TestResult(this, true));
}
return(new TestResult(this, false, "This item had no versions in any language. This can be valid, but is highly unusual."));
}
public async Task AddToPlayListAsync(PlayList playList, DiskItem diskItem)
{
var item = new ItemList()
{
ItemID = diskItem.ID, PlayListID = playList.ID
};
await _localContext.ItemsInPlaylist.AddAsync(item);
await Save();
}
public async Task RemoveFromPlayListAsync(PlayList playList, DiskItem diskItem)
{
var item = await _localContext.ItemsInPlaylist.FirstOrDefaultAsync(i => i.ItemID == diskItem.ID && i.PlayListID == playList.ID);
if (item != null)
{
_localContext.ItemsInPlaylist.Remove(item);
await Save();
}
}
RenameDialog(DiskItem item)
{
InitializeComponent();
label.Content = $"Please enter new name for {item.Name}:";
this.item = item;
ItemName = item.Name;
name.Focus();
name.CaretIndex = item.NameWoExtension.Length;
name.Select(0, name.CaretIndex);
}
public TestResult Execute(DiskItem contextItem, DiskItem[] allItems)
{
var duplicates = allItems.Where(x =>
x.Item.DatabaseName.Equals(contextItem.Item.DatabaseName, StringComparison.Ordinal) &&
x.Item.ID.Equals(contextItem.Item.ID, StringComparison.Ordinal) &&
x.FullPath != contextItem.FullPath)
.ToArray();
if (duplicates.Length == 0) return new TestResult(this, true);
return new TestResult(this, false, contextItem.Item.ID + " was present in other files: " + string.Join(",", duplicates.Select(x => x.FullPath)));
}
public async Task <DiskItem> CreateItemAsync(DiskItem diskItem)
{
if (diskItem.ID != 0)
{
return(diskItem);
}
var result = await _localContext.Items.AddAsync(diskItem);
await Save();
return(result.Entity);
}
public async Task <DiskItem> UpdateItemAsync(DiskItem diskItem)
{
if (diskItem.ID == 0)
{
return(null);
}
var result = _localContext.Items.Update(diskItem);
await Save();
return(result.Entity);
}
private void DownLoadFile(DiskItem f)
{
var path = GetRootPath(f);
var fullpath = Path.Combine(path, f.FileName);
// conflict?
if (File.Exists(fullpath))
{
bool conflict = true;
int count = 1;
while (conflict)
{
string name = Path.GetFileNameWithoutExtension(f.FileName);
name = name + "(" + count + ")" + Path.GetExtension(f.FileName);
if (File.Exists(Path.Combine(path, name)))
{
count++;
}
else
{
fullpath = Path.Combine(path, name);
conflict = false;
f.FileName = name;
}
}
}
// f.Path = fullpath;
f.Path = f.FileName;
db.Update(f);
using (var client = new WebClient())
{
string url = server + "rest/sync/get?key=" + key + "&apiId=" + apiId + "&docId=" + f.Id;
try {
client.DownloadFile(url, fullpath);
var length = new System.IO.FileInfo(fullpath).Length;
f.Size = length;
f.Updated = DateTime.Now;
f.UpdatedOnDiskUTC = File.GetLastWriteTimeUtc(fullpath);
f.CreatedOnDiskUTC = File.GetCreationTimeUtc(fullpath);
db.Update(f);
}
catch (WebException e)
{
Console.Error.Write("Problem connecting to Glasscubes");
Console.Error.Write(e);
}
}
}
private void DeleteDiskItem(DiskItem i)
{
db.Delete(i);
var path = Path.Combine(GetRootPath(i), i.FileName);
if (File.Exists(path) && !i.Folder)
{
File.Delete(path);
}
if (Directory.Exists(path) && i.Folder)
{
Directory.Delete(path, true);
}
}
private string GetRootPath(DiskItem f, string path)
{
if (f.FolderId > 0)
{
DiskItem parent = db.Find <DiskItem>(f.FolderId);
return(GetRootPath(parent, Path.Combine(parent.Path, path)));
}
Workspace w = db.Find <Workspace>(f.WorkspaceId);
path = Path.Combine(rootDir, w.Name, path);
return(path);
}
public TestResult Execute(DiskItem contextItem, DiskItem[] allItems)
{
var duplicates = allItems.Where(x =>
x.Item.DatabaseName.Equals(contextItem.Item.DatabaseName, StringComparison.Ordinal) &&
x.Item.ID.Equals(contextItem.Item.ID, StringComparison.Ordinal) &&
x.FullPath != contextItem.FullPath)
.ToArray();
if (duplicates.Length == 0)
{
return(new TestResult(this, true));
}
return(new TestResult(this, false, contextItem.Item.ID + " was present in other files: " + string.Join(",", duplicates.Select(x => x.FullPath))));
}
public async Task <bool> PlayPlaylistAsync(PlayList playlist)
{
if (playlist == null)
{
return(false);
}
_currentPlayList = playlist;
if (_currentPlayList.DiskItems.Count == 0)
{
return(false);
}
_currentlyPlaying = _currentPlayList.DiskItems.FirstOrDefault();
return(await PlayDiskItemAsync(_currentlyPlaying));
}
// We need to check if this GCAction event has occured from a user or from the DownloadMinitor (me) i.e. event arising from files being downloaded/deleted/rename etc on Glasscubes
private bool ThisIsFromMe(GCAction action)
{
Object o = FindDiskItem(action);
if (o == null)
{
return(false);
}
if (o is DiskItem)
{
DiskItem di = (DiskItem)o;
// Test to see if its the same file/folder or a different version
FileInfo fi = new FileInfo(action.Path);
if (di.Folder)
{
// fuzzy timecheck
TimeSpan span = fi.LastAccessTimeUtc - di.UpdatedOnDiskUTC;
if (span.TotalMilliseconds < FUZZY_TIMESTAMP_DIFF_MS)
{
return(true);
}
}
else
{
var length = fi.Length;
if (di.Size == length)
{
// fuzzy timecheck
TimeSpan span = fi.LastAccessTimeUtc - di.UpdatedOnDiskUTC;
if (span.Milliseconds < FUZZY_TIMESTAMP_DIFF_MS)
{
return(true);
}
}
}
}
if (o is Workspace)
{
return(true);
}
return(false);
}
public TestResult Execute(DiskItem contextItem, DiskItem[] allItems)
{
var parent = Path.GetDirectoryName(contextItem.FullPath) + PathUtils.Extension;
if (File.Exists(parent))
{
var parentItem = allItems.First(x => x.FullPath.Equals(parent, StringComparison.Ordinal));
bool result = parentItem.Item.ID.Equals(contextItem.Item.ParentID, StringComparison.Ordinal);
if(result) return new TestResult(this, true);
return new TestResult(this, false, string.Format("Parent ID: {0} did not match actual serialized parent ID {1}", contextItem.Item.ParentID, parentItem.Item.ID));
}
return new TestResult(this, true);
}
private void createChildFolders(DiskItem item, string path)
{
var folders = db.Query <DiskItem>("select * from DiskItem where FolderId = ? and Folder = ?", item.Id, true);
foreach (var f in folders)
{
string newPath = Path.Combine(path, f.FileName);
System.IO.Directory.CreateDirectory(newPath);
//f.Path = newPath;
f.Path = f.FileName;
f.Updated = DateTime.Now;
f.UpdatedOnDiskUTC = Directory.GetLastWriteTimeUtc(newPath);
f.CreatedOnDiskUTC = Directory.GetCreationTimeUtc(newPath);
db.Update(f);
createChildFolders(f, newPath);
}
}
public TestResult Execute(DiskItem contextItem, DiskItem[] allItems)
{
if(!ID.IsID(contextItem.Item.ID))
return new TestResult(this, false, (contextItem.Item.ID ?? "null") + " is not a valid item ID.");
if(ID.Parse(contextItem.Item.ID) == ID.Null)
return new TestResult(this, false, "Item ID was the null ID.");
if (!ID.IsID(contextItem.Item.ParentID))
return new TestResult(this, false, (contextItem.Item.ParentID ?? "null") + " is not a valid parent ID.");
if (ID.Parse(contextItem.Item.ParentID) == ID.Null && contextItem.Item.ID != ItemIDs.RootID.ToString())
return new TestResult(this, false, "Parent ID was the null ID.");
if (!ID.IsID(contextItem.Item.TemplateID))
return new TestResult(this, false, (contextItem.Item.TemplateID ?? "null") + " is not a valid template ID.");
if (ID.Parse(contextItem.Item.TemplateID) == ID.Null)
return new TestResult(this, false, "Template ID was the null ID.");
if (!ID.IsID(contextItem.Item.MasterID))
return new TestResult(this, false, (contextItem.Item.MasterID ?? "null") + " is not a valid master ID.");
if(string.IsNullOrWhiteSpace(contextItem.Item.TemplateName))
return new TestResult(this, false, "Template name was null or empty.");
if (string.IsNullOrWhiteSpace(contextItem.Item.ItemPath))
return new TestResult(this, false, "Path was null or empty.");
if (string.IsNullOrWhiteSpace(contextItem.Item.DatabaseName))
return new TestResult(this, false, "Database was null or empty.");
if (string.IsNullOrWhiteSpace(contextItem.Item.Name))
return new TestResult(this, false, "Item name was null or empty.");
if (contextItem.Item.SharedFields.Count == 0)
{
if (contextItem.Item.Versions.Count == 0 || contextItem.Item.Versions[0].Fields.Count == 0)
return new TestResult(this, false, "Item had no shared fields and no versioned fields. While this can be valid, it is highly unusual.");
}
return new TestResult(this, true);
}
public async Task <bool> DownloadItem(DiskItem diskItem)
{
if (diskItem == null)
{
return(false);
}
var picker = new FolderPicker
{
ViewMode = PickerViewMode.Thumbnail,
SuggestedStartLocation = PickerLocationId.PicturesLibrary
};
if (diskItem.DisplayName.Contains("."))
{
picker.FileTypeFilter.Add($".{diskItem.DisplayName.Split('.').LastOrDefault()}");
}
else
{
FileTypes.Extensions.Keys.ToList().ForEach(e => picker.FileTypeFilter.Add(e));
}
var folder = await picker.PickSingleFolderAsync();
if (folder != null)
{
if (!diskItem.IsFolder)
{
var downloadUrl = await Client.GetDownloadURL(diskItem.Path);
if (downloadUrl.IsError())
{
return(false);
}
var result = await Client.DownLoadFileAsync(downloadUrl, folder, diskItem.DisplayName, new CancellationTokenSource().Token);
return(!result.IsError());
}
}
return(false);
}
private void NewFileAdded(DiskItem i)
{
i.Updated = DateTime.Now;
if (i.Folder)
{
string newPath = Path.Combine(GetRootPath(i), i.FileName);
System.IO.Directory.CreateDirectory(newPath);
// i.Path = newPath;
i.Path = i.FileName;
i.CreatedOnDiskUTC = Directory.GetCreationTimeUtc(newPath);
i.UpdatedOnDiskUTC = Directory.GetLastAccessTimeUtc(newPath);
db.Insert(i);
}
else
{
db.Insert(i);
DownLoadFile(i);
}
}
public TestResult Execute(DiskItem contextItem, DiskItem[] allItems)
{
var parent = Path.GetDirectoryName(contextItem.FullPath) + PathUtils.Extension;
if (File.Exists(parent))
{
var parentItem = allItems.First(x => x.FullPath.Equals(parent, StringComparison.Ordinal));
bool result = parentItem.Item.ID.Equals(contextItem.Item.ParentID, StringComparison.Ordinal);
if (result)
{
return(new TestResult(this, true));
}
return(new TestResult(this, false, string.Format("Parent ID: {0} did not match actual serialized parent ID {1}", contextItem.Item.ParentID, parentItem.Item.ID)));
}
return(new TestResult(this, true));
}
public async Task <bool> PlayDiskItemAsync(DiskItem diskItem)
{
if (diskItem == null || !diskItem.MimeType.StartsWith("audio") && !diskItem.MimeType.StartsWith("video"))
{
return(false);
}
var url = await DiskService.Client.GetDownloadURL(diskItem.Path);
if (url.IsError())
{
return(false);
}
var nameParts = diskItem.DisplayName.Split('.');
_currentlyPlaying = diskItem;
PlayByURL(new Uri(url.URL), string.Join(" ", nameParts.Take(nameParts.Length - 1)), _currentlyPlaying.MimeType.StartsWith("audio"));
return(true);
}
private async void _mediaPlayer_MediaEnded(MediaPlayer sender, object args)
{
if (_currentlyPlaying == null && sender.PlaybackSession.CanPause)
{
sender.Pause();
return;
}
if (_currentPlayList != null && _currentPlayList.DiskItems.Count > 0 && _currentPlayList.DiskItems.Contains(_currentlyPlaying))
{
var current = _currentPlayList.DiskItems.IndexOf(_currentlyPlaying);
if (current < 0)
{
sender.Pause();
return;
}
_currentlyPlaying = current < _currentPlayList.DiskItems.Count - 1 ?
_currentPlayList.DiskItems.Skip(current + 1).Take(1).FirstOrDefault() :
_currentPlayList.DiskItems.FirstOrDefault();
await PlayDiskItemAsync(_currentlyPlaying);
}
}
public TestResult Execute(DiskItem contextItem, DiskItem[] allItems)
{
// translate the full physical path into an item path
var mappedPath = PathUtils.MakeItemPath(contextItem.FullPath, _rootPath);
// if more than one item is in the same path with the same name, it will map something like "name_FDA63242325453" (guid)
// we want to strip the disambiguating GUID from the name, if it exists
var split = mappedPath.Split('_');
if (ShortID.IsShortID(split.Last()))
mappedPath = string.Join("_", split.Take(split.Length - 1));
if (_databaseName != null)
{
string dbPrefix = "/" + _databaseName;
if (mappedPath.StartsWith(dbPrefix, StringComparison.OrdinalIgnoreCase))
mappedPath = mappedPath.Substring(dbPrefix.Length);
}
// MakeItemPath seems to return paths in the format "//sitecore/foo" sometimes, let's normalize that
mappedPath = "/" + mappedPath.TrimStart('/');
// if we have a database name (e.g. we are pointing at a raw serialized root such as "serialization\master" instead of "serialization"), prepend to the mapped path
if (_databaseName != null)
{
mappedPath = "/" + _databaseName + mappedPath;
}
// compute the item reference path for the context item SyncItem
string syncItemReferencePath = new ItemReference(contextItem.Item.DatabaseName, contextItem.Item.ItemPath).ToString();
// ensure the ref path is prepended with /
syncItemReferencePath = "/" + syncItemReferencePath.TrimStart('/');
bool passed = mappedPath.Equals(syncItemReferencePath, StringComparison.OrdinalIgnoreCase);
if (passed) return new TestResult(this, true);
return new TestResult(this, false, string.Format("Physical: {0} != Serialized: {1}", mappedPath, syncItemReferencePath));
}
private bool DoesThisNeedUpdating(DiskItem i)
{
DiskItem di = db.Find <DiskItem>(i.Id);
if (di == null)
{
return(true);
}
switch (i.Action)
{
case "ADD":
return(false);
case "DELETE":
return(true);
case "UPDATED":
if (di.Updated != i.Updated ||
di.FileName != i.FileName ||
di.Version != i.Version ||
di.Size != i.Size)
{
return(true);
}
return(false);
case "RENAME":
if (di.FileName != i.FileName)
{
return(true);
}
return(false);
}
return(true);
}
private void DiskItemRenamed(DiskItem i)
{
try
{
DiskItem orig = db.Find <DiskItem>(i.Id);
string root = GetRootPath(orig);
string newFullPath = Path.Combine(root, i.FileName);
if (i.Folder)
{
Directory.Move(Path.Combine(root, orig.FileName), newFullPath);
}
else
{
File.Move(Path.Combine(root, orig.FileName), newFullPath);
}
//i.Path = Path.Combine(root, i.FileName).ToString();
i.Path = i.FileName;
DateTime now = DateTime.Now;
i.Updated = now;
if (i.Folder)
{
Directory.SetLastWriteTime(newFullPath, now);
i.UpdatedOnDiskUTC = Directory.GetLastWriteTimeUtc(newFullPath);
}
else
{
File.SetLastWriteTime(newFullPath, now);
i.UpdatedOnDiskUTC = File.GetLastWriteTimeUtc(newFullPath);
}
db.Update(i);
}
catch (SQLiteException e)
{
//TODO
}
}
public static SizableToolBar CreateToolBar(DiskItem item)
{
var bar = new SizableToolBar();
//bar.DataContext = item;
Binding itemsBinding = new Binding()
{
Source = item,
Path = new PropertyPath("SubItems"),
Mode = BindingMode.OneWay,
UpdateSourceTrigger = UpdateSourceTrigger.PropertyChanged
};
BindingOperations.SetBinding(bar, ToolBar.ItemsSourceProperty, itemsBinding);
return(bar);
/*var list = new ListView()
* {
* ItemsSource = item.SubItems
* };
* list.SelectionChanged += ToolbarListView_SelectionChanged;
* bar.Items.Add(list);*/
/*bar.Tag = item.ItemPath;
*
* bool containsThis = false;
* foreach (DiskItem d in Config.FolderToolBars)
* {
* if (d.ItemPath.ToLowerInvariant() == item.ItemPath.ToLowerInvariant())
* containsThis = true;
* }
* if (!containsThis)
* {
* Config.FolderToolBars.Add(item);
* return bar;
* }
* else
* return null;*/
}
public TestResult Execute(DiskItem contextItem, DiskItem[] allItems)
{
if (contextItem.Item.Versions.Count > 0) return new TestResult(this, true);
return new TestResult(this, false, "This item had no versions in any language. This can be valid, but is highly unusual.");
}
private Object FindParentDiskItem(GCAction action)
{
string[] directories = action.Path.Split(Path.DirectorySeparatorChar);
string path = "";
Workspace workspace = null;
DiskItem parent = null;
bool matchRoot = true;
bool matchWorkspace = false;
bool matchFoldersOrFiles = false;
int index = 1;
foreach (string p in directories)
{
if (path == "")
{
path = p + "\\";
}
else
{
path = Path.Combine(path, p);
}
if (matchRoot && path == rootDir)
{
matchRoot = false;
matchWorkspace = true;
}
else
if (matchWorkspace)
{
var wrs = from w in db.Table <Workspace>()
where w.Path.Equals(p)
select w;
if (wrs.Count() != 0)
{
workspace = wrs.FirstOrDefault <Workspace>();
}
// TODO no workspace?
matchWorkspace = false;
matchFoldersOrFiles = true;
}
else
if (matchFoldersOrFiles)
{
if (parent == null)
{
IEnumerable <DiskItem> d = db.Query <DiskItem>("select * from DiskItem where Path = ? and WorkspaceId = ?", p, workspace.Id);
DiskItem it = d.FirstOrDefault <DiskItem>();
if (it != null && index + 1 == directories.Length)
{
parent = it;
}
}
else
{
IEnumerable <DiskItem> d = db.Query <DiskItem>("select * from DiskItem where Path = ? and WorkspaceId = ? and FolderId = ? ", p, workspace.Id, parent.Id);
DiskItem item = d.FirstOrDefault <DiskItem>();
if (item != null && index + 1 == directories.Length)
{
parent = item;
}
}
}
index++;
}
if (parent != null)
{
return(parent);
}
if (workspace != null)
{
return(workspace);
}
return(null);
}
private void DoRenamed(GCAction action)
{
//Does it still exist?
if (!FileOrDirectoryExists(action.Path))
{
return;
}
if (ThisIsFromMe(action))
{
return;
}
Object o = FindDiskItem(action);
// We should already have this file in DB unless its a new folder thats just got renamed
if (!Directory.Exists(action.Path) && o == null)
{
return;
}
if (o == null)
{
// new folder
DoNew(action);
return;
}
// @GET
// @Path("/rename")
// @Produces(MediaType.APPLICATION_JSON)
// @Transactional
//public FileMetaUpdate rename(
// @QueryParam("apiId") String apiId,
// @QueryParam("key") String key,
// @QueryParam("docId") Long docId,
// @QueryParam("filename") String fileName,
// @QueryParam("folder") Boolean isFolder) {
if (o is DiskItem)
{
DiskItem item = (DiskItem)o;
var request = newReq("/rest/sync/rename");
SetUpRequest(request);
request.AddParameter("docId", item.Id);
request.AddParameter("folder", item.Folder);
request.AddParameter("filename", Path.GetFileName(action.Path));
var response = client.Execute <NewFileMeta>(request);
if (response.ResponseStatus == ResponseStatus.Completed)
{
NewFileMeta meta = response.Data;
if (meta.success)
{
// what do if anything?
return;
}
}
Console.Error.Write("Could not rename file ? ", action.Path);
}
// we do nothing if workspace
Console.Error.Write("Workspace NOT being renamed ? ", action.Path);
}
public ItemTestResult(DiskItem item, TestResultCollection results)
{
Item = item;
Results = results;
}
public ItemTestResult(DiskItem item, TestResultCollection results)
{
Item = item;
Results = results;
}
