This is a fairly common thing to come up against, and the easy solution is on the web, but it doesn’t appear to be in the nUnit help so I thought I’d put it here too, and make it specific to the dependency injection/Sharp Architecture web projects that my team use.

There are two things that you can do. The quick thing to do is to find your tests dll file. In a Sharp Architecture 1.6 project this will be in something like [project root]/tests/[namespace].Tests/bin/Debug. The dll file will be called (unsurprisingly) [namespace].Tests.dll.

You will see that nUnit has also created a [namespace].Tests.dll.config file. This is where you should put your application settings. When you open it up you can see that it looks similar to the web.config file – there is already an appsettings section. Simply copy your web.config settings to here.

That is all very well, but what if you want to mock different values of this app setting when you are testing? If you are using a dependency injection development pattern you might also want to consider having a separate class and interface that just handles the retrieval of application settings, e.g.

public class AppSettingsService: IAppSettingsService
{
        public string ManagerRole
        {
            get { 
              if (ConfigurationManager.ConnectionStrings["ManagerRole"] == null)
                 return "";
              else
                 return ConfigurationManager.ConnectionStrings["ManagerRole"].ToString();  
            } 
        }
}

You can then inject this service class into the class that you are testing, use the methods on this service class to retrieve your appsettings, and mock them to your heart’s content.

Note: I am assuming you know what dependency injection, mocking, interfaces etc are. If not I suggest searching the net – they are a very good way of developing!

To start with download the DotNetOpenAuth .Net library, put it in your solution’s main lib directory, and then add a reference to it in your Controllers project.

Then download the OpenId-Selector javascript library and add the script, css and images to your Web project.

Next copy the CASP class from JaSig’s site and put it in your ApplicationServices project with a class name of ‘CASService’. This class was written for Webforms rather than MVC, and as it stands is not really unit testable, but it gives a good start, I’ll leave it up to you if you want to refactor it, but I didn’t bother for this proof-of-concept. The only changes you need to make are to first remove the currentPage property and replace any references to it with HttpContext.Current. Replace the currentPage parameter in the constructor and Authenticate methods with ‘string ReturnURL’ instead. The main constructor should now look like this:

    public CASP(string baseCasUrl, string ReturnURL, bool alwaysRenew)
        {
            //if (currentPage == null)
            //    throw new ArgumentNullException("currentPage cannot be null");
            if (baseCasUrl == null)
                throw new ArgumentNullException("baseCasUrl cannot be null");

            this.baseCasUrl = baseCasUrl;
            //this.currentPage = currentPage;
            this.AlwaysRenew = alwaysRenew;
            ServiceUrl = HttpUtility.UrlEncode(HttpContext.Current.Request.Url.AbsoluteUri.Split('?')[0]+ "?ReturnUrl=" + ReturnURL);
        }

The authentication mode in web.config should be set to Forms, e.g.

<authentication mode="Forms">
        <forms loginUrl="~/Security/LogOn"  name="AuthCookie" timeout="60"/>
</authentication>

The first login page is basically just a method of selecting which authentication provider you want to use (note I’ve not styled this at all, just in case you were wondering ). I’m assuming here that you have developed your own master page and simple controller method to display this.

The master page should include these lines:

link href="<%= Url.Content("~/Content/openid-shadow.css") %>"
     rel="stylesheet" type="text/css" />
    <link href="<%= Url.Content("~/Content/openid.css")%>" 
     rel="stylesheet" type="text/css" />
    <script src="<%= Url.Content("~/Scripts/openid-en.js")%>" 
     type="text/javascript"></script>
    <script src="<%=Url.Content("~/Scripts/openid-jquery.js")%>" 
     type="text/javascript"></script>
    <script type="text/javascript">
        $(document).ready(function () {
            openid.init('openid_identifier');
        });
    </script>

And this is the login page:

<%@ Page Title="" Language="C#" MasterPageFile="~/Views/Shared/OpenId.Master" Inherits="System.Web.Mvc.ViewPage<IdeaFactory.ApplicationServices.ViewModels.LogOnViewModel>" %>

<asp:Content ID="Content1" ContentPlaceHolderID="MainContent" runat="server">
  <form action=
"CASAuthenticate?ReturnUrl=<%= HttpUtility.UrlEncode(Request.QueryString["ReturnUrl"]) %>"
 method="post" id="cas_form">

