public IList <TaskCard> GetTaskByTaskId(string taskId)
        {
            try
            {
                Logger.LogInfo("Get: Assign to task process start");
                IList <TaskCard> taskcards =
                    new List <TaskCard>();

                DataTable dtAppConfig = DataBase.DBService.ExecuteCommand(string.Format(SELECT_BY_TASKID_WHICH_NOT_CLOSE_OR_DISCARD, taskId));
                foreach (DataRow dr in dtAppConfig.Rows)
                {
                    TaskCard task = convertToTaskCard(dr);
                    taskcards.Add(task);
                }
                Logger.LogInfo("Get: Assign to task process completed.");
                return(taskcards);
            }
            catch (Exception ex)
            {
                StackTrace st = new StackTrace();
                StackFrame sf = st.GetFrame(0);
                MethodBase currentMethodName = sf.GetMethod();
                LogDebug(currentMethodName.Name, ex);
                return(null);
            }
        }
 public void SaveTransaction(TaskCard taskCard, int id)
 {
     sip        = new FinancialPlanner.Common.JSONSerialization().DeserializeFromString <SIP>(taskCard.TaskTransactionType.ToString());
     sip.TaskId = id;
     DataBase.DBService.ExecuteCommandString(string.Format(INSERT_SIP,
                                                           sip.TaskId,
                                                           sip.CID,
                                                           sip.MemberName,
                                                           sip.SecondHolder,
                                                           sip.ThirdHolder,
                                                           sip.Nominee,
                                                           sip.Guardian,
                                                           sip.AMC,
                                                           sip.FolioNo,
                                                           sip.SchemeId,
                                                           sip.Option,
                                                           sip.Amount,
                                                           sip.AccounType,
                                                           sip.SIPDayOn,
                                                           sip.TransactionDate.ToString("yyyy-MM-dd hh:mm:ss"),
                                                           sip.SIPStartDate.ToString("yyyy-MM-dd hh:mm:ss"),
                                                           sip.SIPEndDate.ToString("yyyy-MM-dd hh:mm:ss"),
                                                           sip.ModeOfExecution,
                                                           sip.Remark), true);
 }
        public ObjectResult PostCard(string boardId, string listId, [FromBody] TaskCard newCard)
        {
            newCard.Id = shortUid.generate();
            var item = boards.Find((b) => b.Id == boardId)?.Find(listId).Add(newCard);

            return(new CreatedAtRouteResult(new { id = item.Id }, item));
        }
Esempio n. 4
0
        public void TakeTaskCard(int playerId, TaskCard task)
        {
            if (!this.roundState.PlayerStates.TryGetValue(playerId, out var playerPrivateState))
            {
                logger.LogWarning($"Denied request to take task card by player {playerId} in game {gameId}. Player is not in the game.");
                throw new Exception("Player state not found!");
            }


            if (this.roundState.CurrentPlayerId != playerId)
            {
                logger.LogWarning($"Denied request to take task card by player {playerId} in game {gameId}. Player is not on turn.");
                throw new Exception("Player no on turn!");
            }

            if (!this.roundState.AvailableGoals.Remove(task))
            {
                var msg = $"Task card {task} is not available in current round of game {gameId}.";
                logger.LogWarning(msg);
                throw new Exception(msg);
            }

            playerPrivateState.UnfinishedTasks.Add(task);
            MoveToNextPlayer();
            return;
        }
