Office System Israeli Bloggers

Presenting at SharePoint User Group Tomorrow

Sun, 27 May 2012 07:10:15 +0000

תזכורת: מחר (28/05/2012) בשעה 17:30 יתקיים מפגש של SharePoint User Group. אני אעביר הרצאה על Claims Based Authentication in SharePoint 2010.
המפגש אינו כרוך בתשלום, אך מצריך הרשמה מראש בקישור:
http://spug-28-may-eorg.eventbrite.com

הערה: למי שהיה בהרצאה שלי בכנס SharePoint Extreme האחרון, מדובר על אותה הרצאה.

BDC -> BCS?

Tue, 15 May 2012 12:40:17 +0000

MOSS 2007 had a feature called Business Data Catalog. When SharePoint 2010 came out, this feature was introduced as Business Connectivity Services.

The common belief is that BCS is the new version of BDC, and that in the new version the name was changed from BDC to BCS. According to this, there is no reason to use the term BDC in the context of SharePoint 2010.
This is not exactly correct.
BDC was and still the infrastructure that allows SharePoint to connect to other systems. It has the concept of metadata and descriptors, and is still present in 2010 under the name “Business Data Connectivity”. BCS is based on BDC and is what makes all the advanced connectivity scenarios possible (such as integration with Office, ECT,…).

In the bottom-line, the terms BDC and BCS is used interchangeably, so you should too. But you don’t have to be angry if you see BDC in the same sentence with SharePoint 2010 :)

Here are some supporting quotes from MSDN:

“Business Data Connectivity (BDC) service is the new version of the Business Data Catalog that was provided in Microsoft Office SharePoint Server 2007”
http://msdn.microsoft.com/en-us/library/ee556407.aspx

“Business Data Connectivity (BDC) service succeeds the Business Data Catalog that was provided in Microsoft Office SharePoint Server 2007”
http://msdn.microsoft.com/en-us/library/ee558876.aspx

“BDC is the foundation of Business Connectivity Services”
http://msdn.microsoft.com/en-us/library/ee559650.aspx

“Business Data Connectivity (BDC) service in Microsoft Business Connectivity Services (BCS) is the underlying framework in the Microsoft SharePoint Foundation 2010 platform on which Business Connectivity Services is built”
http://msdn.microsoft.com/en-us/library/ee557963.aspx

Xml Serialize Interface Typed Members

Mon, 30 Apr 2012 07:48:30 +0000

If you try to serialize a class that has a public member of an interface type to xml file using the regular .net XmlSerializer, you will get an error: “Cannot serialize member {m} of type {t} because it is an interface.” ({m} and {t} are placeholders).
In this post I suggest a workaround to this issue.

Consider the following scenario:

You have an object model like this:

   1: public class Car

   2: {

   3:     public string Model { get; set; }

   4:     public int Year { get; set; }

   5:     public IEngine Engine { get; set; }

   6: }

7:

   8: public interface IEngine

   9: {

  10:     void Work();

  11: }

12:

  13: public class ElectricEngine : IEngine

  14: {

  15:     int batteryPrecentageLeft;

  16:     public int BatteryPrecentageLeft

  17:     {

  18:         get { return this.batteryPrecentageLeft; }

  19:         set { this.batteryPrecentageLeft = value; }

  20:     }

21:

  22:     void IEngine.Work() { }

  23: }

24:

  25: public class InternalCombustionEngine : IEngine

  26: {

  27:     int gasLitersLeft;

  28:     public int GasLitersLeft

  29:     {

  30:         get { return this.gasLitersLeft; }

  31:         set { this.gasLitersLeft = value; }

  32:     }

33:

  34:     void IEngine.Work() { }

  35: }

And you use it like so:

   1: Car myCar = new Car();

   2: myCar.Model = "Ford Focus";

   3: myCar.Year = 2011;

   4: myCar.Engine = new ElectricEngine() { BatteryPrecentageLeft = 70 };

5:

   6: myCar.Engine.Work();

If you would try to serialize myCar using the regular XmlSerializer, you will get the error above.

There are many reasons why you shouldn’t want to serialize an interface typed member. I will not dive into this debate right now. I assume that you have considered this before, and are just looking for a workaround.

So first lets understand what we are trying to achieve.
In the example above, I expect the serialized output of myCar to be something like this:

   1: <Car xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">

   2:   <Model>Ford Focus</Model>

   3:   <Year>2011</Year>

   4:   <Engine>

   5:     <ElectricEngine FullAssemblyQualifiedTypeName="Common.ElectricEngine, Common, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null">

   6:       <BatteryPrecentageLeft>70</BatteryPrecentageLeft>

   7:     </ElectricEngine>

   8:   </Engine>

   9: </Car>

I have asked a question on StackOverflow, and Jens Granlund has pointed me in the right direction.
The workaround that I have implemented consists of the following steps:

Mark all interface typed members with the XmlIgnoreAttribute, that tells the XmlSerializer to not serialize those members.
Now serialize the class to produce an output similar to the one above, but without the problematic members.
For-each member marked with the attribute, get it’s current value, and that value’s type. That can only be done in runtime.
Use that type to create a standard XmlSerializer, and use that serializer to serialize that value.
Inject those serialized values to the parent class’s serialized xml.
In order to allow regular use of the XmlIgnoreAttribute, implement a new attribute that act like it.
During deserialization perform the same process in reverse.

I have followed that basic recipe to create my own “RuntimeXmlSerializer”. You use it the same way you would use the standard XmlSerializer.

   1: public class RuntimeXmlSerializerAttribute : XmlIgnoreAttribute { }

2:

   3: public class RuntimeXmlSerializer

   4: {

   5:     private Type m_type;

   6:     private XmlSerializer m_regularXmlSerializer;

7:

   8:     private const string k_FullClassNameAttributeName = "FullAssemblyQualifiedTypeName";

9:

  10:     public RuntimeXmlSerializer(Type i_subjectType)

  11:     {

  12:         this.m_type = i_subjectType;

  13:         this.m_regularXmlSerializer = new XmlSerializer(this.m_type);

  14:     }

15:

  16:     public void Serialize(object i_objectToSerialize, Stream i_streamToSerializeTo)

  17:     {

  18:         StringWriter sw = new StringWriter();

  19:         this.m_regularXmlSerializer.Serialize(sw, i_objectToSerialize);

  20:         XDocument objectXml = XDocument.Parse(sw.ToString());

  21:         sw.Dispose();

  22:         SerializeExtra(i_objectToSerialize,objectXml);

  23:         string res = objectXml.ToString();

  24:         byte[] bytesToWrite = Encoding.UTF8.GetBytes(res);

  25:         i_streamToSerializeTo.Write(bytesToWrite, 0, bytesToWrite.Length);

  26:     }

27:

  28:     public object Deserialize(Stream i_streamToSerializeFrom)

  29:     {

  30:         string xmlContents = new StreamReader(i_streamToSerializeFrom).ReadToEnd();

  31:         StringReader sr;

  32:         sr = new StringReader(xmlContents);

  33:         object res = this.m_regularXmlSerializer.Deserialize(sr);

  34:         sr.Dispose();

  35:         sr = new StringReader(xmlContents);

  36:         XDocument doc = XDocument.Load(sr);

  37:         sr.Dispose();

  38:         deserializeExtra(res, doc);

  39:         return res;

  40:     }

41:

  42:     private void deserializeExtra(object i_desirializedObject, XDocument i_xmlToDeserializeFrom)

  43:     {

  44:         IEnumerable propertiesToDeserialize = i_desirializedObject.GetType()

  45:             .GetProperties().Where(p => p.GetCustomAttributes(true)

  46:                 .FirstOrDefault(a => a.GetType() ==

  47:                     typeof(RuntimeXmlSerializerAttribute)) != null);

  48:         foreach (PropertyInfo prop in propertiesToDeserialize)

  49:         {

  50:             XElement propertyXml = i_xmlToDeserializeFrom.Descendants().FirstOrDefault(e =>

  51:                 e.Name == prop.Name);

  52:             if (propertyXml == null) continue;

  53:             XElement propertyValueXml = propertyXml.Descendants().FirstOrDefault();

  54:             Type type = Type.GetType(propertyValueXml.Attribute(k_FullClassNameAttributeName).Value.ToString());

  55:             XmlSerializer srl = new XmlSerializer(type);

  56:             object deserializedObject = srl.Deserialize(propertyValueXml.CreateReader());

  57:             prop.SetValue(i_desirializedObject, deserializedObject, null);

  58:         }

  59:     }

60:

  61:     private void SerializeExtra(object objectToSerialize, XDocument xmlToSerializeTo)

  62:     {

  63:         IEnumerable propertiesToSerialize =

  64:             objectToSerialize.GetType().GetProperties().Where(p =>

  65:                 p.GetCustomAttributes(true).FirstOrDefault(a =>

  66:                     a.GetType() == typeof(RuntimeXmlSerializerAttribute)) != null);

  67:         foreach (PropertyInfo prop in propertiesToSerialize)

  68:         {

  69:             XElement serializedProperty = new XElement(prop.Name);

  70:             serializedProperty.AddFirst(serializeObjectAtRuntime(prop.GetValue(objectToSerialize, null)));

  71:             xmlToSerializeTo.Descendants().First().Add(serializedProperty); //TODO

  72:         }

  73:     }

74:

  75:     private XElement serializeObjectAtRuntime(object i_objectToSerialize)

  76:     {

  77:         Type t = i_objectToSerialize.GetType();

  78:         XmlSerializer srl = new XmlSerializer(t);

  79:         StringWriter sw = new StringWriter();

  80:         srl.Serialize(sw, i_objectToSerialize);

  81:         XElement res = XElement.Parse(sw.ToString());

  82:         sw.Dispose();

  83:         XAttribute fullClassNameAttribute = new XAttribute(k_FullClassNameAttributeName, t.AssemblyQualifiedName);

  84:         res.Add(fullClassNameAttribute);

85:

  86:         return res;

  87:     }

  88: }

Notice that this solution doesn’t handle situations in which the interface typed member is not a direct descendent of the type being serialized. In example if Car has a member of type List<IWheel> or if Car has a member of type Dashboard which has a member f type IGauge, than serialization will fail.
This can be solved by recursively performing the “Runtime” serialization on all members, until we reach a primitive member which we can serialize using the regular serializer.

You can find the Visual Studio project in this link:
http://blogs.microsoft.co.il/files/folders/1078707/download.aspx

Enterprise Wiki site template vs. Wiki Library template

Sun, 15 Apr 2012 17:00:52 +0000

We all know wikis and how they work. It's a quick way to create inter-connected items of unstructured data.
SharePoint 2010 Introduces two wiki solutions that appear similar on first sight, but are actually different. In this post I will cover technical differences between the two.

First is the "Enterprise Wiki" site template. It's a template that can be used to create site collections, or sub-sites. The Enterprise Wiki site template creates a site that is dedicated to wiki content. The main component in the site is the "Pages" Library. We will explorer it later.

Second is the "Wiki Page Library" list template. This Wiki Library can host wiki pages. It can be created in any kind of site.
As a matter of fact, this Wiki Library list template is used as the default pages library in the "Team Site" site template.

According to this article on MSDN, here is a short comparison between the two:

If you want to:	Use this site template:
Encourage one-to-many communication	Team Site
Encourage many-to-many communication	Enterprise Wiki
Offer a structured exchange of information	Team Site
Enable a collaborative exchange of information	Enterprise Wiki
Insert images or files in a pages	Team Site or Enterprise Wiki
Mark pages for easier reference by tagging them with enterprise keywords	Enterprise Wiki

