public IActionResult Upload(CreatePost post)
{
MemoryStream stream = new MemoryStream();
post.MyCSV.CopyTo(stream);
stream.Seek(0, 0);
StreamReader fin = new StreamReader(stream);
if (!fin.EndOfStream)
{
PrenotazioneContext db = new PrenotazioneContext();
string riga = fin.ReadLine();
while (!fin.EndOfStream)
{
riga = fin.ReadLine();
string[] colonne = riga.Split(';');
Prenotazione p = new Prenotazione {
Nome = colonne[0], Email = colonne[1], DataPrenotazione = Convert.ToDateTime(colonne[2])
};
db.Prenotazioni.Add(p);
}
db.SaveChanges();
return(View("Grazie", db.Prenotazioni));
}
return(View());
}
public void CreatePostContentResize()
{
HomePage homePage = new HomePage(this.driver);
homePage.NavigateTo();
LoginPage logPage = new LoginPage(this.driver);
logPage.NavigateTo();
var loginUser = AccessExcelData.GetTestDataLoging("LoginSuccessfully");
logPage.FillLoginForm(loginUser);
homePage.CreatePostLink.Click();
CreatePost createPage = new CreatePost(this.driver);
var postUser = AccessExcelData.GetTestDataPosts("CreatePostSuccessfuly");
createPage.NavigateTo();
Actions builder = new Actions(this.driver);
var action = builder.MoveToElement(createPage.Content)
.MoveByOffset((createPage.Content.Size.Width / 2) - 2, (createPage.Content.Size.Height / 2) - 2)
.ClickAndHold()
.MoveByOffset(300, 300)
.Release();
action.Perform();
createPage.AssertCreatePageIsDisplayed("Create Article");
createPage.AssertComtentResizeField(300);
}
// PUT api/<controller>/5
public string Put(int id, [FromBody] CreatePost value)
{
con = new SqlConnection(str);
var query = "UPDATE Posts SET Image=@Image,Year=@Year,Brend=@Brend,Comment=@Comment,Description=@Description,IDUser=@IDUser WHERE IDPost=" + id;
SqlCommand insertCommand = new SqlCommand(query, con);
insertCommand.Parameters.AddWithValue("@Image", value.Image);
insertCommand.Parameters.AddWithValue("@Year", value.Year);
insertCommand.Parameters.AddWithValue("@Brend", value.Brend);
insertCommand.Parameters.AddWithValue("@Comment", value.Comment);
insertCommand.Parameters.AddWithValue("@Description", value.Description);
insertCommand.Parameters.AddWithValue("@IDUser", value.IDUser);
con.Open();
int result = insertCommand.ExecuteNonQuery();
if (result > 0)
{
return("true");
}
else
{
return("false");
}
}
public async Task <Post> Create(int forumId, CreatePost create)
{
_logger.LogInformation($"Creating post {JsonConvert.SerializeObject(create)}");
if (!_userService.Exists())
{
_logger.LogWarning("User not authenticated");
return(null);
}
var forum = await _forumService.Read(forumId);
if (forum == null)
{
_logger.LogWarning("Forum not found");
return(null);
}
var post = _mapper.Map <Post>(create);
post.UserId = _userService.Id();
post.Forum = forum;
_logger.LogInformation($"Saving post {JsonConvert.SerializeObject(post)}");
await _postRepository.Create(post);
_logger.LogInformation($"Post was assigned ID {post.Id}");
return(post);
}
public async Task CreatePost_Returns_Correct_Response()
{
var post = new CreatePost
{
UserId = 1,
OfferCountry = "Polska",
OfferCity = "Bydgoszcz",
OfferCost = 2500.00,
OfferDescription = "Opis oferty",
OfferPhotoHref = "img/obrazek.jpg"
};
int expectedResult = 0;
_postRepositoryMock.Setup(x => x.AddPost
(new Domain.Post.Post
(post.UserId,
post.OfferCountry,
post.OfferCity,
post.OfferCost,
post.OfferDescription,
post.OfferPhotoHref)))
.Returns(Task.FromResult(expectedResult));
//Act
var result = await _postService.CreatePost(post);
//Assert
Assert.IsType <Domain.Post.Post>(result);
Assert.NotNull(result);
Assert.Equal(expectedResult, result.PostId);
}
public IActionResult Upload(CreatePost post)
{
MemoryStream memStream = new MemoryStream();
post.MyCSV.CopyTo(memStream);
//mette a zero il puntatore dello StreamReader
memStream.Seek(0, 0);
StreamReader fim = new StreamReader(memStream);
if (!fim.EndOfStream)
{
//accedi al database
var db = new DBContext(); //oppure PrenotazioneContext db=new PrenotazioneContext();
string riga = fim.ReadLine();
while (!fim.EndOfStream)
{
riga = fim.ReadLine();
string[] colonne = riga.Split(";");
Prenotazione p = new Prenotazione {
Nome = colonne[0], Email = colonne[1], DataPrenotazione = Convert.ToDateTime(colonne[2])
};
db.Prenotazioni.Add(p);
}
db.SaveChanges();
return(View("Grazie", db));
}
return(View());
}
public ReturnModel CreateUsingAjaX([FromForm] CreatePost model)
{
// do other validations on your model as needed
if (model.MyImage != null)
{
var uniqueFileName = GetUniqueFileName(model.MyImage.FileName);
var uploads = Path.Combine(hostingEnvironment.WebRootPath, "uploads");
var filePath = Path.Combine(uploads, uniqueFileName);
model.MyImage.CopyTo(new FileStream(filePath, FileMode.Create));
//to do : Save uniqueFileName to your db table
return(new ReturnModel {
ReturnValue = 1
});
}
else
{
return new ReturnModel {
ReturnValue = -1
}
};
}
public void CancleButtonFuntionality()
{
HomePage homePage = new HomePage(this.driver);
homePage.NavigateTo();
LoginPage logPage = new LoginPage(this.driver);
logPage.NavigateTo();
var loginUser = AccessExcelData.GetTestDataLoging("LoginSuccessfully");
logPage.FillLoginForm(loginUser);
homePage.CreatePostLink.Click();
CreatePost createPage = new CreatePost(this.driver);
var postUser = AccessExcelData.GetTestDataPosts("CancelButtonTestData").ToString();
createPage.NavigateTo();
createPage.Title.SendKeys(postUser);
createPage.Content.SendKeys(postUser);
createPage.CancelButton.Click();
createPage.AssertPostCreationCancelButton("Test Post");
}
public async Task <IActionResult> CreatePost([FromBody] CreatePost newPost)
{
try
{
if (!ModelState.IsValid)
{
return(Json(new { IsSuccess = false, Message = "" }));
}
else
{
var currentUser = _userRepository.GetByIdAsync(_userAppContext.CurrentUserId);
newPost.OwnerId = currentUser.Id;
newPost.UserUId = currentUser.UId;
newPost.OwnerWalletAddress = currentUser.WalletAddress.ToLower();
var postCreated = await _postService.CreatePost(newPost);
return(Json(new { IsSuccess = true, Post = postCreated }));
}
}
catch (Exception e)
{
return(Json(new { IsSuccess = false, Message = e.Message }));
}
}
private ActionResult DeleteItem(CreatePost model)
{
long id;
var message = "";
return(View(model));
}
public bool CreatePost(CreatePost model)
{
try
{
var entity =
new Post
{
Id = model.Id,
Content = model.Content,
OwnerId = _userId,
CreationDate = DateTime.Now,
ThreadId = model.ThreadId,
Edited = false,
};
using (var ctx = new ApplicationDbContext())
{
ctx.Posts.Add(entity);
return(ctx.SaveChanges() == 1);
}
}
catch (NullReferenceException)
{
return(false);
}
catch (ArgumentNullException)
{
return(false);
}
}
public async Task <IActionResult> Upload(CreatePost post)
{
if (post.Song?.Length > 20971520)
{
ModelState.AddModelError("Song", "The file is too large");
}
if (post.Song?.ContentType != "audio/mpeg")
{
ModelState.AddModelError("Song", "The file is not song");
}
if (ModelState.IsValid)
{
await using var stream = new MemoryStream();
if (post.Song != null)
{
await post.Song.CopyToAsync(stream);
}
await _session.Upload(stream, post.Title);
var artist = new Artist(post.Artist);
var album = new Album(post.Album, post.Year, artist);
var song = new Song(post.Title, album, _session.GetFileId(post.Title));
await _artists.AddArtist(artist);
await _albums.AddAlbum(album);
await _songs.AddSong(song);
}
return(View("Index"));
}
public async Task CreatePost_ValidData_ShouldSuccess()
{
var now = DateTime.UtcNow;
var command = new CreatePost
{
Title = " title ",
Content = " content ",
CategoryId = GuidHelper.GetGuidFromInt(1)
};
var payload = GetPayload(command);
var response = await Client.PostAsync(BaseUrl, payload);
response.StatusCode.Should().Be(HttpStatusCode.Created);
response.Headers.Location.ToString().Should().NotBeNullOrWhiteSpace();
var result = await GetResourceAsync <PostDto>(response.Headers.Location.ToString());
result.Response.StatusCode.Should().Be(HttpStatusCode.OK);
result.Data.Id.Should().NotBe(Guid.Empty);
result.Data.Title.Should().Be(command.Title.Trim());
result.Data.Content.Should().Be(command.Content.Trim());
result.Data.CategoryId.Should().Be(command.CategoryId);
result.Data.CreatedAt.Should().BeAfter(now);
result.Data.UpdatedAt.Should().BeAfter(now);
}
public async Task <IActionResult> CreatePostAsync(Guid userId, [FromForm] CreatePost post)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var tags = JsonConvert.DeserializeObject <List <SelectTag> >(post.Tags);
string coverImagePath = null;
if (post.CoverImage != null)
{
var uniqueFileName = GetUniqueFileName(post.CoverImage.FileName);
var uploads = Path.Combine(_hostingEnvironment.ContentRootPath, "Storage/Uploads");
var filePath = Path.Combine(uploads, uniqueFileName);
await post.CoverImage.CopyToAsync(new FileStream(filePath, FileMode.Create));
coverImagePath = uniqueFileName;
}
var createdPost = await _repo.CreatePostAsync(
new Post
{
Title = post.Title,
Body = post.Body,
UserId = userId,
CoverImagePath = coverImagePath
},
tags
);
return(Created(nameof(Route.PostsCreate), createdPost));
}
public IActionResult DOCNew(CreatePost model)
{
// do other validations on your model as needed
string FileExtension = Path.GetExtension(model.Archivo.FileName);
string uniqueFileName = model.Documento + FileExtension;
string PathDestino = @"C:\Users\jbelenguer\Documents\My Web Sites\SGDE_VC\wwwroot\Files\RIP\DOC\";
string PathDestinoPDF = @"C:\Users\jbelenguer\Documents\My Web Sites\SGDE_VC\wwwroot\Files\RIP\PDF\";
if (model.Archivo != null)
{
//to do : Save uniqueFileName to your db table
ViewBag.Mensaje = Metodos.SQL_Ejecuta_pDocumentosAdd(model.Documento, Metodos.ObtenUsuarioActivo(User.Identity.Name).Cod3, Metodos.ObtenUsuarioActivo(User.Identity.Name).Usuario, model.CTipo, model.TipoDocumento, model.Descripcion, uniqueFileName, model.Obs);
if (ViewBag.Mensaje.ToString().Substring(0, 5).ToUpper() != "ERROR")
{
Metodos.SubirFichero(model, PathDestino);
if (FileExtension == ".doc" || FileExtension == ".docx")
{
Metodos.WordAPDF(PathDestino, PathDestinoPDF, uniqueFileName);
}
PathDestino = @"C:\Users\jbelenguer\Documents\My Web Sites\SGDE_VC\wwwroot\Files\RIP\DOC\" + uniqueFileName;
PathDestinoPDF = @"C:\Users\jbelenguer\Documents\My Web Sites\SGDE_VC\wwwroot\Files\RIP\PDF\" + model.Documento + ".pdf";
if (FileExtension == ".xls" || FileExtension == ".xlsx")
{
Metodos.Excel_PDF(PathDestino, PathDestinoPDF);
}
if (ViewBag.Mensaje.ToString().Substring(0, 2).ToUpper() == "OK")
{
Metodos.EnviaEmail("Creado Nuevo Documento: " + model.Documento, Metodos.ObtenUsuarioActivo(User.Identity.Name).Usuario + " ha creado un nuevo documento", "*****@*****.**");
}
}
}
// to do : Return something
return(View());
}
public IActionResult AddImageBlock(int?id, CreatePost model)
{
if (id == null)
{
return(StatusCode(StatusCodes.Status400BadRequest));
}
var post = new ImageBlock()
{
ImageCaption = model.ImageCaption
};
if (model.MyImage != null)
{
var uniqueFileName = GetUniqueFileName(model.MyImage.FileName);
string extension = Path.GetExtension(model.MyImage.FileName).ToLower();
if (extension == ".png" || extension == ".jpg" || extension == ".jpeg")
{
var FilePath = Path.Combine(filePath, uniqueFileName);
model.MyImage.CopyTo(new FileStream(FilePath, FileMode.Create));
post.MyImage = GetByteArrayFromImage(model.MyImage);
post.ImageName = uniqueFileName;
post.ImagePath = FilePath;
post.ImageBlockIndex = model.ImageBlockIndex;
post.ImageDescription = model.ImageDescription; //must include every attribute
}
else
{
Response.WriteAsync("Accepted file format: .jpeg, .jpg");
}
}
int?storyId_ = HttpContext.Session.GetInt32(sessionId_);
var story = context_.Story.Find(storyId_);
if (story != null)
{
if (story.ImageBlocks == null)
{
List <ImageBlock> ims = new List <ImageBlock>();
story.ImageBlocks = ims;
}
story.ImageBlocks.Add(post);
try
{
context_.SaveChanges();
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status404NotFound));
}
}
return(RedirectToAction("EditStory", new { id = storyId_ }));
}
public async Task <Domain.Post.Post> CreatePost(CreatePost createPost)
{
var post = new Domain.Post.Post(createPost.UserId, createPost.CreationDate, createPost.OfferDescription, createPost.OfferCountry, createPost.OfferCity, createPost.OfferCost, createPost.HotelName, createPost.DeparturePlace, createPost.DateOfDeparture, createPost.DateOfReturn, createPost.IsActivePost, createPost.IsBannedPost, createPost.OfferPhotoHref);
post.PostId = await _postRepository.AddPost(post);
return(post);
}
public void Setup()
{
_command = PostFactories.CreatePostCommand();
_validatorMock = new Mock <IValidator <CreatePost> >();
_validatorMock.Setup(x => x.Validate(_command)).Returns(new ValidationResult());
_post = new Post(_command, _validatorMock.Object);
_event = _post.Events.OfType <PostCreated>().Single();
}
public async Task <IActionResult> Post([FromBody] CreatePost command)
{
command.AggregateRootId = Guid.NewGuid();
command.BlogId = BlogId;
await _mediator.SendAndPublishAsync <CreatePost, Post>(command);
return(new NoContentResult());
}
public static void SubirFichero(CreatePost posteado, string PathDestino)
{
string uniqueFileName = posteado.Documento + Metodos.ExtensionArchivo(posteado.Archivo.FileName);
string filePath = Path.Combine(PathDestino, uniqueFileName);
using var stream = System.IO.File.Create(filePath);
posteado.Archivo.CopyTo(stream);
}
public async Task <IActionResult> Post([FromBody] CreatePost model)
{
var entity = model.MapEntity(model, await _postService.GetAuthorId(model.AuthorUsername));
var createdResult = await _postService.CreatePostAsync(entity);
return(new JsonResult(createdResult));
}
private void AddPost()
{
var result = new CreatePost().ShowDialog();
if (result == true)
{
RefreshList();
}
}
public async Task <ActionResult <PostResponse> > Create(int forumId, CreatePost create)
{
var post = await _postService.Create(forumId, create);
var response = _mapper.Map <PostResponse>(post);
response.Author = _userService.Auth().Username;
return(Created($"api/forum/{forumId}/post/{response.Id}", response));
}
public void Map_FromCreateToPost_MapsAllPropertiesFromSource()
{
var create = new CreatePost {
Content = "Content"
};
var post = Mapper.Map <Post>(create);
Assert.Equal(create.Content, post.Content);
Assert.True(post.CreatedAt > DateTime.Now.AddMilliseconds(-10));
}
public void Validate_ValidCreatePost_SuccessfullyValidates()
{
var create = new CreatePost {
Content = "This is a test"
};
var context = new ValidationContext(create);
var result = Validator.TryValidateObject(create, context, null, true);
Assert.True(result);
}
public async Task <CreatePostResponse> Post(CreatePost request)
{
var user = GetUser();
AssertCanPostToOrganization(Db, request.OrganizationId, user, out var org, out var orgMember);
AssertCanPostTypeToOrganization(request.Type, org, orgMember, user);
var existingPost = request.Url != null
? await Db.SingleAsync <Post>(x => x.Url == request.Url && x.Deleted == null && x.Hidden == null && !x.Archived)
: null;
if (existingPost != null)
{
throw new ArgumentException($"URL already used in unarchived /posts/{existingPost.Id}/{existingPost.Slug}", nameof(request.Url));
}
var post = request.ConvertTo <Post>();
post.Slug = request.Title.GenerateSlug();
post.Created = post.Modified = DateTime.Now;
post.CreatedBy = post.ModifiedBy = user.UserName;
post.UserId = user.UserAuthId.ToInt();
post.UpVotes = 0;
post.Points = 1;
post.ContentHtml = await Markdown.TransformAsync(post.Content, user.GetGitHubToken());
post.Rank = 0;
if (!user.IsOrganizationModerator(orgMember))
{
post.Labels = null;
}
if (string.IsNullOrEmpty(post.ImageUrl) && Request.Files.Length > 0)
{
post.ImageUrl = Request.Files[0].UploadToImgur(AppSettings.GetString("oauth.imgur.ClientId"),
nameof(post.ImageUrl), minWidth: 200, minHeight: 200, maxWidth: 4000, maxHeight: 4000);
}
var id = await Db.InsertAsync(post, selectIdentity : true);
await Db.UpdateAddAsync(() => new UserActivity { PostsCount = 1 },
where : x => x.Id == post.UserId);
await SendNotificationAsync(nameof(CreatePost), nameof(Post), id);
ClearPostCaches();
return(new CreatePostResponse
{
Id = id,
Slug = post.Slug,
});
}
private void BtnCreate_Click(object sender, RoutedEventArgs e)
{
var window = new CreatePost(Connector);
window.ShowDialog();
if (window.NewPost != null)
{
Posts.Insert(0, window.NewPost);
}
}
// Start is called before the first frame update
void Start()
{
//texthead = gameObject.transform.GetChild(1).gameObject;
challenge_Butt = GameObject.Find("ButtonScript").GetComponent <challenge_butt>();
create_Post_scrp = GameObject.Find("Createpost_Script").GetComponent <CreatePost>();
mark_bg_textdetail = GameObject.Find("mark_bg_textdetail");
bg_textdetail = GameObject.Find("bg_textdetail");
textdetail = GameObject.Find("Textdetail");
textname = GameObject.Find("Textname");
score_show = GameObject.Find("score_show");
this_star = create_Post_scrp.act_difficulty;
}
public async Task <ActionResult> Post([FromBody] CreatePost command, CancellationToken token)
{
return(new JsonResult(new
{
Post = await _mediator.Send(new CreatePostCommand
{
Content = _stringToHtmlHelper.GetHtml(command.Content),
ThreadId = command.ThreadId,
UserId = User.Claims.Single(x => x.Type == "Id").Value
}, token)
}));
}
public NormalAnswer CreatePost(CreatePost input, int userId)
{
var command = new SQLiteCommand(this.connection);
command.CommandText = $"INSERT INTO post (title, beschreibung, pfad, userId) VALUES ('{input.title}', '{input.description}', '{input.path}', {userId})";
if (command.ExecuteNonQuery() > 0)
{
return(new NormalAnswer(true, "successful", 200));
}
return(new NormalAnswer(false, "internal server error [sql]", 500));
}
