示例#1
0
 public void UpdateEntiteit(Entiteit entiteitToUpdate)
 {
     /*
      * foreach (var trend in entiteitToUpdate.Trends)
      * {
      *  //ctx.Entry(trend).State = System.Data.Entity.EntityState.Added;
      *  ctx.Trends.Attach(trend);
      * }
      */
     ctx.Entry(entiteitToUpdate).State = System.Data.Entity.EntityState.Modified;
     ctx.SaveChanges();
 }
示例#2
0
        public List <String> getTopPersonWords(Persoon person)
        {
            EntiteitRepository erepo    = new EntiteitRepository();
            Entiteit           entiteit = erepo.ReadEntiteit(person.EntiteitId);

            initNonExistingRepo();
            List <Post> posts        = person.Posts;
            List <Word> persoonWords = new List <Word>();

            foreach (Post post in posts)
            {
                persoonWords.AddRange(postRepository.GetAllWordsFromPost(post));
            }

            Dictionary <string, int> WordCountDic = new Dictionary <string, int>();

            foreach (Word item in persoonWords)
            {
                if (!WordCountDic.ContainsKey(item.word))
                {
                    WordCountDic.Add(item.word, 1);
                }
                else
                {
                    int count = 0;
                    WordCountDic.TryGetValue(item.word, out count);
                    WordCountDic.Remove(item.word);
                    WordCountDic.Add(item.word, count + 1);
                }
            }


            var sortedDict = WordCountDic.OrderByDescending(entry => entry.Value)
                             .Take(10)
                             .ToDictionary(pair => pair.Key, pair => pair.Value);
            var values = sortedDict.Keys.ToList();



            return(values);
        }
