Geekswithblogs.net

Use Hand Coding Coded UI Test For Automated Vs2010 Test Scripting

AbhishekLohani — Tue, 07 Feb 2012 07:56:21 GMT

Coded UI Test comes news with Vs2010. Use Hand Coding Coded UI Test For Automated Vs2010 Test Scripting Hand Coding Coded UI Test use the scripting Language c# or vb.net Thanks Abhishek

An alternative to cursor

saiful — Tue, 07 Feb 2012 05:28:26 GMT

While working with database we often require to use Cursor. Cursors force the database engine to repeatedly fetch rows. This may slow down your database and locking may occur. As a result cursor are not suggested to use if not extremely necessary.

If there is a primary key on a table, you can usually write a WHILE loop to do the same work without incurring the overhead of a cursor. The following example demonstrate the idea:

Declare @ItemId bigint

Declare @OldItemCode varchar(50)

SELECT Top 1 @ItemId= ItemId, @OldItemCode=OldItemCode

FROM InvItem

WHERE (IsStockItem = 'true')

WHILE @ItemId is not null

BEGIN

print 'Item: '+convert(varchar(10),@ItemId)+' - '+convert(varchar(50),@OldItemCode)

if exists (select ItemId from InvItem where IsStockItem=1 and ItemId>@ItemId)

begin

SELECT Top 1 @ItemId=ItemId, @OldItemCode=OldItemCode

FROM InvItem

WHERE (IsStockItem = 'true') and ItemId>@ItemId

end

else

begin

set @ItemId=null

end

END

Using Entity Framework to Query Dynamic Types

David Barrett — Mon, 06 Feb 2012 23:21:41 GMT

I ran across a unique scenario recently, and I’m not sure if I should be proud of the solution, or appalled at the Frankenstein result. Either way, I thought I’d post about it to possibly help others in the same situation.

I was developing a website leveraging jQuery / AJAX to query views of data at runtime. The kicker? I didn’t know which views. The choice of database view was determined via configuration and user choice.

