The first is simple, a popup calendar: Dynamic Date Selector

This popup calendar works by using a hidden HTML table on your page. When you click in the box, the calendar is set to visible and moved around where you clicked. I chose this widget because it's easy to use and modify. All of the styles are in their own stylesheet, not embedded deep within the code, which makes customizing it very easy. I was also able to modify the code very easily to include a drop-down menu for the year and have a calendar icon to the right of the text box that I can click to open the calendar. Very useful little widget.

4 Stars for ease of use but potential div/table arguments.

Second, a JavaScript validator: JSValidate

This JavaScript tool is early in it's development. It's hard to say if there's much of a future for this project...we'll have to get to a version 1 before that's determined. Regardless, this script requires you to add a class attribute to your input fields...that's it. Give the class a name like "jsrequired" or "jsvalidate-number" to enable the validation. All the validation is done using regular expressions, and it's super-easy to add your own. It's a little tough to do two validations on one field (like required and number), but you can add two classes and it works. The only problem is that you get both error messages if either of the errors occur. The only other downside is that you have to add the "name" attribute to your form, which doesn't validate on XHTML strict, but that's reported to be fixed in another version. Overall, very nice and some beautiful effects. I hope to see this developed further.

3 Stars because it is an early version and does not fully validate.

Finally, the best of them all: GreyBox

GreyBox is a self titled "Pop-up window that doesn't suck". And that's right...it doesn't! This AJAX tool (AJAX is just JavaScript and other technologies mixed) rocks. You just click a link and it opens up in an in-browser window. It's not a real popup, just divs and tables mixed with some nice AJAX effects. The best way to see this is to just try it for yourself at the website linked above. Again, this is easy to install and use and looks great. I use it for input forms on my website.

5 Stars because it simply rocks.

However, we will require opportunities (since not everyone are suitable candidates to provide feedback to us. Think courtesy bias) and time to further improve ourselves. Does this mean that there's nothing much we can do in the meantime? Actually, no. There are two qualities that we can work on immediately. This is because developing these two qualities does not require substantial amount of time and effort. It just requires a change in mindset. So, what are these two qualities? It's sincerity and dedication.

All of us can be sincere towards our interactions with people and situation. We should refrain from merely showing sincerity. In fact, showing sincerity is simple. Fulfilling a promise, meeting a friend on time, helping someone in need are all examples of how we can express sincerity. However, there are some of us who stop here. This is insufficient.  When it comes to sincerity, we should live it. This brings us to the concept of intention. One can show sincerity in every aspects of one's communication but if one' intention is ultimately to deceive or to manipulate, then one is not sincere. In another words, we need to ask ourselves about what we wish to achieve with our intentions. If it's altruistic in nature or for the greater good, then it's great. If not, we need to question our intentions more closely, lest our sincerity become suspect.

Being sincere and expressing sincerity will enhance our interpersonal communication almost immediately. I am not saying this to satisfy one's need for instant gratification of positive results but rather, I am saying this as a fact. When we are sincere both in our mind, heart and speech, others are able to sense our sincerity and this is always a good start to an excellent communication process.

However, sincerity alone is insufficient. Another factor is required: dedication. Dedication is inseparable from consistency. When we look at someone who is dedicated in his work, they are usually very consistently in their work, working on their project continually till their tasks are completed.   So, how do we express dedication in our communications with others? We achieve this through a consistent display of sincerity with no signs of our goodwill abating anytime soon. Thus, it is through the coupling of sincerity and dedication that one achieves success in interpersonal communication.

Now, let's look at how these two concepts work together in the classroom and the workplace.

In the classroom, if educators are sincere and dedicated in the coaching of their students, students are usually attuned to their teachings. When the students are aware that their educators are sincere in their approach and dedicated in their guidance, the students will reciprocate with their gesture of goodwill as well. Many educators use discipline to maintain order in the classroom. While this is a feasible approach, winning the hearts of students is equally or even more important. And to win the heart of students, sincerity and dedication is important.

In the workplace, employers are able to display sincerity by treating each of their employees in an unbiased manner and reducing office politics (which usually undermine the credibility of sincerity in the workplace seriously). Employers should also display dedication through their personal display of dedication in their work, putting in their best effort in all of their endeavours.

The importance of sincerity and dedication goes way beyond one's ability to improve interpersonal communications. When others sense the existence of sincerity and dedication in our approach, I realise that they tend to ignore the areas that we might be not be very proficient in when we communicate with them.  It seems to be human nature that we are often vulnerable to a sincere display of sincerity and dedication.

This is probably why Beauty fell in love with the Beast eventually. Although the Beast's expression of sincerity and dedication is somewhat situational (he is a prince transformed into a beast by a witch of which only finding true love will allow him to recover his original form), it's undoubtedly a fact that it's sincerity and dedication that ultimately won the heart of Beauty.

The authorization class will not take care of a login script or anything validating a user trying to login on your application. If you need a easy and fast login script you can read all about that on my SQL Login post. This class will take care of the page validation you need to do to make sure the logged in user is valid. This is done by introducing three different types: roles, resources and actions.

A role represents a user group for example guest, member, staff or moderator. A resource is easily explained as an object such as news, articles, users or games. Lastly the action is something you want to do such as add, delete, edit, view or list. With these three types we are able to specify authorization rules for various roles.

"Hum, I still don't get it!"

