Microsoft Business Productivity Online Standard Suite (BPOS) is a set of messaging and collaboration solutions hosted by Microsoft, and consists of Exchange Online, SharePoint Online, Office Live Meeting, and Office Communications Online.

Unfortunately, public folders are not supported by BPOS. To migrate your old public folders to BPOS, you’ll need to find a workaround.

One of the ways to migrate your old Shared Folders, is by creating a shared mailbox that everybody can access.

The easiest way to set up a Shared Mailbox, is to create a new BPOS account (for example shared@example.com). On a client machine, you can install the Microsoft Online Services Sign In tool, which you can download from http://www.microsoft.com/downloads/details.aspx?displaylang=en&FamilyID=5c2ca866-4107-4ae5-98d5-76bf1b18ff87 .

The Sign In Tool will configure your outlook to access the new mailbox. Once your outlook is restored, you can import a PST file containing your public folders to your new mailbox and Outlook will start synchronizing with BPOS. Off course, this will take some time depending on the size of your Public Folders.

Now, we need to give all people access to this new shared mailbox. One way to do this is by right-clicking on the folders and edit the Permissions of the folders as shown in the figures below.

This looks like the easiest way, but there’s one problem with this method: setting Permissions on a folder is not recursive, so you will need to set these permissions on all subfolders. If you have a complex folder structure with lots of subfolders, and you need to give some people access to all folders using this method, good luck!

But there is an alternative way: in BPOS, you can give other people Full Access to a mailbox. So by giving all the members of your team Full Access to the shared mailbox, they will automatically have Full Access to all subfolders of your shared mailbox. To do this, you’ll need to have the Migration Tools installed on the client machine, and use some PowerShell.

To grant somebody full-access to the shared mailbox, you can use the Add-MSOnlineMailPermission as described in http://technet.microsoft.com/en-us/library/ee662271.aspx

An example is shown below:

Add-MSOnlineMailPermission -Identity shared@example.com -Credential $cred -TrustedUser admin@example.com –GrantFullAccess True –GrantSendAs True

This will give the user admin@example.com Full Access and SendAs permissions to the shared@example.com mailbox. This is only a basic example, with some coding skills you’ll easily manage to write a PowerShell script to give all users the needed permissions.

To finish the story, the users still need to open the Shared Mailbox. When using Outlook, they can easily open an additional mailbox. To do this, just follow the steps explained on http://office.microsoft.com/en-us/outlook-help/add-another-person-s-mailbox-to-your-account-HP005242139.aspx.

Good luck migrating to BPOS!

This week we started investigating OData and WCF data services as a way to easily expose and query a remote database.

OData, the Open Data Protocol is a protocol for querying and updating data over using Http and AtomPub

Visual studio 2010 and .NET 4.0 come with rich support to both produce and consume data using the Open Data Protocol.

This post is a tutorial on how to set up a web service that exposes OData, and how to query it from a client application.

Prerequisites

Exposing data as Odata

Create a new ASP.NET Web application

Create the Entity Data Model for the Northwind database

The Entity Data Model will be the base for the WCF Data Service that will expose the Northwind data in the OData format

Here we can choose which Tables, Views and Stored Procedures will be exposed

Finish creates the Entity Data Model for the Northwind database

Create a new WCF Data Service

The NorthwindService inherits from the DataService with as generic parameter the EntityDataModel we want to expose, in this case the NorthwindEntities we just created.

By default noone can do anything, we first need to set access rules for our entities.

The easyest way to do this is to expose all entities with read-all rights:

config.SetEntitySetAccessRule("*", EntitySetRights.AllRead);

If the Entity Data Model is in a different assembly you’ll need to add a reference, and make sure the connectionstring is in the web.config of the referencing project

Visiting the service now shows the exposed data:

Consuming the data

To use the data exposed by the web service we create a client application.

Add a Service Reference to the web service.

For testing, there is always a public Northwind web service available on http://services.odata.org/Northwind/Northwind.svc/

This generates a web service proxy.

New is that this also generates a DataServiceContext.

Using the DataServiceContext we can query the data service through a linq provider.

The following extremely simple example print a list with the Name and Unit Price of all available products.

class Program
{
   static void Main(string[] args)
   {
       string url = "http://localhost:40171/NorthwindService.svc/";
       var context = new NorthwindEntities(new Uri(url));

       var someProducts = from p in context.Products
                          where !p.Discontinued
                          select p;

       foreach (var product in someProducts)
       {
           Console.Out.WriteLine("{0} - {1}",product.ProductName,product.UnitPrice);
       }
       Console.Read();
   }
}

Download the sample code:

http://www.orbitone.com/SiteCollectionDocuments/Northwind%20OData%20Service%20Sample.zip

More information, samples, articles and tutorials can be found on http://www.odata.org/

Some more links to get you started:

• Open Data Protocol Visualizer
  http://visualstudiogallery.msdn.microsoft.com/en-us/f4ac856a-796e-4d78-9a3d-0120d8137722
  
• Open Data Protocol (OData) with Pablo Castro
  http://www.hanselminutes.com/default.aspx?ShowID=223
  
• Episode 43: Talking OData and SQL Modeling with Douglas Purdy
  http://deepfriedbytes.com/podcast/episode-43-talking-odata-and-sql-modeling-services-with-douglas-purdy/?utm_source=feedburner&utm_medium=feed&utm_campaign=Feed%3A+deepfriedbytes+%28Deep+Fried+Bytes%29&utm_content=Google+Reader
  
• Carl and Richard get the word on oData from Brad Abrams, Bob Dimpsey and Lance Olson.
  http://www.dotnetrocks.com/default.aspx?ShowNum=519
  
• Using Data Services over SharePoint 2010 – Part 1 – Getting Started
  http://blogs.msdn.com/b/astoriateam/archive/2009/10/21/using-data-services-over-sharepoint-2010-part-1-getting-started.aspx
  
• The Open Data Protocol (OData)
  http://www.stephenforte.net/PermaLink,guid,28df55a8-8811-4c4b-b319-75c5c58d1444.aspx

Thanks to a colleague of mine Voicu Matei I came across this very interesting presentation about what actually motivates people:

Giving money rewards works very well to motivate people doing simple, straightforward tasks.

But surprisingly, it has the opposite effect for more complicated tasks that require some conceptual, creative thinking! For these kind of tasks, such as software development, 3 factors lead to better performance & personal satisfaction:

1. Autonomy: the desire to direct our own lives. Self-direction leads to engagement.

2. Challenge and Mastery: the urge to get better at stuff and making a contribution.

3. Purpose: more and more organisations feel that having a transcendent purpose/ motive helps people set higher goals and achieve better results.

This research is completely in-line with the concepts of The New World of Work. We at Orbit One strongly believe in a flexible working environment resulting in people feeling better, and organization being more productive.

See blog post about The New World of Work: http://www.orbitone.com/en/blog/archive/2010/05/03/the-new-world-of-work-het-nieuwe-werken-orbit-one.aspx

Noticed when tested the next CRM rollup.

Consider this scenario:

1. Open Active Contacts view in CRM.

2. Select several contacts (ctrl + click, or shift + click).

3. Start mail merge with merging selected records on current page.

When we get a list of recipients, it is sorted randomly, as well as resulting letters:

Then we are at risk to put wrong letters to envelopes.

Work around? Don’t forget to sort the list of recipients in mail merge dialog box before creating letters. No others’ experience found by now.

Luckily this didn’t happen with merging all contacts from saved Advanced Find views or from marketing lists. This is an advised way of working.

Microsoft unveiled Search Server Express 2010. This is a free download from Microsoft and is supposed to be a Google Mini Appliance killer. It’s main drawback compared to the full SharePoint Server 2010 Search is that it can only be used in a one server farm. But still with proper hardware it should be able to index and search about 3 million items with a sub-second response time.

See the compare chart:

As the Search Server is based on SharePoint technology (so effectively comes on top of SharePoint Foundation) it appears the ideal solution for small deployments on premise compared to Foundation itself as that offers only very limited search capabilities: No cross site search, no refinements, no external source indexing. 

http://www.microsoft.com/enterprisesearch/searchserverexpress/en/us/default.aspx

Since we started using SharePoint 2010 we had trouble using it to store .msg (Outlook message format) in document libraries.

You can easily save your email from Outlook to a SharePoint location but opening it always gave a prompt dialog to save or cancel, not to open. So you were forced to store the email locally and then open it. Needless to say that this behavior is really annoying. I tried changing MIME types in IIS but it didn’t help and searching the internet I didn’t find a solution either.

But then a colleague pointed me to a setting that changes the way SharePoint treats files opened from a browser. Its located in Central Administration > Manage Web Applications > Your WebApp > General Settings

Changing this setting to permissive makes it possible to open .msg files in Outlook from SharePoint straight away. See screenshot below:

LifeSize is a HD videoconference equipment market leader. They have a wide range of devices, and it can be confusing to understand the differences between them.

We made a comparison matrix that helps you select the right device for your scenario:

Download the PDF compare sheet.

Selecting the right model for your needs

