Click here to Skip to main content
Click here to Skip to main content
Add your own
alternative version

Flexible and Plug-in-based .NET Application using Provider Pattern

, , 1 Dec 2005
This paper demonstrates creating a flexible, extensible, plug-in-based .NET application (JOM - Smart Job Manager). JOM is an asynchronous job processing engine built using the MS Provider design pattern and the .NET technology available today.
smartjobmanager.zip
Code
Bin
ClientApplication.exe
EntLibHelper.dll
log
exceptions
SmartJobManager.log
Microsoft.Practices.EnterpriseLibrary.Caching.dll
Microsoft.Practices.EnterpriseLibrary.Common.dll
Microsoft.Practices.EnterpriseLibrary.Configuration.dll
Microsoft.Practices.EnterpriseLibrary.Data.dll
Microsoft.Practices.EnterpriseLibrary.ExceptionHandling.dll
Microsoft.Practices.EnterpriseLibrary.ExceptionHandling.Logging.dll
Microsoft.Practices.EnterpriseLibrary.Logging.dll
Microsoft.Practices.EnterpriseLibrary.Security.ActiveDirectory.dll
Microsoft.Practices.EnterpriseLibrary.Security.Cache.CachingStore.dll
Microsoft.Practices.EnterpriseLibrary.Security.Cryptography.dll
Microsoft.Practices.EnterpriseLibrary.Security.Database.Authentication.dll
Microsoft.Practices.EnterpriseLibrary.Security.Database.dll
Microsoft.Practices.EnterpriseLibrary.Security.dll
Providers.dll
SampleProviders.dll
ScreencaptureJobManagerProvider.dll
SimpleJobManagerProvider.dll
SmartJobManager.BusinessLogicLayer.dll
SmartJobManagerService.exe
ClientApplication
App.ico
bin
ClientApplication.csproj.user
EntLibHelper
bin
EntLibHelper.csproj.user
Library
Microsoft.Practices.EnterpriseLibrary.Caching.dll
Microsoft.Practices.EnterpriseLibrary.Common.dll
Microsoft.Practices.EnterpriseLibrary.Configuration.dll
Microsoft.Practices.EnterpriseLibrary.Data.dll
Microsoft.Practices.EnterpriseLibrary.ExceptionHandling.dll
Microsoft.Practices.EnterpriseLibrary.ExceptionHandling.Logging.dll
Microsoft.Practices.EnterpriseLibrary.Logging.dll
Microsoft.Practices.EnterpriseLibrary.Security.ActiveDirectory.dll
Microsoft.Practices.EnterpriseLibrary.Security.Cache.CachingStore.dll
Microsoft.Practices.EnterpriseLibrary.Security.Cryptography.dll
Microsoft.Practices.EnterpriseLibrary.Security.Database.Authentication.dll
Microsoft.Practices.EnterpriseLibrary.Security.Database.dll
Microsoft.Practices.EnterpriseLibrary.Security.dll
Objects
bin
Release
SmartJobManager.BusinessLogicLayer.dll
SmartJobManager.csproj.user
Providers
bin
Configuration
Providers.csproj.user
System
Configuration
Providers
Providers
SampleProviders
bin
SampleProviders.csproj.user
ScreencaptureJobManagerProvider
bin
ScreencaptureJobManagerProvider.csproj.user
SimpleJobManagerProvider
bin
SimpleJobManagerProvider.csproj.user
SmartJobManagerService
bin
SmartJobManagerService.csproj.user
// =====================================================================================
// Copyright � 2005 by Shahed Khan. All rights are reserved.
// 
// If you like this code then feel free to go ahead and use it.
// The only thing I ask is that you don't remove or alter my copyright notice.
//
// Your use of this software is entirely at your own risk. I make no claims or
// warrantees about the reliability or fitness of this code for any particular purpose.
// If you make changes or additions to this code please mark your code as being yours.
// 
// website , email shahed.khan@gmail.com
// =====================================================================================


//Originally written by Omar Al Zabir I modified according to my need

// Copyright � 2005 by Omar Al Zabir. All rights are reserved.
// 
// If you like this code then feel free to go ahead and use it.
// The only thing I ask is that you don't remove or alter my copyright notice.
//
// Your use of this software is entirely at your own risk. I make no claims or
// warrantees about the reliability or fitness of this code for any particular purpose.
// If you make changes or additions to this code please mark your code as being yours.
// 
// website http://www.oazabir.com, email OmarAlZabir@gmail.com, msn oazabir@hotmail.com

