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); }