In Part 1 we looked at the basics of connecting to web service and retrieving the metadata. Part 2 looked at how to create a datasource first class object (FCO) and the quirks of the "well known" properties (thanks to Wade Dorrell for the feedback and for raising a usability bug for the next version). In this post we'll look at how to create one of the other FCO's - in this case a report though as you can imagine the process for creating a KPI (the other "singular" FCO) is similar.
Once again, its not too hard to work out that we'll need to use the CreateReportView function and as before we'll create a ReportView object in our code that will get passed to the function once we've set up all the properties.
private static PPSM.ReportView CreateReport(PPSM.PmService mon)
{
//declare our reportview object
PPSM.ReportView rep = new PPSM.ReportView();
//set the guid for our object - this gets used as the primary key in the db table
rep.Guid = System.Guid.NewGuid();
We know how to set the "well known" properties from part 2 and it's exactly the same process here (including the identifier) so it makes sense to create a re-usable function to do this for all our FCO's
private static PPSM.BpmProperty[] SetWellKnownProperties(string name, string description, string owner)
{
//declare the three individual property types for the property array
PPSM.BpmPropertyText bpmName = new PPSM.BpmPropertyText();
PPSM.BpmPropertyLongText bpmDesc = new PPSM.BpmPropertyLongText();
PPSM.BpmPropertyUser bpmOwner = new PPSM.BpmPropertyUser();
//set some details for the properties
bpmName.Text = name;
bpmDesc.Text = description;
bpmOwner.Login = owner;
//initialise the properties array
PPSM.BpmProperty[] wkprop = new PPSM.BpmProperty[3];
//set the properties array with the three elements
wkprop[0] = bpmName;
wkprop[1] = bpmDesc;
wkprop[2] = bpmOwner;
//declate a GUID and set the unique id of each property
wkprop[0].UniqueName = "8dd07d4d87794510afdb1f07664359bc_Element_Name";
wkprop[1].UniqueName = "8dd07d4d87794510afdb1f07664359bc_Element_Description";
wkprop[2].UniqueName = "8dd07d4d87794510afdb1f07664359bc_Element_Owner";
return wkprop;
}
Lets call the function and also set the type of report (in our case an Olap Grid). All good so far....
//set the well known properties
rep.Properties = SetWellKnownProperties("My Report", "My Rep Desc", "Me");
//set the type
rep.TypeName = "OLAPGrid";
There are a couple more obvious properties that can be set (e.g. begin points and end points) but from here things get more complicated. The majority of the important properties are stored in a single XML property of the ReportView object called CustomData. This means that you'll have create and manipulate an xml document in your code that matches exactly the format required.
In practical use this may preclude using purely the web service to create FCOs completely from scratch. As an alternative workaround you could start from a template report stored on the server and then use and update the custom data property from that template. In reality of course you are unlikely to be automating the creation of reports completely from scratch - much more likely to just be updating the report datasource for example. Just for the sake of proving the concept, this is what we'll do in our case.
The other workaround is to code against the object model in Microsoft.PerformancePoint.Scorecards.Client.dll rather than the WSDL of the web service. This exposes the properties more clearly and is, as I understand, what happens behind the scenes in Dashboard Designer. IMHO this slightly defeats the object of a web service but I'm sure this will be rectified going forward.
As we've already gone through the process of creating a new reportview object we'll carry on down that path for this example. Of course it might be simpler in reality to grab an existing reportview object using GetReportView and simply change the required properties and assign a new guid. You use the CreateReportView function regardless of whether you are creating or updating - the existence of the object's guid in the underlying database table will define which happens.
This function returns the customdata for an object
private static string GetCustomData(PPSM.PmService mon, string ReportID)
{
Guid g = new Guid(ReportID);
PPSM.ReportView rep = mon.GetReportView(g);
return rep.CustomData;
}
Next we need to declare an XMLDocument to store the customdata and call our function passing in the Guid of a known report. I'm sure there are much cleaner ways to work with XML objects but it's Friday night!!
//declare an xmldoc to hold the customdata
XmlDocument custData = new XmlDocument();
//you'll need to find the id of a similar type report from your PPS Monitoring database
//load the custom data from ana existing report into an xmldocument
custData.LoadXml(GetCustomData(mon, "d8c5ffbd-c01c-409f-ab1b-d0695227049b"));
Now obviously using the GUI of Dashboard designer it's easy too grab the data source by name. In code you would need to come up with a clever way of doing this or just work with knowing the guid of the datasources you want to use for the report. It's possible that you may have just created or updated a datasource as part of your application.
//update the datasource elements of the customdata - quick and dirty hack!
custData.DocumentElement["QueryData"].ChildNodes[1].InnerText = "3da20613-0a02-4e6f-ad17-6a42ec4d6b62";
custData.DocumentElement["QueryState"].ChildNodes[2].InnerText = "3da20613-0a02-4e6f-ad17-6a42ec4d6b62";
//and now lets pass the edited customdata to our new reportview object
rep.CustomData = custData.InnerXml.ToString();
Finally pass to the web service
//finally lets pass our modified reportview object to the webservice
mon.CreateReportView(rep);
Updated project is on the download site as usual and includes an example of the customdata xml for a reportview object. Thanks as usual to Wade, Alyson and Tim at MS for taking the time to answer my DFQs!
Here's a quick one for creating an end date column when you only have an effective date column in your data source to work with. The secret is to join the table to itself with a greater than join on the effective date. You then use the effective date from your joined table to give you your end date.
SELECT
DT1.AccountID
,DT1.EffectiveDate
--Add a default end date for current record and subtract a day so the end date is one day before the next start date
,ISNULL(DATEADD(d,-1, DT2.EffectiveDate), '31/12/2099') AS EndDate
,DT1.Price
FROM
dbo.PriceTable AS DT2
RIGHT OUTER JOIN
dbo.PriceTable AS DT1
DT2.AccountID = DT1.AccountID
AND
DT2.EffectiveDate > DT1.EffectiveDate
Following on from Sacha's post re Adatis achieving MS Gold partnership I just wanted to:
a) blow our own trumpet a little bit more ;-); and
b) add my thanks to our customers, partners and especially the awesome Adatis team who have worked their a*ses off to make this possible!
Whilst Gold partnership isn't perhaps the rarest thing these days it's still a big deal for a small company like ourselves to achieve it.
I'll go now before I do a Gwyneth....sniffle...
In my last post we looked at the basics of connecting to the web service and using some simple functions to retrieve some metadata. Those of you who downloaded the sample project would have spotted that I added some functionality to retrieve all the annotations for a given scorecard - something we've been asked for by a number of clients. This time we'll look a little deeper and look at how we could automate production of the FCOs (First Class Objects) within PPSM.
The process of building a dashboard in code is in essence just as you would do it in Dashboard Designer. Remember when you are using Dashboard Designer it's actually making calls to the web service behind the scenes - no dll's involved. If you use a tool such as Fiddler2 you can see exactly what is getting passed in the calls.
So first we need to create a data source. Once again our friendly PPSM dev team have named the functions just as you would expect so no prizes for guessing we need to use the CreateDataSource function. You then need to create a datasource object in your code which is passed to that function. This is fairly straight-forward in that you set the attributes of the data source object you've created and give it a unique ID (GUID). The usual apologies for the state of my code!
private void CreatePPSDS(PPSM.PmService mon)
{
//declare the datasource
PPSM.DataSource ds = new PPSM.DataSource();
//set the attributes of the data source
ds.SourceName = "ADOMD.NET";
ds.ServerName = "Localhost";
ds.DatabaseName = "Adventure Works DW Standard Edition";
ds.CubeName = "Adventure Works";
ds.CubeDisplayName = "Adventure Works";
//give the data source a GUID
ds.Guid = System.Guid.NewGuid();
The first quirk is that the data source name, owner and description aren't directly exposed on the DataSource object but in a BpmProperty array called Properties so first you need to declare each element individually so you can set it's individual properties; Name is a BpmPropertyText, Description is a BpmPropertyLongText and Owner is a BpmPropertyUser. This properties array is common to all FCO's (and in fact inherited from the base Element Object) so this will be the same method we use for Data Sources, Scorecards, Dashboards etc.
//declare the three individual property types for the property array
PPSM.BpmPropertyText dsName = new PPSM.BpmPropertyText();
PPSM.BpmPropertyLongText dsDesc = new PPSM.BpmPropertyLongText();
PPSM.BpmPropertyUser dsOwner = new PPSM.BpmPropertyUser();
//set some details for the properties
dsName.DisplayName = "Name";
dsName.Description = "Name Description";
dsName.Text = "A data source name";
dsName.Visible = true;
dsDesc.Text = "MyDataSourceDescription";
dsOwner.Login = "TCK";
Next we have to initialise the Properties array on the DataSource object itself so we can assign the individual properties we declared earlier to the elements within it. And here comes the next quirk - and I'll unashamedly admit that this one had me completely foxed! Each element of the DataSource properties array requires a uniquename, and not just any unique name but a very specific one - 8dd07d4d87794510afdb1f07664359bc. Without this your data source will be created but won't have a name, description or owner! Thanks to Alyson Powell Erwin of the PPSM Team for solving this one for me :)
//initialise the properties array of the data source
ds.Properties = new PPSM.BpmProperty[3];
//set the properties array with the three elements
ds.Properties[0] = dsName;
ds.Properties[1] = dsDesc;
ds.Properties[2] = dsOwner;
//declare a GUID and set the unique id of each property
ds.Properties[0].UniqueName = "8dd07d4d87794510afdb1f07664359bc_Element_Name";
ds.Properties[1].UniqueName = "8dd07d4d87794510afdb1f07664359bc_Element_Description";
ds.Properties[2].UniqueName = "8dd07d4d87794510afdb1f07664359bc_Element_Owner";
Note the "_Element_..." on the end of the UniqueName - this is also mandatory. That's all the quirks now :)
Next we can add members to our roles if required. These are stored in the Memberships array of the DataSource
//initialise the Memberships array
ds.Memberships = new PPSM.Membership[1];
//for each membership you want to add you then need to initialise the element of the array
ds.Memberships[0] = new PPSM.Membership();
//then set the properties (note the control backslash in the login name)
ds.Memberships[0].Login = "Domain\\login";
ds.Memberships[0].Role = "Editor";
Finally call the CreateDataSource method passing your DataSource object of the web service and your work here is done!
//finally pass to the web service call
mon.CreateDataSource(ds);
If you need to update the data source then you retrieve the data source using GetDataSource, update the properties as before and then pass the object the CreateDataSource function. This automatically deals with versioning.
The sample project is here (you'll need to login and don't forget to open as a web site rather than a project in VS)
Next time we'll look at how to create one of the other 1st class objects using our data source.
I was a little surprised to see that (as of June 2008) there are already 329 people certified in PerformancePoint (i.e. have passed the 70-556 exam) and whilst it's not the hardest exam (IMO compared to 445 and 446) it's a good sign that PPS uptake is getting stronger and stronger.
Mind you most of the 329 probably work for CapGemini who should have had 3000 consultants trained in PPS by the end of 2007!! Amazing ;)
Thanks to all of you who take the time to leave comments on our blogs - it's always good to know that people are actually reading :)
Unfortunately for every one genuine comment we get hundreds of spam comments so we've decided to make it a requirement to sign in to add a comment. Please be assured that any information you provide will be used for nothing other than managing your logins. The first time you leave a comment after signing in we will need to approve your account but after that your comments should appear automatically. Please drop us a mail (blogs (at) adatis.co.uk) if you have any issues.
Thanks
Tim
Don't tell MSFT I said this but this is really quite cool:
http://code.google.com/apis/chart/
The Google charts API allows you to create charts as a web page by simply setting the querystring:
http://chart.apis.google.com/chart?chs=400x200&chd=t:50,10,20,20&cht=p3&chl=Bully|Jezza|Sach|Tim&chtt=Who+ate+all+the+pies
If you use it in conjunction with a simple web page that is picking up the parameters from a PPSM filter (like Nick B has created here) you've got some instant functionality - e.g. display the country/state you've filtered on. Here, I've taken Nick's example and built the response.redirect statement to include the country code from a tabular data source based on the parameter selected:
Taking it a step further you could create a custom report type using the SDK for PPSM that connects to one of the built in data sources and prepares a querystring.
The main drawback is of course that you need an Internet connection to display the charts. Another drawback is that there is a limit to length of a querystring so thousands of data points is not possible (nor should it be allowed in charts!!) but other than that this a definitely a short-term solution to some of the <whispers!> shortcomings of the built-in PPSM V1 chart.
Sample Code and BSWX
This will be cross posted all over the place but Service Pack 1 has now been released! Details from the PPS Technet Forum:
PerformancePoint Server 2007 Service Pack 1 (x86): http://www.microsoft.com/downloads/details.aspx?FamilyId=28B1F86B-B7F2-4215-8BC9-8F8507FF8831&displaylang=en
PerformancePoint Server 2007 Service Pack 1 (x64): http://www.microsoft.com/downloads/details.aspx?FamilyId=6245C354-9191-4C4D-8C0C-C10D6C778AF8&displaylang=en
PerformancePoint Server 2007 Evaluation Version (x86): http://www.microsoft.com/downloads/details.aspx?FamilyId=6372C24F-67DD-42DD-B034-748907B23420&displaylang=en
PerformancePoint Server 2007 Evaluation Version (x64): http://www.microsoft.com/downloads/details.aspx?FamilyId=3ADAC793-DEF0-4BA8-A9AB-228979B8DB40&displaylang=en
What’s New for PerformancePoint Planning Server SP1
· Windows Server 2008 Support
· Add-in for Excel Performance Improvements – The Performance of opening reports and opening and refreshing workflow assignments is improved significantly.
· Add-in for Excel offers a new workbook option Clear Changes after workflow action – When you set this option to True, Add-in For Excel automatically clears any changes after the workflow action occurs when the form is used in an assignment. This improves performance of subsequent queries. However, if submission fails with this options set the user will be unable to resubmit the changes and the changes will be lost.
· Add-in for Excel offers a new workbook option Enable what-if analysis – When you set this option to True for a matrix, Add-in For Excel automatically performs what-if calculations that show the effect the change will have on an assignment if submitted. If False, no changes are applied to the matrix, this can help improve query performance.
· Annotations – Forms and Reports can now be created for models that have annotations disabled.)
· Workflow Assignments – Contributors can now use the discard action after submitting an assignment to clear the version of the form template they recently submitted allowing the most recently published version of the form template to be retrieved.
· User Dimension – Allows creation of dimension properties that link to the user dimension.
· Kerberos Support – The PPS Planning Service can now reside on the same IIS server as other IIS sites that also require Kerberos authentication.
· Data Import Wizard is decoupled from Microsoft Dynamics AX and works with any data provider – The data import wizard is now a generic data integration wizard that allows customers and partners to develop their own data providers to integrate source financial data. The PerformancePoint Server Data Integration Toolkit, provided by Microsoft, is a companion tool that provides a data integration framework. You can use this framework to create your own data providers. To obtain this toolkit, visit the following web site: http://go.microsoft.com/fwlink/?LinkId=117552&clcid=0x409
What you need to know about installing:
http://technet.microsoft.com/en-us/library/cc514367(TechNet.10).aspx
What’s New for PerformancePoint Monitoring Server SP1
· Microsoft Windows Server 2008 Support
· Default Display Conditions can be Created – It is now possible to add a default display condition report view (see related blog post also posted today)
· Multi-select Filter Enhancements – Multi-select Monitoring server filters now pass to multi-select SQL Server Reporting Services report parameters and Strategy Map views
· Time Intelligence Post Filter formula date corrections
o In some instances filters were passing a one day offset, this is resolved
o Date format of filter will now honor localized formats
· Negative numbers will not cause a text wrap in scorecards
· Dashboard filter performance improvements
· Expand/collapse functions work properly with hidden parent KPI members
· Tabular filter enhancements
· Limit of 1,000 characters in an MDX expression for KPIs has been removed
· No longer blocked from using SQL Server 2008 as a data source (NOTE: full support for 2008 is coming in SP2, we just won’t prevent you from running on it with SP1)
What you need to know about installing:
· The SP1 file MUST be installed on every PPS Monitoring Server in your environment
· The SP1 file MUST also be installed on every MOSS/WSS box that has the PPS Web Parts installed
· Dashboard designers should download the Dashboard Designer from the server again after the server has been upgraded
On a slightly similar note to the PPS Planning data migration tool recently released by Microsoft, Kevin Idzi (also MSFT) got in touch to let us know about project he has recently released on Codeplex for automating moving reports between servers/environments when using PerformancePoint, ProClarity Analytic Server or MOSS/SharePoint. Check it out here:
www.codeplex.com/bipublisher
I haven't had a chance to look at in any depth yet but first impressions look pretty impressive and it will certainly be useful to us!
Both the Planning and Monitoring components of PPS provide their functionality via web services. Martyn and I spent quite a while picking the planning web service apart for our web part. It was less than straight-forward as it uses the same method to carry out different functions with different objects. The Monitoring Web Service by comparison is much easier to decipher. You view the methods by entering the following in your web browser:
http://<yourmonitoringservername>:40000/WebService/PmService.asmx
Most of the things you can do in Dashboard Designer and SharePoint are included in the list which means the possibilities of what you can do programmatically are huge! On top of this there's also the Monitoring SDK which allows even further extensibility such as custom reports/data sources.
Over the next few weeks/months I'll be taking a look at the Monitoring web service in more detail and showing examples of what you can do with it. This week it's 101 - connect to the web service and list objects. And no comments on the quality of my code - it's been a while!
The first thing we need to is set up a visual studio project. This could be a web project, Windows form, web part etc. In this example we'll be creating a simple web page so are using a asp.net web site project. Next add a web reference to the Monitoring Web Service by right-clicking on your project in the solution explorer pane:
Enter the address of the web service as per above and give it a suitable reference name (in the examples below it's PPSM). To keep things simple I'm going to just add the code to the page load event of the default page. First we have to initialise the web service and pass it our credentials:
protected void Page_Load(object sender, EventArgs e)
{
//initialise the web service
PPSM.PmService mon = new PPSM.PmService();
//you could make the url of the web service configurable
//mon.Url = <your url>
//next we have to pass the logged on user credentials to make
//sure that we have permissions to make the web servoce calls
mon.Credentials = System.Net.CredentialCache.DefaultCredentials;From here we can now call the web service methods as required. First of all lets list the dashboards on our server and loop through them listing the name using the GetDashboards method. Note that we have to use a BpmPropertyText object to get to the dashboard title.
//now we simply use web service calls to get the objects
PPSM.Dashboard[] dash = mon.GetDashboards();
//loop through the dashboard array and print the title
for (int a = 1; a < dash.Length; a++)
{
//in this case we have to pass the title back in a BpmPropertyText object
PPSM.BpmPropertyText dashname = (PPSM.BpmPropertyText)dash[a].Properties[0];
Response.Write(dashname.Text);
}Lets do the same now with Scorecards using the (yep you guessed it) GetScorecards method:
//declare an array of scorecard objects and initialise using the
//get scorecards method
PPSM.Scorecard[] scd = mon.GetScorecards();
//loop through the scorecard array and print the title
for (int j = 1; j < scd.Length; j++)
{
//again we have to pass the title back in a BpmPropertyText object
PPSM.BpmPropertyText scdname = (PPSM.BpmPropertyText)scd[j].Properties[0];
Response.Write(scdname.Text);
}Next we can do some specific things with each of the scorecards in the array. In this case get all the KPI's associated with each scorecard using the GetKpisFromScorecard. This take an argument of the scorecard guid which we can get from the array elements in our previous call
//next we're going to get the kpi's for the current scorecard
PPSM.Kpi[] kpi = mon.GetKpisFromScorecard(scd[j].Guid);
Response.Write("<b>Kpis in " + scdname.Text + "</b>");
Response.Write("<br>");
for (int i = 1; i < kpi.Length; i++)
{
PPSM.BpmPropertyText kpiname = (PPSM.BpmPropertyText)kpi[i].Properties[0];
Response.Write(kpiname.Text);
}No need to clean up any connections - one of the perks of the web service (everything is returned as xml objects).
Pretty straightforward stuff really. Next time we'll look a bit deeper! I've attached the sample project here. It has a web reference to a localhost monitoring service so you'll need to update it if you're running the code against a remote server. There's no solution file as it's a web site project so you'll need to use the open web site option in VS.
As Adrian mentions there's a really good community starting to build around PerformancePoint and some excellent bloggers putting out some great posts. I'm sure those of you who have been on the PPS Planning forum will recognise Paul Steynberg's name and any of you who've read his posts will know that he seriously know his stuff, particularly from and finance and accounting perspective (and being able to apply that to IT/IS).
Paul has recently started his own blog and I've no doubt it will be well worth subscribing to:
http://paulsteynberg.blogspot.com/
Just a quick one tonight whilst I'm sat in Mcdonalds waiting for Breakdown Recovery :-( Obviously should have spent 50k on a successful man's car instead of my window cleaner's VW!
I recently had a requirement from a client who had a number of data-driven RS subscriptions; simple enough. However they wanted to only run the subscriptions on completion of their cube processing (which was controlled by an SSIS job). My solution (maybe not the most elegant but it worked for me) was to use the sp_Start_Job system stored procedure (MSDB).
As you may know whenever you set up a subscription in RS it creates a SQL Agent job to trigger the subscription. These jobs are given GUIDs as names which is less than helpful but you can work out which is your job by looking at the create date and the schedule you created for the subscription. Once you've found it you can re-name it with a more meaningful name and also delete the timed schedule as this is not required.
Next create a simple control table to hold the job names that you wish to trigger. Then create a simple SSIS Package that loops on the control table and use an Execute SQL task to run the sp_Start_Job stored procedure passing the job name as parameter
Finally add this package to your main batch processing package.
When I have a moment I'll upload the package. Be interested to hear from people who have done it differently...
PerformancePoint Monitoring has made it really easy to build and publish basic dashboards. However designing really great dashboards is something that very few people achieve. Despite my recent post on making your reports pretty, I'm not a fan of bells and whistles - in a pre-sales/sales situation they definitely have their place - but in a production dashboard it's hard to justify.
A dashboard needs to deliver the right information in an easy to read and and easy to interpret manner. Sounds simple right? IMO it's easier to come up with a bad dashboard than a good one but a good dashboard maybe harder to sell than a bad one particularly when the budget holder isn't going to be actually using it.
One of those that has mastered dashboard design is Stephen Few and I'm unashamedly going to crib from his excellent book "Information Dashboard Design - The Effective Visual Communication of Data" for this post. This is one of my favourite IT books and I urge anyone who works with any type of report to get a copy. It's got loads of examples of dashboards and makes it clear why each is good or bad. I guarantee you will design your dashboards differently after reading; use pie charts in your reports? You won't after reading this book!
Anyway this post isn't supposed to be a free ad for Stephen's book, it's meant to give a few simple tips on making your dashboards a little better so here goes:
Don't exceed a single screen - that bit of information that is off the bottom of the screen is less important, right? Wrong! You might even give the wrong message by leaving part of a report off the screen. Most dashboard tools make it easy to provide navigation to detail so think more about why you need to put the information together. And consider your layout - the brain naturally gives least attention to the bottom right area.
Don't overuse colour or decorate unnecessarily - My post about adding pretty borders to your reports is a great example of unnecessary use of decoration; What value does that border round the reports really add to the user-experience? It often distracts from the real information. Does a traffic-lighted map of the UK really add any value where a bar chart is much more readable? "Dude! - your dashboard looks like a real car dashboard! coooool". And Sacha will kill me for this but please - NO 3D charts!
Your company's logo here? errr No thanks :)
Too much or too little information- By nature a dashboard is a high-level overview - you really don't need sales figures to the penny. Consider also the context of the data you are presenting: actual sales for January may not be much use unless you can compare it to budget, forecast or previous information.
Use variety only when necessary - dashboard designers often feel compelled to use variety where variety isn't necessary - I'm definitely guilty of this one. It's not a crime to have your dashboard only use barchart and grids. Don't add a Radar chart just because it will add something different.
Highlight Important Data - sounds obvious but not always simple. You should be drawn straight away to the information that requires your attention the most. In the key figures area of the dashboard below you can see straight away that Late Arrivals has some issues. I particularly like the lack of a green icon against the other KPI's.
Of course there's so much more to it than these few points and in fact when you consider the complexity of human visual perception perhaps it's a wonder anyone can get it right!
So what does a great dashboard look like? Well everyone has their own tastes but compare the dashboard above with the one below and make your own decisions: one is simple, clean, readable and informative! In case you're wondering the lower dashboard was built using XLCubed.
I suspect most of you who read our blogs also subscribe to Adrian Downes' blog and will have already read that B-IQ Principal Consultant Nick Barclay has been awarded MVP SQL Server. What Adrian forgets to mention is that he has also been awarded the MVP!!
Both these guys have been at the forefront of pushing MS BI and in particular PerformancePoint to new levels - they are MVP's in the truest sense if the word.
Huge Congratulations from all of us Adatis!
Alyson Powell Erwin from the PPS Monitoring team did a great webcast yesterday on building advanced dashboards. If, like me, you were unable to watch it live you can view the recording here. This was actually the last of a series of PPS webcasts.
There's a bit of everything in this one so well worth a watch.
Alyson confirms in the presentation that SP1 is due for release in May and one of the fixes will be passing multi-value parameters to Reporting Services reports - yaayyyy! Unfortunately, from previous correspondence I've had with Alyson, cascading filters will not be making it. Fingers crossed for V2 as this has been an issue for a few of our clients.
More Posts
Next page »