public Result <IList <CurrentClientProcess> > GetClientProcess(int clientId, int?plannerId)
        {
            var result = new Result <IList <CurrentClientProcess> >();
            ClientProcessService processService = new ClientProcessService();

            result.Value     = processService.GetClientProcess(clientId, plannerId);
            result.IsSuccess = true;
            return(result);
        }
        public Result <IList <CurrentClientProcess> > GetAll()
        {
            var result = new Result <IList <CurrentClientProcess> >();
            ClientProcessService processService = new ClientProcessService();

            result.Value     = processService.GetAll();
            result.IsSuccess = true;
            return(result);
        }
        public int Update(TaskCard taskCard)
        {
            try
            {
                DataBase.DBService.ExecuteCommand(SELECT_ALL);
                DataBase.DBService.BeginTransaction();
                DataBase.DBService.ExecuteCommandString(string.Format(UPDATE_TASK,
                                                                      taskCard.TransactionType,
                                                                      (int)taskCard.Type,
                                                                      taskCard.CustomerId,
                                                                      taskCard.Title,
                                                                      taskCard.Description,
                                                                      (int)taskCard.Priority,
                                                                      (int)taskCard.TaskStatus,
                                                                      taskCard.Owner,
                                                                      taskCard.AssignTo,
                                                                      taskCard.CompletedPercentage,
                                                                      taskCard.UpdatedOn.ToString("yyyy-MM-dd hh:mm:ss"),
                                                                      taskCard.UpdatedBy,
                                                                      taskCard.DueDate.ToString("yyyy-MM-dd hh:mm:ss"),
                                                                      taskCard.DueDate.ToString("yyyy-MM-dd hh:mm:ss"), taskCard.Id,
                                                                      taskCard.OtherName), true);

                if ((taskCard.ProjectId == 1 || taskCard.ProjectId == 2) && !taskCard.TransactionType.Equals("Others"))
                {
                    updateTransactionType(taskCard, taskCard.Id);
                }
                DataBase.DBService.CommitTransaction();

                if (taskCard.TaskStatus == Common.Model.TaskManagement.TaskStatus.Complete)
                {
                    DataTable dataTable = DataBase.DBService.ExecuteCommand(string.Format(SELECT_CLIENTPROCESS_ID, taskCard.TaskId));
                    if (dataTable.Rows.Count > 0)
                    {
                        DataBase.DBService.ExecuteCommandString(string.Format(UPDATE_CLIENT_PROCESS_DETAILS, dataTable.Rows[0]["ClientProcessDetailId"].ToString()));

                        DataBase.DBService.ExecuteCommandString(string.Format(UPDATE_CLIENT_PROCESS, dataTable.Rows[0]["ClientProcessId"].ToString()));

                        //TODO: Get next process id and add process and task for that
                        DataTable dtNextProcess = DataBase.DBService.ExecuteCommand(string.Format(SELECT_NEXT_PROCESS_ID,
                                                                                                  dataTable.Rows[0]["PrimaryStepId"].ToString(), dataTable.Rows[0]["LinkSubStepId"].ToString()));
                        if (dtNextProcess.Rows.Count > 0)
                        {
                            ClientProcessService clientProcessService = new ClientProcessService();
                            ClientProcess        clientProcess        = new ClientProcess();
                            clientProcess.ClientId      = (int)taskCard.CustomerId;
                            clientProcess.PrimaryStepId = int.Parse(dtNextProcess.Rows[0]["PrimaryStepId"].ToString());   // dr.Field<int>("PrimaryStepId");
                            //clientProcess.LinkStepId = int.Parse(dtNextProcess.Rows[0]["LinkSubStepId"].ToString());
                            clientProcess.Status             = "P";
                            clientProcess.IsProcespectClient = false;
                            if (dtNextProcess.Rows[0]["LinkSubStepId"] != DBNull.Value)
                            {
                                clientProcess.LinkStepId = int.Parse(dtNextProcess.Rows[0]["LinkSubStepId"].ToString());
                            }
                            int assignTo = (int)taskCard.AssignTo;
                            //DataTable dtPrimaryStep = DataBase.DBService.ExecuteCommand(string.Format(SELECT_PRIMARY_STEP, clientProcess.PrimaryStepId));

                            //if (dtPrimaryStep.Rows.Count > 0)
                            //{
                            //    int.TryParse(dtPrimaryStep.Rows[0]["UserId"].ToString(), out assignTo);
                            //}
                            //if (dtPrimaryStep.Rows.Count > 0)
                            //{
                            //    int.TryParse(dtPrimaryStep.Rows[0]["UserId"].ToString(), out assignTo);
                            //}
                            clientProcessService.Add(clientProcess, assignTo);
                        }
                    }
                }

                //DataBase.DBService.ExecuteCommandString(string.Format(UPDATE_TASKID, taskCard.TaskId + "-" + id, id), true);
                //Activity.ActivitiesService.Add(ActivityType.CreateTask, EntryStatus.Success,
                //        Source.Server, taskCard.UpdatedByUserName, taskCard.TaskId, taskCard.MachineName);

                return(taskCard.Id);
            }
            catch (Exception ex)
            {
                DataBase.DBService.RollbackTransaction();
                StackTrace st = new StackTrace();
                StackFrame sf = st.GetFrame(0);
                MethodBase currentMethodName = sf.GetMethod();
                LogDebug(currentMethodName.Name, ex);
                throw ex;
            }
        }
