public static ResultArgs ReadSector(int sector, M1KeyMode keyMode, byte[] key)
{
ICardReader cardReader = ContextManager.GetCardReader();
ResultArgs ret = cardReader.Select();
if (!ret.Succ)
{
return(new ResultArgs(false, null, "Select Card Error!"));
}
CardSelectResult info = (CardSelectResult)ret.Result;
logger.Debug(String.Format("Select card_id={0}, ATQA=0x{1}, SAK={2}",
BitConverter.ToString(info.SN),
info.ATQA.ToString("X4"),
info.SAK.ToString("X2")));
if (!cardReader.Authen(keyMode, sector * 4, key))
{
logger.Debug(String.Format("Auth sector {0} failed !", sector));
return(new ResultArgs(false, null, "Auth sector failed !"));
}
byte[] buffer;
int len = 0;
if (!cardReader.ReadSector(sector, out buffer, out len))
{
return(new ResultArgs(false, null, "Read sector failed !"));
}
return(new ResultArgs(true, BitConverter.ToString(buffer), "OK"));
}
public ResultArgs ExecuteAsScripts(string sSQL)
{
ResultArgs result = new ResultArgs();
try
{
connection = OpenConnection();
//var script = new (connection, sSQL);
//var resultScript = script.Execute();
result.Success = true;
//result.RowsAffected = resultScript;
}
catch (Exception e)
{
result.Exception = e;
result.Success = false;
using (ErrorLog objlog = new ErrorLog())
{
objlog.WriteError("Error Handler", "FetchData(DataValue,string)", sSQL, e.Message);
}
CloseConnection();
}
finally
{
CloseConnection();
}
return(result);
#endregion
}
private void SetRowUniqueIdentifierValue(ResultArgs result, OracleCommand OracleCommand)
{
if (OracleCommand.CommandType == CommandType.StoredProcedure)
{
OracleParameterCollection OracleParameterCollection = OracleCommand.Parameters;
string paramName = "";
foreach (OracleParameter OracleParameter in OracleParameterCollection)
{
if (OracleParameter.ParameterName == rowUniqueParmName)
{
paramName = RemoveParameterDelimiter(OracleParameter.ParameterName);
result.RowUniqueIdCollection[paramName] = OracleParameter.Value;
break;
}
}
}
else
{
if (getRowUniqueId)
{
string sQuery = "SELECT LAST_INSERT_ID()";
OracleCommand.CommandText = sQuery;
OracleCommand.CommandType = CommandType.Text;
result.RowUniqueId = OracleCommand.ExecuteScalar().ToString();
}
}
}
public ResultArgs GetDataBaseName(DataValue dv)
{
ResultArgs result = new ResultArgs();
SqlDataAdapter Adapter;
SqlCommand Command = null;
DataSet ds = new DataSet();
string connection = "server=" + dv.GetItem(0).FieldValue + ";port=" + dv.GetItem(1).FieldValue + ";uid=" + dv.GetItem(2).FieldValue + ";pwd=" + dv.GetItem(3).FieldValue + ";Allow User Variables=True;";
string sFetchQuery = "show databases";
DataTable dtFetchDb = new DataTable();
if (dv != null)
{
SqlConnection mcon = new SqlConnection(connection);
mcon.Open();
Command = new SqlCommand(sFetchQuery, mcon);
Adapter = new SqlDataAdapter(Command);
if (result.dataSource == null)
{
result.dataSource = new DataTable();
}
result.RowsAffected = Adapter.Fill(result.dataSource as DataTable);
result.Success = true;
}
return(result);
}
/// <summary>Execute Scalar Query </summary>
/// <param name="dv">DataValue Object</param>
/// <param name="query">The Select Query</param>
/// <returns>If The Execute Scalar Returns the Null, the function will return
/// the empty string otherwise the value</returns>
/// <exception name="ArgumentNullException"></exception>
/// <exception name="InvalidOperationException"></exception>
public ResultArgs ExecuteScalar(DataValue dv, string query, EnumCommand.SQLType sqlType = EnumCommand.SQLType.Static)
{
ResultArgs resultArgs = new ResultArgs();
string ScalarValue = string.Empty;
SqlCommand Command = null;
SqlConnection Con = OpenConnection();
try
{
if (string.IsNullOrEmpty(query))
{
// throw new ArgumentNullException("Query is empty!", "ExecuteScalar(DataValue dv, string query)");
using (ErrorLog objlog = new ErrorLog())
{
objlog.WriteError("Error Handler", "ExecuteScalar(DataValue,string)", query, "Query is empty!");
}
}
if (dv == null)
{
Command = new SqlCommand(query, Con);
}
else
{
Command = SetSQLCommand(dv, query, Con, sqlType);
}
Object obj = Command.ExecuteScalar();
if (obj != null)
{
ScalarValue = obj.ToString();
resultArgs.Success = true;
}
}
catch (InvalidOperationException ex)
{
using (ErrorLog objHandler = new ErrorLog())
{
objHandler.WriteError("MysqlHandler", "ExecuteScalar(DataValue dv, string query)", ex.Message);
objHandler.WriteError(ex);
}
}
catch (Exception ex)
{
using (ErrorLog objHandler = new ErrorLog())
{
objHandler.WriteError("MysqlHandler", "ExecuteScalar(DataValue dv, string query)", ex.Message);
objHandler.WriteError(ex);
}
}
finally
{
if (Command != null)
{
Command.Dispose();
}
Command = null;
CloseConnection();
}
resultArgs.StringResult = ScalarValue;
return(resultArgs);
}
public ResultArgs CreateAppAuthenDongle(String userId, DongleUserInfo keyInfo)
{
ResultArgs ret = new ResultArgs(false);
if (!IsActive())
{
ret.Msg = "Create authen key failed -- no dongle opened!";
logger.Debug(ret.Msg);
return(ret);
}
byte[] newAdminPin;
byte[] appId;
if (!Initialize(this.hDongle, userId, out newAdminPin, out appId))
{
ret.Msg = "initialize dongle failed ";
return(ret);
}
if (!CreateUserInfo(this.hDongle, keyInfo) ||
!CreateAuthenKeyFile(this.hDongle))
{
ret.Msg = "Create Key info file failed !";
return(ret);
}
return(CreateAuthenKey(userId, appId, newAdminPin));
}
private void SetRowUniqueIdentifierValue(ResultArgs result, SqlCommand mySqlCommand)
{
if (mySqlCommand.CommandType == CommandType.StoredProcedure)
{
SqlParameterCollection mySqlParameterCollection = mySqlCommand.Parameters;
string paramName = "";
foreach (SqlParameter mySqlParameter in mySqlParameterCollection)
{
if (mySqlParameter.ParameterName == rowUniqueParmName)
{
paramName = RemoveParameterDelimiter(mySqlParameter.ParameterName);
result.RowUniqueIdCollection[paramName] = mySqlParameter.Value;
break;
}
}
}
else
{
if (getRowUniqueId)
{
string sQuery = "SELECT @@identity";
mySqlCommand.CommandText = sQuery;
mySqlCommand.CommandType = CommandType.Text;
result.RowUniqueId = mySqlCommand.ExecuteScalar().ToString();
}
}
}
private ResultArgs CreateAuthenKey(String userId, byte[] appId, byte[] adminPin)
{
IntPtr pubKey = IntPtrUtil.Create(IntPtrUtil.SizeOf(typeof(RSA_PUBLIC_KEY)));
IntPtr priKey = IntPtrUtil.Create(IntPtrUtil.SizeOf(typeof(RSA_PRIVATE_KEY)));
ResultArgs ret = new ResultArgs(true);
try
{
this.lastErrorCode = Dongle_RsaGenPubPriKey(this.hDongle, DongleConst.AUTHEN_KEY_DESCRIPTOR, pubKey, priKey);
LogKey(pubKey, priKey);
// renew appid
this.dongleInfo[this.selectedIndex].AppId = this.Encoder.GetString(appId);
RSA_PUBLIC_KEY pubStru = IntPtrUtil.ToStru <RSA_PUBLIC_KEY>(pubKey);
ret.Result = new AppAuthenDongleResult()
{
PubKey = Convert.ToBase64String(pubStru.exponent, 0, DongleConst.RSA_KEY_LEN),
Version = this.dongleInfo[this.selectedIndex].Version,
AppId = this.dongleInfo[this.selectedIndex].AppId,
UserId = userId,
KeyPwd = this.Encoder.GetString(adminPin),
KeyId = this.dongleInfo[this.selectedIndex].KeyId
};
}
finally
{
IntPtrUtil.Free(ref pubKey);
IntPtrUtil.Free(ref priKey);
// reset authen status as anonymous
Reset();
}
return(ret);
}
private void TestKey(M1KeyMode keyMode, byte[] key)
{
ResultArgs ret = this.reader.Select();
if (!ret.Succ)
{
this.TraceMsg.Trace("Select Card Error!");
return;
}
CardSelectResult info = (CardSelectResult)ret.Result;
this.TraceMsg.Trace(String.Format("Select card_id={0}, ATQA=0x{1}, SAK={2}",
BitConverter.ToString(info.SN),
info.ATQA.ToString("X4"),
info.SAK.ToString("X2")));
foreach (CheckBox cb in this.cardSectorSelected)
{
if (!cb.Checked)
{
continue;
}
int sector = int.Parse(cb.Text.Trim());
if (!this.reader.Authen(keyMode, sector * 4, key))
{
this.TraceMsg.Trace("Authen sector {0} failed !", sector);
}
else
{
this.TraceMsg.Trace("Authen sector {0} OK !", sector);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void _controller_ResultEvent(object sender, EventArgs e)
{
ResultArgs args = this._controller.ResultArgs;
if (args.IsSuccess)
{
this.Sync.Post(new SendOrPostCallback(StatusBarTarget), args.Message);
}
else
{
this.Sync.Post(new SendOrPostCallback(MessageBoxTarget), args.Message);
}
if (args.IsSuccess)
{
if (args.IsComplete)
{
if (StringHelper.Equal(args.ExecuteArgs.ExecuteName, XD1100OperaNames.OPERA_READ))
{
this.Sync.Post(new SendOrPostCallback(ReadLineTarget), args.KeyValues);
this._canWrite = true;
}
else if (StringHelper.Equal(args.ExecuteArgs.ExecuteName, XD1100OperaNames.OPERA_WRITE))
{
this.Sync.Post(new SendOrPostCallback(MessageBoxTarget),
XD100Strings.WriteControlModeSuccess);
}
}
}
this._isExecuting = false;
}
private void BtnCreateUserRootKey_Click(object sender, EventArgs e)
{
int selected = this.Dongles.SelectedIndex;
byte[] userRootKey = HexString.FromHexString(this.UserRootKey.Text.Trim(), "-");
String userId = this.UserID.Text.Trim();
DongleUserInfo keyInfo = DongleUserInfo.CreateTestDongleKeyInfo(DongleType.USER_ROOT, userId);
ResultArgs arg = this.dongle.CreateUserRootDongle(userId, userRootKey, keyInfo);
if (arg.Succ)
{
this.TraceMsg.Trace(String.Format("Create user root key ok! "), true);
UserRootDongleResult res = (UserRootDongleResult)arg.Result;
this.TraceMsg.Trace(res.ToString());
logger.Debug(res.ToString());
}
else
{
this.TraceMsg.Trace(String.Format("Create user root key Error! err msg = {0}", this.dongle.LastErrorMessage), true);
}
// refresh dongle
RefreshDongle(false);
}
public async Task <ResultArgs <object> > AskAdviceAsync(QuestionArgs questionArgs)
{
if (questionArgs == null)
{
throw new ArgumentNullException("questionArgs");
}
//WE ONLY KNOW HOW TO DEAL WITH PHRASE EDIT QUESTIONS ABOUT PERCENT KNOWN.
if (!(questionArgs.State is PhraseEdit) ||
questionArgs.Question != StudyResources.AdvisorQuestionWhatIsPhrasePercentKnown)
{
return(await new Task <ResultArgs <object> >(() =>
{
var errorMsg = string.Format("Unknown question for advice.\n" +
"questionArgs.State: {0}\n" +
"questionArgs.Question: {1}",
questionArgs.State.ToString(), questionArgs.Question);
var error = new Study.StudyException(errorMsg);
return new ResultArgs <object>(error);
}));
}
var phrase = (PhraseEdit)questionArgs.State;
var result = await GetPercentKnownAsync(phrase);
//THE RESULT IS CASTED ALREADY AS A DOUBLE. WE NEED TO WRAP IT AS A DOUBLE
var percentKnownObjectWrapper = new ResultArgs <object>(result.Object);
return(await StudyHelper.WrapInTask <ResultArgs <object> >(percentKnownObjectWrapper));
//var answerTask = new Task<ResultArgs<object>>(() => { return new ResultArgs<object>(percentKnown); });
//return await answerTask;
}
void LoadFinish(ref ResultArgs loadResultArgs)
{
GameObject ins = loadResultArgs.Instantiate();
ins.name = _index.ToString();
_index++;
ins.transform.SetParent(Test, false);
}
public IHttpActionResult Create(dynamic request)
{
String userId = Convert.ToString(request.userId);
String jsonString = Convert.ToString(request.keyInfo);
DongleUserInfo keyInfo = JsonConvert.DeserializeObject <DongleUserInfo>(jsonString);
ResultArgs ret = DongleUtil.dongle.CreateAppAuthenDongle(userId, keyInfo);
return(Json <ResultArgs>(ret));
}
public static ResultArgs Restore(String keyPwd)
{
byte[] keyPwdBytes = dongle.Encoder.GetBytes(keyPwd);
ResultArgs ret = dongle.Restore(keyPwdBytes)
? new ResultArgs(true, null, "OK")
: new ResultArgs(false, null, dongle.LastErrorMessage);
return(ret);
}
public ResultArgs Update(object command, Common.CommandType cmdType)
{
result = new ResultArgs();
try
{
objCommand = new SqlCommand();
objCommand.Connection = objConnection;
if (hasTransaction)
{
objCommand.Transaction = objTransaction;
}
if (cmdType == Common.CommandType.StroeProcedure)
{
objCommand.CommandType = CommandType.StoredProcedure;
QueryFetch objQueryFetch = new QueryFetch();
objCommand.CommandText = objQueryFetch.GetQuery(command);
}
else if (cmdType == Common.CommandType.Query)
{
objCommand.CommandType = CommandType.Text;
QueryFetch objQueryFetch = new QueryFetch();
objCommand.CommandText = objQueryFetch.GetQuery(command);
}
BindParameterWithCommand();
if (objConnection.State != ConnectionState.Open)
{
objConnection.Open();
}
result.AffectedRows = objCommand.ExecuteNonQuery();
result.Success = true;
}
catch (Exception ex)
{
Logger.WriteErrorLog(objCommand.CommandText);
foreach (SqlParameter item in parameterCollection)
{
Logger.WriteErrorLog(string.Format("Name - {0} - Value - {1}", item.ParameterName, item.Value));
}
Logger.WriteErrorLog(ex.Message);
result.Message = ex.Message;
result.AffectedRows = 0;
result.Success = false;
}
finally
{
if (!hasTransaction)
{
objConnection.Close();
}
parameterCollection.Clear();
}
return(result);
}
void LoadSceneEnd(ref ResultArgs args)
{
args.LoadScene();
var scene = SceneManager.GetActiveScene();
Debug.Log("scene = " + scene + " name " + scene.name);
var allscenes = SceneManager.GetAllScenes();
Debug.Log("allscenes = " + allscenes.Length);
}
public static async Task <ResultArgs <StudyItemViewModelArgs> > GetAbortedAsync()
{
var abortTask = new Task <ResultArgs <StudyItemViewModelArgs> >(
() =>
{
var abortResult =
new ResultArgs <StudyItemViewModelArgs>(StudyItemViewModelArgs.Aborted);
return(abortResult);
});
return(await abortTask);
}
public void CommitTrasaction(ResultArgs result)
{
if (result.Success)
{
objTransaction.Commit();
}
else
{
objTransaction.Rollback();
}
objConnection.Close();
}
public static ResultArgs FetchData <T>(OracleParameter[] param, string sSQL, EnumCommand.DataSource dataSourceType, string sAcademicYear = "") where T : new()
{
ResultArgs resultArgs = new ResultArgs();
DataValue dv = new DataValue();
dv.Clear();
try
{
if (string.IsNullOrEmpty(sSQL))
{
resultArgs.Success = false;
resultArgs.Message = Common.Message.QueryIsEmpty;
return(resultArgs);
}
if (sAcademicYear != string.Empty)
{
sSQL = sSQL.Replace(Common.Delimiter.QUS + "", sAcademicYear);
}
//if (param != null)
//{
// DataValue Construction
// foreach (var prop in obj.GetType().GetProperties())
// {
// objValue = prop.GetValue(obj, null);
// objValue = (objValue == null) ? string.Empty : objValue.ToString();
// dv.Add(prop.Name, objValue.ToString(), EnumCommand.DataType.String);
// }
//}
if (dataSourceType == EnumCommand.DataSource.list)
{
using (OracleHelper objHelper = new OracleHelper())
{
resultArgs = objHelper.FecthDataAsList <T>(sSQL, param, EnumCommand.SQLType.StoredProcedure);
}
}
else
{
using (OracleHelper objHelper = new OracleHelper())
{
resultArgs = objHelper.FetchData(sSQL, dataSourceType, param, EnumCommand.SQLType.StoredProcedure);
}
}
}
catch (System.Exception ex)
{
using (ErrorLog objlog = new ErrorLog())
{
objlog.WriteError("OracleHelper", "FetchData", sSQL, ex.Message);
}
resultArgs.Success = false;
}
return(resultArgs);
}
public IHttpActionResult Encrypt(dynamic request)
{
String plain = Convert.ToString(request.plain);
byte[] plainBytes = DongleUtil.dongle.Encoder.GetBytes(plain);
byte[] cipher;
ResultArgs ret = DongleUtil.dongle.Encrypt(DongleType.AUTHEN, plainBytes, out cipher) ?
new ResultArgs(true, BitConverter.ToString(cipher), "OK") :
new ResultArgs(false, null, DongleUtil.dongle.LastErrorMessage);
return(Json <ResultArgs>(ret));
}
/// <summary>
///
/// </summary>
/// <param name="status"></param>
private void Target(ResultArgs args)
{
//Console.WriteLine("RemoteController Target: {0} {1} {2} {3} ",
// args.IsComplete,
// args.IsSuccess,
// args.Message,
// args.ExecuteName);
this._resultArgs = args;
if (this.ResultEvent != null)
{
this.ResultEvent(this, EventArgs.Empty);
}
}
public IHttpActionResult Create(dynamic request)
{
String userId = Convert.ToString(request.userId);
String rootKey = Convert.ToString(request.rootKey);
byte[] rootKeyBytes = HexString.FromHexString(rootKey);
String jsonString = Convert.ToString(request.keyInfo);
DongleUserInfo keyInfo = JsonConvert.DeserializeObject <DongleUserInfo>(jsonString);
ResultArgs ret = DongleUtil.dongle.CreateUserRootDongle(userId, rootKeyBytes, keyInfo);
return(Json <ResultArgs>(ret));
}
/// <summary>
/// select test 2
/// return card_id, atqa, sak
/// </summary>
private void BtnSelectCard2_Click(object sender, EventArgs e)
{
ResultArgs ret = this.reader.Select();
this.TraceMsg.Trace("Select Card " + ((ret.Succ) ? "OK!" : "Failed!"), true);
if (ret.Succ)
{
CardSelectResult card = (CardSelectResult)ret.Result;
this.TraceMsg.Trace(String.Format("card_id={0}, atqa=0x{1}, sak=0x{2}",
BitConverter.ToString(card.SN),
card.ATQA.ToString("X4"),
card.SAK.ToString("X2")));
}
}
public Object Parse(Type type, byte[] byteArray)
{
String func;
if (type.Equals(typeof(Int16)))
{
func = "ToInt16";
}
else if (type.Equals(typeof(UInt16)))
{
func = "ToUInt16";
}
else if (type.Equals(typeof(Int32)))
{
func = "ToInt32";
}
else if (type.Equals(typeof(UInt32)))
{
func = "ToUInt32";
}
else if (type.Equals(typeof(UInt64)))
{
func = "ToUInt64";
}
else if (type.Equals(typeof(Int64)))
{
func = "ToInt64";
}
else
{
return(null);
}
IMethodBroker broker = new MethodBroker(typeof(BitConverter), func);
ResultArgs ret = broker.Invoke(new List <Object> {
byteArray
});
if (ret.Succ)
{
return(ret.Result);
}
return(null);
}
public byte[] GetBytes(object obj, int length)
{
IMethodBroker broker = new MethodBroker(typeof(BitConverter), "GetBytes");
Type type = numberType[obj.GetType().ToString()];
ResultArgs ret = broker.Invoke(new List <Object> {
obj
});
if (ret.Succ)
{
return(ret.Result as byte[]);
}
return(ByteUtil.Malloc(length));
}
/// <summary>
/// Create user root dongle
/// userRootKey can't less 16 bytes
/// </summary>
public ResultArgs CreateUserRootDongle(String userId, byte[] userRootKey, DongleUserInfo keyInfo)
{
ResultArgs ret = new ResultArgs(false);
if (!IsActive())
{
ret.Msg = "Create user root key failed -- no dongle opened!";
logger.Debug(ret.Msg);
return(ret);
}
byte[] newAdminPin;
byte[] appId;
if (!Initialize(this.hDongle, userId, out newAdminPin, out appId))
{
ret.Msg = "initialize dongle failed ";
return(ret);
}
if (!CreateUserInfo(this.hDongle, keyInfo) ||
!CreateUserRootKeyFile(this.hDongle, DongleConst.USER_ROOT_KEY_DESCRIPTOR, userRootKey))
{
ret.Msg = "Create User root Key failed !";
return(ret);
}
// renew appid
this.dongleInfo[this.selectedIndex].AppId = this.Encoder.GetString(appId);
// reset authen status as anonymous
Reset();
ret.Succ = true;
ret.Result = new UserRootDongleResult
{
KeyPwd = this.Encoder.GetString(newAdminPin),
AppId = this.dongleInfo[this.selectedIndex].AppId,
KeyId = this.dongleInfo[this.selectedIndex].KeyId,
Version = this.dongleInfo[this.selectedIndex].Version,
UserId = userId,
TestCipher = CreateTestCipher(userId)
};
return(ret);
}
public ResultArgs Select()
{
ResultArgs ret = new ResultArgs(false);
CardSelectResult cardInfo = new CardSelectResult();
if (this.hReader == -1)
{
return(ret);
}
//atqa :: M1_S50: 0x0004; M1_S70: 0x0002
UInt16 atqa = 0;
if (dc_request(this.hReader, 0x00, ref atqa) != SUCC)
{
ret.Msg = "Can't request atqa !";
return(ret);
}
cardInfo.ATQA = atqa;
byte[] sn = ByteUtil.Malloc(16);
if (dc_anticoll(this.hReader, 0x00, sn) != SUCC)
{
ret.Msg = "AntiCollision Failed !";
return(ret);
}
// remove zero at the end
cardInfo.SN = ByteUtil.TrimEnd(sn);
//M1: sak = 0x08
//CPU simulate M1: sak=0x28
byte sak = 0x00;
if (dc_select(this.hReader, sn, ref sak) != SUCC)
{
ret.Msg = "Can't get SAK!";
return(ret);
}
cardInfo.SAK = sak;
ret.Succ = true;
ret.Result = cardInfo;
return(ret);
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void te_Ended(object sender, EventArgs e)
{
TaskExecutor exe = (TaskExecutor)sender;
ExecuteEventArgs eeArgs = Get(exe);
ResultArgs args = new ResultArgs();
args.ExecuteArgs = eeArgs.ExecuteArgs;
args.IsComplete = true;
args.IsSuccess = exe.Task.LastParseResult.IsSuccess;
args.Message = exe.Task.LastParseResult.ToString();
if (args.IsSuccess)
{
args.KeyValues = exe.Task.LastParseResult.Results;
}
eeArgs.CallbackWrapper.Callback(args);
}
public bool Initialize(UInt16[] sector)
{
ResultArgs ret = this.reader.Select();
if (!ret.Succ)
{
return(false);
}
CardSelectResult card = (CardSelectResult)ret.Result;
this.logger.Debug(String.Format("card_id={0}, atqa=0x{1}, sak=0x{2}", BitConverter.ToString(card.SN), card.ATQA.ToString("X4"), card.SAK.ToString("X2")));
List <CardInitRequest> req = PrepareRequest(card.SN, sector);
List <CardInitResponse> response = keyService.ComputeKey(req);
return(UpdateCardKey(response));
}
void netfinder_OnAssignCompleted(object sender, ResultArgs e)
{
ShowMsg(e.Result);
}
