$.jgrid.parseDate = function (format, value) {
}

Note: this .js file will need to be loaded after the JQGrid .js file

So first we will need to create some functions that will format our date into a string so that the sorter can handle it much better. I have included two functions below, that we use that both converts the .NET date type to a javascript data, and then converts it to a string in the format that we use.

function formatDateValue(value) {
var date = convertToDate(value);
var curr_date = date.getDate();
if (curr_date < 10)
curr_date = '0' + curr_date;
var curr_month = date.getMonth();
curr_month++;
if (curr_month < 10)
curr_month = '0' + curr_month;
var curr_year = date.getFullYear();
var datestring = curr_month + "/" + curr_date + "/" + curr_year;
return datestring;
}

function convertToDate(value) {
var date;
if (Object.prototype.toString.call(value) === '[object Date]')
date = value;
else if (value.indexOf('Date(') != -1)
date = new Date(parseInt(value.substr(6))); // json type
else
date = new Date(value);
return date;
}

Finally we need to just bring over the code from the JQGrid src and simply add a call to our function at the top:


$.jgrid.parseDate = function (format, value) {
var date = formatDateValue(value); //call to our function to correct the issue
var tsp = { m: 1, d: 1, y: 1970, h: 0, i: 0, s: 0 }, k, hl, dM, regdate = /[\\\/:_;.,\t\T\s-]/;
if (date && date !== null && date !== undefined) {
date = $.trim(date);
date = date.split(regdate);
format = format.split(regdate);
var dfmt = $.jgrid.formatter.date.monthNames;
var afmt = $.jgrid.formatter.date.AmPm;
var h12to24 = function (ampm, h) {
if (ampm === 0) { if (h == 12) { h = 0; } }
else { if (h != 12) { h += 12; } }
return h;
};
for (k = 0, hl = format.length; k < hl; k++) {
if (format[k] == 'M') {
dM = $.inArray(date[k], dfmt);
if (dM !== -1 && dM < 12) { date[k] = dM + 1; }
}
if (format[k] == 'F') {
dM = $.inArray(date[k], dfmt);
if (dM !== -1 && dM > 11) { date[k] = dM + 1 - 12; }
}
if (format[k] == 'a') {
dM = $.inArray(date[k], afmt);
if (dM !== -1 && dM < 2 && date[k] == afmt[dM]) {
date[k] = dM;
tsp.h = h12to24(date[k], tsp.h);
}
}
if (format[k] == 'A') {
dM = $.inArray(date[k], afmt);
if (dM !== -1 && dM > 1 && date[k] == afmt[dM]) {
date[k] = dM - 2;
tsp.h = h12to24(date[k], tsp.h);
}
}
if (date[k] !== undefined) {
tsp[format[k].toLowerCase()] = parseInt(date[k], 10);
}
}
tsp.m = parseInt(tsp.m, 10) - 1;
var ty = tsp.y;
if (ty >= 70 && ty <= 99) { tsp.y = 1900 + tsp.y; }
else if (ty >= 0 && ty <= 69) { tsp.y = 2000 + tsp.y; }
}
return new Date(tsp.y, tsp.m, tsp.d, tsp.h, tsp.i, tsp.s, 0);
}


Golf is a Patience game where players try to earn the lowest number of points (as in golf, the sport) over the course of nine deals (or “holes” to further use golfing teminology). It has a tableau of 35 face-up cards and a higher ratio of skill to luck than most other solitaire card games.

My attempts in this tutorial series will be able to keep the code reusable and hopefully build onto this series with other Card/Solitaire games.

XNA Tutorial Series 1: Golf (Patience) Solitaire Part III – Deck Class
For this tutorial we will focus on the class that will handle the logic for a group of cards. Start by right clicking on your classes folder and adding a new class called Deck.cs. The first thing we will need to do is setup are using’s as follows:

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;


Next set your class to be public.

Now we can begin by adding a Enum to our class to represent a deck type:

public enum DeckType
{
User = 1,
Source,
Waste,
Target
};


Now we can setup the individual properties that a Card will have, I will show the code first and then proceed to explain what each property is for:

protected List cards = new List();
protected Point pos;
protected int deckID;
protected DeckType deckType;
Texture2D background;

public DeckType Type
{
get
{
return deckType;
}
}

cards will be a list of the cards in the deck, pos is a point that is used for offsetting a card image so you can have one card on top of another and see the values for both. deckID is an ID for keeping track of the decks. DeckType to indicate the enum for which type of deck it is, and a texture to store the decks background.

Next we have our constructors:

public Deck()
{
deckType = DeckType.User;
}

public Deck(int id)
{
deckID = id;
deckType = DeckType.User;
}