The PHP Authorization Class will help us define and set up rules for different roles. We can apply various action rules onto our resources which are, in the end, connected to our roles. We take a look at a example. Say we have three different roles defined for our application:

• guest - a visitor on the site which are not logged in.
• member - a logged in visitor.
• admin - the administrator

To simplify our application we only have one resource on the site which is:

• news

If we look at the overall actions we would like to do with this resource we might end up with something like this:

• view - look at a specific news item
• list - look at all news items presented as a list
• add - add news
• edit - edit news
• delete - delete news

Going back to our roles, we don't want to let the guest role adding, editing nor deleting news. In this example we don't even let guests view a specific news. As for a member they should be able to view, list and add news. The administrator should be able to do everything. We can achieve this by writing something like this:

$authorization = new Authorization();
$guest = 'guest';
$authorization->addRole($guest);
$authorization->addAccess('news', $guest, 'list');

$member = 'member';
$authorization->addRole($member, $guest);
$authorization->addAccess('news', $member, array('view', 'add'));

$admin = 'admin';
$authorization->addRole($admin, $member);
$authorization->addAccess('news', $admin, array('edit', 'delete'));

The above code implements the description of rules we stated a bit further up. We made a DSL to implement our authorization class if you will. Let's look at the code in more detail to see if we find anything interesting.

$authorization = new Authorization();

We create our PHP Authorization object and assign it to a variable named authorization.

$guest = 'guest';
$authorization->addRole($guest);
$authorization->addAccess('news', $guest, 'list');

We assign the variable guest the value of 'guest'. Then we add that variable to our list of roles our authorization class holds. The third line adds access rules. We start with providing the resource, the role and lastly the action. We could skip the first line and just add 'guest' instead of $guest. So, to make this very clear: These three lines of code gives the user group/role guest the ability to list all news on the site.

The next two sections are very similar to the first except for two things:

$authorization->addRole($member, $guest);
$authorization->addAccess('news', $member, array('view', 'add'));

In the first section the addRole method only took one argument and here we have two. What does this mean? It means that the first argument will be extended with the second argument. In this case, member will be extended with guest. This is really useful if member should have the same access as guest plus a few more. We don't need to add the list action to member because guest already has it. Basically guest is the parent of member (which is acting like a child). Everything we add to guest is also added to member even if we decide to assign more rules to guest after we have defined and created the member role. Pretty sweet huh?

The other thing that differ is the number of actions you can provide to the addAccess method. You can add just one action as a normal string or provide an array of actions. Also very useful if a resource has a lot of different actions defined.

So, the code above created our three different roles and we applied different action access for each of the roles on our news resource. Now we are able to query our Authorization class to see if a specific role have access to a specific resource with a specific action. We do this by using the isAllowed method.

echo $authorization->isAllowed($guest, 'news', 'list') ? 'allowed' : 'denied';

What do you think? Is guest allowed to list the news? The answer is yes. Can answer these:

echo $authorization->isAllowed($member, 'news', 'list') ? 'allowed' : 'denied';
echo $authorization->isAllowed($member, 'news', 'add') ? 'allowed' : 'denied';
echo $authorization->isAllowed($admin, 'news', 'add') ? 'allowed' : 'denied';
echo $authorization->isAllowed($admin, 'news', 'list') ? 'allowed' : 'denied';
echo $authorization->isAllowed($admin, 'news', 'comment') ? 'allowed' : 'denied';

And the answers:

Yes, member is extended with guest and guest is allowed to list news.
Yes, member is allowed to add news.
Yes, admin is extended by member and member is allowed to add news.
Yes, admin is extended by member and member is extended by guest and guest is allowed to list news.
No, admin is denied to comment on news.

Pretty cool! This can be used in your PHP pages where you need to check if the user is valid. For example in your header file to make sure unauthorized users don't get access to your pages and files. To know if you should add a comment form or not you simple check if the role in question have the access to comment. You are able to be very specific and you can show different parts of the page depending on the role type.

Since the class doesn't require a database it's 100% customizable. You can add your very own roles, resources and actions. All of this sounds pretty nice but how would it work in real action? I will give you a sweet example.

To be able to check if the role has access to the resource with a specific action we need to know the role, the resource and of course the action. It might sound like a huge amount of effort to get this to work, but it isn't! The specific role needs to be fetch from the user in question. Let's say we have a database with users and each user has a access type, say A-C. Either you can use these values straight of as your roles or we can translate them to understandable roles: A = guest, B = member and C = admin. This can then be saved in a session or in anyway you know as long as you are able to access it often and fast. The get our hands on the resource and action we can use the splendid mod_rewrite found in the Apache server software. If you don't know what this module does, I suggest you take a peak at my other post about friendly URL's. If we use the .htaccess wisely we will be able to fetch the resource and action from our URL.

.htaccess example:

RewriteEngine on
RewriteRule ^([a-z_]+)$ /authorization/$1/ [R]
RewriteRule ^([a-z_]+)/$ /authorization/index.php?resource=$1&action=list
RewriteRule ^([a-z_]+)/([a-z_]+)$ /authorization/$1/$2/ [R]
RewriteRule ^([a-z_]+)/([a-z_]+)/$ /authorization/index.php?resource=$1&action=$2

In this example my root is /authorization. The first two rewrites takes care of an example looking like this:

http://www.dosspot.com/games

