The CodePlex Corner: SUSHI

The link to the project is https://sushi.codeplex.com/

The project that this edition of the CodePlex Corner is going to look at has been part of the SharePoint community for quite a while. It goes by the name of Sushi (which stands for SharePoint Utility with a Smart, Helpful Interface) and was originally intended to be an administrative Swiss army knife for those that look after infrastructure. Sushi has been created by Joseph Fluckiger, a senior software architect at ThermoFisher, with additional SharePoint 2010 contributions being made by SharePoint MVP Ryan Hayes.

Sushi is a Windows form application that needs to be run from one of the SharePoint servers in order to work. It is available for SharePoint 2007 and 2010. There is no SharePoint 2013 version currently available. When you download and run Sushi from CodePlex, it does not install any DLLS, web parts or anything that can be considered invasive. However it does search for the appropriate hive folder for your version of SharePoint. It’s for this reason that Sushi cannot currently be run from a desktop client.

It has been built as a server client application for the following reasons: -

  1. Richer client interface, which is deemed easier to use than web parts
  2. The security reports feature (that reports on specific user rights) within Sushi does not hide anything from the person generating the report. This is something that you might not want all users to have access to
  3. It was felt that more functionality was available by creating the tool as a windows form application rather than via web parts and layouts pages

Historically, Sushi popped up on the SharePoint stage back in the SharePoint 2007 era with a number of handy utilities and functions that stsadm just couldn’t provide. The introduction of PowerShell support from SharePoint 2010 onwards has lessened the usefulness of Sushi slightly but it hasn’t eliminated it entirely. It is still a valuable tool for active SharePoint 2007 deployments and a handy addition for SP2010 administrators who have limited PowerShell knowledge. Sushi has enough literature of its own to guide a user through what it does but for the sake of convenience its current features are document below. The following table provides a snapshot view of what Sushi provides: -

Category

Actions & Notes

Administration

  • User Security Reports: View all sites / lists a user can access
  • Profile Images Import: Upload profile images and apply them to User Profiles
  • Site Backup: Backup a site
  • Site Restore: Restore a site
  • Email Test: Send a test email to make sure that outbound email is correctly set-up

List / Library Management

  • Copy View: Copy view from one list to another
  • Metadata: Get detailed information about metadata in a list. Move metadata from one column to another for all items in a list
  • Bulk List Creation: Create a large number of lists based on a template
  • Bulk Site Columns: Create site columns
  • Import Documents: Upload file structures from a file share or source folder into a SharePoint document library
  • Delete Old Documents: Copy documents older than a specified date into an archive folder and then delete from SharePoint

Site Management

  • Bulk Site Creation: Bulk-create sites based on a site template
  • Bulk Apply Themes: Apply a theme to many sites at once

 

This is a screenshot of the Sushi interface once it has been downloaded and started. The options detailed in the table above are present on the left hand side of the application with the main window available for interacting with each feature.


Something that needs to be reconciled is how old Sushi is and the fact that there are now other facilities available that may compete with it. With the stsadm utility is a deprecated utility and that many SharePoint technical staff are becoming fluent in PowerShell it would be prudent to review each of the features that Sushi offers against modern day alternatives. The table below is provided for illustration and to help users decide which features may be of use to them.

Action

Notes

Alternatives

User Security Reports

This feature allows the administrator to display which sites and lists/libraries a user has access to within a site collection. It also allows an administrator to view which AD groups an account is part of.

SP Admin toolkit and PowerShell scripts are free utilities but these are not as easy to use.

 

SPFarmReport, is a CodePlex alternative that allows you to generate holistic reports for all uses

Profile Images Import

A very useful feature that is limited by the need for an image name to match an account name. Some characters are also hardcoded.

PowerShell can be used for SharePoint 2010 deployments that have image present in AD and kb2394320 installed. Script and instructions detailed here.

 