<div>
    
        <legend>Login using  CAS</legend>
        
        <div id="Div2">
            <img src='<%= Url.Content("~/Content/Images/cas.gif")%>' />
            <input type="submit" value="Log On" />
        </div>
       
        <div>
           
        </div>
   
</div>
</form>

<br /><br />

    <form action=
"Authenticate?ReturnUrl=<%= HttpUtility.UrlEncode(Request.QueryString["ReturnUrl"]) %>"
 method="post" id="openid_form">
<input type="hidden" name="action" value="verify" />
<div>
    
        <legend>Or login using OpenID</legend>
        <div class="openid_choice">
            <p>
                Please click your account provider:</p>
            <div id="openid_btns">
            </div>
        </div>
        <div id="openid_input_area">
            <%= Html.TextBox("openid_identifier") %>
            <input type="submit" value="Log On" />
        </div>
        <noscript>
            <p>
                OpenID is service that allows you to log-on to many different websites 
                using a single indentity. Find out <a href="http://openid.net/what/">
                 more about OpenID</a>and <a href="http://openid.net/get/">
                 how to get an OpenID enabled account</a>.</p>
        </noscript>
        <div>
           
        </div>
   
</div>
</form>
<br />

</asp:Content>

The LogInViewModel is simple, just enough to hold the OpenID returned by the javascript library:

 public class LogOnViewModel
    {
        public string openid_identifier { get; set; }
    }

Below are the raltively simple controller methods for authentication. Note that these have to be available as both HttpPost and HttpGet.

// Include these namespaces in your controller
using DotNetOpenAuth.Messaging;
using DotNetOpenAuth.OpenId;
using DotNetOpenAuth.OpenId.Extensions.SimpleRegistration;
using DotNetOpenAuth.OpenId.RelyingParty;
using DotNetOpenAuth.OpenId.Extensions.AttributeExchange;

       public ActionResult CASAuthenticate(LogOnViewModel model, string ReturnUrl)
        {
            
           

            // Simple call to authenticate CAS.
            string username = CASP.Authenticate("https://login.casserver.com/cas/", ReturnUrl, false, false);
           
            try
            {
                if (username != null)
                {
                    _formsService.SignIn(username, false);



                    return Redirect(ReturnUrl);
                }
            }
            catch (Exception ex)
            {
              
            }

            return View("LogOn");
        }

        // Largely copied from http://weblogs.asp.net/haithamkhedre/archive/2011/03/13/openid-authentication-with-asp-net-mvc3-dotnetopenauth-and-openid-selector.aspx
        public ActionResult Authenticate(LogOnViewModel model, string returnUrl)
        {
            var response = openid.GetResponse();
            if (response == null)
            {
                //Let us submit the request to OpenID provider
                Identifier id;
                if (Identifier.TryParse(model.openid_identifier, out id))
                {
                    try
                    {
                        var request = openid.CreateRequest(
                                             model.openid_identifier);
                        return request.RedirectingResponse.AsActionResult();
                    }
                    catch (ProtocolException ex)
                    {
                     
                        return View("LogOn");
                    }
                }

              
                return View("LogOn");
            }

            //Let us check the response
            switch (response.Status)
            {

                case AuthenticationStatus.Authenticated:
                    LogOnViewModel lm = new LogOnViewModel();
                    lm.openid_identifier = response.ClaimedIdentifier;
                   
                    _formsService.SignIn(lm.openid_identifier, false);


                    return Redirect(returnUrl);

                case AuthenticationStatus.Canceled:
                    
                    return View("LogOn");
                case AuthenticationStatus.Failed:
                  
                    return View("LogOn");
            }

            return new EmptyResult();
        }

The _formsService class is what actually creates the login cookie:

public class FormsAuthenticationService:IFormsAuthenticationService
    {
        public void SignIn(string userName, bool createPersistentCookie)
        {
            if (String.IsNullOrEmpty(userName)) throw new ArgumentException("Value cannot be null or empty.", "userName");
            
            FormsAuthenticationTicket tkt;
            string cookiestr;
            HttpCookie ck;
            tkt = new FormsAuthenticationTicket(1, userName, DateTime.Now, DateTime.Now.AddMinutes(30), false, "");
            cookiestr = FormsAuthentication.Encrypt(tkt);
            ck = new HttpCookie(FormsAuthentication.FormsCookieName, cookiestr);
            ck.HttpOnly = true;
            ck.Path = FormsAuthentication.FormsCookiePath;
            HttpContext.Current.Response.Cookies.Add(ck);
            
        }


        public void SignOut()
        {
            FormsAuthentication.SignOut();
        }
    }