These are nice guidelines, but what is the real difference of each?
I am now going to go through the detailed process that I took for investigating the case. You can skip to the end if you want the summary.

Wiki Page Library

The template is part of the feature called "WebPageLibrary". In this feature, you can find the list definition at: "14\TEMPLATES\FEATURES\WebPageLibrary\ListTemlpates\WebPageLibrary.xml".
If you look at it, you'll notice that the list template id is 119, and BaseType="1", which means it is a regular document library.

If we take a look at the schema.xml file at "14\TEMPLATES\FEATURES\WebPageLibrary\WebPageLib\schema.xml", we will see that the template associates a content type with ID 0x010108 to the library. This content type is called "WikiDocument", and is defined in: "14\TEMPLATES\FEATURES\ctypes\ctypeswss.xml". It inherits from the base "Document" content type, does 2 things: Add the "WikiField", and remove the "Title" field.
The "WikiField" field is what holds the content of the page.

Enterpries Wiki

This is an entierly different beast. First of all, it's a site definition. You will find the "Enterprise Wiki" site definition at 14\TEMPLATE\1033\XML\webtempsps.xml. Let's take a closer look at it.
The site definition onet.xml file is at: 14\TEMPLATE\SiteTemplates\ENTERWIKI\XML\onet.xml. In here, we can see that this is actually a publishing site (publishing features, such as "Publishing 22A9EF51-737B-4ff2-9346-694633FE4416" are activated).

In addition to the standatd pablishing features, there's an additional feature with id "76D688AD-C16E-4cec-9B71-7B7F0D79B9CD". This is the EnterpriseWiki feature, you can find it's source at: 14\TEMPALTE\FEATURES\EnterpriseWiki.

If you take a look at EnterpriseWikiContentTypeBinding.xml, you will see that the feature takes the default pages library that is created with the publishing infrastructure, and binds to it 2 content types. One is the standard Redirect Page content type, and the other is the Enterprise Wiki content type.
The Enterprise Wiki content type is defined at: 14\TEMPALTE\FEATURES\EnterpriseWikiContentTypes, and defines the following fields: ModifiedBy, PublishingPageContent, Rating, RatingCount.

If we take a look at the page layout at: 14\TEMPALTE\FEATURES\EnterpriseWikiLayouts\PageLayouts\EnterpriseWiki.aspx, we will see that the field that holds the content of the page is "PublishingPageContent". This field is just like the "WikiField" field that we discussed earlier.

Rendering

Handling wiki style markup is integrated into SharePoint foundation. From what I have found, it seems that the translation from wiki syntax to html is done in the field level (not UI control). The class "SPFieldMultilineText" has a property called "WikiLinking" (boolean), that toggles the feature on or off.
For publishing pages, the "HtmlField" inherits indirectly from SPFieldMultilineText, so it supports this too.

You can use this feature with regular publishing pages as well (not nessicarely wiki page layouts).
If you look at the source of a publishing page you will see a line similar to this: document.getElementById('ctl00_PlaceHolderMain_PageContent_RichHtmlField_displayContent').WikiLinking = 'on';
This controls whether or not the wiki syntax translation is active.

Summary

SharePoint has different 2 solutions for wiki style editing:

1. Wiki Library - a web pages library that uses the "Wiki Document" content type. This content type has a field called "WikiField" to hold the wiki content.

2. Enterprise Wiki - a site definition that is based on the publishing infrustructure. As such, it is based on the built in "Pages" library. It uses a content type called "Enterprise Wiki", in which the field "PublishingPageContent" is used to hold wiki content.

This knowledge can be helpful if you are developing solutions that are usign the wiki features programmatically.

-- My name is Itay Shakury, and I'm a SharePoint consultant --

ArcGIS–Getting the Legend Labels out

Tue, 27 Mar 2012 08:18:19 +0000

Working with ESRI’s ArcGIS package, especially the WPF API, can be confusing. There’s the REST API, the SOAP APIs, and the WPF classes themselves, which expose some web service calls and information, but not everything. With all that, it can be hard to find specific features between the different options. Some functionality is handed to you on a silver platter, while some is maddeningly hard to implement.

Today, for instance, I was working on adding a Legend control to my map-based WPF application, to explain the different symbols that can appear on the map.

This is how the legend looks on ESRI’s own map-editing tools:

but this is how it looks when I used the Legend control, supplied out of the box by ESRI:

Very pretty, but unfortunately missing the option to display the name of the fields that make up the symbology.

Luckily, the WPF controls have a lot of templating/extensibility points, to allow you to specify the layout of each field:

   1: <esri:Legend>

   2:     <esri:Legend.MapLayerTemplate>

   3:         <DataTemplate>

   4:              <TextBlock Text="{Binding Layer.ID}"/>

   5:         </DataTemplate>

   6:     </esri:Legend.MapLayerTemplate>

   7: </esri:Legend>

but that only replicates the same built in behavior. I could now add any additional fields I liked, but unfortunately, I couldn’t find them as part of the Layer, GraphicsLayer or FeatureLayer definitions. This is the part where ESRI’s lack of organization is noticeable, since I can see this data easily when accessing the ArcGis Server’s web-interface, but I had no idea how to find it as part of the built-in class. Is it a part of Layer? Of LayerInfo? Of the LayerDefinition class that exists only in the SOAP service?

