public async Task <bool> Create(PayloadModel payload)
{
bool result = false;
var model = _context.HistoryData.Where(x => x.Key == payload.Key).FirstOrDefault();
try
{
if (model != null)
{
model.FirstName = payload.FirstName;
model.LastName = payload.LastName;
model.Address = payload.Address;
model.UpdatedDate = DateTime.UtcNow;
_context.Update(model);
await _context.SaveChangesAsync();
result = true;
}
else
{
payload.Id = Guid.NewGuid();
payload.CreatedDate = DateTime.UtcNow;
_context.HistoryData.Add(payload);
await _context.SaveChangesAsync();
result = true;
}
}
catch (Exception ex)
{
throw new Exception(ex.Message.ToString());
}
return(result);
}
public override async Task Start(int botId, Guid agentId)
{
var bot = await botRepository.GetById(botId);
OutMessage outMessage = null;
var serializer = new DataContractSerializer(typeof(OutMessage));
using (var reader = XmlReader.Create(bot.InvitationMessage))
{
outMessage = (OutMessage)serializer.ReadObject(reader);
}
//
var model = new PayloadModel<OutMessage>
{
BotId = botId,
AgentId = agentId,
Message = outMessage
};
using (var httpClient = new HttpClient())
{
httpClient.BaseAddress = new Uri("https://localhost:5001/api/");
{
context.SetState<SubscribedState>();
await context.Start(botId, agentId);
}
public Task HandleGuildDeleteAsync(PayloadModel payload)
{
var model = payload.D.ToType <WebSocketGuildModel>();
if (model.Unavailable.HasValue)
{
if (!_guilds.TryGetValue(model.Id, out var guild))
{
Log(LogSeverity.Information, $"Guild {model.Id} is uncached and became unavailable.");
return(Task.CompletedTask);
}
// TODO set unavailable or something
Log(LogSeverity.Information, $"Guild '{guild}' ({guild.Id}) became unavailable.");
return(_client._guildUnavailable.InvokeAsync(new GuildUnavailableEventArgs(guild)));
}
else
{
if (!_guilds.TryRemove(model.Id, out var guild))
{
// This should only ever be the case for user tokens and lurkable guilds?
Log(LogSeverity.Information, $"Left uncached guild {model.Id}.");
return(Task.CompletedTask);
}
foreach (var member in guild.Members.Values)
{
member.SharedUser.References--;
}
Log(LogSeverity.Information, $"Left guild '{guild}' ({guild.Id}).");
return(_client._leftGuild.InvokeAsync(new LeftGuildEventArgs(guild)));
}
}
private static async Task SendD2CMessageAsync(string displayName, string address, double low, double high, string engUnit)
{
while (true)
{
Random rnd = new Random();
double value = rnd.NextDouble() * (high - low) + low;
PayloadModel messagePayload = new PayloadModel();
messagePayload.DisplayName = displayName;
messagePayload.Address = address;
messagePayload.Value = Math.Round(value, 2);
messagePayload.EngUnit = engUnit;
messagePayload.SourceTimestamp = DateTime.UtcNow;
var messagePayloadInJson = JsonConvert.SerializeObject(messagePayload);
var encodedMessage = new Message(Encoding.ASCII.GetBytes(messagePayloadInJson));
await deviceClient.SendEventAsync(encodedMessage);
Console.WriteLine($"Message sent: {messagePayloadInJson}");
Task.Delay(60000).Wait(); //Send message every 5 seconds
}
}
public async void Update_Exist_Version()
{
//arrange
var record = new PayloadModel
{
Key = "customer.1",
FirstName = "new name",
LastName = "manea",
Address = "earth"
};
var options = new DbContextOptionsBuilder <HistoryContext>()
.UseInMemoryDatabase(databaseName: "MyData2").Options;
// Seed Data
using (var context = new HistoryContext(options))
{
context.HistoryData.Add(new PayloadModel {
Key = "customer.1", FirstName = "siaf", LastName = "manea", Address = "berlin", CreatedDate = DateTime.UtcNow
});
_ = context.AddAsync(record);
_ = context.SaveChangesAsync();
}
// Act
using (var context = new HistoryContext(options))
{
RegistrationHistoryService historyRepository = new RegistrationHistoryService(context);
// Assert
Assert.True(await historyRepository.Create(record));
}
}
public Task HandleMessageCreateAsync(PayloadModel payload)
{
var model = payload.D.ToType <MessageModel>();
ICachedMessageChannel channel;
CachedUser author;
CachedGuild guild = null;
var isWebhook = model.WebhookId.HasValue;
if (model.GuildId != null)
{
guild = GetGuild(model.GuildId.Value);
channel = guild.GetTextChannel(model.ChannelId);
}
else
{
channel = GetPrivateChannel(model.ChannelId);
}
if (isWebhook)
{
author = new CachedUnknownUser(_client, model.Author.Value);
}
else
{
if (model.GuildId != null)
{
author = model.Author.HasValue && model.Member.HasValue
? GetOrAddMember(guild, model.Member.Value, model.Author.Value)
: guild.GetMember(model.Author.Value.Id);
}
else
{
author = GetUser(model.Author.Value.Id);
}
}
if (author == null && !isWebhook)
{
Log(LogSeverity.Warning, $"Uncached author and/or guild == null in MESSAGE_CREATE.\n{payload.D}");
return(Task.CompletedTask);
}
var message = CachedMessage.Create(channel, author, model);
if (message is CachedUserMessage userMessage)
{
_messageCache?.TryAddMessage(userMessage);
}
if (guild != null)
{
(channel as CachedTextChannel).LastMessageId = message.Id;
}
else
{
(channel as CachedPrivateChannel).LastMessageId = message.Id;
}
return(_client._messageReceived.InvokeAsync(new MessageReceivedEventArgs(message)));
}
public Task HandleGuildCreateAsync(PayloadModel payload)
{
var model = payload.D.ToType <WebSocketGuildModel>();
var guild = _guilds.AddOrUpdate(model.Id,
_ => new CachedGuild(_client, model),
(_, oldValue) =>
{
oldValue.Update(model);
return(oldValue);
});
if (model.Unavailable.HasValue)
{
_client.GetGateway(model.Id).Log(LogSeverity.Information, $"Guild '{guild}' ({guild.Id}) became available.");
return(_client._guildAvailable.InvokeAsync(new GuildAvailableEventArgs(guild)));
}
else
{
if (guild.IsLarge)
{
_ = _client.GetGateway(guild.Id).SendRequestMembersAsync(guild.Id);
}
_client.GetGateway(model.Id).Log(LogSeverity.Information, $"Joined guild '{guild}' ({guild.Id}).");
return(_client._joinedGuild.InvokeAsync(new JoinedGuildEventArgs(guild)));
}
}
/**
* pay接口： 星云地址之间的转账
* @param goods 商品详情
* @param to 转账目标地址
* @param value 转账value，单位为wei (1NAS =10^18 wei)
*/
public static void Pay(GoodsModel goods, String to, String value, String serialNumber)
{
OpenAppMode openAppMode = new OpenAppMode();
openAppMode.category = Constants.CATEGORY;
openAppMode.des = Constants.DESCRIPTION;
PageParamsModel pageParamsModel = new PageParamsModel();
pageParamsModel.serialNumber = serialNumber;
pageParamsModel.callback = isMainnet ? mainnetUrl : testnetUrl;
pageParamsModel.goods = goods;
PayloadModel payloadModel = new PayloadModel();
payloadModel.type = Constants.PAY_PAYLOAD_TYPE;
PayModel payModel = new PayModel();
payModel.currency = Constants.PAY_CURRENCY;
payModel.payload = payloadModel;
payModel.value = value;
payModel.to = to;
pageParamsModel.pay = payModel;
openAppMode.pageParams = pageParamsModel;
String _params = OpenAppMode.getOpenAppModel(openAppMode);
String url = OpenAppSchema.getSchemaUrl(_params);
ContractAction.start(url);
}
public Task HandleMessageReactionRemoveAsync(PayloadModel payload)
{
var model = payload.D.ToType <MessageReactionRemoveModel>();
var channel = model.GuildId != null
? GetGuildChannel(model.ChannelId) as ICachedMessageChannel
: GetPrivateChannel(model.ChannelId);
if (channel == null)
{
Log(LogSeverity.Warning, $"Uncached channel in MessageReactionRemove. Id: {model.ChannelId}");
return(Task.CompletedTask);
}
var message = channel.GetMessage(model.MessageId);
ReactionData reaction = null;
if (message != null)
{
message._reactions.TryGetValue(model.Emoji.ToEmoji(), out reaction);
if (reaction != null)
{
var count = reaction.Count - 1;
if (count == 0)
{
message._reactions.TryRemove(reaction.Emoji, out _);
}
else
{
reaction.Count--;
if (model.UserId == _currentUser.Id)
{
reaction.HasCurrentUserReacted = false;
}
}
}
}
var messageOptional = FetchableSnowflakeOptional.Create <CachedMessage, RestMessage, IMessage>(
model.MessageId, message, RestFetchable.Create((this, model), (tuple, options) =>
{
var(@this, model) = tuple;
return(@this._client.GetMessageAsync(model.ChannelId, model.MessageId, options));
}));
var userOptional = FetchableSnowflakeOptional.Create <CachedUser, RestUser, IUser>(
model.UserId, channel is CachedTextChannel textChannel
? textChannel.Guild.GetMember(model.UserId) ?? GetUser(model.UserId)
: GetUser(model.UserId),
RestFetchable.Create((this, model), async(tuple, options) =>
{
var(@this, model) = tuple;
return(model.GuildId != null
? await @this._client.GetMemberAsync(model.GuildId.Value, model.UserId, options).ConfigureAwait(false)
?? await @this._client.GetUserAsync(model.UserId, options).ConfigureAwait(false)
: await @this._client.GetUserAsync(model.UserId, options).ConfigureAwait(false));
}));
return(_client._reactionRemoved.InvokeAsync(new ReactionRemovedEventArgs(
channel, messageOptional, userOptional, reaction ?? Optional <ReactionData> .Empty, model.Emoji.ToEmoji())));
}
public void TestInitialize()
{
_model = GenFu.GenFu.New <PayloadModel>();
using (var aes = Aes.Create())
{
_sut = new AesPayloadProtector(new KeyProvider(aes.Key));
}
}
public Task HandleGuildMemberAddAsync(PayloadModel payload)
{
var model = Serializer.ToObject <GuildMemberAddModel>(payload.D);
var guild = GetGuild(model.GuildId);
var member = AddMember(guild, model, model.User);
return(_client._memberJoined.InvokeAsync(new MemberJoinedEventArgs(member)));
}
public Task HandleGuildRoleDeleteAsync(PayloadModel payload)
{
var model = payload.D.ToType <GuildRoleDeleteModel>();
var guild = GetGuild(model.GuildId);
guild._roles.TryRemove(model.RoleId, out var role);
return(_client._roleDeleted.InvokeAsync(new RoleDeletedEventArgs(role)));
}
public Task HandleRelationshipRemoveAsync(PayloadModel payload)
{
var model = Serializer.ToObject <RelationshipModel>(payload.D);
_currentUser._relationships.TryRemove(model.Id, out var relationship);
relationship.User.SharedUser.References--;
return(_client._relationshipDeleted.InvokeAsync(new RelationshipDeletedEventArgs(relationship)));
}
public Task HandleGuildSyncAsync(PayloadModel payload)
{
var model = Serializer.ToObject <GuildSyncModel>(payload.D);
var guild = GetGuild(model.Id);
guild?.Update(model);
guild.SyncTcs.SetResult(true);
GC.Collect();
return(Task.CompletedTask);
}
public Task HandleGuildEmojisUpdateAsync(PayloadModel payload)
{
var model = payload.D.ToType <GuildEmojisUpdateModel>();
var guild = GetGuild(model.GuildId);
var oldEmojis = guild.Emojis;
guild.Update(model.Emojis);
return(_client._guildEmojisUpdated.InvokeAsync(new GuildEmojisUpdatedEventArgs(guild, oldEmojis)));
}
public Task HandleRelationshipAddAsync(PayloadModel payload)
{
var model = Serializer.ToObject <RelationshipModel>(payload.D);
var relationship = _currentUser._relationships.AddOrUpdate(model.Id, _ => new CachedRelationship(_client, model), (_, old) =>
{
old.Update(model);
return(old);
});
return(_client._relationshipCreated.InvokeAsync(new RelationshipCreatedEventArgs(relationship)));
}
internal async Task SendAsync(PayloadModel payload, CancellationToken cancellationToken)
{
var json = Serializer.Serialize(payload);
if (Library.Debug.DumpJson)
{
Library.Debug.DumpWriter.WriteLine(Encoding.UTF8.GetString(json.Span));
}
await _ws.SendAsync(new WebSocketRequest(json, cancellationToken)).ConfigureAwait(false);
}
public async Task <IActionResult> AddVersion([FromBody] PayloadModel payload)
{
if (!ModelState.IsValid)
{
return(BadRequest("One or more required values not given!"));
}
bool result = await _historyRegistration.Create(payload);
return(result == true?Json(new { Message = "Added Successfully",
HttpStatusCode.Created }) : Json(new { HttpStatusCode.BadRequest }));
}
public Task HandleUserNoteUpdateAsync(PayloadModel payload)
{
var model = Serializer.ToObject <UserNoteUpdateModel>(payload.D);
string oldNote = null;
_currentUser._notes.AddOrUpdate(model.Id, model.Note, (_, old) =>
{
oldNote = old;
return(model.Note);
});
return(_client._userNoteUpdated.InvokeAsync(new UserNoteUpdatedEventArgs(_client, model.Id, oldNote, model.Note)));
}
public IActionResult In([FromBody] PayloadModel <InMessage> model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var messageType = model.Message.DetermineMessageType();
var stateContext = stateMachineService.Get(model.AgentId);
return(Ok());
}
public Task HandleVoiceServerUpdateAsync(PayloadModel payload)
{
var model = Serializer.ToObject <VoiceServerUpdateModel>(payload.D);
if (model.GuildId == null)
{
return(Task.CompletedTask);
}
var guild = GetGuild(model.GuildId.Value);
return(_client._voiceServerUpdated.InvokeAsync(new VoiceServerUpdatedEventArgs(guild, model.Token, model.Endpoint)));
}
public IActionResult Index()
{
PayloadModel model = new PayloadModel();
model.Title = "Realpage";
model.SubTitle = "Notification Buddy";
model.Body = "A GOOD LAUGH and LONG SLEEP are two BEST CURES for anything";
model.Actions = new List <string>()
{
"Yes", "No"
};
return(View(model));
}
