Example #1
0
        public async Task <User> GetIncludeAsync(string id, CancellationToken token = default)
        {
            using (var db = new GuoGuoCommunityContext())
            {
                var user = await db.Users.Include(x => x.Shop).Where(x => x.Id.ToString() == id && x.IsDeleted == false).FirstOrDefaultAsync(token);

                if (user == null)
                {
                    throw new NotImplementedException("该用户不存在!");
                }

                return(user);
            }
        }
Example #2
0
        public async Task <List <Shop> > GetAllAsync(ShopDto dto, CancellationToken token = default)
        {
            using (var db = new GuoGuoCommunityContext())
            {
                var list = await db.Shops.Where(x => x.IsDeleted == false).ToListAsync(token);

                if (!string.IsNullOrWhiteSpace(dto.Name))
                {
                    list = list.Where(x => x.Name.Contains(dto.Name)).ToList();
                }

                return(list);
            }
        }
        public async Task <StationLetterBrowseRecord> AddAsync(StationLetterBrowseRecordDto dto, CancellationToken token = default)
        {
            using (var db = new GuoGuoCommunityContext())
            {
                var entity = db.StationLetterBrowseRecords.Add(new StationLetterBrowseRecord
                {
                    StationLetterId       = dto.StationLetterId,
                    CreateOperationTime   = dto.OperationTime,
                    CreateOperationUserId = dto.OperationUserId,
                });
                await db.SaveChangesAsync(token);

                return(entity);
            }
        }
        public async Task <List <Announcement> > GetListForStreetOfficeAsync(AnnouncementDto dto, CancellationToken token = default)
        {
            using (var db = new GuoGuoCommunityContext())
            {
                var list = await db.Announcements.Where(x => x.IsDeleted == false && x.DepartmentValue == dto.DepartmentValue).ToListAsync(token);

                if (!string.IsNullOrWhiteSpace(dto.Title))
                {
                    list = list.Where(x => x.Title.Contains(dto.Title)).ToList();
                }
                list = list.Where(x => x.CreateOperationTime >= dto.StartTime && x.CreateOperationTime <= dto.EndTime).ToList();

                return(list.Where(x => x.StreetOfficeId == dto.StreetOfficeId).ToList());
            }
        }
        public async Task <SmallDistrictShopForPageDto> GetAllIncludeForShopUserAsync(SmallDistrictShopDto dto, CancellationToken token = default)
        {
            using (var db = new GuoGuoCommunityContext())
            {
                var list = db.SmallDistrictShops.Include(x => x.Shop).Where(item => item.IsDeleted == false && item.SmallDistrictId.ToString() == dto.SmallDistrictId && item.Shop.IsDeleted == false);

                list = list.OrderBy(item => item.Sort);
                List <SmallDistrictShop> resultList = await list.Skip((dto.PageIndex - 1) *dto.PageSize).Take(dto.PageSize).ToListAsync(token);

                SmallDistrictShopForPageDto pagelist = new SmallDistrictShopForPageDto {
                    List = resultList, Count = list.Count()
                };
                return(pagelist);
            }
        }
Example #6
0
        public async Task <VoteAnnex> AddAsync(VoteAnnexDto dto, CancellationToken token = default)
        {
            using (var db = new GuoGuoCommunityContext())
            {
                var entity = db.VoteAnnices.Add(new VoteAnnex
                {
                    VoteId                = dto.VoteId,
                    AnnexContent          = dto.AnnexContent,
                    CreateOperationTime   = dto.OperationTime,
                    CreateOperationUserId = dto.OperationUserId,
                });
                await db.SaveChangesAsync(token);

                return(entity);
            }
        }
