private static async Task CreateDocumentCollectionIfNotExists(string databaseName, string collectionName)
{
try
{
await Client.ReadDocumentCollectionAsync(UriFactory.CreateDocumentCollectionUri(databaseName, collectionName));
}
catch (DocumentClientException de)
{
// If the document collection does not exist, create a new collection
if (de.StatusCode == HttpStatusCode.NotFound)
{
DocumentCollection collectionInfo = new DocumentCollection();
collectionInfo.Id = collectionName;
// Configure collections for maximum query flexibility including string range queries.
collectionInfo.IndexingPolicy = new IndexingPolicy(new RangeIndex(DataType.String) { Precision = -1 });
// Here we create a collection with 400 RU/s.
await Client.CreateDocumentCollectionAsync(
UriFactory.CreateDatabaseUri(databaseName),
collectionInfo,
new RequestOptions { OfferThroughput = 400 });
}
else
{
throw;
}
}
}
public DocumentDBDataReader()
{
var dict = new Dictionary<HighchartsHelper.DocumentTypes, IEnumerable<Document>>();
_documentClient = new DocumentClient(new Uri(ConfigurationManager.AppSettings["DocumentServiceEndpoint"]), ConfigurationManager.AppSettings["DocumentKey"]);
_database = _documentClient.CreateDatabaseQuery().Where(db => db.Id == ConfigurationManager.AppSettings["DocumentDatabase"]).AsEnumerable().FirstOrDefault();
if (_database == null)
throw new ApplicationException("Error: DocumentDB database does not exist");
// Check to verify a document collection with the id=FamilyCollection does not exist
_documentCollection = _documentClient.CreateDocumentCollectionQuery(_database.CollectionsLink).Where(c => c.Id == ConfigurationManager.AppSettings["DocumentCollection"]).AsEnumerable().FirstOrDefault();
if (_documentCollection == null)
throw new ApplicationException("Error: DocumentDB collection does not exist");
try
{
_documentClient.CreateUserDefinedFunctionAsync(_documentCollection.SelfLink, new UserDefinedFunction
{
Id = "ISDEFINED",
Body = @"function ISDEFINED(doc, prop) {
return doc[prop] !== undefined;
}"
});
}
catch (Exception)
{
//fail silently for now..
}
}
private static void CreateDocumentCollection(DocumentClient documentClient)
{
// Create the database if it doesn't exist.
try
{
documentClient.ReadDocumentCollectionAsync(UriFactory.CreateDocumentCollectionUri(DatabaseName, CollectionName))
.GetAwaiter()
.GetResult();
}
catch (DocumentClientException de)
{
// If the document collection does not exist, create it
if (de.StatusCode == HttpStatusCode.NotFound)
{
var collectionInfo = new DocumentCollection
{
Id = CollectionName,
IndexingPolicy = new IndexingPolicy(new RangeIndex(DataType.String) { Precision = -1 })
};
documentClient.CreateDocumentCollectionAsync(
UriFactory.CreateDatabaseUri(DatabaseName),
collectionInfo,
new RequestOptions { OfferThroughput = 400 }).GetAwaiter().GetResult();
}
else
{
throw;
}
}
}
/// <summary>
/// Initialize a HashPartitionResolver.
/// </summary>
/// <param name="partitionKeyPropertyName">The property name to be used as the partition Key.</param>
/// <param name="client">The DocumentDB client instance to use.</param>
/// <param name="database">The database to run the samples on.</param>
/// <param name="collectionNames">The names of collections used.</param>
/// <returns>The created HashPartitionResolver.</returns>
public static async Task<HashPartitionResolver> InitializeHashResolver(string partitionKeyPropertyName, DocumentClient client, Database database, string[] collectionNames)
{
// Set local to input.
string[] CollectionNames = collectionNames;
int numCollectionNames = CollectionNames.Length;
// Create array of DocumentCollections.
DocumentCollection[] collections = new DocumentCollection[numCollectionNames];
// Create string array of Self Links to Collections.
string[] selfLinks = new string[numCollectionNames];
//Create some collections to partition data.
for (int i = 0; i < numCollectionNames; i++)
{
collections[i] = await DocumentClientHelper.GetCollectionAsync(client, database, CollectionNames[i]);
selfLinks[i] = collections[i].SelfLink;
}
// Join Self Link Array into a comma separated string.
string selfLinkString = String.Join(", ", selfLinks);
//Initialize a partition resolver that users hashing, and register with DocumentClient.
//Uses User Id for PartitionKeyPropertyName, could also be TenantId, or any other variable.
HashPartitionResolver hashResolver = new HashPartitionResolver(partitionKeyPropertyName, new[] { selfLinkString });
client.PartitionResolvers[database.SelfLink] = hashResolver;
return hashResolver;
}
private async Task<DocumentClient> GetDocumentDbClient()
{
var client = new DocumentClient(new Uri(_endPointUrl), _authorizationKKry);
var database = client.CreateDatabaseQuery().
Where(db => db.Id == DocumentDbId).AsEnumerable().FirstOrDefault();
if (database == null)
{
database = await client.CreateDatabaseAsync(
new Database
{
Id = DocumentDbId
});
}
DocumentCollection = client.CreateDocumentCollectionQuery
("dbs/" + database.Id).Where(c => c.Id == _collectionId).AsEnumerable().FirstOrDefault();
if (DocumentCollection == null)
{
DocumentCollection = await client.CreateDocumentCollectionAsync("dbs/" + DocumentDbId,
new DocumentCollection
{
Id = _collectionId
});
}
return client;
}
private static RangePartitionResolver<long> GetUpdateResolver(RangePartitionResolver<long> oldResolver,
DocumentCollection newDc)
{
var map = new Dictionary<Range<long>, string>();
var vs = oldResolver.PartitionMap;
if (vs.Count > 1)
{
foreach (var v in vs)
{
if (map.Count < vs.Count - 1)
{
map.Add(new Range<long>(v.Key.Low, v.Key.High), v.Value);
}
}
}
//Check Resolver
var now = (long) (DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1))).TotalMilliseconds;
if (now < vs.LastOrDefault().Key.Low || now > vs.LastOrDefault().Key.High) return null;
map.Add(new Range<long>(vs.LastOrDefault().Key.Low, now), vs.LastOrDefault().Value);
map.Add(new Range<long>(now + 1, vs.LastOrDefault().Key.High), newDc.SelfLink);
return new RangePartitionResolver<long>(
u => ((PostMessage) u).Info.timestamp,
map);
}
public async Task CollectionTransfer(DocumentCollection dc1, DocumentCollection dc2)
{
var sp = await _iDBoperation.GetStoreProcedure(dc1.SelfLink, "BatchDelete");
var sp2 = await _iDBoperation.GetStoreProcedure(dc1.SelfLink, "BatchInsert");
var docs = _iDBoperation.GetDocumentByType(dc1.DocumentsLink, "Post");
var l = docs.ToList();
var cur = 0;
int maxDoc = 400;
while (cur < l.Count)
{
var s = new List<dynamic>();
for (var i = cur; i < l.Count; i++)
{
if (s.Count < maxDoc)
{
s.Add(l[i]);
}
}
var n = await BatchTransfer(sp2.SelfLink, sp.SelfLink, s);
//Console.WriteLine(n + "----" + l.Count);
cur = cur + n;
}
}
public DocumentCollection FetchAll()
{
DocumentCollection coll = new DocumentCollection();
Query qry = new Query(Document.Schema);
coll.LoadAndCloseReader(qry.ExecuteReader());
return coll;
}
private static async Task<DocumentCollection> CreateDocumentCollection(DocumentClient client, Database database, string collectionId)
{
var collectionSpec = new DocumentCollection { Id = collectionId };
var requestOptions = new RequestOptions { OfferType = "S1" };
return await client.CreateDocumentCollectionAsync(database.SelfLink, collectionSpec, requestOptions);
}
//new add
private static async Task GetStart()
{
var client = new DocumentClient(new Uri(EndpointURL), AuthorizationKey);
database = client.CreateDatabaseQuery().Where(d => d.Id == "ppweict").AsEnumerable().FirstOrDefault();
collection = client.CreateDocumentCollectionQuery(database.SelfLink).Where(c => c.Id == "Exam_Pool").AsEnumerable().FirstOrDefault();
var EfDs = client.CreateDocumentQuery(collection.DocumentsLink, "SELECT * FROM Exam_pool f WHERE f.verify = \"true\" ");
foreach (exam_pool EfD in EfDs)
{
Console.WriteLine(EfD);
exams.Add(new exam_pool
{
id = EfD.id,
exam_catrgory = EfD.exam_catrgory,
exam_level = EfD.exam_level,
questions = EfD.questions,
answer_A = EfD.answer_A,
answer_B = EfD.answer_B,
answer_C = EfD.answer_C,
answer_D = EfD.answer_D,
answer_E = EfD.answer_E,
C_answer = EfD.C_answer,
exam_link = EfD.exam_link,
lang = EfD.lang,
verify = EfD.verify,
});
}
}
public ProcessMessage(DbService iDbService, QueueService iQueueService)
{
_documentClient = iDbService.GetDocumentClient();
_client = iDbService.GetFirebaseClient();
_documentCollection = iDbService.GetDc("LMSCollection", "LMSRegistry");
_sp = iDbService.GetSp(_documentCollection, "Post");
_queue = iQueueService.GetQueue("queue");
}
public void Initialize()
{
tr = new AC_Transactions();
DocColl = Application.DocumentManager;
DocColl.DocumentCreated += DocColl_DocumentCreated;
if (tr.AC_Doc != null){ findandLink(); }
}
private async Task CreateCollection(string collectionId)
{
collection = client.CreateDocumentCollectionQuery(database.SelfLink).Where(c => c.Id == collectionId).ToArray().FirstOrDefault();
if (null == collection)
{
collection = await client.CreateDocumentCollectionAsync(database.SelfLink, new DocumentCollection { Id = collectionId });
}
}
public async static Task GoOnVacation(DocumentClient client, DocumentCollection collection, string jeffersons, bool left)
{
var family = GetFamily(client, collection, jeffersons);
dynamic doc = GetDocumentById(client, collection,family.id);
Family f = doc;
f.IsHome = false;
var task = await client.ReplaceDocumentAsync(doc.SelfLink, f);
}
public async Task<DocumentCollection> GetCollection()
{
if (_documentCollection == null)
{
var db = await GetDatabase();
_documentCollection = await GetCollection(_config["DocumentCollection"], db);
}
return _documentCollection;
}
public async Task UpdateCurrentCollection(DocumentCollection newDc)
{
await _iDBoperation.DeleteDocById("CurrentCollection");
var doc = new CurrentCollection
{
id = "CurrentCollection",
name = newDc.Id
};
await _iDBoperation.CreateDocument(doc);
}
static UsersController()
{
var address = CloudConfigurationManager.GetSetting("DocumentDbEndpointAddress");
var authorizationKey = CloudConfigurationManager.GetSetting("DocumentDbAuthorizationKey");
Client = new DocumentClient(new Uri(address), authorizationKey);
var database = GetOrCreateDatabase(Client, "CloudCampDb");
DocumentCollection = GetOrCreateCollection(Client, database.SelfLink, "Users");
}
private async Task InitClient()
{
_client = new DocumentClient(new Uri(Uri), Key);
_database = await _client.GetDatabase("reportdb");
_documentCollection = await _client.GetCollection(_database, "reports");
if (HasReports() == false)
{
await CreateDummyReportsAsync();
}
}
private static async Task DeletePost(DocumentCollection dc,string id)
{
var ds =
from d in _client.CreateDocumentQuery(dc.DocumentsLink)
where d.Id==id
select d;
foreach (var d in ds)
{
await _client.DeleteDocumentAsync(d.SelfLink);
}
}
private async Task CreateCollectionIfNotExistsAsync(string collectionName)
{
_collection = (await _client.ReadDocumentCollectionFeedAsync(_database.CollectionsLink))
.SingleOrDefault(c => c.Id == collectionName);
if (_collection == null)
_collection = await _client.CreateDocumentCollectionAsync(_database.SelfLink, new DocumentCollection
{
Id = collectionName
});
}
private static async Task ReadOrCreateCollection(string databaseLink)
{
Collection = Client.CreateDocumentCollectionQuery(databaseLink).Where(col => col.Id == _collectionId).AsEnumerable().FirstOrDefault();
if (Collection == null)
{
var collectionSpec = new DocumentCollection {Id = _collectionId};
var requestOptions = new RequestOptions {OfferType = "S1"};
Collection = await Client.CreateDocumentCollectionAsync(databaseLink, collectionSpec, requestOptions);
}
}
public SpeakerAzureDocDbRepository(Settings settings)
{
_settings = settings;
_client = new DocumentClient(new Uri(endpointUrl), authorizationKey);
//Get, or Create, the Database
_database = GetOrCreateDatabaseAsync(databaseId).Result;
//Get, or Create, the Document Collection
_collection = GetOrCreateCollectionAsync(_database.SelfLink, collectionId).Result;
}
private async Task EnsureStoryCollectionAsync()
{
await EnsureDatabaseAsync();
var coll = _client.CreateDocumentCollectionQuery(DatabaseLink)
.Where(s => s.Id == STORYCOLLECTIONID)
.AsEnumerable()
.FirstOrDefault();
if (coll == null)
{
_storyCollection = await _client.CreateDocumentCollectionAsync(_database.CollectionsLink, new DocumentCollection() { Id = STORYCOLLECTIONID });
}
}
internal static DocumentCollection ReadOrCreateCollection(DocumentClient client, string databaseLink, string collectionId)
{
var collections = client.CreateDocumentCollectionQuery(databaseLink)
.Where(col => col.Id == collectionId).ToArray();
if (collections.Any())
{
return collections.First();
}
var collection = new DocumentCollection { Id = collectionId };
return client.CreateDocumentCollectionAsync(databaseLink, collection).Result;
}
private async Task SetupCollection(string databaseLink)
{
_collection = Client.CreateDocumentCollectionQuery(databaseLink)
.Where(c => c.Id == _collectionName)
.AsEnumerable()
.FirstOrDefault();
if (_collection == null)
{
var collectionSpec = new DocumentCollection { Id = _collectionName };
_collection = await Client.CreateDocumentCollectionAsync(databaseLink, collectionSpec);
}
}
/// <summary>
/// Initialize a RangePartitionResolver.
/// </summary>
/// <param name="partitionKeyPropertyName">The property name to be used as the partition Key.</param>
/// <param name="client">The DocumentDB client instance to use.</param>
/// <param name="database">The database to run the samples on.</param>
/// <param name="collectionNames">The names of collections used.</param>
/// <returns>The created HashPartitionResolver.</returns>
public static async Task<RangePartitionResolver<string>> InitializeRangeResolver(string partitionKeyPropertyName, DocumentClient client, Database database, string[] collectionNames)
{
// Set local to input.
string[] CollectionNames = collectionNames;
int numCollectionNames = CollectionNames.Length;
// Create array of DocumentCollections.
DocumentCollection[] collections = new DocumentCollection[numCollectionNames];
// Create string array of Self Links to Collections.
string[] selfLinks = new string[numCollectionNames];
//Create some collections to partition data.
for (int i = 0; i < numCollectionNames; i++)
{
collections[i] = await DocumentClientHelper.GetCollectionAsync(client, database, CollectionNames[i]);
selfLinks[i] = collections[i].SelfLink;
}
// Join Self Link Array into a comma separated string.
string selfLinkString = String.Join(", ", selfLinks);
// If each collection represents a range, it will have both a start and end point in its range, thus there are 2 rangeNames for each collection.
string[] rangeNames = new string[numCollectionNames * 2];
// Keeping track of where in the rangeNames array to add a new start/end of a range.
int currentRangePosition = 0;
for (int y = 0; y < numCollectionNames; y++)
{
string[] rangeTemp = collectionNames[y].Split('-');
for (int z = 0; z < rangeTemp.Length; z++)
{
rangeNames[currentRangePosition] = rangeTemp[z];
currentRangePosition++;
}
}
// Dictionary needed to input into RangePartitionResolver with corresponding range and collection self link.
Dictionary<Range<string>, string> rangeCollections = new Dictionary<Range<string>, string>();
// TO DO:: Iterate through the ranges and add then to rangeCollections with the appropriate start/end point, with the corresponding collection self link.
//rangeCollections.Add()
RangePartitionResolver<string> rangeResolver = new RangePartitionResolver<string>(
partitionKeyPropertyName,
rangeCollections);
client.PartitionResolvers[database.SelfLink] = rangeResolver;
return rangeResolver;
}
private static async Task BackupPostCollection(DocumentCollection dc, DocumentClient client)
{
Trace.TraceInformation("Collection '{0}' start. Time: '{1}'", dc.Id,
DateTime.Now.ToString(CultureInfo.CurrentCulture));
try
{
var ds =
from d in client.CreateDocumentQuery<PostMessage>(dc.DocumentsLink)
where d.Type == "Post"
select d;
TableBatchOperation batchOperation = new TableBatchOperation();
List<dynamic> docList = new List<dynamic>();
foreach (var d in ds)
{
TablePost c = ModelService.TablePostData(d);
batchOperation.Insert(c);
docList.Add(d);
if (batchOperation.Count == 100)
{
var operation = batchOperation;
var res = await _retryPolicy.ExecuteAsync(
() => _table.ExecuteBatchAsync(operation));
batchOperation = new TableBatchOperation();
if (res.Count == operation.Count)
{
await _iDbService.DocumentDb.BatchDelete(dc, docList);
docList = new List<dynamic>();
Trace.TraceInformation("inserted");
}
}
}
if (batchOperation.Count > 0)
{
var operation = batchOperation;
var res = await _retryPolicy.ExecuteAsync(
() => _table.ExecuteBatchAsync(operation));
if (res.Count == operation.Count)
{
await _iDbService.DocumentDb.BatchDelete(dc, docList);
Trace.TraceInformation("inserted");
}
}
}
catch (Exception e)
{
Trace.TraceError("Error in BackupCollection " + e.Message);
}
}
private static async Task ReadOrCreateCollection(string databaseLink)
{
var collections = Client.CreateDocumentCollectionQuery(databaseLink)
.Where(col => col.Id == _collectionId).ToArray();
if (collections.Any())
{
_collection = collections.First();
}
else
{
_collection = await Client.CreateDocumentCollectionAsync(databaseLink,
new DocumentCollection { Id = _collectionId });
}
}
public async Task<List<Order>> GetOrders()
{
List<Order> orderDetailsList = new List<Order>();
if (null == client)
{
await InitializeDocumentDB();
}
collection = client.CreateDocumentCollectionQuery(database.SelfLink).Where(c => c.Id == "OrderDetails").ToArray().FirstOrDefault();
//var query = client.CreateDocumentQuery(collection.SelfLink, "SELECT * FROM OrderDetails");
var query = from ordr in client.CreateDocumentQuery<Order>(collection.SelfLink) select ordr;
foreach (Order order in query.AsEnumerable())
{
orderDetailsList.Add(order);
}
return orderDetailsList;
}
public UserStore(DocumentClient documentClient, DocumentCollection users) // DocumentCollection of TUser
{
_Client = documentClient;
_Users = users;
UsesPartitioning = _Users.PartitionKey?.Paths.Any() ?? false;
}
/// <summary>
/// Create a new document.
/// </summary>
/// <param name="collection">The document collection the entity belongs to.</param>
/// <param name="entity">The document entity to create.</param>
/// <returns>The async task.</returns>
public async Task <ResourceResponse <Microsoft.Azure.Documents.Document> > CreateDocumentAsync(DocumentCollection collection, T entity)
{
return(await _client.CreateDocumentAsync(collection.SelfLink, entity));
}
public OrdreProfessionalGraphRepository(DocumentClient documentClient, DocumentCollection documentCollection) : base(documentClient, documentCollection)
{
}
/// <summary>
/// Driver function for bulk import.
/// </summary>
/// <returns></returns>
private async Task RunBulkImportAsync()
{
// Cleanup on start if set in config.
DocumentCollection dataCollection = null;
try
{
if (bool.Parse(ConfigurationManager.AppSettings["ShouldCleanupOnStart"]))
{
Database database = Utils.GetDatabaseIfExists(client, DatabaseName);
if (database != null)
{
await client.DeleteDatabaseAsync(database.SelfLink);
}
Trace.TraceInformation("Creating database {0}", DatabaseName);
database = await client.CreateDatabaseAsync(new Database { Id = DatabaseName });
Trace.TraceInformation(String.Format("Creating collection {0} with {1} RU/s", CollectionName, CollectionThroughput));
dataCollection = await Utils.CreatePartitionedCollectionAsync(client, DatabaseName, CollectionName, CollectionThroughput);
}
else
{
dataCollection = Utils.GetCollectionIfExists(client, DatabaseName, CollectionName);
if (dataCollection == null)
{
throw new Exception("The data collection does not exist");
}
}
}
catch (Exception de)
{
Trace.TraceError("Unable to initialize, exception message: {0}", de.Message);
throw;
}
// Prepare for bulk import.
// Creating documents with simple partition key here.
string partitionKeyProperty = dataCollection.PartitionKey.Paths[0].Replace("/", "");
long numberOfDocumentsToGenerate = long.Parse(ConfigurationManager.AppSettings["NumberOfDocumentsToImport"]);
// Set retry options high for initialization (default values).
client.ConnectionPolicy.RetryOptions.MaxRetryWaitTimeInSeconds = 30;
client.ConnectionPolicy.RetryOptions.MaxRetryAttemptsOnThrottledRequests = 9;
IBulkExecutor graphbulkExecutor = new GraphBulkExecutor(client, dataCollection);
await graphbulkExecutor.InitializeAsync();
// Set retries to 0 to pass control to bulk executor.
client.ConnectionPolicy.RetryOptions.MaxRetryWaitTimeInSeconds = 0;
client.ConnectionPolicy.RetryOptions.MaxRetryAttemptsOnThrottledRequests = 0;
var tokenSource = new CancellationTokenSource();
var token = tokenSource.Token;
BulkImportResponse vResponse = null;
BulkImportResponse eResponse = null;
try
{
vResponse = await graphbulkExecutor.BulkImportAsync(
Utils.GenerateVertices(numberOfDocumentsToGenerate),
enableUpsert : true,
disableAutomaticIdGeneration : true,
maxConcurrencyPerPartitionKeyRange : null,
maxInMemorySortingBatchSize : null,
cancellationToken : token);
eResponse = await graphbulkExecutor.BulkImportAsync(
Utils.GenerateEdges(numberOfDocumentsToGenerate),
enableUpsert : true,
disableAutomaticIdGeneration : true,
maxConcurrencyPerPartitionKeyRange : null,
maxInMemorySortingBatchSize : null,
cancellationToken : token);
}
catch (DocumentClientException de)
{
Trace.TraceError("Document client exception: {0}", de);
}
catch (Exception e)
{
Trace.TraceError("Exception: {0}", e);
}
Console.WriteLine("\nSummary for batch");
Console.WriteLine("--------------------------------------------------------------------- ");
Console.WriteLine(
"Inserted {0} graph elements ({1} vertices, {2} edges) @ {3} writes/s, {4} RU/s in {5} sec)",
vResponse.NumberOfDocumentsImported + eResponse.NumberOfDocumentsImported,
vResponse.NumberOfDocumentsImported,
eResponse.NumberOfDocumentsImported,
Math.Round(
(vResponse.NumberOfDocumentsImported) /
(vResponse.TotalTimeTaken.TotalSeconds + eResponse.TotalTimeTaken.TotalSeconds)),
Math.Round(
(vResponse.TotalRequestUnitsConsumed + eResponse.TotalRequestUnitsConsumed) /
(vResponse.TotalTimeTaken.TotalSeconds + eResponse.TotalTimeTaken.TotalSeconds)),
vResponse.TotalTimeTaken.TotalSeconds + eResponse.TotalTimeTaken.TotalSeconds);
Console.WriteLine(
"Average RU consumption per insert: {0}",
(vResponse.TotalRequestUnitsConsumed + eResponse.TotalRequestUnitsConsumed) /
(vResponse.NumberOfDocumentsImported + eResponse.NumberOfDocumentsImported));
Console.WriteLine("---------------------------------------------------------------------\n ");
if (vResponse.BadInputDocuments.Count > 0 || eResponse.BadInputDocuments.Count > 0)
{
using (System.IO.StreamWriter file = new System.IO.StreamWriter(@".\BadVertices.txt", true))
{
foreach (object doc in vResponse.BadInputDocuments)
{
file.WriteLine(doc);
}
}
using (System.IO.StreamWriter file = new System.IO.StreamWriter(@".\BadEdges.txt", true))
{
foreach (object doc in eResponse.BadInputDocuments)
{
file.WriteLine(doc);
}
}
}
// Cleanup on finish if set in config.
if (bool.Parse(ConfigurationManager.AppSettings["ShouldCleanupOnFinish"]))
{
Trace.TraceInformation("Deleting Database {0}", DatabaseName);
await client.DeleteDatabaseAsync(UriFactory.CreateDatabaseUri(DatabaseName));
}
Trace.WriteLine("\nPress any key to exit.");
Console.ReadKey();
}
public DocumentConnection(Database db, DocumentClient client, DocumentCollection collection)
{
Database = db;
Client = client;
Collection = collection;
}
public async Task CreateDocumentCollectionIfNotExistsAsync(Uri uri, DocumentCollection documentCollection)
{
await client.CreateDocumentCollectionIfNotExistsAsync(uri, documentCollection);
}
/// <summary>
/// Run the get started application.
/// </summary>
/// <param name="client">The DocumentDB client instance</param>
/// <returns>A Task for asynchronous execuion.</returns>
public async Task RunAsync(DocumentClient client)
{
Database database = await client.CreateDatabaseIfNotExistsAsync(new Database { Id = "graphdb" });
DocumentCollection graph = await client.CreateDocumentCollectionIfNotExistsAsync(
UriFactory.CreateDatabaseUri("graphdb"),
new DocumentCollection { Id = "Persons" },
new RequestOptions { OfferThroughput = 10000 });
// Azure Cosmos DB supports the Gremlin API for working with Graphs. Gremlin is a functional programming language composed of steps.
// Here, we run a series of Gremlin queries to show how you can add vertices, edges, modify properties, perform queries and traversals
// For additional details, see https://aka.ms/gremlin for the complete list of supported Gremlin operators
Dictionary <string, string> gremlinQueries = new Dictionary <string, string>
{
{ "Cleanup", "g.V().drop()" },
{ "AddVertex 1", "g.addV('person').property('id', 'thomas').property('firstName', 'Thomas').property('age', 44)" },
{ "AddVertex 2", "g.addV('person').property('id', 'mary').property('firstName', 'Mary').property('lastName', 'Andersen').property('age', 39)" },
{ "AddVertex 3", "g.addV('person').property('id', 'ben').property('firstName', 'Ben').property('lastName', 'Miller')" },
{ "AddVertex 4", "g.addV('person').property('id', 'robin').property('firstName', 'Robin').property('lastName', 'Wakefield')" },
{ "AddEdge 1", "g.V('thomas').addE('knows').to(g.V('mary'))" },
{ "AddEdge 2", "g.V('thomas').addE('knows').to(g.V('ben'))" },
{ "AddEdge 3", "g.V('ben').addE('knows').to(g.V('robin'))" },
{ "UpdateVertex", "g.V('thomas').property('age', 44)" },
{ "CountVertices", "g.V().count()" },
{ "Filter Range", "g.V().hasLabel('person').has('age', gt(40))" },
{ "Project", "g.V().hasLabel('person').values('firstName')" },
{ "Sort", "g.V().hasLabel('person').order().by('firstName', decr)" },
{ "Traverse", "g.V('thomas').outE('knows').inV().hasLabel('person')" },
{ "Traverse 2x", "g.V('thomas').outE('knows').inV().hasLabel('person').outE('knows').inV().hasLabel('person')" },
{ "Loop", "g.V('thomas').repeat(out()).until(has('id', 'robin')).path()" },
{ "DropEdge", "g.V('thomas').outE('knows').where(inV().has('id', 'mary')).drop()" },
{ "CountEdges", "g.E().count()" },
{ "DropVertex", "g.V('thomas').drop()" },
};
foreach (KeyValuePair <string, string> gremlinQuery in gremlinQueries)
{
Console.WriteLine($"Running {gremlinQuery.Key}: {gremlinQuery.Value}");
// The CreateGremlinQuery method extensions allow you to execute Gremlin queries and iterate
// results asychronously
IDocumentQuery <dynamic> query = client.CreateGremlinQuery <dynamic>(graph, gremlinQuery.Value);
while (query.HasMoreResults)
{
foreach (dynamic result in await query.ExecuteNextAsync())
{
Console.WriteLine($"\t {JsonConvert.SerializeObject(result)}");
}
}
Console.WriteLine();
}
// Data is returned in GraphSON format, which be deserialized into a strongly-typed vertex, edge or property class
// The following snippet shows how to do this
string gremlin = gremlinQueries["AddVertex 1"];
Console.WriteLine($"Running Add Vertex with deserialization: {gremlin}");
IDocumentQuery <Vertex> insertVertex = client.CreateGremlinQuery <Vertex>(graph, gremlinQueries["AddVertex 1"]);
while (insertVertex.HasMoreResults)
{
foreach (Vertex vertex in await insertVertex.ExecuteNextAsync <Vertex>())
{
// Since Gremlin is designed for multi-valued properties, the format returns an array. Here we just read
// the first value
string name = (string)vertex.GetVertexProperties("firstName").First().Value;
Console.WriteLine($"\t Id:{vertex.Id}, Name: {name}");
}
}
Console.WriteLine();
Console.WriteLine("Done. Press any key to exit...");
Console.ReadLine();
}
public static async Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequestMessage req, TraceWriter log)
{
log.Info("C# HTTP trigger function processed a request.");
string shipmasterId = req.GetQueryNameValuePairs()
.FirstOrDefault(q => string.Compare(q.Key, "ShipmasterId", true) == 0)
.Value;
string shipmentId = req.GetQueryNameValuePairs()
.FirstOrDefault(q => string.Compare(q.Key, "ShipmentID", true) == 0)
.Value;
if (string.IsNullOrEmpty(shipmasterId) || string.IsNullOrEmpty(shipmentId))
{
return(req.CreateErrorResponse(HttpStatusCode.BadRequest, "Input is Null or Empty"));
}
var Cosmosconnectionstring = Environment.GetEnvironmentVariable("NoSQLConnectionString");
var ConnectionstrinG = Environment.GetEnvironmentVariable("SQLConnectionString");
var PrimaryKey = Environment.GetEnvironmentVariable("NoSqlPrimaryKey");
DocumentClient client = new DocumentClient(new Uri(Cosmosconnectionstring), PrimaryKey);
FeedOptions feedOptions = new FeedOptions();
Database databaseInfo = client.CreateDatabaseQuery().Where(x => x.Id == "TitanCosmosDB").AsEnumerable().FirstOrDefault();
string DB = databaseInfo.SelfLink;
DocumentCollection documentCollection = new DocumentCollection {
Id = "TitanTelemetryCollection"
};
var collectionlinK = UriFactory.CreateDocumentCollectionUri("TitanCosmosDB", "TitanTelemetryCollection");
var collectionAlert = UriFactory.CreateDocumentCollectionUri("TitanCosmosDB", "TitanAlertCollection");
List <SensorDetails> sensorList = new List <SensorDetails>();
var Connectionstring = Environment.GetEnvironmentVariable("SQLConnectionString");
string SqlSelect = "SELECT DISTINCT [ObjectType],[ObjectId],[BeaconId],'NonAlert'As [BeaconStatus] FROM [Beacon_Object_Info] WHERE [ShipMasterId]=@ShipMasterId" +
" AND[BeaconId] not in (SELECT DISTINCT[BeaconID] from Alert_Process where [ShipmentID] = @ShipmentID and[Status] = 'Active')" +
" UNION " +
" SELECT DISTINCT[ObjectType],[ObjectId],[BeaconId],'Alert'As[BeaconStatus] FROM[Beacon_Object_Info] WHERE[ShipMasterId]=@ShipMasterId" +
" AND[BeaconId] in (SELECT DISTINCT [BeaconID] from Alert_Process where[ShipmentID] = @ShipmentID and[Status]='Active')";
string cosmosTelemeterySelect = "";
using (SqlConnection conn = new SqlConnection(Connectionstring))
{
using (SqlCommand cmd = new SqlCommand(SqlSelect, conn))
{
cmd.Parameters.Add("@ShipMasterId", SqlDbType.Int).Value = shipmasterId;
cmd.Parameters.Add("@ShipmentID", SqlDbType.NVarChar).Value = shipmentId;
conn.Open();
SqlDataReader reader = cmd.ExecuteReader();
while (reader.Read())
{
SensorDetails Sensor = new SensorDetails();
Sensor.ObjectType = (string)reader["ObjectType"];
Sensor.ObjectId = (string)reader["ObjectId"];
Sensor.BeaconId = (string)reader["BeaconId"];
Sensor.BeaconStatus = (string)reader["BeaconStatus"];
TelemetryDetails objTelmetry = new TelemetryDetails();
cosmosTelemeterySelect = "SELECT TOP 1 c.temperature,c.humidity,f.current_system_time,c.humidity_alert,c.temperature_alert,c.tamper_alert,c.shock_alert " +
" FROM f JOIN c IN f.sensor_Values WHERE c.sensorID = '" + Sensor.BeaconId + "' order by f.current_system_time desc";
IQueryable <TelemetryDetails> cosTelemetry = client.CreateDocumentQuery <TelemetryDetails>(collectionlinK, cosmosTelemeterySelect);
objTelmetry = cosTelemetry.ToList().SingleOrDefault();
if (objTelmetry != null)
{
Sensor.Temperature = objTelmetry.Temperature;
Sensor.Humidity = objTelmetry.Humidity;
Sensor.BeaconTimestamp = objTelmetry.current_system_time;
Sensor.HumidityAlert = objTelmetry.humidity_alert;
Sensor.TamperAlert = objTelmetry.tamper_alert;
Sensor.TemperatureAlert = objTelmetry.temperature_alert;
Sensor.ShockVibrationAlert = objTelmetry.shock_alert;
}
sensorList.Add(Sensor);
}
reader.Close();
conn.Close();
}
}
return(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(JsonConvert.SerializeObject(sensorList, Formatting.Indented), Encoding.UTF8, "application/json")
});
}
public async Task ContainerV2CompatTest()
{
string containerId = "SerializeContainerTest";
DocumentCollection documentCollection = new DocumentCollection()
{
Id = containerId,
PartitionKey = new PartitionKeyDefinition()
{
Paths = new Collection <string>()
{
"/pkPath"
}
},
IndexingPolicy = new IndexingPolicy()
{
IncludedPaths = new Collection <IncludedPath>()
{
new IncludedPath()
{
Path = "/*"
}
},
CompositeIndexes = new Collection <Collection <CompositePath> >()
{
new Collection <CompositePath>()
{
new CompositePath()
{
Path = "/address/test/*",
Order = CompositePathSortOrder.Ascending
},
new CompositePath()
{
Path = "/address/test2/*",
Order = CompositePathSortOrder.Ascending
}
}
},
SpatialIndexes = new Collection <SpatialSpec>()
{
new SpatialSpec()
{
Path = "/name/first/*",
SpatialTypes = new Collection <SpatialType>()
{
SpatialType.LineString
}
}
}
},
};
string documentJsonString = null;
using (MemoryStream memoryStream = new MemoryStream())
{
documentCollection.SaveTo(memoryStream);
memoryStream.Position = 0;
using (StreamReader sr = new StreamReader(memoryStream))
{
documentJsonString = await sr.ReadToEndAsync();
}
}
Assert.IsNotNull(documentJsonString);
string cosmosJsonString = null;
using (MemoryStream memoryStream = new MemoryStream())
{
documentCollection.SaveTo(memoryStream);
memoryStream.Position = 0;
CosmosJsonDotNetSerializer serializerCore = new CosmosJsonDotNetSerializer();
ContainerProperties containerProperties = serializerCore.FromStream <ContainerProperties>(memoryStream);
Assert.IsNotNull(containerProperties);
Assert.AreEqual(containerId, containerProperties.Id);
using (Stream stream = serializerCore.ToStream <ContainerProperties>(containerProperties))
{
using (StreamReader sr = new StreamReader(stream))
{
cosmosJsonString = await sr.ReadToEndAsync();
}
}
}
JObject jObjectDocumentCollection = JObject.Parse(documentJsonString);
JObject jObjectContainer = JObject.Parse(cosmosJsonString);
Assert.IsTrue(JToken.DeepEquals(jObjectDocumentCollection, jObjectContainer), $"v2:{documentJsonString}; v3:{cosmosJsonString}");
}
static public void Plan2HoePrSelPolygonLayer()
{
try
{
if (!OpenHoePrPalette())
{
return;
}
var opts = Globs.TheHoePrOptions;
Document doc = Application.DocumentManager.MdiActiveDocument;
using (DocumentLock m_doclock = doc.LockDocument())
{
DocumentCollection dm = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager;
if (doc == null)
{
return;
}
Editor ed = doc.Editor;
#if NEWSETFOCUS
doc.Window.Focus();
#else
Autodesk.AutoCAD.Internal.Utils.SetFocusToDwgView(); // previous 2014 AutoCAD - Versions
#endif
PromptNestedEntityOptions peo = new PromptNestedEntityOptions("\nPolylinie wählen: ");
//peo.SetRejectMessage("\nDas gewählte Element ist keine Polylinie.");
//peo.AddAllowedClass(typeof(Polyline), true);
//peo.AddAllowedClass(typeof(Polyline2d), true);
//peo.AddAllowedClass(typeof(Polyline3d), true);
PromptEntityResult per = ed.GetNestedEntity(peo);
if (per.Status == PromptStatus.OK)
{
using (var tr = doc.TransactionManager.StartTransaction())
{
DBObject obj = tr.GetObject(per.ObjectId, OpenMode.ForRead);
Entity ent = obj as Entity;
if (ent != null)
{
if (ent is Polyline || ent is Polyline2d || ent is Polyline3d)
{
opts.SetPolygonLayer(ent.Layer);
}
else
{
ed.WriteMessage("\nDas gewählte Element ist keine Polylinie.");
}
}
tr.Commit();
}
}
}
}
catch (System.Exception ex)
{
Application.ShowAlertDialog(string.Format(CultureInfo.CurrentCulture, "Fehler in Plan2HoePrSelPolygonLayer aufgetreten! {0}", ex.Message));
}
}
public async Task <DocumentCollection> CreateDocumentCollectionIfNotExistsAsync(Uri databaseUri, DocumentCollection documentCollection, RequestOptions options)
{
ResourceResponse <DocumentCollection> response = await _client.CreateDocumentCollectionIfNotExistsAsync(databaseUri, documentCollection, options);
return(response.Resource);
}
private bool GetHeightFromVermBlocks(ref double height)
{
DocumentCollection dm = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager;
Document doc = dm.MdiActiveDocument;
Editor ed = doc.Editor;
#if NEWSETFOCUS
doc.Window.Focus();
#else
Autodesk.AutoCAD.Internal.Utils.SetFocusToDwgView(); // previous 2014 AutoCAD - Versions
#endif
PromptEntityResult per = ed.GetEntity("\nErsten Vermessungsblock wählen: ");
//DocumentLock loc = dm.MdiActiveDocument.LockDocument();
//using (loc)
//{
//}
bool blockFound = false;
double height1 = 0.0;
double height2 = 0.0;
if (per.Status == PromptStatus.OK)
{
Transaction tr = doc.TransactionManager.StartTransaction();
using (tr)
{
DBObject obj = tr.GetObject(per.ObjectId, OpenMode.ForRead);
BlockReference br = obj as BlockReference;
if (br == null)
{
return(false);
}
if (br.Name == "GEOINOVA")
{
blockFound = true;
height1 = br.Position.Z;
br.Highlight();
}
if (blockFound)
{
blockFound = false;
per = ed.GetEntity("\nZweiten Vermessungsblock wählen: ");
if (per.Status == PromptStatus.OK)
{
obj = tr.GetObject(per.ObjectId, OpenMode.ForRead);
BlockReference br2 = obj as BlockReference;
if (br2 == null)
{
return(false);
}
if (br2.Name == "GEOINOVA")
{
blockFound = true;
height2 = br2.Position.Z;
}
}
if (blockFound)
{
height = Math.Abs(height1 - height2);
}
br.Unhighlight();
}
tr.Commit();
}
if (!blockFound)
{
return(false);
}
return(true);
}
return(false);
}
public GivenACosmosConnection()
{
someDummyDocument = new DummyCosmosDocument
{
Id = someDocumentId,
Data = someDocumentData,
ETag = someDocumentETag,
SelfLink = someSelfLink
};
jsonSerializerSettings = new JsonSerializerSettings();
someRequestOptions = new RequestOptions();
someFeedOptions = new FeedOptions();
someDocument = new Document();
someDocument.LoadFrom(new JsonTextReader(new StringReader(JsonConvert.SerializeObject(someDummyDocument))), jsonSerializerSettings);
someCollectionUri = UriFactory.CreateDocumentCollectionUri(someDatabaseId, someCollectionId);
someDocumentUri = UriFactory.CreateDocumentUri(someDatabaseId, someCollectionId, someDocumentId);
connectionPolicy = new ConnectionPolicy();
retryOptions = new Mock <RetryOptions>();
retryOptions.Object.MaxRetryAttemptsOnThrottledRequests = 9;
retryOptions.Object.MaxRetryWaitTimeInSeconds = 30;
connectionPolicy.RetryOptions = retryOptions.Object;
documentClient = new Mock <IDocumentClient>();
documentClient.Setup(x => x.ConnectionPolicy).Returns(connectionPolicy);
documentClient.Setup(x => x.CreateDocumentAsync(someCollectionUri, someDummyDocument, It.IsAny <RequestOptions>(), It.IsAny <bool>(), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(new ResourceResponse <Document>(someDocument)));
documentClient.Setup(x => x.CreateDocumentQuery <DummyCosmosDocument>(someCollectionUri, It.IsAny <FeedOptions>()))
.Returns(new List <DummyCosmosDocument> {
someDummyDocument
}.AsQueryable().OrderBy(d => d.Id));
documentClient.Setup(x => x.CreateDocumentQuery <DummyCosmosDocument>(someCollectionUri, It.IsAny <SqlQuerySpec>(), It.IsAny <FeedOptions>()))
.Returns(new List <DummyCosmosDocument> {
someDummyDocument
}.AsQueryable().OrderBy(d => d.Id));
databaseFactory = new Mock <IDatabaseFactory>();
databaseFactory.Setup(x => x.DocumentClient()).Returns(documentClient.Object);
someDocumentCollection = new DocumentCollection
{
Id = someCollectionId
};
bulkExecutor = new Mock <IBulkExecutor>();
bulkExecutorWrapper = new Mock <IBulkExecutorWrapper>();
someBulkImportResponse = new BulkImportResponse();
bulkExecutor
.Setup(b => b.BulkImportAsync(It.Is <IEnumerable <CosmosDocumentBase> >(l => l.Count() == 1), true, false, null, null, default))
.Callback(() =>
{
someBulkImportResponse.GetType().GetProperty("NumberOfDocumentsImported").SetValue(someBulkImportResponse, 1);
someBulkImportResponse.GetType().GetProperty("TotalRequestUnitsConsumed").SetValue(someBulkImportResponse, 1);
someBulkImportResponse.GetType().GetProperty("TotalTimeTaken").SetValue(someBulkImportResponse, TimeSpan.FromSeconds(10));
})
.Returns(Task.FromResult(someBulkImportResponse));
bulkExecutor
.Setup(b => b.BulkImportAsync(It.Is <IEnumerable <CosmosDocumentBase> >(l => l.Count() == 2), true, false, null, null, default))
.Callback(() =>
{
someBulkImportResponse.GetType().GetProperty("NumberOfDocumentsImported").SetValue(someBulkImportResponse, 2);
someBulkImportResponse.GetType().GetProperty("TotalRequestUnitsConsumed").SetValue(someBulkImportResponse, 2);
someBulkImportResponse.GetType().GetProperty("TotalTimeTaken").SetValue(someBulkImportResponse, TimeSpan.FromSeconds(20));
})
.Returns(Task.FromResult(someBulkImportResponse));
someDatabaseUri = UriFactory.CreateDatabaseUri(someDatabaseId);
documentClient.Setup(x => x.CreateDocumentCollectionQuery(someDatabaseUri, It.IsAny <FeedOptions>()))
.Returns(new List <DocumentCollection> {
someDocumentCollection
}.AsQueryable().OrderBy(x => x.PartitionKey));
databaseFactory.Setup(x => x.DocumentClient()).Returns(documentClient.Object);
databaseFactory.Setup(x => x.BulkExecutor(documentClient.Object, someDocumentCollection)).Returns(bulkExecutor.Object);
databaseFactory.Setup(x => x.BulkExecutorWrapper(bulkExecutor.Object)).Returns(bulkExecutorWrapper.Object);
sut = new CosmosConnection(databaseFactory.Object, someDatabaseId, someBatchBulkSize);
}
private async Task GetStartedDemo()
{
this.client = new DocumentClient(new Uri(EndpointUri), PrimaryKey);
try
{
await this.client.DeleteDatabaseAsync(UriFactory.CreateDatabaseUri(DatabaseName));
}
catch (DocumentClientException dce)
{
Console.WriteLine("Database not found!");
}
await this.client.CreateDatabaseIfNotExistsAsync(new Database { Id = DatabaseName });
DocumentCollection collectionDefinition = new DocumentCollection
{
Id = CollectionName
};
collectionDefinition.IndexingPolicy.Automatic = true;
collectionDefinition.DefaultTimeToLive = -1; // switch on TTL but no default expiry time
collectionDefinition.PartitionKey.Paths.Add("/moduleId");
// performance / load testing on indexes
collectionDefinition.IndexingPolicy.IncludedPaths.Add(
new IncludedPath
{
Path = "/*",
Indexes = new Collection <Index>
{
new RangeIndex(DataType.Number)
{
Precision = -1, DataType = DataType.Number
},
new RangeIndex(DataType.String)
{
Precision = -1, DataType = DataType.String
}
}
});
collectionDefinition.IndexingPolicy.ExcludedPaths.Add(new ExcludedPath {
Path = "/newObject/?"
});
collectionDefinition.IndexingPolicy.ExcludedPaths.Add(new ExcludedPath {
Path = "/previousObject/?"
});
DocumentCollection auditCollection = await this.client.CreateDocumentCollectionIfNotExistsAsync(
UriFactory.CreateDatabaseUri(DatabaseName),
collectionDefinition,
new RequestOptions { OfferThroughput = 20000 });
List <AuditEvent> AuditEvents = AuditEventFactory.GeneratAuditEvents(10, 10, 5);
await CreateAuditRecords(AuditEvents);
ExecuteSimpleQuery();
ExecuteTextSearch();
ExecuteSqlStringSearch();
ExecuteDateSearch();
}
public GraphObjectGraphRepository(DocumentClient documentClient, DocumentCollection documentCollection) : base(documentClient, documentCollection)
{
}
public async static Task PopulateLimitedIndexesCollection(List <DgProvider> narrowProviders)
{
Uri uri = UriFactory.CreateDocumentCollectionUri(BhProvidersDatabaseDa.DatabaseName, BhProvidersDatabaseDa.CollectionNames.LimtedIndexes.ToString());
//Delete collection if exists
bool exists = BhProvidersDatabaseDa.DocumentClient.CreateDocumentCollectionQuery(BhProvidersDatabaseDa.DatabaseUri)
.ToList()
.Exists(c => c.Id == BhProvidersDatabaseDa.CollectionNames.LimtedIndexes.ToString());
if (exists)
{
await BhProvidersDatabaseDa.DocumentClient.DeleteDocumentCollectionAsync(uri);
}
//Set throughput and partition key
int reservedRUs = 9000;
string partitionKey = "/locations[0].zip";
PartitionKeyDefinition partitionKeyDefinition = new PartitionKeyDefinition();
partitionKeyDefinition.Paths.Add(partitionKey); //Weird. Cannot have more than one partition key...
RequestOptions requestOptions = new RequestOptions {
OfferThroughput = reservedRUs
};
DocumentCollection limitedIndexesCollection = new DocumentCollection {
Id = BhProvidersDatabaseDa.CollectionNames.LimtedIndexes.ToString()
};
limitedIndexesCollection.IndexingPolicy.IncludedPaths = new System.Collections.ObjectModel.Collection <IncludedPath>();
limitedIndexesCollection.IndexingPolicy.IncludedPaths.Add
(new IncludedPath
{
Indexes = new System.Collections.ObjectModel.Collection <Index>
{
new HashIndex(DataType.String)
{
Precision = -1
},
new RangeIndex(DataType.String)
{
Precision = -1
}
},
Path = "/whateverPath/*"
});
limitedIndexesCollection.IndexingPolicy.IndexingMode = IndexingMode.Lazy;
ResourceResponse <DocumentCollection> response = await BhProvidersDatabaseDa.DocumentClient.CreateDocumentCollectionAsync(
BhProvidersDatabaseDa.DatabaseUri,
new DocumentCollection
{
Id = BhProvidersDatabaseDa.CollectionNames.LimtedIndexes.ToString(),
PartitionKey = partitionKeyDefinition
},
requestOptions
);
DocumentCollection collection = response.Resource;
DocumentCollection narrowProviderCollection = new DocumentCollection {
Id = BhProvidersDatabaseDa.CollectionNames.DgNarrowProviders.ToString()
};
narrowProviderCollection.IndexingPolicy.IndexingMode = IndexingMode.Lazy;
/* Index index = new Index();
* narrowProviderCollection.IndexingPolicy.IncludedPaths = new System.Collections.ObjectModel.Collection<IncludedPath>()
* {
* new IncludedPath
* {
* Indexes = new System.Collections.ObjectModel.Collection<Index>()
* { new ;
*/
await BhProvidersDatabaseDa.CreateCollection(BhProvidersDatabaseDa.CollectionNames.DgNarrowProviders);
foreach (DgProvider provider in filteredProviders)
{
DataModels.Narrow.DgProvider narrow = provider;
Task <ResourceResponse <Document> > task = BhProvidersDatabaseDa.DocumentClient.CreateDocumentAsync(uri, narrow);
}
Console.WriteLine($"Received {filteredProviders.Count}");
}
public void ContainerSettingsWithIndexingPolicyTest()
{
string id = Guid.NewGuid().ToString();
string pkPath = "/partitionKey";
// Two equivalent definitions
ContainerProperties cosmosContainerSettings = new ContainerProperties(id, pkPath);
cosmosContainerSettings.IndexingPolicy.Automatic = true;
cosmosContainerSettings.IndexingPolicy.IncludedPaths.Add(new Cosmos.IncludedPath()
{
Path = "/id1/*"
});
Cosmos.UniqueKey cuk1 = new Cosmos.UniqueKey();
cuk1.Paths.Add("/u1");
cosmosContainerSettings.UniqueKeyPolicy.UniqueKeys.Add(cuk1);
DocumentCollection collection = new DocumentCollection()
{
Id = id,
PartitionKey = new PartitionKeyDefinition()
{
Paths = new Collection <string>()
{
pkPath
},
}
};
collection.IndexingPolicy.Automatic = true;
collection.IndexingPolicy.IncludedPaths.Add(new Documents.IncludedPath()
{
Path = "/id1/*"
});
Documents.UniqueKey duk1 = new Documents.UniqueKey();
duk1.Paths.Add("/u1");
collection.UniqueKeyPolicy.UniqueKeys.Add(duk1);
string cosmosSerialized = SettingsContractTests.CosmosSerialize(cosmosContainerSettings);
string directSerialized = SettingsContractTests.DirectSerialize(collection);
// Swap de-serialize and validate
ContainerProperties containerDeserSettings = SettingsContractTests.CosmosDeserialize <ContainerProperties>(directSerialized);
DocumentCollection collectionDeser = SettingsContractTests.DirectDeSerialize <DocumentCollection>(cosmosSerialized);
Assert.AreEqual(collection.Id, containerDeserSettings.Id);
Assert.AreEqual(collection.PartitionKey.Paths[0], containerDeserSettings.PartitionKeyPath);
Assert.AreEqual(collection.IndexingPolicy.Automatic, containerDeserSettings.IndexingPolicy.Automatic);
Assert.AreEqual(collection.IndexingPolicy.IncludedPaths.Count, containerDeserSettings.IndexingPolicy.IncludedPaths.Count);
Assert.AreEqual(collection.IndexingPolicy.IncludedPaths[0].Path, containerDeserSettings.IndexingPolicy.IncludedPaths[0].Path);
Assert.AreEqual(collection.IndexingPolicy.IncludedPaths[0].Indexes.Count, containerDeserSettings.IndexingPolicy.IncludedPaths[0].Indexes.Count);
Assert.AreEqual(collection.UniqueKeyPolicy.UniqueKeys.Count, containerDeserSettings.UniqueKeyPolicy.UniqueKeys.Count);
Assert.AreEqual(collection.UniqueKeyPolicy.UniqueKeys[0].Paths.Count, containerDeserSettings.UniqueKeyPolicy.UniqueKeys[0].Paths.Count);
Assert.AreEqual(collection.UniqueKeyPolicy.UniqueKeys[0].Paths[0], containerDeserSettings.UniqueKeyPolicy.UniqueKeys[0].Paths[0]);
Assert.AreEqual(cosmosContainerSettings.Id, collectionDeser.Id);
Assert.AreEqual(cosmosContainerSettings.PartitionKeyPath, collectionDeser.PartitionKey.Paths[0]);
Assert.AreEqual(cosmosContainerSettings.IndexingPolicy.Automatic, collectionDeser.IndexingPolicy.Automatic);
Assert.AreEqual(cosmosContainerSettings.IndexingPolicy.IncludedPaths.Count, collectionDeser.IndexingPolicy.IncludedPaths.Count);
Assert.AreEqual(cosmosContainerSettings.IndexingPolicy.IncludedPaths[0].Path, collectionDeser.IndexingPolicy.IncludedPaths[0].Path);
Assert.AreEqual(cosmosContainerSettings.IndexingPolicy.IncludedPaths[0].Indexes.Count, collectionDeser.IndexingPolicy.IncludedPaths[0].Indexes.Count);
Assert.AreEqual(cosmosContainerSettings.UniqueKeyPolicy.UniqueKeys.Count, collectionDeser.UniqueKeyPolicy.UniqueKeys.Count);
Assert.AreEqual(cosmosContainerSettings.UniqueKeyPolicy.UniqueKeys[0].Paths.Count, collectionDeser.UniqueKeyPolicy.UniqueKeys[0].Paths.Count);
Assert.AreEqual(cosmosContainerSettings.UniqueKeyPolicy.UniqueKeys[0].Paths[0], collectionDeser.UniqueKeyPolicy.UniqueKeys[0].Paths[0]);
}
public CosmicGraphClient(DocumentClient documentClient, DocumentCollection collection)
{
this.documentClient = documentClient;
this.collection = collection;
}
public static Uri ToDocumentCollectionUri(this DocumentCollection documentCollection) =>
UriFactory.CreateDocumentCollectionUri("BryceMountainPatrol", documentCollectionMap[documentCollection]);
public async Task <IEnumerable <string> > buildDB()
{
var results = new List <string>();
Microsoft.Azure.Documents.Database database = await client.CreateDatabaseIfNotExistsAsync(new Database { Id = "graphdb" });
DocumentCollection graph = await client.CreateDocumentCollectionIfNotExistsAsync(
UriFactory.CreateDatabaseUri("graphdb"),
new DocumentCollection { Id = "Persons" },
new RequestOptions { OfferThroughput = 400 });
Dictionary <string, string> gremlinQueries = new Dictionary <string, string>
{
{ "Cleanup", "g.V().drop()" },
{ "AddAdam", "g.addV('person').property('id', 'Adam').property('Name', 'Adam')" },
{ "AddEve", "g.addV('person').property('id', 'Eve').property('Name', 'Eve')" },
{ "AddCain", "g.addV('person').property('id', 'Cain').property('Name', 'Cain')" },
{ "AddAbel", "g.addV('person').property('id', 'Abel').property('Name', 'Abel')" },
{ "AddSeth", "g.addV('person').property('id', 'Seth').property('Name', 'Seth')" },
{ "AddEnosh", "g.addV('person').property('id', 'Enosh').property('Name', 'Enosh')" },
{ "AddAdam+Eve", "g.V('Adam').addE('Married').to(g.V('Eve'))" },
{ "AddCain->Abel", "g.V('Cain').addE('Brother').to(g.V('Abel'))" },
{ "AddCain->Seth", "g.V('Cain').addE('Brother').to(g.V('Seth'))" },
{ "AddAbel->Seth", "g.V('Abel').addE('Brother').to(g.V('Seth'))" },
{ "AddEve->Abel", "g.V('Eve').addE('Mother').to(g.V('Abel'))" },
{ "AddEve->Cain", "g.V('Eve').addE('Mother').to(g.V('Cain'))" },
{ "AddEve->Seth", "g.V('Eve').addE('Mother').to(g.V('Seth'))" },
{ "AddAdam->Abel", "g.V('Adam').addE('Father').to(g.V('Abel'))" },
{ "AddAdam->Cain", "g.V('Adam').addE('Father').to(g.V('Cain'))" },
{ "AddAdam->Seth", "g.V('Adam').addE('Father').to(g.V('Seth'))" },
{ "AddSeth->Enosh", "g.V('Seth').addE('Father').to(g.V('Enosh'))" },
{ "UpdateAbel1", "g.V('Abel').property('Profession', 'Shepherd')" },
{ "UpdateCain1", "g.V('Cain').property('Profession', 'Farmer')" },
{ "UpdateAdam", "g.V('Adam').property('Max Age', '930').property('Born', '4026 BCE').property('Died', '3096 BCE').property('Name Means', 'Earthling Man; Mankind; Humankind; from a root meaning \"red\"')" },
{ "UpdateAdamFatherAge", "g.V('Adam').outE('Father').as('e').inV().has('Name', 'Seth').select('e').property('Age', '130')" }
};
foreach (KeyValuePair <string, string> gremlinQuery in gremlinQueries)
{
results.Add($"Running {gremlinQuery.Key}: {gremlinQuery.Value}");
// The CreateGremlinQuery method extensions allow you to execute Gremlin queries and iterate
// results asychronously
IDocumentQuery <dynamic> query = client.CreateGremlinQuery <dynamic>(graph, gremlinQuery.Value);
while (query.HasMoreResults)
{
foreach (dynamic result in await query.ExecuteNextAsync())
{
results.Add($"\t {JsonConvert.SerializeObject(result)}");
}
}
results.Add("");
}
return(results);
}
public async Task <IHttpActionResult> GetInfo(string info)
{
DocumentCollection graph = await client.CreateDocumentCollectionIfNotExistsAsync(
UriFactory.CreateDatabaseUri("graphdb"),
new DocumentCollection { Id = "Persons" },
new RequestOptions { OfferThroughput = 400 });
string grem = $"g.V('{info}')";
IDocumentQuery <dynamic> query = client.CreateGremlinQuery <dynamic>(graph, grem);
var vert = new List <dynamic>();
var eMe = new List <dynamic>();
var eOther = new List <dynamic>();
while (query.HasMoreResults)
{
foreach (dynamic result in await query.ExecuteNextAsync())
{
vert.Add(result);
}
}
grem = $"g.V('{info}').outE()";
query = client.CreateGremlinQuery <dynamic>(graph, grem);
while (query.HasMoreResults)
{
string inV = "", label = "", outV = "";
foreach (dynamic result in await query.ExecuteNextAsync())
{
foreach (KeyValuePair <string, JToken> child in (result as JObject))
{
if (child.Key == "inV")
{
inV = (child.Value as JToken).Value <string>();
}
else if (child.Key == "label")
{
label = (child.Value as JToken).Value <string>();
}
else if (child.Key == "outV")
{
outV = (child.Value as JToken).Value <string>();
}
}
eMe.Add(new { outV, label, inV });
}
}
grem = $"g.V('{info}').inE()";
query = client.CreateGremlinQuery <dynamic>(graph, grem);
while (query.HasMoreResults)
{
string inV = "", label = "", outV = "";
foreach (dynamic result in await query.ExecuteNextAsync())
{
foreach (KeyValuePair <string, JToken> child in (result as JObject))
{
if (child.Key == "inV")
{
inV = (child.Value as JToken).Value <string>();
}
else if (child.Key == "label")
{
label = (child.Value as JToken).Value <string>();
}
else if (child.Key == "outV")
{
outV = (child.Value as JToken).Value <string>();
}
}
eOther.Add(new { inV, label, outV });
}
}
string marriedTo = "";
List <dynamic> family = new List <dynamic>();
if (eMe.Any(z => z.label == "Married"))
{
marriedTo = eMe.First(z => z.label == "Married").inV;
eMe.Remove(eMe.First(z => z.label == "Married"));
}
else if (eOther.Any(z => z.label == "Married"))
{
marriedTo = eOther.First(z => z.label == "Married").outV;
eOther.Remove(eOther.First(z => z.label == "Married"));
}
if (eMe.Any(z => z.label == "Father"))
{
family.AddRange(eMe.Where(z => z.label == "Father").Select(z => new { type = "Child", name = (string)z.inV }).ToList());
eMe.RemoveAll((z) => { return(z.label == "Father"); });
}
else if (eMe.Any(z => z.label == "Mother"))
{
family.AddRange(eMe.Where(z => z.label == "Mother").Select(z => new { type = "Child", name = (string)z.inV }).ToList());
eMe.RemoveAll((z) => { return(z.label == "Mother"); });
}
if (eOther.Any(z => z.label == "Father"))
{
family.AddRange(eOther.Where(z => z.label == "Father").Select(z => new { type = "Father", name = (string)z.outV }).ToList());
eOther.RemoveAll((z) => { return(z.label == "Father"); });
}
if (eOther.Any(z => z.label == "Mother"))
{
family.AddRange(eOther.Where(z => z.label == "Mother").Select(z => new { type = "Mother", name = (string)z.outV }).ToList());
eOther.RemoveAll((z) => { return(z.label == "Mother"); });
}
if (eMe.Any(z => z.label == "Sister"))
{
family.AddRange(eMe.Where(z => z.label == "Sister").Select(z => new { type = "Sister", name = (string)z.outV }).ToList());
eMe.RemoveAll((z) => { return(z.label == "Sister"); });
}
else if (eMe.Any(z => z.label == "Brother"))
{
family.AddRange(eMe.Where(z => z.label == "Brother").Select(z => new { type = "Brother", name = (string)z.outV }).ToList());
eMe.RemoveAll((z) => { return(z.label == "Brother"); });
}
if (eOther.Any(z => z.label == "Sister"))
{
family.AddRange(eOther.Where(z => z.label == "Sister").Select(z => new { type = "Sister", name = (string)z.inV }).ToList());
eOther.RemoveAll((z) => { return(z.label == "Sister"); });
}
else if (eOther.Any(z => z.label == "Brother"))
{
family.AddRange(eOther.Where(z => z.label == "Brother").Select(z => new { type = "Brother", name = (string)z.inV }).ToList());
eOther.RemoveAll((z) => { return(z.label == "Brother"); });
}
return(Ok(new { vert, eMe, eOther, marriedTo, family }));
}
public void TestSetup()
{
databaseName = ConfigurationManager.AppSettings["DatabaseAccountId"];
collectionName = Guid.NewGuid().ToString();
partitionedCollectionName = Guid.NewGuid().ToString();
databaseUri = UriFactory.CreateDatabaseUri(databaseName);
collectionUri = UriFactory.CreateDocumentCollectionUri(databaseName, collectionName);
partitionedCollectionUri = UriFactory.CreateDocumentCollectionUri(databaseName, partitionedCollectionName);
Database database = documentClient.CreateDatabaseIfNotExistsAsync(new Database()
{
Id = databaseName
}).Result.Resource;
DocumentCollection newCollection = new DocumentCollection()
{
Id = collectionName
};
try
{
documentClient.CreateDocumentCollectionAsync(databaseUri, newCollection, new RequestOptions {
OfferThroughput = 400
}).Wait();
}
catch (DocumentClientException ex)
{
if (ex.StatusCode == System.Net.HttpStatusCode.ServiceUnavailable)
{
// Emulator con sometimes fail under load, so we retry
Task.Delay(1000);
documentClient.CreateDocumentCollectionAsync(databaseUri, newCollection, new RequestOptions {
OfferThroughput = 400
}).Wait();
}
}
DocumentCollection partitionedCollection = new DocumentCollection()
{
Id = partitionedCollectionName,
PartitionKey = new PartitionKeyDefinition()
{
Paths = new Collection <string> {
"/pk"
},
}
};
try
{
documentClient.CreateDocumentCollectionAsync(databaseUri, partitionedCollection, new RequestOptions {
OfferThroughput = 10000
}).Wait();
}
catch (DocumentClientException ex)
{
if (ex.StatusCode == System.Net.HttpStatusCode.ServiceUnavailable)
{
// Emulator con sometimes fail under load, so we retry
Task.Delay(1000);
documentClient.CreateDocumentCollectionAsync(databaseUri, partitionedCollection, new RequestOptions {
OfferThroughput = 10000
}).Wait();
}
}
}
public override void Load(string contentId, ScaleSettingsNodeViewModel node, Connection connection, DocumentCollection collection)
{
IsLoading = true;
ContentId = contentId;
Node = node;
Title = node.Name;
Header = node.Name;
Connection = connection;
Collection = collection;
var split = Collection.AltLink.Split(new char[] { '/' });
ToolTip = $"{split[1]}>{split[3]}";
AccentColor = Connection.AccentColor;
SetInformation();
IsLoading = false;
}
public void ScreenShotCommand() // This method can have any name
{
DocumentCollection acDocMgr = cadApplication.DocumentManager;
Document document = cadApplication.DocumentManager.MdiActiveDocument;
string fileName = string.Empty;
if (acDocMgr.Count > 1)
{
MessageBox.Show("已经有编辑的源文件在编辑,请手动关闭当前编辑的文件！");
return;
}
else if (acDocMgr.Count == 1)
{
string[] args = Environment.GetCommandLineArgs();
if (args.Length < 5)
{
cadApplication.ShowAlertDialog("参数传递错误！");
return;
}
fileName = args[1];
Environment.SetEnvironmentVariable("fileName", fileName);
/// 如果是只有一个文档的话，且为源文件的话
string curDocName = document.Name;
if (curDocName.Contains(fileName))
{
if (File.Exists(curDocName) &&
curDocName.IndexOf(orgDwgextesion) > -1)
{
string fName = curDocName.Replace(orgDwgextesion, dwgExtesion);
if (File.Exists(fName))
{
File.Delete(fName);
}
}
else if (File.Exists(curDocName) &&
curDocName.IndexOf(orgDwgextesion) < 0)
{
string fName = curDocName.Replace(dwgExtesion, orgDwgextesion);
if (File.Exists(fName))
{
File.Delete(fName);
}
}
}
}
string newFileName = fileName.Replace(dwgExtesion, orgDwgextesion);
Database db = HostApplicationServices.WorkingDatabase;
Editor ed = cadApplication.DocumentManager.MdiActiveDocument.Editor;
/// 当前最新位置的Polyline
ObjectId objId = new ObjectId();
Polyline pl = (Polyline)AutoCADHelper.GetObjFromDic(ref objId, "redId", db, ed);
if (pl == null)
{
return;
}
///保留剪切前的文件
if (!File.Exists(fileName))
{
db.SaveAs(fileName, DwgVersion.Current);
}
else
{
db.SaveAs(newFileName, DwgVersion.Current);
}
//MessageBox.Show(newFileName);
///实行剪切操作
AutoCADHelper.TrimMap(pl);
/// 矩形右上角的点
Point2d pThird = pl.GetPoint2dAt(2);
/// 矩形左下角的点
Point2d pFirst = pl.GetPoint2dAt(0);
PromptSelectionResult result = ed.SelectCrossingWindow(
new Point3d(pFirst.X + 10, pFirst.Y + 10, 0),
new Point3d(pThird.X - 10, pThird.Y - 10, 0));
if (result.Status == PromptStatus.Error)
{
cadApplication.ShowAlertDialog("没有选中坐标点！");
}
else if (result.Status == PromptStatus.OK)
{
///剪切一些没有剪切干净的图形
///选中所有的实体对象
PromptSelectionResult resultAll = ed.SelectAll();
using (Transaction trans = document.TransactionManager.StartTransaction())
{
ObjectId[] sIds = result.Value.GetObjectIds();
List <ObjectId> oIds = sIds.ToList <ObjectId>();
foreach (ObjectId pid in resultAll.Value.GetObjectIds())
{
if (!oIds.Contains(pid))
{
Entity ent = trans.GetObject(pid, OpenMode.ForWrite) as Entity;
if (ent == null)
{
continue;
}
ent.Erase();
}
}
trans.Commit();
}
//if (!File.Exists(fileName))
//{
// db.SaveAs(fileName, DwgVersion.Current);
//}
//else
//{
// CADTools.RunCommand(true, "_qsave", "");
//}
}
}
public void ProcessBlock()
{
double insPnt_X = 0d;
double insPnt_Y = 0d;
Document bDwg = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.MdiActiveDocument;
Autodesk.AutoCAD.DatabaseServices.TransactionManager bTransMan = bDwg.TransactionManager;
Editor ed = bDwg.Editor;
string path = Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory);
string[] familyFiles = Directory.GetFiles(path + "\\fixtures", "*.dwg", SearchOption.TopDirectoryOnly);
ed.WriteMessage("\nUsing directory {0}", path + "\\fixtures");
try
{
DocumentCollection acDocMgr = Application.DocumentManager;
foreach (string familyFile in familyFiles)
{
string equipmentNumber = Path.GetFileNameWithoutExtension(familyFile);
Document doc = acDocMgr.Open(familyFile, false);
if (doc != null)
{
doc.LockDocument();
ed.WriteMessage("\nProcessing {0}", equipmentNumber);
ExplodeBlockByNameCommand(ed, doc, equipmentNumber);
doc.CloseAndSave(familyFile);
doc.Dispose();
}
else
{
ed.WriteMessage("\nCould not open {0}", equipmentNumber);
}
using (bDwg.LockDocument())
using (Transaction bTrans = bTransMan.StartTransaction())
{
Database blkDb = new Database(false, true);
blkDb.ReadDwgFile(familyFile, System.IO.FileShare.Read, true, ""); //Reading block source file
string name = Path.GetFileNameWithoutExtension(familyFile);
ObjectId oid = bDwg.Database.Insert(name, blkDb, true);
using (BlockReference acBlkRef = new BlockReference(new Point3d(insPnt_X, insPnt_Y, 0), oid))
{
BlockTableRecord acCurSpaceBlkTblRec;
acCurSpaceBlkTblRec = bTrans.GetObject(bDwg.Database.CurrentSpaceId, OpenMode.ForWrite) as BlockTableRecord;
acCurSpaceBlkTblRec.AppendEntity(acBlkRef);
bTrans.AddNewlyCreatedDBObject(acBlkRef, true);
}
bTrans.Commit();
}
insPnt_X += 240d;
if (insPnt_X > 2400)
{
insPnt_X = 0;
insPnt_Y += 240d;
}
}
}
catch (System.Exception err)
{
ed.WriteMessage("\nSomething went wrong in main process.");
File.AppendAllText(Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory) + "\\error_main.log", err.ToString());
}
finally
{
}
}
public RestaurantRegisteredEventHandler(DocumentCollection documentCollection,
ITableDataProvider tableDataProvider)
{
_documentCollection = documentCollection;
_tableDataProvider = tableDataProvider;
}
public ConseillerGraphRepository(DocumentClient documentClient, DocumentCollection documentCollection) : base(documentClient, documentCollection)
{
}
public async Task <IEnumerable <KeyValuePair <string, Document> > > GetAllDocumentsAsync(DocumentCollection keysCollection, BucketNamespace bucketNamespace)
{
if (keysCollection.Total == 0)
{
return(null);
}
try
{
string @namespace = GetNamespaceAsString(bucketNamespace);
var pairsCollection = new List <KeyValuePair <string, Document> >();
foreach (var key in keysCollection.Items)
{
var command = new Command
{
Id = EnvelopeId.NewId(),
To = Node.Parse("*****@*****.**"),
Uri = new LimeUri($"/{@namespace}/{key}"),
Method = CommandMethod.Get
};
var envelopeResult = await RunCommandAsync(command);
var document = envelopeResult.Resource;
pairsCollection.Add(new KeyValuePair <string, Document>(key.ToString(), document));
}
return(pairsCollection);
}
catch (HttpRequestException e)
{
Console.WriteLine("\nException Caught!");
Console.WriteLine("Message :{0} ", e.Message);
return(null);
}
}
public void Execute()
{
CheckDisposed();
// Configure with defaults if not already configured
if (_configurator == null)
{
Configure();
}
// Create the input and output folders if they don't already exist
if (!Directory.Exists(InputFolder))
{
Directory.CreateDirectory(InputFolder);
}
if (!Directory.Exists(OutputFolder))
{
Directory.CreateDirectory(OutputFolder);
}
try
{
Stopwatch engineStopwatch = Stopwatch.StartNew();
using (Trace.WithIndent().Information("Executing {0} pipelines", _pipelines.Count))
{
// Setup (clear the document collection and reset cache counters)
DocumentCollection.Clear();
ExecutionCacheManager.ResetEntryHits();
// Enumerate pipelines and execute each in order
int c = 1;
foreach (Pipeline pipeline in _pipelines.Pipelines)
{
Stopwatch pipelineStopwatch = Stopwatch.StartNew();
using (Trace.WithIndent().Information("Executing pipeline \"{0}\" ({1}/{2}) with {3} child module(s)", pipeline.Name, c, _pipelines.Count, pipeline.Count))
{
pipeline.Execute();
pipelineStopwatch.Stop();
Trace.Information("Executed pipeline \"{0}\" ({1}/{2}) in {3} ms resulting in {4} output document(s)",
pipeline.Name, c++, _pipelines.Count, pipelineStopwatch.ElapsedMilliseconds,
DocumentCollection.FromPipeline(pipeline.Name).Count());
}
}
// Clean up (clear unhit cache entries, dispose documents)
// Note that disposing the documents immediately after engine execution will ensure write streams get flushed and released
// but will also mean that callers (and tests) can't access documents and document content after the engine finishes
// Easiest way to access content after engine execution is to add a final Meta module and copy content to metadata
ExecutionCacheManager.ClearUnhitEntries(this);
foreach (Pipeline pipeline in _pipelines.Pipelines)
{
pipeline.ResetClonedDocuments();
}
engineStopwatch.Stop();
Trace.Information("Executed {0} pipelines in {1} ms",
_pipelines.Count, engineStopwatch.ElapsedMilliseconds);
}
}
catch (Exception ex)
{
Trace.Verbose("Exception while executing pipelines: {0}", ex);
throw;
}
}
static public void Plan2HoePrSelHkBlockAndAtt()
{
try
{
if (!OpenHoePrPalette())
{
return;
}
var opts = Globs.TheHoePrOptions;
Document doc = Application.DocumentManager.MdiActiveDocument;
using (DocumentLock m_doclock = doc.LockDocument())
{
DocumentCollection dm = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager;
if (doc == null)
{
return;
}
Editor ed = doc.Editor;
#if NEWSETFOCUS
doc.Window.Focus();
#else
Autodesk.AutoCAD.Internal.Utils.SetFocusToDwgView(); // previous 2014 AutoCAD - Versions
#endif
PromptNestedEntityResult per = ed.GetNestedEntity("\nHöhenkotenblock wählen: ");
if (per.Status == PromptStatus.OK)
{
using (var tr = doc.TransactionManager.StartTransaction())
{
DBObject obj = tr.GetObject(per.ObjectId, OpenMode.ForRead);
BlockReference br = obj as BlockReference;
if (br == null)
{
br = Plan2Ext.Globs.GetBlockFromItsSubentity(tr, per);
if (br == null)
{
return;
}
}
opts.SetHKBlockname(br.Name);
tr.Commit();
}
per = ed.GetNestedEntity("\nHöhen-Attribut wählen: ");
if (per.Status != PromptStatus.OK)
{
return;
}
using (var tr = doc.TransactionManager.StartTransaction())
{
DBObject obj = tr.GetObject(per.ObjectId, OpenMode.ForRead);
AttributeReference ar = obj as AttributeReference;
if (ar == null)
{
return;
}
opts.SetHoehenAtt(ar.Tag);
tr.Commit();
}
}
}
}
catch (System.Exception ex)
{
Application.ShowAlertDialog(string.Format(CultureInfo.CurrentCulture, "Fehler in Plan2HoePrSelHkBlockAndAtt aufgetreten! {0}", ex.Message));
}
}
private static async Task DeleteCourse(Guid guid, DocumentCollection documentCollection)
{
DocumentClient documentClient = new DocumentClient(new Uri("https://schooltest.documents.azure.com:443/"),
"Of414DnEibhmqeSTB0pKShdQtR6dxxfXP8uT93pggxoumKthJGzuECCUJZ27Pqf846VUkFfOrraMTQ74PZaywA==");
Course course = documentClient.CreateDocumentQuery<Course>(documentCollection.DocumentsLink,
new SqlQuerySpec(string.Format("SELECT * FROM c WHERE c.CourseId = '{0}'", guid))).AsEnumerable().FirstOrDefault();
if (course == null)
return;
await documentClient.DeleteDocumentAsync(course.SelfLink);
}
