As a follow on post to the post on Importing Computers via CSV, I wanted to also share with you the method for importing information about the software installed on those computers.  Neil Lydick, one of the developers on our team, put together the resources you’ll need:

• A management pack file that defines a new type projection.
• A data mapping file for software and software updates.
• A sample data file.

You’ll need to import the management pack file into SCSM first since the mapping file depends on it to import the data correctly.

Keep in mind that the System.SoftwareItem class has a compound key comprised of these five properties:

1. Publisher
2. ProductName
3. VersionString
4. IsVirtualApplication
5. LocaleID

Each unique combination of those represents a new Software Item.  If you import a data file with this data:

You will get 2 instances of Software Item – one for the one published by ‘Microsoft’ and another one published by ‘Microsoft Corporation’.  Because the first and third rows have the exact same values for all the key properties the third row will just create a new relationship between mycomputer2 and the software title that will already exist because it was created by importing the first row.

Note: If a Windows computer with the principal name specified does not already exist a new one will be created.

Software Update also has a compound key comprised of the following two properties:

1. Title
2. Vendor

Attached are the necessary files.

One of the most common customizations people need to make to Service Manager is to extend the Service Manager CMDB data model.

Here’s a quick video (less than 5 minutes) on how to extend the data model in SCSM using the authoring tool.  In this particular example I show how to extend the Windows Computer class to add a new property to tracking the Account Departments ID.  You can see how in just a minute or two I can extend the data model and then immediately start to use it in the console thanks to the generic form/extensions tab.

If you have the screen resolution to do it I recommend watching this video in 720p HD at full screen.

In Service Manager you can define properties as “auto incrementing” meaning that each value should be higher than the next and automatically assigned by the system.  One good example of this is the Work Item ID.  Each time a work item is created a new Work Item ID is generated which is 1 larger than the previous one.

There is a secret way to change the auto-incrementing value range in the database.  I”m not even sure this is really supported so don’t do this in production unless you are a risk taker! :)  But it’s great for testing and such things regardless.

Basically there is this table in the ServiceManager database called the AutoIncrementAvailableRange table.  This value stores the next available number for a particular class property.  If the last work item ID that was handed out was 1234 this table would show 1235 and then once 1235 was used it would say 1236.  You get the idea.  So, by changing this number we can change the base number that we start from.  Let’s say for example that we always want our incident IDs to be in the 10,000+ range.  We could change thus number to 10000 and start from there.  Definitely don’t set it lower than the current number though!  That will most likely be very bad.

So – here’s what you do.  First you need to know which row represents the property you want to update.  If you just run this:

select * from AutoIncrementAvailableRange

you’ll get this:

Not exactly human readable.  So – we need to join a few tables.  (sorry in advance for what I’m sure is really bad T-SQL)

select

MT.TypeName,

MT.ManagedTypeId,

MTP.ManagedTypePropertyName,

MTP.ManagedTypePropertyID,

AIAR.FirstAvailableValue

from ManagedType as MT, ManagedTypeProperty as MTP, AutoIncrementAvailableRange as AIAR

where MT.ManagedTypeId = AIAR.ManagedTypeId and MTP.ManagedTypePropertyId = AIAR.ManagedTypePropertyId

That gives us results which are more readable:

So – now let’s say we want to adjust the WorkItem ID to start at 10000.  We would just run a query like this:

update AutoIncrementAvailableRange

set FirstAvailableValue = 10000

where ManagedTypeId = 'F59821E2-0364-ED2C-19E3-752EFBB1ECE9' and ManagedTypePropertyId = '28B1C58F-AEFA-A449-7496-4805186BD94F'

Now if I go to create a new incident look at what the ID number is:

I always intended to post the complete Service Manager Visio Architecture Diagram at the completion of the Service Manager platform blog series, but I never actually got around to it.

Here’s the series if you haven’t had a chance to read it yet.

The System Center Platform in Service Manager Part 1: Introduction

The System Center Platform in Service Manager Part 2: The Model-Based Database

The System Center Platform in Service Manager Part 2: The Model-Based Database - Try It!

The System Center Platform in Service Manager Part 3: The System Center Data Access Service

The System Center Platform in Service Manager Part 3: The System Center Data Access Service - Try It!

The System Center Platform in Service Manager Part 4: The System Center Management Service

The System Center Platform in Service Manager Part 4: The System Center Management Service – Try It!

The System Center Platform in Service Manager Part 5: The Management Configuration Service

The System Center Platform in Service Manager Part 6: The Data Warehouse