Since this deck class is going to be a base type it will default to being a user deck, other deck types (waste, source, etc..) will implement the desk class. Next we will need some basic methods for maintaining the list of cards that are in the deck.

First we will need to be able to retrieve the number of cards in the deck:

public virtual int CardCount()
{
return cards.Count();
}

And finally get a card
public virtual Card GetCard(int index)
{
return cards[index];
}


In the second part of the deck class we will look at Adding cards, handling input, and drawing the cards.

My attempts in this tutorial series will be able to keep the code reusable and hopefully build onto this series with other Card/Solitaire games. Also this tutorial assumes that you have basic XNA knowledge.

XNA Tutorial Series 1: Golf (Patience) Solitaire Part I – Project Setup

Start by creating a new XNA 4.0 Windows game project. In my sample I named the project “Patience” but you are free to name it whatever you like. Then in the main project right click the project and add a new folder called classes. This will be where we define our game logic.

Also in your Content Project right click and add “Cards” and “Fonts” Directories. Where the actual game art will be stored. Right now that gives us the basis for starting our game. In the next tutorial we will focus on creating the Card class.

For this tutorial we will focus on the class that will handle the logic for one individual card. Start by right clicking on your classes folder and adding a new class called Card.cs. The first thing we will need to do is setup are using’s as follows:

using System;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;


Next set your class to be public.

Now we can begin by adding some Enums to our class. The first enum will deal with the suit of the cards:

public enum CardSuit
{
Clubs = 1,
Diamonds,
Hearts,
Spades
}

The next enum will be for the value of the cards:

public enum CardValue
{
Ace = 1,
Two,
Three,
Four,
Five,
Six,
Seven,
Eight,
Nine,
Ten,
Jack,
Queen,
King
}

The final enum will be for indicating what color the card is:

public enum CardColor
{
Black = 1,
Red
}


Now we can setup the individual properties that a Card will have, I will show the code first and then proceed to explain what each property is for:

public Rectangle CardRectangle
{
get
{
return rect;
}
set
{
rect = value;
}
}


The first three will be used to set the enums(Suit, value, and color) for the specific card. IsTurned will be used to determine if the front or the back of the card should be drawn. ParentCard and ChildCard will be used for indicating what card is above and below the card on the screen. ZOrder is similar to the css property z-index and will be used for card drag and drop. Though this game does not have drag and drop capability we are adding the ZOrder property for future use. CardName will be a string that will indicate which artwork to use, it will be made up of concatenating the cards suit with a “-” and the cards value. If you choose to use cards other than the ones I provide, please be sure they follow this naming convention. OwnerDeck will refer to which deck the card is currently in (draw pile, plateau, waste, etc…) this refers to a class that we will develop in part 3 of this series. Teh we have the OriginRect this is a placeholder value so that we always know where the card came from, in case we ever need to return it to that spot. Then we have two static variables for storing the size of the card. Next we have two XNA textures that will store the card image and the back of the card image. Finally we have the rectangle where those card images will be drawn.

Next up is the constructor followed by a description:

public Card(CardSuit suit, CardValue value, int z, ContentManager contentManager)
{
ZOrder = z;
ParentCard = null;
ChildCard = null;
OwnerDeck = null;

LoadCard(suit, value, contentManager);
}


Since we are just declaring the card and not yet putting it in a deck we will be setting several of the properties to null, and then lastly we call another method to load the cards content based on the suit and value that we passed in.

The cards Load method is detailed next:

public void LoadCard(CardSuit suit, CardValue value, ContentManager contentManager)
{
if (suit == CardSuit.Clubs || suit == CardSuit.Spades)
TheColor = CardColor.Black;
else
TheColor = CardColor.Red;

card = contentManager.Load("Cards/" + CardName);
}


Based on the suit we first determine the cards color, Clubs/Spades are black and Hearts/Diamonds are red. We set the cards suit and value from the passed in parameters and then we create the rectangle that will hold the card texture. Next we load the cards background picture into its texture, and then after determine the cards name we load the card image into its texture.

Finally we have the method that will draw the card to the screen:

public void Draw(SpriteBatch theSpriteBatch)
{
if (IsTurned)
{
if (card != null)
theSpriteBatch.Draw(card, CardRectangle, Color.White);
}
else
{
if (cardBack != null)
theSpriteBatch.Draw(cardBack, CardRectangle, Color.White);
}
}

Here we are determining if the card is face up or face down and drawing that particular image to the screen.

That is it right now for our card class. In the future it will be expanded more to handle different input types like drag and drop but for now clicking on the card is all that is necessary. Also not the reason the card has no coordinates is because it’s draw location will be based on the location of it’s stack/deck. Stay tuned for the next part in the series where we will make a deck class.

