public async Task <string> LoginAsync(string userName, string password, AccountIdApi account, string url, List <KeyValuePair <string, string> > KeyValues) { try { await PreAPICall(); var request = new HttpRequestMessage(HttpMethod.Post, $"{constants.serverUrl}/{url}"); request.Content = new FormUrlEncodedContent(KeyValues); var respons = await httpClient.SendAsync(request); var jwt = await respons.Content.ReadAsStringAsync(); JObject jwtDynamic = JsonConvert.DeserializeObject <dynamic>(jwt); var accessToken = jwtDynamic.Value <string>("access_token"); Debug.WriteLine(jwt); AfterAPICall(); return(accessToken); } catch (Exception ex) { var logged = new LoggedException($"Error while trying to call login api {url}", ex); await logged.LoggAPI(); } return(null); }
public override int WriteException(LoggedException e) { XmlDocument doc = new XmlDocument(); XmlNode xException = doc.AppendChild(doc.CreateElement("event")); xException.AppendChild(doc.CreateElement("group")).InnerText = e.Group; xException.AppendChild(doc.CreateElement("type")).InnerText = e.Type; xException.AppendChild(doc.CreateElement("details")).InnerText = e.Details; xException.AppendChild(doc.CreateElement("message")).InnerText = e.Message; xException.AppendChild(doc.CreateElement("stacktrace")).InnerText = e.StackTrace; xException.AppendChild(doc.CreateElement("clientip")).InnerText = e.ClientIp; xException.AppendChild(doc.CreateElement("hostip")).InnerText = e.HostIp; XmlNode xApplication = xException.AppendChild(doc.CreateElement("application")); xApplication.AppendChild(doc.CreateElement("id")).InnerText = e.ApplicationId.ToString(); xApplication.AppendChild(doc.CreateElement("name")).InnerText = e.ApplicationName; xApplication.AppendChild(doc.CreateElement("type")).InnerText = e.ApplicationType.ToString(); EventLog.WriteEntry(xException.OuterXml, EventLogEntryType.Error); //EventLog does not synchronously return IDs for new events, so return 1 //This module is intended to log to a centralized logging source, not the local event log //This module is provided for exabple purposes only return(1); }
public async Task <bool> DeleteAsync(string id, string url) { try { await PreAPICall(); httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", Pt_Hippo_Mobile.Helpers.Settings.AccessToken); var response = await httpClient.DeleteAsync($"{constants.serverUrl}/{url}/{id}"); AfterAPICall(); if (response.IsSuccessStatusCode == false) { await ValidateErrors(response); return(false); } return(response.IsSuccessStatusCode); } catch (Exception ex) { var logged = new LoggedException($"Error while trying to call deleteasync api {url}", ex); await logged.LoggAPI(); } return(false); }
public async Task <T> GetClientId(string url) { try { await PreAPICall(); HttpResponseMessage response = await httpClient.GetAsync($"{constants.serverUrl}/{url}"); var stream = await response.Content.ReadAsStreamAsync(); StreamReader readStream = new StreamReader(stream, Encoding.UTF8); var json = readStream.ReadToEnd(); var account = JsonConvert.DeserializeObject <T>(json); AfterAPICall(); if (response.IsSuccessStatusCode == false) { await ValidateErrors(response); return(default(T)); } return(account); } catch (Exception ex) { var logged = new LoggedException($"Error while trying to call getclientid api {url}", ex); await logged.LoggAPI(); } return(default(T)); }
public async Task <T> GetAsync(string api, string id) { try { await PreAPICall(); httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", Pt_Hippo_Mobile.Helpers.Settings.AccessToken); string url = id == null ? $"{constants.serverUrl}/{api}" : $"{constants.serverUrl}/{api}/" + id; var result = await httpClient.GetAsync(url); if (result.IsSuccessStatusCode == false) { AfterAPICall(); await ValidateErrors(result); return(default(T)); } var json = await result.Content.ReadAsStringAsync(); var taskModels = JsonConvert.DeserializeObject <T>(json); AfterAPICall(); return(taskModels); } catch (Exception ex) { var logged = new LoggedException($"Error while trying to call getasync api {api}", ex); await logged.LoggAPI(); } return(default(T)); }
//update List Async public async Task <bool> PutListAsync(List <T> data, string api) { try { await PreAPICall(); httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", Pt_Hippo_Mobile.Helpers.Settings.AccessToken); var json = JsonConvert.SerializeObject(data); HttpContent httpContent = new StringContent(json); httpContent.Headers.ContentType = new MediaTypeHeaderValue("application/json"); var result = await httpClient.PutAsync($"{constants.serverUrl}/{api}", httpContent); AfterAPICall(); if (result.IsSuccessStatusCode == false) { await ValidateErrors(result); return(false); } return(result.IsSuccessStatusCode); } catch (Exception ex) { var logged = new LoggedException($"Error while trying to call putlist api {api}", ex); await logged.LoggAPI(); } return(false); }
public async Task <List <T> > GetListOptionalId(string api, string id, bool authorize = true) { try { await PreAPICall(); if (authorize) { httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", Pt_Hippo_Mobile.Helpers.Settings.AccessToken); } string url = id == null ? $"{constants.serverUrl}/{api}" : $"{constants.serverUrl}/{api}/" + id; var json = await httpClient.GetStringAsync(url); var taskModels = JsonConvert.DeserializeObject <List <T> >(json); AfterAPICall(); return(taskModels); } catch (Exception ex) { var logged = new LoggedException($"Error while trying to call api {api}", ex); await logged.LoggAPI(); } return(null); }
private static int ReadDayCodeLine(string line) { CheckNullLine(line, "day code"); LoggedException.RaiseIf(line[0] != '-' || line.Length != 6, nameof(PASReader), "Invalid day code format"); return(int.Parse(line.Substring(1, 5))); }
private ConstructorInfo AddCtor(Type t) { Log.Verbose(nameof(ReflectionCache), $"Adding constructor for type '{t.Name}' to cache"); ConstructorInfo result = t.GetConstructor(ctorTypes); LoggedException.RaiseIf(result == null, $"Cannot find serializable constructor for type: '{t.Name}'"); ctors = ctors.Concat(result); return(result); }
// avoid the exception handling middleware which would log the exception again public virtual IActionResult HandleError(string message, LoggedException ex) { return(View(nameof(HomeController.Error) , new ErrorViewModel { RequestId = Activity.Current?.Id ?? HttpContext.TraceIdentifier })); // a bit of cargo-culting here - Activity is some sort of diagnostic thing // as presumably is TraceIdentifier }
private EntrySaveState InternalSaveEntry(Entry entry, TrackbackInfoCollection trackbackList, CrosspostInfoCollection crosspostList) { EntrySaveState rtn = EntrySaveState.Failed; // we want to prepopulate the cross post collection with the crosspost footer if (dasBlogSettings.SiteConfiguration.EnableCrossPostFooter && dasBlogSettings.SiteConfiguration.CrossPostFooter != null && dasBlogSettings.SiteConfiguration.CrossPostFooter.Length > 0) { foreach (CrosspostInfo info in crosspostList) { info.CrossPostFooter = dasBlogSettings.SiteConfiguration.CrossPostFooter; } } // now save the entry, passign in all the necessary Trackback and Pingback info. try { // if the post is missing a title don't publish it if (entry.Title == null || entry.Title.Length == 0) { entry.IsPublic = false; } // if the post is missing categories, then set the categories to empty string. if (entry.Categories == null) { entry.Categories = ""; } rtn = dataService.SaveEntry( entry, MaybeBuildWeblogPingInfo(), entry.IsPublic ? trackbackList : null, MaybeBuildPingbackInfo(entry), crosspostList); //TODO: SendEmail(entry, siteConfig, logService); } catch (Exception ex) { //TODO: Do something with this???? // StackTrace st = new StackTrace(); // logService.AddEvent(new EventDataItem(EventCodes.Error, ex.ToString() + Environment.NewLine + st.ToString(), "")); LoggedException le = new LoggedException("file failure", ex); var edi = new EventDataItem(EventCodes.Error, null , "Failed to Save a Post on {date}", System.DateTime.Now.ToShortDateString()); logger.LogError(edi, le); } // we want to invalidate all the caches so users get the new post // BreakCache(entry.GetSplitCategories()); return(rtn); }
public void CanCreateLoggedException() { const string msg1 = "Message 1"; const string msg2 = "Message 2"; var ex = new LoggedException(msg1, new Exception(msg2)); Assert.AreEqual(ex.Message, msg1); Assert.AreEqual(ex.InnerException.Message, msg2); }
/// <summary> /// Removes an item at the specified index. /// </summary> /// <param name="index"> The specified index. </param> /// <exception cref="LoggedException"> The index was out of range. </exception> public void RemoveAt(int index) { LoggedException.RaiseIf(index >= Count, nameof(ThreadSafeList <T>), "index out of range"); EnterWriteLock(); ShiftLeft(index); --size; ExitWriteLock(); }
/// <summary> /// Initializes a new instance of the <see cref="StopableThread"/> class. /// </summary> /// <param name="init"> The function to call when initialzing the run loop (can be <see langword="null"/>). </param> /// <param name="term"> The function to call when terminating the run loop (can be <see langword="null"/>). </param> /// <param name="tick"> The function that handles the thread tick, cannot be <see langword="null"/>. </param> /// <param name="name"> The name of the thread. </param> public StopableThread(ThreadStart init, ThreadStart term, ThreadStart tick, string name = null) { LoggedException.RaiseIf(tick == null, nameof(StopableThread), "Unable to create thread!", new ArgumentNullException("tick", "tick cannot be null!")); TickCooldown = 10; this.init = init; this.term = term; this.tick = tick; Name = name; nameSet = !string.IsNullOrEmpty(name); thread = ThreadBuilder.CreateSTA(Run, name); }
public static void LogTrace(this ILogger logger, EventDataItem edi, LoggedException ex = null) { if (ex != null) { logger.LogTrace(100, ex, edi.UserMessage, edi.Params); } else { logger.LogTrace(100, edi.UserMessage, edi.Params); } }
/// <summary> /// Inserts an item at the specified index. /// </summary> /// <param name="index"> The position of the new item. </param> /// <param name="item"> The item to be added. </param> /// <exception cref="LoggedException"> The index was out of range. </exception> public void Insert(int index, T item) { LoggedException.RaiseIf(index >= Count, nameof(ThreadSafeList <T>), "index out of range"); EnterWriteLock(); ShiftRight(index); data[index] = item; ++size; ExitWriteLock(); }
private static RouteStop ReadStopStartLine(string line) { CheckNullLine(line, "route start line"); LoggedException.RaiseIf(line[0] != '>' || line[8] != ',' || line.Length != 13, nameof(PASReader), "Invalid route start format"); RouteStop result = new RouteStop { Id = line.Substring(1, 6) }; result.SetLeaveFromString(line.Substring(9, 4)); return(result); }
private static BigRouteStop ReadBigStopLine(string line) { CheckNullLine(line, "big route line"); LoggedException.RaiseIf(line[0] != '+' || line[8] != ',' || line.Length != 18, nameof(PASReader), "Invalid big route format"); BigRouteStop result = new BigRouteStop { Id = line.Substring(1, 6) }; result.SetLeaveFromString(line.Substring(9, 4)); result.SetArriveFromString(line.Substring(14, 4)); return(result); }
private static void CheckValidity(string line) { CheckNullLine(line, "validity"); LoggedException.RaiseIf(line[0] != '&' || line[9] != '-' || line.Length != 18, nameof(PASReader), "Invalid validity format"); DateTime start = DateTime.ParseExact(line.Substring(1, 8), "ddMMyyyy", CultureInfo.InvariantCulture); DateTime end = DateTime.ParseExact(line.Substring(10, 8), "ddMMyyyy", CultureInfo.InvariantCulture); if (start > DateTime.Now) { Log.Warning(nameof(PASReader), $"Validty is not yet active ({start})"); } if (end < DateTime.Now) { Log.Warning(nameof(PASReader), $"Validity is no longer active ({end})"); } }
private static RETRoute ReadRouteLine(string line) { CheckNullLine(line, "route"); LoggedException.RaiseIf(line[0] != '#' || line[2] != ',' || line[9] != ',' || line[13] != ',' || line[15] != ',' || line.Length != 21, nameof(PASReader), "Invalid route line format"); RETRoute result = new RETRoute { CompanyId = int.Parse(line.Substring(3, 5)), LineNum = int.Parse(line.Substring(10, 2)), Direction = (Direction)Convert.ToInt32(line[14]), RouteNum = int.Parse(line.Substring(16, 4)) }; result.SetTypeFromChar(line[1]); return(result); }
/// <summary> /// Gets the specified element without removing it. /// </summary> /// <param name="index"> The index of the specific element to peek. </param> /// <returns> The element at the specified position or default(T) when the queue was empty. </returns> /// <exception cref="LoggedException"> The index was out of bounds. </exception> /// <exception cref="LoggedException"> An unhandled exception occured whilst excecuting the method. </exception> public T Peek(int index) { EnterWriteLock(); if (size == 0) { ExitWriteLock(); return(default(T)); } if (index >= size) { ExitWriteLock(); LoggedException.Raise(nameof(ThreadSafeQueue <T>), "index must be smaller than the size of the queue", new IndexOutOfRangeException()); } T result = data[(head + index) % data.Length]; ExitWriteLock(); return(result); }
public async Task <T> Post(string api, object data) { try { await PreAPICall(); httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", Pt_Hippo_Mobile.Helpers.Settings.AccessToken); var json = JsonConvert.SerializeObject(data); HttpContent httpContent = new StringContent(json); httpContent.Headers.ContentType = new MediaTypeHeaderValue("application/json"); string url = $"{constants.serverUrl}/{api}"; var result = await httpClient.PostAsync(url, httpContent); var Data = await result.Content.ReadAsStringAsync(); if (api == URLConfig.MobileLogging) { AfterAPICall(); return(default(T)); } if (result.IsSuccessStatusCode == false) { AfterAPICall(); await ValidateErrors(result); return(default(T)); } var taskModels = JsonConvert.DeserializeObject <T>(Data); AfterAPICall(); return(taskModels); } catch (Exception ex) { var logged = new LoggedException($"Error while trying to call postdata api {api}", ex); await logged.LoggAPI(); } return(default(T)); }
public async Task <T> GetSearch(string api, string searchtext, int pagesize, int pagenumber, string zipcode, DateTime startdate, DateTime enddate, double minhourrate, double maxhourate) { try { await PreAPICall(); httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", Pt_Hippo_Mobile.Helpers.Settings.AccessToken); //string json = ""; httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", Pt_Hippo_Mobile.Helpers.Settings.AccessToken); //string json = ""; //GET /api/job/getBasicSearchForJobs/{pageSize}/{pageNumber}/{zipCode}/{startDate}/{endDate}/{minHourRate}/{maxHourRate} string startDateText = "null"; string endDateText = "null"; if (startdate != DateTime.MinValue) { startDateText = startdate.Date.ToString("MM-dd-yyyy"); } if (enddate != DateTime.MinValue) { endDateText = enddate.Date.ToString("MM-dd-yyyy"); } string url = $"{constants.serverUrl}/{api}/{pagesize}/{pagenumber}/{zipcode}/{startDateText}/{endDateText}/{minhourrate}/{maxhourate}"; var json = await httpClient.GetStringAsync(url); var taskModels = JsonConvert.DeserializeObject <T>(json); AfterAPICall(); return(taskModels); } catch (Exception ex) { var logged = new LoggedException($"Error while trying to call getsearchapi api {api}", ex); await logged.LoggAPI(); } return(default(T)); }
/// <summary> /// Reads specified types from a specified file. /// </summary> /// <typeparam name="T"> The type attempt to serialize to. </typeparam> /// <param name="fileName"> A absolute or relative path to the file. </param> /// <param name="ctor"> A function to user as the types constructor. </param> /// <returns> A list of serialized objects. </returns> private static List <T> ReadTypeFromFile <T>(string fileName) where T : ISerializable, new() { fileName = $"{Settings.Default.DataDirectory}{fileName}"; // Get the full path to the file. List <T> result = new List <T>(); curLine = 0; LoggedException.RaiseIf(!(fileName.EndsWith(".csv") || fileName.EndsWith(".HLT")), nameof(CSVReader), // Raise an exception if the files isn't a .csv file. $"Cannot open file with extension {Path.GetExtension(fileName)}, supply .csv file"); try { using (StreamReader sr = new StreamReader(fileName)) // Open a read stream to the file. { Log.Verbose(nameof(CSVReader), $"Started parsing file: '{Path.GetFileName(fileName)}'"); char[] splitChars = fileName.EndsWith(".csv") ? new char[] { ';' } : new char[] { ',' }; string line; while ((line = sr.ReadLine()) != null) // Read all lines. { ++curLine; // Increment the current line. T cur; if (DeserializeType(line, splitChars, out cur)) { result.Add(cur); // Deserialzie a type from the current line. } } Log.Info(nameof(CSVReader), $"File contains {result.Count} readable entries"); } } catch (Exception e) { Log.Fatal(nameof(CSVReader), new FileLoadException($"An unhandled exception was raised during the processing of file: '{Path.GetFullPath(fileName)}'", e)); } Log.Verbose(nameof(CSVReader), $"Finished parsing file: '{Path.GetFileName(fileName)}'"); return(result); }
/// <summary> /// Gets or sets a value at the specified index. /// </summary> /// <param name="index"> The secified index. </param> /// <returns> The value at the specified index. </returns> /// <exception cref="LoggedException"> The index was out of range. </exception> public T this[int index] { get { LoggedException.RaiseIf(index >= Count, nameof(ThreadSafeList <T>), "index out of range"); EnterReadLock(); T result = data[index]; ExitReadLock(); return(result); } set { LoggedException.RaiseIf(index >= Count, nameof(ThreadSafeList <T>), "index out of range"); EnterWriteLock(); data[index] = value; ExitWriteLock(); } }
private void LoggedExceptionHandler(object sender, EventArgs <Exception> e) { LoggedException?.Invoke(sender, new EventArgs <Exception>(e.Argument)); }
/// <summary> /// Adds the specified logged exception. /// </summary> /// <param name="loggedException">The logged exception.</param> public void Add(LoggedException loggedException) { if (loggedException == null) { throw new ArgumentNullException("loggedException"); } this.loggedExceptions.Add(loggedException); }
public List <EventDataDisplayItem> GetEventsForDay(DateTime date) { List <EventDataDisplayItem> events = new List <EventDataDisplayItem>(); bool isPreviousEvent = false; StringBuilder stackTrace = new StringBuilder(); // add in the stacktrace to the last event void UpdatePreviousEvent() { EventDataDisplayItem existingEddi = events[events.Count - 1]; var completeEddi = new EventDataDisplayItem( existingEddi.EventCode , existingEddi.HtmlMessage + stackTrace , existingEddi.Date); events[events.Count - 1] = completeEddi; stackTrace.Clear(); } try { // process all the lines in the log for the given date // ignore info not related to DasBlog events i.e. Microsoft logging // and aggregate stack traces for dasBlog events with the event line using (var repo = repoFactory.GetRepo()) { foreach (var line in repo.GetEventLines(date)) { char[] chars = line.ToCharArray(); if (chars.Length > 0 && !Char.IsDigit(chars[0])) { goto stack_trace; } // any line not starting with a date is treated as a stack trace frome (bool success, EventDataDisplayItem eddi) = parser.Parse(line); if (success) { goto event_line; } goto non_event_line; // any line that could not be parsed is assumed not to be a dasblog event // and is ignored event_line: if (isPreviousEvent) // previous event still in progress { UpdatePreviousEvent(); } events.Add(eddi); isPreviousEvent = true; continue; non_event_line: if (isPreviousEvent) // previous event still in progress { UpdatePreviousEvent(); } isPreviousEvent = false; continue; stack_trace: if (isPreviousEvent) { stackTrace.Append("<br>"); stackTrace.Append(line); } continue; } } if (isPreviousEvent) { UpdatePreviousEvent(); } } catch (Exception e) { LoggedException le = new LoggedException("file failure", e); logger.LogError(new EventDataItem(EventCodes.Error, null , "Failed to process the log file for {date}", date.ToShortDateString()) , le); throw le; } return(events); }
private static void RaiseLinqException(string method, Exception inner) { LoggedException.Raise(nameof(ArrayExtensions), $"{method} has encountered an unhandled exception", inner); }
internal static void AddLogger(IDisposable sender) { LoggedException.RaiseIf(loggerActive, nameof(ConsoleLogger), "A logger is already active!"); loggerActive = true; loggerDispose += sender.Dispose; }
/// <summary> /// Attemps to enter a write lock. /// </summary> /// <exception cref="LoggedException"> Method timed out. </exception> protected void EnterWriteLock() { LoggedException.RaiseIf(!locker.TryEnterWriteLock(LockTimeout), nameof(LockableObject), "Unable to enter write lock"); writeActive = true; }