The System Center Platform in Service Manager Part 6: The Data Warehouse – Try It!

The Visio architecture diagram is attached.

A common scenario that people want to accomplish is to extend the incident class to capture information about what customer organization is affected by a given incident.  You can follow this simple pattern to add any kind of property to the data model and customize the form to show it.

If your screen resolution is big enough I suggest watching this video in 720p HD full screen (1280x720).

I’ve seen this one enough times now that I just had to do something about it.  Attached is a management pack which will show you all the work items (incidents, change requests, problems, etc. ) that are assigned to you.

Enjoy!

Check out the MP XML if you want to see how I did it.  I tried to get it to show Review Activities where you are a reviewer but that part isn’t working for some reason.

One of the most common things people want to be able to do is extend the model to create new classes, usually new configuration items like customers and other physical assets like phones, desks, etc.  Here is a quick demo video showing you how to do this.

This demo video shows you how to create a new configuration item class using the Service Manager authoring tool. The new configuration item class used for the example is a Customer class. The new class will have a key automatically incrementing string property, a customer name string property. a contract start datetime property and a customer type list data type property to show the different kinds of properties that can be added. Then you will see how you can immediately start using the new class by leveraging the generic form and how you can create a custom form if you want to control the look/feel of the form.

If your screen resolution is high enough I recommend watching this full screen at 720p HD.

BTW - there is also a great blog post here from one of the Microsoft partner systems integrators here:

http://blurbsonit.wordpress.com/2010/08/11/creating-custom-classes-in-system-center-service-manager-2010/

Patrik Sundqvist is at it again!  This time he has come up with a solution for a common request for response time SLA management.  Check out his solution here:

http://blogs.litware.se/?p=749

Great work Patrik!

Awhile back we announced that there is a downloadable solution for dashboards for Service Manager.  Those dashboards are based on SharePoint and require you to have some knowledge of the DW DataMart database and T-SQL in order to create custom dashboard charts.

If you are looking for something a little more fancy, or you want more control of the presentation of the data, or you would rather bring in some data visualization and reporting experts to do the work for you we recommend taking a look at Dundas Dashboards.

Microsoft has had a close relationship with Dundas for quite a few years now.  In some cases, we have licensed their technology and included it in products such as System Center Operations Manager (reports and diagram view) and SQL Server Reporting Services and even in the .Net Framework itself in version 4.0.

We asked Dundas to build a proof of concept of what their consulting services group could build on top of the System Center Service Manager data warehouse using' Dundas’ new dashboard product.  It’s really impressive what they came up with in just about a week’s time.  Here are some screenshots:

You can play around with this online actually so you get a feel for the interactivity and can play around with their ‘Dashblocks’.

Here is a link to the administration/configuration site:

http://consulting-demo.dundas.com/MSDashboard/

Login: Viewer

Password: 1234

Here is a link to the dashboard itself:

http://consulting-demo.dundas.com/MSDashboard/

For more information, please see the Dundas web site:

http://www.dundas.com

Thanks for putting this together guys!  Looks really good!

One of the things that people often ask about is how to use the Service Manager SDK to:

• create new objects, 

• update objects,

• add relationships, 

• remove relationships

One of the keys to using the SDK in this way is to use type projections.  

We have had a few blog posts on this in the past in introduce the concepts and examples:

Getting Started with Type Projections

More with Type Projections

Getting and Working with Type Projections – Basic

These blogs posts were a little abstract though.  

This blog post shows you how to work with type projections using incident management as an example. 

The Visual Studio project is attached for reference.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.EnterpriseManagement;
using Microsoft.EnterpriseManagement.Common;
using Microsoft.EnterpriseManagement.Configuration;
using Microsoft.EnterpriseManagement.Packaging;
using Microsoft.EnterpriseManagement.ConnectorFramework;

