/// <summary>
/// Gets the index of the typed stream.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="block">The block.</param>
/// <param name="service">The service.</param>
/// <param name="typedStreamBlock">The typed stream block.</param>
/// <returns></returns>
public static unsafe uint GetTypedStreamIndex(string name, Block block,
IReadService service, out Block typedStreamBlock)
{
ulong unused;
return(GetTypedStreamIndex(name, block, service, out typedStreamBlock, out unused));
}
public ClientServiceFacade(IReadService <Klijent> clientRead, IInsertService <Klijent> clientInsert, IUpdateService <Klijent> clientUpdate, IDeleteService <Klijent> clientDelete)
{
this._clientRead = clientRead;
this._clientInsert = clientInsert;
this._clientUpdate = clientUpdate;
this._clientDelete = clientDelete;
}
public void Prepare(IReadService readService, out OperationStartupData data)
{
subOperationsToExecute = new List <DeleteChild>();
PrepareInternal(readService, subOperationsToExecute);
data = new OperationStartupData(commonAddress, 0, true);
}
/// <summary>
/// Internal prepare
/// </summary>
/// <param name="readService"></param>
/// <param name="data"></param>
/// <param name="subOps"></param>
unsafe void PrepareInternal(IReadService readService, List <DeleteChild> subOps)
{
// We inspect children.
ulong childrenTS;
Block block = readService.Read(BlockType.NodeHeaderBlock, commonAddress);
fixed(byte *p = block.Data)
{
NodeCommonHeader *header = (NodeCommonHeader *)p;
childrenTS = header->ChildrenBTree;
}
// We check children count.
BPlusTree tree = new BPlusTree(childrenTS);
List <ObjectInfo> objects = tree.ListAll(readService);
// We update stage index/count.
for (int j = 0; j < objects.Count; j++)
{
BlockStream childTagStream = BlockStream.FromBase(objects[j].Address, readService);
ChildTag childTag = Common.DeserializeFromArray(childTagStream.Read(objects[j].Size)) as ChildTag;
foreach (KeyValuePair <string, ulong> child in childTag.Children)
{
DeleteChild subOp = new DeleteChild(child.Value, childrenTS, child.Key);
subOps.Add(subOp);
}
}
subOps.Add(this);
}
public unsafe void Prepare(IReadService readService,
out OperationStartupData data)
{
// We must make sure we can terminate if too many streams.
Block block = readService.Read(BlockType.NodeHeaderBlock, versionNode);
fixed(byte *p = block.Data)
{
NodeVersionHeader *header = (NodeVersionHeader *)p;
if (header->StreamCount + 1 > BlockHelper.MaxTypedStreamsInNode(readService.BlockSize))
{
throw new InvalidOperationException("Number of typed stream in node is more that "
+ BlockHelper.MaxTypedStreamsInNode(readService.BlockSize) + " which is the limit"
+ " at block size " + readService.BlockSize.ToString());
}
}
// We need one allocation if typed stream is single object, otherwise two.
if ((options & StreamOptions.SingleObject) != 0)
{
data = new OperationStartupData(versionNode, 1);
}
else
{
data = new OperationStartupData(versionNode, 2);
}
}
public UserSeed(
ICrudService <User, string> crudService,
IReadService <Role, string> roleReadService)
: base(crudService)
{
_roleReadService = roleReadService;
}
public RemoveValidatorCommandHandler(IReadService <DynamicMetadataDefinition> dynamicMetadataDefinitionService, IWriteService <DynamicMetadataDefinition> dynamicMetadataDefinitionWriteService, IEventDispatcher eventDispatcher, IMapper mapper)
{
_dynamicMetadataDefinitionService = dynamicMetadataDefinitionService;
_dynamicMetadataDefinitionWriteService = dynamicMetadataDefinitionWriteService;
_eventDispatcher = eventDispatcher;
_mapper = mapper;
}
public IReadService CreateChannel()
{
try
{
InstanceContext ic = null;
HOST =
$"{Registry.GetValue("HKEY_CURRENT_USER\\Software\\FormConfiguration", "IPAddress", null)}";
PORT = ushort.Parse(
$"{Registry.GetValue("HKEY_CURRENT_USER\\Software\\FormConfiguration", "Port", null)}");
ic = new InstanceContext(new ReadServiceCallbackClient());
var endPoint =
new EndpointAddress(
new Uri($"net.Tcp://{HOST}:{PORT}/AdvancedScada/{Driver}"));
var factory = new DuplexChannelFactory <IReadService>(ic, GetNetTcpBinding(), endPoint);
Modbusclient = factory.CreateChannel();
}
catch (CommunicationException ex)
{
var err = new HMIException.ScadaException(GetType().Name, ex.Message);
}
return(Modbusclient);
}
public PropertyAddedToMetadataDefinitionEventHandler(IReadService <Movie> movieReadService, IWriteService <Movie> movieWriteService, IReadService <DynamicMetadataDefinition> dynamicMetadataDefinition, IMapper mapper)
{
_movieReadService = movieReadService;
_movieWriteService = movieWriteService;
_dynamicMetadataDefinition = dynamicMetadataDefinition;
_mapper = mapper;
}
public void Constructor_Throws(ILogger <ReadController> logger, IReadService readService, string name)
{
Action act = () => { new ReadController(logger, readService); };
act.Should().Throw <ArgumentNullException>()
.Where(x => x.Message.Contains(name));
}
public ChargeLevelsController()
{
readService = new ReadService();
updateService = new UpdateService();
createService = new CreateService();
deleteService = new DeleteService();
}
public RefreshValidationEventHandler(IReadService <DynamicMetadataDefinition> metadataReadService, IReadService <Movie> movieReadService, IWriteService <Movie> movieWriteService, IValidationFactory validationFactory)
{
_metadataReadService = metadataReadService;
_movieReadService = movieReadService;
_movieWriteService = movieWriteService;
_validationFactory = validationFactory;
}
/// <summary>
/// Gets the index of the typed stream.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="block">The block.</param>
/// <param name="service">The service.</param>
/// <param name="typedStreamBlock">The typed stream block.</param>
/// <returns></returns>
public static unsafe uint GetTypedStreamIndex(string name, Block block,
IReadService service, out Block typedStreamBlock, out ulong address)
{
int nameHash = name.GetHashCode();
fixed(byte *p = block.Data)
{
NodeVersionHeader *header = (NodeVersionHeader *)p;
TSData * data = (TSData *)&header->TypedStreamData[0];
for (uint i = 0; i < header->StreamCount; i++)
{
if (nameHash == data[i].Hash)
{
// We check it if it is the correct one.
typedStreamBlock = service.Read(BlockType.TypedStreamHeader, data[i].Address);
if (IsTypedStreamWithType(typedStreamBlock, name))
{
address = data[i].Address;
return(i);
}
}
}
}
// Noone found.
typedStreamBlock = null;
address = 0;
return(uint.MaxValue);
}
public void SetCreateChannel()
{
try
{
var ic = new InstanceContext(this);
XCollection.CURRENT_MACHINE = new Machine
{
MachineName = Environment.MachineName,
Description = "Free"
};
IPAddress[] hostAddresses = Dns.GetHostAddresses(Dns.GetHostName());
foreach (IPAddress iPAddress in hostAddresses)
{
if (iPAddress.AddressFamily == AddressFamily.InterNetwork)
{
XCollection.CURRENT_MACHINE.IPAddress = $"{iPAddress}";
break;
}
}
client = DriverHelper.GetInstance().GetReadService(ic);
client.Connect(XCollection.CURRENT_MACHINE);
IsConnected = true;
}
catch (Exception ex)
{
EventscadaException?.Invoke(this.GetType().Name, ex.Message);
}
}
public MainForm()
{
try
{
ReadServiceCallbackClient.LoadTagCollection();
XCollection.CURRENT_MACHINE = new Machine
{
MachineName = Environment.MachineName,
Description = "Free"
};
IPAddress[] hostAddresses = Dns.GetHostAddresses(Dns.GetHostName());
foreach (IPAddress iPAddress in hostAddresses)
{
if (iPAddress.AddressFamily == AddressFamily.InterNetwork)
{
XCollection.CURRENT_MACHINE.IPAddress = $"{iPAddress}";
break;
}
}
client = ClientDriverHelper.GetInstance().GetReadService();
client.Connect(XCollection.CURRENT_MACHINE);
Dictionary <string, DriverBase.Devices.Tag> tags = ClientDriverHelper.GetInstance().GetReadServiceWeb().GetCollection();
foreach (KeyValuePair <string, DriverBase.Devices.Tag> item in tags)
{
}
}
catch (CommunicationException ex)
{
EventscadaException?.Invoke(GetType().Name, ex.Message);
}
InitializeComponent();
}
public ScheduleController(IAnalysisService AnalysisService, IBitService BitService, IReadService ReadService,
ITvdbService TvdbService)
{
analysisService = AnalysisService;
bitService = BitService;
readService = ReadService;
tvdbService = TvdbService;
}
public AddValidatorCommandHandler(IReadService <DynamicMetadataDefinition> dynamicMetadataDefinitionService, IWriteService <DynamicMetadataDefinition> dynamicMetadataDefinitionWriteService, IEventDispatcher eventDispatcher, IMapper mapper, IValidationFactory validationFactory)
{
_dynamicMetadataDefinitionService = dynamicMetadataDefinitionService;
_dynamicMetadataDefinitionWriteService = dynamicMetadataDefinitionWriteService;
_eventDispatcher = eventDispatcher;
_mapper = mapper;
_validationFactory = validationFactory;
}
public PropertyDefinitionUpdatedEventHandler(IReadService <Movie> movieReadService, IWriteService <Movie> movieWriteService, IReadService <DynamicMetadataDefinition> dynamicMetadataDefinition, IValidationFactory validationFactory, IMapper mapper)
{
_movieReadService = movieReadService;
_movieWriteService = movieWriteService;
_dynamicMetadataDefinition = dynamicMetadataDefinition;
_validationFactory = validationFactory;
_mapper = mapper;
}
public ChangePropertyTypeAndDefaultValueCommandHandler(IReadService <DynamicMetadataDefinition> dynamicMetadataDefinitonService, IWriteService <DynamicMetadataDefinition> dynamicMetadataDefinitionWriteService, IInputDataParser inputDataParser, IMapper mapper, IEventDispatcher eventDispatcher)
{
_dynamicMetadataDefinitonService = dynamicMetadataDefinitonService;
_dynamicMetadataDefinitionWriteService = dynamicMetadataDefinitionWriteService;
_inputDataParser = inputDataParser;
_mapper = mapper;
_eventDispatcher = eventDispatcher;
}
public WriteTagForm(string Address, IReadService client = null)
{
// This call is required by the designer.
InitializeComponent();
// Add any initialization after the InitializeComponent() call.
txtAddress.Text = Address;
this.client = client;
}
public UpdateMovieMetadataCommandHandler(IReadService <Movie> movieReadService, IWriteService <Movie> movieWriteService, IMapper mapper, IInputDataParser inputDataParser, IReadService <DynamicMetadataDefinition> dynamicMetadataDefinitionReadService, IValidationFactory validationFactory)
{
_movieReadService = movieReadService;
_movieWriteService = movieWriteService;
_mapper = mapper;
_inputDataParser = inputDataParser;
_dynamicMetadataDefinitionReadService = dynamicMetadataDefinitionReadService;
_validationFactory = validationFactory;
}
public bool Startup(Caching.BlockCache provider, JournalRecovery recovery)
{
this.provider = provider;
this.allocator = new Allocator(provider);
this.readService = new ReadService(provider);
// We issue recovery (not written by us but still valid).
return(JournalLog.StartupRecovery(this));
}
public FoodStoreApplicationService(
IReadService <FoodStore, Guid> readService,
IMediatorHandler bus,
IMapper mapper
) : base(readService,
bus, mapper)
{
}
public void Prepare(IReadService readService, out OperationStartupData data)
{
// We comoute how many blocks are needed.
uint allocations = tree.InspectForInserting(readService, index, before);
allocations += BlockHelper.MaxBlocksForObject(readService.BlockSize, (ulong)objectData.LongLength);
data = new OperationStartupData(tree.RootAddress, allocations);
}
public void Prepare(IReadService readService, out OperationStartupData data)
{
// We need to eximine common node address.
uint allocations = childrenTree.InspectForAdding(readService, (uint)childName.GetHashCode());
allocations += 15; // rought estimate (we use dynamic allocation in extreme cases).
data = new OperationStartupData(parentAddress, allocations, true);
}
public WriteTagForm(string Address, IReadService client = null)
{
// This call is required by the designer.
InitializeComponent();
// Add any initialization after the InitializeComponent() call.
txtAddress.Text = Address;
this.client = client;
LayoutControl1.OptionsFocus.EnableAutoTabOrder = false;
}
public ToggleController(ICreateService <ToggleRequest, ToggleResponse> createService,
IReadService <ToggleRequest, ToggleResponse> readService,
IUpdateService <ToggleRequest> updateService,
IDeleteService <ToggleRequest> deleteService)
{
_createService = createService;
_readService = readService;
_updateService = updateService;
_deleteService = deleteService;
}
public InitValuesController(IConfiguration configuration, ILogger <InitValuesController> logger, IHostingEnvironment hostingEnvironment, IMemoryCache memoryCache, IFileProvider fileProvider, IReadService readService)
{
_config = configuration;
_hostingEnvironment = hostingEnvironment;
_logger = logger;
_memoryCache = memoryCache;
_fileProvider = fileProvider;
_readService = readService;
_countriesJsonFilePath = Path.Combine(_hostingEnvironment.ContentRootPath, "Files", "countries.json");
}
public Table(string name, IReadService readService)
{
#region Guards
if (string.IsNullOrEmpty(name)) throw new ArgumentNullException("name", "name cannot be null or empty");
if (readService == null) throw new ArgumentNullException("readService", "readService cannot be null");
#endregion
Name = name;
ReadService = readService;
}
public BaseCRUDApplicationService(
IReadService <T, U> readService,
IMediatorHandler bus,
IMapper mapper
)
{
_readService = readService;
_bus = bus;
_mapper = mapper;
}
public Service()
{
Logger.Log.Info("Incoming request...");
_context = new Context();
_readService = new ReadService(_context);
_readerService = new ReaderService(_context);
_readingService = new ReadingService(_context);
_raceService = new RaceService(_context);
_lastSeenLogService = new LastSeenLogService(_context);
}