As it turns out, neither. Since these fields are used by the symbol renderer to determine which symbol to draw, they’re actually a part of the layer’s Renderer. Since I already had a MyFeatureLayer class derived from FeatureLayer that added extra functionality, I could just add this property to it:

   1: public string LegendFields

   2: {

   3:     get

   4:     {

   5:         if (this.Renderer is UniqueValueRenderer)

   6:         {

   7:             return (this.Renderer as UniqueValueRenderer).Field;

   8:         }

   9:         else if (this.Renderer is UniqueValueMultipleFieldsRenderer)

  10:         {

  11:             var renderer = this.Renderer as UniqueValueMultipleFieldsRenderer;

  12:             return string.Join(renderer.FieldDelimiter, renderer.Fields);

  13:         }

  14:         else return null;

  15: }

For my scenario, all of my layers used symbology derived from a single field or, as in the examples above, from several of them. The renderer even kindly supplied me with the comma to separate the fields with. Now it was a simple matter to get the Legend control in line – assuming that it was bound to a collection of MyFeatureLayer:

   1: <esri:Legend>

   2:     <esri:Legend.MapLayerTemplate>

   3:         <DataTemplate>

   4:             <StackPanel>

   5:                 <TextBlock Text="{Binding Layer.ID}"/>

   6:                 <TextBlock Text="{Binding Layer.LegendFields}" Margin="10,0,0,0" TextStyle="Italic"/>

   7:             </StackPanel>

   8:         </DataTemplate>

   9:     </esri:Legend.MapLayerTemplate>

  10: </esri:Legend>

and get the look I wanted – the list of fields below the layer name, indented.

SharePoint 15 “Apps” (as documented in the CTP SDK)

Mon, 26 Mar 2012 21:25:22 +0000

A while ago, Microsoft has released a CTP (Community Tech Preview) version for the SDK (Software Development Kit) of the next version of SharePoint (aka SharePoint 15).
Browsing through it I have learned about the new concept of Apps in SharePoint 15 (codename). In this post I will share my findings and conclusions.

I start by noticing the SPApp object, that lies in the Microsoft.SharePoint.Administration namespace. It “Represents an app loaded onto Microsoft SharePoint Server and ready to be installed.”
Right next to the SPApp Object, we see the SPAppCatlog class which “Represents all of the SPAppInstance objects installed on an instance of Microsoft SharePoint Server. It provides querying capabilities for discovering installations.”. Naturally, if we are going to have apps, we need some sort of an App Store to obtain apps from.

If we drill down a level into the SPAppCatalog, we will see that it has a GetAppInstance method, that “Gets all the SPAppInstance objects installed at a given SPWeb.”. Also, the SPAppInstance class says it “Represents an SPApp object installed to a specific SPWeb site.”. So apps are scoped to the SPWeb level – cool.

Continuing to the SPWebApplication class, we find that is has a new method called IsUserLicensedForEntity, that “Checks if the currently logged in user has the proper license to access the specified entity.” If we going to have an App Store like system, we need to have a mechanism to enforce licensing.

What more do we know about apps from real world? They need your permissions to access your data. This is usually done (in real world) with the OAuth protocol, and SharePoint 15 apparently supports this too! There’s a new namespace called Microsoft.SharePoint.IdentityModel.OAuth2 that will probably contain the basis for this, and some classes in Microsoft.SharePoint like SPApplicationCredentials and SPAppPrincipalPermissionsManager that will probably allow programmatic handling of permissions.

There’s another new namespace called Microsoft.SharePoint.Administration.AppDeployment that contains two classes – DatabaseProviderConstants, and DatabaseProviderTypePersistedObject. So there’s apparently something with a database for an app. The SPWeb class also has new properties regarding App DBs – for example the AppDataBaseName property that “Gets the name of the app database associated with this Web.”. Frankly, this is still a mystery for me since it’s use is not documented in the CTP SDK, and not very self explanatory.

In conclusion:

SharePoint has a new concept of Apps
Apps are scoped to SPWeb
Apps are distributed via the AppCatalog
There’s built in support for licensing apps
Apps can ask for permission using OAuth
There’s something with app databases yet to be clarified

This is a very interesting direction that the SharePoint team is taking, and probably revolutionary in the SharePoint world. I hope we can here more details soon.

-- My name is Itay Shakury, and I’m a SharePoint Consultant --

Storing Configuration Settings For Timer Jobs

Fri, 23 Mar 2012 13:58:07 +0000

When you develop a custom timer job, there is often a need to store configuration settings.
The best way to do this is using the Hierarchical Object Store in SharePoint, by creating an SPPerststedObject. There are plenty of articles out there that tell you to how to do this.
For more info on this subject, see this:
http://msdn.microsoft.com/en-us/library/cc406686(office.12).aspx
http://msdn.microsoft.com/en-us/library/hh528519.aspx

So it’s called "hierarchical” object store, because you have to attach the settings to a certain object in the SharePoint object model, and that object must support this by inheriting from SPPersistedObject. Most of those articles shows you how to attach settings to SPFarm, SPWebApplication, or SPSiteCollection objects, but as a matter of fact, the SPJobDefinition class is also a SPPersistedObject!

This means that you can attach settings to the job object directly, and not leave them hanging at the farm or a higher level. This has two benefits:

It’s more organized to keep timer job related settings at the timer job level (and not web application level for example)
When you delete the timer job, the settings are deleted as well

Here’s a sample:

   1: SPWebApplication wa = SPWebApplication.Lookup(new Uri("http://MySP"));

   2: SPJobDefinition job = wa.JobDefinitions.First(j => j.Name == "MyTimerJob");

3:

   4: //Store the settings

   5: MyJobSettings settings = new MyJobSettings("settings", job); //here we set job as the parent

   6: settings.settings1 = "Sample Data";

   7: settings.Update();

And the reading:

   1: //Read the settings

   2: MyJobSettings res = job.GetChild<MyJobSettings>("settings");

   3: string setting1 = res.setting1;

-- My name is Itay Shakury, and I’m a SharePoint consultant --

Follow Up on My SharePoint Extreme Session on Claims Based Authentication

Thu, 22 Mar 2012 12:56:58 +0000

בכנס SharePoint Extreme האחרון העברתי מצגת על Claims Based Authentication עם SharePoint 2010.
מכיוון שזהו נושא חדש יחסית, המצגת התמקדה בעיקר בהיכרות עם מה זה בכלל Claims Based Authenticatoin, ואיך זה עובד.
לאחר המצגת קיבלתי שאלות בנוגע לתהליך הטכני. פוסט זה בא להבהיר את התהליך.

התהליך שהצגתי הוא כזה:

משתמש ניגש לשרת SP
המשתמש מופנה ל STS
STS מאמת את המשתמש
STS מחזיר למשתמש Token
המשתמש ניגש אל ה SP, הפעם עם ה Token
SP מאשר את ה Token ומאפשר גישה

השאלה העיקרית הייתה בנוגע לשימוש ב Cookies, ואיך כל זה עובד עם מגבלות כמו Cross-Domain.

הדרך שבה זה עובד בצורה טכנית היא כזו (מספרי השורות תואמים לשלבים שתוארו מקודם):

משתמש מבצע HTTP GET ל SP
SP מחזיר 302 Redirect. בסופו של דבר המשתמש מופנה אל הכתובת של ה STS (בד”כ סדרה של הפניות)
הדפדפן ניגש אל ה STS, המשתמש מאומת באמצעות דף ה Login
ה STS מחזיר למשתמש דף שמכיל את ה Token (בגוף הדף, בד”כ כ hidden field),
באותו דף ישנו קוד Javascript שגורם לדפדפן לעשות HTTP POST אל ה SP, עם ה Token.
SP מקבל את הבקשה ויודע לנתח אותה בהתאם

אם כן, השאלה הבאה היא איך Cookies נכנסים לתמונה?

ה STS, או ה SP יכולים להשתמש ב cookies (או באיזו טכנולוגיה שהם רוצים) כדי לשמר session עם המשתמש.
כלומר, כדי שתהליך ההזדהות לא יקרה בכל פעם, ה SP מנפיק למשתמש cookie שמשאיר אותו מזוהה במהלך השימוש שלו באתר (ע”ע FedAuth).
באותה מידה ה STS יכול להנפיק למשתמש cookie כדי לזהות בצורה אוטומאטית את המשתמש אם הגיעה בקשה נוספת להזדהות.

I’m Speaking at SharePoint Extreme 2012

Mon, 12 Mar 2012 17:30:20 +0000

ביום שלישי הקרוב עד יום חמישי, 13-15/3/2012, יתקיים כנס SharePoint Extreme – כנס מקצועי לחלוטין עם הרצאות ממוקדות לקהלי יעד שונים בנושאי SharePoint.
אני ארצה ביום חמישי במסלול Real World SharePoint Architecture הרצאה על Claims Based Authentication ב SharePoint 2010.
בהרצאה אציג את העולם של Claims Based Authenticatoin, את היתרונות והמניעים לטכנולוגיה, את השילוב עם SharePoint, ותרחישים לדוגמא שמתבססים עליה.

(ההרשמה לכנס כרוכה בתשלום)

לפרטים נוספים והרשמה:
http://www.microsoft.com/israel/sharepointExtreme/content/Lectures/13036.aspx

Datasheet view alternatives

noreply@blogger.com (Shai Petel) — Wed, 07 Mar 2012 16:51:00 +0000

Ok, this is really long overdue…

Ever since Microsoft introduced the datasheet view for editing lists in SharePoint I’ve had mixed emotions about it.

Although datasheet is a great editing tool for SharePoint lists that allows you to quickly edit and update multiple items in an excel-like experience – it has been a challenge getting it to work.

One customer of mine used a proxy server internally to direct traffic into his SharePoint, which made the datasheet view unavailable.

Another customer had deployed office 2010 64 bit on his users computers. Apparently datasheet view does not support office 2010 64bit: http://support.microsoft.com/kb/2266203

Some other customers complaining that they cannot use FireFox or Chrome with datasheet view, or any OS that does not have office installed.

And finally, datasheet view does not support custom field types – they appear as read only. Actually, even standard OOB fields use a different editing control inside the datasheet view, causing an inconsistent editing experience to the user.

This have been bothering me for a long while, and finally with the help of my friend Igor Goldshtaub we came up with an idea that will allow you to:

Edit multiple list items (bulk edit)
Enjoy fast inline editing in list views on all major browsers
Inline edit custom field types as well as OOB field types
Have a consistent user experience, using the same editing controls as used in the actual “edit” item form
Paste information from excel into a list

The best part is, it potentially supports any 3rd party custom field type, from any other vendor or even ones you develop yourself. Most field types just work, others may need to call a JavaScript method when the content is resized (picker is opened, for example) “OnClientResponseEnded();”

Inline editing demo:

Paste from excel demo:

I’d love to hear what you think about this solution, and if you run into trouble using a custom field type – please let me know! My goal is to be able to support all custom field types in this inline editing platform!

Finally, we have an answer for editing custom field types in datasheet view. It’s not datasheet, but it comes close!

Cheers, Shai.

The Case of the Unexpected Expected Exception

Thu, 01 Mar 2012 19:20:00 +0000

“NUnit is being problematic again”, they told me when I came to visit the project. “When running unattended it’s not catching assertions properly and the test is coming up green, but when stepping through in the debugger, it works fine.”. It’s nice, when getting a passing test is acknowledged as a bad thing, at least when you don’t expect it to be. In this case, though, the fault wasn’t really with NUnit.

  1: [Test]
  2: [ExpectedException]
  3: public void DoTheTest()
  4: {
  5:     _myComponent.RunMethod();
  6:     Assert.IsFalse(_myComponent.EverythingIsFine);
  7: }

“It’s simple. Either the method throws an exception, or at the very least – the EverythingIsFine property won’t be set to “True”, so the assert will catch the problem. But in their case, no exception was thrown and Everything wasn’t Fine, but the Assert call wasn’t raising a red flag – unless they stepped through, in which case it did. What’s going on?

The basic problem is that to many developers, NUnit is a kind of magic. You write a self-contained little bit of code, the [Test] method, but you don’t call it yourself, you don’t get a feel for the whole execution flow. The result – developers don’t exercise the same sort of judgement they do on their own application code.

The root of the problem here is that the [ExpectedException] attribute told NUnit to pass the test if an exception is thrown. NUnit’s Assertion utilities, however, use exceptions as the mechanism for failing tests – when an assertion is hit, it raises an exception – it can be an AssertionException. For various mock frameworks, it can be an ExpectationException. It doesn’t matter – it’s these exceptions that make the test fail, and not some behind-the-scenes magic. Because the test had an open-ended [ExpectedException] attribute, these exceptions were caught, fulfilling the condition, and NUnit was happy.

What can we do to avoid this?

Be explicit. Don’t try to catch ALL exceptions with [ExpectedException]. If you’re expecting an exception, you’re probably expecting a specific exception. Specify it.
Be aware of how your tools work. If NUnit works by throwing an exception, don’t wrap it with a try/catch. Your tests are C# code too, as is the plumbing to enable it. It plays by the same rules.

Open Source Vigilantes?

Sun, 26 Feb 2012 10:37:20 +0000

Cache explained - the milk story

noreply@blogger.com (Shai Petel) — Tue, 14 Feb 2012 16:48:00 +0000

Introduction

I came up with this little story when trying to explain what is caching, how to plan for caching and how to use it. Like many things in software, caching is something we use very widely in our day to day life without even knowing about it. Hopefully this example will give you a different, easier to understand point of view on caching that will help you get your head around it.

The milk story

No cache

Caching is like drinking milk.

When you want to drink milk you have to go to the store and buy it.

You can walk (56k modem) ride your bike (3G) or drive there in your corvette (high speed Internet).

You have to identify yourself, find and get the milk you want, check its expiration and pay for it. Since there are many things at the store it takes more time to find your milk.

Then you have to fight traffic back home. Pour the milk into a glass and drink it.

Caching options

Now, how do we make it better?

We notice that the store keeps the same milk for 10 days.

So, we can buy 10 days worth of milk ahead. We calculate our milk usage to be 0.5 liter a day, do we need 5 liters.

Wow - this is when we discover bulk discounts!

But - then we discover we need to store it all in the fridge. This type of storage is very expensive since it has many uses and is limited.

So we compromise and fetch only 2 liters at a time, knowing we will be back at the store once every 4 days.

Now, we notice we go to the store to get cookies with our milk. So when we go in for milk we use that same opportunity to get cookies as well.

Now every time we want milk we need to check our fridge first. If there is milk we can use it and we saved a lot of time and resources!

But, if there is no milk we have to go and get it. In the case we added some overhead by checking the fridge first...

Now, milk is known to go bad from time to time. So we have to check its expiration. If the milk gone bad we have to throw it.

That's another overhead every time we want milk.

Conclusion

Milk is your data.

The store is your data base.

Your fridge is your quick accessible cache storage.

Throwing out bad milk is flushing the cache when invalidated.

Cache is life ( ok, I went too far… ).

We use caching techniques every day!

Microsoft Canada - Imagine Cup

noreply@blogger.com (Shai Petel) — Tue, 14 Feb 2012 15:12:00 +0000

Are you ready to change the world?

All it takes is one good idea. Imagine Cup, one of the premiere worldwide technology competitions, is looking for students, to help solve some of the world’s toughest problems through technology.

This year, Microsoft will be hosting a Canadian Imagine Cup competition with two categories: Software Design and Windows Phone 7 Game Design. You could win a trip to Toronto for the Canadian Finals, a trip to Australia for the Worldwide Finals, international acclaim and cash grants. What are you waiting for? Get involved »

TSQL: Concatenate Column from Multiple Rows into String

Tue, 24 Jan 2012 08:48:58 +0000

Ok , So I had a problem related to concatenation of a single Column into one ( same ) column when using GROUP BY .
The Problem came from a Reporting Services perspective and there might be other solutions ( like coding in VB.NET in the report )

I have found a very nice samples :

Option 1:

use Northwind

declare @CategoryList varchar(1000)
set @CategoryList =''
select @CategoryList = @CategoryList + ' , ' + CategoryName from Categories

select 'Results = ' + @CategoryList

Option 2:

use Northwind

declare @CategoryList varchar(1000)
select @CategoryList = coalesce(@CategoryList + ', ', '') + CategoryName from Categories

select 'Results = ' + @CategoryList

In the end I used option 2 as part of a UserDefiendFunction .

The manipulation was that the of the “GROUP BY” was sent to the UDF to use in it’s select “where” , so it could return the filtered row concatenated. And that UDF was called as part of the grand SELECT.

NOTE: this is a developer solution , a DBA might have a better solution ;)

SharePoint 2010 : The following computer running SharePoint does not contain the required Infopath form template

Mon, 23 Jan 2012 11:43:13 +0000

What can I say … except "elementary my dear Watson" ;)

Ok , the problem is that you didn’t activate a feature in the site you’re working with :P

go to : Site Actions > Site Settings > Manage Site Features > Team Collaboration Lists.

The problem :

The solution:

( Personal Note: I know it has been a while , but once in a while doesn’t hurt ;) )

Speaking Engagements 2012

noreply@blogger.com (Shai Petel) — Wed, 04 Jan 2012 23:04:00 +0000

My 2012 speaking engagements are posted below,
If you are around – come see me!
If you were in one of my sessions, you can find links to the session code and presentation below. Also – if you have any comments on my session – feel free to post it here!

January 7 2012 – SPS Virginia Beach – Session unknown… – Cancelled due to other obligations. Sorry I couldn’t make it!

January 18 2012 – Toronto SharePoint User Group - Developer’s guide: how to enhance your SP performance: Understanding caching

May 16 2012 – Toronto SharePoint Summit- Developer’s guide: how to enhance your SP performance: Understanding caching

My 2011 speaking engagements can be found here.

SharePoint Popup Scroll gone after autoSize

