private async Task SaveDocumentAsync(JsonDocumentModel document, bool saveAs)
{
if (!document.HasFileLocation || saveAs)
{
var fileName = document.HasFileLocation ?
Path.GetFileNameWithoutExtension(document.FilePath) + ".json" :
Strings.DefaultFileName + ".json";
var result = await Messenger.Default.SendAsync(new SaveJsonDocumentMessage(fileName));
if (result.Success)
{
AddRecentFile(result.Result);
document.FilePath = result.Result;
}
else
{
return;
}
}
await RunTaskAsync(async token =>
{
await document.SaveAsync(true);
});
}
private async Task <bool> SaveDocumentAsync(JsonDocumentModel document)
{
if (_strictEditingMode)
{
var errors = await document.Data.ValidateAsync();
if (errors.Count() > 0)
{
await Messenger.Default.SendAsync(
new TextMessage(
string.Format(Strings.MessageNotValidDocumentText, document.DisplayTitle, errors),
Strings.MessageNotValidDocumentTitle));
return(false);
}
else
{
await SaveDocumentAsync(document, false);
}
}
await SaveDocumentAsync(document, false);
return(true);
}
private void AddDocument(JsonDocumentModel document)
{
Documents.Add(document);
SelectedDocument = document;
document.UndoRedoManager.PropertyChanged += UndoRedoManagerOnPropertyChanged;
}
/// <summary>Opens a document from a given file name. </summary>
/// <param name="fileName">The file name. </param>
/// <param name="isReadOnly">The value indicating whether the document can be changed. </param>
/// <returns>The task. </returns>
public async Task OpenDocumentAsync(string fileName, bool isReadOnly)
{
var existingDocument = Documents.SingleOrDefault(d => d.FilePath == fileName);
if (existingDocument != null)
{
SelectedDocument = existingDocument;
}
else
{
await RunTaskAsync(async token =>
{
var schemaPath = JsonDocumentModel.GetDefaultSchemaPath(fileName);
if (!File.Exists(schemaPath))
{
var result = await Messenger.Default.SendAsync(new OpenJsonDocumentMessage(Strings.OpenJsonSchemaDocumentDialog));
if (!result.Success)
{
return;
}
schemaPath = result.Result;
}
var document = await JsonDocumentModel.LoadAsync(fileName, schemaPath, ServiceLocator.Default.Resolve <IDispatcher>());
document.IsReadOnly = isReadOnly;
AddDocument(document);
AddRecentFile(fileName);
});
}
}
/// <summary>Creates a new document from a given JSON schema. </summary>
/// <param name="schemaPath">The path of the JSON schema file. </param>
/// <returns>The task. </returns>
public async Task CreateDocumentAsync(string schemaPath)
{
await RunTaskAsync(async token =>
{
var document = await JsonDocumentModel.CreateAsync(schemaPath, ServiceLocator.Default.Resolve <IDispatcher>());
AddDocument(document);
});
}
private async Task SaveDocumentSchemaAsAsync(JsonDocumentModel document)
{
var fileName = Path.GetFileNameWithoutExtension(document.FilePath) + ".schema.json";
var result = await Messenger.Default.SendAsync(new SaveJsonDocumentMessage(fileName));
if (result.Success)
{
await RunTaskAsync(async token =>
{
await Task.Run(() => File.WriteAllText(result.Result, document.Data.Schema.ToJson()), token);
});
}
}
/// <summary>Opens a document from a given file name. </summary>
/// <param name="fileName">The file name. </param>
/// <param name="isReadOnly">The value indicating whether the document can be changed. </param>
/// <returns>The task. </returns>
public async Task OpenDocumentAsync(string fileName, bool isReadOnly)
{
var existingDocument = Documents.SingleOrDefault(d => d.FilePath == fileName);
if (existingDocument != null)
{
SelectedDocument = existingDocument;
}
else
{
await RunTaskAsync(async token =>
{
JsonDocumentModel document = null;
// First try to load the schema from the default location
var defaultSchemaPath = JsonDocumentModel.GetDefaultSchemaPath(fileName);
if (File.Exists(defaultSchemaPath))
{
document = await JsonDocumentModel.LoadAsync(fileName, defaultSchemaPath, ServiceLocator.Default.Resolve <IDispatcher>());
}
// If no schema was found, check for a "_schema" property on the document
if (document == null)
{
var schemaPropertyPath = JsonObjectModel.GetSchemaProperty(fileName);
if (!String.IsNullOrWhiteSpace(schemaPropertyPath) && File.Exists(schemaPropertyPath))
{
document = await JsonDocumentModel.LoadAsync(fileName, schemaPropertyPath, ServiceLocator.Default.Resolve <IDispatcher>());
}
}
// If no default schema or no schema property, prompt.
if (document == null)
{
var result = await Messenger.Default.SendAsync(new OpenJsonDocumentMessage(Strings.OpenJsonSchemaDocumentDialog));
if (!result.Success)
{
return;
}
document = await JsonDocumentModel.LoadAsync(fileName, result.Result, ServiceLocator.Default.Resolve <IDispatcher>());
}
document.IsReadOnly = isReadOnly;
AddDocument(document);
AddRecentFile(fileName);
});
}
}
private async Task ValidateDocumentAsync(JsonDocumentModel document)
{
var errors = await document.Data.ValidateAsync();
if (errors.Length == 0)
{
await Messenger.Default.SendAsync(
new TextMessage(string.Format(Strings.MessageValidDocumentText, document.DisplayTitle),
Strings.MessageValidDocumentTitle));
}
else
{
await Messenger.Default.SendAsync(
new TextMessage(
string.Format(Strings.MessageNotValidDocumentText, document.DisplayTitle, errors),
Strings.MessageNotValidDocumentTitle));
}
}
/// <summary>Closes the given document and saves it if needed. </summary>
/// <param name="document">The document to close. </param>
/// <returns>The task. </returns>
public async Task<bool> CloseDocumentAsync(JsonDocumentModel document)
{
if (document.UndoRedoManager.CanUndo)
{
var message = new TextMessage(string.Format(Strings.MessageSaveDocumentText, document.DisplayTitle),
Strings.MessageSaveDocumentTitle, MessageButton.YesNoCancel);
var result = await Messenger.Default.SendAsync(message);
if (result.Result == MessageResult.Cancel)
return false;
if (result.Result == MessageResult.Yes)
await SaveDocumentAsync(document);
}
RemoveDocument(document);
return true;
}
/// <summary>Opens a document from a given file name. </summary>
/// <param name="fileName">The file name. </param>
/// <param name="isReadOnly">The value indicating whether the document can be changed. </param>
/// <returns>The task. </returns>
public async Task OpenDocumentAsync(string fileName, bool isReadOnly)
{
var existingDocument = Documents.SingleOrDefault(d => d.FilePath == fileName);
if (existingDocument != null)
{
SelectedDocument = existingDocument;
}
else
{
await RunTaskAsync(async token =>
{
var schemaPath = JsonDocumentModel.GetDefaultSchemaPath(fileName);
var document = await JsonDocumentModel.LoadAsync(fileName, schemaPath, ServiceLocator.Default.Resolve <IDispatcher>());
document.IsReadOnly = isReadOnly;
AddDocument(document);
AddRecentFile(fileName);
});
}
}
/// <summary>Closes the given document and saves it if needed. </summary>
/// <param name="document">The document to close. </param>
/// <returns>The task. </returns>
public async Task <bool> CloseDocumentAsync(JsonDocumentModel document)
{
bool saveOk = true;
if (document.UndoRedoManager.CanUndo)
{
var message = new TextMessage(string.Format(Strings.MessageSaveDocumentText, document.DisplayTitle),
Strings.MessageSaveDocumentTitle, MessageButton.YesNoCancel);
var result = await Messenger.Default.SendAsync(message);
if (result.Result == MessageResult.Cancel)
{
return(false);
}
if (result.Result == MessageResult.Yes)
{
saveOk = await SaveDocumentAsync(document);
}
}
if (saveOk)
{
RemoveDocument(document);
}
if (_strictEditingMode && saveOk)
{
if (Documents.Count == 0)
{
Environment.Exit(0);
}
}
return(true);
}
private Task SaveDocumentAsAsync(JsonDocumentModel document)
{
return(SaveDocumentAsync(document, true));
}
private void RemoveDocument(JsonDocumentModel document)
{
Documents.Remove(document);
document.UndoRedoManager.PropertyChanged -= UndoRedoManagerOnPropertyChanged;
}
private Task SaveDocumentAsync(JsonDocumentModel document)
{
return SaveDocumentAsync(document, false);
}
