Пример #1
0
        private void BuildRoleMembersCache()
        {
            using (TicketDeskEntities ctx = new TicketDeskEntities())
            {
                var configuredTdRoles = new string[] { TdStaffRoleName, TdSubmittersRoleName, TdAdminRoleName };
                var sqlCacheMembers = ctx.AdCachedRoleMembers.ToList();//go ahead and fetch entire table
                foreach (var tdRole in configuredTdRoles)
                {
                    List<UserInfo> adUsersForTdRole = new List<UserInfo>();

                    adUsersForTdRole.AddRange(AdRepository.GetGroupMembersFromAd(tdRole));

                    foreach (var sMember in sqlCacheMembers.Where(rm => rm.GroupName == tdRole))//find roles in SQL that aren't in AD anymore
                    {
                        if (adUsersForTdRole.Count(au => au.Name == sMember.MemberName) < 1)
                        {
                            ctx.AdCachedRoleMembers.DeleteObject(sMember);
                        }
                    }
                    foreach (var aMember in adUsersForTdRole)// file roles in AD that need to be updated/added to SQL
                    {
                        var sMember = sqlCacheMembers.SingleOrDefault(sm => sm.GroupName == tdRole && sm.MemberName == aMember.Name);
                        if (sMember == null)//doesn't exist in SQL, insert
                        {
                            sMember = new AdCachedRoleMember();
                            sMember.GroupName = tdRole;
                            ctx.AdCachedRoleMembers.AddObject(sMember);
                        }
                        sMember.MemberName = aMember.Name;
                        sMember.MemberDisplayName = aMember.DisplayName;
                    }
                    ctx.SaveChanges();
                }
            }
        }
 public void ExecuteUpgrade(string script)
 {
     
     using (var ctx = new TicketDeskEntities())
     {
         var cString = (ctx.Connection as EntityConnection).StoreConnection.ConnectionString;//get connection string from entity framework context
         //entity framework doesn't help us with executing DML and DDL; so we go back to old-skoo ado. 
         SqlConnection conn = new SqlConnection(cString);
         SqlCommand cmd = new SqlCommand(script, conn);
         conn.Open();
         try
         {
             cmd.ExecuteNonQuery();
         }
         finally
         {
             conn.Close();
         }
     }
 }
        /// <summary>
        /// Ensures a valid next delivery date for any newly queud notifications when a notification has been rescheduled.
        /// </summary>
        /// <param name="ticketId">The ticket id.</param>
        /// <param name="notifyUser">The notify user.</param>
        /// <param name="lastSentCommentId">The last sent comment id.</param>
        /// <param name="nextDeliveryAttemptDate">The next delivery attempt date.</param>
        /// <remarks>
        /// While the system is processing ticket emails, new notifications could get queued up.
        /// This method should be called if the sending process has to re-schedule a notifiaciton 
        /// for a later re-try attempt. This will keep the notification that was being processed from
        /// having it's next delivery date kicked out further than newer comments that have queued up.
        /// It should look for any new notifications that are queued for the same user and ticket, 
        /// and ensure that their next-delivery date remains greater than the last one that was processed 
        /// and rescheduled.
        /// </remarks>
        public void EnsureValidNextDeliveryDateForNewlyQueudNotifications(int ticketId, string notifyUser, int lastSentCommentId, DateTime nextDeliveryAttemptDate)
        {

            using (var ctxNew = new TicketDeskEntities())
            {
                //the class's standard context will have cached data from any past reads. Do this on new context
                var newNotes = from tn in ctxNew.TicketEventNotifications
                               where tn.TicketId == ticketId && tn.NotifyUser == notifyUser && tn.CommentId > lastSentCommentId && tn.NextDeliveryAttemptDate <= nextDeliveryAttemptDate
                               select tn;
                if (newNotes.Count() > 0)
                {
                    int advanceSeconds = 1;
                    foreach (var newNote in newNotes)
                    {
                        newNote.NextDeliveryAttemptDate = nextDeliveryAttemptDate.AddSeconds(advanceSeconds);
                        advanceSeconds++;
                    }
                    ctxNew.SaveChanges();
                }
            }
        }
Пример #4
0
 /// <summary>
 /// Gets the group members.
 /// </summary>
 /// <param name="groupName">Name of the group.</param>
 /// <returns></returns>
 internal UserInfo[] GetGroupMembers(string groupName)
 {
     groupName = groupName.ToLowerInvariant();
     UserInfo[] usersInGroup = null;
     using (TicketDeskEntities ctx = new TicketDeskEntities())
     {
         var users = from m in ctx.AdCachedRoleMembers
                     where m.GroupName == groupName
                     select new UserInfo() { Name = m.MemberName, DisplayName = m.MemberDisplayName };
         if (users.Count() > 0)
         {
             usersInGroup = users.ToArray();
         }
     }
     return usersInGroup;
 }
Пример #5
0
        /// <summary>
        /// Gets the user property from the SQL store.
        /// </summary>
        /// <remarks>
        /// If the SQL store doesn't contain data for the user/property requested it will
        /// add the user/property to the table so it gets fetched next time the system 
        /// refreshes from AD. In the meantime though, the method will return null.
        /// </remarks>
        /// <param name="userName">Name of the user.</param>
        /// <param name="propertyName">Name of the property.</param>
        /// <returns>The property stored in the SQL cache; null if no value cached</returns>
        internal string GetUserProperty(string userName, string propertyName)
        {
            userName = userName.ToLowerInvariant();
            string propertyValue = null;

            using (TicketDeskEntities ctx = new TicketDeskEntities())
            {
                var val = ctx.AdCachedUserProperties.FirstOrDefault(p => p.UserName == userName && p.PropertyName == propertyName);

                if (val == null)
                {
                    //add this property/user to the table for the next automated refresh
                    var newUserProp = new AdCachedUserProperty()
                                        {
                                            UserName = userName,
                                            PropertyName = propertyName,
                                            PropertyValue = null,
                                            LastRefreshed = null,
                                            IsActiveInAd = true
                                        };
                    ctx.AdCachedUserProperties.AddObject(newUserProp);
                }
                else
                {
                    propertyValue = val.PropertyValue;
                }
                ctx.SaveChanges();
            }

            return propertyValue;
        }
