public async Task PositionalOnly()
{
const string code = @"
x = 'str'
class C:
x: int
def __init__(self):
self.y = 1
def method(self, x, /, y=True):
return func()
@property
def prop(self) -> int:
return x
def func():
return 2.0
c = C()
";
var analysis = await GetAnalysisAsync(code, PythonVersions.Required_Python38X);
var model = ModuleModel.FromAnalysis(analysis, Services, AnalysisCachingLevel.Library);
using (var dbModule = CreateDbModule(model, analysis.Document.FilePath)) {
dbModule.Should().HaveSameMembersAs(analysis.Document);
}
}
internal async Task CompareBaselineAndRestoreAsync(ModuleModel model, IPythonModule m)
{
//var json = ToJson(model);
//Baseline.CompareToFile(BaselineFileName, json);
// In real case dependency analysis will restore model dependencies.
// Here we don't go through the dependency analysis so we have to
// manually restore dependent modules.
var dc = new DependencyCollector(m);
dc.AddImports(model.Imports);
dc.AddFromImports(model.FromImports);
foreach (var dep in dc.Dependencies)
{
m.Interpreter.ModuleResolution.GetOrLoadModule(dep.Name);
}
var dcs = new DependencyCollector(m, true);
dcs.AddImports(model.StubImports);
dcs.AddFromImports(model.StubFromImports);
foreach (var dep in dcs.Dependencies)
{
m.Interpreter.TypeshedResolution.GetOrLoadModule(dep.Name);
}
var analyzer = Services.GetService <IPythonAnalyzer>();
await analyzer.WaitForCompleteAnalysisAsync();
using (var dbModule = CreateDbModule(model, m.FilePath)) {
dbModule.Should().HaveSameMembersAs(m);
}
}
public IActionResult Update([FromBody] ModuleModel model)
{
// Save module
ModuleInfo module = new ModuleInfo();
module.ModuleId = model.Id;
module.ModuleDefId = model.DefinitionId;
module.PageId = model.PageId;
module.PlaceId = model.PlaceId;
module.Name = model.Name;
module.IsDisabled = model.IsDisabled;
_viewManager.SaveModule(module);
// Handle static module
if (model.IsStatic)
{
PlaceInfo place = _viewManager.GetPlace(model.PlaceId);
place.ModuleId = module.ModuleId;
_viewManager.SavePlace(place);
}
else if (model.Id > 0)
{
PlaceInfo place = _viewManager.GetPlace(model.PlaceId);
if (place.ModuleId == module.ModuleId)
{
place.ModuleId = null;
_viewManager.SavePlace(place);
}
}
#region Permissions
ModulePermissionInfo modulePermission = null;
IList <ModulePermissionInfo> modulePermissions = _securityManager.GetModulePermissionsByModuleId(module.ModuleId);
IList <PermissionInfo> permissions = _securityManager.GetPermissionsList();
foreach (var permission in permissions)
{
if (model.Permissions.Contains(permission.PermissionId) &&
!modulePermissions.Any(mp => mp.PermissionId == permission.PermissionId))
{
modulePermission = new ModulePermissionInfo();
modulePermission.ModuleId = module.ModuleId;
modulePermission.PermissionId = permission.PermissionId;
_securityManager.SaveModulePermission(modulePermission);
}
else if (!model.Permissions.Contains(permission.PermissionId) &&
modulePermissions.Any(mp => mp.PermissionId == permission.PermissionId))
{
_securityManager.DeleteModulePermission(module.ModuleId, permission.PermissionId);
}
}
#endregion
return(Ok(new { module.ModuleId }));
}
/// <summary>
/// Constructs module global scope. This is separate from regular constructor
/// in order to better handle reentrancy due to circular references
/// in the module factory.
/// </summary>
public void Construct(ModuleModel model)
{
var rs = new RestoredGlobalScope(model, this, Services);
GlobalScope = rs;
rs.Construct(model, Services);
}
public ActionResult Add(ModuleModel module)
{
try
{
if (this.ModelState.IsValid)
{
using (xinyuedbEntities db = new xinyuedbEntities())
{
db.Modules.Add(new Module
{
name = module.name,
degree = module.degree,
year = module.year,
semester = module.semester
});
db.SaveChanges();
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
return(this.RedirectToAction("Index"));
}
public IActionResult AddModule(int id, ModuleModel model)
{
StudentProcessor.AddModuleToStudent(id, Convert.ToInt32(model.Title));
string url = $"../AddModule/{id}";
return(Redirect(url));
}
/// <summary>
/// GetSiteFeatures
/// </summary>
/// <param name="siteId"></param>
/// <returns></returns>
public SiteFeaturesModel GetSiteFeaturesSettings(int siteId)
{
SiteFeaturesModel siteFeatureModel = new SiteFeaturesModel();
ServiceResponse <SiteFeatures> siteFeaturesResponse = _securityProxy.Execute(opt => opt.GetSiteFeaturesSettings(siteId));
if (siteFeaturesResponse.Status == ResponseStatus.Success)
{
siteFeatureModel.SiteId = siteFeaturesResponse.Result.SiteId;
siteFeatureModel.SiteCode = siteFeaturesResponse.Result.SiteCode;
siteFeatureModel.SiteName = siteFeaturesResponse.Result.SiteName;
foreach (ModuleDC module in siteFeaturesResponse.Result.Features)
{
ModuleModel moduleModel = Mapper.Map <ModuleDC, ModuleModel>(module);
moduleModel.ModuleFeatures = new List <ModuleFeatureModel>();
foreach (ModuleFeatureDC feature in module.Features)
{
ModuleFeatureModel featureModel = Mapper.Map <ModuleFeatureDC, ModuleFeatureModel>(feature);
featureModel.SiteContentSettings = new List <SiteContentSettingModel>();
foreach (SiteContentSettingDC siteContentSetting in feature.SiteContentSettings)
{
featureModel.SiteContentSettings.Add(Mapper.Map <SiteContentSettingDC, SiteContentSettingModel>(siteContentSetting));
}
moduleModel.ModuleFeatures.Add(featureModel);
}
siteFeatureModel.Features.Add(moduleModel);
}
}
else
{
HandleError(siteFeaturesResponse.Status, siteFeaturesResponse.ResponseMessage);
}
return(siteFeatureModel);
}
public void Construct(ModuleModel model)
{
var gs = new RestoredGlobalScope(model, this);
GlobalScope = gs;
gs.ReconstructVariables();
}
private async void btnSave_Click(object sender, EventArgs e)
{
if (Prompt.Question("Are you sure to save the current record?", this.Text) == DialogResult.Yes)
{
if (AreValidEntries())
{
var item = new ModuleModel
{
ModuleId = txtId.Text.Length > 0 ? int.Parse(txtId.Text) : 0,
Code = txtCode.Text,
Description = txtDescription.Text,
Type = cboTypes.SelectedValue.ToString(),
};
var result = await services.Save(item);
if (result.Contains("successfully"))
{
Prompt.Information(result, this.Text);
ClearFields();
EnableFields(false);
LoadAllRecords();
EnableButtons(OperationType.Default);
isNew = false;
}
else
{
Prompt.Error(result, this.Text);
}
}
}
}
public OperationResult Update(ModuleModel model)
{
var entity = new Module
{
Id = model.Id,
Name = model.Name,
Code = model.Code,
ParentId = model.ParentId != 0 ? model.ParentId : null,
LinkUrl = model.LinkUrl,
Area = model.Area,
Controller = model.Controller,
Action = model.Action,
OrderSort = model.OrderSort,
Icon = model.Icon != null ? model.Icon : "",
Enabled = model.Enabled,
IsMenu = model.IsMenu,
CreateId = model.CreateId,
CreateBy = model.CreateBy,
CreateTime = DateTime.Now,
ModifyId = model.ModifyId,
ModifyBy = model.ModifyBy,
ModifyTime = DateTime.Now
};
ModuleRepository.Update(entity);
return(new OperationResult(OperationResultType.Success, "更新成功"));
}
public async Task Requests()
{
const string code = @"
import requests
x = requests.get('microsoft.com')
";
var analysis = await GetAnalysisAsync(code, PythonVersions.LatestAvailable3X);
var v = analysis.GlobalScope.Variables["requests"];
v.Should().NotBeNull();
if (v.Value.GetPythonType <IPythonModule>().ModuleType == ModuleType.Unresolved)
{
Assert.Inconclusive("'requests' package is not installed.");
}
var rq = analysis.Document.Interpreter.ModuleResolution.GetImportedModule("requests");
var model = ModuleModel.FromAnalysis(rq.Analysis, Services, AnalysisCachingLevel.Library);
var u = model.UniqueId;
u.Should().Contain("(").And.EndWith(")");
var open = u.IndexOf('(');
// Verify this looks like a version.
new Version(u.Substring(open + 1, u.IndexOf(')') - open - 1));
await CompareBaselineAndRestoreAsync(model, rq);
}
public OperationResult Insert(ModuleModel model)
{
var entity = new Module
{
Name = model.Name,
Code = model.Code,
ParentId = model.ParentId,
LinkUrl = model.LinkUrl,
Area = model.Area,
Controller = model.Controller,
Action = model.Action,
OrderSort = model.OrderSort,
IsDeleted = false,
PermissionIds = new List <string>(),
Icon = model.Icon != null ? model.Icon : "",
IsMenu = model.IsMenu,
Enabled = model.Enabled
};
this.CreateBaseData <Module>(entity, model);
HpMongoContext.Save(entity);
CacheHelper.RemoveAllCache("Module");
return(new OperationResult(OperationResultType.Success, "添加成功"));
}
internal ModuleImpl( ApplicationValidationResultIQ validationResult, DictionaryQuery<CompositeModel, PublicCompositeTypeGenerationResult> loadingResults, LayerImpl layer, ModuleModel model )
{
ArgumentValidator.ValidateNotNull( "Layer instance", layer );
ArgumentValidator.ValidateNotNull( "Module model", model );
this._layer = layer;
this._moduleModel = model;
this._serviceContainer = new ThreadsafeServiceContainer();
this._modelInfoContainer = new ModelInfoContainerImpl(
layer.InternalApplication.ModelTypeSupportInternal,
model.CompositeModelsInThisContainer,
validationResult,
loadingResults,
layer.Application.CollectionsFactory,
model.LayerModel.ApplicationModel.GenericPropertyMixinType,
model.LayerModel.ApplicationModel.GenericEventMixinType
);
#if SILVERLIGHT
this._compositeTypeLookupCache = new Dictionary<CompositeModelType, IDictionary<Type[], Tuple<CompositeInstanceStructureOwner, CompositeModel>>>();
#else
this._compositeTypeLookupCache = new System.Collections.Concurrent.ConcurrentDictionary<CompositeModelType, System.Collections.Concurrent.ConcurrentDictionary<Type[], Tuple<CompositeInstanceStructureOwner, CompositeModel>>>();
#endif
this._serviceProvider = new StructureServiceProviderImpl(
this,
layer.InternalApplication.ModelTypeSupportInternal,
matcher => this.FindVisibleModels( matcher )
);
}
protected override void ConfigureModuleCatalog(IModuleCatalog moduleCatalog)
{
DirectoryModuleCatalog directoryCatalog = (DirectoryModuleCatalog)moduleCatalog;
directoryCatalog.Initialize();
moduleCollection = new ObservableCollection <ModuleModel>();
TypeFilter typeFilter = new TypeFilter(InterfaceFilter);
foreach (IModuleCatalogItem item in directoryCatalog.Items)
{
ModuleInfo mi = (ModuleInfo)item;
// in .NetFrameWork we dont need to replace
Assembly asm = Assembly.LoadFrom(mi.Ref.Replace(@"file:///", ""));
foreach (Type t in asm.GetTypes())
{
Type[] myInterfaces = t.FindInterfaces(typeFilter, typeof(IModuleService).ToString());
if (myInterfaces.Length > 0)
{
IModuleService moduleService = (IModuleService)asm.CreateInstance(t.FullName);
ModuleModel module = moduleService.GetModule();
moduleCollection.Add(module);
}
}
}
}
/// <summary>
/// GetRoleFeatures
/// </summary>
/// <param name="roleId"></param>
/// <returns>RoleFeaturesModel</returns>
public RoleFeaturesModel GetRoleFeatures(int roleId)
{
RoleFeaturesModel roleFeatures = new RoleFeaturesModel();
ServiceResponse <RoleFeatures> roleFeaturesResponse = _securityProxy.Execute(opt => opt.GetRoleFeatures(roleId));
if (roleFeaturesResponse.Status == ResponseStatus.Success)
{
roleFeatures.RoleId = roleFeaturesResponse.Result.RoleId;
roleFeatures.RoleCode = roleFeaturesResponse.Result.RoleCode;
roleFeatures.RoleName = roleFeaturesResponse.Result.RoleName;
roleFeatures.Features = new List <ModuleModel>();
foreach (ModuleDC moduleDC in roleFeaturesResponse.Result.Features)
{
ModuleModel module = Mapper.Map <ModuleDC, ModuleModel>(moduleDC);
roleFeatures.Features.Add(module);
module.ModuleFeatures = new List <ModuleFeatureModel>();
foreach (ModuleFeatureDC feature in moduleDC.Features)
{
ModuleFeatureModel featureModel = Mapper.Map <ModuleFeatureDC, ModuleFeatureModel>(feature);
module.ModuleFeatures.Add(featureModel);
featureModel.RoleFeaturePermissions = new List <FeaturePermissionModel>();
foreach (FeaturePermissionDC featurePermission in feature.RoleFeaturePermissions)
{
featureModel.RoleFeaturePermissions.Add(Mapper.Map <FeaturePermissionDC, FeaturePermissionModel>(featurePermission));
}
}
}
}
else
{
HandleError(roleFeaturesResponse.Status, roleFeaturesResponse.ResponseMessage);
}
return(roleFeatures);
}
public ActionResult Create([Bind(Include = "Name,Description,StartDate,EndDate")] CreateModuleViewModel moduleModel, int?id)
{
if (ModelState.IsValid && id != null)
{
var course = db.Courses.FirstOrDefault(c => c.Id == id);
if (course == null)
{
return(HttpNotFound());
}
var module = new ModuleModel {
Course = course,
Name = moduleModel.Name,
Description = moduleModel.Description,
StartDate = moduleModel.StartDate,
EndDate = moduleModel.EndDate,
};
db.Modules.Add(module);
db.SaveChanges();
return(RedirectToAction("Overview", "Course", new { id }));
}
return(View(moduleModel));
}
private bool TryGetModuleModel(string moduleName, string dbPath, out ModuleModel model)
{
model = null;
if (string.IsNullOrEmpty(dbPath))
{
return(false);
}
if (_modelsCache.TryGetValue(moduleName, out model))
{
return(true);
}
model = WithRetries.Execute(() => {
using (var db = new LiteDatabase(dbPath)) {
var modules = db.GetCollection <ModuleModel>("modules");
var storedModel = modules.FindOne(m => m.Name == moduleName);
_modelsCache[moduleName] = storedModel;
return(storedModel);
}
}, $"Unable to locate database for module {moduleName}.", _log);
return(model != null);
}
public ActionResult Edit(ModuleModel model)
{
if (ModelState.IsValid)
{
this.UpdateBaseData <ModuleModel>(model);
if (!string.IsNullOrEmpty(model.LinkUrl) && model.LinkUrl.Split('/').Length == 3)
{
string[] link = model.LinkUrl.Split('/');
model.Area = link[0];
model.Controller = link[1];
model.Action = link[2];
}
OperationResult result = ModuleService.Update(model);
if (result.ResultType == OperationResultType.Success)
{
return(Json(result));
}
else
{
InitParentModule(model);
return(PartialView(model));
}
}
else
{
InitParentModule(model);
return(PartialView(model));
}
}
public UnrealTournamentViewModel(MainManager mainManager,
[Named(nameof(UnrealTournamentModel))] ModuleModel moduleModel, IKernel kernel)
: base(mainManager, moduleModel, kernel)
{
DisplayName = "Unreal Tournament";
InstallGif();
}
public ActionResult Edit(ModuleModel updatedModule)
{
try
{
if (this.ModelState.IsValid)
{
using (xinyuedbEntities db = new xinyuedbEntities())
{
var module = db.Modules.SingleOrDefault(x => x.moduleId == updatedModule.moduleId);
if (module != null)
{
module.name = updatedModule.name;
module.degree = updatedModule.degree;
module.year = updatedModule.year;
module.semester = updatedModule.semester;
db.SaveChanges();
}
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
return(this.RedirectToAction("Index"));
}
/// <summary>
/// 初始化
/// </summary>
public void Initialize()
{
Modules.Clear();
Roles.Clear();
DispatcherHelper.RunAsync(() => {
List <Role> roles = _UserService.QueryRoles();
foreach (var r in roles)
{
Roles.Add(new RoleModel(r));
}
List <Module> modules = _UserService.QueryModuleWithFunctions();
foreach (var m in modules)
{
var module = new ModuleModel(m);
if (m.Function != null && m.Function.Count > 0)
{
List <FunctionModel> functions = new List <FunctionModel>();
foreach (var f in m.Function)
{
functions.Add(new FunctionModel(f, 0));
}
module.Functions = functions;
}
Modules.Add(module);
}
});
}
public static ModuleModel ToEntity(this ModuleViewModel model)
{
if (model == null)
{
return(null);
}
var Permissions = new List <PermissionModel>();
if (model.Permissions != null)
{
model.Permissions.ForEach(delegate(PermissionViewModel permission)
{
var transformedModel = permission.ToEntity();
Permissions.Add(transformedModel);
}
);
}
else
{
Permissions = null;
}
var entity = new ModuleModel
{
ModuleID = model.ModuleID,
Name = model.Name,
Description = model.Description,
Permissions = Permissions,
ModifiedBy = 1,
ModifiedOn = model.ModifiedOn
};
return(entity);
}
public async Task GenericClass()
{
const string code = @"
from typing import Generic, TypeVar, Dict
K = TypeVar('K')
V = TypeVar('V')
class A(Generic[K, V], Dict[K, V]):
def key(self) -> K:
return K
def value(self):
return V
x = A(1, 'a')
";
var analysis = await GetAnalysisAsync(code);
var model = ModuleModel.FromAnalysis(analysis, Services, AnalysisCachingLevel.Library);
//var json = ToJson(model);
//Baseline.CompareToFile(BaselineFileName, json);
using (var dbModule = CreateDbModule(model, analysis.Document.FilePath)) {
dbModule.Should().HaveSameMembersAs(analysis.Document);
}
}
public PythonDbModule(ModuleModel model, string filePath, IServiceContainer services)
: base(model.Name, filePath, services)
{
Documentation = model.Documentation;
_newLines = model.NewLines.Select(nl => new NewLineLocation(nl.EndIndex, nl.Kind)).ToArray();
_fileSize = model.FileSize;
}
public async Task NestedClasses()
{
const string code = @"
x = 'str'
class A:
def methodA(self):
return True
class B:
x: int
class C:
def __init__(self):
self.y = 1
def methodC(self):
return False
def methodB1(self):
return self.C()
def methodB2(self):
return self.C().y
c = B().methodB1()
";
var analysis = await GetAnalysisAsync(code);
var model = ModuleModel.FromAnalysis(analysis, Services, AnalysisCachingLevel.Library);
var json = ToJson(model);
Baseline.CompareToFile(BaselineFileName, json);
}
public List <ModuleModel> GenerateModuleModel(string deviceName)
{
var mModel = new List <ModuleModel>();
foreach (var m in DeviceStorage.GetDeviceByName(deviceName).Modules)
{
var buf = new ModuleModel();
buf.module = m;
buf.DeviceName = deviceName;
if (buf.module is Trigger)
{
buf.Type = "Simple Trigger";
buf.StrVal = Utility.UnWrapStates((buf.module as Trigger).State);
}
if (buf.module is VariadicTrigger)
{
buf.Type = "Variadic Trigger";
buf.StrVal = (buf.module as VariadicTrigger).State.ToString();
}
if (buf.module is Sensor)
{
buf.Type = (buf.module as Sensor).State.ToString();
}
mModel.Add(buf);
// mModel[0].Module.
}
return(mModel);
}
//加载功能
private void LoadModule(ModuleModel m, out NavBarGroup CurrentGroup, out BarSubItem CurrentBarItem)
{
var ModuleImage = LoadUIImage.LoadNavBarImage_Group(ConvertLib.ToString(m.ModuleImg));
//添加模块到navBarControl1
//m.ModuleName = "(新)" + m.ModuleName;
//LoadModule(hp, dtModulesFun, m);
//hp.CurrentGroup.Appearance.ForeColor = Color.FromArgb(0x99, 0x00, 0x33);
//hp.CurrentGroup.Appearance.Font = new Font(hp.CurrentGroup.Appearance.Font, FontStyle.Bold);
CurrentGroup = new NavBarGroup()
{
Caption = m.Caption,
SmallImage = ModuleImage,
Tag = m
};
navBarControl1.Groups.Add(CurrentGroup);
//添加模块到bbi_Module
CurrentBarItem = new BarSubItem()
{
Caption = m.Caption,
Glyph = ModuleImage
};
if (m.IsNew)
{
CurrentGroup.Appearance.ForeColor = Color.FromArgb(0x99, 0x00, 0x33);
CurrentGroup.Appearance.Font = new Font(CurrentGroup.Appearance.Font, FontStyle.Bold);
}
ribbonControl1.Items.Add(CurrentBarItem);
bsi_Modules.AddItem(CurrentBarItem);
}
private void AddModuleInternal <TModule>(ModuleModel module, IModuleConfiguration <TModule> config)
{
module.Name = config.Name;
module.Description = config.Description;
module.ExcludeFromCommandName = config.ExcludeFromCommandName;
var newCommands = new List <CommandModel>();
var methods = module.Type.GetTypeInfo().GetMethods();
foreach (var method in methods)
{
if (config.IsRemoved(method))
{
continue;
}
if (_commandConstructor.TryCreate(method, module, out var command))
{
var result = _commandValidator.Validate(command);
if (!result.IsValid)
{
throw new InvalidCommandException(command, result.Errors);
}
module.Commands.Add(command);
newCommands.Add(command);
}
}
// TODO: test for command duplicates
_commands.AddRange(newCommands);
}
private bool FindModuleModel(string moduleName, string filePath, out ModuleModel model)
{
model = null;
// We don't cache results here. Module resolution service decides when to call in here
// and it is responsible of overall management of the loaded Python modules.
for (var retries = 50; retries > 0; --retries)
{
try {
// TODO: make combined db rather than per module?
var dbPath = FindDatabaseFile(moduleName, filePath);
if (string.IsNullOrEmpty(dbPath))
{
return(false);
}
using (var db = new LiteDatabase(dbPath)) {
if (!db.CollectionExists("modules"))
{
return(false);
}
var modules = db.GetCollection <ModuleModel>("modules");
model = modules.Find(m => m.Name == moduleName).FirstOrDefault();
return(model != null);
}
} catch (Exception ex) when(ex is IOException || ex is UnauthorizedAccessException)
{
Thread.Sleep(10);
}
}
return(false);
}
public ModuleFactory(ModuleModel model, IPythonModule module, IGlobalScope gs)
{
_model = model;
_gs = gs;
Module = module;
DefaultLocation = new Location(Module);
}
public static ModuleDC Convert(ModuleModel module)
{
var map = Mapper.Resolve<ModuleModel, ModuleDC>(MapResolveOptions.UsePrivateSetter);
ModuleDC moduleDC = Mapper.Map<ModuleModel, ModuleDC>(module);
//module.Features.ToList().ForEach(feature => featureModel.ModuleFeatures.Add(Convert(feature)));
return moduleDC;
}
/// <summary>
/// AddRole
/// </summary>
/// <param name="roleModel"></param>
public void SaveModule(ModuleModel moduleModel)
{
ModuleDC moduleRequest = SecurityClientTranslate.Convert(moduleModel);
ServiceResponse moduleResponse = _securityProxy.Execute(opt => opt.SaveModule(moduleRequest));
if (moduleResponse.Status != ResponseStatus.Success)
HandleError(moduleResponse.Status, moduleResponse.ResponseMessage);
}
