public static CdmManifestDeclarationDefinition FromData(CdmCorpusContext ctx, DatabaseEntity obj)
{
var name = obj.Name.Replace(".manifest.cdm.json", "");
var newManifestDoc = ctx.Corpus.MakeObject <CdmManifestDeclarationDefinition>(CdmObjectType.ManifestDeclarationDef, name);
newManifestDoc.Definition = name + "/" + name + ".manifest.cdm.json";
DatabaseProperties databaseProperties = ((JToken)obj.Properties).ToObject <DatabaseProperties>();
if (databaseProperties.Properties != null)
{
if (databaseProperties.Properties.ContainsKey("cdm:lastFileStatusCheckTime"))
{
newManifestDoc.LastFileStatusCheckTime = DateTimeOffset.Parse(databaseProperties.Properties["cdm:lastFileStatusCheckTime"].ToObject <string>());
}
if (databaseProperties.Properties.ContainsKey("cdm:lastFileModifiedTime"))
{
newManifestDoc.LastFileModifiedTime = DateTimeOffset.Parse(databaseProperties.Properties["cdm:lastFileModifiedTime"].ToObject <string>());
}
if (databaseProperties.Properties.ContainsKey("cdm:explanation"))
{
newManifestDoc.Explanation = databaseProperties.Properties["cdm:explanation"].ToObject <string>();
}
}
return(newManifestDoc);
}
public Database()
: base(ObjectType1.Database)
{
//AllObjects = new SearchSchemaBase();
Assemblies = new SchemaList<Assembly, Database>(this);
ClrFunctions = new SchemaList<ClrFunction, Database>(this);
ClrProcedures = new SchemaList<ClrStoreProcedure, Database>(this);
//DdlTriggers = new SchemaList<Trigger, Database>(this);
Defaults = new SchemaList<Default, Database>(this);
//Dependencies = new Dependencies();
FileGroups = new SchemaList<FileGroup, Database>();
FullText = new SchemaList<FullText, Database>(this);
//Functions = new SchemaList<Function, Database>(this);
//IsCaseSensitive = true;
//Options =
PartitionFunctions = new SchemaList<PartitionFunction, Database>(this);
PartitionSchemes = new SchemaList<PartitionScheme, Database>(this);
Procedures = new SchemaList<StoreProcedure, Database>(this);
Properties = new DatabaseProperties();
//Roles = new SchemaList<Role, Database>();
Rules = new SchemaList<Rule, Database>(this);
Schemas = new SchemaList<SchemaObsolete, Database>(this);
Synonyms = new SchemaList<Synonym, Database>(this);
//Tables = new SchemaList<Table, Database>(this);
TablesTypes = new SchemaList<TableType, Database>(this);
Users = new SchemaList<User1, Database>(this);
UserTypes = new SchemaList<UserDataType, Database>(this);
//Views = new SchemaList<View, Database>(this);
XmlSchemas = new SchemaList<XmlSchema, Database>(this);
}
public void DatabaseSettingsDeSerializeTest()
{
string dbResponsePayload = @"{
_colls : 'dbs/6GoAAA==/colls/',
_users: 'dbs/6GoAAA==/users/',
id: 'QuickStarts',
_rid: '6GoAAA==',
_self: 'dbs/6GoAAA==/',
_ts: 1530581163,
_etag: '00002000-0000-0000-0000-5b3ad0ab0000'
}";
DatabaseProperties databaseSettings = SettingsContractTests.CosmosDeserialize <DatabaseProperties>(dbResponsePayload);
Database db = SettingsContractTests.DirectDeSerialize <Database>(dbResponsePayload);
// Not all are exposed in CosmosDatabaseSettings
// so lets only validate relevant parts
Assert.AreEqual(db.Id, databaseSettings.Id);
Assert.AreEqual(db.ETag, databaseSettings.ETag);
Assert.AreEqual(db.ResourceId, databaseSettings.ResourceId);
Assert.AreEqual("QuickStarts", databaseSettings.Id);
Assert.AreEqual("00002000-0000-0000-0000-5b3ad0ab0000", databaseSettings.ETag);
Assert.AreEqual("6GoAAA==", databaseSettings.ResourceId);
}
public async Task ImplicitConversion()
{
string databaseName = Guid.NewGuid().ToString();
DatabaseResponse cosmosDatabaseResponse = await this.cosmosClient.GetDatabase(databaseName).ReadAsync(cancellationToken: this.cancellationToken);
Cosmos.Database cosmosDatabase = cosmosDatabaseResponse;
DatabaseProperties cosmosDatabaseSettings = cosmosDatabaseResponse;
Assert.IsNotNull(cosmosDatabase);
Assert.IsNull(cosmosDatabaseSettings);
cosmosDatabaseResponse = await this.CreateDatabaseHelper();
cosmosDatabase = cosmosDatabaseResponse;
cosmosDatabaseSettings = cosmosDatabaseResponse;
Assert.IsNotNull(cosmosDatabase);
Assert.IsNotNull(cosmosDatabaseSettings);
cosmosDatabaseResponse = await cosmosDatabase.DeleteAsync(cancellationToken : this.cancellationToken);
cosmosDatabase = cosmosDatabaseResponse;
cosmosDatabaseSettings = cosmosDatabaseResponse;
Assert.IsNotNull(cosmosDatabase);
Assert.IsNull(cosmosDatabaseSettings);
}
public void DatabaseStreamDeserialzieTest()
{
string dbId = "946ad017-14d9-4cee-8619-0cbc62414157";
string rid = "vu9cAA==";
string self = "dbs\\/vu9cAA==\\/";
string etag = "00000000-0000-0000-f8ea-31d6e5f701d4";
double ts = 1555923784;
DateTime UnixStartTime = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
DateTime expected = UnixStartTime.AddSeconds(ts);
string testPyaload = "{\"id\":\"" + dbId
+ "\",\"_rid\":\"" + rid
+ "\",\"_self\":\"" + self
+ "\",\"_etag\":\"" + etag
+ "\",\"_colls\":\"colls\\/\",\"_users\":\"users\\/\",\"_ts\":" + ts + "}";
DatabaseProperties deserializedPayload =
JsonConvert.DeserializeObject <DatabaseProperties>(testPyaload);
Assert.IsTrue(deserializedPayload.LastModified.HasValue);
Assert.AreEqual(expected, deserializedPayload.LastModified.Value);
Assert.AreEqual(dbId, deserializedPayload.Id);
Assert.AreEqual(rid, deserializedPayload.ResourceId);
Assert.AreEqual(etag, deserializedPayload.ETag);
}
private async Task <Cosmos.Database> CreateDatabaseStreamHelper(
string databaseId = null,
int?throughput = null,
bool databaseExists = false)
{
if (string.IsNullOrEmpty(databaseId))
{
databaseId = Guid.NewGuid().ToString();
}
DatabaseProperties databaseSettings = new DatabaseProperties()
{
Id = databaseId
};
ResponseMessage response = await this.cosmosClient.CreateDatabaseStreamAsync(
databaseSettings,
throughput : 400);
Assert.IsNotNull(response);
Assert.IsNotNull(response.Headers.RequestCharge);
Assert.IsNotNull(response.Headers.ActivityId);
Assert.IsTrue(response.StatusCode == HttpStatusCode.OK || (response.StatusCode == HttpStatusCode.Created && !databaseExists));
return(this.cosmosClient.GetDatabase(databaseId));
}
public async Task StreamCreateConflictTestAsync()
{
DatabaseProperties databaseSettings = new DatabaseProperties()
{
Id = Guid.NewGuid().ToString()
};
using (ResponseMessage response = await this.cosmosClient.CreateDatabaseStreamAsync(databaseSettings))
{
Assert.AreEqual(HttpStatusCode.Created, response.StatusCode);
Assert.IsNotNull(response.Headers);
Assert.IsTrue(response.Headers.RequestCharge > 0);
}
// Stream operations do not throw exceptions.
using (ResponseMessage response = await this.cosmosClient.CreateDatabaseStreamAsync(databaseSettings))
{
Assert.AreEqual(HttpStatusCode.Conflict, response.StatusCode);
Assert.IsNotNull(response.Headers);
Assert.IsTrue(response.Headers.RequestCharge > 0);
}
using (ResponseMessage response = await this.cosmosClient.GetDatabase(databaseSettings.Id).DeleteStreamAsync())
{
Assert.AreEqual(HttpStatusCode.NoContent, response.StatusCode);
Assert.IsNotNull(response.Headers);
Assert.IsTrue(response.Headers.RequestCharge > 0);
}
}
public async Task DatabaseContractTest()
{
DatabaseResponse response = await this.CreateDatabaseHelper();
Assert.IsNotNull(response);
Assert.IsTrue(response.RequestCharge > 0);
Assert.IsNotNull(response.Headers);
Assert.IsNotNull(response.Headers.ActivityId);
DatabaseProperties databaseSettings = response.Resource;
Assert.IsNotNull(databaseSettings.Id);
Assert.IsNotNull(databaseSettings.ResourceId);
Assert.IsNotNull(databaseSettings.ETag);
Assert.IsTrue(databaseSettings.LastModified.HasValue);
Assert.IsTrue(databaseSettings.LastModified.Value > new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc), databaseSettings.LastModified.Value.ToString());
DatabaseInternal databaseCore = response.Database as DatabaseInlineCore;
Assert.IsNotNull(databaseCore);
Assert.IsNotNull(databaseCore.LinkUri);
Assert.IsFalse(databaseCore.LinkUri.ToString().StartsWith("/"));
response = await response.Database.DeleteAsync(cancellationToken : this.cancellationToken);
Assert.AreEqual(HttpStatusCode.NoContent, response.StatusCode);
}
public static async Task createAzureDocumentDatabase(string EndpointUrl, string PrimaryKey)
{
var client = new CosmosClient(EndpointUrl, PrimaryKey);
DatabaseResponse databaseResponse = await client.CreateDatabaseIfNotExistsAsync(dbName);
Database database = databaseResponse;
DatabaseProperties databaseProperties = databaseResponse;
// Create a database with a shared manual provisioned throughput
string databaseIdManual = dbName;
database = await client.CreateDatabaseIfNotExistsAsync(databaseIdManual, ThroughputProperties.CreateManualThroughput(OfferThroughput));
ContainerResponse container = await database.CreateContainerIfNotExistsAsync(
id : collectionName,
partitionKeyPath : partitionKey,
throughput : OfferThroughput);
//Database dataBase = new Database { Id = dbName };
//await client.CreateDatabaseIfNotExistsAsync(dataBase).ConfigureAwait(false);
//DocumentCollection myCollection = new DocumentCollection();
//myCollection.Id = collectionName;
//myCollection.PartitionKey.Paths.Add(partitionKey);
//await client.CreateDocumentCollectionIfNotExistsAsync(
// UriFactory.CreateDatabaseUri(dbName),
// myCollection,
// new RequestOptions { OfferThroughput = OfferThroughput }).ConfigureAwait(false);
}
public static async Task <SymsManifestContent> ToDataAsync(CdmManifestDefinition instance, ResolveOptions resOpt, CopyOptions options,
bool isDeltaSync = false, IList <TableEntity> existingSymsTables = null, IList <RelationshipEntity> existingSymsRelationships = null)
{
var source = CreateDataSource(instance);
if (source == null)
{
return(null);
}
var properties = CreateDatabasePropertyBags(instance, resOpt, options);
Dictionary <string, TableEntity> existingTableEntities = null;
List <string> removedSymsTable = null;
if (existingSymsTables != null && existingSymsTables.Count > 0)
{
// convert to dictionary for better searching
existingTableEntities = existingSymsTables.ToDictionary(x => x.Name, x => x);
removedSymsTable = existingSymsTables.Select(x => x.Name).Except(instance.Entities.Select(x => x.EntityName)).ToList();
}
var addedOrModifiedSymsTables = await CreateSymsTablesObjects(instance, resOpt, options, source.Location, existingTableEntities);
// TODO : Submanifest
Dictionary <string, RelationshipEntity> existingRelationshipEntities = null;
List <string> removedSymsRelationships = null;
if (existingSymsRelationships != null && existingSymsRelationships.Count > 0)
{
existingRelationshipEntities = existingSymsRelationships.ToDictionary(x => x.Name, x => x);
removedSymsRelationships = existingSymsRelationships.Select(x => x.Name).Except(instance.Relationships.Select(x => x.Name)).ToList();
}
var addedOrModifiedSymsRelationships = CreateRelationships(instance, existingRelationshipEntities, resOpt, options);
DatabaseProperties dbProperties = new DatabaseProperties
{
Description = instance.Explanation != null ? instance.Explanation : $"{instance.ManifestName} syms database",
Source = source,
Properties = properties
};
var databaseEntity = new DatabaseEntity
{
Name = instance.ManifestName,
Properties = dbProperties,
Type = SASEntityType.DATABASE
};
return(new SymsManifestContent
{
Database = databaseEntity,
Entities = addedOrModifiedSymsTables,
Relationships = addedOrModifiedSymsRelationships,
InitialSync = !isDeltaSync,
RemovedEntities = removedSymsTable,
RemovedRelationships = removedSymsRelationships
});
}
public void FixtureSetUp()
{
using (var session = SessionFactory.OpenSession())
{
var q = DatabasePropertiesMap.CreateQuery(session);
testedObject = q.UniqueResult<DatabaseProperties>();
}
}
protected void Page_Load(object sender, EventArgs e)
{
//load url arguments in variables
string INSTANCE_NAME = @Request.QueryString["instance"];
string CATALOG_NAME = Request.QueryString["catalog"];
string CUBE_NAME = Request.QueryString["cube"];
//Create Excel file name
string ConnectionName = INSTANCE_NAME.Replace("\\","_") + "_" + CATALOG_NAME + "_" + CUBE_NAME;
Response.Write(ConnectionName);
//Create Workbook
string filename = Server.MapPath(@"tmp/" + ConnectionName + ".xlsx");
// Create a spreadsheet document by supplying the filepath.
// By default, AutoSave = true, Editable = true, and Type = xlsx.
SpreadsheetDocument spreadsheetDocument = SpreadsheetDocument.Create(filename, SpreadsheetDocumentType.Workbook);
// Add a WorkbookPart to the document.
WorkbookPart workbookpart = spreadsheetDocument.AddWorkbookPart();
workbookpart.Workbook = new Workbook();
// Add a WorksheetPart to the WorkbookPart.
WorksheetPart worksheetPart = workbookpart.AddNewPart<WorksheetPart>();
worksheetPart.Worksheet = new Worksheet(new SheetData());
// Add Sheets to the Workbook.
Sheets sheets = spreadsheetDocument.WorkbookPart.Workbook.AppendChild<Sheets>(new Sheets());
// Append a new worksheet and associate it with the workbook.
Sheet sheet = new Sheet() { Id = spreadsheetDocument.WorkbookPart.GetIdOfPart(worksheetPart), SheetId = 1, Name = "mySheet" };
sheets.Append(sheet);
//Add a connectionPart to the workbookpart
ConnectionsPart connectionsPart1 = workbookpart.AddNewPart<ConnectionsPart>();
Connections connections1 = new Connections();
Connection connection1 = new Connection() { Id = (UInt32Value)1U, KeepAlive = true, Name = ConnectionName, Type = (UInt32Value)5U, RefreshedVersion = 5, Background = true };
DatabaseProperties databaseProperties1 = new DatabaseProperties() { Connection = "Provider=MSOLAP.4;Integrated Security=SSPI;Persist Security Info=True;Initial Catalog=" + CATALOG_NAME + ";Data Source=" + @INSTANCE_NAME + ";MDX Compatibility=1;Safety Options=2;MDX Missing Member Mode=Error", Command = CUBE_NAME, CommandType = (UInt32Value)1U };
OlapProperties olapProperties1 = new OlapProperties() { SendLocale = true, RowDrillCount = (UInt32Value)1000U };
connection1.Append(databaseProperties1);
connection1.Append(olapProperties1);
connections1.Append(connection1);
connectionsPart1.Connections = connections1;
//Add a PivottableCache part
PivotTableCacheDefinitionPart pivotTableCacheDefinitionPart1 = workbookpart.AddNewPart<PivotTableCacheDefinitionPart>();
PivotCacheDefinition pivotCacheDefinition1 = new PivotCacheDefinition() { SaveData = false, BackgroundQuery = true, SupportSubquery = true, SupportAdvancedDrill = true };
pivotTableCacheDefinitionPart1.PivotCacheDefinition = pivotCacheDefinition1;
workbookpart.Workbook.Save();
// Close the document.
spreadsheetDocument.Close();
Response.Clear();
Response.AddHeader("content-disposition", "attachment; filename=" + @"D:\MyBI\SSAS\SSAS2012_MyBI\tmp\test.xlsx");
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
Response.WriteFile(Server.MapPath(@"tmp/" + ConnectionName + ".xlsx"));
Response.End();
}
public async Task DatabaseNameShouldSetCorrectly()
{
DatabaseResponse databaseResponse = await _cosmosContext.Database.ReadAsync();
DatabaseProperties properties = databaseResponse;
var actual = properties.Id;
actual.Should().Be("EmulatorTestDb");
}
/// <summary>
/// See https://docs.microsoft.com/en-us/azure/cosmos-db/sql-api-dotnet-v3sdk-samples
/// </summary>
/// <param name="client"></param>
private static void RunDatabaseDemo(CosmosClient client)
{
// An object containing relevant information about the response
DatabaseResponse databaseResponse =
client.CreateDatabaseIfNotExistsAsync(databaseId, 400).Result;
// A client side reference object that allows additional operations like ReadAsync
Database database = databaseResponse;
_database = database;
// The response from Azure Cosmos
DatabaseProperties properties = databaseResponse;
Console.WriteLine($"\n1. Create a database resource with id: " +
$"{properties.Id} and last modified time stamp: {properties.LastModified}");
Console.WriteLine($"\n2. Create a database resource request charge: " +
$"{databaseResponse.RequestCharge} and Activity Id: {databaseResponse.ActivityId}");
// Read the database from Azure Cosmos
DatabaseResponse readResponse = database.ReadAsync().Result;
Console.WriteLine($"\n3. Read a database: {readResponse.Resource.Id}");
_container =
readResponse.Database.CreateContainerAsync("testContainer", "/city").Result;
// Get the current throughput for the database
int?throughputResponse = database.ReadThroughputAsync().Result;
if (throughputResponse.HasValue)
{
Console.WriteLine($"\n4. Read a database throughput: {throughputResponse}");
// Update the current throughput for the database
database.ReplaceThroughputAsync(11000).Wait();
}
Console.WriteLine("\n5. Reading all databases resources for an account");
using (FeedIterator <DatabaseProperties> iterator =
client.GetDatabaseQueryIterator <DatabaseProperties>())
{
while (iterator.HasMoreResults)
{
foreach (DatabaseProperties db in iterator.ReadNextAsync().Result)
{
Console.WriteLine(db.Id);
}
}
}
// Delete the database from Azure Cosmos.
//database.DeleteAsync().Wait();
//Console.WriteLine($"\n6. Database {database.Id} deleted.");
}
public void DatabaseSettingsDefaults()
{
DatabaseProperties dbSettings = new DatabaseProperties();
Assert.IsNull(dbSettings.LastModified);
Assert.IsNull(dbSettings.ResourceId);
Assert.IsNull(dbSettings.Id);
Assert.IsNull(dbSettings.ETag);
SettingsContractTests.TypeAccessorGuard(typeof(DatabaseProperties), "Id");
}
public DBProperties(VolumeDatabase db)
{
BuildGui();
this.db = db;
props = db.GetDBProperties();
entName.Text = props.Name;
tvDescription.Buffer.Text = props.Description;
entCreated.Text = props.Created.ToString();
}
public static async Task CreateDatabase(string databaseName)
{
WriteLine($"\n>>> Create Database {databaseName} <<<");
DatabaseResponse result = await Shared.Client.CreateDatabaseIfNotExistsAsync(databaseName);
DatabaseProperties database = result.Resource;
// todo check StatusCode
WriteLine($" Database Id: {database.Id}; Modified: {database.LastModified}");
}
public override Task <ResponseMessage> CreateDatabaseStreamAsync(
DatabaseProperties databaseProperties,
int?throughput = null,
RequestOptions requestOptions = null,
CancellationToken cancellationToken = default)
{
return(this.cosmosClient.CreateDatabaseStreamAsync(
databaseProperties,
throughput,
requestOptions,
cancellationToken));
}
public async Task ImplicitConversion()
{
DatabaseResponse cosmosDatabaseResponse = await this.CreateDatabaseHelper();
Cosmos.Database cosmosDatabase = cosmosDatabaseResponse;
DatabaseProperties cosmosDatabaseSettings = cosmosDatabaseResponse;
Assert.IsNotNull(cosmosDatabase);
Assert.IsNotNull(cosmosDatabaseSettings);
cosmosDatabaseResponse = await cosmosDatabase.DeleteAsync(cancellationToken : this.cancellationToken);
cosmosDatabase = cosmosDatabaseResponse;
cosmosDatabaseSettings = cosmosDatabaseResponse;
Assert.IsNotNull(cosmosDatabase);
Assert.IsNull(cosmosDatabaseSettings);
}
private void DetermineConnections(WorkbookPart workbookPart)
{
if (workbookPart.ConnectionsPart != null)
{
ConnectionsPart connectionPart = workbookPart.ConnectionsPart;
foreach (Connection connection in connectionPart.Connections)
{
var connectionInfo = new Connections
{
Description = connection.Description,
Name = connection.Name,
ConnectionProperties = new ConnectionProperties()
};
DatabaseProperties databaseProperties = connection.DatabaseProperties;
connectionInfo.ConnectionProperties.Command = databaseProperties.Command.InnerText;
connectionInfo.ConnectionProperties.ConnectionDetails = databaseProperties.Connection.InnerText;
this.connections.Add(connectionInfo);
}
this.workbook.HasDataConnections = true;
}
}
public void DatabaseSettingsSerializeTest()
{
string id = Guid.NewGuid().ToString();
DatabaseProperties databaseSettings = new DatabaseProperties()
{
Id = id
};
Database db = new Database()
{
Id = id
};
string cosmosSerialized = SettingsContractTests.CosmosSerialize(databaseSettings);
string directSerialized = SettingsContractTests.DirectSerialize(db);
// Swap de-serialize and validate
DatabaseProperties dbDeserSettings = SettingsContractTests.CosmosDeserialize <DatabaseProperties>(directSerialized);
Database dbDeser = SettingsContractTests.DirectDeSerialize <Database>(cosmosSerialized);
Assert.AreEqual(dbDeserSettings.Id, dbDeser.Id);
Assert.AreEqual(dbDeserSettings.Id, db.Id);
}
public Database(DatabaseProperties connectionProperties)
{
this._connectionProperties = connectionProperties;
}
public async Task ValidateResponseFactoryJsonSerializer()
{
ResponseMessage databaseResponse = this.CreateResponse();
ResponseMessage containerResponse = this.CreateResponse();
ResponseMessage storedProcedureExecuteResponse = this.CreateResponse();
ResponseMessage storedProcedureResponse = this.CreateResponse();
ResponseMessage triggerResponse = this.CreateResponse();
ResponseMessage udfResponse = this.CreateResponse();
ResponseMessage itemResponse = this.CreateResponse();
ResponseMessage feedResponse = this.CreateResponse();
Mock <CosmosSerializer> mockUserJsonSerializer = new Mock <CosmosSerializer>();
Mock <CosmosSerializer> mockDefaultJsonSerializer = new Mock <CosmosSerializer>();
CosmosResponseFactory cosmosResponseFactory = new CosmosResponseFactory(
defaultJsonSerializer: mockDefaultJsonSerializer.Object,
userJsonSerializer: mockUserJsonSerializer.Object);
// Test the user specified response
mockUserJsonSerializer.Setup(x => x.FromStream <ToDoActivity>(itemResponse.Content)).Returns(new ToDoActivity());
mockUserJsonSerializer.Setup(x => x.FromStream <ToDoActivity>(storedProcedureExecuteResponse.Content)).Returns(new ToDoActivity());
mockUserJsonSerializer.Setup(x => x.FromStream <CosmosFeedResponseUtil <ToDoActivity> >(feedResponse.Content)).Returns(new CosmosFeedResponseUtil <ToDoActivity>()
{
Data = new Collection <ToDoActivity>()
});
// Verify all the user types use the user specified version
await cosmosResponseFactory.CreateItemResponseAsync <ToDoActivity>(Task.FromResult(itemResponse));
await cosmosResponseFactory.CreateStoredProcedureExecuteResponseAsync <ToDoActivity>(Task.FromResult(storedProcedureExecuteResponse));
cosmosResponseFactory.CreateResultSetQueryResponse <ToDoActivity>(feedResponse);
// Throw if the setups were not called
mockUserJsonSerializer.VerifyAll();
// Test the system specified response
ContainerProperties containerSettings = new ContainerProperties("mockId", "/pk");
DatabaseProperties databaseSettings = new DatabaseProperties()
{
Id = "mock"
};
StoredProcedureProperties cosmosStoredProcedureSettings = new StoredProcedureProperties()
{
Id = "mock"
};
TriggerProperties cosmosTriggerSettings = new TriggerProperties()
{
Id = "mock"
};
UserDefinedFunctionProperties cosmosUserDefinedFunctionSettings = new UserDefinedFunctionProperties()
{
Id = "mock"
};
mockDefaultJsonSerializer.Setup(x => x.FromStream <DatabaseProperties>(databaseResponse.Content)).Returns(databaseSettings);
mockDefaultJsonSerializer.Setup(x => x.FromStream <ContainerProperties>(containerResponse.Content)).Returns(containerSettings);
mockDefaultJsonSerializer.Setup(x => x.FromStream <StoredProcedureProperties>(storedProcedureResponse.Content)).Returns(cosmosStoredProcedureSettings);
mockDefaultJsonSerializer.Setup(x => x.FromStream <TriggerProperties>(triggerResponse.Content)).Returns(cosmosTriggerSettings);
mockDefaultJsonSerializer.Setup(x => x.FromStream <UserDefinedFunctionProperties>(udfResponse.Content)).Returns(cosmosUserDefinedFunctionSettings);
Mock <Container> mockContainer = new Mock <Container>();
Mock <Database> mockDatabase = new Mock <Database>();
// Verify all the system types that should always use default
await cosmosResponseFactory.CreateContainerResponseAsync(mockContainer.Object, Task.FromResult(containerResponse));
await cosmosResponseFactory.CreateDatabaseResponseAsync(mockDatabase.Object, Task.FromResult(databaseResponse));
await cosmosResponseFactory.CreateStoredProcedureResponseAsync(Task.FromResult(storedProcedureResponse));
await cosmosResponseFactory.CreateTriggerResponseAsync(Task.FromResult(triggerResponse));
await cosmosResponseFactory.CreateUserDefinedFunctionResponseAsync(Task.FromResult(udfResponse));
// Throw if the setups were not called
mockDefaultJsonSerializer.VerifyAll();
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, AppDatabase database, EmailService emailService)
{
HostEnvironment = env;
app.UseLiveReload();
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.Use(async(context, next) =>
{
await next();
if (context.Response.StatusCode >= 400 && context.Response.StatusCode <= 499 && !context.Response.HasStarted)
{
context.Request.Path = "/Error";
await next();
}
});
app.UseHttpsRedirection();
app.UseStaticFiles(new StaticFileOptions
{
OnPrepareResponse = context =>
{
context.Context.Response.Headers.Add("Cache-Control", "no-cache, no-store");
context.Context.Response.Headers.Add("Expires", "-1");
}
});
app.UseRouting();
app.UseAuthentication();
app.UseAuthorization();
app.UseSession();
app.UseRequestLocalization(app.ApplicationServices.GetService <IOptions <RequestLocalizationOptions> >().Value);
app.UseMiddleware <LanguageChangeMiddleware>();
app.UseMiddleware <EnsureSubjectMiddleware>();
app.UseMiddleware <SubjectChangeMiddleware>();
app.UseMiddleware <RoleChangeMiddleware>();
app.UseMiddleware <PhpRedirectMiddleware>();
app.UseMiddleware <AuthCookieTimeoutMiddleware>();
app.UseEndpoints(endpoints =>
{
endpoints.MapRazorPages();
endpoints.MapControllers();
});
database.Database.EnsureDeleted();
database.Database.EnsureCreated();
var gradeLevelKG = database.GradeLevels.Add(new GradeLevel
{
Name = "Kindergarten",
RegistryConfiguration = new RegistryConfiguration
{
StartTime = TimeSpan.FromHours(8),
Slots = Enumerable.Range(0, 2).Select(_ => new RegistryTimeSlot
{
Duration = 1,
HasClass = true,
HasText = true
}).Concat(new[]
{
new RegistryTimeSlot
{
Duration = 2,
HasClass = true,
HasText = true
}
}).Concat(Enumerable.Range(0, 1).Select(_ => new RegistryTimeSlot
{
Duration = 1,
HasClass = true,
HasText = true
})).Concat(new[]
{
new RegistryTimeSlot
{
Duration = 2,
HasClass = true,
HasText = true
}
}).Concat(new[]
{
new RegistryTimeSlot
{
Duration = 2,
HasClass = true,
HasText = true
}
}).Concat(new[]
{
new RegistryTimeSlot
{
Duration = 3,
HasClass = true,
HasText = true,
CustomLabel = "Others"
}
}).ToList()
}
}).Entity;
var gradeElementaryStep = database.GradeLevels.Add(new GradeLevel
{
Name = "Elementary (step)",
RegistryConfiguration = new RegistryConfiguration
{
StartTime = TimeSpan.FromHours(8),
Slots = Enumerable.Range(0, 2).Select(_ => new RegistryTimeSlot
{
Duration = 1,
HasClass = true,
HasText = true
}).Concat(new[]
{
new RegistryTimeSlot
{
Duration = 3,
HasClass = true,
HasText = true
}
}).Concat(Enumerable.Range(0, 5).Select(_ => new RegistryTimeSlot
{
Duration = 1,
HasClass = true,
HasText = true
})).ToList()
}
}).Entity;
var gradeElementary = database.GradeLevels.Add(new GradeLevel
{
Name = "Elementary",
RegistryConfiguration = new RegistryConfiguration
{
StartTime = TimeSpan.FromHours(8),
Slots = Enumerable.Range(0, 10).Select(_ => new RegistryTimeSlot
{
Duration = 1,
HasClass = true,
HasSubject = true,
HasText = true
}).ToList()
},
EmailOnGradeAdded = true,
EmailOnGradeDeleted = true,
EmailOnAbsenceAdded = true,
EmailOnAbsenceDeleted = true,
EmailOnDisciplinaryAdded = true,
EmailOnDisciplinaryDeleted = true
}).Entity;
var gradeMiddle = database.GradeLevels.Add(new GradeLevel
{
Name = "Middle",
RegistryConfiguration = new RegistryConfiguration
{
StartTime = TimeSpan.FromHours(7),
Slots = Enumerable.Range(0, 11).Select(_ => new RegistryTimeSlot
{
Duration = 1,
HasClass = true,
HasSubject = true,
HasText = true,
HasPCO = true
}).ToList()
}
}).Entity;
database.SaveChanges();
var adminGroup = database.Groups.Add(new Group {
GroupType = GroupType.Admin, Name = "Administrators"
});
var teacherGroup = database.Groups.Add(new Group {
GroupType = GroupType.Teacher, Name = "Teachers"
});
var adminUser = database.Users.Add(new User
{
FullName = "Administrator",
LoginName = "admin",
PasswordHash = "AQAAAAEAACcQAAAAEBFsY1RMVJIl9QZM2pFvdjhJQbC/OwzYV+j3JaP2hXCnhaPIyHDBPXrF3Ye3tHxAmA==",
LastLogin = DateTime.Now,
TeacherGradeLevel = gradeLevelKG
});
adminUser.Entity.Groups = new List <Group> {
adminGroup.Entity, teacherGroup.Entity
};
var teacherUser = database.Users.Add(new User
{
FullName = "Test Teacher",
LoginName = "tteacher1",
PasswordHash = "AQAAAAEAACcQAAAAEBFsY1RMVJIl9QZM2pFvdjhJQbC/OwzYV+j3JaP2hXCnhaPIyHDBPXrF3Ye3tHxAmA==",
LastLogin = DateTime.Now,
TeacherGradeLevel = gradeElementary
});
teacherUser.Entity.Groups = new List <Group> {
teacherGroup.Entity
};
var classGroup1 = database.Groups.Add(new Group {
GroupType = GroupType.Class, GradeLevel = gradeElementary, Name = "IV.A"
});
var classGroup2 = database.Groups.Add(new Group {
GroupType = GroupType.Class, GradeLevel = gradeMiddle, Name = "VII.B"
});
var s1 = database.Subjects.Add(new Subject {
Name = "Programming", RegistryName = "I.T.", HasMidterm = true
}).Entity;
var s2 = database.Subjects.Add(new Subject {
Name = "English", RegistryName = "Foreign language"
}).Entity;
s1.Classes = new List <Group> {
classGroup1.Entity, classGroup2.Entity
};
s1.Teachers = new List <User> {
adminUser.Entity
};
s2.Teachers = new List <User> {
adminUser.Entity
};
adminUser.Entity.TaughtClasses = new List <Group> {
classGroup1.Entity, classGroup2.Entity
};
teacherUser.Entity.TaughtClasses = new List <Group> {
classGroup1.Entity, classGroup2.Entity
};
teacherUser.Entity.TaughtSubjects = new List <Subject> {
s1, s2
};
classGroup1.Entity.FormMaster = adminUser.Entity;
classGroup1.Entity.Subjects = new List <Subject> {
s1, s2
};
classGroup2.Entity.Subjects = new List <Subject> {
s1, s2
};
database.SaveChanges();
var student = database.Users.Add(new User
{
FullName = $"Student_1",
LoginName = $"s1",
PasswordHash = "AQAAAAEAACcQAAAAEBFsY1RMVJIl9QZM2pFvdjhJQbC/OwzYV+j3JaP2hXCnhaPIyHDBPXrF3Ye3tHxAmA==",
NotificationEmail = "*****@*****.**"
}).Entity;
student.Groups = new List <Group> {
classGroup1.Entity
};
var rand = new Random();
for (int i = 0; i < 20; i++)
{
database.Grades.Add(new Grade
{
Student = student,
Semester = rand.Next(0, 2) == 0 ? 1 : 2,
Teacher = adminUser.Entity,
Value = rand.Next(1, 10),
Date = DateTime.Today - TimeSpan.FromDays(rand.Next(1, 230)),
Subject = rand.Next(0, 2) == 0 ? s1 : s2
});
database.Absences.Add(new Absence
{
Student = student,
Semester = rand.Next(0, 2) == 0 ? 1 : 2,
Teacher = adminUser.Entity,
Date = DateTime.Today - TimeSpan.FromDays(rand.Next(1, 230)),
Subject = rand.Next(0, 2) == 0 ? s1 : s2,
Comment = Guid.NewGuid().ToString(),
Verified = rand.Next(0, 3) == 0
});
database.Disciplinary.Add(new Disciplinary
{
Student = student,
Semester = rand.Next(0, 2) == 0 ? 1 : 2,
Teacher = adminUser.Entity,
Date = DateTime.Today - TimeSpan.FromDays(rand.Next(1, 230)),
Subject = rand.Next(0, 2) == 0 ? s1 : s2,
Comment = Guid.NewGuid().ToString(),
Points = 0 - rand.Next(1, 11)
});
}
database.DisciplinaryPresets.Add(new DisciplinaryPreset {
Text = "stupid", Value = -1
});
database.DisciplinaryPresets.Add(new DisciplinaryPreset {
Text = "dumb f**k", Value = -10
});
database.RegistryEntries.Add(new RegistryEntry
{
Class = classGroup1.Entity,
Subject = s1,
Teacher = adminUser.Entity,
Text = "asdasdasd",
EntryDate = DateTime.Now,
ModifyDate = DateTime.Now,
Date = DateTime.Parse("2021-03-09 08:00:00")
});
database.RegistryEntries.Add(new RegistryEntry
{
Class = classGroup1.Entity,
Subject = s1,
Teacher = adminUser.Entity,
Text = "qwe",
EntryDate = DateTime.Now,
ModifyDate = DateTime.Now,
Date = DateTime.Parse("2021-03-10 09:00:00")
});
var properties = new DatabaseProperties(database);
database.SaveChanges();
emailService.TryConnecting();
}
protected void Page_Load(object sender, EventArgs e)
{
//load url arguments in variables
string INSTANCE_NAME = @Request.QueryString["instance"];
string CATALOG_NAME = Request.QueryString["catalog"];
string CUBE_NAME = Request.QueryString["cube"];
//Create Excel file name
string ConnectionName = INSTANCE_NAME.Replace("\\", "_") + "_" + CATALOG_NAME + "_" + CUBE_NAME;
Response.Write(ConnectionName);
//Create Workbook
string filename = Server.MapPath(@"tmp/" + ConnectionName + ".xlsx");
// Create a spreadsheet document by supplying the filepath.
// By default, AutoSave = true, Editable = true, and Type = xlsx.
SpreadsheetDocument spreadsheetDocument = SpreadsheetDocument.Create(filename, SpreadsheetDocumentType.Workbook);
// Add a WorkbookPart to the document.
WorkbookPart workbookpart = spreadsheetDocument.AddWorkbookPart();
workbookpart.Workbook = new Workbook();
// Add a WorksheetPart to the WorkbookPart.
WorksheetPart worksheetPart = workbookpart.AddNewPart <WorksheetPart>();
worksheetPart.Worksheet = new Worksheet(new SheetData());
// Add Sheets to the Workbook.
Sheets sheets = spreadsheetDocument.WorkbookPart.Workbook.AppendChild <Sheets>(new Sheets());
// Append a new worksheet and associate it with the workbook.
Sheet sheet = new Sheet()
{
Id = spreadsheetDocument.WorkbookPart.GetIdOfPart(worksheetPart), SheetId = 1, Name = "mySheet"
};
sheets.Append(sheet);
//Add a connectionPart to the workbookpart
ConnectionsPart connectionsPart1 = workbookpart.AddNewPart <ConnectionsPart>();
Connections connections1 = new Connections();
Connection connection1 = new Connection()
{
Id = (UInt32Value)1U, KeepAlive = true, Name = ConnectionName, Type = (UInt32Value)5U, RefreshedVersion = 5, Background = true
};
DatabaseProperties databaseProperties1 = new DatabaseProperties()
{
Connection = "Provider=MSOLAP.4;Integrated Security=SSPI;Persist Security Info=True;Initial Catalog=" + CATALOG_NAME + ";Data Source=" + @INSTANCE_NAME + ";MDX Compatibility=1;Safety Options=2;MDX Missing Member Mode=Error", Command = CUBE_NAME, CommandType = (UInt32Value)1U
};
OlapProperties olapProperties1 = new OlapProperties()
{
SendLocale = true, RowDrillCount = (UInt32Value)1000U
};
connection1.Append(databaseProperties1);
connection1.Append(olapProperties1);
connections1.Append(connection1);
connectionsPart1.Connections = connections1;
//Add a PivottableCache part
PivotTableCacheDefinitionPart pivotTableCacheDefinitionPart1 = workbookpart.AddNewPart <PivotTableCacheDefinitionPart>();
PivotCacheDefinition pivotCacheDefinition1 = new PivotCacheDefinition()
{
SaveData = false, BackgroundQuery = true, SupportSubquery = true, SupportAdvancedDrill = true
};
pivotTableCacheDefinitionPart1.PivotCacheDefinition = pivotCacheDefinition1;
workbookpart.Workbook.Save();
// Close the document.
spreadsheetDocument.Close();
Response.Clear();
Response.AddHeader("content-disposition", "attachment; filename=" + @"D:\MyBI\SSAS\SSAS2012_MyBI\tmp\test.xlsx");
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
Response.WriteFile(Server.MapPath(@"tmp/" + ConnectionName + ".xlsx"));
Response.End();
}
private static void SetConnectionStartDatabaseOperation(ProductDbType dbType, DatabaseProperties databaseProperties, string operation)
{
var productDatabase = new ProductDatabase();
if (productDatabase.SetConnection(dbType, databaseProperties))
{
OperationType operationType = productDatabase.GetOperationType(operation);
productDatabase.StartDatabaseOperation(operationType);
}
else
{
throw new Exception(Messages.ErrorMessage001);
}
}
private static void ExecuteArguments(string[] args)
{
if (args.Length > 0)
{
string argMaster = args[0].ToLower();
if (argMaster == "-newupdt")
{
if (!FileHelper.CreateNextUpdateFolders())
{
othersLogger.Error(Messages.ErrorMessage020);
Environment.ExitCode = -1;
}
}
else if (argMaster == "-oracle")
{// -oracle owner password tnsname td ti [i|u|gint|compare]
if (args.Length == 7)
{
var databaseProperties = new DatabaseProperties(args[1], args[2], args[3], args[4], args[5]);
string operation = args[6];
SetConnectionStartDatabaseOperation(ProductDbType.Oracle, databaseProperties, operation);
}
else
{
othersLogger.Error(Messages.ErrorMessage023);
Environment.ExitCode = -1;
}
}
else if (argMaster == "-sqlserver")
{// -sqlserver user password server databaseName install ||OR|| -sqlserver trusted server databaseName [i|u]
if (args.Length >= 4)
{
DatabaseProperties databaseProperties;
string operation;
if (args.Length == 6)
{
operation = args[5];
databaseProperties = new DatabaseProperties(args[1], args[2], args[3], args[4], false);
}
else if (args.Length == 4)
{
operation = args[3];
databaseProperties = new DatabaseProperties(null, null, args[1], args[2], true);
}
else
{
othersLogger.Error(Messages.ErrorMessage023);
Environment.ExitCode = -1;
return;
}
SetConnectionStartDatabaseOperation(ProductDbType.SqlServer, databaseProperties, operation);
}
else
{
othersLogger.Error(Messages.ErrorMessage023);
Environment.ExitCode = -1;
}
}
}
}
public static CdmManifestDefinition FromObject(CdmCorpusContext ctx, string docName, string nameSpace, string path, SymsManifestContent dataObj)
{
DatabaseEntity database = dataObj.Database;
if (database == null || database.Type != SASEntityType.DATABASE)
{
Logger.Error((ResolveContext)ctx, Tag, nameof(FromObject), null, CdmLogCode.ErrPersistSymsInvalidDbObject);
return(null);
}
DatabaseProperties databaseProperties = ((JToken)database.Properties).ToObject <DatabaseProperties>();
if (databaseProperties == null || databaseProperties.Source == null)
{
Logger.Error((ResolveContext)ctx, Tag, nameof(FromObject), null, CdmLogCode.ErrPersistSymsInvalidDbPropObject);
return(null);
}
var properties = databaseProperties.Properties;
var manifest = ctx.Corpus.MakeObject <CdmManifestDefinition>(CdmObjectType.ManifestDef);
manifest.ManifestName = dataObj.Database.Name;
manifest.Name = docName;
manifest.FolderPath = path;
manifest.Namespace = nameSpace;
manifest.Explanation = databaseProperties.Description;
if (properties != null)
{
if (properties.ContainsKey("cdm:schema"))
{
manifest.Schema = properties["cdm:schema"].ToObject <string>();
}
if (properties.ContainsKey("cdm:jsonSchemaSemanticVersion"))
{
manifest.JsonSchemaSemanticVersion = properties["cdm:jsonSchemaSemanticVersion"].ToObject <string>();
}
if (properties.ContainsKey("cdm:documentVersion"))
{
manifest.DocumentVersion = properties["cdm:documentVersion"].ToObject <string>();
}
else if (properties.ContainsKey("cdm:traits"))
{
Utils.AddListToCdmCollection(manifest.ExhibitsTraits, Utils.CreateTraitReferenceList(ctx, properties["cdm:traits"]));
}
if (properties.ContainsKey("cdm:imports"))
{
foreach (var importObj in properties["cdm:imports"].ToObject <List <Import> >())
{
manifest.Imports.Add(ImportPersistence.FromData(ctx, importObj));
}
}
if (properties.ContainsKey("cdm:lastFileStatusCheckTime"))
{
manifest.LastFileStatusCheckTime = DateTimeOffset.Parse(properties["cdm:lastFileStatusCheckTime"].ToObject <string>());
}
if (properties.ContainsKey("cdm:lastFileModifiedTime"))
{
manifest.LastFileModifiedTime = DateTimeOffset.Parse(properties["cdm:lastFileModifiedTime"].ToObject <string>());
}
if (properties.ContainsKey("cdm:lastChildFileModifiedTime"))
{
manifest.LastChildFileModifiedTime = DateTimeOffset.Parse(properties["cdm:lastChildFileModifiedTime"].ToObject <string>());
}
}
var t2pm = new TraitToPropertyMap(manifest);
var sourceTrait = t2pm.FetchTraitReference(dbLocationTrait);
if (sourceTrait == null)
{
sourceTrait = Utils.CreateSourceTrait(ctx, dbLocationTrait, dbLocationTraitArgName);
manifest.ExhibitsTraits.Add(sourceTrait);
}
var adlsPath = Utils.SymsPathToAdlsAdapterPath(databaseProperties.Source.Location);
var adlsCorpusPath = ctx.Corpus.Storage.AdapterPathToCorpusPath(adlsPath);
if (adlsCorpusPath == null)
{
Tuple <string, string> pathTuple = StorageUtils.SplitNamespacePath(sourceTrait.Arguments[0].Value);
if (null == Utils.CreateAndMountAdlsAdapterFromAdlsPath(ctx.Corpus.Storage, adlsPath, pathTuple.Item1))
{
Logger.Error((ResolveContext)ctx, Tag, nameof(FromObject), null, CdmLogCode.ErrPersistSymsAdlsAdapterNotMounted, adlsPath);
return(null);
}
}
if (dataObj.Entities != null)
{
foreach (var entityObj in dataObj.Entities)
{
if (entityObj.Type == SASEntityType.TABLE)
{
var entity = LocalEntityDeclarationPersistence.FromData(ctx, entityObj, manifest, databaseProperties.Source.Location);
if (entity != null)
{
manifest.Entities.Add(entity);
}
else
{
Logger.Warning((ResolveContext)ctx, Tag, nameof(FromObject), null, CdmLogCode.WarnPersistSymsEntitySkipped, entityObj.Name);
}
}
}
}
if (!manifest.Imports.Any((CdmImport importPresent) => importPresent.CorpusPath == Constants.FoundationsCorpusPath))
{
manifest.Imports.Add(Constants.FoundationsCorpusPath);
}
if (dataObj.Relationships != null)
{
foreach (var relationshipEntity in dataObj.Relationships)
{
manifest.Relationships.AddRange(E2ERelationshipPersistence.FromData(ctx, relationshipEntity));
}
}
// TODO : Submanifest
return(manifest);
}
// Generates content of connectionsPart1.
private void GenerateConnectionsPart1Content(ConnectionsPart connectionsPart1)
{
Connections connections1 = new Connections();
Connection connection1 = new Connection(){ Id = (UInt32Value)1U, ConnectionFile = "C:\\Users\\pberruti\\Documents\\My Data Sources\\xlextdat105 Timestamps\\DAT105 Timestamp - Foodmart 2000 account.odc", Name = "DAT105 Timestamp - Foodmart 2000 account", Type = (UInt32Value)100U, RefreshedVersion = 5, MinRefreshableVersion = 5, Background = true };
ConnectionExtensionList connectionExtensionList1 = new ConnectionExtensionList();
ConnectionExtension connectionExtension1 = new ConnectionExtension(){ Uri = "{DE250136-89BD-433C-8126-D09CA5730AF9}" };
connectionExtension1.AddNamespaceDeclaration("x15", "http://schemas.microsoft.com/office/spreadsheetml/2010/11/main");
X15.Connection connection2 = new X15.Connection(){ Id = "d500245d-c151-4de3-9436-83c6e82b7f22", AutoDelete = true };
X15.OleDbPrpoperties oleDbPrpoperties1 = new X15.OleDbPrpoperties(){ Connection = "Provider=SQLOLEDB.1;Integrated Security=SSPI;Persist Security Info=True;Data Source=xlextdat105;Use Procedure for Prepare=1;Auto Translate=True;Packet Size=4096;Workstation ID=PB07641564SHIP;Use Encryption for Data=False;Tag with column collation when possible=False;Initial Catalog=Foodmart 2000" };
X15.DbCommand dbCommand1 = new X15.DbCommand(){ Text = "SELECT *, suser_name() CurrentUser, current_timestamp RefreshTime FROM \"Foodmart 2000\".\"dbo\".\"account\"" };
oleDbPrpoperties1.Append(dbCommand1);
connection2.Append(oleDbPrpoperties1);
connectionExtension1.Append(connection2);
connectionExtensionList1.Append(connectionExtension1);
connection1.Append(connectionExtensionList1);
Connection connection3 = new Connection(){ Id = (UInt32Value)2U, KeepAlive = true, Name = "ModelConnection_Query", Description = "Model", Type = (UInt32Value)5U, RefreshedVersion = 5, MinRefreshableVersion = 3, SaveData = true };
DatabaseProperties databaseProperties1 = new DatabaseProperties(){ Connection = "Data Model Connection", Command = "Query", CommandType = (UInt32Value)3U };
ConnectionExtensionList connectionExtensionList2 = new ConnectionExtensionList();
ConnectionExtension connectionExtension2 = new ConnectionExtension(){ Uri = "{DE250136-89BD-433C-8126-D09CA5730AF9}" };
connectionExtension2.AddNamespaceDeclaration("x15", "http://schemas.microsoft.com/office/spreadsheetml/2010/11/main");
X15.Connection connection4 = new X15.Connection(){ Id = "", Model = true };
connectionExtension2.Append(connection4);
connectionExtensionList2.Append(connectionExtension2);
connection3.Append(databaseProperties1);
connection3.Append(connectionExtensionList2);
Connection connection5 = new Connection(){ Id = (UInt32Value)3U, KeepAlive = true, Name = "ThisWorkbookDataModel", Description = "Model", Type = (UInt32Value)5U, RefreshedVersion = 5, MinRefreshableVersion = 5, Background = true };
DatabaseProperties databaseProperties2 = new DatabaseProperties(){ Connection = "Data Model Connection", Command = "Model", CommandType = (UInt32Value)1U };
OlapProperties olapProperties1 = new OlapProperties(){ SendLocale = true, RowDrillCount = (UInt32Value)1000U };
ConnectionExtensionList connectionExtensionList3 = new ConnectionExtensionList();
ConnectionExtension connectionExtension3 = new ConnectionExtension(){ Uri = "{DE250136-89BD-433C-8126-D09CA5730AF9}" };
connectionExtension3.AddNamespaceDeclaration("x15", "http://schemas.microsoft.com/office/spreadsheetml/2010/11/main");
X15.Connection connection6 = new X15.Connection(){ Id = "", Model = true };
connectionExtension3.Append(connection6);
connectionExtensionList3.Append(connectionExtension3);
connection5.Append(databaseProperties2);
connection5.Append(olapProperties1);
connection5.Append(connectionExtensionList3);
connections1.Append(connection1);
connections1.Append(connection3);
connections1.Append(connection5);
connectionsPart1.Connections = connections1;
}
public ManagementApiController(IRazorPartialToStringRenderer partialToStringRenderer, DatabaseProperties properties, EmailService emailService)
{
this.partialToStringRenderer = partialToStringRenderer;
this.properties = properties;
this.emailService = emailService;
}
public void ValidateResponseFactoryJsonSerializer()
{
ResponseMessage databaseResponse = this.CreateResponse();
ResponseMessage containerResponse = this.CreateResponse();
ResponseMessage storedProcedureExecuteResponse = this.CreateResponse();
ResponseMessage storedProcedureResponse = this.CreateResponse();
ResponseMessage triggerResponse = this.CreateResponse();
ResponseMessage udfResponse = this.CreateResponse();
ResponseMessage itemResponse = this.CreateResponse();
Mock <CosmosSerializer> mockUserJsonSerializer = new Mock <CosmosSerializer>();
CosmosSerializerCore serializerCore = new CosmosSerializerCore(mockUserJsonSerializer.Object);
CosmosResponseFactoryInternal cosmosResponseFactory = new CosmosResponseFactoryCore(
serializerCore);
// Test the user specified response
mockUserJsonSerializer.Setup(x => x.FromStream <ToDoActivity>(itemResponse.Content)).Callback <Stream>(input => input.Dispose()).Returns(new ToDoActivity());
mockUserJsonSerializer.Setup(x => x.FromStream <ToDoActivity>(storedProcedureExecuteResponse.Content)).Callback <Stream>(input => input.Dispose()).Returns(new ToDoActivity());
// Verify all the user types use the user specified version
cosmosResponseFactory.CreateItemResponse <ToDoActivity>(itemResponse);
cosmosResponseFactory.CreateStoredProcedureExecuteResponse <ToDoActivity>(storedProcedureExecuteResponse);
// Throw if the setups were not called
mockUserJsonSerializer.VerifyAll();
// Test read feed scenario
ResponseMessage readFeedResponse = this.CreateReadFeedResponse();
mockUserJsonSerializer.Setup(x => x.FromStream <ToDoActivity[]>(It.IsAny <Stream>()))
.Callback <Stream>(input => input.Dispose())
.Returns(new ToDoActivity[] { new ToDoActivity() });
FeedResponse <ToDoActivity> feedResponse = cosmosResponseFactory.CreateItemFeedResponse <ToDoActivity>(readFeedResponse);
foreach (ToDoActivity toDoActivity in feedResponse)
{
Assert.IsNotNull(toDoActivity);
}
mockUserJsonSerializer.VerifyAll();
ResponseMessage changeFeedResponseMessage = this.CreateChangeFeedNotModifiedResponse();
FeedResponse <ToDoActivity> changeFeedResponse = cosmosResponseFactory.CreateItemFeedResponse <ToDoActivity>(changeFeedResponseMessage);
Assert.AreEqual(HttpStatusCode.NotModified, changeFeedResponse.StatusCode);
Assert.IsFalse(changeFeedResponse.Resource.Any());
ResponseMessage queryResponse = this.CreateReadFeedResponse();
mockUserJsonSerializer.Setup(x => x.FromStream <ToDoActivity[]>(It.IsAny <Stream>())).Callback <Stream>(input => input.Dispose()).Returns(new ToDoActivity[] { new ToDoActivity() });
FeedResponse <ToDoActivity> queryFeedResponse = cosmosResponseFactory.CreateItemFeedResponse <ToDoActivity>(queryResponse);
foreach (ToDoActivity toDoActivity in queryFeedResponse)
{
Assert.IsNotNull(toDoActivity);
}
mockUserJsonSerializer.VerifyAll();
// Test the system specified response
ContainerProperties containerSettings = new ContainerProperties("mockId", "/pk");
DatabaseProperties databaseSettings = new DatabaseProperties()
{
Id = "mock"
};
StoredProcedureProperties cosmosStoredProcedureSettings = new StoredProcedureProperties()
{
Id = "mock"
};
TriggerProperties cosmosTriggerSettings = new TriggerProperties()
{
Id = "mock"
};
UserDefinedFunctionProperties cosmosUserDefinedFunctionSettings = new UserDefinedFunctionProperties()
{
Id = "mock"
};
Mock <Container> mockContainer = new Mock <Container>();
Mock <Database> mockDatabase = new Mock <Database>();
// Verify all the system types that should always use default
cosmosResponseFactory.CreateContainerResponse(mockContainer.Object, containerResponse);
cosmosResponseFactory.CreateDatabaseResponse(mockDatabase.Object, databaseResponse);
cosmosResponseFactory.CreateStoredProcedureResponse(storedProcedureResponse);
cosmosResponseFactory.CreateTriggerResponse(triggerResponse);
cosmosResponseFactory.CreateUserDefinedFunctionResponse(udfResponse);
}
protected BaseDatabaseOperationFunctions(DatabaseProperties databaseProperties)
{
DatabaseProperties = databaseProperties;
}
private static void DescribeDatabase(DatabaseProperties database)
{
Console.WriteLine($"Database Id: {database.Id}; Modified: {database.LastModified}");
}
public EmailService(AppDatabase database, DatabaseProperties databaseProperties, IRazorPartialToStringRenderer partialToStringRenderer)
{
this.database = database;
this.databaseProperties = databaseProperties;
this.partialToStringRenderer = partialToStringRenderer;
}