And then if you want to set the Identity with the app then you can just go to Global.asax and add/edit the OnAuthenticationRequest method:

      protected void Application_OnAuthenticateRequest(object sernder, EventArgs e)
        {
          
                    // Extract the forms authentication cookie
                    string cookieName = FormsAuthentication.FormsCookieName;
                    HttpCookie authCookie = Context.Request.Cookies[cookieName];

                    if(null == authCookie)
                    {
                      // There is no authentication cookie.
                      return;
                    } 


                    FormsAuthenticationTicket authTicket = null;
                    try
                    {
                      authTicket = FormsAuthentication.Decrypt(authCookie.Value);
                    }
                    catch(Exception ex)
                    {
                      // Log exception details (omitted for simplicity)
                      return;
                    }

                    if (null == authTicket)
                    {
                      // Cookie failed to decrypt.
                      return; 
                    } 


                    // When the ticket was created, the UserData property was assigned a
                    // pipe delimited string of role names.
                    string[] roles = authTicket.UserData.Split(new char[]{'|'});


                    // Create an Identity object
                    FormsIdentity id = new FormsIdentity( authTicket ); 

                    // This principal will flow throughout the request.
                    GenericPrincipal principal = new GenericPrincipal(id, roles);
                    // Attach the new principal object to the current HttpContext object
                    Context.User = principal;


              
        }

Remember that when a user logs out of your site, they are not necessarily logged out of your identification provider, so you may want to provide a message that informs them of this.

So nothing particularly original, but as I couldn’t find anything specifically on this topic, and some of the information comes from some pretty hard-to-find places, I thought I’d post here to save others the time in searching.

If you have a method such as the following in your controller (I am assuming you have created the relevant entity and repository), then this is actually enough to update your ‘RecordType’ database record! Presumably this happens because the transaction is committed once the method is returned. You still need to called SaveOrUpdate() to create new records.

I personally don’t like this feature (I don’t know if it is Sharp or nHibernate) because it is too easy to accidentally update something that shouldn’t be, but once you know it exists then you can look out for it.

[AcceptVerbs(HttpVerbs.Post)]
[Transaction]
public ActionResult Update(MyViewModel model)
{
     RecordType record = _myRepository.GetById(model.Id);
     if (record != null)
     {
           record.Description = model.Description;
      }
}

For example, take the following route in your registry:

routes.MapRoute(
                "MyRoute",
                "ShowMe/{qid}",
                new { controller = "Show", action = "Me" }
                );

and then the View returned by the ‘Me’ controller method uses the following ViewModel:

public class ShowMeViewModel
{
      public string qid {get;set;}
}

Then when the page is called with the URL of ShowMe/TheWorld the ‘qid’ property of the ViewModel will become automatically set to ‘TheWorld’, regardless of what you try to set it to within the ‘Me’ controller method.

So after a frustrating couple of days I have finally figured out how to do it and the steps are below. Skip steps 2-5 if you have MVC 2 already installed. If I have learnt anything from this it is to make notes of everything when using Open Source software.

1. Close down all instances of Visual Studio.
2. Rename folder C:\Program Files\Microsoft Web Designer Tools\VWD to C:\Program Files\Microsoft Web Designer Tools\Wibble
3. Install Visual Studio 2008 Service Pack 1 from here: http://www.microsoft.com/download/en/details.aspx?id=10986
4. Rename folder C:\Program Files\Microsoft Web Designer Tools\Wibble to C:\Program Files\Microsoft Web Designer Tools\VWD
5. Install ASP.NET MVC 2 from here: http://www.microsoft.com/download/en/details.aspx?displaylang=en&id=22079
6. Download the file SharpArchApplicationTemplate_1_6_VS2008.zip from here: https://github.com/sharparchitecture/Sharp-Architecture/downloads
7. Rename the file downloaded in 6 to SharpArchApplicationTemplate.zip, then copy it to the Visual Studio 2008\Templates\ProjectTemplates\Visual C#\Web folder in your ‘My Documents’ area. Obviously create that folder if it doesn’t already exist. See note a) below.
8. Download the file SharpArchitecture_1_6_FullSourceAndTemplates.zip from the same place as in 6.
9. From the zip file downloaded in 8 extract the SharpArchApplicationWizard.dll file from the VisualStudioTemplate folder. Put it in C:\Program Files\Microsoft Visual Studio 9.0\Common7\IDE.
10. Open a command line prompt (in XP, Start button->Run->type cmd). Change directory to the folder in 9 by typing cd “C:\Program Files\Microsoft Visual Studio 9.0\Common7\IDE”.
11. Run the following command – .\devenv /installvstemplates (the first dot is important). This should take about 30-60 seconds to complete depending on how many other templates you have installed.
12. Start Visual Studio 2008. You should now be able to see the Sharp template in the template window when you create a new project (under Visual C#/Web).

a) (Additional note for step 7) This zip file seems to cause problems when creating a new project for some people, in which case you can also extract it from the zip file downloaded in 8 (VisualStudioTemplate directory), which so far seems OK.

   <script type="text/javascript">

        function delCheck() {
            if (confirm("Are you sure you want to delete?") == true) {

                
                $('#btnSubmit').attr("disabled", "disabled");
                return true;
            }
            else
                return false;
        }
    </script>

