public async Task <UploadResult> UploadVideosAsync(List <IFormFile> files, string folder = "")
{
var uploadResult = new VideoUploadResult();
foreach (var file in files)
{
if (file.Length <= 0)
{
continue;
}
await using var stream = file.OpenReadStream();
var uploadParams = new VideoUploadParams
{
File = new FileDescription(file.FileName, stream),
Folder = folder
};
uploadResult = await _cloudinary.UploadAsync(uploadParams);
if (uploadResult.Error != null)
{
throw new Exception(uploadResult.Error.Message);
}
}
return(new UploadResult
{
Url = uploadResult.SecureUrl.AbsoluteUri,
PublicId = uploadResult.PublicId,
CreatedAt = uploadResult.CreatedAt
});
}
public async Task <FileUploadResult> AddVideo(IFormFile file)
{
var uploadResult = new VideoUploadResult();
if (file.Length > 0)
{
using (var stream = file.OpenReadStream())
{
var uploadParams = new VideoUploadParams
{
File = new FileDescription(file.FileName, stream),
Transformation = new Transformation().Quality("auto"),
};
uploadResult = await _cloudinary.UploadLargeAsync(uploadParams);
}
}
if (uploadResult.Error != null)
{
return new FileUploadResult
{
PublicId = "",
Url = "",
Message = uploadResult.Error.Message
}
}
;
return(new FileUploadResult
{
PublicId = uploadResult.PublicId,
Url = uploadResult.SecureUrl.AbsoluteUri,
Message = ""
});
}
public PhotoUploadResult AddVideo(IFormFile file)
{
var uploadResult = new VideoUploadResult();
if (file.Length > 0)
{
using (var stream = file.OpenReadStream())
{
var uploadParams = new VideoUploadParams
{
File = new FileDescription(file.FileName, stream)
};
uploadResult = _cloudinary.Upload(uploadParams);
}
}
if (uploadResult.Error != null)
{
throw new Exception(uploadResult.Error.Message);
}
return(new PhotoUploadResult
{
PublicId = uploadResult.PublicId,
Url = uploadResult.SecureUri.AbsoluteUri
});
}
public async Task <NatureShot.Data.Models.Video> CreateVideo(string userId, VideoUploadResult videoInput)
{
var seconds = (int)Math.Round(videoInput.Duration, MidpointRounding.AwayFromZero);
var minitus = 0;
var url = videoInput.Url.AbsoluteUri;
if (seconds > 60)
{
minitus = seconds / 60;
seconds -= minitus * 60;
}
if (url.StartsWith("http"))
{
url = url.Replace("http", "https");
}
var video = new NatureShot.Data.Models.Video
{
AddedByUserId = userId,
Extension = videoInput.Format,
VideoUrl = url,
Length = new TimeSpan(0, minitus, seconds),
};
await this.videoRepository.AddAsync(video);
await this.videoRepository.SaveChangesAsync();
return(video);
}
public async Task <IActionResult> AddVideoForUser(int businessId,
[FromForm] VideoForCreationDto videoForCreationDto)
{
var businessFromRepo = await _repo.GetBusiness(businessId);
if (businessFromRepo.UserId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
var file = videoForCreationDto.File;
var uploadResult = new VideoUploadResult();
if (file.Length > 0)
{
using (var stream = file.OpenReadStream())
{
var uploadParams = new VideoUploadParams
{
File = new FileDescription(file.Name, stream)
};
uploadResult = _cloudinary.Upload(uploadParams);
}
}
if (businessFromRepo.Video != null && businessFromRepo.Video.PublicId != null)
{
var deleteParams = new DeletionParams(businessFromRepo.Video.PublicId)
{
ResourceType = ResourceType.Video
};
var result = _cloudinary.Destroy(deleteParams);
if (result.Result == "ok")
{
_repo.Delete(businessFromRepo.Video);
}
}
videoForCreationDto.Url = uploadResult.Uri.ToString();
videoForCreationDto.PublicId = uploadResult.PublicId;
var video = _mapper.Map <VideoModel>(videoForCreationDto);
businessFromRepo.Video = video;
if (await _repo.SaveAll())
{
var videoToReturn = _mapper.Map <VideoForReturnDto>(video);
return(CreatedAtRoute("GetVideo", new { id = video.Id }, videoToReturn));
}
return(BadRequest("Cloud not add the video"));
}
public async Task <IActionResult> AddVideo([FromForm] VideoForCreationDto videoForCreationDto)
{
if (!await _repo.IsExistTopic(videoForCreationDto.TopicId))
{
return(BadRequest("Topic doesn't Exist"));
}
var topic = await _repo.GetTopicsById(videoForCreationDto.TopicId);
var file = videoForCreationDto.File;
var uploadResult = new VideoUploadResult();
if (file.Length > 0)
{
using (var stream = file.OpenReadStream())
{
var uploadParams = new VideoUploadParams()
{
File = new FileDescription(file.FileName, stream),
/* Transformation = new Transformation()
* .Width(500).Height(500).Crop("fill").Gravity("face"), */
/* EagerTransforms = new List<Transformation>()
* {
* new EagerTransformation().Width(300).Height(300).Crop("pad").AudioCodec("none"),
* new EagerTransformation().Width(160).Height(100).Crop("crop").Gravity("south").AudioCodec("none")},
* EagerAsync = true */
};
uploadResult = _cloudinary.UploadLarge(uploadParams);
}
}
var videoToCreate = _mapper.Map <Videos>(videoForCreationDto);
videoToCreate.Url = uploadResult.Uri.ToString();
videoToCreate.PublicId = uploadResult.PublicId;
videoToCreate.ChapterName = topic.ChapterName;
videoToCreate.ClassName = topic.ClassName;
videoToCreate.CreatedDate = DateTime.Now;
videoToCreate.SubjectName = topic.SubjctName;
videoToCreate.TopicName = topic.Name;
videoToCreate.ClassId = topic.ClassId;
videoToCreate.SubjectForClassId = topic.SubjectIdInClass;
videoToCreate.ChapterId = topic.ChapterId;
_repo.Add <Videos>(videoToCreate);
if (await _repo.SaveAll())
{
return(Ok());
}
return(BadRequest("Failed to add Video"));
}
public async Task <VideoUploadResult> UploadAsync(VideoUploadParams parameters)
{
var url = Api.ApiUrlVideoUpV.BuildUrl();
ResetInternalFileDescription(parameters.File, int.MaxValue);
using (var response = await Api.CallAsync(HttpMethod.Post, url, parameters.ToParamsDictionary(), parameters.File, null))
{
return(await VideoUploadResult.Parse(response));
}
}
/// <summary>
/// Uploads a video file to cloudinary.
/// </summary>
/// <param name="parameters">Parameters of video uploading .</param>
/// <returns>Results of video uploading.</returns>
public VideoUploadResult Upload(VideoUploadParams parameters)
{
string uri = m_api.ApiUrlVideoUpV.BuildUrl();
ResetInternalFileDescription(parameters.File);
using (HttpWebResponse response = m_api.Call(HttpMethod.POST, uri, parameters.ToParamsDictionary(), parameters.File))
{
return(VideoUploadResult.Parse(response));
}
}
public void FileUpload()
{
VideoUploadParams uploadParams = new VideoUploadParams
{
File = new FileDescription(@"D:\Git\Ggg.Github\Ggg.Csharp\apps\app-cloudinary\videos\dog.mp4"),
PublicId = "my_folder/my_sub_folder/my_dog",
Overwrite = true,
NotificationUrl = "http://mysite/my_notification_endpoint"
};
VideoUploadResult uploadResult = Cloudinary.Upload(uploadParams);
TestUtilities.LogAndWrite(uploadResult, "FileUpload.txt");
}
public void VideoResizeAndRotate()
{
Cloudinary cloudinary = TestUtilities.GetCloudinary();
VideoUploadResult videoUploadResult = TestUtilities.UploadVideo();
Transformation transformation = new Transformation()
.Width(0.4).Angle(20).Chain()
.Overlay("cloudinary_icon").Opacity(50).Width(60).Gravity("south_east").Y(15).X(60);
string buildVideoTag = cloudinary.Api.UrlVideoUp.Transform(transformation)
.BuildVideoTag("dog");
TestUtilities.LogAndWrite(videoUploadResult, "UploadVideo.txt");
TestUtilities.LogAndWrite(buildVideoTag, "VideoResizeAndRotate.txt");
}
public async Task <CloudinaryDotNet.Actions.VideoUploadResult> AddAudioAsync(IFormFile file)
{
var uploadResult = new VideoUploadResult();
if (file.Length > 0)
{
using var stream = file.OpenReadStream();
var upladParams = new VideoUploadParams
{
File = new FileDescription(file.FileName, stream),
};
uploadResult = await _cloudinary.UploadAsync(upladParams);
}
return(uploadResult);
}
public async Task <CloudinaryAsset> AddCloudAssetAsync(CloudinaryAsset cloudinaryAsset, int id, int lessonId)
{
var file = cloudinaryAsset.File;
var uploadResult = new VideoUploadResult();
try
{
if (file.Length > 0)
{
using (var stream = file.OpenReadStream())
{
var uploadParams = new VideoUploadParams()
{
File = new FileDescription(file.Name, stream)
};
uploadResult = _cloudinary.Upload(uploadParams);
}
}
}
catch (Exception e)
{
string errorMessage = $"Exception - MESSAGE: {e.Message} STACK TRACE: {e.StackTrace}";
// Exception logging code here
}
cloudinaryAsset.Url = uploadResult.Uri.ToString();
cloudinaryAsset.PublicId = uploadResult.PublicId;
cloudinaryAsset.AssetName = cloudinaryAsset.File.FileName;
cloudinaryAsset.Type = cloudinaryAsset.File.ContentType;
cloudinaryAsset.UserId = id;
cloudinaryAsset.LessonId = lessonId;
var assetForReturn = cloudinaryAsset;
CloudAsset asset = new CloudAsset()
{
AssetName = cloudinaryAsset.AssetName,
Type = cloudinaryAsset.Type,
Url = cloudinaryAsset.Url,
PublicId = cloudinaryAsset.PublicId,
UserId = cloudinaryAsset.UserId,
LessonId = cloudinaryAsset.LessonId
};
await _repository.AddCloudAssetAsync(asset);
return(assetForReturn);
}
public async Task <IActionResult> AddVideo(int propertyId, [FromForm] VideoCreateDto videoCreateDto)
{
int userId = Convert.ToInt32(_userManager.GetUserId(User));
if (userId != _context.Properties.FindAsync(propertyId).Result.UserId)
{
return(Unauthorized());
}
var propertyFromRepo = await _repo.GetProperty(propertyId);
var file = videoCreateDto.VideoFile;
var uploadResult = new VideoUploadResult();
if (file.Length > 0)
{
using (var stream = file.OpenReadStream())
{
var uploadParams = new VideoUploadParams()
{
File = new FileDescription(file.Name, stream),
Transformation = new Transformation().Width(500)
.Height(500)
};
uploadResult = _cloudinary.Upload(uploadParams);
}
}
videoCreateDto.VideoUrl = uploadResult.Uri.ToString();
videoCreateDto.VideoPublicId = uploadResult.PublicId;
var video = _mapper.Map <Video>(videoCreateDto);
propertyFromRepo.Videos.Add(video);
if (await _repo.SaveAll())
{
var videoToReturn = _mapper.Map <VideoReturnDto>(video);
return(CreatedAtRoute("GetVideo", new { id = propertyId }, videoToReturn));
}
return(BadRequest("Failed to add video"));
}
public static VideoUploadResult UploadVideo()
{
Cloudinary cloudinary = GetCloudinary();
VideoUploadParams uploadParams = new VideoUploadParams()
{
File = new FileDescription(GetVideosFolder() + @"\dog.mp4"),
PublicId = "dog",
EagerTransforms = new List <Transformation>()
{
new Transformation().Width(300).Height(300).Crop("pad").AudioCodec("none"),
new Transformation().Width(160).Height(100).Crop("crop").Gravity("south").AudioCodec("none"),
},
EagerAsync = true,
EagerNotificationUrl = "https://requestbin.fullcontact.com/1964k7d1"
};
VideoUploadResult uploadResult = cloudinary.Upload(uploadParams);
return(uploadResult);
}
public void ServerSideUpload()
{
Cloudinary cloudinary = TestUtilities.GetCloudinary();
VideoUploadParams uploadParams = new VideoUploadParams()
{
File = new FileDescription(TestUtilities.GetVideosFolder() + @"\dog.mp4"),
PublicId = "my_folder/my_sub_folder/dog_closeup",
EagerTransforms = new List <Transformation>()
{
new Transformation().Width(300).Height(300).Crop("pad").AudioCodec("none"),
new Transformation().Width(160).Height(100).Crop("crop").Gravity("south").AudioCodec("none"),
},
EagerAsync = true,
EagerNotificationUrl = "https://requestbin.fullcontact.com/1964k7d1"
};
VideoUploadResult uploadResult = cloudinary.Upload(uploadParams);
TestUtilities.LogAndWrite(uploadResult, "ServerSideUpload.txt");
}
public int FillVideoInfo(VideoUploadResult model, string name)
{
var height = model.Height;
var width = model.Width;
var sign = model.Signature;
var pubId = model.PublicId;
var url = model.Uri;
var secureUrl = model.SecureUri;
var format = model.Format;
var resType = model.ResourceType;
var duration = model.Duration;
var query = "INSERT INTO `VideoData`(`Name`, `Height`, `Width`, `Signature`, `PublicId`, `Url`, `SecureUrl`, `Format`, `ResourceType`,`Duration`) " +
"VALUES('" + name + "','" + height + "','" + width + "','" + sign + "','" + pubId + "','" + url + "','" + secureUrl + "','" + format + "','" + resType + "','" + duration + "');";
var command = CreateCommand(query);
var result = command.ExecuteNonQuery();
return(result);
}
public async Task <IActionResult> Addvideo(int userId, int id, [FromForm] VideoForCreationDto videoForCreationDto)
{
if (userId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
videoForCreationDto.UserId = userId;
// var userFromRepo = await _repository.GetUser(userId, true);
var file = videoForCreationDto.File;
var uploadResult = new VideoUploadResult();
if (file != null && file.Length > 0)
{
using (var stream = file.OpenReadStream())
{
var uploadParams = new VideoUploadParams()
{
File = new FileDescription(file.Name, stream),
Transformation = new Transformation()
.Width(900).Height(800).Crop("crop")
};
uploadResult = _cloudinary.Upload(uploadParams);
}
}
videoForCreationDto.Url = uploadResult.Uri.ToString();
videoForCreationDto.publicId = uploadResult.PublicId;
videoForCreationDto.PlaylistId = id;
var Video = _mapper.Map <video>(videoForCreationDto);
_repository.Add(Video);
// userFromRepo.videos.Add(Video);
if (await _repository.SaveAll())
{
var VideosToReturn = _mapper.Map <VideoForReturnDto>(Video);
return(CreatedAtRoute("GetVideo", new { id = Video.Id }, VideosToReturn));
}
return(BadRequest("خطأ في إضافة الفيديو"));
}
public async Task <IActionResult> AddVideoForUser(int userId, [FromForm] VideoForCreationDto videoForCreationDto)
{
if (userId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
var userFromRepo = await _repo.GetUser(userId);
var file = videoForCreationDto.File;
var uploadResults = new VideoUploadResult();
if (file.Length > 0)
{
using (var stream = file.OpenReadStream()){
var uploadParams = new VideoUploadParams()
{
File = new FileDescription(file.Name, stream),
Transformation = new Transformation().Width(500).Height(500).Crop("fill")
};
uploadResults = _cloudinary.Upload(uploadParams);
}
}
videoForCreationDto.VideoUrl = uploadResults.Uri.ToString();
videoForCreationDto.PublicId = uploadResults.PublicId;
var video = _mapper.Map <Models.Video>(videoForCreationDto);
userFromRepo.Videos.Add(video);
if (await _repo.SaveAll())
{
var videoToReturn = _mapper.Map <VideoForReturnDto>(video);
return(CreatedAtRoute("GetVideo", new VideoForReturnDto {
Id = video.Id
}, videoToReturn));
}
return(BadRequest("Could not add the video!"));
}
public async Task <DocumentForCreationResponse> AddVideoAsync(DocumentForCreationResponse documentForCreationResponse, int id)
{
var file = documentForCreationResponse.File;
var uploadResult = new VideoUploadResult();
if (file.Length > 0)
{
using (var stream = file.OpenReadStream())
{
var uploadParams = new VideoUploadParams()
{
File = new FileDescription(file.Name, stream)
};
uploadResult = _cloudinary.Upload(uploadParams);
}
}
documentForCreationResponse.Url = uploadResult.Uri.ToString();
documentForCreationResponse.PublicId = uploadResult.PublicId;
documentForCreationResponse.Name = documentForCreationResponse.File.FileName;
documentForCreationResponse.Type = documentForCreationResponse.File.ContentType;
documentForCreationResponse.UserId = id;
var assetForReturn = documentForCreationResponse;
Asset asset = new Asset()
{
Name = documentForCreationResponse.Name,
Type = documentForCreationResponse.Type,
Url = documentForCreationResponse.Url,
PublicId = documentForCreationResponse.PublicId,
UserId = documentForCreationResponse.UserId
};
await _repository.AddImage(asset);
return(assetForReturn);
}
public async Task <IActionResult> AddDocumentForUser(int userId,
[FromForm] DocumentForCreationDto docForCreationDto)
{
// [FromForm]PhotoForCreationDto = PhotoForCreationDto)
if (userId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
int DocumentUploadeeId = userId;
int DocumentUploaderId = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value);
var checkIfUploaderSelectedUploadee = await _repo.GetSelect(DocumentUploaderId, DocumentUploadeeId);
var checkIfUploadeeSelectedUploader = await _repo.GetSelect(DocumentUploadeeId, DocumentUploaderId);
if (checkIfUploadeeSelectedUploader != null && checkIfUploaderSelectedUploadee == null)
{
return(BadRequest("You cannot upload photos until you accept user's request"));
}
else if (checkIfUploadeeSelectedUploader == null && checkIfUploaderSelectedUploadee == null)
{
return(Unauthorized());
}
}
var userFromRepo = await _repo.getUser(userId);
var file = docForCreationDto.File;
var imageUploadResult = new ImageUploadResult();
var videoUploadResult = new VideoUploadResult();
// var uploadResult = new RawUploadResult();
if (file.Length > 0)
{
using (var stream = file.OpenReadStream())
{
if (file.ContentType.Contains("image"))
{
var uploadParams = new ImageUploadParams()
{
File = new FileDescription(file.Name, stream),
Transformation = new Transformation()
.Width(500).Height(500).Crop("fill").Gravity("face")
};
imageUploadResult = _cloudinary.Upload(uploadParams);
docForCreationDto.Url = imageUploadResult.Uri.ToString();
docForCreationDto.PublicId = imageUploadResult.PublicId;
}
if (file.ContentType.Contains("video"))
{
var uploadParams = new VideoUploadParams()
{
File = new FileDescription(file.Name, stream),
EagerTransforms = new List <Transformation>()
{
new Transformation().Width(300).Height(300)
.Crop("pad").AudioCodec("none"),
new Transformation().Width(160).Height(100)
.Crop("crop").Gravity("south").AudioCodec("none")
}
};
videoUploadResult = _cloudinary.Upload(uploadParams);
docForCreationDto.Url = videoUploadResult.Uri.ToString();
docForCreationDto.PublicId = videoUploadResult.PublicId;
}
// var uploadParams = new RawUploadParams() {
// File = new FileDescription(file.Name, stream),
// // Transformation = new Transformation()
// // .Width(500).Height(500).Crop("fill").Gravity("face")
// };
// uploadResult = _cloudinary.Upload(uploadParams);
}
}
// docForCreationDto.Url = uploadResult.Uri.ToString();
// docForCreationDto.PublicId = uploadResult.PublicId;
docForCreationDto.Type = file.ContentType;
var document = _mapper.Map <Document>(docForCreationDto);
// if (!userFromRepo.Documents.Any(u => u.IsMain))
// photo.IsMain = true;
userFromRepo.Documents.Add(document);
//var photoToReturn = _mapper.Map<PhotosForReturnDto>(photo);
if (await _repo.SaveAll())
{
var docToReturn = _mapper.Map <DocumentForReturnDto>(document);
return(CreatedAtRoute("GetDocument", new { id = document.id }, docToReturn));
}
return(BadRequest("Could not add the photo"));
}
public async Task CreateVideoPostAsync(VideoPostInputModel input, string userId, VideoUploadResult videoInput)
{
var video = await this.videosService.CreateVideo(userId, videoInput);
var camera = await this.cameraService.GetCameraByNameAsync(input.Camera);
var country = await this.countriesService.GetCountry(input.Country);
var location = await this.locationsService.GetLocation(input.Location, country);
var postType = this.postTypeRepository.All().FirstOrDefault(x => x.Name == "Video");
var post = new Post
{
AddedByUserId = userId,
Camera = camera,
Caption = input.Caption,
Type = postType,
Dislikes = 0,
Likes = 0,
Video = video,
VideoId = video.Id,
Location = location,
};
var tags = await this.tagsService.GetTagsForPost(input.Tags);
foreach (var tag in tags)
{
post.Tags.Add(new PostTag
{
Tag = tag,
Post = post,
});
}
await this.postRepository.AddAsync(post);
await this.postRepository.SaveChangesAsync();
}
public JsonResult CreatePost([FromForm] PostCreateApi model)
{
using (var scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
try
{
if (string.IsNullOrEmpty(model.Text))
{
Result.Status = false;
Result.Message = "You can not add a post without writing text ! ";
return(BadResponse(Result));
}
var appUser = _userService.FindByUserName(User.Identity.Name);
if (appUser == null)
{
return(BadResponse(new ResultModel
{
Status = false,
Message = "User not found !"
}));
}
bool hasImage = CheckItemType.HasItemImage(model);
bool hasVideo = CheckItemType.HasItemVideo(model);
var imageUploadResult = new ImageUploadResult();
var videoUploadResult = new VideoUploadResult();
#region CloudinaryProcess
#region ImageUploadingProcess
if (hasImage)
{
using (var stream = model.Photo.OpenReadStream())
{
var uploadParams = new ImageUploadParams
{
File = new FileDescription(model.Photo.Name, stream)
};
imageUploadResult = _cloudinary.Upload(uploadParams);
if (imageUploadResult.Error != null)
{
scope.Dispose();
return(BadResponse(ResultModel.Error("The upload process can not be done !")));
}
}
}
#endregion
#region VideoUploadingProcess
if (hasVideo)
{
using (var stream = model.Video.OpenReadStream())
{
var uploadParams = new VideoUploadParams
{
File = new FileDescription(model.Video.Name, stream)
};
videoUploadResult = _cloudinary.Upload(uploadParams);
if (videoUploadResult.Error != null)
{
scope.Dispose();
return(BadResponse(ResultModel.Error("The upload process can not be done !")));
}
}
}
#endregion
#endregion
#region CRUD
var newPost = new Post
{
Text = model.Text,
PostType = hasImage == true ? (int)PostTypeEnum.PostImage
: hasVideo == true ? (int)PostTypeEnum.PostVideo
: (int)PostTypeEnum.PostText,
CreatedBy = appUser.Id
};
ResultModel postModel = _postService.Create(newPost);
if (!postModel.Status)
{
scope.Dispose();
return(BadResponse(ResultModel.Error("The upload process can not be done !")));
}
#region PostImages
if (imageUploadResult != null && imageUploadResult.StatusCode == HttpStatusCode.OK)
{
var postImages = new PostImage
{
PostId = newPost.Id,
ImageUrl = imageUploadResult.Url.ToString()
};
ResultModel postImageModel = _postImageService.Create(postImages);
if (!postImageModel.Status)
{
scope.Dispose();
return(BadResponse(ResultModel.Error("The upload process can not be done !")));
}
}
#endregion
#region PostVideos
if (videoUploadResult != null && videoUploadResult.StatusCode == HttpStatusCode.OK)
{
var postVideos = new PostVideo
{
PostId = newPost.Id,
VideoUrl = videoUploadResult.Url.ToString()
};
ResultModel postVideoModel = _postVideoService.Create(postVideos);
if (!postVideoModel.Status)
{
scope.Dispose();
return(BadResponse(ResultModel.Error("The upload process can not be done !")));
}
}
#endregion
#endregion
scope.Complete();
//TODO
//There must be an integration that returns the last post that has just been createad.
return(OkResponse(new PostListDto
{
Id = newPost.Id,
Text = newPost.Text,
ImageUrl = imageUploadResult.Url?.ToString(),
CreatedByUserName = appUser.UserName,
CreatedByUserPhoto = appUser.UserDetail.ProfilePhotoPath,
CreatedDate = newPost.CreatedDate,
VideoUrl = videoUploadResult.Url?.ToString(),
PostType = newPost.PostType,
Comments = null
}));
}
catch (Exception ex)
{
scope.Dispose();
Result.Status = false;
Result.Message = ex.ToString();
return(BadResponse(Result));
}
}
}
public async Task <IActionResult> CreatePost([FromForm] CreatePostDto createPostDto)
{
var post = new Post();
post.UserId = UserId;
if (!String.IsNullOrEmpty(createPostDto.Text))
{
post.Text = createPostDto.Text;
}
if (createPostDto.Photo != null)
{
var uploadResultImage = new ImageUploadResult();
using (var stream = createPostDto.Photo.OpenReadStream())
{
var uploadParams = new ImageUploadParams()
{
File = new FileDescription(createPostDto.Photo.Name, stream)
};
uploadResultImage = _cloudinary.Upload(uploadParams);
}
var photo = new Photo
{
Id = uploadResultImage.PublicId,
Url = uploadResultImage.Uri.ToString()
};
post.Photo = photo;
}
if (createPostDto.Video != null)
{
var uploadResultVideo = new VideoUploadResult();
using (var stream = createPostDto.Video.OpenReadStream())
{
var uploadParams = new VideoUploadParams()
{
File = new FileDescription(createPostDto.Video.Name, stream)
};
uploadResultVideo = _cloudinary.Upload(uploadParams);
}
var video = new Domain.Video
{
Id = uploadResultVideo.PublicId,
Url = uploadResultVideo.Uri.ToString()
};
post.Video = video;
}
_context.Posts.Add(post);
await _context.SaveChangesAsync();
var postDto = _mapper.Map <PostItemDto>(post);
var userProfile = await _context.Profiles.Include(p => p.Avatar).FirstOrDefaultAsync(p => p.UserId == UserId);
postDto.Avatar = userProfile.Avatar.Url;
return(Ok(postDto));
}
public IActionResult StoryAdd([FromForm] List <IFormFile> model)
{
try
{
var currentUserId = User.FindFirst(ClaimTypes.NameIdentifier).Value;
if (model.Any(f => f.Length == 0))
{
return(StatusCode(301, "Resim veya Video Yok"));
}
var stories = new List <Story>();
foreach (var file in model)
{
var extention = Path.GetExtension(file.FileName);
if (extention == ".jpg" || extention == ".png")
{
var uploadResult = new ImageUploadResult();
using (var stream = file.OpenReadStream())
{
var uploadParams = new ImageUploadParams
{
File = new FileDescription(file.Name, stream),
};
uploadResult = _cloudinary.Upload(uploadParams);
}
stories.Add(new Story()
{
Id = Guid.NewGuid(),
StoryUrl = uploadResult.Uri.ToString(),
UserId = Guid.Parse(currentUserId),
PublicId = uploadResult.PublicId,
CreatedDate = DateTime.Now,
IsActive = true
});
}
if (extention == ".mp4")
{
var uploadvideoResult = new VideoUploadResult();
using (var stream = file.OpenReadStream())
{
var uploadParams = new VideoUploadParams()
{
File = new FileDescription(file.Name, stream)
};
uploadvideoResult = _cloudinary.Upload(uploadParams);
}
stories.Add(new Story()
{
Id = Guid.NewGuid(),
StoryUrl = uploadvideoResult.Uri.ToString(),
UserId = Guid.Parse(currentUserId),
PublicId = uploadvideoResult.PublicId,
CreatedDate = DateTime.Now,
IsActive = true
});
}
}
_storyService.AddRange(stories);
return(StatusCode(200, "Başarılı"));
}
catch (Exception e)
{
return(StatusCode(302, "Hata oluştu"));
}
}
public IActionResult Add([FromForm] PostDTO model)
{
try
{
var currentUserId = User.FindFirst(ClaimTypes.NameIdentifier).Value;
var guid = Guid.NewGuid();
if (model.Photos.Count == 0)
{
return(StatusCode(397));
}
if (model.Photos == null)
{
return(StatusCode(398));
}
var images = new List <Image>();
foreach (var file in model.Photos)
{
var extention = Path.GetExtension(file.FileName);
if (extention == ".jpg" || extention == ".png")
{
var uploadResult = new ImageUploadResult();
using (var stream = file.OpenReadStream())
{
var uploadParams = new ImageUploadParams
{
File = new FileDescription(file.Name, stream),
};
uploadResult = _cloudinary.Upload(uploadParams);
}
images.Add(new Image
{
Id = Guid.NewGuid(),
ImageUrls = uploadResult.Uri.ToString(),
PostId = guid,
PublicId = uploadResult.PublicId
});
}
if (extention == ".mp4")
{
var uploadvideoResult = new VideoUploadResult();
using (var stream = file.OpenReadStream())
{
var uploadParams = new VideoUploadParams()
{
File = new FileDescription(file.Name, stream)
};
uploadvideoResult = _cloudinary.Upload(uploadParams);
}
images.Add(new Image
{
Id = Guid.NewGuid(),
ImageUrls = uploadvideoResult.Uri.ToString(),
PostId = guid,
PublicId = uploadvideoResult.PublicId
});
}
}
_imageService.AddRange(images);
if (model.Steps != null)
{
List <Step> steps = new List <Step>();
foreach (var step in model.Steps)
{
steps.Add(new Step {
Id = Guid.NewGuid(), PostId = guid, Description = step
});
}
_stepService.AddRange(steps);
}
if (model.Ingredients != null)
{
List <Ingredients> ingredientses = new List <Ingredients>();
foreach (var ingredient in model.Ingredients)
{
ingredientses.Add(new Ingredients
{
Id = Guid.NewGuid(), PostId = guid, Ingredient = ingredient
});
}
_ingredientService.AddRange(ingredientses);
}
_postService.Add(new Post
{
Id = guid, Description = model.Description, UserId = Guid.Parse(currentUserId),
PostDate = DateTime.Now, LikeCount = 0, Title = model.Title, StarGivenUserCount = 0, SumStar = 0,
Star = 0
});
return(Ok("Success"));
}
catch (Exception e)
{
return(StatusCode(399));
}
}