Here is how we help our customers selecting the right model for their needs:

• We start by looking at an Express 220
• If the customer plan to have meetings with 3 or more parties, we advise a Team 220 Phone or Room 220. These are multipoint devices:
  • The Team 220 allows for calls up to 4 parties: yourself + 3 other locations
  • The Room 220 allows for calls up to 8 parties: yourself + 7 other locations
• If the customer is looking for a low-cost, portable solution, we offer the LifeSize Passport.
• It’s important to understand the limitations of the Passport. The most important are:
  • You cannot send PC images from the Passport. From our experience, 50% of the videoconferences benefit from PC screen sharing. This issue can be solved by using a 3rd party software such as WebEx or LiveMeeting.
  • You cannot view video and PC content simultaneously on the LifeSize Passport. Imagine that you are in a videoconference with another party that has an Express, Team or Room. The moment they start sending PC content, you cannot see their faces anymore. It’s one or the other. This is very annoying.
• Conclusion: the LifeSize Passport is a low cost alternative for people who do not need to share PC content often.

Notes

• We do advise against buying the earlier 200 models. They are outdated and not will offer less compatibility with future products, such as the LifeSize Video Center
• Once a customer selects the Team 220, we always advise to take the “Phone” version instead of the Dual Mic pod. The price difference is not that much anymore (700€ excl VAT), and having the phone comes in handy:
  • When you are not videoconferencing, you can use it as a high quality conference phone.
  • When you are in a videoconference, you can add audio-only participants by calling them up, or having them dial-in.

Although Microsoft would claim that during the design process of SharePoint 2007 it invented social networking before Facebook and LinkedIn did, the times have changed somewhat since then and SharePoint 2007 wasnt really as social capable as we are now accustomed to.

In this post I would like to give an overview of all the cool new social features which I think will make SharePoint that much more interesting from a knowledge management perspective.

Tagging & Noteboard

In my previous post on SharePoint 2010 Term store and other metadata enhancements - Orbit One Blog I talked about the new tagging possibilities in SharePoint. The cool thing is that this functionality is present on all pages within SharePoint at the top right of the page.

So by clicking on these buttons you can quickly tag en note pages that you see within SharePoint but even nicer is to  put a button on your favorites bar to tag and note stuff on the internet as well

– Well for that just press the button once on a SharePoint page make the link on the screen a favorite.

The tagging function works with autocomplete which is nice and on the same screen you see recent activity on the item.

SharePoint profiles

Already since SharePoint 2003, users of SharePoint have had a profile with information about themselves. Normally these profiles get stale from the moment it got first updated on the first working day of a new employee :-)

The new version of SharePoint offers some new features that might be interesting in this respect:

Integration of the Microsoft Knowledge Network

The Microsoft Knowledge Network was introduced by Microsoft as an add-on for SharePoint 2007. It automates the discovery and sharing of undocumented knowledge and relationships, mining your communications for keywords and relationships within Outlook and updating your SharePoint profile accordingly. This way enabling you to quickly locate who knows whom and who knows what within your constantly changing organization.

Now the combination of Outlook 2010 and SharePoint 2010 gives you the opportunity to do just that out-of-the-box. It’s called Colleague and Outlook Social Connector

Sync SharePoint profile with other systems (social networks, Active Directory)

It is now possible to sync your SharePoint profile back to Active Directory including your profile picture. This way it will be easier to maintain data in your Active Directory. Another cool opportunity would be a Business Connectivity Services (BCS) connection that would sync your SharePoint profile with your profile on a social network, for instance LinkedIn?

• What's New Business Connectivity Services
• LinkedIn Developer Network Community APIs

So now that you are tagging, noting inside and outside of the firewall and your SharePoint profile is always up to date how will you other people within your organisation benefit from all this data?

Newsfeed

Well with a newsfeed just like you have on common social network sites:

Within your profile you can set the types of updates you want to get in your newsfeed. See the following screenshot for the out-of-the-box settings. Developers can customize the activities that can be followed so you can track custom actions happening in SharePoint as well.

That is it for the new and interesting social networking features in SharePoint.

We have deployed several intranet/extranet applications on SharePoint 2007 that required a mixed authentication scheme. Windows Integrated authentication for domain user and forms based authentication for extranet users.

In SharePoint 2007 this was possible by extending a web application and using different authentication schemes for the different sites. This worked somewhat nice, but there were several problems with it.

• There are really separate websites running on the same content database. Some customisations need to be deployed twice, for example Smart Parts.
• There are two url’s, for example extranet.example.com and intranet.example.com.
• Rich Client Integration has lots and lots of problems when using forms based authentication
• The possibilities of the People Picker are somewhat limited.

SharePoint 2010 was announced to have Mixed Authentication, which would solve all problems!

Setting up Mixed authentication in SharePoint 2010

1. Create a new Web Application with Claims Based Authentication

   
   

2. Select Authentication providers

    

   

   Note: As you can see the last option is “Trusted Identity Provider”

   This option is only available if you have configured Trusted Identity Providers. To do this the certificate of the trusted party needs to be installed first.

3. Select Sign In page.

   
   

   

   here you can specify a custom login page. The default Sign In pages offers a drop down list with the configured authentication types.

4. Create a site collection for the new web application

   
   

   The web application needs a root site collection

5. Select a site collection administrator

   
   
   

    

   The people picker is much improved. Search results are linked to the membership provider and it is possible to search only for a single provider.

6. Configure the providers

   
   

   Add the Membership and Role provider to the web.config of the web application we just created

   

   for simplicity’s sake I used an XML Membership and Role provider from Codeplex
   

7. Sign in using Forms Authentication

   Trying to access  the web site now presents us with a Sign In page where we can choose how we authenticate

   

   With windows authentication we can log in with our domain account

   

   with forms authentication we get a login form

   

   However, trying to log in with forms authentication will give a yellow page of death: A WCF FaultException telling us we can’t see the real error.
   

8. Configure the Security Token Service

   
   

   Digging through the SharePoint logs reveals the following error message:

   Cannot get Membership Provider with name XmlMembershipProvider. The membership provider for this process was not properly configured. You must configure the membership provider in the .config file for every SharePoint process.

   It turns out the SecurityTokenService tries to access the membership provider directly, but is not configured to do so.

   After adding the Membership and Role provider to the web.config of the Security Token Service everything starts working. The web.config can be found here:
   C:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\14\WebServices\SecurityToken

   
   

9. Sign in using forms authentication

   
   

   We can now sign in using forms authentication. Make sure to add the forms authentication based users to a SharePoint Group, or they will get Access Denied the moment they log in.

   

    

Rich Client Integration

Office integration works great for both windows and forms authentication now. If you didn’t click “remember me” on the Sign In page you will be presented with a log in page that is actually usable. After clicking “remember me” all authentication will be transparent, and you can open the document for editing straight from SharePoint.

Concept

The New World of Work is a new flexible way of working and collaborating with co-workers, partners, customers etc. This new kind of working is funded on three pillars: People & Organisation, The Office and ICT.

People & Organisation

In order to stay competitive organisations need to hire and retain the best staff. To be an attractive employer for talent you need to challenge them and make them responsible for the results they deliver. In this culture of openness Managers control less and support more.

ICT

ICT is the underlying enabler of the “New World of Work” because it makes it possible for people to work from anywhere, at any time, with anybody. We use solutions as video conferencing, presence and virtual workspaces on a daily basis and feel it is key for working in the “New World of Work” 

The Office – Workplace

The office & its workplaces need to invite and stimulate people to perform different types of work in the most effective and pleasurable way. People spend more and more time collaborating with others (co-workers, partners or customers) so setup workspaces specific for these types of activity: meetings, brainstorms, video conferences, chats and of course some relax spaces to play and have fun.

Orbit One and The New World of Work

Within Orbit One we wanted to know where we stand in ‘the new world of work’ so we did a survey originally created by Dik Bijl in Dutch and translated it into English because in our team of 17 enthusiastic employees that is the working language :-)

If you want to do the survey yourself please download it and use the excel template analyzing the results.

Results

Here is a graph of the results of the survey focusing on the different aspects of ‘the new world of work’

The results of the survey told us that we are doing reasonably well but as always there is room for improvement! We started on our physical work environment: The Office.

Come and experience One Office

With the survey in mind we started with the upgrade of our Office in Gent to be ready for the ‘New World of Work’.

We rent out part of our office so if you want to take advantage of this highly productive and fun working environment or if you just want to have peek inside, don’t be shy, come and visit us in Gent!

For more info on one office flexible workplaces see our website “One Office”

What can Orbit One offer you?

Orbit One is a Internet Solutions provider that assists clients in becoming more efficient using technologies such as: SharePoint, Office Communications Server (OCS), Exchange, Direct Access and SSL VPN. With these technologies we create an integrated environment for your people (employees, partners and customers) that simply works and will boosts their productivity!

Find out more in our presentation on slideshare

Downloads and other related stuff