noreply@blogger.com (Shai Petel) — Tue, 29 Nov 2011 20:27:00 +0000

I’m writing this post after not finding anything about this problem in Google.

The issue

When you have a SharePoint 2010 popup dialog, that uses autoSize (like the new item / edit item forms in any SharePoint list), if you call “window.frameElement.autoSize()” second time, there is no scroll in the popup.

Say you have a field control or a web part that changes in height when the user interacts with it. In my case, I was working on a “repeating rows” field type, where the user can add as many rows to the field as he wants – much like in InfoPath.

When the user add new rows, the height of my popup changes, so I have to resize it.

Documentation is pretty clear, call window.frameElement.autoSize() and it should resize your dialog.

Apparently, this works well for the first time you call it, but for some reason if I call it second/third/ninth time – once the popup is too high the vertical scroll is gone.

Another issue is, that even when it does fit to the page – the top of the popup does not move up so you end up having to move the popup to the top of the page yourself.

This caused great frustration for some of our customers, and by extent – our product manager and support – and by extent – me!

The solution

I knew I was alone in this, since not only Google did not have any solution for this issue – I could not even find someone asking about it in any forums / mailing list.

So, since waiting for a Microsoft fix for this, which may or may not come eventually (after all this issue is introduced with custom development and not on OOB scenarios), I had to dig deep and get dirty with Microsoft JavaScript and popup DOM.

It wasn’t pretty, I tell you, but I did find lots of cool stuff, like a function that calculates the width of the scroll bars in the browser :) (yeah, they actually have a function for it!)

Well, it appears that the popup have few divs and iframe behind it to make it look and work so cool (great job on that Microsoft!), I figured the problem was that the height was not calculating correctly on the second call to autoSize. It disregards the maximum size of the parent window, and does not reposition the window vertically.

I had to do it myself.

I came up with this code, now – it is not fail proof, and might not work on some scenarios – but it did work for me, our QA and our customers. I will appreciate if you have any comments or fixes to this code, or if you know of another more “clean” solution to this issue.

//call autoSize
window.frameElement.autoSize();
//Fix scroll bar and positioning. $kw is our alias for jQuery
var bodyHeight = $kw(top.document.body).height();
var dialogMaxHeight = bodyHeight - 60;
//if dialog is too high
if ($kw(window.frameElement).height() > dialogMaxHeight) {
    //move dialog to top
    top.document.getElementsByClassName('ms-dlgContent')[0].style.top = '8px';
    top.document.getElementsByClassName('ms-dlgContent')[0].previousSibling.style.top = '8px';
    //resize all dialog divs/frames/whatnot
    window.frameElement.style.height = dialogMaxHeight + 'px';
    top.document.getElementsByClassName('ms-dlgContent')[0].previousSibling.style.height = dialogMaxHeight + 'px';
    top.document.getElementsByClassName('ms-dlgContent')[0].style.height = dialogMaxHeight + 32 + 'px';
    top.document.getElementsByClassName('ms-dlgBorder')[0].style.height = dialogMaxHeight + 32 + 'px';
}
//end issue fix

Thanks, Shai.

Redirect to custom error page from event handler

noreply@blogger.com (Shai Petel) — Thu, 24 Nov 2011 15:52:00 +0000

I’ve seen a lot of posts saying you can’t redirect to a custom error page from a SPItemEventReceiver in SharePoint 2007.

In 2010, you can use Properties.RedirectUrl which will send you to a custom error page, instead of the OOB error page that displays your properties.ErrorMessage. this is simple enough, all you have to do is set properties.Cancel = true – and the custom redirect Url kicks in.

But still, in 2007 this property does not exist, and in 2010 – you might want to have a custom redirect page and not cancel the event.

Good news – it is all possible!

Redirecting

The way to do it, is to add some code to a sync event. Async events can’t help you since they are not guaranteed to run immediately, and they don’t have any user context when they execute…

You can use the SPUtility.Redirect(PageUrl, SPRedirectFlags, HTTPContext); within your ItemAdding, ItemUpdating or ItemDeleting event handler to redirect your user to a custom page.

This redirection kicks in and throws the “ThreadAbortException”, stopping the rest of your code from running and redirecting the user to your custom page.

Few things to know:

1. ThreadAbortException is a “catch me if you can” exception. you can put it in try…catch… block, but this exception will always bubble up and be thrown again and again. essentially, only the catch and finally code blocks will run after this exception is thrown. you can set “SPRedirectFlags.DoNotEndResponse” if you don’t want this exception to be thrown and it should still redirect at the end, but using SPRedirectFlags.Default will throw it.

2. You may notice, that if you try using HTTPContext.Current in your event handler method – you will get a null context. So, the only way to get the HTTPContext.Current is in your event handler class constructor. save it as a member, and use it in your event handlers. DONT SAVE IT AS A STATIC MEMBER! Use any instance member (private/public/protected…) but don’t use a static member as you may run into unexpected trouble.

Cancelling the event

Now, we took care of redirecting, but it is good to remember that this on its own will not cancel the item event and it will still be updated/added/deleted.

If you want to cancel the item event, you still have to do that using properties.Cancel = true.

Since we talked about ThreadAbortException – now you know you have to put the SPUtility.Redirect code in a try block, and set the properties.Cancel in the catch block.

Code Example:

Your code should look like this:

try
{
    SPUtility.Redirect("/_layouts/KWizCom/AppError.aspx?ErMsg=" + errMessage, SPRedirectFlags.DoNotEndResponse, currentContext);
}
catch
{
    properties.ErrorMessage = errMessage;
    properties.Cancel = true;
}

Good luck!

כנס בנושא ניהול ידע וניהול מסמכים

Thu, 17 Nov 2011 05:16:00 +0000

שלום לכולם,

אני אשתתף בוועידה המרכזית בנושא ניהול ידע וניהול מסמכים שתתקיים ב- 29.11 במרכז הכנסים, קסאנאדו, פתח תקווה.

אני אדבר על יישום פורטל ארגוני בפלטפורמה של SharePoint Portal Server, על שלבי העבודה, על הקשיים, על ההצלחות והרבה דוגמאות מהשטח.

בנוסף, אציג איך SPS מהווה כלי שניתן להשתמש בו לבניית תהליכים ומערכות כמעט מבלי לכתוב קוד.

ההשתתפות אינה כרוכה בתשלום.

הולך להיות מעניין.

מי שרוצה יכול להירשם בקישור:

http://www.meda-conferences.com/index.php?option=com_mtree&task=viewlink&link_id=101&Itemid=14

להתראות,

אפרת קרמר

Developer's Guide: How to enhance your SharePoint performance - Understand Caching

noreply@blogger.com (Shai Petel) — Sat, 29 Oct 2011 16:16:00 +0000

I have just finished my presentation at SharePoint Saturday Twin Cities!

I talked with developers and ITPro on how to enhance their SharePoint and SharePoint customization performance using some of the built in caching features, such as:
- BLOB cache
- Ghost files
- Object cache
- Page output cache
As well as other coding practices, such as:
- Query pagination
- Indexed columns
- Throttling
- Code cache in multi-threaded environment

Here is the complete presentation, download to read comments in each slide:

Developer’s guide understand caching

View more presentations from Shai Petel

Moq, Callbacks and Out parameters: a particularly tricky edge case

Fri, 07 Oct 2011 00:16:03 +0000

In my current project we’re using Moq as our mocking framework for unit testing. It’s a very nice package – very simple, very intuitive for someone who has his wrapped around basic mocking concepts, but tonight I ran into an annoying limitation that, while rare, impeded my tests considerably.

Consider the following code:

  1: public interface IOut
  2: {
  3:    void DoOut (out string outval);
  4: }
  5: 
  6: [Test]
  7: public void TestMethod()
  8: {
  9:   var mock = new Mock<IOut>();
 10:   string outVal = "";
 11:   mock.Setup(out => out.DoOut(out outVal))
 12:       .Callback<string>(theValue => DoSomethingWithTheValue(theValue));
 13: }

What this code SHOULD do is create a mock object for the IOut interface that, when called with an out parameter, both assigns a value to it, and does something with the value in the Callback.

Unfortunately, this does not work.

The reason it doesn’t work is that the Callback method has many overloads, but they are all to various variants of the Action<> delegate. Either Action<T1>, which receives one parameter, or to Action<T1, T2, T3>, which receives three. None of these support out parameters. But none of these delegates has a signature with an out parameter. The result, at runtime, would be an error to the effect of

“Invalid callback parameters <string> on object ISetup<string&>”

Note the highlighted bits – The Setup method referred to a string& (a ref/out param), while the Callback inferred an Action<string> delegate, which expectes a regular string param.

So what CAN we do?

The first option is submit a patch to the Moq project. It’s open-source, and a solution might be appreciated, especially since the project’s lead, Daniel Cazzulino, pretty much acknowledged that this is not supported right now. I might do that later, but right now it’s the middle of the night and I just want my tests to pass. So I manage to hack together this workaround which does the trick:

  1: public static class MoqExtension
  2: {
  3:    public delegate void OutAction<TOut> (out TOut outVal);   
  4:    public static IReturnsThrows<TMock, TReturn> 
  5:                         OutCallback<TOut, TMock, TReturn>
  6:                                  (this ICallback<TMock,T4> mock, 
  7:                                   OutAction<TOut> action) 
  8:                                      where TMock : class
  9:    {
 10:       mock.GetType()
 11:           .Assembly.GetType("Moq.MethodCall")
 12:           .InvokeMember("SetCallbackWithArguments", 
 13:                         BindingFlags.InvokeMethod 
 14:                             | BindingFlags.NonPublic 
 15:                             | BindingFlags.Instance, 
 16:                         null, mock, new object[] {action});
 17:       return mock as IReturnsThrows<TMock,TReturn>;
 18:    }
 19: }

We’ve created a new delegate, OutAction<T>, that has out T as its parameters, and we’ve added a new extension method to Moq, OutCallback, which we will use instead of Callback. What this extension method does is use brute-force Reflection to hack into Moq’s internals and call the SetCallbackWithArguments method, which registers the Callback with Moq. Yes, it even works. I’m as surprised as you are.

Note and Caveats:

1) This code works for the very specific void Function (out T) signature. You will have to tailor it to the specific methods you want to mock. To make it generic, we’ll have to create a bucket-load of OutAction overloads, with different combinations of out and regular parameters.

2) This is very hacky and very fragile. If Moq’s inner implementation changes in a future version (the one I’m using is 4.0.10827.0), it will break.

3) I don’t like using out params, usually, but this is a 3rd party library, so I have to work with what I got.

Comments? Questions? Scathing criticisms on how ugly my code is? A different, simpler method of accomplishing this that I totally missed? Bring’em on.

מגמות וניהול ידע

Sun, 25 Sep 2011 13:15:45 +0000

העם דורש צדק חברתי! לא רחוק היום שהרחוב יחלחל למקומות העבודה.

אנו רואים מגמה חוזרת ונשנית של תופעה מסוימת שמתרחשת בחיינו הפרטיים ואחרי תקופה מועתקת גם למקומות העבודה שלנו, קרי, לארגונים ולחברות השונות.

ניתן לראות זאת בדוגמא הרשתות החברתיות שמעניינות את כולנו.

לפני כשלוש שנים כשיצאו לאוויר העולם אתרי הרשתות החברתיות כמו Facebook, כולנו התלהבנו, נרשמנו, פתחנו פרופילים, התכתבנו אחד עם השני, שיתפנו, צחקנו וכל זאת עד עצם היום הזה וכנראה גם בעתיד.

כל זה התנהל כל אחד בשטחו הפרטי, ב"כובע האישי" של כל אחד מאתנו, אבל לא התנהלנו כך במקום העבודה שלנו.