So that brings me to my solution which is simple and free, and no it is not braindumps which will just hurt you in the long run. Microsoft provides you all you need to prepare by giving you the outline. Utilizing the outline and MSDN it is relatively easy, though very time consuming, to essentially frame out your own book that will be current and error free. So for example lets take a look at the outline for exam 70-573: Microsoft SharePoint 2010, Application Development. The first section deals with interacting with the Sharepoint UI via .NET, more specifically in the first bullet point of utilizing the SPWeb and SPSite objects. What I will do is copy the contents of the outline in to my own html file and proceed to seek out links, preferabbly to the MSDN, detailing the content that the bullet point refers to. So for the example of the 1st bullet point in exam 70-573 the outline has as follows: (Content is subject to change at Microsoft’s discretion)

This objective may include but is not limited to: creating sub webs, referencing SPFiles, manipulating property bag, when to call Update, referencing SPContext, SPSite, SPWeb, SPSite.OpenWeb, SPWeb.Webs, feature activiation and deactivation

This objective does not include: trivial cases such as setting title and other loose properties of the objects

I then proceed to build up my content links similar to what I show here:

This objective may include but is not limited to:

• Site
  Architecture
• SPFiles
• SPContext
• SPSite
• 
  SPSite.Features
• 
  SPFeatureCollection
• SPWeb
• 
  SPWeb.Features
• 
  SPWeb.Properties
• SPSite.OpenWeb
• SPWeb.Webs
• 
  SPWebCollection
• 
  Disposal

Not only are you getting the content from the source that the exams are based off, but as you delve deeper and deeper into the MSDN you will get a more fuller and rewarding experience then most of the preparatory textbooks will provide. This has become a popular technique for preparation over the past few years, and sometimes you may find bloggers that will post their MSDN linked outlines online, but usually I prefer to create my own since they may have excluded content that they didnt neccesarily need for their own preperation. So hopefully this technique will help you some in your own preparation, and good luck.

By default this wonderful tool is not available but can be easily added. To install the dashboard launch the SharePoint 2010 Management Shell and enter the following command:

stsadm -o setproperty -pn developer-dashboard -pv ondemand


The ondemand option configures the dashboard to open only when you click the icon, other options are “on” for always on, and “off” to disable the dashboard. Once the command has successfuly installed the dashboard you will now have an icon in your portal like pictured below.

Happy Debugging!

http://[host_and_port]/webct/public/autosignon?wuui=[uid]&timestamp=[unix_epoch_time]&url=[url]&glcid=[glcid]&mac=[mac]

Replacing the following the bracketed items with:
[host_and_port] enter your WebCT server host and port number
[uid] the userid for the user that is being auto signed in.
[unix_epoch_time] the number of seconds since 1/1/1970, which we will calculate below
[url] the page in WebCT that the user will be directed to ex. cobaltMainFrame.dowebct is used for the default page
[glcid] this is an ID for the WebCT. Generally this is something you can get from your WebCT admin
[mac] this is the Message Authentication Code(MAC) which is the summed ASCII values of the [uid], [unix_epoch_time], and [url]. That value is then converted to a string and then the WebCT Shared Secret* is appended to the value. That string is then encrytped using MD5 and then converted to hexadecimal.

*WebCT Shared Secret is a secret passphrase stored in the settings of WebCT that generally this is something you can get from your WebCT admin

Now that we know what needs to be constructed, we can get to a little coding to build up the URL.

The first piece we are going to need is that odd unix_epoch_time value. To get we are going to have to take the current UTC time and subtract the number of seconds since 1/1/1970

string timestamp = ((Int64)(DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalSeconds).ToString();

The second piece is then the MAC. For this we will want to write a function that will accept our [uid], [timestamp], [url], and the Shared Secret. Since we will be just using the sum of the ASCII values for [uid], [timestamp], [url] I will just be passing them in all as one string with out spaces. (i.e. [uid] + [timestamp] + [url])

The following code sample will require these Includes:

using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;

     static string getMd5Hash(string input, string secret)
     {
            // get ascii of all param values
            int asciiValue = 0;
            byte[] value;

            for (int i = 0; i < input.Length; i++)
            {
                value = Encoding.ASCII.GetBytes(input.ToString().Substring(i, 1));//get the characters ASCII value
                asciiValue += Convert.ToInt32(value[0].ToString());//add to total
            }

            MD5 md5Hash = MD5.Create();
            byte[] data = new byte[16];

            //Hash the asciiValue + the secret
            data = md5Hash.ComputeHash(Encoding.Default.GetBytes(asciiValue.ToString() + secret));
            StringBuilder builder = new StringBuilder();

            //convert to hexadecimal
            for (int i = 0; i < data.Length; i++)
                builder.Append(String.Format("{0,2:x}", data[i]).Replace(" ", "0"));

            return builder.ToString();
        }

You now have the necessary values to build your URL for implementing SSO with Blackboard.

First we will need to create a class for the Html Helper, I usually prefer to add a folder to my solution called Helpers. Both the class and the method will need to be static. In addition you will need to add a HtmlHelper parameter to the method that is preceded by the keyword this. This first parameter of the extension method indicates the class that the extension method extends, which in our case would be a input control.


using System;
using System.Web.Mvc;

}
}


