public async Task <IActionResult> PostStudentData(StudentModel studentModel) { RestMessage <StudentModel> response = new RestMessage <StudentModel>(); try { AuthenticationResult authenticationResult = await GetAuthenticationResult(); ServiceInterface serviceInterface = ServiceInterface.Instance; response = await serviceInterface.PostDataToAPI <StudentModel>(authenticationResult, "student", studentModel); if (!response.Success) { response.StatusText = "Error saving data"; } } catch (Exception e) { response.Exception = e; response.SetAsBadRequest(); response.StatusText = "Error saving data"; } return(Json(response)); }
public RestMessage <Dictionary <string, string> > Get(string name) { var data = new Dictionary <string, string>(); var result = new RestMessage <Dictionary <string, string> >(data); try { var values = Enum.GetValues(enumMap[name]); var names = Enum.GetNames(enumMap[name]); for (int i = 0; i < names.Length; i++) { data[names[i]] = values.GetValue(i).ToString(); } } catch (Exception err) { this.logger.LogError(err, "error during enum resolution"); result.Errors.Add(new Error() { Code = "001", Title = "Error getting enum", Description = err.Message }); } return(result); }
public async Task <IActionResult> GetStudents() { RestMessage <List <StudentModel> > response = new RestMessage <List <StudentModel> >(); try { AuthenticationResult authenticationResult = await GetAuthenticationResult(); ServiceInterface serviceInterface = ServiceInterface.Instance; response = await serviceInterface.GetDataAsync <List <StudentModel> >(authenticationResult, "student"); if (!response.Success) { response.StatusText = "Error fetching Student data"; } } catch (Exception e) { response.Exception = e; response.SetAsBadRequest(); response.StatusText = "Error fetching Student data"; } return(Json(response)); }
public RestMessage <bool> Delete(string collection, string id) { RestMessage <bool> response = new RestMessage <bool>(false); try { bool result = service.Delete(collection, id); response.Data = true; return(response); } catch (ValidationException err) { response.Errors = err.Errors; } catch (Exception untrapped) { //TODO: log here response.Errors.Add(new Library.Core.Error() { Code = "UNEXPEXTED", Title = $"{collection} produces an unexpexted error", Description = untrapped.Message, }); } return(response); }
public RestMessage <bool> Put(string collection, string id, [FromBody] JObject value) { RestMessage <bool> response = new RestMessage <bool>(false); try { value["_id"] = id; service.Update(collection, value, true); response.Data = true; return(response); } catch (ValidationException err) { response.Errors = err.Errors; } catch (Exception untrapped) { //TODO: log here response.Errors.Add(new Library.Core.Error() { Code = "UNEXPEXTED", Title = $"{collection} produces an unexpexted error", Description = untrapped.Message, }); } return(response); }
public RestMessage <JObject> Post(string collection, [FromBody] JObject value, bool omitPayload = false) { RestMessage <JObject> response = new RestMessage <JObject>(new JObject()); try { var added = service.Insert(collection, value); if (omitPayload) { response.Data["_id"] = added["_id"]; } else { response.Data = added; } return(response); } catch (ValidationException err) { response.Errors = err.Errors; } catch (Exception untrapped) { //TODO: log here response.Errors.Add(new Library.Core.Error() { Code = "UNEXPEXTED", Title = $"{collection} produces an unexpexted error", Description = untrapped.Message, }); } return(response); }
public DiscordMessage(RestMessage message) { MessageId = message.Id; AuthorId = message.Author.Id; ChannelId = message.Channel.Id; Source = message.Source; Content = message.Content; CreatedAt = message.CreatedAt; IsPinned = message.IsPinned; MentionedChannelIDs = new List <ulong>(); foreach (var channel in message.MentionedChannelIds) { MentionedChannelIDs.Add(channel); } MentionedRoleIDs = new List <ulong>(); foreach (var role in message.MentionedRoleIds) { MentionedRoleIDs.Add(role); } MentionedUserIDs = new List <ulong>(); foreach (var user in message.MentionedUsers) { MentionedUserIDs.Add(user.Id); } AttachmentIDs = new List <ulong>(); foreach (var attachment in message.Attachments) { AttachmentIDs.Add(attachment.Id); } }
/// <summary> /// Initializes a new instance of the <see cref="RawApiDataEventArgs" /> class /// </summary> /// <param name="uri">The <see cref="Uri"/> used to get the api data</param> /// <param name="restMessage">The rest message</param> /// <param name="requestParams">The parameters associated with the request</param> /// <param name="requestTime">The time needed to execute request</param> /// <param name="language">The language associated with the request</param> public RawApiDataEventArgs(Uri uri, RestMessage restMessage, string requestParams, TimeSpan requestTime, string language) { Uri = uri; RestMessage = restMessage; RequestParams = requestParams; RequestTime = requestTime; Language = language; }
public async Task GetPinAsync() { if (!Context.Channel.HasPins(out IReadOnlyCollection <RestMessage> pins)) { await ReplyAsync(embed : EmbedData.Throw(Context, "This channel has no pinned messages.")); return; } RestMessage pin = pins.ToList()[RandomProvider.Instance.Next(1, pins.Count) - 1]; await ModuleManager.TryExecute(Context.Channel, Context.Channel.SendRestMessageAsync(pin)); }
private void DispatchReceivedRawApiData(Uri uri, RestMessage restMessage, string requestParams, TimeSpan requestTime, string culture) { // send RawFeedMessage if needed try { var args = new RawApiDataEventArgs(uri, restMessage, requestParams, requestTime, culture); RawApiDataReceived?.Invoke(this, args); } catch (Exception e) { ExecutionLog.LogError(e, $"Error dispatching raw message for {uri}"); } // continue normal processing }
private void DispatchReceivedRawApiData(Uri uri, RestMessage restMessage) { // send RawFeedMessage if needed try { var args = new RawApiDataEventArgs(uri, restMessage); RawApiDataReceived?.Invoke(this, args); } catch (Exception e) { ExecutionLog.LogError($"Error dispatching raw message for {uri}", e); } // continue normal processing }
private async Task HandleCommand(RestMessage message) { if (message == null) { return; } if (!(message.Content.StartsWith(_prefix))) { return; } Logger.Log($"{message.Author.Username}: {message.Content}"); await _commandManager.ExecuteCommandAsync(message); }
public async Task ExecuteCommandAsync(RestMessage message) { await Task.Factory.StartNew(async() => { string[] commands = message.Content.Split(" "); string command = commands.FirstOrDefault()?.Substring(1); foreach (var module in _modules) { var type = module.GetType(); var methods = type.GetMethods().Where(m => m.GetCustomAttributes(typeof(CommandAttribute)).Any()); var methodToCall = methods .FirstOrDefault(m => ((MemberInfo)m).GetCustomAttributes() .Any(c => (c as CommandAttribute)?.Command == command)); if (methodToCall == null) { continue; } var instance = _modules.FirstOrDefault(m => m.GetType() == methodToCall.DeclaringType); if (instance == null) { continue; } instance.SetContext(new CommandContext(_client, message)); var parameters = methodToCall.GetParameters(); string[] splitArgs = commands.Skip(1).ToArray(); var args = new List <object>(); int i = 0; foreach (var p in parameters) { try { args.Add(Convert.ChangeType(splitArgs[i], p.ParameterType)); i++; } catch (Exception) { await _client.SendMessageAsync(message.Channel.Id, "Error bad args"); } } methodToCall.Invoke(instance, args.ToArray()); } }); }
private async Task <ItemResult> GetPlanningResult(RestMessage message) { var yesReactions = await message.GetReactionsAsync(YesReaction); var maybeReactions = await message.GetReactionsAsync(MaybeReaction); var noReactions = await message.GetReactionsAsync(NoReaction); var result = new ItemResult() { Message = message, YesUserNames = SelectUserName(yesReactions), MaybeUserNames = SelectUserName(maybeReactions), NoUserNames = SelectUserName(noReactions), }; return(result); }
private void DispatchHandler(NetworkFrame msg) { switch (msg.Type) { case "READY": HandleReadyEvent(msg); break; case "GUILD_CREATE": HandleGuildCreate(msg); break; case "MESSAGE_CREATE": var message = JsonConvert.DeserializeObject <Message>(msg.Data.ToString()); OnMessageReceived(RestMessage.CreateMessage(message)); break; default: Logger.Log("Other type"); break; } }
private Embed GetEmbedFromMessage(RestMessage message) { return(new EmbedBuilder { Author = new EmbedAuthorBuilder { IconUrl = message.Author.GetAvatarUrl(), Name = $"{message.Author.Username}#{message.Author.Discriminator}" }, Color = GetRandomColor(), Fields = new List <EmbedFieldBuilder> { new EmbedFieldBuilder { IsInline = false, Name = "Content", Value = message.Content }, new EmbedFieldBuilder { IsInline = false, Name = "Attachments", Value = message.Attachments.Count } }, ImageUrl = message.Attachments.Count != 0 ? message.Attachments.ElementAt(0).Url : string.Empty, Timestamp = message.Timestamp, Title = "Pinned Message", Url = message.GetJumpUrl(), Footer = new EmbedFooterBuilder { Text = message.Channel.Name, IconUrl = Context.Guild.IconUrl } }.Build()); }
public static async Task SendRestMessageAsync(this ISocketMessageChannel channel, RestMessage msg) { // safemessage class for rest messages to easily convert. string content = msg.Content ?? UnicodeIndex.Invisible.ToString(); bool tts = msg.IsTTS; Embed e = null; if (msg.Embeds.Funct()) { if (msg.Embeds.Any(x => x.IsPureEmbed())) { e = msg.Embeds.Where(x => x.IsPureEmbed()).First(); } } await channel.SendMessageAsync(content, tts, e); }
private void OnMessageReceived(RestMessage msg) { MessageReceived?.Invoke(msg); }
/// <summary> /// Initializes a new instance of the <see cref="RawApiDataEventArgs" /> class /// </summary> /// <param name="uri">The <see cref="Uri" /> used to get the api data</param> /// <param name="restMessage">The rest message</param> public RawApiDataEventArgs(Uri uri, RestMessage restMessage) { Uri = uri; RestMessage = restMessage; }
public CommandContext(DiscordClient client, RestMessage message) { Client = client; Message = message; }