Beispiel #1
0
        // Token: 0x060022C4 RID: 8900 RVA: 0x000C6EB8 File Offset: 0x000C50B8
        internal override IEnumerator <Participant> GetRecipientsCollection(RecipientWellType type)
        {
            RecipientItemType recipientItemType;

            switch (type)
            {
            case RecipientWellType.To:
                recipientItemType = RecipientItemType.To;
                break;

            case RecipientWellType.Cc:
                recipientItemType = RecipientItemType.Cc;
                break;

            case RecipientWellType.Bcc:
                recipientItemType = RecipientItemType.Bcc;
                break;

            default:
                recipientItemType = RecipientItemType.Unknown;
                break;
            }
            foreach (IParticipant participant2 in this.itemPart.Recipients[recipientItemType])
            {
                Participant participant = (Participant)participant2;
                yield return(participant);
            }
            yield break;
        }
        internal override IEnumerator <Participant> GetRecipientsCollection(RecipientWellType type)
        {
            if (this.calendarItemBase != null)
            {
                AttendeeType attendeeType;
                switch (type)
                {
                case RecipientWellType.Cc:
                    attendeeType = AttendeeType.Optional;
                    goto IL_69;

                case RecipientWellType.Bcc:
                    attendeeType = AttendeeType.Resource;
                    goto IL_69;
                }
                attendeeType = AttendeeType.Required;
IL_69:
                foreach (Attendee attendee in this.calendarItemBase.AttendeeCollection)
                {
                    if (attendee.AttendeeType == attendeeType && !attendee.IsOrganizer)
                    {
                        yield return(attendee.Participant);
                    }
                }
            }
            yield break;
        }
Beispiel #3
0
        // Token: 0x06002386 RID: 9094 RVA: 0x000CC5B0 File Offset: 0x000CA7B0
        internal override IEnumerator <Participant> GetRecipientsCollection(RecipientWellType type)
        {
            RecipientItemType recipientItemType;

            switch (type)
            {
            case RecipientWellType.To:
                recipientItemType = RecipientItemType.To;
                break;

            case RecipientWellType.Cc:
                recipientItemType = RecipientItemType.Cc;
                break;

            case RecipientWellType.Bcc:
                recipientItemType = RecipientItemType.Bcc;
                break;

            default:
                recipientItemType = RecipientItemType.Unknown;
                break;
            }
            foreach (BlobRecipient recipient in this.meetingRequest.GetMergedRecipientList())
            {
                if (MapiUtil.MapiRecipientTypeToRecipientItemType((RecipientType)recipient[InternalSchema.RecipientType]) == recipientItemType)
                {
                    yield return(recipient.Participant);
                }
            }
            yield break;
        }
        internal override IEnumerator <Participant> GetRecipientCollection(RecipientWellType type)
        {
            if (this.calendarItemBase != null)
            {
                ResponseType responseType;
                switch (type)
                {
                case RecipientWellType.Cc:
                    responseType = ResponseType.Tentative;
                    goto IL_69;

                case RecipientWellType.Bcc:
                    responseType = ResponseType.Decline;
                    goto IL_69;
                }
                responseType = ResponseType.Accept;
IL_69:
                foreach (Attendee attendee in this.calendarItemBase.AttendeeCollection)
                {
                    if (attendee.ResponseType == responseType)
                    {
                        yield return(attendee.Participant);
                    }
                }
            }
            yield break;
        }
Beispiel #5
0
        // Token: 0x06002FE2 RID: 12258 RVA: 0x00117798 File Offset: 0x00115998
        public static string GetDisplayAttendees(MeetingRequest meetingRequest, RecipientWellType type)
        {
            if (meetingRequest == null)
            {
                throw new ArgumentNullException("meetingRequest");
            }
            object obj    = null;
            string result = string.Empty;

            if (type == RecipientWellType.To)
            {
                obj = meetingRequest.TryGetProperty(CalendarItemBaseSchema.DisplayAttendeesTo);
            }
            else if (type == RecipientWellType.Cc)
            {
                obj = meetingRequest.TryGetProperty(CalendarItemBaseSchema.DisplayAttendeesCc);
            }
            string text = obj as string;

            if (text != null)
            {
                result = text;
            }
            return(result);
        }
