public ContentPane AddContentPane(ModuleType moduleType, string paneName = null)
{
UserControl userControl = this.GetControl(moduleType);
ContentPane contentPane = this._MainWindow.DockManager.AddDocument(this._MainWindow.AuthorizedModules[moduleType].ModuleDescription, userControl);
if (paneName == null)
{
contentPane.Name = this.GetPaneName(moduleType);
if (this.IsMultipleOpenModule(moduleType))
{
contentPane.CloseAction = PaneCloseAction.RemovePane;
this._MultipleOpenModuleMaxSuffixes[moduleType]++;
contentPane.Name += "_" + this._MultipleOpenModuleMaxSuffixes[moduleType].ToString();
}
}
else
{
contentPane.Name = paneName;
if(this.IsMultipleOpenModule(moduleType))
{
contentPane.CloseAction = PaneCloseAction.RemovePane;
int suffix = this.GetSuffix(paneName);
int currentSuffix = this._MultipleOpenModuleMaxSuffixes[moduleType];
this._MultipleOpenModuleMaxSuffixes[moduleType] = Math.Max(currentSuffix, suffix);
}
}
contentPane.Padding = contentPane.BorderThickness = new Thickness(0);
this._OnAddContentPane(moduleType, userControl);
return contentPane;
}
internal QueryableModule(ModuleDefinition moduleDefinition, QueryableAssembly assembly)
{
_assembly = assembly;
_name = Utility.ToString(_getName(moduleDefinition));
_fullPath = Utility.ToString(moduleDefinition.FullyQualifiedName);
_moduleType = _getModuleType(moduleDefinition);
_targetRuntimeVersion = Utility.ToString(_getTargetRuntimeVersion(moduleDefinition));
_targetPlatform = _getTargetPlatform(moduleDefinition);
_hasNativeCode = _getHasNativeCode(moduleDefinition);
_isStrongNameSigned = _getIsStrongNameSigned(moduleDefinition);
if (moduleDefinition.Assembly != null && moduleDefinition == moduleDefinition.Assembly.MainModule)
{
_assembly.MainModule = this;
}
foreach (Resource resource in moduleDefinition.Resources)
{
_resources.Add(new QueryableResource(resource, this));
}
foreach (TypeDefinition typeDefinition in moduleDefinition.Types)
{
QueryableType type = new QueryableType(typeDefinition, this, null);
_addTypesAndMethods(type);
}
}
public static IContext CreateByType(ModuleType type)
{
switch (type)
{
case ModuleType.DARC:
return new DARCContext();
case ModuleType.Banner:
return new BannerContext();
case ModuleType.CGFX:
return new CGFXContext();
case ModuleType.CBMD:
return new CBMDContext();
case ModuleType.CIA:
return new CIAContext();
case ModuleType.CWAV:
return new CWAVContext();
case ModuleType.ICN:
return new ICNContext();
case ModuleType.MPO:
return new MPOContext();
case ModuleType.CCI:
return new CCIContext();
case ModuleType.CXI:
return new CXIContext();
case ModuleType.SaveFlash_Decrypted:
case ModuleType.SaveFlash:
return new SaveFlashContext();
case ModuleType.Archive:
return new ArchivedCCIContext();
case ModuleType.TMD:
return new TMDContext();
}
return null;
}
public string GetCaption(ModuleType moduleType) {
switch(moduleType) {
case ModuleType.Unknown:
return null;
case ModuleType.EmployeesPeek:
case ModuleType.EmployeesFilterPane:
return "Employees";
case ModuleType.CustomersPeek:
case ModuleType.CustomersFilterPane:
return "Customers";
case ModuleType.ProductsPeek:
case ModuleType.ProductsFilterPane:
return "Products";
case ModuleType.Orders:
case ModuleType.OrdersFilterPane:
return "Sales";
case ModuleType.Quotes:
case ModuleType.QuotesFilterPane:
return "Opportunities";
case ModuleType.Dashboards:
<<<<<<< HEAD
case ModuleType.DashboardsFilterPane:
=======
case ModuleType.DashboardsPane:
case ModuleType.DashboardsEdit:
>>>>>>> 58d5963b05133ab1068392b2084d015cb969dfb8
return "Dashboards";
default:
return moduleType.ToString();
}
}
Module(ModuleType type, IModuleSource source)
{
if (source == null)
throw new ArgumentNullException(nameof(source));
this.ModuleType = type;
this.source = source;
var name = source.Name;
name = name.Replace("__", "{**}");
name = name.Replace('_', '.');
name = name.Replace("{**}", "_");
switch (type)
{
case ModuleType.x86:
name = name.Replace(".86", string.Empty);
break;
case ModuleType.x64:
name = name.Replace(".64", string.Empty);
break;
case ModuleType.Exe:
name = name.Replace(".exe", string.Empty);
break;
}
this.Name = name;
this.assemblyReference = new WeakReference(null);
}
public DbModule(String schemaName, String moduleName, String definition, ModuleType type)
{
this.SchemaName = schemaName;
this.ModuleName = moduleName;
this.Definition = definition;
this.ModuleType = type;
}
public bool HasPermission(ModuleCategoryType categoryType, ModuleType moduleType, string operationCode)
{
if (User.IsAdmin)
{
return true;
}
return this.UserPermission.HasPermission(categoryType, moduleType, operationCode);
}
public EngineWrapper(Part part)
{
if ((mEFX = part.transform.GetComponent<ModuleEnginesFX>()) != null)
type = ModuleType.MODULEENGINESFX;
else if ((mE = part.transform.GetComponent<ModuleEngines>()) != null)
type = ModuleType.MODULEENGINES;
else
throw new ArgumentException("Unable to find engine-like module");
}
public ModulesDataWorkingViewModel(int subjectId, int moduleId, ModuleType type)
{
SubjectId = subjectId;
ParentModule = type;
var subject = SubjectManagementService.GetSubject(subjectId);
Module = subject.SubjectModules.First(e => (int)e.Module.Id == moduleId).Module;
switch (type)
{
case ModuleType.Practical:
{
switch (Module.ModuleType)
{
case ModuleType.ScheduleProtection:
{
break;
}
case ModuleType.Results:
{
break;
}
case ModuleType.StatisticsVisits:
{
break;
}
}
break;
}
case ModuleType.Labs:
{
switch (Module.ModuleType)
{
case ModuleType.ScheduleProtection:
{
ScheduleProtectionLabsGenerate();
break;
}
case ModuleType.Results:
{
break;
}
case ModuleType.StatisticsVisits:
{
break;
}
}
break;
}
}
}
private ModuleType Register(ModuleType module)
{
// null during bootstrapping of built-in types
if (analyzer.Builtins != null)
{
module.Table.addSuper(analyzer.Builtins.BaseModule.Table);
}
return module;
}
public ChelaCompiler(ModuleType moduleType)
{
// Create the module node.
moduleNode = new ModuleNode(null, null);
moduleNode.SetName("global");
// Create the module.
ChelaModule module = new ChelaModule();
moduleNode.SetModule(module);
module.SetName("unnamed");
module.SetModuleType(moduleType);
}
public static string ModuleTypeToString(ModuleType type)
{
if (type == ModuleType.Vhdl)
{
return "vhdl";
}
else if (type == ModuleType.Verilog)
{
return "verilog";
}
return "unknown";
}
/// <summary>
/// Initialize module info and construct per-module metadata reader.
/// </summary>
/// <param name="moduleHandle">Handle (address) of module to initialize</param>
internal unsafe ModuleInfo(IntPtr moduleHandle, ModuleType moduleType)
{
Handle = moduleHandle;
ModuleType = moduleType;
DynamicModulePtr = null;
byte* pBlob;
uint cbBlob;
if (RuntimeAugments.FindBlob(moduleHandle, (int)ReflectionMapBlob.EmbeddedMetadata, new IntPtr(&pBlob), new IntPtr(&cbBlob)))
{
MetadataReader = new MetadataReader((IntPtr)pBlob, (int)cbBlob);
}
}
public IEnumerable<ErrorInfo> SaveModuleType(ModuleType moduleType)
{
using(CMSContext context=new CMSContext()) {
IEnumerable<ErrorInfo> errors=ValidationHelper.Validate(moduleType);
if(errors.Any()==false) {
if(moduleType.ModuleTypeID<=0) {
context.ModuleTypes.Add(moduleType);
} else {
context.Entry(moduleType).State=EntityState.Modified;
}
context.SaveChanges();
}
return errors;
}
}
public ModuleBase(ModuleType moduleType, ConcurrentQueue<IQuantumDevice> quantumsQueue, ISignalGeneratorFactory signalGeneratorFactory)
{
// Идентификатор модуля будет равен типу модуля.
Id = (byte)moduleType;
ModuleType = moduleType;
ChannelCount = 1;
GainFactor = 0;
SplineLevel = 0;
Parameters = new List<IModuleParameter>();
Frequency = defaultFrequency;
QuantumsQueue = quantumsQueue;
active = false;
signalGenerator = signalGeneratorFactory.Create(ModuleType, this);
}
public bool HasPermission(ModuleCategoryType categoryType, ModuleType moduleType, string operationCode)
{
bool isOwn = false;
if (FunctionPermissions.ContainsKey("admin"))
{
return true;
}
if (FunctionPermissions.Count == 0)
{
return false;
}
List<FuncPermissionStatus> category;
if (FunctionPermissions.TryGetValue("root", out category))
{
foreach (FuncPermissionStatus item in category)
{
if (item.Code == Enum.GetName(typeof(ModuleCategoryType), categoryType))
{
isOwn = item.HasPermission;
}
}
}
List<FuncPermissionStatus> module;
if (FunctionPermissions.TryGetValue(Enum.GetName(typeof(ModuleCategoryType), categoryType), out module))
{
foreach (FuncPermissionStatus item in module)
{
if (item.Code == Enum.GetName(typeof(ModuleType), moduleType))
{
isOwn = item.HasPermission;
}
}
}
List<FuncPermissionStatus> operation;
if (FunctionPermissions.TryGetValue(Enum.GetName(typeof(ModuleType), moduleType), out operation))
{
foreach (FuncPermissionStatus item in operation)
{
if (item.Code == operationCode)
{
isOwn = item.HasPermission;
}
}
}
return isOwn;
}
private void AddLoadableModule(string path, ModuleType type)
{
FileInfo file = new FileInfo(path);
string moduleFullName = file.Name.Remove(file.Name.Length - 4, 4);
string name = "";
if (type == ModuleType.Display)
name = moduleFullName.Remove(0, 8);
else if (type == ModuleType.IO)
name = moduleFullName.Remove(0, 3);
else
throw new NotSupportedException();
ModuleInfo loadableModule = new ModuleInfo();
loadableModule.Name = name;
loadableModule.FullName = moduleFullName;
loadableModule.Type = type;
loadableModule.Path = path;
_moduleList.Add(loadableModule);
}
public static string AddOmittedExtensionToFile(string file, ModuleType type)
{
if (string.IsNullOrEmpty(Path.GetExtension(file)))
{
if (type == ModuleType.Vhdl)
{
return Path.ChangeExtension(file, "vhd");
}
else if (type == ModuleType.Verilog)
{
return Path.ChangeExtension(file, "v");
}
else
{
throw new NotSupportedException("Unsupported ModuleType");
}
}
return file;
}
protected override void OnLoad(EventArgs e) {
base.OnLoad(e);
InitializePeekPanels();
ViewModel.SelectedModuleType = ModuleType.Employees;
<<<<<<< HEAD
var types = new ModuleType[] { ModuleType.Employees, ModuleType.Customers, ModuleType.Products, ModuleType.Orders, ModuleType.Quotes, ModuleType.Dashboards };
=======
var types = new ModuleType[]
{
ModuleType.Employees,
ModuleType.Customers,
ModuleType.Products,
ModuleType.Orders,
ModuleType.Quotes,
ModuleType.DashboardsEdit
};
>>>>>>> 58d5963b05133ab1068392b2084d015cb969dfb8
RegisterNavigationMenuItems(barNavigationItem, types);
RegisterNavPanes(navBar, types);
DevExpress.DevAV.StartUpProcess.Running("Successfully loaded.");
}
public override object GetModuleImage(ModuleType moduleType) {
switch(moduleType) {
case ModuleType.Employees:
case ModuleType.EmployeesFilterPane:
return DevExpress.OutlookInspiredApp.Win.Properties.Resources.icon_nav_employees_32;
case ModuleType.Customers:
case ModuleType.CustomersFilterPane:
return DevExpress.OutlookInspiredApp.Win.Properties.Resources.icon_nav_customers_32;
case ModuleType.Products:
case ModuleType.ProductsFilterPane:
return DevExpress.OutlookInspiredApp.Win.Properties.Resources.icon_nav_products_32;
case ModuleType.Orders:
case ModuleType.OrdersFilterPane:
return DevExpress.OutlookInspiredApp.Win.Properties.Resources.icon_nav_sales_32;
case ModuleType.Quotes:
case ModuleType.QuotesFilterPane:
return DevExpress.OutlookInspiredApp.Win.Properties.Resources.icon_nav_opportunities_32;
case ModuleType.Unknown:
default:
return null;
}
}
public static UserControl GetControl(ModuleType moduleType)
{
switch (moduleType)
{
case ModuleType.UserManager:
return new UserManagerControl();
case ModuleType.RoleManager:
return new RoleManagerControl();
case ModuleType.InstrumentManager:
break;
case ModuleType.QuoationSource:
break;
case ModuleType.QuotePolicy:
break;
case ModuleType.AbnormalQuotation:
break;
case ModuleType.Quote:
return new QutePriceControl();
default:
break;
}
return null;
}
/// <summary>
/// Initialize module info and construct per-module metadata reader.
/// </summary>
/// <param name="moduleHandle">Handle (address) of module to initialize</param>
internal ModuleInfo(IntPtr moduleHandle, ModuleType moduleType)
{
Handle = moduleHandle;
ModuleType = moduleType;
byte* pBlob;
uint cbBlob;
if (RuntimeAugments.FindBlob(moduleHandle, (int)ReflectionMapBlob.EmbeddedMetadata, new IntPtr(&pBlob), new IntPtr(&cbBlob)))
{
MetadataReader = new MetadataReader((IntPtr)pBlob, (int)cbBlob);
}
DynamicModule* dynamicModulePtr = (DynamicModule*)MemoryHelpers.AllocateMemory(sizeof(DynamicModule));
dynamicModulePtr->CbSize = DynamicModule.DynamicModuleSize;
Debug.Assert(sizeof(DynamicModule) >= dynamicModulePtr->CbSize);
#if SUPPORTS_R2R_LOADING
if (moduleType == ModuleType.ReadyToRun)
{
// ReadyToRun modules utilize dynamic type resolution
dynamicModulePtr->DynamicTypeSlotDispatchResolve = Intrinsics.AddrOf(
(Func<IntPtr, IntPtr, ushort, IntPtr>)ReadyToRunCallbacks.ResolveTypeSlotDispatch);
}
else
#endif
{
Debug.Assert(moduleType == ModuleType.Eager);
// Pre-generated modules do not
dynamicModulePtr->DynamicTypeSlotDispatchResolve = IntPtr.Zero;
}
dynamicModulePtr->GetRuntimeException = Intrinsics.AddrOf(
(Func<ExceptionIDs, Exception>)RuntimeExceptionHelpers.GetRuntimeException);
DynamicModulePtr = dynamicModulePtr;
}
public void ShowPeekModule(ModuleType moduleType) {
var peekModuleType = GetPeekModuleType(moduleType);
GetService<IPeekModulesHostingService>().ShowModule(peekModuleType);
}
internal static Patch MakeInsertion(string name, ModuleType type, string module)
=> new Patch(type, name, ChangeType.AddFile,
chunks: new[] { new Chunk {
OldStartLine = 1, NewStartLine = 1, NewText = module
} });
public int AddModuleToPage(TabInfo t, ModuleType type)
{
string DesktopModuleFriendlyName = "";
string ModuleDefFriendlyName = "";
ModuleDefinitionInfo moduleDefinitionInfo = new ModuleDefinitionInfo();
ModuleInfo moduleInfo = new ModuleInfo();
moduleInfo.PortalID = t.PortalID;
moduleInfo.TabID = t.TabID;
moduleInfo.ModuleOrder = 1;
moduleInfo.ModuleTitle = "";
moduleInfo.DisplayPrint = false;
moduleInfo.IsShareable = true;
moduleInfo.IsShareableViewOnly = true;
switch (type)
{
case ModuleType.DisplayPlugg:
moduleInfo.PaneName = "RowTwo_Grid8_Pane";
DesktopModuleFriendlyName = "DisplayPlugg";
ModuleDefFriendlyName = "DisplayPlugg";
break;
case ModuleType.DisplayCourse:
moduleInfo.PaneName = "RowTwo_Grid8_Pane";
DesktopModuleFriendlyName = "DisplayCourse";
ModuleDefFriendlyName = "DisplayCourse";
break;
case ModuleType.CourseMenu:
moduleInfo.PaneName = "RowTwo_Grid4_Pane";
DesktopModuleFriendlyName = "CourseMenu";
ModuleDefFriendlyName = "CourseMenu";
break;
case ModuleType.Rating:
moduleInfo.PaneName = "RowTwo_Grid4_Pane";
DesktopModuleFriendlyName = "DNNCentric RnC";
ModuleDefFriendlyName = "DNNCentric.RatingAndComments";
break;
case ModuleType.Comments:
moduleInfo.PaneName = "RowTwo_Grid8_Pane";
DesktopModuleFriendlyName = "DNNCentric RnC";
ModuleDefFriendlyName = "DNNCentric.RatingAndComments";
break;
case ModuleType.DisplayPluggeTitle:
moduleInfo.PaneName = "RowTwo_Grid4_Pane";
DesktopModuleFriendlyName = "DisplayPluggeTitle";
ModuleDefFriendlyName = "DisplayPluggeTitle";
break;
}
DesktopModuleInfo myModule = null;
foreach (KeyValuePair <int, DesktopModuleInfo> kvp in DesktopModuleController.GetDesktopModules(t.PortalID))
{
DesktopModuleInfo mod = kvp.Value;
if (mod != null)
{
if (mod.FriendlyName == DesktopModuleFriendlyName)
{
myModule = mod;
break;
}
}
}
int moduleId = 0;
if (myModule != null)
{
var mc = new ModuleDefinitionController();
var mInfo = new ModuleDefinitionInfo();
mInfo = ModuleDefinitionController.GetModuleDefinitionByFriendlyName(ModuleDefFriendlyName,
myModule.DesktopModuleID);
moduleInfo.ModuleDefID = mInfo.ModuleDefID;
moduleInfo.CacheTime = moduleDefinitionInfo.DefaultCacheTime; //Default Cache Time is 0
moduleInfo.InheritViewPermissions = true; //Inherit View Permissions from Tab
moduleInfo.AllTabs = false;
moduleInfo.Alignment = "Top";
ModuleController moduleController = new ModuleController();
moduleId = moduleController.AddModule(moduleInfo);
}
DotNetNuke.Common.Utilities.DataCache.ClearModuleCache(t.TabID);
DotNetNuke.Common.Utilities.DataCache.ClearTabsCache(t.PortalID);
DotNetNuke.Common.Utilities.DataCache.ClearPortalCache(t.PortalID, false);
//Add settings for RnC
ModuleController m = new ModuleController();
if (type == ModuleType.Rating)
{
AddModuleSettingsRnCCommon(moduleId);
m.UpdateModuleSetting(moduleId, "PRC_settingCommentObject", "tabid:" + t.TabID);
m.UpdateModuleSetting(moduleId, "PRC_settingShow", "OnlyRatings");
m.UpdateModuleSetting(moduleId, "PRC_settingRncWidth", "357");
}
if (type == ModuleType.Comments)
{
AddModuleSettingsRnCCommon(moduleId);
m.UpdateModuleSetting(moduleId, "PRC_settingCommentObject", "tabid:" + t.TabID);
m.UpdateModuleSetting(moduleId, "PRC_settingShow", "OnlyComments");
m.UpdateModuleSetting(moduleId, "PRC_settingRncWidth", "744");
}
if (type == ModuleType.Rating || type == ModuleType.Comments)
{
RnCController c = new RnCController();
DCC_PRC_CommentObject myCO = new DCC_PRC_CommentObject();
myCO.CommentObject = "tabid:" + t.TabID;
myCO.CommentObjectViewCount = 0;
myCO.PortalID = t.PortalID;
c.CreateCommentObject(myCO);
}
return(moduleId);
}
/// <summary>
/// Base constructor - construct the common features across all commands.
/// </summary>
/// <param name="commandHandlerType"></param>
/// <param name="module"></param>
/// <param name="aliases"></param>
/// <param name="examples"></param>
/// <param name="help"></param>
protected Command(CommandHandlerType commandHandlerType, string[] aliases, string examples, string help, ModuleType module, bool requiresSymbol = true, bool noSetAlias = false)
{
this.CommandHandlerType = commandHandlerType;
this.Aliases = aliases;
this.Examples = examples;
this.Help = help;
this.Module = module;
this.RequiresSymbol = requiresSymbol;
this.NoSetAlias = noSetAlias;
}
/// <summary>
/// Returns the name of the DataEntryContract based on the Module Type and the DefaultNamingConvention.
/// </summary>
public static string GetContractNameForModule(ModuleType module)
{
return(string.Format(DefaultNamingConvention, module.GetDescription()));
}
bool IPeekModulesHostingService.IsDocked(ModuleType moduleType) {
return peekModulesHost.IsDocked(moduleType);
}
public EngineWrapper(ModuleEnginesFX mod)
{
mEFX = mod;
type = ModuleType.MODULEENGINESFX;
}
public bool At(ModuleType moduleType)
{
return(target == moduleType && eta == 0);
}
/// <summary>
/// Respond to the message with a random choice.
/// </summary>
/// <param name="aliases"></param>
/// <param name="choices"></param>
/// <param name="help"></param>
public ResponseMessageCommand(IEnumerable <string> aliases, IEnumerable <string> choices, string examples, string help, ModuleType module, ResponseType responseType, bool requiresSymbol)
: base(CommandHandlerType.ResponseMessage, aliases?.ToArray(), examples, help, module, requiresSymbol)
{
this.choices = choices?.ToArray();
this.responseType = responseType;
}
private object GetModuleCore <TKey>(IDictionary <TKey, WeakReference> cache, TKey key, ModuleType moduleType,
Func <string, object, object> activatorRoutine, object parameter)
{
WeakReference moduleReference;
if (!cache.TryGetValue(key, out moduleReference) || moduleReference.Target == null)
{
var resolver = serviceContainer.GetService <IModuleTypesResolver>();
var module = activatorRoutine(resolver.GetTypeName(moduleType), parameter);
if (moduleReference == null)
{
moduleReference = new WeakReference(module);
cache.Add(key, moduleReference);
}
else
{
moduleReference.Target = module;
}
}
return(moduleReference.Target);
}
private object GetModuleCore(IDictionary <ModuleType, WeakReference> cache, ModuleType moduleType,
Func <string, object, object> activatorRoutine, object parameter)
{
return(GetModuleCore(cache, moduleType, moduleType, activatorRoutine, parameter));
}
public bool IsModuleLoaded(ModuleType moduleType)
{
return(modulesCache.ContainsKey(moduleType));
}
/// <summary>
/// Register all modules which were added (Registered) to the runtime and are not already registered with the TypeLoader.
/// </summary>
/// <param name="moduleType">Type to assign to all new modules.</param>
public void RegisterNewModules(ModuleType moduleType)
{
// prevent multiple threads from registering modules concurrently
using (LockHolder.Hold(_moduleRegistrationLock))
{
// Fetch modules that have already been registered with the runtime
int loadedModuleCount = RuntimeAugments.GetLoadedModules(null);
IntPtr[] loadedModuleHandles = new IntPtr[loadedModuleCount];
int loadedModuleCountUpdated = RuntimeAugments.GetLoadedModules(loadedModuleHandles);
Debug.Assert(loadedModuleCount == loadedModuleCountUpdated);
LowLevelList<IntPtr> newModuleHandles = new LowLevelList<IntPtr>(loadedModuleHandles.Length);
foreach (IntPtr moduleHandle in loadedModuleHandles)
{
// Skip already registered modules.
int oldModuleIndex;
if (_loadedModuleMap.HandleToModuleIndex.TryGetValue(moduleHandle, out oldModuleIndex))
{
continue;
}
newModuleHandles.Add(moduleHandle);
}
// Copy existing modules to new dictionary
int oldModuleCount = _loadedModuleMap.Modules.Length;
ModuleInfo[] updatedModules = new ModuleInfo[oldModuleCount + newModuleHandles.Count];
if (oldModuleCount > 0)
{
Array.Copy(_loadedModuleMap.Modules, 0, updatedModules, 0, oldModuleCount);
}
for (int newModuleIndex = 0; newModuleIndex < newModuleHandles.Count; newModuleIndex++)
{
ModuleInfo newModuleInfo = new ModuleInfo(newModuleHandles[newModuleIndex], moduleType);
updatedModules[oldModuleCount + newModuleIndex] = newModuleInfo;
if (_moduleRegistrationCallbacks != null)
{
_moduleRegistrationCallbacks(newModuleInfo);
}
}
// Atomically update the module map
_loadedModuleMap = new ModuleMap(updatedModules);
}
}
void IPeekModulesHostingService.ShowModule(ModuleType moduleType) {
peekModulesHost.ShowPeek(moduleType);
}
protected string FindModulePath(string name, ModuleType type)
=> ModuleFilePaths.Find(s => string.Equals(_so.PathGetFileName(s), name + ModuleProcessing.ExtensionFromType(type),
StringComparison.OrdinalIgnoreCase));
/// <summary>
/// 构造函数
/// </summary>
/// <param name="moduleType"></param>系统类型
public ModuleBase(ModuleType moduleType)
{
this.ModuleType = moduleType;
msgHanderDic = null;
}
public EngineCoreModuleAttribute(ModuleType moduleType)
{
this.m_moduleType = moduleType;
}
/// <summary>
/// Register all modules which were added (Registered) to the runtime and are not already registered with the TypeLoader.
/// </summary>
/// <param name="moduleType">Type to assign to all new modules.</param>
public void RegisterNewModules(ModuleType moduleType)
{
// prevent multiple threads from registering modules concurrently
using (LockHolder.Hold(_moduleRegistrationLock))
{
// Fetch modules that have already been registered with the runtime
int loadedModuleCount = RuntimeAugments.GetLoadedModules(null);
TypeManagerHandle[] loadedModuleHandles = new TypeManagerHandle[loadedModuleCount];
int loadedModuleCountUpdated = RuntimeAugments.GetLoadedModules(loadedModuleHandles);
Debug.Assert(loadedModuleCount == loadedModuleCountUpdated);
LowLevelList <TypeManagerHandle> newModuleHandles = new LowLevelList <TypeManagerHandle>(loadedModuleHandles.Length);
foreach (TypeManagerHandle moduleHandle in loadedModuleHandles)
{
// Skip already registered modules.
int oldModuleIndex;
if (_loadedModuleMap.HandleToModuleIndex.TryGetValue(moduleHandle, out oldModuleIndex))
{
continue;
}
newModuleHandles.Add(moduleHandle);
}
// Copy existing modules to new dictionary
int oldModuleCount = _loadedModuleMap.Modules.Length;
ModuleInfo[] updatedModules = new ModuleInfo[oldModuleCount + newModuleHandles.Count];
if (oldModuleCount > 0)
{
Array.Copy(_loadedModuleMap.Modules, 0, updatedModules, 0, oldModuleCount);
}
for (int newModuleIndex = 0; newModuleIndex < newModuleHandles.Count; newModuleIndex++)
{
ModuleInfo newModuleInfo;
unsafe
{
byte *pBlob;
uint cbBlob;
if (RuntimeAugments.FindBlob(newModuleHandles[newModuleIndex], (int)ReflectionMapBlob.EmbeddedMetadata, new IntPtr(&pBlob), new IntPtr(&cbBlob)))
{
newModuleInfo = new NativeFormatModuleInfo(newModuleHandles[newModuleIndex], moduleType, (IntPtr)pBlob, (int)cbBlob);
}
else
{
newModuleInfo = new ModuleInfo(newModuleHandles[newModuleIndex], moduleType);
}
}
updatedModules[oldModuleCount + newModuleIndex] = newModuleInfo;
if (_moduleRegistrationCallbacks != null)
{
_moduleRegistrationCallbacks(newModuleInfo);
}
}
// Atomically update the module map
_loadedModuleMap = new ModuleMap(updatedModules);
}
}
public SummaryVehicleModified(Guid identityId, Guid entityId, ModuleType moduleType, string entityType, EventOperation operationType)
: base(identityId, entityId, moduleType, entityType, operationType)
{
}
public string GetModulePath(string name, ModuleType type) => _parent.FindModulePath(name, type);
private List <Guid> GetAgenciesWithViewGranted(ModuleType module)
{
return(GetCurrentIdentity().Permissions.AgencyPermissions.
Where(x => x.DataEntryModulePermissions.Any(y => y.ModuleType == module && y.ViewGranted)).
Select(x => x.AgencyId).ToList());
}
public AdressGetter(ModuleType moduleType, int adress)
{
this.moduleType = moduleType;
this.adress = adress;
}
/// <summary>
/// Initialize module info and construct per-module metadata reader.
/// </summary>
/// <param name="moduleHandle">Handle (address) of module to initialize</param>
internal NativeFormatModuleInfo(TypeManagerHandle moduleHandle, ModuleType moduleType, IntPtr pBlob, int cbBlob) : base(moduleHandle, moduleType)
{
MetadataReader = new MetadataReader((IntPtr)pBlob, (int)cbBlob);
}
internal HelpCommand(CommandController commandController, LanguageHandler languageHandler, string[] aliases, string examples, string help, ModuleType module)
: base(CommandHandlerType.Help, aliases, examples, help, module)
{
this.commandController = commandController;
this.languageHandler = languageHandler;
}
public Module(string name, ModuleType type)
{
this.ModuleName = name;
this.ModuleType = type;
}
public static Expression <Func <Summary, bool> > ByNumber(Guid agencyId, ModuleType moduleType, string number)
{
return(summary => summary.AgencyId == agencyId && summary.ModuleType == moduleType && summary.Number == number);
}
internal ChooseCommand(LanguageHandler languageHandler, string[] aliases, string examples, string help, ModuleType module, string delimiter)
: base(CommandHandlerType.Choose, aliases, examples, help, module)
{
this.languageHandler = languageHandler;
this.delimiter = delimiter;
}
/// <summary>
/// Checks if the module is represent in IoC Container configuration
/// </summary>
/// <param name="moduleTypeType"></param>
/// <returns></returns>
public bool IsModuleActive(ModuleType moduleTypeType)
{
return(this._kernel.HasComponent(string.Concat("module.", moduleTypeType.ClassName)));
}
public bool CanShowPeekModule(ModuleType moduleType) {
var peekModuleType = GetPeekModuleType(moduleType);
return !GetService<IPeekModulesHostingService>().IsDocked(peekModuleType);
}
public void ActivateModule(ModuleType moduleType)
{
//only one thread at a time
System.Threading.Monitor.Enter(lockObject);
string assemblyQualifiedName = moduleType.ClassName + ", " + moduleType.AssemblyName;
if (log.IsDebugEnabled)
{
log.DebugFormat("Loading module {0}.", assemblyQualifiedName);
}
// First, try to get the CLR module type
Type moduleTypeType = Type.GetType(assemblyQualifiedName);
if (moduleTypeType == null)
{
throw new Exception("Could not find module: " + assemblyQualifiedName);
}
try
{
// double check, if we should continue
if (this._kernel.HasComponent(moduleTypeType))
{
// Module is already registered
if (log.IsDebugEnabled)
{
log.DebugFormat("The module with type {0} is already registered in the container.", moduleTypeType.ToString());
}
return;
}
// First, register optional module services that the module might depend on.
foreach (ModuleService moduleService in moduleType.ModuleServices)
{
Type serviceType = Type.GetType(moduleService.ServiceType);
Type classType = Type.GetType(moduleService.ClassType);
if (log.IsDebugEnabled)
{
log.DebugFormat("Loading module service {0}, (1).", moduleService.ServiceKey, moduleService.ClassType);
}
LifestyleType lifestyle = LifestyleType.Singleton;
if (moduleService.Lifestyle != null)
{
try
{
lifestyle = (LifestyleType)Enum.Parse(typeof(LifestyleType), moduleService.Lifestyle);
}
catch (ArgumentException ex)
{
throw new Exception(String.Format("Unable to load module service {0} with invalid lifestyle {1}."
, moduleService.ServiceKey, moduleService.Lifestyle), ex);
}
}
this._kernel.AddComponent(moduleService.ServiceKey, serviceType, classType, lifestyle);
}
//Register the module
string moduleTypeKey = "module." + moduleTypeType.FullName;
this._kernel.AddComponent(moduleTypeKey, moduleTypeType); // no lifestyle because ModuleBase has the Transient attribute.
//Configure NHibernate mappings and make sure we haven't already added this assembly to the NHibernate config
if (typeof(INHibernateModule).IsAssignableFrom(moduleTypeType) && ((HttpContext.Current.Application[moduleType.AssemblyName]) == null))
{
if (log.IsDebugEnabled)
{
log.DebugFormat("Adding module assembly {0} to the NHibernate mappings.", moduleTypeType.Assembly.ToString());
}
this._sessionFactoryHelper.AddAssembly(moduleTypeType.Assembly);
//set application variable to remember the configurated assemblies
HttpContext.Current.Application.Lock();
HttpContext.Current.Application[moduleType.AssemblyName] = moduleType.AssemblyName;
HttpContext.Current.Application.UnLock();
}
if (typeof(IMvcModule).IsAssignableFrom(moduleTypeType))
{
IMvcModule module = this._kernel.Resolve <IMvcModule>(moduleTypeKey);
// Add routes to the routetable if the module supports MVC
module.RegisterRoutes(RouteTable.Routes);
// Register module controllers
this._kernel.Register(AllTypes
.Of(typeof(IController))
.FromAssembly(moduleTypeType.Assembly)
.Configure(c => c.LifeStyle.Transient));
}
// Register model validators for modules
this._kernel.Register(AllTypes
.Of <IModelValidator>()
.FromAssembly(moduleTypeType.Assembly)
.Configure(c => c.LifeStyle.Transient));
}
finally
{
System.Threading.Monitor.Exit(lockObject);
}
} //end method
/// <summary>
/// The actual function that needs to be overriden (instead of SetDefaults) since
/// visuals will be handled automatically then.
/// </summary>
protected virtual void SetModuleData()
{
item.name = "Module Base";
item.width = 20;
item.height = 20;
item.toolTip = "A standard issue Module without functionality";
item.value = Item.buyPrice(0, 0, 0, 0);
item.rare = -1;
this.moduleType = ModuleType.None;
}
public EngineWrapper(ModuleEngines mod)
{
mE = mod;
type = ModuleType.MODULEENGINES;
}
private void LoadXml(XmlElement xmlElement)
{
Type = xmlElement.GetAttributeValue("id").ToModuleType();
}
public ReportDrugModified(Guid identityId, Guid entityId, ModuleType moduleType, string entityType, EventOperation operationType)
: base(identityId, entityId, moduleType, entityType, operationType)
{
}
void IPeekModulesHostingService.UndockModule(ModuleType moduleType) {
peekModulesHost.UndockModule(moduleType);
}
public void SelectModule(ModuleType type)
{
SelectedModuleType = type;
}
public bool CheckPermissions(ModuleType type, int operationId)
{
return this._AccessPermissions.Contains(new AccessPermission(type, operationId));
}
public bool CanSelectModule(ModuleType type)
{
return(type != SelectedModuleType);
}