It will first add a / to the end and reload and send the user to my index page with two get variables resource and action. We we haven't added an action the default action is list. The other two rules are activated if we have applied an action to.

http://www.dosspot.com/games/view/

Now we are able to fetch the resource and action out from our GET array and see if the role is valid for this page. If not we send him/her of to another page. So now we have two examples where we use the Authorization class inside a page using the isAllowed method to see if the user in question should be able to do various actions. Or we can use the URL to fetch the resource and action in question and validate. In our index.php page it might look something like this:

if(isset($_GET['resource']) && isset($_GET['action'])) {
$resource = mysql_real_escape_string($_GET['resource']);
$action = mysql_real_escape_string($_GET['action']);
$role = $_SESSION['role'];
}

if($authorization->isAllowed($role, $resource, $action)) {
echo 'You are allowed';
} else {
echo 'You are not allowed in here!';
}

Pretty simple put yet effective. But! There is more to it! Now we have a set of methods we can use to grant access to resources with different actions. If a user doesn't have the access s/he is thrown out from that page. We might want to apply a few of these access rules to every role avaible and we don't want to use extend, because there might just be one access we want to share, and we don't want to write it twice. How can we do this? Simple, we add null instead of a role in the addAccess method. By supplying null as the role the access rule will be applied to all roles, including roles added after the null access.

So let's say we want our guest to be able to access both the list and add news. The member role should just be able to list, not add. In this case we cannot extend the member role with the guest role since then the member role would be able to add news. Here is some code:

$authorization = new Authorization();
$authorization->addAccess('news, null, 'list);

$guest = 'guest';
$authorization->addRole($guest);
$authorization->addAccess('news', $guest, 'add');

$member = 'member';
$authorization->addRole($member);
$authorization->addAccess('news', $member, 'view');

With this slightly different code everyone will be able to list the news but the guest will be the only one able to add news and member the only one able to view a news. If this would be a real case it would be very bad, in this example though it shows the example pretty well. Notice that member isn't extended by the guest role.

The next thing we might be interested in is how we save the authorization object. We can do this with a simple session or we can store it using the serialize method in PHP. Since we have been working with session before we are going to use the serialize technique. Basically we are able to serialize an object meaning that we are able to save it on a file. We can then just unserialize the file and get our object back. By doing this we can write our authorization code in one file, serialize it and remove that code. Since the object is stored in a file we don't need to create our object everytime we want to access it, we just unserialize the file and the object with it's current state it presented to us. Sadly I'm a newbie working with the serialize method so if you know any problems or errors working with it, please let me know.

We simply use the save() method in the Authorization class to serialize our authorization object. We are able to provide a filename, by default it's saved as authorization. With our .htaccess file we are able to block everyone out from this file and deny everyone trying to access it. In every page we want to validate the user we simple do this:

include('Authorization.php');
$object = implode("", @file("authorization"));
$authorization = unserialize($object );

We have to include the class file and then we read the file and finally use the unserialize method to unserialze the object and we assign it again to our authorization variable. Now we are able to use the object exactly the same as we did in the examples above. Combine this with the .htaccess rewrite options you will find it rather easy to control the visitors using your system. It's easy, straight forward and pretty cool!

The download below provides everything you will need to run the authorization class, including unit tests!

• Download the PHP Authorization Class

In this post we will try to explain what is a verbatim string.

An explanation of verbatim string in MSDN is:

A verbatim string literal consists of an @ character followed by a double-quote character, zero or more characters, and a closing double-quote character. A simple example is @"hello". In a verbatim string literal, the characters between the delimiters are interpreted verbatim, the only exception being a quote-escape-sequence. In particular, simple escape sequences and hexadecimal and Unicode escape sequences are not processed in verbatim string literals. A verbatim string literal may span multiple lines.

The MSDN explanation of  is clear cut enough but allow me to give you one example:

@"\w+([-.]\w+)*\@\w+([-.]\w+)*\.[A-Za-z]{2,4}$"

The above string is a regular expression for validating an email address.

Notice in the above string, I used the '\' (escape) character quite a number of times. But a closer observation will prompt one questions: none of the escape sequence make sense. This is where the @ character preceding the string come handy. The @ character basically tell the compiler to ignore escape character in the string that follows.

Without the preceding @ character, the above regular expression string should be written as:

"\\w+([-.]\\w+)*\\@\\w+([-.]\\w+)*\\.[A-Za-z]{2,4}$"

Hope this helps.

..:: Whereever you go, stay in touch. Download toolbar now! It´s free, private and secure. ::..

End Try
Return True
End Function

..:: Whereever you go, stay in touch. Download toolbar now! It´s free, private and secure. ::..

Guitar Guy is starting to seriously piss me off.

I mean, okay, as a person, I'm generally pissed off by at least a few things at any given time, but this is ridiculous.  The man is managing to both validate me and try to reject me at the same time, and unless I can repeatedly slap him or (preferably) get him into a dark corner and have my wicked way with him, I see no obvious resolution before my departure for the motherland.

Last night, work seeming futile because one of our rare, all-day Florida thunderstorms was in the works (usually there's 20 minutes of apocalyptic downpour, complete with hail and lightening, and then we're back to tropical blue skies with very little fuss), we all went in with low expectations for business and a laid back demeanor.

While chatting at the bar with my roommate and the hot gay bartender about his recent tryst with an ex, whom he now knows is in a relationship, I pointed out to him that his ex's new beau is in no way his responsibility.  To which the roommate responded, laughingly, "Yeah, this from the girl who wants to hook up with someone in a --."