Beispiel #6
0
 // Token: 0x060000B5 RID: 181 RVA: 0x00006B6D File Offset: 0x00004D6D
 public void Render(TextWriter writer, RecipientWellType type)
 {
     if (writer == null)
     {
         throw new ArgumentNullException("writer");
     }
     this.Render(writer, type, RecipientWell.RenderFlags.None);
 }
        // Token: 0x06002F20 RID: 12064 RVA: 0x0010FC90 File Offset: 0x0010DE90
        public void RenderRecipientWellControl(Strings.IDs addressBookButtonLabel, RecipientWellType recipientWellType)
        {
            RecipientWellEventHandler.RenderRecipientWellContainerBegin(addressBookButtonLabel, base.UserContext, this.Writer);
            EmptyRecipientWell emptyRecipientWell = new EmptyRecipientWell();

            emptyRecipientWell.Render(this.Writer, base.UserContext, recipientWellType, RecipientWell.RenderFlags.None, string.Empty, string.Empty, string.Empty);
            RecipientWellEventHandler.RenderRecipientWellContainerEnd(this.Writer);
        }
Beispiel #8
0
 // Token: 0x06002388 RID: 9096 RVA: 0x000CC62A File Offset: 0x000CA82A
 public override bool HasRecipients(RecipientWellType type)
 {
     if (this.meetingRequest.IsDelegated())
     {
         return(!string.IsNullOrEmpty(CalendarUtilities.GetDisplayAttendees(this.meetingRequest, type)));
     }
     return(base.HasRecipients(type));
 }
Beispiel #9
0
        internal override IEnumerator <Participant> GetRecipientsCollection(RecipientWellType type)
        {
            if (this.message != null)
            {
                RecipientItemType recipientItemType;
                switch (type)
                {
                case RecipientWellType.To:
                    recipientItemType = RecipientItemType.To;
                    break;

                case RecipientWellType.Cc:
                    recipientItemType = RecipientItemType.Cc;
                    break;

                case RecipientWellType.Bcc:
                    recipientItemType = RecipientItemType.Bcc;
                    break;

                default:
                    recipientItemType = RecipientItemType.Unknown;
                    break;
                }
                if (recipientItemType == RecipientItemType.To && this.message is ReportMessage)
                {
                    Participant participant = ((ReportMessage)this.message).ReceivedRepresenting;
                    if (null != participant)
                    {
                        yield return(participant);
                    }
                }
                else if (type == RecipientWellType.From)
                {
                    Participant participant2 = this.message.From;
                    if (null != participant2)
                    {
                        yield return(participant2);
                    }
                }
                else
                {
                    foreach (Recipient recipient in this.message.Recipients)
                    {
                        if (recipient.RecipientItemType == recipientItemType)
                        {
                            object isResentMessage = this.message.TryGetProperty(MessageItemSchema.IsResend);
                            if (!(isResentMessage is bool) || !(bool)isResentMessage || !recipient.Submitted)
                            {
                                yield return(recipient.Participant);
                            }
                        }
                    }
                }
            }
            yield break;
        }
        // Token: 0x060000C1 RID: 193 RVA: 0x00007184 File Offset: 0x00005384
        public override bool HasRecipients(RecipientWellType type)
        {
            if (type < RecipientWellType.To)
            {
                throw new ArgumentOutOfRangeException("type", "type has an invalid value");
            }
            IEnumerator <Participant> recipientCollection = this.GetRecipientCollection(type);

            return(recipientCollection != null && recipientCollection.MoveNext());
        }
 // Token: 0x06001E99 RID: 7833 RVA: 0x000B0638 File Offset: 0x000AE838
 public virtual void Render(TextWriter writer, UserContext userContext, RecipientWellType type)
 {
     if (writer == null)
     {
         throw new ArgumentNullException("writer");
     }
     if (userContext == null)
     {
         throw new ArgumentNullException("userContext");
     }
     this.Render(writer, userContext, type, RecipientWell.RenderFlags.None);
 }
