private async Task <DesignSummaryListModel> GetDesignSummaryListModel(PagingState pagingState)
        {
            var svcDesignSummaryList = await DesignUserService.GetDesignSummariesAsync(GetUserId(), null, null);

            var model = ModelFactory.CreateDesignSummaryListModel(svcDesignSummaryList, pagingState);

            return(model);
        }
Exemple #2
0
        private async Task <MemberSummaryModel> GetMemberSummaryModel()
        {
            var svcDesignSummaryList = await DesignUserService.GetDesignSummariesAsync(GetUserId(), 0, 5);

            var svcProjectSummaryList = await ProjectUserService.GetProjectSummariesAsync(GetUserId(), 0, 5);

            var model = ModelFactory.CreateMemberSummaryModel(svcDesignSummaryList, svcProjectSummaryList);

            return(model);
        }
        public async Task <ActionResult> RenameDesign(DesignRenameModel renameDesign)
        {
            var result = await DesignUserService.RenameDesignAsync(GetUserId(), renameDesign.DesignId, renameDesign.NewDesignName);

            if (!result)
            {
                throw new Exception("RenameDesignAsync failure.");
            }

            return(RedirectToAction("Index"));
        }
        public async Task <ActionResult> DesignSnapshot(int id, string size)
        {
            if (!int.TryParse(size, out var sizeValue))
            {
                sizeValue = Constants.ThumbnailSize;
            }

            var image = await DesignUserService.GetDesignSnapshotThumbnailAsync(GetUserId(), id, sizeValue);

            return(new FileContentResult(image, "image/jpg"));
        }
        public async Task <ActionResult> ListSubmit(DesignSummaryListModel model)
        {
            var actionData = this.GetActionData();

            switch (actionData?.ActionName)
            {
            case Actions.New:
            {
                return(RedirectToAction("Index", new { id = Guid.Empty }));
            }

            case Actions.Delete:
            {
                var designId = Guid.Parse(actionData.ActionParameter);
                var result   = await DesignUserService.DeleteDesignAsync(GetUserId(), designId);

                if (!result)
                {
                    throw new Exception("DeleteCartItemAsync failure.");
                }
            }
            break;

            case Actions.Create:
            {
                var designId = Guid.Parse(actionData.ActionParameter);
                var kitId    = await ProjectUserService.CreateProjectAsync(GetUserId(), ProjectUserService.ProjectType_Kit, "Kit", designId);

                return(RedirectToAction("Index", "Kit", new { id = kitId }));
            }

            case Actions.Undelete:
            {
                var result = await DesignUserService.UndeleteDesignAsync(GetUserId());

                if (string.IsNullOrEmpty(result))
                {
                    AddFeedbackMessage(FeedbackMessageTypes.Error, "Design could not be undeleted at this time.");
                }
                else
                {
                    AddFeedbackMessage(FeedbackMessageTypes.Informational, "Design undeleted.");
                }
            }
            break;
            }

            this.SetPagingState(model.Filter);

            model = await GetDesignSummaryListModel(this.GetPagingState(0));

            return(View("List", model));
        }
        public async Task <ActionResult> Delete([Bind(Prefix = "id")] Guid designId)
        {
            var result = await DesignUserService.DeleteDesignAsync(GetUserId(), designId);

            if (result)
            {
                AddFeedbackMessage(FeedbackMessageTypes.Informational, "Design deleted.");
            }
            else
            {
                AddFeedbackMessage(FeedbackMessageTypes.Error, "Design could not be deleted at this time.");
            }

            return(RedirectToAction("Index"));
        }