- copy over from legacy MVC
- fixup namespaces, remove copyright notices, ...
- temporarily remove `RouteBeginForm() overloads
- move main components to `HtmlHelper` and declare in `IHtmlHelper<T>`
- change `UrlHelper` to avoid treating an existing dictionary as an object
- add `HtmlHelper.Createform()` factory
- use in MVC sample; move BeginForm / TextBox samples to a new row
1. Adding a view component
2. Adding more partial views from the sample and enabled a few of them.
3. Updating Account controller to accomodate all the recent identity changes.
4. Enabling some available Url helpers like Url.Content
5. Adding a ~ to all the scripts and images as this bug is fixed now.
Initial draft for DefineSection \ RenderSection. This change is based on
changes to the Razor parser to enable Razor to generate HelperResults for
section instead of void delegates.
- remove a duplicate using of `System.Collections.Generic`
- FYI `k build` command does not detect this problem
- nit: also cleanup long lines and align wrapped parameters
- HtmlHelper service now needs an `IModelMetadataProvider` instance
- make `GetInputTypeString()` private
- use `TextBox()` and `TextBoxFor()` in MVC sample
- throw if `ExpressionMetadataProvider.FromLambdaExpression()` returns `null`
Copy from:
- some `static` `ModelMetadata` methods -> `ExpressionMetadataProvider`
- `TryGetValueDelegate` -> `TryGetValueDelegate`
- `TypeHelpers.CreateTryGetValueDelegate()`, related bits -> `TryGetValueProvider`
- `ViewDataDictionary.ViewDataEvaluator` inner class -> `ViewDataEvaluator`
- `ViewDataInfo` -> `ViewDataInfo`
- `ViewDataDictionary.Eval()`, related bits -> add to `ViewDataDictionary`
Change to fit in new world:
- usual stuff: `var`, `[NotNull]`, String -> string, namespaces, etc.
- PropertyDescriptor -> PropertyInfo
- update Reflection use
- no `IModelMetadata.Container` property
- improve a couple of variable and parameter names
- make `ViewDataInfo` immutable
- make `ViewDataDictionary.FormatValueInternal` `public` and -> `FormatValue`
- remove `[SuppressMessage]` attributes
1. Removing copyright text from all files per a code review feedback
2. Adding a cookie based session to the application to retrieve the cart Id.
3. Enabled the Accounts controller as we now have the necessary Http abstractions for User, SignIn, SignOut etc.
4. Changing self hosting scripts to run on coreclr by default.
5. Enabling the layout page on all required views.
6. Adding a favico.ico
7. Renaming the Cart property in the EF context to CartItems as it returns a CartItems list.
8. Uncommenting some code which was previously accessing unavailable APIs. They are available now (but yet to validate them).
- correct `ArgumentNullOrEmpty` and pass parameter name to
`ArgumentException` constructor
- remove `[SuppressMessage]` attributes
- `AnonymousObjectToHtmlAttributes` should return an `IDictionary`
- `var`
- remove straggling copyright notices
- wrap long lines (did not reword any comments)
- align a few parameters
- `Name()` is a `virtual` instance method to allow useful derivation
- `NameFor()` is an instance method to avoid adding `GetExpressionName()`
to the public surface; either method could be `virtual`
- `NameForModel()` is an extension method because it's not usefully overridden
- use `Name*()` in sample
- usual stuff, especially use of `var` and `[NotNull]`
- remove references to `ExpressionFingerprintChain` and so on to minimize
classes we bring over now (and remove one cache)
- copy over missing resource
- rework checks in `IsSingleArgumentIndexer()`
There are several portions of model validation that attempt to avoid
revalidating if a field has been validated. However the behavior of
ModelStateDictionary makes it difficult to distinguish between an
unvalidated field and a field without validation errors. This change
resolves this issue by letting the caller distinguish between the two
cases.
For link generation to areas, we need to provide the set of values that
the route could potentially provide.
Basically if we know what action we want to reach, we want to know whether
or not a given route could hit that action before giving it the OK to
generate a link.
For instance a route like '{controller}' couldn't hit an action like
'HomeController:DoACoolThing', since it can never provide a value for
'action'. This makes it possible for WebFX to make the right decision
without changing the behavior of any of the routing constructs. This also
has the side-effect of removing a class of order dependencies in routing
that cause bad links to be generated.
The code that does an 'UPSERT' of seed data on app start was querying
existing instances and attaching as modified of seed instances on the
same context. Now that we track query results this will throw because
the context has two instances of the same entity (same key value).
Swapping to use a temporary context to query existing data.
- add `IHtmlHelper<T>` and `ICanHasViewContext`
- adjust `HtmlHelper` and `HtmlHelper<T>` to match
- throw if `ViewContext` accessed prior to `Contextualize` call
- XML comments (from old world) all around
Note
- no current need for an `HtmlHelper` copy constructor or `Clone()` method
- expect recursion code to get another injected `IHtmlHelper<T>` and then
"contextualize" that instance with a new `ViewContext`
- start with `FormContext` and classes it needs from legacy world
- FYI `ModelClientValidationRule` came from Web Pages; the rest from MVC
Cleanup and make files compile in new world
- remove `FormContext.GetJsonValidationMetadata` method; will file an
issue to revive this using Json.NET
- don't store `FormContext` in the `HttpContext`, no longer have child
actions
- do `null` checks in setters, not getters (minor perf improvement)
- fix namespaces and usings
- wrap long lines; use `[NotNull]`; no copyright notice
- use explicit comparers for dictionaries
- add XML comment for odd `ModelClientValidationRule.ValidationType`
property
- Collection -> List
1. Adding scripts to self host & custom host Music store
2. Updating readme
3. Cleanup some helper classes that are not necessary.
4. Adding error page middleware for diagnostics.
5. Flipping the switch to run helios on "K" by default.
Compared to legacy MVC:
- correct usings and namespace
- remove `GetFullHtmlFieldId` method; depends on `HtmlHelper` method that
can't be static
- String -> string
- remove reference to a legacy bug
- convert internal `VisitedObjects` property to public `AddVisited()` method
Further cleanup
- remove explicit backing fields for remaining properties
- add copy constructor to replace code distributed around legacy MVC
- don't "combine and trim" in `GetFullHtmlFieldName()`
This was causing intellisense failures in VS. It looks like the
commandline is able to accidentally pick up the compatability extensions
from the model binding assembly, but this is not the case in VS.
Changed this code not to rely on compatability extensions.
We'll need to access the accepted values to do proper link generation, so
separating this process out into 2 parts.
Also moving defaults into the TemplateBinder because they are conceptually
part of the route, not part of the request. I'll do the same for
TemplateMatcher soon, but it's a big change and worth separating.
This doesn't add any new extensibility, and will likely change again in
the future when we add extensibility. For now this is a stopgap to reduce
duplication between JsonResult and JsonViewComponentResult.
We'll create a scoped service provider if the middleware that does it
isn't there.
We resolve all of our stuff from the scoped service provider, allowing
users to plug in any scoped things they want.
Ported UrlHelper to be a scoped service.
- move `DynamicObject` derivation up to new `DynamicViewData` class, fixing [WebFx-169](http://projectk-tc:8080/browse/WEBFX-169)
- avoid direct `_data` lookup in previous `TryGetMember()`, fixing [#118](https://github.com/aspnet/WebFx/issues/118)
- rename ViewData -> ViewDataDictionary
Also
- flesh out `IDictionary<string, object>` implementation in `ViewData`
- provide `ViewData` copy constructor that allows TModel to change
- remove `TryGetIndex()` and `TrySetIndex()` implementations; use `ViewData[]` instead
- restore `ViewContext.ViewBag` from legacy MVC
Swapping context to use OnModelCreating & OnConfiguring now that models
are cached
Adding some [Required] annotations to properties that are really
required in the domain model
Renaming Cart => CartItem because that's what it really is :)
Allowing database to hold some null data now that we can materialize it
(although we can't save it yet)
Enabling data access against new EF stack.
Uses SQL Server when running on Net45 and an in-memory database for K10
(because SQL Client isn't available on K10 yet).
Various workarounds in place to compensate for missing features in EF
(all marked with "// TODO [EF]..."
Changes include
(1) Inclusion of all views (with non compiling code commented out)
(2) Inclusion of all models with data annotations
(3) images & setting up of static files
(4) MVC application setup and scripts to run the application
(5) Scripts to clean up the temporary files and capture LKG build.
Modified ModelState to only ever be created on the ActionContext and then plumbed/exposed it on ViewData and Controller. This will enable: ActionFilterContext's will have access to ModelState via its ActionContext member, allow HTMLHelpers to access ModelState via ViewData, and unify the locations of "source" model state. In the old world we used to copy/replace/instantiate new model state all over unnecessarily.
- demonstrate `ModelMetadata` is available in a view
Also
- simplify `View()` overloads in `Controller`, pending #110 decisions
- make `Model` in `RazorView<T>` readonly
This will be necessary for partials, and for Components.
Basically, the view engine uses a dictionary of data to find the top level
view (for an action) - after we do that, we want this context to be
sticky, which means we need to pass it around. This ensures that partials
and components will be resolved under the same paths as the main view.
Currently this 'data' is just the route values - and there is an ongoing
discussing about the right design here. The data that's being passed WILL
change in the future.
and only use RouteValues (or generically just Dictionary<string, object>).
This is temporary and will change once we get Partials (which are currently just dead code)
For now this will unblock ViewComponents
The changes include:
1. Action executor changes required for supporting sync and async operations Taksk and Task
2. Adding test project for MVC core - This contains ActionExecutor Tests.
3. Also adding a resources file for MVC core project
- add missing `[NotNull]` attributes
- remove now-unneeded usings for ...ModelBinding.Internal namespace
Also get ModelBinding test project working under CoreCLR
- create separate k10 and net45 folders under test in VS
- add `[InternalsVisibleTo]` to make `TypeExtensions` visible to test assembly
- correct tests' `CultureInfo` use to compile under CoreCLR
- ifdef out CoreCLR tests depending on Moq, ReadOnly, ...
- remove a couple of tests expecting TypeConverter to work
1. Areas defined by the Area attribute
2. Areas are a routeconstraint on the actiondescriptor
3. Areas find pages through route values
Other changes:
1. Remove Path from ActionDescriptor - It doesn't make sense with this change
2. Add sample Area
- use Microsoft.AspNet.Mvc.Rendering namespace throughout assembly
Also
- move `IdAttributeDotReplacement` from `TagBuilder` to `HtmlHelper`
- remove commented-out code in `HtmlHelper`
- use `var` and `[NotNull]` more
- `String` -> `string`
- correct Resources references; add missing resources
This is as simple as modifying the base class to return task and await the ExecuteAsync method. Also added a piece to the sample project to verify functionality.
Removed all System.CodeDOM related code from net45. This involved modifying some existing code paths and most of all reducing the complexity of all of the CodeGenerators. Added some factory creation methods to build CodeBuilders. Ran code analysis and made adjustments to pass analysis.
This follows a similar pattern to html helpers - a minimal basis interface
that performs the main functionality, and a set of extension methods that
make up the rich API.
- NRE in TypeExtensions.IsCompatibleWith()
- ComplexModelDtoResultTest.Constructor_ThrowsIfValidationNodeIsNull() won't work w/o validation
- BindModel_Error_FormatExceptionsTurnedIntoStringsInModelState() looking for wrong message
- BindModel_Error_FormatExceptionsTurnedIntoStringsInModelState_ErrorNotAddedIfCallbackReturnsNull() a dupe
- Also add [NotNull] attributes in TypeExtensions
- Now that services are being flowed through the entire stack
we can nuke the csc service and always use the roslyn based compilation for views
- The RoslynCompilationService is still very much a prototype but it's a good
step to see what other services might may or may not need to flow.
- Removed the PhysicalFileSystem construction from Mvc itself. This will come from
the hosting layer and is newed up temporarily in the PathBasedViewFactory itself.
* Modify ReflectedActionInvoker to model bind parameters
* Introduce IBodyReader for reading request bodies
* Introduce types for per-action-context specific binders, value providers
and body readers
Added newlines inbetween ending line pragma's and code. Without the extra line the document does not format correctly. Separated expression and statement padding functionality. Statements need to have 1 less padding to account for the transition. Changed how runtime and design time code generates to enable accurate debugging experiences in runtime and functional formatting experiences during design time.
- Implement RoleManager
- Replace IIdentityValidator with IUser/Role/Password Validator
- Add test project.json and working tests for InMemoryUserStore
- Flow the host service provider to MvcServices
- Use assembly neutral interfaces to access host services
- Added RoslynCompilationService to Microsoft.AspNet.Mvc.Razor
- Modified self host sample as helios needs to be updated to flow more services
This allows for users to write "@using System;" and still have proper intellisense and mapping. Also removed some legacy code that I came across when running tests.
.NET FX Team will not be adding Char.GetUnicodeCategory because it breaks layering. We cannot have a dependency form System.Runtime.dll to System.Globalization.dll.
This updates the K version of Music Store to use the updated Entity Framework API surface from the data repro. The changes made previously to the models and controllers in the full .NET version are also included here to bring both versions into line. The code is still non-functional as it was before.
Added a CSharpPaddingBuilder based on the existing
CodeGeneratorPaddingHelper to allow accurate padding within the generated
C# files. Also created tests based on the existing PaddingTest tests to
verify padding functionality.
Renamed actiondescriptor to routecontext, because action selection didn't happen yet.
Need to add actiondescriptors back and modify RazorViewEngine to use the right thing.
Scan only relevant (non skipped) assemblies
FinalizeSetup point, to make "stuff" immutable
Support controllers under any namespace
support customizing controller discovery
support customizing skipped assemblies
support customizing multiple controllers with the same name under different namespaces and assemblies
support controller ambiguity detection
Removed Equals from SetModelTypeCodeGenerator and removed accidentally
committed file. The Equals method caused a warning without a corresponding
GetHashCode().
* Paths rooted by a leading slash (e.g. /foo) are correctly resolved by the
PhysicalFileSystem. This change is an experiment to determine if we can
get away with not having virtual paths in WebFx.
* Additionally removing types (MetadataVirtualPathViewFactory,
VirtualPathAttribute) that are currently unused.
This involved adding more boiler plate to the base of the visitor classes such as a Writer and a Context. By following this contract for new visitors we'll ensure that visitors have enough information to add new features to Razor.
Without the initial code tree acceptance you end up stack overflowing. Also removed a validation check that ensures that there's always a base type (not true).
This is heavily based right now on raw Owin as the request/response model
since that will work for building samples/tests, and doesn't require
ifdefs in the code for k10. Once it's feasible, I'll port this to use the
Microsoft.AspNet.Abstractions types.
The sample here includes some basic route/endpoint implementations just to
prove that the route engine works in naive scenarios. These might live on
in the future in some form, but for now it's just part of the sample.
The next step is to integrate this with WebFX and start developing the
integration/configuration story for WebFX.
Specifically:
- Dispose contexts
- Use async wherever possible
- Stop using initializers (currently hard-coded to drop and recreate each run)
- Some general cleanup
- Stop using AttachDbFilename
Not included here:
- No major changes to app structure
- No major changes to data model
- No major changes to error handling, concurrency, etc.
This addition will eventually replace CodeDOM to allow for the k10 project to build. It is a new type of codegeneration method that is highly extensible.
Sornakumar
Praburaj
David Fowler
harshgMSFT
Ryan Nowak
Pranav K
dougbu
N. Taylor Mullen
Hao Kung
Yishai Galatzer
Chris Ross
rowanmiller
Louis DeJardin
Stephen Halter
GrabYourPitchforks
Shih-Ying Hsu
Nick Guerrera
ajcvickers