Example #1
0
        /// <summary>
        /// In deze methode zal zodra de pagina geladen is, de lijst met inspecties als ItemSource voor het grid instellen.
        /// Inspecties die eerder afgerond werden worden aan de SelectedItems van het grid toegevoegd zodat deze worden aangevinkt.
        /// Tenslotte wordt de eerste inspectie in de lijst die niet aangevinkt werd in beeld gescrolled. Indien een dringend (volgens de gps) eerst komt wordt deze in beeld gebracht.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void VerschillendeTestenPage_Loaded(object sender, RoutedEventArgs e)
        {
            gvwInspecties.HorizontalContentAlignment = Windows.UI.Xaml.HorizontalAlignment.Stretch;
            gvwInspecties.ItemsSource = inspecties;
            bool gescrolled = false; //Houd bij of naar het eerste onvoldooide activiteit gescrolled werd of niet.
            foreach (Inspectie inspectie in inspecties)
            {
                if (inspectie.Status)
                    gvwInspecties.SelectedItems.Add(inspectie);
                else if (!gescrolled)
                {
                    gescrolled = true;
                    scrollenNaarInspectie = inspectie;
                }
            }
            if (scrollenNaarInspectie != null)
                gvwInspecties.ScrollIntoView(scrollenNaarInspectie, ScrollIntoViewAlignment.Leading);

            //scrollViewer van gridview ophalen is niet mogelijk in standaard RT - wel met WinRTXamlToolkit
            scrollViewer = gvwInspecties.GetFirstDescendantOfType<ScrollViewer>();
        }
Example #2
0
 /// <summary>
 /// Methode die luistert naar updates van de Geolocator.
 /// De ItemTemplateSelector wordt opnieuw aan het gridview toegewezen wat ervoor zorgt dat elk item opnieuw een DataTemplate
 /// toegewezen krijgt naargelang de gereden kilometers.
 /// </summary>
 /// <param name="kilometersGereden">kilometers is van het type int</param>
 private void LocatieUpdate(int kilometersGereden)
 {
     this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
     {
         foreach (Inspectie inspectie in inspecties)
         {
             if (kilometersGereden > inspectie.Kilometerstand - 501 && kilometersGereden < inspectie.Kilometerstand)
             {
                 scrollenNaarInspectie = inspectie;
                 break;
             }
         }
         DataTemplateSelector selector = gvwInspecties.ItemTemplateSelector;
         gvwInspecties.ItemTemplateSelector = null;
         gvwInspecties.ItemTemplateSelector = selector;
         gvwInspecties.ScrollIntoView(scrollenNaarInspectie);
     }).AsTask().Wait();
         }
