public IActionResult CreatePost([FromBody] PostPayload payload)
{
String[] authorization = Request.Headers["authorization"].ToString().Split(" ");
var token = authorization[1];
var id = ((JwtSecurityToken) new JwtSecurityTokenHandler().ReadToken(token)).Claims.First(claim => claim.Type == "id").Value;
try
{
var newPost = new Post
{
Title = payload.Title,
Text = payload.Text,
ImgUrl = payload.ImgUrl,
Date = DateTime.Now,
UserId = Int32.Parse(id)
};
_db.Posts.Add(newPost);
_db.SaveChanges();
return(Ok(new { message = "success" }));
}
catch (Exception ex)
{
return(StatusCode(500, $"Internal server error {ex}"));
}
}
public IActionResult PostSomething(PostPayload postPayload)
{
return(Ok(new {
RequestPayload = postPayload,
Claims = User.Claims.Select(c => new {
c.Type, c.Value
})
}));
}
public async Task <IActionResult> addpost([FromBody] PostPayload postPayload)
{
var post = new Post();
post.UserName = postPayload.UserName;
post.imageLink = postPayload.imgLink;
post.text = postPayload.text;
_db.Posts.Add(post);
_db.SaveChanges();
return(Ok(new { status = true }));
}
public async Task <ActionResult <SucceedInfomation> > createpostcontent([FromForm] PostPayload postpayload)
{
SucceedInfomation succeedinformation = new SucceedInfomation();
post Newpost = new post()
{
posttitle = postpayload.posttitle
};
if (postpayload.imgfile == null || postpayload.posttitle.Length < 3)
{
succeedinformation.Issucceed = false;
succeedinformation.SucceedDetail = "Please complete the form";
return(Ok(succeedinformation));
}
if (postpayload.imgfile.FileName.EndsWith(".jpg"))
{
Newpost.titleimgurl = await _imgservice.SaveFileJpg(postpayload.imgfile);
}
else if (postpayload.imgfile.FileName.EndsWith(".png"))
{
Newpost.titleimgurl = await _imgservice.SaveFilePng(postpayload.imgfile);
}
// else if(postpayload.imgfile.Length == 0)
// {
// succeedinformation.Issucceed = false;
// succeedinformation.SucceedDetail = "file format invalide , pls use jpg or png";
// return Ok(succeedinformation);
// }
content Newcontent = new content()
{
contentdetail = postpayload.contentdetail
};
_Context.posts.Add(Newpost);
_Context.contents.Add(Newcontent);
_Context.SaveChanges();
var Newposcontent = new postcontent()
{
postid = Newpost.postid,
contentid = Newcontent.contentid,
userid = postpayload.userid,
categoryid = postpayload.categoryid,
postcontentcreated = DateTime.UtcNow
};
_Context.postcontents.Add(Newposcontent);
_Context.SaveChanges();
return(succeedinformation);
}
public async Task <IActionResult> RunAsyncToken([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = "directlinetoken")] HttpRequest req, ILogger log)
{
log.LogInformation("Enttering RunAsyncToken");
var pp = new PostPayload()
{
user = new User()
{
id = "dl_" + Guid.NewGuid().ToString(),
name = "You"
}
};
HttpRequestMessage request = new HttpRequestMessage(
HttpMethod.Post,
Environment.GetEnvironmentVariable("DirectLineConversationEndpoint"));
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer",
Environment.GetEnvironmentVariable("DirectLineSecret"));
//
request.Content = new StringContent(JsonConvert.SerializeObject(pp), Encoding.UTF8, "application/json");
var response = await htc.SendAsync(request);
var cnt = await response.Content.ReadAsStringAsync();
if (response.IsSuccessStatusCode)
{
string token = JsonConvert.DeserializeObject <DirectLineToken>(cnt).token;
var config = new ChatConfig()
{
Token = token, UserId = pp.user.id
};
return((IActionResult) new OkObjectResult(config));
}
else
{
throw new Exception("");
}
}
public ActionResult <Post> Create([FromBody] PostPayload payload)
{
try
{
var postToAdd = new Post
{
Author = payload.Author,
BodyPost = payload.BodyPost,
LikesNum = payload.LikesNum
};
_db.Posts.Add(postToAdd);
_db.SaveChanges();
return(Ok(postToAdd));
}
catch (Exception)
{
return(new StatusCodeResult(StatusCodes.Status500InternalServerError));
}
}
public IActionResult UploadToWorkspace(PostPayload upload)
{
if (!SetVersion <T> .CanModify())
{
throw new AuthenticationException("User is not a Set Version Operator.");
}
var formFile = upload.file;
try
{
var size = formFile.Length;
var filePaths = new List <string>();
if (formFile.Length <= 0)
{
return(null);
}
// full path to file in temp location
var filePath = Path.GetTempFileName();
filePaths.Add(filePath);
var str = new StreamReader(formFile.OpenReadStream()).ReadToEnd();
var packageModel = str.FromJson <SetVersion <T> .Payload>();
var objs = packageModel.Items.ToJson().FromJson <List <T> >();
Data <T> .RemoveAll();
Data <T> .Save(objs, null, true);
Data <T> .New().AfterSetUpdate();
return(Ok(new { size, filePaths }));
} catch (Exception e)
{
Log.Add(e);
throw;
}
}
public ActionResult <Post> Update([FromBody] PostPayload payload)
{
try
{
if (payload.Id.HasValue)
{
var postToBeUpdated = _db.Posts.Single(post => payload.Id.Value == post.Id);
postToBeUpdated.Author = payload.Author;
postToBeUpdated.BodyPost = payload.BodyPost;
postToBeUpdated.LikesNum = payload.LikesNum;
_db.SaveChanges();
return(Ok(postToBeUpdated));
}
else
{
return(new StatusCodeResult(StatusCodes.Status400BadRequest));
}
}
catch (Exception)
{
return(new StatusCodeResult(StatusCodes.Status500InternalServerError));
}
}
public IHttpActionResult Post(PostPayload postPayload)
{
var authenticatedUser = User as ClaimsPrincipal;
if (authenticatedUser == null)
{
return(Unauthorized());
}
if (!authenticatedUser.Identity.IsAuthenticated)
{
return(Unauthorized());
}
return(Ok(new {
RequestPayload = postPayload,
Claims = authenticatedUser.Claims
.Select(c => new {
c.Type, c.Value
})
.ToList()
}
));
}
public ActionResult <Post> AddPost([FromBody] PostPayload payload)
{
var token = HttpContext.Request.Headers["token"].ToString();
var validation = ValidateJwtToken(token);
if (validation != null)
{
if (payload.UserId != validation)
{
return(new StatusCodeResult(StatusCodes.Status401Unauthorized));
}
try
{
var postToAdd = new Post
{
Title = payload.Title,
Text = payload.Text,
Username = payload.Username,
UserId = payload.UserId,
ImgUrl = payload.ImgUrl,
};
_db.Posts.Add(postToAdd);
_db.SaveChanges();
return(Ok(postToAdd));
}
catch (Exception)
{
return(new StatusCodeResult(StatusCodes.Status500InternalServerError));
}
}
else
{
return(new StatusCodeResult(StatusCodes.Status401Unauthorized));
}
}
private MattermostMessage PostCreated(PostPayload payload)
{
var p = payload.post;
if (_config.IgnoredTopicTitles.Contains(p.topic_title))
{
throw new WarningException("Post title matches an ignored title");
}
if (_config.IgnorePrivateMessages)
{
//We're not really doing anything here yet
//TODO: Revisit in the future
try
{
JObject.Parse(
new WebClient().DownloadString($"{_discourseUrl}/t/{p.topic_id}.json"));
}
catch
{
throw new WarningException("Unable to retrieve topic, possibly a PM so we should ignore this.");
}
}
if (p.cooked == "")
{
throw new WarningException("Body empty, nothing to post.");
}
var retVal = new MattermostMessage
{
Channel = _config.MattermostConfig.Channel,
IconUrl = new Uri(_config.MattermostConfig.IconUrl),
Username = _config.MattermostConfig.Username,
Attachments = new List <MattermostAttachment>
{
new MattermostAttachment
{
Fallback = "New Post in Discourse Topic",
Title = p.topic_title,
TitleLink = new Uri($"{_discourseUrl}/t/{p.topic_id}/{p.post_number}"),
Text = new Converter().Convert(ExpandDiscourseUrls(p.cooked, _discourseUrl)),
AuthorName = p.username,
AuthorLink = new Uri($"{_discourseUrl}/u/{p.username}"),
AuthorIcon = new Uri($"{_discourseUrl}{p.avatar_template.Replace("{size}","16")}")
}
}
};
if (p.post_number.ToString() == "1")
{
retVal.Text = "#NewTopic\n";
}
retVal.Text += $"#{p.topic_slug}";
return(retVal);
}
//[ValidateAntiForgeryToken]
public ActionResult <IEnumerable <string> > Post(PostPayload postPayload)
{
return(new string[] { "This", "is", "an", "antiforgery", "test" });
}
