public async Task <JsonResult> AddUserToObservation(string userName)
{
var errors = new List <string>();
var observableUser = new ObservableUser();
string errorMessage = "Failed to add user!";
if ((await _repository.GetListAsync <ObservableUser>()).ToList().Count() < 4)
{
observableUser.InstagramPK = _instaApi.GetPrimaryKeyByUsername(userName);
observableUser.Username = userName;
bool added = await _repository.CreateAsync(observableUser);
if (!added)
{
errors.Add(errorMessage);
throw new HttpException(errorMessage);
}
else
{
Response.StatusCode = 200;//ok
}
}
else
{
errors.Add(errorMessage);
errors.Add("The maximum number of users that can be observed [3]!");
throw new HttpException(errorMessage);
}
return(Json(new
{
observableUser = observableUser,
Errors = errors
}));
}
public async Task RemoveUserFromObservationAsync(ApplicationUser observer, ObservableUser observable)
{
var observableTasks = _tasks.Where(at => at.Observer.Equals(observer) &&
at.Observable.Equals(observable)).ToList();
if (observableTasks.Count == 0) // User is not under observation yet.
{
return;
}
foreach (var aTask in observableTasks)
{
aTask.CancellationTokenSource.Cancel();
}
foreach (var aTask in observableTasks)
{
foreach (var task in aTask.Tasks)
{
task.Wait();
}
}
_tasks = _tasks.Except(observableTasks).ToList();
}
private async Task StartLikesAnalizingAsync(
ApplicationUser observer, ObservableUser observable)
{
foreach (var targetUser in observable.ObservableUsers)
{
StartLikesAnalizingAsync(observer, observable, targetUser);
}
}
private async Task StartCommentsAnalizingAsync(
ApplicationUser observer, ObservableUser observable)
{
Parallel.ForEach(observable.ObservableUsers, targetUser =>
{
StartCommentsAnalizingAsync(observer, observable, targetUser);
});
}
private static List <User> CreateKey(
ApplicationUser observer,
ObservableUser observable,
ObservableUser targetUser)
{
return(new List <User> {
observer, observable, targetUser
});
}
public AnalizationTask(
ApplicationUser observer,
ObservableUser observable,
ObservableUser targetUser)
{
Observer = observer;
Observable = observable;
TargetUser = targetUser;
Tasks = new List <Task>();
CancellationTokenSource = new CancellationTokenSource();
}
public void SelectUserAvatar(ObservableUser observableUser)
{
// var fileDialog = new OpenFileDialog();
// var result = fileDialog.ShowDialog();
//
// if (result == true)
// {
// var file = fileDialog.FileName;
// observableUser.Image = file;
// }
ImagePicker.PickImage(observableUser, nameof(observableUser.Image));
}
public AnalizationTask(
ApplicationUser observer,
ObservableUser observable,
ObservableUser targetUser,
IEnumerable <Task> tasks,
CancellationTokenSource cancellationTokenSource)
{
Observer = observer;
Observable = observable;
TargetUser = targetUser;
Tasks = new List <Task>(tasks);
CancellationTokenSource = cancellationTokenSource;
}
public async Task <ActionResult> AddObservableUser(ObservableUserViewModel observableUser)
{
// The current registered user who uses our application
string primaryKey = System.Web.HttpContext.Current.Session["PrimaryKey"].ToString();
var observer = await _repository.GetAsync <ApplicationUser>(u => u.InstagramPK == primaryKey);
// The user we are going to add to the database
var user = new ObservableUser();
user.Username = observableUser.UserName;
user.InstagramPK = _instaApi.GetPrimaryKeyByUsername(observableUser.UserName);
user.Observers.Add(observer);
// Checking the presence of the user we want to add to the database in the database
var observable = await _repository.GetAsync <ObservableUser>(x => x.InstagramPK == user.InstagramPK);
if (observable != null)
{
// If such a user exists, check the existence of the current user in the list of its observers
if (observable.Observers.Contains(observer))
{
// If such a observer exists, return a message about it.
return(RedirectToAction("Index", new { status = "repeat" }));
}
else
{
/* If such a observer does not exist, add it to the collection of observers,
* update the data in the database and return a message about the successful operation.*/
observable.Observers.Add(observer);
await _repository.UpdateAsync <ObservableUser>(observable);
observer.ObservableAccounts.Add(observable);
await _repository.UpdateAsync <ApplicationUser>(observer);
return(RedirectToAction("Index", new { status = "success" }));
}
}
// Trying to add a new observable user to the database
if (!await _repository.CreateAsync <ObservableUser>(user))
{
return(RedirectToAction("Index", new { status = "bad" }));
}
// Update the data in the database
observer.ObservableAccounts.Add(user);
await _repository.UpdateAsync <ApplicationUser>(observer);
// Return a message about the successful operation
return(RedirectToAction("Index", new { status = "success" }));
}
public async Task <ActionResult> AddObservableAccountForObservableUser(ObservableAccountForObservableUserVM observablePage)
{
// Receive the observable user
var observableUser = new ObservableUser();
observableUser = await _repository.GetAsync <ObservableUser>(x => x.Username == observablePage.observableUserName);
// Checking the presence of the target content we want to add to the database in the database
var page = await _repository.GetAsync <ObservableUser>(x => x.Username == observablePage.TargetContentName);
if (page != null)
{
// If such content exists, check the existence of the observable user in the list of its ActivityInitiators
if (observableUser != null && page.ActivityInitiators.Contains(observableUser))
{
return(RedirectToAction("Index", new { status = "repeat" }));
}
else
{
/* If such observable user does not exist, add it to the collection of ActivityInitiators,
* update the data in the database and return a message about the successful operation.*/
page.ActivityInitiators.Add(observableUser);
await _repository.UpdateAsync <ObservableUser>(page);
observableUser.ObservableUsers.Add(page);
await _repository.UpdateAsync <ObservableUser>(observableUser);
return(RedirectToAction("Index", new { status = "success" }));
}
}
// If such content is not in the database, then we initialize the new content
page = new ObservableUser();
page.InstagramPK = _instaApi.GetPrimaryKeyByUsername(observablePage.TargetContentName);
page.Username = observablePage.TargetContentName;
page.ActivityInitiators.Add(observableUser);
// Trying to add a new content to the database
if (!await _repository.CreateAsync <ObservableUser>(page))
{
return(RedirectToAction("Index", new { status = "bad" }));
}
// Update the data in the database
observableUser.ObservableUsers.Add(page);
await _repository.UpdateAsync <ObservableUser>(observableUser);
// Return a message about the successful operation
return(RedirectToAction("Index", new { status = "success" }));
}
private async Task StartLikesAnalizingAsync(
ApplicationUser observer, ObservableUser observable, ObservableUser targetUser)
{
IInstagramAPI instagramAPI = new InstagramAPI.InstagramAPI();
instagramAPI.SetCookies(observer.StateData);
List <InstagramPost> posts =
await GetProfileStateAsync(instagramAPI, targetUser);
var cancellationTokenSource = new CancellationTokenSource();
Task likesAnalizingTask = Task.Run(
() =>
{
List <InstagramPost> newPostsState = new List <InstagramPost>();
do
{
newPostsState =
instagramAPI.GetUserPostsByPrimaryKey(targetUser.InstagramPK);
if (AreDifferencesPresent(posts, newPostsState))
{
var postsWithDifference = GetDistinctivePosts(posts, newPostsState);
foreach (var distinctivePost in postsWithDifference)
{
CheckForUserLike(observer, observable, targetUser, distinctivePost.Key, distinctivePost.Value);
}
}
posts = newPostsState;
try
{
Sleep(SLEEP_TIMEOUT, cancellationTokenSource.Token);
}
catch (OperationCanceledException ex)
{
break;
}
} while (!cancellationTokenSource.Token.IsCancellationRequested);
SaveProfileStateAsync(targetUser, newPostsState);
});
TryAddToTasks(observer, observable, targetUser, likesAnalizingTask, cancellationTokenSource);
}
private void CheckForUserComment(ApplicationUser observer, ObservableUser observable, User postOwner, InstagramPost firstPostState, InstagramPost secondPostState)
{
if (!firstPostState.Commenters.Contains(observable) &&
secondPostState.Commenters.Contains(observable))
{
var activity = new UserActivity();
activity.ObserverPrimaryKey = observer.InstagramPK;
activity.InitiatorPrimaryKey = observable.InstagramPK;
activity.TargetUserPrimaryKey = postOwner.InstagramPK;
activity.LinkToMedia = firstPostState.MediaFileUri;
activity.EventDate = DateTime.Now;
activity.ActivityType = UserActivityType.Comment;
_commentCreated?.Invoke(null, activity);
}
}
public AnalizationTask(
ApplicationUser observer,
ObservableUser observable,
ObservableUser targetUser,
Task task,
CancellationTokenSource cancellationTokenSource)
{
Observer = observer;
Observable = observable;
TargetUser = targetUser;
Tasks = new List <Task> {
task
};
CancellationTokenSource = cancellationTokenSource;
}
private async Task SaveProfileStateAsync(ObservableUser profileOwner, List <InstagramPost> posts)
{
var profile = await _repository.GetAsync <UserProfile>(p => p.Owner.Equals(profileOwner));
if (profile != null) // Profile state already exists in DB.
{
posts = profile.Posts;
_repository.UpdateAsync(profile);
}
else // We have to create new record in DB.
{
profile = new UserProfile
{
Owner = profileOwner,
Posts = posts
};
_repository.CreateAsync(profile);
}
}
private void TryAddToTasks(
ApplicationUser observer,
ObservableUser observable,
ObservableUser targetUser,
Task task,
CancellationTokenSource cancellationTokenSource)
{
var analizationTask = _tasks.Where(at => at.Observer.Equals(observer) &&
at.Observable.Equals(observable) &&
at.TargetUser.Equals(targetUser)).FirstOrDefault();
if (analizationTask == null) // Task not created yet.
{
var newAnalizationTask =
new AnalizationTask(observer, observable, targetUser, task, cancellationTokenSource);
_tasks.Add(newAnalizationTask);
}
analizationTask.AddTask(task);
}
private List <ObservableUser> GetPostLikers(InstaMedia media)
{
var likers = new List <ObservableUser>();
Task <IResult <InstaLikersList> > likersListTask =
Task.Run(() =>
_instaApi.MediaProcessor.GetMediaLikersAsync(media.Pk));
likersListTask.Wait();
IResult <InstaLikersList> likersList = likersListTask.Result;
foreach (var liker in likersList.Value)
{
var newUser = new ObservableUser();
newUser.InstagramPK = liker.Pk.ToString();
newUser.Username = liker.UserName;
likers.Add(newUser);
}
return(likers);
}
private List <ObservableUser> GetPostCommenters(InstaMedia media)
{
var commenters = new List <ObservableUser>();
Task <IResult <InstaCommentList> > commentsListTask =
Task.Run(() =>
_instaApi.CommentProcessor.GetMediaCommentsAsync(media.Pk, PaginationParameters.MaxPagesToLoad(MAX_PAGES_TO_LOAD)));
commentsListTask.Wait();
IResult <InstaCommentList> commentsList = commentsListTask.Result;
foreach (var comment in commentsList.Value.Comments)
{
var newUser = new ObservableUser();
newUser.InstagramPK = comment.User.Pk.ToString();
newUser.Username = comment.User.UserName;
commenters.Add(newUser);
}
return(commenters);
}
private void DeleteUser(ObservableUser obj)
{
_observableUsers.Remove(obj);
_users.Remove(obj.Source);
}
public void SelectUser(ObservableUser observableUser)
{
PulsesOverviewVM.Instance.ObservableUser = observableUser;
MainWindowVM.Navigate(typeof(PulsesOverview));
}
public async Task StartObservationAsync(ApplicationUser observer, ObservableUser observable, ObservableUser targetUser)
{
StartLikesAnalizingAsync(observer, observable, targetUser);
StartCommentsAnalizingAsync(observer, observable, targetUser);
}
public async Task RemoveTargetUserFromObservationAsync(ApplicationUser observer, ObservableUser observable, User targetUser)
{
var aTask = _tasks.Where(at => at.Observer.Equals(observer) &&
at.Observable.Equals(observable) &&
at.TargetUser.Equals(targetUser)).FirstOrDefault();
if (aTask == null) // User is not under observation.
{
return;
}
aTask.CancellationTokenSource.Cancel();
foreach (var task in aTask.Tasks)
{
task.Wait();
}
_tasks.Remove(aTask);
}