Beispiel #12
0
 // Token: 0x060024FE RID: 9470 RVA: 0x000D65A8 File Offset: 0x000D47A8
 public override void Render(TextWriter writer, UserContext userContext, RecipientWellType type, RecipientWell.RenderFlags flags, string id, string content, string extraStyle)
 {
     RecipientWellNode.RenderFlags renderFlags = RecipientWellNode.RenderFlags.RenderCommas;
     if ((flags & RecipientWell.RenderFlags.ReadOnly) != RecipientWell.RenderFlags.None)
     {
         renderFlags |= RecipientWellNode.RenderFlags.ReadOnly;
     }
     if (content != null)
     {
         Utilities.HtmlEncode(content, writer);
         return;
     }
     this.RenderContents(writer, userContext, type, renderFlags, new RenderRecipientWellNode(PrintRecipientWellNode.Render));
 }
 // Token: 0x0600256E RID: 9582 RVA: 0x000D8B58 File Offset: 0x000D6D58
 private MultiValuedProperty <string> GetAddressList(RecipientWellType type)
 {
     if (type == RecipientWellType.To)
     {
         return(this.calendarConfig.BookInPolicy);
     }
     if (type == RecipientWellType.Cc)
     {
         return(this.calendarConfig.RequestInPolicy);
     }
     if (type == RecipientWellType.Bcc)
     {
         return(this.calendarConfig.RequestOutOfPolicy);
     }
     throw new ArgumentException("invalid RecipientWellType");
 }
Beispiel #14
0
        // Token: 0x060000B8 RID: 184 RVA: 0x00006C00 File Offset: 0x00004E00
        private static string GetWellName(RecipientWellType type)
        {
            switch (type)
            {
            case RecipientWellType.To:
                return("To");

            case RecipientWellType.Cc:
                return("Cc");

            case RecipientWellType.Bcc:
                return("Bcc");

            default:
                return(null);
            }
        }
Beispiel #15
0
        // Token: 0x060000B4 RID: 180 RVA: 0x00006AB4 File Offset: 0x00004CB4
        public void Render(TextWriter writer, RecipientWellType type, RecipientWell.RenderFlags flags, string id)
        {
            if (writer == null)
            {
                throw new ArgumentNullException("writer");
            }
            if (id == null)
            {
                throw new ArgumentNullException("id");
            }
            if (!this.HasRecipients(type))
            {
                return;
            }
            bool flag = (flags & RecipientWell.RenderFlags.ReadOnly) != RecipientWell.RenderFlags.None;

            if (!flag)
            {
                writer.Write("<table class=\"rcptWll\" cellspacing=0 cellpadding=0 border=0><tr><td>");
            }
            if (!string.IsNullOrEmpty(id))
            {
                writer.Write("<div id=\"div{0}\"", id);
            }
            else
            {
                writer.Write("<div id=\"div{0}\"", RecipientWell.GetWellName(type));
            }
            if (flag)
            {
                writer.Write(" class=\"rwWRO\"");
            }
            writer.Write(">");
            RecipientWellNode.RenderFlags renderFlags = RecipientWellNode.RenderFlags.RenderCommas;
            if (flag)
            {
                renderFlags |= RecipientWellNode.RenderFlags.ReadOnly;
            }
            this.RenderContents(writer, type, renderFlags);
            writer.Write("</div>");
            if (!flag)
            {
                writer.Write("</td></tr></table>");
            }
        }
        // Token: 0x06001E98 RID: 7832 RVA: 0x000B05A8 File Offset: 0x000AE7A8
        private static string GetWellName(RecipientWellType type)
        {
            switch (type)
            {
            case RecipientWellType.To:
                return("To");

            case RecipientWellType.Cc:
                return("Cc");

            case RecipientWellType.Bcc:
                return("Bcc");

            case RecipientWellType.From:
                return("From");

            case RecipientWellType.AddAttendee:
                return("AddAttndRW");

            case RecipientWellType.AddRoom:
                return("AddRmRW");

            case RecipientWellType.AutoSchedUser:
                return("AutoSched");

            case RecipientWellType.ManualSchedUser:
                return("ManualSched");

            case RecipientWellType.BothSchedUser:
                return("BothSched");

            case RecipientWellType.OpenMailbox:
                return("OpnMbxRw");

            case RecipientWellType.OpenOtherMailboxFolder:
                return("OpnOthMbxRw");

            case RecipientWellType.Select:
                return("Select");

            default:
                return(null);
            }
        }