示例#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);
        }
 public void UpdateEntiteit(Entiteit entiteitToUpdate)
 {
     initNonExistingRepo();
     repo.UpdateEntiteit(entiteitToUpdate);
 }
        public bool berekenTrends(int minVoorwaarde, Entiteit entiteit, TrendType type, Domain.Alert.Voorwaarde voorwaarde)
        {
            initNonExistingRepo();
            //DateTime vandaag = DateTime.Today;
            //DateTime gisteren = DateTime.Today.AddDays(-1);
            DateTime    vandaag        = new DateTime(2018, 01, 14);
            DateTime    gisteren       = new DateTime(2018, 01, 13);
            List <Post> AllePosts      = entiteit.Posts;
            List <Post> PostsGisteren  = AllePosts.Where(x => x.Date.Day == gisteren.Day).Where(x => x.Date.Month == gisteren.Month).Where(x => x.Date.Year == gisteren.Year).ToList();
            List <Post> PostsVandaag   = AllePosts.Where(x => x.Date.Day == vandaag.Day).Where(x => x.Date.Month == vandaag.Month).Where(x => x.Date.Year == vandaag.Year).ToList();
            int         AantalGisteren = PostsGisteren.Count;
            int         AantalVandaag  = PostsVandaag.Count;
            //We MOETEN entiteit even zelf ophalen zodat de context op de hoogte is van welke entiteit we gebruiken
            Entiteit p        = getAlleEntiteiten().Single(x => x.EntiteitId == entiteit.EntiteitId);
            Trend    newTrend = new Trend();

            double trendVerandering = 1.3;


            //controle of trend al bestaat, zoja moeten we de berekening niet maken
            foreach (var trend in p.Trends)
            {
                if (trend.Type == type)
                {
                    return(true);
                }
            }

            //PRESET voor berekening juist zetten
            switch (type)
            {
            case TrendType.STERKOPWAARDS:
                trendVerandering = 1.3;
                newTrend.Type    = TrendType.STERKOPWAARDS;
                break;

            case TrendType.MATIGOPWAARDS:
                trendVerandering = 1.1;
                newTrend.Type    = TrendType.MATIGOPWAARDS;
                break;

            case TrendType.MATIGDALEND:
                trendVerandering = 0.9;
                newTrend.Type    = TrendType.MATIGDALEND;
                break;

            case TrendType.STERKDALEND:
                trendVerandering = 0.7;
                newTrend.Type    = TrendType.STERKDALEND;
                break;
            }

            switch (voorwaarde)
            {
            case Voorwaarde.SENTIMENT:
                if (type == TrendType.STIJGEND)
                {
                    double sentimentGisteren = 0;
                    double sentimentVandaag  = 0;

                    foreach (var post in PostsGisteren)
                    {
                        sentimentGisteren += (post.sentiment.polariteit * post.sentiment.objectiviteit) / AantalGisteren;
                    }

                    foreach (var post in PostsVandaag)
                    {
                        sentimentVandaag += (post.sentiment.polariteit * post.sentiment.objectiviteit) / AantalVandaag;
                    }
                    double sentimentVerschil = sentimentVandaag - sentimentGisteren;
                    if (sentimentVerschil >= minVoorwaarde)
                    {
                        newTrend.Type = TrendType.STIJGEND;
                        entiteit.Trends.Add(newTrend);
                        UpdateEntiteit(entiteit);
                        return(true);
                    }
                }
                break;

            case Voorwaarde.AANTALVERMELDINGEN:
                if (type == TrendType.STIJGEND)
                {
                    if ((AantalVandaag - AantalGisteren) >= minVoorwaarde)
                    {
                        return(true);
                    }
                }
                if (type == TrendType.DALEND)
                {
                    if ((AantalGisteren - AantalVandaag) >= minVoorwaarde)
                    {
                        return(true);
                    }
                }
                if (type == TrendType.STERKOPWAARDS)
                {
                    if ((AantalVandaag / AantalGisteren) >= trendVerandering)
                    {
                        if (entiteit.Trends == null)
                        {
                            entiteit.Trends = new List <Trend>();
                        }
                        entiteit.Trends.Add(newTrend);
                        UpdateEntiteit(p);
                        return(true);
                    }
                }
                break;

            case Voorwaarde.KEYWORDS:
                break;

            default:
                break;
            }

            //ALS het een type stijging is, dit is een waarde die de user heeft opgegeven kijken we of deze stijging voldoet aan de voorwaarde.
            if (type == TrendType.STIJGEND)
            {
                if ((AantalVandaag - AantalGisteren) >= minVoorwaarde)
                {
                    return(true);
                }
            }
            //zelde als bij stijging maar hier kijken we of de daling voldoet.
            else if (type == TrendType.DALEND)
            {
                if ((AantalGisteren - AantalVandaag) >= minVoorwaarde)
                {
                    return(true);
                }
            }
            else
            {
                if ((AantalVandaag / AantalGisteren) >= trendVerandering)
                {
                    if (entiteit.Trends == null)
                    {
                        entiteit.Trends = new List <Trend>();
                    }
                    entiteit.Trends.Add(newTrend);
                    UpdateEntiteit(p);
                    return(true);
                }
            }
            //als we hier komen wil het zeggen dat er geen trend aanwezig is dus moet de alert niet getriggered worden.
            return(false);
        }