Example #3
0
        /// <summary>
        /// Alle tabellen worden geïnitializeerd en opgevuld met de nodige gegevens.
        /// Alle gegevens worden van de server gehaald.
        /// </summary>
        public async Task CreateDatabase(bool toegewezenAuto)
        {
            try
            {
                #region Verwijderen en aanmaken van tabellen

                await db.DropTableAsync<USER>(); //Tabel USER verwijderen
                await db.CreateTableAsync<USER>(); //Tabel USER aanmaken

                await db.DropTableAsync<VEHICLE>(); //Tabel VEHICLE verwijderen
                await db.CreateTableAsync<VEHICLE>(); //Tabel VEHICLE aanmaken

                await db.DropTableAsync<ENGINE>(); //Tabel ENGINE verwijderen
                await db.CreateTableAsync<ENGINE>(); //Tabel ENGINE aanmaken

                await db.DropTableAsync<BRAND>(); //Tabel BRAND verwijderen
                await db.CreateTableAsync<BRAND>(); //Tabel BRAND aanmaken

                await db.DropTableAsync<FUEL>(); //Tabel FUEL verwijderen
                await db.CreateTableAsync<FUEL>(); //Tabel FUEL aanmaken

                await db.DropTableAsync<TRANSMISSION>(); //Tabel TRANSMISSION verwijderen
                await db.CreateTableAsync<TRANSMISSION>(); //Tabel TRANSMISSION aanmaken

                await db.DropTableAsync<WEIGHTS>(); //Tabel WEIGHTS verwijderen
                await db.CreateTableAsync<WEIGHTS>(); //Tabel WEIGHTS aanmaken

                await db.DropTableAsync<DEFECT_CODES>(); //Tabel PROBLEM verwijderen
                await db.CreateTableAsync<DEFECT_CODES>(); //Tabel PROBLEM aanmaken

                await db.DropTableAsync<SCRIPT>(); //Tabel SCRIPT verwijderen
                await db.CreateTableAsync<SCRIPT>(); //Tabel SCRIPT aanmaken

                if (!toegewezenAuto)
                {
                await db.DropTableAsync<INSPECTIE>(); //Tabel INSPECTIE verwijderen
                await db.CreateTableAsync<INSPECTIE>(); //Tabel INSPECTIE aanmaken

                    await db.DropTableAsync<COMMENT>(); //Tabel COMMENT verwijderen
                    await db.CreateTableAsync<COMMENT>(); //Tabel COMMENT aanmaken
                }

                await db.DropTableAsync<CATEGORY>(); //Tabel CATEGORIE verwijderen
                await db.CreateTableAsync<CATEGORY>(); //Tabel CATEGORIE aanmaken

                await db.DropTableAsync<OBJECT_CODES>(); //Tabel OBJECT_CODES verwijderen
                await db.CreateTableAsync<OBJECT_CODES>(); //TAbel OBJECT_CODES aanmaken

                #endregion

                //Deze region bevat commentaar, alle andere regions gebruiken het zelfde principe.
                #region Users aanmaken & toevoegen

                //Referentie naar users uit de Webservice halen
                var refUsers = await webService.SQLite_GetUsersAsync();
                try
                {
                    //De body bevat een lijst van lijsten.
                    var userPairs = refUsers.Body.SQLite_GetUsersResult; //Elke lijst in de lijst bevat een KeyValuePair (serializable klasse van de webservice) dat een USER object representeeert.
                    var user = new USER();
                    try
                    {
                        List<USER> users = new List<USER>(); //Zal alle gevonden users bevatten
                        foreach (List<WebserviceRef.SerializableKeyValuePair> userPair in userPairs) //Voor elk KeyValuePair
                        {
                            user = new USER
                            {
                                Id = Convert.ToInt32(userPair[0].Value),
                                Username = userPair[1].Value.ToString(),
                                Password = userPair[2].Value.ToString(),
                                Admin = (bool)userPair[3].Value
                            }; //Een nieuw gebruiker aanmaken van een KeyValuePair
                            users.Add(user); //Gebruiker toevoegen aan de lijst met gebruikers
                        }
                        await db.InsertAllAsync(users); //De lijst asynchroon importeren in de SQLite database
                    }
                    catch (InvalidCastException)
                    {
                        paLogging.log.Error(String.Format("User met Id ({0}) heeft een veld dat geen integer bevat.",
                                                    user.Id + 1));
                    }
                    catch (FormatException)
                    {
                        paLogging.log.Error(String.Format("Een veld van engine {0} kon niet worden geconverteerd naar een integer.",
                                                    user.Id + 1));
                    }
                }
                catch (Exception e)
                {
                    paLogging.log.Error("Er is een fout opgetreden bij het opvullen van de database (tabel problem) : " + e.Message);
                }

                #endregion

                #region Auto gerelateerde opvullingmethodes
                if (toegewezenAuto)
                {
                    await HaalToegewezenAutoOp();

                    #region Brand aanmaken & toevoegen

                    try
                    {
                        var refMerkPairs = (await webService.SQLite_GetBrandsAsync(completeAuto.Merk_Id)).Body.SQLite_GetBrandsResult;
                        if (refMerkPairs.Any())
                        {
                            var merkPair = refMerkPairs.First();
                            Brand merk = new Brand();
                            try
                            {
                                merk = new Brand(Convert.ToInt32(merkPair[0].Value), merkPair[1].Value.ToString(), merkPair[2].Value.ToString());
                                await db.InsertAsync(merk.GetBRAND());
                                completeAuto.SetBrand(merk);
                            }
                            catch (InvalidCastException)
                            {
                                paLogging.log.Error(String.Format("Fuel met id {0} heeft een veld dat geen integer bevat.",
                                                            merk.Id + 1));
                            }
                            catch (FormatException)
                            {
                                paLogging.log.Error(String.Format("Een veld van fuel {0} kon niet worden geconverteerd naar een integer.",
                                                            merk.Id + 1));
                            }
                        }
                        else
                        {
                            completeAuto.SetBrand(new Brand());
                        }
                    }
                    catch (Exception e)
                    {
                        paLogging.log.Error("Er is een fout opgetreden bij het opvullen van de database (tabel problem) : " + e.Message);
                    }

                    #endregion

                    #region Engine aanmaken & toevoegen

                    try
                    {
                        var refEngines = (await webService.SQLite_GetEnginesAsync(completeAuto.Motor_Id)).Body.SQLite_GetEnginesResult;
                        if (refEngines.Any())
                        {
                            var enginePair = refEngines.First();
                            var engine = new Engine();
                            try
                            {
                                engine = new Engine(Convert.ToInt32(enginePair[0].Value), enginePair[1].Value.ToString(), Convert.ToDecimal(enginePair[2].Value.ToString()), Convert.ToInt32(enginePair[3].Value));

                                await db.InsertAsync(engine.GetENGINE());
                            }
                            catch (InvalidCastException)
                            {
                                paLogging.log.Error(String.Format("Engine met id {0} heeft een veld dat geen integer bevat.",
                                                            engine.Id + 1));
                            }
                            catch (FormatException)
                            {
                                paLogging.log.Error(String.Format("Een veld van engine {0} kon niet worden geconverteerd naar een integer.",
                                                            engine.Id + 1));
                            }
                        }
                        else
                        {
                            completeAuto.SetEngine(new Engine());
                        }
                    }
                    catch (Exception e)
                    {
                        paLogging.log.Error("Er is een fout opgetreden bij het opvullen van de database (tabel problem) : " + e.Message);
                    }

                    #endregion

                    #region Fuel aanmaken & toevoegen

                    try
                    {
                        var fuelPairs = (await webService.SQLite_GetFuelsAsync(completeAuto.Motor_Brandstof_Id)).Body.SQLite_GetFuelsResult;
                        if (fuelPairs.Any())
                        {
                            var fuelPair = fuelPairs.First();
                            Fuel brandstof = new Fuel();
                            try
                            {
                                brandstof = new Fuel(Convert.ToInt32(fuelPair[0].Value), fuelPair[1].Value.ToString());
                                await db.InsertAsync(brandstof.GetFUEL());
                                completeAuto.SetFuel(brandstof);
                            }
                            catch (InvalidCastException)
                            {
                                paLogging.log.Error(String.Format("Fuel met id {0} heeft een veld dat geen integer bevat.",
                                                            brandstof.Id + 1));
                            }
                            catch (FormatException)
                            {
                                paLogging.log.Error(String.Format("Een veld van fuel {0} kon niet worden geconverteerd naar een integer.",
                                                            brandstof.Id + 1));
                            }
                        }
                        else
                        {
                            completeAuto.SetFuel(new Fuel());
                        }
                    }
                    catch (Exception e)
                    {
                        paLogging.log.Error("Er is een fout opgetreden bij het opvullen van de database (tabel problem) : " + e.Message);
                    }

                    #endregion

                    #region Transmission aanmaken & toevoegen

                    try
                    {
                        var transmissionPairs = (await webService.SQLite_GetTransmissionsAsync(completeAuto.Transmissie_Id)).Body.SQLite_GetTransmissionsResult;
                        if (transmissionPairs.Any())
                        {
                            var transmissionPair = transmissionPairs.First();
                            Transmission transmissie = new Transmission();
                            try
                            {
                                transmissie = new Transmission(Convert.ToInt32(transmissionPair[0].Value), transmissionPair[2].Value.ToString(), Convert.ToInt32(transmissionPair[1].Value));
                                await db.InsertAsync(transmissie.GetTRANSMISSION());
                                completeAuto.SetTransmissie(transmissie);
                            }
                            catch (InvalidCastException)
                            {
                                paLogging.log.Error(String.Format("Transmissie met id {0} heeft een veld dat geen integer bevat.",
                                                            transmissie.Id + 1));
                            }
                            catch (FormatException)
                            {
                                paLogging.log.Error(String.Format("Een veld van transmissie {0} kon niet worden geconverteerd naar een integer.",
                                                            transmissie.Id + 1));
                            }
                        }
                        else
                        {
                            completeAuto.SetTransmissie(new Transmission());
                        }
                    }
                    catch (Exception e)
                    {
                        paLogging.log.Error("Er is een fout opgetreden bij het opvullen van de database (tabel problem) : " + e.Message);
                    }

                    #endregion
                }
                #endregion

                #region Vehicles aanmaken & toevoegen

                var refVehicles = await webService.SQLite_GetVehiclesAsync();
                try
                {
                    var vehiclePairs = refVehicles.Body.SQLite_GetVehiclesResult;
                    var auto = new VEHICLE();
                    try
                    {
                        List<VEHICLE> autos = new List<VEHICLE>();
                        foreach (List<WebserviceRef.SerializableKeyValuePair> vehiclePair in vehiclePairs)
                        {
                            auto = new VEHICLE
                            {
                                Id = Convert.ToInt32(vehiclePair[0].Value),
                                Number = vehiclePair[1].Value.ToString(),
                                Brand_Id = Convert.ToInt32(vehiclePair[2].Value),
                                Engine_Id = Convert.ToInt32(vehiclePair[3].Value),
                                Transmission_Id = Convert.ToInt32(vehiclePair[4].Value),
                                Eenheid_Id = Convert.ToInt32(vehiclePair[5].Value.ToString()),
                                Active = (bool)vehiclePair[6].Value
                            };
                            autos.Add(auto);
                        }
                        await db.InsertAllAsync(autos);
                    }
                    catch (InvalidCastException)
                    {
                        paLogging.log.Error(String.Format("Vehicle Id ({0}) is geen integer.",
                                                    auto.Id + 1));
                    }
                    catch (FormatException)
                    {
                        paLogging.log.Error(String.Format("Vehicle Id ({0}) kon niet worden geconverteerd naar een integer.",
                                                    auto.Id + 1));
                    }
                }
                catch (Exception e)
                {
                    paLogging.log.Error("Er is een fout opgetreden bij het opvullen van de database (tabel problem) : " + e.Message);
                }

                #endregion

                #region Inspecties aanmaken & toevoegen

                if (completeAuto != null)
                {
                    try
                    {
                        var refInspecties = await webService.SQLite_GetScriptsAsync(completeAuto.Id.ToString());
                        var inspectiePairs = refInspecties.Body.SQLite_GetScriptsResult;
                        var inspectie = new Inspectie();
                        try
                        {
                            List<INSPECTIE> inspecties = new List<INSPECTIE>();
                            List<Inspectie> inspectieScherm = new List<Inspectie>();
                            foreach (List<WebserviceRef.SerializableKeyValuePair> inspectiePair in inspectiePairs)
                            {
                                inspectie = new Inspectie
                                {
                                    Id = Convert.ToInt32(inspectiePair[0].Value),
                                    VehicleId = Convert.ToInt32(inspectiePair[1].Value),
                                    Kilometerstand = Convert.ToInt32(inspectiePair[2].Value),
                                    Cycli = inspectiePair[3].Value.ToString(),
                                    Activity = inspectiePair[4].Value.ToString(),
                                    Eenheid = Convert.ToInt32(inspectiePair[5].Value),
                                    Status = false
                                };
                                inspecties.Add(inspectie.GetINSPECTIE());
                                inspectieScherm.Add(inspectie);
                            }
                            await db.InsertAllAsync(inspecties);
                            VerschillendeInspecties.HaalInspectiesOp(inspectieScherm);
                        }
                        catch (InvalidCastException)
                        {
                            paLogging.log.Error(String.Format("Script met id {0} heeft een veld dat geen integer bevat.",
                                                        inspectie.Id + 1));
                        }
                        catch (FormatException)
                        {
                            paLogging.log.Error(String.Format("Een veld van script {0} kon niet worden geconverteerd naar een integer.",
                                                        inspectie.Id + 1));
                        }
                    }
                    catch (NullReferenceException)
                    {
                        paLogging.log.Warn("De database werd opgevuld hoewel er geen wagen toegewezen is. Er zijn geen inspecties opgehaald.");
                    }
                    catch (Exception e)
                    {
                        paLogging.log.Error("Er is een fout opgetreden bij het opvullen van de database (tabel scripts) : " + e.Message);
                    }
                }
                else
                {
                    paLogging.log.Warn("De database werd opgevuld hoewel er geen wagen toegewezen is. Er zijn geen inspecties opgehaald.");
                }
                #endregion

                #region Defectcodes aanmaken & toevoegen

                var refDefectCodes = await webService.SQLite_GetDefectcodesAsync();
                try
                {
                    var defectPairs = refDefectCodes.Body.SQLite_GetDefectcodesResult;
                    var defectcode = new DEFECT_CODES();
                    try
                    {
                        List<DEFECT_CODES> defectcodes = new List<DEFECT_CODES>();
                        foreach (List<WebserviceRef.SerializableKeyValuePair> defectPair in defectPairs)
                        {
                            defectcode = new DEFECT_CODES
                            {
                                Id = Convert.ToInt32(defectPair[0].Value),
                                Code = defectPair[1].Value.ToString(),
                                Beschrijving = defectPair[2].Value.ToString(),
                                Type_Defect = defectPair[3].Value.ToString()
                            };
                            defectcodes.Add(defectcode);
                        }
                        await db.InsertAllAsync(defectcodes);
                    }
                    catch (InvalidCastException)
                    {
                        paLogging.log.Error(String.Format("Defectcode met id {0} heeft een veld dat geen integer bevat.",
                                                    defectcode.Id + 1));
                    }
                    catch (FormatException)
                    {
                        paLogging.log.Error(String.Format("Een veld van defectcode {0} kon niet worden geconverteerd naar een integer.",
                                                    defectcode.Id + 1));
                    }
                }
                catch (Exception e)
                {
                    paLogging.log.Error("Er is een fout opgetreden bij het opvullen van de database (tabel defect codes) : " + e.Message);
                }

                #endregion

                #region Objectcodes aanmaken & toevoegen

                try
                {
                    var objectPairs = (await webService.SQLite_GetObjectCodesAsync()).Body.SQLite_GetObjectCodesResult;
                    var objectcode = new ObjectCodes();
                    try
                    {
                        List<OBJECT_CODES> objectcodes = new List<OBJECT_CODES>();
                        List<ObjectCodes> doorTeGevenCodes = new List<ObjectCodes>();
                        foreach (List<WebserviceRef.SerializableKeyValuePair> objectPair in objectPairs)
                        {
                            objectcode = new ObjectCodes(
                                Convert.ToInt32(objectPair[0].Value), objectPair[1].Value.ToString(), objectPair[2].Value.ToString(), objectPair[3].Value.ToString(), objectPair[4].Value.ToString());
                            objectcodes.Add(objectcode.GetOBJECTCODES());
                            doorTeGevenCodes.Add(objectcode);
                        }
                        await db.InsertAllAsync(objectcodes);
                    }
                    catch (InvalidCastException)
                    {
                        paLogging.log.Error(String.Format("Object code met id {0} heeft een veld dat geen integer bevat.",
                                                    objectcode.Id + 1));
                    }
                    catch (FormatException)
                    {
                        paLogging.log.Error(String.Format("Een veld van object code {0} kon niet worden geconverteerd naar een integer.",
                                                    objectcode.Id + 1));
                    }
                }
                catch (Exception e)
                {
                    paLogging.log.Error("Er is een fout opgetreden bij het opvullen van de database (tabel object codes) : " + e.Message);
                }

                #endregion

                #region Categorie aanmaken & toevoegen
                var c1 = new CATEGORY
                {
                    Id = 1,
                    ProblemCategory = "Motor",
                    Description = "Problemen ivm de motor"
                };
                var c2 = new CATEGORY
                {
                    Id = 2,
                    ProblemCategory = "Remfunctie",
                    Description = "Problemen ivm de remfunctie"
                };
                var c3 = new CATEGORY
                {
                    Id = 3,
                    ProblemCategory = "Lichten",
                    Description = "Problemen met de lichten"
                };
                await db.InsertAsync(c1);
                await db.InsertAsync(c2);
                await db.InsertAsync(c3);
                #endregion

                #region Comments aanmaken & toevoegen

                /*var refComments = await webService.SQLite_GetCommentsAsync();
                try
                {
                    var commentPairs = refComments.Body.SQLite_GetCommentsResult;
                    var commentaar = new COMMENT();
                    try
                    {
                        List<COMMENT> commentaren = new List<COMMENT>();
                        foreach (List<WebserviceRef.SerializableKeyValuePair> commentPair in commentPairs)
                        {
                            commentaar = new COMMENT
                            {
                                Id = Convert.ToInt32(commentPair[0].Value),
                                DefectCodeId = Convert.ToInt32(commentPair[1].Value),
                                Omschrijving = commentPair[2].Value.ToString()
                            };
                            commentaren.Add(commentaar);
                        }
                        await db.InsertAllAsync(commentaren);
                    }
                    catch (InvalidCastException)
                    {
                        paLogging.log.Error(String.Format("Commentaar met id {0} heeft een veld dat geen integer bevat.",
                                                    commentaar.Id + 1));
                    }
                    catch (FormatException)
                    {
                        paLogging.log.Error(String.Format("Een veld van commentaar {0} kon niet worden geconverteerd naar een integer.",
                                                    commentaar.Id + 1));
                    }
                }
                catch (Exception e)
                {
                    paLogging.log.Error("Er is een fout opgetreden bij het opvullen van de database (tabel object codes) : " + e.Message);
                }*/
                #endregion
            }
            catch (Exception e)
            {
                paLogging.log.Error("Fout bij het lezen of schrijven van de database\nFoutmelding: " + e.Message);
            }
        }