public async Task <bool> Delete(SLAEscalationMail SLAEscalationMail)
 {
     if (await ValidateId(SLAEscalationMail))
     {
     }
     return(SLAEscalationMail.IsValidated);
 }
        public async Task <SLAEscalationMail> Get(long Id)
        {
            SLAEscalationMail SLAEscalationMail = await DataContext.SLAEscalationMail.AsNoTracking()
                                                  .Where(x => x.Id == Id).Select(x => new SLAEscalationMail()
            {
                CreatedAt       = x.CreatedAt,
                UpdatedAt       = x.UpdatedAt,
                Id              = x.Id,
                SLAEscalationId = x.SLAEscalationId,
                Mail            = x.Mail,
                SLAEscalation   = x.SLAEscalation == null ? null : new SLAEscalation
                {
                    Id = x.SLAEscalation.Id,
                    TicketIssueLevelId = x.SLAEscalation.TicketIssueLevelId,
                    IsNotification     = x.SLAEscalation.IsNotification,
                    IsMail             = x.SLAEscalation.IsMail,
                    IsSMS             = x.SLAEscalation.IsSMS,
                    Time              = x.SLAEscalation.Time,
                    TimeUnitId        = x.SLAEscalation.TimeUnitId,
                    IsAssignedToUser  = x.SLAEscalation.IsAssignedToUser,
                    IsAssignedToGroup = x.SLAEscalation.IsAssignedToGroup,
                    SmsTemplateId     = x.SLAEscalation.SmsTemplateId,
                    MailTemplateId    = x.SLAEscalation.MailTemplateId,
                },
            }).FirstOrDefaultAsync();

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

            return(SLAEscalationMail);
        }
        public async Task <bool> Delete(SLAEscalationMail SLAEscalationMail)
        {
            await DataContext.SLAEscalationMail.Where(x => x.Id == SLAEscalationMail.Id).UpdateFromQueryAsync(x => new SLAEscalationMailDAO {
                DeletedAt = StaticParams.DateTimeNow
            });

            return(true);
        }
 public TicketIssueLevel_SLAEscalationMailDTO(SLAEscalationMail SLAEscalationMail)
 {
     this.Id = SLAEscalationMail.Id;
     this.SLAEscalationId = SLAEscalationMail.SLAEscalationId;
     this.Mail            = SLAEscalationMail.Mail;
     this.SLAEscalation   = SLAEscalationMail.SLAEscalation == null ? null : new TicketIssueLevel_SLAEscalationDTO(SLAEscalationMail.SLAEscalation);
     this.CreatedAt       = SLAEscalationMail.CreatedAt;
     this.UpdatedAt       = SLAEscalationMail.UpdatedAt;
     this.Errors          = SLAEscalationMail.Errors;
 }
        public async Task <SLAEscalationMail> Get(long Id)
        {
            SLAEscalationMail SLAEscalationMail = await UOW.SLAEscalationMailRepository.Get(Id);

            if (SLAEscalationMail == null)
            {
                return(null);
            }
            return(SLAEscalationMail);
        }
        public async Task <bool> Create(SLAEscalationMail SLAEscalationMail)
        {
            SLAEscalationMailDAO SLAEscalationMailDAO = new SLAEscalationMailDAO();

            SLAEscalationMailDAO.Id = SLAEscalationMail.Id;
            SLAEscalationMailDAO.SLAEscalationId = SLAEscalationMail.SLAEscalationId;
            SLAEscalationMailDAO.Mail            = SLAEscalationMail.Mail;
            SLAEscalationMailDAO.CreatedAt       = StaticParams.DateTimeNow;
            SLAEscalationMailDAO.UpdatedAt       = StaticParams.DateTimeNow;
            DataContext.SLAEscalationMail.Add(SLAEscalationMailDAO);
            await DataContext.SaveChangesAsync();

            SLAEscalationMail.Id = SLAEscalationMailDAO.Id;
            await SaveReference(SLAEscalationMail);

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

            if (SLAEscalationMailDAO == null)
            {
                return(false);
            }
            SLAEscalationMailDAO.Id = SLAEscalationMail.Id;
            SLAEscalationMailDAO.SLAEscalationId = SLAEscalationMail.SLAEscalationId;
            SLAEscalationMailDAO.Mail            = SLAEscalationMail.Mail;
            SLAEscalationMailDAO.UpdatedAt       = StaticParams.DateTimeNow;
            await DataContext.SaveChangesAsync();

            await SaveReference(SLAEscalationMail);

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

            int count = await UOW.SLAEscalationMailRepository.Count(SLAEscalationMailFilter);

            if (count == 0)
            {
                SLAEscalationMail.AddError(nameof(SLAEscalationMailValidator), nameof(SLAEscalationMail.Id), ErrorCode.IdNotExisted);
            }
            return(count == 1);
        }
        public async Task <SLAEscalationMail> Update(SLAEscalationMail SLAEscalationMail)
        {
            if (!await SLAEscalationMailValidator.Update(SLAEscalationMail))
            {
                return(SLAEscalationMail);
            }
            try
            {
                var oldData = await UOW.SLAEscalationMailRepository.Get(SLAEscalationMail.Id);

                await UOW.Begin();

                await UOW.SLAEscalationMailRepository.Update(SLAEscalationMail);

                await UOW.Commit();

                SLAEscalationMail = await UOW.SLAEscalationMailRepository.Get(SLAEscalationMail.Id);

                await Logging.CreateAuditLog(SLAEscalationMail, oldData, nameof(SLAEscalationMailService));

                return(SLAEscalationMail);
            }
            catch (Exception ex)
            {
                await UOW.Rollback();

                if (ex.InnerException == null)
                {
                    await Logging.CreateSystemLog(ex, nameof(SLAEscalationMailService));

                    throw new MessageException(ex);
                }
                else
                {
                    await Logging.CreateSystemLog(ex.InnerException, nameof(SLAEscalationMailService));

                    throw new MessageException(ex.InnerException);
                }
            }
        }
 public async Task <bool> Create(SLAEscalationMail SLAEscalationMail)
 {
     return(SLAEscalationMail.IsValidated);
 }
 private async Task SaveReference(SLAEscalationMail SLAEscalationMail)
 {
 }