public IHttpActionResult FollowSubject([FromUri] string AccessToken, [FromUri] int SubjectId)
{
var UserId = TokenValidator.VerifyToken(AccessToken);
var Subject = SQLContext.Subjects.Find(SubjectId);
if (Subject == null)
{
return(NotFound());
}
var AlreadyExists = UserAuxiliar.FollowedSubjects(UserId, SQLContext).Contains(Subject);
if (AlreadyExists)
{
return(Ok("Already Exists"));
}
var UserInterest = new UserSubject()
{
UserId = UserId,
SubjectId = SubjectId
};
SQLContext.UserSubjects.Add(UserInterest);
SQLContext.SaveChanges();
return(Ok(UserInterest));
}
public IHttpActionResult RecommendedPosts([FromUri] string AccessToken)
{
var UserId = TokenValidator.VerifyToken(AccessToken);
var UserFollows = UserAuxiliar
.Follows(UserId, SQLContext)
.Select(x => x.Id);
var UserTopics = UserAuxiliar.FollowedSubjects(UserId, SQLContext);
var UserPosts = PostAuxiliar.PostsByAuthor(UserId);
var UserMentionPosts = PostAuxiliar.MentionsUser(UserId, SQLContext);
var FollowsPosts = PostAuxiliar.PostsByAuthors(UserFollows);
var FollowsMentionPosts = PostAuxiliar.MentionsUsers(UserFollows);
var TopicsPosts = PostAuxiliar.PostsBySubjects(UserTopics.Select(x => x.Id));
var PostComparer = new PostComparer();
var RecommendedPosts = UserPosts
.Union(UserMentionPosts, PostComparer)
.Union(FollowsPosts, PostComparer)
.Union(FollowsMentionPosts, PostComparer)
.Union(TopicsPosts, PostComparer)
.ToList();
RecommendedPosts = PostAuxiliar.UpdateOwner(RecommendedPosts, SQLContext);
RecommendedPosts = GraphAuxiliar.OrderPostsByAffinity(UserId, RecommendedPosts, SQLContext);
return(Ok(RecommendedPosts));
}
public IHttpActionResult FollowedSubjects([FromUri] string AccessToken)
{
var UserId = TokenValidator.VerifyToken(AccessToken);
var Subjects = UserAuxiliar.FollowedSubjects(UserId, SQLContext);
return(Ok(Subjects));
}
public IHttpActionResult ProductsByPro(int ProId)
{
var User = SQLContext.Users.Find(ProId);
if (User == null || !User.IsPro)
{
return(NotFound());
}
return(Ok(UserAuxiliar.Products(ProId, SQLContext)));
}
//TA MT FEIO HORROROSO DESCULPA
private static List <dynamic> CreateAffinityProducts(int UserId, List <Product> Products, SQLContext SQLContext)
{
var ProductRecommendation = new List <dynamic>();
var TaskArray = new List <Task>();
foreach (var Product in Products)
{
var NewTask = Task.Run
(
() =>
{
double OwnerAffinity = 0;
double SubjectAffinity = 0;
double FollowsAffinity = 0;
var OwnerId = Product.ProId;
IEnumerable <int> SubjectsFollowedByOwner;
IEnumerable <int> UsersFollowedByOwner;
IEnumerable <int> OwnerFollowers;
lock (SQLContext)
{
SubjectsFollowedByOwner = UserAuxiliar.FollowedSubjects((int)OwnerId, SQLContext).Select(x => x.Id);
UsersFollowedByOwner = UserAuxiliar.Follows((int)OwnerId, SQLContext).Select(x => x.Id);
OwnerFollowers = UserAuxiliar.Followers((int)OwnerId, SQLContext).Select(x => x.Id);
}
var Follows = UsersFollowedByOwner.Union(OwnerFollowers);
Follow OwnerFollow;
lock (SQLContext)
{
OwnerFollow = SQLContext.Follows.FirstOrDefault(x => x.FollowerId == UserId && x.FollowedId == OwnerId);
}
if (OwnerFollow != default)
{
OwnerAffinity += OwnerFollow.Affinity;
}
int RawSubjectAffinity = 0;
lock (SQLContext)
{
var SameSubjects = SQLContext.UserSubjects.Where(x => x.UserId == UserId && SubjectsFollowedByOwner.Contains(x.SubjectId));
if (SameSubjects.Any())
{
RawSubjectAffinity = SameSubjects.Sum(x => x.Affinity);
}
}
if (SubjectsFollowedByOwner.Any())
{
SubjectAffinity = RawSubjectAffinity / SubjectsFollowedByOwner.Count();
}
IQueryable <Follow> EqualFollows;
lock (SQLContext)
{
EqualFollows = SQLContext.Follows.Where(x => Follows.Contains(x.FollowedId) && x.FollowerId == UserId);
if (EqualFollows.Any())
{
FollowsAffinity = EqualFollows.Sum(x => x.Affinity) / EqualFollows.Count();
}
}
if (OwnerAffinity != 0 || FollowsAffinity != 0 || SubjectAffinity != 0)
{
ProductRecommendation.Add(new { Product, OwnerAffinity, SubjectAffinity, FollowsAffinity });
}
}
);
TaskArray.Add(NewTask);
}
Task.WaitAll(TaskArray.ToArray());
return(ProductRecommendation);
}
public IHttpActionResult AddProductToCart([FromUri] string AccessToken, [FromBody] ProductInfo ProductInfo)
{
var UserId = TokenValidator.VerifyToken(AccessToken);
var Cart = UserAuxiliar.StoreCart(UserId, ProductInfo.ProId, SQLContext);
if (Cart == default || Cart.Finished)
{
var NewCart = new Cart()
{
ProId = ProductInfo.ProId,
UserId = UserId,
Finished = false
};
SQLContext.Carts.Add(NewCart);
SQLContext.SaveChanges();
try
{
var ProductCart = new ProductCart()
{
ProductId = ProductInfo.ProductId,
CartId = NewCart.Id,
Amount = ProductInfo.Amount
};
SQLContext.ProductCarts.Add(ProductCart);
SQLContext.SaveChanges();
}catch(DbUpdateException)
{
return Content(HttpStatusCode.Forbidden, new { Message = "Estoque insuficente!" });
}
var Product = SQLContext.Products.Find(ProductInfo.ProductId);
return Ok(new { Cart = NewCart, Product = FilterProduct(Product) });
}
var AlreadyExists = SQLContext.ProductCarts.FirstOrDefault(x => x.CartId == Cart.Id
&& x.ProductId == ProductInfo.ProductId
&& !x.Cart.Finished);
if(AlreadyExists != default)
{
try
{
AlreadyExists.Amount += ProductInfo.Amount;
SQLContext.Entry(AlreadyExists).State = EntityState.Modified;
SQLContext.SaveChanges();
return Ok(new { Cart, Product = FilterProduct(AlreadyExists.Product) });
}catch(DbUpdateException)
{
return Content(HttpStatusCode.Forbidden, new { Message = "Estoque insuficente!" });
}
}
try
{
var NewProductCart = new ProductCart()
{
ProductId = ProductInfo.ProductId,
CartId = Cart.Id,
Amount = ProductInfo.Amount
};
SQLContext.ProductCarts.Add(NewProductCart);
SQLContext.SaveChanges();
return Ok(new { Cart, Product = FilterProduct(NewProductCart.Product)});
}
catch (DbUpdateException)
{
return Content(HttpStatusCode.Forbidden, new { Message = "Estoque insuficente!" });
}
}
