Example #1
0
        public async Task <IActionResult> ApprovedTask(int idTask, TaskApproveAdmin typeTask)
        {
            await _globalConfigurationService.SetValueConfig(Constants.Configuration.IsAdminApproving, "true");

            BackgroundJob.Schedule(() => this.DoApprovedTask(idTask, typeTask), TimeSpan.FromSeconds(1));
            //TempData["Message"] = Model.Resources.ValidationMessages.ApproveInprogress;
            return(Json(new { success = true }));
        }
Example #2
0
        public IActionResult RejectedTask(int idTask, TaskApproveAdmin typeTask)
        {
            var model = new TaskApproveModel();

            model            = _taskService.GetTaskById(idTask, typeTask).Result;
            model.TaskStatus = TaskStatusAdmin.Rejected;
            model.TaskType   = typeTask;
            return(View(model));
        }
Example #3
0
        public async Task <TaskApproveModel> GetTaskById(int idTask, TaskApproveAdmin typeTask)
        {
            var tasksModel = new TaskApproveModel();

            if (typeTask == TaskApproveAdmin.Nav)
            {
                var taskFunds = await _fund.GetFundByStatus(EditStatus.Updating);

                var infoFund = taskFunds.Find(x => x.LastUpdatedBy != null);

                if (taskFunds != null && taskFunds.Count > 0)
                {
                    var taskFund = taskFunds.FirstOrDefault(m => m.Id == idTask);
                    if (taskFund != null)
                    {
                        tasksModel.IdTask          = taskFund.Id;
                        tasksModel.NameTask        = taskFund.Title;
                        tasksModel.TaskType        = typeTask;
                        tasksModel.DateLastUpdated = infoFund != null ? infoFund.DateLastUpdated : DateTime.MinValue;
                        tasksModel.LastUpdatedBy   = infoFund?.LastUpdatedBy;
                    }
                }
            }
            else if (typeTask == TaskApproveAdmin.Portfolio)
            {
                var taskPortfolios = await _portfolio.GetPortfolioByStatus(EditStatus.Updating);

                if (taskPortfolios != null && taskPortfolios.Count > 0)
                {
                    var taskPortfolio = taskPortfolios.FirstOrDefault(m => m.Id == idTask);
                    if (taskPortfolio != null)
                    {
                        var portfolioFund = _portfolio.GetPortfolioFundByPortfolioId(taskPortfolio.Id, EditStatus.Updating).Result;
                        var infoPortfolio = portfolioFund.Find(x => x.LastUpdatedBy != null);

                        if (portfolioFund.Count > 0)
                        {
                            tasksModel.IdTask          = taskPortfolio.Id;
                            tasksModel.NameTask        = taskPortfolio.Title;
                            tasksModel.TaskType        = TaskApproveAdmin.Portfolio;
                            tasksModel.DateLastUpdated = infoPortfolio != null ? infoPortfolio.DateLastUpdated : DateTime.MinValue;
                            tasksModel.LastUpdatedBy   = infoPortfolio?.LastUpdatedBy;
                        }
                    }
                }
            }

            return(tasksModel);
        }
Example #4
0
 public async Task DoApprovedTask(int idTask, TaskApproveAdmin typeTask)
 {
     try
     {
         if (typeTask == TaskApproveAdmin.Portfolio)
         {
             await _fundTransactionHistoryService.ApproveFundPercent(idTask);
         }
         else if (typeTask == TaskApproveAdmin.Nav)
         {
             await _fundService.UpdateApprovedFunds();
         }
     }
     finally
     {
         await _globalConfigurationService.SetValueConfig(Constants.Configuration.IsAdminApproving, "false");
     }
 }