namespace IncidentTypeProjection
{
    class Program
    {
        static void Main(string[] args)
        {
            //First get a connection to the Management Group
            EnterpriseManagementGroup emg = new EnterpriseManagementGroup("localhost");
            
            //======================================================
            //Example #1 - Creating a single incident object
            //======================================================
            Console.WriteLine("Creating an incident object....");
            //Get the System.WorkItem.Incident class
            ManagementPackClass classIncident = 
                emg.EntityTypes.GetClass(new Guid("A604B942-4C7B-2FB2-28DC-61DC6F465C68")); 
                
            
            //Also get the Medium urgency and impact enums 
            //since they are required values to create a new incident
            //More information on working with enums here: 
            //http://blogs.technet.com/b/servicemanager/archive/2010/05/25/programmatically-working-with-enumerations.aspx 
            ManagementPackEnumeration enumUrgencyMedium = 
                emg.EntityTypes.GetEnumeration(new Guid("02625C30-08C6-4181-B2ED-222FA473280E"));
            ManagementPackEnumeration enumImpactMedium = 
                emg.EntityTypes.GetEnumeration(new Guid("80CC222B-2653-2F68-8CEE-3A7DD3B723C1"));

            //Now create a CreatableEnterpriseManagementObject so we can create a 
            //new incident object and populate its properties and Commit() it.
            CreatableEnterpriseManagementObject cemoIncident = 
                new CreatableEnterpriseManagementObject(emg,classIncident);
            //Just doing this for demo purposes.  Obviously a GUID is not a good display name!
            String strTestID = Guid.NewGuid().ToString();  
            //Set some property values
            cemoIncident[classIncident, "DisplayName"].Value = strTestID;
            cemoIncident[classIncident, "Title"].Value = strTestID;
            cemoIncident[classIncident, "Urgency"].Value = enumUrgencyMedium;
            cemoIncident[classIncident, "Impact"].Value = enumImpactMedium;
            //And submit...
            cemoIncident.Commit();
            Console.WriteLine("Incident object created named: " + strTestID);

            
            //======================================================
            //Example #2 - Creating a Relationship between to Objects - Incidnet and User via the Affected User relationship
            //======================================================
            //Get the incident
            Console.WriteLine("Creating an relationship between the incidena and a user....");
            String strIncidentByTitleCriteria = 
                String.Format(@"<Criteria xmlns=""http://Microsoft.EnterpriseManagement.Core.Criteria/"">" + 
                      "<Expression>" +
                        "<SimpleExpression>" +
                          "<ValueExpressionLeft>" +
                            "<Property>$Target/Property[Type='System.WorkItem.Incident']/Title$</Property>" + 
                          "</ValueExpressionLeft>" + 
                          "<Operator>Equal</Operator>" +
                          "<ValueExpressionRight>" +
                            "<Value>" + strTestID + "</Value>" +
                          "</ValueExpressionRight>" +
                        "</SimpleExpression>" +
                      "</Expression>" +
                    "</Criteria>");

            //System.WorkItem.Incident.Library MP
            ManagementPack mpIncidentLibrary = 
                emg.ManagementPacks.GetManagementPack(new Guid("DD26C521-7C2D-58C0-0980-DAC2DACB0900"));  

            //Get the incident using the criteria from above...
            EnterpriseManagementObjectCriteria emocIncidnetByTitle = 
                new EnterpriseManagementObjectCriteria((String)strIncidentByTitleCriteria,classIncident,mpIncidentLibrary,emg);
            IObjectReader<EnterpriseManagementObject> readerEmoIncidentAffectedUsers = 
                emg.EntityObjects.GetObjectReader<EnterpriseManagementObject>(emocIncidnetByTitle,ObjectQueryOptions.Default);
            EnterpriseManagementObject emoIncident = readerEmoIncidentAffectedUsers.ElementAt(0);

            //Get a user..
            //System.Domain.User class
            ManagementPackClass classUser = 
                emg.EntityTypes.GetClass(new Guid("ECA3C52A-F273-5CDC-F165-3EB95A2B26CF")); 
            IObjectReader<EnterpriseManagementObject> readerEmoDomainUsers = 
                emg.EntityObjects.GetObjectReader<EnterpriseManagementObject>(classUser,ObjectQueryOptions.Default);
            //Just getting whatever the first user is that comes back for demo purposes
            EnterpriseManagementObject emoDomainUser = readerEmoDomainUsers.ElementAt(0); 

            //Create a Relationship between the service and the user
            //System.WorkItemAfectedUser relationship type
            ManagementPackRelationship relIncidentAffectedUser = 
                emg.EntityTypes.GetRelationshipClass(new Guid("DFF9BE66-38B0-B6D6-6144-A412A3EBD4CE"));
            CreatableEnterpriseManagementRelationshipObject cemroIncidentAffectedUser = 
                new CreatableEnterpriseManagementRelationshipObject(emg, relIncidentAffectedUser);
            //Set the source and target...
            cemroIncidentAffectedUser.SetSource(emoIncident);
            cemroIncidentAffectedUser.SetTarget(emoDomainUser);
            //And submit...
            cemroIncidentAffectedUser.Commit();
            Console.WriteLine("Relationship created.");
            
            //======================================================
            //Example #3 - Creating relationships in bulk using Incremental Discovery Data
            //======================================================
            Console.WriteLine("Creating relationships to affected Windows computers...");

            //First get the class and relationship type we want to work with
            //Microsoft.Windows.Computer class
            ManagementPackClass classWindowsComputer = 
                emg.EntityTypes.GetClass(new Guid("EA99500D-8D52-FC52-B5A5-10DCD1E9D2BD"));
            //System.WorkItemAboutConfigItem relationship type
            ManagementPackRelationship relAffectedConfigurationItem = 
                emg.EntityTypes.GetRelationshipClass(new Guid("B73A6094-C64C-B0FF-9706-1822DF5C2E82")); 

            //Now create a "bucket" (IncrementalDiscoveryData class) for putting 
            //updates into so we can submit them all at once.
            IncrementalDiscoveryData iddRelationshipsToAdd = new IncrementalDiscoveryData();
            
            //Get all the Windows computers in the system.  
            //This is not typical.  Just doing this for demo purposes only.
            IObjectReader<EnterpriseManagementObject> readerEmoWindowsComputers = 
                emg.EntityObjects.GetObjectReader<EnterpriseManagementObject>(classWindowsComputer,ObjectQueryOptions.Default);
            foreach (EnterpriseManagementObject emoWindowsComputer in readerEmoWindowsComputers)
            {
                CreatableEnterpriseManagementRelationshipObject cemroAffectedConfigurationItem = 
new CreatableEnterpriseManagementRelationshipObject(emg, relAffectedConfigurationItem);
                //Set the source and target...
                cemroAffectedConfigurationItem.SetSource(emoIncident);
                cemroAffectedConfigurationItem.SetTarget(emoWindowsComputer);
                //Add it to the bucket...
                iddRelationshipsToAdd.Add(cemroAffectedConfigurationItem);
            }

            //And submit...
            iddRelationshipsToAdd.Overwrite(emg);
            Console.WriteLine("Relationships created.");

            
            //======================================================
            //Example #4 - Getting type projection objects and iterating through them
            //======================================================
            Console.WriteLine("Getting incidents and showing the users computers that are affected by them...");
            
            //Getting incidents and then list the computers and users they are affecting
            //System.WorkItem.Incident.ProjectionType
            ManagementPackTypeProjection mptpIncident = 
                emg.EntityTypes.GetTypeProjection(new Guid("285CB0A2-F276-BCCB-563E-BB721DF7CDEC")); 
            ObjectProjectionCriteria opcIncident = new ObjectProjectionCriteria(mptpIncident);
            IObjectProjectionReader<EnterpriseManagementObject> oprIncidents = 
                emg.EntityObjects.GetObjectProjectionReader<EnterpriseManagementObject>(opcIncident, ObjectQueryOptions.Default);
            foreach (EnterpriseManagementObjectProjection emopIncident in oprIncidents)
            {
                if (emopIncident[relIncidentAffectedUser.Target].Count > 0)
                {
                    //Show the affected user
                    Console.WriteLine(emopIncident.Object.DisplayName);
                }
                foreach (IComposableProjection icpAffectedConfigurationItem in emopIncident[relAffectedConfigurationItem.Target])
                {
                    //Show each of the affected configuration items
                    Console.WriteLine("\t" + icpAffectedConfigurationItem.Object.DisplayName);
                }
            }

            Console.WriteLine("Done showing incidents with related users and computers.");
            
            
            //======================================================
            //Example #5 - Creating objects and relationships at the same time via type projection
            //======================================================
            Console.WriteLine("Creating an incident and its relationships via a type projection...");
            //First create the seed object
            EnterpriseManagementObjectProjection emopIncidentToCreate = new EnterpriseManagementObjectProjection(emg, classIncident);

            //Just using this for testing.  Obviously using a GUID for a incidnet display name is not a good idea...
 Visual Studio Project
            String strIncidentName = Guid.NewGuid().ToString(); 
            //Set some properties on the object
            emopIncidentToCreate.Object[classIncident, "DisplayName"].Value = strIncidentName;
            emopIncidentToCreate.Object[classIncident, "Title"].Value = strIncidentName;
            emopIncidentToCreate.Object[classIncident, "Impact"].Value = enumImpactMedium;
            emopIncidentToCreate.Object[classIncident, "Urgency"].Value = enumUrgencyMedium;

            //Then relate it to other objects as needed
            IObjectReader<EnterpriseManagementObject> readerUsers = 
                emg.EntityObjects.GetObjectReader<EnterpriseManagementObject>(classUser, ObjectQueryOptions.Default);
            
            foreach (EnterpriseManagementObject emoUser in readerUsers )
            {
                emopIncidentToCreate.Add(emoUser,relAffectedConfigurationItem.Target);
            }

            //And submit...
            emopIncidentToCreate.Overwrite();
           
            Console.WriteLine("Incident and relationships created...");
            
            
            //======================================================
            //Example #6 - Updating objects and relationships at the same time via type projection
            //======================================================
            Console.WriteLine("Updating an incident and its relationships at the same time via a type projection...");
            //First get the EnterpriseManagmentObjectProjection
            IObjectProjectionReader<EnterpriseManagementObject> oprIncidentsToUpdate = 
                emg.EntityObjects.GetObjectProjectionReader<EnterpriseManagementObject>(opcIncident, ObjectQueryOptions.Default);
            foreach (EnterpriseManagementObjectProjection emopIncident in oprIncidentsToUpdate)
            {
                //Update a property
                emopIncident.Object[classIncident, "DisplayName"].Value = 
                    emopIncident.Object[classIncident, "DisplayName"].Value + " - Updated";
                //Remove a relationship
                foreach (IComposableProjection icpAffectedUser in emopIncident[relIncidentAffectedUser.Target])
                {
                    icpAffectedUser.Remove();
                }
                //Add a relationship
                //Just getting the first user here as an example
                EnterpriseManagementObject emoUserToAdd = 
                    emg.EntityObjects.GetObjectReader<EnterpriseManagementObject>(classUser,ObjectQueryOptions.Default).ElementAt(0); 
                emopIncident.Add(emoUserToAdd, relIncidentAffectedUser.Target);
            }
        }
    }
}