And then we were cut off.  By Guitar Guy.  Rounding the corner.  Awkward.  He definitely knew something was up as we all fell silent and looked at him expectantly until he expressed a want for a bottle of water, which I was made to retrieve.

Anyway, as the night progressed, Guitar Guy continued his futile attempts to distance himself from me, by trying to not let me catch him watching me.  Now, okay, honestly, Guitar Guy, if you're really trying to distance yourself, wouldn't you just stop staring all together?

It got so ridiculous that, not only were other co-workers noticing, with laughs, that as soon as I'd glance at the stage, he'd quickly jerk his focus down to the floor and stay there for several minutes, but guests started to pick up on it too.

Around 2/3 of the way through the night, he almost slammed into me as I turned away from a table, and he quickly said he was sorry.  I'm not sure why, but my reply was a snippy, "Are you?"

I'm not sure why I said it.  All I know is that as I walked away, I heard him say "Yes?" in a puzzled sort of way.

I guess I should be over it, and maybe I would be if he weren't so cripplingly touchable, and if there weren't these moments that broke away from the irritation.  Last night, for example, after ringing in another 17 beers for my drunken table of Brits, I turned from the computer to search for someone to help me take down some garbage bags, and unexpectedly caught his eye, as he'd been intently watching me from the stage.

The song being performed at the moment was "I can't make you love me," which, while lyrically inappropriate, was tonally just fine.

My smile immediately slipped from my face and we remained trained on each other for a good fifteen seconds or so until, though it seemed to pain him, he forced himself to look away.  I was unexpectedly jolted by this, deep in my stomach, and I'm not really sure what it means.  The moment itself was intense beyond description.

Aside from getting a light up tee shirt that flashes the word "Sex?" when I push a button and using it on him every time no one else is looking until he cracks, I can't think of a good way to resolve this in a quick and efficient manner.

He needs to get out of his relationship, as it clearly isn't fulfilling him.  And then he needs to come over, and fulfill me.

I used to paint traditional portraits, still life, and the occasional abstract art when I felt really angry and short of the deadline and found that once the painting is hung and displayed for sale, it's your opinion of your piece that matters, not the concept, idea or message that's already obvious in your piece. I could've painted an upside down man and picked a random bullshit speech on agony and suffering completely out of the blue... and people would just eat it all up. I found that it didn't matter what subject I painted, I got the same kind of response whether something mattered to me or not. Are these people really “seeing” it? Are they really acknowledging my skill or are they just trying to be nice? It's difficult for me to take people's feedback seriously when it's meant to be an emotional transaction than validating what it is that I have achieved.

I have a tendency to be over critical of my artwork and point out obvious errors and critic it to try and get a response or opinion to help me fix the problem but all I would get is the “Oh, it's so wonderful!” No, you're not listening. I'm serious. Her eye is lopsided, he's missing his big toe, he has buck teeth, the orange looks like a miniature watermelon, it didn't matter how horrible or glaringly bad it was, I would get a response leading to a pat on the back. When I didn't respond appreciatively, I would get a puzzled look.

Everybody loves a modest talent up until that person fully realizes their capacity and acknowledges it them self. This is often unfairly labeled “arrogance” when truly it's just jealousy for this person's understanding of themselves better than you understand yourself. I draw and write because I enjoy doing it and because I believe other people might enjoy it too. It means more to me to actually draw and write than it is to hear and acknowledge someone's opinion about it. Sure, I enjoy reading feedback, but I'm not obligated to have to validate you or accept it. This is what's difficult about the arts or sharing interests, automatically it's considered something that everybody is obligated to have a say on and for you as the artist to take it even if it doesn't mean anything to you. Nobody likes a self-deprecating whore after a while.

I find that many people play a social echolocation game where they're only talking and socializing with other people simply to figure out who agrees with who and to validate their existence. They automatically become insulted when you don't recognize this. Honestly, you don't need any body's validation to feel important. You only need yourself.

It already takes a lot of courage to understand and accept yourself for who you are and what you value. Nobody else can do this for you but yourself. Before you can even start to appreciate something or someone, those feelings and thoughts start with you.

“To say 'I love you' one must first be able to say the 'I.'”

]]> http://vailo.wordpress.com/?p=51 Wed, 25 Jun 2008 06:02:52 +0000 vailo http://vailo.wordpress.com/?p=51 The PHP Forms class is the last class out of 4 in the PHP Class series #1. So far we have been looking at a Database Class, a Paging Class and a Record Class and now it's time to integrate and implement our Forms Class to get a good end on the first series. The reason for creating this PHP Forms Class is to make working with forms and validating forms a lot more fun and easy. We have a few goals we want the Forms Class to for fill:

1. Extracting all form tags and attributes into our Forms class.
2. Auto-generate a form based on a table in a MySQL database.
3. Validate form fields using keywords such as letter, number, string, email, text and file.
4. Add, edit and delete form fields from a form based on a table or built from scratch.

UPDATES: This walkthough is covering the basics of the PHP Form class. The download at the bottom of the page includes the very latest version which might be slightly different than the walkthough here!