Beispiel #17
0
        // Token: 0x060000B6 RID: 182 RVA: 0x00006B88 File Offset: 0x00004D88
        public bool RenderAnr(TextWriter writer, UserContext userContext)
        {
            if (writer == null)
            {
                throw new ArgumentNullException("writer");
            }
            if (userContext == null)
            {
                throw new ArgumentNullException("userContext");
            }
            RecipientWellType type = RecipientWellType.To;
            bool flag  = false;
            bool flag2 = true;

            while (flag2)
            {
                if (this.HasRecipients(type))
                {
                    flag = this.RenderAnrContents(writer, userContext, type, flag);
                }
                switch (type)
                {
                case RecipientWellType.To:
                    type = RecipientWellType.Cc;
                    break;

                case RecipientWellType.Cc:
                    type = RecipientWellType.Bcc;
                    break;

                case RecipientWellType.Bcc:
                    flag2 = false;
                    break;
                }
            }
            if (flag)
            {
                writer.Write("<tr><td class=\"h100\"></td></tr></table></td></tr></table>");
            }
            return(flag);
        }
        // Token: 0x060000BF RID: 191 RVA: 0x00006CF0 File Offset: 0x00004EF0
        protected override void RenderContents(TextWriter writer, RecipientWellType type, RecipientWellNode.RenderFlags flags)
        {
            if (!this.HasRecipients(type))
            {
                return;
            }
            AdRecipientBatchQuery     adRecipientBatchQuery = new AdRecipientBatchQuery(this.GetRecipientCollection(type), this.UserContext);
            IEnumerator <Participant> recipientCollection   = this.GetRecipientCollection(type);

            RecipientWellNode.RenderFlags renderFlags = flags & ~RecipientWellNode.RenderFlags.RenderCommas;
            bool flag = true;
            RecipientItemType recipientItemType = ItemRecipientWell.GetRecipientItemType(type);
            bool isWebPartRequest = OwaContext.Current.UserContext.IsWebPartRequest;
            int  num = 0;

            while (recipientCollection.MoveNext())
            {
                Participant            participant                = recipientCollection.Current;
                int                    recipientFlags             = 0;
                ADObjectId             adObjectId                 = null;
                int                    readItemType               = 1;
                string                 smtpAddressAndADObjectInfo = ItemRecipientWell.GetSmtpAddressAndADObjectInfo(participant, adRecipientBatchQuery, out adObjectId, out recipientFlags, out readItemType);
                StoreObjectId          storeObjectId              = null;
                StoreParticipantOrigin storeParticipantOrigin     = participant.Origin as StoreParticipantOrigin;
                if (storeParticipantOrigin != null)
                {
                    storeObjectId = storeParticipantOrigin.OriginItemId;
                }
                string idString = ItemRecipientWell.BuildRecipientIdString(recipientItemType, num++);
                if (RecipientWellNode.Render(this.UserContext, writer, participant.DisplayName, smtpAddressAndADObjectInfo, participant.EmailAddress, participant.RoutingType, RecipientAddress.ToAddressOrigin(participant), recipientFlags, readItemType, recipientItemType, adObjectId, storeObjectId, renderFlags, idString, isWebPartRequest) && flag)
                {
                    flag = false;
                    if ((flags & RecipientWellNode.RenderFlags.RenderCommas) != RecipientWellNode.RenderFlags.None)
                    {
                        renderFlags |= RecipientWellNode.RenderFlags.RenderCommas;
                    }
                }
            }
        }
        // Token: 0x060000C3 RID: 195 RVA: 0x0000727C File Offset: 0x0000547C
        private static RecipientItemType GetRecipientItemType(RecipientWellType type)
        {
            RecipientItemType result;

            switch (type)
            {
            case RecipientWellType.To:
                result = RecipientItemType.To;
                break;

            case RecipientWellType.Cc:
                result = RecipientItemType.Cc;
                break;

            case RecipientWellType.Bcc:
                result = RecipientItemType.Bcc;
                break;

            default:
                result = RecipientItemType.Unknown;
                break;
            }
            return(result);
        }
 // Token: 0x06001E8F RID: 7823
 public abstract bool HasRecipients(RecipientWellType type);
        internal override void RenderContents(TextWriter writer, UserContext userContext, RecipientWellType type, RecipientWellNode.RenderFlags flags, RenderRecipientWellNode wellNode)
        {
            if (writer == null)
            {
                throw new ArgumentNullException("writer");
            }
            if (userContext == null)
            {
                throw new ArgumentNullException("userContext");
            }
            if (!this.HasRecipients(type))
            {
                return;
            }
            IEnumerator <Participant> recipientsCollection = this.GetRecipientsCollection(type);

            RecipientWellNode.RenderFlags renderFlags = flags & ~RecipientWellNode.RenderFlags.RenderCommas;
            bool flag  = true;
            bool flag2 = userContext.IsInstantMessageEnabled();

            Result <ADRawEntry>[] array = null;
            int num = 0;

            while (recipientsCollection.MoveNext())
            {
                Participant participant       = recipientsCollection.Current;
                string      smtpAddress       = null;
                string      alias             = null;
                string      text              = null;
                int         num2              = 0;
                ADObjectId  adObjectId        = null;
                string      mobilePhoneNumber = null;
                if (participant.RoutingType == "EX" && !string.IsNullOrEmpty(participant.EmailAddress))
                {
                    bool flag3 = (flags & RecipientWellNode.RenderFlags.ReadOnly) != RecipientWellNode.RenderFlags.None;
                    if (flag3)
                    {
                        alias = Utilities.GetParticipantProperty <string>(participant, ParticipantSchema.Alias, null);
                    }
                    bool participantProperty = Utilities.GetParticipantProperty <bool>(participant, ParticipantSchema.IsDistributionList, false);
                    if (participantProperty)
                    {
                        num2 |= 1;
                    }
                    bool participantProperty2 = Utilities.GetParticipantProperty <bool>(participant, ParticipantSchema.IsRoom, false);
                    if (participantProperty2)
                    {
                        num2 |= 2;
                    }
                    smtpAddress = Utilities.GetParticipantProperty <string>(participant, ParticipantSchema.SmtpAddress, null);
                    if (flag2 && !participantProperty && !participantProperty2)
                    {
                        text = Utilities.GetParticipantProperty <string>(participant, ParticipantSchema.SipUri, null);
                        if (text == null || text.Trim().Length == 0)
                        {
                            if (array == null)
                            {
                                array = AdRecipientBatchQuery.FindAdResultsByLegacyExchangeDNs(this.GetRecipientsCollection(type), userContext);
                            }
                            ADRawEntry data = array[num].Data;
                            if (data != null)
                            {
                                adObjectId = (ADObjectId)data[ADObjectSchema.Id];
                                text       = InstantMessageUtilities.GetSipUri((ProxyAddressCollection)data[ADRecipientSchema.EmailAddresses]);
                                if (text != null && text.Trim().Length == 0)
                                {
                                    text = null;
                                }
                            }
                        }
                    }
                    if (userContext.IsSmsEnabled)
                    {
                        if (array == null)
                        {
                            array = AdRecipientBatchQuery.FindAdResultsByLegacyExchangeDNs(this.GetRecipientsCollection(type), userContext);
                        }
                        ADRawEntry data2 = array[num].Data;
                        if (data2 != null)
                        {
                            mobilePhoneNumber = (string)data2[ADOrgPersonSchema.MobilePhone];
                        }
                    }
                    num++;
                }
                else if (participant.RoutingType == "SMTP")
                {
                    smtpAddress = participant.EmailAddress;
                    if (flag2)
                    {
                        text = participant.EmailAddress;
                    }
                }
                else if (string.CompareOrdinal(participant.RoutingType, "MAPIPDL") == 0)
                {
                    num2 |= 1;
                }
                StoreObjectId          storeObjectId          = null;
                EmailAddressIndex      emailAddressIndex      = EmailAddressIndex.None;
                StoreParticipantOrigin storeParticipantOrigin = participant.Origin as StoreParticipantOrigin;
                if (storeParticipantOrigin != null && storeParticipantOrigin.OriginItemId != null)
                {
                    storeObjectId     = storeParticipantOrigin.OriginItemId;
                    emailAddressIndex = storeParticipantOrigin.EmailAddressIndex;
                }
                if (wellNode(writer, userContext, participant.DisplayName, smtpAddress, participant.EmailAddress, participant.RoutingType, alias, RecipientAddress.ToAddressOrigin(participant), num2, storeObjectId, emailAddressIndex, adObjectId, renderFlags, text, mobilePhoneNumber) && flag)
                {
                    flag = false;
                    if ((flags & RecipientWellNode.RenderFlags.RenderCommas) != RecipientWellNode.RenderFlags.None)
                    {
                        renderFlags |= RecipientWellNode.RenderFlags.RenderCommas;
                    }
                }
            }
        }
