Пример #1
0
        public void AddAlert(Alert alert, int entiteitId, bool web, bool android, bool mail)
        {
            initNonExistingRepo(true);
            EntiteitManager emg = new EntiteitManager(uowManager);

            alert.Entiteit = emg.getEntiteit(entiteitId);

            // var entiteit = emg.getEntiteit(1);
            //entiteit.Alerts.Add(alert);



            if (android == true)
            {
                alert.PlatformType = Domain.Enum.PlatformType.ANDROID;
                repo.AddAlert(alert);
            }

            if (web == true)
            {
                alert.PlatformType = Domain.Enum.PlatformType.WEB;
                repo.AddAlert(alert);
            }

            if (mail == true)
            {
                alert.PlatformType = Domain.Enum.PlatformType.EMAIL;
                repo.AddAlert(alert);
            }



            uowManager.Save();
        }
Пример #2
0
        public void UpdateGrafiek(List <int> EntiteitIds, Grafiek grafiek)
        {
            initNonExistingRepo(true);
            EntiteitManager entiteitManager = new EntiteitManager(uowManager);

            Grafiek         grafiekToUpdate = GetGrafiek(grafiek.GrafiekId);
            List <Entiteit> entiteiten      = new List <Entiteit>();

            grafiekToUpdate.Entiteiten.Clear();
            foreach (var i in EntiteitIds)
            {
                var e = postRepository.getAlleEntiteiten().Single(x => x.EntiteitId == i);
                entiteiten.Add(e);
                grafiekToUpdate.Entiteiten.Add(e);
            }

            grafiekToUpdate.Waardes      = BerekenGrafiekWaardes(grafiekToUpdate.CijferOpties, entiteiten);
            grafiekToUpdate.Naam         = grafiek.Naam;
            grafiekToUpdate.GrafiekSoort = grafiek.GrafiekSoort;

            //grafiekToUpdate.Entiteiten = entiteiten;
            //entiteiten.Clear();
            //grafiekToUpdate.Entiteiten.Add(entiteitManager.getEntiteit(4));
            postRepository.UpdateGrafiek(grafiekToUpdate);
            uowManager.Save();
        }
Пример #3
0
        public Dictionary <string, double> BerekenGrafiekWaarde(Domain.Enum.GrafiekType grafiekType, List <Entiteit> entiteiten)
        {
            initNonExistingRepo(true);
            IEntiteitManager            entiteitManager = new EntiteitManager(uowManager);
            Dictionary <string, double> grafiekMap      = new Dictionary <string, double>();

            switch (grafiekType)
            {
            case Domain.Enum.GrafiekType.CIJFERS:
                Entiteit    e1          = entiteitManager.getAlleEntiteiten().Single(x => x.EntiteitId == entiteiten.First().EntiteitId);
                List <Post> postsEerste = e1.Posts;
                int         aantalPosts = postsEerste.Count;
                int         retweets    = postsEerste.Where(x => x.retweet == true).Count();
                //grafiek.Entiteiten.First().Trends;

                grafiekMap.Add("aantalPosts", aantalPosts);
                grafiekMap.Add("aantalRetweets", retweets);
                break;
            }
            return(grafiekMap);
        }
Пример #4
0
        public void genereerAlerts()
        {
            initNonExistingRepo(true);
            EntiteitManager entiteitMgr   = new EntiteitManager(uowManager);
            List <Alert>    Alerts        = getAlleAlerts();
            List <Alert>    mailAlerts    = new List <Alert>();
            List <Alert>    androidalerts = new List <Alert>();
            Entiteit        e;

            //1 keer alle trends resetten om vandaag te kunnen kijken of er een trend aanwezig is
            entiteitMgr.ResetTrends();
            foreach (var alert in Alerts)
            {
                e = alert.Entiteit;
                if (entiteitMgr.berekenTrends(alert.MinWaarde, e, alert.TrendType, alert.Voorwaarde))
                {
                    alert.Triggered = true;
                    UpdateAlert(alert);
                    if (alert.PlatformType == Domain.Enum.PlatformType.EMAIL)
                    {
                        mailAlerts.Add(alert);
                    }
                    if (alert.PlatformType == Domain.Enum.PlatformType.ANDROID)
                    {
                        androidalerts.Add(alert);
                    }
                }
            }

            //Alerts (mail & android) verzenden naar de gebruiker.
            if (mailAlerts.Count > 0)
            {
                sendMailAlerts(mailAlerts);
            }
            if (androidalerts.Count > 0)
            {
                sendAndroidAlerts(androidalerts);
            }
        }