Okay, looking a bit closer at our goals we see that the second goal is rather complex. If we manage to pull it off it will be really sweet. We need to handle normal form fields, text fields, file fields and select boxes, radio boxes and checkboxes. And all this needs to be auto-generate just using information from our MySQL database. We will work with three different pages: the one handling the Forms Class, the JavaScript handling the AJAX and the PHP validation script. Before we continue I want to tell you that none of these PHP classes is 100% correct or flawless. I'm posting them here to get input from you and share my ideas.

All 4 goals will be reach using 12 different functions and 7 private class variables and 1 static privat  variable. We start presenting the private class variables:

• $_fields: is a array containing all form fields
• $_method: is either 'POST' or 'GET', used when applying the <form> tag.
• $_action: contains the URL we should go to when the form is validated an submitted.
• $_id: each form we create will have a unique id, we can either provide one or it will get an auto-generate form id.
• $_db: holds and database instance.
• $_table: the name of a database table.
• $_validate: a boolean variable telling us to validate or not.
• $_numForms: the static private variable, counting how many forms we create.

The functions in the form.php file are:

• public __construct(): initializing our form object.
• public addField(): we use this to add a form field to our object.
• public getField(): returns the given form field.
• public setField(): updates a given form field.
• public setAttribute(): updates a attribute of a field in the form fields arra.
• public removeField(): removes a given form field.
• public generate(): generates a form from a specific MySQL database table.
• private createField(): creates the actual html markup
• private createLabel(): help function to createField(), generates a label.
• pubic validate(): makes it possible to turn off the validation script.
• public create(): sets everything together.
• public view(): used for debug.

Starting with the __construct() function we are required to supply at least 2 parameters: $method and $action. They have the same task as in normal HTML markup, the $method decide if we should use 'GET' or 'POST'. The $action let us know where we are suppose to go when the form is valid and submitted. Then we are able to supply a third parameter in a array. The array can have an 'id', 'db' and 'table' key. Even though the Form Class gives a unique id to every form we create we might want to supply our own id, this is done here. As for the 'db' and 'table' key, these are used when we want to auto generate a form using the generate() function. Since the third parameter is optional we don't need to supple a 'db' and 'table' to be able to create a form from scratch. At the very end of the function we create a $_SESSION which we will use when we validate. The main task of the function is to assign our private class variables with the incoming parameters. We are using static class functions from the Common Class.

Next, public addField(). The function takes 3 parameters, 2 required, 1 optional. The required once are $name, $type and the optional $attributes.

• $name: the name of the field.
• $type: which type the field should be. (text, password, textarea, select, radio, checkbox)
• $attributes: a vast list of key => value entries in an array. Each one will be described in the validation presentation.

The function assigns new fields into our class variable $_fields. If we find a field with the type = file we change the private variable $method to post. The $attribute parameter is the magic parameter holding all information regarding validation. We check if we want to show labels and if we find any 'snippets'. A snippet is a piece of code we want to add after the field.

Next four functions are rather easy and self-telling. We use these functions to manipulate fields already added in the private $_fields variable, which were created from our auto-generate function. We might want to remove fields, edit field values or validation rules, look at a field and more. The functions I'm talking about is getField(), setField(), setAttribute() and removeField(). We just make sure the parameter, $key, is found in our private $_fields array. The $key must be the name of the field.

This next public function is a rather large one, but not that complicated. The generate() function is the function making this Form Class interesting. The function takes 1 optional parameters: $attributes. The $attributes parameter is an array of default values and default validation rules. The first thing we do is to see that we have added a database object and a table to work on. After that we gather information from both the mysql_fetch_field method and by using the 'SHOW COLUMNS' query command. This is because we want to know two important things:

1. When we encounter a blob, we need to know if it is of data type text or a file. This can't be done just using mysql_fetch_field.
2. When we encounter a enum, we want to be able to get all values in a nice radio link. This can't either be done just using mysql_fetch_field.

The two ways of getting information about a MySQL field is sometime overlaying each other, meaning we get the same information twice, at least we are able to fetch the same information from both techniques. Sadly non of them alone is supplying enought information, therefore we use both techniques.

Inside the for-loop we are able to set validations rules to each field depending on the data type of the field in the database. The validation rules are these: required, format, min, max, label, showLabel, boxClass, fieldClass and snippet. This means we can set a max value and a min value. We are able to see if the field is required or optional and set a validation rule for that. Each field will get a 'format' rule depending on the data type. If the name of the field is 'email' or 'password' we use special format validation rules. We can supply a class for the form field and a box class for the div around each form field. At the very end we add each field to our private $_field array using the addField() function. Basically this function takes one field at a time found in the supplied MySQL database table. We gather as much information as possible about the field and then make desicions about which validation rules the field should get. When we are done we add it to the private $_fields variable.

Puew, that's a long function but each line is small and simple. The next function, createField() is also a long function but a very simple one. The function will create a correct label and form field with the HTML markup code. We will look at the field and see if the field type matches anything of: text, password, hidden, file, radio, checkbox, textarea, select or submit. If it does we create the HTML markup code. Together with this function we use createLabel(), it will create the label for the field and it's used as a help function to createField(). The code itself is not that complicated so I will not describe it any further, it's just made up of if/elseif to find the correct field type.

The next three functions are similar the ones found in the Database Class and the Paging Class. The first one is validate(), with this you are able to turn of the validating script when setting the incoming parameter to false, the validating script is true as default.

