//-----------------------------------------------------------------------------------------------------------------------------------------------------
protected virtual TestFactory CreateTestFactory(
DynamicModule module,
ClassType classType,
Func <TypeKey, ClassWriterBase> classDefinitionCallback)
{
return(new TestFactory(module, classType, classDefinitionCallback));
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
protected void InitializeTestClass()
{
m_Module = new DynamicModule(
"EmittedBy" + this.GetType().Name,
allowSave: this.ShouldSaveAssembly,
saveDirectory: TestDirectory);
}
public void TestFixtureSetUp()
{
m_Module = new DynamicModule(
simpleName: "Hapil.UnitTests.EmittedByObjectFactoryBaseTests",
allowSave: true,
saveDirectory: TestContext.CurrentContext.TestDirectory);
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
protected override TypeBuilder CreateTypeBuilder(DynamicModule module, string classFullName, Type baseType, ClassType containingClass)
{
return(containingClass.TypeBuilder.DefineNestedType(
containingClass.TakeMemberName(classFullName, mustUseThisName: false),
TypeAttributes.NestedPrivate,
baseType));
}
//-------------------------------------------------------------------------------------------------------------------------------------------------
public TestFactory(
DynamicModule module,
ClassType classType,
Func <TypeKey, ClassWriterBase> classDefinitionCallback)
: base(module)
{
m_ClassType = classType;
m_ClassDefinitionCallback = classDefinitionCallback;
}
public void FixtureSetUp()
{
m_Module = new DynamicModule(
"Hapil.UnitTests.EmittedBy" + this.GetType().Name,
allowSave: true,
saveDirectory: TestContext.CurrentContext.TestDirectory);
m_Factory = new XTupleFactory(m_Module);
}
private static Type CreateCustomType(int size)
{
var attrs = TypeAttributes.NotPublic | TypeAttributes.SequentialLayout;
TypeBuilder type = DynamicModule.DefineType("VariantArray" + size, attrs, typeof(ValueType));
for (int i = 0; i < size; i++)
{
type.DefineField("Element" + i, typeof(Variant), FieldAttributes.Public);
}
return(type.CreateType());
}
public Type CreateType(AssemblyBuilder assemblyBuilder, string moduleName)
{
var module = new DynamicModule(assemblyBuilder.DefineDynamicModule(moduleName));
if (additionalTypes != null)
{
foreach (var additionalType in additionalTypes)
{
additionalType.InnerCreateType(module);
}
}
return(InnerCreateType(module));
}
public SelectionForm(Core core, SelectionMode mode, DynamicModule dz)
{
this.core = core;
this.mode = mode;
this.dz = dz;
InitializeComponent();
switch (mode)
{
case SelectionMode.MODE_STRATEGY:
// initialize wizard set
ws = new WizardSet();
tb = ((WizardSet)ws).WizardTable;
// update selection-type strings
mode_name = "Strategy";
moreOptionsLabel.Visible = true;
moreOptionsGroupBox.Visible = true;
moreOptionsButton.Visible = true;
break;
case SelectionMode.MODE_INDICATOR:
// initialize indicator set
ws = new IndicatorSet();
tb = ((IndicatorSet)ws).IndicatorTable;
// update selection-type strings
mode_name = "Indicator";
moreOptionsLabel.Visible = false;
moreOptionsGroupBox.Visible = false;
moreOptionsButton.Visible = false;
break;
}
Text = Text.Replace("<selection-type>", mode_name);
selectionLabel.Text = selectionLabel.Text.Replace("<selection-type>", mode_name);
// initialize strategy list
listComboBox.Items.Clear();
listComboBox.Items.Add("");
ArrayList list = dz.GetList();
foreach (string s in list)
{
listComboBox.Items.Add(s);
}
// load saved config
LoadConfig();
}
/// <summary>
/// Installs the default detail template.
/// </summary>
/// <param name="dynamicModule">The dynamic module.</param>
/// <param name="moduleType">Type of the module.</param>
/// <returns></returns>
public Guid InstallDetailTemplate(DynamicModule dynamicModule, DynamicModuleType moduleType)
{
var moduleTitle = dynamicModule.Title;
var area = string.Format(MvcConstants.DynamicAreaFormat, moduleTitle, moduleType.DisplayName);
var pluralModuleTypeName = PluralsResolver.Instance.ToPlural(moduleType.DisplayName);
var dynamicTypeName = moduleType.GetFullTypeName();
var condition = string.Format(MvcConstants.MvcTemplateCondition, dynamicTypeName);
var controlType = typeof(DynamicContentController).FullName;
var detailTemplateName = string.Format(MvcConstants.DetailTemplateName, moduleType.DisplayName);
var friendlyControlDetail = string.Format(MvcConstants.FriendlyControlDynamicDetailTemplate, moduleTitle, pluralModuleTypeName);
var nameForDevelopersDetail = detailTemplateName.Replace('.', '-');
var content = this.GenerateDetailTemplate(moduleType);
var detailTemplate = this.RegisteredTemplate(area, detailTemplateName, nameForDevelopersDetail, friendlyControlDetail, content, condition, controlType);
return(detailTemplate.Id);
}
internal List<ExplorerItem> GetSchemaAndBuildAssembly(
ConnectionProperties connectionProperties,
AssemblyName assemblyToBuild,
ref string nameSpace,
ref string typeName)
{
var simpleName = Path.GetFileNameWithoutExtension(assemblyToBuild.CodeBase);
var module = new DynamicModule(simpleName, allowSave: true, saveDirectory: Path.GetDirectoryName(assemblyToBuild.CodeBase));
var model = ODataClientContextBase.LoadModelFromService(new Uri(connectionProperties.Uri + "/$metadata"));
var factory = new ODataClientContextFactory(module);
var generatedType = factory.ImplementClientContext(model);
nameSpace = generatedType.Namespace;
typeName = generatedType.Name;
module.SaveAssembly();
return BuildSchema(model);
}
/// <summary>
/// Gets the toolbox section where the dynamic widget will be placed.
/// </summary>
/// <param name="dynamicModule">The dynamic module.</param>
/// <param name="toolboxesConfig">The toolboxes configuration.</param>
/// <returns></returns>
private static ToolboxSection GetModuleToolboxSection(DynamicModule dynamicModule, ToolboxesConfig toolboxesConfig)
{
var pageControls = toolboxesConfig.Toolboxes["PageControls"];
var moduleSectionName = string.Concat(DynamicModuleType.defaultNamespace, ".", MvcWidgetInstaller.moduleNameValidationRegex.Replace(dynamicModule.Name, string.Empty));
ToolboxSection section = pageControls.Sections.Where <ToolboxSection>(e => e.Name == moduleSectionName).FirstOrDefault();
if (section == null)
{
var sectionDescription = string.Format(MvcWidgetInstaller.ModuleSectionDescription, dynamicModule.GetTitle());
section = new ToolboxSection(pageControls.Sections)
{
Name = moduleSectionName,
Title = dynamicModule.Title,
Description = sectionDescription
};
pageControls.Sections.Add(section);
}
return(section);
}
public int Include(params string[] moduleNames)
{
if (LoadedModules == null)
{
return(-1);
}
int c = 0;
foreach (var str in moduleNames)
{
var module = new DynamicModule <IAutoquitModule>(str);
if (!module.IsValid)
{
continue;
}
_cacheModules.Add(module);
_moduleNames.Add(str.Replace(".dll", string.Empty));
c++;
}
File.WriteAllLines(_configPath, moduleNames);
return(c);
}
/// <summary>
/// Installs the default detail template.
/// </summary>
/// <param name="dynamicModule">The dynamic module.</param>
/// <param name="moduleType">Type of the module.</param>
/// <returns></returns>
public Guid InstallDetailTemplate(DynamicModule dynamicModule, DynamicModuleType moduleType)
{
var moduleTitle = dynamicModule.Title;
var area = string.Format(MvcConstants.DynamicAreaFormat, moduleTitle, moduleType.DisplayName);
var pluralModuleTypeName = PluralsResolver.Instance.ToPlural(moduleType.DisplayName);
var dynamicTypeName = moduleType.GetFullTypeName();
var condition = string.Format(MvcConstants.MvcTemplateCondition, dynamicTypeName);
var controlType = typeof(DynamicContentController).FullName;
var detailTemplateName = string.Format(MvcConstants.DetailTemplateName, moduleType.DisplayName);
var friendlyControlDetail = string.Format(MvcConstants.FriendlyControlDynamicDetailTemplate, moduleTitle, pluralModuleTypeName);
var nameForDevelopersDetail = detailTemplateName.Replace('.', '-');
var content = this.GenerateDetailTemplate(moduleType);
var detailTemplate = this.RegisteredTemplate(area, detailTemplateName, nameForDevelopersDetail, friendlyControlDetail, content, condition, controlType);
Type dynamicType = Telerik.Sitefinity.Utilities.TypeConverters.TypeResolutionService.ResolveType(moduleType.GetFullTypeName(), false);
ControlTemplates.RegisterTemplatableControl(typeof(DynamicContentController), dynamicType, null, area, string.Format("{0} - single", area));
return(detailTemplate.Id);
}
/// <summary>
/// 复制动态模块
/// </summary>
/// <param name="NewID">新的编号</param>
/// <param name="OldID">老的编号</param>
public void CopyDynamicModules(Int32 NewID, Int32 OldID)
{
//找到动态模块老数据
var DynamicModules = Playngo_ClientZone_DynamicModule.FindListByFilter(OldID, (Int32)EnumDynamicModuleType.GameSheet, ModuleId);
if (DynamicModules != null && DynamicModules.Count > 0)
{
foreach (var DynamicModule in DynamicModules)
{
//查找动态项老数据
var DynamicItems = Playngo_ClientZone_DynamicItem.FindListByFilter(DynamicModule.ID, ModuleId);
//构造新的动态模块
var DynamicModuleNew = DynamicModule.Clone() as Playngo_ClientZone_DynamicModule;
DynamicModuleNew.ID = 0;
DynamicModuleNew.LinkID = NewID;
DynamicModuleNew.LastTime = xUserTime.UtcTime();
DynamicModuleNew.LastIP = WebHelper.UserHost;
DynamicModuleNew.LastUser = UserId;
DynamicModuleNew.ID = DynamicModuleNew.Insert();
if (DynamicModuleNew.ID > 0 && DynamicItems != null && DynamicItems.Count > 0)
{
foreach (var DynamicItem in DynamicItems)
{
//构造性的动态项
var DynamicItemNew = DynamicItem.Clone() as Playngo_ClientZone_DynamicItem;
DynamicItemNew.ID = 0;
DynamicItemNew.DynamicID = DynamicModuleNew.ID;
DynamicItemNew.LastTime = xUserTime.UtcTime();
DynamicItemNew.LastIP = WebHelper.UserHost;
DynamicItemNew.LastUser = UserId;
DynamicItemNew.Insert();
}
}
}
}
}
/// <summary>
/// 删除数据所关联的所有动态模块项
/// </summary>
/// <param name="LinkID"></param>
/// <param name="ModuleId"></param>
/// <param name="DynamicType"></param>
/// <returns></returns>
public static Int32 DeleteAll(Int32 LinkID, Int32 ModuleId, Int32 DynamicType)
{
int RecordCount = 0;
var DynamicModules = FindListByFilter(LinkID, DynamicType, ModuleId);
if (DynamicModules != null && DynamicModules.Count > 0)
{
foreach (var DynamicModule in DynamicModules)
{
if (DynamicModule.Delete() > 0)
{
RecordCount++;
QueryParam qp = new QueryParam();
qp.Where.Add(new SearchParam(Playngo_ClientZone_DynamicItem._.DynamicID, DynamicModule.ID, SearchType.Equal));
qp.Where.Add(new SearchParam(Playngo_ClientZone_DynamicItem._.ModuleId, ModuleId, SearchType.Equal));
RecordCount += Playngo_ClientZone_DynamicItem.Delete(qp);
}
}
}
return(RecordCount);
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
protected ClassType(DynamicModule module, TypeKey key, string classFullName, Type baseType, ClassType containingClass)
{
var resolvedBaseType = TypeTemplate.Resolve(baseType);
m_Key = key;
m_Module = module;
m_Writers = new List <ClassWriterBase>();
m_Members = new List <MemberBase>();
m_MembersByDeclarations = new Dictionary <MemberInfo, MemberBase>();
m_MembersByName = new Dictionary <string, MemberBase>();
m_FactoryMethods = new List <MethodInfo>();
m_MemberNames = new UniqueNameSet();
m_NotImplementedMembers = new HashSet <MemberInfo>();
m_NotImplementedMembers.UnionWith(TypeMemberCache.Of(resolvedBaseType).ImplementableMembers);
m_CompiledType = null;
m_DependencyFields = new List <FieldMember>();
m_NestedClasses = new List <NestedClassType>();
//m_TypeBuilder = module.ModuleBuilder.DefineType(classFullName, DefaultTypeAtributes, resolvedBaseType);
// ReSharper disable once DoNotCallOverridableMethodsInConstructor
m_TypeBuilder = CreateTypeBuilder(module, classFullName, resolvedBaseType, containingClass);
}
private static void Install(DynamicModule module, DynamicModuleType type, string transactionName)
{
MvcWidgetInstaller.RegisterTemplates(module, type, transactionName);
MvcWidgetInstaller.RegisterToolboxItem(module, type);
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
internal ClassType(DynamicModule module, TypeKey key, string classFullName, Type baseType)
: this(module, key, classFullName, baseType, containingClass : null)
{
}
public WizardMath(WizardSet[] ws, Core core, DynamicModule dz)
{
this.core = core;
this.ws = ws;
this.dz = dz;
}
public MarkerInterfaceFactory(DynamicModule module)
: base(module)
{
}
private Type InnerCreateType(DynamicModule module)
{
Type result;
if (module.CreatedTypes.TryGetValue(name, out result))
{
return(result);
}
TypeBuilder typeBuilder = null;
switch (type)
{
case KindOfDynamicType.Struct:
typeBuilder = module.Builder.DefineType(name,
TypeAttributes.Public |
TypeAttributes.Sealed |
TypeAttributes.SequentialLayout |
TypeAttributes.Serializable,
typeof(ValueType));
break;
case KindOfDynamicType.Interface:
typeBuilder = module.Builder.DefineType(name, TypeAttributes.Interface | TypeAttributes.Public | TypeAttributes.Abstract);
break;
case KindOfDynamicType.Class:
typeBuilder = module.Builder.DefineType(name, TypeAttributes.Class | TypeAttributes.Public);
if (genericArgument != null)
{
typeBuilder.DefineGenericParameters(new [] { "TFirst" });
}
break;
}
if (baseClass != null)
{
typeBuilder.SetParent(baseClass.InnerCreateType(module));
}
foreach (var field in fields)
{
if (field.Value.DynamicType != null && field.Value.Type == null)
{
field.Value.Type = field.Value.DynamicType.InnerCreateType(module);
}
var fBldr = typeBuilder.DefineField(field.Key, field.Value.Type, FieldAttributes.Public);
if (field.Value.IsTransient)
{
var taC = typeof(TransientAttribute).GetConstructor(System.Type.EmptyTypes);
fBldr.SetCustomAttribute(new CustomAttributeBuilder(taC, new object[0]));
}
if (field.Value.IsConstructor)
{
var taC = typeof(ConstructorAttribute).GetConstructors()[0];
fBldr.SetCustomAttribute(new CustomAttributeBuilder(taC, new object[] { new object[0] }));
}
}
result = typeBuilder.CreateType();
if (genericArgument != null)
{
result = result.MakeGenericType(genericArgument.InnerCreateType(module));
}
module.CreatedTypes[name] = result;
return(result);
}
public void FixtureSetUp()
{
m_Module = new DynamicModule(
"Hapil.UnitTests.EmittedBy" + this.GetType().Name,
allowSave: false);
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
protected virtual TypeBuilder CreateTypeBuilder(DynamicModule module, string classFullName, Type baseType, ClassType containingClass)
{
return(module.ModuleBuilder.DefineType(classFullName, DefaultTypeAtributes, baseType));
}
public ODataClientEntityFactory(DynamicModule module)
: base(module, new ODataClientEntityConvention())
{
}
/// <summary>
/// Gets the toolbox section where the dynamic widget will be placed.
/// </summary>
/// <param name="dynamicModule">The dynamic module.</param>
/// <param name="toolboxesConfig">The toolboxes configuration.</param>
/// <returns></returns>
private static ToolboxSection GetModuleToolboxSection(DynamicModule dynamicModule, ToolboxesConfig toolboxesConfig)
{
var pageControls = toolboxesConfig.Toolboxes["PageControls"];
var moduleSectionName = string.Concat(DynamicModuleType.defaultNamespace, ".", MvcWidgetInstaller.moduleNameValidationRegex.Replace(dynamicModule.Name, string.Empty));
ToolboxSection section = pageControls.Sections.Where<ToolboxSection>(e => e.Name == moduleSectionName).FirstOrDefault();
if (section == null)
{
var sectionDescription = string.Format(MvcWidgetInstaller.ModuleSectionDescription, dynamicModule.GetTitle());
section = new ToolboxSection(pageControls.Sections)
{
Name = moduleSectionName,
Title = dynamicModule.Title,
Description = sectionDescription
};
pageControls.Sections.Add(section);
}
return section;
}
public EmptyObjectFactory(DynamicModule module)
: base(module)
{
}
private static void Install(DynamicModule module, DynamicModuleType type, string transactionName)
{
MvcWidgetInstaller.RegisterTemplates(module, type, transactionName);
MvcWidgetInstaller.RegisterToolboxItem(module, type);
}
public ODataClientContextFactory(DynamicModule module)
: base(module, new ODataClientContextConvention(module))
{
}
public XTupleFactory(DynamicModule module)
: base(module)
{
}
//-------------------------------------------------------------------------------------------------------------------------------------------------
public ODataClientContextConvention(DynamicModule module)
: base(Will.InspectDeclaration | Will.ImplementBaseClass)
{
_entityFactory = new ODataClientEntityFactory(module);
}
