Esempio n. 1
0
        public ApiResult Save([FromBody] ActivityEditOutput input)
        {
            if (!this.IsFormValid())
            {
                return(ApiResult.Failure <ActivityEditOutput>(this.FormInvalidReason()));
            }

            var result = Resolve <IActivityApiService>().Save(input);

            return(ToResult(result));
        }
Esempio n. 2
0
        /// <summary>
        ///     set model value
        /// </summary>
        private ServiceResult SetModelValue(ActivityEditOutput model)
        {
            //check type
            var activity = model.Activity;
            var type     = activity.Key.GetTypeByFullName();

            if (type == null)
            {
                return(ServiceResult.Failure("key不能为空,活动类型不存在"));
            }

            var instance = Activator.CreateInstance(type);

            if (!(instance is IActivity))
            {
                return(ServiceResult.Failure("该类型不属于活动实体"));
            }

            var activityEntityInstance = instance as IActivity;

            //set value
            var ruleResult = activityEntityInstance.SetValueOfRule(model.ActivityRules);

            if (!ruleResult.Succeeded)
            {
                return(ServiceResult.Failure(ruleResult.ErrorMessages));
            }

            model.ActivityRules = ruleResult.ReturnObject == null
                ? model.ActivityRules.ToObject(type)
                : ruleResult.ReturnObject;

            //user range
            if (model.UserRange == UserRange.AllUser)
            {
                activity.LimitGradeId = Guid.Empty;
            }
            //time range
            var timeRange = model.DateTimeRange.ToSplitList("/");

            if (timeRange == null || timeRange.Count != 2)
            {
                return(ServiceResult.Failure("活动时间范围填写出错"));
            }

            activity.StartTime = timeRange[0].ConvertToDateTime();
            activity.EndTime   = timeRange[1].ConvertToDateTime();
            if (activity.StartTime.Year < 1970 || activity.EndTime.Year < 1970)
            {
                return(ServiceResult.Failure("活动时间范围填写出错"));
            }

            if (DateTime.Compare(activity.StartTime, activity.EndTime) > 0)
            {
                return(ServiceResult.Failure("活动结束时间需在活动开始时间之后"));
            }
            //support single product
            var attribute = Resolve <IActivityAdminService>().GetActivityModuleAttribute(activity.Key);

            if (attribute != null && attribute.IsSupportSigleProduct)
            {
                if (model.ProductId > 0)
                {
                    activity.ActivityExtension.ProductIds.Add(model.ProductId);
                }
            }

            activity.ProductId = model.ProductId;
            activity.Extension = activity.ActivityExtension.ToJson();
            activity.Value     = model.ActivityRules.ToJson();

            return(ServiceResult.Success);
        }
Esempio n. 3
0
        /// <summary>
        ///     Adds the or update activity.
        /// </summary>
        public ServiceResult Save(ActivityEditOutput model)
        {
            //check and set  model value.
            var result = SetModelValue(model);

            if (!result.Succeeded)
            {
                return(result);
            }

            var activity     = model.Activity;
            var allActvities = Resolve <IActivityService>().GetList(a => a.Key == activity.Key).ToList();

            if (activity.Id > 0)
            {
                //update remove selft
                allActvities.RemoveAll(a => a.Id == activity.Id);
            }

            if (allActvities.Exists(a => a.ProductId == model.ProductId))
            {
                return(ServiceResult.Failure($"产品id:{model.ProductId} ,该商品已经存在相关设置"));
            }

            //check product
            var product = Resolve <IProductService>().GetSingle(r => r.Id == model.ProductId);

            if (product == null)
            {
                return(ServiceResult.Failure("活动商品不存在"));
            }

            if (product.ProductActivityExtension == null)
            {
                product.ProductActivityExtension = new ProductActivityExtension();
            }
            //check product repeat
            if (product.ProductActivityExtension.Activitys.FirstOrDefault(r => r.Key == activity.Key) != null &&
                product.Id != model.ProductId)
            {
                return(ServiceResult.Failure("该商品已存在同类型的活动,不能重复添加"));
            }

            activity.Name = product.Name;

            //transaction
            var context = Repository <IActivityRepository>().RepositoryContext;

            try {
                context.BeginTransaction();

                //save activity
                if (activity.Id <= 0)
                {
                    activity.Status = ActivityStatus.HasNotStarted;
                    Resolve <IActivityService>().Add(activity);
                }
                else
                {
                    Resolve <IActivityService>().UpdateNoTracking(activity);
                }

                // add activity to product for group by activity.
                if (activity.Key == typeof(GroupBuyActivity).FullName)
                {
                    product.ProductActivityExtension.IsGroupBuy = true;
                }

                //modify product
                var productActivity = AutoMapping.SetValue <ProductActivity>(activity);
                //productActivity.Value = result.ReturnObject;
                var productFindActivity =
                    product.ProductActivityExtension.Activitys.FirstOrDefault(r => r.Key == model.Activity.Key);
                if (productFindActivity == null)
                {
                    product.ProductActivityExtension.Activitys.Add(productActivity);
                }
                else
                {
                    product.ProductActivityExtension.Activitys.Remove(productFindActivity);
                    product.ProductActivityExtension.Activitys.Add(productActivity);
                }

                Resolve <IProductService>().Update(r => { r.Activity = product.ProductActivityExtension.ToJson(); },
                                                   r => r.Id == product.Id);

                context.SaveChanges();
                context.CommitTransaction();
            } catch (Exception ex) {
                Console.WriteLine(ex.Message);
                context.RollbackTransaction();
                return(ServiceResult.Failure("数据保存失败"));
            } finally {
                context.DisposeTransaction();
            }

            return(result);
        }