示例#6
0
        public async Task InitialiseData()
        {
            _context.Database.EnsureDeleted();
            if (_context.Database.EnsureCreated())
            {
                // Gebruikers
                // Admin
                IdentityUser admin = new IdentityUser {
                    UserName = "******", Email = "*****@*****.**"
                };
                await _userManager.CreateAsync(admin, "test");

                await _userManager.AddClaimAsync(admin, new Claim(ClaimTypes.Role, "admin"));

                // TestEntiteiten
                Entiteit entiteit1 = new Entiteit("KA Dendermonde", "*****@*****.**");
                Entiteit entiteit2 = new Entiteit("MS Atheneum", "*****@*****.**");
                _context.Entiteiten.AddRange(entiteit1, entiteit2);

                IdentityUser entiteitUser1 = new IdentityUser {
                    UserName = "******", Email = "*****@*****.**"
                };
                await _userManager.CreateAsync(entiteitUser1, "test");

                await _userManager.AddClaimAsync(entiteitUser1, new Claim(ClaimTypes.Role, "entiteit"));

                IdentityUser entiteitUser2 = new IdentityUser {
                    UserName = "******", Email = "*****@*****.**"
                };
                await _userManager.CreateAsync(entiteitUser2, "test");

                await _userManager.AddClaimAsync(entiteitUser2, new Claim(ClaimTypes.Role, "entiteit"));

                // TestBeheerders
                Beheerder beheerder1 = new Beheerder("*****@*****.**");
                Beheerder beheerder2 = new Beheerder("*****@*****.**");
                beheerder1.Entiteiten.Add(new EntiteitBeheerder {
                    EntiteitId = entiteit1.Id, BeheerderId = beheerder1.Id
                });
                beheerder1.Entiteiten.Add(new EntiteitBeheerder {
                    EntiteitId = entiteit2.Id, BeheerderId = beheerder2.Id
                });

                IdentityUser beheerderUser1 = new IdentityUser {
                    UserName = "******", Email = "*****@*****.**"
                };
                await _userManager.CreateAsync(beheerderUser1, "test");

                await _userManager.AddClaimAsync(beheerderUser1, new Claim(ClaimTypes.Role, "beheerder"));

                IdentityUser beheerderUser2 = new IdentityUser {
                    UserName = "******", Email = "*****@*****.**"
                };
                await _userManager.CreateAsync(beheerderUser2, "test");

                await _userManager.AddClaimAsync(beheerderUser2, new Claim(ClaimTypes.Role, "beheerder"));

                _context.Beheerders.AddRange(beheerder1, beheerder2);
                // Finish transaction
                _context.SaveChanges();
            }
        }
示例#7
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();
        }
示例#8
0
 public Entiteit getEntiteit(Entiteit entiteit)
 {
     return(ctx.Entiteiten.Find(entiteit.EntiteitId));
 }
示例#9
0
 public void updateEntiteit(Entiteit entiteit)
 {
     ctx.Entry(entiteit).State = EntityState.Modified;
     ctx.SaveChanges();
 }
