コード例 #1
0
        public async Task <bool> UpdateAsync(WorkIssue issue)
        {
            issue.Update();
            ProcessIssueCommands(issue);

            _unitOfWorkAsync.Repository <WorkIssue>().Update(issue);
            int _result = _unitOfWorkAsync.SaveChangesAsync().Result;

            if (_result >= 0)
            {
                Notify(issue);
                if (issue.Status == IssueStatus.Done)
                {
                    WorkIssue _newIssue = new WorkIssue();
                    if (issue.Repeat == ScheduleType.Daily)
                    {
                        _newIssue = issue.MoveTo(issue.Start.Value.AddDays(1));
                    }
                    else if (issue.Repeat == ScheduleType.Weekly)
                    {
                        _newIssue = issue.MoveTo(issue.Start.Value.AddDays(5));
                    }
                    else if (issue.Repeat == ScheduleType.Monthly)
                    {
                        _newIssue = issue.MoveTo(issue.Start.Value.AddMonths(1));
                    }
                    else if (issue.Repeat == ScheduleType.Yearly)
                    {
                        _newIssue = issue.MoveTo(issue.Start.Value.AddYears(1));
                    }
                    _newIssue.Status = IssueStatus.New;
                    _newIssue.Update();
                    _unitOfWorkAsync.Repository <WorkIssue>().Insert(_newIssue);
                    Notify(_newIssue);
                    await _unitOfWorkAsync.SaveChangesAsync();
                }
                return(true);
            }
            else
            {
                return(false);
            }
        }
コード例 #2
0
        public async Task <ActionResult> Create(WorkIssue workIssue)
        {
            if (ModelState.IsValid)
            {
                if (!workIssue.IsValid())
                {
                    if (Request.IsAjaxRequest())
                    {
                        return(PartialView("_NotifyMessage", "Issue is not valid"));
                    }
                    else
                    {
                        return(View("_NotifyMessage", "Issue is not valid"));
                    }
                }
                workIssue.Id        = Guid.NewGuid();
                workIssue.CreatedBy = User.Identity.Name;
                workIssue.PrepareToCreate();
                workIssue.Update();

                if (workIssue.Tags.Count > 0)
                {
                    var projects        = ProjectManager.GetAllOf(User.Identity.Name).ToList();
                    var _tag            = workIssue.Tags[0].ToLower();
                    var _selectProjects = projects
                                          .Where(t => t.Title.ToLower().Contains(_tag))
                                          .ToList();

                    if (_selectProjects != null && _selectProjects.Any())
                    {
                        workIssue.ProjectId = _selectProjects.FirstOrDefault().Id;
                    }
                    else
                    {
                        var _project = ProjectManager.GetByName(_tag);
                        if (_project != null)
                        {
                            workIssue.ProjectId = _project.Id;
                        }
                    }
                }

                IssueManager.Insert(workIssue);

                if (workIssue.ProjectId.HasValue)
                {
                    var _project = ProjectManager.GetById(workIssue.ProjectId.Value);
                    if (!_project.IsOf(User.Identity.Name))
                    {
                        Contact contact = new Contact();
                        contact.CreatedBy = User.Identity.Name;
                        contact.Email     = User.Identity.Name;
                        contact.UserName  = User.Identity.Name;
                        contact.Projects.Add(_project);
                        workIssue.Contacts.Add(contact);
                        await ProjectManager.AddContactAsync(_project.Id, contact);
                    }
                }

                //if(workIssue.HasInnerMembers())
                //{
                //    var _innerMembers = workIssue.GetInnerMembers();
                //    foreach(string _member in _innerMembers)
                //    {
                //        Contact _contact = new Contact();
                //        _contact.Email = _member;
                //        _contact.UserName = _member;
                //        _contact.CreatedBy = User.Identity.Name;
                //        await ContactManager.AddContactAsync(_contact, User.Identity.Name);
                //    }
                //}

                if (Request.IsAjaxRequest())
                {
                    var _viewObject = Mapper.Map <WorkIssue, IssueView>(workIssue);
                    return(PartialView("Issues/_IssueItem", _viewObject));
                }
                return(RedirectToAction("Details", "WorkIssues", new { id = workIssue.Id }));
            }

            return(View(workIssue));
        }