Пример #5
0
        public void maakVasteGrafieken()
        {
            initNonExistingRepo(true);
            DateTime                 since                  = new DateTime(2018, 04, 01);
            DateTime                 until                  = new DateTime(2018, 04, 30);
            EntiteitManager          entiteitManager        = new EntiteitManager(uowManager);
            AccountManager           accountManager         = new AccountManager(uowManager);
            Dictionary <int, double> dictionarySentiment    = new Dictionary <int, double>();
            Dictionary <int, int>    dictionaryPopulariteit = new Dictionary <int, int>();
            Dictionary <string, int> dictionaryWords        = new Dictionary <string, int>();

            foreach (var p in entiteitManager.GetAllPeople(1))
            {
                double sentiment = 0;
                foreach (var post in p.Posts)
                {
                    sentiment += (post.Sentiment.polariteit * post.Sentiment.subjectiviteit) / p.Posts.Count();
                }
                dictionarySentiment.Add(p.EntiteitId, sentiment);
                dictionaryPopulariteit.Add(p.EntiteitId, p.Posts.Count);
            }

            Grafiek grafiekSentiment = new Grafiek()
            {
                Type    = Domain.Enum.GrafiekType.VASTE,
                Waardes = new List <GrafiekWaarde>(),
                Naam    = "Meest Positieve/Negatieve personen"
            };

            Grafiek grafiekPopulair = new Grafiek()
            {
                Type    = Domain.Enum.GrafiekType.VASTE,
                Waardes = new List <GrafiekWaarde>(),
                Naam    = "Meest Populaire personen"
            };

            Grafiek grafiekPopulairWords = new Grafiek()
            {
                Type    = Domain.Enum.GrafiekType.VASTE,
                Waardes = new List <GrafiekWaarde>(),
                Naam    = "Meest Populaire Woorden"
            };

            var orderedSentiment    = dictionarySentiment.OrderBy(x => x.Value);
            var orderedPopulariteit = dictionaryPopulariteit.OrderByDescending(x => x.Value);
            var frequency           = postRepository.GetAllWords().GroupBy(x => x).ToDictionary(x => x.Key, x => x.Count()).OrderByDescending(x => x.Value);

            for (int i = 0; i < 4; i++)
            {
                GrafiekWaarde waarde = new GrafiekWaarde()
                {
                    Naam   = entiteitManager.getEntiteit(orderedSentiment.ElementAt(i).Key).Naam,
                    Waarde = orderedSentiment.ElementAt(i).Value
                };
                GrafiekWaarde waardePop = new GrafiekWaarde()
                {
                    Naam   = entiteitManager.getEntiteit(orderedPopulariteit.ElementAt(i).Key).Naam,
                    Waarde = orderedPopulariteit.ElementAt(i).Value
                };

                GrafiekWaarde waardeWords = new GrafiekWaarde()
                {
                    Naam   = frequency.ElementAt(i).Key.word,
                    Waarde = frequency.ElementAt(i).Value
                };

                grafiekSentiment.Waardes.Add(waarde);
                grafiekPopulair.Waardes.Add(waardePop);
                grafiekPopulairWords.Waardes.Add(waardeWords);
            }
            postRepository.AddGrafiek(grafiekSentiment);
            postRepository.AddGrafiek(grafiekPopulair);
            postRepository.AddGrafiek(grafiekPopulairWords);
            uowManager.Save();
        }