• Survey for the New World of Work
• Excel template for results survey
• Orbit One Presentation “The New World of Work”
• OneOffice website
• Klein receptenboek voor het nieuwe werken door Roland Hameeteman, ..
• Het nieuwe werken, op weg naar een productieve kenniseconomie

If you’re interested contact us we can give a presentation/demo of how we work in the new world of work and how we can make you work more productive as well

Orbit One is one of the SharePoint 2010 launch partners in Belgium.

We have several clients who are planning to upgrade to Microsoft SharePoint 2010, and we have some real-life projects running on Microsoft SharePoint 2010 RC.

One of the issues was finding a tool to migrate a big load of files and folders to SharePoint, and keep the original created and modified dates. The creation/modified date of files are sometimes really important, as it allows the user to understand how relevant the information is.

We looked at MetaLogix and DocKIT, both where working on beta versions of migration tools for SharePoint 2010.

Our customers where looking for a cost-effective solution, without having to pay based on the number of GB they want to transfer.

This was a perfect scenario to make use of the new Managed Client Object Model, allowing us to build a nice small tool.

Since we figure this could be useful to others, we published the SharePoint 2010 Bulk Document Importer on Codeplex.

Feel free to use and improve it!

Features:

• Run it anywhere. Every action is done using the Client Object Model, there is no need to install it on the server.
• Import folders and files with all subfolders
• Retain creation and modified date fields after moving to SharePoint
• Retain author/editor fields from office documents after moving to SharePoint
• Incompatible file names are renamed (filename too long, illegal characters)
• Unsupported files (large file size, blocked file extension, …) are skipped
• Files already existing on SharePoint are skipped (no overwrite)
• Successfully migrated files and folders can be moved to an “archive” folder
• Detailed log (log4Net) with info on migration issues
• Option to skip creation of empty folders in SharePoint
• Option to merge subfolders to a flat list in SharePoint.

The application is a command line application that can be easily batched for several migrations to different document libraries.

Example:

Import all files from the user guides folder on the central file share to the userguides document library on the intranet.

OrbitOne.SharePoint.Importer.exe -folder:"\\fileshare\documents\user guides" site:"http://intranet/documentation" -documentlibrary:userguides

More information, examples and technical information can be found on the documentation wiki.

The long expected successor of MOSS 2007, SharePoint 2010 will launch on May 12. We are all very excited about this! The last couple of months we have been working with the new version and we would like to give you an overview of the key new features regarding metadata and classification.

In the coming weeks we will dive deeper into other aspects of the platform: Search, Social Features, Offline access and Workflow.

Term store

The Term store is a service application that can be setup to manage metadata across farms, web applications and site collections.

Taxonomy and Folksonomy

Within the term store metadata can be managed top-down (taxonomy) or bottom-up (folksonomy). This means that an organisation can have an official taxonomy but at the same time provide users with the ability to add free tags to content as they please. Another cool thing about this is that you can ‘upgrade’ terms from the folksonomy to the taxonomy!

Hierarchical terms

The terms within the term store can be hierarchical in nature: For instance Regions and countries form a hierarchical structure. When people tag a specific item within SharePoint with Bermuda you can find it under Caribbean or Americas as well.

Management of terms

Each set of terms has an owner. He or she can maintain the terms and other people can give suggestions on synonyms or missing terms directly via the user interface. This makes SharePoint a very user friendly tool for managing metadata.

Autocomplete on terms and tags

When typing a term users get an autocomplete functionality to guide them to already used tags and the predefined taxonomy.

Content type hub

With the term store it is possible to reuse content types across site collections, web applications and even farms. This way policies and workflows can be forced on content across the enterprise which is key in larger organisations. To start using this functionality you need to set up a site collection as your content type hub. In this site collection you’ll maintain your enterprise wide content types. Other sites can use the content types created there.

Other enhancements to metadata usage

Metadata navigation

When browsing libraries or lists users can use key filters and metadata navigation to quickly find the right document within the library. This functionality makes folders look so 2009 ;-)

Facetted Search

Known already from addons like Codeplex’s MOSS Faceted Search or Surfray’s Ontolica Search for SharePoint this feature creates dynamic filters based on your search result which make it easy for end users to refine their search based on metadata properties.

Validation based on Excel based formulas

SharePoint 2010 makes it possible to validate data coming into SharePoint. The user will be instructed on what specific rules a certain property needs to comply to be saved to SharePoint. The formulas describing the rules are based on Excel logic.

That's it for now. Stay tuned for more good SharePoint 2010 stuff!

We’re happy to announce that the new website of Recytyre VZW was launched. Recytyre is a controlling organism for waste-tyres in Belgium, focussing on sustainable solutions contributing to a greener future.

www.recytyre.be

Orbit One will attend Microsoft TechDays this week, Metropolis Antwerp - Belgium.
I’m looking forward to good sessions, meeting friends and loads of food :-)

Meet our team, look for our T-shirts!

• Pre-conference + Techdays 30-31 March, 1 April: Mel, Wim DC, Thijs, Viktor, Tom, Olivier
• TechDays 31-1 April: Wim R, Jan, Hans, Dennis, Voicu, Lieven, Pieter-Jan

There is a lot to talk about this year:

• SharePoint 2010
• Visual Studio 2010
• .NET Framework 4.0
• ASP.NET 4.0
• Entity Framework 4.0
• Windows Communication Foundation 4
• Workflow Foundation 4
• Windows Server 2008 R2
• SQL Server 2008 R2
• Exchange 2010
• Office 2010

Met het concept OneOffice stelt Orbit One haar kantoren open voor mensen die op zoek zijn naar een flexibele werkomgeving in hartje Gent.

De nadruk ligt op het creëren van een aangename omgeving waar mensen werken en samenwerken, ondersteund door de laatste technologie.

Het concept is opgebouwd rond Het nieuwe werken, een vooruitstrevende manier van samenwerken.

http://www.oneoffice.be

Imagine the following scenario. You are typing some rich text entry on your SharePoint intranet with the internal URL http://intranet/. It might be a blog post, a discussion board, or just a content editor web part. You insert a link to other intranet site, like http://intranet.client.com. When you test the link, it looks like you want, but it works as just http://intranet/.

If the site has alternate access mapping (AAM) with several web applications (for example, with different authentication), and default or intranet AAM has such short form (in the following example it’s http://portal/), all instances of the website convert the link this way:

(normally it ends with 404 error)

So SharePoint converts internal links to relative and overrules the conversion for such external links. The links which have the same beginning as default or intranet site URL are converted to relative ones, and then they are interpreted as being located on the default URL:

How does SharePoint do the translation? Possible scenarios:
a) In real time every time the page is loaded. This means that in the database, the absolute link is still there.
b) in the background process (database) (not very probable).
c) When the user saves the content.

Shortly after saving, on the back end (in the content database, table AllUserData, field ntext2) the links are already relative:

<div class=ExternalClass97C68512A4184122B15D3302EC759305>
<div><a href="http://portal.client.org">http://portal.client.org</a></div>
<div><a href="/">http://intranet.client.com</a> </div></div>

What happens when you add additional alternative access mappings AFTER you already entered content? The relative URL’s are no more updated, they stay as they were with an old AAM.

So this conversion takes place when the user saves the content (scenario c).

Cheating like trying to put a slash next to short URL in AAM doesn’t work, the extra slash is cleaned on saving.

This behavior was noticed a long time ago and not fixed by now in SP 2007:

http://www.eggheadcafe.com/software/aspnet/30556472/directrelative-links-in.aspx

http://www.toddklindt.com/blog/Lists/Posts/Post.aspx?ID=57

http://blog.mastykarz.nl/inconvenient-content-editor-web-part/

Luckily in SharePoint 2010 this bug is fixed.

Orbit One has developed a unique solution that allows you to track and analyse “unhandled exceptions” in the code of web applications. “Unhandled exceptions” are problems that are not supposed to happen.
No system is perfect and environmental changes as well as different types of clients devices (browsers) can result in small issues.
You can make a friendly error page that explains the user an issue has happened, and invite him to try his action again.
If the problem remains, the user can click on a link and send an email to your support.
This email contains the unique reference number of the issue.
Your development team can monitor and fix the issues as soon as possible.
All issues are centralized in a database, allowing your team to quickly find detailed information about the problem.
This unique solution allows you to be efficient and provide high quality web applications.

You can find more information, the code, documentation and ready to use installers on Codeplex.

Orbit One provides videoconferencing solutions based on LifeSize equipment.
In this PowerPoint presentation we share our tips and guidelines.

• Why videoconferencing
• Types of videoconferencing
• LifeSize 200 series models
• Multiple monitors
• Technical guidelines
• Meeting Room adjustments
• Additional equipment

http://www.slideshare.net/orbitone/high-definition-videoconferencing

Find our PowerPoint presentations on http://www.slideshare.net/orbitone

• NUnit vs MSTest
• Continuous Integration
• Interacting with the Exchange Web Services
• ReportViewer Web Server Control
• Introduction to Code Reviews
• Office Communication Server Integration
• Introduction and tips about Microsoft Dynamics CRM
• Nintex - SharePoint Workflow