示例#10
0
 public void addEntiteit(Entiteit entiteit)
 {
     ctx.Entiteiten.Add(entiteit);
     ctx.SaveChanges();
 }
        public Dictionary <string, double> BerekenGrafiekWaarde(Domain.Enum.GrafiekType grafiekType, List <Entiteit> entiteiten, List <string> CijferOpties, string VergelijkOptie)
        {
            initNonExistingRepo();
            Dictionary <string, double> grafiekMap = new Dictionary <string, double>();

            switch (grafiekType)
            {
            case Domain.Enum.GrafiekType.CIJFERS:
                Entiteit    e1          = entiteitRepository.getAlleEntiteiten().Single(x => x.EntiteitId == entiteiten.First().EntiteitId);
                List <Post> postsEerste = e1.Posts;
                foreach (var cijferOptie in CijferOpties)
                {
                    if (cijferOptie.ToLower() == "aantalposts")
                    {
                        int aantalPosts = postsEerste.Count;
                        grafiekMap.Add("Aantal posts", aantalPosts);
                    }
                    if (cijferOptie.ToLower() == "aantalretweets")
                    {
                        int retweets = postsEerste.Where(x => x.retweet == true).Count();
                        grafiekMap.Add("Aantal retweets", retweets);
                    }
                    if (cijferOptie.ToLower() == "aanwezigetrends")
                    {
                        foreach (var trend in e1.Trends)
                        {
                            switch (trend.Voorwaarde)
                            {
                            case Voorwaarde.SENTIMENT:
                                grafiekMap.Add("Trend Sentiment", 1);
                                break;

                            case Voorwaarde.AANTALVERMELDINGEN:
                                grafiekMap.Add("Trend Aantal Vermeldingen", 1);
                                break;

                            case Voorwaarde.TRENDING:
                                grafiekMap.Add("Trend trending", 1);
                                break;

                            case Voorwaarde.KEYWORDS:
                                grafiekMap.Add("Trend Keywords", 1);
                                break;

                            default:
                                break;
                            }
                        }
                    }
                }
                break;

            case GrafiekType.VERGELIJKING:
                if (VergelijkOptie.ToLower() == "populariteit")
                {
                    foreach (var e in entiteiten)
                    {
                        grafiekMap.Add("Post " + e.Naam, e.Posts.Count);
                    }
                }
                if (VergelijkOptie.ToLower() == "postfrequentie")
                {
                    DateTime today   = DateTime.Today;
                    int      counter = 0;
                    foreach (var e in entiteiten)
                    {
                        for (int i = 10; i > 0; i--)
                        {
                            List <Post> postsHuidigeDag = e.Posts.Where(x => x.Date.Date == today.AddDays(-i).Date).ToList();
                            grafiekMap.Add("Posts" + i + " " + e.Naam, postsHuidigeDag.Count);
                        }
                        grafiekMap.Add("EndPostFrequentie" + counter, counter);
                        counter++;
                    }
                }
                break;
            }
            return(grafiekMap);
        }
 public void addEntiteit(Entiteit entiteit)
 {
     initNonExistingRepo();
     entiteitRepository.AddEntiteit(entiteit);
 }
        public bool berekenTrends(double minVoorwaarde, Entiteit entiteit, TrendType type, Voorwaarde voorwaarde)
        {
            initNonExistingRepo();
            DateTime vandaag  = DateTime.Today;
            DateTime gisteren = DateTime.Today.AddDays(-1);
            //DateTime vandaag = new DateTime(2018, 01, 14);
            //DateTime gisteren = new DateTime(2018, 01, 13);
            List <Post> AllePosts      = entiteit.Posts;
            List <Post> PostsGisteren  = AllePosts.Where(x => x.Date.Day == gisteren.Day).Where(x => x.Date.Month == gisteren.Month).Where(x => x.Date.Year == gisteren.Year).ToList();
            List <Post> PostsVandaag   = AllePosts.Where(x => x.Date.Day == vandaag.Day).Where(x => x.Date.Month == vandaag.Month).Where(x => x.Date.Year == vandaag.Year).ToList();
            int         AantalGisteren = PostsGisteren.Count;
            int         AantalVandaag  = PostsVandaag.Count;
            //We MOETEN entiteit even zelf ophalen zodat de context op de hoogte is van welke entiteit we gebruiken
            Entiteit e                = getAlleEntiteiten().Single(x => x.EntiteitId == entiteit.EntiteitId);
            Trend    newTrend         = new Trend();
            double   trendVerandering = 1.3;

            //controle of trend al bestaat, zoja moeten we de berekening niet maken
            foreach (var trend in e.Trends)
            {
                if (trend.Type == type)
                {
                    return(true);
                }
            }

            //PRESET voor berekening juist zetten
            switch (type)
            {
            case TrendType.STERKOPWAARTS:
                trendVerandering = 1.3;
                newTrend.Type    = TrendType.STERKOPWAARTS;
                break;

            case TrendType.MATIGOPWAARDS:
                trendVerandering = 1.1;
                newTrend.Type    = TrendType.MATIGOPWAARDS;
                break;

            case TrendType.MATIGDALEND:
                trendVerandering = 0.9;
                newTrend.Type    = TrendType.MATIGDALEND;
                break;

            case TrendType.STERKDALEND:
                trendVerandering = 0.7;
                newTrend.Type    = TrendType.STERKDALEND;
                break;
            }


            switch (voorwaarde)
            {
            case Voorwaarde.SENTIMENT:
                double sentimentGisteren = 0;
                double sentimentVandaag  = 0;

                foreach (var post in PostsGisteren)
                {
                    sentimentGisteren += (post.Sentiment.polariteit * post.Sentiment.subjectiviteit) / AantalGisteren;
                }

                foreach (var post in PostsVandaag)
                {
                    sentimentVandaag += (post.Sentiment.polariteit * post.Sentiment.subjectiviteit) / AantalVandaag;
                }
                double sentimentVerschil = 0;

                if (type == TrendType.STIJGEND)
                {
                    sentimentVerschil = sentimentVandaag - sentimentGisteren;
                    if (sentimentVerschil >= minVoorwaarde)
                    {
                        newTrend.Type       = TrendType.STIJGEND;
                        newTrend.Voorwaarde = Voorwaarde.SENTIMENT;
                        entiteit.Trends.Add(newTrend);
                        updateEntiteit(e);
                        return(true);
                    }
                }
                else if (type == TrendType.DALEND)
                {
                    sentimentVerschil   = sentimentGisteren - sentimentVandaag;
                    newTrend.Type       = TrendType.DALEND;
                    newTrend.Voorwaarde = Voorwaarde.SENTIMENT;
                    entiteit.Trends.Add(newTrend);
                    updateEntiteit(e);
                    return(true);
                }
                break;

            case Voorwaarde.AANTALVERMELDINGEN:
                newTrend.Voorwaarde = Voorwaarde.AANTALVERMELDINGEN;
                if (type == TrendType.DALEND)
                {
                    if ((AantalGisteren - AantalVandaag) >= minVoorwaarde)
                    {
                        return(true);
                    }
                }
                if (type == TrendType.STIJGEND)
                {
                    if ((AantalVandaag - AantalGisteren) >= minVoorwaarde)
                    {
                        return(true);
                    }
                }
                if (type == TrendType.STERKOPWAARTS)
                {
                    if ((AantalVandaag / AantalGisteren) >= trendVerandering)
                    {
                        if (entiteit.Trends == null)
                        {
                            entiteit.Trends = new List <Trend>();
                        }
                        entiteit.Trends.Add(newTrend);
                        updateEntiteit(e);
                        return(true);
                    }
                }
                if (type == TrendType.STERKDALEND)
                {
                    if ((AantalVandaag / AantalGisteren) <= trendVerandering)
                    {
                        if (entiteit.Trends == null)
                        {
                            entiteit.Trends = new List <Trend>();
                        }
                        entiteit.Trends.Add(newTrend);
                        updateEntiteit(e);
                        return(true);
                    }
                }
                break;


            case Voorwaarde.TRENDING:
                //de eventuele trend die aanwezig kan zijn juist zetten op de trend waarop we vergelijken
                newTrend.Voorwaarde = Voorwaarde.TRENDING;
                //if kijkt na of het aantal posts van gisteren tegenover vandaag met 50% is gestegen en er moet minstens een volume van 10 posts zijn
                if ((AantalVandaag / AantalGisteren) > 1.5 && AantalGisteren >= 10 && AantalVandaag >= 10)
                {
                    if (entiteit.Trends == null)
                    {
                        entiteit.Trends = new List <Trend>();
                    }
                    entiteit.Trends.Add(newTrend);
                    updateEntiteit(e);
                    return(true);
                }
                break;

            case Voorwaarde.KEYWORDS:
                break;

            default:
                break;
            }
            //als we hier komen is er geen trend aanwezig.
            return(false);
        }
 public void updateEntiteit(Entiteit entiteit)
 {
     initNonExistingRepo();
     entiteitRepository.updateEntiteit(entiteit);
 }
 public List <Post> getPostsOnEntiteit(Entiteit entiteit)
 {
     return(AllePosts().Where(x => x.Persoon == entiteit).ToList());
 }