/// <summary> /// Gets the specified <see cref="Rock.Model.EntityType"/> by the object type. If a match is not found, it can optionally create a new <see cref="Rock.Model.EntityType"/> for the object. /// </summary> /// <param name="type">The <see cref="System.Type"/> to search for.</param> /// <param name="createIfNotFound">A <see cref="System.Boolean"/> value that indicates if a new <see cref="Rock.Model.EntityType"/> should be created if a match is not found. This value /// will be <c>true</c> if a new <see cref="Rock.Model.EntityType"/> should be created if there is not a match; otherwise <c>false</c>/</param> /// <param name="personAlias">A <see cref="Rock.Model.PersonAlias"/> representing the alias of the <see cref="Rock.Model.Person"/> who is searching for and possibly creating a new EntityType. This value can be /// null if the logged in person is not known (i.e. an anonymous user).</param> /// <returns>A <see cref="Rock.Model.EntityType"/> matching the provided type. If a match is not found and createIfNotFound is false this value will be null.</returns> public EntityType Get(Type type, bool createIfNotFound, PersonAlias personAlias) { var entityType = Get(type.FullName); if (entityType != null) { return(entityType); } if (createIfNotFound) { // Create a new context so type can be saved independing of current context using (var rockContext = new RockContext()) { var entityTypeService = new EntityTypeService(rockContext); entityType = new EntityType(); entityType.Name = type.FullName; entityType.FriendlyName = type.Name.SplitCase(); entityType.AssemblyName = type.AssemblyQualifiedName; entityTypeService.Add(entityType); rockContext.SaveChanges(); } // Read type using current context return(this.Get(entityType.Id)); } return(null); }
/// <summary> /// Gets the by public key. /// </summary> /// <param name="publicKey">The public key.</param> /// <returns></returns> public virtual PersonAlias GetByAliasPublicKey(string publicKey) { try { string[] idParts = publicKey.Split('>'); if (idParts.Length == 2) { int id = Int32.Parse(idParts[0]); Guid guid = new Guid(idParts[1]); PersonAlias personAlias = GetByAliasId(id); if (personAlias != null && personAlias.AliasPersonGuid.CompareTo(guid) == 0) { return(personAlias); } } return(null); } catch { return(null); } }
/// <summary> /// Gets the PersonAlias the by AliasPersonId /// </summary> /// <param name="aliasPersonId">The alias person identifier.</param> /// <returns></returns> public virtual PersonAlias GetByAliasId(int aliasPersonId) { var personAlias = Queryable("Person").Where(a => a.AliasPersonId == aliasPersonId).FirstOrDefault(); if (personAlias != null) { return(personAlias); } else { // If the personId is valid, there should be a personAlias with the AliasPersonID equal // to that personId. If there isn't for some reason, create it now. var person = new PersonService((RockContext)this.Context).Get(aliasPersonId); if (person != null) { personAlias = new PersonAlias(); personAlias.Guid = Guid.NewGuid(); personAlias.AliasPersonId = person.Id; personAlias.AliasPersonGuid = person.Guid; personAlias.PersonId = person.Id; // Use a different context so calling method's changes are not yet saved var rockContext = new RockContext(); new PersonAliasService(rockContext).Add(personAlias); rockContext.SaveChanges(); return(Get(personAlias.Id)); } } return(null); }
/// <summary> /// Logs new <see cref="Rock.Model.ExceptionLog" /> entities. This method serves as an interface to asynchronously log exceptions. /// </summary> /// <param name="ex">A <see cref="System.Exception" /> object to log.</param> /// <param name="request">The <see cref="T:System.Net.HttpRequestMessage" /></param> /// <param name="personAlias">The person alias.</param> public static void LogApiException(Exception ex, HttpRequestMessage request, PersonAlias personAlias = null) { // Populate the initial ExceptionLog with data from HttpContext. Must capture initial // HttpContext details before spinning off new thread, because the current context will // not be the same within the context of the new thread. var exceptionLog = PopulateExceptionLog(ex, request, personAlias); // Spin off a new thread to handle the real logging work so the UI is not blocked whilst // recursively writing to the database. Task.Run(() => LogExceptions(ex, exceptionLog, true)); }
/// <summary> /// Gets the value. /// </summary> /// <param name="personAlias">The person alias.</param> /// <param name="personAliasId">The person alias identifier.</param> /// <param name="rockContext">The rock context.</param> /// <param name="blankValue">The blank value.</param> /// <returns></returns> private static string GetPersonAliasValue(PersonAlias personAlias, int?personAliasId, RockContext rockContext, string blankValue) { Person person = null; if (personAlias != null && personAlias.Person != null) { person = personAlias.Person; } else if (personAliasId.HasValue) { person = new PersonAliasService(rockContext).GetPerson(personAliasId.Value); } return(person != null?string.Format("{0} [{1}]", person.FullName, person.Id) : blankValue); }
/// <summary> /// Creates and stores a new PersonToken for a person using the specified ExpireDateTime, UsageLimit, and Page /// Returns the encrypted URLEncoded Token which can be used as a rckipid /// </summary> /// <param name="personAlias">The person alias.</param> /// <param name="expireDateTime">The expire date time.</param> /// <param name="usageLimit">The usage limit.</param> /// <param name="pageId">The page identifier.</param> /// <returns></returns> public static string CreateNew(PersonAlias personAlias, DateTime?expireDateTime, int?usageLimit, int?pageId) { if (personAlias == null) { return(null); } using (var rockContext = new RockContext()) { var token = Rock.Security.Encryption.GenerateUniqueToken(); PersonToken personToken = new PersonToken(); personToken.PersonAliasId = personAlias.Id; personToken.Token = token; if (expireDateTime != null) { personToken.ExpireDateTime = expireDateTime; } else { int?tokenExpireMinutes = GlobalAttributesCache.Get().GetValue("core.PersonTokenExpireMinutes").AsIntegerOrNull(); if (tokenExpireMinutes.HasValue) { personToken.ExpireDateTime = RockDateTime.Now.AddMinutes(tokenExpireMinutes.Value); } else { personToken.ExpireDateTime = null; } } personToken.TimesUsed = 0; personToken.UsageLimit = usageLimit ?? GlobalAttributesCache.Get().GetValue("core.PersonTokenUsageLimit").AsIntegerOrNull(); personToken.PageId = pageId; var personTokenService = new PersonTokenService(rockContext); personTokenService.Add(personToken); rockContext.SaveChanges(true); var encryptedToken = Rock.Security.Encryption.EncryptString(token); // do a Replace('%', '!') after we UrlEncode it (to make it more safely embeddable in HTML and cross browser compatible) return(System.Web.HttpUtility.UrlEncode(encryptedToken).Replace('%', '!')); } }
/// <summary> /// Returns a <see cref="System.String" /> that represents this instance. /// </summary> /// <returns> /// A <see cref="System.String" /> that represents this instance. /// </returns> public override string ToString() { var sb = new StringBuilder(); sb.AppendFormat("{0} ", this.AllowOrDeny == "A" ? "Allow" : "Deny"); if (SpecialRole != Model.SpecialRole.None) { sb.AppendFormat("{0} ", SpecialRole.ToStringSafe().SplitCase()); } else if (PersonAlias != null) { sb.AppendFormat("{0} ", PersonAlias.ToStringSafe()); } else if (Group != null) { sb.AppendFormat("{0} ", Group.ToStringSafe()); } sb.AppendFormat("{0} Access", Action); return(sb.ToString()); }
/// <summary> /// Evaluates the person alias change. /// </summary> /// <param name="historyMessages">The history messages.</param> /// <param name="propertyName">Name of the property.</param> /// <param name="oldPersonAliasId">The old person alias identifier.</param> /// <param name="newPersonAlias">The new person alias.</param> /// <param name="newPersonAliasId">The new person alias identifier.</param> /// <param name="rockContext">The rock context.</param> public static void EvaluateChange(List <string> historyMessages, string propertyName, int?oldPersonAliasId, PersonAlias newPersonAlias, int?newPersonAliasId, RockContext rockContext) { EvaluateChange(historyMessages, propertyName, oldPersonAliasId, newPersonAlias, newPersonAliasId, rockContext, string.Empty, false); }
/// <summary> /// Populates the <see cref="Rock.Model.ExceptionLog" /> entity with the exception data. /// </summary> /// <param name="ex">The <see cref="System.Exception" /> to log.</param> /// <param name="context">The <see cref="System.Web.HttpContext" />.</param> /// <param name="pageId">An <see cref="System.Int32" /> containing the Id of the <see cref="Rock.Model.Page" /> where the exception occurred. /// This value is nullable.</param> /// <param name="siteId">An <see cref="System.Int32" /> containing the Id the <see cref="Rock.Model.Site" /> where the exception occurred. /// This value is nullable.</param> /// <param name="personAlias">The person alias.</param> /// <returns></returns> private static ExceptionLog PopulateExceptionLog(Exception ex, HttpContext context, int?pageId, int?siteId, PersonAlias personAlias) { int?personAliasId = null; if (personAlias != null) { personAliasId = personAlias.Id; } var exceptionLog = new ExceptionLog { SiteId = siteId, PageId = pageId, HasInnerException = ex.InnerException != null, ExceptionType = ex.GetType().ToString(), Description = ex.Message, Source = ex.Source, StackTrace = ex.StackTrace, Guid = Guid.NewGuid(), CreatedByPersonAliasId = personAliasId, ModifiedByPersonAliasId = personAliasId, CreatedDateTime = RockDateTime.Now, ModifiedDateTime = RockDateTime.Now }; try { // If current HttpContext is null, return early. if (context == null) { return(exceptionLog); } // If current HttpContext is available, populate its information as well. var request = context.Request; StringBuilder cookies = new StringBuilder(); var cookieList = request.Cookies; if (cookieList.Count > 0) { cookies.Append("<table class=\"cookies exception-table\">"); foreach (string cookie in cookieList) { var httpCookie = cookieList[cookie]; if (httpCookie != null) { cookies.Append("<tr><td><b>" + cookie + "</b></td><td>" + httpCookie.Value + "</td></tr>"); } } cookies.Append("</table>"); } StringBuilder formItems = new StringBuilder(); var formList = request.Form; if (formList.Count > 0) { formItems.Append("<table class=\"form-items exception-table\">"); foreach (string formItem in formList) { formItems.Append("<tr><td><b>" + formItem + "</b></td><td>" + formList[formItem] + "</td></tr>"); } formItems.Append("</table>"); } StringBuilder serverVars = new StringBuilder(); var serverVarList = request.ServerVariables; if (serverVarList.Count > 0) { serverVars.Append("<table class=\"server-variables exception-table\">"); foreach (string serverVar in serverVarList) { serverVars.Append("<tr><td><b>" + serverVar + "</b></td><td>" + serverVarList[serverVar] + "</td></tr>"); } serverVars.Append("</table>"); } exceptionLog.Cookies = cookies.ToString(); exceptionLog.StatusCode = context.Response.StatusCode.ToString(); exceptionLog.PageUrl = request.Url.ToString(); exceptionLog.ServerVariables = serverVars.ToString(); exceptionLog.QueryString = request.Url.Query; exceptionLog.Form = formItems.ToString(); } catch { // Intentionally do nothing } return(exceptionLog); }
/// <summary> /// Populates the <see cref="Rock.Model.ExceptionLog" /> entity with the exception data. /// </summary> /// <param name="ex">The <see cref="System.Exception" /> to log.</param> /// <param name="context">The <see cref="System.Web.HttpContext" />.</param> /// <param name="pageId">An <see cref="System.Int32" /> containing the Id of the <see cref="Rock.Model.Page" /> where the exception occurred. /// This value is nullable.</param> /// <param name="siteId">An <see cref="System.Int32" /> containing the Id the <see cref="Rock.Model.Site" /> where the exception occurred. /// This value is nullable.</param> /// <param name="personAlias">The person alias.</param> /// <returns></returns> private static ExceptionLog PopulateExceptionLog(Exception ex, HttpContext context, int?pageId, int?siteId, PersonAlias personAlias) { int?personAliasId = null; if (personAlias != null) { personAliasId = personAlias.Id; } string exceptionMessage = ex.Message; if (ex is System.Data.SqlClient.SqlException) { var sqlEx = ex as System.Data.SqlClient.SqlException; var sqlErrorList = sqlEx.Errors.OfType <System.Data.SqlClient.SqlError>().ToList().Select(a => string.Format("{0}: Line {1}", a.Procedure, a.LineNumber)); if (sqlErrorList.Any()) { exceptionMessage += string.Format("[{0}]", sqlErrorList.ToList().AsDelimited(", ")); } } var exceptionLog = new ExceptionLog { SiteId = siteId, PageId = pageId, HasInnerException = ex.InnerException != null, ExceptionType = ex.GetType().ToString(), Description = exceptionMessage, Source = ex.Source, StackTrace = ex.StackTrace, Guid = Guid.NewGuid(), CreatedByPersonAliasId = personAliasId, ModifiedByPersonAliasId = personAliasId, CreatedDateTime = RockDateTime.Now, ModifiedDateTime = RockDateTime.Now, ModifiedAuditValuesAlreadyUpdated = true }; if (exceptionLog.StackTrace == null) { try { // if the Exception didn't include a StackTrace, manually grab it var stackTrace = new System.Diagnostics.StackTrace(2); exceptionLog.StackTrace = stackTrace.ToString(); } catch { // ignore } } try { ex.Data.Add("ExceptionLogGuid", exceptionLog.Guid); } catch { // ignore } try { // If current HttpContext is null, return early. if (context == null) { return(exceptionLog); } // If current HttpContext is available, populate its information as well. var request = context.Request; StringBuilder cookies = new StringBuilder(); var cookieList = request.Cookies; if (cookieList.Count > 0) { cookies.Append("<table class=\"cookies exception-table\">"); foreach (string cookie in cookieList) { var httpCookie = cookieList[cookie]; if (httpCookie != null) { cookies.Append("<tr><td><b>" + cookie + "</b></td><td>" + httpCookie.Value.EncodeHtml() + "</td></tr>"); } } cookies.Append("</table>"); } StringBuilder formItems = new StringBuilder(); var formList = request.Form; if (formList.Count > 0) { formItems.Append("<table class=\"form-items exception-table\">"); foreach (string formItem in formList) { if (formItem.IsNotNullOrWhiteSpace()) { string formValue = formList[formItem].EncodeHtml(); string lc = formItem.ToLower(); if (lc.Contains("nolog") || lc.Contains("creditcard") || lc.Contains("cc-number") || lc.Contains("cvv") || lc.Contains("ssn") || lc.Contains("accountnumber") || lc.Contains("account-number")) { formValue = "***obfuscated***"; } formItems.Append("<tr><td><b>" + formItem + "</b></td><td>" + formValue + "</td></tr>"); } } formItems.Append("</table>"); } StringBuilder serverVars = new StringBuilder(); var serverVarList = request.ServerVariables; if (serverVarList.Count > 0) { serverVars.Append("<table class=\"server-variables exception-table\">"); foreach (string serverVar in serverVarList) { string val = string.Empty; try { // 'serverVarList[serverVar]' throws an exception if the value is empty, even if the key exists. Was not able to find a more elegant way to avoid an exception. val = serverVarList[serverVar].ToStringSafe().EncodeHtml(); } catch { } serverVars.Append($"<tr><td><b>{serverVar}</b></td><td>{val}</td></tr>"); } serverVars.Append("</table>"); } exceptionLog.Cookies = cookies.ToString(); exceptionLog.StatusCode = context.Response.StatusCode.ToString(); exceptionLog.PageUrl = request.Url.ToString(); exceptionLog.ServerVariables = serverVars.ToString(); exceptionLog.QueryString = request.Url.Query; exceptionLog.Form = formItems.ToString(); } catch { // Intentionally do nothing } return(exceptionLog); }
public GroupMember GetInverseRelationship(GroupMember groupMember, bool createGroup, PersonAlias personAlias) { return(GetInverseRelationship(groupMember, createGroup)); }
/// <summary> /// Populates the <see cref="Rock.Model.ExceptionLog" /> entity with the exception data. /// </summary> /// <param name="ex">The <see cref="System.Exception" /> to log.</param> /// <param name="context">The <see cref="System.Web.HttpContext" />.</param> /// <param name="pageId">An <see cref="System.Int32" /> containing the Id of the <see cref="Rock.Model.Page" /> where the exception occurred. /// This value is nullable.</param> /// <param name="siteId">An <see cref="System.Int32" /> containing the Id the <see cref="Rock.Model.Site" /> where the exception occurred. /// This value is nullable.</param> /// <param name="personAlias">The person alias.</param> /// <returns></returns> private static ExceptionLog PopulateExceptionLog(Exception ex, HttpContext context, int?pageId, int?siteId, PersonAlias personAlias) { int?personAliasId = null; if (personAlias != null) { personAliasId = personAlias.Id; } string exceptionMessage = ex.Message; if (ex is System.Data.SqlClient.SqlException) { var sqlEx = ex as System.Data.SqlClient.SqlException; var sqlErrorList = sqlEx.Errors.OfType <System.Data.SqlClient.SqlError>().ToList().Select(a => string.Format("{0}: Line {1}", a.Procedure, a.LineNumber)); if (sqlErrorList.Any()) { exceptionMessage += string.Format("[{0}]", sqlErrorList.ToList().AsDelimited(", ")); } } var exceptionLog = new ExceptionLog { SiteId = siteId, PageId = pageId, HasInnerException = ex.InnerException != null, ExceptionType = ex.GetType().ToString(), Description = exceptionMessage, Source = ex.Source, StackTrace = ex.StackTrace, Guid = Guid.NewGuid(), CreatedByPersonAliasId = personAliasId, ModifiedByPersonAliasId = personAliasId, CreatedDateTime = RockDateTime.Now, ModifiedDateTime = RockDateTime.Now, ModifiedAuditValuesAlreadyUpdated = true }; if (exceptionLog.StackTrace == null) { try { // if the Exception didn't include a StackTrace, manually grab it var stackTrace = new System.Diagnostics.StackTrace(2); exceptionLog.StackTrace = stackTrace.ToString(); } catch { } } try { ex.Data.Add("ExceptionLogGuid", exceptionLog.Guid); } catch { } try { // If current HttpContext is null, return early. if (context == null) { return(exceptionLog); } // If current HttpContext is available, populate its information as well. var request = context.Request; StringBuilder cookies = new StringBuilder(); var cookieList = request.Cookies; if (cookieList.Count > 0) { cookies.Append("<table class=\"cookies exception-table\">"); foreach (string cookie in cookieList) { var httpCookie = cookieList[cookie]; if (httpCookie != null) { cookies.Append("<tr><td><b>" + cookie + "</b></td><td>" + httpCookie.Value.EncodeHtml() + "</td></tr>"); } } cookies.Append("</table>"); } StringBuilder serverVars = new StringBuilder(); // 'serverVarList[serverVar]' throws an exception if the value is empty, even if the key exists, // so make a copy of the request server variables to help avoid that error var serverVarList = new NameValueCollection(request.ServerVariables); var serverVarListString = serverVarList.ToString(); var serverVarKeys = request.ServerVariables.AllKeys; if (serverVarList.Count > 0) { serverVars.Append("<table class=\"server-variables exception-table\">"); foreach (string serverVar in serverVarList) { string val = string.Empty; try { val = serverVarList[serverVar].ToStringSafe().EncodeHtml(); } catch { // ignore } serverVars.Append($"<tr><td><b>{serverVar}</b></td><td>{val}</td></tr>"); } serverVars.Append("</table>"); } exceptionLog.Cookies = cookies.ToString(); exceptionLog.StatusCode = context.Response.StatusCode.ToString(); exceptionLog.PageUrl = request.UrlProxySafe().ToString(); exceptionLog.ServerVariables = serverVars.ToString(); exceptionLog.QueryString = request.UrlProxySafe().Query; /* * SK - 11/24/2021 * We are commenting out below line as we have decided not to store form data from now on as it may contain sensative data. * exceptionLog.Form = formItems.ToString(); */ } catch { } return(exceptionLog); }
/// <summary> /// Creates and stores a new PersonToken for a person limited to a specific PageId /// Returns the encrypted URLEncoded Token which can be used as a rckipid /// </summary> /// <param name="personAlias">The person alias.</param> /// <param name="pageId">The page identifier.</param> /// <returns></returns> public static string CreateNew(PersonAlias personAlias, int pageId) { return(CreateNew(personAlias, null, null, pageId)); }
/// <summary> /// Creates and stores a new PersonToken for a person using the default ExpireDateTime and UsageLimit. /// Returns the encrypted URLEncoded Token which can be used as a rckipid. /// </summary> /// <param name="personAlias">The person alias.</param> /// <returns></returns> public static string CreateNew(PersonAlias personAlias) { return(CreateNew(personAlias, null, null, null)); }
/// <summary> /// Evaluates the change. /// </summary> /// <param name="historyMessages">The history messages.</param> /// <param name="propertyName">Name of the property.</param> /// <param name="oldPersonAliasId">The old person alias identifier.</param> /// <param name="newPersonAlias">The new person alias.</param> /// <param name="newPersonAliasId">The new person alias identifier.</param> /// <param name="rockContext">The rock context.</param> /// <param name="blankValue">The blank value.</param> /// <param name="isSensitive">if set to <c>true</c> [is sensitive].</param> public static void EvaluateChange(List <string> historyMessages, string propertyName, int?oldPersonAliasId, PersonAlias newPersonAlias, int?newPersonAliasId, RockContext rockContext, string blankValue, bool isSensitive) { if (!oldPersonAliasId.Equals(newPersonAliasId)) { string oldStringValue = GetValue <PersonAlias>(null, oldPersonAliasId, rockContext, blankValue); string newStringValue = GetValue <PersonAlias>(newPersonAlias, newPersonAliasId, rockContext, blankValue); EvaluateChange(historyMessages, propertyName, oldStringValue, newStringValue, isSensitive); } }
/// <summary> /// Gets the value. /// </summary> /// <param name="personAlias">The person alias.</param> /// <param name="personAliasId">The person alias identifier.</param> /// <param name="rockContext">The rock context.</param> /// <returns></returns> private static string GetPersonAliasValue(PersonAlias personAlias, int?personAliasId, RockContext rockContext) { return(GetPersonAliasValue(personAlias, personAliasId, rockContext, string.Empty)); }
/// <summary> /// Populates the <see cref="Rock.Model.ExceptionLog" /> entity with the exception data. /// </summary> /// <param name="ex">The <see cref="System.Exception" /> to log.</param> /// <param name="request">The <see cref="T:System.Net.HttpRequestMessage" />.</param> /// <param name="personAlias">The person alias.</param> /// <returns></returns> private static ExceptionLog PopulateExceptionLog(Exception ex, HttpRequestMessage request, PersonAlias personAlias) { string exceptionMessage = ex.Message; if (ex is System.Data.SqlClient.SqlException) { var sqlEx = ex as System.Data.SqlClient.SqlException; var sqlErrorList = sqlEx.Errors.OfType <System.Data.SqlClient.SqlError>().ToList().Select(a => string.Format("{0}: Line {1}", a.Procedure, a.LineNumber)); if (sqlErrorList.Any()) { exceptionMessage += string.Format("[{0}]", sqlErrorList.ToList().AsDelimited(", ")); } } var exceptionLog = new ExceptionLog { HasInnerException = ex.InnerException != null, ExceptionType = ex.GetType().ToString(), Description = exceptionMessage, Source = ex.Source, StackTrace = ex.StackTrace, Guid = Guid.NewGuid(), CreatedByPersonAliasId = personAlias?.Id, ModifiedByPersonAliasId = personAlias?.Id, CreatedDateTime = RockDateTime.Now, ModifiedDateTime = RockDateTime.Now, ModifiedAuditValuesAlreadyUpdated = true }; if (exceptionLog.StackTrace == null) { try { // if the Exception didn't include a StackTrace, manually grab it var stackTrace = new System.Diagnostics.StackTrace(2); exceptionLog.StackTrace = stackTrace.ToString(); } catch { } } try { ex.Data.Add("ExceptionLogGuid", exceptionLog.Guid); } catch { } try { // If current HttpRequestMessage is null, return early. if (request == null) { return(exceptionLog); } StringBuilder cookies = new StringBuilder(); var cookieList = request.Headers.GetCookies(); if (cookieList.Count > 0) { cookies.Append("<table class=\"cookies exception-table\">"); foreach (var cookieHeaderValue in cookieList) { foreach (var cookie in cookieHeaderValue.Cookies) { cookies.Append("<tr><td><b>" + cookie.Name + "</b></td><td>" + cookie.Value.EncodeHtml() + "</td></tr>"); } } cookies.Append("</table>"); } // // Check query string parameters for sensitive data. // string queryString = null; var queryCollection = request.RequestUri.ParseQueryString(); if (queryCollection.Count > 0) { var nvc = new NameValueCollection(); foreach (string qKey in queryCollection.Keys) { if (IsKeySensitive(qKey.ToLower())) { nvc.Add(qKey, "obfuscated"); } else { nvc.Add(qKey, queryCollection[qKey]); } } queryString = "?" + String.Join("&", nvc.AllKeys.Select(a => a.UrlEncode() + "=" + nvc[a].UrlEncode())); } exceptionLog.Cookies = cookies.ToString(); exceptionLog.PageUrl = request.RequestUri.GetLeftPart(UriPartial.Path); exceptionLog.QueryString = queryString; } catch { } return(exceptionLog); }
/// <summary> /// Populates the <see cref="Rock.Model.ExceptionLog" /> entity with the exception data. /// </summary> /// <param name="ex">The <see cref="System.Exception" /> to log.</param> /// <param name="context">The <see cref="System.Web.HttpContext" />.</param> /// <param name="pageId">An <see cref="System.Int32" /> containing the Id of the <see cref="Rock.Model.Page" /> where the exception occurred. /// This value is nullable.</param> /// <param name="siteId">An <see cref="System.Int32" /> containing the Id the <see cref="Rock.Model.Site" /> where the exception occurred. /// This value is nullable.</param> /// <param name="personAlias">The person alias.</param> /// <returns></returns> private static ExceptionLog PopulateExceptionLog(Exception ex, HttpContext context, int?pageId, int?siteId, PersonAlias personAlias) { int?personAliasId = null; if (personAlias != null) { personAliasId = personAlias.Id; } string exceptionMessage = ex.Message; if (ex is System.Data.SqlClient.SqlException) { var sqlEx = ex as System.Data.SqlClient.SqlException; var sqlErrorList = sqlEx.Errors.OfType <System.Data.SqlClient.SqlError>().ToList().Select(a => string.Format("{0}: Line {1}", a.Procedure, a.LineNumber)); if (sqlErrorList.Any()) { exceptionMessage += string.Format("[{0}]", sqlErrorList.ToList().AsDelimited(", ")); } } var exceptionLog = new ExceptionLog { SiteId = siteId, PageId = pageId, HasInnerException = ex.InnerException != null, ExceptionType = ex.GetType().ToString(), Description = exceptionMessage, Source = ex.Source, StackTrace = ex.StackTrace, Guid = Guid.NewGuid(), CreatedByPersonAliasId = personAliasId, ModifiedByPersonAliasId = personAliasId, CreatedDateTime = RockDateTime.Now, ModifiedDateTime = RockDateTime.Now, ModifiedAuditValuesAlreadyUpdated = true }; try { ex.Data.Add("ExceptionLogGuid", exceptionLog.Guid); } catch { // ignore } try { // If current HttpContext is null, return early. if (context == null) { return(exceptionLog); } // If current HttpContext is available, populate its information as well. var request = context.Request; StringBuilder cookies = new StringBuilder(); var cookieList = request.Cookies; if (cookieList.Count > 0) { cookies.Append("<table class=\"cookies exception-table\">"); foreach (string cookie in cookieList) { var httpCookie = cookieList[cookie]; if (httpCookie != null) { cookies.Append("<tr><td><b>" + cookie + "</b></td><td>" + httpCookie.Value.EncodeHtml() + "</td></tr>"); } } cookies.Append("</table>"); } StringBuilder formItems = new StringBuilder(); var formList = request.Form; if (formList.Count > 0) { formItems.Append("<table class=\"form-items exception-table\">"); foreach (string formItem in formList) { formItems.Append("<tr><td><b>" + formItem + "</b></td><td>" + formList[formItem].EncodeHtml() + "</td></tr>"); } formItems.Append("</table>"); } StringBuilder serverVars = new StringBuilder(); var serverVarList = request.ServerVariables; if (serverVarList.Count > 0) { serverVars.Append("<table class=\"server-variables exception-table\">"); foreach (string serverVar in serverVarList) { serverVars.Append("<tr><td><b>" + serverVar + "</b></td><td>" + serverVarList[serverVar].EncodeHtml() + "</td></tr>"); } serverVars.Append("</table>"); } exceptionLog.Cookies = cookies.ToString(); exceptionLog.StatusCode = context.Response.StatusCode.ToString(); exceptionLog.PageUrl = request.Url.ToString(); exceptionLog.ServerVariables = serverVars.ToString(); exceptionLog.QueryString = request.Url.Query; exceptionLog.Form = formItems.ToString(); } catch { // Intentionally do nothing } return(exceptionLog); }
/// <summary> /// Gets the inverse relationship. /// Returns the <see cref="Rock.Model.GroupMember" /> who has an inverse relationship to the provided <see cref="Rock.Model.GroupMember" />. /// </summary> /// <param name="groupMember">A <see cref="Rock.Model.GroupMember" /> representing the person to find the inverse relationship for.</param> /// <param name="createGroup">A <see cref="System.Boolean"/> flag indicating if a new <see cref="Rock.Model.Group"/> can be created /// for the person with the inverse relationship. </param> /// <param name="personAlias">The alias of the <see cref="Rock.Model.Person"/> who has the inverse relationship.</param> /// <returns> /// A <see cref="Rock.Model.GroupMember"/> representing the <see cref="Rock.Model.Person"/> with the inverse relationship. /// </returns> /// <remarks> /// In Rock, examples of inverse relationships include: Parent/Child, Can Check In/Check in By, Sibling/Sibling, Grandparent/Grandchild, etc. /// </remarks> public GroupMember GetInverseRelationship(GroupMember groupMember, bool createGroup, PersonAlias personAlias) { var groupRole = groupMember.GroupRole; if (groupRole == null) { groupRole = Queryable() .Where(m => m.Id == groupMember.Id) .Select(m => m.GroupRole) .FirstOrDefault(); } if (groupRole != null) { if (groupRole.Attributes == null) { groupRole.LoadAttributes(); } if (groupRole.Attributes.ContainsKey("InverseRelationship")) { Guid ownerRoleGuid = new Guid(Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_OWNER); var memberInfo = Queryable() .Where(m => m.GroupId == groupMember.GroupId && m.GroupRole.Guid.Equals(ownerRoleGuid)) .Select(m => new { PersonId = m.PersonId, RoleId = m.GroupRoleId }) .FirstOrDefault(); int?ownerPersonId = null; int?ownerRoleId = null; if (memberInfo != null) { ownerPersonId = memberInfo.PersonId; ownerRoleId = memberInfo.RoleId; } if (ownerPersonId.HasValue && ownerRoleId.HasValue) { // Find related person's group var inverseGroup = Queryable() .Where(m => m.PersonId == groupMember.PersonId && m.Group.GroupTypeId == groupRole.GroupTypeId && m.GroupRole.Guid.Equals(ownerRoleGuid)) .Select(m => m.Group) .FirstOrDefault(); if (inverseGroup == null && createGroup) { var ownerGroupMember = new GroupMember(); ownerGroupMember.PersonId = groupMember.PersonId; ownerGroupMember.GroupRoleId = ownerRoleId.Value; inverseGroup = new Group(); inverseGroup.Name = groupRole.GroupType.Name; inverseGroup.GroupTypeId = groupRole.GroupTypeId.Value; inverseGroup.Members.Add(ownerGroupMember); } if (inverseGroup != null) { Guid inverseRoleGuid = Guid.Empty; if (Guid.TryParse(groupRole.GetAttributeValue("InverseRelationship"), out inverseRoleGuid)) { var inverseGroupMember = Queryable() .Where(m => m.PersonId == ownerPersonId && m.GroupId == inverseGroup.Id && m.GroupRole.Guid.Equals(inverseRoleGuid)) .FirstOrDefault(); if (inverseGroupMember == null) { var inverseRole = new GroupTypeRoleService((RockContext)Context).Get(inverseRoleGuid); if (inverseRole != null) { inverseGroupMember = new GroupMember(); inverseGroupMember.PersonId = ownerPersonId.Value; inverseGroupMember.Group = inverseGroup; inverseGroupMember.GroupRoleId = inverseRole.Id; Add(inverseGroupMember); } } return(inverseGroupMember); } } } } } return(null); }