/// <summary>
/// Initializes a new instance of the <see cref="BasicNode"/> class.
/// </summary>
/// <param name="context">The node context.</param>
public InputSelector(INodeContext context)
: base(context, INPUT_PREFIX)
{
context.ThrowIfNull("context");
mTypeService = context.GetService <ITypeService>();
// Initialize the input count, allowing range 2..99.
mInputCount = mTypeService.CreateInt(PortTypes.Integer, "InputCount", 2);
mInputCount.MinValue = 2;
mInputCount.MaxValue = 50;
// Initialize inputs using a helper function that grows/shrinks the list of inputs
// whenever the input count is changed
mInputs = new List <AnyValueObject>();
ListHelpers.ConnectListToCounter(mInputs, mInputCount,
mTypeService.GetValueObjectCreator(PortTypes.Any, INPUT_PREFIX),
updateOutputValues);
// Initialize the input for the index of the input to select.
mSelectIndexInput = mTypeService.CreateInt(PortTypes.Integer, "InputSelectIndex");
mSelectIndexInput.MinValue = 0;
mSelectIndexInput.MaxValue = mInputCount.MaxValue - 1;
mSelectIndexInput.ValueSet += updateOutputValues;
// Initialize the selector for "send-on-select".
mSelectAction = mTypeService.CreateEnum("ESelectAction2",
"SelectAction2", mSelectActionValues, "ResendCurrent");
// Initialize the output
mOutput = mTypeService.CreateAny(PortTypes.Any, "Output");
}
/// <summary>
/// Initializes a new instance of the <see cref="UnifiPresenceDetectionNode"/> class.
/// </summary>
/// <param name="context">The node context.</param>
public UnifiPresenceDetectionNode(INodeContext context)
: base(context)
{
context.ThrowIfNull("context");
// Get the TypeService from the context
this.TypeService = context.GetService <ITypeService>();
this.Trigger = this.TypeService.CreateBool(PortTypes.Bool, "Trigger", false);
this.BaseUrl = this.TypeService.CreateString(PortTypes.String, "BaseURL", "https://127.0.0.1:8443");
this.SiteId = this.TypeService.CreateString(PortTypes.String, "UniFi Site", "default");
this.Username = this.TypeService.CreateString(PortTypes.String, "Username", "");
this.Password = this.TypeService.CreateString(PortTypes.String, "Password", "");
this.DeviceAmount = this.TypeService.CreateInt(PortTypes.Integer, "Anzahl Geräte", 1);
this.DeviceAmount.MinValue = 1;
this.DeviceAmount.MaxValue = 15;
this.Devices = new List <IValueObject>();
this.DeviceAmount.ValueSet += this.GenerateDevicePorts;
this.ConnectedAmount = this.TypeService.CreateInt(PortTypes.Integer, "Anzahl angemeldete Clients", 0);
this.IsOneConnected = this.TypeService.CreateBool(PortTypes.Bool, "Mindestens ein Device angemeldet", false);
this.IsAllConnected = this.TypeService.CreateBool(PortTypes.Bool, "Alle Devices angemeldet", false);
this.ConnectedPersons = this.TypeService.CreateString(PortTypes.String, "Angemeldete Personen", "");
this.Error = this.TypeService.CreateString(PortTypes.String, "Fehlermeldung", "");
this.DeviceAmount.Value = 1;
this.DefinedDevicesAndPersons = new Dictionary <string, string>();
}
public TypeArgumentController(IConfiguration config, ITypeService ts, ITypeArgumentService tas, ITypeDataDefineService tds)
{
this._config = config;
this._ts = ts;
this._tas = tas;
this._tds = tds;
}
internal async Task InitializeAsync()
{
IndexCommand.ResetQueryCache();
Indexes = new List <IIndexProvider>();
ScopedIndexes = new List <Type>();
ValidateConfiguration();
_sessionPool = new ObjectPool <Session>(MakeSession, Configuration.SessionPoolSize);
Dialect = SqlDialectFactory.For(Configuration.ConnectionFactory.DbConnectionType);
TypeNames = new TypeService();
using (var connection = Configuration.ConnectionFactory.CreateConnection())
{
await connection.OpenAsync();
using (var transaction = connection.BeginTransaction(Configuration.IsolationLevel))
{
var builder = new SchemaBuilder(Configuration, transaction);
await Configuration.IdGenerator.InitializeAsync(this, builder);
transaction.Commit();
}
}
// Pre-initialize the default collection
await InitializeCollectionAsync("");
}
public ItemsController(IItemService service, ISystemService systemService, ITypeService typeService, IUserItemService userItemService)
{
this.service = service;
this.systemService = systemService;
this.typeService = typeService;
this.userItemService = userItemService;
}
public LogMessageService(ILogConfigurationService logConfigurationService, ITypeService typeService, ILogMessageRepository repository)
{
this.logConfigurationService = logConfigurationService;
this.typeService = typeService;
this.repository = repository;
base.repository = repository;
}
public ModbusClientNode(INodeContext context)
{
context.ThrowIfNull("context");
ITypeService typeService = context.GetService <ITypeService>();
this.TimeSpan = typeService.CreateInt(PortTypes.Integer, "Abfrageinterval", 60);
this.ModbusHost = typeService.CreateString(PortTypes.String, "Modbus TCP Host");
this.ModbusPort = typeService.CreateInt(PortTypes.Integer, "Port", 502);
this.ModbusID = typeService.CreateInt(PortTypes.Integer, "Geräte ID", 1);
this.ModbusID.MinValue = 1;
this.ModbusID.MaxValue = 256;
// --------------------------------------------------------------------------------------- //
this.ModbusAddress1 = typeService.CreateInt(PortTypes.Integer, "Register Addresse", 1);
this.ModbusAddress1.MinValue = 1;
this.ModbusAddress1.MaxValue = 65535;
this.FunctionCode = typeService.CreateEnum("ModbusFunction", "Funktion", FunctionCodeEnum.VALUES, FunctionCodeEnum.FC_03);
this.DataType = typeService.CreateEnum("ModbusDataType", "Datentyp", DataTypeEnum.VALUES, DataTypeEnum.INT32);
this.RegisterOrder = typeService.CreateEnum("ModbusRegisterOrder", "Register Reihenfolge", ByteOrderEnum.VALUES, ByteOrderEnum.LOW_HIGH);
this.OutputValue1 = typeService.CreateDouble(PortTypes.Number, "Register Wert");
this.ErrorMessage = typeService.CreateString(PortTypes.String, "RAW / Error");
SchedulerService = context.GetService <ISchedulerService>();
}
public TypeHardWareConfigController(IConfiguration config, ITypeService ts, ITypeDataDefineService tds, ITypeHardwareConfigService ths)
{
this._config = config;
this._ts = ts;
this._tds = tds;
this._ths = ths;
}
public LimitTimeBuyController(
ILimitTimeBuyService iLimitTimeBuyService,
ISlideAdsService iSlideAdsService,
IShopService iShopService,
IProductService iProductService,
IProductDescriptionTemplateService iProductDescriptionTemplateService,
IShopCategoryService iShopCategoryService,
ICommentService iCommentService,
IConsultationService iConsultationService,
ICouponService iCouponService,
ICashDepositsService iCashDepositsService, ITypeService iTypeService
)
{
_iLimitTimeBuyService = iLimitTimeBuyService;
_iSlideAdsService = iSlideAdsService;
_iShopService = iShopService;
_iProductService = iProductService;
_iProductDescriptionTemplateService = iProductDescriptionTemplateService;
_iShopCategoryService = iShopCategoryService;
_iCommentService = iCommentService;
_iConsultationService = iConsultationService;
_iCouponService = iCouponService;
_iCashDepositsService = iCashDepositsService;
_iTypeService = iTypeService;
}
private async void GetAttributeList()
{
ITypeService type_service = service_factory.CreateClient <ITypeService>();
using (type_service)
{
try
{
Task <List <AttributeType> > task = type_service.GetAttributeTypeListAsync();
await task;
List <AttributeType> atttype_list = task.Result;
ObservableCollection <AttributeType> atttypes = new ObservableCollection <AttributeType>(atttype_list);
var acct_atts = atttype_list.Where(item => item.AttributeTypeCategory == "Company").ToList();
var gcnt_atts = atttype_list.Where(item => item.AttributeTypeCategory == "Company Contact").ToList();
var all_atts = acct_atts.Concat(gcnt_atts);
List <AttributeType> available_attribute_types = new List <AttributeType>(all_atts);
LoadEntityAttrbuteList(available_attribute_types);
}
catch (Exception ex)
{
DisplayErrorMessage(ex);
return;
}
}
}
public override void Process(ITypeService service, MethodDef m, MethodSpec o)
{
foreach (var t in o.GenericInstMethodSig.GenericArguments)
{
service.AddAssociatedType(m, t);
}
}
internal async Task InitializeAsync()
{
IndexCommand.ResetQueryCache();
Indexes = new List <IIndexProvider>();
ScopedIndexes = new List <Type>();
ValidateConfiguration();
_sessionPool = new ObjectPool <Session>(MakeSession, Configuration.SessionPoolSize);
Dialect = SqlDialectFactory.For(Configuration.ConnectionFactory.DbConnectionType);
TypeNames = new TypeService();
using (var connection = Configuration.ConnectionFactory.CreateConnection())
{
await connection.OpenAsync();
using (var transaction = connection.BeginTransaction())
{
var builder = new SchemaBuilder(Configuration, transaction);
await Configuration.IdGenerator.InitializeAsync(this, builder);
transaction.Commit();
}
//)FIXME : in Oracle it's forbidden to index an already indexed column and PK/UK is already indexed
//.AlterTable(LinearBlockIdGenerator.TableName, table => table
// .CreateIndex("IX_Dimension", "dimension")
}
// Pee-initialize the default collection
await InitializeCollectionAsync(Dialect.NullString);
}
public Generator(GeneratorOptions options, ILogger logger = null)
{
Requires.NotNull(options, nameof(options));
_generationContext = new GenerationContext();
FileContentGenerated += OnFileContentGenerated;
Options = options;
Logger = logger;
var generatorOptionsProvider = new GeneratorOptionsProvider {
GeneratorOptions = options
};
var internalStorage = new InternalStorage();
_fileSystem = new FileSystem();
_metadataReaderFactory = new MetadataReaderFactory();
_typeService = new TypeService(_metadataReaderFactory, generatorOptionsProvider);
_typeDependencyService = new TypeDependencyService(_typeService, _metadataReaderFactory);
_templateService = new TemplateService(internalStorage, generatorOptionsProvider);
_tsContentGenerator = new TsContentGenerator(_typeDependencyService,
_typeService,
_templateService,
new TsContentParser(_fileSystem),
_metadataReaderFactory,
generatorOptionsProvider,
logger);
}
public SystemBlockHandler(ITypeService typeService)
{
this.typeService = typeService;
components = new Dictionary <ComponentType, IContainer>();
Clear();
}
public OrderComplaintController(IOrderService iOrderService, IShopService iShopService, IComplaintService iComplaintService, ITypeService iTypeService)
{
_iOrderService = iOrderService;
_iShopService = iShopService;
_iComplaintService = iComplaintService;
_iTypeService = iTypeService;
}
public UserOrderController(
IShopBonusService iShopBonusService,
ICashDepositsService iCashDepositsService,
ISiteSettingService iSiteSettingService,
IOrderService iOrderService,
IRefundService iRefundService,
ICustomerService iCustomerService,
IProductService iProductService,
ICouponService iCouponService,
ICommentService iCommentService,
IFightGroupService iFightGroupService, ITypeService iTypeService
)
{
_iShopBonusService = iShopBonusService;
_iCashDepositsService = iCashDepositsService;
_iSiteSettingService = iSiteSettingService;
_iOrderService = iOrderService;
_iRefundService = iRefundService;
_iCustomerService = iCustomerService;
_iProductService = iProductService;
_iCouponService = iCouponService;
_iCommentService = iCommentService;
_iFightGroupService = iFightGroupService;
_iTypeService = iTypeService;
}
public MainPage()
{
InitializeComponent();
_userService = InstanceFactory.GetInstance <IUserService>();
_categoryService = InstanceFactory.GetInstance <ICategoryService>();
_typeService = InstanceFactory.GetInstance <ITypeService>();
}
public CheckpointController(ICheckpointService checkpointService, ITypeService typeService,
IAdmissionService admissionService)
{
this.checkpointService = checkpointService;
this.typeService = typeService;
this.admissionService = admissionService;
}
public TypeModuleFeedbackController(ITypeDataDefineService td, ITypeService ts, ITypeModuleControlService tmcs, ITypeModuleFeedbackService tfs)
{
this._td = td;
this._ts = ts;
this._tmcs = tmcs;
this._tfs = tfs;
}
public override void ProcessOperand(ITypeService service, MethodDef method, IList <Instruction> body, ref int index, MethodDef operand)
{
var currentMethod = service.GetScannedItem(method);
var targetMethod = service.GetScannedItem(operand);
/* //Type field scrabmble
* var targetType = service.GetScannedItem(operand.DeclaringType);
* if (targetType != null) {
* var typeSigList = targetType.GenericCallTypes.Select(x => currentMethod?.ToGenericIfAvalible(x) ?? x).ToArray();
* new TypeSpecUser(new GenericInstSig(new ClassSig(operand.DeclaringType), typeSigList));
* }
*/
if (body[index].OpCode == OpCodes.Newobj)
{
FactoryHealper.ApplyObjectCreationProxy(service, currentMethod, body, ref index, operand);
}
else
{
FactoryHealper.ApplyCallProxy(service, currentMethod, body, ref index, operand);
}
if (targetMethod != null)
{
var typeSigList = targetMethod.GenericCallTypes.Select(x => currentMethod?.ToGenericIfAvalible(x) ?? x).ToArray();
body[index].Operand = new MethodSpecUser(operand, new GenericInstMethodSig(typeSigList));
}
}
public TypeModuleControlController(ITypeDataDefineService td, ITypeService ts, ITypeModuleService tms, ITypeModuleControlService tmcs)
{
this._td = td;
this._ts = ts;
this._tms = tms;
this._tmcs = tmcs;
}
public TypeController(ITypeService tserv, ILevelService lserv, ICourseService cserv, ISectionService sserv)
{
this.typeService = tserv;
this.levelService = lserv;
this.courseService = cserv;
this.sectionService = sserv;
}
public TypeImageController(ILogger <TypeImageController> log, ITypeImageService ti, IConfiguration config, IWebHostEnvironment webHostEnvironment, ITypeService ts)
{
this._log = log;
this._ti = ti;
this._config = config;
this._webHostEnvironment = webHostEnvironment;
this._ts = ts;
}
public FinanceFormFactory(IPaymentService paymentService, ICategoryService categoryService, ITypeService typeService, IStatusService statusService, ITemplateService paymentTemplateService)
{
_paymentService = paymentService;
_categoryService = categoryService;
_typeService = typeService;
_statusService = statusService;
_paymentTemplateService = paymentTemplateService;
}
public TypeController(ILogger <TypeController> log, IConfiguration config, ITypeService ts, IGroupService gs, IWebHostEnvironment webHostEnvironment)
{
this._log = log;
this._ts = ts;
this._gs = gs;
this._webHostEnvironment = webHostEnvironment;
this._config = config;
}
public TourController(ITourService tourService,
ITypeService typeService,
IUserService userService)
{
this.tourService = tourService;
this.typeService = typeService;
this.userService = userService;
}
public ProductController(IProductService productService, ISizeService sizeService, ITypeService typeService, IOriginService originService, IModelService modelService)
{
_productService = productService;
_sizeService = sizeService;
_typeService = typeService;
_originService = originService;
_modelService = modelService;
}
public void Dispose()
{
if (channel != null)
{
channel.Dispose();
channel = null;
}
}
public ProductTypeController(ITypeService iTypeService,
IOperationLogService iOperationLogService,
IBrandService iBrandService)
{
_iTypeService = iTypeService;
_iOperationLogService = iOperationLogService;
_iBrandService = iBrandService;
}
public TradeHelper()
{
regionService = Himall.ServiceProvider.Instance <IRegionService> .Create;
_iOrderService = Himall.ServiceProvider.Instance <IOrderService> .Create;
_iMemberService = Himall.ServiceProvider.Instance <IMemberService> .Create;
_iFightGroupService = Himall.ServiceProvider.Instance <IFightGroupService> .Create;
_iTypeService = Himall.ServiceProvider.Instance <ITypeService> .Create;
}
/// <summary>
///
/// </summary>
/// <param name="typeService"></param>
/// <exception cref="ArgumentNullException"></exception>
public IsAssignable(ITypeService typeService)
{
// validate arguments
if (typeService == null)
throw new ArgumentNullException("typeService");
this.typeService = typeService;
}
/// <summary>
/// Constructs a listening decorated <see cref="IRepository"/>.
/// </summary>
/// <param name="decoratedRepository">The <see cref="IRepository"/> being decorated.</param>
/// <param name="typeService">The <see cref="ITypeService"/>.</param>
public ListeningRepositoryDecorator(IRepository decoratedRepository, ITypeService typeService) : base(decoratedRepository)
{
// validate arguments
if (typeService == null)
throw new ArgumentNullException("typeService");
// set values
this.typeService = typeService;
}
/// <summary>
///
/// </summary>
/// <param name="typeService"></param>
/// <exception cref="ArgumentNullException"></exception>
public GetProtectedResourceDatasetTag(ITypeService typeService)
{
// validate arguments
if (typeService == null)
throw new ArgumentNullException("typeService");
// set values
this.typeService = typeService;
}
/// <summary>
/// Constructs this processor.
/// </summary>
public TypeArgumentProcessor(ITypeService typeService) : base(100)
{
// validate arguments
if (typeService == null)
throw new ArgumentNullException("typeService");
// set values
this.typeService = typeService;
}
/// <summary>
///
/// </summary>
/// <param name="typeService"></param>
public GroupTypeFacetsTag(ITypeService typeService)
{
// validate arguments
if (typeService == null)
throw new ArgumentNullException("typeService");
// set value
this.typeService = typeService;
}
/// <summary>
///
/// </summary>
public SchemaCreatorApplicationInitializer(ITypeService typeService) : base(20)
{
// validate arguments
if (typeService == null)
throw new ArgumentNullException("typeService");
// set values
this.typeService = typeService;
}
/// <summary>
///
/// </summary>
/// <param name="typeService"></param>
/// <exception cref="ArgumentNullException"></exception>
public TypeExists(ITypeService typeService)
{
// validate arguments
if (typeService == null)
throw new ArgumentNullException("typeService");
// set values
this.typeService = typeService;
}
/// <summary>
/// Initializes a new instance of the <see cref="JetModelBinder" /> class.
/// </summary>
/// <param name="typeService">The type service.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="typeService" /> is <c>null</c>.</exception>
public JetModelBinder(ITypeService typeService)
{
if (typeService == null)
{
throw new ArgumentNullException();
}
_typeService = typeService;
}
/// <summary>
///
/// </summary>
/// <param name="typeService"></param>
/// <exception cref="ArgumentNullException"></exception>
public GetTypeDefinitionProperty(ITypeService typeService)
{
// validate arguments
if (typeService == null)
throw new ArgumentNullException("typeService");
// set values
this.typeService = typeService;
}
/// <summary>
/// </summary>
/// <param name="typeService"></param>
/// <exception cref="ArgumentNullException"></exception>
public UpdateNodeCommand(ITypeService typeService)
{
// validate arguments
if (typeService == null)
throw new ArgumentNullException("typeService");
// set values
this.typeService = typeService;
}
/// <summary>
///
/// </summary>
/// <param name="parser"></param>
/// <param name="typeService"></param>
/// <exception cref="ArgumentNullException"></exception>
public RetrieveLayoutNodeTag(IQueryParser parser, ITypeService typeService)
: base(parser)
{
// validate arguments
if (typeService == null)
throw new ArgumentNullException("typeService");
// set values
this.typeService = typeService;
}
/// <summary>
///
/// </summary>
/// <param name="nucleus"> </param>
/// <param name="typeService"></param>
/// <exception cref="ArgumentNullException"></exception>
/// <exception cref="InvalidOperationException"></exception>
public NodeUrlService(INucleus nucleus, ITypeService typeService)
{
// validate arguments
if (nucleus == null)
throw new ArgumentNullException("nucleus");
if (typeService == null)
throw new ArgumentNullException("typeService");
// set values
this.typeService = typeService;
}
/// <summary>
/// Constructs the index definition resolver.
/// </summary>
/// <param name="typeService">The <see cref="ITypeDefinition"/>.</param>
/// <param name="cachingService">The <see cref="ICachingService"/>.</param>
public IndexDefinitionResolver(ITypeService typeService, ICachingService cachingService)
{
// validate arguments
if (typeService == null)
throw new ArgumentNullException("typeService");
if (cachingService == null)
throw new ArgumentNullException("cachingService");
// set values
this.typeService = typeService;
this.cachingService = cachingService;
}
/// <summary>
///
/// </summary>
/// <param name="typeService"></param>
/// <param name="parser"> </param>
/// <param name="repository"></param>
/// <exception cref="ArgumentNullException"></exception>
public SyncTablesTag(ITypeService typeService, IQueryParser parser, SqlServerRepository repository)
{
// validate arguments
if (typeService == null)
throw new ArgumentNullException("typeService");
if (parser == null)
throw new ArgumentNullException("parser");
if (repository == null)
throw new ArgumentNullException("repository");
// set values
this.typeService = typeService;
this.parser = parser;
this.repository = repository;
}
public DefaultRequestRuntimeProvider(ITypeService typeService)
{
_typeService = typeService;
}
public DefaultRequestHandlerProvider(ITypeService typeService)
{
_typeService = typeService;
}
public DefaultRequestAuthorizerProvider(ITypeService typeService)
{
_typeService = typeService;
}
public DefaultRequestIgnorerProvider(ITypeService typeService)
{
_typeService = typeService;
}
public TypeController(ITypeService service)
{
_typeService = service;
}
