static async Task Main(string[] args)
{
_serviceProvider = DependencyHelper.RegisterServices(_serviceProvider);
Console.WriteLine("Initializing Agent...");
bool endTransfer = false;;
while (!endTransfer)
{
Console.WriteLine("Press a key to perform an action:");
Console.WriteLine("h: Send Telemetry for Heart Rate");
Console.WriteLine("q: End");
var input = Console.ReadKey().KeyChar;
if (char.ToLower(input) == 'q')
{
endTransfer = true;
}
else
{
endTransfer = false;
}
switch (char.ToLower(input))
{
case 'h':
Console.WriteLine("Number of Telemetry Events to be Generated");
var numberOfTelemertry = Console.ReadLine();
int numberOfEvents;
int.TryParse(numberOfTelemertry, out numberOfEvents);
await SendHeartRateTelemetry(numberOfEvents);
break;
default:
break;
}
}
}
public void ArgumentInline()
{
var id = Guid.NewGuid().ToString("N").ToUpper();
IInlineMessage message = new InlineMessage
{
ID = id,
State = MessageState.Accept,
Service = "Topic",
Method = "Title",
Argument = @"{""Value"": ""Content""}",
Result = @"{""Value"": ""Result""}"
};
message.CheckState();
Assert.IsTrue(message.DataState == (MessageDataState.ArgumentOffline | MessageDataState.ResultOffline), message.DataState.ToString());
//message.PrepareResult(null, ApiResultHelper.State);
message.RestoryContent(DependencyHelper.GetService <IJsonSerializeProxy>(), typeof(Argument));;
Assert.IsTrue(message.ArgumentData is Argument, message.ArgumentData.GetTypeName());
Assert.IsTrue(message.DataState == (MessageDataState.ArgumentOffline | MessageDataState.ResultOffline | MessageDataState.ArgumentInline),
message.DataState.ToString());
}
static void Main(String[] args)
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
try
{
string message = "";
if (DependencyHelper.CheckDependencies(ref message))
{
Application.Run(new ScriptWizard());
}
else
{
MessageBox.Show(message, "Dependencies");
}
}
catch (Exception ex)
{
MessageBox.Show("Sorry! SQLAzureMW encountered an error. Please see additional information to resolve." + Environment.NewLine + ex.ToString());
}
}
private static bool CheckToken(IInlineMessage message, IZeroContext context)
{
if (message.TraceInfo.Token.IsBlank() || !message.IsOutAccess)
{
return(true);
}
var resolver = DependencyHelper.GetService <ITokenResolver>();
if (resolver == null)
{
return(true);
}
context.User = resolver.TokenToUser(message.TraceInfo.Token);
if (context.User[ZeroTeamJwtClaim.Iss] != ToolsOption.Instance.JwtIssue)
{
FlowTracer.MonitorInfomation(() => $"非法令牌颁发机构 => {context.User[ZeroTeamJwtClaim.Iss]}");
message.State = MessageState.Deny;
message.Result = ApiResultHelper.DenyAccessJson;
return(false);
}
return(true);
}
protected virtual AbstractEntityRepository CreateEntityRepository(bool isReadOnly)
{
if (NhDependencyHelper == null)
{
var extra = "(null)";
if (DependencyHelper != null)
{
extra = DependencyHelper.GetType().Name;
if (DependencyHelper.ProviderMetadata != null)
{
extra += " with key " + DependencyHelper.ProviderMetadata.Alias.IfNullOrWhiteSpace("(no key)");
}
}
throw new NullReferenceException("NhDependencyHelper is null and DependencyHelper is " + extra);
}
if (NhDependencyHelper.FactoryHelper == null)
{
throw new NullReferenceException("NhDependencyHelper.FactoryHelper is null");
}
ISession session;
var transaction = NhDependencyHelper.FactoryHelper.GenerateSessionAndTransaction(isReadOnly, out session);
var schemaRepository = NhSchemaRepositoryFactory != null
? NhSchemaRepositoryFactory.GetRepository(transaction, isReadOnly)
: SchemaRepositoryFactory.GetRepository();
var revisionRepository = NhRevisionRepositoryFactory != null
? NhRevisionRepositoryFactory.GetRepository(transaction, isReadOnly)
: RevisionRepositoryFactory.GetRepository();
return(new EntityRepository(ProviderMetadata, schemaRepository, revisionRepository, transaction, session, FrameworkContext, isReadOnly));
}
private void OnTextChanged(PropertyChangedFromTextBoxEventArgs property)
{
PropertyModel p = property.Property;
BarCodeControl c = (BarCodeControl)property.PrintControl;
DependencyObject d = DependencyHelper.FindVisualChildByName(c, p.Name);
if (d != null)
{
Type t = d.GetType();
if (t == typeof(TextBlock))
{
TextBlock r = d as TextBlock;
int i = (int)Convert.ChangeType(p.Value, typeof(int));
if (i == 66)
{
r.Visibility = Visibility.Visible;
}
else
{
r.Visibility = Visibility.Collapsed;
}
}
}
}
public void InitializeDeps_WithRidSpecificNativeAssets_LoadsExpectedDependencies(string rid, string expectedNativeRid, string prefix, string suffix, bool expectMatch)
{
string depsPath = Path.Combine(Directory.GetCurrentDirectory(), "Description", "DotNet", "TestFiles", "DepsFiles", "RidNativeDeps");
List <string> ridFallback = DependencyHelper.GetRuntimeFallbacks(rid);
(_, IDictionary <string, RuntimeAsset[]> nativeLibraries) =
FunctionAssemblyLoadContext.InitializeDeps(depsPath, ridFallback);
string nativeAssetFileName = $"{prefix}Cosmos.CRTCompat.{suffix}";
bool result = FunctionAssemblyLoadContext.TryGetDepsAsset(nativeLibraries, nativeAssetFileName, ridFallback, out RuntimeAsset asset);
if (expectMatch)
{
Assert.True(result);
Assert.Equal($"runtimes/{expectedNativeRid}/native/{nativeAssetFileName}", asset.Path);
}
else
{
Assert.False(result);
Assert.Null(asset);
}
}
public BaseController(IOptions <AppSettings> options)
{
DependencyHelper.ThrowIfNull(options);
_appSettings = options.Value;
}
public void Initialize()
{
DependencyHelper dependencyHelper = new DependencyHelper();
exactCharacterSetDetectionService = dependencyHelper.GetExactCharacterSetDetectionService();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddCors(options =>
{
options.AddPolicy("CorsPolicy",
builder => builder.AllowAnyOrigin()
.AllowAnyMethod()
.AllowAnyHeader());
});
// Add framework services.
services.AddDbContext <AppIdentityDbContext>(options => options.UseSqlServer(Configuration.GetConnectionString("Default"), b => b.MigrationsAssembly("Web.Api.Infrastructure")));
services.AddDbContext <AppDbContext>(options => options.UseSqlServer(Configuration.GetConnectionString("Default"), b => b.MigrationsAssembly("Web.Api.Infrastructure")));
// Register the ConfigurationBuilder instance of AuthSettings
var authSettings = Configuration.GetSection(nameof(AuthSettings));
services.Configure <AuthSettings>(authSettings);
var signingKey = new SymmetricSecurityKey(Encoding.ASCII.GetBytes(authSettings[nameof(AuthSettings.SecretKey)]));
// jwt wire up
// Get options from app settings
var jwtAppSettingOptions = Configuration.GetSection(nameof(JwtIssuerOptions));
// Configure JwtIssuerOptions
services.Configure <JwtIssuerOptions>(options =>
{
options.Issuer = jwtAppSettingOptions[nameof(JwtIssuerOptions.Issuer)];
options.Audience = jwtAppSettingOptions[nameof(JwtIssuerOptions.Audience)];
options.SigningCredentials = new SigningCredentials(signingKey, SecurityAlgorithms.HmacSha256);
});
var tokenValidationParameters = new TokenValidationParameters
{
ValidateIssuer = true,
ValidIssuer = jwtAppSettingOptions[nameof(JwtIssuerOptions.Issuer)],
ValidateAudience = true,
ValidAudience = jwtAppSettingOptions[nameof(JwtIssuerOptions.Audience)],
ValidateIssuerSigningKey = true,
IssuerSigningKey = signingKey,
RequireExpirationTime = false,
ValidateLifetime = true,
ClockSkew = TimeSpan.Zero
};
services.AddAuthentication(options =>
{
options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
}).AddJwtBearer(configureOptions =>
{
configureOptions.ClaimsIssuer = jwtAppSettingOptions[nameof(JwtIssuerOptions.Issuer)];
configureOptions.TokenValidationParameters = tokenValidationParameters;
configureOptions.SaveToken = true;
configureOptions.Events = new JwtBearerEvents
{
OnAuthenticationFailed = context =>
{
if (context.Exception.GetType() == typeof(SecurityTokenExpiredException))
{
context.Response.Headers.Add("Token-Expired", "true");
}
return(Task.CompletedTask);
}
};
});
// api user claim policy
services.AddAuthorization(options =>
{
options.AddPolicy("ApiUser", policy => policy.RequireClaim(Constants.Strings.JwtClaimIdentifiers.Rol, Constants.Strings.JwtClaims.ApiAccess));
});
// add identity
var identityBuilder = services.AddIdentityCore <AppUser>(o =>
{
// configure identity options
o.Password.RequireDigit = false;
o.Password.RequireLowercase = false;
o.Password.RequireUppercase = false;
o.Password.RequireNonAlphanumeric = false;
o.Password.RequiredLength = 6;
});
identityBuilder = new IdentityBuilder(identityBuilder.UserType, typeof(IdentityRole), identityBuilder.Services);
identityBuilder.AddEntityFrameworkStores <AppIdentityDbContext>().AddDefaultTokenProviders();
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1).AddFluentValidation(fv => fv.RegisterValidatorsFromAssemblyContaining <Startup>());
services.AddAutoMapper();
// Register the Swagger generator, defining 1 or more Swagger documents
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new Info {
Title = "AspNetCoreApiStarter", Version = "v1"
});
// Swagger 2.+ support
c.AddSecurityDefinition("Bearer", new ApiKeyScheme
{
In = "header",
Description = "Please insert JWT with Bearer into field",
Name = "Authorization",
Type = "apiKey"
});
c.AddSecurityRequirement(new Dictionary <string, IEnumerable <string> >
{
{ "Bearer", new string[] { } }
});
});
// Now register our services with Autofac container.
//var builder = new ContainerBuilder();
//builder.RegisterModule(new CoreModule());
//builder.RegisterModule(new InfrastructureModule());
//Register Service
DependencyHelper.RegisterDBConfiguration(Configuration, services);
DependencyHelper.RegisterServices(services);
// Presenters
//builder.RegisterAssemblyTypes(Assembly.GetExecutingAssembly()).Where(t => t.Name.EndsWith("Presenter")).SingleInstance();
//builder.Populate(services);
// var container = builder.Build();
// Create the IServiceProvider based on the container.
//return new AutofacServiceProvider(container);
}
/// <summary>
/// 准备
/// </summary>
/// <param name="service">当前服务</param>
/// <param name="message">当前消息</param>
/// <param name="tag">扩展信息</param>
/// <returns></returns>
async Task <bool> IMessageMiddleware.Prepare(IService service, IInlineMessage message, object tag)
{
if (message.Service != "_health_")
{
return(true);
}
var col = Collection;
Collection = new ApiCollection
{
Start = DateTime.Now,
End = DateTime.Now
};
var checkers = DependencyHelper.GetServices <IHealthCheck>();
var res = new NameValue <Dictionary <string, HealthInfo> >
{
Name = ZeroAppOption.Instance.HostName,
Value = new Dictionary <string, HealthInfo>(StringComparer.OrdinalIgnoreCase)
};
res.Value.Add("ApiCollection", new HealthInfo
{
Value = (col.End - col.Start).TotalSeconds,
Details = col.ToJson()
});
foreach (var checker in checkers)
{
if (res.Value.ContainsKey(checker.Name))
{
continue;
}
DateTime start = DateTime.Now;
try
{
var info = await checker.Check();
info.Value = (DateTime.Now - start).TotalMilliseconds;
if (info.Value < 10)
{
info.Level = 5;
}
else if (info.Value < 100)
{
info.Level = 4;
}
else if (info.Value < 500)
{
info.Level = 3;
}
else if (info.Value < 3000)
{
info.Level = 2;
}
else
{
info.Level = 1;
}
res.Value.Add(checker.Name, info);
}
catch (Exception ex)
{
res.Value.Add(checker.Name, new HealthInfo
{
Level = -1,
ItemName = checker.Name,
Details = ex.Message
});
}
}
message.RealState = MessageState.Success;
message.ResultData = ApiResultHelper.Succees(res);
return(false);
}
/// <summary>
/// Recupera uma entrada do cache.
/// </summary>
/// <param name="key"></param>
/// <param name="item"></param>
/// <param name="flag"></param>
/// <param name="group"></param>
/// <param name="subGroup"></param>
/// <param name="cacheEntry"></param>
/// <returns></returns>
public UserBinaryObject GetCacheEntry(string key, ProviderCacheItem item, ref BitSet flag, string group, string subGroup, out CacheEntry cacheEntry)
{
UserBinaryObject val = null;
cacheEntry = null;
object serializableObject = null;
if ((item != null) && (item.Value != null))
{
if ((item.Group == null) && (item.SubGroup != null))
{
throw new OperationFailedException("Error occurred while synchronization with data source; group must be specified for sub group");
}
if ((group != null) && !CacheHelper.CheckDataGroupsCompatibility(new GroupInfo(item.Group, item.SubGroup), new GroupInfo(group, subGroup)))
{
throw new OperationFailedException("Error occurred while synchronization with data source; groups are incompatible");
}
if (flag == null)
{
flag = new BitSet();
}
serializableObject = item.Value;
Hashtable hashtable = new Hashtable();
TypeInfoMap typeInfoMap = _context.CacheRoot.GetTypeInfoMap();
hashtable["query-info"] = CacheLoaderUtil.GetQueryInfo(item.Value, typeInfoMap);
if (item.Tags != null)
{
Hashtable tagInfo = CacheLoaderUtil.GetTagInfo(item.Value, item.Tags);
if (tagInfo != null)
{
hashtable.Add("tag-info", tagInfo);
}
}
if (item.NamedTags != null)
{
try
{
Hashtable hashtable3 = CacheLoaderUtil.GetNamedTagsInfo(item.Value, item.NamedTags, typeInfoMap);
if (hashtable3 != null)
{
hashtable.Add("named-tag-info", hashtable3);
}
}
catch (Exception exception)
{
throw new OperationFailedException("Error occurred while synchronization with data source; " + exception.Message);
}
}
if (!item.Value.GetType().IsSerializable&& !_type.IsAssignableFrom(item.Value.GetType()))
{
throw new OperationFailedException("Read through provider returned an object that is not serializable.");
}
serializableObject = SerializationUtil.SafeSerialize(serializableObject, _context.SerializationContext, ref flag);
if (_context.CompressionEnabled)
{
item.Value = CompressionUtil.Compress(item.Value as byte[], ref flag, _context.CompressionThreshold);
}
val = UserBinaryObject.CreateUserBinaryObject(serializableObject as byte[]);
EvictionHint evictionHint = new PriorityEvictionHint(item.ItemPriority);
ExpirationHint expiryHint = DependencyHelper.GetExpirationHint(item.Dependency, item.AbsoluteExpiration, item.SlidingExpiration);
if (expiryHint != null)
{
expiryHint.CacheKey = key;
if (item.ResyncItemOnExpiration)
{
expiryHint.SetBit(2);
}
}
cacheEntry = new CacheEntry(val, expiryHint, evictionHint);
cacheEntry.Flag = flag;
cacheEntry.GroupInfo = new GroupInfo(item.Group, item.SubGroup);
cacheEntry.QueryInfo = hashtable;
cacheEntry.ResyncProviderName = (item.ResyncProviderName == null) ? null : item.ResyncProviderName.ToLower();
}
return(val);
}
public UserController(IOptions <AppSettings> options, IUserService userService) : base(options)
{
DependencyHelper.ThrowIfNull(userService);
_userService = userService;
}
/// <summary>
/// Initializes a new instance of the <see cref="Queryable{T}"/> class and configure it using an execution context.
/// </summary>
/// <param name="context">Action to configure the <see cref="ArchiveExecutionContext"/>.</param>
public Queryable(Action <ArchiveExecutionContext> context)
: this(DependencyHelper.CreateTypedQueryExecutor <T>(context))
{
}
/// <summary>
/// Handles the disposal of resources. Derived from abstract class <see cref="DisposableObject"/> which handles common required locking logic.
/// </summary>
protected override void DisposeResources()
{
RevisionRepositoryFactory.Dispose();
SchemaRepositoryFactory.Dispose();
DependencyHelper.Dispose();
}
public UserRepository(IOptions <AppSettings> options, IMapper mapper) : base(options)
{
DependencyHelper.ThrowIfNull(options, mapper);
_mapper = mapper;
}
IMessageReceiver IReceiverGet.Receiver(string service)
{
return(ReceiverName == null ? null : DependencyHelper.GetService <IMessageReceiver>(ReceiverName));
}
public void TestCleanup()
{
DependencyHelper.ClearContainer();
}
private static void InitializeDependencyInjectionContainer()
{
DependencyHelper.Initialize();
}
static int Main(string[] args)
{
try
{
Assembly assem = Assembly.GetEntryAssembly();
AssemblyName assemName = assem.GetName();
Console.WriteLine(CommonFunc.FormatString(Properties.Resources.ProgramVersion, assemName.Name, assemName.Version.ToString()));
string message = "";
if (!DependencyHelper.CheckDependencies(ref message))
{
Console.WriteLine(message);
return(-1);
}
try
{
string txt = CommonFunc.GetTextFromFile(CommonFunc.GetAppSettingsStringValue("ObjectSelector"));
_ObjectSelector = (ObjectSelector)CommonFunc.DeserializeXmlString(txt, typeof(ObjectSelector));
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
_ObjectSelector = GenerateDefaultObjectSelector();
}
finally
{
if (_ObjectSelector == null)
{
_ObjectSelector = GenerateDefaultObjectSelector();
}
}
string argValues = Environment.NewLine + Properties.Resources.ProgramArgs + Environment.NewLine;
_outputDir = new StringBuilder(CommonFunc.GetAppSettingsStringValue("OutputDirectory"));
_SourceServerName = ConfigurationManager.AppSettings["SourceServerName"];
_SourceUserName = ConfigurationManager.AppSettings["SourceUserName"];
_SourcePassword = ConfigurationManager.AppSettings["SourcePassword"];
_SourceDatabase = ConfigurationManager.AppSettings["SourceDatabase"];
_bSourceConnectNTAuth = CommonFunc.GetAppSettingsBoolValue("SourceConnectNTAuth");
_OutputResultsFile = ConfigurationManager.AppSettings["OutputResultsFile"];
_bAddDateTimeFolder = CommonFunc.GetAppSettingsBoolValue("AppendDateTimeFolder");
for (int index = 0; index < args.Length; index++)
{
switch (args[index])
{
case "-a":
case "/a":
_bAddDateTimeFolder = args[++index].Equals(Properties.Resources.True, StringComparison.CurrentCultureIgnoreCase);
break;
case "-S":
case "/S":
_SourceServerName = args[++index];
break;
case "-U":
case "/U":
_SourceUserName = args[++index];
break;
case "-P":
case "/P":
_SourcePassword = args[++index];
break;
case "-D":
case "/D":
_SourceDatabase = args[++index];
break;
case "-o":
case "/o":
_OutputResultsFile = args[++index];
break;
case "-O":
case "/O":
_outputDir.Remove(0, _outputDir.Length);
_outputDir.Append(args[++index]);
break;
case "-T":
case "/T":
_bSourceConnectNTAuth = true;
break;
default:
Console.WriteLine(argValues);
return(-1);
}
}
int retVal = Process();
return(retVal);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return(-1);
}
}
public void InvalidPropertyPath()
{
DependencyHelper.GetPropertyPath(
(RecursiveEntity entity) => entity.Other.Other.Other.GetType());
}
public void Initialize()
{
DependencyHelper dependencyHelper = new DependencyHelper();
morphemeConversionService = dependencyHelper.GetMorphemeConversionService();
}
public override void ConfigureContainer(ContainerBuilder builder)
{
DependencyHelper.RegisterCommonTypes(builder, GetType());
base.ConfigureContainer(builder);
}
public SimpleQueryable(Action <ArchiveExecutionContext> context)
: this(DependencyHelper.CreateArchiveManager <T>(context))
{
}
/// <summary>
/// Registering types with using Autofac
/// </summary>
/// <param name="builder"></param>
public override void ConfigureContainer(ContainerBuilder builder)
{
base.ConfigureContainer(builder);
DependencyManager.ConfigureContainer(builder);
DependencyHelper.RegisterCommonTypes(builder, typeof(Program));
}
public void Configure()
{
DependencyHelper.Configure(new INinjectModule[] { new NHibernateDomainNinjectModule() });
}
IMessageReceiver IReceiverGet.Receiver(string service)
{
return(DependencyHelper.GetService <IMessageConsumer>());
}
public VotingService(IHubContext <VotingHub> context)
{
DependencyHelper.ThrowIfNull(context);
_context = context;
}
public SlideRepository(IOptions <AppSettings> config, IMapper mapper) : base(config)
{
DependencyHelper.ThrowIfNull(mapper);
_mapper = mapper;
}
public void MessageLifeCycle()
{
var id = Guid.NewGuid().ToString("N").ToUpper();
IInlineMessage message = new InlineMessage
{
ID = id,
State = MessageState.Accept,
Service = "Topic",
Method = "Title",
Argument = @"{""Value"": ""Content""}",
Result = @"{""Value"": ""Result""}"
};
message.CheckState();
Assert.IsTrue(message.DataState == (MessageDataState.ArgumentOffline | MessageDataState.ResultOffline), message.DataState.ToString());
//message.PrepareResult(null, ApiResultHelper.State);
message.RestoryContent(DependencyHelper.GetService <IJsonSerializeProxy>(), typeof(Argument));;
Assert.IsTrue(message.ArgumentData is Argument, message.ArgumentData.GetTypeName());
Assert.IsTrue(message.DataState == (MessageDataState.ArgumentOffline | MessageDataState.ResultOffline | MessageDataState.ArgumentInline),
message.DataState.ToString());
message = new InlineMessage
{
ID = id,
State = MessageState.Accept,
Service = "Topic",
Method = "Title",
Argument = @"{""Value"": ""Content""}",
Result = @"{""Value"": ""Result""}"
};
message.ResetToRequest();
Assert.IsTrue(message.DataState == MessageDataState.ArgumentOffline, message.DataState.ToString());
Assert.IsTrue(message.Result == null, message.Result);
//message.PrepareResult(null, ApiResultHelper.State);
message.RestoryContent(DependencyHelper.GetService <IJsonSerializeProxy>(), typeof(Argument));;
Assert.IsTrue(message.DataState == (MessageDataState.ArgumentOffline | MessageDataState.ArgumentInline), message.DataState.ToString());
message.ResultData = new Argument <int>
{
Value = 1
};
Assert.IsTrue(message.DataState == (MessageDataState.ArgumentOffline | MessageDataState.ArgumentInline | MessageDataState.ResultInline),
message.DataState.ToString());
message.OfflineResult();
Assert.IsTrue(message.Result != null, message.Result);
Assert.IsTrue(message.DataState == (MessageDataState.ArgumentOffline | MessageDataState.ArgumentInline | MessageDataState.ResultOffline | MessageDataState.ResultInline),
message.DataState.ToString());
var result = message.ToMessageResult(true);
var json = SmartSerializer.ToString(result);
var result2 = SmartSerializer.ToObject <MessageResult>(json);
Assert.IsTrue(result2.ID == message.ID, result2.ID);
Assert.IsTrue(result2.ResultData == result.ResultData, result2.ResultData.GetTypeName());
Assert.IsTrue(result2.State == result.State, result2.State.ToString());
Assert.IsTrue(result2.DataState == result.DataState, result2.DataState.ToString());
Assert.IsTrue(result2.Result == result.Result, result2.Result);
Assert.IsTrue(result2.Trace.LocalMachine == message.TraceInfo.LocalMachine, result2.Trace.LocalMachine);
}
