public async Task <IHttpActionResult> Post(AccountEvent request)
{
await _orchestrator.CreateEvent(request);
// 201 for list of all events
return(CreatedAtRoute("GetAllAccountEvents", new {}, default(AccountEvent)));
}
protected void Page_Load(object sender, EventArgs e)
{
AccountEvent accountEvent = new AccountEvent("03401", "李明", 200);
accountEvent.Overdraw += new EventHandler(account_Overdraw);
accountEvent.Acquire(400);
}
protected void Page_Load(object sender, EventArgs e)
{
AccountEvent account = new AccountEvent("3113002319", "李代福", 200);
account.Overdraw += new EventHandler(account_Overdraw);
account.Acquire(300);
}
void GetUserInfoResultHandler(int reqID, ResponseState state, PlatformType type, Hashtable result)
{
UnityEngine.Debug.Log("GetUserInfoResultHandler" + MiniJSON.jsonEncode(result));
if (state == ResponseState.Success)
{
AccountEvent.ThirdPartyLoginResult ret;
ret.head = (string)result["figureurl_qq_2"];
ret.name = (string)result["nickname"];
ret.sex = ((string)result["gender"]) == "女"?0:1;
ret.openId = _thirdOpenId;
ret.token = _thirdToken;
ret.expireTime = _thirdExpireTime;
AccountEvent.EM().InvokeEvent(AccountEvent.EVENT.THIRD_PARTY_LOGIN_RET, (object)ret);
}
else if (state == ResponseState.Fail)
{
CommonUtil.Util.showDialog("温馨提示", "获取用户信息错误! error code = " + result["error_code"] + "; error msg = " + result["error_msg"]);
}
else if (state == ResponseState.Cancel)
{
CommonUtil.Util.showDialog("温馨提示", "您取消了登陆");
}
}
protected override async Task HandleCore(CreateAccountEventCommand command)
{
_logger.Info($"Received message {command.Event}", accountId: command.ResourceUri, @event: command.Event);
Validate(command);
try
{
var newAccountEvent = new AccountEvent
{
Event = command.Event,
CreatedOn = DateTime.UtcNow,
ResourceUri = command.ResourceUri
};
await _accountEventRepository.Create(newAccountEvent);
_logger.Info($"Finished processing message {command.Event}");
}
catch (Exception ex)
{
_logger.Error(ex, $"Error processing message {command.Event} - {ex.Message}", accountId: command.ResourceUri, @event: command.Event);
throw;
}
}
public void addAllEvent()
{
AccountEvent.EM().AddEvent(AccountEvent.EVENT.LOGIN_SUCCESS, onAccountLoginSuccess);
//子界面或独立界面刷新事件，请参考store
LobbyEvent.EM().AddEvent(LobbyEvent.EVENT.SHOW_USER_INFO, onEventShowUserInfo);
LobbyEvent.EM().AddEvent(LobbyEvent.EVENT.SHOW_PLAZA, onEventShowPlaza);
LobbyEvent.EM().AddEvent(LobbyEvent.EVENT.SHOW_LUCKDRAW, onEventShowLuckDraw);
LobbyEvent.EM().AddEvent(LobbyEvent.EVENT.SHOW_PACKAGE, onEventShowPackage);
LobbyEvent.EM().AddEvent(LobbyEvent.EVENT.SHOW_PRIVATE_MSG, onEventShowPrivateMsg);
LobbyEvent.EM().AddEvent(LobbyEvent.EVENT.SHOW_SIGNIN, onEventShowSignIn);
LobbyEvent.EM().AddEvent(LobbyEvent.EVENT.SHOW_STORE, onEventShowStore);
LobbyEvent.EM().AddEvent(LobbyEvent.EVENT.SHOW_FRIEND, onEventShowFriend);
LobbyEvent.EM().AddEvent(LobbyEvent.EVENT.SHOW_RANK, onEventShowRank);
LobbyEvent.EM().AddEvent(LobbyEvent.EVENT.REQ_UPDATE_EMAIL, onEventReqUpdateEmail);
LobbyEvent.EM().AddEvent(LobbyEvent.EVENT.REQ_FEEDBACK, onEventReqFeedback);
LobbyEvent.EM().AddEvent(LobbyEvent.EVENT.REQ_OPEN_TALENTSLOT, onEventReqOpenTalentslot);
LobbyEvent.EM().AddEvent(LobbyEvent.EVENT.UPDATE_USER_TALENT, onEventUpdateUserTalent);
//声音
LobbyEvent.EM().AddEvent(LobbyEvent.EVENT.OPEN_CLOSE_BG_SND, onEventBgSndSwitch);
LobbyEvent.EM().AddEvent(LobbyEvent.EVENT.OPEN_CLOSE_EFFECT_SND, onEventEffectSndSwitch);
ProtocolManager.getInstance().addPushMsgEventListener(LobbyProtocol.P_LOBBY_AWARD_EMAIL, OnAwardEmail);
}
private void FormAdmin_UpdateAccountEvent(object sender, AccountEvent e)
{
lbDisplayName.Text = e.Acc.DisplayName;
if (e.Acc.Type == 0)
{
btnAdmin.Hide();
}
}
// Use this for initialization
void Start()
{
//add all need game event and call back
ssdk.authHandler = AuthResultHandler;
ssdk.showUserHandler = GetUserInfoResultHandler;
AccountEvent.EM().InvokeEvent(AccountEvent.EVENT.CONNECT_SERVER, (object)false);
}
public static AccountEvent EM()
{
if (_instance == null)
{
_instance = new AccountEvent();
}
return(_instance);
}
// обработчик вывода средств
private static void WithdrawSumHandler(object sender, AccountEvent e)
{
Console.WriteLine(e.Message);
if (e.Sum > 0)
{
Console.WriteLine("Идем тратить деньги");
}
}
public bool UpdateAccount(UpdateCustomerEvent updateAccount, DbAccount accountDetails)
{
try
{
var accountEvent = new AccountEvent
{
AccountName = updateAccount.CustomerName,
AccountUID = updateAccount.CustomerUID,
Action = Operation.Update.ToString(),
BSSID = updateAccount.BSSID,
DealerAccountCode = updateAccount.DealerAccountCode,
NetworkCustomerCode = updateAccount.NetworkCustomerCode,
fk_ParentCustomerUID = accountDetails.fk_ParentCustomerUID ?? null,
fk_ChildCustomerUID = accountDetails.fk_ChildCustomerUID ?? null,
ActionUTC = updateAccount.ActionUTC,
ReceivedUTC = updateAccount.ReceivedUTC
};
if (!FieldHelper.IsValidValuesFilled(accountEvent, accountDetails, logger))
{
logger.LogError("DB Object expects typeOf IDbTable");
}
FieldHelper.ReplaceEmptyFieldsByNull(accountEvent);
var message = new KafkaMessage
{
Key = updateAccount.CustomerUID.ToString(),
Topic = AccountTopic,
Message = new { AccountEvent = accountEvent }
};
var accountObj = new DbAccount
{
CustomerAccountID = accountDetails.CustomerAccountID,
CustomerAccountUID = accountEvent.AccountUID,
BSSID = accountEvent.BSSID,
AccountName = accountEvent.AccountName,
NetworkCustomerCode = accountEvent.NetworkCustomerCode,
DealerAccountCode = accountEvent.DealerAccountCode,
fk_ChildCustomerUID = accountDetails.fk_ChildCustomerUID ?? null,
fk_ParentCustomerUID = accountDetails.fk_ParentCustomerUID ?? null,
RowUpdatedUTC = DateTime.UtcNow
};
var actions = new List <Action>()
{
() => transaction.Upsert(accountObj),
() => transaction.Publish(message)
};
return(transaction.Execute(actions));
}
catch (Exception ex)
{
logger.LogError($"Error while updating account customer : {ex.Message}, {ex.StackTrace}");
throw;
}
}
// Калл бэк при старте модуля
public static void OnStartGameScene(GameScene scene) // калл бэк при загрузке модуля: ...
//var _this = getScenesController;
{
if (scene == GameScene.RAFFLE)
{
//var accountEvent = _this.getNetwork().GetComponent<AccountEvent>();
AccountEvent.requestAccountInformation();
}
}
public async Task ThenTheEventIsCreated()
{
var request = new AccountEvent {
ResourceUri = "/api/accounts/ABC123", Event = "Test"
};
await Orchestrator.CreateEvent(request);
EventsLogger.Verify(x => x.Info($"Creating Account Event ({request.Event})", request.ResourceUri, null, request.Event));
Mediator.Verify(m => m.SendAsync(It.Is <CreateAccountEventCommand>(x => x.ResourceUri == request.ResourceUri && x.Event == request.Event)));
}
private void CreateHistory(AccountEvent accountEvent, CancellationToken cancellationToken)
{
var account = _context.Accounts.Find(accountEvent.Account.No);
if (account is Account)
{
var history = new AccountOperation(accountEvent.When, accountEvent.ToString(), accountEvent.Amount, accountEvent.What);
account.AddOperation(history);
}
}
public void addAllEvent()
{
AccountEvent.EM().AddEvent(AccountEvent.EVENT.CONNECT_SERVER, onConnectServer);
AccountEvent.EM().AddEvent(AccountEvent.EVENT.LOGIN, onLogin);
AccountEvent.EM().AddEvent(AccountEvent.EVENT.LOGOUT, onLogout);
AccountEvent.EM().AddEvent(AccountEvent.EVENT.THIRD_PARTY_LOGIN_RET, onThirdPartyLoginResult);
AccountEvent.EM().AddEvent(AccountEvent.EVENT.NETWORK_DISCONNECT, onDisconnect);
AccountEvent.EM().AddEvent(AccountEvent.EVENT.NETWORK_ERROR, onError);
}
//void onMarketItemsRecive() {
//AccountEvent.requestAccountInformation(); // запрашиваем данные об аккаунте
//}
void onRoomsReceive(RoomsData rooms) // █ получив комнаты
{
Rooms.setNewRoomsData(rooms);
/////////////////////////////////////////////////////////
//var controller = WindowController.getWinController;
//MarketEvent marketEvent = controller.getMarketEvent();
//marketEvent.OnReady += (sender, e) => controller.onMarketItemsRecive();
//WindowController.requestContent(WindowController.TypePopUpWindow.NONE);
/////////////////////////////////////////////////////////
AccountEvent.requestAccountInformation(); // запрашиваем данные об аккаунте
}
public async Task Publish(AccountEvent evt)
{
var message = new BrokeredMessage();
message.Properties["AccountId"] = evt.AccountId;
message.Properties["CustomerId"] = evt.CustomerId;
message.Properties["Type"] = evt.Type.ToString();
message.Properties["Amount"] = evt.Amount;
await _queueClient.SendAsync(message);
}
public void AndValidationFailsThenTheFailureIsLogged()
{
var request = new AccountEvent();
var validationException = new ValidationException("Exception");
Mediator.Setup(m => m.SendAsync(It.Is <CreateAccountEventCommand>(x => x.ResourceUri == request.ResourceUri && x.Event == request.Event))).ThrowsAsync(validationException);
Assert.ThrowsAsync <ValidationException>(() => Orchestrator.CreateEvent(request));
EventsLogger.Verify(x => x.Warn(validationException, "Invalid request", request.ResourceUri, null, request.Event));
}
public void AndAnExceptionOccursThenTheErrorIsLogged()
{
var request = new AccountEvent();
var exception = new Exception("Exception");
Mediator.Setup(m => m.SendAsync(It.Is <CreateAccountEventCommand>(x => x.ResourceUri == request.ResourceUri && x.Event == request.Event))).ThrowsAsync(exception);
Assert.ThrowsAsync <Exception>(() => Orchestrator.CreateEvent(request));
EventsLogger.Verify(x => x.Error(exception, exception.Message, null, null, null));
}
/// <summary>
/// Brokerages can send account updates, this include cash balance updates. Since it is of
/// utmost important to always have an accurate picture of reality, we'll trust this information
/// as truth
/// </summary>
private void HandleAccountChanged(AccountEvent account)
{
// how close are we?
var delta = _algorithm.Portfolio.CashBook[account.CurrencySymbol].Quantity - account.CashBalance;
if (delta != 0)
{
Log.Trace(string.Format("BrokerageTransactionHandler.HandleAccountChanged(): {0} Cash Delta: {1}", account.CurrencySymbol, delta));
}
// override the current cash value to we're always gauranted to be in sync with the brokerage's push updates
_algorithm.Portfolio.CashBook[account.CurrencySymbol].Quantity = account.CashBalance;
}
public async Task CreateAccountEvent()
{
var input = new AccountEvent();
var employerRequest = new TestRequest(new Uri(ExpectedApiBaseUrl + $"api/events/accounts"), JsonConvert.SerializeObject(input));
_fakeHandler.AddFakeResponse(employerRequest, new HttpResponseMessage {
StatusCode = HttpStatusCode.OK, Content = new StringContent(string.Empty)
});
await _sut.CreateAccountEvent(input);
Assert.Pass();
}
/// <summary>
/// Event invocator for the AccountChanged event
/// </summary>
/// <param name="e">The AccountEvent</param>
protected virtual void OnAccountChanged(AccountEvent e)
{
try
{
Log.Trace($"Brokerage.OnAccountChanged(): {e}");
AccountChanged?.Invoke(this, e);
}
catch (Exception err)
{
Log.Error(err);
}
}
public override void SetInstance(ScheduleInstance instance)
{
if (instance.Schedule.AccountEvents == null || instance.Schedule.AccountEvents.Count != 1)
{
throw new Exception(string.Format("Orphaned schedule instance {0}.", instance.Id));
}
AccountEvent evt = (AccountEvent)instance.Schedule.AccountEvents[0];
AccountEventId = evt.Id;
AccountEventType = evt.AccountEventType.Name;
Description = evt.Description;
Created = evt.Created;
Modified = evt.Modified;
AccountId = evt.Account.Id;
AccountName = evt.Account.Name;
ScheduleId = evt.Schedule.Id;
PlaceId = evt.Place.Id;
PlaceName = evt.Place.Name;
if (evt.Place.City != null)
{
PlaceCity = evt.Place.City.Name;
}
if (evt.Place.City != null && evt.Place.City.Country != null)
{
PlaceCountry = evt.Place.City.Country.Name;
}
if (evt.Place.City != null && evt.Place.City.State != null)
{
PlaceState = evt.Place.City.State.Name;
}
if (evt.Place.Neighborhood != null)
{
PlaceNeighborhood = evt.Place.Neighborhood.Name;
}
Name = evt.Name;
Phone = evt.Phone;
Email = evt.Email;
Website = evt.Website;
Cost = evt.Cost;
PictureId = ManagedService <AccountEventPicture, TransitAccountEventPicture> .GetRandomElementId(evt.AccountEventPictures);
StartDateTime = instance.StartDateTime;
EndDateTime = instance.EndDateTime;
Instance = instance.Instance;
NoEndDateTime = instance.Schedule.NoEndDateTime;
base.SetInstance(instance);
}
public static void showError(Api.ServerErrors serverErrorType, GameScene fromScene = GameScene.UNDEF)
{
switch (serverErrorType)
{
case Api.ServerErrors.E_VERSION_ERROR: showError(TypeError.ES_NEED_UPDATE, fromScene); break;
case Api.ServerErrors.E_SESSION_EXPIRED: showError(TypeError.ES_SESSION_EXPIRED, fromScene); break;
case Api.ServerErrors.E_REQUEST_PARAMS: show("Ошибка покупки", () => { WindowController.rebildCurrentWindow(); }); break;
case Api.ServerErrors.E_DRAWING_END: ScenesController.loadScene(GameScene.MAIN_MENU); break;
case Api.ServerErrors.E_NOT_ENOUGH: {
var errWnd = show("Недостаточно средств для совершения операции.\nПопробуйте ещё.");
errWnd.setAction(0, () => {
WindowController.rebildCurrentWindow();
AccountEvent.requestAccountInformation();
if (fromScene == GameScene.RAFFLE)
{
ScenesController.loadScene(GameScene.MAIN_MENU);
}
});
} break;
case Api.ServerErrors.E_SESSION: { showErrorAndReAutification("Ошибка сессии"); } break;
case Api.ServerErrors.E_SESSION_ID: { showErrorAndReAutification("Ошибка сессии"); } break;
case Api.ServerErrors.E_DB_ERROR: showServerError("Ошибка сервера", fromScene); break;
case Api.ServerErrors.E_TEMP_ERROR: showServerError("Временная ошибка сервера", fromScene); break;
case Api.ServerErrors.E_PENDING: showServerError("ошибка сервера", fromScene); break;
default: {
if (fromScene != GameScene.AUTORIZATION)
{
var errWnd = show("Неизвестная ошибка");
errWnd.setAction(0, () => { ScenesController.loadScene(GameScene.AUTORIZATION); });
}
else
{
var errWnd = show("Приложение не рабочее", "выход");
errWnd.setAction(0, () => { MAIN.exit(); });
}
} break;
}
}
/// <summary>
/// Brokerages can send account updates, this include cash balance updates. Since it is of
/// utmost important to always have an accurate picture of reality, we'll trust this information
/// as truth
/// </summary>
private void HandleAccountChanged(AccountEvent account)
{
// how close are we?
var delta = _algorithm.Portfolio.CashBook[account.CurrencySymbol].Amount - account.CashBalance;
if (delta != 0)
{
Log.Trace(string.Format("BrokerageTransactionHandler.HandleAccountChanged(): {0} Cash Delta: {1}", account.CurrencySymbol, delta));
}
// maybe we don't actually want to do this, this data can be delayed. Must be explicitly supported by brokerage
if (_brokerage.AccountInstantlyUpdated)
{
// override the current cash value so we're always guaranteed to be in sync with the brokerage's push updates
_algorithm.Portfolio.CashBook[account.CurrencySymbol].SetAmount(account.CashBalance);
}
}
/// <summary>
/// Event invocator for the AccountChanged event
/// </summary>
/// <param name="e">The AccountEvent</param>
protected virtual void OnAccountChanged(AccountEvent e)
{
try
{
Log.Trace("Brokerage.OnAccountChanged(): " + e);
var handler = AccountChanged;
if (handler != null)
{
handler(this, e);
}
}
catch (Exception err)
{
Log.Error(err);
}
}
/// <summary>
/// Event invocator for the AccountChanged event
/// </summary>
/// <param name="e">The AccountEvent</param>
protected virtual void OnAccountChanged(AccountEvent e)
{
try
{
if (!CashSyncEnabled)
{
Log.Trace($"Brokerage.OnAccountChanged(): {e}. Skipping cash sync disabled");
return;
}
Log.Trace($"Brokerage.OnAccountChanged(): {e}");
AccountChanged?.Invoke(this, e);
}
catch (Exception err)
{
Log.Error(err);
}
}
public void addEvent(AccountEvent.Alter.Event pevent)
{
if (this.actEvent < Account.MAX_EVENT)
{
this.events[this.actEvent] = pevent;
System.Console.WriteLine(this.events[this.actEvent]);
if (pevent is TransferEvent)
{
TransferEvent te = (TransferEvent)pevent;
Account targetAccount = te.TargetAccount;
if ( (targetAccount is MoneyAccount) && (this is MoneyAccount) ){
MoneyAccount baseAccount = (MoneyAccount)this;
MoneyAccount targetMoneyAccount = (MoneyAccount)targetAccount;
baseAccount.Money -= te.TransferValue;
targetMoneyAccount.Money += te.TransferValue;
}
}
actEvent++;
}
}
public override Task <Unused> Account(AccountEvent request, ServerCallContext context)
{
string action = string.Empty;
if (request.Action == Crud.Create)
{
action = "created";
}
else if (request.Action == Crud.Update)
{
action = "updated";
}
else if (request.Action == Crud.Delete)
{
action = "deleted";
}
else
{
action = "unknown";
}
return(Task.FromResult(new Unused()));
}
protected override async Task HandleMessage(FeedMessage msg)
{
if (msg.Type == "message" && msg.Topic == Topic)
{
var obj = msg.Data.ToObject <AccountEventData>();
if (msg.Subject == "orderMargin.change")
{
obj.EventType = EventType.OrderMargin;
}
else if (msg.Subject == "availableBalance.change")
{
obj.EventType = EventType.OrderMargin;
}
else if (msg.Subject == "withdrawHold.change")
{
obj.EventType = EventType.OrderMargin;
}
await PushNext(obj);
AccountEvent?.Invoke(this, obj);
if (msg.Subject == "orderMargin.change")
{
OrderMaginEvent?.Invoke(this, obj);
}
else if (msg.Subject == "availableBalance.change")
{
AvailableBalanceEvent?.Invoke(this, obj);
}
else if (msg.Subject == "withdrawHold.change")
{
WithdrawHoldEvent?.Invoke(this, obj);
}
}
}
public async Task CreateEvent(AccountEvent request)
{
try
{
_logger.Info($"Creating Account Event ({request.Event})", accountId: request.ResourceUri, @event: request.Event);
await _mediator.SendAsync(new CreateAccountEventCommand
{
Event = request.Event,
ResourceUri = request.ResourceUri
});
}
catch (ValidationException ex)
{
_logger.Warn(ex, "Invalid request", accountId: request.ResourceUri, @event: request.Event);
throw;
}
catch (Exception ex)
{
_logger.Error(ex, ex.Message);
throw;
}
}
public static ACL GetACL(ISession session, AccountEvent instance, Type type) { return new ManagedAccountEvent(session, instance).GetACL(type); }
public static string GetObjectName(AccountEvent instance, int id) { return instance.Name; }
public static int GetOwnerId(AccountEvent instance, int id) { return instance.Account.Id; }
