protected override void ExecuteCmdlet()
{
var manager = new AppManager(ClientContext);
if (MyInvocation.BoundParameters.ContainsKey("Identity"))
{
AppMetadata app = null;
if (Identity.Id != Guid.Empty)
{
app = manager.GetAvailable(Identity.Id);
}
else if (!string.IsNullOrEmpty(Identity.Title))
{
app = manager.GetAvailable(Identity.Title);
}
if (app != null)
{
WriteObject(app);
}
else
{
throw new System.Exception("App not found");
}
}
else
{
var apps = manager.GetAvailable();
WriteObject(apps, true);
}
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
services.Configure <List <AppUser> >(Configuration.GetSection("AppUsers"));
services.AddSingleton <BasicAuthenticationFilter>();
var appMetadata = new AppMetadata {
Name = Configuration.GetValue <string>("APP_NAME", "sample-dotnet-app"),
Description = Configuration.GetValue <string>("APP_DESCRIPTION", "A sample ASP.NET 2.2 Web API application"),
Version = Configuration.GetValue <string>("APP_VERSION", "set APP_VERSION in env to override")
};
services.AddSingleton(appMetadata);
string valuesServiceType = Configuration.GetSection("VALUES_SERVICE_TYPE").Get <string>();
if (valuesServiceType == "simple")
{
services.AddSingleton <IValuesService, SimpleValuesService>();
}
else
{
services.AddSingleton <IValuesService, DefaultValuesService>();
}
services.AddHealthChecks();
}
/// <summary>
/// Get the default server schema compiled from the database.
/// For a config variable, we fetch a static defined server, database and schema from the application's metadata to show "intellisence".
/// </summary>
/// <param name="defaultMetadatas">Metadatas of the plain old database</param>
/// <param name="serverId">Could be an Id like 0 or a variable like {$KEY{SERVER_VALUE}} OR {$SERVER_SOURCE{1}}.</param>
private static ServerMetadata GetServerMetadata(AppMetadata defaultMetadatas, string serverId)
{
if (serverId == null)
{
throw new ArgumentNullException("defaultMetadata");
}
//If is a serverId
Int16 id;
if (Int16.TryParse(serverId, out id))
{
if (defaultMetadatas.ContainsKey(id))
{
return(defaultMetadatas[id]);
}
}
//If is a variable
var configVar = serverId.ParseConfigVariable();
if (configVar != null && configVar.Server != 0 && defaultMetadatas.ContainsKey(configVar.Server))
{
return(defaultMetadatas[configVar.Server]);
}
throw new ConfigurationException(String.Format("Server not found in the configuration. Id : {0}", serverId));
}
public void Equals_different_references_can_still_be_equal()
{
var metadata1 = new AppMetadata("Name", "Description");
var metadata2 = new AppMetadata("Name", "Description");
metadata1.Equals(metadata2).ShouldBeTrue();
}
public static Query Load(string path)
{
if (!File.Exists(path))
{
throw new FileNotFoundException(path);
}
int formatVersion;
string description;
ImmutableHashSet <SqlConnection> connections;
AppMetadata metadata;
ExecutionPlanByServer executionPlanByServer;
FastAccessList <object> referenceTracking;
using (var istream = new FileStream(path, FileMode.Open))
using (var lzstream = new LZ4Stream(istream, CompressionMode.Decompress))
using (var bstream = new BinaryReader(lzstream, Encoding.UTF8, true))
{
formatVersion = bstream.ReadInt32();
description = bstream.ReadString();
referenceTracking = DeserializeReferenceTracking(bstream);
connections = DeserializeConnections(bstream);
executionPlanByServer = ExecutionPlanByServer.Deserialize(bstream, referenceTracking);
metadata = AppMetadata.Deserialize(bstream, referenceTracking);
}
return(new Query(metadata, executionPlanByServer, connections, formatVersion)
{
Description = description
});
}
public void Constructor_sets_values()
{
var metadata = new AppMetadata("Name", "Description");
metadata.Name.ShouldBe("Name");
metadata.Description.ShouldBe("Description");
}
protected QueryHelperBase(AppMetadata metadata, string providerName, string connectionString)
{
var factory = DbProviderFactories.GetFactory(providerName);
_metadata = metadata;
Connection = factory.CreateConnection();
Connection.ConnectionString = connectionString;
}
protected override void OnBackKeyPress(System.ComponentModel.CancelEventArgs e)
{
base.OnBackKeyPress(e);
if (!NavigationService.CanGoBack)
{
AppMetadata.CheckForReview(this);
}
}
protected virtual bool RequireUpgrade(AppMetadata metadata, out Version latestVersion)
{
latestVersion = IsExperimentalEnabled(metadata.LatestVersion.ExperimentalPercentage)
? metadata.LatestVersion.ExperimentalVersion
: metadata.LatestVersion.StableVersion;
return(latestVersion > CurrentVersion);
}
public void InitProviders(AppMetadata appMetadata, IEnumerable <SqlConnection> connections)
{
_queryHelpers = new Dictionary <short, IQueryHelper>();
foreach (var conn in connections)
{
_queryHelpers.Add(conn.Id, QueryHelperFactory.GetQueryHelper(appMetadata, conn.ProviderName, conn.ConnectionString));
}
}
public void Print(AppMetadata metadata)
{
Console.WriteLine("Usage:");
Console.WriteLine(" <command> [arguments] [options]");
Console.WriteLine("Commands:");
foreach (var command in metadata.Commands)
{
Console.WriteLine($" {command.Name}");
}
}
public static ApplicationViewModel Load(ProjectContainer proj, AppMetadata defaultAppMetadata)
{
return(new ApplicationViewModel
{
_name = proj.Name,
_connections = LoadConnections(proj.ConnectionStrings),
_templates = LoadTemplates(proj.Templates, defaultAppMetadata),
_defaultMetadatas = defaultAppMetadata
});
}
/// <summary>
/// Update the ViewModels, substract the defaultSchema from the configuration then save the file to disk.
/// </summary>
/// <param name="appVM">In-memory application view model.</param>
/// <param name="defaultSchema">Schema of the plain old database.</param>
public static void Save(this ApplicationViewModel appVM, AppMetadata defaultSchema, string path)
{
var proj = new ProjectContainer();
proj.Name = appVM.Name;
proj.ConnectionStrings = CreateConnectionStrings(appVM.Connections.Connections);
proj.Templates = CreateTemplates(appVM.Templates.ServerModifiers, defaultSchema);
proj.Save(path);
}
private static bool MergeDatabase(DatabaseModifierModel mergedDatabase,
List <DatabaseModifier> userConfigDatabases,
DatabaseMetadata defaultDatabaseSchema,
AppMetadata appMetadata)
{
var hasChange = false;
var userConfigDatabase = userConfigDatabases.FirstOrDefault(d => d.Name == mergedDatabase.Name);
if (defaultDatabaseSchema == null)
{
hasChange = true;
}
//Add new
if (userConfigDatabase == null)
{
userConfigDatabase = new DatabaseModifier {
Name = mergedDatabase.Name
};
userConfigDatabases.Add(userConfigDatabase);
}
//Apply changes
userConfigDatabase.TemplateId = mergedDatabase.TemplateId;
userConfigDatabase.BasedOn = mergedDatabase.UseTemplateId;
userConfigDatabase.Description = mergedDatabase.Description;
if (mergedDatabase.TemplateId != 0 ||
mergedDatabase.UseTemplateId != 0 ||
!String.IsNullOrEmpty(mergedDatabase.Description))
{
hasChange = true;
}
if (mergedDatabase.Schemas != null)
{
foreach (var mergedSchema in mergedDatabase.Schemas)
{
var defaultSchema = GetSchemaMetadata(defaultDatabaseSchema, appMetadata, mergedSchema.Name);
if (MergeSchema(mergedSchema, userConfigDatabase.Schemas, defaultSchema))
{
hasChange = true;
}
}
}
//If no change has been detected with the default config
if (!hasChange)
{
userConfigDatabases.Remove(userConfigDatabase);
}
return(hasChange);
}
/**
* Begin advertising for Nearby Connections, if possible.
*/
async void StartAdvertising()
{
// Discover nearby apps that are advertising with the required service ID.
var serviceId = GetString(Resource.String.service_id);
Log("startAdvertising " + serviceId);
if (!IsConnectedToNetwork())
{
Log("startAdvertising: not connected to WiFi network.");
return;
}
// Advertising with an AppIdentifer lets other devices on the network discover
// this application and prompt the user to install the application.
var appIdentifierList = new List <AppIdentifier> ();
appIdentifierList.Add(new AppIdentifier(this.PackageName));
var appMetadata = new AppMetadata(appIdentifierList);
// Advertise for Nearby Connections. This will broadcast the service id defined in
// AndroidManifest.xml. By passing 'null' for the name, the Nearby Connections API
// will construct a default name based on device model such as 'LGE Nexus 5'.
string name = null;
var result = await NearbyClass.Connections.StartAdvertisingAsync(
mGoogleApiClient, name, appMetadata, TIMEOUT_ADVERTISE, new MyConnectionRequestListener
{
ConnectionRequestHandler = OnConnectionRequest
});
Log("startAdvertising:onResult:" + result);
if (result.Status.IsSuccess)
{
Log("startAdvertising:onResult: SUCCESS");
UpdateViewVisibility(NearbyConnectionState.Advertising);
}
else
{
Log("startAdvertising:onResult: FAILURE ");
// If the user hits 'Advertise' multiple times in the timeout window,
// the error will be STATUS_ALREADY_ADVERTISING
if (result.Status.StatusCode == ConnectionsStatusCodes.StatusAlreadyAdvertising)
{
Log("STATUS_ALREADY_ADVERTISING");
}
else
{
UpdateViewVisibility(NearbyConnectionState.Ready);
}
}
}
private static bool MergeServer(ServerModifierModel mergedServer,
List <ServerModifier> userConfigServers,
ServerMetadata defaultServerSchema,
AppMetadata appMetadata)
{
var hasChange = false;
var userConfigServer = userConfigServers.FirstOrDefault(s => s.Id == mergedServer.Id);
if (defaultServerSchema == null)
{
hasChange = true;
}
//Add new
if (userConfigServer == null)
{
userConfigServer = new ServerModifier {
Id = mergedServer.Id
};
userConfigServers.Add(userConfigServer);
}
//Apply changes
userConfigServer.TemplateId = mergedServer.TemplateId;
userConfigServer.BasedOn = mergedServer.UseTemplateId;
userConfigServer.Description = mergedServer.Description;
if (mergedServer.TemplateId != 0 ||
mergedServer.UseTemplateId != 0 ||
!String.IsNullOrEmpty(mergedServer.Description))
{
hasChange = true;
}
if (mergedServer.Databases != null)
{
foreach (var mergedDatabase in mergedServer.Databases)
{
var defaultDatabaseSchema = GetDatabaseMetadata(defaultServerSchema, appMetadata, mergedDatabase.Name);
if (MergeDatabase(mergedDatabase, userConfigServer.Databases, defaultDatabaseSchema, appMetadata))
{
hasChange = true;
}
}
}
//If no change has been detected with the default config
if (!hasChange)
{
userConfigServers.Remove(userConfigServer);
}
return(hasChange);
}
internal Query(AppMetadata metadata,
ExecutionPlanByServer executionPlanByServer,
IEnumerable <SqlConnection> connections,
int formatVersion)
{
_metadata = metadata;
_executionPlanByServer = executionPlanByServer;
_connections = connections.ToImmutableHashSet();
_dispatcher = new QueryDispatcher();
_dispatcher.InitProviders(metadata, connections);
FormatVersion = formatVersion;
}
public override void Run(IList <string> args)
{
var store = new MongoMetaStore();
var appMetadata = store.GetAppById(args[0]);
if (appMetadata == null)
{
appMetadata = new AppMetadata {
AppId = args[0], Platforms = new Dictionary <string, AppSecret>()
}
}
;
if (string.IsNullOrEmpty(appMetadata.ApiKey))
{
appMetadata.ApiKey = GenerateApiKey();
}
if (!string.IsNullOrWhiteSpace(_apnsCertFile))
{
appMetadata.Platforms["apns"] = new AppSecret {
Certificate = File.ReadAllBytes(_apnsCertFile)
};
}
if (_mpnsCertFile != null)
{
appMetadata.Platforms["mpns"] = new AppSecret
{
Certificate = string.IsNullOrWhiteSpace(_mpnsCertFile) ? null : File.ReadAllBytes(_mpnsCertFile)
};
}
if (!string.IsNullOrWhiteSpace(_gcmKey))
{
appMetadata.Platforms["gcm"] = new AppSecret {
Key = _gcmKey
};
}
if (!string.IsNullOrEmpty(_wnsKey))
{
var parts = _wnsKey.Split('?');
Console.WriteLine(parts.Length);
if (parts.Length != 2 || string.IsNullOrWhiteSpace(parts[0]) || string.IsNullOrWhiteSpace(parts[1]))
{
throw new ArgumentException("WNS credentials must be in the format SID?secret");
}
appMetadata.Platforms["wns"] = new AppSecret {
AppId = parts[0], Key = parts[1]
};
}
store.Save(appMetadata);
Console.WriteLine("API Key: " + appMetadata.ApiKey);
}
public void WriteAppMetadata(AppMetadata appMetadata)
{
var appMetadataJson = StorageJsonUtils.AppMetadataToJson(appMetadata);
string appMetadataPath = _credentialPathManager.GetAppMetadataPath(appMetadata);
ReadModifyWrite(
appMetadataPath,
fileContent =>
{
JsonMerge(appMetadataJson, fileContent);
return(appMetadataJson);
});
}
public void WriteAppMetadata(AppMetadata appMetadata)
{
try
{
//using (new StorageManagerDelegateManager(this, new TokenCacheNotificationArgs(null, null), true))
{
_storageWorker.WriteAppMetadata(appMetadata);
}
}
catch (Exception ex)
{
HandleException(ex);
}
}
public CommandMetadata Parse(AppMetadata appMetadata, Token[] tokens)
{
var commandName = ParseCommandName(tokens);
if (commandName == null)
{
return(null);
}
var metadata = appMetadata
.Commands
.First(command => command.Name == commandName);
return(metadata);
}
public override async Task <AppIcon> DownloadIconAsync(AppMetadata meta)
{
if (string.IsNullOrEmpty(meta.IconUrl))
{
throw new ArgumentException("Metadata has empty icon url", nameof(meta));
}
var result = new AppIcon();
var httpResult = await Client.GetAsync(new Uri(meta.IconUrl));
if (httpResult.Content != null)
{
result.ContentType = httpResult.Content?.Headers?.ContentType?.MediaType;
result.Content = await httpResult.Content.ReadAsByteArrayAsync();
}
return(result);
}
public async Task MetadataMiddlewareResponseMustBeDeSerializableForSimpleCSharpClient()
{
using (BitOwinTestEnvironment testEnvironment = new BitOwinTestEnvironment())
{
HttpResponseMessage getMetadataForV1 = await testEnvironment.Server.BuildHttpClient()
.GetAsync("Metadata/V1");
getMetadataForV1.EnsureSuccessStatusCode();
AppMetadata appMetadata = await getMetadataForV1.Content.ReadAsAsync <AppMetadata>();
Assert.IsTrue(appMetadata.Messages.Any());
Assert.IsTrue(appMetadata.Dtos.Any());
Assert.IsTrue(appMetadata.Projects.Any());
}
}
protected QueryHelperBase(AppMetadata metadata, string providerName, string connectionString)
{
DbProviderFactory factory;
//var factory = DbProviderFactories.GetFactory(providerName);
switch (providerName)
{
case QueryHelperMsSql.ProviderName:
factory = SqlClientFactory.Instance;
break;
default:
throw new Exception("Provider not supported");
}
_metadata = metadata;
Connection = factory.CreateConnection();
Connection.ConnectionString = connectionString;
}
public async Task <bool> UpdateAsync(AppMetadata metadata)
{
PrepareUpgrade();
if (!RequireUpgrade(metadata, out var latestVersion))
{
return(true);
}
var upgradeInfo = GetUpgradeInfo(latestVersion);
var upgradeResult = await UpgradeCoreAsync(upgradeInfo);
if (upgradeResult)
{
CurrentVersion = upgradeInfo.Version;
}
return(upgradeResult);
}
/// <summary>
/// Compile the execution plan with default values.
/// </summary>
/// <returns>An executable query.</returns>
public Query Compile()
{
OptimizeExecutionPlans(_executionPlanByServer);
//Purify
var conns = new List <SqlConnection>();
var metadata = new AppMetadata();
var destinationSrv = (from server in _executionPlanByServer
from insertStep in server.Value.InsertSteps
select insertStep.DestinationTable.ServerId).Distinct();
foreach (var srv in destinationSrv)
{
conns.Add(MetadataContainer.ConnectionStrings.First(c => c.Id == srv));
metadata.Add(srv, MetadataContainer.Metadatas.First(s => s.Key == srv).Value);
}
return(new Query(metadata, _executionPlanByServer, conns, Query.CURRENT_FORMAT_VERSION));
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
base.OnNavigatedTo(e);
if (e.NavigationMode == NavigationMode.New)
{
ErrorReporting.CheckForPreviousException(true);
AppMetadata.CheckForNewVersion();
}
// settings changed
if (lastEmail != null && lastEmail != Settings.GetString(Setting.Email))
{
ErrorReporting.Log("Settings changed");
activeCourses.ItemsSource = null;
upcomingCourses.ItemsSource = null;
finishedCourses.ItemsSource = null;
}
var email = Settings.GetString(Setting.Email);
var password = Settings.GetString(Setting.Password);
lastEmail = email;
if (string.IsNullOrEmpty(email) || string.IsNullOrEmpty(password))
{
if (e.NavigationMode != NavigationMode.Back)
{
this.NavigateToSettings();
}
else
{
messageTextBlock.Text = "Please set your email and password in the Settings.";
messageTextBlock.Visibility = Visibility.Visible;
}
}
else if (activeCourses.ItemsSource == null)
{
LoadCourses(email, password, false);
}
}
void StartAdvertising()
{
DebugLog("startAdvertising");
if (!IsConnectedToNetwork)
{
DebugLog("startAdvertising: not connected to WiFi network.");
return;
}
var appIdentifierList = new List <AppIdentifier> ();
appIdentifierList.Add(new AppIdentifier(PackageName));
var appMetadata = new AppMetadata(appIdentifierList);
var name = string.Empty;
NearbyClass.Connections.StartAdvertising(mGoogleApiClient, name, appMetadata, TIMEOUT_ADVERTISE,
this).SetResultCallback((IConnectionsStartAdvertisingResult result) => {
Log.Debug(TAG, "startAdvertising:onResult:" + result);
if (result.Status.IsSuccess)
{
DebugLog("startAdvertising:onResult: SUCCESS");
UpdateViewVisibility(NearbyConnectionState.Advertising);
}
else
{
DebugLog("startAdvertising:onResult: FAILURE ");
int statusCode = result.Status.StatusCode;
if (statusCode == ConnectionsStatusCodes.StatusAlreadyAdvertising)
{
DebugLog("STATUS_ALREADY_ADVERTISING");
}
else
{
UpdateViewVisibility(NearbyConnectionState.Ready);
}
}
});
}
public static IQueryHelper GetQueryHelper(AppMetadata schema, string providerName, string connectionString)
{
switch (providerName)
{
case QueryHelperMsSql.ProviderName:
return(new QueryHelperMsSql(schema, connectionString));
case QueryHelperMySql.ProviderName:
return(new QueryHelperMySql(schema, connectionString));
case QueryHelperPostgreSql.ProviderName:
return(new QueryHelperPostgreSql(schema, connectionString));
//case OracleProvider.ProviderName:
// return new OracleProvider();
//case SqlServerCEProvider.ProviderName:
// return new SqlServerCEProvider();
//case SqliteProvider.ProviderName:
// return new SqliteProvider();
}
throw new Exception("Unkown provider");
}
public virtual AppMetadata GetAppMetadata()
{
if (_appMetadata == null)
{
List <ObjectMetadata> allMetadata = _metadataBuilders
.SelectMany(mb => mb.BuildMetadata())
.ToList();
AppEnvironment activeAppEnvironment = _appEnvironmentProvider.GetActiveAppEnvironment();
_appMetadata = new AppMetadata
{
Messages = activeAppEnvironment.Cultures.ToList(),
Views = allMetadata.OfType <ViewMetadata>().ToList(),
Dtos = allMetadata.OfType <DtoMetadata>().ToList(),
Projects = allMetadata.OfType <ProjectMetadata>().ToList()
};
}
return(_appMetadata);
}
async Task StartAdvertising ()
{
DebugLog ("startAdvertising");
if (!IsConnectedToNetwork) {
DebugLog ("startAdvertising: not connected to WiFi network.");
return;
}
var appIdentifierList = new List<AppIdentifier> ();
appIdentifierList.Add (new AppIdentifier (PackageName));
var appMetadata = new AppMetadata (appIdentifierList);
var name = string.Empty;
var result = await NearbyClass.Connections.StartAdvertisingAsync (mGoogleApiClient, name, appMetadata, TIMEOUT_ADVERTISE, this);
Log.Debug (TAG, "startAdvertising:onResult:" + result);
if (result.Status.IsSuccess) {
DebugLog ("startAdvertising:onResult: SUCCESS");
UpdateViewVisibility (NearbyConnectionState.Advertising);
} else {
DebugLog ("startAdvertising:onResult: FAILURE ");
int statusCode = result.Status.StatusCode;
if (statusCode == ConnectionsStatusCodes.StatusAlreadyAdvertising) {
DebugLog ("STATUS_ALREADY_ADVERTISING");
} else {
UpdateViewVisibility (NearbyConnectionState.Ready);
}
}
}
