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