Пример #6
0
        private void ConvertAndSaveToDb(List <TextGainResponse> response, int entiteitId)
        {
            initNonExistingRepo(true);
            EntiteitManager entiteitManager = new EntiteitManager(uowManager);
            Entiteit        entiteit        = entiteitManager.getAlleEntiteiten().Single(x => x.EntiteitId == entiteitId);
            List <Post>     PostsToAdd      = new List <Post>();

            foreach (var post in response)
            {
                Post newPost = new Post()
                {
                    Profile    = new Domain.Post.Profile(),
                    HashTags   = new List <HashTag>(),
                    Words      = new List <Word>(),
                    Date       = post.date,
                    Persons    = new List <Person>(),
                    Sentiment  = new Sentiment(),
                    retweet    = post.retweet,
                    source     = post.source,
                    Urls       = new List <URL>(),
                    Mentions   = new List <Mention>(),
                    postNummer = post.id
                };

                //alle hashtags in ons object steken
                foreach (var hashtag in post.hashtags)
                {
                    HashTag newTag = new HashTag()
                    {
                        hashTag = hashtag
                    };
                    newPost.HashTags.Add(newTag);
                }

                //alle woorden in ons object steken
                foreach (var word in post.Words)
                {
                    Word newWord = new Word()
                    {
                        word = word
                    };
                    newPost.Words.Add(newWord);
                }

                //alle persons in ons object steken
                foreach (var person in post.persons)
                {
                    Person newPerson = new Person()
                    {
                        Naam = person
                    };
                    newPost.Persons.Add(newPerson);
                }

                //alle urls in ons object steken
                foreach (var url in post.urls)
                {
                    URL newURL = new URL()
                    {
                        Link = url
                    };
                    newPost.Urls.Add(newURL);
                }

                foreach (var mention in post.mentions)
                {
                    Mention newMention = new Mention()
                    {
                        mention = mention
                    };
                    newPost.Mentions.Add(newMention);
                }

                //sentiment in textgain geeft altijd 2 elementen terug, eerste is polariteit, tweede subjectiviteit
                if (post.sentiment.Count != 0)
                {
                    double polariteit     = double.Parse(post.sentiment.ElementAt(0), CultureInfo.InvariantCulture);
                    double subjectiviteit = double.Parse(post.sentiment.ElementAt(1), CultureInfo.InvariantCulture);
                    newPost.Sentiment.polariteit     = polariteit;
                    newPost.Sentiment.subjectiviteit = subjectiviteit;
                }

                newPost.retweet = post.retweet;
                newPost.source  = post.source;

                entiteit.Posts.Add(newPost);
                PostsToAdd.Add(newPost);
            }

            //linkt de juist entiteit en voegt nieuwe posts toe.
            //postRepository.AddPosts(PostsToAdd);
            entiteitManager.updateEntiteit(entiteit);
            uowManager.Save();
        }
