public async Task TransferAllAssetsToAddress(string clientId, string srcAddress, string srcPrivateKey, string destAddress) { var transactionId = Guid.NewGuid().ToString("N"); var transfer = await _transferEventsRepository.RegisterAsync(TransferEvent.CreateNewTransferAll(clientId, transactionId, srcAddress)); var contextData = TransferContextData.Create(new TransferContextData.TransferModel { ClientId = clientId, OperationId = transfer.Id }); await _bitCoinTransactionsRepository.CreateAsync(transactionId, null, contextData); if (_baseSettings.UsePushPrivateKeyService) { await _srvBlockchainHelper.PushPrivateKey(srcPrivateKey); srcPrivateKey = null; } var assets = (await _assetsDict.Values()).ToArray(); bool needToTransferAssets = (await _srvBlockchainReader.GetBalancesForAdress(srcAddress, assets)).Any(x => x.Balance > 0); if (needToTransferAssets) { var queueMsg = await _bitCoinCommandProducer.TransferAllAssetsToAddress(transactionId, srcAddress, srcPrivateKey, destAddress); await _bitCoinTransactionsRepository.UpdateRequestAsync(transactionId, queueMsg); } }
public async Task Transfer(MessageContext context, TransferEvent inputEvent) { var card = cardsRepository.GetCard(inputEvent.Transfer.CardId); if (card == null) { throw new ArgumentException("Card not found."); } var blockRequestTime = DateTime.UtcNow; var title = $"{DateTime.UtcNow} card usage for a transfer worth {inputEvent.Transfer.Amount} EUR"; var transfer = new Transfer { AccountId = card.AccountId, CardId = card.Id, Recipient = inputEvent.Transfer.Recipient, Amount = inputEvent.Transfer.Amount, Title = title }; var accountTransferEvent = new TransferEvent { Transfer = transfer }; var reply = await eventsAwaiter.AwaitResponse <SelectedTransactionsEvent>(context.FlowId, () => publishingRouter.Publish(Queues.Accounts, accountTransferEvent, context.FlowId, Queues.Cards)); var transaction = reply.Transactions.Single(); cardsRepository.CreateBlock(card.Id, transaction.Id, blockRequestTime); if (context.ReplyTo != null) { publishingRouter.Publish(context.ReplyTo, reply, context.FlowId); } }
protected void OnDimTrsfEvent(string type, string message) { AutoControlEventArgs acArgs = new AutoControlEventArgs() { EventType = type, Message = message, EvtTime = DateTime.Now }; TransferEvent?.Invoke(this, acArgs); }
public Task Transfer(Transfer transfer) { var flowId = HttpContext.Items["flowId"].ToString(); var payload = new TransferEvent { Transfer = transfer }; publishingRouter.Publish(Queues.Accounts, payload, flowId); return(Task.CompletedTask); }
public Task Transfer(Transfer transfer) { var transferEvent = new TransferEvent { Transfer = transfer }; var flowId = HttpContext.Items["flowId"].ToString(); publishingRouter.Publish(Queues.Cards, transferEvent, flowId); return(Task.CompletedTask); }
public async Task EventHandle(TransferEvent evt, EventMeta eventBase) { using (var db = this.ServiceProvider.GetService <TransferDbContext>()) { var entity = await db.Accounts.FirstOrDefaultAsync(x => x.Id == this.ActorId); this.accountSnapshotHandler.EntityHandle(entity, evt); await db.SaveChangesAsync(); } }
private async Task RegisterOperation(TransferEvent operation) { var response = await _transferEventsRepositoryClient.RegisterAsync(operation); if (response.Id != operation.Id) { _log.Warning($"Unexpected response from Operations Service: {response.ToJson()}", context: operation.ToJson()); } ChaosKitty.Meow(); }
public async Task IsLogForEvent() { var indexer = new Mock <IEventIndexer <TransferEvent> >(); var processor = new EventIndexProcessor <TransferEvent>(indexer.Object); var transferLog = new FilterLog { Topics = new object[] { TransferEvent.Signature() } }; var irrelevantLog = new FilterLog { Topics = new object[] { "SignatureForAnotherEvent" } }; Assert.True(processor.IsLogForEvent(transferLog)); Assert.False(processor.IsLogForEvent(irrelevantLog)); }
public Task Transfer(MessageContext context, TransferEvent inputEvent) { if (!accountsRepository.CanTransfer(inputEvent.Transfer.AccountId, inputEvent.Transfer.Recipient, inputEvent.Transfer.Amount)) { throw new ArgumentException("Cannot transfer founds."); } var transfer = TransferToCreateTransactionEvent(inputEvent.Transfer); accountsRepository.Transfer(inputEvent.Transfer.AccountId, inputEvent.Transfer.Recipient, inputEvent.Transfer.Amount); //info do kogo ma wrocic publishingRouter.Publish(Queues.Transactions, transfer, context.FlowId, context.ReplyTo); return(Task.CompletedTask); }
public Task <bool> Transfer(long toAccountId, decimal amount) { if (Snapshot.State.Balance >= amount) { var evt = new TransferEvent { Amount = amount, Balance = Snapshot.State.Balance - amount, ToId = toAccountId }; return(RaiseEvent(evt)); } else { return(Task.FromResult(false)); } }
private async Task ProcessMessageAsync(TransferEvent arg) { _log.Info("Got new message from ethereum core", arg.ToDetails()); try { await _ethereumTransferHandler.Handle(arg); } catch (UnknownErc20TokenException e) { _log.Error(e, context: e.TokenAddress); throw; } catch (UnknownErc20AssetException e) { _log.Error(e, context: e.Asset); throw; } catch (UnexpectedEthereumTransferTypeException e) { _log.Error(e, context: e.TransferType.ToString()); throw; } catch (UnexpectedEthereumEventTypeException e) { _log.Error(e, context: e.EventType.ToString()); throw; } catch (DefaultErrorResponseException e) when(e.StatusCode == HttpStatusCode.BadRequest) { if (e.InnerException is ApiException apiException) { _log.Error(e, context: new { message = e.Error?.ErrorMessage ?? apiException.Content, errors = e.Error?.ModelErrors }.ToDetails()); } throw; } }
public Task <bool> Transfer(long toAccountId, decimal amount, string transferId) { if (this.Snapshot.Data.Balance >= amount) { var evt = new TransferEvent { Amount = amount, Balance = this.Snapshot.Data.Balance - amount, ToId = toAccountId }; return(this.RaiseEvent(evt, transferId)); } else { return(Task.FromResult(false)); } }
private async Task ProcessTransferEvents(TransactionReceipt transactionReceipt) { try { var events = DecodeAllEventsAndFilter <SentEventDTO>(transactionReceipt); foreach (var @event in events) { if (string.IsNullOrEmpty(@event.Event.From) || string.IsNullOrEmpty(@event.Event.To)) { continue; } var evt = new TransferEvent { SourceAddress = @event.Event.From, TargetAddress = @event.Event.To, Amount = Money18.CreateFromAtto(@event.Event.Amount), EventIndex = (int)@event.Log.LogIndex.Value, TransactionHash = @event.Log.TransactionHash, ObservedAt = DateTime.UtcNow, }; await _transferEventPublishingService.PublishAsync(evt); _log.Info($"{nameof(TransferEvent)} has been published", evt); } } catch (Exception e) { #region Logging _log.Error ( e, $"Failed to process transfer events from transaction [{transactionReceipt.TransactionHash}].", new { transactionHash = transactionReceipt.TransactionHash } ); #endregion throw; } }
public async Task <bool> Transfer(long toAccountId, decimal amount) { if (this.Snapshot.Data.Balance >= amount) { var evt = new TransferEvent { Amount = amount, Balance = this.Snapshot.Data.Balance - amount, ToId = toAccountId }; await this.TxRaiseEvent(evt); return(true); } else { return(false); } }
public void DecodeTopics_Decodes_Transfer_Event() { var topics = new[] { "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x000000000000000000000000c14934679e71ef4d18b6ae927fe2b953c7fd9b91", "0x0000000000000000000000000000000000000000000000400000402000000001" }; var data = "0x"; var transferDto = new TransferEvent(); new EventTopicDecoder().DecodeTopics(transferDto, topics, data); Assert.True("0x0000000000000000000000000000000000000000".IsTheSameAddress(transferDto.From)); Assert.True("0xc14934679e71ef4d18b6ae927fe2b953c7fd9b91".IsTheSameAddress(transferDto.To)); Assert.Equal("1180591691223594434561", transferDto.Value.ToString()); }
public static void AddFeeDataToOperation(this TransferEvent operation, TransferQueueMessage message, Asset asset) { var fee = message?.Fees?.FirstOrDefault(); if (fee?.Instruction == null) { return; } if (fee.Instruction.SourceClientId == operation.ClientId) { operation.FeeSize = (double)(fee.Transfer?.Volume ?? 0); operation.FeeType = FeeType.Absolute; } if (fee.Instruction.TargetClientId == operation.ClientId) { // client receives more (amount + fee), amount should be increased operation.Amount = (operation.Amount + (double)(fee.Transfer?.Volume ?? 0)).TruncateDecimalPlaces(asset.Accuracy, true); } }
public async Task GenerateTransferFromOrdinaryWallet(string clientId, string sourceAddress, string sourceKey, double amount, string assetId, TransferContextData.AdditionalActions additionalActionsDest = null) { var asset = await _assetsRepository.GetAssetAsync(assetId); if (asset == null) { return; } amount = Math.Abs(amount); var transactionId = Guid.NewGuid().ToString("N"); var clientCreds = await _walletCredentialsRepository.GetAsync(clientId); var transfer = await _transferEventsRepository.RegisterAsync(TransferEvent.CreateNew(clientId, clientCreds.MultiSig, null, assetId, amount, transactionId, sourceAddress, clientCreds.MultiSig)); var contextData = TransferContextData.Create(new TransferContextData.TransferModel { ClientId = clientId, OperationId = transfer.Id, Actions = additionalActionsDest }); if (_baseSettings.UsePushPrivateKeyService) { await _srvBlockchainHelper.PushPrivateKey(sourceKey, true); sourceKey = null; } var queueMsg = await _bitCoinCommandProducer.ProduceGenerateTransferAsync(transactionId, sourceAddress, sourceKey, clientCreds.MultiSig, amount, asset.BlockChainId); await _bitCoinTransactionsRepository.CreateAsync(transactionId, queueMsg, contextData); }
public async Task <bool> Transfer(long toAccountId, decimal amount) { var result = false; await ConcurrentRaiseEvent(async (snapshot, func) => { if (snapshot.State.Balance > amount) { var evt = new TransferEvent { Amount = amount, Balance = Snapshot.State.Balance - amount, ToId = toAccountId }; await func(evt, null); result = true; } }); return(result); }
public Task EventHandle(TransferEvent evt) { var toActor = this.GrainFactory.GetGrain <IAccount>(evt.ToId); return(toActor.TransferArrived(evt.Amount)); }
public Task EventHandle(TransferEvent evt, EventBase eventBase) { //æ¤å¤„æ›´æ–°db return(Task.CompletedTask); }
public Task EventHandle(TransferEvent evt, EventBase eventBase) { var toActor = GrainFactory.GetGrain <IAccount>(evt.ToId); return(toActor.TransferArrived(evt.Amount, new EventUID(eventBase.GetEventId(GrainId.ToString()), eventBase.Timestamp))); }
public Task EventHandle(TransferEvent evt, EventUID uid) { var toActor = GrainFactory.GetGrain <IAccount>(evt.ToId); return(toActor.TransferArrived(evt.Amount, uid)); }
public async Task Handle(TransferEvent transferEvent) { if (transferEvent == null) { return; } Erc20Token token = await _assetsService.Erc20TokenGetByAddressAsync(transferEvent.TokenAddress); if (token == null) { throw new UnknownErc20TokenException(transferEvent.TokenAddress); } Asset asset = await _assetsService.AssetGetAsync(token.AssetId); if (asset == null) { throw new UnknownErc20AssetException(token.AssetId); } switch (transferEvent.SenderType) { case SenderType.Customer: var inboundTransactionRequest = Mapper.Map <RegisterInboundTxModel>( transferEvent, opt => { opt.Items["AssetId"] = asset.DisplayId; opt.Items["AssetMultiplier"] = asset.MultiplierPower; opt.Items["AssetAccuracy"] = asset.Accuracy; }); await _log.LogPayInternalExceptionIfAny(() => _payInternalClient.RegisterEthereumInboundTransactionAsync(inboundTransactionRequest)); break; case SenderType.EthereumCore: switch (transferEvent.EventType) { case EventType.Started: var outboundTransactionRequest = Mapper.Map <RegisterOutboundTxModel>( transferEvent, opt => { opt.Items["AssetId"] = asset.DisplayId; opt.Items["AssetMultiplier"] = asset.MultiplierPower; opt.Items["AssetAccuracy"] = asset.Accuracy; }); await _log.LogPayInternalExceptionIfAny(() => _payInternalClient .RegisterEthereumOutboundTransactionAsync(outboundTransactionRequest)); break; case EventType.Failed: await _log.LogPayInternalExceptionIfAny(() => _payInternalClient.FailEthereumOutboundTransactionAsync( Mapper.Map <FailOutboundTxModel>(transferEvent))); break; case EventType.Completed: await _log.LogPayInternalExceptionIfAny(() => _payInternalClient.CompleteEthereumOutboundTransactionAsync( Mapper.Map <CompleteOutboundTxModel>(transferEvent, opt => { opt.Items["AssetMultiplier"] = asset.MultiplierPower; opt.Items["AssetAccuracy"] = asset.Accuracy; }))); break; case EventType.NotEnoughFunds: await _log.LogPayInternalExceptionIfAny(() => _payInternalClient.FailEthereumOutboundTransactionAsync( Mapper.Map <NotEnoughFundsOutboundTxModel>(transferEvent))); break; default: throw new UnexpectedEthereumEventTypeException(transferEvent.EventType); } break; default: throw new UnexpectedEthereumTransferTypeException(transferEvent.SenderType); } }
public async Task Handle(TransferOperationStateSavedEvent evt) { var message = evt.QueueMessage; var transactionId = message.Id; var amountNoFee = evt.AmountNoFee; var context = await _transactionService.GetTransactionContext <TransferContextData>(transactionId); //Get eth request if it is ETH transfer var ethTxRequest = await _ethereumTransactionRequestRepository.GetAsync(Guid.Parse(transactionId)); //Get client wallets var wallets = (await _walletCredentialsRepository.GetWalletsAsync(new[] { message.ToClientid, message.FromClientId })).ToList(); var destWallet = wallets.FirstOrDefault(x => x.ClientId == message.ToClientid); var sourceWallet = wallets.FirstOrDefault(x => x.ClientId == message.FromClientId); //Register transfer events var transferState = ethTxRequest == null ? TransactionStates.SettledOffchain : ethTxRequest.OperationType == OperationType.TransferBetweenTrusted ? TransactionStates.SettledNoChain : TransactionStates.SettledOnchain; var asset = await _assetsServiceWithCache.TryGetAssetAsync(message.AssetId); var toOperation = new TransferEvent { Id = context.Transfers.Single(x => x.ClientId == message.ToClientid).OperationId, ClientId = message.ToClientid, DateTime = DateTime.UtcNow, FromId = null, AssetId = message.AssetId, Amount = amountNoFee, TransactionId = transactionId, IsHidden = false, AddressFrom = destWallet?.Address, AddressTo = destWallet?.MultiSig, Multisig = destWallet?.MultiSig, IsSettled = false, State = transferState }; var fromOperation = new TransferEvent { Id = context.Transfers.Single(x => x.ClientId == message.FromClientId).OperationId, ClientId = message.FromClientId, DateTime = DateTime.UtcNow, FromId = null, AssetId = message.AssetId, Amount = -amountNoFee, TransactionId = transactionId, IsHidden = false, AddressFrom = sourceWallet?.Address, AddressTo = sourceWallet?.MultiSig, Multisig = sourceWallet?.MultiSig, IsSettled = false, State = transferState }; toOperation.AddFeeDataToOperation(message, asset); fromOperation.AddFeeDataToOperation(message, asset); await RegisterOperation(toOperation); await RegisterOperation(fromOperation); }
/// <summary> /// This is the call back method called by the FaspManager on any event /// </summary> /// <param name="asperaEvent">The event for callback.</param> /// <param name="sessionStats">The Session levels statistics for the Session that triggered this event</param> /// <param name="fileStats">Statistics of the last file transferred in this session</param> public void fileSessionEvent(TransferEvent asperaEvent, SessionStats sessionStats, FileStats fileStats) { Console.WriteLine("Job Name: " + sessionStats.Cookie); Console.WriteLine("\tJob State: " + sessionStats.State); Console.WriteLine("\tTarget Rate: " + sessionStats.TargetRateKbps + "Kbps"); if (sessionStats.ElapsedUSec > 0) Console.WriteLine("\tAvg Actual Rate: " + (sessionStats.TotalTransferredBytes * 8 * 1000 / sessionStats.ElapsedUSec) + "Kbps"); Console.WriteLine("\tSession Downloaded: " + (sessionStats.TotalTransferredBytes / 1000) + "KB"); if (fileStats != null) { Console.WriteLine("\tFileName: " + fileStats.name); Console.WriteLine("\tFile Downloaded: " + (fileStats.writtenBytes / 1000) + "KB"); } Console.Write("\n"); // And stop the fasp manager if (asperaEvent == TransferEvent.SESSION_STOP || asperaEvent == TransferEvent.SESSION_ERROR) { currentFile.IsUploaded = true; currentFile.UploadEndTime = DateTime.Now; try { if (FaspManager.getInstance().getSessionIDList().Count == 1) { //FaspManager.destroy(); MoveFileToArchive(currentFile); } } catch (Exception) { } } if (asperaEvent == TransferEvent.SESSION_ERROR) { Console.WriteLine(sessionStats.ErrorDescription); } }
//return whether we have sent to rabbit or not private async Task <bool> SendCompleteEvent(string transactionHash, string operationId, bool success, QueueTriggeringContext context, CoinTransactionMessage transaction) { try { var operation = await GetOperationAsync(transactionHash, operationId); if (operation == null) { return(false); } (BigInteger? amount, string blockHash, ulong blockNumber)transferedInfo = (null, null, 0); string amount = operation.Amount.ToString(); switch (operation.OperationType) { case HotWalletOperationType.Cashout: break; case HotWalletOperationType.Cashin: //There will be nothing to index in failed event if (success) { transferedInfo = await _transactionEventsService.IndexCashinEventsForErc20TransactionHashAsync( transactionHash); if (transferedInfo.amount == null || transferedInfo.amount == 0) { //Not yet indexed SendMessageToTheQueueEnd(context, transaction, 10000); return(false); } amount = transferedInfo.amount.ToString(); } break; default: return(false); } EventType eventType = success ? EventType.Completed : EventType.Failed; TransferEvent @event = new TransferEvent(operation.OperationId, transactionHash, amount, operation.TokenAddress, operation.FromAddress, operation.ToAddress, transferedInfo.blockHash, transferedInfo.blockNumber, SenderType.EthereumCore, eventType, WorkflowType.Airlines, DateTime.UtcNow); await _rabbitQueuePublisher.PublshEvent(@event); return(true); } catch (Exception e) { await _log.WriteErrorAsync(nameof(AirlinesHotWalletMonitoringTransactionJob), "SendCompletedCoinEvent", $"trHash: {transactionHash}", e, DateTime.UtcNow); SendMessageToTheQueueEnd(context, transaction, 100); return(false); } }
void manager_UnhandledEvent(object sender, ManagerEvent e) { log.Debug("New unhandled event received: " + e.GetType().Name); LineControl lc = null; //StateServer switch (e.GetType().Name) { case "AGIExecEvent": AGIExecEvent agievent = e as AGIExecEvent; break; case "AlarmClearEvent": AlarmClearEvent alarmclear = e as AlarmClearEvent; break; case "AlarmEvent": AlarmEvent alarmevent = e as AlarmEvent; break; case "AsyncAGIEvent": AsyncAGIEvent asyncagievent = e as AsyncAGIEvent; break; case "BridgeEvent": BridgeEvent bridgeevent = e as BridgeEvent; break; case "CdrEvent": CdrEvent cdrevent = e as CdrEvent; break; case "ChannelReloadEvent": ChannelReloadEvent channelreload = e as ChannelReloadEvent; break; case "ChannelUpdateEvent": ChannelUpdateEvent channelupdate = e as ChannelUpdateEvent; break; case "ConnectEvent": ConnectEvent connectevent = e as ConnectEvent; break; case "ConnectionStateEvent": ConnectionStateEvent connectionstate = e as ConnectionStateEvent; break; case "DBGetResponseEvent": DBGetResponseEvent dbget = e as DBGetResponseEvent; log.Debug("DBGet response: " + dbget.ToString()); switch (dbget.Family) { case "DND": ss.SetLineControl(setLineControlDND(dbget.Key, true)); break; case "CF": ss.SetLineControl(setLineControlForward(dbget.Key, dbget.Val)); break; } break; case "DialEvent": DialEvent dial = e as DialEvent; log.Debug("Dial event: " + dial.ToString()); break; case "DisconnectEvent": DisconnectEvent disconnect = e as DisconnectEvent; log.Debug("Disconnect event: " + disconnect.ToString()); break; case "DNDStateEvent": DNDStateEvent dndstate = e as DNDStateEvent; log.Debug("DND state event: " + dndstate.ToString()); break; case "ExtensionStatusEvent": ExtensionStatusEvent extensionstatus = e as ExtensionStatusEvent; log.Debug("Extension status event: " + extensionstatus.ToString() + ", status: " + extensionstatus.Status + ", hint: " + extensionstatus.Hint); ss.SetLineControl(getLineControlFromExtensionStatusEvent(extensionstatus)); break; case "FaxReceivedEvent": FaxReceivedEvent faxreceived = e as FaxReceivedEvent; break; case "HangupEvent": HangupEvent hangup = e as HangupEvent; log.Debug("Hangup event: " + hangup.ToString() + " callerid: " + hangup.CallerId + " calleridnum: " + hangup.CallerIdNum); //line control if (channels.Contains(hangup.Channel)) { lc = getLineControl((string)channels[hangup.Channel]); int hi = 0; LineControlConnection[] newLCC = null; if (lc.lineControlConnection.Length > 1) { newLCC = new LineControlConnection[lc.lineControlConnection.Length - 1]; foreach (LineControlConnection hlcc in lc.lineControlConnection) { if (hlcc.callid != hangup.Channel) { newLCC[hi] = hlcc; hi++; } } } lc.lineControlConnection = newLCC; ss.SetLineControl(lc); channels.Remove(hangup.Channel); } //missed calls callToFind = hangup.UniqueId.Substring(0, 6) + "," + hangup.UniqueId.Substring(6); Call mCall = missedCalls.Find(FindCall); if (mCall != null) { log.Debug("Missed call finded for callid: " + hangup.UniqueId); AddCallLogs(mCall.callee, mCall); if (missedCalls.Remove(mCall)) { log.Debug("Call " + mCall.callId + " successfully removed from missedcall cache"); } else { log.Debug("Call " + mCall.callId + " cannot be removed from missedcall cache"); } } break; case "HoldedCallEvent": HoldedCallEvent holdedcall = e as HoldedCallEvent; break; case "HoldEvent": HoldEvent holdevent = e as HoldEvent; break; case "JabberEvent": JabberEvent jabberevent = e as JabberEvent; break; case "JitterBufStatsEvent": JitterBufStatsEvent jitter = e as JitterBufStatsEvent; break; case "JoinEvent": JoinEvent join = e as JoinEvent; break; case "LeaveEvent": LeaveEvent leave = e as LeaveEvent; break; case "LinkEvent": LinkEvent link = e as LinkEvent; log.Debug("Link event: " + link.ToString()); lc = getLineControl(link.CallerId1); if (lc != null) { foreach (LineControlConnection linklcc in lc.lineControlConnection) { if (linklcc.callid == link.Channel1) { linklcc.contact = link.CallerId2; ss.SetLineControl(lc); break; } } } lc = getLineControl(link.CallerId2); if (lc != null) { foreach (LineControlConnection linklcc in lc.lineControlConnection) { if (linklcc.callid == link.Channel2) { linklcc.contact = link.CallerId1; ss.SetLineControl(lc); break; } } } break; case "LogChannelEvent": LogChannelEvent logchannel = e as LogChannelEvent; break; case "ManagerEvent": ManagerEvent managerevent = e; break; case "MeetmeEndEvent": MeetmeEndEvent meetmeend = e as MeetmeEndEvent; break; case "MeetmeJoinEvent": MeetmeJoinEvent meetmejoin = e as MeetmeJoinEvent; break; case "MeetmeLeaveEvent": MeetmeLeaveEvent meetmeleave = e as MeetmeLeaveEvent; break; case "MeetmeMuteEvent": MeetmeMuteEvent meetmemute = e as MeetmeMuteEvent; break; case "MeetmeStopTalkingEvent": MeetmeStopTalkingEvent meetmestoptalking = e as MeetmeStopTalkingEvent; break; case "MeetmeTalkingEvent": MeetmeTalkingEvent meetmetalking = e as MeetmeTalkingEvent; break; case "MeetmeTalkRequestEvent": MeetmeTalkRequestEvent meetmetalkrequest = e as MeetmeTalkRequestEvent; break; case "MessageWaitingEvent": MessageWaitingEvent messagewaiting = e as MessageWaitingEvent; log.Debug("Message waiting event: " + messagewaiting.ToString()); lc = getLineControl(messagewaiting.Mailbox.Substring(0, messagewaiting.Mailbox.IndexOf("@"))); if (lc != null) { if (messagewaiting.Waiting > 0) { lc.mwiOn = true; } else { lc.mwiOn = false; } ss.SetLineControl(lc); } break; case "MobileStatusEvent": MobileStatusEvent mobilestatus = e as MobileStatusEvent; break; case "ModuleLoadReportEvent": ModuleLoadReportEvent moduleload = e as ModuleLoadReportEvent; break; case "MonitorStartEvent": MonitorStartEvent monitorstart = e as MonitorStartEvent; break; case "MonitorStopEvent": MonitorStopEvent monitorstop = e as MonitorStopEvent; break; case "NewAccountCodeEvent": NewAccountCodeEvent newaccountcode = e as NewAccountCodeEvent; break; case "NewCallerIdEvent": NewCallerIdEvent newcallerid = e as NewCallerIdEvent; log.Debug("New caller id envent: " + newcallerid.ToString()); break; case "NewChannelEvent": NewChannelEvent newchannel = e as NewChannelEvent; log.Debug("New Channel event: " + newchannel.ToString()); CommandAction ca = new CommandAction("core show channel " + newchannel.Channel); CommandResponse cr = (CommandResponse)manager.SendAction(ca, 10000); log.Debug("Channel info: " + cr.ToString()); string dn = newchannel.CallerIdNum; log.Debug("Retreive call information..."); bool callerIdUnknown = true; if (newchannel.CallerIdNum != "<unknown>") { callerIdUnknown = false; } else { foreach (string s in cr.Result) { if (s.Contains("Caller ID:")) { dn = s.Substring(s.LastIndexOf(" ")); break; } } } Call newOutboundCall = getOutboundCallFromChannelInfo(cr.Result, callerIdUnknown); if (newOutboundCall != null) { Call missedCall = newOutboundCall; AddCallLogs(dn, newOutboundCall); dnToFind = newOutboundCall.callee; if (linecontrols.Find(FindLineControl) != null) { log.Debug("This call will be put in missedcall cache: " + missedCall.callId); missedCall.type = CallType.missed; missedCalls.Add(missedCall); } } break; case "NewExtenEvent": NewExtenEvent newexten = e as NewExtenEvent; log.Debug("New exten event: " + newexten.ToString()); string channel = ""; char[] splitter = { '/' }; string[] splitchannel = newexten.Channel.Split(splitter); splitter[0] = '-'; splitchannel = splitchannel[1].Split(splitter); channel = splitchannel[0]; //DND? if (newexten.Extension == Properties.Settings.Default.FeatureCodeDNDToggle && newexten.Application == "Playback") { switch (newexten.AppData) { case "do-not-disturb&activated": log.Debug("Successfully activate dnd for channel: " + channel); ss.SetLineControl(setLineControlDND(channel, true)); break; case "do-not-disturb&de-activated": log.Debug("Successfully deactivate dnd for channel: " + channel); ss.SetLineControl(setLineControlDND(channel, false)); break; } } //Forward all? else if (newexten.Extension.Contains(Properties.Settings.Default.FeatureCodeCallForwardAllActivate) && newexten.Application == "Playback" && newexten.AppData == "call-fwd-unconditional&for&extension") { string forward = newexten.Extension.Substring(Properties.Settings.Default.FeatureCodeCallForwardAllActivate.Length); log.Debug("Call forward all from channel: " + channel + " to " + forward); ss.SetLineControl(setLineControlForward(channel, forward)); } // UnForwardAll else if (newexten.Extension == Properties.Settings.Default.FeatureCodeCallForwardAllDeactivate && newexten.Application == "Playback" && newexten.AppData == "call-fwd-unconditional&de-activated") { log.Debug("Call unforward all from channel: " + channel); ss.SetLineControl(setLineControlForward(channel, "")); } break; case "NewStateEvent": NewStateEvent newstate = e as NewStateEvent; log.Debug("New State event: " + newstate.ToString()); LineControl newstateLc = getLineControl(newstate.CallerId); LineControlConnection[] newStateLccs = null; int i = 0; if (newstateLc.lineControlConnection != null) { bool isContained = false; foreach (LineControlConnection elcc in newstateLc.lineControlConnection) { if (elcc.callid == newstate.Channel) { isContained = true; newStateLccs = newstateLc.lineControlConnection; break; } i++; } if (!isContained) { i = 0; newStateLccs = new LineControlConnection[newstateLc.lineControlConnection.Length + 1]; foreach (LineControlConnection newstateLcc in newstateLc.lineControlConnection) { newStateLccs[i] = newstateLcc; i++; } } } else { newStateLccs = new LineControlConnection[1]; newStateLccs[0] = new LineControlConnection(); } try { switch (newstate.State) { case "Up": //received call? callToFind = newstate.UniqueId; Call rCall = missedCalls.Find(FindCall); if (rCall != null) { log.Debug("Missed call finded: " + callToFind + ", this call will be received"); rCall.type = CallType.received; AddCallLogs(rCall.callee, rCall); missedCalls.Remove(rCall); } if (newStateLccs != null) { if (!channels.Contains(newstate.Channel)) { channels.Add(newstate.Channel, newstate.CallerId); } newStateLccs[i].callid = newstate.Channel; newStateLccs[i].remoteState = Wybecom.TalkPortal.CTI.Proxy.ConnectionState.established; newStateLccs[i].state = Wybecom.TalkPortal.CTI.Proxy.ConnectionState.established; newStateLccs[i].terminalState = TerminalState.talking; } break; case "Ringing": if (newStateLccs != null) { if (!channels.Contains(newstate.Channel)) { channels.Add(newstate.Channel, newstate.CallerId); } newStateLccs[i].callid = newstate.Channel; newStateLccs[i].remoteState = Wybecom.TalkPortal.CTI.Proxy.ConnectionState.established; newStateLccs[i].state = Wybecom.TalkPortal.CTI.Proxy.ConnectionState.alerting; newStateLccs[i].terminalState = TerminalState.ringing; } break; case "Ring": if (newStateLccs != null) { if (!channels.Contains(newstate.Channel)) { channels.Add(newstate.Channel, newstate.CallerId); } newStateLccs[i].callid = newstate.Channel; newStateLccs[i].remoteState = Wybecom.TalkPortal.CTI.Proxy.ConnectionState.alerting; newStateLccs[i].state = Wybecom.TalkPortal.CTI.Proxy.ConnectionState.dialing; newStateLccs[i].terminalState = TerminalState.inuse; } break; } } catch (Exception stateException) { log.Debug("NewState exception: " + stateException.Message); } if (newstateLc != null) { newstateLc.lineControlConnection = newStateLccs; ss.SetLineControl(newstateLc); } break; case "OriginateResponseEvent": OriginateResponseEvent originateresponse = e as OriginateResponseEvent; break; case "ParkedCallEvent": ParkedCallEvent parkedcall = e as ParkedCallEvent; break; case "ParkedCallGiveUpEvent": ParkedCallGiveUpEvent parkedcallgiveup = e as ParkedCallGiveUpEvent; break; case "ParkedCallsCompleteEvent": ParkedCallsCompleteEvent parkedcallscomplete = e as ParkedCallsCompleteEvent; break; case "ParkedCallTimeOutEvent": ParkedCallTimeOutEvent parkedcalltimeout = e as ParkedCallTimeOutEvent; break; case "PeerEntryEvent": log.Debug("SipAction: one peer entry event received, " + e.ToString()); PeerEntryEvent peerentry = e as PeerEntryEvent; peers.Add(peerentry); ss.SetLineControl(getLineControlFromPeerEntry(peerentry)); break; case "PeerlistCompleteEvent": log.Debug("SipAction: peer list completed " + e.ToString()); PeerlistCompleteEvent peerlistcomplete = e as PeerlistCompleteEvent; acs.setPeers(peers); break; case "PeerStatusEvent": PeerStatusEvent peerstatus = e as PeerStatusEvent; log.Debug("Peer status: " + peerstatus.ToString()); break; case "PRIEvent": PRIEvent pri = e as PRIEvent; break; case "RegistryEvent": RegistryEvent registry = e as RegistryEvent; break; case "ReloadEvent": ReloadEvent reload = e as ReloadEvent; break; case "RenameEvent": RenameEvent rename = e as RenameEvent; break; case "ResponseEvent": ResponseEvent response = e as ResponseEvent; break; case "RTCPReceivedEvent": RTCPReceivedEvent rtcpreceived = e as RTCPReceivedEvent; break; case "RTCPSentEvent": RTCPSentEvent rtcpsent = e as RTCPSentEvent; break; case "RTPReceiverStatEvent": RTPReceiverStatEvent rtpreceiver = e as RTPReceiverStatEvent; break; case "RTPSenderStatEvent": RTPSenderStatEvent rtpsender = e as RTPSenderStatEvent; break; case "ShowDialPlanCompleteEvent": ShowDialPlanCompleteEvent showdialplan = e as ShowDialPlanCompleteEvent; break; case "ShutdownEvent": ShutdownEvent shutdown = e as ShutdownEvent; break; case "StatusCompleteEvent": StatusCompleteEvent statuscomplete = e as StatusCompleteEvent; break; case "StatusEvent": StatusEvent status = e as StatusEvent; break; case "TransferEvent": TransferEvent transfer = e as TransferEvent; break; case "UnholdEvent": UnholdEvent unhold = e as UnholdEvent; break; case "UnknownEvent": UnknownEvent unknown = e as UnknownEvent; break; case "UnlinkEvent": UnlinkEvent unlink = e as UnlinkEvent; log.Debug("Unlink event : " + unlink.ToString()); LineControlConnection[] lccs = null; i = 0; lc = getLineControl(unlink.CallerId1); if (lc != null) { if (lc.lineControlConnection.Length > 1) { lccs = new LineControlConnection[lc.lineControlConnection.Length - 1]; foreach (LineControlConnection linklcc in lc.lineControlConnection) { if (linklcc.callid != unlink.Channel1) { lccs[i] = linklcc; i++; break; } } } else { lc.lineControlConnection = null; } ss.SetLineControl(lc); } i = 0; lc = getLineControl(unlink.CallerId2); if (lc != null) { if (lc.lineControlConnection.Length > 1) { lccs = new LineControlConnection[lc.lineControlConnection.Length - 1]; foreach (LineControlConnection linklcc in lc.lineControlConnection) { if (linklcc.callid != unlink.Channel2) { lccs[i] = linklcc; i++; break; } } } else { lc.lineControlConnection = null; } ss.SetLineControl(lc); } break; case "UnparkedCallEvent": UnparkedCallEvent unparked = e as UnparkedCallEvent; break; case "UserEvent": UserEvent user = e as UserEvent; break; case "VarSetEvent": VarSetEvent varset = e as VarSetEvent; break; case "ZapShowChannelsCompleteEvent": ZapShowChannelsCompleteEvent zapshowchannelscomplete = e as ZapShowChannelsCompleteEvent; break; case "ZapShowChannelsEvent": ZapShowChannelsEvent zapshowchannels = e as ZapShowChannelsEvent; break; } //ACDConnector switch (e.GetType().Name) { case "AgentCallbackLoginEvent": AgentCallbackLoginEvent agentcallbacklogin = e as AgentCallbackLoginEvent; break; case "AgentCallbackLogoffEvent": AgentCallbackLogoffEvent agentcallbacklogoff = e as AgentCallbackLogoffEvent; break; case "AgentCalledEvent": AgentCalledEvent agentcalled = e as AgentCalledEvent; break; case "AgentCompleteEvent": AgentCompleteEvent agentcomplete = e as AgentCompleteEvent; break; case "AgentConnectEvent": AgentConnectEvent agentconnect = e as AgentConnectEvent; break; case "AgentDumpEvent": AgentDumpEvent agentdump = e as AgentDumpEvent; break; case "AgentLoginEvent": AgentLoginEvent agentlogin = e as AgentLoginEvent; break; case "AgentLogoffEvent": AgentLogoffEvent agentlogoff = e as AgentLogoffEvent; break; case "AgentsCompleteEvent": AgentsCompleteEvent agentscomplete = e as AgentsCompleteEvent; break; case "AgentsEvent": AgentsEvent agentevent = e as AgentsEvent; break; case "QueueCallerAbandonEvent": QueueCallerAbandonEvent queuecallerabandon = e as QueueCallerAbandonEvent; break; case "QueueEntryEvent": QueueEntryEvent queueentry = e as QueueEntryEvent; break; case "QueueEvent": QueueEvent queue = e as QueueEvent; break; case "QueueMemberEvent": QueueMemberEvent queuemember = e as QueueMemberEvent; break; case "QueueMemberPausedEvent": QueueMemberPausedEvent queuememberpaused = e as QueueMemberPausedEvent; break; case "QueueMemberPenaltyEvent": QueueMemberPenaltyEvent queuememberpenalty = e as QueueMemberPenaltyEvent; break; case "QueueMemberRemovedEvent": QueueMemberRemovedEvent queuememberremoved = e as QueueMemberRemovedEvent; break; case "QueueMemberStatusEvent": QueueMemberStatusEvent queuememberstatus = e as QueueMemberStatusEvent; break; case "QueueParamsEvent": QueueParamsEvent queueparams = e as QueueParamsEvent; break; case "QueueStatusCompleteEvent": QueueStatusCompleteEvent queuestatuscomplete = e as QueueStatusCompleteEvent; break; } }
public void EventHandle(AccountState state, TransferEvent evt) { state.Balance = evt.Balance; }
/// <summary> /// Creates the class (one instance only) that parses a scenario and puts events on queues /// </summary> /// <param name="scenarioFile"></param> public ScenarioToQueues(string scenarioFile, string schemaFile) { TimerQueueClass timerQueue = new TimerQueueClass(); // Extract fields from the XML file (and schema) // see http://weblogs.asp.net/dbrowning/articles/114561.aspx // paths to xml/xsd // const string path = @"C:\Documents and Settings\dgeller\My Documents\Visual Studio 2005\Projects\"; //const string scenarioFile = path + @"DDD\Scenario.xml"; // const string xsdPath = path + @"XMLTrial\XMLTrial\ScenarioSchema.xsd"; FileStream fs; Boolean returnVal; // ScenarioToQueues.schemaFile = schemaFile; // try // { returnVal = ValidateScenario(scenarioFile); // } /* catch (System.Exception e) * { * * string message = "Failed to validate schema. " + e.Message; * Coordinator.debugLogger.LogException("Scenario Reader", message); * throw new ApplicationException(message, e); * }*/ if (!returnVal) { return; } try { fs = File.Open(scenarioFile, FileMode.Open); } catch (System.Exception e) { string message = "Could not open scenario file on pass 2." + e.Message; Coordinator.debugLogger.LogException("Scenario Reader", message); throw new ApplicationException(message, e); } /// XmlReader readerTwo; try { XmlSchemaSet sc = new XmlSchemaSet(); sc.Add(null, ScenarioToQueues.namedSchemaFile);//+".xsd"); XmlReaderSettings readerSettings = new XmlReaderSettings(); // readerSettings.ValidationType = ValidationType.Schema; readerSettings.IgnoreWhitespace = true; // makes no difference ?! readerSettings.IgnoreWhitespace = true; // readerSettings.ValidationEventHandler += new ValidationEventHandler(SchemaValidationHandler); reader = XmlReader.Create(fs, readerSettings); parser.SetReader(reader); } catch (System.Exception e) { fs.Close(); string message = "Could not open schema file. " + e.Message; Coordinator.debugLogger.LogException("Scenario Reader", message); throw new ApplicationException(message, e); } //Build reverse dictionary of commnds->stage //This lets us enforce moving through the commands in a prescribed order Dictionary <string, int> stages = new Dictionary <string, int>(); string[][] stageMembers = parser.StageMembers(); for (int level = 0; level < stageMembers.Length; level++) { for (int member = 0; member < stageMembers[level].Length; member++) { stages[stageMembers[level][member]] = level; } } int currentStage = 0; string scenarioName = ""; string description = ""; reader.Read(); // opens, gets to xml declaration reader.Read(); try { if ("Scenario" == reader.Name) // only Scenario can be top level { reader.Read(); // pass by "Scenario" while (!reader.EOF && !((XmlNodeType.EndElement == reader.NodeType) && ("Scenario" == reader.Name))) { //Coordinator.debugLogger.Writeline("."); switch (reader.NodeType) { case XmlNodeType.Element: Coordinator.debugLogger.Writeline("ScenarioToQueues", "ELEMENT " + reader.Name, "test"); if (stages.ContainsKey(reader.Name)) { if (stages[reader.Name] < currentStage) { throw new ApplicationException("Command " + reader.Name + " out of sequence."); } currentStage = stages[reader.Name]; //NB, if command is not found in stages it will be trapped in the switch's default } switch (reader.Name) { case "ScenarioName": scenarioName = parser.pGetString(); break; case "Description": description = parser.pGetString(); break; case "ClientSideAssetTransfer": ClientSideAssetTransferType assetTransfers = new ClientSideAssetTransferType(parser.pGetBoolean()); TimerQueueClass.SendBeforeStartup(assetTransfers); Coordinator.debugLogger.Writeline("ScenarioToQueues", " ClientSideAssetTransferType ", "test"); break; case "ClientSideStartingLabelVisible": ClientSideStartingLabelVisibleType labelsVisible = new ClientSideStartingLabelVisibleType(parser.pGetBoolean()); TimerQueueClass.SendBeforeStartup(labelsVisible); Coordinator.debugLogger.Writeline("ScenarioToQueues", " ClientSideStartingLabelVisibleType ", "test"); break; case "ClientSideRangeRingVisibility": ClientSideRangeRingVisibilityType rangeRingVisibility = new ClientSideRangeRingVisibilityType(parser.pGetString()); TimerQueueClass.SendBeforeStartup(rangeRingVisibility); Coordinator.debugLogger.Writeline("ScenarioToQueues", "ClientSideRangeRingVisibilityType", "test"); break; case "Playfield": // except for the optional name/description // Playfield must be first scenario item sent // enforced by schema string errorText = string.Empty; string imgLibPath = string.Empty; string mapFilePath = string.Empty; string hostname = Aptima.Asim.DDD.CommonComponents.ServerOptionsTools.ServerOptions.HostName; pPlayfieldType pDefine = parser.pGetPlayfield(); PlayfieldEventType playfield = new PlayfieldEventType(pDefine); playfield.ScenarioName = scenarioName; playfield.Description = description; if (playfield.IconLibrary.EndsWith(".dll")) { imgLibPath = String.Format(@"\\{0}\{1}", ServerOptions.DDDClientPath, playfield.IconLibrary); //icon library does include dll extension } else { imgLibPath = String.Format(@"\\{0}\{1}.dll", ServerOptions.DDDClientPath, playfield.IconLibrary); //icon library doesnt include dll extension } mapFilePath = String.Format(@"\\{0}\MapLib\{1}", ServerOptions.DDDClientPath, playfield.MapFileName); //map file includes file extension //check image library path if (!File.Exists(imgLibPath)) { if (System.Windows.Forms.MessageBox.Show(String.Format("The server was not able to locate the image library in {0}. There is a chance that clients connecting to this machine will have a similar issue locating this file. If you'd still like to run the simulation, click Yes. If you'd like to stop the server, click No.", imgLibPath), "File not found", System.Windows.Forms.MessageBoxButtons.YesNo, System.Windows.Forms.MessageBoxIcon.Information) == System.Windows.Forms.DialogResult.Yes) { //User wants to continue } else { //user wants to stop server throw new Exception("User Cancelled server process. Server was unable to locate the image library at " + imgLibPath); return; } } //check map file path if (!File.Exists(mapFilePath)) { if (System.Windows.Forms.MessageBox.Show(String.Format("The server was not able to locate the map file in {0}. There is a chance that clients connecting to this machine will have a similar issue locating this file. If you'd still like to run the simulation, click Yes. If you'd like to stop the server, click No.", mapFilePath), "File not found", System.Windows.Forms.MessageBoxButtons.YesNo, System.Windows.Forms.MessageBoxIcon.Information) == System.Windows.Forms.DialogResult.Yes) { //User wants to continue } else { //user wants to stop server throw new Exception("User Cancelled server process. Server was unable to locate the map file at " + mapFilePath); return; } } TimerQueueClass.SendBeforeStartup(playfield); Coordinator.debugLogger.Writeline("ScenarioToQueues", "Playfield", "test"); TimerQueueClass.SendBeforeStartup(new RandomSeedType()); break; case "LandRegion": pLandRegionType region = parser.pGetLandRegion(); RegionEventType regionEvent = new RegionEventType(region); TimerQueueClass.SendBeforeStartup(regionEvent); Coordinator.debugLogger.Writeline("ScenarioToQueues", " LandRegion " + regionEvent.UnitID, "test"); break; /* * case "ScoringRegion": * pScoringRegionType regionS = parser.pGetScoringRegion(); * RegionEventType regionEventS = new RegionEventType(regionS); * TimerQueueClass.SendBeforeStartup(regionEventS); * Coordinator.debugLogger.Writeline("ScenarioToQueues", " ScoringRegion " + regionEventS.UnitID, "test"); * break; */ case "ActiveRegion": pActiveRegionType regionA = parser.pGetActiveRegion(); RegionEventType regionEventA = new RegionEventType(regionA); if (!NameLists.activeRegionNames.New(regionA.ID, regionEventA)) { throw new ApplicationException("Duplicate active region name " + regionA.ID); } TimerQueueClass.SendBeforeStartup(regionEventA); Coordinator.debugLogger.Writeline("ScenarioToQueues", " ActiveRegion " + regionEventA.UnitID, "test"); break; case "Team": pTeamType team = parser.pGetTeam(); TeamType teamEvent = new TeamType(team); for (int i = 0; i < teamEvent.Count(); i++) { UnitFacts.AddEnemy(teamEvent.Name, teamEvent.GetEnemy(i)); } Coordinator.debugLogger.Writeline("ScenarioToQueues", " Team " + team.Name.ToString(), "test"); if (!NameLists.teamNames.New(team.Name, teamEvent)) { throw new ApplicationException("Duplicate team name " + team.Name); } TimerQueueClass.SendBeforeStartup(teamEvent); break; case "DecisionMaker": DecisionMakerType decisionMaker = new DecisionMakerType(parser.pGetDecisionMaker()); UnitFacts.AddDM(decisionMaker.Identifier, decisionMaker.Chroma, decisionMaker.Team); TimerQueueClass.SendBeforeStartup(decisionMaker); Coordinator.debugLogger.Writeline("ScenarioToQueues", "Decision Maker ", "test"); break; case "Network": NetworkType network = new NetworkType(parser.pGetNetwork()); NetworkTable.AddNetwork(network); TimerQueueClass.SendBeforeStartup(network); Coordinator.debugLogger.Writeline("ScenarioToQueues", "Network ", "test"); break; case "Sensor": //sensor follows Playfield pSensor sen = parser.pGetSensor(); // if Attribute is "all" there will be one cone; only extent is filled in from parser if (sen.Attribute == "All") { sen.Cones[0].Spread = 360; sen.Cones[0].Level = "Total"; } SensorTable.Add(sen.Name, new SensorType(sen.Attribute, sen.IsEngram, sen.TypeIfEngram, sen.Cones)); Coordinator.debugLogger.Writeline("ScenarioToQueues", " Sensor " + sen.Name.ToString(), "test"); break; /* case "TimeToRemove": * Defaults.DefaultTimeToRemove = parser.pGetInt(); * break; */ case "Classifications": ClassificationsType classifications = new ClassificationsType(parser.pGetClassifications()); TimerQueueClass.SendBeforeStartup(classifications); Coordinator.debugLogger.Writeline("ScenarioToQueues", " Classifications ", "test"); break; case "TimeToAttack": Defaults.DefaultTimeToAttack = parser.pGetInt() * 1000; break; case "Genus": pGenusType g = parser.pGetGenus(); if (!NameLists.speciesNames.New(g.Name, g)) { throw new ApplicationException("Duplicate use of genus name " + g.Name); } Genealogy.Add(g.Name); Coordinator.debugLogger.Writeline("ScenarioToQueues", "Genus " + g.Name, "test"); // StartupForUnits.Add(genus); break; case "Species": // Genus and species come after playfield pSpeciesType s = parser.pGetSpecies(); SpeciesType species = new SpeciesType(s); if (!NameLists.speciesNames.New(species.Name, species)) { throw new ApplicationException("Duplicate use of species name " + species.Name); } Genealogy.Add(species.Name, species.BasedOn); if (species.IsWeapon) { WeaponTable.Add(species.Name); } WorkStates.Clear(); WorkStates.Add(species.States); StatesForUnits.AddStatesOf(species.Name, WorkStates.CollapseStates(species.Name, species.BasedOn)); Coordinator.debugLogger.Writeline("ScenarioToQueues", "Species " + s.Name, "test"); // StartupForUnits.Add(species); break; case "Create_Event": //string newId; // Create_EventType platformCreate;//used for sub platforms pCreateType c = parser.pGetCreate(); Create_EventType createEvent = new Create_EventType(c); Genealogy.Add(createEvent.UnitID, createEvent.UnitBase); createEvent.Genus = Genealogy.GetGenus(createEvent.UnitID); UnitFacts.AddUnit(createEvent.UnitID, createEvent.Owner, createEvent.UnitBase); createEvent.Parameters = new ObjectDictionary(); SpeciesType speciesInfo = (SpeciesType)NameLists.speciesNames[createEvent.UnitBase]; foreach (KeyValuePair <string, StateBody> kvp in StatesForUnits.StateTable[createEvent.UnitBase]) { string stateName = kvp.Key; ExtendedStateBody extended = new ExtendedStateBody(kvp.Value); //end species dependent atts createEvent.Parameters.Add(stateName, (object)extended); // EngramDependants.Add(createEvent.UnitID, extended); } // TimerQueueClass.Add(1, createEvent); NameLists.unitNames.New(createEvent.UnitID, null); TimerQueueClass.SecondarySendBeforeStartup(createEvent); UnitFacts.CurrentUnitStates.Add(createEvent.UnitID, ""); Coordinator.debugLogger.Writeline("ScenarioToQueues", "createEvent for " + createEvent.UnitID, "test"); //for some reason this docs everyone at time 1. this seems to be the heart of the bug /* * for (int i = 0; i < createEvent.Subplatforms.Count;i++ ) * { * SubplatformDockType dockNotice = new SubplatformDockType(createEvent.Subplatforms[i], createEvent.UnitID); * dockNotice.Time = 1; * TimerQueueClass.SecondarySendBeforeStartup(dockNotice); * * } */ break; case "Reveal_Event": pRevealType r = parser.pGetReveal(); Reveal_EventType revealEvent = new Reveal_EventType(r); revealEvent.Genus = Genealogy.GetGenus(revealEvent.UnitID); if (r.Time > 1) { TimerQueueClass.Add(r.Time, revealEvent); } else { TimerQueueClass.SecondarySendBeforeStartup(revealEvent); } Coordinator.debugLogger.Writeline("ScenarioToQueues", "revealEvent for " + revealEvent.UnitID + " at time" + r.Time.ToString(), "test"); RevealDocked(r.UnitID, r.Time); break; case "Move_Event": pMoveType m = parser.pGetMove(); if (!UnitFacts.IsAUnit(m.UnitID)) { throw new ApplicationException("Cannot move non-exsitant unit " + m.UnitID); } Move_EventType moveEvent = new Move_EventType(m); TimerQueueClass.Add(moveEvent.Time, moveEvent); Coordinator.debugLogger.Writeline("ScenarioToQueues", " moveEvent for " + moveEvent.UnitID, "test"); break; case "Completion_Event": HappeningCompletionType completionType = new HappeningCompletionType(parser.pGetHappeningCompletion()); HappeningList.Add(completionType); break; case "Species_Completion_Event": pSpeciesCompletionType sct = parser.pGetSpeciesCompletion(); SpeciesCompletionType speciesCompletion = new SpeciesCompletionType(sct); SpeciesHappeningList.Add(speciesCompletion); break; case "Reiterate": ReiterateType reiterate = new ReiterateType(parser.pGetReiterate()); Move_EventType mQueued = (Move_EventType)(reiterate.ReiterateList[0]); Move_EventType mQCopy = (Move_EventType)(reiterate.ReiterateList[0]); mQueued.Range = reiterate.Range; mQueued.Time = reiterate.Time; TimerQueueClass.Add(mQueued.Time, mQueued); Coordinator.debugLogger.Writeline("ScenarioToQueues", " moveEvent from reiterate for " + mQueued.UnitID, "test"); reiterate.ReiterateList.RemoveAt(0); reiterate.ReiterateList.Add(mQCopy); HappeningCompletionType envelope = new HappeningCompletionType(reiterate); HappeningList.Add(envelope); break; case "StateChange_Event": StateChangeEvent change = new StateChangeEvent(parser.pGetStateChange()); if (!UnitFacts.IsAUnit(change.UnitID)) { throw new ApplicationException("State change event references unknown unit " + change.UnitID); } if (!StatesForUnits.UnitHasState(change.UnitID, change.NewState)) { throw new ApplicationException("State chage for " + change.UnitID + " refers to unknwon state " + change.NewState); } for (int i = 0; i < change.Except.Count; i++) { // if (!StatesForUnits.UnitHasState(Genealogy.GetBase(change.UnitID), change.Except[i])) throw new ApplicationException("State change for " + change.UnitID + " refers to unknown state " + change.Except); if (!StatesForUnits.UnitHasState(change.UnitID, change.Except[i])) { throw new ApplicationException("State change for " + change.UnitID + " refers to unknown state " + change.Except); } } for (int i = 0; i < change.From.Count; i++) { // if (!StatesForUnits.UnitHasState(Genealogy.GetBase(change.UnitID), change.From[i])) throw new ApplicationException("State change for " + change.UnitID + " refers to unknown state " + change.From); if (!StatesForUnits.UnitHasState(change.UnitID, change.From[i])) { throw new ApplicationException("State change for " + change.UnitID + " refers to unknown state " + change.From); } } TimerQueueClass.Add(change.Time, change); break; case "Transfer_Event": TransferEvent t = new TransferEvent(parser.pGetTransfer()); if (!UnitFacts.IsDM(t.From)) { throw new ApplicationException("Transfer event references unknown DM (from) " + t.From); } if (!UnitFacts.IsDM(t.To)) { throw new ApplicationException("Transfer event references unknown DM (to) " + t.To); } if (!UnitFacts.IsAUnit(t.UnitID)) { throw new ApplicationException("Transfer event references unknown unit " + t.UnitID); } TimerQueueClass.Add(t.Time, t); break; case "Launch_Event": LaunchEventType launch = new LaunchEventType(parser.pGetLaunch()); if (!UnitFacts.IsAUnit(launch.UnitID)) { throw new ApplicationException("Cannot launch from non-existent unit " + launch.UnitID); } TimerQueueClass.Add(launch.Time, launch); break; case "WeaponLaunch_Event": WeaponLaunchEventType weaponLaunch = new WeaponLaunchEventType(parser.pGetWeaponLaunch()); if (!UnitFacts.IsAUnit(weaponLaunch.UnitID)) { throw new ApplicationException("Cannot launch from non-existent unit " + weaponLaunch.UnitID); } TimerQueueClass.Add(weaponLaunch.Time, weaponLaunch); break; case "DefineEngram": pDefineEngramType defineEngram = parser.pGetDefineEngram(); Engrams.Create(defineEngram.Name, defineEngram.EngramValue, defineEngram.Type); TimerQueueClass.SendBeforeStartup(new EngramSettingType(defineEngram.Name, "", defineEngram.EngramValue, defineEngram.Type)); break; case "ChangeEngram": ChangeEngramType changeEngram = new ChangeEngramType(parser.pGetChangeEngram()); if (!Engrams.ValidUpdate(changeEngram.Name, changeEngram.EngramValue)) { throw new ApplicationException("Illegal value " + changeEngram.EngramValue + " for engram " + changeEngram.Name); } TimerQueueClass.Add(changeEngram.Time, changeEngram); // Engrams.SendUpdate(changeEngram.Name); break; case "RemoveEngram": RemoveEngramEvent removeEngram = new RemoveEngramEvent(parser.pGetRemoveEngram()); TimerQueueClass.Add(removeEngram.Time, removeEngram); break; //These chat commands are those from the scenario only; // thos from client are handled immediately case "OpenChatRoom": OpenChatRoomType openChatRoom = new OpenChatRoomType(parser.pGetOpenChatRoom()); TimerQueueClass.Add(openChatRoom.Time, openChatRoom); break; case "CloseChatRoom": CloseChatRoomType closeChatRoom = new CloseChatRoomType(parser.pGetCloseChatRoom()); TimerQueueClass.Add(closeChatRoom.Time, closeChatRoom); break; /* Not implemented yet * case "DropChatters": * DropChattersType dropChatters = new DropChattersType(parser.pGetDropChatters()); * TimerQueueClass.Add(dropChatters.Time, dropChatters); * break; * case "AddChatters": * AddChattersType addChatters = new AddChattersType(parser.pGetAddChatters()); * TimerQueueClass.Add(addChatters.Time, addChatters); * break; * */ case "OpenWhiteboardRoom": OpenWhiteboardRoomType openWhiteboardRoom = new OpenWhiteboardRoomType(parser.pGetOpenWhiteboardRoom()); TimerQueueClass.Add(openWhiteboardRoom.Time, openWhiteboardRoom); break; case "OpenVoiceChannel": OpenVoiceChannelType openVoiceChannel = new OpenVoiceChannelType(parser.pGetOpenVoiceChannel()); TimerQueueClass.Add(openVoiceChannel.Time, openVoiceChannel); break; case "CloseVoiceChannel": CloseVoiceChannelType closeVoiceChannel = new CloseVoiceChannelType(parser.pGetCloseVoiceChannel()); TimerQueueClass.Add(closeVoiceChannel.Time, closeVoiceChannel); break; /* * //Removed before 4.1 * case "GrantVoiceChannelAccess": * GrantVoiceAccessType grantVoiceChannelAccess = new GrantVoiceAccessType(parser.pGetGrantVoiceChannelAccess()); * TimerQueueClass.Add(grantVoiceChannelAccess.Time, grantVoiceChannelAccess); * break; * case "RemoveVoiceChannelAccess": * RemoveVoiceAccessType removeVoiceChannelAccess = new RemoveVoiceAccessType(parser.pGetRemoveVoiceChannelAccess()); * TimerQueueClass.Add(removeVoiceChannelAccess.Time, removeVoiceChannelAccess); * break; */ case "Rule": pScoringRuleType srt = parser.pGetScoringRule(); ScoringRuleType scoreRule = new ScoringRuleType(srt); if (!NameLists.ruleNames.New(srt.Name, scoreRule)) { throw new ApplicationException("Duplicate scoring rule name " + srt.Name); } ScoringRules.Add(scoreRule); break; case "Score": pScoreType pst = parser.pGetScore(); ScoreType st = new ScoreType(pst); if (!NameLists.scoreNames.New(pst.Name, st)) { throw new ApplicationException("Duplicate score name " + pst.Name); } Scores.Register(st); break; case "FlushEvents": FlushEvents flush = new FlushEvents(parser.pGetFlushEventsType()); TimerQueueClass.Add(flush.Time, flush); break; case "SendChatMessage": SendChatMessageType sendChat = new SendChatMessageType(parser.pGetSendChatMessage()); if (!UnitFacts.IsDM(sendChat.Sender) && !("EXP" == sendChat.Sender)) { throw new ApplicationException("In SendChatMessage, '" + sendChat.Sender + "' is not a valid DM name."); } // Note: Can't validate chat room name at parse time; it might not have been created yet TimerQueueClass.Add(sendChat.Time, sendChat); break; case "Apply": ApplyType apply = new ApplyType(parser.pGetApply()); //what does this do? TimerQueueClass.Add(apply.Time, apply); break; case "SendVoiceMessage": SendVoiceMessageType playVoiceMessage = new SendVoiceMessageType(parser.pGetSendVoiceMessage()); //what does this do? TimerQueueClass.Add(playVoiceMessage.Time, playVoiceMessage); break; case "SendVoiceMessageToUser": SendVoiceMessageToUserType playVoiceMessageToUser = new SendVoiceMessageToUserType(parser.pGetSendVoiceMessageToUser()); //what does this do? TimerQueueClass.Add(playVoiceMessageToUser.Time, playVoiceMessageToUser); break; default: throw new ApplicationException("ScenarioToQueues: Unknown Scenario Element is *" + reader.Name); } //switch break; default: Coordinator.debugLogger.Writeline("ScenarioToQueues", "Unhandled or out-of-sequence XML tag " + reader.Value, "test"); reader.Read(); break; } //switch } //while // All of scenario processed. Now do last things //verify that the Chat, Whiteboard, and Voice lists contain only DMs and make them symmetric. List <string> allDMs = UnitFacts.GetAllDms(); for (int i = 0; i < allDMs.Count; i++) { DecisionMakerType thisDM = DecisionMakerType.GetDM(allDMs[i]); for (int j = 0; j < thisDM.ChatPartners.Count; j++) { if (!allDMs.Contains(thisDM.ChatPartners[j])) { throw new ApplicationException("Unknown decision maker name '" + thisDM.ChatPartners[j] + "' found as chat partner of '" + allDMs[i] + "'"); } DecisionMakerType partnerDM = DecisionMakerType.GetDM(thisDM.ChatPartners[j]); if (!partnerDM.ChatPartners.Contains(allDMs[i])) { partnerDM.MayChatWith(allDMs[i]); } } for (int j = 0; j < thisDM.WhiteboardPartners.Count; j++) { if (!allDMs.Contains(thisDM.WhiteboardPartners[j])) { throw new ApplicationException("Unknown decision maker name '" + thisDM.WhiteboardPartners[j] + "' found as whiteboard partner of '" + allDMs[i] + "'"); } DecisionMakerType partnerDM = DecisionMakerType.GetDM(thisDM.WhiteboardPartners[j]); if (!partnerDM.WhiteboardPartners.Contains(allDMs[i])) { partnerDM.MayWhiteboardWith(allDMs[i]); } } for (int j = 0; j < thisDM.VoicePartners.Count; j++) { if (!allDMs.Contains(thisDM.ChatPartners[j])) { throw new ApplicationException("Unknown decision maker name '" + thisDM.VoicePartners[j] + "' found as voice partner of '" + allDMs[i] + "'"); } DecisionMakerType partnerDM = DecisionMakerType.GetDM(thisDM.VoicePartners[j]); if (!partnerDM.VoicePartners.Contains(allDMs[i])) { partnerDM.MaySpeakWith(allDMs[i]); } } } // Add networks for DMs that have none List <string> dmList = UnitFacts.GetAllDms(); for (int nextDM = 0; nextDM < dmList.Count; nextDM++) { if (!NetworkTable.IsNetworkMember(dmList[nextDM])) { string netName = "Network-For-" + dmList[nextDM]; NetworkTable.AddMember(netName, dmList[nextDM]); NetworkType newNet = new NetworkType(netName); newNet.Add(dmList[nextDM]); TimerQueueClass.SendBeforeStartup(newNet); Coordinator.debugLogger.Writeline("ScenarioToQueues", "Network ", "test"); } } //AD: Don't create default chat room, user should have control of this // Create the detault Broadcast chatroom //OpenChatRoomType broadcastChatRoom = new OpenChatRoomType(1, "", "Broadcast", dmList); //TimerQueueClass.SendBeforeStartup(broadcastChatRoom); }//if } catch (System.Exception e) { if (e.Message.StartsWith("User Cancelled")) {//This means a missing map or icon library, and the user wanted to stop the server. Do not write to error log, just stop the server. throw e; } string message = "Failure in Parsing Control for next tag=" + reader.Name + " : " + e.Message; Coordinator.debugLogger.LogException("ScenarioReader", message); throw new ApplicationException(message, e); } finally { reader.Close(); fs.Close(); // Coordinator.debugLogger.Writeline("ScenarioToQueues", "Done", "general"); } }//
public Task EventHandle(TransferEvent evt, EventMeta eventBase) { // Update database here return(Task.CompletedTask); }
private void OnTransfer2(TransferEvent e) { int mods = ServerInput.ToServerModifiers(e.KeyModifiers); SendMessage("xfer2", e.Delta, mods); }