The TechNet forum community for Service Manager has grown substantially large now that we should add some topic-specific forums to make it easier to post issues and find problems. The following new forums have been added in addition to the existing General forum. The forum owner PM is indicated.

You can get to an index of all of the SCSM forums here:

http://social.technet.microsoft.com/Forums/en-US/category/servicemanager

o Service Manager - General (Travis Wright)

General discussion group for Service Manager.

o Setup (Darko Vukovic)

This forum can be used to discuss any issues related to planning a Service Manager deployment, installing or configuring prerequisite software or hardware, installing the product, or upgrade.

o Customization Using the SDK and Authoring Tool (Paul Chen)

This forum is for discussing how to extend or customize Service Manager using the SDK or Authoring Tool.

o Data Warehouse, Reporting and Dashboards (Chris Lauren)

This forum covers topics related to the data warehouse, ETL, MP Sync, reporting infrastructure, reports, creating custom reports, and the dashboard.

o ITIL and MOF Processes - Incident, Problem, Change Management (Ketan Ghelani)

Use this forum to discuss how to configure and use any of the ITIL/MOF solutions provided out of the box such as Incident, Problem, or Change Management.

o Administration (User Roles, Notifications, Workflows, etc.) (Travis Wright)

This forum is for all things related to administering the product. This includes anything you could find in the Administration portion of the console, backups, restores, disaster recovery, and other admin topics.