Example #7
0
        public async Task DeleteAsync(RoleMenuDto dto, CancellationToken token = default)
        {
            using (var db = new GuoGuoCommunityContext())
            {
                var roleMenu = await db.Role_Menus.Where(x => x.MenuId == dto.MenuId && x.RolesId == dto.RoleId && x.IsDeleted == false).FirstOrDefaultAsync(token);

                if (roleMenu == null)
                {
                    throw new NotImplementedException("该菜单权限信息不存在!");
                }
                roleMenu.LastOperationTime   = dto.OperationTime;
                roleMenu.LastOperationUserId = dto.OperationUserId;
                roleMenu.DeletedTime         = dto.OperationTime;
                roleMenu.IsDeleted           = true;
                await db.SaveChangesAsync(token);
            }
        }
        public async Task <VoteAssociationVipOwner> AddAsync(VoteAssociationVipOwnerDto dto, CancellationToken token = default)
        {
            using (var db = new GuoGuoCommunityContext())
            {
                var entity = db.VoteAssociationVipOwners.Add(new VoteAssociationVipOwner
                {
                    VipOwnerId            = dto.VipOwnerId,
                    VoteId                = dto.VoteId,
                    CreateOperationTime   = dto.OperationTime,
                    CreateOperationUserId = dto.OperationUserId,
                    ElectionNumber        = dto.ElectionNumber
                });
                await db.SaveChangesAsync(token);

                return(entity);
            }
        }
Example #9
0
        public async Task <List <VipOwnerCertificationCondition> > GetAllAsync(VipOwnerCertificationConditionDto dto, CancellationToken token = default)
        {
            using (var db = new GuoGuoCommunityContext())
            {
                var list = await db.VipOwnerCertificationConditions.Where(x => x.IsDeleted == false).ToListAsync(token);

                if (!string.IsNullOrWhiteSpace(dto.TypeValue))
                {
                    list = list.Where(x => x.TypeValue == dto.TypeValue).ToList();
                }
                if (!string.IsNullOrWhiteSpace(dto.Title))
                {
                    list = list.Where(x => x.Title.Contains(dto.Title)).ToList();
                }
                return(list);
            }
        }
Example #10
0
        public async Task <User> GetIncludeAsync(UserDto dto, CancellationToken token = default)
        {
            using (var db = new GuoGuoCommunityContext())
            {
                var user = await db.Users.Include(x => x.Shop).Where(x => (x.Account == dto.Name || x.PhoneNumber == dto.Name) && x.IsDeleted == false).FirstOrDefaultAsync(token);

                if (user == null)
                {
                    throw new NotImplementedException("该用户不存在!");
                }
                if (user.Password != dto.Password)
                {
                    throw new NotImplementedException("密码不正确!");
                }
                return(user);
            }
        }
Example #11
0
        private async Task <bool> OnDelete(GuoGuoCommunityContext db, SmallDistrictDto dto, CancellationToken token = default)
        {
            //楼宇
            if (await db.Buildings.Where(x => x.SmallDistrictId.ToString() == dto.Id && x.IsDeleted == false).FirstOrDefaultAsync(token) != null)
            {
                return(true);
            }

            //业委会
            if (await db.VipOwners.Where(x => x.IsDeleted == false && x.SmallDistrictId.ToString() == dto.Id).FirstOrDefaultAsync(token) != null)
            {
                return(true);
            }

            //公告
            if (await db.Announcements.Where(x => x.IsDeleted == false && x.SmallDistrictId == dto.Id).FirstOrDefaultAsync(token) != null)
            {
                return(true);
            }

            //投票
            if (await db.Votes.Where(x => x.IsDeleted == false && x.SmallDistrictId == dto.Id).FirstOrDefaultAsync(token) != null)
            {
                return(true);
            }

            //业委会成员申请
            if (await db.VipOwnerApplicationRecords.Where(x => x.IsDeleted == false && x.SmallDistrictId == dto.Id).FirstOrDefaultAsync(token) != null)
            {
                return(true);
            }

            //用户
            if (await db.Users.Where(x => x.SmallDistrictId == dto.Id.ToString() && x.IsDeleted == false).FirstOrDefaultAsync(token) != null)
            {
                return(true);
            }

            //小区物业商户
            if (await db.SmallDistrictShops.Where(x => x.SmallDistrictId.ToString() == dto.Id.ToString() && x.IsDeleted == false).FirstOrDefaultAsync(token) != null)
            {
                return(true);
            }

            return(false);
        }