Example #4
0
        public void AddProspectClient(ProspectClient prospectClient)
        {
            try
            {
                DataBase.DBService.ExecuteCommand(string.Format(INSERT_PROSPECTCLIENT_QUERY,
                                                                prospectClient.Name, prospectClient.PhoneNo, prospectClient.Email,
                                                                prospectClient.Occupation, prospectClient.Event, prospectClient.EventDate.ToString("yyyy-MM-dd hh:mm:ss"),
                                                                prospectClient.ReferedBy, prospectClient.Remarks,
                                                                prospectClient.CreatedOn.ToString("yyyy-MM-dd hh:mm:ss"), prospectClient.CreatedBy,
                                                                prospectClient.UpdatedOn.ToString("yyyy-MM-dd hh:mm:ss"), prospectClient.UpdatedBy,
                                                                prospectClient.IsConvertedToClient, prospectClient.StopSendingEmail,
                                                                prospectClient.IntroductionCompleted,
                                                                prospectClient.IntroductionCompletedDate.ToString("yyyy-MM-dd hh:mm:ss"),
                                                                prospectClient.ClientAssignTo));


                //DataTable dtPrimaryStep = DataBase.DBService.ExecuteCommand(string.Format(SELECT_PRIMARY_STEP, 1));
                DataTable dtStepNo = DataBase.DBService.ExecuteCommand(string.Format(SELECT_PRIMARY_LINKSUBSTEP_ID, 1));
                foreach (DataRow dr in dtStepNo.Rows)
                {
                    int maxClientId = int.Parse(DataBase.DBService.ExecuteCommandScalar(SELECT_MAX_ID));
                    ClientProcessService clientProcessService = new ClientProcessService();
                    ClientProcess        clientProcess        = new ClientProcess();
                    clientProcess.ClientId           = maxClientId;
                    clientProcess.PrimaryStepId      = dr.Field <int>("PrimaryStepId");
                    clientProcess.LinkStepId         = 0;
                    clientProcess.Status             = "C";
                    clientProcess.IsProcespectClient = true;
                    if (dr["LinkSubStepId"] != DBNull.Value)
                    {
                        clientProcess.LinkStepId = dr.Field <int>("LinkSubStepId");
                    }
                    DataTable dtPrimaryStep = DataBase.DBService.ExecuteCommand(string.Format(SELECT_PRIMARY_STEP, clientProcess.PrimaryStepId));
                    int       assignTo      = 0;
                    if (dtPrimaryStep.Rows.Count > 0)
                    {
                        int.TryParse(dtPrimaryStep.Rows[0]["UserId"].ToString(), out assignTo);
                    }

                    clientProcessService.Add(clientProcess, assignTo);
                }
                //DataTable dtPrimaryStep = DataBase.DBService.ExecuteCommand(string.Format(SELECT_PRIMARY_STEP, 1));
                //foreach (DataRow dr in dtPrimaryStep.Rows)
                //{
                //    int maxId = int.Parse(DataBase.DBService.ExecuteCommandScalar(SELECT_MAX_ID));

                //    //Add entry into process step
                //    DataBase.DBService.ExecuteCommand(string.Format(INSERT_CLIENT_PROCESS,
                //        maxId, 1, 0, 'C', 1));

                //    int maxProcessId = int.Parse(DataBase.DBService.ExecuteCommandScalar(SELECT_MAX_CLIENTPROCESS_ID));

                //    DataBase.DBService.ExecuteCommand(string.Format(INSERT_CLIENT_PROCESS_DETAILS,
                //        maxProcessId,
                //        dr["UserId"].ToString(),
                //        DateTime.Now.ToString("yyyy-MM-dd"),
                //        DateTime.Now.ToString("yyyy-MM-dd"),
                //        DateTime.Now.ToString("yyyy-MM-dd")
                //        ));
                //}


                Activity.ActivitiesService.Add(ActivityType.CreateProspectClient, EntryStatus.Success,
                                               Source.Client, prospectClient.UpdatedByUserName, prospectClient.Name, prospectClient.MachineName);
            }
            catch (Exception ex)
            {
                FinancialPlanner.Common.Logger.LogDebug(ex.Message);
                throw ex;
            }
        }