The create() function will gather all the information about the fields we have provided and finally end up adding the form tags making it possible to echo out the result as a working form with correct and valid syntax. Lastly we have the view() function which is used when we want to debug our form, we are able to see which fields we have, the validation rules, values and much more.

Okay, we are done with the first part of the Form Class We have presented the actual Form class. With this we are able to write a form using this syntax:

We create our form object with the two required parameters 'GET', 'default.php' as $method and $action. We add two fields named 'username' and 'password', each with 'text' as type for 'username' and 'password as type for the 'password' field. Then we add the validation rules with different formats, both fields are required and the minium length of the field must be 3 chars long. Lastly we add the 'submit' button.

This next example will show two new things. We will fetch values using our Record Class from a user, we will use the get_values() from the Record class. Secondly we will auto generate the the same form we did in example one. We will add a 'db' and a 'table' key where we create our object. We will then add the values we fetched from our user to our generate() function and the username field will get a default value (password will be empty because that field is empty in the database).

Both example results is shown here:

Okay, so there we have it. This is the Form Class part 1. Coming up is the JavaScript file and the validation PHP page. You might wonder why we will use a PHP page to validate our fields, this is only because we have the Form class containing our fields which we are going to validate.

You can download the full PHP source code of the Forms Class right here:

• Download the PHP Forms Class source code
• Continue reading about the Forms Class JavaScript
• Continue reading about the Forms Class Validation script
• See the PHP class examples

#1 Find the id of the lifecycle with DQL:

SELECT r_object_id FROM dm_policy WHERE object_name='<your_lifecycle>'

This returns the CURRENT version of the lifecycle

# Use API to validate, install:

validate,c,<dm_policy_id>
install,c,,<dm_policy_id>

[sourcecode language='html']

[/sourcecode]

[sourcecode language='php']
class ProdutoController extends Zend_Controller_Action
{

function insere(){

// Pegando os valores da camada de visao

$nome = $this->_request->getParam("nomeProduto");
$valor = $this->_request->getParam("valorProduto");

// Dando Loader na classes de validacao
Zend_Loader::loadClass('Zend_Validate_StringLength');
Zend_Loader::loadClass('Zend_Validate_Float');

// Instanciando os validadores
$validadorNome = new Zend_Validate_StringLength(1,100);
$validadorValor = new Zend_Validate_Float();

// Setando as mensagens e os tipos de validação
$validadorNome->setMessage(
"Campo nome é obrigatório".,
Zend_Validate_StringLength::TOO_SHORT);

$validadorNome->setMessage(
"Campo nome maior que o permitido.",
Zend_Validate_StringLength::TOO_LONG);

$validadorValor->setMessage(
"Campo valor nao é um número válido.",
Zend_Validate_Float::NOT_FLOAT);

// Verificando se os valores digitados sao válidos
if ( $validadorNome->isValid(trim($nome)) &&
$validadorNome->isValid($nome) &&
$validadorValor->isValid($valor) ){

// Executa os procedimentos para insercao

} else {
// Deu erro na validacao

$msg = array_merge( $validadorNome->getMessages(), $validadorValor->getMessages() );

// Na variavel $msg vai ter todos os erros apontados no formulario,
//basta exibir em um alert ou direto no corpo da página.
}

}

}
[/sourcecode]

Uma boa prática é carregar todas as mensagens em um arquivo texto ao invés de utilizar as mensagens direto no arquivo do controller, apesar de php ser uma linguagem script e nao ser necessário a compilação de todo o sistema para apenas a troca de uma mensagem, um arquivo texto com todas as mensagens é válido pois iremos ter centralizado todas as mensagens.

Pode usar um absctract controller que faz esse papel, colocando a mensagem na camada de visao pois ela poderá usar em todos os controladores.

connect target /

run {
# set disk to be default device type
CONFIGURE DEFAULT DEVICE TYPE TO DISK;
# number of concurrent sessions to spawn
CONFIGURE DEVICE TYPE DISK PARALLELISM 10 BACKUP TYPE TO BACKUPSET;
# check datafiles for corruption 10 datafiles in each session
BACKUP VALIDATE CHECK LOGICAL DATABASE FILESPERSET=10;
}

Corruptions information are recorded in the V$DATABASE_BLOCK_CORRUPTION view.

You might have noticed this logo on some websites . Well, this logo means that the page you are surfing is created according to the norms given by W3C, for creating a XHTML Page. W3C has also given standards for HTML, XHTML, CSS and FEED.

Read the full article here.

You might have noticed this logo on some websites . Well, this logo means that the page you are surfing is created according to the norms given by W3C, for creating a XHTML Page. W3C has also given standards for HTML, XHTML, CSS and FEED.

Creating a validated page helps a lot in making it cross-browser. We should always try to create a validated page, as it also makes easier for the search-engine crawlers to find them. And it only requires a little more time but gives a good impression on our visitors(mainly professional) that we are following the standards. Now let me tell you, how to validate->

How to validate:

1. If you are planning to validate a HTML or XHTML document, then follow this link. Click Here.
2. It offers validation by three types, i.e., url validation, file upload validation and validation by direct input.
3. If you happen to validate a CSS file, then follow this link. Click Here.
4. If you want to validate a feed, then follow this link. Click Here.

Now you know how to validate. Follow the following links for a demonstration:

• XHTML Validation. Click Here.
• CSS Validation. Click Here.
• FEED Validation. Click Here.

