Beispiel #1
0
        public async Task <Notificaiton> Create(Notificaiton Notificaiton)
        {
            if (!await NotificaitonValidator.Create(Notificaiton))
            {
                return(Notificaiton);
            }

            try
            {
                await UOW.Begin();

                await UOW.NotificaitonRepository.Create(Notificaiton);

                await UOW.Commit();

                await Logging.CreateAuditLog(Notificaiton, new { }, nameof(NotificaitonService));

                return(await UOW.NotificaitonRepository.Get(Notificaiton.Id));
            }
            catch (Exception ex)
            {
                await UOW.Rollback();

                await Logging.CreateSystemLog(ex.InnerException, nameof(NotificaitonService));

                if (ex.InnerException == null)
                {
                    throw new MessageException(ex);
                }
                else
                {
                    throw new MessageException(ex.InnerException);
                }
            }
        }
        public async Task <Notificaiton> Get(long Id)
        {
            Notificaiton Notificaiton = await DataContext.Notificaiton.Where(x => x.Id == Id).Select(x => new Notificaiton()
            {
                Id        = x.Id,
                AccountId = x.AccountId,
                Content   = x.Content,
                Time      = x.Time,
                Unread    = x.Unread,
                Account   = x.Account == null ? null : new Account
                {
                    Id                   = x.Account.Id,
                    DisplayName          = x.Account.DisplayName,
                    Email                = x.Account.Email,
                    Phone                = x.Account.Phone,
                    Password             = x.Account.Password,
                    Salt                 = x.Account.Salt,
                    PasswordRecoveryCode = x.Account.PasswordRecoveryCode,
                    ExpiredTimeCode      = x.Account.ExpiredTimeCode,
                    Address              = x.Account.Address,
                    Dob                  = x.Account.Dob,
                    Avatar               = x.Account.Avatar,
                    RoleId               = x.Account.RoleId,
                },
            }).AsNoTracking().FirstOrDefaultAsync();

            if (Notificaiton == null)
            {
                return(null);
            }

            return(Notificaiton);
        }
 public async Task <bool> Delete(Notificaiton Notificaiton)
 {
     if (await ValidateId(Notificaiton))
     {
     }
     return(Notificaiton.IsValidated);
 }
Beispiel #4
0
        private Notificaiton ConvertDTOToEntity(Notificaiton_NotificaitonDTO Notificaiton_NotificaitonDTO)
        {
            Notificaiton Notificaiton = new Notificaiton();

            Notificaiton.Id        = Notificaiton_NotificaitonDTO.Id;
            Notificaiton.AccountId = Notificaiton_NotificaitonDTO.AccountId;
            Notificaiton.Content   = Notificaiton_NotificaitonDTO.Content;
            Notificaiton.Time      = Notificaiton_NotificaitonDTO.Time;
            Notificaiton.Unread    = Notificaiton_NotificaitonDTO.Unread;
            Notificaiton.Account   = Notificaiton_NotificaitonDTO.Account == null ? null : new Account
            {
                Id                   = Notificaiton_NotificaitonDTO.Account.Id,
                DisplayName          = Notificaiton_NotificaitonDTO.Account.DisplayName,
                Email                = Notificaiton_NotificaitonDTO.Account.Email,
                Phone                = Notificaiton_NotificaitonDTO.Account.Phone,
                Password             = Notificaiton_NotificaitonDTO.Account.Password,
                Salt                 = Notificaiton_NotificaitonDTO.Account.Salt,
                PasswordRecoveryCode = Notificaiton_NotificaitonDTO.Account.PasswordRecoveryCode,
                ExpiredTimeCode      = Notificaiton_NotificaitonDTO.Account.ExpiredTimeCode,
                Address              = Notificaiton_NotificaitonDTO.Account.Address,
                Dob                  = Notificaiton_NotificaitonDTO.Account.Dob,
                Avatar               = Notificaiton_NotificaitonDTO.Account.Avatar,
                RoleId               = Notificaiton_NotificaitonDTO.Account.RoleId,
            };
            Notificaiton.BaseLanguage = CurrentContext.Language;
            return(Notificaiton);
        }
 public Notificaiton_NotificaitonDTO(Notificaiton Notificaiton)
 {
     this.Id        = Notificaiton.Id;
     this.AccountId = Notificaiton.AccountId;
     this.Content   = Notificaiton.Content;
     this.Time      = Notificaiton.Time;
     this.Unread    = Notificaiton.Unread;
     this.Account   = Notificaiton.Account == null ? null : new Notificaiton_AccountDTO(Notificaiton.Account);
     this.Errors    = Notificaiton.Errors;
 }
