public async Task <IActionResult> SendMessageAsync([FromBody] SendMessageParams messageInfo)
{
try
{
var contactUser = await userProvider.GetUserWithUserNameAsync(messageInfo.ContactUserName);
var senderUser = await userProvider.GetCurrentUser();
if (contactUser == null)
{
return(NotFound(Response <string> .GetError(null, $"There is no user with name: '{messageInfo.ContactUserName}'")));
}
var isUserBlocked = userService.IsUserAlreadyBlocked(contactUser, senderUser);
if (isUserBlocked)
{
return(BadRequest(Response <string> .GetError(null, "User restricted for sending message to contact user")));
}
var result = messageService.CreateMessageInfo(messageInfo, senderUser, contactUser);
if (result != null)
{
return(Ok(Response <CreateMessageInfoResponse> .GetSuccess(result)));
}
else
{
return(BadRequest(Response <string> .GetError(null, "Message could not send")));
}
}
catch (Exception ex)
{
logger.LogError(ex, ex.Message);
return(StatusCode(500, Response <string> .GetError(null, "An error occured")));
}
}
/// <summary>
/// Sends a message to the given sender (user or group chat)
/// </summary>
/// <param name="messageParams"/>Information of message to send/param>
/// <returns>Message that was sent</returns>
public Message SendMessage(SendMessageParams messageParams)
{
if (messageParams == null)
{
throw new ArgumentNullException(nameof(messageParams));
}
var request = Utils.GenerateRestRequest(Resources.Method_SendMessage, Method.POST, null,
new Dictionary <string, object>
{
{ Resources.Param_ChatId, messageParams.ChatId },
{ Resources.Param_Text, messageParams.Text },
{ Resources.Param_ParseMode, messageParams.ParseMode },
{ Resources.Param_DisableWebPagePreview, messageParams.DisableWebPagePreview },
});
if (messageParams.ReplyToMessage != null)
{
request.AddParameter(Resources.Param_ReplyToMmessageId, messageParams.ReplyToMessage.MessageId);
}
if (messageParams.CustomKeyboard != null)
{
request.AddParameter(Resources.Param_ReplyMarkup,
new RestRequest().JsonSerializer.Serialize(messageParams.CustomKeyboard));
}
var result = _botClient.Execute <Message>(request);
return(result.Data);
}
public void SendMessageTest()
{
Message message = null;
messageRepository.Setup(x => x.Add(It.IsAny <Message>())).Callback <Message>(m => message = m);
SendMessageParams param = new SendMessageParams()
{
AuthorID = 1,
Content = "Siema Heniek",
Date = DateTime.Now,
ThreadID = 10,
Day = GameHelper.CurrentDay
};
messageService.SendMessage(param);
Assert.AreEqual(message.AuthorID, param.AuthorID);
Assert.AreEqual(message.Content, param.Content);
Assert.AreEqual(message.Date, param.Date);
Assert.AreEqual(message.ThreadID, param.ThreadID);
Assert.AreEqual(message.Day, GameHelper.CurrentDay);
}
public BookModelService(IRepository <Client> clientRepository, IRepository <Author> authorRepository, IRepository <BookModel> repository, IOptions <SendMessageParams> options)
{
_clientRepository = clientRepository;
_authorRepository = authorRepository;
_repository = repository;
_options = options.Value;
}
/// <summary>
///
/// </summary>
/// <param name="toAccount"></param>
/// <param name="fromAccount"></param>
/// <param name="messageType"></param>
/// <param name="message"></param>
/// <param name="extParams"></param>
/// <returns></returns>
public bool SendMessage(string toAccount, string fromAccount, string messageType, string message, IDictionary <string, object> extParams)
{
if (false == this.LoadAccessToken())
{
return(false);
}
var sendMessageUrl = string.Format(SendMessageApi, this.OrgName, this.AppName);
var data = new SendMessageParams()
{
TargetType = "users", //给用户发消息
Target = new string[] { toAccount },
From = fromAccount,
ExtParams = extParams,
Message = new SendMessageParams.SendMessageParams_Message()
{
Type = messageType,
Msg = message
}
};
var tokenResponse = HttpJson(HttpDecorator.HttpMethod.POST, sendMessageUrl, data);
if (IsErrorResult(tokenResponse.Content))
{
LogManager.GetLogger().Error("Easemob-Error(SendMessage): {0}[{1},{2}] => {3}", sendMessageUrl, this.AccessToken, fromAccount, JsonConvert.SerializeObject(data));
return(false);
}
else
{
LogManager.GetLogger().Info("Easemob-Result(SendMessage): {0}[{1},{2}] => {3}", sendMessageUrl, this.AccessToken, fromAccount, JsonConvert.SerializeObject(data));
return(true);
}
}
public CreateMessageInfoResponse CreateMessageInfo(SendMessageParams message,
User senderUser,
User contactUser)
{
var messageInfo = GetInsertMessageInfo(senderUser, contactUser, message);
MessageInfoToMongo(messageInfo);
return(GetResponseCreateMessageInfo(messageInfo));
}
private MessageInfo GetInsertMessageInfo(User senderUser,
User contactUser,
SendMessageParams message)
{
return(new MessageInfo()
{
SenderUserId = senderUser.Id,
SenderUserEmail = senderUser.Email,
SenderUserUserName = senderUser.Email,
ContactUserId = contactUser.Id,
ContactUserEmail = contactUser.Email,
ContactUserUserName = contactUser.Email,
MessageText = message.MessageText,
CreatedAt = DateTime.Now,
});
}
public Message SendMessage(SendMessageParams pars)
{
var message = new Message()
{
AuthorID = pars.AuthorID,
Content = pars.Content,
Date = pars.Date,
Day = pars.Day,
ThreadID = pars.ThreadID
};
messageRepository.Add(message);
messageRepository.SaveChanges();
return(message);
}
public RedirectToRouteResult SendMessage(int threadID, string content)
{
var entity = SessionHelper.CurrentEntity;
var ps = new SendMessageParams()
{
AuthorID = entity.EntityID,
Content = content,
Date = DateTime.Now,
Day = GameHelper.CurrentDay,
ThreadID = threadID
};
messageService.SendMessage(ps);
return(RedirectToAction("Message", new { threadID = threadID }));
}
public ActionResult Send(SendMessageViewModel vm)
{
SendMessageValidator validator = new SendMessageValidator(ModelState, entityRepository);
validator.Validate(vm);
if (validator.IsValid)
{
var user = SessionHelper.CurrentEntity;
List <int> recipients = new List <int>()
{
user.EntityID,
};
if (vm.RecipientID.HasValue)
{
recipients.Add(vm.RecipientID.Value);
}
else
{
var recipientID = entityRepository.Where(e => e.Name.ToLower() == vm.RecipientName.ToLower()).Select(e => e.EntityID).FirstOrDefault();
recipients.Add(recipientID);
}
var thread = messageService.CreateNewThread(recipients, vm.Title);
var param = new SendMessageParams()
{
AuthorID = user.EntityID,
Content = vm.Content,
Date = DateTime.Now,
Day = GameHelper.CurrentDay,
ThreadID = thread.ID
};
messageService.SendMessage(param);
return(RedirectToAction("Message", new { threadID = thread.ID }));
}
return(View(vm));
}
public HttpResponseMessage SendMessage(SendMessageParams submitted)
{
try
{
if (!Common.HasGroupReadPermission(submitted.ResourceGroupId))
Request.CreateResponse(HttpStatusCode.Unauthorized, new { Message = App_GlobalResources.Errors.ErrorNotAuthorized });
var message = _repository.Update(UpdateMessage(new MessageViewModel(submitted.Message)));
Components.Notifications.SendMessage(Components.Common.ViewMailUrl(ActiveModule.ModuleID, message.MessageId),message.ExpireDate,ActiveModule.PortalID,message.MessageTo,message.MessageCc,message.MessageCco);
return Request.CreateResponse(HttpStatusCode.OK, new
{
Success = true,
PostBackUrl = Components.Common.GroupsUrl(ActiveModule.ModuleID)
});
}
catch (Exception)
{
return Request.CreateResponse(HttpStatusCode.InternalServerError, App_GlobalResources.Errors.ErrorGeneric);
}
}
public Citizen CreateCitizen(RegisterInfo info)
{
var entity = entitiesService.CreateEntity(info.Name, EntityTypeEnum.Citizen);
entity.Equipment.ItemCapacity = 25;
var country = countriesRepository.GetById(info.CountryID);
Citizen citizen = new Citizen()
{
BirthDay = configurationRepository.GetCurrentDay(),
CreationDate = DateTime.Now,
CitizenshipID = info.CountryID,
Email = info.Email,
RegionID = info.RegionID,
Verified = true,
PlayerTypeID = (int)info.PlayerType,
ID = entity.EntityID,
HitPoints = 100
};
using (NoSaveChanges)
SetPassword(citizen, info.Password);
var currency = Persistent.Countries.GetCountryCurrency(country);
walletService.AddMoney(entity.WalletID, new Money(currency, 50));
walletService.AddMoney(entity.WalletID, new Money(GameHelper.Gold, 5));
equipmentService.GiveItem(ProductTypeEnum.Bread, 5, 1, entity.Equipment);
citizenRepository.Add(citizen);
citizenRepository.SaveChanges();
Money citizenFee = new Money(Persistent.Currencies.GetById(country.CurrencyID), country.CountryPolicy.CitizenFee);
if (walletService.HaveMoney(country.Entity.WalletID, citizenFee))
{
Transaction feeTransaction = new Transaction()
{
Arg1 = "Citizen Fee",
Arg2 = info.Name,
DestinationEntityID = citizen.ID,
Money = citizenFee,
SourceEntityID = country.ID,
TransactionType = TransactionTypeEnum.CitizenFee
};
transactionService.MakeTransaction(feeTransaction);
}
else
{
string citMessage = "Your country did not have enough money to give you birth starting money.";
warningService.AddWarning(citizen.ID, citMessage);
var citLink = EntityLinkCreator.Create(citizen.Entity);
string countryMessage = $"You did not have enough money to give birth starting money to {citLink}.";
warningService.AddWarning(country.ID, countryMessage);
}
string welcomeMessage = country.GreetingMessage;
var thread = messageService.CreateNewThread(new List <int> {
citizen.ID, country.ID
}, "Welcome message");
var smp = new SendMessageParams()
{
AuthorID = country.ID,
Content = welcomeMessage,
Date = DateTime.Now,
Day = GameHelper.CurrentDay,
ThreadID = thread.ID
};
messageService.SendMessage(smp);
return(citizen);
}
