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));
}
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;
}
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);
}
}
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);
}
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;
}
}
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);
}
}
public void AddTaskCard(string userId, int taskId, TaskCard taskCard)
{
Task task = _taskRepository.LoadEager(userId, taskId);
task.AddCard(taskCard);
_unitOfWork.Save();
}
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);
}
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());
}
public ReturnObject addNewCard(TaskCard card)
{
try
{
carddeckRepository.addCard(card);
return(new ReturnObject(true, "Card added."));
}catch (Exception e)
{
return(new ReturnObject(false, e.Message));
}
}
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);
}
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);
}
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);
}
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);
}
