public async Task <IActionResult> GetPosts([FromQuery] PostParams postParams)
{
var userClaim = User.FindFirst(ClaimTypes.NameIdentifier);
if (userClaim != null)
{
var userId = int.Parse(userClaim.Value);
postParams.UserId = userId;
}
// var currentUserId = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value);
// var userFromRepo = await _repo.GetUser(currentUserId);
// postParams.UserId = currentUserId;
// if(string.IsNullOrEmpty(userParams.Gender)){
// userParams.Gender = userFromRepo.Gender == "male"? "female" : "male";
// }
var posts = await _repo.GetPosts(postParams);
var postsToReturn = _mapper.Map <IEnumerable <PostForListDto> >(posts);
Response.AddPagination(posts.CurrentPage, posts.PageSize,
posts.TotalCount, posts.TotalPages);
return(Ok(postsToReturn));
}
private async void HandlePostParams(PostParams postParams)
{
var poemLines = postParams.Poem.Split('\n');
await SendMessage(ConfigurationManager.AppSettings["VowelCalcQueueName"], postParams.UserId, postParams.CorrId, poemLines);
await SendMessage(ConfigurationManager.AppSettings["PoemStatsQueueName"], postParams.UserId, postParams.CorrId, poemLines);
}
/// <summary>
/// Compare request
/// </summary>
/// <param name="obj">object to compare to</param>
/// <returns>true if requests are equal; false otherwise</returns>
public override bool Equals(object obj)
{
if (obj == null)
{
return(false);
}
if (ReferenceEquals(this, obj))
{
return(true);
}
if (obj.GetType() != typeof(Request))
{
return(false);
}
var other = (Request)obj;
return(Method.Equals(other.Method) &&
buildUri().Equals(other.buildUri()) &&
QueryParams.All(other.QueryParams.Contains) &&
other.QueryParams.All(QueryParams.Contains) &&
PostParams.All(other.PostParams.Contains) &&
other.PostParams.All(PostParams.Contains) &&
HeaderParams.All(other.HeaderParams.Contains) &&
other.HeaderParams.All(HeaderParams.Contains));
}
// --> Qui inseriremo variabili e costanti del progetto
#endregion
#region cBot Events
protected override void OnStart()
{
// --> Stampo nei log la versione corrente
Print("{0} : {1}", NAME, VERSION);
// --> Controllo se i valori sono coerenti
Webhook = Webhook.Trim();
if (Webhook.Length < 1)
{
MessageBox.Show("Wrong 'Webhook', es. 'https://api.telegram.org/bot[ YOUR TOKEN ]/sendMessage'", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
Stop();
}
Message = Message.Trim();
if (Message.Length < 1)
{
MessageBox.Show("Wrong 'Message', es. '#{0} opened {1} position at {2} for {3} lots'", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
Stop();
}
PostParams = PostParams.Trim();
if (PostParams.IndexOf("{0}") < 0)
{
MessageBox.Show("Wrong 'POST params', es. 'chat_id=[ @CHATID ]&text={0}'", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
Stop();
}
// --> Registro il callback per condividere le operazioni
Positions.Opened += OnPositionOpened;
}
public async Task <IActionResult> GetUserLikedPosts(int userId, [FromQuery] PostParams postParams)
{
if (userId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
postParams.UserId = userId;
// if(string.IsNullOrEmpty(userParams.Gender)){
// userParams.Gender = userFromRepo.Gender == "male"? "female" : "male";
// }
var posts = await _repo.GetPosts(postParams);
// var postsToReturn = _mapper.Map<PagedList<Post>, List<LikedPostDto>>(posts);
var postsToReturn = _mapper.Map <PagedList <Post>, List <LikedPostDto> >(posts,
opt => opt.AfterMap((src, dest) =>
{
for (int i = 0; i < dest.Count(); i++)
{
var newPost = dest[i];
var oldPost = src[i];
newPost.LikedTime = oldPost.Likers.FirstOrDefault(l => l.LikerId == userId).Created;
}
})
);
Response.AddPagination(posts.CurrentPage, posts.PageSize,
posts.TotalCount, posts.TotalPages);
return(Ok(postsToReturn));
}
private static XmlDocument Request(String operation, PostParams par)
{
var url = Config.Orbcomm.WebGatewayUrl + operation;
var encoding = new ASCIIEncoding();
var data = encoding.GetBytes(par.Serialize());
var req = (HttpWebRequest)WebRequest.Create(url);
req.Method = "POST";
req.ContentType = "application/x-www-form-urlencoded";
req.ContentLength = data.Length;
try
{
var postStream = req.GetRequestStream();
postStream.Write(data, 0, data.Length);
postStream.Close();
var response = (HttpWebResponse)req.GetResponse();
var responseStream = new StreamReader(response.GetResponseStream(), Encoding.UTF8);
var xml = new XmlDocument();
xml.Load(responseStream);
response.Close();
return(xml);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public Refresh Refresh(String sessionId)
{
const String op = "Refresh";
var par = PostParams.Create().Add("SESSION_ID", sessionId);
var res = Request(op, par);
return(new Refresh(res.DocumentElement));
}
public Logout Logout(String sessionId)
{
const String op = "Logout";
var par = PostParams.Create().Add("SESSION_ID", sessionId);
var res = Request(op, par);
return(new Logout(res.DocumentElement));
}
public async Task <ActionResult <IEnumerable <UserPost> > > GetPosts([FromQuery] PostParams postParams)
{
var posts = await _unitOfWork.PostsRepository.GetPostsAsync(postParams);
var returnPosts = _mapper.Map <PostDto[]>(posts);
Response.AddPaginationHeader(posts.CurrentPage, posts.PageSize, posts.TotalCount, posts.TotalPages);
return(Ok(returnPosts));
}
public async Task <PagedList <Post> > GetUserPosts(PostParams postParams)
{
var posts = _context.Posts
.Where(x => x.UserId == postParams.SenderId)
.OrderByDescending(x => x.DateOfCreation)
.Include(x => x.User);
return(await PagedList <Post> .CreateAsync(posts, postParams.PageNumber));
}
public async Task <IActionResult> Post(PostParams postParams)
{
var id = Guid.NewGuid();
await mediator.Send(
new StoreChainCreateCommand(id, postParams.Name));
return(Ok(id));
}
public async Task <IActionResult> Post([FromBody] PostParams postParams)
{
var id = Guid.NewGuid();
await mediator.Send(
new ProductCreateCommand(id, postParams.Name, postParams.PhotoUrl));
return(Ok(id));
}
public QueryDeviceStatus QueryDeviceStatus(String sessionId, String deviceId)
{
const String op = "QueryDeviceStatus";
var par = PostParams.Create().Add("SESSION_ID", sessionId)
.Add("DEVICE_ID", deviceId)
.Add("VERSION", "2");
var res = Request(op, par);
return(new QueryDeviceStatus(res.DocumentElement));
}
public DeleteMessage DeleteMessage(String sessionId, String confNum)
{
const String op = "DeleteMessage";
var par = PostParams.Create().Add("SESSION_ID", sessionId)
.Add("CONF_NUM", confNum)
.Add("VERSION", "2");
var res = Request(op, par);
return(new DeleteMessage(res.DocumentElement));
}
public Authenticate Authenticate(string user, string password)
{
const string op = "Authenticate";
var par = PostParams.Create().Add("LOGIN", user)
.Add("PSSWD", password)
.Add("VERSION", "2");
var res = Request(op, par);
return(new Authenticate(res.DocumentElement));
}
public async Task <IActionResult> GetPosts([FromQuery] PostParams postParams)
{
var posts = await _repo.GetPosts(postParams);
var postsToReturn = _mapper.Map <IEnumerable <PostsToReturn> >(posts);
Response.AddPagination(posts.CurrentPage, posts.PageSize,
posts.TotalCount, posts.TotalPages);
return(Ok(postsToReturn));
}
public async Task <IActionResult> GetUserProfile([FromQuery] PostParams postParams)
{
var userFromRepo = await _repo.GetUser(postParams.SenderId);
if (userFromRepo == null)
{
return(BadRequest("User don't exist"));
}
var userToReturn = _mapper.Map <UserDetailedDto>(userFromRepo);
var senderId = int.Parse(this.User.FindFirst(ClaimTypes.NameIdentifier).Value);
var status = await _repo.GetFriendshipStatus(userFromRepo.Id, senderId);
var statusReversed = await _repo.GetFriendshipStatus(senderId, userFromRepo.Id);
var jsonFormatter = new JsonSerializerSettings();
jsonFormatter.ContractResolver = new CamelCasePropertyNamesContractResolver();
jsonFormatter.Formatting = Formatting.Indented;
if ((status == 1 || status == 4) || (statusReversed == 1 || statusReversed == 4))
{
var postsFromRepo = await _repo.GetUserPosts(postParams);
var mappedPosts = _mapper.Map <PostDto[]>(postsFromRepo);
Response.AddPagination(postsFromRepo.CurrentPage,
postsFromRepo.PageSize,
postsFromRepo.TotalCount,
postsFromRepo.TotalPages);
var objectToReturn = new {
posts = mappedPosts,
user = userToReturn,
};
var response = JsonConvert.SerializeObject(objectToReturn, jsonFormatter);
return(Ok(response));
}
else
{
var objectToReturn = new {
posts = new {},
user = userToReturn,
};
var response = JsonConvert.SerializeObject(objectToReturn, jsonFormatter);
return(Ok(response));
}
}
public async Task <IActionResult> Post(PostParams postParams)
{
var id = Guid.NewGuid();
await mediator.Send(
new StoreCreateCommand(
id, postParams.StoreChainId, postParams.Name,
postParams.Latitude, postParams.Longitude, postParams.Address));
return(Ok(id));
}
public QueryMessageStatus QueryMessageStatus(String sessionId, String confNum)
{
const String op = "QueryMessageStatus";
var par = PostParams.Create().Add("SESSION_ID", sessionId)
.Add("CONF_NUM", confNum)
.Add("MESSAGE", "1")
.Add("VERSION", "2");
var res = Request(op, par);
return(new QueryMessageStatus(res.DocumentElement));
}
/// <summary>
/// Generate hash code for request
/// </summary>
/// <returns>generated hash code</returns>
public override int GetHashCode()
{
unchecked
{
return((Method?.GetHashCode() ?? 0) ^
(buildUri()?.GetHashCode() ?? 0) ^
(QueryParams?.GetHashCode() ?? 0) ^
(PostParams?.GetHashCode() ?? 0) ^
(HeaderParams?.GetHashCode() ?? 0));
}
}
public static SetMessageFlag SetMessageFlag(String sessionId, int select, String criteria, int setMessageFlag)
{
const String op = "SetMessageFlag";
var par = PostParams.Create().Add("SESSION_ID", sessionId)
.Add("SELECT", select.ToString(CultureInfo.InvariantCulture))
.Add("CRITERIA", criteria)
.Add("FLAG", setMessageFlag.ToString(CultureInfo.InvariantCulture));
var res = Request(op, par);
return(new SetMessageFlag(res.DocumentElement));
}
public ActionResult getPostsPaging([FromQuery] PostParams postParams)
{
var posts = _postContext.getPostsPaging(postParams);
if (posts.Items == null)
{
return(BadRequest("there are no posts to view"));
}
Response.AddApplicationPagination(posts.PageSize, posts.PageNumber, posts.totalPages, posts.count);
return(Ok(posts.Items));
}
public async Task <PagedList <Post> > GetUserDashboard(PostParams postParams)
{
var posts = _context.Posts
.Where(x => x.User.FriendsRecieved
.Any(y => y.RequestorId == postParams.SenderId && y.Status == 1) ||
x.User.FriendsRequested
.Any(y => y.RecieverId == postParams.SenderId && y.Status == 1))
.OrderByDescending(x => x.DateOfCreation)
.Include(x => x.User);
return(await PagedList <Post> .CreateAsync(posts, postParams.PageNumber, postParams.PageSize));
}
public SendMessage SendMessage(String sessionId, String deviceId, String subject, String body, bool bodyBinary)
{
const String op = "SendMessage";
var par = PostParams.Create().Add("SESSION_ID", sessionId)
.Add("DEVICE_ID", deviceId)
.Add("NETWORK_ID", "3")
.Add("MESSAGE_SUBJECT", subject)
.Add("MESSAGE_BODY_TYPE", bodyBinary ? "1" : "0")
.Add("MESSAGE_BODY", body)
.Add("SEND_TIME", "************");
var res = Request(op, par);
return(new SendMessage(res.DocumentElement));
}
public PageList <Post> getPostsByTopUserCategorie(PostParams postParams)
{
List <Post> posts = _dataContext.posts.OrderByDescending(x => x.date.Date).Include(x => x.reactionSet).Include(p => p.Author.user).Include(p => p.Author).Include(p => p.Categorie).ToList();
List <Post> postsByTopUserCategorie = new List <Post>();
PageList <Post> pageList = new PageList <Post>();
List <CategorieJoin> userCategories = new List <CategorieJoin>();
userCategories = this._dataContext.categorieJoins.Where(x => x.userId == postParams.userId).ToList();
foreach (var post in posts)
{
if (userCategories.Where(x => x.categorieId == post.categorieId).Any())
{
postsByTopUserCategorie.Add(post);
}
}
posts = postsByTopUserCategorie;
if (postParams.sortBy == "" || postParams.sortBy == null)
{
posts = _dataContext.posts.Include(x => x.reactionSet).Include(p => p.Author.user).Include(p => p.Author).Include(p => p.Categorie).ToList();
}
else if (postParams.sortBy == "Top")
{
Post[] ppp = posts.ToArray();
for (int i = 0; i < ppp.Length; i++)
{
for (int j = 0; j < ppp.Length; j++)
{
if (ppp[i].reactionSet != null)
{
if (ppp[i].reactionSet.ToArray().Length > ppp[j].reactionSet.ToArray().Length&&(ppp[i].date >= ppp[j].date))
{
var temp = ppp[i];
ppp[i] = ppp[j];
ppp[j] = temp;
}
}
}
}
posts = ppp.ToList();
}
else if (postParams.sortBy == "New")
{
posts = _dataContext.posts.OrderByDescending(x => x.date.Date).Include(p => p.Author.user).Include(p => p.Author).Include(p => p.Categorie).ToList();
}
pageList.addCreationAsync(posts.AsQueryable(), postParams.pageNumber, postParams.pageSize, postParams.sortBy);
return(pageList);
}
// POST: Add a new Author
public IHttpActionResult Post(PostParams param)
{
var newAuthor = new Author
{
Name = param.AuthorName,
Born = param.AuthorBorn,
Died = param.AuthorDied
};
var db = new LibraryContext();
db.Authors.Add(newAuthor);
db.SaveChanges();
return(Ok(newAuthor));
}
public RetrieveMessages RetrieveMessages(String sessionId, int messageFlag, int setMessageFlag, int messageStatusFlag, int messageId, bool returnMessageBody)
{
const String op = "RetrieveMessages";
var par = PostParams.Create().Add("SESSION_ID", sessionId)
.Add("NETWORK_ID", "3")
.Add("MSG_FLAG", messageFlag.ToString(CultureInfo.InvariantCulture))
.Add("SET_FLAG", setMessageFlag.ToString(CultureInfo.InvariantCulture))
.Add("MSG_STATUS", messageStatusFlag.ToString(CultureInfo.InvariantCulture))
.Add("MESSAGE_ID", messageId.ToString(CultureInfo.InvariantCulture))
.Add("MESSAGE", returnMessageBody ? "1" : "0")
.Add("MTAG", "1")
.Add("VERSION", "2");
var res = Request(op, par);
return(new RetrieveMessages(res.DocumentElement));
}
public async Task <PagedList <Post> > GetPosts(PostParams postParams)
{
var posts = _context.Posts
.OrderByDescending(u => u.CreatedAt).AsQueryable();
if (postParams.Provider != null)
{
posts = posts.Where(p => p.Provider.Name == postParams.Provider);
}
if (postParams.Category != null)
{
posts = posts.Where(p => p.Category.Name == postParams.Category);
}
return(await PagedList <Post> .CreateAsync(posts, postParams.PageNumber, postParams.PageSize));
}
public async Task <IActionResult> GetUserPosts(int userId, [FromQuery] PostParams postParams)
{
var userRequesting = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value);
// if(userId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
// return Unauthorized();
postParams.UserId = userId;
var posts = await _repo.GetPosts(postParams);
var postsToReturn = _mapper.Map <IEnumerable <PostForListDto> >(posts);
Response.AddPagination(posts.CurrentPage, posts.PageSize,
posts.TotalCount, posts.TotalPages);
return(Ok(postsToReturn));
}
public async Task <IActionResult> GetPosts([FromQuery] PostParams postParams)
{
//Console.WriteLine("accepting all");
//Console.WriteLine("in post get");
//Console.WriteLine(postParams.PageNumber.ToString(),postParams.PageSize.ToString());
//var pipeline = new MarkdownPipelineBuilder().UseAdvancedExtensions().ConfigureNewLine("\r\n").Build();
var posts = await this.postRepository.Get(postParams);
var pipeline = new MarkdownPipelineBuilder().UseAdvancedExtensions().ConfigureNewLine("\r\n").Build();
posts.postsTobeListed.ForEach(delegate(Post post){
post.Content = MarkdownStrip.HtmlToPlainText(Markdown.ToHtml(post.Content, pipeline)).TrimStart().Substring(0, 50);
});
Response.AddPagination(posts.CurrentPage, posts.PageSize, Convert.ToInt32(posts.TotalCount), posts.TotalPages);
return(Ok(posts.postsTobeListed));
}