So next you are creating a webpage, remember to validate it. Till then Happy Reading :-D. Don't forget to post your valuable comments.

Note:

If you ever happen to face problem with validation, you are free to contact us. We will try our best to help you.

Pesquisa vai pesquisa vem eu leio num tutorial do TaQ que essas mensagens só podem ser corrigidas pela alteração do código Rails.. vixi Maria.. tudo que eu não curto fazer: explorar código alheio.. e tem mais.. eu deveria modificar novamente no servidor remoto final ! Como ela não falou mais nada, eu deixei quieto né :P Logo depois me passou a tarefa de validar CPF/CNPJ, então, nas minhas explorações por um código pronto decente ouvi falar de um tal de Brazilian-Rails, instalei o bixinho e pá.. ele não valida CPF coisa nenhuma.. uhaehusahehuaeaueauh (não que eu saiba pelo menos) PORéM descobri que ele faz coisas muito mais importantes !

Benefícios:

• Altamente facil de usar.. precisou de uma função ela tá na mão !!
• Free & Open.
• Ainda em desenvolvimento (nesse caso isso é bom:P )
• Tradução das terríveis msgs de erro do validate
• Só colar no Vendor>Plugins e reiniciar o server que já está funcionando !
• Conversões extremamente intuitivas.
• Pluralização em portugues !

Homepage do Projeto: http://brazilian-rails.rubyforge.org/ Procurem como funciona por lá ok ?
Meu MIRROR NA UEL, (principalmente para aqueles que sofrem no download de baixo de proxy)
(esse mirror não é oficial da faculdade e o servidor cai as vezes ok ??)
Versão de Abril de 2008 !

http://validator.w3.org/

In giro esistono molti programmini per controllare se una carta di credito è valida o falsa. Ho deciso però anche io di scriverne uno semplice semplice in java. Per farlo,ho usato l'algoritmo di Luhn. Con lo stesso algoritmo potrete creare anche un generatore di carte di credito. Eccovi il mio scriptino:

[sourcecode language="java"]
public class ValidateCard {

public static void main(String[] args) {
if (args.length < 1) {
System.err.println("Wrong Usage. Use: ValidateCard Card_Number");
System.exit(1);
}

for (int i = 0; i < args.length; i++) {
System.out.print("Card '" + args[i] + "'" );
if (!args[i].matches("^\\d{13,19}$")) {
System.out.println(" Error,must be 13-19 digits.");
}
else if (Validate(args[i])) {
System.out.println(" is a valid credit card.\n");
}
else{
System.out.println(" is an invalid credit card.\n");
}
}

}
/*
La formula di Luhn si basa su tre semplici passaggi:

1. Moltiplicare per 2 ogni cifra posta in posizione dispari, se il risultato è composto da un numero a 2 cifre, bisogna sommarle in modo da ottenere un’unica cifra (es. 18 = 1+8)
2. Sommare tutti i risultati ottenuti
3. Sommare al risultato le cifre di posizione par
*/
public static boolean Validate(String Card_Number){

int tot = 0;

for (int i=0; i<= Card_Number.length() - 1; i+=2) {
int temp = Integer.parseInt(Card_Number.substring(i, i + 1));

temp *= 2;
if (temp > 9){
temp = (temp % 10) + 1;
}
tot += temp;
}
return (tot % 10 == 0);
}

}

[/sourcecode]

System administrators have ripped Microsoft Corp. for pushing a trial anti-piracy program meant for limited distribution to all enterprise update servers, a mistake that has triggered false warnings of Office counterfeits.

Earlier this month, Microsoft announced it would kick off a pilot program for software to display nagging notices on copies of Office that it deems fake. The program, part of the Office Genuine Advantage (OGA) initiative, which already requires users to validate their software as legitimate, was to run in only four countries: Chile, Italy, Spain and Turkey. The notices would appear on machines running phony copies of Office XP (called Office 2002 by some), Office 2003 and Office 2007.

Last Tuesday, however, Microsoft published the test update to all Windows Server Update Services (WSUS) servers, and did not limit its delivery to end users in Chile, Italy, Span and Turkey. WSUS is the primary update mechanism used by businesses to patch their Microsoft software. Later, Microsoft said the mistake had seeded the OGA update to WSUS servers for about 24 hours.

By early Wednesday, administrators in the U.S., U.K., New Zealand and elsewhere were posting messages on Microsoft support newsgroups, asking why their WSUS systems had received the Office nag. In some cases, administrators reported that the update had fingered large numbers of desktop PCs as running counterfeit copies of Office.

"Update KB949810 arrived via WSUS yesterday and now all my XP workstations running Word 2002 are telling me it needs activating," said a user identified as "morriswoodyman," who said he is in the U.K. "The only problem is that the software is genuine and was activated three years ago," the user added in a message to a Microsoft support newsgroup.

The support document morriswoodyman referenced -- KB949810 -- is the one associated with the OGA notification update, and was how WSUS labeled the update in its listings.

Source: ComputerWorld Security

We can write a JavaScript that can validate a page on given parameter. Below I have written a very simple JavaScript function to test a page's web standard. But you can customize it according to your requirements. This kind of JavaScript function can be helpful when we have lots of pages and we need to check them one by one by just clicking a button. Now let us make a HTML page with a JavaScript function and we will give validator.html as its name. The page's code is as below:

<html>
<head>
<title>W3C Web Standard Test</title>
<script language="javascript" type="text/javascript">

