public void BeforePropertyChanged(IDataRecord record, string name, object previousValue, object nextValue)
{
if (IsUndoRedo)
{
return;
}
if (CurrentUndoGroupId == null || record is UndoItem || record is RedoItem)
{
return;
}
try
{
var undoItem = new UndoItem();
undoItem.Time = DateTime.Now;
undoItem.Group = CurrentUndoGroupId;
undoItem.DataRecordId = record.Identifier;
undoItem.Data = InvertJsonExtensions.SerializeObject(record).ToString();
undoItem.RecordType = record.GetType().AssemblyQualifiedName;
undoItem.Type = UndoType.Changed;
undoItem.Name = CurrentName;
UndoItems.Add(undoItem);
}
catch (Exception ex)
{
}
}
public void Commit()
{
_isCommiting = true;
if (!DirectoryInfo.Exists)
{
DirectoryInfo.Create();
}
foreach (var item in Cached)
{
//filename is calculated inside of the if scopes, because, Path.Combine seems to be a bottleneck. ECSDemoProject took around 4000 invokcations to this method and took average
//time of 1000ms to process all the Path.Combine.
if (Removed.Contains(item.Key))
{
var filename = Path.Combine(RecordsPath, item.Key + ".json");
if (File.Exists(filename))
{
File.Delete(filename);
}
}
else
{
if (item.Value.Changed)
{
var filename = Path.Combine(RecordsPath, item.Key + ".json");
var json = InvertJsonExtensions.SerializeObject(item.Value);
File.WriteAllText(filename, json.ToString(true));
}
item.Value.Changed = false;
}
}
_isCommiting = false;
}
public static TType Copy <TType>(this TType record) where TType : class, IDataRecord
{
var result = InvertJsonExtensions.DeserializeObject <TType>((string)InvertJsonExtensions.SerializeObject(record).ToString()) as TType;
result.Identifier = Guid.NewGuid().ToString();
return(result);
}
public virtual void Commit()
{
_isCommiting = true;
if (!DirectoryInfo.Exists)
{
DirectoryInfo.Create();
}
foreach (var item in Cached)
{
var filename = Path.Combine(RecordsPath, item.Key + ".json");
if (Removed.Contains(item.Key))
{
if (File.Exists(filename))
{
File.Delete(filename);
}
}
else
{
if (item.Value.Changed)
{
var json = InvertJsonExtensions.SerializeObject(item.Value);
File.WriteAllText(filename, json.ToString(true));
}
item.Value.Changed = false;
}
}
_isCommiting = false;
}
private IEnumerable <UFramePackageRevisionDescriptor> RequestPackageRevisionsByIds(IEnumerable <string> revisionsToRequest)
{
Thread.Sleep(300);
var text = Resources.Load <TextAsset>("Revisions");
var packs = InvertJsonExtensions.DeserializeObject <List <UFramePackageRevisionDescriptor> >(text.text).Where(r => revisionsToRequest.Contains(r.Id));
return(packs);
}
private List <UFramePackageDescriptor> RequestLatestPackages()
{
//TODO KOINONIA: make request to web... should block the thread?
Thread.Sleep(300);
var text = Resources.Load <TextAsset>("Package");
var packs = InvertJsonExtensions.DeserializeObject <List <UFramePackageDescriptor> >(text.text);
return(packs);
}
private string RequestPackageRevisionDescriptorById(string id)
{
//TODO KOINONIA: make request to web... should block the thread?
Thread.Sleep(300);
var text = Resources.Load <TextAsset>("Revisions");
var packs = InvertJsonExtensions.DeserializeObject <List <UFramePackageRevisionDescriptor> >(text.text);
var pack = packs.FirstOrDefault(p => p.Id == id);
return(InvertJsonExtensions.SerializeObject(pack));
}
public string RequestPackageRevisionByPackageIdAndTag(string packageId, string tag)
{
//TODO KOINONIA: make request to web... should block the thread?
Thread.Sleep(300);
var text = Resources.Load <TextAsset>("Revisions");
var packs = InvertJsonExtensions.DeserializeObject <List <UFramePackageRevisionDescriptor> >(text.text);
var pack = packs.FirstOrDefault(p => p.VersionTag == tag && p.PackageId == packageId);
return(InvertJsonExtensions.SerializeObject(pack));
}
public IDataRecord ImportType(Type type, JSONClass cls)
{
var node = InvertJsonExtensions.DeserializeObject(type, cls) as IDataRecord;
if (node != null)
{
Repository.Add(node);
}
return(node);
}
private string ExportItems(List <IDataRecord> items, IRepository graph, uFrameExport export)
{
var repo = graph as TypeDatabase;
if (repo == null)
{
throw new Exception("Couldn't export, must be TypeDatabase");
}
var actualItems = items;
var ids = items.Select(p => p.Identifier).ToArray();
foreach (var record in graph.AllOf <IDataRecord>())
{
if (record is Workspace)
{
continue;
}
if (!record.ForeignKeys.Any())
{
continue;
}
if (record.ForeignKeys.All(x => ids.Any(p => p != null && x != null && (p == x || p.StartsWith(x)))))
{
if (!actualItems.Contains(record))
{
actualItems.Add(record);
}
}
}
actualItems.RemoveAll(p => p.Identifier.Contains(":"));
export.Repositories = actualItems.GroupBy(p => p.GetType()).Select(p => new ExportedRepository()
{
Records = p.Select(x => new ExportedRecord()
{
Data = InvertJsonExtensions.SerializeObject(x).ToString(true),
Identifier = x.Identifier
}).ToList(),
Type = p.Key.FullName
}).ToList();
var config = Container.Resolve <IGraphConfiguration>();
var generators = InvertGraphEditor.GetAllFileGenerators(config,
actualItems.ToArray(), true);
export.CodeFiles = generators.Where(p => File.Exists(p.SystemPath)).Select(p => new ExportedCode()
{
Code = File.ReadAllText(p.SystemPath),
RelativePath = p.AssetPath.Replace(config.CodeOutputPath, "")
}).ToList();
var contents = InvertJsonExtensions.SerializeObject(export).ToString(true);
return(contents);
}
public UFramePackageDescriptor GetPackageDescriptorById(string id)
{
if (KoinoniaSystem.IsRemoteServerAvailable && CachedPackageDescriptorNeedsUpdate(id))
{
var json = RequestPackageDescriptorById(id);
var descriptor = InvertJsonExtensions.DeserializeObject <UFramePackageDescriptor>(json);
UpdateCacheWithPackageDescriptor(descriptor);
return(descriptor);
}
return(Cache.All <UFramePackageDescriptor>().FirstOrDefault(d => d.Id == id));
}
public List <ExportedRepository> Export()
{
var list = Repositories.Select(p => new ExportedRepository()
{
Records = p.Value.GetAll().Select(record => new ExportedRecord()
{
Data = InvertJsonExtensions.SerializeObject(record).ToString(true),
Identifier = record.Identifier
}).ToList(),
Type = p.Key.FullName
}).ToList();
return(list);
}
public UFramePackageRevisionDescriptor GetRevisionDescriptorByPackageIdAndTag(string packageId, string tag)
{
var possibleRevision =
Cache.All <UFramePackageRevisionDescriptor>().FirstOrDefault(r => r.PackageId == packageId && r.VersionTag == tag);
if (possibleRevision == null || CachedRevisionDescriptorNeedsUpdate(possibleRevision.Id))
{
var json = RequestPackageRevisionByPackageIdAndTag(packageId, tag);
var descriptor = InvertJsonExtensions.DeserializeObject <UFramePackageRevisionDescriptor>(json);
UpdateCacheWithPackageRevisionDescriptor(descriptor);
return(descriptor);
}
return(possibleRevision);
}
private void LoadRecord(FileInfo file)
{
if (Cached.ContainsKey(Path.GetFileNameWithoutExtension(file.Name)))
{
return;
}
var record = InvertJsonExtensions.DeserializeObject(For, JSON.Parse(File.ReadAllText(file.FullName))) as IDataRecord;
if (record != null)
{
record.Repository = this.Repository;
Cached.Add(record.Identifier, record);
record.Changed = false;
}
}
public void Import(ExportedRecord record)
{
LoadRecordsIntoCache();
if (Cached.ContainsKey(record.Identifier))
{
InvertJsonExtensions.DeserializeExistingObject(Cached[record.Identifier],
JSON.Parse(record.Data).AsObject);
}
else
{
var dataRecord = InvertJsonExtensions.DeserializeObject(For, JSON.Parse(record.Data)) as IDataRecord;
if (dataRecord != null)
{
Add(dataRecord);
}
}
}
public void Execute(PasteCommand command)
{
var copiedNodes = CopiedNodes.ToArray();
foreach (var item in copiedNodes)
{
var filter = item as IGraphFilter;
if (filter != null)
{
CopiedNodes.AddRange(filter.FilterItems.Where(p => p.Node != item));
}
}
var offset = command.Position - CopiedNodes.Last().Position;
foreach (var item in CopiedNodes)
{
var node = item.Node;
var repository = node.Repository;
var nodeJson = InvertJsonExtensions.SerializeObject(node);
var copiedNode = InvertJsonExtensions.DeserializeObject(node.GetType(), nodeJson) as GraphNode;
copiedNode.Identifier = Guid.NewGuid().ToString();
copiedNode.Name += "_Copy";
copiedNode.Graph = InvertGraphEditor.CurrentDiagramViewModel.GraphData;
repository.Add(copiedNode);
foreach (var child in node.GraphItems.ToArray())
{
if (child == node)
{
continue;
}
var childJson = InvertJsonExtensions.SerializeObject(child);
var copiedChild = InvertJsonExtensions.DeserializeObject(child.GetType(), childJson) as IDiagramNodeItem;
copiedChild.Identifier = Guid.NewGuid().ToString();
copiedChild.Node = copiedNode;
repository.Add(copiedChild);
}
//item.GetPropertiesByAttribute<>()
InvertGraphEditor.CurrentDiagramViewModel.GraphData.CurrentFilter.ShowInFilter(copiedNode,
item.Position + offset);
}
}
public void Execute(RedoCommand command)
{
IsUndoRedo = true;
Repository = Container.Resolve <IRepository>();
var redoGroup = Repository.All <RedoItem>().GroupBy(p => p.Group).LastOrDefault();
if (redoGroup == null)
{
return;
}
foreach (var redoItem in redoGroup)
{
// Create redo item
var undoItem = InvertJsonExtensions.DeserializeObject(typeof(UndoItem), JSON.Parse(redoItem.UndoData)) as UndoItem;
if (redoItem.Type == UndoType.Inserted)
{
var record = Repository.GetById <IDataRecord>(redoItem.DataRecordId);
Repository.Remove(record);
}
else if (redoItem.Type == UndoType.Removed)
{
var obj = InvertJsonExtensions.DeserializeObject(Type.GetType(redoItem.RecordType), JSON.Parse(redoItem.Data).AsObject) as IDataRecord;
Repository.Add(obj);
}
else
{
var record = Repository.GetById <IDataRecord>(redoItem.DataRecordId);
// We don't want to signal any events on deserialization
record.Repository = null;
InvertJsonExtensions.DeserializeExistingObject(record, JSON.Parse(redoItem.Data).AsObject);
record.Changed = true;
record.Repository = Repository;
}
Repository.Remove(redoItem);
Repository.Add(undoItem);
}
IsUndoRedo = false;
Repository.Commit();
}
public void Execute(ImportCommand command)
{
var fileDialog = new ShowOpenFileDialog()
{
Extension = "ufdata",
Title = "Import"
};
this.Execute(fileDialog);
var file = fileDialog.Result;
var uFrameExport = InvertJsonExtensions.DeserializeObject <uFrameExport>(File.ReadAllText(file));
if (uFrameExport != null)
{
try
{
DatabaseService.SilentMode = true;
var currentConfig = Container.Resolve <IGraphConfiguration>();
var repository = Container.Resolve <IRepository>() as TypeDatabase;
if (repository != null)
{
repository.Import(uFrameExport.Repositories);
}
foreach (var codeFile in uFrameExport.CodeFiles)
{
var path = Path.Combine(Application.dataPath.Substring(0, Application.dataPath.Length - 7),
currentConfig.CodeOutputPath + codeFile.RelativePath);
var dir = Path.GetDirectoryName(path);
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
File.WriteAllText(path, UpdateNamespace(codeFile.Code, currentConfig.Namespace));
}
}
finally
{
DatabaseService.SilentMode = false;
}
}
}
public void RecordRemoved(IDataRecord record)
{
if (IsUndoRedo)
{
return;
}
if (CurrentUndoGroupId == null || record is UndoItem || record is RedoItem)
{
return;
}
var undoItem = new UndoItem();
undoItem.Time = DateTime.Now;
undoItem.Group = CurrentUndoGroupId;
undoItem.DataRecordId = record.Identifier;
undoItem.Data = InvertJsonExtensions.SerializeObject(record).ToString();
undoItem.RecordType = record.GetType().AssemblyQualifiedName;
undoItem.Name = CurrentName;
undoItem.Type = UndoType.Removed;
UndoItems.Add(undoItem);
}
private void LoadRecord(string file)
{
if (Cached.ContainsKey(Path.GetFileNameWithoutExtension(file)))
{
return;
}
try
{
var record = InvertJsonExtensions.DeserializeObject(For, JSON.Parse(ReadFile(file))) as IDataRecord;
if (record != null)
{
record.Repository = this.Repository;
Cached.Add(record.Identifier, record);
record.Changed = false;
}
}
catch (Exception ex)
{
throw new Exception(string.Format("Error parsing file {0}", file), ex);
}
}
public void Execute(UndoCommand command)
{
Repository = Container.Resolve <IRepository>();
var undoGroup = Repository.All <UndoItem>().GroupBy(p => p.Group).LastOrDefault();
if (undoGroup == null)
{
return;
}
IsUndoRedo = true;
try
{
foreach (var undoItem in undoGroup)
{
// Create redo item
var redoItem = new RedoItem();
redoItem.Data = undoItem.Data;
redoItem.Group = undoItem.Group;
redoItem.DataRecordId = undoItem.DataRecordId;
redoItem.Name = undoItem.Name;
redoItem.Time = undoItem.Time;
redoItem.Type = undoItem.Type;
redoItem.RecordType = undoItem.RecordType;
redoItem.UndoData = InvertJsonExtensions.SerializeObject(undoItem).ToString();
if (undoItem.Type == UndoType.Inserted)
{
var record = Repository.GetById <IDataRecord>(undoItem.DataRecordId);
redoItem.Data = InvertJsonExtensions.SerializeObject(record).ToString();
Repository.Remove(record);
redoItem.Type = UndoType.Removed;
}
else if (undoItem.Type == UndoType.Removed)
{
var obj =
InvertJsonExtensions.DeserializeObject(Type.GetType(undoItem.RecordType),
JSON.Parse(undoItem.Data).AsObject) as IDataRecord;
Repository.Add(obj);
redoItem.Type = UndoType.Inserted;
redoItem.Data = InvertJsonExtensions.SerializeObject(obj).ToString();
}
else
{
var record = Repository.GetById <IDataRecord>(undoItem.DataRecordId);
// We don't want to signal any events on deserialization
record.Repository = null;
redoItem.Data = InvertJsonExtensions.SerializeObject(record).ToString();
InvertJsonExtensions.DeserializeExistingObject(record, JSON.Parse(undoItem.Data).AsObject);
record.Changed = true;
record.Repository = Repository;
}
Repository.Remove(undoItem);
Repository.Add(redoItem);
}
}
catch (Exception ex)
{
// If we don't catch the exception IsUndoRedo won't be set back to fals causing cascading issues
}
IsUndoRedo = false;
Repository.Commit();
}