Beispiel #6
0
        public bool RequestMovie(IWebElement movieElement)
        {
            var request = movieElement.FindElement(By.XPath(".//div[3]/form/button"));

            request.Click();

            PageFactory.InitElements(WebDriver, this);

            return(Notificaiton.Exists());
        }
Beispiel #7
0
        public async Task <Notificaiton> Get(long Id)
        {
            Notificaiton Notificaiton = await UOW.NotificaitonRepository.Get(Id);

            if (Notificaiton == null)
            {
                return(null);
            }
            return(Notificaiton);
        }
Beispiel #8
0
        public async Task <ActionResult <Notificaiton_NotificaitonDTO> > Get([FromBody] Notificaiton_NotificaitonDTO Notificaiton_NotificaitonDTO)
        {
            if (!ModelState.IsValid)
            {
                throw new BindException(ModelState);
            }

            Notificaiton Notificaiton = await NotificaitonService.Get(Notificaiton_NotificaitonDTO.Id);

            return(new Notificaiton_NotificaitonDTO(Notificaiton));
        }
        public async Task <bool> Create(Notificaiton Notificaiton)
        {
            NotificaitonDAO NotificaitonDAO = new NotificaitonDAO();

            NotificaitonDAO.Id        = Notificaiton.Id;
            NotificaitonDAO.AccountId = Notificaiton.AccountId;
            NotificaitonDAO.Content   = Notificaiton.Content;
            NotificaitonDAO.Time      = Notificaiton.Time;
            NotificaitonDAO.Unread    = Notificaiton.Unread;
            DataContext.Notificaiton.Add(NotificaitonDAO);
            await DataContext.SaveChangesAsync();

            Notificaiton.Id = NotificaitonDAO.Id;
            await SaveReference(Notificaiton);

            return(true);
        }
        public async Task <bool> Update(Notificaiton Notificaiton)
        {
            NotificaitonDAO NotificaitonDAO = DataContext.Notificaiton.Where(x => x.Id == Notificaiton.Id).FirstOrDefault();

            if (NotificaitonDAO == null)
            {
                return(false);
            }
            NotificaitonDAO.Id        = Notificaiton.Id;
            NotificaitonDAO.AccountId = Notificaiton.AccountId;
            NotificaitonDAO.Content   = Notificaiton.Content;
            NotificaitonDAO.Time      = Notificaiton.Time;
            NotificaitonDAO.Unread    = Notificaiton.Unread;
            await DataContext.SaveChangesAsync();

            await SaveReference(Notificaiton);

            return(true);
        }
        public async Task <bool> ValidateId(Notificaiton Notificaiton)
        {
            NotificaitonFilter NotificaitonFilter = new NotificaitonFilter
            {
                Skip = 0,
                Take = 10,
                Id   = new IdFilter {
                    Equal = Notificaiton.Id
                },
                Selects = NotificaitonSelect.Id
            };

            int count = await UOW.NotificaitonRepository.Count(NotificaitonFilter);

            if (count == 0)
            {
                Notificaiton.AddError(nameof(NotificaitonValidator), nameof(Notificaiton.Id), ErrorCode.IdNotExisted);
            }
            return(count == 1);
        }
Beispiel #12
0
        public async Task <ActionResult <Notificaiton_NotificaitonDTO> > Create([FromBody] Notificaiton_NotificaitonDTO Notificaiton_NotificaitonDTO)
        {
            if (!ModelState.IsValid)
            {
                throw new BindException(ModelState);
            }

            Notificaiton Notificaiton = ConvertDTOToEntity(Notificaiton_NotificaitonDTO);

            Notificaiton = await NotificaitonService.Create(Notificaiton);

            Notificaiton_NotificaitonDTO = new Notificaiton_NotificaitonDTO(Notificaiton);
            if (Notificaiton.IsValidated)
            {
                return(Notificaiton_NotificaitonDTO);
            }
            else
            {
                return(BadRequest(Notificaiton_NotificaitonDTO));
            }
        }
 private async Task SaveReference(Notificaiton Notificaiton)
 {
 }
        public async Task <bool> Delete(Notificaiton Notificaiton)
        {
            await DataContext.Notificaiton.Where(x => x.Id == Notificaiton.Id).DeleteFromQueryAsync();

            return(true);
        }
 public async Task <bool> Create(Notificaiton Notificaiton)
 {
     return(Notificaiton.IsValidated);
 }