public PSCompositePath(CompositePath compositePath)
{
if (compositePath == null)
{
return;
}
Path = compositePath.Path;
Order = compositePath.Order;
}
/// <summary>
/// Opens a file inside a zip file, returning the stream for reading its contents. The stream must be disposed after use.
/// Returns null if the zip file or the file inside it does not exist.
/// </summary>
public static Stream GetZipFileStream(CompositePath path)
{
var zipfile = _cache.GetEntry(path.File.ToLowerInvariant(), () => new ZipCacheEntry(path.File)).Zip;
if (zipfile == null)
{
return(null);
}
var entry = zipfile.GetEntry(path.InnerFile.Replace('\\', '/'));
if (entry == null)
{
return(null);
}
else
{
return(zipfile.GetInputStream(entry));
}
}
static int Main(string[] args)
{
// Configure Classify. This goes before the post-build check because it depends on it
Classify.DefaultOptions = new ClassifyOptions()
.AddTypeOptions(typeof(W.Color), new colorTypeOptions())
.AddTypeOptions(typeof(D.Color), new colorTypeOptions())
.AddTypeOptions(typeof(Filename), new filenameTypeOptions())
.AddTypeOptions(typeof(ObservableCollection <LayerBase>), new listLayerBaseOptions())
.AddTypeOptions(typeof(ObservableCollection <EffectBase>), new listEffectBaseOptions());
if (args.Length == 2 && args[0] == "--post-build-check")
{
return(RT.Util.Ut.RunPostBuildChecks(args[1], Assembly.GetExecutingAssembly()));
}
System.Windows.Forms.Application.EnableVisualStyles();
System.Windows.Forms.Application.SetCompatibleTextRenderingDefault(false);
#if DEBUG
CompositePath.Tests();
#endif
Thread.CurrentThread.Name = "Main";
#if !DEBUG
AppDomain.CurrentDomain.UnhandledException += (_, ea) =>
{
bool copy = DlgMessage.ShowError(App.Translation.Error.ExceptionGlobal,
App.Translation.Error.ErrorToClipboard_Copy, App.Translation.Error.ErrorToClipboard_OK) == 0;
if (copy)
{
if (Ut.ClipboardSet(Ut.ExceptionToDebugString(ea.ExceptionObject)))
{
DlgMessage.ShowInfo(App.Translation.Error.ErrorToClipboard_Copied);
}
}
};
#else
var dummy = App.Translation.Error.ExceptionGlobal; // to keep Lingo happy that the string is used
var dummy2 = new StringBuilder(); // to keep the "using" clause used
#endif
// Find all the layer and effect types in the assembly (required before settings are loaded)
App.LayerTypes = findTypes <LayerBase>("layer");
App.EffectTypes = findTypes <EffectBase>("effect");
// Load all settings
SettingsUtil.LoadSettings(out App.Settings);
UpdateSettingsIfNecessary();
// Guess the language if the OS language has changed (or this is the first run)
var osLingo = Ut.GetOsLanguage();
if (App.Settings.OsLingo != osLingo)
{
App.Settings.OsLingo = App.Settings.Lingo = osLingo;
}
// Load translation
App.Translation = Lingo.LoadTranslationOrDefault <Translation>("TankIconMaker", ref App.Settings.Lingo);
// Run the UI
var app = new App();
app.InitializeComponent();
app.Run();
// Save settings upon exit, even though they should be saved on every change anyway
App.Settings.SaveQuiet();
return(0);
}
public async Task ContainerContractTest()
{
ClientEncryptionIncludedPath clientEncryptionIncludedPath1 = new ClientEncryptionIncludedPath()
{
Path = "/path",
ClientEncryptionKeyId = "dekId",
EncryptionAlgorithm = "AEAD_AES_256_CBC_HMAC_SHA256",
EncryptionType = "Randomized"
};
Collection <ClientEncryptionIncludedPath> paths = new Collection <ClientEncryptionIncludedPath>()
{
clientEncryptionIncludedPath1
};
ContainerProperties containerProperties = new ContainerProperties(Guid.NewGuid().ToString(), "/users")
{
IndexingPolicy = new IndexingPolicy()
{
Automatic = true,
IndexingMode = IndexingMode.Consistent,
IncludedPaths = new Collection <IncludedPath>()
{
new IncludedPath()
{
Path = "/*"
}
},
ExcludedPaths = new Collection <ExcludedPath>()
{
new ExcludedPath()
{
Path = "/test/*"
}
},
CompositeIndexes = new Collection <Collection <CompositePath> >()
{
new Collection <CompositePath>()
{
new CompositePath()
{
Path = "/address/city",
Order = CompositePathSortOrder.Ascending
},
new CompositePath()
{
Path = "/address/zipcode",
Order = CompositePathSortOrder.Descending
}
}
},
SpatialIndexes = new Collection <SpatialPath>()
{
new SpatialPath()
{
Path = "/address/spatial/*",
SpatialTypes = new Collection <SpatialType>()
{
SpatialType.LineString
}
}
}
},
ClientEncryptionPolicy = new ClientEncryptionPolicy(paths)
};
CosmosJsonDotNetSerializer serializer = new CosmosJsonDotNetSerializer();
Stream stream = serializer.ToStream(containerProperties);
ContainerProperties deserialziedTest = serializer.FromStream <ContainerProperties>(stream);
ContainerResponse response = await this.database.CreateContainerAsync(containerProperties);
Assert.IsNotNull(response);
Assert.IsTrue(response.RequestCharge > 0);
Assert.IsNotNull(response.Headers);
Assert.IsNotNull(response.Headers.ActivityId);
ContainerProperties responseProperties = response.Resource;
Assert.IsNotNull(responseProperties.Id);
Assert.IsNotNull(responseProperties.ResourceId);
Assert.IsNotNull(responseProperties.ETag);
Assert.IsTrue(responseProperties.LastModified.HasValue);
Assert.IsTrue(responseProperties.LastModified.Value > new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc), responseProperties.LastModified.Value.ToString());
Assert.AreEqual(1, responseProperties.IndexingPolicy.IncludedPaths.Count);
IncludedPath includedPath = responseProperties.IndexingPolicy.IncludedPaths.First();
Assert.AreEqual("/*", includedPath.Path);
Assert.AreEqual("/test/*", responseProperties.IndexingPolicy.ExcludedPaths.First().Path);
Assert.AreEqual(1, responseProperties.IndexingPolicy.CompositeIndexes.Count);
Assert.AreEqual(2, responseProperties.IndexingPolicy.CompositeIndexes.First().Count);
CompositePath compositePath = responseProperties.IndexingPolicy.CompositeIndexes.First().First();
Assert.AreEqual("/address/city", compositePath.Path);
Assert.AreEqual(CompositePathSortOrder.Ascending, compositePath.Order);
Assert.AreEqual(1, responseProperties.IndexingPolicy.SpatialIndexes.Count);
SpatialPath spatialPath = responseProperties.IndexingPolicy.SpatialIndexes.First();
Assert.AreEqual("/address/spatial/*", spatialPath.Path);
Assert.AreEqual(4, spatialPath.SpatialTypes.Count); // All SpatialTypes are returned
Assert.AreEqual(1, responseProperties.ClientEncryptionPolicy.IncludedPaths.Count());
Assert.AreEqual(1, responseProperties.ClientEncryptionPolicy.PolicyFormatVersion);
ClientEncryptionIncludedPath clientEncryptionIncludedPath = responseProperties.ClientEncryptionPolicy.IncludedPaths.First();
Assert.IsTrue(this.VerifyClientEncryptionIncludedPath(clientEncryptionIncludedPath1, clientEncryptionIncludedPath));
}
public async Task ContainerMigrationTest()
{
string containerName = "MigrationIndexTest";
Documents.Index index1 = new Documents.RangeIndex(Documents.DataType.String, -1);
Documents.Index index2 = new Documents.RangeIndex(Documents.DataType.Number, -1);
Documents.DocumentCollection documentCollection = new Microsoft.Azure.Documents.DocumentCollection()
{
Id = containerName,
IndexingPolicy = new Documents.IndexingPolicy()
{
IncludedPaths = new Collection <Documents.IncludedPath>()
{
new Documents.IncludedPath()
{
Path = "/*",
Indexes = new Collection <Documents.Index>()
{
index1,
index2
}
}
}
}
};
Documents.DocumentCollection createResponse = await NonPartitionedContainerHelper.CreateNonPartitionedContainer(this.database, documentCollection);
// Verify the collection was created with deprecated Index objects
Assert.AreEqual(2, createResponse.IndexingPolicy.IncludedPaths.First().Indexes.Count);
Documents.Index createIndex = createResponse.IndexingPolicy.IncludedPaths.First().Indexes.First();
Assert.AreEqual(index1.Kind, createIndex.Kind);
// Verify v3 can add composite indexes and update the container
Container container = this.database.GetContainer(containerName);
ContainerProperties containerProperties = await container.ReadContainerAsync();
Assert.IsNotNull(containerProperties.SelfLink);
string cPath0 = "/address/city";
string cPath1 = "/address/state";
containerProperties.IndexingPolicy.CompositeIndexes.Add(new Collection <CompositePath>()
{
new CompositePath()
{
Path = cPath0,
Order = CompositePathSortOrder.Descending
},
new CompositePath()
{
Path = cPath1,
Order = CompositePathSortOrder.Ascending
}
});
containerProperties.IndexingPolicy.SpatialIndexes.Add(
new SpatialPath()
{
Path = "/address/test/*",
SpatialTypes = new Collection <SpatialType>()
{
SpatialType.Point
}
});
ContainerProperties propertiesAfterReplace = await container.ReplaceContainerAsync(containerProperties);
Assert.AreEqual(0, propertiesAfterReplace.IndexingPolicy.IncludedPaths.First().Indexes.Count);
Assert.AreEqual(1, propertiesAfterReplace.IndexingPolicy.CompositeIndexes.Count);
Collection <CompositePath> compositePaths = propertiesAfterReplace.IndexingPolicy.CompositeIndexes.First();
Assert.AreEqual(2, compositePaths.Count);
CompositePath compositePath0 = compositePaths.ElementAt(0);
CompositePath compositePath1 = compositePaths.ElementAt(1);
Assert.IsTrue(string.Equals(cPath0, compositePath0.Path) || string.Equals(cPath1, compositePath0.Path));
Assert.IsTrue(string.Equals(cPath0, compositePath1.Path) || string.Equals(cPath1, compositePath1.Path));
Assert.AreEqual(1, propertiesAfterReplace.IndexingPolicy.SpatialIndexes.Count);
Assert.AreEqual("/address/test/*", propertiesAfterReplace.IndexingPolicy.SpatialIndexes.First().Path);
}
public async Task ContainerContractTest()
{
ContainerProperties containerProperties = new ContainerProperties(Guid.NewGuid().ToString(), "/users")
{
IndexingPolicy = new IndexingPolicy()
{
Automatic = true,
IndexingMode = IndexingMode.Consistent,
IncludedPaths = new Collection <IncludedPath>()
{
new IncludedPath()
{
Path = "/*"
}
},
ExcludedPaths = new Collection <ExcludedPath>()
{
new ExcludedPath()
{
Path = "/test/*"
}
},
CompositeIndexes = new Collection <Collection <CompositePath> >()
{
new Collection <CompositePath>()
{
new CompositePath()
{
Path = "/address/city",
Order = CompositePathSortOrder.Ascending
},
new CompositePath()
{
Path = "/address/zipcode",
Order = CompositePathSortOrder.Descending
}
}
},
SpatialIndexes = new Collection <SpatialPath>()
{
new SpatialPath()
{
Path = "/address/spatial/*",
SpatialTypes = new Collection <SpatialType>()
{
SpatialType.LineString
}
}
}
}
};
var serializer = new CosmosJsonDotNetSerializer();
Stream stream = serializer.ToStream(containerProperties);
ContainerProperties deserialziedTest = serializer.FromStream <ContainerProperties>(stream);
ContainerResponse response = await this.database.CreateContainerAsync(containerProperties);
Assert.IsNotNull(response);
Assert.IsTrue(response.RequestCharge > 0);
Assert.IsNotNull(response.Headers);
Assert.IsNotNull(response.Headers.ActivityId);
ContainerProperties responseProperties = response.Resource;
Assert.IsNotNull(responseProperties.Id);
Assert.IsNotNull(responseProperties.ResourceId);
Assert.IsNotNull(responseProperties.ETag);
Assert.IsTrue(responseProperties.LastModified.HasValue);
Assert.IsTrue(responseProperties.LastModified.Value > new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc), responseProperties.LastModified.Value.ToString());
Assert.AreEqual(1, responseProperties.IndexingPolicy.IncludedPaths.Count);
IncludedPath includedPath = responseProperties.IndexingPolicy.IncludedPaths.First();
Assert.AreEqual("/*", includedPath.Path);
Assert.AreEqual("/test/*", responseProperties.IndexingPolicy.ExcludedPaths.First().Path);
Assert.AreEqual(1, responseProperties.IndexingPolicy.CompositeIndexes.Count);
Assert.AreEqual(2, responseProperties.IndexingPolicy.CompositeIndexes.First().Count);
CompositePath compositePath = responseProperties.IndexingPolicy.CompositeIndexes.First().First();
Assert.AreEqual("/address/city", compositePath.Path);
Assert.AreEqual(CompositePathSortOrder.Ascending, compositePath.Order);
Assert.AreEqual(1, responseProperties.IndexingPolicy.SpatialIndexes.Count);
SpatialPath spatialPath = responseProperties.IndexingPolicy.SpatialIndexes.First();
Assert.AreEqual("/address/spatial/*", spatialPath.Path);
Assert.AreEqual(1, spatialPath.SpatialTypes.Count);
Assert.AreEqual(SpatialType.LineString, spatialPath.SpatialTypes.First());
}
public PSCompositePath(CompositePath compositePath)
{
Path = compositePath.Path;
Order = compositePath.Order;
}
IndexingPolicy.Definition.IWithCompositeIndexList <DefinitionParentT> IndexingPolicy.Definition.IWithCompositeIndexList <DefinitionParentT> .WithCompositePath(CompositePath compositePath)
{
return(this.WithCompositePath(compositePath));
}
IndexingPolicy.Update.IWithCompositeIndexList <UpdateParentT> IndexingPolicy.Update.IWithCompositeIndexList <UpdateParentT> .WithCompositePath(CompositePath compositePath)
{
return(this.WithCompositePath(compositePath));
}
public IndexingPolicyImpl <ParentImplT, IParentT, DefinitionParentT, UpdateParentT> WithCompositePath(CompositePath compositePath)
{
Inner.CompositeIndexes.Last().Add(compositePath);
return(this);
}