Next within our DatePicker Method we will want to add the input control and the Jquery, and I found this easiest way to do this was to use TagBuilders. The TagBuilder Class is a utility that easily allows you to build html tags. We will be using two TagBuilders, one for generating our input box, and a second TagBuilder for the script tag. An overview of the TagBuilder class can be found here. Any script tag will need to be written with the TagBuilders InnerHtml property, or it will be interpreted as text on the page. The resulting code is below:


using System;
using System.Web.Mvc;

var scriptBuilder = new TagBuilder("script");
scriptBuilder.InnerHtml = "$(function() { $('#" + id + "').datepicker();});";
return builder.ToString(TagRenderMode.Normal) + scriptBuilder.ToString(TagRenderMode.Normal);
}
}
}


Next to be able add the control easily on any page we will need to add the Namespace for our Helpers to the web.config file as shown below.


<pages>
<namespaces>
<add namespace="System.Web.Mvc" />
<add namespace="System.Web.Mvc.Ajax" />
<add namespace="System.Web.Mvc.Html" />
<add namespace="System.Web.Routing" />
<add namespace="MvcApplication1.Helpers"/>
</namespaces>
</pages>


Finally we can easily add our DatePicker control anywhere to our site with our new Extension.

Date: <%= Html.DatePicker("myDatePicker") %>


This short tutorial assumes that your site is already set up for using JQuery, and the UI controls. Details for using Jquery can be found here.

Unfortunately this is a step that will need to be reproduced each and every time a database refresh is done. So an approach that worked for us was to create a new EF4 model at runtime, injecting the required code into it.

To do this first you need to create a MetadataWorkspace (System.Data.Entity), which allows you to interact with model metadata.

MetadataWorkspace workspace = new MetadataWorkspace();

Next you will need to read the existing metadata from your current model and replace the text with the change we manually added before. To do this we will query the executing assembly for the Store Schema Definition Language (SSDL) file which is the file we initially had to manually edit.  You can locate the names of your SSDL, MSL, and CSDL in the web.config.

Assembly edmAssembly = Assembly.GetExecutingAssembly();
StreamReader metaReader = new StreamReader(edmAssembly.GetManifestResourceStream("Models.ModelName.ssdl"));
var text = metaReader.ReadToEnd();
text = text.Replace("<Property Name=\"RowGUID\" Type=\"uniqueidentifier\" Nullable=\"false\" />", "<Property Name=\"RowGUID\" Type=\"uniqueidentifier\" Nullable=\"false\"  StoreGeneratedPattern=\"Identity\" />");

Once we have a modified SSDL we can began to build a new EF4 model. This will require the other two components, the Conceptual Schema Definition Language (CSDL) and the Mapping Specification Language (MSL).

The MSL, SSDL, and CSDL did Snoop Dogg Come up with these names?

To get the MSL and CSDL we can just read them in with MemoryStreams (System.IO) like so.

var ms = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(text));
var sReaders = new[] { XmlReader.Create(ms) };
var mReaders = new[] { XmlReader.Create(edmAssembly.GetManifestResourceStream("Models.ModelName.msl")) };

var cReaders = new[] { XmlReader.Create(edmAssembly.GetManifestResourceStream("Models.ModelName.csdl")) };

Now that we have streams of the 3 necessary files we can assemble them into the model. For the SSDL we use a StoreItemCollection (System.Data.Entity) to load the xml file. For the CSDL we use the EdmItemCollection (System.Data.Entity) and then we map those to files to the MSL using the StorageMappingItemCollection (System.Data.Mapping).

var sCollection = new StoreItemCollection(sReaders);
var cCollection = new EdmItemCollection(cReaders);
var csCollection = new StorageMappingItemCollection(cCollection, sCollection, mReaders);

Now that we have our new EF4 model built we simply register it in the MetadataWorkspace.

workspace.RegisterItemCollection(sCollection);
workspace.RegisterItemCollection(csCollection);
workspace.RegisterItemCollection(cCollection);

Finally we declare are data model context with the new workspace and our connection string.

DBModel _db = new DBModel(new EntityConnection(workspace, (SqlConnection) connectionString));

We then have access to a new EF4 model at runtime that now has a GUID that can be an entity key. To be safe we then clean up any loose ends after committing the database changes.

ms.Close();
_db.Dispose();