function testMyPage(webpageLocation)
{

var url = 'http://validator.w3.org/check?uri=' + webpageLocation;

window.open(url, '', 'width=775, height=500, status=yes, resizable=yes, scrollbars=yes, location=yes');

}

</script>
</head>
<body>

<input name="Button" type="button" value="Test My Page" onclick="testMyPage('www.wordpress.com');" />

</body>
</html>

A new window opens with your given page location i.e. url as below:

Remember that the above window may not appear if you have a pop-up killer active. I suggest you turn off the pop-up killer program (if any) to test the code.

Now, if your page passes the validation, you will get a "This Page Is Valid XHTML 1.0 Transitional!" message. You will also get a congratulations message. If you want, you can use available options such as Show Source, Show Outline, Validate error pages, Clean up Markup with HTML Tidy etc. and revalidate the page.

If you want to test the current page, the validator.html page's code will be as below:

<html>
<head>
<title>W3C Web Standard Test</title>
<script language="javascript" type="text/javascript">

function testMyPage()

{

var url = 'http://validator.w3.org/check?uri=' + window.location.href;

window.open(url, '', 'width=775, height=500, status=yes, resizable=yes, scrollbars=yes, location=yes');

}

</script>
</head>
<body>

<input name="Button" type="button" value="Test My Page" onclick="testMyPage();" />

</body>
</html>

What I have done here is --- I just changed the webpageLocation parameter to window.location.href.

I must mention one thing and that is you cannot validate i.e. test web standard of any page that is located in your localhost.

Thus, this is very easy but important to validate our pages. I believe validation should be a part of professional website development although it takes some time. But it is a benchmark of the quality of your webpage.

OK. That is all I know.

Bueno aquí va como hacer dicho método:

1. Primero debemos cerrar todo producto de Microsoft Office.

2. Vamos a  Inicio > Ejecutar > Escribimos regedit

3. Debemos buscar esta entrada:

HKEY_LOCAL_MACHINE\software\Microsoft\office\12.0\registro

Una vez encontrada dicha entrada, debemos de buscar otra subentrada como esta:

HKEY_LOCAL_MACHINE\software\Microsoft\office\12.0\registro \ {90120000-0030-0000-0000-0000000FF1CE

O una como esta:

HKEY_LOCAL_MACHINE\software\Microsoft\office\12.0\registro \ {91120000-0011-0000-0000-0000000FF1CE

4. Debes de asegurarte que aparezca dentro de esas subentradas el nombre del producto del Office, como por ejemplo:

ProductName=Microsoft Office Professional Plus 2007
ProductName=Microsoft Office Enterprise 2007

5. Una vez encontrada las algunas de las claves antes mencionadas, busca estas entradas del regedit y eliminalas:

DigitalProductID
ProductID

Lo que hicimos fue borrar la clave del producto del Microsoft Office, ahora haremos que nunca más la pida:

6. Vamos a la carpeta de instalación del Microsoft Office 2007, que debe de estar en esta dirección:

C:\Archivos de programa\Archivos comunes\Microsoft Shared\OFFICE12\Office Setup Controller\Proof.es

También debemos hacerlo para la carpeta Proof.en, que es esta:

C:\Archivos de programa\Archivos comunes\Microsoft Shared\OFFICE12\Office Setup Controller\Proof.en

Buscamos el archivo: proof.xml y lo abrimos con el Bloc de Notas.

Y editamos la penúltima línea:

<Feature Id="SetupXmlFiles" Cost="1359">
<OptionRef Id="AlwaysInstalled"/>
</Feature>

Le quitamos el AlwaysInstalled y le ponemos: neverInstalled. Debe de quedar algo así:

<Feature Id="SetupXmlFiles" Cost="1359">
<OptionRef Id="neverInstalled"/>
</Feature>

Fuente:http://www.luiskano.net/

 One of the first things that made my head go around was the Task Sequencer. I've never worked with SMS but who did, told me it was something similar to what we call today Microsoft Deployment tools.

Now, here it's some info that I've extrated from Deployment_Customization_Guide.doc about the task sequences that are set by default when you install MS Deployment:

The Microsoft Deployment process occurs in phases that are defined in the TS.xml file. Task Sequencer parses the TS.xml file to identify the appropriate sequence for performing the deployment process. The phases defined in the TS.xml file include:

Validate Phase
Performs validation checks to make sure that the operating system installation can proceed; specifically blocks installation on server operating systems.

State Capture Phase
Gathers information from the configuration file, databases, and the local machine to determine how the image installation process should proceed, including whether there is enough space to do a local USMT state backup. The scripts also invoke the USMT Scanstate.exe command as appropriate.

Preinstall Phase
Confirms that the necessary information has been gathered in the State Capture Phase for the Refresh Computer and Upgrade Computer scenarios. In the New Computer and Replace Computer scenarios, the script gathers the necessary information in this phase because these scenarios do not perform the State Capture Phase. Also, a backup of the computer can be optionally performed for the Refresh Computer and Upgrade Computer scenarios.

Install Phase
Installs the target operating system on the target computers.

Post Install Phase
Updates the Sysprep.inf file, Sysprep.xml file, or Unattend.txt file with information gathered in the previous custom actions based on the operating system being deployed.

State Restore Phase
Invokes the USMT Loadstate.exe command to restore the user state that was previously backed up.