private void CreateItems()
{
var item = TreeView.SelectedItem as ItemTreeViewItem;
if (item == null)
{
return;
}
var databaseName = item.Item.ItemUri.DatabaseName;
var logWindow = new ProjectLogWindow
{
Maximum = createItems.Count
};
logWindow.AutoStart = delegate
{
var iterator = new ElementIterator <CreateItem>(createItems);
iterator.Process = delegate(CreateItem element)
{
if (!element.IsChecked)
{
logWindow.Increment();
iterator.Next();
return;
}
if (element.ProjectItem == null)
{
element.ProjectItem = Add(element);
}
var projectItem = element.ProjectItem;
ProcessedEventHandler callback = delegate(object sender, ProcessedEventArgs args)
{
WriteResult(logWindow, projectItem, args);
logWindow.Increment();
iterator.Next();
};
element.Handler.Handle(databaseName, projectItem, element.ItemPath, callback);
};
iterator.Finish = delegate
{
logWindow.Write(Rocks.Resources.Finished, string.Empty, string.Empty);
logWindow.Finish();
};
iterator.Start();
};
AppHost.Shell.ShowDialog(logWindow);
SaveProjects();
}
public abstract void Update([NotNull] ProcessedEventHandler callback);
protected virtual void Handle([NotNull] NewItemWizardPipeline pipeline, [NotNull] DatabaseName databaseName, [NotNull] ProjectItem projectItem, [NotNull] string itemPath, [NotNull] ProcessedEventHandler callback)
{
Debug.ArgumentNotNull(pipeline, nameof(pipeline));
Debug.ArgumentNotNull(databaseName, nameof(databaseName));
Debug.ArgumentNotNull(projectItem, nameof(projectItem));
Debug.ArgumentNotNull(itemPath, nameof(itemPath));
Debug.ArgumentNotNull(callback, nameof(callback));
var projectFile = (ProjectFileItem)projectItem;
var site = projectItem.Project.Site;
if (site == null)
{
return;
}
var databaseUri = new DatabaseUri(site, databaseName);
var name = Path.GetFileNameWithoutExtension(projectItem.Path);
GetItemsCompleted <ItemPath> completed = delegate(IEnumerable <ItemPath> items)
{
if (!items.Any())
{
callback(this, new ProcessedEventArgs(Resources.PathBasedFileItemHandler_Create_failed, Resources.PathBasedFileItemHandler_Create_Path_was_not_created));
return;
}
// create item
var parentUri = items.First().ItemUri;
var templateuri = new ItemUri(databaseUri, TemplateId);
var itemUri = site.DataService.AddFromTemplate(parentUri, templateuri, name);
UpdateFields(pipeline, projectItem, itemUri);
// done
projectFile.Items.Add(itemUri);
callback(this, new ProcessedEventArgs(Resources.PathBasedFileItemHandler_Create_created, Path.GetDirectoryName(itemPath) + @"/" + name));
Notifications.RaiseItemAdded(this, new ItemVersionUri(itemUri, LanguageManager.CurrentLanguage, Version.Latest), parentUri);
if (AppHost.CurrentContentTree != null)
{
AppHost.CurrentContentTree.Locate(itemUri);
}
};
site.DataService.CreateItemPath(databaseUri, (Path.GetDirectoryName(itemPath) ?? string.Empty).Replace('\\', '/'), completed);
}
public abstract void Commit([NotNull] ProcessedEventHandler callback);
public override void Handle(DatabaseName databaseName, ProjectItem projectItem, string itemPath, ProcessedEventHandler callback)
{
Assert.ArgumentNotNull(databaseName, nameof(databaseName));
Assert.ArgumentNotNull(projectItem, nameof(projectItem));
Assert.ArgumentNotNull(itemPath, nameof(itemPath));
Assert.ArgumentNotNull(callback, nameof(callback));
var projectFile = (ProjectFileItem)projectItem;
var serverPath = @"/" + projectFile.Path.Replace('\\', '/');
var site = projectItem.Project.Site;
if (site == null)
{
return;
}
var databaseUri = new DatabaseUri(site, databaseName);
if (string.IsNullOrEmpty(itemPath))
{
itemPath = GetItemPath(projectItem);
}
var name = Path.GetFileNameWithoutExtension(projectItem.Path) ?? string.Empty;
GetItemsCompleted <ItemPath> completed = delegate(IEnumerable <ItemPath> items)
{
if (!items.Any())
{
callback(this, new ProcessedEventArgs(Resources.PathBasedFileItemHandler_Create_failed, Resources.PathBasedFileItemHandler_Create_Path_was_not_created));
return;
}
// create item
var parentUri = items.First().ItemUri;
var templateuri = new ItemUri(databaseUri, TemplateId);
var itemUri = site.DataService.AddFromTemplate(parentUri, templateuri, name);
// set "Path" field
var pathField = new Field
{
Value = serverPath,
HasValue = true
};
pathField.FieldUris.Add(new FieldUri(new ItemVersionUri(itemUri, LanguageManager.CurrentLanguage, Version.Latest), FieldId));
var fields = new List <Field>
{
pathField
};
site.DataService.Save(databaseName, fields);
// done
projectFile.Items.Add(itemUri);
callback(this, new ProcessedEventArgs(Resources.PathBasedFileItemHandler_Create_created, Path.GetDirectoryName(itemPath) + @"/" + name));
Notifications.RaiseItemAdded(this, new ItemVersionUri(itemUri, LanguageManager.CurrentLanguage, Version.Latest), parentUri);
if (AppHost.CurrentContentTree != null)
{
AppHost.CurrentContentTree.Locate(itemUri);
}
};
site.DataService.CreateItemPath(databaseUri, (Path.GetDirectoryName(itemPath) ?? string.Empty).Replace('\\', '/'), completed);
}
public override void Commit(ProcessedEventHandler callback)
{
Assert.ArgumentNotNull(callback, nameof(callback));
if (IsAdded && !IsValid)
{
Project.Remove(this);
callback(this, new ProcessedEventArgs(Resources.ProjectFileItem_Commit_deleted));
return;
}
var fileInfo = new FileInfo(AbsoluteFileName);
var fileContent = string.Empty;
var action = string.Empty;
if (IsValid)
{
fileContent = System.Convert.ToBase64String(System.IO.File.ReadAllBytes(AbsoluteFileName));
}
else
{
action += Resources.ProjectFileItem_Commit__delete;
}
switch (ConflictResolution)
{
case ConflictResolution.NotResolved:
callback(this, new ProcessedEventArgs(Resources.ProjectFileItem_Commit_skipped, Resources.ProjectFileItem_Commit_Conflict_not_resolved_));
return;
case ConflictResolution.UseLocalVersion:
action += Resources.ProjectFileItem_Commit__overwrite;
break;
case ConflictResolution.UseServerVersion:
callback(this, new ProcessedEventArgs(Resources.ProjectFileItem_Commit_skipped, Resources.ProjectFileItem_Commit_Use_Update_command_to_overwrite_local_version_with_server_version));
return;
}
CommitCompleted process = delegate(string result, long serverTimestamp, long serverFileSize)
{
var processed = new ProcessedEventArgs(result);
switch (result)
{
case "ok":
processed.Text = IsAdded ? Resources.ProjectFileItem_Commit_added : Resources.ProjectFileItem_Commit_committed;
FileSize = fileInfo.Length;
FileTimestamp = fileInfo.LastWriteTimeUtc.Ticks;
ServerTimestamp = serverTimestamp;
ServerFileSize = serverFileSize;
ConflictResolution = ConflictResolution.None;
break;
case "deleted":
Project.Remove(this);
processed.Text = Resources.ProjectFileItem_Commit_deleted;
break;
case "conflict":
ServerTimestamp = serverTimestamp;
ServerFileSize = serverFileSize;
ConflictResolution = ConflictResolution.NotResolved;
processed.Text = Resources.ProjectFileItem_Commit_conflict;
break;
}
callback(this, processed);
};
var site = Project.Site;
if (site != null)
{
site.DataService.Commit(File, fileContent, ServerTimestamp, ServerFileSize, action, false, process);
}
}
public override void Update(ProcessedEventHandler callback)
{
Assert.ArgumentNotNull(callback, nameof(callback));
var action = string.Empty;
switch (ConflictResolution)
{
case ConflictResolution.NotResolved:
callback(this, new ProcessedEventArgs(Resources.ProjectFileItem_Update_skipped, Resources.ProjectFileItem_Update_Conflict_not_resolved));
return;
case ConflictResolution.UseLocalVersion:
callback(this, new ProcessedEventArgs(Resources.ProjectFileItem_Update_skipped, Resources.ProjectFileItem_Update_Use_Commit_command_to_overwrite_server_version_with_local_version));
return;
case ConflictResolution.UseServerVersion:
action += Resources.ProjectFileItem_Update__revert;
break;
}
UpdateCompleted process = delegate(string result, ref byte[] file, long serverTimestamp, long serverFileSize)
{
var processed = new ProcessedEventArgs(result);
switch (result)
{
case "ok":
if ((IsModified || IsAdded) && action.IndexOf(Resources.ProjectFileItem_Update_revert, StringComparison.InvariantCultureIgnoreCase) < 0)
{
ServerTimestamp = serverTimestamp;
ServerFileSize = serverFileSize;
ConflictResolution = ConflictResolution.NotResolved;
processed.Text = Resources.ProjectFileItem_Update_conflict;
processed.Comment = Resources.ProjectFileItem_Update_Local_file_has_been_modified;
}
else
{
processed.Text = Resources.ProjectFileItem_Update_updated;
WriteFile(ref file, serverTimestamp, serverFileSize, processed);
ConflictResolution = ConflictResolution.None;
}
break;
case "deleted":
processed.Text = Resources.ProjectFileItem_Update_deleted;
DeleteFile(processed, serverTimestamp, serverFileSize);
break;
case "conflict":
ServerTimestamp = serverTimestamp;
ServerFileSize = serverFileSize;
ConflictResolution = ConflictResolution.NotResolved;
processed.Text = Resources.ProjectFileItem_Update_conflict;
break;
case "unchanged":
processed.Ignore = true;
break;
}
callback(this, processed);
};
Project.Site.DataService.Update(File, ServerTimestamp.ToString(CultureInfo.InvariantCulture), ServerFileSize, action, process);
}
public abstract void Handle(DatabaseName databaseName, ProjectItem projectItem, string itemPath, ProcessedEventHandler callback);
