Beispiel #1
0
        /// <summary>
        /// Returns all dialogs associated with current user
        /// </summary>
        /// <param name="retrieveDialogsRequest">Retrieve dialogs request info</param>
        /// <returns></returns>
        public async Task <HttpResponse <RetrieveDialogsResponse> > GetDialogsAsync(RetrieveDialogsRequest retrieveDialogsRequest = null)
        {
            var headers = RequestHeadersBuilder.GetDefaultHeaders().GetHeaderWithQbToken(this.quickbloxClient.Token);

            return(await HttpService.GetAsync <RetrieveDialogsResponse, RetrieveDialogsRequest>(this.quickbloxClient.ApiEndPoint,
                                                                                                QuickbloxMethods.GetDialogsMethod, retrieveDialogsRequest, headers));
        }
Beispiel #2
0
        public async Task GetDialogsWithOperationFiltersSuccess()
        {
            var retriveDialogsRequest = new RetrieveDialogsRequest();

            var aggregator = new FilterAggregator();

            aggregator.Filters.Add(new SortFilter <int>(SortOperator.Asc, () => new DialogResponse().Type));
            aggregator.Filters.Add(new FieldFilterWithOperator <String>(SearchOperators.Lte, () => new DialogResponse().Id, "551d50bd535c123fc50260db"));

            retriveDialogsRequest.Filter = aggregator;
            var response = await this.client.ChatClient.GetDialogsAsync(retriveDialogsRequest);

            Assert.AreEqual(response.StatusCode, HttpStatusCode.OK);
        }
Beispiel #3
0
        public async Task GetDialogsWithFiltersSuccess()
        {
            var retriveDialogsRequest = new RetrieveDialogsRequest();

            var aggregator = new FilterAggregator();

            //aggregator.Filters.Add(new DialogSortFilter<int>(SortOperator.Asc, () => new DialogResponse().Type));
            aggregator.Filters.Add(new FieldFilter <int[]>(() => new DialogResponse().OccupantsIds, new int[] { 11879, 12779 }));

            retriveDialogsRequest.Filter = aggregator;
            var response = await this.client.ChatClient.GetDialogsAsync(retriveDialogsRequest);

            Assert.AreEqual(response.StatusCode, HttpStatusCode.OK);
        }
Beispiel #4
0
        public async Task <Dialog> GetDialogAsync(string dialogId)
        {
            var retrieveDialogsRequest = new RetrieveDialogsRequest();
            var filterAgreaggator      = new FilterAggregator();

            filterAgreaggator.Filters.Add(new FieldFilterWithOperator <string>(SearchOperators.In, () => new DialogResponse().Id, dialogId));
            retrieveDialogsRequest.Filter = filterAgreaggator;
            var response = await client.ChatClient.GetDialogsAsync(retrieveDialogsRequest);

            if (await HandleResponse(response, HttpStatusCode.OK) && response.Result.Items.Any())
            {
                return(response.Result.Items[0]);
            }

            return(null);
        }
        public async Task <DialogTable> GetDialogAsync(int[] userIds)
        {
            var retrieveDialogsRequest = new RetrieveDialogsRequest();
            var filterAgreaggator      = new FilterAggregator();

            filterAgreaggator.Filters.Add(new FieldFilterWithOperator <int[]>(SearchOperators.All, () => new DialogResponse().OccupantsIds, userIds));
            retrieveDialogsRequest.Filter = filterAgreaggator;
            var response = await client.ChatClient.GetDialogsAsync(retrieveDialogsRequest);

            if (await HandleResponse(response, HttpStatusCode.OK) && response.Result.Items.Any())
            {
                return(new DialogTable(response.Result.Items[0]));
            }

            return(null);
        }
Beispiel #6
0
        public async Task <Dialog> GetDialogAsync(int[] userIds)
        {
            var retrieveDialogsRequest = new RetrieveDialogsRequest();
            var filterAgreaggator      = new FilterAggregator();

            //filterAgreaggator.Filters.Add(new FieldFilterWithOperator<int[]>(SearchOperators.In, () => new DialogResponse().OccupantsIds, userIds));
            filterAgreaggator.Filters.Add(new FieldFilterWithOperator <int>(SearchOperators.In, () => new DialogResponse().Type, (int)DialogType.Private));
            retrieveDialogsRequest.Filter = filterAgreaggator;
            var response = await client.ChatClient.GetDialogsAsync(retrieveDialogsRequest);

            if (await HandleResponse(response, HttpStatusCode.OK) && response.Result.Items.Any())
            {
                var dialog = response.Result.Items.FirstOrDefault(d => d.OccupantsIds.Contains(userIds[0]) && d.OccupantsIds.Contains(userIds[1]));
                return(dialog);
            }

            return(null);
        }