o System Center Integration, Opalis, and Connectors (Marc Umeno)

This forum is for System Center Operations Manager, System Center Configuration Manager, and Active Directory connectors. This forum can also be used to discuss CSV import, using the Opalis integration pack for Service Manager or how to create custom connectors.

o Documentation (Steve Moore)

This forum is to capture any feedback about the official Service Manager product documentation found on TechNet.

o Portals (Darko Vukovic)

This forum can be used to discuss configuring or using any of the portals provided in Service Manager such as the end user self-service portal or the analyst portal.

Please start using the new forums right away. If you are unsure about which forum to post in, please use the General forum. Thanks for the great participation so far!

Tip – if you want to search all of the SCSM forums you can do so by pulling down the drop down menu next to the search bar:

Many people working with the System Center product suite have most likely read one of the “Unleashed” books. In many forums they have been described as a very valuable technical resource. We are pleased to announce there will be a new Unleashed book for Service Manager 2010!

Service Manager, the long-awaited major component of Microsoft’s System Center suite, addresses the "Supporting" quadrant of the MOF process model.  System Center Service Manager 2010 Unleashed will provide in-depth reference and technical information about Microsoft System Center Service Manager 2010, as well as information on other products and technologies on which its features and components are dependent.

The content uses an end-to-end feature implementation perspective, facilitating more optimized deployments by covering related topics in a stepwise order for a given feature area. The book begins with an overview, moves into planning, design, and implementation, and then covers the most important and significant feature sets of the product - of interest to SCSM administrators worldwide.

