internal Element(BaseStorage storage, Guid obj, ApplicationType appType, int identifier)
{
_storage = storage;
_obj = obj;
_appType = appType;
_identifier = identifier;
}
public SemanticValidator(FileFormatVersions format, ApplicationType app)
{
FileFormat = format;
AppType = app;
_curReg = new SemanticConstraintRegistry(format, app);
}
/// <summary>
/// Constructor
/// </summary>
public SemanticConstraintRegistry(FileFormatVersions format, ApplicationType appType)
{
_format = format;
_appType = appType;
Initialize();
}
public OfficeApplicationObjectProvider(object officeApplicationObject, ApplicationType applicationType)
{
// TODO: Complete member initialization
this.officeApplicationObject = officeApplicationObject;
m_bExternalApplication = officeApplicationObject != null;
this.applicationType = applicationType;
}
/// <summary>
/// Register a constraint to this registry.
/// </summary>
public void RegisterConstraint(int elementTypeID, int ancestorTypeID, FileFormatVersions fileFormat, ApplicationType appType, SemanticConstraint constraint )
{
if ((fileFormat & _format) == _format && (appType & _appType) == _appType)
{
AddConstraintToDic(constraint, ancestorTypeID, _cleanList);
AddConstraintToDic(constraint, elementTypeID, _semConstraintMap);
}
}
internal static MonoProcess Start(ApplicationType type, string _targetExe)
{
if (type == ApplicationType.Desktopapplication)
return new MonoDesktopProcess(_targetExe);
if (type == ApplicationType.Webapplication)
return new MonoWebProcess();
throw new Exception("Unknown ApplicationType");
}
public async Task HelloWorld(ServerType serverType, RuntimeFlavor runtimeFlavor, RuntimeArchitecture architecture, string applicationBaseUrl, ServerType delegateServer, ApplicationType applicationType)
{
var logger = new LoggerFactory()
.AddConsole()
.AddDebug()
.CreateLogger($"HelloWorld:{serverType}:{runtimeFlavor}:{architecture}:{delegateServer}");
using (logger.BeginScope("HelloWorldTest"))
{
var deploymentParameters = new DeploymentParameters(Helpers.GetTestSitesPath(applicationType), serverType, runtimeFlavor, architecture)
{
ApplicationBaseUriHint = applicationBaseUrl,
EnvironmentName = "HelloWorld", // Will pick the Start class named 'StartupHelloWorld',
ServerConfigTemplateContent = (serverType == ServerType.IISExpress) ? File.ReadAllText("Http.config") : null,
SiteName = "HttpTestSite", // This is configured in the Http.config
TargetFramework = runtimeFlavor == RuntimeFlavor.Clr ? "net451" : "netcoreapp1.0",
ApplicationType = applicationType
};
using (var deployer = ApplicationDeployerFactory.Create(deploymentParameters, logger))
{
var deploymentResult = deployer.Deploy();
var httpClientHandler = new HttpClientHandler();
var httpClient = new HttpClient(httpClientHandler)
{
BaseAddress = new Uri(deploymentResult.ApplicationBaseUri),
Timeout = TimeSpan.FromSeconds(5),
};
// Request to base address and check if various parts of the body are rendered & measure the cold startup time.
var response = await RetryHelper.RetryRequest(() =>
{
return httpClient.GetAsync(string.Empty);
}, logger, deploymentResult.HostShutdownToken, retryCount: 30);
var responseText = await response.Content.ReadAsStringAsync();
try
{
Assert.Equal("Hello World", responseText);
response = await httpClient.GetAsync("/Path%3F%3F?query");
responseText = await response.Content.ReadAsStringAsync();
Assert.Equal("/Path??", responseText);
response = await httpClient.GetAsync("/Query%3FPath?query?");
responseText = await response.Content.ReadAsStringAsync();
Assert.Equal("?query?", responseText);
}
catch (XunitException)
{
logger.LogWarning(response.ToString());
logger.LogWarning(responseText);
throw;
}
}
}
}
public void Save(ApplicationType type)
{
if (type == ApplicationType.Application && MainFunc != null)
{
MethodInfo wrappedMain = WrapMain(MainFunc);
_assemblyBuilder.SetEntryPoint(wrappedMain, PEFileKinds.ConsoleApplication);
}
SaveAssembly(_fileName, _assemblyBuilder);
}
public static INodeCartridge GetHandler(ApplicationType applicationType)
{
switch (applicationType)
{
case ApplicationType.Mono:
return new MonoCartridge();
default:
throw new MonoscapeException("Unknown application type found");
}
}
/// <summary>
/// Get the directory for the default location of the CruiseControl.NET data files.
/// </summary>
/// <param name="application">Type of the application. E.g. Server or WebDashboard.</param>
/// <returns>The location of the CruiseControl.NET data files.</returns>
public string GetDefaultProgramDataFolder(ApplicationType application)
{
if (application == ApplicationType.Unknown)
{
throw new ArgumentOutOfRangeException("application");
}
var pgfPath = AppDomain.CurrentDomain.BaseDirectory;
return pgfPath;
}
public async Task NonWindowsOS(
ServerType serverType,
RuntimeFlavor runtimeFlavor,
RuntimeArchitecture architecture,
ApplicationType applicationType,
string applicationBaseUrl)
{
var smokeTestRunner = new SmokeTests(_logger);
await smokeTestRunner.SmokeTestSuite(serverType, runtimeFlavor, architecture, applicationType, applicationBaseUrl);
}
public Application(ApplicationType type, string applicant, string destacc, string destname, string memo)
{
AppType = type;
Applicant = applicant;
DestAcc = destacc;
DestName = destname;
Memo = memo;
CreationTime = DateTime.Now;
AppType = ApplicationType.APerson;
}
public async Task NtlmAuthenticationTest(ServerType serverType, RuntimeFlavor runtimeFlavor, RuntimeArchitecture architecture, ApplicationType applicationType, string applicationBaseUrl)
{
using (_logger.BeginScope("NtlmAuthenticationTest"))
{
var musicStoreDbName = DbUtils.GetUniqueName();
var deploymentParameters = new DeploymentParameters(Helpers.GetApplicationPath(applicationType), serverType, runtimeFlavor, architecture)
{
PublishApplicationBeforeDeployment = true,
TargetFramework = runtimeFlavor == RuntimeFlavor.Clr ? "net451" : "netcoreapp1.0",
ApplicationType = applicationType,
ApplicationBaseUriHint = applicationBaseUrl,
EnvironmentName = "NtlmAuthentication", //Will pick the Start class named 'StartupNtlmAuthentication'
ServerConfigTemplateContent = (serverType == ServerType.IISExpress) ? File.ReadAllText("NtlmAuthentation.config") : null,
SiteName = "MusicStoreNtlmAuthentication", //This is configured in the NtlmAuthentication.config
UserAdditionalCleanup = parameters =>
{
DbUtils.DropDatabase(musicStoreDbName, _logger);
}
};
// Override the connection strings using environment based configuration
deploymentParameters.EnvironmentVariables
.Add(new KeyValuePair<string, string>(
MusicStore.StoreConfig.ConnectionStringKey,
DbUtils.CreateConnectionString(musicStoreDbName)));
using (var deployer = ApplicationDeployerFactory.Create(deploymentParameters, _logger))
{
var deploymentResult = deployer.Deploy();
var httpClientHandler = new HttpClientHandler() { UseDefaultCredentials = true };
var httpClient = new HttpClient(httpClientHandler) { BaseAddress = new Uri(deploymentResult.ApplicationBaseUri) };
// Request to base address and check if various parts of the body are rendered & measure the cold startup time.
var response = await RetryHelper.RetryRequest(async () =>
{
return await httpClient.GetAsync(string.Empty);
}, logger: _logger, cancellationToken: deploymentResult.HostShutdownToken);
Assert.False(response == null, "Response object is null because the client could not " +
"connect to the server after multiple retries");
var validator = new Validator(httpClient, httpClientHandler, _logger, deploymentResult);
Console.WriteLine("Verifying home page");
await validator.VerifyNtlmHomePage(response);
Console.WriteLine("Verifying access to store with permissions");
await validator.AccessStoreWithPermissions();
_logger.LogInformation("Variation completed successfully.");
}
}
}
/// <summary>
/// Function to save work detail.
/// </summary>
/// <param name="workDetail">work detail information</param>
/// <param name="applicationType">Application type</param>
public void InsertOrUpdate(WorkDetail workDetail, ApplicationType applicationType)
{
if (workDetail == null)
{
throw new ArgumentNullException(WorkDetailConst);
}
workDetail.Date = workDetail.Date.Date;
workDetail.ApplicationID = (byte)applicationType;
this.timesheetRepository.InsertOrUpdate(workDetail);
this.unitOfWork.Save();
}
public async Task NonWindowsOS(
ServerType serverType,
RuntimeFlavor runtimeFlavor,
RuntimeArchitecture architecture,
ApplicationType applicationType,
string applicationBaseUrl,
bool noSource)
{
var testRunner = new PublishAndRunTests(_logger);
await testRunner.Publish_And_Run_Tests(
serverType, runtimeFlavor, architecture, applicationType, applicationBaseUrl, noSource);
}
public static LogServerComponent CreateLogServerComponent(ApplicationType appType,
LogServerComponentType logServer)
{
var ht = GetHost(appType, logServer.hostID);
var component = new LogServerComponent(logServer.componentID, appType.applicationID, ht)
{
WorkingDir = logServer.workingDir,
Port = logServer.port,
HostName = ht.hostname
};
return component;
}
/// <summary>
/// Inserts the specified work detail.
/// </summary>
/// <param name="workDetail">The work detail.</param>
/// <param name="applicationType">Type of the application.</param>
/// <returns>The total timesheet hours</returns>
public decimal Insert(WorkDetail workDetail, ApplicationType applicationType)
{
if (workDetail == null)
{
throw new ArgumentNullException(WorkDetailConst);
}
workDetail.Date = workDetail.Date.Date;
workDetail.ApplicationID = (byte)applicationType;
var result = this.timesheetRepository.Insert(workDetail);
this.unitOfWork.Save();
return result;
}
public static ForgeComponent CreateForgeComponent(ApplicationType appType, ForgeComponentType forge)
{
var ht = GetHost(appType, forge.hostID);
var component = new ForgeComponent(forge.componentID, appType.applicationID, ht)
{
OutputDirectory = ResolveRelativePath(forge.workingDir, forge.outputDir),
InputDirectory = ResolveRelativePath(forge.workingDir, forge.inputDir),
LogDir = ResolveRelativePath(forge.workingDir, Path.GetDirectoryName(forge.logFile)),
WorkingDir = forge.workingDir,
DataPrefix = forge.outputPrefixName
};
LoadCustomProperties(component, forge);
return component;
}
public static int GeneratePairedKey(string initialKey, ApplicationType appType)
{
string constantKey = "CashRegister2013";
if (appType == ApplicationType.TaxCalculator)
{
constantKey = "TaxCalculator2014";
}
int hash = 23;
hash = hash * 2 + initialKey.GetHashCode();
hash = hash * 3 + constantKey.GetHashCode();
hash = Math.Abs(hash);
Debug.WriteLine("generated paired key: " + hash);
return hash;
}
public static DgidxComponent CreateDgidxComponent(ApplicationType appType, DgidxComponentType dgidx)
{
var ht = GetHost(appType, dgidx.hostID);
var component = new DgidxComponent(dgidx.componentID, appType.applicationID, ht)
{
WorkingDir = dgidx.workingDir,
OutputDirectory = ResolveRelativePath(dgidx.workingDir,
RemovePrefixNameFromDir(dgidx.outputPrefix)),
InputDirectory = ResolveRelativePath(dgidx.workingDir, RemovePrefixNameFromDir(dgidx.inputPrefix)),
LogDir = ResolveRelativePath(dgidx.workingDir, Path.GetDirectoryName(dgidx.logFile)),
DataPrefix = GetDataPrefixFromDir(dgidx.outputPrefix)
};
LoadCustomProperties(component, dgidx);
return component;
}
public IosPushMessageSender(ApplicationType? appType)
{
if(appType == ApplicationType.Tablet)
config = new ApnsConfiguration(PushSharp.Apple.ApnsConfiguration.ApnsServerEnvironment.Production,
Options.ApnsCertificateFileTablet, Options.ApnsCertificatePasswordTablet);
else
config = new ApnsConfiguration(PushSharp.Apple.ApnsConfiguration.ApnsServerEnvironment.Production,
Options.ApnsCertificateFileMobile, Options.ApnsCertificatePasswordMobile);
SetUpFeedbackServiceTimer(Options.APNSFeedbackServiceRunDelay);
apnsBroker = new ApnsServiceBroker(config);
apnsBroker.OnNotificationFailed += (notification, aggregateEx) =>
{
aggregateEx.Handle(ex =>
{
if (ex is ApnsNotificationException)
{
var notificationException = (ApnsNotificationException)ex;
var apnsNotification = notificationException.Notification;
var statusCode = notificationException.ErrorStatusCode;
logger.Error(string.Format("Apple Notification Failed: ID={0}, Code={1}, Token ={2}", apnsNotification.Identifier, statusCode, notification.DeviceToken));
System.Diagnostics.Debug.WriteLine(string.Format("Apple Notification Failed: ID={0}, Code={1}, Token ={2}", apnsNotification.Identifier, statusCode, notification.DeviceToken));
}
else
{
logger.Error(string.Format("Apple Notification Failed for some unknown reason : {0}, Token = {1}", ex.InnerException, notification.DeviceToken));
System.Diagnostics.Debug.WriteLine(string.Format("Apple Notification Failed for some unknown reason : {0}, Token = {1}", ex.InnerException, notification.DeviceToken));
}
notificationService.Unsubscribe(notification.DeviceToken, userId);
return true;
});
};
apnsBroker.OnNotificationSucceeded += (notification) =>
{
logger.Info("Notification Successfully Sent to: " + notification.DeviceToken);
System.Diagnostics.Debug.WriteLine("Notification Successfully Sent to: " + notification.DeviceToken);
};
apnsBroker.Start();
}
/// <summary>
/// Sends push message to subscribed user device
/// </summary>
/// <param name="userId"></param>
/// <param name="deviceType"></param>
/// <param name="token"></param>
/// <param name="message"></param>
public void Send(Int64 userId, DeviceType deviceType, string token, string message, ApplicationType? appType)
{
try
{
PushMessageSender pushMessageSender = GetPushMessageSender(deviceType, appType);
if (pushMessageSender == null)
{
throw new ApplicationException(string.Format("Device type: {0} is not supported", deviceType));
}
pushMessageSender.SendPushNotification(token, message, userId);
}
catch(Exception e)
{
throw new ApplicationException(e.Message);
}
}
public ClientInfo(Guid clientID)
{
ClientID = clientID;
ClientType = Common.GetApplicationType();
UserName = Thread.CurrentPrincipal.Identity.Name;
if (string.IsNullOrEmpty(UserName))
UserName = Environment.UserDomainName + "\\" + Environment.UserName;
MachineName = Environment.MachineName;
if (ClientType == ApplicationType.WindowsCui || ClientType == ApplicationType.WindowsGui)
{
ClientName = AppDomain.CurrentDomain.FriendlyName;
}
else if (ClientType == ApplicationType.Web)
{
ClientName = System.Web.HttpContext.Current.Request.ApplicationPath;
}
}
public static DgraphComponent CreateDgraphComponent(ApplicationType appType, DgraphComponentType dgraph)
{
var ht = GetHost(appType, dgraph.hostID);
var component = new DgraphComponent(dgraph.componentID, appType.applicationID, ht)
{
WorkingDir = dgraph.workingDir,
LogDir = ResolveRelativePath(dgraph.workingDir, Path.GetDirectoryName(dgraph.logFile)),
InputDirectory = ResolveRelativePath(dgraph.workingDir,
RemovePrefixNameFromDir(dgraph.inputPrefix)),
UpdateDir = ResolveRelativePath(dgraph.workingDir, dgraph.updateDir),
UpdateLogDir = ResolveRelativePath(dgraph.workingDir, Path.GetDirectoryName(dgraph.updateLogFile))
};
LoadCustomProperties(component, dgraph);
component.IndexDistributionDir = ResolveRelativePath(dgraph.workingDir,
component.CustomProps["localIndexDir"]);
component.DataPrefix = GetDataPrefixFromDir(dgraph.inputPrefix);
component.Port = dgraph.port;
component.HostName = ht.hostname;
return component;
}
/// <summary>
/// 入口程序
/// </summary>
/// <param name="application"></param>
public void Init(HttpApplication application)
{
if (null != application)
{
//关联处理事件
application.BeginRequest += new EventHandler(Application_BeginRequest);
application.AuthorizeRequest += new EventHandler(Application_AuthorizeRequest);
applicationInstalled = ConfigurationManager.AppSettings["Installer"] == null;
currentApplicationType = HiConfiguration.GetConfig().AppLocation.CurrentApplicationType;
//检查是否安装
CheckInstall(application.Context);
if (currentApplicationType != ApplicationType.Installer)
{
//启动工作线程
Hidistro.Core.Jobs.Jobs.Instance().Start();
ExtensionContainer.LoadExtensions();
}
}
}
public static string GetApplicationPath(ApplicationType applicationType)
{
return(Path.GetFullPath(Path.Combine(Directory.GetCurrentDirectory(), "..", "..", "samples", applicationType == ApplicationType.Standalone ? "MusicStore.Standalone" : "MusicStore")));
}
public void TestReadScopeResourcesWithRegistedFullScope(Enums.ResourceType resourceType, ApplicationType appType)
{
InitFullScopeAdapter(appType);
Dictionary <string, object> urlParameter = new Dictionary <string, object>()
{
{ Partition, appInfo.Company.Partition }
};
ReadAndVerifyData(resourceType.ToString(), urlParameter);
}
private async Task HelloWorld(RuntimeFlavor runtimeFlavor, ApplicationType applicationType, ANCMVersion ancmVersion)
{
var serverType = ServerType.IISExpress;
var architecture = RuntimeArchitecture.x64;
var testName = $"HelloWorld_{runtimeFlavor}";
using (StartLog(out var loggerFactory, testName))
{
var logger = loggerFactory.CreateLogger("HelloWorldTest");
var deploymentParameters = new DeploymentParameters(Helpers.GetOutOfProcessTestSitesPath(), serverType, runtimeFlavor, architecture)
{
EnvironmentName = "HelloWorld", // Will pick the Start class named 'StartupHelloWorld',
ServerConfigTemplateContent = (serverType == ServerType.IISExpress) ? File.ReadAllText("AppHostConfig/Http.config") : null,
SiteName = "HttpTestSite", // This is configured in the Http.config
TargetFramework = runtimeFlavor == RuntimeFlavor.Clr ? "net461" : "netcoreapp2.1",
ApplicationType = applicationType,
ANCMVersion = ancmVersion
};
using (var deployer = ApplicationDeployerFactory.Create(deploymentParameters, loggerFactory))
{
var deploymentResult = await deployer.DeployAsync();
// Request to base address and check if various parts of the body are rendered & measure the cold startup time.
var response = await RetryHelper.RetryRequest(() =>
{
return(deploymentResult.HttpClient.GetAsync(string.Empty));
}, logger, deploymentResult.HostShutdownToken, retryCount : 30);
var responseText = await response.Content.ReadAsStringAsync();
try
{
Assert.Equal("Hello World", responseText);
response = await deploymentResult.HttpClient.GetAsync("/Path%3F%3F?query");
responseText = await response.Content.ReadAsStringAsync();
Assert.Equal("/Path??", responseText);
response = await deploymentResult.HttpClient.GetAsync("/Query%3FPath?query?");
responseText = await response.Content.ReadAsStringAsync();
Assert.Equal("?query?", responseText);
response = await deploymentResult.HttpClient.GetAsync("/BodyLimit");
responseText = await response.Content.ReadAsStringAsync();
Assert.Equal("null", responseText);
response = await deploymentResult.HttpClient.GetAsync("/Auth");
responseText = await response.Content.ReadAsStringAsync();
// We adapted the Http.config file to be used for inprocess too. We specify WindowsAuth is enabled
// We now expect that windows auth is enabled rather than disabled.
Assert.True("backcompat;Windows".Equals(responseText) || "latest;Windows".Equals(responseText), "Auth");
}
catch (XunitException)
{
logger.LogWarning(response.ToString());
logger.LogWarning(responseText);
throw;
}
}
}
}
/// <summary> /// Loads and validates the application configuration from a configuration section. /// </summary> /// <param name="file">The file.</param> /// <param name="applicationType">Type of the application.</param> /// <param name="systemType">Type of the system.</param> /// <returns>Application configuration</returns> public static Task <ApplicationConfiguration> Load(FileInfo file, ApplicationType applicationType, Type systemType) => ApplicationConfiguration.Load(file, applicationType, systemType, true);
private void setApplicationType(SchemaItemDTO dto, ApplicationType newApplicationType)
{
OnEvent(() => _presenter.SetApplicationType(dto, newApplicationType));
}
/// <summary>
/// Create a 106 kbps card type B like a credit card
/// </summary>
/// <param name="atqb">Data to decode</param>
public Data106kbpsTypeB(byte[] atqb)
{
try
{
Command = atqb[0];
NfcId = new byte[4];
atqb.AsSpan().Slice(1, 4).CopyTo(NfcId);
ApplicationData = new byte[4];
atqb.AsSpan().Slice(5, 4).CopyTo(ApplicationData);
BitRates = atqb[9];
MaxFrameSize = (MaxFrameSize)(atqb[10] & 0b1111_0000);
ISO14443_4Compliance = (atqb[10] & 0b0000_11111) == 1;
var fwi = atqb[11] & 0b1111_0000;
if (fwi == 0b0000_0000)
{
FrameWaitingTime = 302.1f;
}
else if (fwi == 0b0001_0000)
{
FrameWaitingTime = 604.1f;
}
else if (fwi == 0b0010_0000)
{
FrameWaitingTime = 1203.3f;
}
else if (fwi == 0b0011_0000)
{
FrameWaitingTime = 2416.5f;
}
else if (fwi == 0b0100_0000)
{
FrameWaitingTime = 4833.0f;
}
else if (fwi == 0b0101_0000)
{
FrameWaitingTime = 9666.1f;
}
else if (fwi == 0b0110_0000)
{
FrameWaitingTime = 19332.2f;
}
else if (fwi == 0b0111_0000)
{
FrameWaitingTime = 38664.3f;
}
else if (fwi == 0b1000_0000)
{
FrameWaitingTime = 77328.6f;
}
else if (fwi == 0b1001_0000)
{
FrameWaitingTime = 154657.2f;
}
else if (fwi == 0b1010_0000)
{
FrameWaitingTime = 309314.5f;
}
else if (fwi == 0b1011_0000)
{
FrameWaitingTime = 618628.9f;
}
else if (fwi == 0b1100_0000)
{
FrameWaitingTime = 1237257.8f;
}
else if (fwi == 0b1101_0000)
{
FrameWaitingTime = 2474515.6f;
}
else if (fwi == 0b1110_0000)
{
FrameWaitingTime = 4949031.3f;
}
NadSupported = (atqb[11] & 0b0000_0010) == 0b0000_0010;
CidSupported = (atqb[11] & 0b0000_0001) == 0b0000_0001;
ApplicationType = (ApplicationType)(atqb[11] & 0b0000_1100);
// Ignore the 2 last bytes. They are CRC
}
catch (ArgumentOutOfRangeException ex)
{
throw new ArgumentOutOfRangeException($"Can't create a 106 kbpd card type B", ex.InnerException);
}
}
public void TestInvalidCodeDirectScopeIsIgnored(string scope, ApplicationType appType)
{
InitApiHelpers(appType);
VerifyCodeDirectScope(scope, appType);
}
private static string pkParameterNameForCmaxRatio(ApplicationType applicationType)
{
return(applicationType == ApplicationType.Multiple ? Constants.PKParameters.C_max_tLast_tEnd : Constants.PKParameters.C_max);
}
public ContactHandler(string appId, string appSecret, ApplicationType appType, string language, IConfigurationProvider configManager)
: base(appId, appSecret, appType, language, configManager)
{
}
public void TestOauthWithoutScopeRegister(string scope, string type, object errorCode, ApplicationType appType)
{
InitApiHelpers(appType);
using (var appInfoRead = AuthenticationInfoProvider.Current.Manager.GetApplication(
new ApplicationSpecBuilder().ParameterEquals("type", appType.ToString()).ParameterContains("categories", "read_scope")))
{
using (var appInfoWrite = AuthenticationInfoProvider.Current.Manager.GetApplication(
new ApplicationSpecBuilder().ParameterEquals("type", appType.ToString()).ParameterContains("categories", "write_scope")))
{
Dictionary <string, object> oauthParams = new Dictionary <string, object>()
{
};
oauthParams.Add("response_type", "code_direct");
oauthParams.Add("scope", scope);
string appId = string.Empty;
switch (type)
{
case "read":
appId = appInfoWrite.Key;
break;
case "write":
appId = appInfoRead.Key;
break;
}
oauthParams.Add("app_id", appId);
Handler handler = oAuthAPI.Read(oauthParams);
Assert.That(handler.HttpCode, Is.EqualTo(System.Net.HttpStatusCode.OK), "The http code is invalid");
APITestFramework.Resources.PublicAPI.Authentication result = XmlHelper.ParseXMLString <APITestFramework.Resources.PublicAPI.Authentication>(handler.RawContent);
Assert.That(result, Is.Not.Null, "Failed to parse the server's response");
Assert.That(int.Parse(result.Error), Is.EqualTo(errorCode), result.Message);
}
}
}
/// <summary>
/// Raises all BeforeSection events. These events are raised before a section is commited to the datastore
/// </summary>
public static void BeforeSection(Section section, ObjectState state, ApplicationType appType)
{
CSApplication.Instance().ExecutePreSectionUpdate(section,state,appType);
}
/// <summary>
/// Raises all BeforeGroup events. These events are raised before a group change is commited to the datastore
/// </summary>
public static void BeforeGroup(Group group, ObjectState state, ApplicationType appType)
{
CSApplication.Instance().ExecutePreSectionGroupUpdate(group,state,appType);
}
private void InitFullScopeAdapter(ApplicationType appType)
{
appInfo = GetDefaultApplication(appType);
adapter = GetDefaultAdapter(appType);
}
private static string IdentifierToName(ApplicationType appType, int identifier)
{
ElementClass idClass = GetClass(identifier);
if (idClass == ElementClass.Library)
{
switch (identifier)
{
case 0x11000001: return("device");
case 0x12000002: return("path");
case 0x12000004: return("description");
case 0x12000005: return("locale");
case 0x14000006: return("inherit");
case 0x15000007: return("truncatememory");
case 0x14000008: return("recoverysequence");
case 0x16000009: return("recoveryenabled");
case 0x1700000A: return("badmemorylist");
case 0x1600000B: return("badmemoryaccess");
case 0x1500000C: return("firstmegabytepolicy");
case 0x16000010: return("bootdebug");
case 0x15000011: return("debugtype");
case 0x15000012: return("debugaddress");
case 0x15000013: return("debugport");
case 0x15000014: return("baudrate");
case 0x15000015: return("channel");
case 0x12000016: return("targetname");
case 0x16000017: return("noumex");
case 0x15000018: return("debugstart");
case 0x16000020: return("bootems");
case 0x15000022: return("emsport");
case 0x15000023: return("emsbaudrate");
case 0x12000030: return("loadoptions");
case 0x16000040: return("advancedoptions");
case 0x16000041: return("optionsedit");
case 0x15000042: return("keyringaddress");
case 0x16000046: return("graphicsmodedisabled");
case 0x15000047: return("configaccesspolicy");
case 0x16000048: return("nointegritychecks");
case 0x16000049: return("testsigning");
case 0x16000050: return("extendedinput");
case 0x15000051: return("initialconsoleinput");
}
}
else if (idClass == ElementClass.Application)
{
switch (appType)
{
case ApplicationType.FirmwareBootManager:
case ApplicationType.BootManager:
switch (identifier)
{
case 0x24000001: return("displayorder");
case 0x24000002: return("bootsequence");
case 0x23000003: return("default");
case 0x25000004: return("timeout");
case 0x26000005: return("resume");
case 0x23000006: return("resumeobject");
case 0x24000010: return("toolsdisplayorder");
case 0x26000020: return("displaybootmenu");
case 0x26000021: return("noerrordisplay");
case 0x21000022: return("bcddevice");
case 0x22000023: return("bcdfilepath");
case 0x27000030: return("customactions");
}
break;
case ApplicationType.OsLoader:
switch (identifier)
{
case 0x21000001: return("osdevice");
case 0x22000002: return("systemroot");
case 0x23000003: return("resumeobject");
case 0x26000010: return("detecthal");
case 0x22000011: return("kernel");
case 0x22000012: return("hal");
case 0x22000013: return("dbgtransport");
case 0x25000020: return("nx");
case 0x25000021: return("pae");
case 0x26000022: return("winpe");
case 0x26000024: return("nocrashautoreboot");
case 0x26000025: return("lastknowngood");
case 0x26000026: return("oslnointegritychecks");
case 0x26000027: return("osltestsigning");
case 0x26000030: return("nolowmem");
case 0x25000031: return("removememory");
case 0x25000032: return("increaseuserva");
case 0x25000033: return("perfmem");
case 0x26000040: return("vga");
case 0x26000041: return("quietboot");
case 0x26000042: return("novesa");
case 0x25000050: return("clustermodeaddressing");
case 0x26000051: return("usephysicaldestination");
case 0x25000052: return("restrictapiccluster");
case 0x26000060: return("onecpu");
case 0x25000061: return("numproc");
case 0x26000062: return("maxproc");
case 0x25000063: return("configflags");
case 0x26000070: return("usefirmwarepcisettings");
case 0x25000071: return("msi");
case 0x25000072: return("pciexpress");
case 0x25000080: return("safeboot");
case 0x26000081: return("safebootalternateshell");
case 0x26000090: return("bootlog");
case 0x26000091: return("sos");
case 0x260000A0: return("debug");
case 0x260000A1: return("halbreakpoint");
case 0x260000B0: return("ems");
case 0x250000C0: return("forcefailure");
case 0x250000C1: return("driverloadfailurepolicy");
case 0x250000E0: return("bootstatuspolicy");
}
break;
case ApplicationType.Resume:
switch (identifier)
{
case 0x21000001: return("filedevice");
case 0x22000002: return("filepath");
case 0x26000003: return("customsettings");
case 0x26000004: return("pae");
case 0x21000005: return("associatedosdevice");
case 0x26000006: return("debugoptionenabled");
}
break;
case ApplicationType.MemoryDiagnostics:
switch (identifier)
{
case 0x25000001: return("passcount");
case 0x25000002: return("testmix");
case 0x25000003: return("failurecount");
case 0x25000004: return("testtofail");
}
break;
case ApplicationType.NtLoader:
case ApplicationType.SetupLoader:
switch (identifier)
{
case 0x22000001: return("bpbstring");
}
break;
case ApplicationType.Startup:
switch (identifier)
{
case 0x26000001: return("pxesoftreboot");
case 0x22000002: return("applicationname");
}
break;
}
}
else if (idClass == ElementClass.Device)
{
switch (identifier)
{
case 0x35000001: return("ramdiskimageoffset");
case 0x35000002: return("ramdisktftpclientport");
case 0x31000003: return("ramdisksdidevice");
case 0x32000004: return("ramdisksdipath");
case 0x35000005: return("ramdiskimagelength");
case 0x36000006: return("exportascd");
case 0x35000007: return("ramdisktftpblocksize");
}
}
else if (idClass == ElementClass.Hidden)
{
switch (identifier)
{
case 0x45000001: return("devicetype");
case 0x42000002: return("apprelativepath");
case 0x42000003: return("ramdiskdevicerelativepath");
case 0x46000004: return("omitosloaderelements");
case 0x46000010: return("recoveryos");
}
}
return(identifier.ToString("X8", CultureInfo.InvariantCulture));
}
public void TestLongCodeDirectScopeIsIgnored(ApplicationType appType)
{
InitApiHelpers(appType);
VerifyCodeDirectScope(Util.GetUniqueString(2048, false), appType);
}
public async Task Publish_And_Run_Tests(
ServerType serverType,
RuntimeArchitecture architecture,
ApplicationType applicationType,
bool noSource)
{
var noSourceStr = noSource ? "NoSource" : "WithSource";
var testName = $"PublishAndRunTests_{serverType}_{architecture}_{applicationType}_{noSourceStr}";
using (StartLog(out var loggerFactory, testName))
{
var logger = loggerFactory.CreateLogger("Publish_And_Run_Tests");
var musicStoreDbName = DbUtils.GetUniqueName();
var deploymentParameters = new DeploymentParameters(
Helpers.GetApplicationPath(applicationType), serverType, RuntimeFlavor.CoreClr, architecture)
{
PublishApplicationBeforeDeployment = true,
PreservePublishedApplicationForDebugging = Helpers.PreservePublishedApplicationForDebugging,
TargetFramework = "netcoreapp2.0",
Configuration = Helpers.GetCurrentBuildConfiguration(),
ApplicationType = applicationType,
UserAdditionalCleanup = parameters =>
{
DbUtils.DropDatabase(musicStoreDbName, logger);
}
};
// Override the connection strings using environment based configuration
deploymentParameters.EnvironmentVariables
.Add(new KeyValuePair <string, string>(
MusicStoreConfig.ConnectionStringKey,
DbUtils.CreateConnectionString(musicStoreDbName)));
using (var deployer = ApplicationDeployerFactory.Create(deploymentParameters, loggerFactory))
{
var deploymentResult = await deployer.DeployAsync();
var httpClientHandler = new HttpClientHandler()
{
UseDefaultCredentials = true
};
var httpClient = deploymentResult.CreateHttpClient(httpClientHandler);
// Request to base address and check if various parts of the body are rendered &
// measure the cold startup time.
// Add retry logic since tests are flaky on mono due to connection issues
var response = await RetryHelper.RetryRequest(async() => await httpClient.GetAsync(string.Empty), logger : logger, cancellationToken : deploymentResult.HostShutdownToken);
Assert.False(response == null, "Response object is null because the client could not " +
"connect to the server after multiple retries");
var validator = new Validator(httpClient, httpClientHandler, logger, deploymentResult);
logger.LogInformation("Verifying home page");
await validator.VerifyHomePage(response);
logger.LogInformation("Verifying static files are served from static file middleware");
await validator.VerifyStaticContentServed();
if (serverType != ServerType.IISExpress)
{
if (Directory.GetFiles(
deploymentParameters.ApplicationPath, "*.cmd", SearchOption.TopDirectoryOnly).Length > 0)
{
throw new Exception("publishExclude parameter values are not honored.");
}
}
logger.LogInformation("Variation completed successfully.");
}
}
}
public void TestOauthValidInput(string redirect_url, string scope, string state, string response_type, ApplicationType appType)
{
InitApiHelpers(appType);
var appInfo = GetDefaultApplication(appType);
Dictionary <string, object> oauthParams = new Dictionary <string, object>()
{
};
oauthParams.Add("app_id", appInfo.Key);
if (null != redirect_url)
{
oauthParams.Add("redirect_url", redirect_url);
}
if (null != scope)
{
oauthParams.Add("scope", scope);
}
if (null != state)
{
oauthParams.Add("state", state);
}
if (null != response_type)
{
oauthParams.Add("response_type", response_type);
}
Handler handler = oAuthAPI.Read(oauthParams);
Assert.That(handler.HttpCode, Is.EqualTo(System.Net.HttpStatusCode.OK), "The http code is invalid");
APITestFramework.Resources.PublicAPI.Authentication result = XmlHelper.ParseXMLString <APITestFramework.Resources.PublicAPI.Authentication>(handler.RawContent);
Assert.That(result, Is.Not.Null, "Failed to parse the server's response");
if (response_type == "code_direct" && appType == ApplicationType.ThirdParty)
{
Assert.That(int.Parse(result.Error), Is.EqualTo(Enums.PublicAPIAuthCode.ResponseTypeInvalid), "Wrong error code. Received message: '" + result.Message + "', while expected 'Invalid Response Type' ");
}
else
{
Assert.That(int.Parse(result.Error), Is.EqualTo(Enums.PublicAPIAuthCode.Success), result.Message);
}
}
private static string pkParameterNameForAUCRatio(ApplicationType applicationType)
{
return(applicationType == ApplicationType.Multiple ? Constants.PKParameters.AUC_inf_tLast : Constants.PKParameters.AUC_inf);
}
public AttachmentControllerAdapter(ApplicationType type, Domain domain) : base(type, domain)
{
}
public IPKSimCommand SetApplicationType(ISchemaItem schemaItem, ApplicationType applicationType)
{
return(new SetSchemaItemApplicationTypeCommand(schemaItem, applicationType).Run(_executionContext));
}
/// <summary>
/// 是否存在菜单
/// </summary>
/// <param name="parentNodeId">上级节点Id</param>
/// <param name="applicationType">应用程序类型</param>
/// <param name="menuName">菜单名称</param>
/// <returns>是否存在</returns>
public bool ExistsMenu(Guid?parentNodeId, ApplicationType applicationType, string menuName)
{
return(this._repMediator.MenuRep.Exists(parentNodeId, applicationType, menuName));
}
private void VaryByArchitecture(List <TestVariant> variants, string tfm, string skip, ApplicationType type)
{
foreach (var arch in Architectures)
{
var archSkip = skip ?? SkipIfArchitectureNotSupportedOnCurrentSystem(arch);
variants.Add(new TestVariant()
{
Tfm = tfm,
ApplicationType = type,
Architecture = arch,
Skip = archSkip,
});
}
}
/// <summary>
/// 是否存在权限
/// </summary>
/// <param name="infoSystemNo">信息系统编号</param>
/// <param name="applicationType">应用程序类型</param>
/// <param name="authorityPath">权限路径</param>
/// <returns>是否存在</returns>
public bool ExistsAuthority(string infoSystemNo, ApplicationType applicationType, string authorityPath)
{
return(this._repMediator.AuthorityRep.ExistsPath(infoSystemNo, applicationType, authorityPath));
}
/// <summary>
/// Ensures that the application configuration is valid.
/// </summary>
/// <param name="applicationType">Type of the application.</param>
public virtual async Task Validate(ApplicationType applicationType)
{
if (String.IsNullOrEmpty(ApplicationName))
{
throw ServiceResultException.Create(StatusCodes.BadConfigurationError, "ApplicationName must be specified.");
}
if (SecurityConfiguration == null)
{
throw ServiceResultException.Create(StatusCodes.BadConfigurationError, "SecurityConfiguration must be specified.");
}
SecurityConfiguration.Validate();
// load private key
await SecurityConfiguration.ApplicationCertificate.LoadPrivateKeyEx(SecurityConfiguration.CertificatePasswordProvider);
Func <string> generateDefaultUri = () => {
var sb = new StringBuilder();
sb.Append("urn:");
sb.Append(Utils.GetHostName());
sb.Append(":");
sb.Append(ApplicationName);
return(sb.ToString());
};
if (String.IsNullOrEmpty(ApplicationUri))
{
m_applicationUri = generateDefaultUri();
}
if (applicationType == ApplicationType.Client || applicationType == ApplicationType.ClientAndServer)
{
if (ClientConfiguration == null)
{
throw ServiceResultException.Create(StatusCodes.BadConfigurationError, "ClientConfiguration must be specified.");
}
ClientConfiguration.Validate();
}
if (applicationType == ApplicationType.Server || applicationType == ApplicationType.ClientAndServer)
{
if (ServerConfiguration == null)
{
throw ServiceResultException.Create(StatusCodes.BadConfigurationError, "ServerConfiguration must be specified.");
}
ServerConfiguration.Validate();
}
if (applicationType == ApplicationType.DiscoveryServer)
{
if (DiscoveryServerConfiguration == null)
{
throw ServiceResultException.Create(StatusCodes.BadConfigurationError, "DiscoveryServerConfiguration must be specified.");
}
DiscoveryServerConfiguration.Validate();
}
// toggle the state of the hi-res clock.
HiResClock.Disabled = m_disableHiResClock;
if (m_disableHiResClock)
{
if (m_serverConfiguration != null)
{
if (m_serverConfiguration.PublishingResolution < 50)
{
m_serverConfiguration.PublishingResolution = 50;
}
}
}
await m_certificateValidator.Update(this.SecurityConfiguration);
}
//命令部分
#region # 创建信息系统 —— void CreateInfoSystem(string infoSystemNo, string infoSystemName...
/// <summary>
/// 创建信息系统
/// </summary>
/// <param name="infoSystemNo">信息系统编号</param>
/// <param name="infoSystemName">信息系统名称</param>
/// <param name="adminLoginId">系统管理员账号</param>
/// <param name="applicationType">应用程序类型</param>
public void CreateInfoSystem(string infoSystemNo, string infoSystemName, string adminLoginId, ApplicationType applicationType)
{
#region # 验证
if (this._repMediator.InfoSystemRep.ExistsNo(infoSystemNo))
{
throw new ArgumentOutOfRangeException(nameof(infoSystemNo), $"信息系统编号\"{infoSystemNo}\"已存在！");
}
if (this._repMediator.UserRep.ExistsNo(adminLoginId))
{
throw new ArgumentOutOfRangeException(nameof(adminLoginId), $"用户名：\"{adminLoginId}\"已存在！");
}
#endregion
InfoSystem infoSystem = new InfoSystem(infoSystemNo, infoSystemName, adminLoginId, applicationType);
User superAdmin = this._unitOfWork.Resolve <User>(CommonConstants.AdminLoginId);
User systemAdmin = new User(infoSystem.AdminLoginId, $"{infoSystem.Name}管理员", CommonConstants.InitialPassword);
Role systemAdminRole = new Role($"{infoSystem.Name}管理员", infoSystem.Number, null, infoSystem.Number);
superAdmin.AppendRoles(new[] { systemAdminRole });
systemAdmin.AppendRoles(new[] { systemAdminRole });
Menu systemMenu = new Menu(infoSystem.Number, infoSystem.ApplicationType, infoSystem.Name, 0, null, null, null, null);
this._unitOfWork.RegisterAdd(infoSystem);
this._unitOfWork.RegisterAdd(systemAdmin);
this._unitOfWork.RegisterAdd(systemAdminRole);
this._unitOfWork.RegisterAdd(systemMenu);
this._unitOfWork.RegisterSave(superAdmin);
this._unitOfWork.Commit();
}
/// <summary> /// Loads and validates the application configuration from a configuration section. /// </summary> /// <param name="sectionName">Name of configuration section for the current application's default configuration containing <see cref="ConfigurationLocation"/>.</param> /// <param name="applicationType">Type of the application.</param> /// <returns>Application configuration</returns> public static Task <ApplicationConfiguration> Load(string sectionName, ApplicationType applicationType) => Load(sectionName, applicationType, typeof(ApplicationConfiguration));
public IActionResult Create(ApplicationType obj)
{
_db.ApplicationType.Add(obj);
_db.SaveChanges();
return(RedirectToAction("Index"));
}
public void TestReadScopeOtherResourcesWithRegistedFullScope(string resource, ApplicationType appType)
{
InitFullScopeAdapter(appType);
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ Partition, appInfo.Company.Partition }
};
switch (resource)
{
case "user":
parameters.Add("request_type", 1);
ReadAndVerifyData <User>(adapter, parameters);
break;
case "partition":
parameters.Add("request_type", 1);
parameters.Remove(Partition);
ReadAndVerifyData <Partition>(adapter, parameters);
break;
case "field":
parameters.Add("resource", (int)Enums.ResourceType.Client);
ReadAndVerifyData <Field>(adapter, parameters);
break;
case "option":
ReadAndVerifyData <Option>(adapter, parameters);
break;
}
}
public void TestWriteScopeResourcesWithRegistedFullScope(Enums.ResourceType resourceType, ApplicationType appType)
{
InitFullScopeAdapter(appType);
XmlResource resource = CreateResourceInstance(resourceType);
string id = adapter.WriteSuccess(resource, cleaner.Delete);
Assert.That(id, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType));
}
/// <summary>
/// Raises all RatePost events. These events are raised after a post is rated.
/// </summary>
public static void RatePost(Post post, ApplicationType appType)
{
CSApplication.Instance().ExecuteRatePostEvents(post,appType);
}
private IParameterCollection GetParameterCollection(ApplicationDocumentation application, ApplicationType applicationType)
{
switch (applicationType)
{
case ApplicationType.SingleCommand:
return(Assert.IsType <SingleCommandApplicationDocumentation>(application));
case ApplicationType.MultiCommand:
var mutliCommandApplication = Assert.IsType <MultiCommandApplicationDocumentation>(application);
return(Assert.Single(mutliCommandApplication.Commands));
default:
throw new NotImplementedException();
}
}
/// <summary>
/// Raises all BeforePost events. These events are raised before a post is commited to the datastore
/// </summary>
public static void BeforePost(Post post, ObjectState state, ApplicationType appType)
{
CSApplication.Instance().ExecutePrePostUpdateEvents(post,state,appType);
}
public void Named_parameters_are_loaded_correctly(ApplicationType applicationType)
{
// ARRANGE
using var assembly = Compile($@"
using System;
using CommandLine;
public enum SomeEnum
{{
Value1,
Value2,
SomeOtherValue
}}
{GetClassAttributes(applicationType)}
public class Command1Options
{{
[Option(""option1"", HelpText = ""some help text"", Default = ""some default"")]
public string Option1Property {{ get; set; }}
[Option('x', Default = 23)]
public int Option2Property {{ get; set; }}
[Option('y', Default = true)]
public bool? Option3Property {{ get; set; }}
[Option(""option4"", Hidden = true)]
public string Option4Property {{ get; set; }}
[Option(""option5"", Required = true, MetaValue = ""PATH"")]
public string Option5Property {{ get; set; }}
[Option('z', ""option6"")]
public SomeEnum Option6Property {{ get; set; }}
[Option(""option7"", Default = SomeEnum.SomeOtherValue)]
public SomeEnum Option7Property {{ get; set; }}
[Option(""option8"", Default = true)]
public bool? Option8Property {{ get; set; }}
}}
");
// ACT
var sut = new CommandLineParserLoader(m_Logger);
// ACT
var application = sut.Load(assembly);
// ASSERT
Assert.NotNull(application);
var parameterCollection = GetParameterCollection(application, applicationType);
Assert.Empty(parameterCollection.SwitchParameters);
Assert.Empty(parameterCollection.PositionalParameters);
Assert.Collection(parameterCollection.NamedParameters,
param =>
{
Assert.Equal("option1", param.Name);
Assert.Null(param.ShortName);
Assert.Equal("some help text", param.Description);
Assert.False(param.Required);
Assert.Equal("some default", param.DefaultValue);
Assert.Null(param.AcceptedValues);
Assert.Null(param.ValuePlaceHolderName);
},
param =>
{
Assert.Equal("option5", param.Name);
Assert.Null(param.ShortName);
Assert.Null(param.Description);
Assert.True(param.Required);
Assert.Null(param.DefaultValue);
Assert.Null(param.AcceptedValues);
Assert.Equal("PATH", param.ValuePlaceHolderName);
},
param =>
{
Assert.Equal("option6", param.Name);
Assert.Equal("z", param.ShortName);
Assert.Null(param.Description);
Assert.False(param.Required);
Assert.Null(param.DefaultValue);
Assert.NotNull(param.AcceptedValues);
Assert.Equal(3, param.AcceptedValues !.Count);
Assert.Contains("Value1", param.AcceptedValues);
Assert.Contains("Value2", param.AcceptedValues);
Assert.Contains("SomeOtherValue", param.AcceptedValues);
Assert.Null(param.ValuePlaceHolderName);
},
/// <summary>
/// Creates an application object.
/// </summary>
/// <param name="imageType">The image type of the application.</param>
/// <param name="appType">The application's type.</param>
/// <returns>The object representing the new application.</returns>
public BcdObject CreateApplication(ApplicationImageType imageType, ApplicationType appType)
{
Guid obj = _store.CreateObject(Guid.NewGuid(), BcdObject.MakeApplicationType(imageType, appType));
return new BcdObject(_store, obj);
}
public void TestOauthInvalidInput(string redirect_url, string scope, string state, string response_type, object errorCode, ApplicationType appType)
{
InitApiHelpers(appType);
var appInfo = GetDefaultApplication(appType);
Dictionary <string, object> oauthParams = new Dictionary <string, object>()
{
};
oauthParams.Add("app_id", appInfo.Key);
if (null != redirect_url)
{
oauthParams.Add("redirect_url", redirect_url);
}
if (null != scope)
{
oauthParams.Add("scope", scope);
}
if (null != state)
{
oauthParams.Add("state", state);
}
if (null != response_type)
{
oauthParams.Add("response_type", response_type);
}
Handler handler = oAuthAPI.Read(oauthParams);
Assert.That(handler.HttpCode, Is.EqualTo(System.Net.HttpStatusCode.OK), "The http code is invalid");
APITestFramework.Resources.PublicAPI.Authentication result = XmlHelper.ParseXMLString <APITestFramework.Resources.PublicAPI.Authentication>(handler.RawContent);
Assert.That(result, Is.Not.Null, "Failed to parse the server's response");
Assert.That(int.Parse(result.Error), Is.EqualTo(errorCode), result.Message);
}