Esempio n. 5
0
        private TaskCard getTaskCard(int AssignTo, ClientProcess clientProcess)
        {
            TaskCard taskCard = new TaskCard();

            taskCard.TaskId              = "OT";
            taskCard.ProjectId           = 3;
            taskCard.TransactionType     = "";
            taskCard.Type                = CardType.Task;
            taskCard.CustomerId          = 0;
            taskCard.Title               = getTaskTitleByProcessId(clientProcess.PrimaryStepId, clientProcess.LinkStepId);
            taskCard.Owner               = 1;
            taskCard.CreatedBy           = 1;
            taskCard.CreatedOn           = System.DateTime.Now.Date;
            taskCard.UpdatedBy           = taskCard.CreatedBy;
            taskCard.UpdatedByUserName   = "******";
            taskCard.UpdatedOn           = System.DateTime.Now.Date;
            taskCard.AssignTo            = AssignTo;
            taskCard.Priority            = Priority.High;
            taskCard.TaskStatus          = Common.Model.TaskManagement.TaskStatus.Backlog;
            taskCard.DueDate             = getDueDate(clientProcess);
            taskCard.CompletedPercentage = 0;
            taskCard.Description         = string.Format(DESCRIPTION, primaryStepNo, taskCard.Title);
            taskCard.MachineName         = System.Environment.MachineName;
            if (clientProcess.IsProcespectClient)
            {
                ProspectClient prospectClient = new ProspectClientService().GetById(clientProcess.ClientId);
                taskCard.OtherName = prospectClient.Name;
            }
            else
            {
                taskCard.CustomerId = clientProcess.ClientId;
            }
            return(taskCard);
        }
        public IList <TaskCard> GetAllTasks()
        {
            try
            {
                Logger.LogInfo("Get: Task Card process start");
                IList <TaskCard> taskcards =
                    new List <TaskCard>();

                DataTable dtAppConfig = DataBase.DBService.ExecuteCommand(SELECT_ALL_TASKS);
                foreach (DataRow dr in dtAppConfig.Rows)
                {
                    TaskCard task = convertToTaskCard(dr);
                    taskcards.Add(task);
                }
                Logger.LogInfo("Get: Task Card process completed.");
                return(taskcards);
            }
            catch (Exception ex)
            {
                StackTrace st = new StackTrace();
                StackFrame sf = st.GetFrame(0);
                MethodBase currentMethodName = sf.GetMethod();
                LogDebug(currentMethodName.Name, ex);
                return(null);
            }
        }
    private void OnTriggerEnter(Collider other)
    {
        if (other == null)
        {
            return;
        }
        if (other.gameObject == null)
        {
            return;
        }
        TaskCard taskCard = other.gameObject.GetComponent <TaskCard>();

        if (taskCard == null)
        {
            return;
        }

        if (taskCard.taskCompleted == true && !levelComplete)
        {
            taskCard.taskCompleted = false;
            PlaceTaskCard(taskCard.gameObject);
            UpdateCompletedTasksText();
            TaskManager.GetInstance().CheckLevelCompletion();
        }
    }
        public async Task<bool> Handle(UpdateTaskCardsDetailsCommand request, CancellationToken cancellationToken)
        {
            if (request == null) throw new ArgumentNullException(nameof(request));

            var result = false;

            var taskCardIds = new List<string>();

            foreach (var cardDetail in request.TaskCardDetails)
            {
                var entity =
                    new TaskCard(
                        id: cardDetail.Id,
                        listId: cardDetail.ListId,
                        title: cardDetail.Title,
                        description: cardDetail.Description,
                        position: cardDetail.Position
                    );

                taskCardIds.Add(await updateTaskCard.UpdateAsync(entity, cancellationToken).ConfigureAwait(false));
            }

            if (taskCardIds.Count == request.TaskCardDetails.Count())
            {
                result = true;
            }

            return result;
        }
        public object GetOverDueTasks(int userId)
        {
            try
            {
                Logger.LogInfo("Get: Overdue task card process start");
                IList <TaskCard> taskcards =
                    new List <TaskCard>();

                DataTable dtAppConfig = DataBase.DBService.ExecuteCommand(string.Format(SELECT_OVERDUE_TASKS_BY_USEID, userId));
                foreach (DataRow dr in dtAppConfig.Rows)
                {
                    TaskCard task = convertToTaskCard(dr);
                    taskcards.Add(task);
                }
                Logger.LogInfo("Get: Overdue task card process completed.");
                return(taskcards);
            }
            catch (Exception ex)
            {
                StackTrace st = new StackTrace();
                StackFrame sf = st.GetFrame(0);
                MethodBase currentMethodName = sf.GetMethod();
                LogDebug(currentMethodName.Name, ex);
                return(null);
            }
        }
        public IList <TaskCard> GetOpenTaskByProjectForUser(string projectName, int userId)
        {
            try
            {
                Logger.LogInfo("Get: Task Card process start");
                IList <TaskCard> taskcards =
                    new List <TaskCard>();

                DataTable dtAppConfig = DataBase.DBService.ExecuteCommand(
                    string.Format(SELECT_TASK_BYPROJECTNAME_OPENSTATUS_ASSIGNTO, userId, projectName));
                foreach (DataRow dr in dtAppConfig.Rows)
                {
                    TaskCard task = convertToTaskCard(dr);
                    taskcards.Add(task);
                }
                Logger.LogInfo("Get: Task Card process completed.");
                return(taskcards);
            }
            catch (Exception ex)
            {
                StackTrace st = new StackTrace();
                StackFrame sf = st.GetFrame(0);
                MethodBase currentMethodName = sf.GetMethod();
                LogDebug(currentMethodName.Name, ex);
                return(null);
            }
        }