PowerShell can also be used to upload the images to a SharePoint 2010 library and alter the –PictureUrl parameter. Script and instructions detailed here.

Site Backup

The Sushi back-up facility is a wrapper for stsadm functionality. Its time r functionality plugs into the Windows Task Scheduler

PowerShell commands for back-up / restore and export / import for SharePoint 2010 deployments. These provide more functionality.

 

Very good utility for SharePoint 2007 deployments still

Site Restore

The Sushi restore facility is a wrapper for stsadm functionality. Its time r functionality plugs into the Windows Task Scheduler

PowerShell commands for back-up / restore and export / import for SharePoint 2010 deployments are best suited for these tasks.

 

Very good utility for SharePoint 2007 deployments still

Email Test

Very useful utility for both SharePoint 2010 and 2007. It still requires the SMTP settings to be configured but removes the need to create an alert manually. This feature is also useful for SharePoint migrations into 2007 / 2010

Matthew Yarlett has discovered and documented a mock SMTP solution in CodePlex .

 

The link to the smtp4dev facility is https://smtp4dev.codeplex.com/

Copy View

Incredibly useful feature and no other facility exists that allows easy replication of views from one list to another.

 

This only works within a single site level.

Nothing else exists that can do this for either SharePoint 2007 or SharePoint 2010

Metadata

This facility allows provides bulk and easy editing for metadata within a list / library. A tutorial for this has been written here.

Very useful for both SharePoint 2007 and 2010. Sushi provides more flexibility than the datasheet view and removes the need to filter and interact with data

Bulk List Creation

Quick and easy facility for bulk list creation. Limited to single site level

PowerShell is an alternative but the complexity of the sort of scripts needed for this needs some familiarity with PowerShell

Bulk Site Columns

Quick and easy facility for the creation of site columns in bulk.

PowerShell is an alternative but the complexity of the sort of scripts needed for this needs some familiarity with PowerShell

Import Documents

With this feature, Sushi allows you to import a directory tree into SharePoint. It’ll remove illegal characters for you too.

 

This usability of this feature is determined by how you approach metadata. If you use the term store or columns instead of folders, than this may not be as useful

  1. Metalogix Content Matrix is an commercial alternative
  2. DocAve File System Migrator is a commercial alternative
  3. Vyapin Document Import Kit is a commercial alternative
  4. SharePoint 2010 Bulk Uploader is a CodePlex alternative

Delete Old Documents

Another potentially useful, Sushi allows you to archive files from a SharePoint library onto the desktop / servers. It is an on demand facility that does not provide the ability to schedule when archiving is done.

This can be achieved with PowerShell as documented here.

 

OOB functionality that can do this is Information Rights Policy.

Bulk Site Creation

Useful site that creates sub-sites swiftly. It accepts copy / paste parameters from the clip board that you may have prepared with an Excel spread sheet

PowerShell will also allow you to achieve this but it would be tricky

Bulk Apply Themes

This allows you to apply sites to a site and its subsites.

PowerShell will also allow you to achieve this but it would be tricky

 

Link to SharePointReviews.com product review

Currently there is no product review for Sushi on SharePointReviews.com

“End User – Developer” scale

Sushi sits comfortably on the administration spoke of the End User à Developer scale. It has some tools that could be useful to power users but the need to run this from any of the SharePoint servers means is a potential security risk. Therefore, those that will be using Sushi are more than likely going to be experienced, technical staff.

Potential pitfalls / problems

The following points are ones that should be taken into account whilst using the application:

  1. The utility has to be run from a SharePoint server and has no client version
  2. The profile images import hardcodes a backslash character before the username and does not allow you to specify mappable attributes. The image name must match a profile name
  3. The import document function has hardcoded file types that it blocks rather than relying on those specified in the S
  4. The back-up / restore stsadm commands are still subject to stsadm size limitations

Tutorial

