private bool EggLayingEventExists(Side side)
{
EventIdentifier id = (side == Side.Player) ? EventIdentifier.PlayerEggLaying : EventIdentifier.EnemyEggLaying;
GameEvent e = Managers.GameClock.GetEvent(id);
return(e != null);
}
private void LoadEventTemplate(EventIdentifier eventIdentifier)
{
strEvent.Append(GuiLanguage.GetGuiLanguage("Templates").GetString(string.Format("Notification{0}Body{1}", Carrier, eventIdentifier)));
int intStart = strEvent.ToString().IndexOf("<itemtemplate>", StringComparison.InvariantCultureIgnoreCase);
int intStopp = strEvent.ToString().IndexOf("</itemtemplate>", StringComparison.InvariantCultureIgnoreCase);
if (intStart >= 0 && intStopp > intStart)
{
strEventItem = new StringBuilder();
int intLength = intStopp - (intStart + 14);
strEventItem.Append(strEvent.ToString().Substring(intStart + 14, intLength));
strEventAlternateItem = new StringBuilder(strEventItem.ToString());
strEvent = strEvent.Remove(intStart, (intStopp - intStart) + 15);
strEvent.Insert(intStart, Constants.K_ITEM);
}
intStart = strEvent.ToString().IndexOf("<alternatingitemtemplate>", StringComparison.InvariantCultureIgnoreCase);
intStopp = strEvent.ToString().IndexOf("</alternatingitemtemplate>", StringComparison.InvariantCultureIgnoreCase);
if (intStart >= 0 && intStopp > intStart)
{
strEventAlternateItem = new StringBuilder();
int intLength = intStopp - (intStart + 25);
strEventAlternateItem.Append(strEvent.ToString().Substring(intStart + 25, intLength));
strEvent = strEvent.Remove(intStart, (intStopp - intStart) + 26);
}
}
public ReflectedEvent(EventIdentifier name, EventInfo ev, Type targetType)
: base(name, null, ev, targetType)
{
DeclaringName = ev.DeclaringType != targetType
? IdentifierFor.Event(ev, ev.DeclaringType)
: name;
}
public void CreateEggLayingEvent(Side side, bool initial = false)
{
if (EggLayingEventExists(side))
{
// event exists - abort!
return;
}
DifficultySettings difficulty = Managers.SettingsManager.GetCurrentSettings();
EventIdentifier id = (side == Side.Player) ? EventIdentifier.PlayerEggLaying : EventIdentifier.EnemyEggLaying;
if (side == Side.Player)
{
float delay;
if (initial)
{
delay = difficulty.PlayerInitialEggLayingDelay;
}
else
{
delay = difficulty.PlayerEggLayingDelay;
}
Managers.GameClock.RegisterEvent(delay, CheckIfPlayerEggLayingPossible, id);
}
else
{
float delay = difficulty.EnemyEggLayingDelay;
Managers.GameClock.RegisterEvent(delay, CheckIfEnemyEggLayingPossible, id);
}
}
/// <summary>
/// Determines the expected responce length given the message type
/// </summary>
/// <param name="eventIdentifier">The type of message we are going to send</param>
/// <returns>The number of bytes (as a string) we expect to receive from the device</returns>
private int getResponceLength(EventIdentifier inEventIdentifier)
{
int toReturn = 0;
log.Debug(string.Format("getting responce length for message type {0}", inEventIdentifier));
switch (inEventIdentifier)
{
case EventIdentifier.ConnectRequest:
toReturn = 1;
break;
case EventIdentifier.AnalogPinQueryRequest:
toReturn = 2;
break;
case EventIdentifier.QueryCounterRequest:
toReturn = 4;
break;
default:
break;
}
log.Debug(string.Format("returning responce length:{0} for message type {1}", toReturn, inEventIdentifier));
return(toReturn);
}
public static Event Unresolved(EventIdentifier eventIdentifier, DeclaredType type)
{
return(new Event(eventIdentifier, type)
{
IsResolved = false
});
}
public void RegisterEvent(float timeInFuture, Action action, EventIdentifier identifier = EventIdentifier.None)
{
GameEvent newEvent = new GameEvent();
newEvent.ExecutionTime = this.time + timeInFuture;
newEvent.Action = action;
newEvent.Identifier = identifier;
InsertInEventQueue(newEvent);
}
public void RaiseEvent(EventIdentifier eventIdentifier, object sender, EventArgs args)
{
Delegate handler;
lock (events)
{
events.TryGetValue(eventIdentifier, out handler);
}
handler?.DynamicInvoke(sender, args);
}
public void AddEvent(EventIdentifier eventIdentifier, Delegate handler)
{
lock (events)
{
Delegate oldHandler;
events.TryGetValue(eventIdentifier, out oldHandler);
events[eventIdentifier] = Delegate.Combine(handler, oldHandler);
}
}
public GameEvent GetEvent(EventIdentifier identifier)
{
foreach (GameEvent e in this.eventQueue)
{
if (e.Identifier == identifier)
{
return(e);
}
}
return(null);
}
public void EventIdentifier_GetEventsIn_TestClassWithOneEvent_OneEventIdentified()
{
var testClass = new EventIdentifierTestable();
var events = EventIdentifier.GetEventsIn(testClass.GetType());
Assert.AreEqual(1, events.Length);
var eventIdentifier = events.First().Item1;
Assert.AreEqual(Guid.Parse(EventID), eventIdentifier.id);
Assert.AreEqual(EventName, eventIdentifier.name);
}
internal static EventIdentifier GetEventIdentifierEnum(string value, EventIdentifier defaultValue)
{
foreach (EventIdentifier item in Enum.GetValues(typeof(EventIdentifier)))
{
if (item.ToString() == value)
{
return(item);
}
}
return(defaultValue);
}
public RegistrationDefault Item(EventIdentifier key)
{
if (list.ContainsKey(key))
{
return(list[key]);
}
else
{
return(null);
}
}
public void AddEvent(SqlDataReader sqlReader)
{
if (hasEvents.ContainsKey(sqlReader["NEV_ID"].ToString()))
{
return;
}
else
{
hasEvents.Add(sqlReader["NEV_ID"].ToString(), null);
}
EventIdentifier enuEventIdentifier = (EventIdentifier)Convert.ToInt32(sqlReader["NRE_Identifier"]);
if (strAddress.Length == 0)
{
strAddress = sqlReader[string.Format("NUS_Carrier_{0}", (int)Carrier)].ToString();
ReplaceTag(strBase, sqlReader, enuEventIdentifier);
}
//Wenn irgend ein Event 'true' ist so müssen alle 'true' sein
if (!blnConfident)
{
if (Convert.ToBoolean(sqlReader["NEV_Confident"]))
{
blnConfident = true;
}
}
if (enuLastEventIdentifier != enuEventIdentifier)
{
enuLastEventIdentifier = enuEventIdentifier;
strEventList.Append(strEvent.ToString().Replace(Constants.K_ITEM, string.Empty));
LoadEventTemplate(enuEventIdentifier);
blnFlip = true;
}
StringBuilder strItem = null;
if (blnFlip)
{
strItem = new StringBuilder(strEventItem.ToString());
}
else
{
strItem = new StringBuilder(strEventAlternateItem.ToString());
}
blnFlip = !blnFlip;
ReplaceTag(strItem, sqlReader, enuEventIdentifier);
strItem.AppendLine(Constants.K_ITEM);
strEvent = strEvent.Replace(Constants.K_ITEM, strItem.ToString());
}
public void ReportEvent(EventIdentifier identifier, Guid userIDLogedIn, string subject, string body, string address, bool confident)
{
SqlConnection Conn = new SqlConnection(Helper.GetSiemeConnectionString());
try
{
SqlCommand GetData = new SqlCommand();
GetData.Connection = Conn;
GetData.CommandType = CommandType.StoredProcedure;
GetData.CommandText = "hisp_Notification_NotificationSend_Insert";
GetData.Parameters.Add(SqlHelper.AddParameter("@Identifier", SqlDbType.Int, (int)identifier));
GetData.Parameters.Add(SqlHelper.AddParameter("@Carrier", SqlDbType.Int, (int)CarrierType.EMail));
if (address.Length > 0)
{
GetData.Parameters.Add(SqlHelper.AddParameter("@Address", SqlDbType.UniqueIdentifier, address));
}
else
{
GetData.Parameters.Add(SqlHelper.AddParameter("@Address", SqlDbType.UniqueIdentifier));
}
if (subject.Length > 0)
{
GetData.Parameters.Add(SqlHelper.AddParameter("@Subject", SqlDbType.UniqueIdentifier, subject));
}
else
{
GetData.Parameters.Add(SqlHelper.AddParameter("@Subject", SqlDbType.UniqueIdentifier));
}
if (body.Length > 0)
{
GetData.Parameters.Add(SqlHelper.AddParameter("@Body", SqlDbType.UniqueIdentifier, body));
}
else
{
GetData.Parameters.Add(SqlHelper.AddParameter("@Body", SqlDbType.UniqueIdentifier));
}
GetData.Parameters.Add(SqlHelper.AddParameter("@DeleteAfterSuccess", SqlDbType.Bit, confident ? 0 : 1));
Conn.Open();
GetData.ExecuteNonQuery();
}
finally
{
Conn.Close();
}
}
/// <inheritdoc/>
public string ToDelimitedString()
{
CultureInfo culture = CultureInfo.CurrentCulture;
return(string.Format(
culture,
StringHelper.StringFormatSequence(0, 4, Configuration.FieldSeparator),
Id,
QueryTag,
EventIdentifier?.ToDelimitedString(),
InputParameterList != null ? string.Join(Configuration.FieldRepeatSeparator, InputParameterList.Select(x => x.ToDelimitedString())) : null
).TrimEnd(Configuration.FieldSeparator.ToCharArray()));
}
public override bool Equals(object obj)
{
var other = obj as CustomerCreatedEvent;
if (other == null)
{
return(false);
}
var result = EventIdentifier.Equals(other.EventIdentifier) &&
EventSourceId.Equals(other.EventSourceId) &&
EventSequence.Equals(other.EventSequence) &&
Name.Equals(other.Name) &&
Age.Equals(other.Age);
return(result);
}
public override bool Equals(object obj)
{
var other = obj as CustomerNameChanged;
if (other == null)
{
return(false);
}
var result = EventIdentifier.Equals(other.EventIdentifier) &&
EventSourceId.Equals(other.EventSourceId) &&
EventSequence.Equals(other.EventSequence) &&
CustomerId.Equals(other.CustomerId) &&
NewName.Equals(other.NewName);
return(result);
}
public override bool Equals(object obj)
{
var other = obj as AccountTitleChangedEvent;
if (other == null)
{
return(false);
}
bool result = EventIdentifier.Equals(other.EventIdentifier) &&
EventSourceId.Equals(other.EventSourceId) &&
EntityId.Equals(other.EntityId) &&
EventSequence.Equals(other.EventSequence) &&
EventTimeStamp.Equals(other.EventTimeStamp) &&
NewTitle.Equals(other.NewTitle);
return(result);
}
public void RemoveEvents(EventIdentifier identifier)
{
// TODO - replace with RemoveALL and predicate call
List <GameEvent> eventsToRemove = new List <GameEvent>();
foreach (GameEvent e in this.eventQueue)
{
if (e.Identifier == identifier)
{
eventsToRemove.Add(e);
}
}
foreach (GameEvent e in eventsToRemove)
{
this.eventQueue.Remove(e);
}
}
private void FillObject(Business.RegistrationDefaultList list, XmlElement xmlDefault)
{
EventIdentifier enuEventIdentifier = (EventIdentifier)Convert.ToInt32(xmlDefault.GetAttribute("Identifier"));
Business.RegistrationDefault item = list.Item(enuEventIdentifier);
if (item != null)
{
item.Identifier = enuEventIdentifier;
CarrierType enuCarrierType = (CarrierType)Convert.ToInt32(xmlDefault.GetAttribute("Carrier"));
Business.Carrier objCarrier = item.Carriers.Item(enuCarrierType);
if (objCarrier != null)
{
objCarrier.Checked = true;
objCarrier.Collect = (CarrierCollect)Convert.ToInt32(xmlDefault.GetAttribute("Collect"));
objCarrier.CollectValue = 1;
}
}
}
public void RemoveEvent(EventIdentifier eventIdentifier, Delegate handler)
{
lock (events)
{
Delegate oldHandler;
if (events.TryGetValue(eventIdentifier, out oldHandler))
{
;
}
{
var newHandler = Delegate.Remove(oldHandler, handler);
if (newHandler != null)
{
events[eventIdentifier] = newHandler;
}
else
{
events.Remove(eventIdentifier);
}
}
}
}
public override string ToString()
{
return(string.Format("{0}[{1}]", Payload.GetType().FullName, EventIdentifier.ToString("D")));
}
public void Load(bool useConfig, Business.RegistrationList list, Guid currentUserID, Guid?objectID, Guid?userID, Guid?communityID, int[] objectTypes, List <Business.TagWord> tagWords, bool global)
{
StringBuilder sb = new StringBuilder();
sb.AppendFormat("SELECT * ");
sb.AppendFormat("FROM hitbl_Notification_RegisteredEvent_NRE ");
sb.AppendFormat("WHERE ");
sb.AppendFormat("NUS_USR_ID = '{0}' ", currentUserID);
sb.AppendFormat("AND NRE_IsGlobal = {0} ", global ? 1 : 0);
if (objectID.HasValue)
{
sb.AppendFormat("AND NRE_ObjectID = '{0}' ", objectID);
}
if (userID.HasValue)
{
sb.AppendFormat("AND NRE_UserID = '{0}' ", userID);
}
if (communityID.HasValue)
{
sb.AppendFormat("AND NRE_CommunityID = '{0}' ", communityID);
}
if (objectTypes != null && objectTypes.Length > 0)
{
sb.AppendFormat("AND (");
for (int i = 0; i < objectTypes.Length; i++)
{
sb.AppendFormat("({0} IN (SELECT OBJ_Type FROM hirel_Notification_Event_ObjectType_NEO WHERE hirel_Notification_Event_ObjectType_NEO.NRE_ID = hitbl_Notification_RegisteredEvent_NRE.NRE_ID)) ", (int)objectTypes[i]);
if (i < objectTypes.Length - 1)
{
sb.AppendFormat("AND ");
}
}
sb.AppendFormat(") ");
}
if (tagWords != null && tagWords.Count > 0)
{
sb.AppendFormat("AND ( 1=1 ");
for (int tagGroupID = 1; tagGroupID < 4; tagGroupID++)
{
List <Business.TagWord> tagWordPerGroup = tagWords.FindAll(x => x.GroupID == tagGroupID);
if (tagWordPerGroup.Count > 0)
{
for (int i = 0; i < tagWordPerGroup.Count; i++)
{
sb.AppendFormat("AND ('{0}' IN (SELECT TGW_ID FROM hirel_Notification_Event_TagLog_NET WHERE hirel_Notification_Event_TagLog_NET.NRE_ID = hitbl_Notification_RegisteredEvent_NRE.NRE_ID AND hirel_Notification_Event_TagLog_NET.NET_TagWordGroup = {1})) ", tagWordPerGroup[i].TagID, tagWordPerGroup[i].GroupID);
}
}
else
{
sb.AppendFormat("AND (NOT EXISTS (SELECT TGW_ID FROM hirel_Notification_Event_TagLog_NET WHERE hirel_Notification_Event_TagLog_NET.NRE_ID = hitbl_Notification_RegisteredEvent_NRE.NRE_ID AND hirel_Notification_Event_TagLog_NET.NET_TagWordGroup = {0})) ", tagGroupID);
}
}
sb.AppendFormat(") ");
}
sb.AppendFormat(" ORDER BY NRE_CommunityID, NRE_UserID, NRE_Identifier");
SqlConnection sqlConnection = new SqlConnection(connectionString);
try
{
SqlCommand sqlCommand = new SqlCommand();
sqlCommand.Connection = sqlConnection;
sqlCommand.CommandType = CommandType.Text;
sqlCommand.CommandText = sb.ToString();
sqlConnection.Open();
SqlDataReader registrationItemSqlReader = sqlCommand.ExecuteReader();
while (registrationItemSqlReader.Read())
{
Business.Registration item;
if (useConfig)
{
EventIdentifier identifier = (EventIdentifier)Convert.ToInt32(registrationItemSqlReader["NRE_Identifier"]);
item = list.GetItemByType(identifier);
}
else
{
Business.ConfigurationList listConfig = new Business.ConfigurationList(); // TODO: Load config in business logic
listConfig.Load(list.RootFolder);
EventIdentifier eventType = (EventIdentifier)Convert.ToInt32(registrationItemSqlReader["NRE_Identifier"]);
item = CopyConfig(listConfig[eventType], list, (bool)registrationItemSqlReader["NRE_IsGlobal"]);
list.Add(item);
}
FillObject(item, registrationItemSqlReader);
}
registrationItemSqlReader.Close();
foreach (Business.Registration item in list)
{
Business.Carrier objCarrier = item.Carriers.CheckedCarrier();
if (objCarrier != null && objCarrier.Type != CarrierType.None)
{
SqlCommand sqlCommand2 = new SqlCommand();
sqlCommand2.Connection = sqlConnection;
sqlCommand2.CommandType = CommandType.Text;
sqlCommand2.CommandText = string.Format("SELECT * FROM hirel_Notification_Event_ObjectType_NEO WHERE NRE_ID = '{0}'", item.ID);
SqlDataReader objectTypesSqlReader = sqlCommand2.ExecuteReader();
item.ObjectTypeList.Clear();
while (objectTypesSqlReader.Read())
{
FillObjectTypes(item, objectTypesSqlReader);
}
objectTypesSqlReader.Close();
SqlCommand sqlCommand3 = new SqlCommand();
sqlCommand3.Connection = sqlConnection;
sqlCommand3.CommandType = CommandType.Text;
sqlCommand3.CommandText = string.Format("SELECT * FROM hirel_Notification_Event_TagLog_NET WHERE NRE_ID = '{0}'", item.ID);
SqlDataReader tagWordsSqlReader = sqlCommand3.ExecuteReader();
item.TagWords.Clear();
while (tagWordsSqlReader.Read())
{
FillObjectTagWords(item, tagWordsSqlReader);
}
tagWordsSqlReader.Close();
}
}
}
finally
{
if (sqlConnection != null && sqlConnection.State != ConnectionState.Closed)
{
sqlConnection.Close();
}
}
}
public void ReportEvent(EventIdentifier identifier, Guid userIDLogedIn, Guid?objectID, int objectType, string title,
Guid?communityID, Guid?userID, Guid?parentID, DateTime?birthday, string subject, string body, bool confident)
{
SqlConnection Conn = new SqlConnection(Helper.GetSiemeConnectionString());
try
{
SqlCommand GetData = new SqlCommand();
GetData.Connection = Conn;
GetData.CommandType = CommandType.StoredProcedure;
GetData.CommandText = "hisp_Notification_Event_Insert";
GetData.Parameters.Add(SqlHelper.AddParameter("@Identifier", SqlDbType.Int, (int)identifier));
GetData.Parameters.Add(SqlHelper.AddParameter("@Confident", SqlDbType.Bit, confident ? 1 : 0));
GetData.Parameters.Add(SqlHelper.AddParameter("@USR_ID", SqlDbType.UniqueIdentifier, userIDLogedIn));
if (objectID.HasValue)
{
GetData.Parameters.Add(SqlHelper.AddParameter("@OBJ_ID", SqlDbType.UniqueIdentifier, objectID.Value));
}
else
{
GetData.Parameters.Add(SqlHelper.AddParameter("@OBJ_ID", SqlDbType.UniqueIdentifier));
}
if (objectType != 0)
{
GetData.Parameters.Add(SqlHelper.AddParameter("@OBJ_Type", SqlDbType.Int, objectType));
}
else
{
GetData.Parameters.Add(SqlHelper.AddParameter("@OBJ_Type", SqlDbType.Int));
}
if (userID.HasValue)
{
GetData.Parameters.Add(SqlHelper.AddParameter("@OBJ_USR_ID", SqlDbType.UniqueIdentifier, userID.Value));
}
else
{
GetData.Parameters.Add(SqlHelper.AddParameter("@OBJ_USR_ID", SqlDbType.UniqueIdentifier));
}
if (communityID.HasValue)
{
GetData.Parameters.Add(SqlHelper.AddParameter("@OBJ_CTY_ID", SqlDbType.UniqueIdentifier, communityID.Value));
}
else
{
GetData.Parameters.Add(SqlHelper.AddParameter("@OBJ_CTY_ID", SqlDbType.UniqueIdentifier));
}
if (parentID.HasValue)
{
GetData.Parameters.Add(SqlHelper.AddParameter("@OBJ_Parent_ID", SqlDbType.UniqueIdentifier, parentID.Value));
}
else
{
GetData.Parameters.Add(SqlHelper.AddParameter("@OBJ_Parent_ID", SqlDbType.UniqueIdentifier));
}
if (birthday != null)
{
GetData.Parameters.Add(SqlHelper.AddParameter("@OBJ_Birthday", SqlDbType.DateTime, birthday.Value.Date));
}
else
{
GetData.Parameters.Add(SqlHelper.AddParameter("@OBJ_Birthday", SqlDbType.UniqueIdentifier));
}
if (subject.Length > 0)
{
GetData.Parameters.Add(SqlHelper.AddParameter("@Subject", SqlDbType.UniqueIdentifier, subject));
}
else
{
GetData.Parameters.Add(SqlHelper.AddParameter("@Subject", SqlDbType.UniqueIdentifier));
}
if (body.Length > 0)
{
GetData.Parameters.Add(SqlHelper.AddParameter("@Body", SqlDbType.UniqueIdentifier, body));
}
else
{
GetData.Parameters.Add(SqlHelper.AddParameter("@Body", SqlDbType.UniqueIdentifier));
}
Conn.Open();
GetData.ExecuteNonQuery();
}
finally
{
Conn.Close();
}
}
public static void ReportEvent(EventIdentifier identifier, Guid userIDLogedIn, Guid?objectID, bool confident)
{
Data.Event objData = new Data.Event();
objData.ReportEvent(identifier, userIDLogedIn, objectID, null, string.Empty, string.Empty, confident);
}
public Registration GetItemByType(EventIdentifier key)
{
return(list.Find(x => x.Identifier == key));
}
public static Event Unresolved(EventIdentifier eventIdentifier, DeclaredType type)
{
return new Event(eventIdentifier, type) { IsResolved = false };
}
/// <summary>
/// Initializes a new instance of the <see cref="Event"/> class.
/// </summary>
/// <param name="identifier">
/// The identifier.
/// </param>
/// <param name="type">
/// The type.
/// </param>
public Event(EventIdentifier identifier, DeclaredType type)
: base(identifier)
{
this.Type = type;
}
/// <summary>
/// Builds a Event and sets its identifier to the correct vale
/// </summary>
public Event()
{
identifier = EventIdentifier.GenericEvent;
}
private void ReplaceTag(StringBuilder target, SqlDataReader sqlReader, EventIdentifier eventIdentifier)
{
int enuObjectType = (int)Convert.ToInt32(sqlReader["OBJ_Type"]);
DateTime dat = DateTime.Parse(sqlReader["NEV_Time"].ToString());
if (target.ToString().IndexOf(Constants.K_FIELD_WEB_ROOT) > -1)
{
target = target.Replace(Constants.K_FIELD_WEB_ROOT, strWebRoot);
}
if (target.ToString().IndexOf(Constants.K_FIELD_EVENT_LINK) > -1)
{
if (eventIdentifier == EventIdentifier.NewMember)
{
target = target.Replace(Constants.K_FIELD_EVENT_LINK, EventLink(Helper.GetObjectTypeNumericID("Community"), sqlReader["NRE_ForObjectID"].ToString()));
}
else
{
target = target.Replace(Constants.K_FIELD_EVENT_LINK, EventLink(enuObjectType, sqlReader["OBJ_ID"].ToString()));
}
}
if (target.ToString().IndexOf(Constants.K_FIELD_USER_LINK) > -1)
{
target = target.Replace(Constants.K_FIELD_USER_LINK, UserLink(sqlReader["OBJ_ID"].ToString()));
}
if (target.ToString().IndexOf(Constants.K_FIELD_COMMUNITY_LINK) > -1)
{
target = target.Replace(Constants.K_FIELD_COMMUNITY_LINK, CommunityLink(sqlReader["OBJ_ID"].ToString()));
}
if (target.ToString().IndexOf(Constants.K_FIELD_EVENT_TITLE) > -1)
{
target = target.Replace(Constants.K_FIELD_EVENT_TITLE, sqlReader["OBJ_Title"].ToString());
}
if (target.ToString().IndexOf(Constants.K_FIELD_EVENT_OBJECT_BIRTHDATE_AGE) > -1)
{
if (sqlReader["OBJ_Birthday"] != DBNull.Value)
{
int intAge = DateTime.Now.Year - Convert.ToDateTime(sqlReader["OBJ_Birthday"]).Year;
target = target.Replace(Constants.K_FIELD_EVENT_OBJECT_BIRTHDATE_AGE, intAge.ToString());
}
else
{
target = target.Replace(Constants.K_FIELD_EVENT_OBJECT_BIRTHDATE_AGE, "[not set]");
}
}
if (target.ToString().IndexOf(Constants.K_FIELD_EVENT_OBJECT_BIRTHDATE_DAY) > -1)
{
if (sqlReader["OBJ_Birthday"] != DBNull.Value)
{
target = target.Replace(Constants.K_FIELD_EVENT_OBJECT_BIRTHDATE_DAY, Convert.ToDateTime(sqlReader["OBJ_Birthday"]).Day.ToString());
}
else
{
target = target.Replace(Constants.K_FIELD_EVENT_OBJECT_BIRTHDATE_DAY, "[not set]");
}
}
if (target.ToString().IndexOf(Constants.K_FIELD_EVENT_OBJECT_BIRTHDATE_DAY_LONG) > -1)
{
if (sqlReader["OBJ_Birthday"] != DBNull.Value)
{
target = target.Replace(Constants.K_FIELD_EVENT_OBJECT_BIRTHDATE_DAY_LONG, Convert.ToDateTime(sqlReader["OBJ_Birthday"]).ToString("dddd"));
}
else
{
target = target.Replace(Constants.K_FIELD_EVENT_OBJECT_BIRTHDATE_DAY_LONG, "[not set]");
}
}
if (target.ToString().IndexOf(Constants.K_FIELD_EVENT_OBJECT_BIRTHDATE_MONTH) > -1)
{
if (sqlReader["OBJ_Birthday"] != DBNull.Value)
{
target = target.Replace(Constants.K_FIELD_EVENT_OBJECT_BIRTHDATE_MONTH, Convert.ToDateTime(sqlReader["OBJ_Birthday"]).Month.ToString());
}
else
{
target = target.Replace(Constants.K_FIELD_EVENT_OBJECT_BIRTHDATE_MONTH, "[not set]");
}
}
if (target.ToString().IndexOf(Constants.K_FIELD_EVENT_OBJECT_BIRTHDATE_MONTH_LONG) > -1)
{
if (sqlReader["OBJ_Birthday"] != DBNull.Value)
{
target = target.Replace(Constants.K_FIELD_EVENT_OBJECT_BIRTHDATE_MONTH_LONG, Convert.ToDateTime(sqlReader["OBJ_Birthday"]).ToString("MMMM"));
}
else
{
target = target.Replace(Constants.K_FIELD_EVENT_OBJECT_BIRTHDATE_MONTH_LONG, "[not set]");
}
}
if (target.ToString().IndexOf(Constants.K_FIELD_EVENT_OBJECT_BIRTHDATE_YEAR) > -1)
{
if (sqlReader["OBJ_Birthday"] != DBNull.Value)
{
target = target.Replace(Constants.K_FIELD_EVENT_OBJECT_BIRTHDATE_YEAR, Convert.ToDateTime(sqlReader["OBJ_Birthday"]).Year.ToString());
}
else
{
target = target.Replace(Constants.K_FIELD_EVENT_OBJECT_BIRTHDATE_YEAR, "[not set]");
}
}
if (target.ToString().IndexOf(Constants.K_FIELD_EVENT_DATE) > -1)
{
target = target.Replace(Constants.K_FIELD_EVENT_DATE, dat.ToShortDateString());
}
if (target.ToString().IndexOf(Constants.K_FIELD_EVENT_TIME) > -1)
{
target = target.Replace(Constants.K_FIELD_EVENT_TIME, dat.ToShortTimeString());
}
if (target.ToString().IndexOf(Constants.K_FIELD_EVENT_OBJECT_TYPE) > -1)
{
target = target.Replace(Constants.K_FIELD_EVENT_OBJECT_TYPE, enuObjectType.ToString());
}
if (target.ToString().IndexOf(Constants.K_FIELD_USER_ID) > -1)
{
target = target.Replace(Constants.K_FIELD_USER_ID, sqlReader["NUS_USR_ID"].ToString());
}
if (target.ToString().IndexOf(Constants.K_FIELD_USER_NICKNAME) > -1)
{
target = target.Replace(Constants.K_FIELD_USER_NICKNAME, sqlReader["NUS_Nickname"].ToString());
}
if (target.ToString().IndexOf(Constants.K_FIELD_USER_NAME) > -1)
{
target = target.Replace(Constants.K_FIELD_USER_NAME, sqlReader["NUS_Name"].ToString());
}
if (target.ToString().IndexOf(Constants.K_FIELD_USER_FIRSTNAME) > -1)
{
if (sqlReader["NUS_Firstname"] == null)
{
target = target.Replace(Constants.K_FIELD_USER_FIRSTNAME, sqlReader["NUS_Firstname"].ToString());
}
else
{
target = target.Replace(Constants.K_FIELD_USER_FIRSTNAME, sqlReader["NUS_Nickname"].ToString());
}
}
}
public Event(EventIdentifier identifier, DeclaredType type)
: base(identifier)
{
Type = type;
}
private string GetEventString(EventIdentifier ident)
{
string key = "TextAlerts" + ident.ToString();
return(language.GetString(key));
}
public UndocumentedEvent(EventIdentifier name, EventInfo ev, Type targetType)
: base(name, null, ev, targetType)
{}