במקום העבודה כלי המשחק שונים: אנו כפופים לנהלים ולהנחיות גם לגבי שיתוף הידע שלנו. אנו עובדים בתרבות ארגונית שברוב המקרים מאוד ברורה: אנו מדווחים למנהל הישיר שלנו ואנו משתפים ידע בד"כ את הקולגות שלנו לעבודה בצוות.

הולכים ומתרבים הארגונים שמשכילים להבין כי יש לספק כלים לשימור וניהול הידע הארגוני, ואף מנהלים את השינוי הארגוני באמצעות כלים אלה כך שבאמת העובדים משתפים בידע שלהם.

בתקופה האחרונה, תרבות הרשת החברתית גולשת גם למקומות העבודה. כבר מבחינת מוכנותם של הפלטפורמות הטכנולוגיות ניתן לראות כי היצרניות מוצאות גרסאות חדשות שמכילות יכולות התחברות לרשתות החברתיות, לדוגמא: SharePoint Portal Server 2010.

בשלב זה במקום העבודה משכילים העובדים לנצל את חזקתה של המדיה הדיגיטאלית להפצת המידע.

תרבות הרשתות החברתיות בשטח הפרטי משפיעה עלינו באופן אישי ואני מאמינה שגם תשפיע על התרבות הארגונית במקום העבודה.

אם התחולל אצלנו במקום האישי שינוי ואנו מוכנים להיחשף יותר בחיינו הפרטיים, זה יעשה את שלו גם במקום העבודה. אנו נכונים להתחבר אל חברי העבר, אל חברי בית ספר היסודי, אל חברינו מתקופת הצבא וכו'. בפירוש ניתן לראות מגמת היחשפות ושיתוף.

לא חסרות דוגמאות של חברויות שנוצרו ברשתות החברתיות והבשילו לכדי חברות מעבר לכך.

יכול להיות שנעשינו חברותיים יותר?

מעניין מה יקרה הלאה?

שתהיה לכולנו שנה טובה, שגשוג, בריאות וכלכלה טובה.

,שלכם, אפרת קרמר

Windows 8 Developer Preview!

noreply@blogger.com (Shai Petel) — Thu, 15 Sep 2011 16:45:00 +0000

Finally, My Lenovo tablet, x201, multi touch screen, will be more cool than my iPad!

and that’s saying a lot!

I just installed windows 8 on my hyper V, looks real nice.

First impressions:

Login

First of all, logging in to windows is now done using your live ID login (email and password) and it promises to keep your desktop settings synced across all your PC’s.

Nice, finally some info on the boring lock screen. didn't ask for much, clock and date will defiantly suffice.

The new Start menu

Logging in with my live id, gets me to the new start menu. Yeah – you heard me.
It feels like they took windows 7, build a huge new start menu, and hid windows desktop behind the start menu – and it looks and feels great!

Build for wide screen displays, high res, and for touch – obviously!

While in this mode, you work in a table or smartphone look and feel. Every app you open takes up the whole screen, so no more confusing display of many small windows. I guess, for the average user that is pretty good, while for work that might be less useful.

Start menu apps

The new internet explorer looks pretty amazing and works very well. check out this new “tiles” instead of tabs:

overall, the new UI with large buttons made for touch.

This build ships with a built-in twitter application called tweet@rama, which might reminds you of something else already out there (pardon the blur, for protecting my info):

Start menu UX

Another change you might notice while in this new menu, is that the windows key in your keyboard is now used to switching between you current active application and back to the menu. As mentioned before, you can only have one application opened at a time, and it works in full screen only, which honestly makes more sense to me and is much better user experience especially for non-developer users.

I am sure this new UX will increase adaptability to the new system by the public who is now more and more used to smart phones.

And… Windows Desktop

One of the tiles in the start menu allows you to get to the original windows desktop mode:

reminds me of windows 7 so far, but – careful! clicking the start menu will not open a start menu as you know it, but will bring you back to the new start menu with the huge tiles we got on logon.

task manager had a serious face lift as well, with a minimal view:

and advanced views:

Overall, super excited!

As a long time advocate of touch screens, and the owner of 3(!) windows based multi touch computers (2 laptops and 1 HT TouchSmart) I can safely say I have waited a long time for this, and Microsoft did not disappoint!

To me, this is a huge breakthrough that will finally windows OS to lots of people, who can easily use a smart phone or and iPad but found the mouse-keyboard interaction a bit confusing.

Ok, I know this type of posts is not typical for me, a non technical product eval type of post, but I guess I am just too much excited!

Error: “value cannot be null parameter name publickey”

noreply@blogger.com (Shai Petel) — Tue, 06 Sep 2011 20:04:00 +0000

I just had a very strange error message in my visual studio 2010 SharePoint project…

When building the project everything goes well, but when packaging it or deploying it I got this error message:

“value cannot be null parameter name publickey”

Also, trying to open the package editor in visual studio to take a look at the “preview of packaged manifest” showed me the same error:

Google did not prove to be useful as I did not find anything close to this error message.

Well, in the interest of saving you time, let me just say that after some search around the project I found that the strong name signing of my project was missing the signature file (SNK), which produced an unsigned DLL, and as such – I guess caused this issue with the package building.

Hope this will at least save some time to anyone else out there,

Happy SharePointing!

WPF: Snooping Attached Properties

Thu, 01 Sep 2011 11:28:20 +0000

When developing WPF applications, Snoop is a wonderful tool that can let us see our visual tree at runtime, and find errors in data binding that are otherwise hard to track down in debugging. However, Snoop has an annoying limitation – it can’t show us data-bound Attached Properties. Let’s say we have the following XAML:

<Canvas>
   <Button Canvas.Left="{Binding Location.X}"
           Canvas.Top="{Binding Location.Y"}/>
</Canvas>

Snooping this application won’t show Canvas.Left and Canvas.Top among the Button’s properties, since they’re not a part of the Button object. If we have a bug in our binding, we won’t be able to find it.

So what do we do? We can set various TraceLevel attributes to save the binding errors to a log, but a quick workaround during debugging is to bind our data, in addition to the attached properties, to the element’s Tag property, a generic object that can bind to anything, and allow us to Snoop the binding – and find out any problems:

<Canvas>
   <Button Canvas.Left="{Binding Location.X}"
           Canvas.Top="{Binding Location.Y}"
           Tag="{Binding Location}" />
</Canvas>

This allowed me to find out, quickly, that my bug was simple – I had forgotten to make my Location property public, causing the binding to fail silently.

Accessing SharePoint Silverlight 4 API from outside of SharePoint

noreply@blogger.com (Shai Petel) — Mon, 27 Jun 2011 20:42:00 +0000

If you are like me, building Silverlight SharePoint components, you probably noticed that debugging Silverlight running from within a SharePoint solution is almost impossible!

There are many settings to take care of, and you have to install and configure your server to allow debugging, honestly I gave up in the middle.

Instead, I though, why not run the Silverlight application locally, and have it connect to the SharePoint API?

Well, try that and you will be in to a little surprise.

Any Microsoft.SharePoint.Client.Silverlight call you make will get you a System.Security.SecurityException: Security error.

Not a lot of info there, but this is easy to fix and not documented well enough anywhere in all the Silverlight SharePoint development guides I looked at.

The cause for this error, is that Silverlight blocks cross domain access by default, preventing applications from one domain to invoke requests from another domain, unless the remove domain explicitly allows it.

To allow that call, Silverlight makes a request to the root of the remote server to read a configuration file named clientaccesspolicy.xml, if this file does not exist – Silverlight checks for a flash configuration policy file instead (but lets focus on pure Silverlight 4 for now.)

In order to allow cross domain requests to be executed, just put this configuration file in the root of your web application (next to the web.config file):

file name: clientaccesspolicy.xml

<?xml version="1.0" encoding="utf-8"?>
<access-policy>
 <cross-domain-access>
  <policy>
   <allow-from http-request-headers="*">   
    <domain uri="*"/>
   </allow-from>   
   <grant-to>   
    <resource path="/" include-subpaths="true"/>
   </grant-to>   
  </policy>
 </cross-domain-access>
</access-policy>

Once you have this file, you should be able to run and debug your Silverlight application from anywhere, making it easy to debug your SharePoint Silverlight applications on either dev, testing or production servers!

Cheers, Shai.

Visual Studio 2010 find and replace window too wide

noreply@blogger.com (Shai Petel) — Wed, 01 Jun 2011 16:09:00 +0000

Do you have that problem too?

Every once in a while when you hit Ctrl+f the find and replace dialog is way too wide, growing and growing and does not fit your screen?

Well, you are not alone.

It seems that every time you close and open this window, it grow just a few pixel wider… So slowly and surly it become ridiculously wide forcing you to tame it, yet once again.

This has become quite a familiar game for developers – but no more!

Apparently this is a know issue with a fix available:

http://support.microsoft.com/kb/2268081

good luck!

Web part functional specifications document template

noreply@blogger.com (Nimrod Geva) — Tue, 31 May 2011 03:33:00 +0000

Following my last session at the Toronto SharePoint Business user group, here's a link to web part functional specifications document template I've mentioned there.

The purpose of this template is to help SharePoint business analysts to make sure they fully cover all functional aspects when designing a custom developed web part.

Please feel free to comment.

Coming soon: SharePoint site functional specifications template.

Cheers

Nimrod

Setting default value to column in document library

noreply@blogger.com (Shai Petel) — Mon, 30 May 2011 21:32:00 +0000

Hi,

One question I hear a lot from developers and system designers is “How can I set a default value to a column in a document library”?

The same goes for form libraries in SharePoint, Apparently SharePoint does not support default values for document libraries.

The first thing that comes to mind, as a solution for this predicament, is to build an event handler that will set a default value to the fields you need whenever a new item (document) is added to the library.

An experienced developer will tell you you should use the ItemAdding event, in order to set the default values to the field during the same update that the user initiated, and under his credentials.

To do that, you will have to use the properties.AfterProperties["FieldName"] = “Default Value”; to set your value.

But – you will be surprised that document libraries, although they do support the ItemAdding event, do not support properties.AfterProperties use. This collection is always empty and ignored in document libraries!

So, the only solution to set a default value to a field in a document library is by using the ItemAdded event.

During this event, the SPListItem was already created and is accessible through properties.ListItem property (unlike ItemAdding, that happens before the item was created).

So, setting the field should be rather easy: properties.ListItem[“FieldName”] = “Default value”;

But you will have to update the file manually yourself, since this happens after SharePoint has already processed the update of the item.

Naturally, you will not want to update the modified date/time, modified by user, and also you will not want to create a new version or emails alerts to be sent out.

So, instead of using the properties.ListItem.Update() method, use these lines of code:

base.DisableEventFiring();
properties.ListItem.SystemUpdate(false);
base.EnableEventFiring();

Or the SharePoint 2010 code equivalent:

this.EventFiringEnabled = false;
properties.ListItem.SystemUpdate(false);
this.EventFiringEnabled = true;

This will allow you to use custom code and programmatically set a default value to any SharePoint library column. Note that the same code should also work for SharePoint Lists, but this is supported through the UI or during the ItemAdding event.

For those of you who are not developers, or would rather a 3rd party solution, you can use KWizCom List Forms Extension solution version 2.1.60 or higher, where you can find a settings page that allows you to set advanced default values using this workaround.

Thanks, Shai.

Recruiting senior developers

noreply@blogger.com (Shai Petel) — Tue, 24 May 2011 17:11:00 +0000

Hi all,

Just an FYI, KWizCom is recruiting senior SharePoint developers to it’s R&D product development team.