More to come!

The Composite Application Library helps architects and developers create composite Windows Presentation Foundation (WPF) and Silverlight applications. Composite applications are composed of discrete, functionally complete, pieces that work together to create a single, integrated user interface. The Composite Application Library accelerates the development of composite applications using proven design patterns to help you build these types of applications.

Commands are a way to handle user interface (UI) actions. They are a loosely coupled way to bind the UI to the logic that performs the action.

When building composite applications, presentation design patterns such as Model-View-Presenter (MVP) and Model-View-Controller (MVC) are often used to separate the UI logic from the UI layout and presentation. When implementing these patterns with Windows Presentation Foundation (WPF), the presenter or controller handles commands but lives outside the logical tree. WPF-routed commands deliver command messages through UI elements in the tree, but the elements outside the tree will not receive these messages because they only propagate events up or down from the focused element or an explicitly stated target element. Additionally, the WPF-routed commands require a command handler in the code behind.

The Composite Application Library introduces two new commands that can be routed outside the boundaries of the logical tree and that do not require handling logic in the code behind. The commands are custom implementations of the ICommand interface defined by WPF, and they implement their own routing mechanism to get the command messages delivered to objects outside of the logical tree. The commands in the Composite Application Library include DelegateCommand and CompositeCommand.

The command support in WPF is at this moment rather limited. Very few of the default controls support binding to a command. One of the controls that has a Command dependency property is the Button.

If we want to execute some code on button press and we want to leverage the commanding support, we need a few things in the view model and in the XAML view:

1. a property for the command

public ICommand ClickCommand {get; set;} 

2. Initialization code for the command (eventually in the view model’s constructor)

public MyConstructor()
{
  ClickCommand = new DelegateCommand<object>(OnClickCommand);
}

3. Command handler:

private void OnClickCommand(object argument)
{  /**/ }

4. and some XAML code in the view that guarantees the command will be executed on button click:

<Button Height="24" x:Name="MyButton"  
        Command=”{Binding ClickCommand}”/>

This is straightforward if you are familiar with the M-V-VM pattern.

Let’s consider another scenario where we need to execute a command for the lost focus event of a TextBox. To be able to solve this in the same manner as above we would need to use the Command dependency property of the TextBox and bind a DelegateCommand to it.

Unfortunately, the TextBox does not accept commands by default for the lost focus event.

A solution to the problem is to use the attached properties feature of WPF.

The goal is to create an attached property for the TextBox. The attached property’s name will also be Command and the command bound to it will handle the PreviewLostKeyboardFocus event. After we have this, we will be able to write the following code in the XAML view:

<UserControl xmlns:Commands= "clr-namespace:{namespace containing the attached command class}">
   <TextBox Commands:PreviewLostKeyboardFocus.Command="{Binding MyTextBoxPreviewLostKeyboardFocus}"/>
</UserControl>

The code in the view model is identical as for the Button scenario (but with suggestive variable and method names of course):

public ICommand LostFocusCommand {get; set;}
public MyConstructor() 
{
   ClickCommand = new DelegateCommand<object>(OnLostFocusCommand); 
} 
private void OnLostFocusCommand(object argument)
{  …  } 

Now let’s dive into the implementation of the attached CommandProperty.

public class PreviewLostKeyboardFocus
    {
        /*Dependency property for the Command attached property. 
         For the Command property to be bindable it has to be dependency property.*/
        public static readonly DependencyProperty CommandProperty = DependencyProperty.RegisterAttached(
                "Command",
                typeof (ICommand),
                typeof (PreviewLostKeyboardFocus),
                new PropertyMetadata(OnSetCommandCallback));

        public static readonly DependencyProperty LostFocusCommandBehaviorProperty =
                DependencyProperty.RegisterAttached("LostFocusCommandBehavior",
                                                    typeof (TextBoxLostFocusCommandBehavior),
                                                    typeof (PreviewLostKeyboardFocus),
                                                    null);

        /*Acessor methods for the Command attached property*/
        public static void SetCommand(TextBox textBox, ICommand command)
        {
            textBox.SetValue(CommandProperty, command);
        }

        public static ICommand GetCommand(TextBox textBox)
        {
            return textBox.GetValue(CommandProperty) as ICommand;
        }
       
        /*Callback executed when the Command property  is databound*/
        private static void OnSetCommandCallback(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            var textBox = d as TextBox;
            if (textBox != null)
            {
                TextBoxLostFocusCommandBehavior behavior = GetOrCreateBehavior(textBox,  e.NewValue as ICommand);
            }
        }

        /*Creates the command behavior if it does not already exist*/
        private static TextBoxLostFocusCommandBehavior GetOrCreateBehavior(TextBox textBox, ICommand command)
        {
            var behavior = textBox.GetValue(LostFocusCommandBehaviorProperty) as TextBoxLostFocusCommandBehavior;
            if (behavior == null)
            {
                behavior = new TextBoxLostFocusCommandBehavior(textBox, command);
                textBox.SetValue(LostFocusCommandBehaviorProperty, behavior);
            }
            return behavior;
        }

        #region Nested type: TextBoxLostFocusCommandBehavior

        /*Wrapper for the PreviewLostKeyboardFocus  event*/
        public class TextBoxLostFocusCommandBehavior : CommandBehaviorBase<TextBox>
        {
            public TextBoxLostFocusCommandBehavior(TextBox textBox, ICommand command) : base(textBox)
            {
                Command = command;
                textBox.PreviewLostKeyboardFocus += (sender, args) => Command.Execute(new PreviewLostKeyboardFocusCommandArgs
                                                                                          {
                                                                                                  Sender = (TextBox) sender,
                                                                                                  KeyboardFocusChangedEventArgs = args
                                                                                          }); 
            }
        }

        #endregion
    }

As it’s obvious from the event wrapper class, the event forwards the sender and the event arguments to the command. So the command’s handler has access to the same data as the event itself. the PreviewLostKeyboardFocusCommandArgs  class is a custom class used to transfer parameters:

public class PreviewLostKeyboardFocusCommandArgs
{
    public TextBox Sender { get; set; }
    public KeyboardFocusChangedEventArgs KeyboardFocusChangedEventArgs { get; set; }} 

The PreviewLostKeyboardFocus class might seem quite verbose, but this is the standard WPF way of defining attached properties that can take part in the data binding binding process.

Most of the code is standard and can be extracted in a R# template. The template can be downloaded here.

That’s it!

With just a little coding effort we can have a clean view and be able to wrap WPF event in Commands and handle the view events in the view model or controller(depending of the design approach).

When importing data in Dynamics CRM 4.0 there is no client side code triggered, so to make sure you get phonenumbers (or anything else for that matter) in a clean format, you might want to consider creating a plugin that runs server side and generates an import failure to let the customer know some data is not valid in his imports.

This way the user knows when something went wrong and the correct data will still be imported.

To make this plugin work there is the issue of the country prefixes and areacodes that exist. Therefore it is necessary to create two new entities: Country and AreaCode.

The Country entity needs to contains the telephone prefix of that country (eg: belgium = 32, Netherlands = 33 …)

The AreaCode is contains a link to the country entity and contains the phone areacode. (eg: 9 for Ghent, Belgium …)

Ones this data is in CRM we can use it in our plugin through the webservice.

In the end the phonenumbers will be formatted in an outlook compatible format.

eg: +32 (9) 265.74.20

When using the installer inside the project on CodePlex the plugin will be registered for the create and update messages for lead, account and contact.

You can find the plugin on CodePlex in our Dynamics CRM 4.0 Plugins project

Why do I need it?

We've noticed the CRM Duplicate detection doesn't allow for much creativity, you can only create Duplicate Detection Rules with the following condition:

• full string match
• begins with (number of characters)
• ends with (number of characters)

The problem with this is that people or companies aren't always entered in the same format. For instance if you look at our company name we would create the account with the name "Orbit One". Other people might write "Orbit One BVBA" (the bvba part is a type of business entity)
There are some other examples that come to mind:
"Dell NV" vs "Dell"
"HP Belgium" vs "HP"
"Gaëtan" vs "Gaetan"
"François" vs "Francois"
These exceptions will never be caught by the default CRM Duplicate detection.

How can I fix this?

We added the following attributes and filled the with data:

• on account => new_matchname (contains the accounts name)
• on contact => new_matchname (contains the contacts first + lastname)
• on lead => new_matchcontact (contains the leads first+ lastname)
• on lead => new_matchcompany (contains the lead company name)

The fields are filled with a normalized name. The process is:

• to lower case and trim.
• replace special characters (except parenthesis, a-z, 0-9, special characters like éèàç ..., and spaces) with empty string.
• remove everything between the parentheses eg: "HP (was Compaq)" becomes "HP"
• remove suffixes and prefixes that are type of business entity
• remove all spaces
• replace special characters (eg: é > e, à => a, ç => c, ñ => n, ...)

Next there need to be some new duplicate detection rules.

• full string match on new_matchname for contact
• full string match on new_matchname for account
• full string match on new_matchcontact for lead (add companyname if needed in your specific cases)