Пример #7
0
        public async Task SyncDataAsync(int platformid)
        {
            initNonExistingRepo(true);
            EntiteitManager entiteitManager = new EntiteitManager(uowManager);
            //Sync willen we datum van vandaag en gisteren.
            DateTime vandaag  = DateTime.Today.Date;
            DateTime gisteren = DateTime.Today.AddDays(-30).Date;
            List <Domain.Entiteit.Persoon> AllePersonen = entiteitManager.GetAllPeople(platformid);

            //Enkele test entiteiten, puur voor debug, later vragen we deze op uit onze repository//

            /*
             * List<Domain.Entiteit.Persoon> AllePersonen = entiteitManager.GetAllPeople(0);
             *
             * /*  PostRequest postRequest1 = new PostRequest()
             * {
             * since = gisteren,
             * until = vandaag
             * };
             *
             * using (HttpClient http = new HttpClient())
             * {
             *  string uri = "https://kdg.textgain.com/query";
             *  http.DefaultRequestHeaders.Add("X-API-Key", "aEN3K6VJPEoh3sMp9ZVA73kkr");
             * // var myContent = JsonConvert.SerializeObject(postRequest1);
             *  //var buffer = System.Text.Encoding.UTF8.GetBytes(myContent);
             *  //var byteContent = new ByteArrayContent(buffer);
             *  //byteContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
             *  var result = await http.PostAsync(uri,null).Result.Content.ReadAsStringAsync();
             *  try
             *  {
             *      var posts = JsonConvert.DeserializeObject<List<TextGainResponse>>(result);
             *      if (posts.Count != 0)
             *      {
             *         // ConvertAndSaveToDb(posts);
             *
             *        //  System.IO.File.WriteAllText(@"C:\Users\Zeger\source\repos\Integratieproject\WebUI\Controllers\DataTextGain.json", result);
             *      }
             *  }
             *  catch (Newtonsoft.Json.JsonReaderException)
             *  {
             *
             *  }
             *
             * }*/
            //Voor elke entiteit een request maken, momenteel gebruikt het test data, later halen we al onze entiteiten op.
            foreach (var Persoon in AllePersonen)
            {
                PostRequest postRequest = new PostRequest()
                {
                    name = Persoon.Naam,
                    //since = new DateTime(2018, 04, 01),
                    //until = new DateTime(2018, 04, 30)
                    since = gisteren,
                    until = vandaag
                };



                using (HttpClient http = new HttpClient())
                {
                    string uri = "https://kdg.textgain.com/query";
                    http.DefaultRequestHeaders.Add("X-API-Key", "aEN3K6VJPEoh3sMp9ZVA73kkr");
                    var myContent   = JsonConvert.SerializeObject(postRequest);
                    var buffer      = System.Text.Encoding.UTF8.GetBytes(myContent);
                    var byteContent = new ByteArrayContent(buffer);
                    byteContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
                    var result = await http.PostAsync(uri, byteContent).Result.Content.ReadAsStringAsync();

                    try
                    {
                        var posts = JsonConvert.DeserializeObject <List <TextGainResponse> >(result);
                        if (posts.Count != 0)
                        {
                            ConvertAndSaveToDb(posts, Persoon.EntiteitId);
                            //  System.IO.File.WriteAllText(@"C:\Users\Zeger\source\repos\Integratieproject\WebUI\controllers\DataTextGain" + Persoon.EntiteitId + ".json", result);
                        }
                    }
                    catch (Newtonsoft.Json.JsonReaderException)
                    {
                    }
                }
            }
        }
Пример #8
0
        public void AddUserGrafiek(List <CijferOpties> opties, List <int> entiteitIds, GrafiekType grafiekType, int platId, string IdentityId, string naam, GrafiekSoort grafiekSoort)
        {
            initNonExistingRepo(true);
            EntiteitManager entiteitManager = new EntiteitManager(uowManager);
            IPostManager    postManager     = new PostManager(uowManager);
            List <Entiteit> entiteiten      = new List <Entiteit>();

            Account user = accountRepository.ReadAccount(IdentityId);

            //geselecteerde entiteiten opzoeken
            foreach (var i in entiteitIds)
            {
                entiteiten.Add(entiteitManager.getEntiteit(i));
            }

            //nieuwe grafiek aanmaken
            Grafiek grafiek = new Grafiek()
            {
                CijferOpties = opties,
                Entiteiten   = entiteiten,
                Type         = grafiekType,
                Waardes      = new List <GrafiekWaarde>(),
                Naam         = naam,
                GrafiekSoort = grafiekSoort
            };

            if (opties.First().optie.ToLower() == "populariteit")
            {
                grafiek.soortGegevens = Domain.Enum.SoortGegevens.POPULARITEIT;
            }
            else if (opties.First().optie.ToLower() == "postfrequentie")
            {
                grafiek.soortGegevens = Domain.Enum.SoortGegevens.POSTFREQUENTIE;
            }
            else if (opties.First().optie.ToLower() == "sentiment")
            {
                grafiek.soortGegevens = Domain.Enum.SoortGegevens.SENTIMENT;
            }

            //waardes voor de grafiek berekenen
            grafiek.Waardes = postManager.BerekenGrafiekWaardes(opties, entiteiten);

            foreach (var e in entiteiten)
            {
                e.Posts.Clear();
            }
            ;

            //kijkt na of de gebruiker al een lijst van blokken heeft om nullpointer te vermijden
            if (user.Dashboard.Configuratie.DashboardBlokken == null)
            {
                user.Dashboard.Configuratie.DashboardBlokken = new List <DashboardBlok>();
            }

            //nieuw blok aanmaken voor de configuratie
            DashboardBlok dashboardBlok = new DashboardBlok()
            {
                Grafiek = grafiek,
            };

            user.Dashboard.Configuratie.DashboardBlokken.Add(dashboardBlok);
            accountRepository.updateUser(user);
            uowManager.Save();
        }
