/// <summary>
/// dll loader
/// </summary>
/// <param name="serviceEntryContainer"></param>
/// <param name="logger"></param>
/// <param name="path">where are the dll directory</param>
/// <param name="watchingFilePattern">what type of file will be watch when enableWatchChanged is true</param>
/// <param name="enableWatchChanged">whether enable watch file changed</param>
public ServicesLoader(IServiceEntryContainer serviceEntryContainer, ILogger logger, ServiceOptions options)
{
_logger = logger;
_serviceEntryContainer = serviceEntryContainer;
_options = options;
//if (string.IsNullOrEmpty(_options.Path))
//{
// _options.Path = "./";
//}
}
public override IDictionary <PaymentType, string> GetPaymentTypeMappings()
{
var paymentTypeMappings = new Dictionary <PaymentType, string> {
{ PaymentType.Cash, "0" },
{ PaymentType.Card, "1" },
{ PaymentType.Check, "2" }
};
ServiceOptions.RemapPaymentTypes(Info.SerialNumber, paymentTypeMappings);
return(paymentTypeMappings);
}
protected BgFiscalPrinter(
IChannel channel,
ServiceOptions serviceOptions,
IDictionary <string, string>?options = null)
{
ServiceOptions = serviceOptions;
Options = new Dictionary <string, string>()
.MergeWith(GetDefaultOptions())
.MergeWith(options);
Channel = channel;
}
/// <summary>
/// Creates new instance of the <see cref="ESRI.ArcLogistics.Routing.IVrpRequestAnalyzer"/>
/// object corresponding to the specified service options.
/// </summary>
/// <param name="options">The options specifying the analyzer to be used.</param>
/// <param name="solverConfig">Solver config, containing info about max orders and routes
/// count for synq request.</param>
/// <returns>The reference to the new instance of the VRP requests analyzer.</returns>
private static IVrpRequestAnalyzer _CreateRequestAnalyzer(ServiceOptions options,
SolveInfoWrap solverConfig)
{
// Check that sync vrp is allowed.
if ((options & ServiceOptions.UseSyncVrp) != 0)
{
return(new SimpleVrpRequestAnalyzer(solverConfig.MaxSyncVrpRequestRoutesCount,
solverConfig.MaxSyncVrpRequestOrdersCount));
}
return(new ConstantVrpRequestAnalyzer(false));
}
public CommodityLoader(ILogger <CommodityLoader> logger, EntityParser entityParser,
IJsonFileReaderWriter jsonFileReaderWriter,
LoaderService <CommodityTypeAndSubType> commodityTypeService,
IOptions <ServiceOptions> options, LocalisationService localisationService)
{
_logger = logger;
_entityParser = entityParser;
_jsonFileReaderWriter = jsonFileReaderWriter;
_localisationService = localisationService;
CommodityTypes = commodityTypeService.Items;
_options = options.Value;
}
public void ShouldSerializeAndDeserialize()
{
var options = new ServiceOptions
{
StorageConnectionString = "Filename=storage.litedb;InitialSize=123"
};
var s = JsonConvert.SerializeObject(options);
var deserialized = JsonConvert.DeserializeObject <ServiceOptions>(s);
deserialized.Should().NotBeSameAs(options);
deserialized.StorageConnectionString.Should().Be("Filename=storage.litedb;InitialSize=123");
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
//services.AddScoped<IHostedService, MqttClient>();
//services.AddHostedService<MqttClient>();
services.AddSingleton(Log.Logger);
services.AddHostedService <ClientConnectorHostedService>();
services.AddSingleton <MqttClientFactory>();
services.AddControllers();
services.AddHealthChecks()
.AddCheck <ClientHealthCheck>("mqtt_connection_health_check");
ServiceOptions.Setup(Configuration);
}
/// <summary>
/// Gets options for the AMI service.
/// </summary>
/// <returns>Returns options for the AMI service.</returns>
public override ServiceOptions Options()
{
this.ThrowIfNotReady();
RestOperationContext.Current.OutgoingResponse.StatusCode = (int)HttpStatusCode.OK;
RestOperationContext.Current.OutgoingResponse.Headers.Add("Allow", $"GET, PUT, POST, OPTIONS, HEAD, DELETE{(ApplicationServiceContext.Current.GetService<IPatchService>() != null ? ", PATCH" : null)}");
if (ApplicationServiceContext.Current.GetService <IPatchService>() != null)
{
RestOperationContext.Current.OutgoingResponse.Headers.Add("Accept-Patch", "application/xml+sdb-patch");
}
// mex configuration
var mexConfig = ApplicationServiceContext.Current.GetService <IConfigurationManager>().GetSection <SanteDB.Rest.Common.Configuration.RestConfigurationSection>();
String boundHostPort = $"{RestOperationContext.Current.IncomingRequest.Url.Scheme}://{RestOperationContext.Current.IncomingRequest.Url.Host}:{RestOperationContext.Current.IncomingRequest.Url.Port}";
if (!String.IsNullOrEmpty(mexConfig.ExternalHostPort))
{
var tUrl = new Uri(mexConfig.ExternalHostPort);
boundHostPort = $"{tUrl.Scheme}://{tUrl.Host}:{tUrl.Port}";
}
var serviceOptions = new ServiceOptions
{
InterfaceVersion = "1.0.0.0",
Endpoints = ApplicationServiceContext.Current.GetService <IServiceManager>().GetServices().OfType <IApiEndpointProvider>().Select(o =>
new ServiceEndpointOptions(o)
{
BaseUrl = o.Url.Select(url =>
{
var turi = new Uri(url);
return($"{boundHostPort}{turi.AbsolutePath}");
}).ToArray()
}
).ToList()
};
// Get endpoints
var config = ApplicationServiceContext.Current.GetService <IConfigurationManager>().GetSection <AmiConfigurationSection>();
if (config?.Endpoints != null)
{
serviceOptions.Endpoints.AddRange(config.Endpoints);
}
// Get the resources which are supported
foreach (var itm in this.GetResourceHandler().Handlers)
{
var svc = this.ResourceOptions(itm.ResourceName);
serviceOptions.Resources.Add(svc);
}
return(serviceOptions);
}
public ShipLoader(ILogger <ShipLoader> logger, EntityParser entityParser, IOptions <ServiceOptions> options,
IJsonFileReaderWriter jsonFileReaderWriter, VehicleParser vehicleParser,
LocalisationService localisationService, LoaderService <Manufacturer> manufacturersService)
{
_logger = logger;
_entityParser = entityParser;
_jsonFileReaderWriter = jsonFileReaderWriter;
_vehicleParser = vehicleParser;
_localisationService = localisationService;
Manufacturers = manufacturersService.Items;
_options = options.Value;
}
public TwitterApi(SecretsStoreManager secretsStoreManager, string id, object ServiceOptions) : base(secretsStoreManager, id)
{
Options = (ServiceOptions)ServiceOptions;
client.Authenticator = OAuth1Authenticator.ForProtectedResource(
secretsStoreManager.TryGetSecret(Options.ConsumerKey),
secretsStoreManager.TryGetSecret(Options.ConsumerSecret),
secretsStoreManager.TryGetSecret(Options.Token),
secretsStoreManager.TryGetSecret(Options.TokenSecret)
);
client.AddHandler("application/json", new DynamicJsonDeserializer());
}
/// <summary>
/// Creates new instance of the REST context provider for the synchronous
/// VRP service.
/// </summary>
/// <param name="options">Options for VRP service to create context for.</param>
/// <returns></returns>
private IRestServiceContextProvider _CreateSyncContextProvider(ServiceOptions options)
{
if ((options & ServiceOptions.UseSyncVrp) == 0)
{
return(new NullRestServiceContextProvider());
}
return(new RestServiceContextProvider(
_syncVrpServiceConfig.RestUrl,
_syncVrpServiceConfig.ToolName,
_syncVrpServer));
}
public JsonFileReaderWriter(ILogger <JsonFileReaderWriter> logger, IOptions <ServiceOptions> options)
{
JsonConvert.DefaultSettings = () => new JsonSerializerSettings
{
Formatting = Formatting.Indented,
NullValueHandling = NullValueHandling.Ignore,
ReferenceLoopHandling = ReferenceLoopHandling.Ignore
};
_logger = logger;
_options = options.Value;
}
public virtual void AttachOptions(ServiceOptions serviceOptions)
{
if (EditorUtility.DisplayDialog
(
serviceOptions.ServiceType.ToString().Replace("_", " "),
"Provider: " + serviceOptions.ServiceName + "\n\nDo you want to attach " + serviceOptions.ServiceType.ToString().Replace("_", " ") + " to:\n" + Selection.activeTransform.gameObject.name,
"Attach",
"Cancel"
))
{
string typeAbbrev = string.Empty;
switch (serviceOptions.ServiceType)
{
case ServiceType.Cognigy_AI:
typeAbbrev = "AI";
break;
case ServiceType.Speech_To_Text:
typeAbbrev = "STT";
break;
case ServiceType.Text_To_Speech:
typeAbbrev = "TTS";
break;
}
string path = "Assets";
string assetPathAndName = AssetDatabase.GenerateUniqueAssetPath(path + "/" + typeAbbrev + "_" + serviceOptions.ServiceName + ".asset");
AssetDatabase.CreateAsset(serviceOptions, assetPathAndName);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
TServiceComponent serviceComponent;
if ((serviceComponent = (TServiceComponent)Selection.activeTransform.gameObject.GetComponent(typeof(TServiceComponent))) == null)
{
serviceComponent = (TServiceComponent)Selection.activeTransform.gameObject.AddComponent(typeof(TServiceComponent));
}
serviceComponent.serviceOptions = serviceOptions;
SetFocus(serviceComponent);
this.Close();
}
}
public MapBoxConversionService(ILogger <MapBoxConversionService> logger,
IOptions <ServiceOptions> serviceOptions,
IMbConversionQueue mbConversionQueue,
IStatusTable statusTable,
ITileStorage tileStorage,
IMapLayerUpdateTopicClient topicClient)
{
_logger = logger;
_serviceOptions = serviceOptions.Value;
_mbConversionQueue = mbConversionQueue;
_statusTable = statusTable;
_tileStorage = tileStorage;
_topicClient = topicClient;
}
public ItemLoader(ILogger <ItemLoader> logger, EntityParser entityParser,
IJsonFileReaderWriter jsonFileReaderWriter, LoaderService <Manufacturer> manufacturersService,
IOptions <ServiceOptions> options, LocalisationService localisationService,
LoaderService <Ship> shipService, LoaderService <Commodity> commodtiyService)
{
_logger = logger;
_entityParser = entityParser;
_jsonFileReaderWriter = jsonFileReaderWriter;
_localisationService = localisationService;
Manufacturers = manufacturersService.Items;
Ships = shipService.Items;
Commodities = commodtiyService.Items;
_options = options.Value;
}
public void SentinelConnectTest()
{
var options = ServiceOptions.Clone();
options.EndPoints.Add(TestConfig.Current.SentinelServer, TestConfig.Current.SentinelPortA);
var conn = ConnectionMultiplexer.SentinelConnect(options);
var db = conn.GetDatabase();
var test = db.Ping();
Log("ping to sentinel {0}:{1} took {2} ms", TestConfig.Current.SentinelServer,
TestConfig.Current.SentinelPortA, test.TotalMilliseconds);
}
public TwitterWeb(SecretsStoreManager secretsStoreManager, string id, object ServiceOptions) : base(secretsStoreManager, id)
{
Options = (ServiceOptions)ServiceOptions;
var driverOptions = new ChromeOptions();
#if !DEBUG
driverOptions.AddArgument("headless");
#endif
driverOptions.AddArgument("disable-gpu");
driver = new ChromeDriver(Directory.GetCurrentDirectory(), driverOptions);
driver.Manage().Timeouts().ImplicitWait = new TimeSpan(0, 0, 30);
}
public static SSSBService Create(IServiceProvider serviceProvider, Action <ServiceOptions> configure)
{
ServiceOptions serviceOptions = new ServiceOptions()
{
IsQueueActivationEnabled = false, MaxReadersCount = 1, Name = null
};
configure?.Invoke(serviceOptions);
if (string.IsNullOrEmpty(serviceOptions.Name))
{
throw new ArgumentException($"SSSBService must have a Name");
}
return(ActivatorUtilities.CreateInstance <SSSBService>(serviceProvider, new object[] { serviceOptions }));
}
/// <summary>
/// Setup Dependency constructor Injections for interfaces
/// </summary>
/// <param name="service"></param>
/// <param name="configuration"></param>
public static void Config(IServiceCollection service, IConfiguration configuration)
{
var config = new ServiceOptions();
configuration.GetSection("Services").Bind(config);
service.AddDbContext <CustomerDbContext>(option => option.UseSqlServer(config.DefaultConnection));
service.AddTransient <ICustomerRuleManager, CustomerRuleManager>();
service.AddTransient <IAddressRuleProcessor, AddressRuleProcessor>();
service.AddTransient <IContactsRuleProcessor, ContactsRuleProcessor>();
service.AddTransient <ICustomerRulesProcessor, CustomerRulesProcessor>();
service.AddTransient <IContactRuleManager, ContactRuleManager>();
service.AddTransient <IAddressRuleManager, AddressRuleManager>();
service.AddSingleton <IUnitOfWork, UnitOfWork>();
service.AddSingleton <IRepositoryFactory, RepositoryFactory>();
}
public GdalConversionService(ILogger <GdalConversionService> logger,
IOptions <ServiceOptions> serviceOptions,
IGdConversionQueue gdConversionQueue,
IMbConversionQueue mbConversionQueue,
IStatusTable statusTable,
IGeoJsonStorage geoJsonStorage)
{
_logger = logger;
_serviceOptions = serviceOptions.Value;
_gdConversionQueue = gdConversionQueue;
_mbConversionQueue = mbConversionQueue;
_statusTable = statusTable;
_geoJsonStorage = geoJsonStorage;
}
public static IHostBuilder CreateHostBuilder(string[] args, IConfiguration configuration)
{
var serviceOptions = new ServiceOptions();
var serviceOptionsSection = configuration.GetSection("Services");
serviceOptionsSection.Bind(serviceOptions);
return(Host
.CreateDefaultBuilder(args)
.ConfigureServices((context, services) =>
{
services.AddOptions <ServiceOptions>().Bind(serviceOptionsSection);
})
.CustomConfigWebHostFor(serviceOptions.GraphQLApi, typeof(Startup), configuration, serviceOptions));
}
public BloombergPricingAPIService()
{
// Generate unique resource indentifiers.
var resourceIdPostfix = DateTime.UtcNow.ToString("yyyyMMddhhmmss");
var sfx = Options.CustomerName.Substring(0, 3).ToUpper();
UniverseId = $"{sfx}Universe{resourceIdPostfix}";
FieldListId = $"{sfx}FieldList{resourceIdPostfix}";
TriggerId = $"{sfx}Trigger{resourceIdPostfix}";
RequestId = $"{sfx}Req{resourceIdPostfix}";
Options = new ServiceOptions();
ServiceResponse = new ServiceResponse()
{
RequestId = resourceIdPostfix,
RequestDateTime = DateTime.Now
};
}
public static IHostBuilder CreateHostBuilder(string[] args)
{
var configuration = ConfigurationExtensions.BuildConfiguration(Directory.GetCurrentDirectory());
var serviceOptions = new ServiceOptions();
var serviceOptionsSection = configuration.GetSection("Services");
serviceOptionsSection.Bind(serviceOptions);
return(Host
.CreateDefaultBuilder(args)
.ConfigureServices((context, services) =>
{
services.AddOptions <ServiceOptions>().Bind(serviceOptionsSection);
})
.CustomConfigWebHostFor(serviceOptions.InventoriesApi, typeof(Startup), configuration, serviceOptions));
}
private void _InitSettings(
SolveInfoWrap settings,
ICollection <AgsServer> servers,
ServiceOptions options)
{
Debug.Assert(settings != null);
Debug.Assert(servers != null);
// VRP data
_InitVrpSettings(settings, servers, options);
// route data
_InitRouteSettings(settings, servers);
// solver settings
_solverConfig = settings;
}
Dictionary <string, string> DumpOptions(FileDescriptorProto source, ServiceOptions options)
{
var optionsKv = new Dictionary <string, string>();
if (options == null)
{
return(optionsKv);
}
if (options.deprecatedSpecified)
{
optionsKv.Add("deprecated", options.deprecated ? "true" : "false");
}
DumpOptionsMatching(source, ".google.protobuf.ServiceOptions", options, optionsKv);
return(optionsKv);
}
private TransportService CreateService()
{
var options = new ServiceOptions
{
ServiceIntervalMs = 100000,
Transports = new List <TransportOptions>
{
new TransportOptions
{
IsEnabled = true,
SendErrorReport = false,
SystemName = TelegramSystemName
}
}
};
return(new TransportService(_loggerFactory.CreateLogger <TransportService>(), _serviceProviderMock.Object, Options.Create(options)));
}
public PollingService(IOptions <ServiceOptions> option, ILoggerFactory loggerFactory) : base(loggerFactory)
{
try
{
this.options = option.Value;
var serviceSchedule = this.options.ServiceSchedules?.FirstOrDefault(sc => string.Compare(sc.Name, this.GetType().Name) == 0);
schedule = serviceSchedule.Schedule;
pollingControl = new Dictionary <string, pollWrapper>();
//BeforeTaskStartsAsync = async (m) => { await BeforeStart(m); };
//AfterTaskCompletesAsync = async (m) => { await AfterFinish(m); };
CreatePipeline(this);
}
catch (Exception)
{
Debugger.Break();
throw;
}
}
private void ConfigureRabbitMq(IBusRegistrationContext context, IRabbitMqBusFactoryConfigurator rabbitMqCfg)
{
_rabbitMqOptions = Configuration.GetSection(ServiceDependenciesOptions.SERVICE_DEPENDENCIES)
.Get <ServiceOptions[]>()
.First(svc => svc.Name.Equals("RabbitMQ"));
X509Certificate2 x509Certificate2 = null;
var store = new X509Store(StoreName.My, StoreLocation.LocalMachine);
store.Open(OpenFlags.ReadOnly);
try
{
var certificatesInStore = store.Certificates;
x509Certificate2 = certificatesInStore.OfType <X509Certificate2>()
.FirstOrDefault(cert => cert.Thumbprint?.ToLower() == _rabbitMqOptions.SslThumbprint?.ToLower());
}
finally
{
store.Close();
}
rabbitMqCfg.Host(_rabbitMqOptions.Host, _rabbitMqOptions.VirtualHost, h =>
{
h.Username(_rabbitMqOptions.Username);
h.Password(_rabbitMqOptions.Password);
if (_rabbitMqOptions.UseSsl)
{
h.UseSsl(ssl =>
{
ssl.ServerName = Dns.GetHostName();
ssl.AllowPolicyErrors(SslPolicyErrors.RemoteCertificateNameMismatch);
ssl.Certificate = x509Certificate2;
ssl.Protocol = SslProtocols.Tls12;
ssl.CertificateSelectionCallback = CertificateSelectionCallback;
});
}
});
rabbitMqCfg.ConfigureEndpoints(context);
}
public override IDictionary <PaymentType, string> GetPaymentTypeMappings()
{
var paymentTypeMappings = new Dictionary <PaymentType, string> {
{ PaymentType.Cash, "P" },
{ PaymentType.Check, "N" },
{ PaymentType.Coupons, "C" },
{ PaymentType.ExtCoupons, "D" },
{ PaymentType.Packaging, "I" },
{ PaymentType.InternalUsage, "J" },
{ PaymentType.Damage, "K" },
{ PaymentType.Card, "L" },
{ PaymentType.Bank, "M" },
{ PaymentType.Reserved1, "Q" },
{ PaymentType.Reserved2, "R" }
};
ServiceOptions.RemapPaymentTypes(Info.SerialNumber, paymentTypeMappings);
return(paymentTypeMappings);
}
public override IDictionary <PaymentType, string> GetPaymentTypeMappings()
{
var paymentTypeMappings = new Dictionary <PaymentType, string> {
{ PaymentType.Cash, "0" },
{ PaymentType.Check, "1" },
{ PaymentType.Coupons, "2" },
{ PaymentType.ExtCoupons, "3" },
{ PaymentType.Packaging, "4" },
{ PaymentType.InternalUsage, "5" },
{ PaymentType.Damage, "6" },
{ PaymentType.Card, "7" },
{ PaymentType.Bank, "8" },
{ PaymentType.Reserved1, "9" },
{ PaymentType.Reserved2, "A" }
};
ServiceOptions.RemapPaymentTypes(Info.SerialNumber, paymentTypeMappings);
return(paymentTypeMappings);
}
/// <summary>Helper: Serialize into a MemoryStream and return its byte array</summary>
public static byte[] SerializeToBytes(ServiceOptions instance)
{
using (var ms = new MemoryStream())
{
Serialize(ms, instance);
return ms.ToArray();
}
}
/// <summary>Helper: Serialize with a varint length prefix</summary>
public static void SerializeLengthDelimited(Stream stream, ServiceOptions instance)
{
var data = SerializeToBytes(instance);
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteUInt32(stream, (uint)data.Length);
stream.Write(data, 0, data.Length);
}
/// <summary>Serialize the instance into the stream</summary>
public static void Serialize(Stream stream, ServiceOptions instance)
{
if (instance.UninterpretedOption != null)
{
foreach (var i999 in instance.UninterpretedOption)
{
// Key for field: 999, LengthDelimited
stream.Write(new byte[]{186, 62}, 0, 2);
using (var ms999 = new MemoryStream())
{
Google.protobuf.UninterpretedOption.Serialize(ms999, i999);
// Length delimited byte array
uint ms999Length = (uint)ms999.Length;
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteUInt32(stream, ms999Length);
stream.Write(ms999.GetBuffer(), 0, (int)ms999Length);
}
}
}
}
/// <summary>Helper: create a new instance to deserializing into</summary>
public static ServiceOptions DeserializeLengthDelimited(Stream stream)
{
ServiceOptions instance = new ServiceOptions();
DeserializeLengthDelimited(stream, instance);
return instance;
}
/// <summary>Helper: create a new instance to deserializing into</summary>
public static ServiceOptions DeserializeLength(Stream stream, int length)
{
ServiceOptions instance = new ServiceOptions();
DeserializeLength(stream, length, instance);
return instance;
}
/// <summary>Helper: put the buffer into a MemoryStream and create a new instance to deserializing into</summary>
public static ServiceOptions Deserialize(byte[] buffer)
{
ServiceOptions instance = new ServiceOptions();
using (var ms = new MemoryStream(buffer))
Deserialize(ms, instance);
return instance;
}
/// <summary>Helper: create a new instance to deserializing into</summary>
public static ServiceOptions Deserialize(Stream stream)
{
ServiceOptions instance = new ServiceOptions();
Deserialize(stream, instance);
return instance;
}
public ServiceThreadMethod(ServiceControl ss, string serviceName, ServiceOptions so)
{
_ss = ss;
_serviceName = serviceName;
_so = so;
}
/// <summary>
/// �첽���Ʒ���
/// </summary>
/// <param name="serviceName">������</param>
/// <param name="so">����ѡ��</param>
public void AsyncService(string serviceName, ServiceOptions so)
{
ServiceThreadMethod stm = new ServiceThreadMethod(this, serviceName, so);
Thread _th = new Thread(new ThreadStart(stm.RunThread));
_th.Start();
}
public ProductService(HttpContextBase http, ServiceOptions options)
{
Http = http;
}
/// <summary>Serialize the instance into the stream</summary>
public static void Serialize(Stream stream, ServiceOptions instance)
{
var msField = global::SilentOrbit.ProtocolBuffers.ProtocolParser.Stack.Pop();
if (instance.UninterpretedOption != null)
{
foreach (var i999 in instance.UninterpretedOption)
{
// Key for field: 999, LengthDelimited
stream.WriteByte(186);
stream.WriteByte(62);
msField.SetLength(0);
Google.Protobuf.UninterpretedOption.Serialize(msField, i999);
// Length delimited byte array
uint length999 = (uint)msField.Length;
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteUInt32(stream, length999);
msField.WriteTo(stream);
}
}
global::SilentOrbit.ProtocolBuffers.ProtocolParser.Stack.Push(msField);
}