Richard Willis

It’s that time of year again when Olympia opens its doors to the world of IT in Education and BETT begins. I’ll be there on Wednesday, Thursday and Friday and would love to meet as many of your as possible, whether you are customers, SLK users or just vaguely interested in what we do. Again I’ll be spending most of my time looking at the stands, so if you want to meet we can either arrange a date and time or you can just give me a call when you are free – although judging from past years it’s not always possible to hear my phone at BETT. Failing that, I’ll probably spend some time at the LP+ stand (E46 in the Main Hall), currently I’m planning to be there 1400-1445 every day. I also expect I’ll be hanging around the Microsoft stand as well as I know quite a few of the guys on there.

I’ve finally released SLK 1.4 to Beta. Sorry about the delay, but in the end I’ve rewritten the drop box functionality to hopefully work seamlessly within SharePoint. To do this I knew I needed to make changes to how the drop box library was created which would be incompatible and so decided to hold back on officially releasing it.

You can download from the release page on CodePlex.

It is not backwards compatible with the version uploaded to the patches folder, so any documents returned by that will not be available via this version. The documents will still be present though.

The major changes compared to the version in the patches folder are:

1. Students can open office documents and save them straight back to SharePoint without having to save to disk first.
2. Teachers can open and comment on office documents without having to save to disk first.
3. The drop box library is created as required. You do not have to enable the SLK feature on the site to create it.
4. Although folders are still used as containers to hold student’s work (as the document names are likely to be the same), they are not used to navigate the assignments. You either use the default view which is grouped by assignment or use assignment specific views which are created when an assignment is created.
5. You can use the drop box in a locale which doesn’t use US style dates.
6. I’ve currently removed the download all and upload all files options for teachers so that I can get the release out. I just haven’t had time to complete this.
7. I’ve removed Course Manager from the install. This will again be available as a separate release. The reason is that the quality is still not there for it to be bundled.

I will consider this version to be in beta until 24 Jan at the latest. At which point there will be another beta version with at a minimum the download all and upload all functionality in, or a final release. Please download and report any bugs, which I will attempt to resolve quickly. I am keen to get 1.4 RTM so we can move on to the next version and get the project moving again.

Note, I still need to update the documentation to cover this release, this may take some time. If anyone would like to volunteer to do this it would be really helpful. I’m also considering moving it to the wiki pages on CodePlex rather than just having the getting started pdf as it will be easier to maintain and distribute. Does anyone have any thoughts on this?

I’ve just updated the Salamander DataViewer web part to support connections to other web parts which provide an IWebPartField connection.

I’ve also updated the User Search and My Children web parts, part of our MIS Web Parts solution, to provide an IWebPartField connection. Here’s a screen shot of a simple connection where My Children is linked to the DataViewer.

This is likely going to be most useful for linking to external systems holding information about your pupils and staff.

I recently had a requirement to set the owners of users home directories on a Windows server. The .Net framework has built-in support for this so it simply looked like a case of doing this:

IdentityReference owner = new NTAccount("MYDOMAIN\\MyUser");
DirectoryInfo directory = new DirectoryInfo("c:\\myDirectory");
DirectorySecurity directorySecurity = directory.GetAccessControl();
directorySecurity.SetOwner(owner);
directory.SetAccessControl(directorySecurity);

However, when I tried this I just got an InvalidOperationException with the message "The security identifier is not allowed to be the owner of this object".

It turns out that the reason for this is that normally you are only allowed to take ownership yourself, and not assign it. For a user to take ownership they must either have been given the Take Ownership permission or be an administrator.

There is one exception to this rule, and that is if the user has the Restore files and directories privilege then they can assign ownership to other users. Now administrators have this privilege, but by default it is disabled. More details on this from Microsoft.

So to set the owner of the file, you need to have the Restore Files and Directories privilege and then enable it before setting the owner. Really we should also disable the privilege when we’ve finished using it as well.

Unfortunately .Net doesn’t have built in support for this yet, so we are reduced to PInvoking native methods and here’s the code:

sealed class UnmanagedCode
{
    [DllImport("kernel32.dll", SetLastError=true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    static extern bool CloseHandle(IntPtr hObject);

    // Use this signature if you do not want the previous state
    [DllImport("advapi32.dll", SetLastError=true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    static extern bool AdjustTokenPrivileges(IntPtr tokenHandle,
        [MarshalAs(UnmanagedType.Bool)]bool disableAllPrivileges,
        ref TOKEN_PRIVILEGES newState,
        UInt32 bufferLength,
        IntPtr previousState,
        IntPtr returnLength);

    [DllImport("kernel32.dll", ExactSpelling = true)]
    static extern IntPtr GetCurrentProcess();

    [DllImport("advapi32.dll", ExactSpelling = true, SetLastError = true)]
    static extern bool OpenProcessToken
        (IntPtr processHandle, int desiredAccess, ref IntPtr phtok);

    [DllImport("advapi32.dll", SetLastError = true)]
    static extern bool LookupPrivilegeValue
            (string host, string name, ref LUID lpLuid);

    [StructLayout(LayoutKind.Sequential, Pack = 1)]
    struct TOKEN_PRIVILEGES
    {
        public UInt32 PrivilegeCount;
        public LUID Luid;
        public UInt32 Attributes;
    }

    [StructLayout(LayoutKind.Sequential)]
    public struct LUID
    {
       public uint LowPart;
       public int HighPart;
    }

    const int SE_PRIVILEGE_ENABLED = 0x00000002;
    const int TOKEN_QUERY = 0x00000008;
    const int TOKEN_ADJUST_PRIVILEGES = 0x00000020;
    //http://msdn.microsoft.com/en-us/library/bb530716(VS.85).aspx
    const string SE_RESTORE_PRIVILEGE = "SeRestorePrivilege"; 

    public static void GiveRestorePrivilege()
    {
        TOKEN_PRIVILEGES tokenPrivileges;
        tokenPrivileges.PrivilegeCount = 1;
        tokenPrivileges.Luid = new LUID();
        tokenPrivileges.Attributes = SE_PRIVILEGE_ENABLED;

        IntPtr tokenHandle = RetrieveProcessToken();

        try
        {
            bool success = LookupPrivilegeValue
                        (null, SE_RESTORE_PRIVILEGE, ref tokenPrivileges.Luid);
            if (success == false)
            {
                int lastError = Marshal.GetLastWin32Error();
                throw new Exception(
                    string.Format("Could not find privilege {0}. Error {1}",
                                        SE_RESTORE_PRIVILEGE, lastError));
            }

            success = AdjustTokenPrivileges(
                                                tokenHandle, false,
                                                ref tokenPrivileges, 0,
                                                IntPtr.Zero, IntPtr.Zero);
            if (success == false)
            {
                int lastError = Marshal.GetLastWin32Error();
                throw new Exception(
                    string.Format("Could not assign privilege {0}. Error {1}",
                                    SE_RESTORE_PRIVILEGE, lastError));
            }
        }
        finally
        {
            CloseHandle(tokenHandle);
        }

    }

    static IntPtr RetrieveProcessToken()
    {
        IntPtr processHandle = GetCurrentProcess();
        IntPtr tokenHandle = IntPtr.Zero;
        bool success = OpenProcessToken(processHandle,
                                        TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
                                        ref tokenHandle);
        if (success == false)
        {
            int lastError = Marshal.GetLastWin32Error();
            throw new Exception(
                string.Format("Could not retrieve process token. Error {0}",
                                    lastError));
        }
        return tokenHandle;
    }
}

To remove the privilege you will just need to replace SE_PRIVILEGE_ENABLED with the disabled value. In my use I’m just setting the owner and finishing the process so it’s not really required.

One of our latest products interacts with a Restful web service. As this is the core part of its functionality as part of Test Driven Development and Unit Testing I needed to be able to test the calls to the web service using HttpWebRequest.

A quick Google didn’t come up with anything so I started looking at the best way to mock the calls. My initial thought was to extract all use of HttpWebRequest into a separate class, define an interface for setting the request and getting the response and use Dependency Injection to determine whether to use the ‘normal’ class or a mock.

Then I looked a bit closer at WebRequest.Create which is the method you use to create a HttpWebRequest. I noticed that it uses a Factory Method so you could actually register your own factory object depending on the url used. So without any extra code required in the class under test, you can register your factory object and the .Net Framework will automatically use your mocks or stubs. This is pretty cool.

To take advantage of this you need to implement the IWebRequestCreate interface on your factory object, and then register your factory object with WebRequest.RegisterPrefix. What you do in the Create method is up to you, but I created a simple WebRequest and WebResponse pair which store the request for you to test the input, and which returns a configurable response.

First an example of how you can use these:

string response = "my response string here";
WebRequest.RegisterPrefix("test", new TestWebRequestCreate());
TestWebRequest request = TestWebRequestCreate.CreateTestRequest(response);

string url = "test://MyUrl";

ObjectUnderTest myObject = new ObjectUnderTest();
myObject.Url = url;
// DoStuff call the url with a request and then processes the
// response as set above
myObject.DoStuff();

string requestContent = request.ContentAsString();
Assert.AreEqual(expectedRequestContent, requestContent);

The code for these 3 objects is:

/// <summary>A web request creator for unit testing.</summary>
class TestWebRequestCreate : IWebRequestCreate
{
    static WebRequest nextRequest;
    static object lockObject = new object();

    static public WebRequest NextRequest
    {
        get { return nextRequest ;}
        set
        {
            lock (lockObject)
            {
                nextRequest = value;
            }
        }
    }

    /// <summary>See <see cref="IWebRequestCreate.Create"/>.</summary>
    public WebRequest Create(Uri uri)
    {
        return nextRequest;
    }

    /// <summary>Utility method for creating a TestWebRequest and setting
    /// it to be the next WebRequest to use.</summary>
    /// <param name="response">The response the TestWebRequest will return.</param>
    public static TestWebRequest CreateTestRequest(string response)
    {
        TestWebRequest request = new TestWebRequest(response);
        NextRequest = request;
        return request;
    }
}

class TestWebRequest : WebRequest
{
    MemoryStream requestStream = new MemoryStream();
    MemoryStream responseStream;

    public override string Method { get; set; }
    public override string ContentType { get; set; }
    public override long ContentLength { get; set; }

    /// <summary>Initializes a new instance of <see cref="TestWebRequest"/>
    /// with the response to return.</summary>
    public TestWebRequest(string response)
    {
        responseStream = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(response));
    }

    /// <summary>Returns the request contents as a string.</summary>
    public string ContentAsString()
    {
        return System.Text.Encoding.UTF8.GetString(requestStream.ToArray());
    }

    /// <summary>See <see cref="WebRequest.GetRequestStream"/>.</summary>
    public override Stream GetRequestStream()
    {
        return requestStream;
    }

    /// <summary>See <see cref="WebRequest.GetResponse"/>.</summary>
    public override WebResponse GetResponse()
    {
        return new TestWebReponse(responseStream);
    }
}

class TestWebReponse : WebResponse
{
    Stream responseStream;

    /// <summary>Initializes a new instance of <see cref="TestWebReponse"/>
    /// with the response stream to return.</summary>
    public TestWebReponse(Stream responseStream)
    {
        this.responseStream = responseStream;
    }

    /// <summary>See <see cref="WebResponse.GetResponseStream"/>.</summary>
    public override Stream GetResponseStream()
    {
        return responseStream;
    }
}

This is quite a simple implementation, just to check the request and return a known response. Once you’ve got this working, you can obviously do more tests such as simulating error conditions.

I’m pleased to announce that we’ve got a new product in our line-up, Salamander MoodleRooms. This allows integration between School Management Systems and the MoodleRooms hosted Moodle solution.

So whether you are using Sims, Facility CMIS, Integris, Phoenix or any of the other main systems, we can now automatically maintain users and courses in your hosted Moodle as they change in your MIS.

On a technical level, we using MoodleRooms’ system integration tool (UIB) over https to send the changes up to MoodleRooms.

I often ftp files up to our web server so I can access them while on client machines. Up until now I’ve been using FireFtp a Firefox extension, which works great as an FTP client. However, I’d been getting annoyed by it for 2 reasons:

1. Not being able to use keyboard shortcuts as it was hosted in a browser
2. Not being able to use the Favourite links set up in explorer. About 90% of what I upload would be available in one-click from there.

So I started looking for an alternative client. What if found was even better. You can add a network location in Windows Explorer which is an ftp location and can then drag and drop files completely within Explorer.

To set it up all you need to do is select Computer in the folder view, then right click in the details pane and select "Add Network Location" and follow the wizard.

I imagine it’s present in other versions of Windows, but I’ve only tested it in Vista.

While debugging the issue in my last post, the customer pointed out the the owner of uploaded documents and created folders wasn’t being set as expected i.e. as the user logged SharePoint.

This was the result of overcoming the double-hop problem – one option is to access the file system as the SharePoint app pool, or the user defined in a configuration file. In these cases, it was this user who was set as the owner of the object. I’ve now fixed this so the owner will be the user logged into SharePoint.

I actually released a German version of My Documents a while back after a customer request. I just spent some time with them debugging an issue where files and folders weren’t getting saved. I tracked the issue down to a date time localisation issue. To check if the file/folder is present I’m using File.GetCreationTime because when impersonating a user File.Exists always returned true. GetCreationTime returns a "zero" date time if the file doesn’t exist, however it returns it in local time so when I was comparing against a manually created DateTime object it was always greater than it. Once I realised what was wrong it was easy to check properly.

Now that I’ve localised the web part once, all I need for other locales is a translation of the messages within the application, which makes it easy to get ready for other locales.

I’m a big user of Test Driven Development (TDD) using it in most of my projects. One of the leading proponents of TDD, Roy Osherove, is running a masterclass on TDD in London in September. It would be well worth going if you are interested in starting TDD and can persuade the budget holder to pay.

Quoting from the bbits blog:

Roy Osherove is giving an hands-on TDD Masterclass in the UK, September 21-25. Roy is author of "The Art of Unit Testing" (http://www.artofunittesting.com/), a leading tdd & unit testing book; he maintains a blog at http://iserializable.com (which amoung other things has critiqued tests written by Microsoft for asp.net MVC – check out the testreviews category) and has recently been on the Scott Hanselman podcast (http://bit.ly/psgYO) where he educated Scott on best practices in Unit Testing techniques. For a further insight into Roy’s style, be sure to also check out Roy’s talk at the recent Norwegian Developer’s Conference (http://bit.ly/NuJVa). 

Full Details here: http://bbits.co.uk/tddmasterclass

bbits are holding a raffle for a free ticket for the event. To be eligible to win the ticket (worth £2395!) you MUST paste this text, including all links, into your blog and email Ian@bbits.co.uk with the url to the blog entry.  The draw will be made on September 1st and the winner informed by email and on bbits.co.uk/blog