using System;

using Microsoft.Practices.EnterpriseLibrary.Logging;
using Microsoft.Practices.EnterpriseLibrary.ExceptionHandling;
using Microsoft.Practices.EnterpriseLibrary.Configuration;
using Microsoft.Practices.EnterpriseLibrary.Caching;
using Microsoft.Practices.EnterpriseLibrary.Security.Cryptography;
using Microsoft.Practices.EnterpriseLibrary.Security;
using System.Security.Principal;
using SmartJobManager;

namespace SmartJobManager
{

	/// <summary>
	/// Helper class for dealing with enterprise library
	/// </summary>
	public class EntLibHelper 
	{
		#region Configuration Section Names

		private const string CONFIGURATION_SECTION_NAME = "globalConfiguration";
		
		private const string EXCEPTION_POLICY_NAME = "Exception Policy";
		private const string SYMMETRIC_INSTANCE = "DPAPI Symmetric Cryptography Provider";
		private const string HASH_INSTANCE = "MD5CryptoServiceProvider";
		private const string GENERAL_CACHE_MANAGER = "General Cache";
		private const string AUTHENTICATION_PROVIDER = "Database Provider";
		private const string CACHING_STORE_PROVIDER = "Caching Store Provider";
		private const string RULE_PROVIDER = "RuleProvider";
		private const string PROFILE_PROVIDER = "Profile Database Provider";
		private const string ROLE_PROVIDER = "Role Database Provider";

		#endregion

		#region Logging

		private const string INFO_CATEGORY = "Info";
		private const string WARN_CATEGORY = "Warn";
		private const string ERROR_CATEGORY = "Error";
		private const string DEBUG_CATEGORY = "Debug";

		private const string JOB_INFO_CATEGORY = "JobInfo";		
		private const string JOB_ERROR_CATEGORY = "JobError";		

		private const int INFO_PRIORITY = 4;
		private const int INFO_EVENTID = 0;

		private const int ERROR_PRIORITY = 3;
		private const int ERROR_EVENTID = 0;

		private const int WARN_PRIORITY = 2;
		private const int WARN_EVENTID = 0;

		private const int DEBUG_PRIORITY = 1;
		private const int DEBUG_EVENTID = 0;

		/*
		Category - used to determine the routing of the LogEntry; 
		Priority - used to filter Log Entries, only those above the �Minimum Priority� are processed (defaults to -1 which indicates that the Minimum Priority should be used); 
		EventId - a value you can use to further categorise Log Entries (defaults to 0 for a LogEntry and to 1 for a LogEntry implicitly created by Logger.Write); 
		Severity - indicates the severity of the Log Entry, e.g., Information, Warning, Error etc. 
		Title - a summary of the LogEntry.Message. 
		*/
		
		private static CacheManager manager = CacheFactory.GetCacheManager(GENERAL_CACHE_MANAGER);

		public static void Info( string title, object message )
		{
			Logger.Write( "Log message", "Debug" );
			Logger.Write( message, INFO_CATEGORY, INFO_PRIORITY, INFO_EVENTID, Microsoft.Practices.EnterpriseLibrary.Logging.Severity.Information, title );
		}

		public static void Error( string title, object message )
		{
			Logger.Write( message, ERROR_CATEGORY, ERROR_PRIORITY, ERROR_EVENTID, Microsoft.Practices.EnterpriseLibrary.Logging.Severity.Error, title );
		}
		
		public static void Warn( string title, object message )
		{
			Logger.Write( message, WARN_CATEGORY, WARN_PRIORITY, WARN_EVENTID, Microsoft.Practices.EnterpriseLibrary.Logging.Severity.Warning, title );
		}
		
		public static void Debug( string title, object message )
		{
			Logger.Write( message, DEBUG_CATEGORY, DEBUG_PRIORITY, DEBUG_EVENTID, Microsoft.Practices.EnterpriseLibrary.Logging.Severity.Unspecified, title );
		}