Example #12
0
        public async Task <List <Building> > GetAllAsync(BuildingDto dto, CancellationToken token = default)
        {
            using (var db = new GuoGuoCommunityContext())
            {
                var list = await db.Buildings.Where(x => x.IsDeleted == false).ToListAsync(token);

                if (!string.IsNullOrWhiteSpace(dto.SmallDistrictId))
                {
                    list = list.Where(x => x.SmallDistrictId.ToString() == dto.SmallDistrictId).ToList();
                }
                if (!string.IsNullOrWhiteSpace(dto.Name))
                {
                    list = list.Where(x => x.Name.Contains(dto.Name)).ToList();
                }
                return(list);
            }
        }
Example #13
0
        public async Task <List <Complaint> > GetAllForVipOwnerAsync(ComplaintDto dto, CancellationToken token = default)
        {
            using (var db = new GuoGuoCommunityContext())
            {
                if (!Guid.TryParse(dto.OwnerCertificationId, out var ownerCertificationId))
                {
                    throw new NotImplementedException("业主认证Id不正确!");
                }
                var ownerCertificationRecord = await db.OwnerCertificationRecords.Include(x => x.Industry.BuildingUnit.Building.SmallDistrict.Community.StreetOffice).Where(x => x.Id == ownerCertificationId && x.IsDeleted == false).FirstOrDefaultAsync(token);

                if (ownerCertificationRecord == null)
                {
                    throw new NotImplementedException("业主认证信息不存在!");
                }
                return(await db.Complaints.Include(x => x.OwnerCertificationRecord.Industry.BuildingUnit.Building.SmallDistrict.Community.StreetOffice).Where(x => x.IsDeleted == false && x.DepartmentValue == Department.YeZhuWeiYuanHui.Value && x.OwnerCertificationRecord.Industry.BuildingUnit.Building.SmallDistrictId.ToString() == ownerCertificationRecord.Industry.BuildingUnit.Building.SmallDistrictId.ToString()).ToListAsync(token));
            }
        }
        public async Task <ShoppingTrolley> AddAsync(ShoppingTrolleyDto dto, CancellationToken token = default)
        {
            using (var db = new GuoGuoCommunityContext())
            {
                //if (!Guid.TryParse(dto.OwnerCertificationRecordId, out var ocrId))
                //{
                //    throw new NotImplementedException("业主ID无效!");
                //}
                if (!Guid.TryParse(dto.ShopCommodityId, out var scId))
                {
                    throw new NotImplementedException("店铺商品ID无效!");
                }
                var user = await db.Users.Where(x => x.Id.ToString() == dto.OperationUserId && x.IsDeleted == false).FirstOrDefaultAsync(token);

                if (user == null)
                {
                    throw new NotImplementedException("创建人信息不存在!");
                }

                //ShoppingTrolley model = new ShoppingTrolley();
                ShoppingTrolley model = await db.ShoppingTrolleys.Where(item => item.ShopCommodityId == scId && item.CreateOperationUserId == user.Id).FirstOrDefaultAsync(token);

                if (model != null)
                {
                    model.CommodityCount += dto.CommodityCount;
                }
                else
                {
                    model = db.ShoppingTrolleys.Add(new ShoppingTrolley
                    {
                        //OwnerCertificationRecordId = ocrId,
                        ShopCommodityId       = scId,
                        CommodityCount        = dto.CommodityCount,
                        CreateOperationTime   = dto.OperationTime,
                        CreateOperationUserId = user.Id,
                        LastOperationTime     = dto.OperationTime,
                        LastOperationUserId   = dto.OperationUserId
                    });
                }
                await db.SaveChangesAsync(token);

                return(model);
            }
            throw new NotImplementedException();
        }
        public async Task UpdateAsync(ShopUserAddressDto dto, CancellationToken token = default)
        {
            using (var db = new GuoGuoCommunityContext())
            {
                if (!Guid.TryParse(dto.Id, out var ID))
                {
                    throw new NotImplementedException("地址ID无效!");
                }
                var shopUserAddress = await db.ShopUserAddresses.Where(item => item.Id == ID).FirstOrDefaultAsync(token);

                if (shopUserAddress == null)
                {
                    throw new NotImplementedException("地址不存在!");
                }

                if (!Guid.TryParse(dto.IndustryId, out var industryId))
                {
                    throw new NotImplementedException("业户Id信息不正确!");
                }
                var industry = await db.Industries.Where(x => x.Id == industryId && x.IsDeleted == false).FirstOrDefaultAsync(token);

                if (industry == null)
                {
                    throw new NotImplementedException("业户信息不存在!");
                }

                if (dto.IsDefault)
                {
                    await db.ShopUserAddresses.Where(x => x.CreateOperationUserId == shopUserAddress.CreateOperationUserId && x.IsDefault && x.Id != shopUserAddress.Id).UpdateAsync(x => new ShopUserAddress {
                        IsDefault = false
                    });
                }

                shopUserAddress.IsDefault           = dto.IsDefault;
                shopUserAddress.IndustryId          = industry.Id;
                shopUserAddress.ReceiverPhone       = dto.ReceiverPhone;
                shopUserAddress.ReceiverName        = dto.ReceiverName;
                shopUserAddress.LastOperationTime   = dto.OperationTime;
                shopUserAddress.LastOperationUserId = dto.OperationUserId;
                if (await db.SaveChangesAsync(token) <= 0)
                {
                    throw new NotImplementedException("数据执行失败。");
                }
            }
        }
