private void DeleteTournament(object obj)
{
if (!(obj is TournamentReportRecord tournament))
{
return;
}
var notification = new PopupBaseNotification()
{
Title = CommonResourceManager.Instance.GetResourceString("Notifications_DeleteTournament_Title"),
CancelButtonCaption = CommonResourceManager.Instance.GetResourceString("Notifications_DeleteHand_Cancel"),
ConfirmButtonCaption = CommonResourceManager.Instance.GetResourceString("Notifications_DeleteHand_Yes"),
Content = CommonResourceManager.Instance.GetResourceString("Notifications_DeleteTournament_Content"),
IsDisplayH1Text = true
};
PopupRequest.Raise(notification,
confirmation =>
{
if (confirmation.Confirmed)
{
var dataService = ServiceLocator.Current.GetInstance <IDataService>();
dataService.DeleteTournament(tournament.TournamentId, tournament.PokerSiteId);
if (ReportSelectedItem != null)
{
ReportCollection.Remove(ReportSelectedItem);
}
eventAggregator.GetEvent <UpdateViewRequestedEvent>().Publish(new UpdateViewRequestedEventArgs {
IsUpdateReportRequested = true
});
}
});
}
public Grammar()
{
Options = RuntimeOptions.Default;
Productions = new ProductionCollection(this);
Symbols = new SymbolCollection(this);
Conditions = new ConditionCollection(this);
Matchers = new MatcherCollection(this);
Mergers = new MergerCollection(this);
Contexts = new ForeignContextCollection(this);
Reports = new ReportCollection();
GlobalContextProvider = new ForeignContextProvider { Owner = this.Contexts };
Joint = new Joint();
for (int i = PredefinedTokens.Count; i != 0; --i)
{
Symbols.Add(null); // stub
}
Symbols[PredefinedTokens.Propagated] = new Symbol("#");
Symbols[PredefinedTokens.Epsilon] = new Symbol("$eps");
Symbols[PredefinedTokens.AugmentedStart] = new Symbol("$start");
Symbols[PredefinedTokens.Eoi] = new Symbol("$")
{
Categories = SymbolCategory.DoNotInsert
| SymbolCategory.DoNotDelete
};
Symbols[PredefinedTokens.Error] = new Symbol("$error");
AugmentedProduction = Productions.Define((Symbol)Symbols[PredefinedTokens.AugmentedStart], new Symbol[] { null });
}
/// <summary>
/// Определение url с максималоьным числом ссылок
/// </summary>
private async Task SelectMaxReferenceResult()
{
UrlReportViewModel maxReferenceUrl = await Task.Run(() =>
{
List <UrlReportViewModel> urls = ReportCollection.ToList();
return(urls.FirstOrDefault(x => x.IsMaxReference));
});
if (maxReferenceUrl != null)
{
maxReferenceUrl.IsMaxReference = false;
}
maxReferenceUrl = await Task.Run(() =>
{
List <UrlReportViewModel> urlsWithValue = ReportCollection.ToList().Where(x => x.ReferenceCount.HasValue).ToList();
if (!urlsWithValue.Any())
{
return(null);
}
return(urlsWithValue.Aggregate(urlsWithValue.First(),
(curr, next) => next.ReferenceCount > curr.ReferenceCount ? next : curr));
});
if (maxReferenceUrl != null)
{
maxReferenceUrl.IsMaxReference = true;
}
}
public ReportCollection FetchAll()
{
ReportCollection coll = new ReportCollection();
Query qry = new Query(Report.Schema);
coll.LoadAndCloseReader(qry.ExecuteReader());
return coll;
}
private void ReportAlarm(object CommandParameter)
{
if (SelectedTask != null)
{
ListBoxEntry delay = CommandParameter as ListBoxEntry;
//si la task n'existe pas déjà, on l'ajoute
if (ReportCollection == null)
{
ReportCollection = new ObservableCollection <Report>();
}
if (!ReportCollection.Any(i => i.TaskID == SelectedTask.ID))
{
var _report = new Report
{
TaskID = SelectedTask.ID,
DateModified = DateTime.Now,
AlarmDiseable = false
};
ReportCollection.Add(_report);
}
var item = ReportCollection.FirstOrDefault(i => i.TaskID == SelectedTask.ID);
if (item != null)
{
item.ExpirationDate = SelectedTask.datStart.AddMinutes(-SelectedTask.MinuteRemind + delay.MinutesData);
}
}
}
public void LoadTaches()
{
#if DEBUG
//data fake
//ReportCollection.Add(new Report { TaskID = 1 });
//ReportCollection.Add( new Report { TaskID = 24 });
#endif
//L'utilisateur s'est-il identifier ?
var IDuser = Properties.Settings.Default.IDuser;
var ListTaches = Requetes.GetListTaches(IDuser);
//retire de la liste des tâches
if (ReportCollection != null && ListTaches != null)
{
var result = ListTaches.ToList();
result.RemoveAll(x => ReportCollection.Any(d => d.TaskID == x.ID));
//var result = ListTaches.Where(x => ReportCollection.Any(d => d.TaskID != x.ID));
TacheCollection = new ObservableCollection <Tache>(result);
}
else
{
TacheCollection = new ObservableCollection <Tache>(ListTaches);
}
OnPropertyChanged("TacheCollection");
}
public Grammar()
{
Options = RuntimeOptions.Default;
Productions = new ProductionCollection(this);
Symbols = new SymbolCollection(this);
Conditions = new ConditionCollection(this);
Matchers = new MatcherCollection(this);
Mergers = new MergerCollection(this);
Contexts = new ForeignContextCollection(this);
Reports = new ReportCollection();
GlobalContextProvider = new ForeignContextProvider {
Owner = this.Contexts
};
Joint = new Joint();
for (int i = PredefinedTokens.Count; i != 0; --i)
{
Symbols.Add(null); // stub
}
Symbols[PredefinedTokens.Propagated] = new Symbol("#");
Symbols[PredefinedTokens.Epsilon] = new Symbol("$eps");
Symbols[PredefinedTokens.AugmentedStart] = new Symbol("$start");
Symbols[PredefinedTokens.Eoi] = new Symbol("$")
{
Categories = SymbolCategory.DoNotInsert
| SymbolCategory.DoNotDelete
};
Symbols[PredefinedTokens.Error] = new Symbol("$error");
AugmentedProduction = Productions.Define((Symbol)Symbols[PredefinedTokens.AugmentedStart], new Symbol[] { null });
}
private void SetDefaultSelection()
{
var report = ReportCollection.FirstOrDefault();
if (report == null)
{
return;
}
ReportSelectedItem = report;
}
public void Merge(ReportCollection reports, bool clearCodeCoverage)
{
if (clearCodeCoverage)
{
Model.Clear();
}
foreach (Report report in reports)
{
Model.Merge(report);
}
OnModelChanged();
}
// GET: ReportCollections/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ReportCollection reportCollection = db.ReportCollection.Find(id);
if (reportCollection == null)
{
return(HttpNotFound());
}
return(View(reportCollection));
}
/// <summary>
/// Обработка нажатия кнопки "НАЧАТЬ"
/// </summary>
/// <param name="parameter"></param>
/// <returns></returns>
private async Task StartProcessingCommandHandler(object parameter)
{
ReportCollection.ToList().ForEach(async x => await x.CancelRequest());
ReportCollection.Clear();
IEnumerable <UrlReportViewModel> urls = await mUrlReportBuilder.GetUrlReportsAsync(UrlFilePath, mUrlRequestService, mUrlParseService, SelectMaxReferenceResult);
List <UrlReportViewModel> urlList = urls as List <UrlReportViewModel> ?? urls.ToList();
urlList.ForEach(async x =>
{
ReportCollection.Add(x);
await x.RequestUrl();
});
}
internal ReportCollection CreateReportCollection()
{
if (!string.IsNullOrEmpty(InSettingsFilePath))
{
return(ReportCollection.LoadFromSettingsFile(InSettingsFilePath));
}
else if (!string.IsNullOrEmpty(Directory))
{
return(ReportCollection.ScanDirectory(Directory, FileSearchPattern));
}
else
{
throw new ArgumentException("Neither reports settings file or directory were specified.");
}
}
public static void DisplayWorkspaceContents()
{
string jsonWorkspaces = ExecuteGetRequest(ProgramConstants.restUrlWorkspaces);
WorkspaceCollection workspaces = JsonConvert.DeserializeObject <WorkspaceCollection>(jsonWorkspaces);
Console.WriteLine("Group Workspaces:");
Console.WriteLine("-----------------");
foreach (Workspace workspace in workspaces.value)
{
Console.WriteLine(" - " + workspace.name + "(" + workspace.id + ")");
}
Console.WriteLine();
Console.WriteLine("Now examining content in your personal workspace...");
Console.WriteLine();
string jsonDatasets = ExecuteGetRequest(ProgramConstants.restUrlDatasets);
DatasetCollection datasets = JsonConvert.DeserializeObject <DatasetCollection>(jsonDatasets);
Console.WriteLine("Datasets:");
Console.WriteLine("---------");
foreach (var ds in datasets.value)
{
Console.WriteLine(" - " + ds.name + "(" + ds.id + ")");
}
Console.WriteLine();
string jsonReports = ExecuteGetRequest(ProgramConstants.restUrlReports);
ReportCollection reports = JsonConvert.DeserializeObject <ReportCollection>(jsonReports);
Console.WriteLine("Reports:");
Console.WriteLine("---------");
foreach (var report in reports.value)
{
Console.WriteLine(" - " + report.name + ": " + report.embedUrl);
}
Console.WriteLine();
string jsonImports = ExecuteGetRequest(ProgramConstants.restUrlImports);
ImportCollection imports = JsonConvert.DeserializeObject <ImportCollection>(jsonImports);
Console.WriteLine("Imports:");
Console.WriteLine("---------");
foreach (var import in imports.value)
{
Console.WriteLine(" - " + import.name + ": " + import.source);
}
Console.WriteLine();
}
protected override Mat OnUpdate()
{
Mat mat = cap.RetrieveMat();
if (DrawGrid)
{
DrawGridFrame(mat);
}
ReportCollection reps = Recognizers.Recognize(mat);
DrawPoints(mat, reps);
reps.Dispose();
return(mat);
}
private async Task LoadReports()
{
IsReportLoading = true;
var reports = await userService.GetUserReports();
ReportCollection.Clear();
foreach (var report in reports)
{
ReportCollection.Add(new ReportElement()
{
Report = report
});
}
IsReportLoading = false;
}
public StatesDB(StarCollection stars, WormholeCollection wormholes, PlanetCollection planets,
ColonyCollection Colonies, StellarisCollection stellarises,
DevelopmentProgressCollection developmentAdvances, ResearchProgressCollection researchAdvances,
TreatyCollection treaties, ReportCollection reports, DesignCollection designs,
FleetCollection fleets, ColonizationCollection colonizations)
{
this.Colonies = Colonies;
this.Planets = planets;
this.Stars = stars;
this.Stellarises = stellarises;
this.Wormholes = wormholes;
this.DevelopmentAdvances = developmentAdvances;
this.ResearchAdvances = researchAdvances;
this.Reports = reports;
this.Designs = designs;
this.Fleets = fleets;
this.ColonizationProjects = colonizations;
this.Treaties = treaties;
}
/// <summary>
/// Initializes a new instance of the MainViewModel class.
/// </summary>
public MainViewModel()
{
AddReportsCommand = new RelayCommand(ExecuteAddReportsCommand);
RemoveCommand = new RelayCommand(ExecuteRemoveCommand);
RemoveAllCommand = new RelayCommand(ExecuteRemoveAllCommand);
SetLocationCommand = new RelayCommand(ExecuteSetLocationCommand);
OpenReportCommand = new RelayCommand(ExecuteOpenReportCommand);
SaveCommand = new RelayCommand(ExecuteSaveCommand);
SelectItemsCommand = new RelayCommand <CrlsReportDocument>(ExecuteSelectItemsCommand);
Reports = new ReportCollection();
BindingOperations.EnableCollectionSynchronization(Reports, _reportsLock);
ReportConnectionInfo = new ReportConnectionInfo(
Settings.Default.Server,
Settings.Default.Database,
Settings.Default.Username,
Settings.Default.Password,
false);
}
internal void UpdateReport(object obj = null)
{
App.Current.Dispatcher.Invoke(() =>
{
if (ReportSelectedItemStat == EnumReports.None)
{
SetDefaultItemStat(IsShowTournamentData);
}
else
{
RaisePropertyChanged(nameof(ReportSelectedItemStat));
}
});
if (ReportCollection.Any())
{
ReportSelectedItem = ReportCollection.FirstOrDefault();
}
}
void DrawPoints(Mat Mat, ReportCollection Reports)
{
int w = Mat.Width - GridMargin.Left - GridMargin.Right;
int h = Mat.Height - GridMargin.Top - GridMargin.Bottom;
float winterval = (float)w / (HorizontalPoints + 1);
float hinterval = (float)h / (VerticalPoints + 1);
const int Range = 7;
Reports.CornerReport corner = Reports.Select <Reports.CornerReport>();
for (int i = 1; HorizontalPoints >= i; i++)
{
for (int j = 1; VerticalPoints >= j; j++)
{
float xpos = GridMargin.Left + (winterval * i);
float ypos = GridMargin.Top + (hinterval * j);
Scalar Color = Scalar.White;
if (InRange(xpos - Range, xpos + Range, MouseLocation.X, true) &&
InRange(ypos - Range, ypos + Range, MouseLocation.Y, true))
{
Color = Scalar.Blue;
}
else
{
foreach (Point2f p in corner.Corners)
{
if (InRange(xpos - Range, xpos + Range, p.X, true) &&
InRange(ypos - Range, ypos + Range, p.Y, true))
{
Color = Scalar.Red;
}
}
}
Mat.Circle(new Point(xpos, ypos), 3, Color, PointThickness, LineTypes.Filled);
}
}
}
public static async Task <ReportsViewModel> GetReports(string reportId)
{
string jsonResult = await ExecuteGetRequest(restUrlReports);
ReportCollection reports = JsonConvert.DeserializeObject <ReportCollection>(jsonResult);
string accessToken = await TokenManagerService.GetPowerBiAccessToken();
ReportsViewModel reportsViewModel = new ReportsViewModel {
UserIsAuthenticated = true,
Reports = reports.value,
CurrentReport = null,
AccessToken = accessToken
};
if (!string.IsNullOrEmpty(reportId))
{
reportsViewModel.CurrentReport = reports.value.Find(report => report.id.Equals(reportId));
}
return(reportsViewModel);
}
private void DeleteTache()
{
if (SelectedTask != null)
{
if (ReportCollection == null)
{
ReportCollection = new ObservableCollection <Report>();
}
//si la task n'existe pas déjà, on l'ajoute
if (!ReportCollection.Any(i => i.TaskID == SelectedTask.ID))
{
var _report = new Report
{
TaskID = SelectedTask.ID,
AlarmDiseable = true
};
ReportCollection.Add(_report);
}
TacheCollection.Remove(SelectedTask);
}
}
// GET: Reports/SingleTestReport/5
public ActionResult SingleTestReport(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
try
{
// Entity Framework can't call methods on join and LINQ syntax
// Convert the Session UserID to a String
// Create a List with SingleTestReportModel objects to be sent to the view
ReportCollection rc = db.ReportCollection.Find(id);
// Return the list to the View
return(View(rc));
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
return(View());
}
}
public void SetUp()
{
state = new MachineState(new RegisterCollection());
reportItems = new ReportCollection();
var buffer = new AbstractBuffer(AbstractValue.GetNewBuffer(0x200));
var pointer = new AbstractValue(buffer);
state.Registers[RegisterName.ESP] = pointer;
state = state.DoOperation(RegisterName.EBP, OperatorEffect.Assignment, RegisterName.ESP);
}
private static Tuple <StatesDB, Player[], Player> loadSaveData(IkonComposite saveData, ObjectDeindexer deindexer, StaticsDB statics)
{
var stateData = saveData[MainGame.StatesKey].To <IkonComposite>();
var ordersData = saveData[MainGame.OrdersKey].To <IkonArray>();
var stars = new StarCollection();
foreach (var rawData in stateData[StatesDB.StarsKey].To <IEnumerable <IkonComposite> >())
{
stars.Add(StarData.Load(rawData, deindexer));
}
var planets = new PlanetCollection();
foreach (var rawData in stateData[StatesDB.PlanetsKey].To <IEnumerable <IkonComposite> >())
{
planets.Add(Planet.Load(rawData, deindexer));
}
var wormholes = new WormholeCollection();
foreach (var rawData in stateData[StatesDB.WormholesKey].To <IEnumerable <IkonComposite> >())
{
wormholes.Add(Wormhole.Load(rawData, deindexer));
}
var players = new List <Player>();
foreach (var rawData in saveData[MainGame.PlayersKey].To <IEnumerable <IkonComposite> >())
{
players.Add(Player.Load(rawData, deindexer));
}
var organellePlayer = Player.Load(saveData[MainGame.OrganellePlayerKey].To <IkonComposite>(), deindexer);
var developments = new DevelopmentProgressCollection();
foreach (var rawData in stateData[StatesDB.DevelopmentAdvancesKey].To <IEnumerable <IkonComposite> >())
{
developments.Add(DevelopmentProgress.Load(rawData, deindexer));
}
var research = new ResearchProgressCollection();
foreach (var rawData in stateData[StatesDB.ResearchAdvancesKey].To <IEnumerable <IkonComposite> >())
{
research.Add(ResearchProgress.Load(rawData, deindexer));
}
var treaties = new TreatyCollection();
foreach (var rawData in stateData[StatesDB.TreatiesKey].To <IEnumerable <IkonComposite> >())
{
treaties.Add(Treaty.Load(rawData, deindexer));
}
var reports = new ReportCollection();
foreach (var rawData in stateData[StatesDB.ReportsKey].To <IEnumerable <IkonComposite> >())
{
reports.Add(ReportFactory.Load(rawData, deindexer));
}
var designs = new DesignCollection();
foreach (var rawData in stateData[StatesDB.DesignsKey].To <IEnumerable <IkonComposite> >())
{
var design = Design.Load(rawData, deindexer);
design.CalcHash(statics);
designs.Add(design);
deindexer.Add(design.ConstructionProject, design.ConstructionProject.IdCode);
}
var colonizations = new ColonizationCollection();
foreach (var rawData in stateData[StatesDB.ColonizationKey].To <IEnumerable <IkonComposite> >())
{
colonizations.Add(ColonizationProject.Load(rawData, deindexer));
}
var fleets = new FleetCollection();
foreach (var rawData in stateData[StatesDB.IdleFleetsKey].To <IEnumerable <IkonComposite> >())
{
fleets.Add(Fleet.Load(rawData, deindexer));
}
var colonies = new ColonyCollection();
foreach (var rawData in stateData[StatesDB.ColoniesKey].To <IEnumerable <IkonComposite> >())
{
colonies.Add(Colony.Load(rawData, deindexer));
}
var stellarises = new StellarisCollection();
foreach (var rawData in stateData[StatesDB.StellarisesKey].To <IEnumerable <IkonComposite> >())
{
stellarises.Add(StellarisAdmin.Load(rawData, deindexer));
}
for (int i = 0; i < players.Count; i++)
{
players[i].Orders = PlayerOrders.Load(ordersData[i].To <IkonComposite>(), deindexer);
}
organellePlayer.Orders = PlayerOrders.Load(saveData[MainGame.OrganelleOrdersKey].To <IkonComposite>(), deindexer);
return(new Tuple <StatesDB, Player[], Player>(
new StatesDB(stars, wormholes, planets, colonies, stellarises, developments, research, treaties, reports, designs, fleets, colonizations),
players.ToArray(),
organellePlayer
));
}
public ReportCollection FetchByQuery(Query qry)
{
ReportCollection coll = new ReportCollection();
coll.LoadAndCloseReader(qry.ExecuteReader());
return coll;
}
public ReportCollection FetchByID(object Id)
{
ReportCollection coll = new ReportCollection().Where("ID", Id).Load();
return coll;
}
public Device(ReportCollection application, Hidraw hidraw)
{
this.application = application ?? throw new ArgumentNullException(nameof(application));
this.hidraw = hidraw ?? throw new ArgumentNullException(nameof(hidraw));
}