A Sushi tutorial is being written and will be linked from this article shortly. This tutorial only covers the features of Sushi that cannot easily be recreated. These are: -

  1. Security Reports
  2. Email Test
  3. Copy View
  4. Meta Data
  5. Delete Old Documents

Conclusion and relevant links

Sushi, despite being one of the elder statesmen of the CodePlex SharePoint project community, is still worth a place in an administrator’s arsenal. The niche that it occupies has shrunk a little, mostly due to the addition of PowerShell support to SharePoint but the attention and care that was originally put into the application has made it very resilient to the aging process. Whilst a few features such as the back-up / restore tools are somewhat redundant almost everything else is still useful. In the long run however, unless the tool is upgraded for the SharePoint 2013 / Office 365 era its scope of usefulness will eventually diminish.

The links below are my reference list: -

  1. Sushi Project Site on CodePlex
  2. Joseph Fluckinger Blog
  3. Ryan Hayes Blog
  4. Patric Luka’s Metadata tutorial for metadata
  5. Matthew Yarlett’s smtp4dev TechNet article
  6. Roger Cormier’s Bulk Download Script

Yammer Chat Emoticons

Posted: March 26, 2014 in Yammer
Tags:

Like many in SharePoint land, I’m in the midst of getting to grips with Yammer and the various challenges in getting it rolled out to the business. A colleague of mine at Live Nation was having a poke around and came up with these. I don’t recall seeing these anywhere in the Yammer documentation I’ve come across thus far, so I thought I’d put these out there for general consideration

Emoticon

Meaning

Icon

(I)

Lightbulb

:$
:-#

sealed lips

:| :-|

straight face / indecision

:-P 
:P

cheeky / playful

*-)

 

;-) 

;)

wink

:-O 
:O

:o

surprise / shock

:-)
:)

smile

<3

heart

:^)

 

:-D 
:D

very happy

