public async Task <bool> Delete(KpiItemContent KpiItemContent)
 {
     if (await ValidateId(KpiItemContent))
     {
     }
     return(KpiItemContent.IsValidated);
 }
 public KpiItem_KpiItemContentDTO(KpiItemContent KpiItemContent)
 {
     this.Id        = KpiItemContent.Id;
     this.KpiItemId = KpiItemContent.KpiItemId;
     this.ItemId    = KpiItemContent.ItemId;
     this.Item      = KpiItemContent.Item == null ? null : new KpiItem_ItemDTO(KpiItemContent.Item);
     this.KpiItemContentKpiCriteriaItemMappings = KpiItemContent.KpiItemContentKpiCriteriaItemMappings?.ToDictionary(x => x.KpiCriteriaItemId, y => y.Value);
     this.Errors = KpiItemContent.Errors;
 }
        public async Task <KpiItemContent> Get(long Id)
        {
            KpiItemContent KpiItemContent = await UOW.KpiItemContentRepository.Get(Id);

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

            KpiItemContentDAO.Id        = KpiItemContent.Id;
            KpiItemContentDAO.KpiItemId = KpiItemContent.KpiItemId;
            KpiItemContentDAO.ItemId    = KpiItemContent.ItemId;
            DataContext.KpiItemContent.Add(KpiItemContentDAO);
            await DataContext.SaveChangesAsync();

            KpiItemContent.Id = KpiItemContentDAO.Id;
            await SaveReference(KpiItemContent);

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

            if (KpiItemContentDAO == null)
            {
                return(false);
            }
            KpiItemContentDAO.Id        = KpiItemContent.Id;
            KpiItemContentDAO.KpiItemId = KpiItemContent.KpiItemId;
            KpiItemContentDAO.ItemId    = KpiItemContent.ItemId;
            await DataContext.SaveChangesAsync();

            await SaveReference(KpiItemContent);

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

            int count = await UOW.KpiItemContentRepository.Count(KpiItemContentFilter);

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

                await UOW.Begin();

                await UOW.KpiItemContentRepository.Update(KpiItemContent);

                await UOW.Commit();

                KpiItemContent = await UOW.KpiItemContentRepository.Get(KpiItemContent.Id);

                await Logging.CreateAuditLog(KpiItemContent, oldData, nameof(KpiItemContentService));

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

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

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

                    throw new MessageException(ex.InnerException);
                }
            }
        }
        public async Task <KpiItemContent> Get(long Id)
        {
            KpiItemContent KpiItemContent = await DataContext.KpiItemContent.AsNoTracking()
                                            .Where(x => x.Id == Id).Select(x => new KpiItemContent()
            {
                Id        = x.Id,
                KpiItemId = x.KpiItemId,
                ItemId    = x.ItemId,
                Item      = x.Item == null ? null : new Item
                {
                    Id          = x.Item.Id,
                    ProductId   = x.Item.ProductId,
                    Code        = x.Item.Code,
                    Name        = x.Item.Name,
                    ScanCode    = x.Item.ScanCode,
                    SalePrice   = x.Item.SalePrice,
                    RetailPrice = x.Item.RetailPrice,
                    StatusId    = x.Item.StatusId,
                    Used        = x.Item.Used,
                },
                KpiItem = x.KpiItem == null ? null : new KpiItem
                {
                    Id             = x.KpiItem.Id,
                    OrganizationId = x.KpiItem.OrganizationId,
                    KpiYearId      = x.KpiItem.KpiYearId,
                    KpiPeriodId    = x.KpiItem.KpiPeriodId,
                    StatusId       = x.KpiItem.StatusId,
                    EmployeeId     = x.KpiItem.EmployeeId,
                    CreatorId      = x.KpiItem.CreatorId,
                },
            }).FirstOrDefaultAsync();

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

            return(KpiItemContent);
        }
 private async Task SaveReference(KpiItemContent KpiItemContent)
 {
 }
        public async Task <bool> Delete(KpiItemContent KpiItemContent)
        {
            await DataContext.KpiItemContent.Where(x => x.Id == KpiItemContent.Id).DeleteFromQueryAsync();

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