Пример #9
0
        public void grafiekAanGebruikerToevoegen(string IdentityId, Domain.Enum.GrafiekType TypeGrafiek, List <int> entiteitInts, List <string> CijferOpties, string VergelijkOptie, Domain.Enum.GrafiekSoort grafiekSoort)
        {
            initNonExistingRepo(true);
            //IPostManager postManager = new PostManager(uowManager);
            IEntiteitManager entiteitManager = new EntiteitManager(uowManager);

            Domain.Account.Account user    = accountRepository.ReadAccount(IdentityId);
            Domain.Post.Grafiek    grafiek = new Domain.Post.Grafiek();
            grafiek.Entiteiten = new List <Entiteit>();
            List <Entiteit> entiteiten = new List <Entiteit>();

            foreach (var i in entiteitInts)
            {
                var e = entiteitManager.getAlleEntiteiten().Single(x => x.EntiteitId == i);
                entiteiten.Add(e);
                grafiek.Entiteiten.Add(e);
            }
            Dictionary <string, double>      waardes        = entiteitManager.BerekenGrafiekWaarde(TypeGrafiek, entiteiten, CijferOpties, VergelijkOptie);
            List <Domain.Post.GrafiekWaarde> grafiekWaardes = new List <Domain.Post.GrafiekWaarde>();

            foreach (var item in waardes)
            {
                Domain.Post.GrafiekWaarde w = new Domain.Post.GrafiekWaarde()
                {
                    Naam   = item.Key,
                    Waarde = item.Value
                };
                grafiekWaardes.Add(w);
            }
            if (CijferOpties != null)
            {
                grafiek.CijferOpties = new List <Domain.Post.CijferOpties>();
                foreach (var opt in CijferOpties)
                {
                    if (opt.ToLower() == "aantalposts")
                    {
                        grafiek.CijferOpties.Add(new Domain.Post.CijferOpties
                        {
                            optie = opt
                        });
                    }
                    if (opt.ToLower() == "aantalretweets")
                    {
                        grafiek.CijferOpties.Add(new Domain.Post.CijferOpties
                        {
                            optie = opt
                        });
                    }
                    if (opt.ToLower() == "aanwezigetrends")
                    {
                        grafiek.CijferOpties.Add(new Domain.Post.CijferOpties
                        {
                            optie = opt
                        });
                    }
                }
            }
            grafiek.Type         = TypeGrafiek;
            grafiek.Waardes      = grafiekWaardes;
            grafiek.GrafiekSoort = grafiekSoort;
            if (VergelijkOptie.ToLower() == "populariteit")
            {
                grafiek.soortGegevens = Domain.Enum.SoortGegevens.POPULARITEIT;
            }
            else if (VergelijkOptie.ToLower() == "postfrequentie")
            {
                grafiek.soortGegevens = Domain.Enum.SoortGegevens.POSTFREQUENTIE;
            }


            //cijfers
            switch (TypeGrafiek)
            {
            case Domain.Enum.GrafiekType.CIJFERS:
                grafiek.Naam = "Cijfer gegevens - " + entiteiten.First().Naam;
                break;

            case Domain.Enum.GrafiekType.VERGELIJKING:
                if (grafiek.soortGegevens == Domain.Enum.SoortGegevens.POSTFREQUENTIE)
                {
                    grafiek.Naam = "Vergelijking post frequentie";
                }
                else if (grafiek.soortGegevens == Domain.Enum.SoortGegevens.POPULARITEIT)
                {
                    grafiek.Naam = "Vergelijking populariteit";
                }
                break;
            }
            foreach (Entiteit e in grafiek.Entiteiten)
            {
                e.Posts = null;
            }
            Domain.Account.DashboardBlok dashboardBlok = new Domain.Account.DashboardBlok()
            {
                Grafiek = grafiek
            };

            if (user.Dashboard.Configuratie.DashboardBlokken == null)
            {
                user.Dashboard.Configuratie.DashboardBlokken = new List <DashboardBlok>();
            }
            user.Dashboard.Configuratie.DashboardBlokken.Add(dashboardBlok);
            accountRepository.updateUser(user);
            uowManager.Save();
        }