public void ReadExceptionFile()
{
var expectedException = new ArgumentException("test");
var mockFile = Mock.Of <File>();
Mock.Get(mockFile).Setup(file => file.ReadAllText()).Returns(expectedException.ToString());
var actualException = ErrorLogHelper.ReadExceptionFile(mockFile);
Assert.AreEqual(expectedException.ToString(), actualException);
}
public void LogMessage_ReplayedMessageSavedUnitilTheLimit()
{
string replayMessage1 = "ReplayMessage1";
Exception exception1 = new ArgumentException("Error");
string replayMessage2 = "ReplayMessage2";
Exception exception2 = new NullReferenceException("Error");
string suffix = nameof(LogMessage_ReplayedMessageSavedUnitilTheLimit);
int eventId = 7;
Mock <ILogEventSender> eventSourceMock = CreateEventSourceMock(isReplayable: true);
ReplayableActivity activity = CreateActivity(suffix);
activity.Start();
(ILogger logger, _) = LogMessage(eventSourceMock, eventId);
logger.LogDebug(exception1, replayMessage1);
logger.LogDebug(exception2, replayMessage2);
activity.Stop();
eventSourceMock.Verify(m_logExpression, Times.Exactly(3));
List <LogMessageInformation> info = activity.GetLogEvents().ToList();
Assert.AreEqual(2, info.Count);
StringAssert.Contains(info[0].Message, replayMessage1);
StringAssert.Contains(info[0].Message, exception1.ToString());
StringAssert.Contains(info[1].Message, replayMessage2);
StringAssert.Contains(info[1].Message, exception2.ToString());
}
public void LogMessage_ReplayedMessageSavedUnitilTheLimit()
{
string replayMessage1 = "ReplayMessage1";
Exception exception1 = new ArgumentException("Error");
string replayMessage2 = "ReplayMessage2";
Exception exception2 = new NullReferenceException("Error");
string suffix = nameof(LogMessage_ReplayedMessageSavedUnitilTheLimit);
int eventId = 7;
Mock <ILogEventSender> eventSourceMock = CreateEventSourceMock();
Activity activity = CreateActivity(suffix);
activity.Start();
(ILogger logger, _) = LogMessage(eventSourceMock, logEventReplayer: CreateLogReplayer(2), eventId);
logger.LogDebug(new DivideByZeroException(), "LostMessage"); // would be lost due overflow
logger.LogDebug(exception1, replayMessage1);
logger.LogDebug(exception2, replayMessage2);
activity.Stop();
eventSourceMock.Verify(s_logExpression, Times.Exactly(4));
List <LogMessageInformation> info = activity.GetReplayableLogs().ToList();
Assert.AreEqual(2, info.Count);
StringAssert.Contains(info[0].Message, replayMessage1);
StringAssert.Contains(info[0].Message, exception1.ToString());
StringAssert.Contains(info[1].Message, replayMessage2);
StringAssert.Contains(info[1].Message, exception2.ToString());
}
public void TestConstructorWithZeroNumberOfCardsAndNullTopCard()
{
// ARRANGE
IAxiom axiom = new Axiom();
const int numberOfCards = 0;
ICard topCard = new Card(Colour.Blue, Number.Five, axiom);
// ACT
ArgumentException argumentException = null;
IRuleScore ruleScore = null;
try
{
ruleScore = new RuleScore(
numberOfCards: numberOfCards,
topCard: topCard);
}
catch (ArgumentException ex)
{
argumentException = ex;
}
// ASSERT
if (argumentException != null)
{
Console.WriteLine(argumentException.ToString());
}
Assert.IsNotNull(argumentException, "argumentException != null");
Assert.IsNull(ruleScore, "ruleScore == null");
}
private IEnumerator ProcessMatchResponse <JSONRESPONSE, USERRESPONSEDELEGATETYPE>(UnityWebRequest client, NetworkMatch.InternalResponseDelegate <JSONRESPONSE, USERRESPONSEDELEGATETYPE> internalCallback, USERRESPONSEDELEGATETYPE userCallback) where JSONRESPONSE : Response, new()
{
yield return(client.SendWebRequest());
JSONRESPONSE jSONRESPONSE = Activator.CreateInstance <JSONRESPONSE>();
bool flag = client.result == UnityWebRequest.Result.Success;
if (flag)
{
try
{
JsonUtility.FromJsonOverwrite(client.downloadHandler.text, jSONRESPONSE);
}
catch (ArgumentException ex2)
{
ArgumentException ex = ex2;
jSONRESPONSE.SetFailure(UnityString.Format("ArgumentException:[{0}] ", new object[]
{
ex.ToString()
}));
}
}
else
{
jSONRESPONSE.SetFailure(UnityString.Format("Request error:[{0}] Raw response:[{1}]", new object[]
{
client.error,
client.downloadHandler.text
}));
}
client.Dispose();
internalCallback(jSONRESPONSE, userCallback);
yield break;
}
public void TestConstructorWithEmptyListOfCardsThrowsException()
{
// ARRANGE
IList <ICard> cards = new List <ICard>();
// ACT
ArgumentException argumentException = null;
IPalette palette = null;
try
{
palette = new Palette(cards);
}
catch (ArgumentException ex)
{
argumentException = ex;
}
// ASSERT
if (argumentException != null)
{
Console.WriteLine(argumentException.ToString());
}
Assert.IsNotNull(argumentException);
Assert.IsNull(palette);
}
public async Task <IActionResult> Create([FromBody] DishType dish)
{
if (dish.Name == null)
{
var ex = new ArgumentException($"{nameof(dish)} can`t be null");
_logger.LogError(ex.ToString());
throw ex;
}
if (!_validator.Validate(dish).IsValid)
{
var ex = new ArgumentException($"{nameof(dish)} is not valid");
_logger.LogError(ex.ToString());
throw ex;
}
try
{
_dishTypeRepository.Add(dish);
await _unitOfWork.SaveChangesAsync();
return(Ok(dish));
}
catch (Exception ex)
{
ex.Data["dish"] = dish;
_logger.LogError(ex.ToString());
throw ex;
}
}
public void TestAddDuplicateCardThrowsAnException()
{
// ARRANGE
IAxiom axiom = new Axiom();
IList <ICard> cards = new List <ICard>
{
new Card(Colour.Orange, Number.Three, axiom),
new Card(Colour.Blue, Number.Seven, axiom),
new Card(Colour.Red, Number.One, axiom)
};
ICard duplicateCard = new Card(Colour.Orange, Number.Three, axiom);
IPalette palette = new Palette(cards);
// ACT
ArgumentException argumentException = null;
try
{
palette.AddCard(duplicateCard);
}
catch (ArgumentException ex)
{
argumentException = ex;
}
// ASSERT
if (argumentException != null)
{
Console.WriteLine(argumentException.ToString());
}
Assert.IsNotNull(argumentException, "Expected exception not thrown");
}
public void ShowError_WhenArgumentIsRemoteInvocationExceptionForOtherException_ShowsError()
{
var remoteException = new ArgumentException(message: "a", new DivideByZeroException(message: "b"));
var remoteError = RemoteErrorUtility.ToRemoteError(remoteException);
var exception = new RemoteInvocationException(
message: "c",
errorCode: 0,
errorData: null,
deserializedErrorData: remoteError);
var defaultLogger = new Mock <INuGetUILogger>();
var projectLogger = new Mock <INuGetUILogger>();
defaultLogger.Setup(
x => x.ReportError(
It.Is <ILogMessage>(logMessage => ReferenceEquals(logMessage, remoteError.LogMessage))));
projectLogger.Setup(
x => x.Log(
It.Is <MessageLevel>(level => level == MessageLevel.Error),
It.Is <string>(message => message == remoteException.ToString())));
using (NuGetUI ui = CreateNuGetUI(defaultLogger.Object, projectLogger.Object))
{
ui.ShowError(exception);
defaultLogger.VerifyAll();
projectLogger.VerifyAll();
}
}
/// <summary>
/// Trains a model using SAR.
/// </summary>
/// <param name="settings">The training settings</param>
/// <param name="usageEvents">The usage events to use for training</param>
/// <param name="catalogItems">The catalog items to use for training</param>
/// <param name="uniqueUsersCount">The number of users in the user id index file.</param>
/// <param name="uniqueUsageItemsCount">The number of usage items in the item id index file</param>
/// <param name="cancellationToken">A cancellation token</param>
public IPredictorModel Train(ITrainingSettings settings,
IList <SarUsageEvent> usageEvents,
IList <SarCatalogItem> catalogItems,
int uniqueUsersCount,
int uniqueUsageItemsCount,
CancellationToken cancellationToken)
{
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
if (usageEvents == null)
{
throw new ArgumentNullException(nameof(usageEvents));
}
if (settings.EnableColdItemPlacement && catalogItems == null)
{
throw new ArgumentNullException(nameof(catalogItems));
}
if (uniqueUsersCount < 0)
{
var exception = new ArgumentException($"{nameof(uniqueUsersCount)} must be a positive integer");
_tracer.TraceWarning(exception.ToString());
throw exception;
}
if (uniqueUsageItemsCount < 0)
{
var exception = new ArgumentException($"{nameof(uniqueUsageItemsCount)} must be a positive integer");
_tracer.TraceWarning(exception.ToString());
throw exception;
}
cancellationToken.ThrowIfCancellationRequested();
using (TlcEnvironment environment = new TlcEnvironment(verbose: true))
{
_detectedFeatureWeights = null;
try
{
environment.AddListener <ChannelMessage>(ChannelMessageListener);
IHost environmentHost = environment.Register("SarHost");
// bind the cancellation token to SAR cancellation
using (cancellationToken.Register(() => { environmentHost.StopExecution(); }))
{
_tracer.TraceInformation("Starting training model using SAR");
return(TrainModel(environmentHost, settings, usageEvents, catalogItems, uniqueUsersCount,
uniqueUsageItemsCount));
}
}
finally
{
environment.RemoveListener <ChannelMessage>(ChannelMessageListener);
}
}
}
public async Task <IActionResult> CreateAsync([FromBody] GameConsoleType gameConsoleType)
{
if (gameConsoleType == null)
{
var ex = new ArgumentException($"{nameof(gameConsoleType)} can't be null");
_logger.LogError(ex.ToString());
throw ex;
}
if (!_validator.Validate(gameConsoleType).IsValid)
{
var ex = new ArgumentException($"{nameof(gameConsoleType)} is not valid");
_logger.LogError(ex.ToString());
throw ex;
}
try
{
_gameConsoleTypeRepository.Add(gameConsoleType);
await _unitOfWork.SaveChangesAsync();
return(Ok(gameConsoleType));
}
catch
{
var ex = new Exception($"Error while adding game console type nameof{nameof(gameConsoleType)}");
_logger.LogError(ex.ToString());
throw ex;
}
}
public async Task <IActionResult> RemoveById(int id)
{
if (id == default)
{
var ex = new ArgumentException($"{nameof(id)} cannot be 0");
_logger.LogError(ex.ToString());
throw ex;
}
try
{
var table = await _tableRepository.Get(x => x.Id == id);
_tableRepository.Remove(table);
await _unitOfWork.SaveChangesAsync();
}
catch (Exception ex)
{
ex.Data["id"] = id;
_logger.LogError(ex.ToString());
throw ex;
}
return(Ok());
}
public void TestConstructorWithPositiveNumberOfCardsAndNullTopCard()
{
// ARRANGE
const int numberOfCards = 1;
// ACT
ArgumentException argumentException = null;
IRuleScore ruleScore = null;
try
{
ruleScore = new RuleScore(
numberOfCards: numberOfCards,
topCard: null);
}
catch (ArgumentException ex)
{
argumentException = ex;
}
// ASSERT
if (argumentException != null)
{
Console.WriteLine(argumentException.ToString());
}
Assert.IsNotNull(argumentException, "argumentException != null");
Assert.IsNull(ruleScore, "ruleScore == null");
}
public async Task <IActionResult> CreateAsync([FromBody] Table table)
{
if (table == null)
{
var ex = new ArgumentException($"{nameof(table)} can't be null");
_logger.LogError(ex.ToString());
throw ex;
}
var validationResult = _validator.Validate(table);
if (!validationResult.IsValid)
{
var ex = new ArgumentException($"{nameof(table)} is not valid");
_logger.LogError(ex.ToString());
throw ex;
}
try
{
_tableRepository.Add(table);
await _unitOfWork.SaveChangesAsync();
return(Ok(table));
}
catch
{
var ex = new Exception($"Error while adding table nameof{nameof(table)}");
_logger.LogError(ex.ToString());
throw ex;
}
}
public async Task <IActionResult> CreateAsync([FromBody] OnlineTableReservation onlineTableReservation)
{
if (onlineTableReservation == null)
{
var ex = new ArgumentException($"{nameof(onlineTableReservation)} can't be null");
_logger.LogError(ex.ToString());
throw ex;
}
if (!_validator.Validate(onlineTableReservation).IsValid)
{
var ex = new ArgumentException($"{nameof(onlineTableReservation)} is not valid");
_logger.LogError(ex.ToString());
throw ex;
}
try
{
_onlineTableReservationRepository.Add(onlineTableReservation);
await _unitOfWork.SaveChangesAsync();
return(Ok(onlineTableReservation));
}
catch
{
var ex = new Exception($"Error while adding onlineTableReservation nameof{nameof(onlineTableReservation)}");
_logger.LogError(ex.ToString());
throw ex;
}
}
public async Task <IActionResult> CreateAsync([FromBody] Dish dish)
{
if (dish == null)
{
var ex = new ArgumentException($"{nameof(dish)} can't be null");
_logger.LogError(ex.ToString());
throw ex;
}
if (!_validator.Validate(dish).IsValid)
{
var ex = new ArgumentException($"{nameof(dish)} is not valid");
_logger.LogError(ex.ToString());
throw ex;
}
try
{
_dishRepository.Add(dish);
await _unitOfWork.SaveChangesAsync();
return(Ok(dish));
}
catch
{
var ex = new Exception($"Error while adding dish nameof{nameof(dish)}");
_logger.LogError(ex.ToString());
throw ex;
}
}
public static void ReAddSameNode_Throws()
{
var jValue = JsonValue.Create(1);
var jObject = new JsonObject();
jObject.Add("Prop", jValue);
ArgumentException ex = Assert.Throws<ArgumentException>(() => jObject.Add("Prop", jValue));
Assert.Contains("Prop", ex.ToString());
}
/// <summary>
/// ArgumentException An argument to a method was invalid.
/// </summary>
/// <param name="ex"></param>
/// <returns></returns>
private static SqlMessage SqlException(ArgumentException ex)
{
SqlMessage meResul = new SqlMessage
{
Status = sqlMessagerType.SystemError,
Title = ex.GetType().FullName,
Message = ex.Message,
ExceptionMesseger = ex.ToString()
};
return(meResul);
}
public async Task <IActionResult> UpdateById(int id, [FromBody] User user)
{
if (id == default)
{
var ex = new ArgumentException($"{nameof(id)} cannot be 0");
_logger.LogError(ex.ToString());
throw ex;
}
var validationResult = _validator.Validate(user);
if (!validationResult.IsValid)
{
var ex = new ArgumentException($"{nameof(user)} is not valid");
_logger.LogError(ex.ToString());
throw ex;
}
try
{
var currentUser = await _userRepository.Get(x => x.Id == id);
if (currentUser == null)
{
var ex = new NullReferenceException($"Error while updating user. User with {nameof(id)}={id} not found");
_logger.LogError(ex.ToString());
throw ex;
}
currentUser.Name = user.Name;
currentUser.PhoneNumber = user.Name;
currentUser.PhoneNumberConfirmed = user.PhoneNumberConfirmed;
currentUser.Email = user.Email;
currentUser.EmailConfirmed = user.PhoneNumberConfirmed;
currentUser.PhoneNumber = user.PhoneNumber;
currentUser.PhoneNumberConfirmed = user.PhoneNumberConfirmed;
currentUser.BirthDate = user.BirthDate;
currentUser.GenderId = user.GenderId;
currentUser.CommunicationLanguage = user.CommunicationLanguage;
currentUser.RoleId = user.RoleId;
_userRepository.Update(currentUser);
await _unitOfWork.SaveChangesAsync();
return(Ok(currentUser));
}
catch (Exception ex)
{
ex.Data["id"] = id;
_logger.LogError(ex.ToString());
throw ex;
}
}
public MofSpecificationSet(MofSpecification[] specifications)
{
this.ClassDeclarations = new Dictionary <string, ClassDeclaration>(StringComparer.OrdinalIgnoreCase);
if (specifications != null)
{
this.m_specifications = specifications;
MofSpecification[] mofSpecificationArray = specifications;
for (int i = 0; i < (int)mofSpecificationArray.Length; i++)
{
MofSpecification mofSpecification = mofSpecificationArray[i];
MofProduction[] productions = mofSpecification.Productions;
int num = 0;
while (num < (int)productions.Length)
{
MofProduction mofProduction = productions[num];
MofProduction.ProductionType type = mofProduction.Type;
switch (type)
{
case MofProduction.ProductionType.ClassDeclaration:
{
ClassDeclaration classDeclaration = (ClassDeclaration)mofProduction;
try
{
this.ClassDeclarations.Add(classDeclaration.Name.FullName, classDeclaration);
num++;
continue;
}
catch (ArgumentException argumentException1)
{
ArgumentException argumentException = argumentException1;
argumentException.ToString();
throw new ParseFailureException(string.Concat("class ", classDeclaration.Name.FullName, " is already defined"), classDeclaration.Location);
}
}
case MofProduction.ProductionType.CompilerDirective:
case MofProduction.ProductionType.InstanceDeclaration:
{
num++;
continue;
}
}
throw new InvalidOperationException();
}
}
return;
}
else
{
throw new ArgumentException();
}
}
public async Task <IActionResult> UpdateById(int id, [FromBody] Employee employee)
{
if (id == default)
{
var ex = new ArgumentException($"{nameof(id)} cannot be 0");
_logger.LogError(ex.ToString());
throw ex;
}
var validationResult = _validator.Validate(employee);
if (!validationResult.IsValid)
{
var ex = new ArgumentException($"{nameof(employee)} is not valid");
_logger.LogError(ex.ToString());
throw ex;
}
try
{
var currentEmployee = await _employeeRepository.Get(x => x.Id == id);
if (currentEmployee == null)
{
var ex = new NullReferenceException($"Error while updating employee. Employee with {nameof(id)}={id} not found");
_logger.LogError(ex.ToString());
throw ex;
}
currentEmployee.FirstName = employee.FirstName;
currentEmployee.LastName = employee.LastName;
currentEmployee.DepartamentId = employee.DepartamentId;
currentEmployee.PhoneNumber = employee.PhoneNumber;
currentEmployee.PositionId = employee.PositionId;
currentEmployee.GenderId = employee.GenderId;
currentEmployee.BirthDate = employee.BirthDate;
_employeeRepository.Update(currentEmployee);
await _unitOfWork.SaveChangesAsync();
return(Ok(currentEmployee));
}
catch (Exception ex)
{
ex.Data["id"] = id;
_logger.LogError(ex.ToString());
throw ex;
}
}
private static void Main(string[] args)
{
if (args[0].ToLower() == UPDATE)
{
updateAll();
}
else if (args[0].ToLower() == OPEN_XML)
{
openXml();
}
else
{
var e = new ArgumentException(string.Format("Avaliable Args:\n{0}\n{1}", UPDATE, OPEN_XML));
Console.Error.Write(e.ToString());
}
}
static void Main(string[] args)
{
Logger.Log("-----------------------------Application started!--------------------------------------");
string inputFilePath;
string outputFilePath;
string outputType;
if (args.Length < 1)
{
inputFilePath = @"Data\dane.csv";
}
else
{
Regex r = new Regex(@"^(([a-zA-Z]:)|(\))(\{1}|((\{1})[^\]([^/:*?<>""|]*))+)$");
if (!r.IsMatch(args[0]))
{
var exc = new ArgumentException("Podana ścieżka " + args[0] + " jest niepoprawna");
Logger.Log(exc.ToString());
throw exc;
}
else
{
inputFilePath = args[0];
}
}
if (args.Length < 2)
{
outputFilePath = @"Data\result.xml";
}
else
{
outputFilePath = args[1];
}
if (args.Length < 3)
{
outputType = "xml";
}
else
{
outputType = args[2];
}
var serializer = new Serializer();
serializer.startSerialization(inputFilePath, outputFilePath, outputType);
Logger.Log("Task Completed Successfully!");
}
public async Task <IActionResult> UpdateById(int id, [FromBody] Table table)
{
if (id == default)
{
var ex = new ArgumentException($"{nameof(id)} cannot be 0");
_logger.LogError(ex.ToString());
throw ex;
}
var validationResult = _validator.Validate(table);
if (!validationResult.IsValid)
{
var ex = new ArgumentException($"{nameof(table)} is not valid");
_logger.LogError(ex.ToString());
throw ex;
}
try
{
var currentTable = await _tableRepository.Get(x => x.Id == id);
if (currentTable == null)
{
var ex = new NullReferenceException($"Error while updating table. Table with {nameof(id)}={id} not found");
_logger.LogError(ex.ToString());
throw ex;
}
currentTable.Identifier = table.Identifier;
currentTable.DepartamentId = table.DepartamentId;
currentTable.SeatingCapacity = table.SeatingCapacity;
currentTable.GameConsoleId = table.GameConsoleId;
_tableRepository.Update(currentTable);
await _unitOfWork.SaveChangesAsync();
return(Ok(currentTable));
}
catch (Exception ex)
{
ex.Data["id"] = id;
_logger.LogError(ex.ToString());
throw ex;
}
}
public async Task <IActionResult> UpdateById(int id, [FromBody] Departament departament)
{
if (id == default)
{
var ex = new ArgumentException($"{nameof(id)} cannot be 0");
_logger.LogError(ex.ToString());
throw ex;
}
if (!_validator.Validate(departament).IsValid)
{
var ex = new ArgumentException($"{nameof(departament)} is not valid");
_logger.LogError(ex.ToString());
throw ex;
}
try
{
var currentDepartament = await _departamentRepository.Get(x => x.Id == id);
if (currentDepartament == null)
{
var ex = new NullReferenceException($"Error while updating departament. Departament with {nameof(id)}={id} not found");
_logger.LogError(ex.ToString());
throw ex;
}
currentDepartament.Name = departament.Name;
currentDepartament.Country = departament.Country;
currentDepartament.City = departament.City;
currentDepartament.Street = departament.Street;
currentDepartament.HouseNumber = departament.HouseNumber;
_departamentRepository.Update(currentDepartament);
await _unitOfWork.SaveChangesAsync();
return(Ok(currentDepartament));
}
catch (Exception ex)
{
ex.Data["id"] = id;
_logger.LogError(ex.ToString());
throw ex;
}
}
public async Task <IActionResult> UpdateById(int id, [FromBody] Dish dish)
{
if (id == default)
{
var ex = new ArgumentException($"{nameof(id)} cannot be 0");
_logger.LogError(ex.ToString());
throw ex;
}
if (!_validator.Validate(dish).IsValid)
{
var ex = new ArgumentException($"{nameof(dish)} is not valid");
_logger.LogError(ex.ToString());
throw ex;
}
try
{
var currentDish = await _dishRepository.Get(x => x.Id == id);
if (currentDish == null)
{
var ex = new NullReferenceException($"Error while updating dish. Dish with {nameof(id)}={id} not found");
_logger.LogError(ex.ToString());
throw ex;
}
currentDish.Name = dish.Name;
currentDish.Price = dish.Price;
currentDish.Description = dish.Description;
currentDish.TypeId = dish.TypeId;
currentDish.IsAvailable = dish.IsAvailable;
_dishRepository.Update(currentDish);
await _unitOfWork.SaveChangesAsync();
return(Ok(currentDish));
}
catch (Exception ex)
{
ex.Data["id"] = id;
_logger.LogError(ex.ToString());
throw ex;
}
}
public async Task <IActionResult> UpdateById(int id, [FromBody] OfflineTableReservation offlineTableReservation)
{
if (id == default)
{
var ex = new ArgumentException($"{nameof(id)} cannot be 0");
_logger.LogError(ex.ToString());
throw ex;
}
if (!_validator.Validate(offlineTableReservation).IsValid)
{
var ex = new ArgumentException($"{nameof(offlineTableReservation)} is not valid");
_logger.LogError(ex.ToString());
throw ex;
}
try
{
var currentOfflineTableReservation = await _offlineTableReservationRepository.Get(x => x.Id == id);
if (currentOfflineTableReservation == null)
{
var ex = new NullReferenceException($"Error while updating offline table rReservation. Offline table reservation with {nameof(id)}={id} not found");
_logger.LogError(ex.ToString());
throw ex;
}
currentOfflineTableReservation.TableId = offlineTableReservation.TableId;
currentOfflineTableReservation.ClientName = offlineTableReservation.ClientName;
currentOfflineTableReservation.ClientPhoneNumber = offlineTableReservation.ClientPhoneNumber;
currentOfflineTableReservation.EmployeeId = offlineTableReservation.EmployeeId;
_offlineTableReservationRepository.Update(currentOfflineTableReservation);
await _unitOfWork.SaveChangesAsync();
return(Ok(currentOfflineTableReservation));
}
catch (Exception ex)
{
ex.Data["id"] = id;
_logger.LogError(ex.ToString());
throw ex;
}
}
public async Task <IActionResult> UpdateById(int id, [FromBody] Game game)
{
if (id == default)
{
var ex = new ArgumentException($"{nameof(id)} cannot be 0");
_logger.LogError(ex.ToString());
throw ex;
}
if (!_validator.Validate(game).IsValid)
{
var ex = new ArgumentException($"{nameof(game)} is not valid");
_logger.LogError(ex.ToString());
throw ex;
}
try
{
var currentGame = await _gameRepository.Get(x => x.Id == id);
if (currentGame == null)
{
var ex = new NullReferenceException($"Error while updating game. Game with {nameof(id)}={id} not found");
_logger.LogError(ex.ToString());
throw ex;
}
currentGame.Name = game.Name;
currentGame.Description = game.Description;
currentGame.LicenseBeginDate = game.LicenseBeginDate;
currentGame.LicenseEndDate = game.LicenseEndDate;
_gameRepository.Update(currentGame);
await _unitOfWork.SaveChangesAsync();
return(Ok(currentGame));
}
catch (Exception ex)
{
ex.Data["id"] = id;
_logger.LogError(ex.ToString());
throw ex;
}
}
public void CreateEntityWithPropertiesShouldGenerateValidEntity()
{
var timestamp = new DateTimeOffset(2014, 12, 01, 18, 42, 20, 666, TimeSpan.FromHours(2));
var exception = new ArgumentException("Some exceptional exception happened");
var level = LogEventLevel.Information;
var messageTemplate = "Template {Temp} {Prop}";
var template = new MessageTemplateParser().Parse(messageTemplate);
var properties = new List <LogEventProperty> {
new LogEventProperty("Temp", new ScalarValue("Temporary")),
new LogEventProperty("Prop", new ScalarValue("Property"))
};
var additionalRowKeyPostfix = "Some postfix";
var logEvent = new Events.LogEvent(timestamp, level, exception, template, properties);
var entity = AzureTableStorageEntityFactory.CreateEntityWithProperties(logEvent, null, additionalRowKeyPostfix);
// Partition key
var expectedPartitionKey = "0" + new DateTime(logEvent.Timestamp.Year, logEvent.Timestamp.Month, logEvent.Timestamp.Day, logEvent.Timestamp.Hour, logEvent.Timestamp.Minute, 0).Ticks;
Assert.AreEqual(expectedPartitionKey, entity.PartitionKey);
// Row Key
var expectedRowKeyWithoutGuid = "Information|Template {Temp} {Prop}|Some postfix|";
var rowKeyWithoutGuid = entity.RowKey.Substring(0, expectedRowKeyWithoutGuid.Length);
var rowKeyGuid = entity.RowKey.Substring(expectedRowKeyWithoutGuid.Length);
Assert.AreEqual(expectedRowKeyWithoutGuid, rowKeyWithoutGuid);
Assert.DoesNotThrow(() => Guid.Parse(rowKeyGuid));
Assert.AreEqual(Guid.Parse(rowKeyGuid).ToString(), rowKeyGuid);
// Timestamp
Assert.AreEqual(logEvent.Timestamp, entity.Timestamp);
// Properties
Assert.AreEqual(6, entity.Properties.Count);
Assert.AreEqual(new EntityProperty(messageTemplate), entity.Properties["MessageTemplate"]);
Assert.AreEqual(new EntityProperty("Information"), entity.Properties["Level"]);
Assert.AreEqual(new EntityProperty("Template \"Temporary\" \"Property\""), entity.Properties["RenderedMessage"]);
Assert.AreEqual(new EntityProperty(exception.ToString()), entity.Properties["Exception"]);
Assert.AreEqual(new EntityProperty("Temporary"), entity.Properties["Temp"]);
Assert.AreEqual(new EntityProperty("Property"), entity.Properties["Prop"]);
}
public void SerializesTwoExceptions()
{
var exception1 = new InvalidOperationException("Some message 1");
var exception2 = new ArgumentException("Some message 2");
var errors =
new ErrorSerializer().Serialize(
new List <ApiError>()
{
new ApiError(exception1), new ApiError(exception2)
})["errors"];
Assert.Equal(exception1.Message, errors[0].Value <string>("title"));
Assert.Equal(exception1.GetType().FullName, errors[0].Value <string>("code"));
Assert.Equal(exception1.ToString(), errors[0].Value <string>("detail"));
Assert.Equal(exception2.Message, errors[1].Value <string>("title"));
Assert.Equal(exception2.GetType().FullName, errors[1].Value <string>("code"));
Assert.Equal(exception2.ToString(), errors[1].Value <string>("detail"));
}
