protected async override Task <object> OnPerform()
{
var reason = JsonConvert.SerializeObject(_taxExemptionContract);
var content = new StringContent(reason, Encoding.UTF8, ApplicationJSON);
var response = await _saleRestClient.SetTaxExemption(content);
var data = await response.Content.ReadAsStringAsync();
switch (response.StatusCode)
{
case HttpStatusCode.OK:
var saleContract = new DeSerializer().MapSale(data);
return(new Mapper().MapSale(saleContract));
default:
return(await HandleExceptions(response));
}
}
protected override async Task <object> OnPerform()
{
var content = new StringContent(JsonConvert.SerializeObject(_saleSummaryContract),
Encoding.UTF8, ApplicationJSON);
var response = await _restClient.SaleSummary(content, _kickBackAmount);
var data = await response.Content.ReadAsStringAsync();
switch (response.StatusCode)
{
case HttpStatusCode.OK:
var saleSummary = new DeSerializer().MapCheckoutSummary(data);
return(new Mapper().MapCheckoutSummary(saleSummary));
default:
return(await HandleExceptions(response));
}
}
protected async override Task <object> OnPerform()
{
var updateTierLevelContract = JsonConvert.SerializeObject(_updateTierLevelContract);
var content = new StringContent(updateTierLevelContract, Encoding.UTF8, ApplicationJSON);
var response = await _fuelPumpRestClient.UpdateTierLevel(content);
var data = await response.Content.ReadAsStringAsync();
switch (response.StatusCode)
{
case HttpStatusCode.OK:
var contract = new DeSerializer().MapTierLevel(data);
return(new Mapper().MapTierLevel(contract));
default:
return(await HandleExceptions(response));
}
}
protected async override Task <object> OnPerform()
{
var changePassword = JsonConvert.SerializeObject(_closeBatchContract);
var content = new StringContent(changePassword, Encoding.UTF8, ApplicationJSON);
var response = await _maintenanceRestClient.Initialize(content);
var data = await response.Content.ReadAsStringAsync();
switch (response.StatusCode)
{
case HttpStatusCode.OK:
var parsedData = new DeSerializer().MapError(data);
return(new Mapper().MapError(parsedData));
default:
return(await HandleExceptions(response));
}
}
/// <summary>
/// Method to add stock
/// </summary>
/// <returns></returns>
protected async override Task <object> OnPerform()
{
var stockContract = new Mapper().MapStock(_stock);
var customer = JsonConvert.SerializeObject(stockContract);
var content = new StringContent(customer, Encoding.UTF8, ApplicationJSON);
var response = await _stockRestClient.AddProduct(content);
var data = await response.Content.ReadAsStringAsync();
switch (response.StatusCode)
{
case HttpStatusCode.OK:
var parsedData = new DeSerializer().MapSuccess(data);
return(parsedData.success);
default:
return(await HandleExceptions(response));
}
}
protected override async Task <object> OnPerform()
{
var response = await _restClient.ValidateAITE(
_cacheManager.SaleNumber, _cacheManager.TillNumberForSale,
_cacheManager.ShiftNumber, _cacheManager.RegisterNumber,
_cardNumber, _barCode, _isCardNumber? 2 : 1);
var data = await response.Content.ReadAsStringAsync();
switch (response.StatusCode)
{
case HttpStatusCode.OK:
var validateAite = new DeSerializer().MapValidateAITE(data);
return(new Mapper().MapValidateAITE(validateAite));
default:
return(await HandleExceptions(response));
}
}
public static void LoadMap(string filePath, GameObject dungeon, GameObject room, string pathOfFolder)
{
NewDungeonModel dungeonModel = DeSerializer.DeserializeXMLFileToObject <NewDungeonModel>(filePath, "Dungeon");
Dungeon = GameObject.Instantiate(dungeon);
//if (dungeonModel == null)
// Debug.Log("ewgbaefdr");
foreach (RoomID r in dungeonModel.Rooms.rooms)
{
//Debug.Log("funkar: " + r.ID);
string path = Path.Combine(pathOfFolder, "room-" + r.ID + ".xml");
FileInfo fileInfo = new FileInfo(path);
//r.ID = "" + roomNumber;
if (fileInfo.Exists)
{
//Debug.Log("finns: " + r.ID);
newRoomModel roomObject = DeSerializer.DeserializeXMLFileToObject <newRoomModel>(path, "Room");
rooms.Add(CallCreateRoom(dungeonModel, roomObject, room));
roomNumber++;
}
else
{
Debug.Log(path + " ERROR PATH");
}
}
foreach (GameObject r in rooms)
{
foreach (GameObject d in r.GetComponent <createRoom>().doors)
{
foreach (GameObject target in rooms)
{
//Debug.Log(target.GetComponent<createRoom>().XmlID + " : " + d.GetComponent<DoorScript>().XmlTargetId);
if (target.GetComponent <createRoom>().XmlID.Equals(d.GetComponent <DoorScript>().XmlTargetId))
{
d.GetComponent <DoorScript>().TargetRoom = target;
d.GetComponent <DoorScript>().targetRoomID = target.GetComponent <createRoom>().RoomID;
}
}
}
}
}
protected async override Task <object> OnPerform()
{
var completeCashDrawContract = MapCompleteCashDrawContract();
var completeCashDrawModel = JsonConvert.SerializeObject(completeCashDrawContract);
var content = new StringContent(completeCashDrawModel, Encoding.UTF8, ApplicationJSON);
var response = await _cashRestClient.CompleteCashDraw(content);
var data = await response.Content.ReadAsStringAsync();
switch (response.StatusCode)
{
case HttpStatusCode.OK:
var returnedSale = new DeSerializer().MapReport(data);
return(new Mapper().MapReport(returnedSale));
default:
return(await HandleExceptions(response));
}
}
protected async override Task <object> OnPerform()
{
var givexcardContract = new Mapper().MapGivexCard(_giveXCardModel);
var givexcard = JsonConvert.SerializeObject(givexcardContract);
var content = new StringContent(givexcard, Encoding.UTF8, ApplicationJSON);
var response = await _givexRestClient.AddAmount(content);
var data = await response.Content.ReadAsStringAsync();
switch (response.StatusCode)
{
case HttpStatusCode.OK:
var contract = new DeSerializer().MapGivexSaleContract(data);
return(new Mapper().MapGivexSaleContract(contract));
default:
return(await HandleExceptions(response));
}
}
protected async override Task <object> OnPerform()
{
var changePasswordContract = new Mapper().MapChangePassword(_cacheManager, _password, _confirmPassword);
var changePassword = JsonConvert.SerializeObject(changePasswordContract);
var content = new StringContent(changePassword, Encoding.UTF8, ApplicationJSON);
var response = await _maintenanceRestClient.ChangePassword(content);
var data = await response.Content.ReadAsStringAsync();
switch (response.StatusCode)
{
case HttpStatusCode.OK:
case HttpStatusCode.Accepted:
var parsedData = new DeSerializer().MapChangePasswordSuccess(data);
return(new Mapper().MapChangePasswordSuccess(parsedData));
default:
return(await HandleExceptions(response));
}
}
protected async override Task <object> OnPerform()
{
var contract = JsonConvert.SerializeObject(_paymentByAccountContract);
var content = new StringContent(contract, Encoding.UTF8, ApplicationJSON);
var response = await _restClient.PaymentByAccount(content);
var data = await response.Content.ReadAsStringAsync();
switch (response.StatusCode)
{
case HttpStatusCode.OK:
var paymentComplete = new DeSerializer().MapTenderSummary(data);
return(new Mapper().MapTenderSummary(paymentComplete));
case HttpStatusCode.NotFound:
throw PurchaseOrderRequiredException(data);
default:
return(await HandleExceptions(response));
}
}
protected async override Task <object> OnPerform()
{
var file = await StorageFile.GetFileFromPathAsync(_image.LocalPath);
var stream = await file.OpenStreamForReadAsync();
var content = new StreamContent(stream);
var response = await _restClient.SaveSignature(content);
var data = await response.Content.ReadAsStringAsync();
switch (response.StatusCode)
{
case HttpStatusCode.OK:
var result = new DeSerializer().MapSuccess(data);
return(result.success);
default:
return(await HandleExceptions(response));
}
}
protected override async Task <object> OnPerform()
{
var response = await _restClient.UpdateTender(
_cacheManager.SaleNumber,
_cacheManager.TillNumberForSale,
_code,
_amount,
_transactionType, _isAmountEnteredManually);
var data = await response.Content.ReadAsStringAsync();
switch (response.StatusCode)
{
case HttpStatusCode.OK:
var tendersSummary = new DeSerializer().MapTenderSummary(data);
return(new Mapper().MapTenderSummary(tendersSummary));
default:
return(await HandleExceptions(response));
}
}
protected override async Task <object> OnPerform()
{
var response = await _restClient.SearchCustomers(_searchTerm,
_pageIndex, _loyalty);
var data = await response.Content.ReadAsStringAsync();
switch (response.StatusCode)
{
case HttpStatusCode.OK:
var customers = new DeSerializer().MapCustomers(data);
return(new Mapper().MapCustomers(customers));
case HttpStatusCode.Accepted:
var sale = new DeSerializer().MapSale(data);
return(new Mapper().MapSale(sale));
default:
return(await HandleExceptions(response));
}
}
protected async override Task <object> OnPerform()
{
var deleteContract = JsonConvert.SerializeObject(_contract);
var content = new StringContent(deleteContract, Encoding.UTF8, ApplicationJSON);
var response = await _fuelPumpRestClient.SaveBasePrices(content);
var data = await response.Content.ReadAsStringAsync();
switch (response.StatusCode)
{
case HttpStatusCode.OK:
var contract = new DeSerializer().MapErrorWithCaption(data);
return(new Mapper().MapErrorWithCaption(contract));
case HttpStatusCode.Conflict:
throw PumpsOfflineException(data);
default:
return(await HandleExceptions(response));
}
}
protected override async Task <object> OnPerform()
{
var addStockToSale = new Mapper().MapAddStockToSale(_tillNumber,
_saleNumber, _registerNumber, _stockCode, _quantity,
_isReturn, _isManuallyAdded, _giftCard);
var reason = JsonConvert.SerializeObject(addStockToSale);
var content = new StringContent(reason, Encoding.UTF8, ApplicationJSON);
var response = await _saleRestClient.AddStockToSale(content);
var data = await response.Content.ReadAsStringAsync();
switch (response.StatusCode)
{
case HttpStatusCode.OK:
var suspendedSales = new DeSerializer().MapSale(data);
return(new Mapper().MapSale(suspendedSales));
default:
return(await HandleExceptions(response));
}
}
protected override async Task <object> OnPerform()
{
var response = await _restClient.CompleteOverLimit(
_cacheManager.SaleNumber,
_cacheManager.TillNumberForSale,
_reason,
_explanation,
_location,
_date);
var data = await response.Content.ReadAsStringAsync();
switch (response.StatusCode)
{
case HttpStatusCode.OK:
var saleSumarry = new DeSerializer().MapCheckoutSummary(data);
return(new Mapper().MapCheckoutSummary(saleSumarry));
default:
return(await HandleExceptions(response));
}
}
public MatchConfiguration(GameLauncher parent)
{
InitializeComponent();
this.gameLauncher = parent;
this.difficultyTrackBar.Value = 0;
this.enemiesTrackBar.Value = 0;
this.mapCollection = DeSerializer.DeserializeMapCollection("Resources\\Maps\\map.xml");
this.charCollection = DeSerializer.DeserializeCharacterCollection("Resources\\Characters\\characters.xml");
this.charCollectionCurrentIndex = 0;
foreach (MapSeriazable ms in mapCollection.Maps)
{
this.mapComboBox.Items.Add(ms.Name);
}
this.mapComboBox.SelectedIndex = 0;
SetCurrentCharacter();
}
protected async override Task <object> OnPerform()
{
var payLoad = _fuelPrices != null ?
(from f in _fuelPrices.Prices
select new FuelPriceContract
{
cashPrice = f.CashPrice,
creditPrice = f.CreditPrice,
grade = f.Grade,
gradeId = f.GradeId,
level = f.Level,
levelId = f.LevelId,
taxExemptedCashPrice = f.TaxExemptedCashPrice,
taxExemptedCreditPrice = f.TaxExemptedCreditPrice,
tier = f.Tier,
tierId = f.TierId,
row = f.Row
}).ToList() : new List <FuelPriceContract>();
var contract = JsonConvert.SerializeObject(payLoad);
var content = new StringContent(contract, Encoding.UTF8, ApplicationJSON);
var response = await _fuelPumpRestClient.VerifyGroupBasePrices(content);
var data = await response.Content.ReadAsStringAsync();
switch (response.StatusCode)
{
case HttpStatusCode.OK:
var responseContract = new DeSerializer().MapSuccess(data);
return(responseContract?.success);
case HttpStatusCode.Conflict:
throw PumpsOfflineException(data);
default:
return(await HandleExceptions(response));
}
}
/// <summary>
/// Generates Api Data Exception based on the data
/// </summary>
/// <param name="data">JSON Data</param>
/// <returns>API Data Exception</returns>
protected ApiDataException NotFoundException(string data)
{
try
{
var error = new DeSerializer().MapError(data);
var errorModel = new Mapper().MapError(error);
return(new ApiDataException
{
Error = errorModel
});
}
catch (Exception ex)
{
return(new ApiDataException
{
Error = new EntityLayer.Entities.Common.Error
{
Message = "Server is not connected"
}
});
}
}
protected async override Task <object> OnPerform()
{
var ipAddress = _cacheManager.IpAddress;
#if DEBUG
// ipAddress = "172.16.0.42";
#endif
var response = await _restClient.GetActiveTheme(ipAddress);
var data = await response.Content.ReadAsStringAsync();
switch (response.StatusCode)
{
case HttpStatusCode.OK:
var parsedData = new DeSerializer().MapTheme(data);
var theme = new Mapper().MapTheme(parsedData);
return(theme);
default:
return(await HandleExceptions(response));
}
}
/// <summary>
/// Method to Complete a Bottle Return Sale
/// </summary>
/// <returns></returns>
protected override async Task <object> OnPerform()
{
_sale.SaleNumber = _cacheManager.SaleNumber;
_sale.TillNumber = _cacheManager.TillNumberForSale;
_sale.Register = _cacheManager.RegisterNumber;
var saleContract = new Mapper().MapBottleReturnSale(_sale);
var sale = JsonConvert.SerializeObject(saleContract);
var content = new StringContent(sale, Encoding.UTF8, ApplicationJSON);
var response = await _stockRestClient.AddBottleReturnSale(content);
var data = await response.Content.ReadAsStringAsync();
switch (response.StatusCode)
{
case HttpStatusCode.OK:
var result = new DeSerializer().MapBottleReturn(data);
return(result);
default:
return(await HandleExceptions(response));
}
}
/// <summary>
/// Serialization method
/// </summary>
/// <returns>Login policies</returns>
protected override async Task <object> OnPerform()
{
var ipAddress = _cacheManager.IpAddress;
// Hard coded IP for development
//#if DEBUG
// // ipAddress = "172.16.0.42";
//#endif
var response = await _restClient.GetLoginPolicyAsync(ipAddress);
//response ok to continue
var data = await response.Content.ReadAsStringAsync();
switch (response.StatusCode)
{
case HttpStatusCode.OK:
//validate json
var loginPolicies = new DeSerializer().MapLoginPolicies(data);
return(new Mapper().MapLoginPolicies(loginPolicies));
default:
return(await HandleExceptions(response));
}
}
public override bool DeSerialize(DeSerializer deserializer, string fieldname, object value)
{
if (base.DeSerialize(deserializer, fieldname, value))
{
return(true);
}
else if (fieldname == "Radius")
{
mRadius = (double)value;
}
else if (fieldname == "Interval")
{
mInterval = (int)value;
}
else if (fieldname == "LineRotAngleDifference")
{
mAngleDifference = (double)value;
}
else if (fieldname == "ShowLines")
{
mShowLines = (bool)value;
}
else if (fieldname == "StartPoint")
{
gpStartPoint = value as gPoint;
}
else if (fieldname == "EndPoint")
{
gpEndPoint = value as gPoint;
}
else
{
return(false);
}
return(true);
}
protected async override Task <object> OnPerform()
{
var updateTenderContract = new UpdateTenderPostContract()
{
tenders = new List <TenderContract>(),
dropReason = _updateTender.DropReason,
tillNumber = _cacheManager.TillNumber,
saleNumber = _cacheManager.SaleNumber
};
foreach (var tender in _updateTender.Tenders)
{
updateTenderContract.tenders.Add(new TenderContract
{
amountEntered = tender.AmountEntered,
tenderCode = tender.TenderCode
});
}
var completeCashDrawModel = JsonConvert.SerializeObject(updateTenderContract);
var content = new StringContent(completeCashDrawModel, Encoding.UTF8, ApplicationJSON);
var response = await _cashRestClient.UpdateTenderForCashdrop(content);
var data = await response.Content.ReadAsStringAsync();
switch (response.StatusCode)
{
case HttpStatusCode.OK:
var updatedTendersGet = new DeSerializer().MapUpdatedTendersGet(data);
return(new Mapper().MapUpdatedTendersGet(updatedTendersGet));
default:
return(await HandleExceptions(response));
}
}
public override bool DeSerialize(DeSerializer deserializer, string fieldname, object value)
{
if (base.DeSerialize(deserializer, fieldname, value))
{
return(true);
}
else if (fieldname == "arrowSize")
{
mArrowSize = (double)value;
}
else if (fieldname == "StartPoint")
{
mStartPoint = (gPoint)value;
}
else if (fieldname == "EndPoint")
{
mEndPoint = (gPoint)value;
}
else
{
return(false);
}
return(true);
}
protected async override Task <object> OnPerform()
{
var contract = new
{
saleNumber = _cacheManager.SaleNumber,
tillNumber = _cacheManager.TillNumber
};
var content = new StringContent(JsonConvert.SerializeObject(contract)
, Encoding.UTF8, ApplicationJSON);
var response = await _checkoutRestClient.PumpTest(content);
var data = await response.Content.ReadAsStringAsync();
switch (response.StatusCode)
{
case HttpStatusCode.OK:
var paymentComplete = new DeSerializer().MapCommonCompletePayment(data);
return(new Mapper().MapCommonCompletePayment(paymentComplete));
default:
return(await HandleExceptions(response));
}
}
private void button5_Click(object sender, EventArgs e)
{
byte[] bytes = new byte[6] {
1, 2, 3, 4, 5, 6
};
Serializer serializer = new Serializer();
byte[] b = serializer.Serialize(bytes);
DeSerializer deSerializer = new DeSerializer();
byte[] bytes2 = deSerializer.DeSerialize <byte[]>(b);
sbyte[] sbytes = new sbyte[6] {
-3, -2, -1, 0, 1, 2
};
b = serializer.Serialize(sbytes);
sbyte[] sbytes2 = deSerializer.DeSerialize <sbyte[]>(b);
}
protected async override Task <object> OnPerform()
{
var payByExactChangeContract = new PayByExactChangeContract
{
saleNumber = _cacheManager.SaleNumber,
tillNumber = _cacheManager.TillNumber
};
var reason = JsonConvert.SerializeObject(payByExactChangeContract);
var content = new StringContent(reason, Encoding.UTF8, ApplicationJSON);
var response = await _paymentRestClient.PayByExactChange(content);
var data = await response.Content.ReadAsStringAsync();
switch (response.StatusCode)
{
case HttpStatusCode.OK:
var exactChangeContract = new DeSerializer().MapExactChange(data);
return(new Mapper().MapExactChange(exactChangeContract));
default:
return(await HandleExceptions(response));
}
}
public void UpdateOverviewFile(string serverPath, Overview newOverview)
{
DeSerializer.Serialize(newOverview, serverPath + Path.DirectorySeparatorChar + OverviewFileName);
}