Example #5
0
        public void UpdateProspectClient(ProspectClient prospectClient)
        {
            try
            {
                bool      isConvertedToClien      = false;
                bool      isIntroductionCompleted = false;
                DataTable dtPropClient            = DataBase.DBService.ExecuteCommand(string.Format(SELECT_BY_ID, prospectClient.ID));
                foreach (DataRow dr in dtPropClient.Rows)
                {
                    isConvertedToClien      = bool.Parse(dr["IsConvertedToClient"].ToString());
                    isIntroductionCompleted = bool.Parse(dr["IntroductionCompleted"].ToString());
                }


                DataBase.DBService.ExecuteCommand(string.Format(UPDATE_PROSPECTCLIENT_QUERY,
                                                                prospectClient.Name, prospectClient.PhoneNo, prospectClient.Email,
                                                                prospectClient.Occupation, prospectClient.Event, prospectClient.EventDate.ToString("yyyy-MM-dd hh:mm:ss"),
                                                                prospectClient.ReferedBy,
                                                                prospectClient.UpdatedOn.ToString("yyyy-MM-dd hh:mm:ss"), prospectClient.UpdatedBy,
                                                                prospectClient.IsConvertedToClient, prospectClient.StopSendingEmail,
                                                                prospectClient.Remarks,
                                                                prospectClient.IntroductionCompleted,
                                                                prospectClient.IntroductionCompletedDate.ToString("yyyy-MM-dd hh:mm:ss"),
                                                                prospectClient.ClientAssignTo,
                                                                prospectClient.ClientId,
                                                                prospectClient.ID));

                //Converted to client from prospect list.
                if (!isConvertedToClien.Equals(prospectClient.IsConvertedToClient) && prospectClient.IsConvertedToClient)
                {
                    // Add code for task to convert to client.
                    //DataTable dtPrimaryStep = DataBase.DBService.ExecuteCommand(string.Format(SELECT_PRIMARY_LINKSUBSTEP_ID, 2));

                    DataTable dtStepNo = DataBase.DBService.ExecuteCommand(
                        string.Format(SELECT_PRIMARY_LINKSUBSTEP_ID, 2));

                    foreach (DataRow dr in dtStepNo.Rows)
                    {
                        //int maxId = int.Parse(DataBase.DBService.ExecuteCommandScalar(SELECT_MAX_ID));

                        //Add entry into process step
                        ClientProcessService clientProcessService = new ClientProcessService();
                        ClientProcess        clientProcess        = new ClientProcess();
                        clientProcess.ClientId           = prospectClient.ClientId;
                        clientProcess.PrimaryStepId      = dr.Field <int>("PrimaryStepId");
                        clientProcess.LinkStepId         = 1;
                        clientProcess.Status             = "P";
                        clientProcess.IsProcespectClient = false;
                        if (dr["LinkSubStepId"] != DBNull.Value)
                        {
                            clientProcess.LinkStepId = dr.Field <int>("LinkSubStepId");
                        }

                        int       assignTo      = 0;
                        DataTable dtPrimaryStep = DataBase.DBService.ExecuteCommand(string.Format(SELECT_PRIMARY_STEP, clientProcess.PrimaryStepId));

                        if (dtPrimaryStep.Rows.Count > 0)
                        {
                            int.TryParse(dtPrimaryStep.Rows[0]["UserId"].ToString(), out assignTo);
                        }
                        if (dtPrimaryStep.Rows.Count > 0)
                        {
                            int.TryParse(dtPrimaryStep.Rows[0]["UserId"].ToString(), out assignTo);
                        }
                        clientProcessService.Add(clientProcess, prospectClient.ClientAssignTo);


                        //DataBase.DBService.ExecuteCommand(string.Format(INSERT_CLIENT_PROCESS,
                        //    prospectClient.ID, 2, 1, 'C', 1));

                        //int maxProcessId = int.Parse(DataBase.DBService.ExecuteCommandScalar(SELECT_MAX_CLIENTPROCESS_ID));

                        //DataBase.DBService.ExecuteCommand(string.Format(INSERT_CLIENT_PROCESS_DETAILS,
                        //    maxProcessId,
                        //    dr["UserId"].ToString(),
                        //    DateTime.Now.ToString("yyyy-MM-dd"),
                        //    DateTime.Now.ToString("yyyy-MM-dd"),
                        //    DateTime.Now.ToString("yyyy-MM-dd")
                        //    ));
                    }
                }

                if (!isIntroductionCompleted.Equals(prospectClient.IntroductionCompleted) && prospectClient.IntroductionCompleted)
                {
                    // Add code for tas to introduction completed.
                }


                Activity.ActivitiesService.Add(ActivityType.UpdateProspectClient, EntryStatus.Success,
                                               Source.Client, prospectClient.UpdatedByUserName, prospectClient.Name, prospectClient.MachineName);
            }
            catch (Exception ex)
            {
                FinancialPlanner.Common.Logger.LogDebug(ex.Message);
                throw ex;
            }
        }