:[

bat

:-( 
:(

unhappy

:@

angry

:’(

crying

     

 

Credit for documenting these goes to Phil Quinn

As most of you will know, there are two basic types of workflow in SharePoint. Some workflows are authored in SharePoint Designer whilst others are created within Visual Studio. This article is aimed at those who author workflows in SPD.

Each time a new workflow is published within SPD, a new instance is added. What this means is that each time a workflow is published, it overwrites a previous version. If an administrator were to check the active workflows, they’d see a history that looks like this

I don’t believe that there is any performance overhead for having these historical workflows listed but wouldn’t it be nice to have a way to remove these. This article is going to show you how.

  1. Download this PowerShell Script from the TechNet Gallery. Download it somewhere that is easy to find, such as C:/Scripts
  2. Right Click on the script and select Open
  3. Look for the following variables and change them as requird
    1. $web: Include the URL of your Site
    2. $listToCancel: Use the display name of the list / library that has the workflow versions you want to delete
    3. $wfToKeep: Use the name of the Workflow to be pruned
  4. Save and close the script
  5. Right click and select Run with PowerShell. Click Yes to the script. You’ll see this as the script has been downloaded from TechNet rather than written locally

  1. Once the script has run, return to your workflow history page. You should see only one version of the workflow as below

Caveats

Please be mindful of any workflow instances that may still be in operation. The script won’t be too choosy in what it removes.

Credits

Thanks to Matthew Yarlett for looking over this script for me.

Recently I was able to present for the first ever time at a UK SharePoint User Group, more specifically I was able to present as part of the line-up for the Southampton User Group.

And I have to admit that it was a lot of fun. Having being a long term TechNet junkie, the idea of getting in front of anyone, least of all a room of informed and knowledgeable peers was somewhat intimidating. But thanks Ian Woodgate (@ianwoodgate) of PointBeyond, who also doubles up as the gang leader for the SharePoint User Group South, I was able to give it a go.

My topic of choice was CodePlex and some of the wonders that it contains. I firmly believe in the value of community and as collaboration professionals that trade in a collaborative platform / currency, it stands to reason that there’s a lot we can learn from CodePlex. This is both from a soft skills, networking and technological perspective. For instance, I’ve met a few talented and gifted individuals looking at the projects that I have.

Talking about this, plus how some of the general Open Source vs Commercial lines of thinking can apply to SharePoint add-ons was also a part of my presentation. I probably could have explored a lot more in-depth than I discussed at Southampton last night but hopefully some thoughts were triggered.

And one question from Ian Chivers already has me thinking about Open Source communities. I’d not given much thought to that community but it definitely worth considering.

Overall, I believe that both the CodePlex / Open Source work plus my own presentation style and ability can only improve from here onwards.

So, with that being said, here’s a link to the presentation itself. I’ll gloss out my presentation notes into something more presentable and will get these upload soon.

Something that SharePoint professionals occasionally get asked is whether it is possible to update a parent folder when child documents within it have been altered. Whilst my first response is to encourage the use of metadata and flatter file structures, it’s fair to assume that this isn’t always achievable. Some teams and personnel are comfortable with folders and don’t see a reason to change.

This blog post shows how you would achieve this using Documents Sets and SharePoint Designer. Document Sets are a bit more flexible than folders. As such this approach doesn’t lend itself well to existing folder structures: -

  1. Create a Site Column called DocSetName. Make it a Single line of text data type
  2. Create a LastModified column. Make it a Date/Time data type
  3. In the document library, where you want to make these changes, activate the management of content types via Document Library Settings à Advanced Settings à Content Types
  4. Click “Add from existing site content types” and add the Document Sets
  5. In the content type section, click on Document Set à Add from existing site or list columns and add DocSetName and LastModified
  6. Next (still within the Document Set Content Type Settings) click on Document Set Settings and scroll down to Shared Columns. Select DocSetName
  7. Next, within SharePoint Designer, create a new workflow at the document library level
  8. Set this workflow to automatically start when an item is created or changed. Using the Update List Item (update item in current list) action set the “LastModified” column to the current document item “Modified” column value. What this means is that any new document “Modified” column will be update the LastModified field of its parent Document Set.
  9. Back in your library, create a view that sorts by LastModified (descending) and you’ll see that the Document Set with the most recently edited item will be on top

The caveat

There is one trade off to getting this working and it’s this. Any new items created within a Document Set MUST have the name of the Document Set manually entered into the DocSetName column. If this isn’t done than the workflow will error out. The reasoning behind this is explained below.

What does the workflow do?

This idea is that each Document Set shares the DocSetName column value with any document contained within it. As set up in step 3 any document that gets created or get modified will trigger the workflow. The workflow effectively goes to find the item whose “Name” column value is equal to current document item “DocSetName” column value. Subsequently it will always find the parent Document Set item and update its “LastModified” column with the current document modified date.

This means that each document set “LastModified” value is always going to be equal to the modified time of one of the child documents within it. Without the DocSetName column on the document level being manually filled, the workflow cannot make the association and will return an error.

That about covers it but let me know if you have any questions, suggestions and so on.

This year was the first year that I’ve taken part in Chris Given‘s ForumJam. I’d not heard of it before and only came across it via my (criminally underused) Twitter feed. Looking at some of the names that were going to enter it, I didn’t think I was in with a chance of getting in the upper ranks

But throwing caution to the wind I decided to enter, I thought it might be fun.

At the end of the two month period of the ForumJam I found myself in third place behind Trevor Seward (@NaupliusTrevor) and Amit Vasu (@AmitVasu) in the standings. I was lucky to claim the position I did in the end as Dimitri Ayrapetov(@dayrapetov) pushed me all the way. Despite being a member of the community for a fair while, this was pretty much the biggest event that I’d entered.

Chris has already outlined some of the advantages from an organiser’s perspective and some of these ring true from a participant’s perspective too. Namely: -

  • Networking & Education: I have my areas of familiarity and experience with the product, as does everyone else. Watching the others at the top of the leader board tackle and answer questions that I was quite honestly clueless on is quite rewarding. I’ve got some new blogs. Feeds and fellow professionals to follow and discuss things with.
  • Sets a new benchmark for personal performance: Hitting up on Chris’ theme of inspiring people to get involved, my time participating set some all high benchmarks for my own performance. When I joined the forums and started collaborating and offering help, the points system hadn’t even been implemented! Looking at my current trajectory, I’ve set my two best months ever (in terms of answers and accumulated points).

I’m rather pleased with my performance in my first ever FoumJam and more so for the people I’ve met. As for the eventual prize, I’m hoping I can blow it on Infamous Second Son

Here’s to the next ForumJam!

This CodePlex Corner tutorial is going to be a little different than those for the previous CodePlex products. This article details how to use the JavaScript Editor for SharePoint (JEFS) to create a simple application / page that pulls down some movie information from the movies database Rotten Tomatoes. The technologies that we will be using are: -

  1. The Rotten Tomatoes API
  2. JQuery
  3. JavaScript
  4. JSRender
  5. HTML

The tutorial itself will go through several stages. These are: -

  1. Installing & activating JEFS
  2. Pulling code together with JEFS

Installing & activating JEFS

JEFS is installed as a sandbox solution to your SharePoint sites. As a sandbox solution, it can be deployed by your site collection administrator. JEFS Codeplex page provides a PowerShell Script that will install the solution for you. Both the WSP and the script can be accessed below:-

  1. Installing JEFS as a sandbox solution (Link to CodePlex Page)

Create the Web Part Page

In this part of the tutorial, you will be guided on setting up the native SharePoint elements needed for the solution. Additionally a key for using the Rotten Tomatoes API will also need to be set-up

  1. Create a blank web part page using the Header, Footer, 3 Columns template and save it within a library. Call it Top 10 movies
  2. Register for a Rotten Tomatoes API. Be mindful of the following
    1. URL for the application (this can later be edited)

Edit the Web page

  1. Open up the Top 10 Movies page that was created in the previous section if it is not already open
  2. Click on Site Actions à Edit Page. This will load the page in editing mode
  3. On the far right of this ribbon, click on the JavaScript Editor button
  4. This will reload the page with the JEFS Editor. The panel on the left hand side is the one that accepts JavaScript. The panel on the right hand side is where library references, HTML and CSS are placed
  5. In the panel in the left hand side, paste the following JavaScript code. You will need to replace the <<YourAPICodeHere> with your own API reference in the apikey variable. Part of what this code does is to perform a JQuery asynchronous AJAX HTTP call to the rotten tomatoes web service via the getMovies function

     

// rotten tomatoes variables

var apikey =
“<<YourAPICodeHere>>”;

var baseUrl =
http://api.rottentomatoes.com/api/public/v1.0&#8243;;

 

var moviesSearchUrl = baseUrl +
‘/lists/movies/box_office.json?apikey=’
+ apikey;

 

// This code runs when the DOM is ready.

$(document).ready(function
()
{

getMovies();

});

 

// This function gets the movies

function getMovies()
{

 

$.ajax({url: moviesSearchUrl,

dataType:
“jsonp”,

success: searchCallback});

}

 

// callback for when we get back the results

function searchCallback(data)
{

$(“#movieContainer”).html($(“#movieTemplate”).render(data.movies));

}

 

  1. Next you are going to insert the HTML that will render the page. In the right hand panel there are several drop-down boxes
  2. In the one called view select the HTML view
  3. Paste in the following code. This code is doing several things. Firstly, the page header using the Rotten Tomatoes header is being linked directly from their own servers. A technology called JSRender is being used to build out the page structure (more information on this here). JsRender is a JavaScript library that allows you to define a boilerplate structure once and reuse it to generate HTML dynamically. The JavaScript snippet created earlier in the tutorial includes a searchCallback function that renders the content ofdata.movies object into the moveTemplate template and the movieContainer div.

<div
				class="intro">
				


				<img
				src="http://images.rottentomatoescdn.com/images/logos/rtlogo.png?v=20130916"/>
				


				<p><h1>Top 10 Movies</h1></p>
				


				<p>Powered by <a
				href="www.rottentomatoes.com">www.rottentomatoes.com</a></p>
				

</div>
				

 

<div
				id="movieContainer">
				

 

</div>
				

 

<script
				id="movieTemplate"
				type="text/x-jsrender">
				


				<div class="movie">
				


				<div class="movieIntro">
				


				<div class="movieTitle"><a href="{{:links.alternate}}">{{:title}}</a></div>
				


				<div>Critics
				Ratings:
				{{:ratings.critics_score}}
				/
				100</div>              

    </div>
				


				<div class="movieDetails">
				


				<p class="movieImage"><img src="{{:posters.detailed}}"/></p>
				


				<p class="movieSynopsis">{{:synopsis}}</p>
				


				<p class="moreInfo"><a href="{{:links.alternate}}">Read
				More</a></p>
				


				</div>

  </div>
				

</script>

 

  1. With both JavaScript and HTML in place it is now time to add the library references that this code relies upon to work
  2. Within JEFS, on the right hand side , change the View drop down to LIB
  3. This will load a window where any JavaScript references needed for solutions should be pasted. In this box paste the following code. These are online references to both JQuery and JSRender. Please note that JSRender JavaScript has no dependency on jQuery and the order of these library references can be changed if desired.

<script
				class="jefs"
				type="text/javascript"
				src="http://ajax.aspnetcdn.com/ajax/jQuery/jquery-1.7.1.js"></script>
				

 

<script
				class="jefs"
				type="text/javascript"
				src="http://www.jsviews.com/download/jsrender.js"></script>

 

  1. With the JavaScript library references that are in place, all that is needed is to add the CSS that will style the page
  2. In JEFS on the right hand side change the view drop down to CSS
  3. Paste in the following code

.partBody

{
				

    margin:
				0;
				

    padding:
				0;
				

    border:
				0;
				

}
				

 

.partDiv

{
				

    margin:
				0;
				

    padding:
				0;
				

    border:
				0;
				

    position: relative;
				

    width:
				300px;
				

    height:
				200px;
				

    background-color:
				#0000FF;
				

    font-family:
				'Segoe UI',
				Arial,
				Helvetica, sans-serif;
				

    color:
				#FFFFFF;
				

    font-size:
				14pt;
				

}
				

 

.partContent

{
				

    position: absolute;
				

    top:
				5px;
				

    left:
				5px;
				

}
				

 

.movie {
				

    border:1px;
				

    clear:both;
				

    border-style: solid;
				

    padding-bottom:20px;
				

    margin-bottom:10px;
				

    width:auto;
				

    height:320px
				!important;
				

}
				

 

.movieIntro {
				

    margin-left:
				10px;
				

    position:relative;
				

}
				

.movieImage {
				


				float:left;
				

    margin-top:10px;
				

    margin-left:
				10px;
				

    width:auto;
				

}
				

 

.movieSynopsis {
				

    width:auto;
				

    font-size:large;
				

    margin-left:
				200px; margin-top:
				5px;
				

}
				

 

.movieTitle {
				

    margin-top:10px;
				

    font-weight: bold;
				

    height:
				20px;
				

    position:relative;
				

}
				

 

.moreInfo{
				

    width:auto;
				

    margin-left:
				200px;
				

    font-size: large;
				

    margin-top:
				-10px;
				

}
				

 

.spacer {
				

    clear:both;
				

}

 

  1. After the CSS has been pasted in, look at the Save & Close button on the top left corner of JEFS
  2. Clicking on this will close JEFS and should load up a page that looks comparable to the one below