<% using (Html.BeginForm("Delete", "MyController"))
   { %>
           <input type="submit" value="Submit" title="Submit" name="btnSubmit" id="btnSubmit" onclick="return delCheck()" /> 
  
<%} %>

Then you will find in MVC that this does not submit when the user is using IE. Internet Explorer does not seem to like the fact that you have disabled the button (this is the case up to IE8, I’ve not checked IE9). All other browsers are OK.

If you need to prevent the user pressing it again then try making it invisible instead, which seems to work OK.

Anyway, below is my solution for a very simple spreadsheet generator service and ActionResult. This just allowed me to create a single worksheet table of data, which was all I required. Hopefully it is a good start point if you want anything more complex. I dare say some points are done clunkily but I didn’t have the time to figure out anything else! Some parts I grabbed from other sites on the Net, but most was added myself.

Note: The OpenXML SDK dll is installed direct to the GAC. So when you publish the website it will not get copied to your apps’s bin directory as Visual Studio seems to assume that as it is in your GAC it will also be on the server. So you need to either install it on your server too, or manually copy it to your app’s bin directory.

Here is the code along with some explanation in the comments – note I am assuming you are using S#arp Architecture.

First the custom ActionResult, which should hopefully be self-explanatory:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Web.Mvc;
using System.IO;
using SharpArch.Core;

namespace MyProject.Web.Controllers.CustomActionResults
{
    public class OpenSpreadsheetResult : ActionResult
    {
        private MemoryStream _spreadStream;
        private string _fileName;

        public OpenSpreadsheetResult(MemoryStream spreadsheetStream, string fileName)
        {
            Check.Require(spreadsheetStream != null, "Spreadsheet stream cannot be null");
            _spreadStream = spreadsheetStream;

            if (String.IsNullOrEmpty(fileName) == true)
                _fileName = "Default.xlsx";
            else
                _fileName = fileName;
        }

        public override void ExecuteResult(ControllerContext context)
        {

            context.HttpContext.Response.Clear();
            context.HttpContext.Response.AddHeader("content-disposition",
              String.Format("attachment;filename={0}", _fileName));
            context.HttpContext.Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
            _spreadStream.WriteTo(context.HttpContext.Response.OutputStream);
            _spreadStream.Close();
            context.HttpContext.Response.End(); 
                    
        } 
    }
}

Create the basic spreadsheet generator service, and also an interface to it if you are using the Castle Windsor part of S#arp:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using DocumentFormat.OpenXml;
using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Spreadsheet;

namespace MyProject.ApplicationServices.ReportsServices
{
    public class SpreadsheetService: ISpreadsheetService
    {
        public MemoryStream SpreadsheetStream { get; set; } // The stream that the spreadsheet gets returned on
        private Worksheet currentWorkSheet { get { return spreadSheet.WorkbookPart.WorksheetParts.First().Worksheet; } }
        private SpreadsheetDocument spreadSheet;
        private Columns _cols;