Example #16
0
        public async Task <List <Vote> > GetAllForPropertyAsync(VoteDto dto, CancellationToken token = default)
        {
            using (var db = new GuoGuoCommunityContext())
            {
                var list = await db.Votes.Where(x => x.IsDeleted == false && x.DepartmentValue == Department.WuYe.Value && x.StreetOfficeId == dto.StreetOfficeId && x.CommunityId == dto.CommunityId && x.SmallDistrictId == dto.SmallDistrictId).ToListAsync(token);

                if (!string.IsNullOrWhiteSpace(dto.Title))
                {
                    list = list.Where(x => x.Title.Contains(dto.Title)).ToList();
                }
                if (!string.IsNullOrWhiteSpace(dto.StatusValue))
                {
                    list = list.Where(x => x.StatusValue == dto.StatusValue).ToList();
                }
                list = list.Where(x => x.CreateOperationTime >= dto.StartTime && x.CreateOperationTime <= dto.EndTime).ToList();
                return(list);
            }
        }
Example #17
0
        public async Task <ComplaintStatusChangeRecording> AddAsync(ComplaintStatusChangeRecordingDto dto, CancellationToken token = default)
        {
            using (var db = new GuoGuoCommunityContext())
            {
                var entity = db.StatusChangeRecordings.Add(new ComplaintStatusChangeRecording
                {
                    ComplaintFollowUpId = Guid.Parse(dto.ComplaintFollowUpId),
                    //ComplaintId = dto.ComplaintId,
                    NewStatus             = dto.NewStatus,
                    OldStatus             = dto.OldStatus,
                    CreateOperationTime   = dto.OperationTime,
                    CreateOperationUserId = dto.OperationUserId,
                });
                await db.SaveChangesAsync(token);

                return(entity);
            }
        }
Example #18
0
        public async Task <List <Complaint> > GetAllForStreetOfficeIncludeAsync(ComplaintDto dto, CancellationToken token = default)
        {
            using (var db = new GuoGuoCommunityContext())
            {
                var list = await db.Complaints.Include(x => x.ComplaintType).Include(x => x.OwnerCertificationRecord.Industry.BuildingUnit.Building.SmallDistrict.Community.StreetOffice).Where(x => x.IsDeleted == false && x.DepartmentValue == Department.JieDaoBan.Value && x.OwnerCertificationRecord.Industry.BuildingUnit.Building.SmallDistrict.Community.StreetOfficeId.ToString() == dto.StreetOfficeId).ToListAsync(token);

                list = list.Where(x => x.CreateOperationTime >= dto.StartTime && x.CreateOperationTime <= dto.EndTime).ToList();
                if (!string.IsNullOrWhiteSpace(dto.StatusValue))
                {
                    list = list.Where(x => x.StatusValue == dto.StatusValue).ToList();
                }
                if (!string.IsNullOrWhiteSpace(dto.Description))
                {
                    list = list.Where(x => x.Description.Contains(dto.Description)).ToList();
                }
                return(list);
            }
        }
