Esempio n. 1
0
        public async Task <FcmInfo> RevokeFcmInfo(string userId, string deviceToken)
        {
            FilterDefinitionBuilder <FcmInfo> builder = Builders <FcmInfo> .Filter;
            FilterDefinition <FcmInfo>        finder  = builder.Eq("user_id", userId) & builder.Eq("device_token", deviceToken);
            FcmInfo exist = await fcmInfoRepository.FindAsync(finder);

            if (exist != null)
            {
                exist.DeviceToken  = string.Empty;
                exist.ModifiedDate = DateTime.Now;
                await fcmInfoRepository.UpdateAsync(exist, exist.Id);

                return(exist);
            }
            else
            {
                return(null);
            }
        }
Esempio n. 2
0
        public async Task <FcmInfo> AddFcmInfo(string userId, string deviceToken)
        {
            FilterDefinition <FcmInfo> finder = Builders <FcmInfo> .Filter.Eq("user_id", userId);

            FcmInfo existFcmInfo = await fcmInfoRepository.FindAsync(finder);

            if (existFcmInfo != null)
            {
                //Remove other
                FilterDefinitionBuilder <FcmInfo> _builder = Builders <FcmInfo> .Filter;
                FilterDefinition <FcmInfo>        _finder  = _builder.Eq("device_token", deviceToken);
                var exist = await fcmInfoRepository.FindListAsync(_finder);

                exist.ForEach(async x =>
                {
                    x.DeviceToken = string.Empty;
                    await fcmInfoRepository.UpdateAsync(x, x.Id);
                });

                existFcmInfo.DeviceToken  = deviceToken;
                existFcmInfo.ModifiedDate = DateTime.Now;
                await fcmInfoRepository.UpdateAsync(existFcmInfo, existFcmInfo.Id);

                existFcmInfo.IsActive = true;
                return(existFcmInfo);
            }
            else
            {
                FcmInfo newFcmInfo = new FcmInfo()
                {
                    UserId       = userId,
                    DeviceToken  = deviceToken,
                    CreatedDate  = DateTime.Now,
                    ModifiedDate = DateTime.Now,
                    IsActive     = true
                };
                await fcmInfoRepository.AddAsync(newFcmInfo);

                return(newFcmInfo);
            }
        }
Esempio n. 3
0
        public async Task <ActionResult <Client> > Login([FromBody] LoginModel model)
        {
            if (ModelState.IsValid)
            {
                Client client = await _unitOfWork.Clients.FindAsync(clnt =>
                                                                    clnt.AbonementNumber == int.Parse(model.AbonementNumber) &&
                                                                    clnt.PasswordHash.Equals(model.PasswordHash));

                if (client != null)
                {
                    await AuthenticateClient(client); // аутентификация

                    //найдем все записи, связанные с id клиента
                    var records = await _unitOfWork.ClientsFcmInfos.FindAllAsync(_cli => _cli.ClientId.Equals(client.Id));

                    if (records != null) //если есть записи
                    {
                        //теперь поищем, нет ли похожего токена в таблице
                        FcmInfo Fcmrecords = null;

                        foreach (var rec in records)
                        {
                            Fcmrecords = await _unitOfWork.FcmInfos.GetAsync(rec.FcmInfoId);

                            if (Fcmrecords != null)
                            {
                                break;
                            }
                        }
                        //если записи в таблице нет, создаем
                        if (Fcmrecords == null)
                        {
                            var info = await _unitOfWork.FcmInfos.AddAsync(new FcmInfo
                                                                           { FcmToken = model.FcmToken, RegistrationDateTime = DateTime.Now });

                            //2. связываем отношением многие ко многим
                            await _unitOfWork.ClientsFcmInfos.AddAsync(new ClientsFcmInfo { ClientId = client.Id, FcmInfoId = info.Id });
                        }
                        else
                        {
                            Fcmrecords.RegistrationDateTime = DateTime.Now;
                            //иначе просто обновим
                            await _unitOfWork.FcmInfos.UpdateAsync(Fcmrecords);
                        }
                    }
                    else //иначе добавим запись
                    {
                        //1.создаем запись в FcmInfo
                        var info = await _unitOfWork.FcmInfos.AddAsync(new FcmInfo
                                                                       { FcmToken = model.FcmToken, RegistrationDateTime = DateTime.Now });

                        //2. связываем отношением многие ко многим
                        await _unitOfWork.ClientsFcmInfos.AddAsync(new ClientsFcmInfo { ClientId = client.Id, FcmInfoId = info.Id });
                    }

                    return(Ok(await client.ToJSONAsync(_unitOfWork)));
                }
                ModelState.AddModelError("", "Некорректные логин и(или) пароль");
            }

            return(NotFound());
        }