Authors are Kerrie Meyler, Alexandre Verkinderen, Anders Bengtsson, David Pultorak, and Patrik Sundqvist. Also contributing are Travis Wright, Kurt Van Hoecke, and Maarten Goet.

Here are some of the topics we plan to cover:

· Service Manager Basics

· Service Manager 2010 Overview

· MOF & ITIL  (Why You Care)

· Looking Inside Service Manager

· Designing Service Manager

· Planning Complex Configurations

· Installing Service Manager 2010

· Using the Service Manager Console

· Connecting to Operations Manager, Configuration Manager, and Active Directory

· Business Services

· Incident Management

· Problem Management

· Change Management

· IT Management - Governance, Risk Management, and Compliance

· Using the Self-Service Portal

· Notification

· Service Manager and Security

· Backup, Recovery, and Maintenance

· Customization Planning

· Customizing Workflows and Management Packs

· Reports, Dashboards, and Data Analysis

· Customizing the Data Warehouse and Reporting

· Service Manager and the Managed Service Provider

· Partner Solutions

Service Manager 2010 Unleashed will be published by Sams Publishing, joining the existing System Center series with Unleashed books on Operations Manager and Configuration Manager. The book will incorporate Service Manager 2010 SP1 as well as enhancements in an anticipated R2 release in 2011.

So – I learned a cool new trick today – how to set the title bar of a form window using XAML and so I thought I would share.  Remember the Service Request project that we created awhile back?  Well – In that original version the title bar would say ‘Form Host’ since I hadn’t done anything to set it:

Now, by adding the bit of XAML below the title bar will read “<Work Item ID> : <Work Item Title>” like this:

The title bar will reflect any changes to the title property as the property is changed.

This is the bit of XAML that needed to be added to the form immediately after the opening <UserControl> element and the before the opening <Grid> element:

<scwpf:BusinessLogic.Rules>
        <scwpf:RuleCollection>
            <!-- Set Window Title -->
            <scwpf:Rule>
                <scwpf:Rule.Triggers>
                    <scwpf:PropertyChangedTrigger Binding="{Binding RelativeSource={x:Static RelativeSource.Self}, Path=DataContext}"/>
                    <scwpf:RoutedEventTrigger RoutedEvent="FrameworkElement.Loaded"/>
                    <scwpf:PropertyChangedTrigger Binding="{Binding Path=Title}"/>
                    <scwpf:PropertyChangedTrigger Binding="{Binding Path=Id}"/>
                </scwpf:Rule.Triggers>
                <scwpf:Rule.Conditions>
                    <scwpf:PropertyMatchCondition Binding="{Binding RelativeSource={x:Static RelativeSource.Self}, Path=DataContext}" Operation="NotEquals">
                        <scwpf:PropertyMatchCondition.Value>
                            <x:Null/>
                        </scwpf:PropertyMatchCondition.Value>
                    </scwpf:PropertyMatchCondition>
                    <scwpf:PropertyMatchCondition Binding="{Binding RelativeSource={x:Static RelativeSource.Self}, Path=IsLoaded}">
                        <scwpf:PropertyMatchCondition.Value>
                            <sys:Boolean>True</sys:Boolean>
                        </scwpf:PropertyMatchCondition.Value>
                    </scwpf:PropertyMatchCondition>
                </scwpf:Rule.Conditions>
                <scwpf:ModifyPropertyAction Binding="{Binding RelativeSource={x:Static RelativeSource.Self},
                                                              Path=(views:FormView.WindowTitle),
                                                              Mode=TwoWay}">
                    <scwpf:ModifyPropertyAction.ValueBinding>
                        <MultiBinding Mode="OneWay">
                            <MultiBinding.Converter>
                                <scwpf:FormatterConverter>{0}: {1}</scwpf:FormatterConverter>
                            </MultiBinding.Converter>
                            <Binding Path="Id" Mode="OneWay" FallbackValue="[New Service Request]"/>
                            <Binding Path="Title" Mode="OneWay" FallbackValue=""/>
                        </MultiBinding>
                    </scwpf:ModifyPropertyAction.ValueBinding>
                </scwpf:ModifyPropertyAction>
            </scwpf:Rule>
        </scwpf:RuleCollection>
    </scwpf:BusinessLogic.Rules>