Beispiel #22
0
 // Token: 0x06002387 RID: 9095 RVA: 0x000CC5D4 File Offset: 0x000CA7D4
 internal override void RenderContents(TextWriter writer, UserContext userContext, RecipientWellType type, RecipientWellNode.RenderFlags flags, RenderRecipientWellNode wellNode)
 {
     if (writer == null)
     {
         throw new ArgumentNullException("writer");
     }
     if (userContext == null)
     {
         throw new ArgumentNullException("userContext");
     }
     if (this.meetingRequest.IsDelegated())
     {
         Utilities.SanitizeHtmlEncode(CalendarUtilities.GetDisplayAttendees(this.meetingRequest, type), writer);
         return;
     }
     base.RenderContents(writer, userContext, type, flags, wellNode);
 }
Beispiel #23
0
 public override bool HasRecipients(RecipientWellType type)
 {
     return(false);
 }
Beispiel #24
0
 internal override void RenderContents(TextWriter writer, UserContext userContext, RecipientWellType type, RecipientWellNode.RenderFlags flags, RenderRecipientWellNode wellNode)
 {
     if (writer == null)
     {
         throw new ArgumentNullException("writer");
     }
     if (userContext == null)
     {
         throw new ArgumentNullException("userContext");
     }
     this.HasRecipients(type);
 }
 // Token: 0x06001E94 RID: 7828 RVA: 0x000B03DD File Offset: 0x000AE5DD
 public virtual void Render(TextWriter writer, UserContext userContext, RecipientWellType type, RecipientWell.RenderFlags flags)
 {
     this.Render(writer, userContext, type, flags, string.Empty, null, string.Empty);
 }
 // Token: 0x06001E92 RID: 7826
 internal abstract void RenderContents(TextWriter writer, UserContext userContext, RecipientWellType type, RecipientWellNode.RenderFlags flags, RenderRecipientWellNode wellNode);