        /// <summary>
        /// Create a basic spreadsheet template 
        /// The structure of OpenXML spreadsheet is something like this from what I can tell:
        ///                        Spreadsheet
        ///                              |         
        ///                         WorkbookPart    
        ///                   /         |             \
        ///           Workbook WorkbookStylesPart WorksheetPart
        ///                 |          |               |
        ///            Sheets     StyleSheet        Worksheet
        ///                |                        /        \       
        ///          (refers to               SheetData        Columns  
        ///           Worksheetparts)            |   
        ///                                     Rows 
        /// 
        /// Obviously this only covers the bits in this class!
        /// </summary>
        /// <returns></returns>
        public bool CreateSpreadsheet()
        {
            try
            {
                SpreadsheetStream = new MemoryStream();

                // Create the spreadsheet on the MemoryStream
                spreadSheet =
                         SpreadsheetDocument.Create(SpreadsheetStream, SpreadsheetDocumentType.Workbook);

                WorkbookPart wbp = spreadSheet.AddWorkbookPart();   // Add workbook part
                WorksheetPart wsp = wbp.AddNewPart<WorksheetPart>(); // Add worksheet part
                Workbook wb = new Workbook(); // Workbook
                FileVersion fv = new FileVersion();
                fv.ApplicationName = "App Name";
                Worksheet ws = new Worksheet(); // Worksheet
                SheetData sd = new SheetData(); // Data on worksheet

                // Add stylesheet
                WorkbookStylesPart stylesPart = spreadSheet.WorkbookPart.AddNewPart<WorkbookStylesPart>();
                stylesPart.Stylesheet = GenerateStyleSheet();
                stylesPart.Stylesheet.Save();

              
                _cols = new Columns(); // Created to allow bespoke width columns
               
                ws.Append(sd); // Add sheet data to worksheet
                wsp.Worksheet = ws; // Add the worksheet to the worksheet part
                wsp.Worksheet.Save();
                // Define the sheets that the workbooks has in it.
                
                Sheets sheets = new Sheets();
                Sheet sheet = new Sheet();
                sheet.Name = "StudentData";
                sheet.SheetId = 1; // Only one sheet per spreadsheet in this class so call it sheet 1
                sheet.Id = wbp.GetIdOfPart(wsp); // ID of sheet comes from worksheet part
                sheets.Append(sheet);
                wb.Append(fv);
                wb.Append(sheets); // Append sheets to workbook

                spreadSheet.WorkbookPart.Workbook = wb;
                spreadSheet.WorkbookPart.Workbook.Save();
               
            }
            catch
            {
                return false;
            }

            return true;
        }


        /// <summary>
        /// add the bespoke columns for the list spreadsheet
        /// </summary>
        public void CreateColumnWidth(uint startIndex, uint endIndex, double width)
        {
            // Find the columns in the worksheet and remove them all
            if (currentWorkSheet.Where(x => x.LocalName == "cols").Count() > 0)
                currentWorkSheet.RemoveChild<Columns>(_cols);

            // Create the column
            Column column = new Column();
            column.Min = startIndex;
            column.Max = endIndex;
            column.Width = width;
            column.CustomWidth = true;
            _cols.Append(column); // Add it to the list of columns

            // Make sure that the column info is inserted *before* the sheetdata
            currentWorkSheet.InsertBefore<Columns>(_cols, currentWorkSheet.Where(x => x.LocalName == "sheetData").First());
            currentWorkSheet.Save();
            spreadSheet.WorkbookPart.Workbook.Save();

        }

        /// <summary>
        /// Close the spreadsheet
        /// </summary>
        public void CloseSpreadsheet()
        {
            spreadSheet.Close();
        }

        /// <summary>
        /// Pass a list of column headings to create the header row
        /// </summary>
        /// <param name="headers"></param>
        public void AddHeader(List<string> headers)
        {
            // Find the sheetdata of the worksheet
            SheetData sd = (SheetData)currentWorkSheet.Where(x => x.LocalName == "sheetData").First();
            Row header = new Row();
            // increment the row index to the next row
            header.RowIndex = Convert.ToUInt32(sd.ChildElements.Count()) + 1; 
            sd.Append(header); // Add the header row

            foreach (string heading in headers)
            {
                AppendCell(header, header.RowIndex, heading, 1);
  
            }

            // save worksheet
            currentWorkSheet.Save();
           
        }


        /// <summary>
        /// Pass a list of data items to create a data row
        /// </summary>
        /// <param name="dataItems"></param>
        public void AddRow(List<string> dataItems)
        {
            // Find the sheetdata of the worksheet
            SheetData sd = (SheetData)currentWorkSheet.Where(x => x.LocalName == "sheetData").First();
            Row header = new Row();
            // increment the row index to the next row
            header.RowIndex = Convert.ToUInt32(sd.ChildElements.Count()) + 1;

            
            sd.Append(header);

            foreach (string item in dataItems)
            {
                AppendCell(header, header.RowIndex, item, 0);

            }

            // save worksheet
            currentWorkSheet.Save();
        }