Beispiel #7
0
        public async Task <List <Dialog> > GetDialogsAsync(List <DialogType> dialogTypeParams)
        {
            var retrieveDialogsRequest = new RetrieveDialogsRequest();

            //TODO: change limit
            retrieveDialogsRequest.Limit = 25;
            if (dialogTypeParams != null)
            {
                var filterAgreaggator = new FilterAggregator();
                var dialogTypes       = string.Join(",", dialogTypeParams.Select(type => (int)type));
                filterAgreaggator.Filters.Add(new FieldFilterWithOperator <int>(SearchOperators.In, () => new DialogResponse().Type, dialogTypes));
                retrieveDialogsRequest.Filter = filterAgreaggator;
            }
            var response = await client.ChatClient.GetDialogsAsync(retrieveDialogsRequest);

            if (await HandleResponse(response, HttpStatusCode.OK))
            {
                return(response.Result.Items.ToList());
            }

            return(null);
        }
		public async Task<List<DialogTable>> GetDialogsAsync(List<DialogType> dialogTypeParams)
		{
			var dialogs = new List<DialogTable> ();
			var retrieveDialogsRequest = new RetrieveDialogsRequest();

			//TODO: change limit
			retrieveDialogsRequest.Limit = 100;
			if (dialogTypeParams != null) {
				var filterAgreaggator = new FilterAggregator ();
				var dialogTypes = string.Join (",", dialogTypeParams.Select(type => (int)type));
				filterAgreaggator.Filters.Add (new FieldFilterWithOperator<int> (SearchOperators.In, () => new DialogResponse ().Type, dialogTypes));
				retrieveDialogsRequest.Filter = filterAgreaggator;
			}
			var response = await client.ChatClient.GetDialogsAsync(retrieveDialogsRequest);
			if (await HandleResponse(response, HttpStatusCode.OK)) {
				dialogs = response.Result.Items.Select(d => new DialogTable(d)).ToList();
			}

			return dialogs;
		}
		public async Task<Dialog> GetDialogAsync(string dialogId)
		{
			var retrieveDialogsRequest = new RetrieveDialogsRequest();
			var filterAgreaggator = new FilterAggregator ();
			filterAgreaggator.Filters.Add(new FieldFilterWithOperator<string>(SearchOperators.In, () => new DialogResponse().Id, dialogId));
			retrieveDialogsRequest.Filter = filterAgreaggator;
			var response = await client.ChatClient.GetDialogsAsync(retrieveDialogsRequest);
			if (await HandleResponse(response, HttpStatusCode.OK) && response.Result.Items.Any()) {
				return response.Result.Items[0];
			}

			return null;
		}
		public async Task<Dialog> GetDialogAsync(int[] userIds)
		{
			var retrieveDialogsRequest = new RetrieveDialogsRequest();
            retrieveDialogsRequest.Limit = 100;

            var filterAgreaggator = new FilterAggregator ();
            filterAgreaggator.Filters.Add (new FieldFilterWithOperator<int> (SearchOperators.In, () => new DialogResponse ().Type, (int)DialogType.Private));
			retrieveDialogsRequest.Filter = filterAgreaggator;
			var response = await client.ChatClient.GetDialogsAsync(retrieveDialogsRequest);
			if (await HandleResponse(response, HttpStatusCode.OK) && response.Result.Items.Any()) {
				var dialog = response.Result.Items.FirstOrDefault (d => d.OccupantsIds.Contains (userIds [0]) && d.OccupantsIds.Contains (userIds [1]));
				return dialog;
			}

			return null;
		}
        public async Task ReloadDialogs()
        {
            if (isReloadingDialogs) return;
            isReloadingDialogs = true;

            try
            {
                var retrieveDialogsRequest = new RetrieveDialogsRequest();
                var response = await quickbloxClient.ChatClient.GetDialogsAsync(retrieveDialogsRequest);
                if (response.StatusCode == HttpStatusCode.OK)
                {
                    Dialogs.Clear();
                    var currentUserId = SettingsManager.Instance.ReadFromSettings<int>(SettingsKeys.CurrentUserId);
                    foreach (var dialog in response.Result.Items)
                    {
                        if (dialog.Type == DialogType.PublicGroup) continue;

                        var dialogVm = DialogViewModel.FromDialog(dialog);

                        if (dialog.Type == DialogType.Private)
                        {
                            int otherUserId = dialogVm.OccupantIds.FirstOrDefault(o => o != currentUserId);
                            dialogVm.Name = GetUserNameFromContacts(otherUserId);
                        }

                        Dialogs.Add(dialogVm);
                    }

                    JoinAllGroupDialogs();
                    await UpdateDialogsStates();
                }
            }
            finally
            {
                isReloadingDialogs = false;
            }
        }