We are looking for skilled and experienced developers in the greater Toronto area.

Your experience:

At least 3 years of developing on Microsoft SharePoint platforms. 2010 experience is an advantage
required skills: C#, ASP.NET, Javascript, jQuery, AJAX, DHTML, Web services, TFS, XML/CAML
nice to have: Silverlight, JSON, XSLT, SharePoint Designer, MS Office, workflow foundation, BDC/BCS/BizTalk, Hyper-V

Your responsibilities:

Work within tight delivery dates
Work in small, highly professional team
Be a part of the product lifecycle, attend brainstorming meetings, have a real impact on the product features and UX
Work in a highly creative environment

Although there is a work from home option, you will be required to attend meetings at our office, located at Markham Ontario, so we are looking for local candidates.

If you are up to it and would like to come in for an interview, please email me your CV to shai at kwizcom dot com.

Thanks!

Promoting user profile changes into local site user profile

noreply@blogger.com (Shai Petel) — Fri, 20 May 2011 13:44:00 +0000

Here is a problem that I faced more then once, with no proper way to resolve it so far…

User changes his email address or display name in his user profile using his mysite’s profile update page, but the changes are not updated in all the site collections where this user is a member of.

Display name, email settings – nothing!

Online doc’s and research says you can use the “STSADM –o sync” command, but it never helped me in those cases where it didn’t work in the first place.

The only other solution I found was to delete the user from the site collection (which removes all his permissions) and add it again. But this is unacceptable for most users.

Recently I stumbled upon this tool in codeplex by Berry Cohen:
http://userprofilesync.codeplex.com/

while his code was for SharePoint 2007, I needed it on my 2010 machine, so I upgraded it to 2010 and shared the new build in the codeplex page.

I have yet to determine if there are any side effects to using this tool, but so far it seems to be working with no problems!

It actually creates the fields in the user profile list for the site collection, which in turn allows me to even edit and modify it directly there.

Only note is, for production farms – use with caution! (and also, for production farms if you have that problem I would investigate it rather than using a workaround).

I was sorry to hear that Berry’s experience with SharePoint was short, and hope to have you back among our lines soon!

PageComponent code example for SharePoint Ribbon

noreply@blogger.com (Shai Petel) — Fri, 06 May 2011 22:18:00 +0000

I get a lot of requests lately to share my example for a simple generic PageComponent JavaScript object (class) that can handle ribbon events.

The was it works is simple, I will probably blog about it in more details later on but in a nutshell there are 3 client side objects that are involved with the ribbon work on the page:

1. PageManager

One object that have a collection of all PageComponent objects for the CommandDispatcher to be able to work with them

2. CommandDispatcher

The only object that handles ribbon events. Any action that happens on the ribbon sends the CommandName of the associated event to the CommandDispatcher. In turn, the CommandDispatcher goes to all available PageComponent objects and ask each one of them if the can handle that command, and if they do – it asks them to handle the command, thus invoking their command handlers.

3. Collection of PageComponent objects

PageComponent object are client side script classes that inherit from CUI.Page.PageComponent (yes, JavaScript class that inherits from a base class!). They declare a collection of CommandName strings of commands they know how to handle and are sometimes associated with a control on the page (web part, field control etc), and when ever such a command is invoked the CommandDispatcher asks them if they can currently handle that command, and if yes – it asks them to handle it. There is no limit to the number of PageComponent objects on the page, or to the number of PageComponent that handles a specific commands. You can also handle commands from OOB ribbon controls, and does not have to be the creator of that ribbon control.
Note: If a command has no PageComponent that can handle it, the control associated with it will be disabled (button, group) except for a tab that does not have to have a command associated with it.

Here is an example of a page component that I start from, feel free to take it and use it, it is very similar to the example available on MSDN with a bit more explanations:

//See documentation in page component: http://msdn.microsoft.com/en-us/library/ff407303.aspx
//TODO: choose namespace like you would in .NET applications. Use company name, project name and module name to avoid conflicts
Type.registerNamespace('Company.Project.Ribbon.PageComponent');

//Create the object
Company.Project.Ribbon.PageComponent = function (PageComponentId) {
    this._pageComponentId = PageComponentId;//keep record of associated control (web part, field control, etc..) that is active in this current instance of page component.
    //Initializes the base type CUI.Page.PageComponent (Base class is associated through Type.registerClass(Type, BaseType)
    Company.Project.Ribbon.PageComponent.initializeBase(this);
}

//Declate it's prototype
Company.Project.Ribbon.PageComponent.prototype =
{
    //This will be initialized by caller (web part, field control etc)
    _pageComponentId: "PageComponentIDHolder",

    getId: function () {
        return this._pageComponentId;
    },
    init: function () {
        //Create a list of commands that your page component can handle (JSON string array).
        //TODO: edit this collection, these are the command names you wish to handle from the ribbon controls you are listening to.
        this._myCommandList = ['Company.Project.Ribbon.PageComponent.CMD1',
                'Company.Project.Ribbon.PageComponent.CMD2',
                'Company.Project.Ribbon.PageComponent.CMD3'];

        //Create an array of methods used to handle commands passed to the page component.
        //Use Function.createDelegate to keep current class instance (this) when the method is called.
        //TODO: add handler per command in this._myCommandList. Later on - you will have to create the actual script handler method.
        this._myHandledCommands = {};
        this._myHandledCommands['Company.Project.Ribbon.PageComponent.CMD1'] = Function.createDelegate(this, this.CMD1_Handler);
        this._myHandledCommands['Company.Project.Ribbon.PageComponent.CMD2'] = Function.createDelegate(this, this.NotImplemented);
        this._myHandledCommands['Company.Project.Ribbon.PageComponent.CMD3'] = Function.createDelegate(this, this.NotImplemented);
    },
    getFocusedCommands: function () {
        return this._myCommandList; //return supported commands collection
    },
    getGlobalCommands: function () {
        return this._myCommandList; //return supported commands collection
    },
    canHandleCommand: function (commandId) {
        //TODO: In our logic, if there is a handler we can handle the command.
        //But you might have more logic here, like: if commandId = DeleteItem - can handle only if there is 1 item selected.
        var canHandle = this._myHandledCommands[commandId];

        if (canHandle)
            return true;
        else
            return false;
    },
    handleCommand: function (commandId, properties, sequence) {
        //Handle the command - simply getting the command handler (delegate) form the hash table and invoking it.
        return this._myHandledCommands[commandId](commandId, properties, sequence);
    },
    isFocusable: function () {
        return true;
    },

    //=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~
    //=~=~ CUSTOM PAGE COMPONENT LOGIC STARTS HERE ~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~
    //=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~
    //    This is where you should add your custom script hadler methods.
    //    TODO: Implement each handler in this._myHandledCommands
    //

    CMD1_Handler: function (commandId, properties, sequence) {
        alert("Handling CMD1_Handler");
    },
    NotImplemented: function (commandId, properties, sequence) {
        alert("This command was not implemented yet");
    }

    //
    //
    //
    //=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~
    //=~=~ CUSTOM PAGE COMPONENT LOGIC ENDS HERE ~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~
    //=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~
}

//This makes our object inherit of CUI.Page.PageComponent
Company.Project.Ribbon.PageComponent.registerClass('Company.Project.Ribbon.PageComponent', CUI.Page.PageComponent)
//Execute pending operations waiting for this script to be loaded.
NotifyScriptLoadedAndExecuteWaitingJobs("Company.Project.Ribbon.PageComponent.js");

So, now that we implemented our PageComponent, all we need is to create an instance and register is with the PageManager using this code that makes sure all JS files were fully loaded:

function init2() {
    //All JS files were loaded - create instance and register it.
    var instance = new Company.Project.Ribbon.PageComponent("ComponentID");
    SP.Ribbon.PageManager.get_instance().addPageComponent(instance);
}

function init1() {
    //Wait for ribbon JS to load
    ExecuteOrDelayUntilScriptLoaded(init2, 'sp.ribbon.js');
}
//Wait for our JS to load
ExecuteOrDelayUntilScriptLoaded(init1, 'Company.Project.Ribbon.PageComponent.js');

I hope this helps you when you are implementing your custom ribbon solutions, or if you need to handle an existing ribbon command in addition to its OOB logic.

Note: to replace an OOB logic of a ribbon command there are other steps you need to take, I will try blogging about it soon as well.

Thanks, Shai.

A little bit about me…

noreply@blogger.com (Shai Petel) — Fri, 08 Apr 2011 18:34:00 +0000

This is just a little update about my certifications - for those of you who are interested…

On April 1st I have:

1. Renewed my MCT (since 2007)

2. Renewed my MCTS SharePoint to 2010 version (was 2003 before…)

3. Achieved MCPD: SharePoint Developer 2010

4. And I was awarded the MVP: SharePoint Server award!

(Really excited about that last one!)

FxCop: Properties should not return arrays

noreply@blogger.com (Shai Petel) — Fri, 25 Mar 2011 14:56:00 +0000

Did you run FxCop and it reported a “Performance” issue regarding “Properties should not return arrays”?

http://msdn.microsoft.com/en-us/library/0fss9skc(v=VS.100).aspx

Well, don’t be in a hurry to fix it just yet.

Microsoft claims that this may pose a performance issue, since developers “must return a copy of the array”, which will cause a performance issue when accessing this property excessively (like via an indexer, in a loop)

They go on later to recommend changing this property into a method, to make it clear for the developer who is using it that he is better off calling the method once and storing it in a local member, rather then using the indexer on the property itself, Or change the property type into a collection. There is even an example at the end of the page of converting the array into a collection, which “resolves” this “performance” issue.

Let me give you a few points to think about before complying to this rule:

1. Properties do not serve the same purpose as methods. If you need to serialize this class, a property would be serialized while a method would not – resulting in loss of data upon serialization. This is extremely important when talking about web part properties. Even changing the property into a read only collection will not help, as XmlSerializer will throw an exception on that property.

2. An array does not serve the same functionality as a collection. Especially when reflecting it, or serializing it for use later (JSON serialize / SOAP serialize in web service for example).

3. If you have an existing web part that uses an array as property, DONT CHANGE IT! you cannot change it’s type, nor change it into a method! Doing so will break all your existing web parts in all pages and you will have to remove them and re-configure them, page by page. This goes to web parts, but also to any serialized content you have of existing code.

4. Speaking of performance issue, the author assumes that *if* you build the array on every get_Property access this will have negative performance. But – why would you do that? In most you just return a private array member, which does not affect performance at all.

5. Even more, by implementing the resolution suggested and converting into a collection, performance will have a far worst negative implication! Working with arrays is with no doubt the fastest way of working with a collection in .NET! It is faster than any other collection type, including Generic collections, in every possible way.
Consider a simple “for” loop, using “items[i]” <—an array will beat any collection any time, any place!

So, by suggesting to fix a non-existent “performance” issue, you actually cause a much greater real “performance” issue on your application.

What I don’t understand is, this rule has been there since 2006 with many people posting comments on its validity, Why is it still out there?

The worst thing about it, with Microsoft SharePoint online hosting, they require your to fix all of these warnings on your code. How can this be a requirement if this is clearly a design consideration and not a clear-cut case of issue to be fixed?

I would suggest you take any tool (FxCop or any other automated tool) as suggestion only, and use your own discretion on when or if to apply these rules.

Resources From My Session At SharePoint Extreme Event

Wed, 23 Mar 2011 19:30:50 +0000

שלום לכולם,

בתאריך 22.3.11 העברתי בכנס SharePoint Extreme ‘הרצאה בנושא שיפור ביצועים באתרי SharePoint.

