We Keep Coding

Replace mvc client-side validation with other framework than jquery validate

I want to know if and how it is possible to use an other client-side validation framework (than jquery validate, eg. Parsley) in asp.net mvc?
I just looked into the mvc sourcecode and it seems to be hard-wired.
This class creates the attributes, which will be added to the control later.
Maybe there is a way to inherit from a class and configure it somehow to be used as default. It seems that asp.net mvc have too many static classes (e.g. HtmlHelper) which makes it nearly impossible to extend some functionality without rewriting a lot of framework-code?
The power of common data annotations is cool to descibe meta information about the data. It's used by Entity Framework and MVC,
but the client-side validation should be limited to jquery validate?
I know, that I can configure client-validation frameworks like parsley to get used with an other prefix like the "data-val-" (of jquery validate) instead of "data-parsley-", but not all features can be used this way and conflicts are possible.
Hope anyone have an answer for me ;-)

You can use any client side validation you want to use. Asp.net provides server code that is translated into client code but that's not the only option. You can use any client side code you want independent of the server code framework. Just include the appropriate client side code on the pages you wish and it'll work.

How do I validate data in C# based on a Struts validation.xml?

I have a validation.xml file from Struts, and am going to implement a server-side validation in .NET based on it. The validation.xml file is accompanied with a validationMessages.properties file. Are there any .NET libraries which are capable of performing a validation based on a Struts validation file?
In case this has never been done I'll have to either create such a class, since the validation file is too long and complex to be implemented as mere C# logic. Which begs the question: How would I even begin?
The end-goal is to be able to populate a C# class with properties for all fields, execute a validation method with that class as a parameter and have it return a list of validation error messages (or no errors in case of success).

I'd be surprised if anything like that existed; it's relatively unusual to move from Java -> .NET.
First, see if there are any custom validators. That code would need to be duplicated.
Then pick apart the different forms (or actions, depending on how they did validation). Put each of those into a C# class (but see below) rather than one giant one. I'm not sure what you mean by "A C# class with properties for all fields"; personally I'd go more granular.
Or just use an existing C# validation package and do a translator from Apache Commons Validation to the C# configuration (or code).
It should be a relatively straight-forward process since the validation config is well-known and documented, and all the code is available.

Does IClientValidatable implementation violate the DRY principle in MVC?

MVC provides a lot of validation attributes which can be used as data annotations to perform simple server-side validations.
However, if I want to do some custom validation using my own business logic, I need to create a custom validation attribute, derived from ValidationAttribute, and override the IsValid method.
So far so good.
However, if I want to perform the same validation on client side, I need to implement the IClientValidatable interface in my validation attribute class, and implement the GetClientValidationRules method, which will tell my application that this validation has to be performed on the client-side too.
The contentious issue however, is that I need to write the logic for this client-side validation as separate JavaScript using jQuery. This is exactly the same logic I already wrote in C# (or VB) when overriding the IsValid method.
Why do I have to write the same logic twice, albeit in different languages? Doesn't this violate the DRY principle? I would have expected MVC to generate the JavaScript for the validation logic itself.
Example illustrating what I am talking about: http://www.c-sharpcorner.com/UploadFile/abhikumarvatsa/enabling-client-side-validation-on-custom-data-annotations-w/
EDIT:
Also, what if my validation logic requires data from the application config file or application cache? How do I use that in the jQuery method I write for client-side validation? If I can't, is there any other way to do client-side validation, the logic for which uses application data?

Yes, but it's often worth it.
The benefits of client side validation are speed and less server load. The benefit of server validation is security. Implementing both gains the best of both worlds.
DRY is a good rule of thumb, but as with all rules of thumb there are situations in which the rule should be violated.
EDIT to answer your follow up question
If your jQuery needs values from server side config you need to pass that to the client as part of the JavaScript. For example, you could define a variable in your view which holds the server side value.

How to change models editable atttribute based on a condition

Based on user credentials, I will allow users to edit a field or not on a Razor View.
So I currently have one model which I can do this for the properties I forbid:
[Editable(allowEdit=false)]
public string FirstName {get;set;}
but when I add the attribute whether or not a user has permission to edit it, they won't be able to. I cannot change the fields in Razor View either as we use a very different way of rendering model properties.
Any idea how can I overcome this problem?

You might want to create custom validation attribute and use that, in it you can inject your boolean and check and make it conditional (in C#).
The better option is to use Fluent Validation - its much easier to work with in these cases, when you need conditional validation. Also it will keep your models cleaner.
So if you can - use Fluent validation, if not, just define your own property and control it in your code including all conditions. Examples and links to libraries are here
Here is another option for you - complete library built with aim to easy the work you trying to achieve : http://foolproof.codeplex.com/
Hope this helps

Data-annotation getting errormessage out database

With asp.net mvc you can use the annotation
[Required (errormessage="This is required")]
How can I create something like this:
[Required (errormessage="ERRORXX")]
So I can look up in a database what this ERRORXX is and display it on my form. Now my form displays ERRORXX.
How can I create something that solves my problem?
Thx!

Just an idea: why not pull the error messages from a resx file? I think this is the common way of doing this. It even allows you to localize your error messages easily.
I think that by using a resource file (resx file) it's even easier to change the error messages later on. A resx file can be opened and edited in Word Pad for example. You don't need to access a database with username/password, query it, etc.
Localizing ASP.NET MVC Validation
Globalizing ASP.NET MVC Client Validation
Take a look here too:
Model Validation & Metadata in ASP.NET MVC 2
Customizing ASP.NET MVC 2 - Metadata and Validation

The default route to take is with Resources.
However, I understand your pain :) The way I've achieved it is a little unusual, but I'll give you a quick rundown.
In our project, using resource files is not an option as its way too limited for our purposes, the details of which I won't bore you with now! :)
At it's most basic principle, we're setting the errorMessage property of the validation attribute to some sort of "key", and then just using that as a way to lookup the correct (languaged) response in our CMS database, when the validation fails (in our case using MVC, when we update the model and check the state - all at Controller level).
This is the same principle as using the resources (by specifying "ErrorMessageResourceName" and "ErrorMessageResourceType"), but you get to do what you want with it.
To be clear, we originally extended the RequiredAttribute (as one example) with our own stuff, including putting in properly named arguments to allow us to retrieve a sensible CMS value from the database later on. To be extra clear, we're using MVC and custom HtmlHelpers to render our own ValidationControls, which are what ultimately consume the custom values from our custom annotations, etc - None of this affects the dumbed-down principle here though, which is to just use "errorMessage" , or something like it, as a way to look up the actual message from where YOU want to, and WHEN you want to.

I think you mean you want to read/use attribute declarations for a given property?
If so, you could either make your own RequiredAttribute class (to allow adding new or more appropriate properties as you wish). See: Attributes Tutorial