The trigger part tells the form to evaluate the business rule on initial load of the form and anytime the title or ID properties change.  The Conditions indicate that this should only be run when the form has a DataContext and that it is completely loaded.  The ModifyPropertyAction specifies the logic to set the title bar property.  Notice how the Path points to view:FormView:WindowTitle.  That’s the trick to set the title bar.  In this case you could put any kind of XAML inside of the .ValueBinding element.  In this case I used a MultiBinding element and a FormatterConverter to put the Title and ID together separated by a colon.

This update has been checked into the CodePlex project if you want to download it and take a look at it:

http://scsmservicerequest.codeplex.com ChangeList 78032

Someone on one of our internal discussion groups this morning asked how they could update AD when a User object is updated in the Service Manager CMDB.  The scenario was that the customer knew the data in AD for people’s phone numbers was out of date.  So – they wanted to use the service desk staff to get it up to date.  Each time a user called in for service they will ask the user to verify their phone number or provide a new one.  In this case they were planning to manually run a SQL query in the CMDB to get all the new phone numbers once per day and then update them in AD (again, I presume manually). 

There are two problems with this approach:

• Why do this manually when it can be easily automated and done in real time using a tiny bit of PowerShell in a workflow in SCSM that is triggered as soon as the property value changes?
• The AD connector runs 1x/hour.  If you enter the new phone number in the Service Manager CMDB, within the hour it will be overwritten by the old number from AD the next time the AD connector runs.  You need to correct it in the source ASAP.

So – here’s a quick video on how to set something like this up.  This is really just a small example of what you could do with AD or any other PowerShell accessible system like Exchange, Windows Server, VMM, SCOM, SCSM, VMWare, DPM, IIS, SQL, Hyper-V, ….

Try running this full screen in HD for full effect!

Seven Winds, a long time System Center partner from the Netherlands, has recently released their Call Script Manager solution for System Center Service Manager!  This solution provides a key solution for improving the quality of incident management by creating call scripts for service desk analysts to follow for common types of calls.  It can walk the analyst through a series of questions, help him find relevant knowledge and other incidents in context, capture the users’ responses, and log everything automatically along the way.

Here’s a demo video (watch it in 720p HD full screen for the full effect):

There’s also a Visio-style workflow designer tool for creating call scripts that can then be utilized by the call script wizard.

Here is the product information page:

http://www.managementpacks.nl/products/seven-winds-call-script-manager

Here’s a whitepaper on the solution:

http://www.managementpacks.nl/pdf/20100926_Whitepaper_Call_Script_Manager_English.pdf

Go here to request a free trial version:

http://www.managementpacks.nl/login.htm?return_url=%2Fdownload_center.htm 

Nice work guys!  This is going to be a great tool for customers!

One of our ISV partners, Cased Dimensions, has recently released a new Service Manager management pack solution for service level agreement management.  This management pack is easy to deploy and all configuration is done in the SCSM console.  The solution allows you to define groups of configuration items, create support schedules (including the ability to specify business hours, exclude holidays, etc.) and define SLA and OLA targets for service levels like time to respond and time to fix.  You can do this for any kind of work item – incident, problem, or change.  Then you can associate support schedules and SLAs to the groups of configuration items.  You can also define escalation and notification rules for when SLAs are breached or about to be breached. 

You can get more information about this solution, download the white paper. and view three different demo videos by registering on the Cased Dimensions site here:

http://www.caseddimensions.com/system_center_videos/

Note: After registration/login, click on the Resources menu bar option to get to the white paper.

A couple of other important things to note:

• Cased Dimensions has a free 30 day evaluation version that you can install to try it out.
• They are working on some more features around this solution which will be available to customers as a free upgrade when it becomes available.

I’m really looking forward to pointing customers to this solution as a way to help improve service levels by measuring actual results vs. service level agreements!  This solution is a great example of the power of the Service Manager platform since it all runs entirely on Service Manager – no separate server installation or databases are required.  It is tightly integrated with the solutions that Microsoft provides out of the box like incident, problem, and change management.  The Power is in the Integration!

As a follow up to this previous blog post/video, below is a link to a short white paper which describes how MPSD deployed Service Manager to manage their 5,000 servers using incident and change management.  MPSD is the operations team at Microsoft that runs Microsoft.com, MSDN, TechNet, and other large online properties you all use every day (including this blog! ).

Here’s the link to the new whitepaper:

http://technet.microsoft.com/en-us/library/gg281359.aspx

And I’ve embedded the video again below for easy access:

Sorry I haven’t been blogging in a while. I’ve been a whirlwind tour around South Africa and Europe for the last three weeks presenting about Service Manager in one forum or another essentially every day.  It’s been exciting but hasn’t left a lot of time for blogging.