Example #19
0
 public async Task <OwnerCertificationRecord> GetAsync(string id, CancellationToken token = default)
 {
     try
     {
         using (var db = new GuoGuoCommunityContext())
         {
             if (Guid.TryParse(id, out var uid))
             {
                 return(await db.OwnerCertificationRecords.Where(x => x.Id == uid).FirstOrDefaultAsync(token));
             }
             throw new NotImplementedException("该认证Id信息不正确!");
         }
     }
     catch (Exception)
     {
         return(new OwnerCertificationRecord());
     }
 }
Example #20
0
 public async Task <User> GetForIdAsync(string id, CancellationToken token = default)
 {
     try
     {
         using (var db = new GuoGuoCommunityContext())
         {
             if (Guid.TryParse(id, out var uid))
             {
                 return(await db.Users.Where(x => x.Id == uid).FirstOrDefaultAsync(token));
             }
             throw new NotImplementedException("该用户Id信息不正确!");
         }
     }
     catch (Exception)
     {
         return(new User());
     }
 }
        public async Task <IDCardPhotoRecord> AddAsync(IDCardPhotoRecordDto dto, CancellationToken token = default)
        {
            using (var db = new GuoGuoCommunityContext())
            {
                var entity = db.IDCardPhotoRecords.Add(new IDCardPhotoRecord
                {
                    ApplicationRecordId       = dto.ApplicationRecordId,
                    Message                   = dto.Message,
                    OwnerCertificationAnnexId = dto.OwnerCertificationAnnexId,
                    PhotoBase64               = dto.PhotoBase64,
                    CreateOperationTime       = dto.OperationTime,
                    CreateOperationUserId     = dto.OperationUserId
                });
                await db.SaveChangesAsync(token);

                return(entity);
            }
        }
        public async Task <SmallDistrictShop> AddAsync(SmallDistrictShopDto dto, CancellationToken token = default)
        {
            using (var db = new GuoGuoCommunityContext())
            {
                if (!Guid.TryParse(dto.ShopId, out var shopId))
                {
                    throw new NotImplementedException("商店id信息不正确!");
                }
                var shop = await db.Shops.Where(x => x.Id == shopId && x.IsDeleted == false).FirstOrDefaultAsync(token);

                if (shop == null)
                {
                    throw new NotImplementedException("该商家不存在!");
                }

                if (!Guid.TryParse(dto.SmallDistrictId, out var smallDistrictId))
                {
                    throw new NotImplementedException("小区id信息不正确!");
                }
                var smallDistrict = await db.SmallDistricts.Where(x => x.Id == smallDistrictId && x.IsDeleted == false).FirstOrDefaultAsync(token);

                if (smallDistrict == null)
                {
                    throw new NotImplementedException("该小区不存在!");
                }
                if (((await db.SmallDistrictShops.Where(x => x.SmallDistrictId.ToString() == dto.SmallDistrictId && x.ShopId.ToString() == dto.ShopId && x.IsDeleted == false).ToListAsync(token)).Any()))
                {
                    throw new NotImplementedException("该商户信息已存在!");
                }
                var entity = db.SmallDistrictShops.Add(new SmallDistrictShop
                {
                    ShopId                = shop.Id,
                    SmallDistrictId       = smallDistrict.Id,
                    Sort                  = dto.Sort,
                    Postage               = dto.Postage,
                    CreateOperationTime   = dto.OperationTime,
                    CreateOperationUserId = dto.OperationUserId
                });
                await db.SaveChangesAsync(token);

                return(entity);
            }
        }
