public IActionResult Create([FromForm] CreateDynamicModuleViewModel viewModel) { if ( ModelState.IsValid && ( !string.IsNullOrEmpty(viewModel.NameOption) || !string.IsNullOrEmpty(viewModel.Name) ) ) { var dynamicModuleModel = m_mapper.Map <DynamicModuleModel>(viewModel); var moduleInfo = m_dynamicModuleProvider.GetLibraryModuleInfos() .FirstOrDefault(x => x.ModuleGuid == dynamicModuleModel.ModuleGuid); //TODO introduce validating service: unique Name (related to Guid) var result = m_dynamicModuleManager.CreateDynamicModule(dynamicModuleModel, moduleInfo); if (!result.HasError) { return(RedirectToAction(nameof(Edit), new { id = result.Result })); } ModelState.AddModelError(result.Error.Message); } var defaultViewModel = ViewModelBuilder.BuildCreateDynamicModuleViewModel(ModelState, viewModel); return(View("Create", defaultViewModel)); }
private static void Generate(ViewModelBuilder vmBuilder, string viewModelClassName, IEnumerable <InjectionToGenerate>?injectionsToGenerate, bool hasCommands, bool isEventSubscriber) { vmBuilder.AppendLineBeforeMember(); vmBuilder.Append($"public {viewModelClassName}("); injectionsToGenerate ??= Enumerable.Empty <InjectionToGenerate>(); var first = true; string?eventAggregatorAccessForSubscription = null; if (isEventSubscriber) { var eventAggregatorInjection = injectionsToGenerate.FirstOrDefault(x => x.Type == "MvvmGen.Events.IEventAggregator"); if (eventAggregatorInjection is not null) { eventAggregatorAccessForSubscription = $"this.{eventAggregatorInjection.PropertyName}"; } else { eventAggregatorAccessForSubscription = "eventAggregator"; first = false; vmBuilder.Append($"MvvmGen.Events.IEventAggregator {eventAggregatorAccessForSubscription}"); } } foreach (var injectionToGenerate in injectionsToGenerate) { if (!first) { vmBuilder.Append(", "); } first = false; vmBuilder.Append($"{injectionToGenerate.Type} {injectionToGenerate.PropertyName.ToCamelCase()}"); } vmBuilder.AppendLine(")"); vmBuilder.AppendLine("{"); vmBuilder.IncreaseIndent(); foreach (var injectionToGenerate in injectionsToGenerate) { vmBuilder.AppendLine($"this.{injectionToGenerate.PropertyName} = {injectionToGenerate.PropertyName.ToCamelCase()};"); } if (isEventSubscriber) { vmBuilder.AppendLine($"{eventAggregatorAccessForSubscription}.RegisterSubscriber(this);"); } if (hasCommands) { vmBuilder.AppendLine($"this.InitializeCommands();"); } vmBuilder.AppendLine($"this.OnInitialize();"); vmBuilder.DecreaseIndent(); vmBuilder.AppendLine("}"); vmBuilder.AppendLine(); vmBuilder.AppendLine($"partial void OnInitialize();"); }
public IActionResult AddScope(int apiResourceId, EditableScopeViewModel scope) { if (!ModelState.IsValid) { var viewModel = ViewModelBuilder.BuildAddScopeViewModel(ModelState, apiResourceId); return(View(viewModel)); } var claimsIds = GetSelectedItems(scope.SelectableClaimTypes).Select(x => x.Id); var scopeModel = Mapper.Map <ScopeModel>(scope); var result = m_scopeManager.AddScopeToApiResource(apiResourceId, scopeModel, claimsIds); if (result.HasError) { ModelState.AddModelError(result.Error.Message); var viewModel = ViewModelBuilder.BuildAddScopeViewModel(ModelState, apiResourceId); return(View(viewModel)); } return(RedirectToAction(nameof(Scopes), new { apiResourceId })); }
/// <summary> /// Initialize services available to the application models. /// </summary> private void InitServices() { this.services = new ServiceContainer(); this.services.AddService(typeof(ITorbViewMaker), this); this.services.AddService(typeof(IMessageBox), new ServiceCreatorCallback( (container, type) => { return(new CustomMessageBox()); } )); this.services.AddService(typeof(IFileDialogService), new ServiceCreatorCallback((container, type) => { return(new FileDialogService()); })); this.services.AddService(typeof(InputBinder), new ServiceCreatorCallback((container, type) => new InputBinder() )); this.services.AddService(typeof(ViewModelBuilder), new ServiceCreatorCallback((c, t) => { ViewModelBuilder builder = new ViewModelBuilder(); builder.FallbackCreator = this.CreateDefaultVM; return(builder); } )); this.services.AddService(typeof(FileDeleteService), new ServiceCreatorCallback((container, type) => { return(new FileDeleteService()); })); }
public async Task <IActionResult> Exam(int id) { var interview = await _interviewService.GetInterviewAsync(id); var exam = await _interviewService.GetExamAsync(interview.ExamId); var candidate = await _userService.GetCandidateAsync(interview.CandidateId); if (exam == null || candidate == null) { return(RedirectToAction(nameof(HomeController.Error))); } var answers = new List <Answer>(); var examQuestions = await _interviewService.GetQuestionsForExamAsync(interview.ExamId); if (examQuestions?.Any() == true) { foreach (var question in examQuestions) { var questionAnswers = await _interviewService.GetAnswersForQuestionAsync(question.Id); if (questionAnswers?.Any() == true) { answers.AddRange(questionAnswers); } } } var viewModel = ViewModelBuilder.GetExamViewModel(interview, exam, candidate, examQuestions, answers); return(View(viewModel)); }
public async Task <IActionResult> Results() { var interviews = await _interviewService.GetPassedInterviewsAsync(); var candidates = await _userService.GetCandidatesAsync(); if (interviews?.Any() != true || candidates?.Any() != true) { return(RedirectToAction(nameof(HomeController.Error))); } var viewModels = new List <ResultViewModel>(); foreach (var interview in interviews) { var candidate = candidates.FirstOrDefault(e => e.Id == interview.CandidateId); if (candidate != null) { var exam = await _interviewService.GetExamAsync(interview.ExamId); viewModels.Add(ViewModelBuilder.GetResultViewModels(interview, candidate, exam)); } } return(View(viewModels.OrderByDescending(e => e.Score).ToList())); }
public IActionResult Create(EditableUserViewModel <UserWithPasswordViewModel> editableViewModel) { if (ModelState.IsValid) { var userViewModel = editableViewModel.UserViewModel as UserViewModel; var userModel = m_mapper.Map <UserModel>(userViewModel); var applicationUser = m_mapper.Map <ApplicationUser>(userModel); var result = m_identityUserManager .CreateAsync(applicationUser, editableViewModel.UserViewModel.Password).Result; if (result.Succeeded) { var roleResult = m_identityUserManager.AddToRolesAsync(applicationUser, editableViewModel.SelectableRoles?.Where(x => x.IsSelected).Select(x => x.Item.Name).ToList()).Result; if (roleResult.Succeeded) { return(RedirectToAction(nameof(View), new { id = applicationUser.Id })); } ModelState.AddModelError( roleResult.Errors.FirstOrDefault()?.Description); //TODO translate by code } ModelState.AddModelError( result.Errors.FirstOrDefault()?.Description); //TODO translate by code } var viewModel = ViewModelBuilder.BuildCreateUserViewModel(ModelState, editableViewModel.UserViewModel); return(View(viewModel)); }
/// <summary> /// Route hijacks requests for pages based on the document type UmbNewsItem, builds the view model and passes to the view /// </summary> /// <param name="p">Page number for news list</param> /// <returns></returns> public ActionResult UmbNewsOverview(int p = 1) { const int PageSize = 2; var vm = ViewModelBuilder.BuildPage <NewsOverviewPageViewModel, PagingDetail>(CurrentPage, new PagingDetail(p, PageSize)); return(View(vm)); }
TargetReport Diff(IPackage pkg, SemanticVersion left, SemanticVersion right) { var creator = new CompareSetCreator(); var differ = new CompareSetDiffer(); var packageDescription = new PackageDescription { PackageId = pkg.Id, Versions = new VersionPair(left.ToString(), right.ToString()) }; var compareSets = creator.Create(packageDescription); var diffedCompareSets = differ.Diff(compareSets); var vm = ViewModelBuilder.Build(packageDescription, diffedCompareSets); foreach (var framework in TopXNugets.Frameworks) { var target = vm.targets.FirstOrDefault(trg => trg.Name == framework); if (target != null) { return(target); } } return(null); }
protected dynamic CreateSerializedObjectViewModel(SerializedObject serializedObject) { ViewModelBuilder viewModelBuilder = new ViewModelBuilder(); viewModelBuilder.BuildId(serializedObject.ObjectId); viewModelBuilder.BuildClassId(serializedObject.ClassId); foreach (SerializedProperty serializedProperty in JsonConvert.DeserializeObject <IEnumerable <SerializedProperty> >(serializedObject.SerializedProperties)) { if (serializedProperty.Member.PropertyDataTypeStorageDataType == StorageDataType.Integer) { viewModelBuilder.BuildProperty(serializedProperty.Member.Code, serializedProperty.IntegerValue); } else if (serializedProperty.Member.PropertyDataTypeStorageDataType == StorageDataType.Decimal) { viewModelBuilder.BuildProperty(serializedProperty.Member.Code, serializedProperty.DecimalValue); } else if (serializedProperty.Member.PropertyDataTypeStorageDataType == StorageDataType.String) { viewModelBuilder.BuildProperty(serializedProperty.Member.Code, serializedProperty.StringValue); } else if (serializedProperty.Member.PropertyDataTypeStorageDataType == StorageDataType.DateTime) { viewModelBuilder.BuildProperty(serializedProperty.Member.Code, serializedProperty.DateTimeValue); } } return(viewModelBuilder.Build()); }
public IActionResult AddClaim(int userId, EditableClaimViewModel claim) { var authorized = m_authorizationService.AuthorizationForUserEditAsync(User, RoleNames.Admin, userId); if (!authorized.Result) { return(Forbid()); } if (!ModelState.IsValid) { var viewModel = ViewModelBuilder.BuildAddClaimViewModel(ModelState, userId); return(View(viewModel)); } var claimModel = m_mapper.Map <ClaimModel>(claim); var result = m_claimManager.AddClaimToUser(userId, claimModel, claim.SelectedClaimType); if (result.HasError) { ModelState.AddModelError(result.Error.Message); var viewModel = ViewModelBuilder.BuildAddClaimViewModel(ModelState, userId); return(View(viewModel)); } return(RedirectToAction(nameof(Claims), new { userId })); }
public void ConstructViewModelData <T1, T2>(ViewModelBuilder <T1, T2> viewModelBuilder) where T1 : ViewModel where T2 : BaseData { viewModelBuilder.BuildViewModelData(); viewModelBuilder.BuildViewModelConcreteData(); }
public async Task Index_Post_ShouldReturnView_WhenPageIsInvalid() { // Arrange var element = new ElementBuilder() .WithType(EElementType.Address) .WithAddressProvider("testAddressProvider") .WithQuestionId("test-address") .Build(); var page = new PageBuilder() .WithElement(element) .WithPageSlug("page-one") .WithValidatedModel(true) .Build(); _pageService.Setup(_ => _.ProcessRequest(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <Dictionary <string, dynamic> >(), It.IsAny <IEnumerable <CustomFormFile> >(), It.IsAny <bool>())) .ReturnsAsync(new ProcessRequestEntity { Page = page, ViewName = "Search", UseGeneratedViewModel = true }); var viewModel = new ViewModelBuilder() .WithEntry("Guid", Guid.NewGuid().ToString()) .WithEntry($"{element.Properties.QuestionId}-postcode", "SK11aa") .Build(); // Act var result = await _homeController.Index("form", "page-one", viewModel, null, "automatic"); // Assert var viewResult = Assert.IsType <ViewResult>(result); Assert.Equal("Search", viewResult.ViewName); }
public async Task Index_Post_ShouldRedirectWhen_RedirectToAction_IsReturnedFrom_ProcessRequest() { // Arrange var actionName = "AddressManual"; var element = new ElementBuilder() .WithType(EElementType.Address) .WithAddressProvider("testAddressProvider") .WithQuestionId("test-address") .Build(); _pageService.Setup(_ => _.ProcessRequest(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <Dictionary <string, dynamic> >(), It.IsAny <IEnumerable <CustomFormFile> >(), It.IsAny <bool>())) .ReturnsAsync(new ProcessRequestEntity { RedirectAction = actionName, RedirectToAction = true }); var viewModel = new ViewModelBuilder() .WithEntry("Guid", Guid.NewGuid().ToString()) .WithEntry($"{element.Properties.QuestionId}-postcode", "SK11aa") .Build(); // Act var result = await _homeController.Index("testform", "page-one", viewModel, null, "automatic"); // Assert var redirectResult = Assert.IsType <RedirectToActionResult>(result); Assert.True(redirectResult.RouteValues.ContainsKey("form")); Assert.True(redirectResult.RouteValues.ContainsKey("path")); Assert.Contains("testform", redirectResult.RouteValues.Values); Assert.Contains("page-one", redirectResult.RouteValues.Values); Assert.Equal(actionName, redirectResult.ActionName); }
public async Task <IActionResult> Interviews() { var categories = await _interviewService.GetCategoriesAsync(); var viewModel = ViewModelBuilder.GetInterviewsViewModel(categories); return(View(viewModel)); }
internal static void GenerateCommentHeader(this ViewModelBuilder vmBuilder, string versionString) { vmBuilder.AppendLine("// <auto-generated>"); vmBuilder.AppendLine("// This code was generated for you by"); vmBuilder.AppendLine("// ⚡ MvvmGen, a tool created by Thomas Claudius Huber (https://www.thomasclaudiushuber.com)"); vmBuilder.AppendLine($"// Generator version: {versionString}"); vmBuilder.AppendLine("// </auto-generated>"); }
internal static void GenerateClass(this ViewModelBuilder vmBuilder, INamedTypeSymbol viewModelClassSymbol, INamedTypeSymbol viewModelBaseSymbol) { var inheritFromViewModelBaseClass = !InheritsFromViewModelBase(viewModelClassSymbol, viewModelBaseSymbol); vmBuilder.AppendLine($"partial class {viewModelClassSymbol.Name}" + (inheritFromViewModelBaseClass ? " : global::MvvmGen.ViewModels.ViewModelBase" : "")); vmBuilder.AppendLine("{"); vmBuilder.IncreaseIndent(); }
public OptionsController() { UserSettingsSection config = (UserSettingsSection)System.Configuration.ConfigurationManager.GetSection("userSettings"); _repository = new FeedRepository(config.ConnectionString.Value); _services = new FeedServices(_repository); _builder = new ViewModelBuilder(_repository); }
internal static void GenerateProperties(this ViewModelBuilder vmBuilder, IEnumerable <PropertyToGenerate>?propertiesToGenerate) { if (propertiesToGenerate is not null) { foreach (var propertyToGenerate in propertiesToGenerate) { GenerateProperty(vmBuilder, propertyToGenerate); } } }
internal static void GenerateConstructor(this ViewModelBuilder vmBuilder, ViewModelToGenerate viewModelToGenerate) { if (viewModelToGenerate.GenerateConstructor) { Generate(vmBuilder, viewModelToGenerate.ViewModelClassSymbol.Name, viewModelToGenerate.InjectionsToGenerate, viewModelToGenerate.CommandsToGenerate?.Any() == true, viewModelToGenerate.IsEventSubscriber); } }
private dynamic CreateViewModel(IRequestHandler requestHandler, Microcontroller microcontroller) { ViewModelBuilder viewModelBuilder = new ViewModelBuilder(); foreach (DataSource dataSource in requestHandler.Storage.GetRepository <IDataSourceRepository>().FilteredByMicrocontrollerId(microcontroller.Id)) { viewModelBuilder.BuildProperty(dataSource.Code, this.CreateDataSourceViewModel(requestHandler, dataSource)); } return(viewModelBuilder.Build()); }
public StoreConnector(ViewModelBuilder <ViewModel> builder, StoreConverter <State, ViewModel> converter, bool distinct = false, ShouldRebuildCallback <ViewModel> shouldRebuild = null, Key key = null) : base(key) { D.assert(builder != null); D.assert(converter != null); this.distinct = distinct; this.builder = builder; this.converter = converter; this.shouldRebuild = shouldRebuild; }
internal static void GenerateCommandProperties(this ViewModelBuilder vmBuilder, IEnumerable <CommandToGenerate>?commandsToGenerate) { if (commandsToGenerate is not null) { foreach (var commandToGenerate in commandsToGenerate) { vmBuilder.AppendLineBeforeMember(); vmBuilder.AppendLine($"public DelegateCommand {commandToGenerate.PropertyName} {{ get; private set; }}"); } } }
internal static void GenerateInjectionProperties(this ViewModelBuilder vmBuilder, IEnumerable <InjectionToGenerate>?injectionsToGenerate) { if (injectionsToGenerate is not null) { foreach (var injectionToGenerate in injectionsToGenerate) { vmBuilder.AppendLineBeforeMember(); vmBuilder.AppendLine($"{injectionToGenerate.PropertyAccessModifier} {injectionToGenerate.Type} {injectionToGenerate.PropertyName} {{ get; {injectionToGenerate.SetterAccessModifier} set; }}"); } } }
public async Task Index_ShouldCallActionsWorkflow_IfPageHasActions() { // Arrange var element = new ElementBuilder() .WithType(EElementType.Textbox) .WithQuestionId("test") .Build(); var behaviour = new BehaviourBuilder() .WithBehaviourType(EBehaviourType.SubmitAndPay) .WithPageSlug("url") .Build(); var pageActions = new ActionBuilder() .WithActionType(EActionType.RetrieveExternalData) .WithPageActionSlug(new PageActionSlug { URL = "www.test.com", Environment = "local", AuthToken = string.Empty }) .WithTargetQuestionId(string.Empty) .WithHttpActionType(EHttpActionType.Post) .Build(); var page = new PageBuilder() .WithElement(element) .WithPageSlug("page-one") .WithValidatedModel(true) .WithBehaviour(behaviour) .WithPageActions(pageActions) .Build(); var viewModel = new ViewModelBuilder() .WithEntry("Guid", Guid.NewGuid().ToString()) .WithEntry($"test", "test") .Build(); _pageService.Setup(_ => _.ProcessRequest(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <Dictionary <string, dynamic> >(), It.IsAny <IEnumerable <CustomFormFile> >(), It.IsAny <bool>())) .ReturnsAsync(new ProcessRequestEntity { Page = page }); _pageService.Setup(_ => _.GetBehaviour(It.IsAny <ProcessRequestEntity>())).Returns(new Behaviour { BehaviourType = EBehaviourType.SubmitAndPay }); _paymentWorkflow.Setup(_ => _.Submit(It.IsAny <string>(), It.IsAny <string>())) .ReturnsAsync("https://www.return.url"); // Act await _homeController.Index("form", "page-one", viewModel, null); // Assert _mockActionsWorkflow.Verify(_ => _.Process(page.PageActions, It.IsAny <FormSchema>(), It.IsAny <string>()), Times.Once); }
public ExternalizedSyncObservableCollection(ObservableCollection <TModel> models, ViewModelBuilder viewModelBuilder) : base(models) { if (viewModelBuilder == null) { throw new ArgumentNullException("viewModelBuilder"); } _viewModelBuilder = viewModelBuilder; this.Synchronize(); }
public IActionResult AddClaim(int userId) { var authorized = m_authorizationService.AuthorizationForUserEditAsync(User, RoleNames.Admin, userId); if (!authorized.Result) { return(Forbid()); } var viewModel = ViewModelBuilder.BuildAddClaimViewModel(ModelState, userId); return(View(viewModel)); }
public async Task <IActionResult> Index(int id) { var category = await _interviewService.GetCategoryAsync(id); if (category == null) { return(NotFound()); } var viewModel = ViewModelBuilder.GetInterviewViewModel(category); return(View(viewModel)); }
public void TestPresent() { var data = new Stack <decimal>(); data.Push(1); data.Push(2); data.Push(3); ViewModelBuilder.PresentStack(data).Should().BeEquivalentTo("stack: 1 2 3"); data.Clear(); ViewModelBuilder.PresentStack(data).Should().BeEquivalentTo("stack:"); }
public async Task <IActionResult> Index(string returnUrl) { var request = await m_interaction.GetAuthorizationContextAsync(returnUrl); if (request == null) { ModelState.AddModelError(Translator.Translate("error-occured")); return(View()); } var vm = ViewModelBuilder.BuildConsentViewModel(ModelState, request, returnUrl); return(View(vm)); }
public ViewDataContainer() { Model = new ViewModelBuilder(); CurrentNode = Model; ViewData = new ViewDataDictionary(); }
public void build_should_return_viewmodels() { var viewModelBuilder = new ViewModelBuilder(); }