		public static void JobInfo( string title, Job job)
		{
			string jobData = string.Format("Job: {0}{1}",job.ToString(),Environment.NewLine);
			foreach(JobDetail detail in job.JobDetailCollection)
			{
				jobData = string.Format("{0}{1}{2}",jobData,detail.ToString(),Environment.NewLine);
			}														
			

			Logger.Write( jobData, JOB_INFO_CATEGORY, INFO_PRIORITY, INFO_EVENTID, Microsoft.Practices.EnterpriseLibrary.Logging.Severity.Information, title );
		}

		public static void JobError( string title, Job job )
		{
			string jobData = string.Format("Job: {0}{1}",job.ToString(),Environment.NewLine);
			foreach(JobDetail detail in job.JobDetailCollection)
			{
				jobData = string.Format("{0}{1}{2}",jobData,detail.ToString(),Environment.NewLine);
			}					

			Logger.Write( jobData, JOB_ERROR_CATEGORY, ERROR_PRIORITY, ERROR_EVENTID, Microsoft.Practices.EnterpriseLibrary.Logging.Severity.Error, title );
		}
		
		#endregion

		#region Exception Handling


		public static bool Exception( string title, Exception x )
		{
			ApplicationException wrapped = new ApplicationException( title, x );
			bool rethrow = ExceptionPolicy.HandleException( wrapped, EXCEPTION_POLICY_NAME );
			return rethrow;
		}

		internal static void UnhandledException(Exception x)
		{
			// An unhandled exception occured somewhere in our application. Let
			// the 'Global Policy' handler have a try at handling it.
			try
			{
				bool rethrow = ExceptionPolicy.HandleException(x, "Unhandled Exception");
				if (rethrow)
				{
					throw x;
				}
			}
			catch
			{
				// Something has gone wrong during HandleException (e.g. incorrect configuration of the block).
				// Exit the application
				string errorMsg = "An unexpected exception occured while calling HandleException with policy 'Global Policy'. "; 
				errorMsg += "Please check the event log for details about the exception." + Environment.NewLine + Environment.NewLine;

				throw new Exception( errorMsg );
			}
		}

		public static bool JobException( string title, Job job, Exception x )
		{
			string jobData = string.Format("Job: {0}{1}",job.ToString(),Environment.NewLine);
			foreach(JobDetail detail in job.JobDetailCollection)
			{
				jobData = string.Format("{0}{1}{2}",jobData,detail.ToString(),Environment.NewLine);
			}														
			title = string.Format("{0}{1}{2}",title,jobData,Environment.NewLine);
			ApplicationException wrapped = new ApplicationException( title, x );
			bool rethrow = ExceptionPolicy.HandleException( wrapped, EXCEPTION_POLICY_NAME );
			return rethrow;
		}		

		#endregion

		#region Caching

		public static void StoreInCache( string key, object data )
		{
			if( null == data ) manager.Remove( key );
			else manager.Add( key, data );			
		}

		public static object GetCachedObject( string key )
		{
			if( manager.Contains( key ) )
				return manager.GetData( key );
			else 
				return null;			
		}
		#endregion

		#region Cryptography

		public static string Encrypt( string data )
		{
			if( 0 == data.Trim().Length ) return string.Empty;
			return Cryptographer.EncryptSymmetric( SYMMETRIC_INSTANCE, data );
		}

		public static string Decrypt( string data )
		{
			if( 0 == data.Trim().Length ) return string.Empty;
			try
			{
				return Cryptographer.DecryptSymmetric( SYMMETRIC_INSTANCE, data );
			}
			catch
			{
				throw new ApplicationException( "Cannot decrypt password. Please set again." );
			}
		}

		public static string Hash( string data )
		{
			if( 0 == data.Length ) return string.Empty;
			
			return Cryptographer.CreateHash( HASH_INSTANCE, data );
		}

		public static byte [] HashUnicoded( string data )
		{
			// Initialize hash provider
			ConfigurationContext context = ConfigurationManager.GetCurrentContext();
			HashProviderFactory hashProviderFactory = new HashProviderFactory(context);
			IHashProvider hashProvider = hashProviderFactory.CreateHashProvider( HASH_INSTANCE );

			byte [] unicodeBytes = System.Text.Encoding.Unicode.GetBytes(data);
			byte[] hashBytes = hashProvider.CreateHash(unicodeBytes);

			return hashBytes;
		}
		
		#endregion

		#region Authentication and Authorization