תודה לכל מי שהשתתף, ותודה לירון ורועי מתבונה-מילניום שארגנו את המסלול.

מצורפת המצגת שהעברתי. שימו לב שבחלק הערות (Notes) של כל שקופית יש קישורים רלוונטיים.

http://cid-3d176b702454b41b.office.live.com/view.aspx/blog/SPE%20-%20SharePoint%202010%20Performance.pptx

I Will Be Speaking at SharePoint Extreme Event

Sun, 20 Mar 2011 18:22:19 +0000

בתאריך 22.3.11 עד 24.3.11 יתקיים כנס SharePoint Extreme - שלושה ימים של סדנאות והרצאות שכולן על SharePoint.

אני אעביר סשן ביום הראשון של הכנס, 22.3, יום שלישי, על ניתוח ושיפור ביצועים של אתרי SharePoint.
ההרצאה שלי תארך כ 45 דקות, ותסקור את הכלים והשיטות שמסייעים למדוד ולשפר ביצועים באתר SharePoint.

ההרצאה היא חלק ממסלול “צעדים ראשונים בבניית אתר אינטרנט מבוסס SharePoint 2010” אותו מוביל ירון בן שלום מחברת תבונה-מילניום.

לפרטים והרשמה:
http://www.microsoft.com/israel/sharepointExtreme/Default.aspx

ההרשמה כרוכה בתשלום.

Parser Error – SharePoint crash after deployment

noreply@blogger.com (Shai Petel) — Tue, 01 Mar 2011 20:12:00 +0000

Today I run into a strange problem.

I build a new version of a product and installed it – and it crashed my entire SharePoint:

Now, I want to say that this does not happen often, but I fear it does… :)

The error reads:

Parser Error

Description: An error occurred during the parsing of a resource required to service this request. Please review the following specific parse error details and modify your source file appropriately.
Parser Error Message: This page has encountered a critical error. Contact your system administrator if this problem persists.

Source Error:

Line 1:  <%@ Page Inherits="Microsoft.SharePoint.Publishing.TemplateRedirectionPage,Microsoft.SharePoint.Publishing,Version=12.0.0.0,Culture=neutral,PublicKeyToken=71e9bce111e9429c" %> <%@ Reference VirtualPath="~TemplatePageUrl" %> <%@ Reference VirtualPath="~masterurl/custom.master" %>
Line 2:  <html xmlns:mso="urn:schemas-microsoft-com:office:office" xmlns:msdt="uuid:C2F41010-65B3-11d1-A29F-00AA00C14882"><head>
Line 3:  <!--[if gte mso 9]><xml>

Source File: /Pages/Default.aspx Line: 1

Well, I started investigating this strange error message…

The weird thing was, all my SharePoint sites reported this error except for central administration – which worked just fine!

After a short research I noticed in SharePoint Log this strange message, that my web part DLL was throwing an exception that it could not load a referenced file: Microsoft.SharePoint.ApplicationPages.Administration

Well… this makes sense, since this file only exists in central administration app_bin folder.

Things started to come together. All I had done wrong was to use this dll in my code, since I had some code that was running in central admin (settings page)

Well, as soon as I removed it from my references everything started working again.

Now I have to find another way to create a settings page, since GlobalAdminPageBase base class (for central admin settings pages) is something I cannot use.

Either that or I will have to separate my settings page into another DLL (which I prefer not to do)

Well, if you get this error message – be sure to check SharePoint logs and make sure you are not using this dll!

List.DefaultView is null ?

noreply@blogger.com (Shai Petel) — Wed, 23 Feb 2011 18:40:00 +0000

I bet many of you fall for this one… I know I did.

You got a SPList object, you want to get the default view, or the default view name, so you write:

list.DefaultView.Title

You never even bother to check if DefaultView is null or not, right? Because it doesnt make sense…

Well, I had a customer who did something crazy.

He created a redirection page inside a list forms folder, and marked it as the default view for the list using SharePoint Designer 2007.

* You will be glad to hear that in SharePoint Designer 2010 this is not possible anymore :)

Well, from this point on, calling the list.DefaultView object returns null, which made our code fail since we didn’t think of checking if there is a valid default view for the list.

So, a lesson to be learned: never trust anyone in SharePoint!

A quick fix I did for it is to see if list.DefaultView is null, and if so, to loop through all list views and get the first valid view.

Here is the code I used:

internal static SPView GetSafeListDefaultView(SPList list, string hideViews)
        {
            if (list.DefaultView != null)
                return list.DefaultView;
            else
            {
                foreach (SPView view in list.Views)
                {
                    if (
                            view.Hidden ||
                            string.IsNullOrEmpty(view.Title.Trim()) ||
                        //Explorer View or subject view in discussion - allow subject views.
                            (view.BaseViewID == "3" && view.ContentTypeId.ToString() == "0x") ||
                            (hideViews.IndexOf(";" + view.Title.ToLower() + ";") >= 0) ||
                        //reply views in discussion board
                            (list.BaseTemplate == SPListTemplateType.DiscussionBoard && !view.ContentTypeId.ToString().StartsWith("0x012001"))
                        )
                        continue;

                    return view;
                }
            }

            throw new Exception("Could not get a safe default view for this list: " + list.Title);
        }

So from now on, I will use this method to get the list default view, and never again trust the list.DefaultView property, which may be null.

By the way, the proper way to do what the customer wanted is to change the list.RootFolder.WelcomePage to the redirection page he created. Changing the default view is not the best idea, and I am not sure if it is supported.

Cheers, Shai.

Assembly redirection in OWSTimer

noreply@blogger.com (Shai Petel) — Tue, 22 Feb 2011 22:53:00 +0000

You may have read my older post on how to add BindingRedirect for assemblies into web.config in SharePoint, which allows you to change the DLL version number of your SharePoint customizations.

One thing I did not mention was, what if you need to use one of these redirected DLL’s in an SPTimerJob?

You will notice that assembly BindingRedirect does not apply to OWSTimer.exe, and it will throw errors such as “Could not load file or assembly 'AssmeblyName, Version=1.2.60.0, Culture=neutral, PublicKeyToken=xxxxxxxxx' or one of its dependencies. The system cannot find the file specified”, while you alraedy have a newer version deployed.

So, how do I make OWSTimer.exe aware of the new version and have my SPTimerJobs running with the latest version every time?

First, we need to understand why this doesn’t work.

Timer jobs run from OWSTimer.exe file, which is not effected by the web.config settings, so our BindingRedirect in web.config file will not help our code to find the correct assembly when running of the OWSTimer.exe file.

Now, for the solution

The bad news are that although a WSP natively allows you to add BindingRedirect to your web.config, it does not allow the same for other config files.

So, we need to do this manually.

Not to fear though! There is a rather simple way of doing that, still within the WSP with no need to come out of the WSP deployment.

It is a little know fact, that a farm feature event handler, with the “FeatureInstalled” event will have 2 special effects:

1. It will run for each web front end server, and not only on one of them

2. It will allow sufficient access to add files to the SharePoint Root.

Just make sure you do not edit / remove any of the out of the box files!

Well, taking this into consideration makes our problem a very simple one to solve.

We just need to create a config file for OWSTimer.exe and add our BindingRedirect statements there, and that’s it – the OWSTimer will know which version of our DLL to look for.

Here is a code example on how to add or update 2 BindingRedirect nodes in that config file, the same method can apply to any other config file during WSP deployment stage:

public void UpdateOWSTimerBindingRedirect()
{
    try
    {
        string configFile = SPUtility.GetGenericSetupPath("TEMPLATE").ToLower().Replace("\\template", "\\bin") + "\\OWSTIMER.EXE.CONFIG";
        //string XMLData = System.IO.File.ReadAllText(configFile, Encoding.UTF8);
        XmlDocument config = new XmlDocument();
        config.Load(configFile);

        //ensure assemblyBinding exists
        XmlNode assemblyBinding = config.SelectSingleNode("configuration/runtime/*[local-name()='assemblyBinding' and namespace-uri()='urn:schemas-microsoft-com:asm.v1']");

        if (assemblyBinding == null)
        {
            assemblyBinding = config.CreateNode(XmlNodeType.Element, "assemblyBinding", "urn:schemas-microsoft-com:asm.v1");
            config.SelectSingleNode("configuration/runtime").AppendChild(assemblyBinding);
        }

        //Delete old entrees if exist
        XmlElement current = assemblyBinding.FirstChild as XmlElement;
        while (current != null)
        {
            XmlElement elmToRemove = null;
            if (current.FirstChild != null)
            {
                var asmIdn = (current.FirstChild as XmlElement);
                if (asmIdn.GetAttribute("name").ToLower().Equals("kwizcom.sharepoint.foundation") ||
                    asmIdn.GetAttribute("name").ToLower().Equals("kwizcom.foundation"))
                    elmToRemove = current;
            }

            current = current.NextSibling as XmlElement;

            if (elmToRemove != null)
                assemblyBinding.RemoveChild(elmToRemove);
        }

        XmlElement dependentAssembly = null;
        if (dependentAssembly == null)//create it
        {
            dependentAssembly = config.CreateElement("dependentAssembly");
            dependentAssembly.InnerXml = "<assemblyIdentity name=\"KWizCom.SharePoint.Foundation\" publicKeyToken=\"30fb4ddbec95ff8f\" culture=\"neutral\" />"+
                                         "<bindingRedirect oldVersion=\"1.0.0.0-20.0.0.00\" newVersion=\"13.2.62.0\" />";
            assemblyBinding.AppendChild(dependentAssembly);
        }

        dependentAssembly = null;
        if (dependentAssembly == null)//create it
        {
            dependentAssembly = config.CreateElement("dependentAssembly");
            dependentAssembly.InnerXml = "<assemblyIdentity name=\"KWizCom.Foundation\" publicKeyToken=\"30fb4ddbec95ff8f\" culture=\"neutral\" />" +
                                         "<bindingRedirect oldVersion=\"1.0.0.0-20.0.0.00\" newVersion=\"13.2.62.0\" />";
            assemblyBinding.AppendChild(dependentAssembly);
        }
 
        config.LoadXml(config.OuterXml.Replace("xmlns=\"\"",""));
        config.Save(configFile);
    }
    catch { }
}

Simply call this method during the FeatureInstalled event and update the code with your DLL name and version number, and you are done.

Hope this helps you with file versioning on SharePoint, which can be a rather difficult task sometimes.

Thanks, Shai.

Adding print functionality to Data View Web Parts

noreply@blogger.com (Shai Petel) — Tue, 15 Feb 2011 17:27:00 +0000

Hi,
A question I got from a customer today was “How can I add a print button to data view web part which will print all documents in the view?”

Well, we have a product called iMUSH Print that allows you to print selected items/document from out of the box list views, and merge them into one PDF file for easy printing.

But the question remains, how do one connects this print functionality to a data view web part?

Well, lists or libraries, the answer is simple and took me about an hour to create a working POC.
First, lets have a look at out of the box iMUSH print feature in standard library view:

One thing to note, is that you can either use the checkboxes to select items for printing or click the print menu and select what you wish to print in the popup:

Ok, so obviously, this popup “knows” how to get a list of items for print. We will use this parameter to send the items form the DVWP.
Now, to the DVWP in SharePoint Designer:
2 changes are needed in the DVWP,

1. Add a print button HTML just before the <table> tag of the DVWP items:

<img alt="print" src="/_layouts/KWizCom_iMushFeature/ico_imush_print_16px.png"onclick="KWizCom_DoDVWPPrint('/iMUSH/_layouts/KWizCom_iMushFeature/KWizComPrintList.aspx',
'567836FC-F9B1-4D48-80AC-D637772703D4', '', this.nextSibling);"/>