The current implemented type of business entity which will be stripped are:

• nv
• sa
• vzw
• bvba
• cvba
• sarl
• sprl
• scrl
• nvsa
• bv
• llc
• gmbh
• ltd
• ag
• kt
• og
• vof
• cvoa
• commva
• commv
• ebvba
• ez
• belgium

Duplicate Detection Jobs

In CRM you can add duplicate detection jobs by going to Settings > Data Management > Duplicate detection jobs

Create a new Duplicate detection job for for instance accounts. Make sure you filter on only active records. When you merge a duplicate record the record that isn’t the master record will be placed on inactive. So if you forget this filter you’ll keep getting the same duplicates ;-)

Once the job ran, you can see the duplicates entries.

What we think is another major pain in the a$$ is that you can only merge 2 records at a time. So not really in bulk… Maybe we will come up with a solution for this later :-)

You can find the Matchname plugin on CodePlex. There is an installer include so that you don’t need to worry about the plugin registration, creating the steps, …. More on this on CodePlex.

The document attached to this blog provides instructions for implementing a basic image-based deployment of Microsoft Windows 7 RC0 operating system.

Migrating an operating system is a major project that requires careful planning and guidance. To ease the process, Microsoft has provided a number of tools for automating Windows 7 deployments including the Windows Automated Installation Kit (WAIK). For Windows 7 Microsoft has released the Beta version of WAIK version 2.0.

There are many guides available on the internet, but we felt they all miss some steps. Therefore we decided to share our internal documentation.

The process for our deployment scenario includes

The document attached does not cover automated deployment of images on multiple computers using tools as ADS.

 Download documentation

The other day we did some research for a client into the synchronization behavior of Dynamics CRM for Outlook specifically when it comes to activities.

Syncing activities like: Tasks, Appointments, Phone Calls and Letters to Outlook is a powerful option in Dynamics CRM but there can be some ambiguity into what’s gets synced where and what happens when you delete items from Outlook that were previously synced to or from CRM.

These are my current activities viewed in the CRM web client.

Looking in my Outlook To-Do bar I get a mix of CRM activities and my own Tasks

As you can see from the example above not all activities get synced from CRM to Outlook. So which ones do and what is there counterpart in Outlook?

Sync activities to Outlook

→ All get synced as tasks in  Outlook.

• Email

→ Email after it’s been send gets synced as sent email but before send it doesn’t get synced to Outlook

• Appointments

→ Appointments get synced to Outlook as meeting in your Calendar.

• Campaign responses

→ Won’t show up in Outlook.

• Service activities

→ Service activities show up as meetings in Outlook

Deleting items in Outlook

This is all quite straightforward but when deleting items in Outlook it is not always clear what happens to the activities in CRM. Well the sync behavior is depended on the status of the activity.

• When an activity is completed CRM it will stay in CRM but it won’t get synced back to Outlook.
• When deleting an activity that is not yet completed it will delete in Outlook and CRM.

Although it would be nice to have the email activity before send also synced to a task in Outlook the overall behavior is quite nice and keeps your work load from CRM and Outlook thightly together which I think is a real advantage over other CRM systems.

Deleting items in CRM

Again the behavior is depended on the status of the activity.

• When an activity is completed CRM it will stay in Outlook.
• When an activity is not yet completed CRM it will be deleted from Outlook as well.

 Some more information Microsoft written about this sync behavior:

http://rc.crm.dynamics.com/rc/regcont/en_us/OP/help/ug_ol_RecordsActivities.htm

When you use Microsoft Dynamics CRM Outlook Client 4.0 on a computer with Internet Explorer 8 (IE8), you might have experienced unexpected “Signed Out” of your Outlook Client every time you open the CRM web interface in Internet Explorer:

You are then unable to use the CRM Outlook Client until you restart Outlook:

First make sure you have the latest Update Rollup installed on your desktop as well as on the server.

Currently Update Rollup 6 is the most recent

http://www.microsoft.com/downloads/details.aspx?displaylang=en&FamilyID=79f90982-c039-41c2-af8e-3119ecf27790

Outlook

First correctly configure the Outlook client with the right URL settings.

Go to CRM > Change organization in Outlook

Choose Online service provider

Url for production crm orbitone is:

https://orbitonecrm.orbitone.com

Go through the other steps, next, next,… finish.

Start Outlook and give CRM credentials. Save user name password.

IE

Now start IE and go to Tools > Internet Options > security tab

Click Reset all levels to default button

Click Intranet zone > Sites > Advanced > enter same URL: https://orbitonecrm.orbitone.com

Click Intranet zone > Enable Protected mode (Requires restarting Internet Explorer)

Works like a charm!

See also:

CRM 4.0: Forced logout from Outlook CRM client when using web client
http://social.microsoft.com/Forums/en-US/crm/thread/4f558522-db2e-4dae-a2fa-9391af66e237

User signed out involuntarily

https://community.dynamics.com/forums/t/6853.aspx

We needed a drop down box in our CRM 4.0 environments for a lot of our clients. The data from the drop down should come from within CRM 4.0 to limit the dependencies to other systems.

The cleanest way we found to do this is via an autocomplete textbox which is actually jQuery.  To make it work we needed to get data from CRM through the CRM webservice. We did this with some helper objects that we found athttp://blogs.inetium.com/blogs/azimmer/archive/2009/02/01/crm-4-0-javascript-web-service-helper-objects.aspx. These objects are created to support a .Net like language to connect to the CRM webservice.

The next problem was an autocomplete function in JavaScript. For this we chose the functions from http://www.pengoworks.com/workshop/jquery/autocomplete.htm. We changed these a bit so there is no-more CSS included, because we did not want to load this (since the look and feel of CRM won’t change (for now)) and we don’t want to screw up the CRM classes that are already in place on the form.

How does it stick together?

Finally we needed to write some plumbing code to make it work.

In the onLoad event of the form you’ll need to add the following code:

function load_script (url) 
{ 
    var x = new ActiveXObject("Msxml2.XMLHTTP"); 
    x.open('GET', url, false); x.send(''); 
    eval(x.responseText); 
    var s = x.responseText.split(/\n/); 
    var r = /^function\s*([a-z_]+)/i; 
    for (var i = 0; i < s.length; i++){ 
        var m = r.exec(s[i]); 
        if (m != null) 
            window[m[1]] = eval(m[1]); 
    } 
} 

load_script("/Custom/ISV/jquery-1.3.2.min.js");
var scriptTag1 = document.createElement("<script src='/Custom/ISV/jquery.autocomplete.js' type='text/javascript'>");
var scriptTag2 = document.createElement("<script src='/Custom/ISV/crmHelpers.js' type='text/javascript'>");
var scriptTag3 = document.createElement("<script src='/Custom/ISV/ISVspecific.js' type='text/javascript'>");
var array = new Array();
array = document.getElementsByTagName("head");
array[0].insertAdjacentElement("afterBegin", scriptTag1);
array[0].insertAdjacentElement("afterBegin", scriptTag2);
array[0].insertAdjacentElement("afterBegin", scriptTag3);

As for the creation of the ISVspecific.js script I would like to link to a previous post a wrote on Client-side validation scripts. In that post you can see a way to create a script paste it in CRM without changing code in the events of every field on every form.

The contactFormLoad function from the previous post (Client-side validation scripts):

function contactFormLoad(){
    var zipoptions = {
                        "borderColor" : "#6699CC",
                        "selectedColor" : "#a7cdf0",
                        "background" : "white",
                        "getDataCallback" : GetCountries 
                     };
    $("#address1_country").autocomplete(zipoptions);
    //add you other onchange scripts here
}

The GetCountries which is assigned to getDataCallback is where the CRM service queries are performed. This should be your own implementation. I have prepared some sample code that retrieves countries from a small custom entity called new_country with the attributes new_countryid and new_name.

function GetCountries(partialCountry){
    try{
        var crmService = new CrmService("new_country", LOGICAL_OPERATOR_OR);
        crmService.AddColumn("new_name");
    
        if(partialCountry != null){
            crmService.AddFilterCondition("new_name", partialCountry + "%", CONDITION_OPERATOR_LIKE);
        }
        var result = crmService.Fetch(20);
        
        for(var i in result.Rows)
        {
            var s= "";
            for(var j in result.Rows[i].Columns)
            {
                s += result.Rows[i].Columns[j].Value;
            }
        }
                
        var ar = new Array();
        var i = 0;
        var addvalue = true;
        for (rowsNumber in result.Rows) {
            addvalue = true;
            var newval = result.Rows[rowsNumber].GetValue("new_name");
            for(resultRow in ar) {
                if(ar[resultRow] == newval) {
                    addvalue = false;
                    break;
                }
            }
            if(addvalue){
                ar[i] = newval;
                i++;
            }
        }
        return ar;
    }
    catch(er) {
        alert(er.message);
    }
}

As you can see in the above code block, the function takes one parameter, being the part you typed in the field you need the autocomplete functionality on. Then some fetch xml is generated by the crmHelper objects and the query is executed. This will only get 20 records as specified in the line crmService.Fetch(20).

