public async Task <FilterDetailsDto> Update(int id, FilterUpdateDto updateDto)
{
var updateFilter = _domainService.Find(id);
if (updateFilter == null)
{
throw SocialExceptions.FilterNotExists(id);
}
if (updateDto.IfPublic == false && updateFilter.IfPublic == true)
{
updateFilter.CreatedBy = UserContext.UserId;
}
_domainService.DeleteConditons(updateFilter);
Mapper.Map(updateDto, updateFilter);
_domainService.UpdateFilter(updateFilter, Mapper.Map <List <FilterConditionCreateDto>, List <FilterCondition> >(updateDto.Conditions.ToList()).ToArray());
using (var uow = UnitOfWorkManager.Begin(TransactionScopeOption.RequiresNew))
{
CurrentUnitOfWork.SaveChanges();
uow.Complete();
}
await _notificationManager.NotifyUpdateFilter(updateFilter.SiteId, updateFilter.Id);
var filterDto = Mapper.Map <FilterDetailsDto>(updateFilter);
List <FilterDetailsDto> filterDtos = new List <FilterDetailsDto>();
filterDtos.Add(filterDto);
_agentService.FillCreatedByName(filterDtos);
return(filterDto);
}
public IList <FilterManageDto> SortingFilters([Required] IList <FilterSortDto> sortDtoList)
{
if (!sortDtoList.Any())
{
throw SocialExceptions.BadRequest("sortDtoList is required.");
}
return(_appService.Sorting(sortDtoList));
}
public void CheckIfCanReopenWhenReply(Conversation conversation)
{
if (conversation.Status == ConversationStatus.Closed)
{
if (!IfCanReopen(conversation))
{
throw SocialExceptions.OnlyOneOpenConversationAllowedForPrivateMessage();
}
}
}
protected override Expression <Func <Conversation, bool> > After(string date)
{
DateTime value;
if (!DateTime.TryParse(date, out value))
{
throw SocialExceptions.BadRequest("The value of date time is invalid");
}
return(t => t.LastMessageSentTime > value);
}
public bool HasConversation(int filterId, int conversationId)
{
var filter = _domainService.Find(filterId);
if (filter == null)
{
throw SocialExceptions.FilterNotExists(filterId);
}
return(_domainService.HasConversation(filter, conversationId));
}
protected override Expression <Func <Conversation, bool> > Before(string date)
{
DateTime value;
if (!DateTime.TryParse(date, out value))
{
throw SocialExceptions.BadRequest("The value of date time is invalid");
}
return(t => t.ModifiedTime.HasValue && t.ModifiedTime.Value < value);
}
private void CheckIfCanReopenWhenUpdate(Conversation oldEntity, Conversation newEntity)
{
if (oldEntity.Status == ConversationStatus.Closed && newEntity.Status != ConversationStatus.Closed)
{
if (!IfCanReopen(oldEntity))
{
throw SocialExceptions.OnlyOneOpenConversationAllowedForPrivateMessage();
}
}
}
public FacebookPageDto GetPage(int id)
{
var entity = _socialAccountService.FindAccount(id, SocialUserSource.Facebook);
if (entity == null)
{
throw SocialExceptions.FacebookPageNotExists(id);
}
return(Mapper.Map <FacebookPageDto>(entity));
}
public void CheckFieldValue(List <FilterCondition> filterConditons)
{
var conversationField = _conversationFieldOptionService.FindAllAndFillOptions().Where(t => filterConditons.Select(f => f.FieldId).Contains(t.Id)).ToList();
foreach (var filterConditon in filterConditons)
{
if (conversationField.Where(t => t.Id == filterConditon.FieldId).FirstOrDefault().DataType == FieldDataType.DateTime)
{
if (conversationField.Where(t => t.Id == filterConditon.FieldId && t.Options.Any(o => o.Value == filterConditon.Value)).Count() == 0)
{
if (filterConditon.MatchType == ConditionMatchType.Between)
{
string[] value = filterConditon.Value.Split('|');
DateTime DateTime1;
if (!DateTime.TryParse(value[0], out DateTime1))
{
throw SocialExceptions.BadRequest("The value of date time is invalid");
}
DateTime DateTime2;
if (!DateTime.TryParse(value[1], out DateTime2))
{
throw SocialExceptions.BadRequest("The value of date time is invalid");
}
}
else
{
DateTime date;
if (!DateTime.TryParse(filterConditon.Value, out date))
{
throw SocialExceptions.BadRequest($"The value's type is not DateTime : '{filterConditon.Value}' ");
}
}
}
}
else if (conversationField.Where(t => t.Id == filterConditon.FieldId).FirstOrDefault().DataType == FieldDataType.Number)
{
int number;
if (!int.TryParse(filterConditon.Value, out number))
{
throw SocialExceptions.BadRequest($"The value's type is not Number : '{filterConditon.Value}' ");
}
}
else if (conversationField.Where(t => t.Id == filterConditon.FieldId).FirstOrDefault().DataType == FieldDataType.Option)
{
if (conversationField.Where(t => t.Id == filterConditon.FieldId && t.Options.Any(o => o.Value == filterConditon.Value)).Count() == 0)
{
if ((!departmentAddOptions.Contains(filterConditon.Value) || !departmentFieldNames.Contains(conversationField.Where(t => t.Id == filterConditon.FieldId).FirstOrDefault().Name)) &&
(!agentAddOptions.Contains(filterConditon.Value) || !agentsFieldNames.Contains(conversationField.Where(t => t.Id == filterConditon.FieldId).FirstOrDefault().Name)))
{
throw SocialExceptions.BadRequest($"The value's type is not Option : '{filterConditon.Value}' ");
}
}
}
}
}
public async Task DeleteAccountAsync(int id)
{
var entity = _socialAccountService.FindAccount(id, SocialUserSource.Twitter);
if (entity == null)
{
throw SocialExceptions.TwitterAccountNotExists(id);
}
await _socialAccountService.DeleteAsync(entity);
}
public TwitterAccountDto GetAccount(int id)
{
var entity = _socialAccountService.FindAccount(id, SocialUserSource.Twitter);
if (entity == null)
{
throw SocialExceptions.TwitterAccountNotExists(id);
}
return(Mapper.Map <TwitterAccountDto>(entity));
}
public async Task Delete(int id)
{
var filter = _domainService.Find(id);
if (filter == null)
{
throw SocialExceptions.FilterNotExists(id);
}
_domainService.Delete(id);
await _notificationManager.NotifyDeleteFilter(filter.SiteId, filter.Id);
}
protected override Expression <Func <Conversation, bool> > Is(string date)
{
DateTime value;
if (!DateTime.TryParse(date, out value))
{
throw SocialExceptions.BadRequest("The value of date time is invalid");
}
return(t => t.ModifiedTime.HasValue && ((DateTime)t.ModifiedTime.Value).Year == value.Year &&
((DateTime)t.ModifiedTime.Value).Month == value.Month &&
((DateTime)t.ModifiedTime.Value).Day == value.Day);
}
public SocialAccount MarkAsEnable(int id, bool?ifEnable = true)
{
var account = this.Find(id);
if (account == null)
{
throw SocialExceptions.SocialUserIdNotExists(id);
}
account.IfEnable = ifEnable.Value;
this.Update(account);
return(account);
}
public async Task <SocialAccount> AddFacebookPageAsync(SocialAccount socialAccount, string originalId)
{
if (IsDupliated(SocialUserSource.Facebook, originalId))
{
throw SocialExceptions.BadRequest($"'{socialAccount.SocialUser.Name}' has already been added.");
}
await _fbClient.SubscribeApp(originalId, socialAccount.Token);
var socialUser = _socialUserRepo.FindAll()
.Where(t => t.OriginalId == originalId && t.Source == SocialUserSource.Facebook)
.OrderByDescending(t => t.Id)
.FirstOrDefault();
if (socialUser == null)
{
// create a new integraton account.
await this.InsertAsync(socialAccount);
}
else
{
// if the user was a customer or a deleted integration account.
socialUser.Type = SocialUserType.IntegrationAccount; // make sure convert a customer to integration account.
socialUser.IsDeleted = false; // make sure to restore a deleted integration account.
socialUser.Avatar = socialAccount.SocialUser.Avatar;
socialUser.Email = socialAccount.SocialUser.Email;
socialUser.OriginalLink = socialAccount.SocialUser.OriginalLink;
socialAccount.Id = socialUser.Id;
socialAccount.SocialUser = socialUser;
if (socialUser.SocialAccount == null)
{
socialUser.SocialAccount = socialAccount;
}
else
{
socialUser.SocialAccount.Token = socialAccount.Token;
socialUser.SocialAccount.FacebookPageCategory = socialAccount.FacebookPageCategory;
socialUser.SocialAccount.FacebookSignInAs = socialAccount.FacebookSignInAs;
}
socialUser.SocialAccount.IsDeleted = false;
socialUser.SocialAccount.IfEnable = true;
socialUser.SocialAccount.IfConvertMessageToConversation = true;
socialUser.SocialAccount.IfConvertVisitorPostToConversation = true;
socialUser.SocialAccount.IfConvertWallPostToConversation = true;
_socialUserRepo.Update(socialUser);
await this.InsertSocialAccountInGeneralDb(SocialUserSource.Facebook, originalId);
}
CurrentUnitOfWork.SaveChanges();
return(this.Find(socialAccount.Id));
}
public async Task UnSubscribeApp(string pageId, string pageToken)
{
FacebookClient client = new FacebookClient();
try
{
await client.DeleteTaskAsync($"https://graph.facebook.com/v2.9/{pageId}/subscribed_apps?access_token={pageToken}");
}
catch (FacebookOAuthException ex)
{
throw SocialExceptions.FacebookOauthException(ex);
}
}
public async Task DeletePageAsync(int id)
{
var entity = _socialAccountService.FindAccount(id, SocialUserSource.Facebook);
if (entity == null)
{
throw SocialExceptions.FacebookPageNotExists(id);
}
await _socialAccountService.DeleteAsync(entity);
await _fbClient.UnSubscribeApp(entity.SocialUser.OriginalId, entity.Token);
}
public FilterDetailsDto Find(int id)
{
var filter = _domainService.Find(id);
if (filter == null)
{
throw SocialExceptions.FilterNotExists(id);
}
var filterDto = Mapper.Map <FilterDetailsDto>(filter);
filterDto.CreatedByName = _agentService.GetDisplayName(filterDto.CreatedBy);
return(filterDto);
}
public Message ReplyTwitterDirectMessage(int conversationId, string message, bool isCloseConversation = false)
{
var twitterService = DependencyResolver.Resolve <ITwitterService>();
Conversation conversation = _conversationService.CheckIfExists(conversationId);
if (conversation.Source != ConversationSource.TwitterDirectMessage)
{
throw SocialExceptions.BadRequest("Conversation source must be twitter direct message.");
}
_conversationService.CheckIfCanReopenWhenReply(conversation);
var messages = Repository.FindAll().Include(t => t.Sender).Include(t => t.Receiver).Where(t => t.ConversationId == conversation.Id).ToList();
SocialAccount twitterAccount = GetSocialAccountFromMessages(messages);
if (twitterAccount == null)
{
throw SocialExceptions.BadRequest($"Twitter account has been deleted.");
}
var customer = messages.Where(t => t.IsDeleted == false && t.Sender.Type == SocialUserType.Customer)
.OrderByDescending(t => t.SendTime).Select(t => t.Sender).FirstOrDefault();
if (customer == null)
{
throw new NotSupportedException($"Cant't find last message from conversation. Conversation Id={conversationId}.");
}
IUser prviousTwitterUser = twitterService.GetUser(twitterAccount, long.Parse(customer.OriginalId));
if (prviousTwitterUser == null)
{
throw new NotSupportedException($"Cant't find twitter user. Conversation Id={conversationId}.");
}
// publish twitter direct message
IMessage twitterDirectMessage = twitterService.PublishMessage(twitterAccount, prviousTwitterUser, message);
// create message to db
Message directMessage = TwitterConverter.ConvertToMessage(twitterDirectMessage);
directMessage.ConversationId = conversation.Id;
directMessage.SenderId = twitterAccount.Id;
directMessage.SendAgentId = UserContext.UserId;
directMessage.ReceiverId = customer.Id;
Save(directMessage, isCloseConversation);
return(this.Find(directMessage.Id));
}
public TwitterAccountDto UpdateAccount(int id, UpdateTwitterAccountDto dto)
{
var socialAccount = _socialAccountService.FindAccount(id, SocialUserSource.Twitter);
if (socialAccount == null)
{
throw SocialExceptions.TwitterAccountNotExists(id);
}
socialAccount = Mapper.Map(dto, socialAccount);
_socialAccountService.Update(socialAccount);
return(Mapper.Map <TwitterAccountDto>(socialAccount));
}
public Conversation CheckIfExists(int id)
{
var conversation = Repository.Find(id);
if (conversation == null)
{
throw SocialExceptions.ConversationIdNotExists(id);
}
if (conversation.IsDeleted)
{
throw SocialExceptions.ConversationIdDelete(id);
}
return(conversation);
}
public FacebookPageDto UpdatePage(int id, UpdateFacebookPageDto dto)
{
var socialAccount = _socialAccountService.FindAccount(id, SocialUserSource.Facebook);
if (socialAccount == null)
{
throw SocialExceptions.FacebookPageNotExists(id);
}
socialAccount = Mapper.Map(dto, socialAccount);
_socialAccountService.Update(socialAccount);
return(Mapper.Map <FacebookPageDto>(socialAccount));
}
public void CheckFieldIdExist(List <FilterCondition> filterConditons)
{
List <int> fieldIds = new List <int>();
foreach (var filterCondition in filterConditons)
{
fieldIds.Add(filterCondition.FieldId);
}
fieldIds.RemoveAll(a => _conversationFieldRepo.FindAll().Where(t => fieldIds.Contains(t.Id)).Select(t => t.Id).ToList().Contains(a));
if (fieldIds.Count != 0)
{
throw SocialExceptions.BadRequest($"FieldId '{fieldIds[0]}' not exists");
}
}
public FilterListDto FindSummary(int id)
{
var filter = _domainService.Find(id);
if (filter == null)
{
throw SocialExceptions.FilterNotExists(id);
}
var dto = Mapper.Map <FilterListDto>(filter);
dto.ConversationNum = _domainService.GetConversationNum(filter);
dto.CreatedByName = _agentService.GetDisplayName(dto.CreatedBy);
return(dto);
}
public Message ReplyFacebookMessage(int conversationId, string content, bool isCloseConversation = false)
{
var conversation = _conversationService.CheckIfExists(conversationId);
if (conversation.Source != ConversationSource.FacebookMessage)
{
throw SocialExceptions.BadRequest("Conversation source must be facebook message.");
}
_conversationService.CheckIfCanReopenWhenReply(conversation);
var messages = Repository.FindAll().Include(t => t.Sender).Include(t => t.Receiver).Where(t => t.ConversationId == conversation.Id).ToList();
SocialAccount socialAccount = GetSocialAccountFromMessages(messages);
if (socialAccount == null)
{
throw SocialExceptions.BadRequest("Facebook integration account can't be found from conversation.");
}
SocialUser recipient = messages.Where(t => t.Sender.Type == SocialUserType.Customer)
.OrderByDescending(t => t.SendTime)
.Select(t => t.Sender).FirstOrDefault();
// publish message to facebook
string fbMessageId = _fbClient.PublishMessage(socialAccount.Token, conversation.OriginalId, content);
if (string.IsNullOrWhiteSpace(fbMessageId))
{
return(null);
}
// create message
var message = new Message
{
ConversationId = conversation.Id,
Content = content,
SenderId = socialAccount.Id,
ReceiverId = recipient != null ? recipient.Id : socialAccount.Id,
SendAgentId = UserContext.UserId,
SendTime = DateTime.UtcNow,
OriginalId = fbMessageId,
Source = MessageSource.FacebookMessage
};
Save(message, isCloseConversation);
return(this.Find(message.Id));
}
public IQueryable <Conversation> ApplyFilter(IQueryable <Conversation> conversations, int?filterId)
{
if (filterId != null)
{
var filter = _filterRepo.Find(filterId.Value);
if (filter != null)
{
conversations = ApplyFilter(conversations, filter);
}
else
{
throw SocialExceptions.BadRequest($"filterId '{filterId}' not exists.");
}
}
return(conversations);
}
protected override Expression <Func <Conversation, bool> > Between(string date)
{
string[] value = date.Split('|');
DateTime DateTime1;
if (!DateTime.TryParse(value[0], out DateTime1))
{
throw SocialExceptions.BadRequest("The value of date time is invalid");
}
DateTime DateTime2;
if (!DateTime.TryParse(value[1], out DateTime2))
{
throw SocialExceptions.BadRequest("The value of date time is invalid");
}
return(t => t.ModifiedTime.HasValue && t.ModifiedTime.Value >= DateTime1 && t.ModifiedTime.Value <= DateTime2);
}
public async Task <FbToken> GetApplicationToken()
{
if (_applicationTokenCache != null && _applicationTokenCache.Item2 > DateTime.UtcNow)
{
return(_applicationTokenCache.Item1);
}
FacebookClient client = new FacebookClient();
FbToken fbToken = null;
try
{
dynamic result = client.Post("oauth/access_token", new
{
client_id = AppSettings.FacebookClientId,
client_secret = AppSettings.FacebookClientSecret,
grant_type = "client_credentials",
});
fbToken = new FbToken
{
AccessToken = result.access_token,
Type = result.token_type,
ExpiresIn = result.expires_in
};
}
catch (FacebookOAuthException ex)
{
throw SocialExceptions.FacebookOauthException(ex);
}
//HttpClient client = new HttpClient();
//string url =
// string.Format(
// "https://graph.facebook.com/v2.9/oauth/access_token?client_id={0}&client_secret={1}&grant_type=client_credentials",
// AppSettings.FacebookClientId,
// AppSettings.FacebookClientSecret
// );
//HttpResponseMessage response = await client.GetAsync(url);
//response.EnsureSuccessStatusCode();
//var jsonRes = await response.Content.ReadAsStringAsync();
//var fbToken = JsonConvert.DeserializeObject<FbToken>(jsonRes);
_applicationTokenCache = new Tuple <FbToken, DateTime>(fbToken, DateTime.UtcNow.AddHours(1));
return(fbToken);
}
public IList <ConversationDto> FindConversations(int socialUserId)
{
SocialUser user = _domainService.Find(socialUserId);
if (user == null)
{
throw SocialExceptions.SocialUserIdNotExists(socialUserId);
}
ConversationSearchDto searchDto = new ConversationSearchDto();
if (user != null)
{
searchDto.UserId = user.Id;
return(_conversationService.Find(searchDto));
}
return(null);
}
public string GetUserToken(string code, string redirectUri)
{
FacebookClient client = new FacebookClient();
try
{
dynamic result = client.Post("oauth/access_token", new
{
client_id = AppSettings.FacebookClientId,
client_secret = AppSettings.FacebookClientSecret,
redirect_uri = redirectUri,
code = code
});
return(result.access_token);
}
catch (FacebookOAuthException ex)
{
throw SocialExceptions.FacebookOauthException(ex);
}
}
