dbloggingprovider.cs

SharpNuke源代码

				dr = DataProvider.Instance().GetLog(logType);
				LogInfo logInfo;
				while (dr.Read())
				{
					logInfo = FillLogInfo(dr);
					objArr.Add(logInfo);
				}
			}
			finally
			{
				if (dr != null)
				{
					dr.Close();
				}
			}
			return objArr;
		}
		
		public override ArrayList GetLogTypeConfigInfo()
		{
			ArrayList arr;
			arr = ((ArrayList) DataCache.GetCache("GetLogTypeConfigInfo"));
			if (arr == null)
			{
				IDataReader dr = DataProvider.Instance().GetLogTypeConfigInfo();
				if (dr == null)
				{
					return new ArrayList();
				}
				arr = CBO.FillCollection(dr, typeof(LogTypeConfigInfo));
				DataCache.SetCache("GetLogTypeConfigInfo", arr);
				FillLogTypeConfigInfoByKey(arr);
			}
			return arr;
		}
		
		public override LogTypeConfigInfo GetLogTypeConfigInfoByID(string id)
		{
			return ((LogTypeConfigInfo) CBO.FillObject(DataProvider.Instance().GetLogTypeConfigInfoByID(Convert.ToInt32(id)), typeof(LogTypeConfigInfo)));
		}
		
		public override ArrayList GetLogTypeInfo()
		{
			return CBO.FillCollection(DataProvider.Instance().GetLogTypeInfo(), typeof(LogTypeInfo));
		}
		
		public override object GetSingleLog(LogInfo logInfo, LoggingProvider.ReturnType returnType)
		{
			IDataReader dr = null;
			LogInfo obj = null;
			try
			{
				dr = DataProvider.Instance().GetSingleLog(logInfo.LogGUID);
				if (dr != null)
				{
					dr.Read();
					obj = FillLogInfo(dr);
				}
			}
			finally
			{
				if (dr != null)
				{
					dr.Close();
				}
			}
			if (returnType == LoggingProvider.ReturnType.LogInfoObjects)
			{
				return obj;
			}
			else
			{
				XmlDocument xmlDoc = new XmlDocument();
				xmlDoc.LoadXml(XmlUtils.Serialize(obj));
				return ((XmlNode) xmlDoc.DocumentElement);
			}
		}
		
		public override bool LoggingIsEnabled(string logType, int portalID)
		{
			string configPortalID = portalID.ToString();
			if (portalID == - 1)
			{
				configPortalID = "*";
			}
			LogTypeConfigInfo logTypeConfigInfo;
			logTypeConfigInfo = GetLogTypeConfigInfoByKey(logType, configPortalID);
			if (logTypeConfigInfo == null)
			{
				return false;
			}
			return logTypeConfigInfo.LoggingIsActive;
		}
		
		public override void PurgeLogBuffer()
		{
			try
			{
				lockPurgeLog.AcquireWriterLock(writerLockTimeout);
				ArrayList list = LogQueue;
				for (int j = list.Count -1; j >= 0; j--)
				{
					//in case the log was removed
					//by another thread simultaneously
					if (list[j] != null)
					{
						LogQueueItem logQueueItem;
						logQueueItem = ((LogQueueItem)(list[j]));
						WriteLog(logQueueItem);
					}
					//in case the log was removed
					//by another thread simultaneously
					if (list[j] != null)
					{
						list.RemoveAt(j);
					}
				}
				
				DataProvider.Instance().PurgeLog();
				
			}
			finally
			{
				lockPurgeLog.ReleaseWriterLock();
			}
		}
		
		public override void SendLogNotifications ()
		{
			ArrayList arrLogConfig = null;
			arrLogConfig = CBO.FillCollection(DataProvider.Instance().GetEventLogPendingNotifConfig(), typeof(LogTypeConfigInfo));
			
			foreach(LogTypeConfigInfo logTypeConfigInfo  in arrLogConfig)
			{
				IDataReader dr = null;
				StringBuilder logs = new StringBuilder();
				try
				{
					dr = DataProvider.Instance().GetEventLogPendingNotif(Convert.ToInt32(logTypeConfigInfo.ID));
					while (dr.Read())
					{
						LogInfo logInfo = this.FillLogInfo(dr);
						logs.Append(Serialize(logInfo) + "\n\n");
					}
				}
				finally
				{
					if (dr != null)
					{
						dr.Close();
					}
				}
				dr = null;
				Globals.SendNotification(logTypeConfigInfo.MailFromAddress, logTypeConfigInfo.MailToAddress, "", "Event Notification", logs.ToString());
				DataProvider.Instance().UpdateEventLogPendingNotif(Convert.ToInt32(logTypeConfigInfo.ID));
			}
		}
		
		public override bool SupportsEmailNotification()
		{
			return true;
		}
		
		public override bool SupportsInternalViewer()
		{
			return true;
		}
		
		public override bool SupportsSendToCoreTeam()
		{
			return false;
		}
		
		public override bool SupportsSendViaEmail()
		{
			return true;
		}
		
		
		public override void AddLogType (string logTypeKey, string logTypeFriendlyName, string logTypeDescription, 
			string logTypeCSSClass, string logTypeOwner)
		{
			DataProvider.Instance().AddLogType(logTypeKey, logTypeFriendlyName, logTypeDescription, logTypeCSSClass, logTypeOwner);
		}
		
		public override void UpdateLogType (string logTypeKey, string logTypeFriendlyName, string logTypeDescription, 
			string logTypeCSSClass, string logTypeOwner)
		{
			DataProvider.Instance().UpdateLogType(logTypeKey, logTypeFriendlyName, logTypeDescription, logTypeCSSClass, logTypeOwner);
		}
		
		public override void DeleteLogType (string logTypeKey)
		{
			DataProvider.Instance().DeleteLogType(logTypeKey);
		}
		#endregion
		
		#region "Private Methods"
		private Hashtable FillLogTypeConfigInfoByKey(ArrayList list)
		{
			Hashtable hashTable = new Hashtable();
			foreach(LogTypeConfigInfo logTypeConfigInfo in list)
			{
				if (logTypeConfigInfo.LogTypeKey == "")
				{
					logTypeConfigInfo.LogTypeKey = "*";
				}
				if (logTypeConfigInfo.LogTypePortalID == "")
				{
					logTypeConfigInfo.LogTypePortalID = "*";
				}
				hashTable.Add(logTypeConfigInfo.LogTypeKey + "|" + logTypeConfigInfo.LogTypePortalID, logTypeConfigInfo);
			}
			DataCache.SetCache("GetLogTypeConfigInfoByKey", hashTable);
			return hashTable;
		}
		
		private LogTypeConfigInfo GetLogTypeConfigInfoByKey(string logTypeKey, string logTypePortalID)
		{
			Hashtable hashTable;
			hashTable = ((Hashtable) DataCache.GetCache("GetLogTypeConfigInfoByKey"));
			if (hashTable == null)
			{
				hashTable = FillLogTypeConfigInfoByKey(GetLogTypeConfigInfo());
			}
			LogTypeConfigInfo logTypeConfigInfo;
			logTypeConfigInfo = ((LogTypeConfigInfo) hashTable[logTypeKey + "|" + logTypePortalID]);
			if (logTypeConfigInfo == null)
			{
				logTypeConfigInfo = ((LogTypeConfigInfo) hashTable["*|" + logTypePortalID]);
				if (logTypeConfigInfo == null)
				{
					logTypeConfigInfo = ((LogTypeConfigInfo) hashTable[logTypeKey + "|*"]);
					if (logTypeConfigInfo == null)
					{
						logTypeConfigInfo = ((LogTypeConfigInfo) hashTable["*|*"]);
					}
					else
					{
						return logTypeConfigInfo;
					}
				}
				else
				{
					return logTypeConfigInfo;
				}
			}
			else
			{
				return logTypeConfigInfo;
			}
			
			return logTypeConfigInfo;
		}
		
		
		
		private LogInfo FillLogInfo(IDataReader dr)
		{
			System.IO.TextReader textReader = null;
			LogInfo logInfo = new LogInfo();
			try
			{
				string logGUID;
				logGUID = Convert.ToString(dr["LogGUID"]);
				
				logInfo.LogCreateDate = Convert.ToDateTime(dr["LogCreateDate"]);
				logInfo.LogGUID = Convert.ToString(dr["LogGUID"]);
				if (! Convert.IsDBNull(dr["LogPortalID"]))
				{
					logInfo.LogPortalID = Convert.ToInt32(dr["LogPortalID"]);
				}
				if (! Convert.IsDBNull(dr["LogPortalName"]))
				{
					logInfo.LogPortalName = Convert.ToString(dr["LogPortalName"]);
				}
				if (! Convert.IsDBNull(dr["LogServerName"]))
				{
					logInfo.LogServerName = Convert.ToString(dr["LogServerName"]);
				}
				if (! Convert.IsDBNull(dr["LogUserID"]))
				{
					logInfo.LogUserID = Convert.ToInt32(dr["LogUserID"]);
				}
				logInfo.LogTypeKey = Convert.ToString(dr["LogTypeKey"]);
				logInfo.LogUserName = Convert.ToString(dr["LogUserName"]);
				logInfo.LogConfigID = Convert.ToString(dr["LogConfigID"]);
				logInfo.LogProperties = Deserialize(Convert.ToString(dr["LogProperties"]));
			}
			finally
			{
				if (textReader != null)
				{
					textReader.Close();
				}
			}
			return logInfo;
		}
		
		private void WriteLog (LogQueueItem logQueueItem)
		{
			LogTypeConfigInfo logTypeConfigInfo = null;
			try
			{
				logTypeConfigInfo = logQueueItem.LogTypeConfigInfo;
				if (logTypeConfigInfo != null)
				{
					LogInfo logInfo;
					logInfo = logQueueItem.LogInfo;
					string logProperties;
					logProperties = Serialize(logInfo.LogProperties);
					DataProvider.Instance().AddLog(logInfo.LogGUID, logInfo.LogTypeKey, logInfo.LogUserID, 
						logInfo.LogUserName, logInfo.LogPortalID, logInfo.LogPortalName, logInfo.LogCreateDate, 
						logInfo.LogServerName, logProperties, Convert.ToInt32(logInfo.LogConfigID));
					
					if (logTypeConfigInfo.EmailNotificationIsActive)
					{
						try
						{
							lockNotif.AcquireWriterLock(readerLockTimeout);
							
							if (logTypeConfigInfo.NotificationThreshold == 0)
							{
								string serialized;
								serialized = XmlUtils.Serialize(logQueueItem.LogInfo);
								Globals.SendNotification(logTypeConfigInfo.MailFromAddress, logTypeConfigInfo.MailToAddress, "", "Event Notification", serialized);
							}
							else if (logTypeConfigInfo.LogTypeKey != "LOG_NOTIFICATION_FAILURE")
							{
								//pending log notifications go here
								
							}
						}
						finally
						{
							lockNotif.ReleaseWriterLock();
						}
					}
				}
				
				if (logTypeConfigInfo.EmailNotificationIsActive == true)
				{
					if (logTypeConfigInfo.NotificationThreshold == 0)
					{
						//SendNotification(logTypeConfigInfo.MailFromAddress, logTypeConfigInfo.MailToAddress, "", "Event Notification", xmlDoc.InnerXml)
					}
					else if (logTypeConfigInfo.LogTypeKey != "LOG_NOTIFICATION_FAILURE")
					{
						
					}
				}
				
			}
			catch (Exception exception)
			{
				if (HttpContext.Current != null)
				{
					HttpResponse response = HttpContext.Current.Response;
					HtmlUtils.WriteHeader(response, "Unhandled Error");
					
					string strMessage = exception.Message;
					HtmlUtils.WriteError(response, logTypeConfigInfo.LogFileNameWithPath, strMessage);
					
					HtmlUtils.WriteFooter(response);
					response.End();
				}
			}
			
		}
		
		#endregion
		
		#region serialization
		private LogProperties Deserialize(string objectString)
		{
			System.IO.Stream stream;
			stream = new System.IO.MemoryStream(System.Text.Encoding.UTF8.GetBytes(objectString));
			Type[] types = new Type[1];
			types[0] = typeof(LogDetailInfo);
			
			XmlSerializer xserializer;
			
			xserializer = new XmlSerializer(typeof(LogProperties), types);
			return ((LogProperties) xserializer.Deserialize(stream));
		}

		private string Serialize(object obj)
		{
			Type[] types = new Type[1];
			types[0] = typeof(LogDetailInfo);
			XmlDocument xmlDoc = new XmlDocument();
			XmlSerializer xserializer;
			StringWriter stringWriter;
			
			xserializer = new XmlSerializer(obj.GetType(), types);
			stringWriter = new StringWriter();
			xserializer.Serialize(stringWriter, obj);
			xmlDoc.LoadXml(stringWriter.GetStringBuilder().ToString());
			XmlNode node = xmlDoc.DocumentElement;
			return node.OuterXml;
		}
		#endregion
	}
	
}