MucRoom.cs

using System;
using System.Collections.Generic;
using Waher.Networking.XMPP.Server;
using Waher.Persistence;
using Waher.Persistence.Attributes;
using Waher.Service.IoTBroker.MultiUserChat.Affiliations;
using Waher.Service.IoTBroker.MultiUserChat.Roles;
 
namespace Waher.Service.IoTBroker.MultiUserChat
{
    [TypeName(TypeNameSerialization.FullName)]
    [ArchivingTime(nameof(ArchiveDays))]
    [CollectionName("MucRooms")]
    [Index("Domain", "Room")]
    public class MucRoom : IEncryptedProperties
    {
        private readonly Dictionary<CaseInsensitiveString, MucOccupant> occupantsByNick = new Dictionary<CaseInsensitiveString, MucOccupant>();
        private readonly Dictionary<CaseInsensitiveString, MucOccupant> occupantsByFullJid = new Dictionary<CaseInsensitiveString, MucOccupant>();
        private readonly Dictionary<CaseInsensitiveString, MucOccupant> occupantsByBareJid = new Dictionary<CaseInsensitiveString, MucOccupant>();
        private readonly object synchObj = new object();
        private string objectId = null;
        private CaseInsensitiveString room = null;
        private CaseInsensitiveString domain = null;
        private CaseInsensitiveString creator = null;
        private string name = string.Empty;
        private string description = string.Empty;
        private string language = string.Empty;
        private string subject = string.Empty;
        private string subjectJid = string.Empty;
        private DateTime subjectTimestamp = DateTime.MinValue;
        private bool logging = false;
        private bool allowChangeSubject = false;
        private bool allowInvites = false;
        private CanSendPrivateMessages allowPrivateMessages = CanSendPrivateMessages.Anyone;
        private int maxOccupants = 20;
        private BroadcastPresence presenceBroadcast = BroadcastPresence.All;
        private RetrieveMembershipList getMemberList = RetrieveMembershipList.All;
        private bool persistent = false;
        private bool archive = false;
        private bool moderated = false;
        private bool membersOnly = false;
        private bool passwordProtected = false;
        private bool _public = false;
        private bool locked = false;
        private string password = string.Empty;
        private DiscoverReadJids discoverRealJids = DiscoverReadJids.Moderators;
        private int maxHistoryFetch = 50;
        private int archiveMessagesDays = 0;
        private CaseInsensitiveString[] members = null;
        private CaseInsensitiveString[] admins = null;
        private CaseInsensitiveString[] owners = null;
 
        public MucRoom()
        {
        }
 
        [ObjectId]
        public string ObjectID
        {
            get => this.objectId;
            set => this.objectId = value;
        }
 
        public CaseInsensitiveString Room
        {
            get => this.room;
            set => this.room = value;
        }
 
        public CaseInsensitiveString Domain
        {
            get => this.domain;
            set => this.domain = value;
        }
 
        public CaseInsensitiveString Creator
        {
            get => this.creator;
            set => this.creator = value;
        }
 
        [DefaultValueStringEmpty]
        public string Name
        {
            get => this.name;
            set => this.name = value;
        }
 
        [DefaultValueStringEmpty]
        public string Description
        {
            get => this.description;
            set => this.description = value;
        }
 
        [DefaultValueStringEmpty]
        public string Language
        {
            get => this.language;
            set => this.language = value;
        }
 
        [DefaultValue(false)]
        public bool Logging
        {
            get => this.logging;
            set => this.logging = value;
        }
 
        [DefaultValue(false)]
        public bool AllowChangeSubject
        {
            get => this.allowChangeSubject;
            set => this.allowChangeSubject = value;
        }
 
        [DefaultValue(false)]
        public bool AllowInvites
        {
            get => this.allowInvites;
            set => this.allowInvites = value;
        }
 
        [DefaultValue(CanSendPrivateMessages.Anyone)]
        public CanSendPrivateMessages AllowPrivateMessages
        {
            get => this.allowPrivateMessages;
            set => this.allowPrivateMessages = value;
        }
 
        [DefaultValue(20)]
        public int MaxOccupants
        {
            get => this.maxOccupants;
            set => this.maxOccupants = value;
        }
 
        [DefaultValue(BroadcastPresence.All)]
        public BroadcastPresence PresenceBroadcast
        {
            get => this.presenceBroadcast;
            set => this.presenceBroadcast = value;
        }
 
        [DefaultValue(RetrieveMembershipList.All)]
        public RetrieveMembershipList GetMemberList
        {
            get => this.getMemberList;
            set => this.getMemberList = value;
        }
 
        [DefaultValue(false)]
        public bool Persistent
        {
            get => this.persistent;
            set
            {
                this.persistent = value;
                this.archive |= value;
            }
        }
 
