Example #1
0
    public static void DeleteExercise()
    {
        int IdExercicio = GlobalController.instance.exercise.idExercicio;

        List <PontosRotuloPaciente> allPrps = PontosRotuloPaciente.Read();


        foreach (var prp in allPrps)
        {
            if (prp.idExercicio == IdExercicio)
            {
                PontosRotuloPaciente.DeleteValue(prp.idRotuloPaciente);
            }
        }

        string pathEx = string.Format("{0}/Exercicios/{1}", Application.dataPath, GlobalController.instance.exercise.pontosExercicio);

        if (File.Exists(pathEx))
        {
            File.Delete(pathEx);
        }

        Exercicio.DeleteValue(IdExercicio);
        Flow.StaticExercisesToReview();
    }
Example #2
0
    /**
     * Descrever aqui o que esse método realiza.
     */
    public void displayGraph(string label, Vector2 val)
    {
        GameObject go = Instantiate(labelPrefab) as GameObject;

        go.transform.localPosition = new Vector3(0f, 0f, 0f);
        go.transform.SetParent(transform, false);

        var scriptInitial = go.GetComponentInChildren <SetInitialX>();
        var scriptFinal   = go.GetComponentInChildren <SetFinalX>();
        var labelName     = go.GetComponentInChildren <TextMesh>();
        var dbPrpObject   = go.GetComponentInChildren <SetLabelPatient>();

        scriptInitial.InitialX = val.x;
        scriptFinal.FinalX     = val.y;

        scriptInitial.Set();
        scriptFinal.Set();

        labelName.text = label;

        PontosRotuloPaciente.Insert(GlobalController.instance.exercise.idExercicio, label, val.x, val.y);
        List <PontosRotuloPaciente> allPrp = PontosRotuloPaciente.Read();

        dbPrpObject.Prp = allPrp[allPrp.Count - 1];
    }
    public static void DeleteMovement()
    {
        int IdMovimento = GlobalController.instance.movement.idMovimento;

        List <Exercicio> allExercises             = Exercicio.Read();
        List <PontosRotuloFisioterapeuta> allPrfs = PontosRotuloFisioterapeuta.Read();
        List <PontosRotuloPaciente>       allPrps = PontosRotuloPaciente.Read();
        List <MovimentoMusculo>           mm      = MovimentoMusculo.Read();

        foreach (var prf in allPrfs)
        {
            if (prf.idMovimento == IdMovimento)
            {
                PontosRotuloFisioterapeuta.DeleteValue(prf.idRotuloFisioterapeuta);
            }
        }


        foreach (var ex in allExercises)
        {
            if (ex.idMovimento == IdMovimento)
            {
                foreach (var prp in allPrps)
                {
                    if (prp.idExercicio == ex.idExercicio)
                    {
                        PontosRotuloPaciente.DeleteValue(prp.idRotuloPaciente);
                    }
                }
                string pathEx = string.Format("{0}/Exercicios/{1}", Application.dataPath, ex.pontosExercicio);
                if (File.Exists(pathEx))
                {
                    File.Delete(pathEx);
                }
                Exercicio.DeleteValue(ex.idExercicio);
            }
        }

        foreach (var m in mm)
        {
            if (m.idMovimento == IdMovimento)
            {
                MovimentoMusculo.DeleteValue(m.idMovimento, m.idMusculo);
            }
        }

        string pathMov = string.Format("{0}/Movimentos/{1}", Application.dataPath, GlobalController.instance.movement.pontosMovimento);

        if (File.Exists(pathMov))
        {
            File.Delete(pathMov);
        }

        Movimento.DeleteValue(IdMovimento);


        Flow.StaticMovements();
    }
        public static void TestPatientLabelPointsRead()
        {
            using (var conn = new SqliteConnection(GlobalController.path))
            {
                conn.Open();

                Pessoa.Insert("patient name1", "m", "1995-01-01", "6198732711", null);
                Pessoa.Insert("patient name2", "m", "1995-01-02", "6198732712", null);
                Pessoa.Insert("patient name3", "m", "1995-01-03", "6198732713", null);
                Pessoa.Insert("physio name1", "m", "1995-01-04", "6198732714", null);
                Pessoa.Insert("physio name2", "m", "1995-01-05", "6198732715", null);
                Pessoa.Insert("physio name3", "m", "1995-01-06", "6198732716", null);

                Fisioterapeuta.Insert(4, "abracadabra1", "demais1", null, null);
                Fisioterapeuta.Insert(5, "abracadabra2", "demais2", null, null);
                Fisioterapeuta.Insert(6, "abracadabra3", "demais3", null, null);

                Paciente.Insert(1, null);
                Paciente.Insert(2, null);
                Paciente.Insert(3, null);

                Movimento.Insert(1, "Movimento1", "Musculo Redondo Maior", null);
                Movimento.Insert(2, "Movimento2", "Musculo Redondo Maior", "Dificuldade nesse local");
                Movimento.Insert(3, "Movimento3", "Musculo Redondo Maior", "Dificuldade nesse local");

                Sessao.Insert(1, 1, "2018-03-01", null);
                Sessao.Insert(2, 2, "2018-03-02", "procedimento2");
                Sessao.Insert(3, 3, "2018-03-03", "procedimento3");

                Exercicio.Insert(1, 1, 1, "caminhopaciente1.ponto", null);
                Exercicio.Insert(1, 2, 1, "caminhopaciente2.ponto", "levantou mt coisa1");
                Exercicio.Insert(2, 1, 2, "caminhopaciente3.ponto", null);
                Exercicio.Insert(2, 2, 2, "caminhopaciente4.ponto", "levantou mt coisa2");
                Exercicio.Insert(3, 1, 3, "caminhopaciente5.ponto", null);
                Exercicio.Insert(3, 2, 3, "caminhopaciente6.ponto", "levantou mt coisa3");

                PontosRotuloPaciente.Insert(1, "Aperfeicoando1", 05.00f, 06.00f);
                PontosRotuloPaciente.Insert(2, "Aperfeicoando2", 06.00f, 07.00f);
                PontosRotuloPaciente.Insert(3, "Aperfeicoando3", 07.00f, 08.00f);

                List <PontosRotuloPaciente> allPatientsLabelPoints = PontosRotuloPaciente.Read();

                for (int i = 0; i < allPatientsLabelPoints.Count; ++i)
                {
                    Assert.AreEqual(allPatientsLabelPoints[i].exer.idExercicio, i + 1);
                    Assert.AreEqual(allPatientsLabelPoints[i].idRotuloPaciente, i + 1);
                    Assert.AreEqual(allPatientsLabelPoints[i].estagioMovimentoPaciente, string.Format("Aperfeicoando{0}", i + 1));
                    Assert.AreEqual(allPatientsLabelPoints[i].tempoInicial, 05.00f + i);
                    Assert.AreEqual(allPatientsLabelPoints[i].tempoFinal, 06.00f + i);
                }

                conn.Dispose();
                conn.Close();
            }

            return;
        }
 public void Awake()
 {
     if (GlobalController.instance.exercise != null)
     {
         List <PontosRotuloPaciente> prps = PontosRotuloPaciente.Read();
         foreach (var prp in prps)
         {
             if (prp.idExercicio == GlobalController.instance.exercise.idExercicio)
             {
                 ButtonSpawner(prp);
             }
         }
     }
 }
    public static void DeletePatient()
    {
        int IdPaciente = GlobalController.instance.user.idPaciente;
        int IdPessoa   = GlobalController.instance.user.persona.idPessoa;

        string nomePessoa = (GlobalController.instance.user.persona.nomePessoa).Replace(' ', '_');
        string nomePasta  = string.Format("Assets/Exercicios/{1}-{2}", Application.dataPath, IdPessoa, nomePessoa);

        List <Sessao>               allSessions  = Sessao.Read();
        List <Exercicio>            allExercises = Exercicio.Read();
        List <PontosRotuloPaciente> allPrps      = PontosRotuloPaciente.Read();

        foreach (var exercise in allExercises)
        {
            if (exercise.idPaciente == IdPaciente)
            {
                foreach (var prp in allPrps)
                {
                    if (prp.idExercicio == exercise.idExercicio)
                    {
                        PontosRotuloPaciente.DeleteValue(prp.idRotuloPaciente);
                    }
                }

                Exercicio.DeleteValue(exercise.idExercicio);
            }
        }

        foreach (var session in allSessions)
        {
            if (session.idPaciente == IdPaciente)
            {
                Sessao.DeleteValue(session.idSessao);
            }
        }

        Paciente.DeleteValue(IdPaciente);
        Pessoa.DeleteValue(IdPessoa);
        if (Directory.Exists(nomePasta))
        {
            Directory.Delete(nomePasta, true);
        }

        Flow.StaticNewPatient();
    }
        public static void RealtimeGraphUDPPatientrotular()
        {
            RealtimeGraphUDPPatientCancelardeletarRotulo();
            var script = GameObject.Find("/Grafico").GetComponent <CreateLabelPatient>();

            bool notregistered = true;

            var prps = PontosRotuloPaciente.Read();

            foreach (var prp in prps)
            {
                if (prp.estagioMovimentoPaciente == "Label Patient Test")
                {
                    notregistered = false;
                }
            }

            if (notregistered)
            {
                script.displayGraph("Label Patient Test", new Vector2(5f, 9f));
            }
        }
        public static IEnumerator TestDeleteExercise()
        {
            Flow.StaticLogin();

            yield return(new WaitForSeconds(0.5f));

            Pessoa.Insert("patient name1", "m", "1995-01-01", "6198732711", null);
            Pessoa.Insert("physio name1", "m", "1995-01-03", "6198732713", null);
            Fisioterapeuta.Insert(2, "abracadabra1", "demais1", null, null);
            Paciente.Insert(1, null);
            Movimento.Insert(1, "levantamento de peso", "asuhasu/caminhoy.com", null);
            Sessao.Insert(1, 1, "1940-10-10", null);

            var pacient  = Paciente.GetLast();
            var fisio    = Fisioterapeuta.GetLast();
            var moves    = Movimento.GetLast();
            var sessions = Sessao.GetLast();

            GlobalController.instance.user     = pacient;
            GlobalController.instance.admin    = fisio;
            GlobalController.instance.movement = moves;
            GlobalController.instance.session  = sessions;

            Flow.StaticMovementsToExercise();

            yield return(new WaitForSeconds(0.5f));

            createExercise.CreateExercise();

            var   device = @"^(.*?(\bDevice|SDK\b)[^$]*)$";
            Regex rgx1   = new Regex(device, RegexOptions.IgnoreCase);

            LogAssert.Expect(LogType.Error, rgx1);

            yield return(new WaitForSeconds(0.5f));

            DeleteExerciseButton.DeleteExercise();

            yield return(new WaitForSeconds(0.5f));

            int IdExercicio = GlobalController.instance.exercise.idExercicio;

            List <PontosRotuloPaciente> allPrps = PontosRotuloPaciente.Read();

            foreach (var prp in allPrps)
            {
                Assert.AreNotEqual(prp.idExercicio, IdExercicio);
            }

            var exers = Exercicio.Read();

            foreach (var exer in exers)
            {
                Assert.AreNotEqual(exer.idExercicio, IdExercicio);
            }

            string pathEx = string.Format("{0}/Exercicios/{1}", Application.dataPath, GlobalController.instance.exercise.pontosExercicio);
            bool   dir    = System.IO.File.Exists(pathEx);

            Assert.AreEqual(dir, false);
        }