        /// <summary>
        /// Add cell into the passed row.
        /// </summary>
        /// <param name="row"></param>
        /// <param name="rowIndex"></param>
        /// <param name="value"></param>
        /// <param name="styleIndex"></param>
        private void AppendCell(Row row,  uint rowIndex, string value, uint styleIndex)
        {
            Cell cell = new Cell();
            cell.DataType = CellValues.InlineString;
            cell.StyleIndex = styleIndex;  // Style index comes from stylesheet generated in GenerateStyleSheet()
            Text t = new Text();
            t.Text = value;

            // Append Text to InlineString object
            InlineString inlineString = new InlineString();
            inlineString.AppendChild(t);

            // Append InlineString to Cell
            cell.AppendChild(inlineString);

            // Get the last cell's column
            string nextCol = "A";
            Cell c = (Cell)row.LastChild;
            if (c != null) // if there are some cells already there...
            {
                int numIndex = c.CellReference.ToString().IndexOfAny(new char[] { '1', '2', '3', '4', '5', '6', '7', '8', '9' });

                // Get the last column reference
                string lastCol = c.CellReference.ToString().Substring(0, numIndex);
                // Increment
                nextCol = IncrementColRef(lastCol);
            }

            cell.CellReference = nextCol + rowIndex;

            row.AppendChild(cell);
        }

        // Increment the column reference in an Excel fashion, i.e. A, B, C...Z, AA, AB etc.
        // Partly stolen from somewhere on the Net and modified for my use.
        private string IncrementColRef(string lastRef)
        {
            char[] characters = lastRef.ToUpperInvariant().ToCharArray();
            int sum = 0;
            for (int i = 0; i < characters.Length; i++)
            {
                sum *= 26;
                sum += (characters[i] - 'A' + 1);
            }

            sum++;

            string columnName = String.Empty;
            int modulo;

            while (sum > 0)
            {
                modulo = (sum - 1) % 26;
                columnName = Convert.ToChar(65 + modulo).ToString() + columnName;
                sum = (int)((sum - modulo) / 26);
            }

            return columnName;


        }

        /// <summary>
        /// Return a stylesheet. Completely stolen from somewhere, possibly this guy's blog,
        /// although I can't find it on there:
        /// http://polymathprogrammer.com/. Thanks whoever it was, it would have been a 
        /// nightmare trying to figure this one out!
        /// </summary>
        /// <returns></returns>
        private Stylesheet GenerateStyleSheet()
        {
            return new Stylesheet(
                new Fonts(
                    new Font(                                                               // Index 0 - The default font.
                        new FontSize() { Val = 11 },
                        new Color() { Rgb = new HexBinaryValue() { Value = "000000" } },
                        new FontName() { Val = "Calibri" }),
                    new Font(                                                               // Index 1 - The bold font.
                        new Bold(),
                        new FontSize() { Val = 11 },
                        new Color() { Rgb = new HexBinaryValue() { Value = "000000" } },
                        new FontName() { Val = "Calibri" }),
                    new Font(                                                               // Index 2 - The Italic font.
                        new Italic(),
                        new FontSize() { Val = 11 },
                        new Color() { Rgb = new HexBinaryValue() { Value = "000000" } },
                        new FontName() { Val = "Calibri" }),
                    new Font(                                                               // Index 2 - The Times Roman font. with 16 size
                        new FontSize() { Val = 16 },
                        new Color() { Rgb = new HexBinaryValue() { Value = "000000" } },
                        new FontName() { Val = "Times New Roman" })
                ),
                new Fills(
                    new Fill(                                                           // Index 0 - The default fill.
                        new PatternFill() { PatternType = PatternValues.None }),
                    new Fill(                                                           // Index 1 - The default fill of gray 125 (required)
                        new PatternFill() { PatternType = PatternValues.Gray125 }),
                    new Fill(                                                           // Index 2 - The yellow fill.
                        new PatternFill(
                            new ForegroundColor() { Rgb = new HexBinaryValue() { Value = "FFFFFF00" } }
                        ) { PatternType = PatternValues.Solid })
                ),
                new Borders(
                    new Border(                                                         // Index 0 - The default border.
                        new LeftBorder(),
                        new RightBorder(),
                        new TopBorder(),
                        new BottomBorder(),
                        new DiagonalBorder()),
                    new Border(                                                         // Index 1 - Applies a Left, Right, Top, Bottom border to a cell
                        new LeftBorder(
                            new Color() { Auto = true }
                        ) { Style = BorderStyleValues.Thin },
                        new RightBorder(
                            new Color() { Auto = true }
                        ) { Style = BorderStyleValues.Thin },
                        new TopBorder(
                            new Color() { Auto = true }
                        ) { Style = BorderStyleValues.Thin },
                        new BottomBorder(
                            new Color() { Auto = true }
                        ) { Style = BorderStyleValues.Thin },
                        new DiagonalBorder())
                ),
                new CellFormats(
                    new CellFormat() { FontId = 0, FillId = 0, BorderId = 0 },                          // Index 0 - The default cell style.  If a cell does not have a style index applied it will use this style combination instead
                    new CellFormat() { FontId = 1, FillId = 0, BorderId = 0, ApplyFont = true },       // Index 1 - Bold 
                    new CellFormat() { FontId = 2, FillId = 0, BorderId = 0, ApplyFont = true },       // Index 2 - Italic
                    new CellFormat() { FontId = 3, FillId = 0, BorderId = 0, ApplyFont = true },       // Index 3 - Times Roman
                    new CellFormat() { FontId = 0, FillId = 2, BorderId = 0, ApplyFill = true },       // Index 4 - Yellow Fill
                    new CellFormat(                                                                   // Index 5 - Alignment
                        new Alignment() { Horizontal = HorizontalAlignmentValues.Center, Vertical = VerticalAlignmentValues.Center }
                    ) { FontId = 0, FillId = 0, BorderId = 0, ApplyAlignment = true },
                    new CellFormat() { FontId = 0, FillId = 0, BorderId = 1, ApplyBorder = true }      // Index 6 - Border
                )
            ); // return
        }

    }
}