Esempio n. 11
0
 public async Task TakeGoalAsync(int gameId, TaskCard goal)
 {
     await this.webApiBrooker.PostAsync(
         ControllerName,
         goal,
         $"{gameId}/TakeGoal");
 }
        private TaskCard convertToTaskCard(DataRow dr)
        {
            TaskCard taskCard = new TaskCard();

            taskCard.Id              = dr.Field <int>("ID");
            taskCard.TaskId          = dr.Field <string>("TaskId");
            taskCard.ProjectId       = dr.Field <int>("ProjectId");
            taskCard.TransactionType = dr.Field <string>("TransactionType");
            taskCard.Type            = (CardType)dr.Field <int>("CardType");
            taskCard.CustomerId      = dr.Field <int>("Cid");
            taskCard.Title           = dr.Field <string>("Title");
            taskCard.Description     = dr.Field <string>("Description");
            taskCard.Priority        = (Priority)dr.Field <int>("Priority");
            taskCard.TaskStatus      = (Common.Model.TaskManagement.TaskStatus)dr.Field <int>("TaskStatus");
            taskCard.Owner           = dr.Field <int>("Owner");
            taskCard.AssignTo        = dr.Field <int?>("AssignTo");
            taskCard.CreatedBy       = dr.Field <int>("CreatedBy");
            taskCard.CreatedOn       = dr.Field <DateTime>("CreatedOn");
            taskCard.UpdatedOn       = dr.Field <DateTime>("UpdatedOn");
            //taskCard.ActualCompletedDate = dr.Field<DateTime>("ActualCompletedDate");
            taskCard.DueDate             = dr.Field <DateTime>("DueDate");
            taskCard.ProjectName         = dr.Field <string>("ProjectName");
            taskCard.OwnerName           = dr.Field <string>("OwnerName");
            taskCard.AssignToName        = getAssignTo(dr.Field <int?>("AssignTo"));
            taskCard.CustomerName        = getCustomerName(taskCard.CustomerId);
            taskCard.TaskTransactionType = getTransactionType(taskCard, taskCard.Id);
            taskCard.OtherName           = dr.Field <string>("OtherName");
            return(taskCard);
        }
Esempio n. 13
0
 public void SaveTransaction(TaskCard taskCard, int id)
 {
     try
     {
         sipCancellation        = new FinancialPlanner.Common.JSONSerialization().DeserializeFromString <SIPCancellation>(taskCard.TaskTransactionType.ToString());
         sipCancellation.TaskId = id;
         DataBase.DBService.ExecuteCommandString(string.Format(INSERT_SIPCANCELLATION,
                                                               sipCancellation.TaskId,
                                                               sipCancellation.Cid,
                                                               sipCancellation.MemberName,
                                                               sipCancellation.Amc,
                                                               sipCancellation.FolioNumber,
                                                               sipCancellation.SchemeId,
                                                               sipCancellation.Options,
                                                               sipCancellation.Amount,
                                                               sipCancellation.SipStartDate.ToString("yyyy-MM-dd hh:mm:ss"),
                                                               sipCancellation.SipEndDate.ToString("yyyy-MM-dd hh:mm:ss"),
                                                               sipCancellation.SipDate,
                                                               sipCancellation.BankId,
                                                               sipCancellation.AccountNo,
                                                               sipCancellation.ModeOfExecution,
                                                               sipCancellation.Remark,
                                                               sipCancellation.Arn), true);
     }
     catch (Exception ex)
     {
         StackTrace st = new StackTrace();
         StackFrame sf = st.GetFrame(0);
         MethodBase currentMethodName = sf.GetMethod();
         LogDebug(currentMethodName.Name, ex);
         throw ex;
     }
 }