The crmHelpers.js contains a method called CrmService.prototype.Fetch, which is a reworked version of the CrmService.prototype.RetreiveMultiple from the code of Andrew Zimmer.

If you would like to use the autocomplete function on a lookup field in CRM (yes, that also works :)) you need to add “_ledit” (without the quotes) to the fieldname. Example:

$("#new_countryid_ledit").autocomplete(zipoptions);

You can download a complete sample but don’t forget to create the new_country entity if you want to test.

We have used NHibernate as ORM mapper in many projects and to facilitate automatic session and transaction management we employed the Castle Windsor NHibernate Integration facility.

When using the Castle NHibernate Facility the configuration file for castle (castle.xml.config) looks like this:

Where the mapping assembly contains all the .hbm.xml files as embedded resources.

When the Fluent NHibernate framework appeared we started thinking about using it in our projects. But we wanted to do this with minimal changes to the Castle configuration schema (in the above screenshot).

The ideal situation would be to specify an assembly containing the Fluent NHibernate mapping classes instead of the assembly containing mapping xml files.

In the screenshot from above you can see in the  highlighted area an <assembly/> declaration. That assembly will be used by Castle NHibernate Facility’s default xml mapper.

We would like to make it possible to specify our own mapper which will make use of Fluent NHibernate to load the mapping classes from the specified assembly.

As the Fluent NHibernate framework is open-source, we considered making out custom build to add the needed functionality. Next I will describe the steps needed to implement and use the custom Fluent NHibernate mapper with Castle’s NHibernate Facility.

1. Download the necessary source files:

• Castle Project 
• Fluent NHibernate

2. Create a new solution including the following projects:

• Castle.Core
• Castle.DynamicProxy
• Castle.Facilities.NHibernateIntegration
• Castle.MicroKernel
• Castle.Services.Transaction
• Castle.Windsor
• FluentNHibernate
• NHibernate.Mapping.Attributes-2.0

3. Create a new folder in the in the Castle.Facilities.NHibernateIntegration project. The project structure should look like the following:

4. In the previously created folder add the following:

• An interface called INhibernateMapper This is the base for all the NHibernate mapper types.
• A class named DefaultNHibernateMapper.
• A class named AttributeNhibernateMapper.
• A class named FluentNhibernateMapper.
  The class diagram is shown below:
   

5. Implement the FluentNHibernateMapper:

  The RegisterAssemblies method loads the assemblies specified in the <assembly/> section of the castle configuration file and registers the FluentNhibernate mapping classes with NHibernate.

6. Expand the Castle.Facilities.NHibernateIntegration project, look for the NHibernateFacility.cs file and locate the protected void RegisterAssemblies(Configuration cfg, IConfiguration facilityConfig) method.

Replace the method’s contents with the following code:

The method tests if a mapper is declared in the <assembly/> section of the castle configuration file. If yes, it will use it. If not it will use the DefaultNhibernateMapper (xml).

Conclusion:

The schema of the configuration file does not change if the preferred mapping type is xml. If the mappings are defined using FluentNHibernate then the castle configuration file transforms like the following:

The extra attribute – mapper  - specifies which IHNibernateMapper implementation to use for loading the NHibernate mappings.

The custom mappers can be implemented in a separate assembly. But the interface (IHNibernateMapper) needs to be located the Castle.Facilities.NHibernateIntegration assembly, because the entry point for loading the NHibernate mapping assemblies is the RegisterAssemblies method in the NHibernateFacility class.

The full source code can be downloaded here.

1. Open CRM
2. Goto Settings
3. Click on the Customization link in the menu (left side)
4. Select the entity for which you want to validate a field
5. Click Forms and Views in the new screen (again on the left side)
6. double click on the Form item
7. double click on the Field you want to validate
8. Select the tab Events
9. Click on the Edit button
10. Write your validation logic in JavaScript
11. Do not forget to enable the event with the checkbox above your validation code
12. Click the OK button
13. Click the OK button
14. Click the Save and Close button on top
15. Click the Actions button on top and select publish.

Steps 7 through 14 are the steps you'll need to do for every field if you do the validations in bulk.

What we do now is the following. We add some code to the OnLoad event of the form as following:

1. Open CRM
2. Goto Settings
3. Click on the Customization link in the menu (left side)
4. Select the entity for which you want to validate a field
5. Click Forms and Views in the new screen (again on the left side)
6. Double click on the Form item
7. Click on the Forms Properties button on the right side
8. Click on the Edit button
9. Write code here:
   var scriptTag = document.createElement("<script src='/Custom/validation.js' type='text/javascript'>" );
   var array = new Array();
   array = document.getElementsByTagName("head");
   array[0].insertAdjacentElement("afterBegin", scriptTag);
10. Do not forget to enable the event with the checkbox above your validation code
11. Click the OK button
12. Click the OK button
13. Click the Save and Close button on top
14. Click the Actions button on top and select publish.

• we can migrate the validations from our staging environment to the production environment by just copying one file.
• we can just edit the file instead of having to click a bunch of times in the CRM web interface
• we can still do everything through the CRM web interface
• we can manage the one file in our source control more easily and track everything better.

I’m currently writing a web service on our SharePoint server to upload documents because one of our clients would like to migrate from a third party document management system to SharePoint.

This client would like to keep the legacy dates like the date of creation and the last modified date. After researching this, I still couldn’t find a way to do this. I noticed there are tools out there are able to do this so it is definitely possible.

So after some more trial and error I finally figured it out. And it wasn’t even that exotic, so I’d like to share how it is done.

When you’ve uploaded the file and checked it in you can change the dates with the following code:

public void UpdateFileDates(

string siteCollectionUrl, string site, 

string file, DateTime created, DateTime modified)

{

    if (siteCollectionUrl == null) 

       throw new ArgumentNullException("siteCollectionUrl");

    using (var spSite = new SPSite(siteCollectionUrl))

    using (var web = string.IsNullOrEmpty(site)

                        ? spSite.RootWeb

                        : spSite.OpenWeb(site))

    {

        var spFile = web.GetFile(file);

        if (spFile != null)

        {

            spFile.CheckIn("");

            var item = spFile.Item;

            if (item != null)

            {

            item["Created"] = created;

            item["Modified"] = modified;

            spFile.CheckOut();

            item.Update();

            //When you do overwritecheckin the 

	   // version doesn't change.

            spFile.CheckIn("", SPCheckinType.OverwriteCheckIn);

            }

        }

    }

}

From 6 to 8 April there is a very interesting conference in London.

Some very known speakers will be there: Joel Oleson, Andrew Connell, Ben Curry, Bob Fox, Eric Schupps, John Timney, …

The same conference was organized in San Diego, California begin February 2009.

They promise it's not a typical "blabla" conference, the point is to go beyond introductions and focus on best practices gathered by on-the-field experience.

Agenda http://www.sharepointbestpractices.co.uk/Agenda.html

From Joel's blog:

"I think the main difference that really stands out to me on this conference vs other SharePoint conferences is the prescriptive nature of the content, with the real world, case study and experience based emphasis. Speakers are grilled on making sure you cover the true WHY and not focus so much on HOW TO. The content is scrubbed to encourage depth and thought in WHY something should be done or not done."

Orbit One will be there!

Viktor, Mel, Rik, Bart and Olivier will join the conference in London. Are you coming too?
Let us know so we can have a beer!

It was previously impossible to mock/fake a SharePoint server which ruled out a full TDD approach or writing unit tests.

Typemock are offering their new product for unit testing SharePoint called Isolator for SharePoint, for a special introduction price. it is the only tool that allows you to unit test SharePoint without a SharePoint server. To learn more click here.

The first 50 bloggers who blog this text in their blog and tell us about it, will get a Full Isolator license, Free. for rules and info click here.

• Prepare an USB stick with “Windows PE Boot Disk”
• Prepare and capture an image (ImageX)
• Manually deploy an image on a single machine (ImageX)

what is jQuery?

jQuery is a lightweight open source JavaScript library (only 15kb in size).

Just recently Microsoft and Nokia announced they will support the JQuery library in their products! Initially they wil integrate it in Visual Studio and use within Microsoft's ASP.NET AJAX framework and ASP.NET MVC Framework.

I'm currently integrating jQuery in MOSS 2007 sites. A first examples is our client pages. I will soon post some tips.  

• Install Vasco Middleware on your server
• Assign Digipass tokens
• Configure the policies
• Configure Juniper Secure Access SSL VPN
• Test configuration and troubleshoot

Hello again,

Today I would like to look into creating a Distribution List through the Exchange Webservice. This is not as straight forward as creating a contact, but it should work none the less. According to this book and the documentation found on the internet, it is not possible to accomplish this. But there is a way around. Lets take the scenic route to create a Distribution List J