        [DefaultValue(false)]
        public bool Archive
        {
            get => this.archive;
            set => this.archive = value;
        }
 
        [DefaultValue(false)]
        public bool Moderated
        {
            get => this.moderated;
            set => this.moderated = value;
        }
 
        [DefaultValue(false)]
        public bool MembersOnly
        {
            get => this.membersOnly;
            set => this.membersOnly = value;
        }
 
        [DefaultValue(false)]
        public bool Public
        {
            get => this._public;
            set => this._public = value;
        }
 
        [DefaultValue(false)]
        public bool PasswordProtected
        {
            get => this.passwordProtected;
            set => this.passwordProtected = value;
        }
 
        [Encrypted(32)]
        public string Password
        {
            get => this.password;
            set => this.password = value;
        }
 
        public string[] EncryptedProperties => new string[] { nameof(this.Password) };
 
        [DefaultValue(DiscoverReadJids.Moderators)]
        public DiscoverReadJids DiscoverRealJids
        {
            get => this.discoverRealJids;
            set => this.discoverRealJids = value;
        }
 
        [DefaultValue(50)]
        public int MaxHistoryFetch
        {
            get => this.maxHistoryFetch;
            set => this.maxHistoryFetch = value;
        }
 
        [DefaultValue(0)]
        public int ArchiveMessagesDays
        {
            get => this.archiveMessagesDays;
            set => this.archiveMessagesDays = value;
        }
 
        [DefaultValueNull]
        public CaseInsensitiveString[] Admins
        {
            get => this.admins;
            set => this.admins = value;
        }
 
        [DefaultValueNull]
        public CaseInsensitiveString[] Owners
        {
            get => this.owners;
            set => this.owners = value;
        }
 
        [IgnoreMember]
        public bool Locked
        {
            get => this.locked;
            set => this.locked = value;
        }
 
        [DefaultValueStringEmpty]
        public string Subject
        {
            get => this.subject;
            set => this.subject = value;
        }
 
        [DefaultValueStringEmpty]
        public CaseInsensitiveString SubjectJid
        {
            get => this.subjectJid;
            set => this.subjectJid = value;
        }
 
        [DefaultValueDateTimeMinValue]
        public DateTime SubjectTimestamp
        {
            get => this.subjectTimestamp;
            set => this.subjectTimestamp = value;
        }
 
        public int ArchiveDays => this.archive ? int.MaxValue : 0;
 
        internal bool TryGetOccupantFromNick(CaseInsensitiveString NickName, out MucOccupant Occupant)
        {
            lock (this.synchObj)
            {
                return this.occupantsByNick.TryGetValue(NickName, out Occupant);
            }
        }
 
        internal bool TryGetOccupantFromFullJid(CaseInsensitiveString FullJid, out MucOccupant Occupant)
        {
            lock (this.synchObj)
            {
                return this.occupantsByFullJid.TryGetValue(FullJid, out Occupant);
            }
        }
 
        internal bool TryGetOccupantFromBareJid(CaseInsensitiveString BareJid, out MucOccupant Occupant)
        {
            lock (this.synchObj)
            {
                return this.occupantsByBareJid.TryGetValue(BareJid, out Occupant);
            }
        }
 
        internal bool Add(MucOccupant Occupant)
        {
            lock (this.synchObj)
            {
                if (this.occupantsByNick.Count >= this.maxOccupants && !(Occupant.Affiliation is Affiliations.Admin) && !(Occupant.Affiliation is Member))
                    return false;
 
                this.occupantsByNick[Occupant.NickName] = Occupant;
                this.occupantsByBareJid[Occupant.BareJid] = Occupant;
 
                if (!(Occupant.FullJids is null))
                {
                    foreach (XmppAddress FullJid in Occupant.FullJids)
                        this.occupantsByFullJid[FullJid.Address] = Occupant;
                }
            }
 
            return true;
        }
 
        internal bool Remove(MucOccupant Occupant)
        {
            bool Result;
 
            lock (this.synchObj)
            {
                Result = this.occupantsByNick.Remove(Occupant.NickName);
                this.occupantsByBareJid.Remove(Occupant.BareJid);
 
                if (!(Occupant.FullJids is null))
                {
                    foreach (XmppAddress FullJid in Occupant.FullJids)
                        this.occupantsByFullJid.Remove(FullJid.Address);
                }
            }
 
            return Result;
        }
 
        internal MucOccupant[] GetOccupants()
        {
            lock (this.synchObj)
            {
                MucOccupant[] Result = new MucOccupant[this.occupantsByNick.Count];
                this.occupantsByNick.Values.CopyTo(Result, 0);
                return Result;
            }
        }
 
