public async Task <ChanpropsRecord> Create(ChanpropsRecord model)
        {
            var tracking = peerChatDb.ChangeTracker.QueryTrackingBehavior;

            peerChatDb.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;

            var existingRecord = await Lookup(new ChanpropsLookup { channelmask = model.channelmask });

            var record = existingRecord.FirstOrDefault();

            model.setAt = DateTime.UtcNow;
            if (record == null)
            {
                var entry = await peerChatDb.AddAsync <ChanpropsRecord>(model);

                var num_modified = await peerChatDb.SaveChangesAsync();

                peerChatDb.ChangeTracker.QueryTrackingBehavior = tracking;
                await ResyncChanPropsForChanMask(model.channelmask, model.kickExisting ?? false);

                return(entry.Entity);
            }
            else
            {
                model.Id = record.Id;
                var entry = peerChatDb.Update <ChanpropsRecord>(model);
                await peerChatDb.SaveChangesAsync();

                peerChatDb.ChangeTracker.QueryTrackingBehavior = tracking;
                await ResyncChanPropsForChanMask(model.channelmask, model.kickExisting ?? false);


                return(entry.Entity);
            }
        }
        public async Task <UsermodeRecord> Create(UsermodeRecord model)
        {
            if (model.isGlobal == true)
            {
                model.setAt = DateTime.UtcNow;
                var entry = await peerChatDb.AddAsync <UsermodeRecord>(model);

                var num_modified = await peerChatDb.SaveChangesAsync();
                await ApplyUserrecords(entry.Entity);

                SendBansUpdate(new List <UsermodeRecord> {
                    entry.Entity
                }, false);
                await ResyncChannelUsermodes(model.channelmask);

                return(entry.Entity);
            }
            else
            {
                if (model.channelmask.Contains("*"))
                {
                    return(null);
                }
                model.Id = WriteTemporaryUsermode(model);
                SendBansUpdate(new List <UsermodeRecord> {
                    model
                }, true);
                await ResyncChannelUsermodes(model.channelmask);

                return(model);
            }
        }
        public async Task <GlobalOpersRecord> Create(GlobalOpersRecord model)
        {
            var entry = await peerChatDb.AddAsync <GlobalOpersRecord>(model);

            var num_modified = await peerChatDb.SaveChangesAsync(true);

            return(entry.Entity);
        }