I was leveraging jqGrid for the client-side grid presentation, sorting, filtering, etc. I was also proving out an approach using the MVC library for jqGrid to bind and query for results (this isn't necessary for this discussion, but was the original reason to create this solution, as we’ll soon see).

The jqGrid MVC library uses IQueryable data sources to bind to the grid. IQueryable in and of itself isn’t that hard to produce, but what about when you don’t know what the type will look like (read => the view you’re binding to is unknown at runtime)? It sure would be nice to leverage an existing technology like Entity Framework, but EF assumes you know the tables / views in advance. It’s not a bad assumption; but I definitely have an edge case here.

So, the summary is: how do you return an IQueryable<T> when T is unknown at compile-time?

There are some constraints here, all of which makes this solution more palatable/scary:

I don’t need to worry about database updates. Views are hard to update, anyway, usually requiring INSTEAD OF triggers.
I could eliminate EF and just run a straight database query, mapping the datareader into a List<T>, where T is dynamically typed at runtime. I could then return List<T>.AsQueryable(), but I lose something significant: deferred execution. I’m returning the entire resultset and then using Linq in memory to sort and filter the result. What if I have a million rows? Awful.

So, I set about to force EF into helping me solve the problem. Nothing like forcing a square peg into a round hole.

First off, how do I create an EF context that will return dynamic results? This part is fairly simple.

/// <summary>
/// Context class for dynamic queries and catalog information
/// </summary>
public class QueryCatalogContext : DbContext
{

    /// <summary>
    /// Initializes a new instance of the <see cref="QueryCatalogContext" /> class.
    /// </summary>
    /// <param name="model">The model.</param>
    public QueryCatalogContext(DbCompiledModel model)
        : base("NewmontDB", model)
    {
        modelProvided = true;
    }

EF allows us to provide a model at runtime, so assuming I can define a model based on my run-time view, I’m OK there. Now how do I return an IQueryable<T> from this context?

/// <summary>
/// Gets a set of generalized query results.
/// </summary>
/// <param name="query">The query.</param>
/// <param name="columns">The columns.</param>
/// <returns></returns>
public IQueryable<T> GetDynamicQueryResults<T>(QueryMetadata query)
{

    List<ColumnMetadata> columns = this.GetColumnMetadata(query);

    string className = QueryTypeFactory.GetType(query, columns).Name;

    // Build the query and execute
    string sql = string.Format("SELECT VALUE {0} FROM CodeFirstContainer.{0} AS {0}", className);
    return new ObjectQuery<T>(sql, ((IObjectContextAdapter)this).ObjectContext, MergeOption.NoTracking);

}

GetColumnMetadata is an internal function that returns a list of column (class property) metadata based on the particular query metadata (it does this by querying the database for view column metadata). QueryTypeFactory uses the Dynamic Linq Library to stamp out (and cache) types based on a set of properties (the columns I just retrieved). I then turn that type info into an EF SQL statement and return an ObjectQuery<T> with no tracking.

OK, that’s fine and dandy, but how do I provide the model and, more importantly, how do I call the generic method if I don’t know what T is in advance?

The service class that actually executes the query using the context passes in the model and calls the generic method. That mechanism follows:

/// <summary>
/// Gets the dynamic query results.
/// </summary>
/// <param name="query">The query.</param>
/// <param name="columns">The columns.</param>
/// <returns></returns>
public IQueryable<T> GetDynamicQueryResults<T>(QueryMetadata query, List<ColumnMetadata> columns) where T : class
{

    // Define a dynamic type and create a configuration for it
    DbModelBuilder builder = new DbModelBuilder(DbModelBuilderVersion.V4_1);
    EntityTypeConfiguration<T> configuration = (EntityTypeConfiguration<T>)Activator.CreateInstance(typeof(DynamicViewConfiguration<>).MakeGenericType(typeof(T)), query, columns);

    // Add configuration for dynamic type
    builder.Configurations.Add(configuration);

    using (SqlConnection connection = new SqlConnection(ConfigurationManager.ConnectionStrings["NewmontDB"].ConnectionString)) // Only need the connection for building the model;

    {
        // Can't use implicit IDisposable because the context is needed when the IQueryable is evaluated.
        QueryCatalogContext context = new QueryCatalogContext(builder.Build(connection).Compile());
        return context.GetDynamicQueryResults<T>(query);
    }
}

First, the service class creates a DbModelBuilder. The magic happens in the next line. Because I don’t know the type T at runtime, I need to use reflection to create an instance of the DynamicViewConfiguration<T> class. I then pass this to the model builder (this class is an EntityTypeConfiguration<T>). I use a new connection string for building the model (EF has to query the view for metadata) and then compile the model, passing it into the context constructor. I then return the GetDynamicQueryResults<T> method, returning a true IQueryable<T> object.

The DynamicViewConfiguration<T> class is used to define the model for EF. At a minimum, models must define what table they map to and what constitutes the primary key. This is what the DynamicViewConfiguration<T> class does.

/// <summary>
/// A dynamic entity configuration for views specified at run-time.
/// </summary>
public class DynamicViewConfiguration<TDynamic> : EntityTypeConfiguration<TDynamic> where TDynamic : class
{

    /// <summary>
    /// Initializes a new instance of the <see cref="DynamicViewConfiguration" /> class.
    /// </summary>
    /// <param name="query">The query.</param>
    /// <param name="columns">The columns.</param>
    public DynamicViewConfiguration(QueryMetadata query, List<ColumnMetadata> columns)
        : base()
    {

        // Locate key column (TODO: Handle multiple key fields)
        ColumnMetadata key = columns.FirstOrDefault(c => c.IsKey) ?? columns[0];
        Activator.CreateInstance(typeof(DynamicViewLambdaGenerator<,>).MakeGenericType(typeof(TDynamic), key.DataType.ClrType), this, key.Name);

        ToTable(query.Name);

    }

}

DynamicViewLambdaGenerator<T> is an internal class that defines the lambda for the PK (the key field).

/// <summary>
/// Internal class to generate lambda expressions for the configuration
/// </summary>
internal class DynamicViewLambdaGenerator<TDynamic, TKey> where TDynamic : class
{

    // TODO: Change to a stateful approach and cache reflection and expressions if usage of this class increases
    private readonly Type type;
    private readonly string keyPropertyName;

    /// <summary>
    /// Initializes a new instance of the <see cref="PropertyLambdaGenerator" /> class.
    /// </summary>
    /// <param name="propertyName">Name of the property.</param>
    public DynamicViewLambdaGenerator(DynamicViewConfiguration<TDynamic> configuration, string keyPropertyName)
    {
        this.keyPropertyName = keyPropertyName;
        this.type = typeof(TDynamic);

        configuration.HasKey(this.Generate());
    }

    /// <summary>
    /// Generates this instance.
    /// </summary>
    /// <returns></returns>
    private Expression<Func<TDynamic, TKey>> Generate()
    {
        PropertyInfo property = type.GetProperty(keyPropertyName);
        ParameterExpression thing = Expression.Parameter(type);
        MemberExpression keyExpression = Expression.Property(thing, property);

        return Expression.Lambda<Func<TDynamic, TKey>>(keyExpression, thing);
    }
}

OK, bear with me. This is where all the real funny stuff goes on. In the DynamicViewConfiguration<T> constructor, we find the primary key column. We use that to (again, through reflection, because we don’t know any generic types as compile time) create the lambda function for the EF entity configuration HasKey method. We use the key property name, reflection, and more of the Dynamic Linq library to return the property of the type within the Generate() method.

After that, we call ToTable passing in the name of the view. Voila. We’ve defined the underlying view name and the key field.

With the context (and model) defined for our runtime type, the service class can then call GetDynamicQueryResults<T>, and as mentioned earlier, I get a true IQueryable<T> back. I can use Linq to filter or sort the results and the view is not queried until the set is iterated.

The last missing piece is how to call the service class. This is done in an MVC controller.

// Generate a type based on the return columns
Type type = QueryTypeFactory.GetType(query, columns);

MethodInfo generic = typeof(IQueryCatalogDynamic).GetMethod("GetDynamicQueryResults").MakeGenericMethod(type);
var data = generic.Invoke(repository, new object[] { query, columns });

The controller gets the runtime type through our type factory class, then calls the GetDynamicQueryResults on the service instance, and we invoke the method, passing in our parameters. The controller uses this functionality to return an IQueryable<T> to the grid databinding function, which actually performs the sort and filter. With literally millions of rows in some tables, the jqGrid client-side paging and sorting was nearly instant.

Now I know that this is sort of a bastardization of technology, but the use case is narrow, and it worked great for my scenario. The purpose isn’t really how to uglify EF, but more so how some solutions can be solved with a little ingenuity (and a lot of head-banging against keyboards).

Android–Create a ListView with rounded corners

Bill Osuch — Mon, 06 Feb 2012 22:26:39 GMT

In a previous post I showed how to create a custom multi-line ListView bound to an ArrayList. Let’s make it a little more visually appealing and give each item some rounded corners.

If you followed the previous how-to you wound up with something that looked like this:

To put each ListView item (name, address & phone) into its own rounded-corner box, create a new file in your res/drawable directory called border.xml, and paste in the following code:

<shape xmlns:android="http://schemas.android.com/apk/res/android" >
    <stroke android:width="1dp" android:color="#FFFFFF" />
    <padding android:left="5dp" android:top="5dp" android:right="5dp" android:bottom="5dp" />
    <corners android:radius="8dp" />
</shape>

Then, specify the background of your LinearLayout in custom_row_view.xml:

android:background="@drawable/border"

And that’s it:

Of course, you can mess with colors, padding etc. to get the look you want, and you can apply this to just about any object in your layout.

setting the database to offline/online state

Łukasz Kuryło — Mon, 06 Feb 2012 20:14:04 GMT

Sometimes we want to make a changes to the database or create a backup, but the users must be disconnected for this time. The easiest way is to set the database to the offline state:
ALTER DATABASE dbname SET OffLine WITH ROLLBACK IMMEDIATE
and back
ALTER DATABASE dbname SET OnLine WITH ROLLBACK IMMEDIATE

The alternative is to set the Restrict Access to the Restricted User in the database Properties/Options.

Accessing all context properties in a custom BizTalk pipeline component

Bill Osuch — Mon, 06 Feb 2012 20:06:17 GMT

Previously I talked about how to create a custom BizTalk pipeline component, and gave a few examples for accessing specific context properties. I wanted to be able to dump all the context properties to disk for examination, so I added a few lines of code and an on/off switch.

First, add two properties to your component:

private bool _EnableContextTrace;
private string _FileTraceLocation;

public bool EnableContextTrace
{
    get { return _EnableContextTrace; }
    set { _EnableContextTrace = value; }
}

public string FileTraceLocation
{
    get { return _FileTraceLocation; }
    set { _FileTraceLocation = value; }
}

Make sure to add them to the Load() and Save() methods in the IPersistPropertyBag region:

public virtual void Load(Microsoft.BizTalk.Component.Interop.IPropertyBag pb, int errlog)
{
    object val = null;
    val = this.ReadPropertyBag(pb, "EnableContextTrace");
    if ((val != null))
        this._EnableContextTrace = ((bool)(val));
    val = this.ReadPropertyBag(pb, "FileTraceLocation");
    if ((val != null))
        this._FileTraceLocation = ((string)(val));
}

public virtual void Save(Microsoft.BizTalk.Component.Interop.IPropertyBag pb, bool fClearDirty, bool fSaveAllProperties)
{
    this.WritePropertyBag(pb, "EnableContextTrace", this.EnableFileTrace);
    this.WritePropertyBag(pb, "FileTraceLocation", this.FileTraceLocation);
}

And finally add some code to the Execute method to loop through all the context properties and write them to a text file:

if (_EnableContextTrace && _FileTraceLocation.Length > 0)
{
    IBaseMessageContext contextList = inmsg.Context;
    string name;
    string nmspace;
    string contextItems = "";
    for (int x = 0; x < contextList.CountProperties; x++)
    {
        contextList.ReadAt(x, out name, out nmspace);
        string value = contextList.Read(name, nmspace).ToString();
        contextItems += "Name: " + name + " - " + "Namespace: " + nmspace + " - " + value + "\r\n";
    }

    using (StreamWriter outfile = new StreamWriter(_FileTraceLocation + "ContextProperties.txt"))
    {
        outfile.Write(contextItems);
    }
}

After building the DLL and adding it to the Pipeline Components directory, you should be able to configure the properties:

Deploy the project, drop and file in, and examine the contents of the ContextProperties.txt file that was created. In my case I ran a HIPAA 837 file through and got the following:

Name: FileCreationTime - Namespace: http://schemas.microsoft.com/BizTalk/2003/file-properties - 2/6/2012 7:41:01 PM
Name: ReceivedFileName - Namespace: http://schemas.microsoft.com/BizTalk/2003/file-properties - C:\Temp\Split5010Claims\Input\0217_ACS_UIC_837P_OUT_20120203124952.edi
Name: ActivityIdentity - Namespace: http://schemas.microsoft.com/BizTalk/2003/messagetracking-properties - {BDE71A7F-7351-480E-90A9-3607A92FAE2F}
Name: AdapterReceiveCompleteTime - Namespace: http://schemas.microsoft.com/BizTalk/2003/messagetracking-properties - 2/6/2012 7:41:01 PM
Name: PortName - Namespace: http://schemas.microsoft.com/BizTalk/2003/messagetracking-properties - Input5010_P
Name: InboundTransportLocation - Namespace: http://schemas.microsoft.com/BizTalk/2003/system-properties - C:\Temp\Split5010Claims\Input\*_837P_*.edi
Name: InterchangeID - Namespace: http://schemas.microsoft.com/BizTalk/2003/system-properties - {E0124062-FF6C-41B1-94F9-BDC929D54FC4}
Name: ReceiveInstanceID - Namespace: http://schemas.microsoft.com/BizTalk/2003/system-properties - {28D3080A-DE0F-48AC-AB08-C0B61285061F}
Name: ReceiveLocationName - Namespace: http://schemas.microsoft.com/BizTalk/2003/system-properties - Input5010_P_FILE
Name: ReceivePortID - Namespace: http://schemas.microsoft.com/BizTalk/2003/system-properties - {C4184808-467F-400F-9681-84924F44E9F4}
Name: ReceivePortName - Namespace: http://schemas.microsoft.com/BizTalk/2003/system-properties - Input5010_P
Name: AuthenticationRequiredOnReceivePort - Namespace: http://schemas.microsoft.com/BizTalk/2003/system-properties - False
Name: InboundTransportType - Namespace: http://schemas.microsoft.com/BizTalk/2003/system-properties - FILE
Name: LRPMsgBodyTracking - Namespace: http://schemas.microsoft.com/BizTalk/2003/system-properties - 0
Name: MessageExchangePattern - Namespace: http://schemas.microsoft.com/BizTalk/2003/system-properties - 1
Name: ReceivePipelineID - Namespace: http://schemas.microsoft.com/BizTalk/2003/system-properties - {45C53C6F-DBE9-49DB-AE7B-58A9D0901730}
Name: ReceivePortAuth - Namespace: http://schemas.microsoft.com/BizTalk/2003/system-properties - 0
Name: MessageType - Namespace: http://schemas.microsoft.com/BizTalk/2003/system-properties - http://schemas.microsoft.com/BizTalk/EDI/X12/2006#X12_00501_837_P
Name: SuspendMessageOnRoutingFailure - Namespace: http://schemas.microsoft.com/BizTalk/2003/system-properties - True
Name: ISA05 - Namespace: http://schemas.microsoft.com/Edi/PropertySchema - 30
Name: ISA06 - Namespace: http://schemas.microsoft.com/Edi/PropertySchema - 208876513
Name: ISA07 - Namespace: http://schemas.microsoft.com/Edi/PropertySchema - 30
Name: ISA08 - Namespace: http://schemas.microsoft.com/Edi/PropertySchema - 205498481UIC5
Name: ISA15 - Namespace: http://schemas.microsoft.com/Edi/PropertySchema - P
Name: ISA_Segment - Namespace: http://schemas.microsoft.com/Edi/PropertySchema - ISA*##*##########*##*##########*30*123456789 *30*987654321UIC5 *120203*1249*U*00501*000000064*0*P*:~
Name: GS01 - Namespace: http://schemas.microsoft.com/Edi/PropertySchema - HC
Name: GS02 - Namespace: http://schemas.microsoft.com/Edi/PropertySchema - 208876513
Name: GS03 - Namespace: http://schemas.microsoft.com/Edi/PropertySchema - 205498481UIC5
Name: GS07 - Namespace: http://schemas.microsoft.com/Edi/PropertySchema - X
Name: GS08 - Namespace: http://schemas.microsoft.com/Edi/PropertySchema - 005010X222A1
Name: ST01 - Namespace: http://schemas.microsoft.com/Edi/PropertySchema - 837
Name: GS_Segment - Namespace: http://schemas.microsoft.com/Edi/PropertySchema - GS*HC*123456789*987654321UIC5*20120203*1249*64*X*005010X222A1~
Name: ReuseEnvelope - Namespace: http://schemas.microsoft.com/Edi/PropertySchema - False
Name: TsSequenceNumberInGroup - Namespace: http://schemas.microsoft.com/Edi/PropertySchema - 72
Name: GE01 - Namespace: http://schemas.microsoft.com/Edi/PropertySchema - 72
Name: AgreementPartIDOnReceive - Namespace: http://schemas.microsoft.com/Edi/PropertySchema - 0
Name: AgreementID - Namespace: http://schemas.microsoft.com/Edi/PropertySchema - 0
Name: AgreementName - Namespace: http://schemas.microsoft.com/Edi/PropertySchema - BTSGuestParty
Name: SenderPartyName - Namespace: http://schemas.microsoft.com/Edi/PropertySchema - BTS-SENDER
Name: PartyName - Namespace: http://schemas.microsoft.com/BizTalk/2003/messagetracking-properties - BTSGuestParty
Name: SourcePartyID - Namespace: http://schemas.microsoft.com/BizTalk/2003/system-properties - s-1-5-7
Name: ReceiverPartyName - Namespace: http://schemas.microsoft.com/Edi/PropertySchema - RECEIVE-PARTNER

Transition to Exchange 2007 from exchange 2003

marc dekeyser — Mon, 06 Feb 2012 20:05:13 GMT

In the lifespan of an organisation it’s messaging environment be transitioned to a newer version several times. Whilst this is not a complicated thing to do it does require some level of planning and thought. I’ll be addressing the transitioning from Exchange 2003 to 2007 from a fairly simple view here. Since the general outlines of the process are the same for nearly every situation there is no need for different detailed documents on this.

We’ll be working with the following infrastructure in this guide:

· 2 windows 2008 R2 domain controllers

· 1 Exchange 2003 SP2 server

· 1 Exchange 2007 SP3 server.

Since this is a transition from a legacy environment there are some more steps to take than if we would be straight up installing a completely new Exchange 2007 environment. I will not neglect to point out some things that you might need to differently in case you would have a slightly different environment. So let’s get started!

Preparing the environment for Exchange 2007

Installing Exchange 2007 in an existing legacy environment firstly require you prepare the legacy permissions. Since the architecture of Exchange 2007 changed quite a bit (f.e. no more routing group connectors!) this will prepare the legacy Exchange environment RUS to work properly whist the 2007 servers are there.

First of all, you need to make sure your Exchange 2003 environment is in native mode:

1. Open Exchange system manager
2. Right click the very top level item (in my case: toasterlans (exchange))
3. Select properties
4. Make sure the operation mode is in Native mode (aka no Exchange 2000 servers). If it is not, upgrade it by clicking the button below operation mode.

5. Now switch over to the future Exchange 2007 server (make sure you are logged on to the domain)
6. Open a command prompt as administrator
7. Navigate to your installation media
8. Type in “setup.com /preparelegacyexchangepermissions”
9. Setup will start to prepare the domain and Exchange 2003 with legacy permissions

The next step is to prepare the Active Directory Schema:

1. Switch over to the future Exchange 2007 server (make sure you are logged on to the domain)
2. Open a command prompt as administrator
3. Type in servermanagercmd –i RSAT-ADDS
4. Reboot
5. Logon on and open a command prompt as administrator
6. Navigate to your installation media
7. Type in “setup.com /prepareschema”
8. Wait for completion…

Note that we installed the RSAT-ADDS component on our server to allow setup to contact the active directory. If you do not wish to install this component (it will get installed later on anyways) you can opt to run the prepare schema and AD operation on a domain controller.

And finally our last step in preparing the environment for Exchange 2007

1. switch over to the future Exchange 2007 server (make sure you are logged on to the domain)
2. Open a command prompt as administrator
3. Navigate to your installation media
4. Type in “setup.com /prepareAD”
5. Wait for completion…

Now that the routing group connectors, the permission and the schema have all been dealt with we can start installing Exchange 2007 in to our environment!

Installation

First of all it might seem I’m missing something here, where are the prerequisites? Your totally right there… Put in the following commands to get those prerequisites on the machine…

Servermanagercmd –I RSAT-ADDS (if you didn’t install this earlier)

Reboot

ServerManagerCmd -i Web-Metabase

ServerManagerCmd -i Web-Lgcy-Mgmt-Console

ServerManagerCmd -i Powershell (installed by default on 2008 R2)

ServerManagerCmd -i Web-Server

ServerManagerCmd -i Web-ISAPI-Ext

ServerManagerCmd -i Web-Metabase

ServerManagerCmd -i Web-Lgcy-Mgmt-Console

ServerManagerCmd -i Web-Basic-Auth

ServerManagerCmd -i Web-Digest-Auth

ServerManagerCmd -i Web-Windows-Auth

ServerManagerCmd -i Web-Dyn-Compression

ServerManagerCmd -i RPC-over-HTTP-proxy

So go ahead and start setup and click the start Exchange 2007 SP3 installation.

Read through the new features, click next. Accept the license agreement and click next.I usually leave error reporting on, but your mileage might differ.

Now on the next screen we have the option between a typical installation and a custom installation. Since this is about a simple all in one server transition, select typical. If you need to change the installation path this would be the time to do so! Click next.

The following screen requires you to select a server in the routing group connector that Exchange 2007 will connect to. Basically this means that all mail flow between the organisations will go through that server. So click browse and select the appropriate server.

Setup will perform some prerequisite tests and check for updates. This might take a while so go and get yourself something to drink. When this ends you might get some warnings. Take note of them and press “install”.

Installation will, once again, take a while depending on your hardware speeds. We’re almost done installing Exchange so no panic! Once the installation is completed you can go ahead and click finish J. You’ll probably get presented by a popup asking the server to reboot before placing it in production, quickly followed by the EMC opening up.

Now, before we move users on to the server we will have to reboot, but first we want to make some configuration changes to the server.

Configuration

Accepted domains

First of all we need to configure the accepted domains J.

1. Open the EMC
2. Open Organization configuration
3. Open Hub transport
4. Open the Accepted Domains tab.
5. Check that all domains have been transferred from the 2003 server
6. Open the email address policies tab
7. Check that all policies have been transferred from the 2003 server.

Mailflow

1. Open the EMC
2. Open the Server configuration section
3. Open Hub Transport
4. Right click the default receive connector
5. Open the permission groups tab
6. Check the anonymous users checkmark
7. Go back to the organization configuration
8. Open hub transport
9. Click on the send connectors tab
10. Create a new send connector by choosing that action in the right pane
11. Name it
12. Choose internet from the intended use drop down list
13. Next
14. Click on add
15. In the address field add “*”
16. Click on OK, next
17. If you have a smarthost use the information in this section
18. Click on next, next, new, finish

With these steps completed you can now send and receive mail through the Exchange 2007 servers! Go ahead and reboot the server before proceeding any further. With the server there is still a number of other tasks that need to be performed; Replication of the public folders, moving the database, OAB generation servers and removing the Exchange installation.

Replicating all public folders

1. Open the EMC
2. Go to toolbox
3. Open Public Folder management Console
4. Configure replication as follows:

a. Right click the public folder you want to replicate
b. Properties
c. Replication tab
d. Add
e. Select the server you want to replicate with
f. Press OK, OK

Note that you will have to replicate the free busy data if you are using outlook 2003 clients! Once the public folders have replicated proceed with the steps below…

Point all external links to the Exchange 2007 CAS servers at this point

Transition

Moving mailboxes

1. Open the EMC
2. Go to recipient configuration
3. Open the mailbox section
4. Select the users you want to move (use batches if possible)
5. Right click
6. Move mailbox
7. Browse to select the Exchange 2007 mailbox store
8. Next
9. Next
10. Next
11. Move
12. Sit back and enjoy

OAB Generation server

1. Open EMC
2. Expand organization configuration
3. Expand mailbox
4. Offline address book tab
5. Right click the default offline address book
6. move
7. Browse to select the new server
8. Move
9. Finish
10. Right click detault offline address book
11. Properties
12. Distribution
13. Enable web-based distribution
14. Add
15. Select the web directory
16. OK, OK

The last seven steps will allow all outlook 2007 and 2010 client to use web distribution to download the OAB.

Removing the routing group connector:

· Get-routinggroupconnector | remove-routinggroupconnector

Moving the RUS

1. Open system manager on the 2003 server
2. Expand recipients node
3. Expand recipient update services
4. Perform the following for both items listed:

a. Right click
b. Properties
c. Brose next to Exchange server
d. Select the Exchange 2007 server
e. OK
f. OK

Uninstalling Exchange 2003

1. Open the control panel
2. Add or remove programs
3. Exchange 2003
4. Change/remove
5. Select remove from the drop down menus

And you are now finished, running completely on Exchange 2007! Of course this was a very basic guide and there are a ton of things more you can do with Exchange 2007 that we’ll cover in upcoming articles!

How To Copy A Schema Container To Another SQL Azure Database

Herve Roggero — Tue, 07 Feb 2012 07:07:00 GMT

This article is written to assist SQL Azure customers to copy a SCHEMA container from one SQL Azure database to another. Schema separation (or compress shard) is a technique used by applications that hold multiple customer “databases” inside the same physical database, but separated logically by a SCHEMA container. At times it may be necessary to copy a given SCHEMA container from one database to another. Copying a SCHEMA container from one database to another can be very difficult because you need to only extract and import the data contained in the tables found in that schema.

If your SQL Azure database has multiple schema containers in it, and you would like to copy the objects under that schema to another database, you can do so by following the steps below. The article uses the Enzo Backup tool (http://bluesyntax.net/backup.aspx), designed to help in achieving this complex task.

Example Overview

Let’s assume you have a database with multiple SCHEMA containers and you would like to copy one of the schema containers to another database. A SCHEMA container holds tables, foreign keys, default constraints, indexes and more. In the screenshot below the selected database has 5 schema contains: the DBO schema and 4 custom SCHEMA container. The tool allows you to copy the objects from any schema into another database.

Backing Up Your SCHEMA Container

The first step is to backup your schema. Enzo Backup gives you the options needed to backup a single SCHEMA container at a time.

1- If you have registered your databases previously with the backup tool, select the database from the list of databases on the left pane, right-click on the SCHEMA container (i.e. your logical database) and select Backup to Blob (or file). Otherwise click on the Backup –> To Blob Device from the menu and enter the server credentials, and specify the name of the SCHEMA to backup from the Advanced screen.

2- Type the name of your backup device

3- Optionally select a cloud agent if you are saving to a Blob on the Advanced tab (note: a cloud agent must be deployed separately)

4- Click Start

Restoring Your SCHEMA Container

Once the backup is complete, you can restore the backup device to the database server of your choice. Note that you could restore to a local SQL Server database or to another SQL Azure database server.

1- Click on Backups on the left pane to view your backup devices and find your device

2- Right-click on your backup device (file or blob)

3- Enter the credentials of the server you are restoring to and the name of the database

4- If the database does not exist, select the Create If… option

5- Optionally, if you are using a Blob device and restoring to a SQL Azure database, check the Use Cloud Agent (note: a cloud agent must be deployed separately)

6- Click Start

If for some reason the database you are restoring to is not empty, you may see a warning indicating that the database has existing objects. Click “Yes” to continue. When the operation is complete, you can inspect your database to verify the presence of your logical database.

Considerations

- You can restore additional SCHEMA containers on an existing database. You would simply need to repeat the above steps for each SCHEMA container.

- If your intent was to “move” the SCHEMA container, you will need to clean up the original database. Once your SCHEMA container has been copied, and you have verified all you data is present in the destination database, you will need to manually drop all the objects in the source database before dropping the SCHEMA container.

- This tool does not support backing up SQL Server database. However you can restore a backup device created with Enzo Backup on a local SQL Server database if desired.

Windows 8 Composition and Content

Joe Mayo — Mon, 06 Feb 2012 17:11:55 GMT

Composition is an integral part of Windows 8 UI design from both aesthetic and logical perspectives. This post modified my previous post, Refactoring Windows 8 Code-Behind to MVVM. adding to the variety of compositional examples. I’ll start with an explanation of composition in Windows 8, modify the previous code to show the power of composition, and then highlight a few more existing examples of where composition naturally fits into the Windows 8 UI environment.

Understanding Windows 8 Composition

A Windows 8 UI is built like a tree. You have a single root element that surrounds all other elements, multiple branches containing more elements, and finally many leaves that don’t contain any elements. In shorthand, the structure looks something like this:

Root

    Content

        Branch

            Branch

                Leaf

            Branch

                Leaf

                Leaf

        Branch

            Leaf

You might have noticed that I sneaked in an extra element, Content, in the figure above that I hadn’t talked about yet. Nevertheless, Content is necessary and important in Windows 8 development. The figure above is a generalization of the hierarchical relationship between elements. However, the XAML below, based on the previous post, is a concrete example:

<UserControl x:Class="TwitterClient.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    d:DesignHeight="768" d:DesignWidth="1366">
  
    <Grid x:Name="LayoutRoot" Background="#FF0C0C0C">
        <Button Content="Refresh Public Tweets" Height="72" Width="365" 
                HorizontalAlignment="Left"  Margin="500,66,0,0" 
                Name="RefreshButton" VerticalAlignment="Top"
                Command="{Binding RefreshCommand}"/>
        <ListBox Height="465" HorizontalAlignment="Left" Margin="5,144,0,0" 
                 Name="PublicTweetListBox" VerticalAlignment="Top" Width="1355"
                 ItemsSource="{Binding Tweets}">
            <ListBox.ItemTemplate>
                <DataTemplate>
                    <StackPanel Orientation="Horizontal" Height="132">
                        <Image Source="{Binding ImageUrl}" 
                               Height="73" Width="73" 
                               VerticalAlignment="Top" Margin="0,10,8,0"/>
                        <StackPanel Width="370">
                            <TextBlock Text="{Binding Name}" 
                                       Foreground="#FFC8AB14" FontSize="28" />
                            <TextBlock Text="{Binding Text}" 
                                       TextWrapping="Wrap" FontSize="24" />
                        </StackPanel>
                    </StackPanel>
                </DataTemplate>
            </ListBox.ItemTemplate>
        </ListBox>
    </Grid>   
</UserControl>

The example above gives a better idea of the compositional relationship between elements and how they form a tree that is visually identifiable through proper spacing of elements. UserControl is the Root element and Grid is the Content element for Root. Subsequent elements form a hierarchy, further displaying the compositional nature of Windows 8 UI development.

Since the examples in this post are based on the previous post, you might find it useful to have a few tips on getting from there to here, which is discussed next.

Reusing Previous Code

Over the past couple of posts, I’ve renamed the same project to something new. This is more tedious than necessary, so I’ll just rename the project one more time to something more generic, like TwitterClient. If you’re thinking, “Oh no, not another Twitter client!”, don’t worry. It’s just a sample program – and besides, no one will ever use it.

Here’s a quick walk-through of the file system part of the rename:

Make a copy of RefactorToMVVM folder in Windows Explorer and rename it to TwitterClient.
In the new TwitterClient folder, rename the solution file, RefactorToMVVM.sln, to TwitterClient.sln.
Unhide files and rename RefactorToMVVM.v11.suo to TwitterClient.v11.suo (Alternatively delete because VS11 recreates it for you).
Rename the project folder, RefactorToMVVM, to TwitterClient.
In the new TwitterClient project folder, rename the project file, RefactorToMVVM.csproj, to TwitterClient.csproj.

Now your file names are up-to-date, you’ll need to change a couple more items in the solution. To get started on this part, go back to the TwitterClient solution folder and double-click on TwitterClient.sln to open the solution. You’ll see an error saying that VS can’t open the RefactorToMVVM project and that’s okay because you intentionally renamed it – meaning that the solution file won’t be able to find the project file under it’s new name. Click OK for the error message box that appears. The following steps fix the project load problem and take you through the rest of the renaming:

After the solution loads, right-click on the grayed-out RefactorToMVVM project and select Remove.
Right-click on the solution, select Add, Existing Project and an Add Existing Project window will appear.
Navigate to the TwitterClient solution, down to the TwitterClient project, select TwitterClient.csproj and click OK. The new project will load.
Under the TwitterClient project, double-click Properties to open the Properties configuration page.
On the Properties Application tab, change both the Assembly name and Default namespaces to TwitterClient.
Open Tweet.cs (or any code file), select RefactorToMVVM, type Ctrl+R+R, and rename to TwitterClient. Select preview, comments, and strings options and observe all the places in code where the change is made. Click Apply when you’re ready to make the changes.
Double-click the Package.appxmanifest file, which opens the Package configuration window.
On the Application UI tab, change Display Name to TwitterClient, Entry Point to TwitterClient.App, and Description to Client Application for Twitter.
On the Packaging tab, change Package Display Name to TwitterClient.
Save and close Package.appxmanifest.
The visual designer for Package.appxmanifest doesn’t let you change everything and there’s one more item to remember. Right-click on Package.appxmanifest, select Open With, select XML Editor, and click OK.
Under /Applications/Application, change the Executable attribute to TwitterClient.exe.

Before finishing, press F7 to build the solution. If you have errors, it’s most likely because of the naming changes done previously. So, it would be useful to retrace your steps if the error message doesn’t lead you to the answer right away. Now that we have a new renamed solution/project, we can proceed to an in-depth discussion of Composition and Content by adding a button the the tweet list.

Adding a Button

Here, we’re not going to just add a button, we’re going to examine how a button supports composition through its Content property. You’ll see attribute content, element content, and a cool trick that makes it easy to code compositional content in XAML.

If you want a simple button with text, you can use the Content attribute, like this:

<Button Content="{Binding Name}" />

The XAML Content attribute corresponds to a Content property of the Button class. Your first thought, upon seeing the Content property on a Button, might be to ask, “Why isn’t this property named Text?” That’s a logical question, especially if you’ve been using Windows Forms, ASP.NET, or one of many other UI frameworks. Actually, Windows 8 is closer to both Silverlight and WPF in their view of composition and content.

The primary rationale for content is because text isn’t the only object you can display on a button. You can add different types of UI elements to a button by assigning those items to the Content property. In previous frameworks, that don’t support content, you would have needed to slog through extra code to create a special button. With Windows 8, you only need to assign a value to the content property of a given control. Here’s an example for creating a button that contains an image:

                        <Button>
                            <Button.Content>
                                <Image Source="{Binding ImageUrl}" 
                                       Height="73" Width="73" 
                                       VerticalAlignment="Top" Margin="0,10,8,0"/>
                            </Button.Content>
                        </Button>

Above, Button contains an image, which can’t be represented in text, as previously shown via the Content attribute. This example uses Property Element syntax – which is the control type and property name, separated by a dot. The power of this approach to re-defining the appearance of a button can’t be understated – you can see how easy it is to do.

Note: The content property isn’t always named Content. i.e. Types derived from ItemsControl, such as ListBox designate the Items property as their content property.

A control can be decorated with Windows.UI.Xaml.Markup.ContentPropertyAttribute, specifying what the content property is for that control. In the case of Button, the content property is Content (same name):

    [ContentProperty("Content")]
    public class UserControl : Windows.UI.Xaml.Controls.Control
    {
        // ...

        public UIElement Content { get; set; }

        // ...
    }

This is good information if you’re a control developer, but it’s also interesting because of a special feature of content properties that gives you simpler syntax. More specifically, you can remove the Property Element syntax, like this:

                        <Button>
                            <Image Source="{Binding ImageUrl}" 
                                   Height="73" Width="73" 
                                   VerticalAlignment="Top" Margin="0,10,8,0"/>
                        </Button>

The image below is a new snapshot of the updated screen, showing how the images look as buttons. As you can see, customizing buttons is very easy. More to the point, composing custom UI elements is easy via Windows 8 content support.

While this discussion focused on the Button, many other control types have content properties and support composition the same way. If you look back at the XAML in the previous section, “Understanding Windows 8 Composition”, you’ll see several more composition examples, including UserControl/Grid, Grid/Elements, ListBox/ListBox.ItemTemplate, and so on.

Summary

This post demonstrated the inherent support for composition in Windows 8 UI development. This capability is supported via content properties. You saw how Button demonstrates the power of composition and the role of the content property in facilitating composition. Remember that Button is only an example, and you should understand that other controls have content properties.

@JoeMayo

Mac type grid view control for asp.net/java web applications

AnkitAgrawal — Mon, 06 Feb 2012 13:56:41 GMT

For one of my project, I made a very dynamic grid which is totally HTML based and very fast while rendering data from server.

Features:

No viewstate
Dynamic grid which gets data on scroll using REST based WCF service in JSon
No DOM modifications which makes the rendering very fast
Custom control which can be integrated in any web application – Java / Asp.Net (However I built it for Asp.Net)
Support for very large record set.
Designer friendly – As the DOM doesn’t change and the basic structure remains the same.
Highly extensible to support any kind of data

Uniqueness of SessionId and GUID

AnkitAgrawal — Mon, 06 Feb 2012 13:55:22 GMT

Random and unique are two different words with very different meaning. To generate random number, there are many algorithms but none to guarantee unique number. This causes a problem of non-unique GUID and SessionId generated in any application whether you use .NET / java / php. (I have seen this in ASP.NET and java). If you grill down to the algorithm that is used to create SessionId, it does never guarantee a unique number whenever it is generated.

When you hover over the SessionId in ASP.NET application in VS, it says Unique SessionId. I don’t know how they can guarantee a unique id when there algorithm doesn’t support so. Below is the code:

internal static string Create(ref RandomNumberGenerator randgen)

{

if (randgen == null)

{

randgen = new RNGCryptoServiceProvider();

}

byte[] data = new byte[15];

randgen.GetBytes(data);

return Encode(data);

}

private static string Encode(byte[] buffer)

{

char[] chArray = new char[0x18];

int num2 = 0;

for (int i = 0; i < 15; i += 5)

{

int num4 = ((buffer[i] | (buffer[i + 1] << 8)) | (buffer[i + 2] << 0x10)) | (buffer[i + 3] << 0x18);

int index = num4 & 0x1f;