		public static string Authenticate( string userName, string password )
		{
			IAuthenticationProvider authenticationProvider = AuthenticationFactory.GetAuthenticationProvider(AUTHENTICATION_PROVIDER);

			IIdentity identity;

			byte [] passwordBytes = System.Text.Encoding.Unicode.GetBytes( password );
			NamePasswordCredential credentials = new NamePasswordCredential(userName, passwordBytes);
				
			bool authenticated = authenticationProvider.Authenticate(credentials, out identity);

			if( authenticated )
			{
				ISecurityCacheProvider cache = SecurityCacheFactory.GetSecurityCacheProvider(CACHING_STORE_PROVIDER);

				// Cache the identity. The SecurityCache will generate a token which is then
				// returned to us.
				IToken token = cache.SaveIdentity(identity);

				return token.Value;
			}
			else
			{
				return null;
			}
		}

		public static bool Authenticate(string tokenValue)
		{
			ISecurityCacheProvider cache = SecurityCacheFactory.GetSecurityCacheProvider(CACHING_STORE_PROVIDER);

			// Retrieves the identity previously saved by using the corresponding token
			IToken token = new GuidToken( new Guid( tokenValue ) );
			IIdentity savedIdentity = cache.GetIdentity(token);

			if( null != savedIdentity )
				return true;
			else
				return false;
		}

		public static void CleanSecurityToken( string tokenValue )
		{
			IToken token = new GuidToken( new Guid( tokenValue ) );
			ISecurityCacheProvider cache = SecurityCacheFactory.GetSecurityCacheProvider(CACHING_STORE_PROVIDER);

			// Expire the identity
			cache.ExpireIdentity(token);
		}

		public static bool IsInRole(string userName, string roleName)
		{
			IRolesProvider rolesProvider = RolesFactory.GetRolesProvider(ROLE_PROVIDER);
			
			IPrincipal principal = rolesProvider.GetRoles(new GenericIdentity(userName)); 
			if (principal != null) 
			{ 
				bool isInRole = principal.IsInRole(roleName); 
				return isInRole;
			}
			else
			{
				return false;
			}
		}

		public static bool IsAuthorized( string userName, string task )
		{
			IRolesProvider roleProvider = RolesFactory.GetRolesProvider(ROLE_PROVIDER);		
			IIdentity identity = new GenericIdentity(userName);
			IPrincipal principal = roleProvider.GetRoles(identity);

			IAuthorizationProvider ruleProvider = AuthorizationFactory.GetAuthorizationProvider(RULE_PROVIDER);

			// Determine if user is authorized for the rule defined e.g. "Print Document"
			bool authorized = ruleProvider.Authorize(principal, task); 

			return authorized;
		}


		[Serializable]
		public class MyIdentity : GenericIdentity
		{
			public string SecurityToken = Guid.NewGuid().ToString();

			public MyIdentity( string userName, string type ) : base( userName, type )
			{
			}

			public MyIdentity( string userName ) : base( userName )
			{
			}
		}
		#endregion
	}
}

By viewing downloads associated with this article you agree to the Terms of Service and the article's licence.

If a file you wish to view isn't highlighted, and is a text file (not binary), please let us know and we'll add colourisation support for it.

License

This article has no explicit license attached to it but may contain usage terms in the article text or the download files themselves. If in doubt please contact the author via the discussion board below.

A list of licenses authors might use can be found here

Share

About the Authors

Shahed.Khan
Web Developer
Australia Australia
I have been awarded MVP (Visual C#) for year 2007, 2008, 2009. I am a Microsoft Certified Application Developer (C# .Net). I currently live in Melbourne, Australia. I am a co-founder and core developer of Pageflakes www.pageflakes.com and Founder of Simplexhub, a highly experienced software development company based in Melbourne Australia and Dhaka, Bangladesh. Simplexhub.
My BLOG http://www.geekswithblogs.net/shahed
http://msmvps.com/blogs/shahed/Default.aspx.

David.Grinberg

Australia Australia
No Biography provided

| Advertise | Privacy | Terms of Use | Mobile
Web02 | 2.8.141223.1 | Last Updated 1 Dec 2005
Article Copyright 2005 by Shahed.Khan, David.Grinberg
Everything else Copyright © CodeProject, 1999-2014
Layout: fixed | fluid