private void AddDeviceNumberEx(IDictionary <string, ResultOrError <StorageDeviceNumber> > dictionary, string path, XmlElement node)
{
if (node == null)
{
return;
}
if (dictionary.ContainsKey(path))
{
return;
}
// Because this is a complex type, The XML will always return the default value.
ResultOrError <StorageDeviceNumber> result = GetResultOrError <StorageDeviceNumber>(node);
if (result != null)
{
dictionary.Add(path, result);
return;
}
string deviceType = node["DeviceType"].Attributes["result"].Value;
string deviceGuidFlags = node["DeviceGuidFlags"].Attributes["result"].Value;
string deviceNumber = node["DeviceNumber"].Attributes["result"].Value;
string devicePartition = node["DevicePartition"].Attributes["result"].Value;
StorageDeviceNumber storageDevNum = new StorageDeviceNumber()
{
DeviceType = (DeviceType)int.Parse(deviceType, CultureInfo.InvariantCulture),
DeviceGuidFlags = (DeviceGuidFlags)int.Parse(deviceGuidFlags, CultureInfo.InvariantCulture),
DeviceGuid = new Guid(node["DeviceGuid"].Attributes["result"].Value),
DeviceNumber = int.Parse(deviceNumber, CultureInfo.InvariantCulture),
PartitionNumber = int.Parse(devicePartition, CultureInfo.InvariantCulture),
};
dictionary.Add(path, new ResultOrError <StorageDeviceNumber>(storageDevNum));
}
public static IEnumerable <object[]> VerifySetupAsync_DataProvider()
{
// SCENARIO: An unsuccessful setup verification result.
// EXPECT: Null to be returned, and an error to be logged.
var unsuccessfulResponse = new ResultOrError <VerifySetupResponse>
{
Success = false,
Result = null,
ErrorMessage = "Hmm, something went wrong.",
};
var mockExtension1 = new Mock <IPlatformExtension>();
mockExtension1
.Setup(ext => ext.VerifySetupAsync("123", "abcdefg"))
.ReturnsAsync(unsuccessfulResponse);
yield return(new object[]
{
null,
mockExtension1,
new SetupRequest {
AccountId = "123",
SetupKey = "abcdefg",
},
});
// SCENARIO: A successful setup verification result.
// EXPECT: A verification response, and no errors to be logged.
var successfulResponse = new ResultOrError <VerifySetupResponse>
{
Success = true,
Result = new VerifySetupResponse
{
AccountId = "202",
AccountDomain = "test.com",
ApiKey = "the_api_key",
ApiSecret = "the_api_secret",
},
};
var mockExtension2 = new Mock <IPlatformExtension>();
mockExtension2
.Setup(ext => ext.VerifySetupAsync("202", "hijklmnop"))
.ReturnsAsync(successfulResponse);
yield return(new object[]
{
new VerifySetupResponse
{
AccountId = "202",
AccountDomain = "test.com",
ApiKey = "the_api_key",
ApiSecret = "the_api_secret",
},
mockExtension2,
new SetupRequest
{
AccountId = "202",
SetupKey = "hijklmnop",
},
});
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
reader.DateTimeZoneHandling = DateTimeZoneHandling.Utc;
reader.DateFormatString = Utils.DateTimeFormat;
reader.DateParseHandling = DateParseHandling.DateTime;
serializer.DateTimeZoneHandling = DateTimeZoneHandling.Utc;
serializer.DateFormatString = Utils.DateTimeFormat;
serializer.DateParseHandling = DateParseHandling.DateTime;
var resultOrError = new ResultOrError <T>();
if (reader.TokenType == JsonToken.StartObject)
{
var jsonObject = JObject.Load(reader);
if (jsonObject["errorCode"] == null)
{
T result = new T();
serializer.Populate(jsonObject.CreateReader(), result);
resultOrError.Result = result;
}
else
{
serializer.Populate(jsonObject.CreateReader(), resultOrError);
}
}
else
{
var jsonArray = JArray.Load(reader);
T result = new T();
serializer.Populate(jsonArray.CreateReader(), result);
resultOrError.Result = result;
}
return(resultOrError);
}
protected override void TestTaskOfResult(ResultOrError <int> result)
{
Task[] tasks = new Task[]
{
result.Async().Bind(() => ResultOrError <int> .Success()),
result.Async().Bind(() => Result <int, int> .Success(100)),
result.Async().Bind(() => Result <int, int> .Success(101), error => Result <int, int> .Error(500)),
result.Async().BindOnError(error => ResultOrError <int> .Error(500)),
result.Async().BindOnError(error => Result.Error()),
result.Async().OnSuccess(() => { }),
result.Async().OnSuccess(() => 101),
result.Async().OnError(error => { }),
result.Async().OnError(error => 500),
result.Async().Either(() => { }, error => { }),
result.Async().Either(() => 101, error => { }),
result.Async().Either(() => { }, error => 500),
result.Async().Either(() => 101, error => 500),
result.Async().Ensure(() => true, () => 500),
result.Async().Match(() => true, error => false),
};
Task.WaitAll(tasks);
}
private ResultOrError <Matrix, string> CalculateMatrices(
IReadOnlyList <Matrix> matrices,
Func <Matrix, Matrix, ResultOrError <Matrix, string> > operation)
{
if (matrices.Count < 2)
{
return(ResultOrError <Matrix, string> .FromError("Нужно минимум две матрицы"));
}
Matrix result = null;
for (var i = 1; i < matrices.Count; i++)
{
var rightOp = matrices[i];
var leftOp = result ?? matrices[i - 1];
var resultOrError = operation(leftOp, rightOp);
if (resultOrError.IsError)
{
return(ResultOrError <Matrix, string> .FromError($"Ошибка при обработке матрицы #{i}: {resultOrError.Error}"));
}
result = resultOrError.Result;
}
return(ResultOrError <Matrix, string> .FromResult(result));
}
public async Task <ResultOrError <PagedResult <ExpenseModel> > > GetMany(Guid userId, int pageNumber, int pageSize = 50, DateTimeOffset?fromDate = null, DateTimeOffset?toDate = null)
{
if (!await _context.DoesExist <User>(userId))
{
return(CommonErrors.UserNotExist);
}
var baseQuery = _context.Expenses
.Include(x => x.Aggregate)
.Include(x => x.ExpenseType)
.Where(x => x.Aggregate.UserId == userId);
if (fromDate.HasValue)
{
baseQuery = baseQuery.Where(x => x.Aggregate.AddedDate >= fromDate.Value);
}
if (toDate.HasValue)
{
baseQuery = baseQuery.Where(x => x.Aggregate.AddedDate <= toDate.Value);
}
var totalItems = await baseQuery.CountAsync();
var items = totalItems == 0
? new List <ExpenseModel>()
: await baseQuery.OrderByDescending(x => x.Aggregate.AddedDate)
.Skip((pageNumber - 1) * pageSize)
.Take(pageSize)
.Select(x => x.ToModel())
.ToListAsync();
return(ResultOrError <PagedResult <ExpenseModel> > .FromResult(
new PagedResult <ExpenseModel>(items, totalItems)));
}
private void AddVolumeInfo(IDictionary <string, ResultOrError <VolumeInfo> > dictionary, string path, XmlElement node)
{
if (node == null)
{
return;
}
if (dictionary.ContainsKey(path))
{
return;
}
// Because this is a complex type, The XML will always return the default value.
ResultOrError <VolumeInfo> result = GetResultOrError <VolumeInfo>(node);
if (result != null)
{
dictionary.Add(path, result);
return;
}
string flags = node["Flags"].Attributes["result"].Value;
VolumeInfo volInfo = new VolumeInfo()
{
VolumeLabel = node["Label"].Attributes["result"].Value,
VolumeSerial = node["SerialNumber"].Attributes["result"].Value,
FileSystem = node["FileSystem"].Attributes["result"].Value,
Flags = (FileSystemFlags)int.Parse(flags, CultureInfo.InvariantCulture)
};
dictionary.Add(path, new ResultOrError <VolumeInfo>(volInfo));
}
protected override void TestKeepMethodsOfResult(ResultOrError <int> result)
{
result.Keep(() => 100, out int num);
result.KeepOnSuccess(() => 100, out int sCode);
result.KeepOnError(error => 500, out int eCode);
result.KeepEither(() => 100, error => 500, out int statusCode);
result.KeepEither(() => 100, error => 500, out int successCode, out int errorCode);
}
public ResultOrError <IReadOnlyList <Matrix>, string> TransposeAllMatrices(IReadOnlyList <Matrix> matrices)
{
var resultMatrices = matrices
.Select(_matrixCalculator.TransposeMatrix)
.ToArray();
return(ResultOrError <IReadOnlyList <Matrix>, string> .FromResult(resultMatrices));
}
public ResultOrError <Matrix, string> AddMatrices(Matrix leftOp, Matrix rightOp)
{
if (leftOp.Width != rightOp.Width || leftOp.Height != rightOp.Height)
{
return(ResultOrError <Matrix, string> .FromError("У матриц при сложении не совпали размеры"));
}
var newMatrix = new int[leftOp.ValuesOneDimensional.Length];
for (var i = 0; i < leftOp.ValuesOneDimensional.Length; i++)
{
newMatrix[i] = leftOp.ValuesOneDimensional[i] + rightOp.ValuesOneDimensional[i];
}
return(ResultOrError <Matrix, string> .FromResult(new Matrix(leftOp.Height, leftOp.Width, newMatrix)));
}
private ResultOrError <Matrix, string> ParseMatrix(string s)
{
var lines = s.Split(new[] { Environment.NewLine }, StringSplitOptions.None).ToArray();
var firstLineWidth = 0;
Matrix result = null;
for (var i = 0; i < lines.Length; i++)
{
var line = lines[i].Split(' ')
.Select(intString => int.TryParse(intString, out var x)
? ResultOrError <int, string> .FromResult(x)
: ResultOrError <int, string> .FromError($"{intString} не является валидным числом"))
.ToArray();
if (!line.Any())
{
return(ResultOrError <Matrix, string> .FromError("В матрице не могут быть пустые строки"));
}
if (line.Any(n => n.IsError))
{
return(ResultOrError <Matrix, string> .FromError(line.First(n => n.IsError).Error));
}
if (i == 0)
{
firstLineWidth = line.Length;
result = new Matrix(lines.Length, line.Length);
}
if (line.Length != firstLineWidth)
{
return(ResultOrError <Matrix, string> .FromError(
$"Число элементов в строке #{i + 1} отличается от первой строки"));
}
for (var j = 0; j < firstLineWidth; j++)
{
// ReSharper disable once PossibleNullReferenceException
result.ValuesOneDimensional[i * firstLineWidth + j] = line[j].Result;
}
}
return(ResultOrError <Matrix, string> .FromResult(result));
}
public ResultOrError <CalculationTask, string> GetTaskDetails()
{
using (var streamReader = _fileReadStreamProvider.GetFileContent())
{
var text = streamReader.ReadToEnd();
var parts = text.Split(new[] { Environment.NewLine + Environment.NewLine },
StringSplitOptions.RemoveEmptyEntries);
if (parts.Length < 2)
{
return(ResultOrError <CalculationTask, string> .FromError("Некорректный формат"));
}
var operation = ParseOperation(parts.First());
if (operation == null)
{
return(ResultOrError <CalculationTask, string> .FromError($"Неизвестная операция {parts.First()}"));
}
if (TwoOperandsOperations.Contains(operation.Value) && parts.Length < 3)
{
return(ResultOrError <CalculationTask, string> .FromError(
"Для сложения/вычитания/умножения нужно как минимум две матрицы"));
}
var matrices = new Matrix[parts.Length - 1];
for (var i = 1; i < parts.Length; i++)
{
var matrixOrError = ParseMatrix(parts[i]);
if (matrixOrError.IsError)
{
return(ResultOrError <CalculationTask, string> .FromError(
$"Ошибка в матрице #{i}: {matrixOrError.Error}"));
}
matrices[i - 1] = matrixOrError.Result;
}
return(ResultOrError <CalculationTask, string> .FromResult(new CalculationTask
{
Matrices = matrices,
Operation = operation.Value
}));
}
}
private void AddItem <T>(IDictionary <string, ResultOrError <T> > dictionary, string path, XmlElement node)
{
if (node == null)
{
return;
}
if (dictionary.ContainsKey(path))
{
return;
}
ResultOrError <T> result = GetResultOrError <T>(node);
if (result == null)
{
throw new ArgumentException("Complex types not supported", nameof(dictionary));
}
dictionary.Add(path, result);
}
protected override void TestSingleResult(ResultOrError <int> result)
{
result.Bind(() => ResultOrError <int> .Success());
result.Bind(() => Result <int, int> .Success(100));
result.Bind(() => Result <int, int> .Success(101), error => Result <int, int> .Error(500));
result.BindOnError(error => ResultOrError <int> .Error(500));
result.BindOnError(error => Result.Error());
result.OnSuccess(() => { });
result.OnSuccess(() => 101);
result.OnError(error => { });
result.OnError(error => 500);
result.Either(() => { }, error => { });
result.Either(() => 101, error => { });
result.Either(() => { }, error => 500);
result.Either(() => 101, error => 500);
result.Ensure(() => true, () => 500);
result.Match(() => true, error => false);
}
protected override void TestLargeContent(ResultOrError <string> result)
{
result.Bind(() => ResultOrError <string> .Success());
result.Bind(() => Result <string, string> .Success(LargeContent));
result.Bind(() => Result <string, string> .Success(LargeContent), error => Result <string, string> .Error(error));
result.BindOnError(error => ResultOrError <string> .Error(error));
result.BindOnError(error => Result <string, string> .Error(error));
result.OnSuccess(() => { });
result.OnSuccess(() => LargeContent);
result.OnError(error => { });
result.OnError(error => error);
result.Either(() => { }, error => { });
result.Either(() => LargeContent, error => { });
result.Either(() => { }, error => error);
result.Either(() => LargeContent, error => error);
result.Ensure(() => true, () => LargeContent);
result.Match(() => LargeContent, error => error);
}
protected override void TestIEnumerableOfResult(ResultOrError <int>[] results)
{
results.Bind(() => ResultOrError <int> .Success()).Count();
results.Bind(() => Result <int, int> .Success(100)).Count();
results.Bind(() => Result <int, int> .Success(101), error => Result <int, int> .Error(500)).Count();
results.BindOnError(error => ResultOrError <int> .Error(500)).Count();
results.BindOnError(error => Result.Error()).Count();
results.OnSuccess(() => { }).Count();
results.OnSuccess(() => 101).Count();
results.OnError(error => { }).Count();
results.OnError(error => 500).Count();
results.Either(() => { }, error => { }).Count();
results.Either(() => 101, error => { }).Count();
results.Either(() => { }, error => 500).Count();
results.Either(() => 101, error => 500).Count();
results.Ensure(() => true, () => 500).Count();
results.Match(() => true, error => false).Count();
}
private void AddStorageDevice(IDictionary <string, ResultOrError <VolumeDeviceQuery> > dictionary, string path, XmlElement node)
{
if (node == null)
{
return;
}
if (dictionary.ContainsKey(path))
{
return;
}
// Because this is a complex type, The XML will always return the default value.
ResultOrError <VolumeDeviceQuery> result = GetResultOrError <VolumeDeviceQuery>(node);
if (result != null)
{
dictionary.Add(path, result);
return;
}
string removableMedia = node["RemovableMedia"].Attributes["result"].Value;
string cmdQueuing = node["CommandQueueing"].Attributes["result"].Value;
string scsiDevType = node["ScsiDeviceType"].Attributes["result"].Value;
string scsiDevMod = node["ScsiModifier"].Attributes["result"].Value;
string busType = node["BusType"].Attributes["result"].Value;
VolumeDeviceQuery devQuery = new VolumeDeviceQuery()
{
VendorId = node["VendorId"].Attributes["result"].Value,
DeviceSerialNumber = node["DeviceSerialNumber"].Attributes["result"].Value,
ProductId = node["ProductId"].Attributes["result"].Value,
ProductRevision = node["ProductRevision"].Attributes["result"].Value,
RemovableMedia = bool.Parse(removableMedia),
CommandQueueing = bool.Parse(cmdQueuing),
ScsiDeviceType = (ScsiDeviceType)int.Parse(scsiDevType, CultureInfo.InvariantCulture),
ScsiDeviceModifier = int.Parse(scsiDevMod, CultureInfo.InvariantCulture),
BusType = (BusType)int.Parse(busType, CultureInfo.InvariantCulture)
};
dictionary.Add(path, new ResultOrError <VolumeDeviceQuery>(devQuery));
}
private void AddDiskExtents(IDictionary <string, ResultOrError <DiskExtent[]> > dictionary, string path, XmlElement node)
{
if (node == null)
{
return;
}
if (dictionary.ContainsKey(path))
{
return;
}
// Because this is a complex type, The XML will always return the default value.
ResultOrError <DiskExtent[]> result = GetResultOrError <DiskExtent[]>(node);
if (result != null)
{
dictionary.Add(path, result);
return;
}
// There may be zero or more disk extents.
XmlNodeList extentNodes = node.SelectNodes("DiskExtent");
List <DiskExtent> extents = new List <DiskExtent>();
foreach (XmlElement extentNode in extentNodes)
{
string offset = extentNode["Offset"].Attributes["result"].Value;
string length = extentNode["Length"].Attributes["result"].Value;
extents.Add(new DiskExtent()
{
Device = extentNode["Device"].Attributes["result"].Value,
StartingOffset = long.Parse(offset, CultureInfo.InvariantCulture),
ExtentLength = long.Parse(length, CultureInfo.InvariantCulture),
});
}
dictionary.Add(path, new ResultOrError <DiskExtent[]>(extents.ToArray()));
}
private async Task <ResultOrError <T> > CallAsync <T>(
string requestUri, Dictionary <string, string> dataMap)
{
HttpResponseMessage httpResponse = null;
var result = new ResultOrError <T>();
try
{
httpResponse = await httpClient.PostAsync(requestUri, new FormUrlEncodedContent(dataMap));
var data = await httpResponse.Content.ReadAsStringAsync();
JsonConvert.PopulateObject(data, result);
}
finally
{
if (httpResponse != null)
{
httpResponse.Dispose();
}
}
return(result);
}
public ResultOrError <Matrix, string> MultiplyMatrices(Matrix leftOp, Matrix rightOp)
{
if (leftOp.Width != rightOp.Height)
{
return(ResultOrError <Matrix, string> .FromError("У матриц при умножении не совпали размеры"));
}
var result = new Matrix(leftOp.Height, rightOp.Width);
for (int i = 0; i < leftOp.Height; i++)
{
for (int j = 0; j < rightOp.Width; j++)
{
var value = 0;
for (int k = 0; k < leftOp.Width; k++)
{
value += leftOp[i, k] * rightOp[k, j];
}
result[i, j] = value;
}
}
return(ResultOrError <Matrix, string> .FromResult(result));
}
private void AddDiskFreeSpace(IDictionary <string, ResultOrError <DiskFreeSpace> > dictionary, string path, XmlElement node)
{
if (node == null)
{
return;
}
if (dictionary.ContainsKey(path))
{
return;
}
// Because this is a complex type, The XML will always return the default value.
ResultOrError <DiskFreeSpace> result = GetResultOrError <DiskFreeSpace>(node);
if (result != null)
{
dictionary.Add(path, result);
return;
}
string sectorsPerCluster = node["SectorsPerCluster"].Attributes["result"].Value;
string bytesPerSector = node["BytesPerSector"].Attributes["result"].Value;
string totalBytes = node["TotalBytes"].Attributes["result"].Value;
string totalBytesFree = node["TotalBytesFree"].Attributes["result"].Value;
string userBytesFree = node["UserBytesFree"].Attributes["result"].Value;
DiskFreeSpace freeInfo = new DiskFreeSpace()
{
SectorsPerCluster = int.Parse(sectorsPerCluster, CultureInfo.InvariantCulture),
BytesPerSector = int.Parse(bytesPerSector, CultureInfo.InvariantCulture),
TotalBytes = long.Parse(totalBytes, CultureInfo.InvariantCulture),
TotalBytesFree = long.Parse(totalBytesFree, CultureInfo.InvariantCulture),
UserBytesFree = long.Parse(userBytesFree, CultureInfo.InvariantCulture),
};
dictionary.Add(path, new ResultOrError <DiskFreeSpace>(freeInfo));
}
private void AddAlignment(IDictionary <string, ResultOrError <StorageAccessAlignment> > dictionary, string path, XmlElement node)
{
if (node == null)
{
return;
}
if (dictionary.ContainsKey(path))
{
return;
}
// Because this is a complex type, The XML will always return the default value.
ResultOrError <StorageAccessAlignment> result = GetResultOrError <StorageAccessAlignment>(node);
if (result != null)
{
dictionary.Add(path, result);
return;
}
string bytesPerCacheLine = node["BytesPerCacheLine"].Attributes["result"].Value;
string bytesOffsetForCacheAlignment = node["BytesOffsetForCacheAlignment"].Attributes["result"].Value;
string bytesPerLogicalSector = node["BytesPerLogicalSector"].Attributes["result"].Value;
string bytesPerPhysicalSector = node["BytesPerPhysicalSector"].Attributes["result"].Value;
string bytesOffsetForSectorAlignment = node["BytesOffsetForSectorAlignment"].Attributes["result"].Value;
StorageAccessAlignment diskAlignment = new StorageAccessAlignment()
{
BytesPerCacheLine = int.Parse(bytesPerCacheLine, CultureInfo.InvariantCulture),
BytesOffsetForCacheAlignment = int.Parse(bytesOffsetForCacheAlignment, CultureInfo.InvariantCulture),
BytesPerLogicalSector = int.Parse(bytesPerLogicalSector, CultureInfo.InvariantCulture),
BytesPerPhysicalSector = int.Parse(bytesPerPhysicalSector, CultureInfo.InvariantCulture),
BytesOffsetForSectorAlignment = int.Parse(bytesOffsetForSectorAlignment, CultureInfo.InvariantCulture),
};
dictionary.Add(path, new ResultOrError <StorageAccessAlignment>(diskAlignment));
}
private void AddGeometry(IDictionary <string, ResultOrError <DiskGeometry> > dictionary, string path, XmlElement node)
{
if (node == null)
{
return;
}
if (dictionary.ContainsKey(path))
{
return;
}
// Because this is a complex type, The XML will always return the default value.
ResultOrError <DiskGeometry> result = GetResultOrError <DiskGeometry>(node);
if (result != null)
{
dictionary.Add(path, result);
return;
}
string mediaType = node["MediaType"].Attributes["result"].Value;
string cylinders = node["Cylinders"].Attributes["result"].Value;
string tracks = node["TracksPerCylinder"].Attributes["result"].Value;
string sectors = node["SectorsPerTrack"].Attributes["result"].Value;
string bytes = node["BytesPerSector"].Attributes["result"].Value;
DiskGeometry diskGeo = new DiskGeometry()
{
MediaType = (MediaType)int.Parse(mediaType, CultureInfo.InvariantCulture),
Cylinders = int.Parse(cylinders, CultureInfo.InvariantCulture),
TracksPerCylinder = int.Parse(tracks, CultureInfo.InvariantCulture),
SectorsPerTrack = int.Parse(sectors, CultureInfo.InvariantCulture),
BytesPerSector = int.Parse(bytes, CultureInfo.InvariantCulture),
};
dictionary.Add(path, new ResultOrError <DiskGeometry>(diskGeo));
}
public static IEnumerable <object[]> VerifySetupAsync_DataProvider()
{
// SCENARIO: An unsuccessful setup verification result.
// EXPECT: Null to be returned.
var unsuccessfulResponse = new ResultOrError <VenueVerifySetupResponse>
{
Success = false,
Result = null,
ErrorMessage = "Hmm, something went wrong.",
};
var mockExtension1 = new Mock <IPlatformExtension>();
mockExtension1
.Setup(ext => ext.VenueVerifySetupAsync("123", "456", "abcdefg"))
.ReturnsAsync(unsuccessfulResponse);
yield return(new object[]
{
null,
mockExtension1,
new VenueSetupRequest
{
Region = "ap-southeast-2",
AccountId = "123",
VenueId = "456",
SetupKey = "abcdefg",
},
"https://www.ivvy.com.au/extension/venue-verify",
});
// SCENARIO: A successful setup verification result.
// EXPECT: A verification response.
var successfulResponse = new ResultOrError <VenueVerifySetupResponse>
{
Success = true,
Result = new VenueVerifySetupResponse
{
AccountId = "123",
AccountDomain = "test.com",
VenueId = "456",
VenueHashId = "venuehashid",
},
};
var mockExtension2 = new Mock <IPlatformExtension>();
mockExtension2
.Setup(ext => ext.VenueVerifySetupAsync("123", "456", "abcdefg"))
.ReturnsAsync(successfulResponse);
yield return(new object[]
{
new VenueVerifySetupResponse
{
AccountId = "123",
AccountDomain = "test.com",
VenueId = "456",
VenueHashId = "venuehashid",
},
mockExtension2,
new VenueSetupRequest
{
Region = "ap-southeast-2",
AccountId = "123",
VenueId = "456",
SetupKey = "abcdefg",
},
"https://www.ivvy.com.au/extension/venue-verify",
});
}
private void AddPartitionInfo(IDictionary <string, ResultOrError <PartitionInformation> > dictionary, string path, XmlElement node)
{
if (node == null)
{
return;
}
if (dictionary.ContainsKey(path))
{
return;
}
// Because this is a complex type, The XML will always return the default value.
ResultOrError <PartitionInformation> result = GetResultOrError <PartitionInformation>(node);
if (result != null)
{
dictionary.Add(path, result);
return;
}
string style = node["Style"].Attributes["result"].Value;
string number = node["Number"].Attributes["result"].Value;
string offset = node["Offset"].Attributes["result"].Value;
string length = node["Length"].Attributes["result"].Value;
PartitionStyle partStyle = (PartitionStyle)int.Parse(style, CultureInfo.InvariantCulture);
int partNumber = int.Parse(number, CultureInfo.InvariantCulture);
long partOffset = long.Parse(offset, CultureInfo.InvariantCulture);
long partLength = long.Parse(length, CultureInfo.InvariantCulture);
switch (partStyle)
{
case PartitionStyle.MasterBootRecord:
dictionary.Add(path, new ResultOrError <PartitionInformation>(
new MbrPartition()
{
Number = partNumber,
Offset = partOffset,
Length = partLength,
Bootable = bool.Parse(node["MbrBootable"].Attributes["result"].Value),
HiddenSectors = int.Parse(node["MbrOffset"].Attributes["result"].Value),
Type = int.Parse(node["MbrType"].Attributes["result"].Value)
}));
break;
case PartitionStyle.GuidPartitionTable:
dictionary.Add(path, new ResultOrError <PartitionInformation>(
new GptPartition()
{
Number = partNumber,
Offset = partOffset,
Length = partLength,
Type = new Guid(node["GptType"].Attributes["result"].Value),
Id = new Guid(node["GptId"].Attributes["result"].Value),
Name = node["GptName"].Attributes["result"].Value,
Attributes = (EFIPartitionAttributes)long.Parse(node["GptAttributes"].Attributes["result"].Value, CultureInfo.InvariantCulture)
}));
break;
default:
dictionary.Add(path, new ResultOrError <PartitionInformation>(
new PartitionInformation(partStyle)
{
Number = partNumber,
Offset = partOffset,
Length = partLength
}));
break;
}
}