This is how your would call the methods of the above class. I put this method in a separate ‘reportManager’ class, but I guess you could just put it in the controller as a quicky:

        // These private variables are instantiated by injection into the constructor
        private IMyRepo _myRepo;
        private ISpreadsheetService _spreadsheetService;
      public MemoryStream GenerateExcelList(// any parameters to your report here)
        {
            if (_spreadsheetService.CreateSpreadsheet() == true)
            {
                // Create a few columns
                _spreadsheetService.CreateColumnWidth(1, 1, 15);
                _spreadsheetService.CreateColumnWidth(2, 3, 20);
                _spreadsheetService.CreateColumnWidth(4, 4, 40);
                _spreadsheetService.CreateColumnWidth(5, 5, 15);
                _spreadsheetService.CreateColumnWidth(6, 7, 50);
                _spreadsheetService.CreateColumnWidth(8, 8, 25);
                _spreadsheetService.CreateColumnWidth(9, 11, 15);

                // Add column headers
                _spreadsheetService.AddHeader(new List<string>() { "ID", "Col1", "Col2", "Col3", "Col4", "Col5", "col6", "Col7", "Col8", "Col9", "Col10", "Total"});

                // Get your data from the database here...
                List<Mydata> MyDataRows = _myRepo.GetAll();

                foreach (MyDataRow instance in MyDataRows)
                {
                   
                    _spreadsheetService.AddRow(new List<string>() { instance.ID, instance.Col1, instance.Col2, instance.Col3, instance.Col4, instance.Col5, instance.Col6, instance.Col7, instance.Col8, instance.Col9, instance.Col10, instance.Total});
                 
                }
                
                // Very important to close it!
                _spreadsheetService.CloseSpreadsheet();
            }
        
            return _spreadsheetService.SpreadsheetStream;
}

Finally in your controller:

public ActionResult GetListReport(// any parameters to report here)
        {
            if (ModelState.IsValid)
            {

             
                try
                {
                   
                    MemoryStream reportStream = _reportsManager.GenerateExcelList(// any parameters here);


                    return new OpenSpreadsheetResult(reportStream, "MyName.xlsx");
                }
                catch (Exception ex)
                {
                    ModelState.AddModelError("MyField", "Error creating report: " +ex.StackTrace);
                    return View("MyReportView", model);
                }


            }
            else
            {
                return View("MyReportView", model);
            }
        }

The way to get around this in your class map is to do as follows (for a table named User, mapped to a class named User). Notice the square brackets around the table name.

public class UserMap: ClassMap<User>
{
    public UserMap()
    {
        Table("[User]");
        ...
    }
}

If you know much SQL then this might have been obvious, but if not then you’d never get there! Of course you could always just not name your tables with SQL keywords, but if you are developing for legacy systems you may not have a choice…

The code below shows a way of doing this in the (slightly contrived but simple) situation where you have a view model with a strongly typed non-nullable DateTime tied to a textbox. This will of course throw an error automatically when trying to submit a blank in the textbox – which is great most of the time. However in a particular context you might want to allow it. Instead of making the DateTime nullable in the view model, and then manually testing for null you could also check for the error in the ModelState and then remove it. Here is how:

public ActionResult Save(MyViewModel model, string btnSave, string btnCancel)
{
       ModelState val;
       if (ModelState.TryGetValue("MyDate", out val) == true)
       {
              if (val.Value.AttemptedValue == "") // Test for the string you are going to allow here              
              {
                        ModelState.Remove(new KeyValuePair<string, ModelState>("MyDate", val));
                        model.MyDate = null; // Set your property to whatever your override is here
              }
       }

      .....
}
 

Obviously the example is a little bit contrived, but the point is that you can use the AttemptedValue property to check for specific entered values – which is useful if you only want to check for a particular value. Also – the TryGetValue method is very useful too, no converting to dictionaries and iterating needed!

Part 1 of that post discussed the DLL contents in detail. Part 2 focused upon using that DLL in an MVC application.

This post follows up on “Part 2″ specifically adding a user’s roles to the UserData objet prior to serialisation, on-route to becoming the auth cookie.

The code sample that I gave for using the AuthServices DLL is repeated below:

_authenticationService.Authenticate(userNameString, password);
if (_authenticationService.Result.Authenticated)
{
       _currentUserData = _authenticationService.Result.CurrentUserData;
       _currentUserData.Roles = GetRolesForUser(userName);//THE SUBJECT OF THIS POST
       _cookieManager.CreateUserCookie(userName, _currentUserData);
}

This post explores in more detail what lies behind the GetRolesForUser(string userName) method and how this can utilise more than one provider of roles.

Why bother?

The organisation in which I work is big. We have thousands of staff and many thousands more students. Applications written for an organisation of this size usually need to access different sources of data to provide a user’s roles relevant to the specific application. In projects like this you can’t easily use the standard RoleProvider stuff in a config file.

The Answer – Multiple Role Providers

To implement multiple roles I inject (in an IOC stylee) into my login service the interface IRolesMgr. IRolesMgr exposes the following:

public interface IRolesMgr
    {
        List GetAllRolesForUser(string userName);
    }

The interesting part is in the constructor of the implementation.

public class RolesMgr: IRolesMgr
    {
        private IRoleMgrComponent[] _roleManagers;

        public RolesMgr(IRoleMgrComponent[] roleManagers)
        {
            _roleManagers = roleManagers;
        }

        public List GetAllRolesForUser(string userName)
        {
            List roles = new List();
            foreach (var mgr in _roleManagers)
            {
                roles.AddRange(mgr.GetRolesForUser(userName));
            }
        }
    }

As can be seen the constructor has a dependency on an array of IRoleMgrComponents each of which will contain the access logic needed to identify a user’s roles from a different source.
Each IRoleMgrComponent implements the following:

public interface IRoleMgrComponent
    {
        List GetRolesForUser(string userName);
    }

That’s all very good, but the trick is getting the IOC container, in this case, Castle Windsor, to instantiate the appropriate implementations of IRoleMgrComponent in the roleManagers array.

This is done in the Component Registrar class used to register components to Castle by using the “ServiceOveride” method (more details of this can be seen on Mike Hadlow’s post – which was the original inspiration for the castle registration code – thanks Mike!). In effect this allows you to register and resolve arrays of dependencis using the fluent api.

container.Register(
                Component.For()
                    .ImplementedBy()
                    .ServiceOverrides(
                        ServiceOverride.ForKey("roleManagers").Eq(
                            "HumsAuthDbRoleManager",
                            "StudentAuthRoleMgr"
                        )
                    ),
                AllTypes
                    .FromAssemblyNamed("ApplicationServices")
                    .BasedOn()
                        .WithService.FromInterface(typeof(IRoleMgrComponent))
                        .Configure(c => c.Named(c.Implementation.Name))
                );

container.Register(
                AllTypes.Pick()
                .FromAssemblyNamed("ApplicationServices")
                .WithService.FirstInterface());

Conclusion

Implementing RolesMgr(IRoleMgrComponent[]) in conjunction with the AuthServices assembly talked about in the last post, means that for any given new project I will only have to write minimal code yet benefit from User Credential information that:
a) Has the execution logic encapsulated in an (extensible) AuthServices library
b) Can uitilise dependency injection to configure how where and how the roles data comes from in the credential information.