I just needed to write some code today and had this question come up from our internal distribution list so I thought I would take a minute to answer it.  The question was how to create a new change request (or any object really) from a template programmatically.

Here you go:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.EnterpriseManagement;
using Microsoft.EnterpriseManagement.Common;
using Microsoft.EnterpriseManagement.Configuration;



namespace ApplyTemplate
{
    class Program
    {
        static void Main(string[] args)
        {
            EnterpriseManagementGroup emg = new EnterpriseManagementGroup("localhost");

            //You'll need to get the ObjectTemplateId GUID from the database after you have created it.  You can find it on the ObjectTemplate table by running a query like this:
            /*
             select MP.MPName,OT.* from ObjectTemplate as OT, ManagementPack as MP order by MP.MPName, OT.ObjectTemplateName 
             */
            ManagementPackObjectTemplate mpt = emg.Templates.GetObjectTemplate(new Guid("8B1AA102-F8A5-07D0-FC9A-2DB2A4FD5003"));  // <-- TODO: YOU'LL NEED TO REPLACE THIS GUID - SEE ABOVE

            //This is how you apply a template to a new object projection you want to create:
            EnterpriseManagementObjectProjection emop = new EnterpriseManagementObjectProjection(emg, mpt);
            emop.Overwrite();

            //This is how you apply a class-targeted template to an object.
            /*
            ManagementPackClass classChangeRequest = emg.EntityTypes.GetClass(new Guid("E6C9CF6E-D7FE-1B5D-216C-C3F5D2C7670C"));
            CreatableEnterpriseManagementObject cemo = new CreatableEnterpriseManagementObject(emg, classChangeRequest);
            cemo.ApplyTemplate(mpt);
            cemo.Commit();
            */
        }
    }
}

You can also call the .ApplyTemplate() method on a EnterpriseManaegmentObject or a EnterpriseManagementObjectProjection to update an object/projection that already exists.

The source code is attached in a Visual Studio application.

Jim Pitts and I presented a session at Tech Ed Europe 2010 last week on how to use Service Manager and Opalis together to automate the process of provisioning VMs.  The session was the #4 rated session for the entire event last time I checked.  Apparently people really like this integration and the power of Opalis + SCSM (because a score that high is certainly not reflective of our presentation skills! )!  Since it was such a hit we decided to record it again and post it here on the blog so everybody could see it.

In this demo we show how you can automate the provisioning of Virtual Machines using Service Manager to control the automated part of the process and using Opalis to do the automated provisioning of the VMs via SCVMM.  This pattern of creating automation can be repeated over an over to automate all kinds of other things like:

• User provisioning/de-provisioning
• VM moves
• VM clones
• New VMs
• Start/Stop VMs
• Software distribution via SCCM
• Maintenance Windows with SCOM
• and on and on….

The pattern is this:

1. Create a new automated activity work item class in the SCSM data model using the SCSM Authoring Tool.  Derive this new class from the ‘Activity’ class so that it can be included in the Change Request process as an activity.
2. Define the properties you need to have the user input information for that will be used by the workflow activities (either SCSM workflow or Opalis workflows).
3. Optionally, create a custom form in the Authoring Tool to make data input easier.  You can also skip this step and just use the generic form.
4. Import the MP into SCSM.
5. Create a new template (or templates) for your new automated activity work items.
6. Create new change request templates that use the new automated activity work item templates you created in step #5.
7. Author your Opalis workflow by using a monitor activity to look for objects of your new automated activity work item class to have their status updated to ‘In Progress’.
8. Author the rest of the Opalis workflow as needed to automate things.  Use the properties on the new custom automated activity work item class as inputs to the workflow activities so that the user input can be used to do exactly what the user wants.
9. When the automation is done successfully change the status of the activity work item in SCSM to ‘Completed’ so the next activity (if any) in the change request process can start.

Here’s the demo video:

Customizing Service Manager and Opalis from Adam Hall on Vimeo.

Note: there is even a (intentional ?) chance to see how to debug a workflow when there is a mistake in the workflow.

Enjoy!

P.S. – check out Ander’s recent blog post on SCSM + Opalis to automate the creation of new users in AD:

http://contoso.se/blog/?p=1945 

Huge thanks to Adam Hall and Sean Christensen for taking the time to capture this demo video again and encode and post it for us!

Opalis 6.3 is going to RTM in the next couple of weeks!!!  Are you ready to automate your data center AND have process control!!?