Example #23
0
        public async Task <GoodsTypeForPageDto> GetAllIncludeForPageAsync(GoodsTypeDto dto, CancellationToken token = default)
        {
            using (var db = new GuoGuoCommunityContext())
            {
                var list = db.GoodsTypes.Where(item => item.IsDeleted == false && item.ShopId.ToString() == dto.ShopId);
                if (!string.IsNullOrEmpty(dto.Name))
                {
                    list = list.Where(item => item.Name.Contains(dto.Name));
                }

                list = list.OrderByDescending(item => item.CreateOperationTime);
                List <GoodsType> resultList = await list.Skip((dto.PageIndex - 1) *dto.PageSize).Take(dto.PageSize).ToListAsync(token);

                GoodsTypeForPageDto pagelist = new GoodsTypeForPageDto {
                    List = resultList, Count = list.Count()
                };
                return(pagelist);
            }
        }
Example #24
0
        public async Task UpdateForUnionIdAsync(WeiXinUserDto dto, CancellationToken token = default)
        {
            using (var db = new GuoGuoCommunityContext())
            {
                if (string.IsNullOrWhiteSpace(dto.Unionid))
                {
                    throw new NotImplementedException("微信用户UnionId不正确!");
                }
                var weiXinUser = await db.WeiXinUsers.Where(x => x.Unionid == dto.Unionid).FirstOrDefaultAsync(token);

                if (weiXinUser == null)
                {
                    throw new NotImplementedException("该微信用户不存在!");
                }

                weiXinUser.Subscribe = dto.Subscribe;
                await db.SaveChangesAsync(token);
            }
        }
Example #25
0
        public async Task UpdateTokenAsync(UserDto dto, CancellationToken token = default)
        {
            using (var db = new GuoGuoCommunityContext())
            {
                if (!Guid.TryParse(dto.Id, out Guid uid))
                {
                    throw new NotImplementedException("用户Id信息不正确!");
                }
                var user = await db.Users.Where(x => x.Id == uid).FirstOrDefaultAsync(token);

                if (user == null)
                {
                    throw new NotImplementedException("该用户不存在!");
                }
                user.RefreshToken = dto.RefreshToken;

                await db.SaveChangesAsync(token);
            }
        }
Example #26
0
        public async Task <VoteQuestion> AddAsync(VoteQuestionDto dto, CancellationToken token = default)
        {
            using (var db = new GuoGuoCommunityContext())
            {
                var entity = db.VoteQuestions.Add(new VoteQuestion
                {
                    OptionMode            = dto.OptionMode,
                    VoteId                = dto.VoteId,
                    Title                 = dto.Title,
                    CreateOperationTime   = dto.OperationTime,
                    CreateOperationUserId = dto.OperationUserId,
                    LastOperationTime     = dto.OperationTime,
                    LastOperationUserId   = dto.OperationUserId
                });
                await db.SaveChangesAsync(token);

                return(entity);
            }
        }
