public void Add(TweetDTO model, string userName, string content, IFormFile image)
{
var user = _uow.User.Find(x => x.UserName == userName);
model.Content = content;
model.UserId = user.Id;
if (image != null)
{
string uploadDir = Path.Combine(_environment.WebRootPath, "media/tweet");
if (!Directory.Exists(uploadDir))
{
Directory.CreateDirectory(uploadDir);
}
string fileName = Path.GetFileName(image.FileName);
using (FileStream stream = new FileStream(Path.Combine(uploadDir, fileName), FileMode.Create))
{
image.CopyTo(stream);
model.ImagePath = fileName;
}
}
Tweet tweet = _mapper.Map <Tweet>(model);
tweet.CreatedDate = DateTime.Now;
_uow.Tweet.Add(tweet);
_uow.SaveChange();
}
public int AddNewTweet(TweetDTO twt)
{
int currid;
try
{
using (GlitterDBEntities dbContext = new GlitterDBEntities())
{
Tweet tweet = new Tweet()
{
Content = twt.Content,
PostDate = DateTime.Now,
UserId = twt.UserId, //Alert
LikeCount = 0,
DislikeCount = 0,
Active = true,
UpdateDate = DateTime.Now
};
dbContext.Tweets.Add(tweet);
dbContext.SaveChanges();
currid = dbContext.Tweets.Max(s => s.TweetId);
}
}
catch (Exception ex)
{
throw ex;
}
return(currid);
}
public TweetDTO AddTweet(TweetDTO tweetDTO)
{
TweetDTO result;
try {
int userId = db.Users.Where(x => x.Email == tweetDTO.Email).Select(x => x.UserId).FirstOrDefault();
tweetDTO.UserId = userId;
Tweet tweet = new Tweet();
tweet.TweetContent = tweetDTO.TweetContent;
tweet.UserId = tweetDTO.UserId;
tweet.Time = DateTime.Now;
db.Tweets.Add(tweet);
Save();
var tweetObj = db.Tweets.OrderByDescending(x => x.Time).First();
var tweetUser = db.Users.Where(x => x.UserId == tweetObj.UserId).FirstOrDefault();
TweetDTO OutTweetDTO = new TweetDTO();
OutTweetDTO.TweetContent = tweetObj.TweetContent;
OutTweetDTO.TweetId = tweetObj.TweetId;
OutTweetDTO.UserId = tweetObj.UserId;
OutTweetDTO.Time = tweetObj.Time;
OutTweetDTO.Name = tweetUser.Name;
OutTweetDTO.ImagePath = tweetUser.ProfileImage;
result = OutTweetDTO;
}
catch (Exception) {
Console.WriteLine("Exception in database handling");
result = null;
}
return(result);
}
// tweets are searched on the basis of the hashtags
public IList <TweetDTO> GetSearchedTweets(string search)
{
IList <TweetDTO> tweets = new List <TweetDTO>();
try
{
int hashTagId = 0;
hashTagId = db.HashTags.Where(x => x.HashTagContent.Contains(search)).Select(x => x.HashTagId).FirstOrDefault();
var tweetIds = db.HashTagTweetMaps.Where(x => x.HashTagId == hashTagId).Select(x => x.TweetId).ToList();
//get the corrosponding tweets
foreach (int tweetId in tweetIds)
{
TweetDTO tweetObj = new TweetDTO();
var tweet = db.Tweets.Where(x => x.TweetId == tweetId).FirstOrDefault();
var tweetUser = db.Users.Where(x => x.UserId == tweet.UserId).FirstOrDefault();
tweetObj.TweetId = tweet.TweetId;
tweetObj.TweetContent = tweet.TweetContent;
tweetObj.UserId = tweet.UserId;
tweetObj.Time = tweet.Time;
tweetObj.Name = tweetUser.Name;
tweetObj.ImagePath = tweetUser.ProfileImage;
tweets.Add(tweetObj);
}
return(tweets);
}
catch (Exception e)
{
tweets = null;
return(tweets);
}
}
public void SampleStreamOnTweetReceived(object?sender, TweetReceivedEventArgs e)
{
IMyTweetDTO myTweetDTO = null;
try
{
var mapper = _container.Resolve <IMapper>();
TweetDTO tweetDto = mapper.Map <TweetDTO>(e.Tweet);
myTweetDTO = new MyTweetDTO
{
Tweet = tweetDto
};
}
catch (Exception ex)
{
}
_totalNumberOfTweetsActorRef.Tell(myTweetDTO);
_tweetAverageActorRef.Tell(myTweetDTO);
//_topEmojisUsedActorRef.Tell(myTweetDTO);
//_percentOfTweetsContainingEmojisActorRef.Tell(myTweetDTO);
//_topHashTagsActorRef.Tell(myTweetDTO);
//_percentOfTweetsWithUrlActorRef.Tell(myTweetDTO);
//_percentOfTweetsWithPhotoUrlActorRef.Tell(myTweetDTO;
//_topDomainsActorRef.Tell(myTweetDTO);
}
public TweetUserResponse(TweetDTO tweet)
{
Id = tweet.UserId;
Name = tweet.Name;
UserName = tweet.UserName;
PhotoUrl = tweet.PhotoUrl;
}
public static TweetDTO AddTweet(TweetDTO tweetObject)
{
TweetDTO newTweet = null;
try
{
using (CMSTweetDBEntities111 context = new CMSTweetDBEntities111())
{
Tweet tweet = new Tweet
{
TweetContent = tweetObject.TweetContent,
UserId = tweetObject.UserId,
Date = tweetObject.Date
};
context.Tweets.Add(tweet);
if (context.SaveChanges() > 0)
{
newTweet = tweetObject;
}
}
}
catch (Exception e)
{
Console.Write(e);
}
return newTweet;
}
public TweetDTO GetTweet(int id)
{
TweetDTO tweet = null;
using var connection = Common.GetConnection();
using var command = SQL_GET_TWEET(id);
command.Connection = connection;
connection.Open();
using var reader = command.ExecuteReader();
while (reader.Read())
{
tweet = _tweetMapper.Map(reader);
if (tweet.Media == Media.Yes)
{
tweet.PhotosUrl = GetTweetPhotos(tweet.Id);
}
}
connection.Close();
return(tweet);
}
public TweetDTO AddTweet([FromBody] TweetDTO tweetDTO)
{
TweetDTO tweetObject = new TweetDTO();
tweetObject = TweetBL.AddTweet(tweetDTO.UserId, tweetDTO.TweetContent);
return(tweetObject);
}
public IActionResult RemoveTweet(TweetDTO tweetDTO)
{
//validate if the tweet id is correct
var aspUserId = this.userManager.GetUserId(HttpContext.User);
this.tweetService.RemoveTweet(tweetDTO.TweetId, aspUserId);
return(Ok());
}
public TweetVM()
{
Likes = new List <Like>();
Comments = new List <Comment>();
AppUsers = new List <AppUser>();
appUser = new AppUser();
tweetdto = new TweetDTO();
Tweets = new List <Tweet>();
}
/// <summary>
/// Forward Data From TweetRepo's
/// AddNewTweet provided Tweet Data
/// and user who posted
/// </summary>
/// <param name="newTweet"></param>
/// <returns></returns>
public List <ErrorDTO> AddNewTweet(string content, int userId)
{
//manipulations
List <ErrorDTO> errorList = null;
List <string> hash = new List <string>();
for (int i = 0; i < content.Length; i++)
{
if (content[i] == '#')
{
string temp = "";
int j;
for (j = i + 1; j < content.Length; j++)
{
if (content[j] == ' ')
{
break;
}
temp = temp + content[j];
}
hash.Add(temp);
i = j;
}
}
TweetDTO tweet = new TweetDTO
{
Content = content,
PostDate = DateTime.Now,
UserId = userId, //Alert
LikeCount = 0,
DislikeCount = 0,
UpdateDate = DateTime.Now
};
ExitTestValidationResult validationResult = Validator <TweetValidator, TweetDTO> .Validate(tweet, ruleSet : "Compose Tweet");
if (validationResult.IsValid)
{
int tweetId = this._tweetRepo.AddNewTweet(tweet);
this._hashRepo.AddNewTweetHash(hash, tweetId);
}
else
{
errorList = new List <ErrorDTO>();
ErrorDTO errorDTO = new ErrorDTO();
foreach (var item in validationResult.Errors)
{
errorDTO.ErrorMessage = item.ErrorMessage;
errorDTO.PropertyName = item.PropertyName;
errorList.Add(errorDTO);
}
}
return(errorList);
}
public TweetReponse GetTweet(int id)
{
TweetDTO tweet = _tweetRepository.GetTweet(id);
if (tweet == null)
{
return(null);
}
return(new TweetReponse(tweet));
}
public static bool UndoResponse(TweetDTO tweet)
{
UserReactionDTO undo = new UserReactionDTO
{
UserId = tweet.UserId,
TweetId = tweet.TweetId,
};
return(USERReactionDataLinker.RemoveFromResponses(undo));
}
public IActionResult AddTweet(TweetDTO tweet)
{
tweet = this.twitterApiService.GetTweetById(tweet.TweetId);
var aspUserId = this.userManager.GetUserId(HttpContext.User);
this.tweetService.SaveTweet(tweet, aspUserId);
return(this.Ok());
}
public TweetReponse(TweetDTO tweet)
{
Id = tweet.Id;
Content = tweet.Content;
Type = tweet.Type.ToString();
Media = tweet.Media;
CreatedAt = tweet.CreatedAt;
UpdatedAt = tweet.UpdatedAt;
PhotosUrl = tweet.PhotosUrl;
User = new TweetUserResponse(tweet);
}
public static bool DisLike(TweetDTO tweet)
{
UserReactionDTO dislike = new UserReactionDTO
{
UserId = tweet.UserId,
TweetId = tweet.TweetId,
IsLiked = -1
};
return(USERReactionDataLinker.AddToDislikes(dislike));
}
public TweetModel GetTweet(string id)
{
TweetsClient client = new TweetsClient(_oAuthInfo);
string tweetJson = client.GetTweet(id, _expansionsFields, _TweetFields, _MediaFields, _PollFields, _PlaceFields, _UserFields);
TweetDTO resultsDTO = JsonConvert.DeserializeObject <TweetDTO>(tweetJson);
TweetModel model = _iMapper.Map <TweetDTO, TweetModel>(resultsDTO);
return(model);
}
public TweetDTO Get(Guid Id)
{
var tweet = _uow.Tweet.GetById(Id);
try
{
TweetDTO model = _mapper.Map <TweetDTO>(tweet);
return(model);
}
catch (Exception)
{
throw;
}
}
public static bool AddHashTag(TweetDTO tweet)
{
IList <HashTagDTO> hashTagsInTheMessage = SplitHashtags(tweet);
bool isAdded = HASHTAGDataLinker.AddToHashTagList(hashTagsInTheMessage);
if (isAdded == true)
{
return(true);
}
else
{
return(false);
}
}
public async Task <bool> AddTweetToUserFavouriteCollection(string userId, TweetDTO tweetDto)
{
if (this.tweetService.GetTweetById(tweetDto.Id) == null)
{
await this.tweetService.Add(tweetDto);
}
this.userTweetRepository.Add(new UserTweet()
{
UserId = userId, TweetId = tweetDto.Id
});
return(await this.UnitOfWork.SaveChangesAsync());
}
public static bool RemoveHashTag(TweetDTO tweet)
{
//string message = tweet.Content;
IList <HashTagDTO> hashTagsInThisMessage = SplitHashtags(tweet);
bool isDeleted = HASHTAGDataLinker.DeleteFromHashTagList(hashTagsInThisMessage);
if (isDeleted == true)
{
return(true);
}
else
{
return(false);
}
}
public IHttpActionResult DeleteTweet(TweetDTO tweetDTO)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
tweetDTO = tweetBs.DeleteTweet(tweetDTO);
if (tweetDTO != null)
{
return(Ok(tweetDTO));
}
else
{
return(NotFound());
}
}
// get all tweets
public IList <TweetDTO> GetUserTweets(string email)
{
IList <TweetDTO> returnedObject = null;
try
{
using (GlitterDBEntities context = new GlitterDBEntities())
{
int id = context.Users.Where(x => x.Email == email).FirstOrDefault().UserId;
IList <TweetDTO> tweets = new List <TweetDTO>();
var followersIds = context.Follows.Where(x => x.FollowerId == id)
.Select(x => x.FollowingId).ToList();
followersIds.Add(id);
foreach (var i in followersIds)
{
var result = context.Tweets.Where(x => x.UserId == i).ToList();
foreach (var item in result)
{
var likeFlag = context.Reactions
.Where(x => x.TweetId == item.TweetId && x.UserId == id)
.Select(x => x.LikeFlag).FirstOrDefault();
TweetDTO tweet = new TweetDTO();
tweet.TweetId = item.TweetId;
tweet.TweetContent = item.TweetContent;
tweet.UserId = item.UserId;
tweet.Time = item.Time;
if (i == id)
{
tweet.Email = email;
}
else
{
tweet.Email = "*****@*****.**";
}
tweet.LikeFlag = likeFlag;
tweets.Add(tweet);
}
}
IList <TweetDTO> sortedTweets = tweets.OrderByDescending(o => o.Time).ToList();
returnedObject = sortedTweets;
}
}
catch (Exception)
{
}
return(returnedObject);
}
private static IList <HashTagDTO> SplitHashtags(TweetDTO tweet)
{
IList <HashTagDTO> listOfHashTagsInMessage = new List <HashTagDTO>();
var regex = new Regex(@"(?<=#)\w+");
var hashTagsInMessage = regex.Matches(tweet.TweetContent);
foreach (Match m in hashTagsInMessage)
{
var newhashtag = new HashTagDTO
{
HashTagName = m.ToString(),
TweetId = tweet.TweetId,
};
listOfHashTagsInMessage.Add(newhashtag);
}
return(listOfHashTagsInMessage);
}
public static TweetDTO EditTweet(TweetDTO editedTweet)
{
TweetDTO newtweet = null;
try
{
using (CMSTweetDBEntities111 context = new CMSTweetDBEntities111())
{
var tweet = context.Tweets.Find(editedTweet.TweetId);
tweet.TweetContent = editedTweet.TweetContent;
tweet.Date = editedTweet.Date;
context.SaveChanges();
}
}
catch (Exception)
{
}
return newtweet;
}
public static bool DeleteTweet(TweetDTO tweettoDelete)
{
try
{
using (CMSTweetDBEntities111 context = new CMSTweetDBEntities111())
{
var tweet = context.Tweets.Find(tweettoDelete.TweetId);
context.Tweets.Remove(tweet);
context.SaveChanges();
}
return true;
}
catch (Exception)
{
return false;
}
}
public static bool DeleteTweet(TweetDTO tweet)
{
if (HashTagBL.RemoveHashTag(tweet))
{
if (UserReactionBL.UndoResponse(tweet))
{
return(TWEETDataLinker.DeleteTweet(tweet));
}
else
{
return(false);
}
}
else
{
return(false);
}
}
public static TweetDTO EditTweet(TweetDTO beforeedit, TweetDTO afteredit)
{
if (HashTagBL.RemoveHashTag(beforeedit))
{
if (HashTagBL.AddHashTag(afteredit))
{
return(TWEETDataLinker.EditTweet(afteredit));
}
else
{
return(null);
}
}
else
{
return(null);
}
}
public void MapFromTweetToDto()
{
// Arrange
var tweetDto = new TweetDTO
{
IdStr = "str",
FullText = "text",
Retweeted = true,
CreatedAt = DateTime.Today,
CreatedBy = new UserDTO
{
IdStr = "userId",
ScreenName = "screen name"
},
Entities = new TweetEntitiesDTO
{
Medias = new List <IMediaEntity>
{
new MediaEntity
{
MediaType = "type",
MediaURL = "url"
}
}
}
};
var dto = Tweetinvi.Tweet.GenerateTweetFromDTO(tweetDto);
// Act
var model = this.mapper.Map(dto, new Status());
// Assert
Assert.Equal(dto.IdStr, model.StatusId);
Assert.Equal(dto.FullText, model.Text);
Assert.Equal(dto.Retweeted, model.Retweeted);
Assert.Equal(dto.CreatedAt, model.CreatedAt);
Assert.Equal(dto.CreatedBy.IdStr, model.CreatedById);
Assert.Equal(dto.CreatedBy.ScreenName, model.CreatedByScreenName);
var media = dto.Entities.Medias.FirstOrDefault();
Assert.Equal(media.MediaType, model.MediaType);
Assert.Equal(media.MediaURL, model.MediaUrl);
}
// TODO - does this belong here?
private static bool IsMatch(TweetDTO first, TweetDTO second)
{
return first.Date == second.Date
&& first.Text == second.Text;
}
