void OnControllerStatusEvent(ImportEvent evnt)
{
Log.DebugFormat("Received controller event: {0}", evnt);
switch (evnt)
{
case ImportEvent.SourceChanged:
HideScanSpinner();
ResetPreview();
import_button.Sensitive = true;
break;
case ImportEvent.PhotoScanStarted:
ShowScanSpinner();
break;
case ImportEvent.PhotoScanFinished:
HideScanSpinner();
break;
case ImportEvent.ImportStarted:
ShowImportProgress();
break;
case ImportEvent.ImportFinished:
ShowFailuresIfNeeded(Controller.FailedImports);
Controller = null;
Destroy();
break;
case ImportEvent.ImportError:
//FIXME
break;
}
}
public void StartImportProcess(CancellationToken cancellationToken = default(CancellationToken),
string clientid = "", bool ignoreError = false, string path = "")
{
Tz.Net.DataSchema.ImportExport iex = new Net.DataSchema.ImportExport(clientid);
ImportEvent impe = iex.ImportScheduleNow(ignoreError, path);
impe.ImportNow();
}
void FireEvent(ImportEvent evnt)
{
ThreadAssist.ProxyToMain(() => {
var h = StatusEvent;
if (h != null)
{
h(evnt);
}
});
}
protected async Task Import(ImportEvent <TModel> evt)
{
string fileName, filterName;
string [] extensions;
TModel template = evt.Object;
Log.Debug("Importing dashboard");
filterName = Catalog.GetString(FilterText);
extensions = new [] { "*" + Extension };
/* Show a file chooser dialog to select the file to import */
fileName = App.Current.Dialogs.OpenFile(ImportText, null, App.Current.HomeDir,
filterName, extensions);
if (fileName == null)
{
return;
}
try {
TModel newTemplate = Provider.LoadFile(fileName);
if (newTemplate != null)
{
bool abort = false;
while (Provider.Exists(newTemplate.Name) && !abort)
{
string name = await App.Current.Dialogs.QueryMessage(NameText,
Catalog.GetString("Name conflict"), newTemplate.Name + "#");
if (name == null)
{
abort = true;
}
else
{
newTemplate.Name = name;
}
}
if (!abort)
{
Provider.Save(newTemplate);
ViewModel.Select(newTemplate);
evt.ReturnValue = true;
}
}
} catch (Exception ex) {
App.Current.Dialogs.ErrorMessage(Catalog.GetString("Error importing file:") +
"\n" + ex.Message);
Log.Exception(ex);
}
}
public async Task ImportTeam_FourStored_CanAdd(string version)
{
// Arrange
await SetWibuManager(version, 4, true);
// Action
var t1 = new ImportEvent <Team> ();
await App.Current.EventsBroker.Publish(t1);
// Assert
Assert.IsTrue(t1.ReturnValue);
}
public async Task ImportDashboard_TwoStored_CanAdd(string version)
{
// Arrange
await SetWibuManager(version, 2, true);
// Action
var d1 = new ImportEvent <Dashboard> ();
await App.Current.EventsBroker.Publish(d1);
// Assert
Assert.IsTrue(d1.ReturnValue);
}
public void ImportEvent(ImportEvent command)
{
try
{
var succesEvent = new EventImported();
var bridgeEvent = Mapper.Map <Event>(command);
var pairsDictionary = new Dictionary <int, Pair>();
command.Pairs.Each(pairMetadata =>
{
var pair = Mapper.Map <Pair>(pairMetadata);
pairsDictionary.Add(pairMetadata.PairId, pair);
bridgeEvent.Pairs.Add(pair);
});
command.Deals.Each(dealMetadata =>
{
var deal = Mapper.Map <Deal>(dealMetadata);
dealMetadata.DealResults.Each(duplicateDealMetadata =>
{
var duplicateDeal = Mapper.Map <DuplicateDeal>(duplicateDealMetadata);
duplicateDeal.EWPair = pairsDictionary[duplicateDealMetadata.EWPairIndex];
duplicateDeal.NSPair = pairsDictionary[duplicateDealMetadata.NSPairIndex];
deal.DuplicateDeals.Add(duplicateDeal);
});
bridgeEvent.Deals.Add(deal);
});
bridgeEvent.IsImported = true;
_context.Events.Add(bridgeEvent);
_context.SaveChanges();
DomainEventExtensions.PrepareSuccessfulEvent(succesEvent, command);
succesEvent.EventId = bridgeEvent.Id;
succesEvent.DealIds = bridgeEvent.Deals.Select(c => c.Id).ToArray();
succesEvent.PairIds = bridgeEvent.Pairs.Select(c => c.Id).ToArray();
DomainEvents.Add(succesEvent);
}
catch (Exception ex)
{
var errorEvent = Mapper.Map <ImportEventAttempted>(command);
DomainEventExtensions.PrepareAttemptedEvent(errorEvent, ex, command);
DomainEvents.Add(errorEvent);
}
}
public IAsyncResult BeginSendEvent(string userName, string password, ImportEvent submitEvent, AsyncCallback callback, object asyncState)
{
return(Channel.BeginSendEvent(userName, password, submitEvent, callback, asyncState));
}
public static void ImportEventCaller(ImportObject importObject)
{
ImportEvent?.Invoke(importObject, null);
}
void FireEvent(ImportEvent evnt)
{
ThreadAssist.ProxyToMain (() => {
var h = StatusEvent;
if (h != null)
h (evnt);
});
}
void FireEvent(ImportEvent evnt)
{
ThreadAssist.ProxyToMain(() => {
StatusEvent?.Invoke(evnt);
});
}
/// <summary>
/// 初始化一个<see cref="ImportExcelProcess{T}"/>类型的实例
/// </summary>
/// <param name="config">导入配置</param>
/// <param name="func">导入方法</param>
public ImportExcelProcess(ImportConfig <T> config, ImportEvent <T> func)
{
this.Config = config;
this.ImportFunc = func;
}
private async Task <ImportEvent> ProcessPbnFile(string filePath)
{
var command = new ImportEvent();
var currentDeal = new DealMetadata();
var currentState = ParseState.ReadingDeal;
var identifiedPairs = 0;
var identifiedDealResults = 0;
var totalScoreTableHeaders = new Dictionary <string, int>();
var scoreTableHeaders = new Dictionary <string, int>();
using (var reader = new StreamReader(filePath))
{
string line;
while ((line = await reader.ReadLineAsync()) != null)
{
if (line.StartsWith("% <META name=PairCount"))
{
command.NoOfPairs = Int32.Parse(ParsePBNHelpers.ExtractValue(line)); continue;
}
if (line.StartsWith("% <META name=BoardCount"))
{
command.NoOfBoards = Int32.Parse(ParsePBNHelpers.ExtractValue(line)); continue;
}
if (line.StartsWith("% <META name=RoundCount"))
{
command.NoOfRounds = Int32.Parse(ParsePBNHelpers.ExtractValue(line)); continue;
}
if (line.StartsWith("[Board"))
{
var deal = new DealMetadata {
Index = Int32.Parse(ParsePBNHelpers.ExtractValue(line))
};
command.Deals.Add(deal);
currentDeal = deal;
currentState = ParseState.ReadingDeal;
identifiedDealResults = 0;
continue;
}
if (line.StartsWith("[Dealer "))
{
var dealer = ParsePBNHelpers.ExtractValue(line);
currentDeal.Dealer = ParsePBNHelpers.GetPlayerIdFromString(dealer);
continue;
}
if (line.StartsWith("[Deal "))
{
currentDeal.PBNRepresentation = ParsePBNHelpers.ExtractValue(line);
currentDeal.HandViewerInput = ParsePBNHelpers.ConvertPBNToHandViewerInput(currentDeal.PBNRepresentation, currentDeal.Index, (SysVulnerabilityEnum)currentDeal.SysVulnerabilityId);
CalculateMakeableContracts(currentDeal);
CalculateOptimalContract(currentDeal);
continue;
}
if (line.StartsWith("[Vulnerable"))
{
currentDeal.SysVulnerabilityId = (int)Enum.Parse(typeof(SysVulnerabilityEnum), ParsePBNHelpers.ExtractValue(line), true);
continue;
}
if (currentState == ParseState.ReadingTotalScoreTable && identifiedPairs < command.NoOfPairs)
{
command.Pairs.Add(ExtractPairMetadata(line, totalScoreTableHeaders));
identifiedPairs++;
continue;
}
if (currentState == ParseState.ReadingDealScoreTable && identifiedDealResults < command.NoOfRounds)
{
var duplicateDeal = ExtractDuplicateDealMetadata(line, currentDeal, scoreTableHeaders);
if (duplicateDeal != null)
{
currentDeal.DealResults.Add(duplicateDeal);
}
identifiedDealResults++;
continue;
}
if (line.StartsWith("[TotalScoreTable"))
{
totalScoreTableHeaders = ParsePBNHelpers.ParseTableHeader(ParsePBNHelpers.ExtractValue(line));
currentState = ParseState.ReadingTotalScoreTable; continue;
}
if (line.StartsWith("[ScoreTable"))
{
scoreTableHeaders = ParsePBNHelpers.ParseTableHeader(ParsePBNHelpers.ExtractValue(line));
currentState = ParseState.ReadingDealScoreTable;
}
}
}
return(command);
}
public Task <bool> SendEvent(ImportEvent submitEvent)
{
return(Task.Factory.FromAsync(client.BeginSendEvent(username, password, submitEvent, null, null),
ar => client.EndSendEvent(ar)));
}
public IAsyncResult BeginSendEvent(string userName, string password, ImportEvent submitEvent, AsyncCallback callback, object asyncState)
{
var _args = new object[] { userName, password, submitEvent };
return(base.BeginInvoke("SendEvent", _args, callback, asyncState));
}
public void When(ImportEvent command)
{
Apply(a => a.ImportEvent(command));
}
public void AddImportEvent(ImportEvent importEvent)
{
_events.Add(importEvent);
_context.SaveChanges();
}
void OnControllerStatusEvent (ImportEvent evnt)
{
Log.DebugFormat ("Received controller event: {0}", evnt);
switch (evnt) {
case ImportEvent.SourceChanged:
HideScanSpinner ();
ResetPreview ();
import_button.Sensitive = true;
break;
case ImportEvent.PhotoScanStarted:
ShowScanSpinner ();
break;
case ImportEvent.PhotoScanFinished:
HideScanSpinner ();
break;
case ImportEvent.ImportStarted:
ShowImportProgress ();
break;
case ImportEvent.ImportFinished:
ShowFailuresIfNeeded (Controller.FailedImports);
Controller = null;
Destroy ();
break;
case ImportEvent.ImportError:
//FIXME
break;
}
}
protected virtual Task HandleImport(ImportEvent <TModel> evt)
{
evt.ReturnValue = false;
return(AsyncHelpers.Return());
}