Take a look at the code in the previous post. You can see that - in the method to create the contact - a CreateItemType is instantiated. If you look at the Items property of that variable you can see that the it expects an NonEmptyArrayOfAllItemsType which again has an Items Property. In that property we can store any ItemType we want except a Distribution List, as you can see here. But if we can not insert the DistributionList in a CreateItem, then how the f* are we going to get it to the exchange server. Well we are going to create an ItemType (base class) and use that to set all the properties needed so that exchange and outlook recognizes the Item as a distribution list. Because an ItemType is the base class, it is not provided with any of the properties we need to create a distribution list. That is where the Extended Properties come in handy. Everything needs to be set through those properties.

Here are some links with more information on the properties:

• [MS-OXOCNTC]: Contact Object Protocol Specification
• [MS-OXPROPS]: Exchange Server Protocols Master Property List Specification

And you can also still use OutlookSpy which was linked in the previous post.
Now for some code.
The first thing I'd like to do is declare the path to extended field variables and set them to point to the properties we're going to use. I'll name them all starting with ptef so we can get the quickly through intellisense.

private static PathToExtendedFieldType ptefDisplayName = 
   new PathToExtendedFieldType
{
  PropertyTag = "0x3001",
  PropertyType = MapiPropertyTypeType.String
};

private static PathToExtendedFieldType ptefDistributionListName = 
   new PathToExtendedFieldType
{
  PropertyId = 0x8053,
  PropertyIdSpecified = true,
  DistinguishedPropertySetId = DistinguishedPropertySetType.Address,
  DistinguishedPropertySetIdSpecified = true,
  PropertyType = MapiPropertyTypeType.String
};

private static PathToExtendedFieldType ptefFileUnder = 
   new PathToExtendedFieldType
{
  PropertyId = 0x8005,
  PropertyIdSpecified = true,
  DistinguishedPropertySetId = DistinguishedPropertySetType.Address,
  DistinguishedPropertySetIdSpecified = true,
  PropertyType = MapiPropertyTypeType.String
};

private static PathToExtendedFieldType ptefMembers = 
   new PathToExtendedFieldType
  {
  PropertyId = 0x8055,
  PropertyIdSpecified = true,
  DistinguishedPropertySetId = DistinguishedPropertySetType .Address,
  DistinguishedPropertySetIdSpecified = true,
  PropertyType = MapiPropertyTypeType.BinaryArray
};

private static PathToExtendedFieldType ptefOneOffMembers = 
   new PathToExtendedFieldType 
{
  PropertyId = 0x8054,
  PropertyIdSpecified = true,
  DistinguishedPropertySetId = DistinguishedPropertySetType.Address,
  DistinguishedPropertySetIdSpecified = true,
  PropertyType = MapiPropertyTypeType.BinaryArray
};

Let's take a look at these PathToExtendedFieldTypes:

• ptefDisplayName: The name of the Distribution List
• ptefDistributionListName: The name of the Distribution List
• ptefFileUnder: Must be the same as the name of the Distribution List
• ptefMembers: The members extended property: This i a list of EntryIds of the objects corresponding to the members of the personal distribution list. Members of the personal distribution list can be other distribution lists, electronic addresses contained in a contact, global address list users or distribution lists, or one-off e-mail addresses. The format of each EntryId MUST be either a one-off EntryId or a Wrapped Entry Id. When setting this property, be sure to ensure its total size is less than 15,000 bytes. Since this property is a BinaryArray type it expects a string Array of Base64 strings. More info can be found in the Protocol Specifications on the MSDN site.
• ptefOneOffMembers: The property specifies the list of one-off EntryIds corresponding to the members of the personal distribution list. These one-off EntryIds encapsulate display names and e-mail addresses of the personal distribution list members. For each entry in this property, there should be an entry in the Members property. The size of this property must also be less than 15,000 bytes. Since this property is a BinaryArray type it expects a string Array of Base64 strings.

private static ContactItemType CreateContact(string pGivenName, string pSurname, Gender pGender, string pTitle)
{
  ContactItemType retval = null;
  ContactItemType contact = new ContactItemType();
  contact.GivenName = pGivenName;
  contact.Surname = pSurname;
  contact.DisplayName = contact.Subject = pGivenName + " " + pSurname;
  contact.EmailAddresses = new EmailAddressDictionaryEntryType[1];
  EmailAddressDictionaryEntryType email1 = 
    new EmailAddressDictionaryEntryType();
  email1.Key = EmailAddressKeyType.EmailAddress1;
  email1.Value = "testUser@example.com";
  contact.EmailAddresses[0] = email1;
  contact.ExtendedProperty = new ExtendedPropertyType[2];
  ExtendedPropertyType gender = new ExtendedPropertyType();
  gender.ExtendedFieldURI = new PathToExtendedFieldType();
  gender.ExtendedFieldURI.PropertyTag = "0x3a4d";
  gender.ExtendedFieldURI.PropertyType = MapiPropertyTypeType.Short;
  gender.Item = ((int)pGender).ToString();
  ExtendedPropertyType title = new ExtendedPropertyType();
  title.ExtendedFieldURI = new PathToExtendedFieldType();
  title.ExtendedFieldURI.PropertyTag = "0x3a45";
  title.ExtendedFieldURI.PropertyType = MapiPropertyTypeType.String;
  title.Item = pTitle;
  contact.ExtendedProperty[0] = gender;
  contact.ExtendedProperty[1] = title;
  CreateItemType createItem = new CreateItemType();
  createItem.Items = new NonEmptyArrayOfAllItemsType
    { 
      Items = new[] { contact }
    };
  DistinguishedFolderIdType folder = 
    new DistinguishedFolderIdType();
  folder.Id = DistinguishedFolderIdNameType.contacts;
  TargetFolderIdType targetFolder = new TargetFolderIdType();
  targetFolder.Item = folder;
  createItem.SavedItemFolderId = targetFolder;
  var response = esb.CreateItem(createItem);
  //There is only one item in the createItem 
  //so the line below should work in this case
  if (response.ResponseMessages.Items[0].ResponseClass == 
      ResponseClassType.Success)
  {
    ItemInfoResponseMessageType rmt = 
      (ItemInfoResponseMessageType)response.ResponseMessages.Items[0];
    retval = (ContactItemType)rmt.Items.Items[0];
  }
  return retval;
}

To create a Distribution List with members you will need to find the EntryId when all we have is the ItemId and we want it in a Hex format. To achieve this I want to use the ConvertId Method on the ExchangeServiceBinding. The convertId Method accepts a ConvertIdType as a parameter. The ConvertIdType properties that are used here are the sourceIds and the destinationFormat. They kinda speak for themselves.

Lets take a look at some code again.

private static string CreateMemberEntryId(ItemType item)
{
  byte[] retval = new byte[0];
  string WrappedEntryIDPrefix = 
      "00000000C091ADD3519DCF11A4A900AA0047FAA4C3";
  ConvertIdType convertReq = new ConvertIdType();
  convertReq.DestinationFormat = IdFormatType.HexEntryId;
  convertReq.SourceIds = new[]
  {      new AlternateIdType()
     {
        Format = IdFormatType.EntryId,
        Id = item.ItemId.Id
     }
  };
  try
  {
    ConvertIdResponseType response = esb.ConvertId(convertReq);
    ArrayOfResponseMessagesType aormt = response.ResponseMessages;
    ResponseMessageType[] rmta = aormt.Items;
    foreach (ConvertIdResponseMessageType resp in rmta)
    {
      if (resp.ResponseClass == ResponseClassType.Success)
      {
        ConvertIdResponseMessageType cirmt = resp;
        AlternateIdType myId = (cirmt.AlternateId as AlternateIdType);
        if (myId != null)
        {
        //Strip the last 48 bytes (96 chars) 
        //this is actually the folderId.
        //Strip the first 7 bytes.
        //then remove 1 byte right after the actual entryId (40 bytes)
        //then the ChangeKey follows (in the rest of the string).
           StringBuilder sb = new StringBuilder();
           sb.Append(WrappedEntryIDPrefix);
           sb.Append("00000000");
           sb.Append(myId.Id.Substring(14, 84));
           sb.Append(myId.Id.Substring(100, myId.Id.Length - 196));
           retval = sb.ToString().ToByteArray();
        }
      }
      else if (resp.ResponseClass == ResponseClassType.Error)
      {
      //TODO error Logging
      }
      else
      {
      //TODO warning logging
      }
    }
  }
  catch (Exception e)
  {
    //TODO error logging
  }
  return Convert.ToBase64String(retval);
}

You can see in previous code block that there is some comment:
Strip the last 48 bytes (96 chars) - this is actually the folderId.
Strip the first 7 bytes.
Then remove 1 byte right after the actual entryId (40 bytes)
Then the ChangeKey follows (in the rest of the string).

Don't pay to much attention to this for the moment. If you want more information about this check out [MS-OXOCNTC]: Contact Object Protocol Specification. The WrappedEntryIDPrefix is a fixed string except the last 2 characters. What it stands for you see in the protocol specification but in the MS-OXOMSG pdf.

They represent a bit settings which specifies what kind of email address the entry id is going to be. So if you change that you could be talking about another distribution list for instance.

