Exemplo n.º 1
0
        public UserDelegationViewModel(Guid id, string groupUrl)
        {
            var group = GroupService.GetGroupByLabelOrId(groupUrl);
            if(group == null)
                throw new BusinessLogicException("Не найдена данная группа");

            var expertGroupMember = DataService.PerThread.GroupMemberSet.SingleOrDefault(x => x.UserId == id && x.GroupId == group.Id);
            if(expertGroupMember == null)
                throw new BusinessLogicException("Данный человек не состоит в данной группе");

            var expert = DataService.PerThread.ExpertSet.SingleOrDefault(x => x.GroupMember.Id == expertGroupMember.Id);
            if (expert == null)
                throw new BusinessLogicException("Данный человек не явлется экспертом в этой группе");

            //expertId = expert.Id;
            Expert = new UserExpertDelegate_ExpertViewModel(expert);

            GroupUrl = expert.GroupMember.Group.Url;
            GroupName = expert.GroupMember.Group.Name;
            GroupLogo = ImageService.GetImageUrl<Group>(expert.GroupMember.Group.Logo);
            var groupId = expert.GroupMember.GroupId;
            GroupMemberCount = DataService.PerThread.GroupMemberSet.Count(x => x.GroupId == groupId);

            GroupMember userInGroup = null;
            if(UserContext.Current != null)
            {
                var userId = UserContext.Current.Id;
                userInGroup =
                    DataService.PerThread.GroupMemberSet.SingleOrDefault(x => x.UserId == userId && x.GroupId == groupId);
            }

            if (userInGroup != null)
                UserIsApprovedMember = (userInGroup.State == (byte)GroupMemberState.Approved || userInGroup.State == (byte)GroupMemberState.Moderator);

            foreach (var t in expert.Tags.Where(x => x.TopicState == (byte)TopicState.GroupTopic))
            {
                var tag = new TagViewModel(t);

                if(userInGroup == null)
                    AnonymouseTags.Add(tag);
                else if (expert.ExpertVotes.Any(x => x.ExpertId == expert.Id && x.GroupMemberId == userInGroup.Id && x.TagId == t.Id))
                    CheckedTags.Add(tag);
                else if (userInGroup.Expert == null)
                    NotCheckedTags.Add(tag);
                else
                {
                    var tt = DataService.PerThread.TagSet.Single(x => x.Id == t.Id);

                    if (!userInGroup.Expert.Tags.Contains(tt))
                        NotCheckedTags.Add(tag);
                    else
                        DisabledTags.Add(tag);
                }

                var votersCount = DataService.PerThread.ExpertVoteSet.Count(x => x.TagId == tag.Id && x.ExpertId == Expert.Id);
                VotersCountForTag.Add(tag.Id, votersCount);
            }
        }
Exemplo n.º 2
0
        public UserExpertsViewModel(User currentUser)
        {
            if (currentUser != null)
            {
                UserId = currentUser.Id;
                var getUserExpertIdQuery = from votes in DataService.PerThread.ExpertVoteSet
                         join tag in DataService.PerThread.TagSet on votes.TagId equals tag.Id
                         join groupMember in DataService.PerThread.GroupMemberSet on votes.GroupMemberId equals groupMember.Id
                         join grp in DataService.PerThread.GroupSet on groupMember.GroupId equals grp.Id
                         join user in DataService.PerThread.BaseUserSet.OfType<User>() on groupMember.UserId equals user.Id
                         where user.Id == UserId
                         select new
                                    {
                                        TagTitle = tag.LowerTitle,
                                        TagId = tag.Id,
                                        GroupName = grp.Name,
                                        GroupId = grp.Id,
                                        ExpertId = votes.ExpertId,
                                        GroupLabel = grp.Label
                                    };

                var getUserFullExpertInfosQuery = from votes in getUserExpertIdQuery
                        join expert in DataService.PerThread.ExpertSet on votes.ExpertId equals expert.Id
                        join groupMember in DataService.PerThread.GroupMemberSet on expert.Id equals groupMember.Expert.Id
                        join user in DataService.PerThread.BaseUserSet.OfType<User>() on groupMember.UserId equals user.Id
                        select
                            new
                                {
                                    TagTitle = votes.TagTitle,
                                    TagId = votes.TagId,
                                    UserFirstName = user.FirstName,
                                    UserSurName = user.SurName,
                                    UserPatronymic = user.Patronymic,
                                    UserAvatar = user.Avatar,
                                    UserId = user.Id,
                                    GroupName = votes.GroupName,
                                    GroupId = votes.GroupId,
                                    GroupLabel = votes.GroupLabel,
                                    ExpertId = votes.ExpertId
                                };
                var expertInfos = getUserFullExpertInfosQuery.GroupBy(x => new { x.UserId, x.UserFirstName, x.UserSurName, x.UserPatronymic, x.UserAvatar }).ToList();

                foreach (var expertInfo in expertInfos)
                {
                    var expert = new UserExperts_ExpertViewModel
                                     {
                                         Id = expertInfo.Key.UserId.ToString(),
                                         FirstName = expertInfo.Key.UserFirstName,
                                         SurName = expertInfo.Key.UserSurName,
                                         Patronymic = expertInfo.Key.UserPatronymic,
                                         Avatar = ImageService.GetImageUrl<User>(expertInfo.Key.UserAvatar)
                                     };

                    var expertGroupInfos = expertInfo.GroupBy(x => new {x.GroupId, x.GroupName, x.GroupLabel, x.ExpertId});
                    foreach (var expertGroupInfo in expertGroupInfos)
                    {
                        var group = new UserExperts_ExpertGroupViewModel
                                        {
                                            Url = expertGroupInfo.Key.GroupLabel ?? expertGroupInfo.Key.GroupId.ToString(),
                                            Name = expertGroupInfo.Key.GroupName,
                                            ExpertId = expertGroupInfo.Key.ExpertId.ToString()
                                        };

                        foreach (var expertGroupTagInfo in expertGroupInfo)
                        {
                            var tagViewModel = new TagViewModel
                                                   {
                                                       Id = expertGroupTagInfo.TagId,
                                                       Title = expertGroupTagInfo.TagTitle
                                                   };
                            group.Tags.Add(tagViewModel);
                        }

                        expert.Groups.Add(group);
                    }

                    Experts.Add(expert);
                }
            }
        }