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();
}
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);
}
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);
}
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();
}
}
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();
}
public Entiteit getEntiteit(Entiteit entiteit)
{
return(ctx.Entiteiten.Find(entiteit.EntiteitId));
}
public void updateEntiteit(Entiteit entiteit)
{
ctx.Entry(entiteit).State = EntityState.Modified;
ctx.SaveChanges();
}
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());
}
