public IotHubConnection(IotHubConnectionString connectionString, AccessRights accessRights)
 {
     this.connectionString = connectionString;
     this.accessRights = accessRights;
     this.faultTolerantSession = new FaultTolerantAmqpObject<AmqpSession>(this.CreateSessionAsync, this.CloseConnection);
     this.refreshTokenTimer = new IOThreadTimer(s => ((IotHubConnection)s).OnRefreshToken(), this, false);
 }

 public BaseRole(string sName, string sID, string sPath, AccessRights AccessRights)
 {
     _sName = sName;
     _sID = sID;
     _sPath = sPath;
     _AccessRight = AccessRights;
 }

 public ServiceBusQueueListenerFactory(ServiceBusAccount account, string queueName, ITriggeredFunctionExecutor executor, AccessRights accessRights)
 {
     _namespaceManager = account.NamespaceManager;
     _messagingFactory = account.MessagingFactory;
     _queueName = queueName;
     _executor = executor;
     _accessRights = accessRights;
 }

 public VKApiManager(int appId, AccessRights rights, bool xmlNeeded = true)
 {
     AuthorizationDetails details = new AuthorizationDetails();
     details.appId = appId;
     details.rights = rights;
     IsXmlResponseNeeded = xmlNeeded;
     status = Init(details);
 }

		/// <summary>
		/// Initializes a new instance of the <see cref="MailKit.AccessControl"/> class.
		/// </summary>
		/// <remarks>
		/// Creates a new <see cref="MailKit.AccessControl"/> with the given name and
		/// access rights.
		/// </remarks>
		/// <param name="name">The identifier name.</param>
		/// <param name="rights">The access rights.</param>
		/// <exception cref="System.ArgumentNullException">
		/// <paramref name="name"/> is <c>null</c>.
		/// </exception>
		public AccessControl (string name, IEnumerable<AccessRight> rights)
		{
			if (name == null)
				throw new ArgumentNullException ("name");

			Rights = new AccessRights (rights);
			Name = name;
		}

		/// <summary>
		/// Initializes a new instance of the <see cref="MailKit.AccessControl"/> class.
		/// </summary>
		/// <remarks>
		/// Creates a new <see cref="MailKit.AccessControl"/> with the given name and
		/// access rights.
		/// </remarks>
		/// <param name="name">The identifier name.</param>
		/// <param name="rights">The access rights.</param>
		/// <exception cref="System.ArgumentNullException">
		/// <para><paramref name="name"/> is <c>null</c>.</para>
		/// <para>-or-</para>
		/// <para><paramref name="rights"/> is <c>null</c>.</para>
		/// </exception>
		public AccessControl (string name, string rights)
		{
			if (name == null)
				throw new ArgumentNullException (nameof (name));

			Rights = new AccessRights (rights);
			Name = name;
		}

        public async Task CreateAsync_AccessRightsNotManage_DoesNotCreateQueue(AccessRights accessRights)
        {
            ServiceBusAccount account = new ServiceBusAccount();
            Mock<ITriggeredFunctionExecutor> mockExecutor = new Mock<ITriggeredFunctionExecutor>(MockBehavior.Strict);
            ServiceBusQueueListenerFactory factory = new ServiceBusQueueListenerFactory(account, "testqueue", mockExecutor.Object, accessRights);

            IListener listener = await factory.CreateAsync(CancellationToken.None);
            Assert.NotNull(listener);
        }

 public ServiceBusSubscriptionListenerFactory(ServiceBusAccount account, string topicName, string subscriptionName, ITriggeredFunctionExecutor executor, AccessRights accessRights)
 {
     _namespaceManager = account.NamespaceManager;
     _messagingFactory = account.MessagingFactory;
     _topicName = topicName;
     _subscriptionName = subscriptionName;
     _executor = executor;
     _accessRights = accessRights;
 }

        public async Task CreateAsync_AccessRightsNotManage_DoesNotCreateTopicOrSubscription(AccessRights accessRights)
        {
            ServiceBusAccount account = new ServiceBusAccount();
            Mock<ITriggeredFunctionExecutor> mockExecutor = new Mock<ITriggeredFunctionExecutor>(MockBehavior.Strict);
            ServiceBusSubscriptionListenerFactory factory = new ServiceBusSubscriptionListenerFactory(account, "testtopic", "testsubscription", mockExecutor.Object, accessRights, new ServiceBusConfiguration());

            IListener listener = await factory.CreateAsync(CancellationToken.None);
            Assert.NotNull(listener);
        }

 public ServiceBusBinding(string parameterName, IArgumentBinding<ServiceBusEntity> argumentBinding, ServiceBusAccount account, IBindableServiceBusPath path, AccessRights accessRights)
 {
     _parameterName = parameterName;
     _argumentBinding = argumentBinding;
     _account = account;
     _namespaceName = ServiceBusClient.GetNamespaceName(account);
     _path = path;
     _accessRights = accessRights;
     _converter = CreateConverter(account, path, accessRights);
 }

 /// <summary>
 /// Констуктор по умолчанию.
 /// </summary>
 public AuthorizationDetails()
 {
     appId = -1;
     secureKey = String.Empty;
     rights = AccessRights.NO_RIGHTS;
     userId = -1;
     accessToken = String.Empty;
     expiresIn = -1;
     issuedTime = DateTime.MinValue;
 }

 public ServiceBusTriggerBinding(string parameterName, ITriggerDataArgumentBinding<BrokeredMessage> argumentBinding,
     ServiceBusAccount account, string topicName, string subscriptionName, AccessRights accessRights)
 {
     _parameterName = parameterName;
     _argumentBinding = argumentBinding;
     _account = account;
     _namespaceName = ServiceBusClient.GetNamespaceName(account);
     _topicName = topicName;
     _subscriptionName = subscriptionName;
     _entityPath = SubscriptionClient.FormatSubscriptionPath(topicName, subscriptionName);
     _accessRights = accessRights;
 }

        private void FixReferencedMemberAccess(AccessRights memberAccessRights)
        {
            var declaration =
                _highlighting.LessVisibleReferencedMember.DeclaredElement
                    .GetDeclarations().FirstOrDefault();

            Contract.Assert(declaration != null);

            ModifiersUtil.SetAccessRights(
                declaration,
                memberAccessRights);
        }

        internal MemberWithAccess(IClrDeclaredElement declaredElement, AccessRights typeAccessRights,
            MemberType memberType, AccessRights memberAccessRights)
        {
            Contract.Requires(declaredElement != null);

            _declaredElement = declaredElement;

            MemberName = declaredElement.ShortName;
            TypeAccessRights = typeAccessRights;
            MemberType = memberType;
            _memberAccessRights = memberAccessRights;
        }

        public static string[] AccessRightsToStringArray(AccessRights accessRights)
        {
            var values = new List<string>(2);
            foreach (AccessRights right in Enum.GetValues(typeof(AccessRights)))
            {
                if (accessRights.HasFlag(right))
                {
                    values.Add(right.ToString());
                }
            }

            return values.ToArray();
        }

        private void FixReferencedTypeAccess(AccessRights newTypeAccess)
        {
            var declaration =
                _highlighting.LessVisibleReferencedMember.DeclaredElement
                .With(x => x.GetContainingType())
                .With(x => x.GetDeclarations().FirstOrDefault());

            Contract.Assert(declaration != null);

            ModifiersUtil.SetAccessRights(
                declaration,
                newTypeAccess);
        }

        public static async Task SendAndCreateQueueIfNotExistsAsync(this MessageSender sender, BrokeredMessage message,
            Guid functionInstanceId, NamespaceManager namespaceManager, AccessRights accessRights, CancellationToken cancellationToken)
        {
            if (sender == null)
            {
                throw new ArgumentNullException("sender");
            }
            else if (namespaceManager == null)
            {
                throw new ArgumentNullException("namespaceManager");
            }

            ServiceBusCausalityHelper.EncodePayload(functionInstanceId, message);

            bool threwMessgingEntityNotFoundException = false;
            cancellationToken.ThrowIfCancellationRequested();

            try
            {
                await sender.SendAsync(message);
                return;
            }
            catch (MessagingEntityNotFoundException)
            {
                if (accessRights != AccessRights.Manage)
                {
                    // if we don't have the required rights to create the queue,
                    // rethrow the exception
                    throw;
                }

                threwMessgingEntityNotFoundException = true;
            }

            Debug.Assert(threwMessgingEntityNotFoundException);
            cancellationToken.ThrowIfCancellationRequested();

            try
            {
                await namespaceManager.CreateQueueAsync(sender.Path);
            }
            catch (MessagingEntityAlreadyExistsException)
            {
            }

            // Clone the message because it was already consumed before (when trying to send)
            // otherwise, you get an exception
            message = message.Clone();
            cancellationToken.ThrowIfCancellationRequested();
            await sender.SendAsync(message);
        }

        public byte[] ChannelCreatedMessage(int clientId, int serverId, EpicsType dataType, int dataCount, AccessRights access)
        {
            MemoryStream mem = new MemoryStream();
            BinaryWriter writer = new BinaryWriter(mem);

            mem.Capacity = 32;

            writer.Write(((UInt16)CommandID.CA_PROTO_ACCESS_RIGHTS).ToByteArray());
            writer.Write(new byte[6]);
            writer.Write(((UInt32)clientId).ToByteArray());
            writer.Write(((UInt32)access).ToByteArray());

            writer.Write(((UInt16)CommandID.CA_PROTO_CREATE_CHAN).ToByteArray());
            if (dataCount > 30000)
                writer.Write(new byte[] { 0xFF, 0xFF });
            else
                writer.Write(new byte[2]);
            writer.Write(((UInt16)dataType).ToByteArray());
            if (dataCount > 30000)
                writer.Write(new byte[] { 0x00, 0x00 });
            else
                writer.Write(((UInt16)dataCount).ToByteArray());
            writer.Write(((UInt32)clientId).ToByteArray());
            writer.Write(((UInt32)serverId).ToByteArray());
            if (dataCount > 30000)
            {
                // Size
                writer.Write(((UInt32)0).ToByteArray());
                // Data count
                writer.Write(((UInt32)dataCount).ToByteArray());
            }

            byte[] buffer = mem.ToArray();
            writer.Close();
            mem.Dispose();

            return buffer;
        }

 public CAServerChannel(CAServer cAServer, int serverId, int clientId, string channelName, CATcpConnection tcpConnection)
 {
     // TODO: Complete member initialization
     this.Server = cAServer;
     this.ServerId = serverId;
     this.ClientId = clientId;
     this.ChannelName = channelName;
     this.TcpConnection = tcpConnection;
     tcpConnection.Closing += new EventHandler(tcpConnection_Closing);
     Property = "VAL";
     if (channelName.Contains("."))
     {
         string[] splitted = channelName.Split('.');
         Record = Server.records[splitted[0]];
         Property = splitted[1].ToUpper();
     }
     else
         Record = Server.records[ChannelName];
     if (!Record.CanBeRemotlySet)
         Access = AccessRights.ReadOnly;
     TcpConnection.Send(Server.Filter.ChannelCreatedMessage(ClientId, ServerId, FindType(Record), Record.dataCount, Access));
     //TcpConnection.Send(Server.Filter.ChannelCreatedMessage(ClientId, ServerId, FindType(Record[Property].GetType()), Record.dataCount, Access));
 }

		/// <summary>
		/// Asynchronously set the access rights for the specified identity.
		/// </summary>
		/// <remarks>
		/// Asynchronously sets the access rights for the specified identity.
		/// </remarks>
		/// <returns>An asynchronous task context.</returns>
		/// <param name="name">The identity name.</param>
		/// <param name="rights">The access rights.</param>
		/// <param name="cancellationToken">The cancellation token.</param>
		/// <exception cref="System.ArgumentNullException">
		/// <para><paramref name="name"/> is <c>null</c>.</para>
		/// <para>-or-</para>
		/// <para><paramref name="rights"/> is <c>null</c>.</para>
		/// </exception>
		/// <exception cref="System.ObjectDisposedException">
		/// The <see cref="IMailStore"/> has been disposed.
		/// </exception>
		/// <exception cref="ServiceNotConnectedException">
		/// The <see cref="IMailStore"/> is not connected.
		/// </exception>
		/// <exception cref="ServiceNotAuthenticatedException">
		/// The <see cref="IMailStore"/> is not authenticated.
		/// </exception>
		/// <exception cref="System.NotSupportedException">
		/// The mail store does not support the ACL extension.
		/// </exception>
		/// <exception cref="System.OperationCanceledException">
		/// The operation was canceled via the cancellation token.
		/// </exception>
		/// <exception cref="System.IO.IOException">
		/// An I/O error occurred.
		/// </exception>
		/// <exception cref="ProtocolException">
		/// The server's response contained unexpected tokens.
		/// </exception>
		/// <exception cref="CommandException">
		/// The command failed.
		/// </exception>
		public virtual Task SetAccessRightsAsync (string name, AccessRights rights, CancellationToken cancellationToken = default (CancellationToken))
		{
			if (name == null)
				throw new ArgumentNullException ("name");

			if (rights == null)
				throw new ArgumentNullException ("rights");

			return Task.Factory.StartNew (() => {
				lock (SyncRoot) {
					SetAccessRights (name, rights, cancellationToken);
				}
			}, cancellationToken, TaskCreationOptions.None, TaskScheduler.Default);
		}