Beispiel #27
0
            internal override IEnumerator <Participant> GetRecipientsCollection(RecipientWellType type)
            {
                yield return(new Participant(this.userContext.MailboxIdentity.GetOWAMiniRecipient()));

                yield break;
            }
        // Token: 0x06001E97 RID: 7831 RVA: 0x000B0420 File Offset: 0x000AE620
        public virtual void Render(TextWriter writer, UserContext userContext, RecipientWellType type, RecipientWell.RenderFlags flags, string id, string content, string extraStyle)
        {
            if (writer == null)
            {
                throw new ArgumentNullException("writer");
            }
            if (userContext == null)
            {
                throw new ArgumentNullException("userContext");
            }
            if (id == null)
            {
                throw new ArgumentNullException("id");
            }
            bool flag = (flags & RecipientWell.RenderFlags.ReadOnly) != RecipientWell.RenderFlags.None;

            if (flag && !this.HasRecipients(type) && type != RecipientWellType.From)
            {
                return;
            }
            if (flags != RecipientWell.RenderFlags.Hidden)
            {
                writer.Write("<div id=divFH>M</div>");
            }
            if (!string.IsNullOrEmpty(id))
            {
                writer.Write("<div id=\"div{0}\"", id);
            }
            else
            {
                writer.Write("<div id=\"div{0}\"", RecipientWell.GetWellName(type));
            }
            if ((flags & RecipientWell.RenderFlags.Hidden) != RecipientWell.RenderFlags.None)
            {
                writer.Write(" disabled");
            }
            this.RenderAdditionalExpandos(writer);
            if (!flag)
            {
                writer.Write(" class=\"rwW");
                writer.Write(string.IsNullOrEmpty(extraStyle) ? SanitizedHtmlString.Empty : SanitizedHtmlString.Format(" {0}", new object[]
                {
                    extraStyle
                }));
                writer.Write("\" contentEditable=\"true\" ");
                writer.Write("spellcheck=\"false\" ");
                writer.Write(">");
            }
            else
            {
                writer.Write(" class=\"rwW rwWRO\" ");
                writer.Write(">");
            }
            RecipientWellNode.RenderFlags renderFlags = RecipientWellNode.RenderFlags.RenderCommas;
            if ((flags & RecipientWell.RenderFlags.ReadOnly) != RecipientWell.RenderFlags.None)
            {
                renderFlags |= RecipientWellNode.RenderFlags.ReadOnly;
            }
            if (content != null)
            {
                Utilities.SanitizeHtmlEncode(content, writer);
            }
            else
            {
                if (userContext.BrowserType != BrowserType.IE && this.HasRecipients(type))
                {
                    writer.Write("&nbsp;");
                }
                this.RenderContents(writer, userContext, type, renderFlags, RecipientWell.wellNodeRenderDelegate);
                if (userContext.BrowserType != BrowserType.IE && this.HasRecipients(type))
                {
                    writer.Write("&nbsp;");
                }
            }
            writer.Write("</div>");
        }
 // Token: 0x06001E95 RID: 7829 RVA: 0x000B03F5 File Offset: 0x000AE5F5
 public virtual void Render(TextWriter writer, UserContext userContext, RecipientWellType type, string extraStyle)
 {
     this.Render(writer, userContext, type, RecipientWell.RenderFlags.None, string.Empty, null, extraStyle);
 }
 public virtual bool ShouldRenderRecipientWell(RecipientWellType recipientWellType)
 {
     return(this.RecipientWell.HasRecipients(recipientWellType));
 }