        internal void RegisterFullJid(MucOccupant Occupant, XmppAddress FullJid)
        {
            lock (this.synchObj)
            {
                this.occupantsByFullJid[FullJid.Address] = Occupant;
                this.occupantsByBareJid[FullJid.BareJid] = Occupant;
            }
 
            Occupant.AddFullJid(FullJid);
        }
 
        internal bool UnregisterFullJid(MucOccupant Occupant, XmppAddress FullJid)
        {
            int c = Occupant.RemoveFullJid(FullJid);
 
            lock (this.synchObj)
            {
                this.occupantsByFullJid.Remove(FullJid.Address);
 
                if (c == 0)
                {
                    this.occupantsByBareJid.Remove(FullJid.BareJid);
                    return true;
                }
            }
 
            return false;
        }
 
        internal Affiliation GetDefaultAffiliation(CaseInsensitiveString BareJid)
        {
            if (!(this.owners is null) && Array.IndexOf(this.owners, BareJid) >= 0)
                return new Owner();
 
            if (!(this.admins is null) && Array.IndexOf(this.admins, BareJid) >= 0)
                return new Affiliations.Admin();
 
            if (!(this.members is null) && Array.IndexOf(this.members, BareJid) >= 0)
                return new Member();
 
            return new Affiliations.None();
        }
 
        internal bool CanBroadcastPresence(MucOccupant Occupant)
        {
            return Occupant?.Role?.CanBroadcastPresence(this.presenceBroadcast) ?? false;
        }
 
        internal bool CanGetMembership(MucOccupant Occupant)
        {
            return Occupant?.Role?.CanGetMembership(this.getMemberList) ?? false;
        }
 
        internal bool CanDiscoverRealJids(MucOccupant Occupant)
        {
            return Occupant?.Role?.CanDiscoverRealJids(this.discoverRealJids) ?? false;
        }
 
        internal bool CanSendPrivateMessage(MucOccupant Occupant)
        {
            if (!(Occupant.Role?.SendPrivateMessages ?? false))
                return false;
 
            return Occupant?.Role?.CanSendPrivateMessage(this.allowPrivateMessages) ?? false;
        }
 
        internal bool IsModerator(MucOccupant Occupant)
        {
            return Occupant.Role is Moderator;
        }
 
        internal bool IsAdmin(MucOccupant Occupant)
        {
            if (!(this.admins is null) && Array.IndexOf(this.admins, Occupant.BareJid) >= 0)
                return true;
 
            return IsOwner(Occupant);
        }
 
        internal bool IsOwner(MucOccupant Occupant)
        {
            return this.IsOwner(Occupant.BareJid);
        }
 
        internal bool IsOwner(CaseInsensitiveString BareJid)
        {
            if (!(this.owners is null) && Array.IndexOf(this.owners, BareJid) >= 0)
                return true;
 
            return false;
        }
 
        internal bool AddMember(CaseInsensitiveString BareJid)
        {
            return Add(ref this.members, BareJid);
        }
 
        internal bool IsMember(CaseInsensitiveString BareJid)
        {
            return !(this.members is null) && Array.IndexOf(this.members, BareJid) >= 0;
        }
 
        internal bool AddAdmin(CaseInsensitiveString BareJid)
        {
            return Add(ref this.admins, BareJid);
        }
 
        internal bool AddOwner(CaseInsensitiveString BareJid)
        {
            return Add(ref this.owners, BareJid);
        }
 
        internal bool RemoveMember(CaseInsensitiveString BareJid)
        {
            return Remove(ref this.members, BareJid);
        }
 
        internal bool RemoveAdmin(CaseInsensitiveString BareJid)
        {
            return Remove(ref this.admins, BareJid);
        }
 
        internal bool RemoveOwner(CaseInsensitiveString BareJid)
        {
            return Remove(ref this.owners, BareJid);
        }
 
        private bool Add(ref CaseInsensitiveString[] List, CaseInsensitiveString BareJid)
        {
            if (List is null)
                List = new CaseInsensitiveString[] { BareJid };
            else if (Array.IndexOf(List, BareJid) >= 0)
                return false;
            else
            {
                CaseInsensitiveString[] New = (CaseInsensitiveString[])List.Clone();
                int c = New.Length;
                Array.Resize(ref New, c + 1);
                New[c] = BareJid;
                List = New;
            }
 
            return true;
        }
 
        private bool Remove(ref CaseInsensitiveString[] List, CaseInsensitiveString BareJid)
        {
            if (List is null)
                return false;
 
            CaseInsensitiveString[] New = (CaseInsensitiveString[])List.Clone();
            int i = Array.IndexOf(New, BareJid);
            if (i < 0)
                return false;
 
            int c = New.Length;
 
            if (i < c - 1)
                Array.Copy(New, i + 1, New, i, c - 1 - i);
 
            Array.Resize(ref New, c - 1);
            List = New;
 
            return true;
        }
    }
}