Esempio n. 14
0
        public JsonResult GetCard(int taskId, int cardId)
        {
            TaskCard      card  = _taskService.GetCard(UserId, taskId, cardId);
            TaskCardModel model = _autoMapperService.MapTaskCardEntity(card);

            return(Json(model, JsonRequestBehavior.AllowGet));
        }
        public IList <TaskCard> GetNotified(int userId)
        {
            try
            {
                Logger.LogInfo("Get: Notified task process start");
                IList <TaskCard> taskcards =
                    new List <TaskCard>();

                DataTable dtAppConfig = DataBase.DBService.ExecuteCommand(string.Format(SELECT_ALL_NOTIFIED_BY_USER, userId));
                foreach (DataRow dr in dtAppConfig.Rows)
                {
                    TaskCard task = convertToTaskCard(dr);
                    taskcards.Add(task);
                }
                DataBase.DBService.ExecuteCommand(string.Format(DELETE_NOTIFIED_TASK_BY_USER, userId));
                Logger.LogInfo("Get: Notified task process completed.");
                return(taskcards);
            }
            catch (Exception ex)
            {
                StackTrace st = new StackTrace();
                StackFrame sf = st.GetFrame(0);
                MethodBase currentMethodName = sf.GetMethod();
                LogDebug(currentMethodName.Name, ex);
                return(null);
            }
        }
Esempio n. 16
0
        public void AddTaskCard(string userId, int taskId, TaskCard taskCard)
        {
            Task task = _taskRepository.LoadEager(userId, taskId);

            task.AddCard(taskCard);

            _unitOfWork.Save();
        }
Esempio n. 17
0
        public string buildCard(string boardId, string listId, int n = 1)
        {
            var inCard = new TaskCard {
                Title = $"card{n}", Content = "lorem"
            };
            var resp = controller.PostCard(boardId, listId, inCard);

            return(((TaskCard)resp.Value).Id);
        }
Esempio n. 18
0
        public int SaveCustImprove(TaskCard tc, TaskItem ti, TaskOfPlan tp, Score score)
        {
            var conn = Resolver.Resolve <ISQLite>().GetConnection();

            conn.InsertOrReplace(tc);
            conn.InsertOrReplace(ti);
            conn.InsertOrReplace(tp);
            return(conn.InsertOrReplace(score));
        }
        public void addNewCardTest()
        {
            var carddeckRepositoryMock = new CarddeckRepositoryMock();
            var addNewCard             = new AddNewCard(carddeckRepositoryMock);
            var card     = new TaskCard(1, "Test task.", "Test penalty.", "Test Card");
            var expected = new ReturnObject(true, "Test");

            var returnObject = addNewCard.addNewCard(card);

            Assert.AreEqual(expected.isSuccess(), returnObject.isSuccess());
        }
Esempio n. 20
0
 public ReturnObject addNewCard(TaskCard card)
 {
     try
     {
         carddeckRepository.addCard(card);
         return(new ReturnObject(true, "Card added."));
     }catch (Exception e)
     {
         return(new ReturnObject(false, e.Message));
     }
 }
Esempio n. 21
0
        private string addTask(ClientProcess clientProcess, int AssignTo)
        {
            TaskCard    taskCard    = getTaskCard(AssignTo, clientProcess);
            TaskService taskService = new TaskService();

            taskService.Add(taskCard);
            System.Threading.Thread.Sleep(1000);
            int taskId = getTaskID(taskCard);

            DataBase.DBService.ExecuteCommandString(string.Format(UPDATE_TASKID, taskCard.TaskId + "-" + taskId, taskId), true);
            return(taskCard.TaskId + "-" + taskId);
        }