We are going to use this MemberEntryId and Members extended property of a distribution list. As said before we'll need the OneOffMembers entry's also so we can put them in the same position as the MemberEntryId. The OneOffMembers entry is a bit less complicated.

private static string CreateOneOffMemberEntryId(ContactItemType contact)
{
  var retval = new List<byte>();
  var flags = Encoding.Unicode.GetBytes("");
  var version = Encoding.Unicode.GetBytes("");
  var pad = Encoding.Unicode.GetBytes("");
  var muid = new byte[]
  {
    0x81, 0x2b, 0x1f, 0xa4, 0xbe,
    0xa3, 0x10, 0x19, 0x9d, 0x6e,
    0x00, 0xdd, 0x01, 0x0f, 0x54, 0x02
  };
  var wFlags = new byte[] {0x01, 0x90};
  var first = Encoding.Unicode.GetBytes(contact.Subject + "(" + contact.EmailAddresses[0].Value + ")");
  var middle = Encoding.Unicode.GetBytes("UNKNOWN");
  var last = Encoding.Unicode.GetBytes(contact.EmailAddresses[0].Value);
  retval.AddRange(flags);
  retval.AddRange(muid);
  retval.AddRange(version);
  retval.AddRange(wFlags);
  retval.AddRange(first);
  retval.AddRange(pad);
  retval.AddRange(middle);
  retval.AddRange(pad);
  retval.AddRange(last);
  retval.AddRange(pad);
  return Convert.ToBase64String(retval.ToArray());
}

Here we only need some actual strings from the contact to create the One Off Members entry. All the values except for wFlags, first, middle and last have fixed values. The wFlags should be changed to 0x8001 if you want to specify a distribution list. So it should read like this:

var wFlags = new byte[] {0x01, 0x80};
var first = Encoding.Unicode.GetBytes(distributionlist.Subject);
var middle = Encoding.Unicode.GetBytes("MAPIPDL");
var last = Encoding.Unicode.GetBytes("Unknown");

Now to actually create a distribution list with members we'll need to create an Item that has all the correct Extended Properties:

private static void CreateDistributionList(string name, string description, ContactItemType contact)
{
  ItemType list = new ItemType();
  list.ItemClass = "IPM.DistList";
  list.Subject = name;
  list.Body = new BodyType 
   { BodyType1 = BodyTypeType.Text, 
   Value = description };
  List<string> members = new List<string>();
  List<string> oneOffMembers = new List<string>();
  members.Add(CreateMemberEntryId(contact));
  members.Add(CreateOneOffMemberEntryId(contact));
  List<ExtendedPropertyType> eProps = 
    new List<ExtendedPropertyType>();
  eProps.Add(new ExtendedPropertyType
  {
    ExtendedFieldURI = ptefDisplayName,
    Item = name
  });
  eProps.Add(new ExtendedPropertyType
  {
    ExtendedFieldURI = ptefDistributionListName,
    Item = name
  });
  eProps.Add(new ExtendedPropertyType
  {
    ExtendedFieldURI = ptefFileUnder,
    Item = name
  });
  eProps.Add(new ExtendedPropertyType
  {
    ExtendedFieldURI = ptefMembers,
    Item = new NonEmptyArrayOfPropertyValuesType
    {
      Items = members.ToArray()
    }
  });
  eProps.Add(new ExtendedPropertyType
  {
    ExtendedFieldURI = ptefOneOffMembers,
    Item = new NonEmptyArrayOfPropertyValuesType
  {
    Items = oneOffMembers.ToArray()
  }
  });
  list.ExtendedProperty = eProps.ToArray();
}

UPDATE

I recently noticed that their are some errors in the CreateMemberEntryId. The best method is to retrieve the contact from the exchange store and ask for the entryId in the extended properties. In my experience this has much more performance and the created WrappedEntryId is correct. So the code will be more like following:

As you can probably see in the code this is not ready to ship...

There is alot more exception handling to be done and so forth, but in order to keep this document a bit more to the point I've skipped those parts.

During the past 2 weeks or so I've been experimenting with the Exchange Webservice (in Exchange 2007 SP1).

I've been trying to create a contact in the contacts folder of a user (testuser). I came accross some problems while trying to accomplish this. Specifically when I tried to set properties that are actually used by Outlook (client properties) and which are not necessarily used by Exchange 2007. But you can still access and even create properties all you want. Lets kick this blog off with the basics of working with the ews (Exchange WebService).

Some ground work:

• Create a new console app.
• Add the Web Reference to your Exchange Webservice (eg.: http://myMailServer/ews/Exchange.Asmx) and lets name it ExchangeService.
• Add the using to the ExchangeService

Now we can go and add a private member

private static ExchangeServiceBinding esb;

Initialize the ExchangeServiceBinding. You can insert credentials here in case of a https connection as seen in the example below.

esb = new ExchangeServiceBinding
{
   Credentials = new NetworkCredential
   {
      Domain = "example.com",
      UserName = "testUser",
      Password = "p455w0rd"
   },
   Url = https://192.168.2.143/EWS/Exchange.asmx
};
esb.RequestServerVersionValue = new RequestServerVersion();
esb.RequestServerVersionValue.Version = 
   ExchangeVersionType.Exchange2007_SP1;

As you can see in above code you need to set the server version, please do not ommit these 2 lines. If you do your code probably won't work. In some cases you will get an error like this: 

System.Web.Services.Protocols.SoapException: The request is valid but does not specify the correct server version in the RequestServerVersion SOAP header. Ensure that the RequestServerVersion SOAP header is set with the correct RequestServerVersionValue.

Now that we have the base of the application we can start concentrating on creating a contact, so we're going to create a method that does just that for us.

private static void CreateContact (string givenName, string surname)
{
  var contact = new ContactItemType();
  contact.GivenName = givenName;
  contact.Surname = surname;
  contact.DisplayName = contact.Subject = givenName + " " + surname;
  contact.EmailAddresses = new EmailAddressDictionaryEntryType[1];
  var email1 = new EmailAddressDictionaryEntryType();
  email1.Key = EmailAddressKeyType.EmailAddress1;
  email1.Value = "testUser@example.com";
  contact.EmailAddresses[0] = email1;
  var createItem = new CreateItemType();
  createItem.Items = new NonEmptyArrayOfAllItemsType
    {
       Items = new[] { contact }
    };
  var folder = new DistinguishedFolderIdType();
  folder.Id = DistinguishedFolderIdNameType.contacts;
  var targetFolder = new TargetFolderIdType();
  targetFolder.Item = folder;
  createItem.SavedItemFolderId = targetFolder;
  var response = esb.CreateItem(createItem);
}

You'll see the contact being created in you testUser's contacts folder.
If you don't fill out the DisplayName, the contact will complain about it in outlook when you open the contact and then close it without editing anything. Outlook will try to save the contact item although we did not change anything.

This was fairly easy to achieve, but just try to fill out all the contact's porperties you need. You'll soon find out that you need to use Extended Properties, because not all the properties are available on the ContactItemType type. I'll show you how to add 2 Extended Properties. Firstly the Gender of the contact and secondly the Title. Insert following somewhere before the instantiation of the CreateItemType createItem.

contact.ExtendedProperty =  new ExtendedPropertyType[2];
var gender = new ExtendedPropertyType();
gender.ExtendedFieldURI = new PathToExtendedFieldType();
gender.ExtendedFieldURI.PropertyTag = "0x3a4d";
gender.ExtendedFieldURI.PropertyType = MapiPropertyTypeType.Short;
gender.Item = "1";
var title = new ExtendedPropertyType();
title.ExtendedFieldURI = new PathToExtendedFieldType();
title.ExtendedFieldURI.PropertyTag = "0x3a45";
title.ExtendedFieldURI.PropertyType = MapiPropertyTypeType.String;
title.Item = "Dr.";
contact.ExtendedProperty[0] = gender;
contact.ExtendedProperty[1] = title;

As you can see both these Extended Properties have a PropertyTag. This is not always the case. In other properties you'll need to use the PropertyId and DistinguisedPropertyId, but we'll see samples of that in a later post in which I am going to discuss how you need to create a DistributionList with the contact created here as the only member.

The Property Tags and Ids can be found in the pdf's concerning the exchange protocol on MSDN or through a nice tool that helped me alot these past weeks: OutlookSpy.

That's it for now. I hope it was clear and helpfull in some way. If you have questions or remarks, do not hesitate to post a comment.

• The Entity Framework
• ADO.NET Data Services
• Dynamic Data

• http://blogs.msdn.com/webdevtools/archive/2008/08/11/web-development-updates-in-visual-studio-2008-sp1.aspx
• http://oakleafblog.blogspot.com/2008/08/joys-of-installing-visual-studio-2008.html
• http://weblogs.asp.net/guybarrette/archive/2008/08/07/sql-server-2008-requires-vs-20008-sp1.aspx
• http://blogs.msdn.com/scothu/archive/2008/08/11/dynamic-data-rtm-is-released.aspx
• http://blogs.microsoft.co.il/blogs/bursteg/archive/2008/08/11/Download-VS2008-SP1-Net-Framework-35-SP1.aspx