public ActionResult GroupsAdd(LeagueGroup group)
        {
            try
            {
                var memId = RDN.Library.Classes.Account.User.GetMemberId();
                var league = MemberCache.GetLeagueOfMember(memId);
                foreach (var mem in league.LeagueMembers)
                {
                    if (!String.IsNullOrEmpty(Request.Form[mem.MemberId + "-check"]))
                    {
                        bool cb = Request.Form[mem.MemberId + "-check"].ToString().Contains("true");
                        if (cb)
                        {
                            LeagueGroupMember m = new LeagueGroupMember();
                            m.MemberId = mem.MemberId;
                            if (!String.IsNullOrEmpty(HttpContext.Request.Form[mem.MemberId + "-memType"]))
                                m.MemberAccessLevelEnum = (GroupMemberAccessLevelEnum)Enum.Parse(typeof(GroupMemberAccessLevelEnum), HttpContext.Request.Form[mem.MemberId + "-memType"].ToString());

                            group.GroupMembers.Add(m);
                        }
                    }
                }


                if (LeagueGroupFactory.AddGroup(group))
                {
                    foreach (var mem in group.GroupMembers)
                    {
                        LeagueGroupFactory.EmailMemberAboutAddedToGroup(group.GroupName, mem.MemberId);
                        MemberCache.Clear(mem.MemberId);
                        MemberCache.ClearApiCache(mem.MemberId);
                        SiteCache.ResetGroups();
                    }
                    MemberCache.Clear(RDN.Library.Classes.Account.User.GetMemberId());
                    return Redirect(Url.Content("~/league/groups?u=" + SiteMessagesEnum.sag));
                }
            }
            catch (Exception exception)
            {
                ErrorDatabaseManager.AddException(exception, exception.GetType());
            }
            return Redirect(Url.Content("~/league/groups?u=" + SiteMessagesEnum.sww));
        }
        public ActionResult GroupsSettings(LeagueGroup group)
        {
            try
            {
                var memId = RDN.Library.Classes.Account.User.GetMemberId();
                var league = MemberCache.GetLeagueOfMember(memId);
                foreach (var mem in league.LeagueMembers)
                {
                    if (!String.IsNullOrEmpty(Request.Form[mem.MemberId + "-check"]))
                    {
                        bool cb = Request.Form[mem.MemberId + "-check"].ToString().Contains("true");

                        LeagueGroupMember m = new LeagueGroupMember();
                        m.MemberId = mem.MemberId;
                        if (!String.IsNullOrEmpty(HttpContext.Request.Form[mem.MemberId + "-memType"]))
                            m.MemberAccessLevelEnum = (GroupMemberAccessLevelEnum)Enum.Parse(typeof(GroupMemberAccessLevelEnum), HttpContext.Request.Form[mem.MemberId + "-memType"].ToString());
                        if (cb)
                        {
                            m.IsApartOfGroup = true;
                        }
                        group.GroupMembers.Add(m);

                    }
                }


                bool updated = LeagueGroupFactory.UpdateGroup(group);
                MemberCache.Clear(memId);
                MemberCache.ClearApiCache(memId);

                MemberCache.UpdateCurrentLeagueMemberCache(memId);
                if (updated)
                    return Redirect(Url.Content("~/league/groups?u=" + SiteMessagesEnum.sag));
            }
            catch (Exception exception)
            {
                ErrorDatabaseManager.AddException(exception, exception.GetType());
            }
            return Redirect(Url.Content("~/league/groups?u=" + SiteMessagesEnum.sww));
        }
        public ActionResult GroupsAdd()
        {
            try
            {
                var memId = RDN.Library.Classes.Account.User.GetMemberId();
                var mems = MemberCache.GetCurrentLeagueMembers(memId);
                ViewData["GroupMembers"] = new SelectList(mems, "MemberId", "DerbyName");

                LeagueGroup group = new LeagueGroup();
                group.League = MemberCache.GetLeagueOfMember(memId);
                ViewData["groupTypeSelectList"] = group.GroupTypeEnum.ToSelectList();
                return View(group);
            }
            catch (Exception exception)
            {
                ErrorDatabaseManager.AddException(exception, exception.GetType());
            }
            return Redirect(Url.Content("~/?u=" + SiteMessagesEnum.sww));
        }
 void ReturnLeagueGroups(List<LeagueGroupBasic> model)
 {
     try
     {
         Groups = new ObservableCollection<LeagueGroup>();
         var first = new LeagueGroup() { Id = 0, GroupName = "Entire League" };
         Groups.Add(first);
         for (int i = 0; i < model.Count; i++)
         {
             Groups.Add(new LeagueGroup() { Id = model[i].Id, GroupName = model[i].GroupName });
         }
         Dispatcher.BeginInvoke(delegate
         {
             GroupsList.ItemsSource = Groups;
         });
     }
     catch (Exception exception)
     {
         ErrorHandler.Save(exception, MobileTypeEnum.WP8);
     }
 }
        public static LeagueGroup DisplayGroup(DataModels.League.Group.Group group)
        {
            if (group == null)
                return null;
            LeagueGroup g = new LeagueGroup();
            try
            {
                g.DefaultBroadcastMessage = group.BroadcastToEveryone;
                g.GroupName = group.GroupName;
                g.GroupTypeEnum = (LeagueGroupTypeEnum)Enum.Parse(typeof(LeagueGroupTypeEnum), group.GroupTypeEnum.ToString());
                g.Id = group.Id;
                g.IsPublicToWorld = group.IsPublicToWorld;
                if (group.ContactCard != null && group.ContactCard.Emails.FirstOrDefault() != null)
                    g.EmailAddress = group.ContactCard.Emails.FirstOrDefault().EmailAddress;
                foreach (var logo in group.Logos)
                {
                    g.Logos.Add(new PhotoItem(logo.ImageUrl, logo.IsPrimaryPhoto, logo.AlternativeText));
                }
                var mems = group.GroupMembers.Where(x => x.IsMemRemoved == false).ToList();
                foreach (var member in mems)
                {
                    try
                    {
                        if (group.League.Members.Where(x => x.HasLeftLeague == false && member.Member != null && member.Member.MemberId == x.Member.MemberId).FirstOrDefault() != null)
                        {
                            RDN.Portable.Classes.League.Classes.LeagueGroupMember mem = new Portable.Classes.League.Classes.LeagueGroupMember();
                            mem.IsApartOfGroup = true;
                            mem.DerbyName = member.Member.DerbyName;
                            mem.PlayerNumber = member.Member.PlayerNumber;
                            mem.MemberId = member.Member.MemberId;
                            mem.Firstname = member.Member.Firstname;
                            mem.LastName = member.Member.Lastname;
                            mem.UserId = member.Member.AspNetUserId;
                            var email = member.Member.ContactCard.Emails.FirstOrDefault();
                            if (email != null)
                                mem.Email = email.EmailAddress;
                            if (member.Member.ContactCard.Communications.Count > 0 && member.Member.ContactCard.Communications.Where(x => x.IsDefault == true).Where(x => x.CommunicationTypeEnum == (byte)CommunicationTypeEnum.PhoneNumber).FirstOrDefault() != null)
                                mem.PhoneNumber = member.Member.ContactCard.Communications.Where(x => x.IsDefault == true).Where(x => x.CommunicationTypeEnum == (byte)CommunicationTypeEnum.PhoneNumber).FirstOrDefault().Data;
                            mem.Notes = member.Notes;
                            mem.DoesReceiveNewPostGroupNotifications = !member.TurnOffEmailNotifications;
                            mem.DoesReceiveGroupBroadcastNotifications = !member.TurnOffBroadcastNotifications;
                            mem.MemberAccessLevelEnum = (GroupMemberAccessLevelEnum)Enum.Parse(typeof(GroupMemberAccessLevelEnum), member.MemberAccessLevelEnum.ToString());
                            g.GroupMembers.Add(mem);
                        }
                    }
                    catch (Exception exception)
                    {
                        ErrorDatabaseManager.AddException(exception, exception.GetType());
                    }

                }
                return g;

            }
            catch (Exception exception)
            {
                ErrorDatabaseManager.AddException(exception, exception.GetType());
            }
            return g;
        }
        public static bool AddGroup(LeagueGroup group)
        {
            try
            {
                var dc = new ManagementContext();
                RDN.Library.DataModels.League.Group.Group g = new DataModels.League.Group.Group();
                g.GroupName = group.GroupName;
                g.GroupTypeEnum = Convert.ToInt32(group.GroupTypeEnum);
                g.IsPublicToWorld = group.IsPublicToWorld;
                g.League = dc.Leagues.Where(x => x.LeagueId == group.League.LeagueId).FirstOrDefault();

                if (!String.IsNullOrEmpty(group.EmailAddress))
                {
                    g.ContactCard = new DataModels.ContactCard.ContactCard();
                    g.ContactCard.Emails.Add(new RDN.Library.DataModels.ContactCard.Email { EmailAddress = group.EmailAddress, IsDefault = true });

                }
                foreach (var mem in group.GroupMembers)
                {
                    GroupMember gm = new GroupMember();
                    gm.Group = g;
                    gm.Member = dc.Members.Where(x => x.MemberId == mem.MemberId).FirstOrDefault();
                    gm.MemberAccessLevelEnum = Convert.ToInt32(mem.MemberAccessLevelEnum);
                    g.GroupMembers.Add(gm);
                }
                dc.LeagueGroups.Add(g);
                int c = dc.SaveChanges();
                var memId = RDN.Library.Classes.Account.User.GetMemberId();
                MemberCache.Clear(memId);
                MemberCache.ClearApiCache(memId);
                if (c > 0)
                    return true;
            }
            catch (Exception exception)
            {
                ErrorDatabaseManager.AddException(exception, exception.GetType());
            }
            return false;
        }
        public static bool UpdateGroup(LeagueGroup group)
        {
            try
            {
                var dc = new ManagementContext();
                var g = dc.LeagueGroups.Where(x => x.Id == group.Id).FirstOrDefault();
                if (g != null)
                {
                    g.GroupName = group.GroupName;
                    g.GroupTypeEnum = Convert.ToInt32(group.GroupTypeEnum);
                    g.IsPublicToWorld = group.IsPublicToWorld;
                    g.League = g.League;
                }

                if (g.ContactCard != null && g.ContactCard.Emails.Count > 0 && !String.IsNullOrEmpty(group.EmailAddress))
                {
                    var e = g.ContactCard.Emails.FirstOrDefault();
                    e.EmailAddress = group.EmailAddress;
                }
                else if (!String.IsNullOrEmpty(group.EmailAddress))
                {
                    if (g.ContactCard == null)
                        g.ContactCard = new DataModels.ContactCard.ContactCard();
                    g.ContactCard.Emails.Add(new RDN.Library.DataModels.ContactCard.Email { EmailAddress = group.EmailAddress, IsDefault = true });

                }



                foreach (var mem in group.GroupMembers)
                {
                    var gm11 = g.GroupMembers.Where(x => x.Member.MemberId == mem.MemberId).FirstOrDefault();
                    if (mem.IsApartOfGroup)
                    {
                        if (gm11 == null)
                        {
                            GroupMember gm = new GroupMember();
                            gm.Group = g;
                            gm.Member = dc.Members.Where(x => x.MemberId == mem.MemberId).FirstOrDefault();
                            gm.MemberAccessLevelEnum = Convert.ToInt32(mem.MemberAccessLevelEnum);
                            g.GroupMembers.Add(gm);
                            LeagueGroupFactory.EmailMemberAboutAddedToGroup(group.GroupName, mem.MemberId);
                        }
                        else
                        {
                            gm11.MemberAccessLevelEnum = Convert.ToInt32(mem.MemberAccessLevelEnum);
                            gm11.IsMemRemoved = false;
                            gm11.Member = gm11.Member;
                            gm11.Group = gm11.Group;
                        }
                    }
                    else
                    {
                        if (gm11 != null)
                        {
                            gm11.IsMemRemoved = true;
                            gm11.Member = gm11.Member;
                            gm11.Group = gm11.Group;
                        }
                    }
                }

                int c = dc.SaveChanges();


                foreach (var mem in group.GroupMembers)
                {
                    if (mem.IsApartOfGroup)
                    {
                        MemberCache.Clear(mem.MemberId);
                        MemberCache.ClearApiCache(mem.MemberId);
                    }
                }


                if (c > 0)
                    return true;
            }
            catch (Exception exception)
            {
                ErrorDatabaseManager.AddException(exception, exception.GetType());
            }
            return false;
        }