public void ErrorLoggerLogsExceptions()
{
var exception = new ArgumentNullException("TestParameter");
_logger.Log(exception);
Assert.IsTrue(File.Exists(_logFilePath));
var fileContent = File.ReadAllText(_logFilePath);
Assert.IsTrue(fileContent.StartsWith(
"Message: Value cannot be null.\r\nParameter name: TestParameter"));
}
public async Task <Entities.Phonebook> FindByIdAsync(long id)
{
try
{
var result = await base.Phonebook.FindAsync(id);
return(result);
}
catch (Exception ex)
{
_logger.Log(LogLevel.Critical, ex);
throw new Exception(ex.Message);
}
}
public string Serialize <T>(T objectGraph)
{
try
{
return(JsonConvert.SerializeObject(objectGraph, Formatting.None, new JsonSerializerSettings()
{
ReferenceLoopHandling = ReferenceLoopHandling.Serialize
}));
}
catch (Exception ex)
{
Debug.WriteLine($"There was an error while serialzie {typeof(T)} object.\nTake a look on this message error:\n {ex.Message}");
errorLogger.Log($"There was an error while serialzie {typeof(T)} object.\nTake a look on this message error:\n {ex.Message}");
return(null);
}
}
protected override User GetUser(HttpContextBase context)
{
string signedRequestValue = context.Request["signed_request"];
try
{
ValidateSignedRequest(signedRequestValue);
}
catch (Exception ex)
{
_errorLogger.Log(ex);
return(null);
}
SignedRequest signedRequest = _facebookClient.ParseSignedRequest(signedRequestValue);
User user = _userService.GetUser(signedRequest.UserId);
if (user == null)
{
user = new User {
FacebookUserId = signedRequest.UserId
};
}
user.AccessToken = signedRequest.AccessToken;
user.SignedRequest = signedRequestValue;
return(user);
}
private bool createDownloadFolder()
{
if (!Directory.Exists(_downLoadFolderPath))
{
try
{
Directory.CreateDirectory(_downLoadFolderPath);
return(true);
}
catch
{
string error = "Diretory Coudn't be created: " + _downLoadFolderPath;
_errorLogger.Log(error);
return(false);
}
}
return(false);
}
private void CreatePost(Database db, string postMessage)
{
try
{
db.Add(postMessage);
}
catch (Exception ex)
{
_errorLogger.NewErrorlogger();
_errorLogger.Log(ex.Message);
}
}
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
try
{
var connectionString = $"Data Source ={ _appHost.ContentRootPath }/Phonebook.db";
optionsBuilder.UseSqlite(connectionString, x => x.SuppressForeignKeyEnforcement()).EnableSensitiveDataLogging(true);
}
catch (Exception ex)
{
_logger.Log(LogLevel.Critical, ex);
throw new Exception(ex.Message);
}
}
public void Send(MessageModel messageModel)
{
try
{
if (string.IsNullOrEmpty(messageModel.Name))
{
messageModel.MessageHandler.Invoke("Name is required");
DisposeConnection();
return;
}
MessageModel = messageModel;
QueueDeclare();
var body = Encoding.UTF8.GetBytes(string.Format(GetMessageByMessageType(), messageModel.Name));
Channel.BasicPublish(string.Empty, GetKeyByMessageType(), null, body);
}
catch (Exception ex)
{
string error = "An error occurred and your request was unscuccessful";
_logger.Log(LogLevel.Critical, ex, error);
messageModel.MessageHandler.Invoke(error);
DisposeConnection();
}
}
public void Simulate()
{
var sim = decorated;
TW.Data.RunningSimulator = sim;
try
{
sim.Simulate();
}
catch (Exception ex)
{
errorLogger.Log(ex, "Error in simulator: " + name);
}
TW.Data.RunningSimulator = null;
}
public void Update(Phonebook phonebook)
{
try
{
if (phonebook.State == State.Modified)
{
_dbContext.Update(phonebook.ConvertToEntity());
return;
}
if (phonebook.Entries.Any())
{
var entry = phonebook.Entries.First();
var entity = _dbContext.FindByIdAsync(phonebook.Id).Result;
switch (entry.State)
{
case State.Added:
entity.Entries.Add(entry.ConvertToEntity());
_dbContext.Update(entity);
return;
case State.Modified:
var modifiedEntry = entity.Entries.First(x => x.Id == entry.Id);
modifiedEntry.State = EntityState.Modified;
modifiedEntry.Name = entry.Name;
modifiedEntry.PhoneNumber = entry.PhoneNumber;
_dbContext.Update(entity);
return;
case State.Deleted:
var deletedEntry = entity.Entries.First(x => x.Id == entry.Id);
entity.Entries.Remove(deletedEntry);
_dbContext.Update(entity);
return;
default:
throw new Exception("State unknown.");
}
}
}
catch (Exception ex)
{
_logger.Log(LogLevel.Critical, ex);
throw new Exception(ex.Message);
}
}
public bool Add(T entity)
{
lock (locker)
{
try
{
dbSet.Add(entity);
context.SaveChanges();
return(true);
}
catch (Exception ex)
{
logger.Log($"Error occured while adding {typeof(T)} to Db.\n\n{ex}");
return(false);
}
}
}
protected HttpResponseMessage ExecFunc(Func <HttpResponseMessage> function, string errorMessage = null)
{
try
{
return(function());
}
catch (DomainException ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex.Message));
}
catch (Exception ex)
{
_errorLogger.Log(ex);
if (errorMessage.IsNullOrEmpty())
{
errorMessage = _baseErrorMessage;
}
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, errorMessage));
}
}
/// <summary>
/// Gets the achievements from http://steamcommunity.com/id/[customurl]/[game]/?xml=1.
/// </summary>
/// <param name="steamUserId"> The steam user id. </param>
/// <param name="closedOnly"> if set to <c>true</c> [closed only]. </param>
/// <param name="language"> The language. </param>
/// <returns> </returns>
private ICollection <UserAchievement> GetAchievements(string steamUserId, bool closedOnly, string language)
{
if (steamUserId == null)
{
throw new ArgumentNullException("steamUserId");
}
List <UserAchievement> achievements = new List <UserAchievement>();
IEnumerable <Game> games = GetGames(steamUserId, language);
if (closedOnly)
{
games = games.Where(g => g.PlayedRecently);
}
foreach (Game game in games)
{
Uri xmlStatsUrl = GetStatsUrl(game.StatsUrl, language);
Debug.WriteLine(xmlStatsUrl);
string xml;
try
{
xml = _webClient.DownloadString(xmlStatsUrl);
}
catch (SteamCommunityDataException)
{
//TODO: notify the user that achievements could not be retrieved for this game
continue;
}
if (xml == null)
{
continue;
}
IEnumerable <UserAchievement> gameAchievements;
try
{
if (closedOnly)
{
gameAchievements = _achievementParser.ParseClosed(xml);
}
else
{
gameAchievements = _achievementParser.Parse(xml);
}
}
catch (XmlException ex)
{
Exception exception = new InvalidStatsXmlException(steamUserId, new Uri(game.StatsUrl), ex);
_errorLogger.Log(exception);
continue;
}
if (!gameAchievements.Any())
{
continue;
}
List <UserAchievement> achievementList = gameAchievements.ToList();
Game game1 = game;
achievementList.ForEach(a =>
{
a.Achievement.Game = game1;
a.Achievement.Language = language;
});
achievements.AddRange(achievementList);
}
return(achievements);
}
/// <summary>
/// Function to log either a text message or an exception, or both.
/// </summary>
/// <param name="message">The message to log.</param>
/// <param name="exception">The exception to log.</param>
/// <param name="callingMethod">The method that made the request to log the error.</param>
/// <returns>Returns the name of the file the log was saved in.</returns>
public static string Log(string message, Exception exception = null, IClock clock = null, [CallerMemberName] string callingMethod = "")
{
return(errorLogger?.Log(message, exception, clock, callingMethod));
}
public void Log(string message, Exception ex)
{
ErrorLogger.Log(string.Concat(LogMessagePrefix, message), ex);
}
public void OnException(ExceptionContext filterContext)
{
if (filterContext.ExceptionHandled || !filterContext.HttpContext.IsCustomErrorEnabled)
{
return;
}
if (filterContext.HttpContext.Request.IsAjaxRequest())
{
filterContext.Result = new JsonResult()
{
ContentType = "application/json",
Data = new
{
name = filterContext.Exception.GetType().Name,
message = filterContext.Exception.Message,
trace = filterContext.Exception.StackTrace
},
JsonRequestBehavior = JsonRequestBehavior.AllowGet
};
filterContext.HttpContext.Response.StatusCode = 500;
filterContext.ExceptionHandled = true;
//Internal Error
}
else
{
Exception ex = filterContext.Exception;
filterContext.ExceptionHandled = true;
var ControllerName = (string)filterContext.RouteData.Values["controller"];
var ActionName = (string)filterContext.RouteData.Values["action"];
var data = new HandleErrorInfo(filterContext.Exception, ControllerName, ActionName);
filterContext.Result = new ViewResult()
{
ViewName = "Error",
ViewData = new ViewDataDictionary(data)
};
filterContext.HttpContext.Response.StatusCode = 500;
filterContext.ExceptionHandled = true;
}
ErrorLog log = new ErrorLog()
{
Message = filterContext.Exception.Message,
StackTrace = filterContext.Exception.StackTrace,
ControllerName = (string)filterContext.RouteData.Values["controller"],
ActionName = (string)filterContext.RouteData.Values["action"],
TargetedResult = filterContext.Result.GetType().Name,
TimeStamp = DateTime.Now,
UserAgent = filterContext.HttpContext.Request.UserAgent,
IPAdress = filterContext.HttpContext.Request.UserHostAddress,
SessionID = null,
ExceptionName = filterContext.Exception.GetType().Name
};
#region loggerService
if (_logger != null)
{
_logger.Log(log);
}
#endregion
#region emailService
if (_msg != null)
{
_msg.SendEmail(new EmailDetails
{
From = "*****@*****.**",
Body = filterContext.Exception.Message + Environment.NewLine + filterContext.Exception.StackTrace,
ToAddresses = "*****@*****.**",
});
}
#endregion
}
