private Azure(RestClient restClient, string subscriptionId, string tenantId, IAuthenticated authenticated)
{
resourceManager = ResourceManager.Fluent.ResourceManager.Authenticate(restClient).WithSubscription(subscriptionId);
storageManager = StorageManager.Authenticate(restClient, subscriptionId);
computeManager = ComputeManager.Authenticate(restClient, subscriptionId);
networkManager = NetworkManager.Authenticate(restClient, subscriptionId);
batchManager = BatchManager.Authenticate(restClient, subscriptionId);
keyVaultManager = KeyVaultManager.Authenticate(restClient, subscriptionId, tenantId);
trafficManager = TrafficManager.Fluent.TrafficManager.Authenticate(restClient, subscriptionId);
dnsZoneManager = DnsZoneManager.Authenticate(restClient, subscriptionId);
sqlManager = SqlManager.Authenticate(restClient, subscriptionId);
redisManager = RedisManager.Authenticate(restClient, subscriptionId);
cdnManager = CdnManager.Authenticate(restClient, subscriptionId);
appServiceManager = AppServiceManager.Authenticate(restClient, subscriptionId, tenantId);
searchManager = SearchManager.Authenticate(restClient, subscriptionId);
serviceBusManager = ServiceBusManager.Authenticate(restClient, subscriptionId);
containerInstanceManager = ContainerInstanceManager.Authenticate(restClient, subscriptionId);
registryManager = RegistryManager.Authenticate(restClient, subscriptionId);
containerServiceManager = ContainerServiceManager.Authenticate(restClient, subscriptionId);
cosmosDBManager = CosmosDBManager.Authenticate(restClient, subscriptionId);
authorizationManager = AuthorizationManager.Authenticate(restClient, subscriptionId);
msiManager = MsiManager.Authenticate(restClient, subscriptionId);
batchAIManager = BatchAIManager.Authenticate(restClient, subscriptionId);
monitorManager = MonitorManager.Authenticate(restClient, subscriptionId);
eventHubManager = EventHubManager.Authenticate(restClient, subscriptionId);
SubscriptionId = subscriptionId;
this.authenticated = authenticated;
}
// Set IoTHub connection strings, using either the user provided value or the configuration
public void SetCurrentIotHub()
{
try
{
// Retrieve connection string from file/storage
this.connString = this.connectionStringManager.GetIotHubConnectionString();
// Parse connection string, this triggers an exception if the string is invalid
IotHubConnectionStringBuilder connStringBuilder = IotHubConnectionStringBuilder.Create(this.connString);
// Prepare registry class used to create/retrieve devices
this.registry = this.registry.CreateFromConnectionString(this.connString);
this.log.Debug("Device registry object ready", () => new { this.ioTHubHostName });
// Prepare hostname used to build device connection strings
this.ioTHubHostName = connStringBuilder.HostName;
this.log.Info("Selected active IoT Hub for devices", () => new { this.ioTHubHostName });
// Prepare the auth key used for all the devices
this.fixedDeviceKey = connStringBuilder.SharedAccessKey;
this.log.Debug("Device authentication key defined", () => new { this.ioTHubHostName });
this.setupDone = true;
}
catch (Exception e)
{
this.log.Error("IoT Hub connection setup failed", e);
throw;
}
}
///GENMHASH:FC4CCB4833EA2DD311741B384FD9316F:8E288AFF39988D3B6818D60EB161D26B
internal RegistryTaskRunImpl(IRegistryManager registryManager, RunInner runInner)
{
this.registryManager = registryManager;
this.registriesInner = registryManager.Inner.Registries;
this.platform = new PlatformProperties();
this.inner = runInner;
}
///GENMHASH:D18EDD2A0D462DC25F8E338158E130F1:92497F2001C42DEB1C90E3A01204233E
internal RegistryImpl(string name, RegistryInner innerObject, IRegistryManager manager, IStorageManager storageManager) : base(name, innerObject, manager)
{
this.storageManager = storageManager;
this.storageAccountId = null;
this.webhooks = new WebhooksImpl(this, "Webhook");
}
///GENMHASH:90436C433DC4B4C48CC8286CCD933506:75801DEBDE7DF693898C5439817D4492
internal RegistryTaskImpl(IRegistryManager registryManager, string taskName)
{
this.tasksInner = registryManager.Inner.Tasks;
this.taskName = taskName;
this.inner = new TaskInner();
this.taskUpdateParameters = new TaskUpdateParametersInner();
}
// Temporary workaround, see https://github.com/Azure/device-simulation-dotnet/issues/136
private IRegistryManager GetRegistry()
{
if (this.registryCount > REGISTRY_LIMIT_REQUESTS)
{
this.registry.CloseAsync();
try
{
this.registry.Dispose();
}
catch (Exception e)
{
// Errors might occur here due to pending requests, they can be ignored
this.log.Debug("Ignoring registry manager Dispose() error", () => new { e });
}
this.registryCount = -1;
}
if (this.registryCount == -1)
{
string connString = this.connectionStringManager.GetIotHubConnectionString();
this.registry = this.registry.CreateFromConnectionString(connString);
this.registry.OpenAsync();
}
this.registryCount++;
return(this.registry);
}
public SettingsViewModel(
IRegistryManager registryManager,
IProcessManager processManager)
{
this.registryManager = registryManager;
this.processManager = processManager;
}
public StartupScanEnabledViewModel(IResolver resolver, IRegistryManager registryManager, ILoginsReader loginsReader, Action onCloseOut, bool isAutoShowPopup)
: base(resolver, null)
{
this.onCloseOut = onCloseOut;
this.onClose = OnClose;
// By default
ScanStatus = DefaultProperties.ReturnString("Onboardv4StatusUnknown");
ScanSummary = registryManager.GetScanSummary();
popupViewModel = new ScanPopupNotificationViewModel(resolver, this, OnClose);
_currentVM = mainViewModel;
bool isScanSummaryEmpty = ScanSummary.Duplicate + ScanSummary.Weak + ScanSummary.Insecure == 0;
IsScanSummaryPopupVisible = isAutoShowPopup && !isScanSummaryEmpty;
if (IsScanSummaryPopupVisible)
{
mainViewModel = new ScanNowViewModel(_resolver, OnClose, () => StartScanCommand.Execute(this));
}
else
{
mainViewModel = new ProgressScanViewModel(_resolver, loginsReader, OnClose, OnScanCompleted);
}
ClosePopup = new RelayCommand((o) =>
{
popupViewModel.LogStep(MarketingActionType.Continue);
IsScanSummaryPopupVisible = false;
CurrentVM = new ScanNowViewModel(_resolver, OnClose, () =>
{
StartScanCommand.Execute(o);
});
});
StartScanCommand = new RelayCommand((o) =>
{
mainViewModel = new ProgressScanViewModel(_resolver, loginsReader, OnClose, OnScanCompleted);
var vm = mainViewModel as ProgressScanViewModel;
if (vm != null)
{
CurrentVM = vm;
vm.StartScan(); // TODO: better move to View.Loaded event, where animation starts now
}
}
);
if (IsScanSummaryPopupVisible)
{
}
else
{
Task.Factory.StartNew(() =>
{
StartScanCommand.Execute(this);
});
}
}
/// <summary>
/// Creates an instance of external child resource in-memory.
/// </summary>
/// <param name="resourceGroupName">The resource group name.</param>
/// <param name="registryName">The registry name.</param>
/// <param name="name">The name of this external child resource.</param>
/// <param name="innerObject">Reference to the inner object representing this external child resource.</param>
/// <param name="containerRegistryManager">Reference to the container registry manager that accesses web hook operations.</param>
///GENMHASH:A21B1A64BBD5DE45FE96382827594FDE:C13877D7A53C23149EEDA94679AF13A2
internal WebhookImpl(string resourceGroupName, string registryName, string name, WebhookInner innerObject, IRegistryManager containerRegistryManager) : base(name, null, innerObject)
{
this.containerRegistryManager = containerRegistryManager;
this.resourceGroupName = resourceGroupName;
this.registryName = registryName;
this.InitCreateUpdateParams();
}
/// <summary>
/// Get IoTHub connection string from either the user provided value or the configuration
/// </summary>
public void SetCurrentIotHub()
{
string connString = this.connectionStringManager.GetIotHubConnectionString();
this.registry = this.registry.CreateFromConnectionString(connString);
this.ioTHubHostName = IotHubConnectionStringBuilder.Create(connString).HostName;
this.log.Info("Selected active IoT Hub for devices", () => new { this.ioTHubHostName });
}
///GENMHASH:F712FF2645AF2A9EDD0A69A05FB730DB:9CE14828E093066A7923277DDBEF714A
internal RegistryTaskImpl(IRegistryManager registryManager, TaskInner inner)
{
this.tasksInner = registryManager.Inner.Tasks;
this.taskName = inner.Name;
this.inner = inner;
this.resourceGroupName = ResourceUtils.GroupFromResourceId(this.inner.Id);
this.registryName = ResourceUtils.NameFromResourceId(ResourceUtils.ParentResourcePathFromResourceId(this.inner.Id));
this.taskUpdateParameters = new TaskUpdateParametersInner();
SetTaskUpdateParameterTriggers();
}
/// <summary>
/// Creates an instance of external child resource in-memory.
/// </summary>
/// <param name="name">The name of this external child resource.</param>
/// <param name="parent">Reference to the parent of this external child resource.</param>
/// <param name="innerObject">Reference to the inner object representing this external child resource.</param>
/// <param name="containerRegistryManager">Reference to the container registry manager that accesses web hook operations.</param>
///GENMHASH:A02845D0393045D983B12D9853197178:8FC0F03D2574AA46828F939572035BF5
internal WebhookImpl(string name, RegistryImpl parent, WebhookInner innerObject, IRegistryManager containerRegistryManager) : base(name, parent, innerObject)
{
this.containerRegistryManager = containerRegistryManager;
if (parent != null)
{
this.resourceGroupName = parent.ResourceGroupName;
this.registryName = parent.Name;
}
this.InitCreateUpdateParams();
}
internal static int LoadBlockstates(IRegistryManager registryManager, ResourceManager resources, bool replace,
bool reportMissing = false, IProgressReceiver progressReceiver = null)
{
//RuntimeIdTable = TableEntry.FromJson(raw);
progressReceiver?.UpdateProgress(0, "Loading block models...");
RegisterBuiltinBlocks();
return(LoadModels(registryManager, resources, replace, reportMissing, progressReceiver));
}
public StartupScanEnabled(IResolver resolver, IRegistryManager registryManager, ILoginsReader loginsReader, bool isAutoShowPopup)
{
_resizer = new WindowResizer(this);
this.Loaded += OnLoaded;
viewModel = new StartupScanEnabledViewModel(resolver,
registryManager,
loginsReader,
() => this.Close(), isAutoShowPopup);
this.DataContext = viewModel;
InitializeComponent();
}
public Devices(
IServicesConfig config,
IIotHubConnectionStringManager connStringManager,
IRegistryManager registryManager,
ILogger logger)
{
this.connectionStringManager = connStringManager;
this.registry = registryManager;
this.log = logger;
this.twinReadsWritesEnabled = config.TwinReadWriteEnabled;
this.registryCount = -1;
this.setupDone = false;
}
public SettingsViewModel(
IRegistryManager registryManager,
IProcessManager processManager,
ISettingsManager settingsManager,
IKeyboardManager keyboardManager)
{
this.registryManager = registryManager;
this.processManager = processManager;
this.settingsManager = settingsManager;
this.keyboardManager = keyboardManager;
pasteDurationBeforeUserInterfaceShowsInMilliseconds = settingsManager.LoadSetting(
nameof(PasteDurationBeforeUserInterfaceShowsInMilliseconds),
300);
}
public AppUpdateService(
IActionLog log,
IUpdateManager updateManager,
IRegistryManager registryManager,
IAppConfigurationManager configurationManager,
IAppWindowManager appWindowManager,
DispatcherTimer timer)
{
this.log = log;
this.updateManager = updateManager;
this.registryManager = registryManager;
this.configurationManager = configurationManager;
this.appWindowManager = appWindowManager;
this.timer = timer;
}
public Devices(
IServicesConfig config,
IIotHubConnectionStringManager connStringManager,
IRegistryManager registryManager,
IDeviceClientWrapper deviceClient,
ILogger logger)
{
this.config = config;
this.connectionStringManager = connStringManager;
this.connString = null;
this.registry = registryManager;
this.deviceClient = deviceClient;
this.log = logger;
this.twinReadsWritesEnabled = config.TwinReadWriteEnabled;
this.setupDone = false;
}
/// <summary>
/// A Factory method to return concrete implementations of <see cref="ILifecycle"/>
/// </summary>
/// <typeparam name="TInterface">Object's contract for which the <see cref="ILifecycle"/> instance is returned</typeparam>
/// <param name="registrar"><see cref="IRegistryManager"/> instance required as a pass through to <see cref="ILifecycle"/> implementations</param>
/// <returns>Instance of <see cref="ILifecycle"/> implementations depending on the object interface's <see cref="LifecycleType"/></returns>
/// <exception cref="InvalidOperationException">If not a valid type of <see cref="LifecycleType"/></exception>
internal static ILifecycle GetLifecycleInstance <TInterface>(IRegistryManager registrar)
{
var existingRegistration = registrar.Find <TInterface>();
switch (existingRegistration.Lifecycle)
{
case LifecycleType.Singleton:
return(new SingletonLifecycle(registrar));
case LifecycleType.Transient:
return(new TransientLifecycle(registrar));
default:
throw new InvalidOperationException($"LifecycleType {existingRegistration.Lifecycle} invalid!");
}
}
public Devices(
IServicesConfig config,
IConnectionStrings connStrings,
IRegistryManager registryManager,
IDeviceClientWrapper deviceClientFactory,
ILogger logger,
IDiagnosticsLogger diagnosticsLogger,
IInstance instance)
{
this.config = config;
this.connectionStrings = connStrings;
this.registry = registryManager;
this.deviceClientFactory = deviceClientFactory;
this.log = logger;
this.diagnosticsLogger = diagnosticsLogger;
this.instance = instance;
this.connString = null;
}
internal static int LoadResources(IRegistryManager registryManager, ResourceManager resources, McResourcePack resourcePack, bool replace,
bool reportMissing = false, IProgressReceiver progressReceiver = null)
{
var raw = ResourceManager.ReadStringResource("Alex.Resources.runtimeidtable.json");
RuntimeIdTable = TableEntry.FromJson(raw);
var blockEntries = resources.Registries.Blocks.Entries;
progressReceiver?.UpdateProgress(0, "Loading block registry...");
for (int i = 0; i < blockEntries.Count; i++)
{
var kv = blockEntries.ElementAt(i);
progressReceiver?.UpdateProgress(i * (100 / blockEntries.Count), "Loading block registry...",
kv.Key);
ProtocolIdToBlockName.TryAdd(kv.Value.ProtocolId, kv.Key);
}
progressReceiver?.UpdateProgress(0, "Loading block models...");
if (resourcePack.TryGetBlockModel("cube_all", out ResourcePackLib.Json.Models.Blocks.BlockModel cube))
{
cube.Textures["all"] = "no_texture";
CubeModel = cube;
UnknownBlockModel = new ResourcePackBlockModel(resources, new BlockStateModel[]
{
new BlockStateModel()
{
Model = CubeModel,
ModelName = "Unknown model",
}
});
AirState.Model = UnknownBlockModel;
}
RegisterBuiltinBlocks();
return(LoadModels(registryManager, resources, resourcePack, replace, reportMissing, progressReceiver));
}
public Devices(
IServicesConfig config,
IIotHubConnectionStringManager connStringManager,
IRegistryManager registryManager,
IDeviceClientWrapper deviceClient,
ILogger logger,
IDiagnosticsLogger diagnosticsLogger,
IInstance instance)
{
this.config = config;
this.connectionStringManager = connStringManager;
this.registry = registryManager;
this.deviceClient = deviceClient;
this.log = logger;
this.diagnosticsLogger = diagnosticsLogger;
this.instance = instance;
this.connString = null;
this.twinReadsWritesEnabled = config.TwinReadWriteEnabled;
}
private void InitializeApplication(UIControlledApplication application)
{
ApplicationGlobals.UiControlledApplication = application;
WindowsApplication.Application.EnableVisualStyles();
var applicationContext = new ApplicationContext("UOL Revit Sample Addin", "1.0.0.0", "UOLSample");
ApplicationGlobals.ApplicationContext = applicationContext;
// Add all services to the ApplicationContext that this Revit Add-in requires.
applicationContext.AddUOLRevitAddIn();
var monitoredExecutionContext = ApplicationGlobals.ApplicationContext.GetService <IMonitoredExecutionContext>();
var windowTools = new WindowTools(monitoredExecutionContext);
ApplicationGlobals.HostWindow = windowTools.GetWindowHandle("Revit");
registryManager = ApplicationGlobals.ApplicationContext.GetService <IRegistryManager>();
var registryHelper = new RegistryHelper();
Thread.CurrentThread.CurrentUICulture = new System.Globalization.CultureInfo(registryHelper.GetLanguage());
}
///GENMHASH:CDAB2C7CC715005191421E1723AFA34B:07766DB5652046D840E62ECBE0F0FDCD
internal WebhooksClientImpl(IRegistryManager containerRegistryManager, RegistryImpl containerRegistry)
{
this.containerRegistryManager = containerRegistryManager;
this.containerRegistry = containerRegistry;
}
///GENMHASH:C20A4C6092C094D9F582AF41A61BBEEE:6BB7F98668B697E6F973980EB0493963
internal RegistryTaskRunsImpl(IRegistryManager registryManager)
{
this.registryManager = registryManager;
}
public static void Init(IRegistryManager registryManager, ResourceManager resources, McResourcePack resourcePack, IProgressReceiver progressReceiver = null)
{
var blockRegistry = registryManager.GetRegistry <Block>();
ResourceManager = resources;
ResourcePack = resourcePack;
var otherRaw = ResourceManager.ReadStringResource("Alex.Resources.items3.json");
SecItemEntries = JsonConvert.DeserializeObject <SecondItemEntry[]>(otherRaw);
var raw = ResourceManager.ReadStringResource("Alex.Resources.items2.json");
ItemEntries = JsonConvert.DeserializeObject <ItemEntry[]>(raw);
var ii = resources.Registries.Items.Entries;
var blocks = resources.Registries.Blocks.Entries;
LoadModels();
Dictionary <ResourceLocation, Func <Item> > items = new Dictionary <ResourceLocation, Func <Item> >();
for (int i = 0; i < blocks.Count; i++)
{
var entry = blocks.ElementAt(i);
progressReceiver?.UpdateProgress((int)(100D * ((double)i / (double)blocks.Count)), $"Processing block items...", entry.Key);
Item item;
/*if (blockRegistry.TryGet(entry.Key, out var blockState))
* {
* item = new ItemBlock(blockState.Value);
* }*/
var bs = BlockFactory.GetBlockState(entry.Key);
if (!(bs.Block is Air))
{
item = new ItemBlock(bs);
// Log.Info($"Registered block item: {entry.Key}");
}
else
{
continue;
}
var minetItem = MiNET.Items.ItemFactory.GetItem(entry.Key.Replace("minecraft:", ""));
if (minetItem != null)
{
if (Enum.TryParse <ItemType>(minetItem.ItemType.ToString(), out ItemType t))
{
item.ItemType = t;
}
SetItemMaterial(item, minetItem.ItemMaterial);
// item.Material = minetItem.ItemMaterial;
item.Meta = minetItem.Metadata;
item.Id = minetItem.Id;
}
item.Name = entry.Key;
item.DisplayName = entry.Key;
var data = ItemEntries.FirstOrDefault(x =>
x.name.Equals(entry.Key.Substring(10), StringComparison.InvariantCultureIgnoreCase));
if (data != null)
{
item.MaxStackSize = data.stackSize;
item.DisplayName = data.displayName;
}
string ns = ResourceLocation.DefaultNamespace;
string path = entry.Key;
if (entry.Key.Contains(':'))
{
var index = entry.Key.IndexOf(':');
ns = entry.Key.Substring(0, index);
path = entry.Key.Substring(index + 1);
}
var key = new ResourceLocation(ns, $"block/{path}");
ResourcePackModelBase model;
if (!(ResourcePack.ItemModels.TryGetValue(key, out model)))
{
foreach (var it in ResourcePack.ItemModels)
{
if (it.Key.Path.Equals(key.Path, StringComparison.InvariantCultureIgnoreCase))
{
model = it.Value;
break;
}
}
}
if (model != null)
{
item.Renderer = new ItemBlockModelRenderer(bs, model, resourcePack, resources);
item.Renderer.Cache(resourcePack);
}
else
{
Log.Warn($"Could not find block model renderer for: {key.ToString()}");
}
items.TryAdd(entry.Key, () =>
{
return(item.Clone());
});
}
for (int i = 0; i < ii.Count; i++)
{
var entry = ii.ElementAt(i);
progressReceiver?.UpdateProgress(i * (100 / ii.Count), $"Processing items...", entry.Key);
Item item;
/*if (blockRegistry.TryGet(entry.Key, out var blockState))
* {
* item = new ItemBlock(blockState.Value);
* }*/
/* if (blocks.ContainsKey(entry.Key) && blockRegistry.TryGet(entry.Key, out var registryEntry))
* {
* item = new ItemBlock(registryEntry.Value);
* }
* else
* {*/
item = new Item();
// }
var minetItem = MiNET.Items.ItemFactory.GetItem(entry.Key.Replace("minecraft:", ""));
if (minetItem != null)
{
if (Enum.TryParse <ItemType>(minetItem.ItemType.ToString(), out ItemType t))
{
item.ItemType = t;
}
SetItemMaterial(item, minetItem.ItemMaterial);
// item.Material = minetItem.ItemMaterial;
item.Meta = minetItem.Metadata;
item.Id = minetItem.Id;
}
item.Name = entry.Key;
item.DisplayName = entry.Key;
var data = ItemEntries.FirstOrDefault(x =>
x.name.Equals(entry.Key.Substring(10), StringComparison.InvariantCultureIgnoreCase));
if (data != null)
{
item.MaxStackSize = data.stackSize;
item.DisplayName = data.displayName;
}
string ns = ResourceLocation.DefaultNamespace;
string path = entry.Key;
if (entry.Key.Contains(':'))
{
var index = entry.Key.IndexOf(':');
ns = entry.Key.Substring(0, index);
path = entry.Key.Substring(index + 1);
}
var key = new ResourceLocation(ns, $"item/{path}");
foreach (var it in ResourcePack.ItemModels)
{
if (it.Key.Path.Equals(key.Path, StringComparison.InvariantCultureIgnoreCase))
{
//Log.Info($"Model found: {entry.Key} = {it.Key}");
ItemModelRenderer renderer;
if (ItemRenderers.TryGetValue(it.Key, out renderer))
{
}
else if (ItemRenderers.TryGetValue(key, out renderer))
{
}
if (renderer != null)
{
//Log.Debug($"Found renderer for {entry.Key}, textures: {it.Value.Textures.Count}");
item.Renderer = renderer;
break;
}
}
}
if (item.Renderer == null)
{
Log.Warn($"Could not find item model renderer for: {key.ToString()}");
}
items.TryAdd(key, () => { return(item.Clone()); });
}
Items = new ReadOnlyDictionary <ResourceLocation, Func <Item> >(items);
}
public RegistryController(IRegistryManager registryManager)
{
_registryManager = registryManager;
}
private static int LoadModels(IRegistryManager registryManager, ResourceManager resources,
McResourcePack resourcePack, bool replace,
bool reportMissing, IProgressReceiver progressReceiver)
{
long idCounter = 0;
var blockRegistry = registryManager.GetRegistry <Block>();
var blockModelRegistry = registryManager.GetRegistry <BlockModel>();
var data = BlockData.FromJson(ResourceManager.ReadStringResource("Alex.Resources.NewBlocks.json"));
int total = data.Count;
int done = 0;
int importCounter = 0;
int multipartBased = 0;
uint c = 0;
foreach (var entry in data)
{
double percentage = 100D * ((double)done / (double)total);
progressReceiver.UpdateProgress((int)percentage, $"Importing block models...", entry.Key);
var variantMap = new BlockStateVariantMapper();
var defaultState = new BlockState
{
Name = entry.Key,
VariantMapper = variantMap
};
if (entry.Value.Properties != null)
{
foreach (var property in entry.Value.Properties)
{
// if (property.Key.Equals("waterlogged"))
// continue;
defaultState = (BlockState)defaultState.WithPropertyNoResolve(property.Key,
property.Value.FirstOrDefault(), false);
}
}
foreach (var s in entry.Value.States)
{
var id = s.ID;
BlockState variantState = (BlockState)(defaultState).CloneSilent();
variantState.ID = id;
variantState.Name = entry.Key;
if (s.Properties != null)
{
foreach (var property in s.Properties)
{
//if (property.Key.Equals("waterlogged"))
// continue;
variantState =
(Blocks.State.BlockState)variantState.WithPropertyNoResolve(property.Key,
property.Value, false);
}
}
if (!replace && RegisteredBlockStates.TryGetValue(id, out BlockState st))
{
Log.Warn(
$"Duplicate blockstate id (Existing: {st.Name}[{st.ToString()}] | New: {entry.Key}[{variantState.ToString()}]) ");
continue;
}
var cachedBlockModel = GetOrCacheModel(resources, resourcePack, variantState, id, replace);
if (cachedBlockModel == null)
{
if (reportMissing)
{
Log.Warn($"Missing blockmodel for blockstate {entry.Key}[{variantState.ToString()}]");
}
cachedBlockModel = UnknownBlockModel;
}
if (variantState.IsMultiPart)
{
multipartBased++;
}
string displayName = entry.Key;
IRegistryEntry <Block> registryEntry;
if (!blockRegistry.TryGet(entry.Key, out registryEntry))
{
registryEntry = new UnknownBlock(id);
displayName = $"(MISSING) {displayName}";
registryEntry = registryEntry.WithLocation(entry.Key); // = entry.Key;
}
else
{
registryEntry = registryEntry.WithLocation(entry.Key);
}
var block = registryEntry.Value;
variantState.Model = cachedBlockModel;
variantState.Default = s.Default;
if (string.IsNullOrWhiteSpace(block.DisplayName) ||
!block.DisplayName.Contains("minet", StringComparison.InvariantCultureIgnoreCase))
{
block.DisplayName = displayName;
}
variantState.Block = block;
block.BlockState = variantState;
if (variantMap.TryAdd(variantState))
{
if (!RegisteredBlockStates.TryAdd(variantState.ID, variantState))
{
if (replace)
{
RegisteredBlockStates[variantState.ID] = variantState;
importCounter++;
}
else
{
Log.Warn(
$"Failed to add blockstate (variant), key already exists! ({variantState.ID} - {variantState.Name})");
}
}
else
{
importCounter++;
}
}
else
{
Log.Warn(
$"Could not add variant to variant map: {variantState.Name}[{variantState.ToString()}]");
}
}
if (!BlockStateByName.TryAdd(defaultState.Name, variantMap))
{
if (replace)
{
BlockStateByName[defaultState.Name] = variantMap;
}
else
{
Log.Warn($"Failed to add blockstate, key already exists! ({defaultState.Name})");
}
}
done++;
}
Log.Info($"Got {multipartBased} multi-part blockstate variants!");
return(importCounter);
}
public ManageController(IRegistryManager registryManager, IConfiguration configuration)
{
_registryManager = registryManager;
_configuration = configuration;
}
public Registry(IRegistryManager rm)
{
_registryManager = rm;
}
public ManageController(IRegistryManager registryManager, IConfiguration configuration)
{
_registryManager = registryManager;
_configuration = configuration;
}
public static void Init(IRegistryManager registryManager, ResourceManager resources, IProgressReceiver progressReceiver = null)
{
ResourceManager = resources;
// ResourcePack = resourcePack;
var otherRaw = ResourceManager.ReadStringResource("Alex.Resources.items3.json");
SecItemEntries = JsonConvert.DeserializeObject <SecondItemEntry[]>(otherRaw);
var raw = ResourceManager.ReadStringResource("Alex.Resources.items2.json");
ItemEntries = JsonConvert.DeserializeObject <ItemEntry[]>(raw);
var ii = resources.Registries.Items.Entries;
var blocks = resources.Registries.Blocks.Entries;
// LoadModels();
ConcurrentDictionary <ResourceLocation, Func <Item> > items = new ConcurrentDictionary <ResourceLocation, Func <Item> >();
// for(int i = 0; i < blocks.Count; i++)
// List<ResourceLocation> addedCurrently = n
int done = 0;
Parallel.ForEach(
blocks, e =>
{
try
{
var entry = e;
progressReceiver?.UpdateProgress(done, blocks.Count, $"Processing block items...", entry.Key);
Item item;
/*if (blockRegistry.TryGet(entry.Key, out var blockState))
* {
* item = new ItemBlock(blockState.Value);
* }*/
var bs = BlockFactory.GetBlockState(entry.Key);
if (!(bs.Block is Air) && bs != null)
{
item = new ItemBlock(bs);
// Log.Info($"Registered block item: {entry.Key}");
}
else
{
return;
}
/*var minetItem = MiNET.Items.ItemFactory.GetItem(entry.Key.Replace("minecraft:", ""));
*
* if (minetItem != null)
* {
* if (Enum.TryParse<ItemType>(minetItem.ItemType.ToString(), out ItemType t))
* {
* item.ItemType = t;
* }
*
* SetItemMaterial(item, minetItem.ItemMaterial);
* // item.Material = minetItem.ItemMaterial;
*
* item.Meta = minetItem.Metadata;
* item.Id = minetItem.Id;
* }*/
item.Name = entry.Key;
item.DisplayName = entry.Key;
var data = ItemEntries.FirstOrDefault(
x => x.name.Equals(entry.Key.Substring(10), StringComparison.OrdinalIgnoreCase));
if (data != null)
{
item.MaxStackSize = data.stackSize;
item.DisplayName = data.displayName;
}
string ns = ResourceLocation.DefaultNamespace;
string path = entry.Key;
if (entry.Key.Contains(':'))
{
var index = entry.Key.IndexOf(':');
ns = entry.Key.Substring(0, index);
path = entry.Key.Substring(index + 1);
}
var resourceLocation = new ResourceLocation(ns, $"block/{path}");
ResourcePackModelBase model = null;
if (!ResourceManager.TryGetBlockModel(resourceLocation, out model))
{
/*foreach (var it in ResourcePack.ItemModels)
* {
* if (it.Key.Path.Equals(key.Path, StringComparison.OrdinalIgnoreCase))
* {
* model = it.Value;
*
* break;
* }
* }*/
}
if (model == null)
{
Log.Debug($"Missing item render definition for block {entry.Key}, using default.");
// model = new ResourcePackItem() {Display = _defaultDisplayElements};
}
else
{
item.Renderer = new ItemBlockModelRenderer(bs, model, bs.Block.Animated ? resources.Atlas.GetAtlas(0) : resources.Atlas.GetStillAtlas());
item.Renderer.Cache(resources);
if (!items.TryAdd(entry.Key, () => { return(item.Clone()); }))
{
// items[entry.Key] = () => { return item.Clone(); };
}
}
}
finally
{
done++;
}
});
int i = 0;
Parallel.ForEach(
ii, (entry) =>
{
// var entry = ii.ElementAt(i);
progressReceiver?.UpdateProgress(i++, ii.Count, $"Processing items...", entry.Key);
var resourceLocation = new ResourceLocation(entry.Key);
resourceLocation = new ResourceLocation(resourceLocation.Namespace, $"item/{resourceLocation.Path}");
if (items.ContainsKey(resourceLocation))
{
return;
}
Item item;
/*if (blockRegistry.TryGet(entry.Key, out var blockState))
* {
* item = new ItemBlock(blockState.Value);
* }*/
/* if (blocks.ContainsKey(entry.Key) && blockRegistry.TryGet(entry.Key, out var registryEntry))
* {
* item = new ItemBlock(registryEntry.Value);
* }
* else
* {*/
item = new Item();
// }
var minetItem = MiNET.Items.ItemFactory.GetItem(resourceLocation.Path);
if (minetItem != null)
{
if (Enum.TryParse <ItemType>(minetItem.ItemType.ToString(), out ItemType t))
{
item.ItemType = t;
}
SetItemMaterial(item, minetItem.ItemMaterial);
// item.Material = minetItem.ItemMaterial;
item.Meta = minetItem.Metadata;
item.Id = minetItem.Id;
}
item.Name = entry.Key;
item.DisplayName = entry.Key;
var data = ItemEntries.FirstOrDefault(
x => x.name.Equals(resourceLocation.Path, StringComparison.OrdinalIgnoreCase));
if (data != null)
{
item.MaxStackSize = data.stackSize;
item.DisplayName = data.displayName;
}
ItemModelRenderer renderer;
if (!ItemRenderers.TryGetValue(resourceLocation, out renderer))
{
if (ResourceManager.TryGetItemModel(resourceLocation, out var model))
{
renderer = new ItemModelRenderer(model);
renderer.Cache(ResourceManager);
ItemRenderers.TryAdd(resourceLocation, renderer);
}
if (renderer == null)
{
var r = ItemRenderers.FirstOrDefault(
x => x.Key.Path.Equals(resourceLocation.Path, StringComparison.OrdinalIgnoreCase));
if (r.Value != null)
{
renderer = r.Value;
}
}
// if (ResourcePack.ItemModels.TryGetValue(resourceLocation, out var itemModel)) { }
}
if (renderer != null)
{
item.Renderer = renderer;
}
if (item.Renderer == null)
{
Log.Warn($"Could not find item model renderer for: {resourceLocation}");
}
if (!items.TryAdd(resourceLocation, () => { return(item.Clone()); }))
{
//var oldItem = items[resourceLocation];
// items[resourceLocation] = () => { return item.Clone(); };
}
});
Items = new ReadOnlyDictionary <ResourceLocation, Func <Item> >(items);
}
public RegistryController(IRegistryManager registryManager, IConfiguration configuration,ILoggingService loggingService )
{
_registryManager = registryManager;
_config = configuration;
_loggingService = loggingService;
}