you will need to replace the url “/iMUSH/” with your real site URL, and the list id ‘5678…’ with your actual list/library GUID.

2. Locate the <tr> tag inside your DVWP items table, and add an “itemid” attribute to it:

<tr itemid="{@ID}">

That’s it for the DVWP.

Next you will have to add some javascript code to your page, anywhere in the page.
My favourite way about it is just adding a content editor web part.
Just insert this JS code:

<script>

function KWizCom_DoDVWPPrint(pageUrl, listId, viewId, dvwpTable)

var url = pageUrl + "?ListId=" + listId + "&View=" + viewId + "&ItemId=";

    //get items from dvwp

var items = "";

    for(var i = 0; i < dvwpTable.rows.length; i++)

if(dvwpTable.rows[i].itemid != undefined)

if( items != "" ) items += ",";

            items += dvwpTable.rows[i].itemid;

}

    url += items;

commonShowModalDialog(url,

'dialogHeight:300px;dialogWidth:180px;scroll:true;toolbar:no;status:no;resizable:yes;',

null, null);

</script>

and you are done!

Now, you can click print on the DVWP to print all items that are displayed in the web part, even after filtering but the user:

That’s it!

Just remember, this functionality requires a license for iMUSH Print.

Joining The Mothership

Tue, 15 Feb 2011 08:30:38 +0000

Short Summary for English speaking readers: I’m Joining Microsoft, no longer MVP.

חברים וחברות יקרים, אני שמח לבשר על הצטרפותי לחברת מיקרוסופט.

לאחר תקופה נהדרת שבה הקדשתי את כל כולי עבורכם – קהילת SharePoint הישראלית - הדרך מובילה אותי קדימה אל מיקרוסופט.
אני אשתדל להמשיך ולתרום, להשפיע ולעזור, כפי שעשיתי עד כה. עם זאת, חלק מהפעילויות אותן ביצעתי, יצטרכו לעבור לידי אחרים (עוד בנושא הזה בהמשך). אם אתם מעוניינים להשפיע על קהילת SharePoint הישראלית, צרו איתי קשר.

איתי שקורי.

Map folder in SharePoint Root

noreply@blogger.com (Shai Petel) — Thu, 03 Feb 2011 18:40:00 +0000

I am sure many of you needed from time to time to get a local path to a file that was deployed to the SharePoint Root (AKA Hive in 2007 version, AKA “12” folder AKA “14” folder).

For whatever reason you needed to do so, you probably notices that the ASP.NET API (Server.MapPath) or any other ASP.NET method of discovering the local path for a file or folder did not work out as excepted.

Without going into a long explanation on why that did not work, There is a very little documented method that I have used a lot in the past and I have learned not many developer know it.

The SPUtility class contains a static method named “GetGenericSetupPath” that takes one string parameter.

That string parameter can be any folder under the SharePoint Root folder, and the result of the method is the local file system path of that folder.

For example, to get the local path for “Template” folder, use this command:
SPUtility.GetGenericSetupPath("Template");

But to get the “Layouts” folder, you have to use this command:
SPUtility.GetGenericSetupPath("Template\\LAYOUTS");

Now, saying that – you have to keep in mind that although you do have read permissions to these folders while inside a SharePoint APP, other permissions (like create file, or create folders) may be blocked.

Cheers,

Shai.

How to identify a Ribbon control ID

noreply@blogger.com (Shai Petel) — Tue, 01 Feb 2011 13:18:00 +0000

A frequent question I get during my “How to develop for the SharePoint Ribbon” session is:

How can I identify and existing ribbon control or group ID?

This is useful when you wish to override, hide a control, or insert new controls into an existing group / new groups into an existing tab.

So, this task is pretty simple once you know this trick:

First, open a page and make your ribbon control visible:

Second, use IE developer tool bar to select the ribbon button you want:

Climb up the HTML to the span container, the span ID will have the ribbon control ID:

In my case, for the wiki page “email a link” here is what we get:

Ribbon.WikiPageTab.Share-LargeLarge-0-0

So, the control ID will be:

“Ribbon.WikiPageTab.Share”

And there you go!

SharePoint Group–1/11

Thu, 06 Jan 2011 09:30:17 +0000

שלום לכולם,

מפגש ראשון של השנה החדשה יתקיים בתאריך ה 23/01/2011. את המפגש יעבירו יוני תורג’מן ואלכס לויטין מחברת גארדיאן.

שימו לב, חובה להרשם על מנת להשתתף באירוע ולקבל חניה בבניין.

תיאור המפגש:

במפגש זה נעסוק בכל נושא העבודה מול ממשק ה-UI של SharePoint 2010. המפגש יתחלק לשלושה חלקים:
1. עבודה עם ממשק ה-Ribbon: בחלק זה נדבר על עבודה מול ממשק ה-Ribbon באמצעות SharePoint Designer 2010 (ללא כתיבת קוד), דרך המתאימה בעיקר למיישמים ומטמיעים, ובאמצעות Visual Studio 2010 ונראה כיצד ניתן באמצעות קוד להרחיב את יכולות הממשק.
2. User Notifications: בחלק זה נדבר על התראות למשתמש באמצעות ה-User Notifications של SharePoint 2010.
Popup Modal .3: בחלק האחרון של המפגש נדבר על עבודה מול ממשק ה-Modal החדש של SharePoint 2010 ונראה איך באמצעות JavaScript ניתן להקפיץ חלונות למשתמש.

לפרטים נוספים והרשמה:
http://www.sharepoint-israel.co.il/events/SPG/SPG11

נתראה במפגש,
איתי שקורי.

SharePoint Group–Meeting 10 Summary

Tue, 28 Dec 2010 18:36:16 +0000

שלום לכולם,

בתאריך 26/12/10 התקיים מפגש בנושא ALM With SharePoint 2010.
את המפגש העביר אסף אבן מחברת אדוונטק.

את המצגת, וחומרים נוספים מהאירוע, ניתן למצוא באתר האירוע, בכתובת הבאה:
http://www.sharepoint-israel.co.il/events/SPG/SPG10

שאלות המשך, ניתן לשאול בפורום בכתובת
http://www.sharepoint-israel.co.il/forums

תודה לכל המשתתפים,
נתראה במפגש הבא,
איתי שקורי.

How My Latest Post Can Help You Save Time

Sun, 19 Dec 2010 16:01:01 +0000

I recently wrote a post regarding a certain performance issue with SharePoint that we solved. I since got some comments and questions about when is this problem relevant.

Well.. It’s practically everywhere ,in an isolated environment, and It’s very common for development machines (usually virtual) to be disconnected. The fixes suggested in that post can help you speed up your work in the following cases:

A desktop application (WinForm\Console) that uses SharePoint APIs.
STSADM.exe.
PowerShell work with SharePoint.
First hit of your SharePoint site.
IIS reset\Recycle app pool when deploying to SharePoint.
Anything else I didn’t think of, that uses SharePoint API’s in it’s own process (app domain to be precise).

Deployment Error In VS2010 On SharePoint 2010 Project Template

Thu, 09 Dec 2010 19:16:45 +0000

After hitting Deploy on a sharepoint 2010 project item in visual studio 2010 and getting the following error:

Error occurred in deployment step 'Activate Features': Value cannot be null.
Parameter name: id

Be sure to check your feature activation dependencies.

if you see a feature with the GUID - 00000000-0000-0000-0000-000000000000, something probably went wrong..

This can be caused by the following scenario:
You`re working on a multiple developers development environment, using TFS as your ALM tool. One developer has deleted a feature which some other feature in the solution is dependant on. After you get the latest version of the visual studio solution the feature your were dependant on doesn't exist anymore and your left with an unrecognized dependency with the non existing feature.

In order to be able to perform a successful Deploy, just remove the invalid dependency, smile, take a deep breath and hit Deploy.

Happy DEPLOYING,

Yuval

Modifying search query before rendering results in CoreResultsWebPart SharePoint 2010

Thu, 02 Dec 2010 16:02:14 +0000

SharePoint 2010 introduce us with new search customizations capabilities in term of inheriting and extending the OOTB webparts.

The search webparts now communicates through a new object, named: QueryManager which exist under the namespace: Microsoft.Office.Server.Search.Query

through the QueryManager object we can change the query before getting results at the CoreResultsWebPart control.

In the following example im overriding the submitted query with the word “Global” just before getting the results.

public class ExtendedResults : CoreResultsWebPart
   {

       private QueryManager queryManager;

       protected override void OnInit(EventArgs e)
       {
           queryManager = SharedQueryManager.GetInstance(this.Page).QueryManager;
           base.OnInit(e);
       }

       protected override System.Xml.XPath.XPathNavigator GetXPathNavigator(string viewPath)
       {
           queryManager.UserQuery = "Global";
           return base.GetXPathNavigator(viewPath);
       }
   }

Notice that other search webparts like the Refinement panel and Pager wont be affected by this modification.

HTH someone.

Yuval Korin

Office System Israeli Bloggers

Presenting at SharePoint User Group Tomorrow

BDC -> BCS?

Xml Serialize Interface Typed Members

Enterprise Wiki site template vs. Wiki Library template

More Findings from reading SharePoint 15 CTP SDK

ArcGIS–Getting the Legend Labels out

SharePoint 15 “Apps” (as documented in the CTP SDK)

Storing Configuration Settings For Timer Jobs

Follow Up on My SharePoint Extreme Session on Claims Based Authentication

I’m Speaking at SharePoint Extreme 2012

Datasheet view alternatives

The Case of the Unexpected Expected Exception

Open Source Vigilantes?

Cache explained - the milk story

Introduction

The milk story

No cache

Caching options

Conclusion

Microsoft Canada - Imagine Cup

TSQL: Concatenate Column from Multiple Rows into String

SharePoint 2010 : The following computer running SharePoint does not contain the required Infopath form template

Speaking Engagements 2012

SharePoint Popup Scroll gone after autoSize

The issue

The solution

Redirect to custom error page from event handler

Redirecting

Cancelling the event

Code Example:

כנס בנושא ניהול ידע וניהול מסמכים

Developer's Guide: How to enhance your SharePoint performance - Understand Caching

Moq, Callbacks and Out parameters: a particularly tricky edge case

מגמות וניהול ידע

Windows 8 Developer Preview!

Login

The new Start menu

Start menu apps

Start menu UX

And… Windows Desktop

Overall, super excited!

Error: “value cannot be null parameter name publickey”

WPF: Snooping Attached Properties

Accessing SharePoint Silverlight 4 API from outside of SharePoint

Visual Studio 2010 find and replace window too wide

Web part functional specifications document template

Setting default value to column in document library

One question I hear a lot from developers and system designers is “How can I set a default value to a column in a document library”?

Recruiting senior developers

Promoting user profile changes into local site user profile

PageComponent code example for SharePoint Ribbon

A little bit about me…

FxCop: Properties should not return arrays

Resources From My Session At SharePoint Extreme Event

I Will Be Speaking at SharePoint Extreme Event

Parser Error – SharePoint crash after deployment

Parser Error

List.DefaultView is null ?

Assembly redirection in OWSTimer

First, we need to understand why this doesn’t work.

Now, for the solution

Adding print functionality to Data View Web Parts

Joining The Mothership

Map folder in SharePoint Root

How to identify a Ribbon control ID

SharePoint Group–1/11

SharePoint Group–Meeting 10 Summary

How My Latest Post Can Help You Save Time

Deployment Error In VS2010 On SharePoint 2010 Project Template

Modifying search query before rendering results in CoreResultsWebPart SharePoint 2010