Example #27
0
        public async Task UpdateForClosedAsync(VoteDto dto, CancellationToken token = default)
        {
            using (var db = new GuoGuoCommunityContext())
            {
                if (!Guid.TryParse(dto.Id, out var uid))
                {
                    throw new NotImplementedException("投票信息不正确!");
                }
                var vote = await db.Votes.Where(x => x.Id == uid).FirstOrDefaultAsync(token);

                if (vote == null)
                {
                    throw new NotImplementedException("该投票不存在!");
                }
                vote.StatusValue = VoteStatus.Closed.Value;
                vote.StatusName  = VoteStatus.Closed.Name;
                await db.SaveChangesAsync(token);
            }
        }
        public async Task UpdateAsync(ShopCommodityDto dto, CancellationToken token = default)
        {
            using (var db = new GuoGuoCommunityContext())
            {
                if (!Guid.TryParse(dto.TypeId, out var typeId))
                {
                    throw new NotImplementedException("商品分类ID无效!");
                }
                var goodsType = await db.GoodsTypes.Where(item => item.Id == typeId).FirstOrDefaultAsync(token);

                if (goodsType == null)
                {
                    throw new NotImplementedException("商品分类不存在!");
                }

                if (!Guid.TryParse(dto.Id, out var Id))
                {
                    throw new NotImplementedException("商品ID无效!");
                }
                var shopCommodity = await db.ShopCommodities.Where(item => item.Id == Id).FirstOrDefaultAsync(token);

                if (shopCommodity == null)
                {
                    throw new NotImplementedException("商品不存在!");
                }

                shopCommodity.TypeId              = goodsType.Id;
                shopCommodity.ImageUrl            = dto.ImageUrl;
                shopCommodity.Price               = dto.Price;
                shopCommodity.CommodityStocks     = dto.CommodityStocks;
                shopCommodity.Description         = dto.Description;
                shopCommodity.DiscountPrice       = dto.DiscountPrice;
                shopCommodity.Name                = dto.Name;
                shopCommodity.Sort                = dto.Sort;
                shopCommodity.LastOperationTime   = dto.OperationTime;
                shopCommodity.LastOperationUserId = dto.OperationUserId;
                if (await db.SaveChangesAsync(token) <= 0)
                {
                    throw new NotImplementedException("数据执行失败。");
                }
            }
        }
Example #29
0
        public async Task UpdateAsync(ActivityDto dto, CancellationToken token = default)
        {
            using (var db = new GuoGuoCommunityContext())
            {
                if (!Guid.TryParse(dto.ID, out var ID))
                {
                    throw new NotImplementedException("活动ID无效!");
                }
                var activity = await db.Activities.Where(item => item.ID == ID).FirstOrDefaultAsync(token);

                if (activity == null)
                {
                    throw new NotImplementedException("活动信息不存在,或已经被删除!");
                }

                var model = db.Activities.Where(x => x.Money == dto.Money && x.IsDeleted == false && x.ID != ID);
                if (dto.ActivitySource == 1)
                {
                    model = model.Where(x => x.ShopId.ToString() == dto.ShopId && x.ActivitySource == 1);
                }
                else
                {
                    model = model.Where(x => x.ActivitySource == 2);
                }
                Activity activityresult = await model.FirstOrDefaultAsync(token);

                if (activityresult != null && !string.IsNullOrEmpty(activityresult.ID.ToString()))
                {
                    throw new NotImplementedException("已经有此档活动存在,请勿重复设置!");
                }
                activity.Money               = dto.Money;
                activity.Off                 = dto.Off;
                activity.ActivityBeginTime   = dto.ActivityBeginTime;
                activity.ActivityEndTime     = dto.ActivityEndTime;
                activity.LastOperationTime   = dto.OperationTime;
                activity.LastOperationUserId = dto.OperationUserId;
                if (await db.SaveChangesAsync(token) <= 0)
                {
                    throw new NotImplementedException("数据执行失败。");
                }
            }
        }
Example #30
0
        public async Task <List <VipOwnerApplicationRecord> > GetAllAsync(VipOwnerApplicationRecordDto dto, CancellationToken token = default)
        {
            using (var db = new GuoGuoCommunityContext())
            {
                var list = await db.VipOwnerApplicationRecords.Where(x => x.IsDeleted == false).ToListAsync(token);

                if (string.IsNullOrWhiteSpace(dto.SmallDistrictId))
                {
                    var smallDistricts = await db.SmallDistricts.Where(x => x.Community.StreetOfficeId.ToString() == dto.OperationUserStreetOfficeId && x.IsDeleted == false).Select(x => x.Id.ToString()).ToListAsync(token);

                    list = list.Where(x => smallDistricts.Contains(x.SmallDistrictId)).ToList();
                }
                else
                {
                    list = list.Where(x => x.SmallDistrictId == dto.SmallDistrictId).ToList();
                }
                list = list.Where(x => x.CreateOperationTime >= dto.StartTime && x.CreateOperationTime <= dto.EndTime).ToList();
                return(list);
            }
        }