Пример #6
0
        private IEnumerable<string> GetAllKnownDistinctUserNamesFrom()
        {
            List<string> allUsers = new List<string>();
    
            using (TicketDeskEntities ctx = new TicketDeskEntities())
            {
                //distincting each one of these just reduces the amount of data coming back from SQL
                //  it doesn't actually give us a truly distinct master list though.
                allUsers.AddRange(ctx.AdCachedRoleMembers.Select(r => r.MemberName.ToLower()).Distinct());
                allUsers.AddRange(ctx.Tickets.Select(t => t.CreatedBy.ToLower()).Distinct());
                allUsers.AddRange(ctx.Tickets.Select(t => t.Owner.ToLower()).Distinct());
                allUsers.AddRange(ctx.Tickets.Select(t => t.AssignedTo.ToLower()).Distinct());
                allUsers.AddRange(ctx.Tickets.Select(t => t.CurrentStatusSetBy.ToLower()).Distinct());
                allUsers.AddRange(ctx.Tickets.Select(t => t.LastUpdateBy.ToLower()).Distinct());
                allUsers.AddRange(ctx.TicketComments.Select(tc => tc.CommentedBy.ToLower()).Distinct());
                allUsers.AddRange(ctx.TicketAttachments.Select(ta => ta.UploadedBy.ToLower()).Distinct());


            }
            var badUsers = allUsers.Where(u => string.IsNullOrEmpty(u)).ToArray();
            foreach (var badUser in badUsers)
            {
                allUsers.Remove(badUser);
            }
            return allUsers.Distinct();//this gets the truly distinct list
          


        }
Пример #7
0
        private void EnsureStandardPropertiesForAllKnownUsers()
        {
            var allKnownUsers = GetAllKnownDistinctUserNamesFrom();
            using (TicketDeskEntities ctx = new TicketDeskEntities())
            {
                //go ahead and fetch entire table. The table is kinda big, but realistically 
                //  there should only be two rows per valid user... even with a thousand users, 
                //  that's not an obsurde amount of data. 
                var existingUserProperties = ctx.AdCachedUserProperties.ToList();


                //loop 1 to add all display name properties for any users not already in the SQL cache

                var existingProps = existingUserProperties.Where(ep => ep.PropertyName == "displayName");

                foreach (var knownUser in allKnownUsers)
                {
                    if (existingProps.Count(ep => string.Equals(ep.UserName, knownUser, StringComparison.InvariantCultureIgnoreCase)) < 1)
                    {
                        var newUserProp = new AdCachedUserProperty()
                                            {
                                                UserName = knownUser,
                                                PropertyName = "displayName",
                                                IsActiveInAd = true
                                            };
                        ctx.AdCachedUserProperties.AddObject(newUserProp);
                    }
                }

                //loop 2 to add all email properties for any users not already in the SQL cache
                existingProps = existingUserProperties.Where(ep => ep.PropertyName == "mail");

                foreach (var knownUser in allKnownUsers)
                {
                    if (existingProps.Count(ep => string.Equals(ep.UserName, knownUser, StringComparison.InvariantCultureIgnoreCase)) < 1)
                    {
                        var newUserProp = new AdCachedUserProperty()
                                            {
                                                UserName = knownUser,
                                                PropertyName = "mail",
                                                IsActiveInAd = true
                                            };
                        ctx.AdCachedUserProperties.AddObject(newUserProp);
                    }


                   
                }
                ctx.SaveChanges();
            }
        }
Пример #8
0
 private void BuildUserPropertiesCache(bool includeInactiveAd)
 {
     var refreshTime = DateTime.Now.AddMinutes((AdUserPropertiesSqlCacheRefreshMinutes * -1));
     using (TicketDeskEntities ctx = new TicketDeskEntities())
     {
         var propertiesForRefresh = ctx.AdCachedUserProperties.Where(up => !up.LastRefreshed.HasValue || up.LastRefreshed.Value <= refreshTime);
         if(!includeInactiveAd)
         { 
             propertiesForRefresh = propertiesForRefresh.Where(up => up.IsActiveInAd);
         }
         foreach(var property in propertiesForRefresh.ToList())
         {
             bool userFound;
             var value = AdRepository.GetUserPropertyFromAd(property.UserName, property.PropertyName, out userFound);
             property.IsActiveInAd = userFound;
             if (userFound)//if the user wasn't found, we don't alter the last value fetched (last fetched value lives forever)
             {
                 property.PropertyValue = value;
             }
             property.LastRefreshed = DateTime.Now;
             ctx.SaveChanges();
         }
         
     }
 }
 /// <summary>
 /// Saves the settings.
 /// </summary>
 /// <remarks>
 /// In the EF implementation we don't need the settings passed as a parameter, but we pass it anyway as other repositories may not work the same way
 /// </remarks>
 /// <param name="settingsToSave">The settings to save.</param>
 /// <returns></returns>
 public bool SaveSettings(IEnumerable<Setting> settingsToSave)
 {
     foreach (var s in settingsToSave)
     {
         if (s.EntityState == System.Data.EntityState.Detached)
         {
             ctx.Settings.AddObject(s);
         }
     }
     ctx.SaveChanges();
     ctx = new TicketDeskEntities();//reset the entities
     return true;
 }