public async Task <ActionResult <CashOrderResponseCreate> > Create(CashOrder cashOrder)
{
try
{
CashOrderHelper.Validate(cashOrder, logger, ModelState);
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
CashOrderHelper.AddClientIp(cashOrder, HttpContext.Connection.RemoteIpAddress.ToString());
CashOrderHelper.SetStatusInProgress(cashOrder);
if (RequestMode.IsCreate(cashOrder))
{
List <CashOrder> cashOrders = SendMessage(cashOrder);
if (cashOrders.Count > 0)
{
return(Ok(CashOrderHelper.ConvertToResponseCreate(cashOrders)));
}
else
{
return(BadRequest());
}
}
}
catch (Exception ex)
{
logger.LogError(ex.Message + "\n" + ex.StackTrace);
return(BadRequest());
}
return(BadRequest());
}
/// <summary>
/// This method does the work of writing a lid to table 2049 and reading
/// the results from table 2050.
/// </summary>
/// <remarks>
/// It is up to the calling method to translate the data. This method
/// always sets the mode to DataOnly.
///
/// Also, it is up to the calling method to perform the PSEM wait.
/// </remarks>
/// <param name="lid">The requested LID</param>
/// <param name="eMode">Request Mode</param>
/// <param name="data">The data returned from the device</param>
/// <returns>PSEMResponse returned from the device</returns>
/// Revision History
/// MM/DD/YY who Version Issue# Description
/// -------- --- ------- ------ ---------------------------------------
/// 05/23/06 mrj 7.30.00 N/A Created
/// 09/27/06 KRC 7.35.00 N/A Add RequestMode
///
public PSEMResponse RetrieveLID(LID lid, RequestMode eMode, out byte[] data)
{
LID[] lids = new LID[1];
lids[0] = lid;
return(RetrieveMulitpleLIDs(lids, eMode, out data));
}
private static void ExecuteBackupPolicy(string message, RestRequest request, RequestMode requestMode)
{
switch (message)
{
case RegistrationFailureError:
ExecuteRequest(request, requestMode);
break;
case UserExistanceError:
UpdateUserAccount(request.Parameters[1].Value.ToString(), request.Parameters[2].Value.ToString(), (PushEnabled)Convert.ToInt16(request.Parameters[3].Value), UserStatus.NotSpecified);
break;
case PasswordUpdateError:
case PushEnabledError:
UpdateUserAccount(request.Parameters[1].Value.ToString(), request.Parameters[2].Value.ToString(), (PushEnabled)Convert.ToInt16(request.Parameters[3].Value), UserStatus.NotSpecified);
break;
case UserNotFoundError:
RegisterUser(request.Parameters[1].Value.ToString(), request.Parameters[2].Value.ToString(), (PushEnabled)Convert.ToInt16(request.Parameters[3].Value));
break;
default:
throw new Exception(message);
}
}
public ActionResult <RequestMode> PostRequestMode(RequestMode requestMode)
{
_requestModeRepository.Add(requestMode);
_requestModeRepository.Save();
return(CreatedAtAction("GetRequestMode", new { id = requestMode.Id }, requestMode));
}
/// <summary>
/// Authenticates the card using the specified authentication mode.
/// </summary>
/// <param name="authMode">The authentication mode.</param>
/// <param name="blockAddress">The block address.</param>
/// <param name="sectorkey">The sectorkey.</param>
/// <param name="cardUid">The card uid.</param>
/// <returns>A status code.</returns>
private Status Authenticate(RequestMode authMode, byte blockAddress, byte[] sectorkey, byte[] cardUid)
{
// First byte should be the authMode (A or B) Second byte is the trailerBlock (usually 7)
var buff = new List <byte> {
(byte)authMode, blockAddress
};
// Now we need to append the authKey which usually is 6 bytes of 0xFF
var i = 0;
while (i < sectorkey.Length)
{
buff.Add(sectorkey[i]);
i++;
}
i = 0;
// Next we append the first 4 bytes of the UID
while (i < 4)
{
buff.Add(cardUid[i]);
i++;
}
// Now we start the authentication itself
var response = CardSendData(Command.Authenticate, buff.ToArray());
// Return the status
return(response.Status != Status.AllOk || (ReadRegister(Register.Status2Reg) & 0x08) == 0
? Status.Error
: Status.AllOk);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="baseUrl">API base url</param>
/// <param name="authMode">Authentication mode</param>
/// <param name="requestMode">Serialization mode</param>
protected AppClient(string baseUrl, AuthMode authMode, RequestMode requestMode)
{
_baseUrl = baseUrl;
_authMode = authMode;
_requestMode = requestMode;
_httpClient = new HttpClient();
_httpClient.DefaultRequestHeaders.Add("User-Agent", $"Disboard/{Version}");
}
/// <summary>
/// 获取发送 Request 命令所需的帧，检查在有效范围内是否有电子标签的存在，
/// 在选择一个新的电子标签进行操作前必须执行此命令。
/// </summary>
/// <param name="mode">0：请求IDLE标签；1：请求所有标签</param>
/// <returns>完整报文</returns>
protected byte[] CreateRequestFrame(RequestMode mode)
{
Frame frame = new Frame(0x06, Com_adr);
byte[] db = frame.DataBlock;
db[2] = I14443Cmd.Request;
db[4] = (byte)mode;
frame.PushCRC();
return(db);
}
/// <summary>
/// Constructor with existing credentials
/// </summary>
/// <param name="credential"></param>
/// <param name="handler"></param>
/// <param name="requestMode"></param>
public AppClient(Credential credential, DisboardHttpHandler handler, RequestMode requestMode)
{
Credential = credential;
_baseUrl = $"https://{Credential.Domain}";
_requestMode = requestMode;
handler.Client = this;
_httpClient = new HttpClient(handler);
_httpClient.DefaultRequestHeaders.Add("User-Agent", $"Disboard/{Version}");
}
/// <summary>
/// Create the launch settings file.
/// </summary>
/// <param name="request">
/// The launch request mode.
/// </param>
/// <param name="port">
/// The debugger port.
/// </param>
/// <param name="program">
/// The program to launch when using Launch mode.
/// </param>
/// <param name="stopOnEntry">
/// Break the debugger on start.
/// </param>
/// <param name="additionalSrcFolders">
/// The collection additional source folders.
/// </param>
public LaunchSettings(RequestMode request, int port,
string program, bool stopOnEntry, IEnumerable <string> additionalSrcFolders)
{
DebuggerType = "Emulicious Debugger";
LaunchName = "Launch Emulicious";
Request = request;
Program = program;
Port = port;
StopOnEntry = stopOnEntry;
AdditionalSrcFolders = additionalSrcFolders;
}
/// <summary>
///
/// </summary>
/// <param name="username"></param>
/// <param name="pushEnabled"></param>
public static void UpdateUserAccount(string username, string password, PushEnabled pushEnabled, UserStatus userStatus)
{
RequestMode requestMode = RequestMode.Set;
if (_voipServerUrl == null)
{
_voipServerUrl = ConfigurationManager.AppSettings[NeeoConstants.VoipServerUrl];
}
RestRequest request = new RestRequest();
request.AddQueryParameter("mode", requestMode.ToString("G").ToLower());
request.AddQueryParameter("mob", username);
if (password != null)
{
request.AddQueryParameter("pass", password);
}
if (pushEnabled != Voip.PushEnabled.NotSpecified)
{
request.AddQueryParameter("pushEnabled", pushEnabled.ToString("D"));
}
if (userStatus != Voip.UserStatus.NotSpecified)
{
request.AddQueryParameter("status", userStatus.ToString("D"));
}
try
{
ExecuteRequest(request, requestMode);
}
catch (ApplicationException firstAppException)
{
LogManager.CurrentInstance.ErrorLogger.LogError(
System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, firstAppException.Message);
try
{
if (!NeeoUtility.IsNullOrEmpty(password))
{
ExecuteBackupPolicy(firstAppException.Message, request, requestMode);
}
else
{
throw new ApplicationException(CustomHttpStatusCode.ServerInternalError.ToString("D"));
}
}
catch (ApplicationException secondAppException)
{
throw new Exception(secondAppException.Message);
}
}
}
/// <summary>
/// Sends a request to the RFID controller.
/// </summary>
/// <param name="requestMode">The request mode.</param>
/// <returns>A standard response.</returns>
public RfidResponse SendControllerRequest(RequestMode requestMode)
{
var tagType = new List <byte> {
(byte)requestMode
};
WriteRegister(Register.BitFramingReg, 0x07);
var result = CardSendData(Command.Transcieve, tagType.ToArray());
return(new RfidResponse(result.Status != Status.AllOk || result.DataBitLength != 0x10 ? Status.Error : Status.AllOk, result));
}
public object ProcessRequest(object input, RequestMode reqMod)
{
object output = null;
switch (reqMod)
{
case RequestMode.Add:
output = Userlogin(input);
break;
}
return output;
}
async Task <T> PerformInner <T>(Func <Task <T> > fn, RequestMode mode, bool isDeactivation = false)
{
bool isolated = mode == RequestMode.Isolated ||
(mode == RequestMode.Unspecified && _defaultIsolation);
Enter(isDeactivation);
await _smActive.WaitAsync();
EnterInner();
if (isolated)
{
await WhenInnerClear();
}
else
{
_smActive.Release();
}
TaskCompletionSource <T> _return = new TaskCompletionSource <T>();
var task = new Task <Task <T> >(fn);
task.Start(_scheduler);
task.Unwrap()
.ContinueWith(t => {
LeaveInner();
if (isolated)
{
_smActive.Release();
}
if (t.IsFaulted)
{
_return.SetException(t.Exception);
}
else
{
_return.SetResult(t.Result);
}
Leave();
}, _scheduler)
.SinkExceptions(_exceptionSink);
return(await _return.Task);
}
public static string Map(RequestMode requestMode)
{
switch (requestMode)
{
case RequestMode.Copy:
return("copy");
case RequestMode.New:
return("new");
default:
throw new ArgumentOutOfRangeException();
}
}
public TestPageHolder(bool initializeState, RequestMode requestMode)
{
_page = new PageMock();
if (requestMode == RequestMode.PostBack)
{
_page.SetRequestValueCollection(new NameValueCollection());
}
_otherNamingContainer = new NamingContainerMock();
_otherNamingContainer.ID = "OtherNamingContainer";
_page.Controls.Add(_otherNamingContainer);
_otherControl = new ControlMock();
_otherControl.ID = "OtherControl";
_otherNamingContainer.Controls.Add(_otherControl);
_namingContainer = new ReplaceableControlMock();
_namingContainer.ID = "NamingContainer";
_page.Controls.Add(_namingContainer);
_parent = new ControlMock();
_parent.ID = "Parent";
_namingContainer.Controls.Add(_parent);
_child = new ControlMock();
_child.ID = "Child";
_parent.Controls.Add(_child);
_child2 = new Control();
_child2.ID = "Child2";
_parent.Controls.Add(_child2);
_pageInvoker = new ControlInvoker(_page);
if (initializeState)
{
_parent.ValueInViewState = "ParentValue";
_parent.ValueInControlState = "ParentValue";
_namingContainer.ValueInViewState = "NamingContainerValue";
_namingContainer.ValueInControlState = "NamingContainerValue";
_otherControl.ValueInViewState = "OtherValue";
_otherControl.ValueInControlState = "OtherValue";
}
Page.RegisterViewStateHandler();
}
private void Browse(RequestMode mode, OpenFileDialog dialog)
{
if (dialog.ShowDialog().GetValueOrDefault())
{
switch (mode)
{
case RequestMode.Background:
_mainController.ImageReformatController.Path = dialog.FileName;
break;
case RequestMode.Ringtone:
_mainController.RingtoneReformatController.Path = dialog.FileName;
break;
}
}
}
/// <summary>
///
/// </summary>
public static void RegisterUser(string username, string password, PushEnabled pushEnabled)
{
RequestMode requestMode = RequestMode.Add;
if (_voipServerUrl == null)
{
_voipServerUrl = ConfigurationManager.AppSettings[NeeoConstants.VoipServerUrl];
}
RestRequest request = new RestRequest();
request.AddQueryParameter("mode", requestMode.ToString("G").ToLower());
request.AddQueryParameter("mob", username);
request.AddQueryParameter("pass", password);
if (pushEnabled != Voip.PushEnabled.NotSpecified)
{
request.AddQueryParameter("pushEnabled", pushEnabled.ToString("D"));
}
try
{
ExecuteRequest(request, requestMode);
}
catch (ApplicationException firstAppException)
{
LogManager.CurrentInstance.ErrorLogger.LogError(
System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, firstAppException.Message);
try
{
ExecuteBackupPolicy(firstAppException.Message, request, requestMode);
}
catch (ApplicationException secondAppException)
{
LogManager.CurrentInstance.ErrorLogger.LogError(
System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, secondAppException.Message);
try
{
ExecuteBackupPolicy(firstAppException.Message, request, requestMode);
}
catch (ApplicationException thirdAppException)
{
throw new Exception(thirdAppException.Message);
}
}
}
}
/// <summary>
/// This method does the work of writing multiple lids to table 2049 and
/// reading the results from table 2050. It can handle up to 8 lids.
/// </summary>
/// <remarks>
/// It is up to the calling method to translate the data. This method
/// always sets the mode to DataOnly.
///
/// Also, it is up to the calling method to perform the PSEM wait.
/// </remarks>
/// <param name="lids">The requested LIDs, up to 8</param>
/// <param name="eMode">Request Mode</param>
/// <param name="data">The data returned from the device</param>
/// <returns>PSEMResponse returned from the device</returns>
/// Revision History
/// MM/DD/YY who Version Issue# Description
/// -------- --- ------- ------ ---------------------------------------
/// 05/23/06 mrj 7.30.00 N/A Created
/// 09/27/06 KRC 7.35.00 N/A Add RequestMode
/// 10/04/06 RCG 7.40.00 N/A Added check to see if the data is null before
/// creating the BinaryReader to avoid an exception
///
public PSEMResponse RetrieveMulitpleLIDs(LID[] lids, RequestMode eMode, out byte[] data)
{
PSEMResponse Result = PSEMResponse.Err;
byte[] bySendData = new byte[2 + (4 * lids.Length)];
byte[] byReadData = null;
int iLIDIndex = 2;
//Build the table to send to the meter
bySendData[0] = (byte)eMode; // Request Mode
bySendData[1] = (byte)lids.Length; // Number of LIDs
//Copy the LIDs to the output array
for (int iIndex = 0; iIndex < lids.Length; iIndex++)
{
byte[] byLID = BitConverter.GetBytes(lids[iIndex].lidValue);
Array.Copy(byLID, 0, bySendData, iLIDIndex, 4);
iLIDIndex = iLIDIndex + 4;
}
//Make the request for the LIDs
Result = m_PSEM.FullWrite(LID_REQUEST_TABLE, bySendData);
//Retrieve the LIDs
if (PSEMResponse.Ok == Result)
{
Result = m_PSEM.FullRead(LID_RETRIEVE_TABLE, out byReadData);
if (PSEMResponse.Ok != Result)
{
byReadData = null;
}
}
data = byReadData;
// Assign the data to the Binary data reader
if (data != null)
{
m_DataReader = new PSEMBinaryReader(new MemoryStream(data));
}
else
{
m_DataReader = null;
}
return(Result);
}
public (Status status, int backBits) Request(RequestMode requestMode)
{
var tagType = new List <byte> {
(byte)requestMode
};
WriteSpi(BitFramingReg, 0x07);
var(status, backData, backBits) = SendCommand(Transceive, tagType.ToArray());
if ((status != OK) | (backBits != 0x10))
{
status = Error;
}
return(status, backBits);
}
/// <summary>
/// Retrieve LID
/// </summary>
/// <param name="lid">The LID to retrieve</param>
/// <param name="eMode">The request mode</param>
/// <param name="objValue">an object containing the data associated with the LID</param>
/// <returns>PSEMResponse</returns>
// Revision History
// MM/DD/YY Who Version Issue# Description
// -------- --- ------- ------ ---------------------------------------------
// 10/05/06 KRC 7.36.00 N/A Created
//
public PSEMResponse RetrieveLID(LID lid, RequestMode eMode, out object objValue)
{
PSEMResponse Result;
objValue = null;
LID[] lids = new LID[1];
lids[0] = lid;
List <object> objValues;
Result = RetrieveMulitpleLIDs(lids, eMode, out objValues);
if (PSEMResponse.Ok == Result)
{
objValue = objValues[0];
}
return(Result);
}
public static IMode GetAckPacket(RequestMode mode, string packetType, string absolutePath, int packetId, string text)
{
if (mode == RequestMode.Packet)
{
PacketMode packet = new PacketMode(packetType, absolutePath, packetId, text);
return(packet);
}
else if (mode == RequestMode.Payload)
{
PacketMode packet = new PacketMode(packetType, absolutePath, packetId, text);
PayloadMode payload = new PayloadMode(packet);
return(payload);
}
else
{
return(null);
}
}
public static string SendRequest(RequestMode method, String url, String reqParams)
{
HttpWebRequest myReq = null;
HttpWebResponse response = null;
string responseFromServer = "";
try
{
if (method == RequestMode.Get)
{
url += "?" + reqParams;
}
myReq = (HttpWebRequest)WebRequest.Create(url);
myReq.Method = method.ToString();
myReq.ReadWriteTimeout = DEFAULT_SOCKET_TIMEOUT;
myReq.ContentType = contentType;
if (method == RequestMode.Post || method == RequestMode.Put || method == RequestMode.Delete)
{
byte[] bs = Encoding.UTF8.GetBytes(reqParams);
myReq.ContentLength = bs.Length;
using (Stream reqStream = myReq.GetRequestStream())
{
reqStream.Write(bs, 0, bs.Length);
reqStream.Close();
}
}
response = (HttpWebResponse)myReq.GetResponse();
if (Equals(response.StatusCode, HttpStatusCode.OK) ||
Equals(response.StatusCode, HttpStatusCode.Created))
{
using (StreamReader reader = new StreamReader(response.GetResponseStream(), Encoding.UTF8))
{
responseFromServer = reader.ReadToEnd();
}
}
}
catch (WebException e)
{
throw e;
}
return(responseFromServer);
}
/// <summary>
/// 发送 Request 命令，检查在有效范围内是否有电子标签的存在，
/// 在选择一个新的电子标签进行操作前必须执行此命令。
/// </summary>
/// <param name="mode">
/// Mode=RequestMode.IdleCard 请求天线范围内处于IDLE 状态的电子标签（处于HALT状态的除外）
/// Mode=RequestMode.AllCard 请求天线范围内所有的电子标签。
/// </param>
/// <returns></returns>
public async Task <RequestInfo> RequestAsync(RequestMode mode)
{
byte[] frame = CreateRequestFrame(mode);
CommunicationReturnInfo cri = await com.SendAsync(frame);
if (cri.ReturnValue != ReturnMessage.Success)
{
RequestInfo ri = new RequestInfo();
ri.SendByte = frame;
ri.ReturnValue = cri.ReturnValue;
ri.ExceptionMessage = cri.ExceptionMessage;
return(ri);
}
RequestInfo info = HandleRequestFrame(cri.RecvByte);
info.SendByte = frame;
return(info);
}
public Status Authenticate(RequestMode authenticationMode, byte blockAddress, Span <byte> sectorKey, Span <byte> serialNumber)
{
// First byte should be the authMode (A or B) Second byte is the trailerBlock (usually 7)
var buff = new List <byte> {
(byte)authenticationMode, blockAddress
};
// Now we need to append the authKey which usually is 6 bytes of 0xFF
var i = 0;
while (i < sectorKey.Length)
{
buff.Add(sectorKey[i]);
i++;
}
i = 0;
// Next we append the first 4 bytes of the UID
while (i < 4)
{
buff.Add(serialNumber[i]);
i++;
}
// Now we start the authentication itself
var(status, _, _) = SendCommand(Command.Authenticate, buff.ToArray());
// Check if an error occurred
if (status != OK)
{
throw new Mfrc522Exception("AUTH ERROR!!");
}
if ((ReadSpi(Status2Reg) & 0x08) == 0)
{
throw new Mfrc522Exception("AUTH ERROR(status2reg & 0x08) != 0");
}
// Return the status
return(status);
}
public IActionResult PutRequestMode(int id, RequestMode requestMode)
{
if (id != requestMode.Id)
{
return(BadRequest());
}
_requestModeRepository.Update(requestMode);
try
{
_requestModeRepository.Save();
}
catch (DbUpdateConcurrencyException ex)
{
string msg = ex.Message;
}
return(NoContent());
}
public async Task <ActionResult <IEnumerable <CashOrderResponseGet> > > Get(CashOrder cashOrder)
{
try
{
List <CashOrder> cashOrders = new List <CashOrder>();
if (RequestMode.IsGetById(cashOrder) || RequestMode.IsGetByUserIdAndOfficeAddress(cashOrder))
{
cashOrders = SendMessage(cashOrder);
return(Ok(CashOrderHelper.ConvertToResponseGet(cashOrders)));
}
}
catch (Exception ex)
{
logger.LogError(ex.Message);
return(BadRequest());
}
return(BadRequest());
}
public (Status status, byte[] atqa) Request(RequestMode requestMode)
{
var tagType = new List <byte> {
(byte)requestMode
};
// Reset baud rates
WriteSpi(TxModeReg, (byte)0x00);
WriteSpi(RxModeReg, (byte)0x00);
// Reset ModWidthReg
WriteSpi(ModWidthReg, 0x26);
WriteSpi(BitFramingReg, 0x07);
var(status, backData, backBits) = SendCommand(Command.Transceive, tagType.ToArray());
LogInfo.Log($"{nameof(Request)} - {BitConverter.ToString(backData)} BackBits: {backBits.ToString()}", LogLevel.Debug);
if ((status != OK) | (backBits != 0x10))
{
status = Error;
}
return(status, backData);
}
/// <summary>
/// 选择当前模式
/// </summary>
/// <param name="mode">The mode.</param>
private void ExecuteSelectModeCommand(string mode)
{
switch (mode)
{
//退票申请
case "RequestBounceOrder":
_currentMode = RequestMode.BounceOrder;
CurrentImageUri = _requestBounceOrder.AttachmentUrl;
break;
//废票申请
case "RequestAnnulOrder":
_currentMode = RequestMode.AnnulOrder;
CurrentImageUri = _requestAnnulOrder.AttachmentUrl;
break;
//改签申请
case "RequestChangeOrder":
_currentMode = RequestMode.ChangeOrder;
CurrentImageUri = null;
break;
//婴儿申请
case "ApplyBabyOrder":
_currentMode = RequestMode.ApplyBabyOrder;
_currentImageUri = null;
break;
//其他理由
case "Modify":
_currentMode = RequestMode.Modify;
CurrentImageUri = null;
break;
default: return;
}
}
//ftia3e diaforous functions gia get kai post requests!!!
//exw ws default to payload na einai empty string giati sto get dn xreiazetai payload kapoies fores!!
public async Task <T> Request <T>(RequestMode mode, string urlPar, string payload = "")
{
try
{
if (!CrossConnectivity.Current.IsConnected)
{
throw new NoInternetException("Please check your Internet Connection...");
}
string url = HostName + urlPar;
using (var result = (mode == RequestMode.GET)?await Client.GetAsync(url):await Client.PostAsync(url, new StringContent(payload, Encoding.UTF8, "application/json")))
{
string resultsContent = await result.Content.ReadAsStringAsync();
if (result.IsSuccessStatusCode)
{
var resultObj = JsonConvert.DeserializeObject <T>(resultsContent);
return(resultObj);
}
else
{
Console.WriteLine("sth happend");
return(default(T));
}
}
}
catch (NoInternetException ex)
{
throw new Exception("Please Check your Internet Connection...");
return(default(T));
}
catch (Exception ex)
{
throw new Exception(ex.Message);
return(default(T));
}
}
/// <summary>
///
/// </summary>
/// <param name="URL"></param>
/// <param name="Mode"></param>
/// <param name="Parameter"></param>
/// <returns></returns>
public static string WebRequest(this string URL, RequestMode Mode, string Parameter)
{
HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(URL);
request.Method = Mode.ToString();
request.ContentType = "application/x-www-form-urlencoded";
if (URL.ToLower().StartsWith("https"))
{
ServicePointManager.ServerCertificateValidationCallback = new RemoteCertificateValidationCallback(CheckValidationResult);
}
if (Mode.ToString().Equals("POST") && !String.IsNullOrEmpty(Parameter))
{
using (var sw = new StreamWriter(request.GetRequestStream()))
{
sw.Write(Parameter);
}
}
var resonse = "";
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
if (response.StatusCode != HttpStatusCode.OK)
{
throw new Exception(string.Format("{0}-{1}", ((int)response.StatusCode).ToString(), "回應不成功"));
}
using (var sr = new StreamReader(response.GetResponseStream()))
{
resonse = sr.ReadToEnd();
}
}
return(resonse);
}
protected async Task <T> PostRegister <T>(RequestMode mode, string urlPar, string payload = "")
{
try
{
string url = HostName + urlPar;
using (var result = (mode == RequestMode.GET) ? await Client.GetAsync(url) : await Client.PostAsync(url, new StringContent(payload, Encoding.UTF8, "application/json")))
{
string resultsContent = await result.Content.ReadAsStringAsync();
if (result.IsSuccessStatusCode)
{
//var resultObj = JsonConvert.DeserializeObject<T>(resultsContent);
return(default(T));
}
else
{
var resultObj = JsonConvert.DeserializeObject <ErrorModel>(resultsContent);
throw new ErrorModelException(resultObj);
Console.WriteLine("sth happend");
//T tempValue = (T)(object)resultsContent;
return((T)(object)resultsContent);
}
}
}
catch (ErrorModelException ex)
{
return((T)(object)ex.Message);
}
catch (Exception ex)
{
Console.WriteLine("sth happend");
return((T)(object)ex.Message);
}
}