Esempio n. 22
0
 public IActionResult DeleteTask(TaskCard task)
 {
     try
     {
         _db.Cards.Remove(task);
         _db.SaveChanges();
         return(Ok());
     }
     catch (Exception ex)
     {
         return(StatusCode(500));
     }
 }
 private static int getTaskID(TaskCard taskcard)
 {
     return(int.Parse(DataBase.DBService.ExecuteCommandScalar(string.Format(SELECT_ID_BY_TASKDETAILS,
                                                                            taskcard.ProjectId,
                                                                            taskcard.Title,
                                                                            taskcard.CustomerId,
                                                                            taskcard.CreatedOn.ToString("yyyy-MM-dd hh:mm:ss"),
                                                                            taskcard.AssignTo,
                                                                            taskcard.Owner,
                                                                            taskcard.TransactionType,
                                                                            taskcard.CreatedBy
                                                                            ))));
 }
        public TaskCard GetItemById(int id)
        {
            TaskEntity item = db.Tasks.GetItemById(id);

            if (item == null)
            {
                return(null);
            }

            TaskCard card = CollectCard(item);

            return(card);
        }
 public void UpdateTransaction(TaskCard taskCard)
 {
     addressChange = new FinancialPlanner.Common.JSONSerialization().DeserializeFromString <AddressChange>(taskCard.TaskTransactionType.ToString());
     DataBase.DBService.ExecuteCommandString(string.Format(UPDATE_CONTACT,
                                                           taskCard.Id,
                                                           addressChange.Arn,
                                                           addressChange.Cid,
                                                           addressChange.MemberName,
                                                           addressChange.Amc,
                                                           addressChange.FolioNumber,
                                                           addressChange.Address,
                                                           addressChange.ModeOfExecution,
                                                           taskCard.Id), true);
 }
 public void SaveTransaction(TaskCard taskCard, int id)
 {
     signatureChange        = new FinancialPlanner.Common.JSONSerialization().DeserializeFromString <SignatureChange>(taskCard.TaskTransactionType.ToString());
     signatureChange.TaskId = id;
     DataBase.DBService.ExecuteCommandString(string.Format(INSERT_QUERY,
                                                           signatureChange.TaskId,
                                                           signatureChange.Arn,
                                                           signatureChange.Cid,
                                                           signatureChange.MemberName,
                                                           signatureChange.Amc,
                                                           signatureChange.FolioNumber,
                                                           signatureChange.SignatureChangeOf,
                                                           signatureChange.ModeOfExecution), true);
 }
 public void UpdateTransaction(TaskCard taskCard)
 {
     minorToMajor = new FinancialPlanner.Common.JSONSerialization().DeserializeFromString <MinorToMajor>(taskCard.TaskTransactionType.ToString());
     DataBase.DBService.ExecuteCommandString(string.Format(UPDATE_QUERY,
                                                           taskCard.Id,
                                                           minorToMajor.Arn,
                                                           minorToMajor.Cid,
                                                           minorToMajor.MinorName,
                                                           minorToMajor.Guardian,
                                                           minorToMajor.Amc,
                                                           minorToMajor.FolioNumber,
                                                           minorToMajor.ModeOfExecution,
                                                           taskCard.Id), true);
 }
Esempio n. 28
0
        public async Task TakeGoalAsync(
            [FromRoute] int gameId,
            [FromBody] TaskCard goal,
            CancellationToken cancellationToken)
        {
            int userId = GetUserId();
            var game   = await gameRepository.GetGameAsync(gameId, cancellationToken);

            cancellationToken.ThrowIfCancellationRequested();

            await game.TakeGoalAsync(userId, goal, this.gameMessenger);

            await this.gameMessenger.FlushAsync();
        }
 public void UpdateTransaction(TaskCard taskCard)
 {
     changeOfName = new FinancialPlanner.Common.JSONSerialization().DeserializeFromString <ChangeOfName>(taskCard.TaskTransactionType.ToString());
     DataBase.DBService.ExecuteCommandString(string.Format(UPDATE_QUERY,
                                                           taskCard.Id,
                                                           changeOfName.Arn,
                                                           changeOfName.Cid,
                                                           changeOfName.FromMemberName,
                                                           changeOfName.ToMemberName,
                                                           changeOfName.Amc,
                                                           changeOfName.FolioNumber,
                                                           changeOfName.ModeOfExecution,
                                                           changeOfName.IsSignatureChanged), true);
 }
Esempio n. 30
0
 public void UpdateTransaction(TaskCard taskCard)
 {
     panCardUpdate = new FinancialPlanner.Common.JSONSerialization().DeserializeFromString <TransmissionAfterDeath>(taskCard.TaskTransactionType.ToString());
     DataBase.DBService.ExecuteCommandString(string.Format(UPDATE_CONTACT,
                                                           taskCard.Id,
                                                           panCardUpdate.Arn,
                                                           panCardUpdate.Cid,
                                                           panCardUpdate.MemberName,
                                                           panCardUpdate.Amc,
                                                           panCardUpdate.FolioNumber,
                                                           panCardUpdate.BeneficiaryName,
                                                           panCardUpdate.IsJoinHolder,
                                                           panCardUpdate.ModeOfExecution,
                                                           taskCard.Id), true);
 }