private async void ChangueState()
        {
            var LaborList = LaborsViewModel.GetInstance();

            if (LaborList.StateId == Constant.Revision)
            {
                await dialogService.ShowMessage("", "No se pueden realizar cambios a la labor, la tarea se encuentra en revisión.");

                return;
            }
            else if (LaborList.StateId != Constant.Iniciar)
            {
                await dialogService.ShowMessage("", "No puede realizarle cambios a la labor, la tarea no se encuentra en ejecución.");

                return;
            }
            if (navigationService.VerifyModal("LaborPage") && LaborList.CanEditTask)
            {
                string[] strings = { "Iniciar", "Suspender", "Finalizar", "Cancelar", "Eliminar" };
                var      value   = await dialogService.DisplayActionList("Labor: " + this.Description, strings);

                byte newState = 0;
                switch (value)
                {
                case "Iniciar":
                    newState = Constant.Iniciar;
                    break;

                case "Suspender":
                    newState = Constant.Suspender;
                    break;

                case "Finalizar":
                    newState = Constant.Finalizar;
                    if (newState == this.State.StateId)
                    {
                        return;
                    }
                    var selectDate = await UserDialogs.Instance.DatePromptAsync("Fecha en que termina la labor:", DateTime.Now);

                    if (selectDate.Ok)
                    {
                        if (selectDate.SelectedDate.Date > DateTime.Today.Date)
                        {
                            await dialogService.ShowMessage("", "La fecha fin de la labor no puede ser mayor a hoy.");

                            return;
                        }
                        else if (selectDate.SelectedDate.Date < this.StartDate)
                        {
                            await dialogService.ShowMessage("", "La fecha fin de la labor no puede ser menor a la fecha de inicio.");

                            return;
                        }
                        this.EndDate = selectDate.SelectedDate;
                    }
                    else
                    {
                        return;
                    }
                    break;

                case "Cancelar":
                    newState = Constant.Cancelar;
                    break;

                case "Eliminar":
                    var confirmar = await dialogService.ShowConfirm("Eliminar Labor", "¿Seguro que desea eliminar la labor?");

                    if (confirmar)
                    {
                        DeleteLabor();
                    }
                    return;

                default: return;
                }
                if (newState == this.State.StateId)
                {
                    return;
                }
                var labor     = this.Cast <Labor>();
                var mainModel = MainViewModel.GetInstance();
                labor.LastUpdateUser = mainModel.CurrentUser.UserCode;
                labor.NewStateId     = newState;
                this.NewStateId      = newState;
                labor.Action         = ResourceCodes.DciModificarLabor;
                labor.Resource       = mainModel.CurrentUser;

                try
                {
                    //Se llama al servicio que actualiza una labor en la base de datos y se obtiene la repuesta
                    var response = await apiService.Put(mainModel.urlBase, "api/", "LaborAPI/PutEstadoLabor/", labor);

                    int result = 0;
                    int.TryParse(response.Message, out result);
                    var message = GetResultStateLabor(result);
                    if (string.IsNullOrEmpty(message))
                    {
                        this.State.StateId = newState;
                        LaborList.Refresh();
                    }
                    else
                    {
                        dialogService.ShortToast(message);
                    }
                }
                catch (Exception ex)
                {
                    await dialogService.ShowMessage("Error", "Ocurrió un error al guardar la información.");
                }
            }
        }
        private async Task <bool> ChangueTaskState(Models.Task task)
        {
            if (navigationService.VerifyNavigation("LaborTabbedPage"))
            {
                string[] strings = { "Iniciar", "Suspender", "Enviar a revisión" };
                var      value   = await dialogService.DisplayActionList("Tarea: " + this.TaskName, strings);

                byte newState = 0;
                switch (value)
                {
                case "Iniciar":
                    newState = Constant.Iniciar;
                    break;

                case "Suspender":
                    newState = Constant.Suspender;
                    if (newState == task.StateId)
                    {
                        return(false);
                    }
                    if (task.StateId == Constant.Abrir)
                    {
                        await dialogService.ShowMessage("", "Una tarea creada solo puede ser puesta en ejecución.");

                        return(false);
                    }
                    if (task.StateId == Constant.Revision)
                    {
                        await dialogService.ShowMessage("", "La tarea se encuentra en revisión, no la puede suspender.");

                        return(false);
                    }
                    this.ReasonMessage = await GetReason();

                    if (string.IsNullOrEmpty(this.ReasonMessage) || this.ReasonMessage == "Salir")
                    {
                        this.ReasonMessage = "";
                        return(false);
                    }
                    break;

                case "Enviar a revisión":
                    newState = Constant.Revision;
                    if (task.StateId == Constant.Abrir)
                    {
                        await dialogService.ShowMessage("", "Una tarea creada solo puede ser puesta en ejecución.");

                        return(false);
                    }
                    if (task.IsRecurrent && task.StateId != Constant.Revision)
                    {
                        await dialogService.ShowMessage("", "No puede enviar a revisión una tarea recurrente.");

                        return(false);
                    }
                    if (string.IsNullOrEmpty(task.Detail) && task.StateId != Constant.Abrir && task.LaborsCount == 0)
                    {
                        await dialogService.ShowMessage("", "Esta enviando una tarea a revisión sin labores. Debe ingresar un detalle.");

                        return(false);
                    }
                    break;

                default: return(false);
                }
                if (newState == task.StateId)
                {
                    return(false);
                }

                var mainModel = MainViewModel.GetInstance();
                task.LastUpdateUser = mainModel.CurrentUser.UserCode;
                task.NewStateId     = newState;
                this.NewStateId     = newState;
                task.Action         = ResourceCodes.DciModificarTarea;
                task.Resource       = mainModel.CurrentUser;
                task.ReasonMessage  = this.ReasonMessage;;

                try
                {
                    //Se llama al servicio que actualiza una labor en la base de datos y se obtiene la repuesta
                    var response = await apiService.Put(mainModel.urlBase, "api/", "TareaAPI/PutEstadoTarea/", task);

                    if (response.IsSuccess)
                    {
                        if (response.Message == "2")
                        {
                            await dialogService.ShowMessage("", "No puede enviar la tarea a revisión, aún le quedan labores pendientes.");
                        }
                        else if (response.Message == "10")
                        {
                            await dialogService.ShowMessage("", "No puede enviar la tarea a revisión, hay labores con fecha final mayor a hoy.");
                        }
                        this.StateId = newState;
                        var TasksList = TasksViewModel.GetInstance();
                        TasksList.Refresh();
                    }
                }
                catch (Exception ex)
                {
                    if (ex.Message.Contains("etapa"))
                    {
                        await dialogService.ShowMessage("", "No puede iniciar la tarea porque la etapa asociada aún no ha iniciado.");
                    }
                    else if (ex.Message.Contains("rol"))
                    {
                        await dialogService.ShowMessage("", "No puede iniciar la tarea porque su rol en el proyecto aún no ha iniciado.");
                    }
                    else
                    {
                        await dialogService.ShowMessage("Error", "Ocurrió un error al guardar la información.");
                    }
                }
            }
            return(true);
        }