1: public class Authentication : IAuthenticationExtension {

   2:  

   3:     #region IAuthenticationExtension Members

   4:     /// <summary>

   5:     /// Required by IAuthenticationExtension. The report server calls the 

   6:     /// GetUserInfo methodfor each request to retrieve the current user 

   7:     /// identity.

   8:     /// </summary>

   9:     /// <param name="userIdentity">represents the identity of the current 

  10:     /// user. The value of IIdentity may appear in a user interface and 

  11:     /// should be human readable</param>

  12:     /// <param name="userId">represents a pointer to a unique user identity

  13:     /// </param>

  14:     public void GetUserInfo(out System.Security.Principal.IIdentity userIdentity, out IntPtr userId) {

  15:         // If the current user identity is not null,

  16:         // set the userIdentity parameter to that of the current user 

  17:         if ( HttpContext.Current != null

  18:               && HttpContext.Current.User != null ) {

  19:             userIdentity = HttpContext.Current.User.Identity;

  20:         } else {

  21:             // The current user identity is null. This happens when the user attempts an anonymous logon.

  22:             // Although it is ok to return userIdentity as a null reference, it is best to throw an appropriate

  23:             // exception for debugging purposes.

  24:             // To configure for anonymous logon, return a Gener

  25:             System.Diagnostics.Debug.Assert( false, "Warning: userIdentity is null! Modify your code if you wish to support anonymous logon." );

  26:             throw new NullReferenceException( "Anonymous logon is not configured. userIdentity should not be null!" );

  27:             //userIdentity = new GenericIdentity( "anon" );

  28:         }

  29:  

  30:         // initialize a pointer to the current user id to zero

  31:         userId = IntPtr.Zero;

  32:     }

  33:  

  34:  

  35:     /// <summary>

  36:     /// The IsValidPrincipalName method is called by the report server when 

  37:     /// the report server sets security on an item. This method validates 

  38:     /// that the user name is valid for Windows.  The principal name needs to 

  39:     /// be a user, group, or builtin account name.

  40:     /// </summary>

  41:     /// <param name="principalName">A user, group, or built-in account name

  42:     /// </param>

  43:     /// <returns>true when the principle name is valid</returns>

  44:     public bool IsValidPrincipalName(string principalName) {

  45:         ValidationManager mgr = new ValidationManager();

  46:         return mgr.ValidatePrincipalName( principalName);

  47:     }

  48:  

  49:     /// <summary>

  50:     /// Indicates whether a supplied username and password are valid.

  51:     /// </summary>

  52:     /// <param name="userName">The supplied username</param>

  53:     /// <param name="password">The supplied password</param>

  54:     /// <param name="authority">Optional. The specific authority to use to

  55:     /// authenticate a user. For example, in Windows it would be a Windows 

  56:     /// Domain</param>

  57:     /// <returns>true when the username and password are valid</returns>

  58:     public bool LogonUser(string userName, string password, string authority) {

  59:         ValidationManager mgr = new ValidationManager();

  60:         return mgr.ValidateUserInfo(HttpContext.Current.Request.Headers);

  61:     }

  62:  

  63:     #endregion

  64:  

  65:     #region IExtension Members

  66:     /// <summary>

  67:     /// You must implement LocalizedName as required by IExtension

  68:     /// </summary>

  69:     public string LocalizedName {

  70:         get { 

  71:             //throw new NotImplementedException();

  72:             return null;

  73:         }

  74:     }

  75:  

  76:     /// <summary>

  77:     /// You must implement SetConfiguration as required by IExtension

  78:     /// </summary>

  79:     /// <param name="configuration">Configuration data as an XML

  80:     /// string that is stored along with the Extension element in

  81:     /// the configuration file.</param>

  82:     public void SetConfiguration(string configuration) {

  83:         //XmlDocument doc = new XmlDocument();

  84:  

  85:         //doc.LoadXml(configuration);

  86:         //if ( doc.DocumentElement.Name == "SecurityConfiguration" ) {

  87:         //    foreach ( XmlNode child in doc.DocumentElement.ChildNodes ) {

  88:         //        if ( child.Name == "ConnectionString" ) {

  89:         //            _userValidationConnectionString = child.InnerText;

  90:         //        } else {

  91:         //            throw new FormatException( "Security configuration element missing from config file" );

  92:         //        }

  93:         //    }

  94:         //} else {

  95:         //    throw new FormatException( "SecurityConfiguration element expected" );

  96:         //}

  97:  

  98:     }

  99:  

 100:     #endregion

 101: }

   1: <?xml version="1.0" encoding="utf-8"?>

   2: <configuration>

   3:     ...

   4:   <system.web>

   5:     ...

   6:     <identity impersonate="false" />

   7:     ...

   8:     <httpModules>

   9:       ...

  10:       <!-- REGISTER YOUR HTTP MODULE HERE IF REQUIRED -->

  11:     </httpModules>

  12:   </system.web>

  13:   <appSettings>

  14:     ...

  15:     <!-- your-server-name should be replaced with the value for your server -->

  16:     <add key="ReportServer" value="your-server-name" />

  17:     <add key="ReportServerInstance" value="RS_MSSQLSERVER" />

  18:     <add key="ReportServerWebServiceUrl" value="https://your-server-name/reportserver" />

  19:     <add key="AuthKey" value="1010101010" />

  20:     <add key="ReportMainConnectionString" value="SERVER=your-server-name;Initial Catalog=UserAuthenticationStore;Integrated Security=SSPI;Trusted_Connection=Yes" />

  21:   </appSettings>

  22:     ...

  23: </configuration>

   1: <?xml version="1.0" encoding="utf-8"?>

   2: <configuration>

   3:   <system.web>

   4:     ...

   5:     <authentication mode="Forms" />

   6:     <authorization>

   7:         <deny users="?" />

   8:     </authorization>

   9:     <identity impersonate="false" />

  10:    ...

  11:   </system.web>

  12:   <appSettings>

  13:       <add key="ReportServerWebServiceUrl" value="https://you-server-name/reportserver" />

  14:       <add key="AuthKey" value="1010101010" />

  15:       <add key="ReportMainConnectionString" value="SERVER=your-server-name;Initial Catalog=UserAuthenticationStore;Integrated Security=SSPI;Trusted_Connection=Yes" />

  16:   </appSettings>

  17:     ...

  18: </configuration>

   1: <Configuration>

   2:     ...

   3:     <Authentication>

   4:         <AuthenticationTypes>

   5:             <Custom/>

   6:         </AuthenticationTypes>

   7:         ...

   8:     </Authentication>

   9:     ...

  10:     <UI>

  11:         <CustomAuthenticationUI>

  12:             <loginUrl>/Pages/UILogon.aspx</loginUrl>

  13:             <UseSSL>False</UseSSL>

  14:         </CustomAuthenticationUI>

  15:         <ReportServerUrl>https://your-server-name/reportserver</ReportServerUrl>

  16:         <PageCountMode>Estimate</PageCountMode>

  17:     </UI>

  18:     <Extensions>

  19:         ...

  20:         <Security>

  21:             <Extension Name="Forms" Type="Sample.ReportingServices.Security.Authorization, Sample.ReportingServices.Security, Version=1.0.0.0, Culture=neutral, PublicKeyToken=d04ec164f4506a18">

  22:                 <Configuration>

  23:                     <AdminConfiguration>

  24:                         <UserName>administrator@sample.com</UserName>

  25:                     </AdminConfiguration>

  26:                 </Configuration>

  27:             </Extension>

  28:         </Security>

  29:         <Authentication>

  30:             <Extension Name="Forms" Type="Sample.ReportingServices.Security.Authentication, Sample.ReportingServices.Security, Version=1.0.0.0, Culture=neutral, PublicKeyToken=d04ec164f4506a18" />

  31:         </Authentication>

  32:         ...

  33: </Configuration>

   1: <CodeGroup

   2:     class="UnionCodeGroup"

   3:     version="1"

   4:     Name="SecurityExtensionCodeGroup"

   5:     Description="Code group for the custom security extension"

   6:     PermissionSetName="FullTrust">

   7:     <IMembershipCondition 

   8:         class="UrlMembershipCondition"

   9:         version="1"

  10:         Url="C:\Program Files\Microsoft SQL Server\MSRS10_50.MSSQLSERVER\Reporting Services\ReportServer\bin\Sample.ReportingServices.Security.dll"

  11:     />

  12: </CodeGroup>

   1: <CodeGroup 

   2:     class="FirstMatchCodeGroup" 

   3:     version="1" 

   4:     PermissionSetName="FullTrust"

   5:     Description="This code group grants MyComputer code Execution 

   6:     permission. ">

   7:     <IMembershipCondition 

   8:         class="ZoneMembershipCondition"

   9:         version="1"

  10:         Zone="MyComputer" />

   1: /// <summary>

   2: /// validates that the user is valid based on values in the header

   3: /// in the form of a hashed value and username

   4: /// </summary>

   5: /// <param name="headers">headers from the http request</param>

   6: /// <returns>true if a valid user account with correct header info</returns>

   7: public bool ValidateUserInfo(NameValueCollection headers) {

   8:  

   9:     bool isValid = false;

  10:  

  11:     //are our headers present?

  12:     if ( headers != null && headers.Count > 0 ) {

  13:         if ( headers["UserToken"] != null ) {

  14:             //need to validate the header information related to the request

  15:             //expecting a header with AuthToken

  16:             //need to validate the user is a valid one in the database

  17:             //expecting a header with UserToken

  18:             isValid = ( IsValidHeaderHash( headers["AuthToken"] ) && IsValidUserToken( headers["UserToken"] ) );

  19:         }

  20:     }

  21:  

  22:     return isValid;

  23: }

  24:  

  25: /// <summary>

  26: /// validates that the user exists and matches in the database

  27: /// </summary>

  28: /// <param name="userName">username to validate</param>

  29: /// <returns>true if user exists and matches provided username</returns>

  30: private bool IsValidUserToken(string userToken) {

  31:     //assume not valid

  32:     bool isUserValid = false;

  33:  

  34:     if ( userToken != null && userToken.Length > 0 ) {

  35:  

  36:         string sql = "SELECT userName, [role] FROM [dbo].[UserSchema] WHERE @username AND [role]='Reports'";

  37:  

  38:         //create parameter

  39:         SqlParameter pram = new SqlParameter( "@username", SqlDbType.VarChar, 256 );

  40:         pram.Value = userToken;

  41:  

  42:         SqlParameter[] prams = {

  43:             pram

  44:         };

  45:  

  46:         //check the database

  47:         if ( DataExists( _connectionString, sql, prams, "userName", userToken ) ) {

  48:             _validatedUserToken = userToken;

  49:             isUserValid = true;

  50:         }

  51:     }

  52:  

  53:     //return

  54:     return isUserValid;

  55: }

  56:  

  57:  

  58: /// <summary>

  59: /// Validate the header auth token to ensure the request is valid

  60: /// </summary>

  61: /// <param name="authKey">header authetication token</param>

  62: /// <returns>true if valid</returns>

  63: private bool IsValidHeaderHash(string authKey) {

  64:     //assume not valid

  65:     bool validHeader = false;

  66:  

  67:     if ( authKey != null && authKey.Length > 0 ) {

  68:  

  69:         if( authKey.Equals(ConfigurationManager.AppSettings["F5AuthKey"]) ) {

  70:             //hash validated

  71:             validHeader = true;

  72:         }

  73:     }

  74:  

  75:     return validHeader;

  76: }

  77:  

  78:  

  79: /// <summary>

  80: /// runs the specified query and tests to see if the data returned matches the value to test 

  81: /// by checking to see if it contains the value 

  82: /// </summary>

  83: /// <param name="connectionString">connection string to database</param>

  84: /// <param name="sqlString">sql to run</param>

  85: /// <param name="prams">parameters to pass</param>

  86: /// <param name="columnToTest">column to validate against</param>

  87: /// <param name="valueToTest">value to test against column</param>

  88: /// <returns>true if the value matches</returns>

  89: private bool DataExists( string connectionString, string sqlString, SqlParameter[] prams, string columnToTest, string valueToTest) {

  90:     bool dataExists = false;

  91:     //connect to store for configuration

  92:     using ( SqlConnection conn = new SqlConnection( connectionString ) ) {

  93:  

  94:         //run command to validate account name

  95:         SqlCommand cmd = new SqlCommand( sqlString, conn );

  96:         cmd.CommandType = CommandType.Text;

  97:  

  98:         //create parameter for account name

  99:         if ( prams != null ) {

 100:             foreach ( SqlParameter pram in prams ) {

 101:                 cmd.Parameters.Add( pram );

 102:             }

 103:         }

 104:  

 105:         try {

 106:             conn.Open();

 107:             using ( SqlDataReader reader = cmd.ExecuteReader() ) {

 108:                 //If a row exists for the user, then assume user is valid

 109:                 //but to be safe we want to explicitly check for a match, rather than assume

 110:                 if ( reader.Read() ) {

 111:                     

 112:                     if ( reader[columnToTest].ToString().Equals( valueToTest ) ) {

 113:                         //data valid

 114:                         dataExists = true;

 115:                     }

 116:                 }

 117:             }

 118:         } catch ( Exception ex ) {

 119:             throw new Exception( ex.Message );

 120:         }

 121:         return dataExists;

 122:     }

 123: }

   1: private void Page_Load(object sender, System.EventArgs e)

   2: {

   3:  

   4:     ValidationManager mgr = new ValidationManager();

   5:     if (mgr.ValidateUserInfo(Request.Headers))

   6:     {

   7:         ReportServerProxy server = new ReportServerProxy();

   8:  

   9:         string reportServer = ConfigurationManager.AppSettings["ReportServer"];

  10:         string instanceName = ConfigurationManager.AppSettings["ReportServerInstance"];

  11:  

  12:         // Get the server URL from the report server using WMI

  13:         server.Url = ValidationManager.GetReportServerUrl(reportServer, instanceName);

  14:  

  15:         server.LogonUser(mgr.ValidatedUserToken, Request.Headers["AuthToken"], null);

  16:         string redirectUrl = Request.QueryString["ReturnUrl"];

  17:         if (redirectUrl != null)

  18:         {

  19:             HttpContext.Current.Response.Redirect(redirectUrl, false);

  20:         }

  21:         else

  22:         {

  23:             HttpContext.Current.Response.Redirect("./Folder.aspx", false);

  24:         }

  25:  

  26:     }

  27: }

   1: namespace Sample.ReportingServices.Security {

   2:     // Because the UILogon uses the Web service to connect to the report server

   3:     // you need to extend the server proxy to support authentication ticket

   4:     // (cookie) management

   5:     public class ReportServerProxy : ReportingService2010 {

   6:  

   7:         protected override WebRequest GetWebRequest(Uri uri) {

   8:             HttpWebRequest request;

   9:             request = (HttpWebRequest)HttpWebRequest.Create( uri );

  10:             // Create a cookie jar to hold the request cookie

  11:             CookieContainer cookieJar = new CookieContainer();

  12:             request.CookieContainer = cookieJar;

  13:             Cookie authCookie = AuthCookie;

  14:             // if the client already has an auth cookie

  15:             // place it in the request's cookie container

  16:             if ( authCookie != null ) {

  17:                 request.CookieContainer.Add( authCookie );

  18:             }

  19:             request.Timeout = -1;

  20:             request.Headers.Add( "Accept-Language", HttpContext.Current.Request.Headers["Accept-Language"] );

  21:             if ( HttpContext.Current.Request.Headers["AuthToken"] != null ) {

  22:                 request.Headers.Add( "AuthToken", HttpContext.Current.Request.Headers["AuthToken"] );

  23:             }

  24:             if ( HttpContext.Current.Request.Headers["UserToken"] != null ) {

  25:                 request.Headers.Add( "UserToken", HttpContext.Current.Request.Headers["UserToken"] );

  26:             }

  27:             return request;

  28:         }

  29:  

  30:         [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Usage", "CA2201:DoNotRaiseReservedExceptionTypes" )]

  31:         protected override WebResponse GetWebResponse(WebRequest request) {

  32:             WebResponse response = base.GetWebResponse( request );

  33:             string cookieName = response.Headers["RSAuthenticationHeader"];

  34:             // If the response contains an auth header, store the cookie

  35:             if ( cookieName != null ) {

  36:                 

  37:                 Utilities.CustomAuthCookieName = cookieName;

  38:                 HttpWebResponse webResponse = (HttpWebResponse)response;

  39:                 Cookie authCookie = webResponse.Cookies[cookieName];

  40:                 // If the auth cookie is null, throw an exception

  41:                 if ( authCookie == null ) {

  42:                     throw new Exception( "Authorization ticket not received by LogonUser" );

  43:                 }

  44:                 // otherwise save it for this request

  45:                 AuthCookie = authCookie;

  46:                 // and send it to the client

  47:                 Utilities.RelayCookieToClient( authCookie );

  48:             }

  49:             return response;

  50:         }

  51:  

  52:         private Cookie AuthCookie {

  53:             get {

  54:                 if ( m_Authcookie == null && HttpContext.Current != null && HttpContext.Current.Request != null )

  55:                     m_Authcookie = Utilities.TranslateCookie(HttpContext.Current.Request.Cookies[Utilities.CustomAuthCookieName] );

  56:                 return m_Authcookie;

  57:             }

  58:             set {

  59:                 m_Authcookie = value;

  60:             }

  61:         }

  62:         private Cookie m_Authcookie = null;

  63:     }

  64:  

  65:     [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Performance", "CA1812:AvoidUninstantiatedInternalClasses" )]

  66:     internal sealed class Utilities {

  67:         internal static string CustomAuthCookieName {

  68:             get {

  69:                 lock ( m_cookieNamelockRoot ) {

  70:                     return m_cookieName;

  71:                 }

  72:             }

  73:             set {

  74:                 lock ( m_cookieNamelockRoot ) {

  75:                     m_cookieName = value;

  76:                 }

  77:             }

  78:         }

  79:         private static string m_cookieName;

  80:         private static object m_cookieNamelockRoot = new object();

  81:  

  82:         private static HttpCookie TranslateCookie(Cookie netCookie) {

  83:             if ( netCookie == null )

  84:                 return null;

  85:             HttpCookie webCookie = new HttpCookie( netCookie.Name, netCookie.Value );

  86:             // Add domain only if it is dotted - IE doesn't send back the cookie 

  87:             // if we set the domain otherwise

  88:             if ( netCookie.Domain.IndexOf( '.' ) != -1 ) {

  89:                 webCookie.Domain = netCookie.Domain;

  90:             }

  91:             webCookie.Expires = netCookie.Expires;

  92:             webCookie.Path = netCookie.Path;

  93:             webCookie.Secure = netCookie.Secure;

  94:             return webCookie;

  95:         }

  96:  

  97:         internal static Cookie TranslateCookie(HttpCookie webCookie) {

  98:             if ( webCookie == null )

  99:                 return null;

 100:             Cookie netCookie = new Cookie( webCookie.Name, webCookie.Value );

 101:             if ( webCookie.Domain == null ) {

 102:                 netCookie.Domain = HttpContext.Current.Request.ServerVariables["SERVER_NAME"];

 103:             }

 104:             netCookie.Expires = webCookie.Expires;

 105:             netCookie.Path = webCookie.Path;

 106:             netCookie.Secure = webCookie.Secure;

 107:             return netCookie;

 108:         }

 109:  

 110:         internal static void RelayCookieToClient(Cookie cookie) {

 111:             // add the cookie if not already in there

 112:             if ( HttpContext.Current.Response.Cookies[cookie.Name] == null ) {

 113:                 HttpContext.Current.Response.Cookies.Remove( cookie.Name );

 114:             }

 115:  

 116:             HttpContext.Current.Response.SetCookie( TranslateCookie( cookie ) );

 117:         }

 118:     }

 119: }

   1: <style>

   2: .pps-parameterTitle {

   3:     FONT-FAMILY: Verdana, Arial, sans-serif; COLOR: red; FONT-SIZE: 14pt

   4: }

   5: select[name^="pps_"] {

   6:     FONT-FAMILY: Verdana, Arial, sans-serif; COLOR: green; FONT-SIZE: 10pt

   7: }

   8: </style>

   1: <XML ID="Microsoft Search Thesaurus">

   2:  

   3: <!--  Commented out

   4: 

   5:     <thesaurus xmlns="x-schema:tsSchema.xml">

   6:     <diacritics_sensitive>0</diacritics_sensitive>

   7:         <expansion>

   8:             <sub>Internet Explorer</sub>

   9:             <sub>IE</sub>

  10:             <sub>IE5</sub>

  11:         </expansion>

  12:         <replacement>

  13:             <pat>NT5</pat>

  14:             <pat>W2K</pat>

  15:             <sub>Windows 2000</sub>

  16:         </replacement>

  17:         <expansion>

  18:             <sub>run</sub>

  19:             <sub>jog</sub>

  20:         </expansion>

  21:     </thesaurus>

  22: -->

  23: </XML>

   1: public partial class thesaurus : LayoutsPageBase

   2:     {

   3:         protected void Page_Load(object sender, EventArgs e)

   4:         {

   5:             //get the list reference

   6:             string listId = Request.QueryString["List"].ToString();

   7:             if (!string.IsNullOrEmpty(listId))

   8:             {

   9:                 Guid listGuid = new Guid(listId);

  10:                 //iterate the values and generate the file

  11:                 SPWeb web = SPContext.Current.Web;

  12:                 SPList list = web.Lists[listGuid];

  13:  

  14:                 using (MemoryStream mem = new MemoryStream())

  15:                 {

  16:                     using (StreamWriter stream = new StreamWriter(mem, Encoding.Unicode))

  17:                     {

  18:  

  19:                         XmlWriterSettings settings = new XmlWriterSettings();

  20:                         settings.Encoding = Encoding.UTF8;

  21:                         settings.OmitXmlDeclaration = true;

  22:                         settings.ConformanceLevel = ConformanceLevel.Fragment;

  23:                         settings.Indent = true;

  24:                         settings.IndentChars = "\t";

  25:                         XmlWriter writer = XmlWriter.Create(stream, settings);

  26:  

  27:                         writer.WriteStartElement("XML");

  28:                         writer.WriteAttributeString("ID", "Microsoft Search Thesaurus");

  29:                         writer.WriteStartElement("thesaurus", "x-schema:tsSchema.xml");

  30:                         writer.WriteElementString("diacritics_sensitive", "0");

  31:                         writer.WriteComment("Generated on " + DateTime.Now.ToShortDateString() + " " + DateTime.Now.ToShortTimeString());

  32:  

  33:                         if (list != null)

  34:                         {

  35:                             foreach (SPListItem item in list.Items)

  36:                             {

  37:                                 if (item["ThesaurusEntryType"].Equals("Expansion"))

  38:                                 {

  39:                                     writer.WriteStartElement("expansion");

  40:                                     writer.WriteElementString("sub", item["ThesaurusWord"].ToString().Trim());

  41:                                 }

  42:                                 else if (item["ThesaurusEntryType"].Equals("Replacement"))

  43:                                 {

  44:                                     writer.WriteStartElement("replacement");

  45:                                     writer.WriteElementString("pat", item["ThesaurusWord"].ToString().Trim());

  46:                                 }

  47:                                 //write the substitutions

  48:                                 string substitutions = item["ThesaurusSubs"].ToString();

  49:                                 string[] subs = substitutions.Split(',');

  50:                                 foreach (string sub in subs)

  51:                                 {

  52:                                     writer.WriteElementString("sub", sub.Trim());

  53:                                 }

  54:  

  55:                                 //close type

  56:                                 writer.WriteEndElement();

  57:                             }

  58:  

  59:                             //}

  60:  

  61:                             // close thesaurus

  62:                             writer.WriteEndElement();

  63:  

  64:                             //close xml

  65:                             writer.WriteEndElement();

  66:  

  67:                             //writer.WriteEndDocument();

  68:                             writer.Flush();

  69:                             writer.Close();

  70:                             // Convert the memory stream to an array of bytes.

  71:                             byte[] bytes = mem.ToArray();

  72:  

  73:                             // Send the XML file to the web browser for download.

  74:                             Response.Clear();

  75:                             Response.Buffer = true;

  76:                             Response.ContentEncoding = Encoding.Unicode;

  77:                             Response.AppendHeader("content-disposition", "attachment; filename=tsneu.xml");

  78:                             Response.Cache.SetExpires(DateTime.UtcNow.AddMinutes(-1));

  79:                             Response.Cache.SetCacheability(HttpCacheability.NoCache);

  80:                             Response.Cache.SetNoStore();

  81:  

  82:                             Response.AppendHeader("Content-Length", bytes.Length.ToString());

  83:                             Response.ContentType = "text/xml";

  84:  

  85:                             Response.BinaryWrite(bytes);

  86:  

  87:                             Response.End();

  88:                         }

  89:                     }

  90:                 }

  91:             }

  92:         }

  93:     }

   1: <?xml version="1.0" encoding="utf-8"?>

   2: <Elements xmlns="https://schemas.microsoft.com/sharepoint/">

   3:     <Field ID="{A2124DA1-5194-4f17-AE5B-23D118C52FF0}"

   4:           Name="ThesaurusEntryType"

   5:           DisplayName="Entry Type"

   6:           Description="Type of Thesaurus Output to create"

   7:           Group="Blog Fields"

   8:           Type="Choice"

   9:           Required="TRUE"

  10:           Format="Dropdown"

  11:           Overwrite="TRUE">

  12:         <CHOICES>

  13:             <CHOICE>Expansion</CHOICE>

  14:             <CHOICE>Replacement</CHOICE>

  15:         </CHOICES>

  16:     </Field>

  17:     <Field ID="{F77E9210-2D52-413d-BB21-6C0788DF2803}"

  18:            Name="ThesaurusWord"

  19:            DisplayName="Match"

  20:            Description="Word to match in the thesaurus"

  21:            Group="Blog Fields"

  22:            Type="Text"

  23:            Required="TRUE"

  24:            Overwrite="TRUE">

  25:     </Field>

  26:     <Field ID="{C7271283-D681-4d56-A502-F2AD78A86412}"

  27:            Name="ThesaurusSubs"

  28:            DisplayName="Substitutions"

  29:            Description="Comma delimited list of words to substitute in the thesaurus"

  30:            Group="Blog Fields"

  31:            Type="Text"

  32:            Required="TRUE"

  33:            Overwrite="TRUE">

  34:     </Field>

  35:   <!-- Parent ContentType: Item (0x01) -->

  36:   <ContentType ID="0x01004aa858bfc0e14b2ba3b4beb23b2cdb48"

  37:                Name="Thesaurus"

  38:                Group="Blog Content Types"

  39:                Description="Content type for managing the thesaurus entries for search"

  40:                Inherits="TRUE"

  41:                Version="0">

  42:     <FieldRefs>

  43:         <RemoveFieldRef ID="{fa564e0f-0c70-4ab9-b863-0177e6ddd247}" Name="Title" />

  44:         <FieldRef ID="{A2124DA1-5194-4f17-AE5B-23D118C52FF0}" Name="ThesaurusEntryType" DisplayName="Entry Type" Required="TRUE" />

  45:         <FieldRef ID="{F77E9210-2D52-413d-BB21-6C0788DF2803}" Name="ThesaurusWord" DisplayName="Match" Required="TRUE" />

  46:         <FieldRef ID="{C7271283-D681-4d56-A502-F2AD78A86412}" Name="ThesaurusSubs" DisplayName="Substitutions" Required="TRUE" />

  47:     </FieldRefs>

  48:   </ContentType>

  49: </Elements>

   1: <?xml version="1.0" encoding="utf-8"?>

   2: <Elements xmlns="https://schemas.microsoft.com/sharepoint/">

   3:     <!-- Do not change the value of the Name attribute below. If it does not match the folder name of the List Definition project item, an error will occur when the project is run. -->

   4:     <ListTemplate

   5:         Name="Thesaurus List"

   6:         Type="10101"

   7:         BaseType="0"

   8:         OnQuickLaunch="TRUE"

   9:         SecurityBits="11"

  10:         Sequence="410"

  11:         DisplayName="Thesaurus List"

  12:         Description="My List Definition"

  13:         Image="/_layouts/images/itgen.png"/>

  14: </Elements>

   1: <CustomAction Id="Blog.CustomActions.ThesaurusGenerator"

   2:         RegistrationType="List"

   3:         RegistrationId="10101"

   4:         GroupId="ActionsMenu"

   5:         Location="Microsoft.SharePoint.StandardMenu"

   6:         Sequence="1001"

   7:         Description="Generates a thesaurus file for sharepoint"

   8:         Title="Create Thesaurus File">

   9:             <UrlAction Url="~site/_layouts/blog/thesaurus.aspx?List={ListId}"/>

  10:     </CustomAction>

   1: <CustomAction Id="ThesaurusCustomRibbonButton"

   2:               RegistrationId="10101"

   3:               RegistrationType="List"

   4:               Location="CommandUI.Ribbon"

   5:               Sequence="5"

   6:               Title="Thesaurus Ribbon Customization">

   7:     <CommandUIExtension>

   8:         <CommandUIDefinitions>

   9:             <CommandUIDefinition Location="Ribbon.List.Actions.Controls._children">

  10:                 <Button

  11:                     Id="Ribbon.List.Actions.CreateThesaurusFile"

  12:                     Sequence="5"

  13:                     Description="Create Thesaurus File" 

  14:                     LabelText="Create Thesaurus File"

  15:                     Alt="Create Thesaurus File" 

  16:                     Command="CreateThesaurusFile"

  17:                     Image32by32="/_layouts/1033/images/formatmap32x32.png"

  18:                     Image16by16="/_layouts/1033/images/formatmap16x16.png"

  19:                     TemplateAlias="o1" />

  20:             </CommandUIDefinition>

  21:         </CommandUIDefinitions>

  22:         <CommandUIHandlers>

  23:             <CommandUIHandler

  24:               Command="CreateThesaurusFile"

  25:               CommandAction="_layouts/blog/thesaurus.aspx?List={ListId}" />

  26:         </CommandUIHandlers>

  27:     </CommandUIExtension>

  28: </CustomAction>

   1: <ViewFields>

   2:     <FieldRef Name="ThesaurusEntryType" />

   3:     <FieldRef Name="ThesaurusWord" />

   4:     <FieldRef Name="ThesaurusSubs" />

   5: </ViewFields>

   1: <WebFeatures>

   2:     <!--  TeamCollab Feature --> 

   3:     <Feature ID="00BFEA71-4EA5-48D4-A4AD-7EA5C011ABE5" /> 

   4:     <!--  MobilityRedirect --> 

   5:     <Feature ID="F41CC668-37E5-4743-B4A8-74D1DB3FD8A4" /> 

   6:     <!--  WikiPageHomePage Feature --> 

   7:     <Feature ID="00BFEA71-D8FE-4FEC-8DAD-01C19A6E4053" /> 

   8: </WebFeatures>

   1: <Feature Id="00BFEA71-D8FE-4FEC-8DAD-01C19A6E4053" 

   2:     Title="$Resources:core,WikiPageHomePage;" 

   3:     Description="$Resources:core,WikiPageHomePage_Desc;" 

   4:     Version="1.0.0.0" 

   5:     Scope="Web" 

   6:     Hidden="FALSE" 

   7:     ReceiverAssembly="Microsoft.SharePoint, Version=14.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" 

   8:     ReceiverClass="Microsoft.SharePoint.SPWikiPageHomePageFeatureReceiver" DefaultResourceFile="core" xmlns="https://schemas.microsoft.com/sharepoint/">

   9:     <ActivationDependencies>

  10:         <!--  WebPageLibrary Feature --> 

  11:       <ActivationDependency FeatureId="00BFEA71-C796-4402-9F2F-0EB9A6E71B18" /> 

  12:     </ActivationDependencies>

  13: </Feature>