public void CheckIfInitializedCardsRepositoryIsRandom()
{
ICardRepository repositoryOne = new CardRepository();
this._initializer.Init((IEditableRepository<ICard>)repositoryOne);
ICardRepository repositoryTwo = new CardRepository();
this._initializer.Init((IEditableRepository<ICard>)repositoryTwo);
Assert.That(repositoryOne, Has.Count.EqualTo(repositoryTwo.Count));
bool areDifferent = false;
for (int i = 0; i < repositoryOne.Count; i++)
{
var cardOne = repositoryOne.NextCard();
var cardTwo = repositoryTwo.NextCard();
if (string.Equals(cardOne.Name, cardTwo.Name))
continue;
areDifferent = true;
break;
}
Assert.That(areDifferent, Is.True);
}
public static IList<Card> ListAllCards()
{
using (ICardRepository cardRepository = new CardRepository())
{
IQueryable<Card> query = cardRepository.GetAll<Card>();
query = cardRepository.IncludeAllRelations(query);
return query.ToList();
}
}
public void CanAddCard()
{
var card = new Card {
Name = "White Knight", CastingCost = "WW", Type = "Creature - Knight"
};
ICardRepository repository = new CardRepository();
repository.Add(card);
// use session to try to load the product);
using (var session = _sessionFactory.OpenSession())
{
var fromDb = session.Get <Card>(card.Id);
// Test that the color was successfully inserted
Assert.IsNotNull(fromDb);
Assert.AreNotSame(card, fromDb);
Assert.AreEqual(card.Name, fromDb.Name);
Assert.AreEqual(card.CastingCost, fromDb.CastingCost);
Assert.AreEqual(card.Type, fromDb.Type);
}
}
public static void Main(string[] args)
{
IReader reader = new ConsoleReader();
IWriter writer = new ConsoleWriter();
IPlayerFactory playerFactory = new PlayerFactory();
IPlayerRepository playerRepository = new PlayerRepository();
ICardFactory cardFactory = new CardFactory();
ICardRepository cardRepository = new CardRepository();
IBattleField battleField = new BattleField();
IManagerController managerController = new ManagerController(
playerFactory,
playerRepository,
cardFactory,
cardRepository,
battleField);
IEngine engine = new Engine(reader, writer, managerController);
engine.Run();
}
public void Fight(IPlayer attackPlayer, IPlayer enemyPlayer)
{
if (attackPlayer.IsDead == true)
{
throw new ArgumentException("Player is dead!");
}
if (enemyPlayer.IsDead == true)
{
throw new ArgumentException("Player is dead!");
}
if (attackPlayer is Beginner beginner)
{
attackPlayer.Health += 40;
CardRepository card = new CardRepository();
}
if (enemyPlayer is Beginner beginner2)
{
enemyPlayer.Health += 40;
}
}
public void CanCreateDeck()
{
var deckRepository = new DeckRepository(Session);
var cardRepository = new CardRepository(Session);
var card = new Card("A", "type", "m14", CardRarity.Special, "Barry", "nowhere");
var deck = new Deck("DeckName");
deck.Cards.Add(card);
Session.BeginTransaction();
cardRepository.Save(card);
deckRepository.Save(deck);
Session.Transaction.Commit();
Session.Evict(card);
Session.Evict(deck);
Session.Clear();
var deckFromRepository = deckRepository.Get(deck.Id);
Assert.AreEqual("DeckName", deckFromRepository.Name);
Assert.AreEqual(1, deckFromRepository.Cards.Count);
}
public IPlayer CreatePlayer(string type, string username)
{
ICardRepository cardRepository = new CardRepository();
IPlayer player;
switch (type)
{
case "Advanced":
player = new Advanced(cardRepository, username);
break;
case "Beginner":
player = new Beginner(cardRepository, username);
break;
default:
player = null;
break;
}
return(player);
}
public static void Main()
{
IReader reader = new Reader();
IWriter writer = new Writer();
IPlayerFactory playerFactory = new PlayerFactory();
IPlayerRepository playerRepository = new PlayerRepository();
ICardFactory cardFactory = new CardFactory();
ICardRepository cardRepository = new CardRepository();
IBattleField battleField = new BattleField();
IManagerController managerController = new ManagerController(
playerFactory,
playerRepository,
cardFactory,
cardRepository,
battleField);
CommandInterpreter commandInterpreter = new CommandInterpreter(managerController);
Engine engine = new Engine(commandInterpreter, reader, writer);
engine.Run();
}
public static bool BuildCommanderDeck(string deckName, string tribeType)
{
var deck = DeckRepository.GetDeck(deckName);
if (deck.Commander == null)
{
return(false);
}
var legalCards = CardRepository.GetAllCommanderLegalCardInGivenColors(CardBLL.GetCardColors(CardMapper.Map(deck.Commander)));
var tempCards = legalCards.Where(c => c.SubTypes.Contains(tribeType) || c.RulesText.Contains(tribeType) && c.Id != deck.Commander.Id);
if (tempCards.Count() > 34)
{
tempCards = tempCards.ToList().GetRange(0, 34);
}
DeckRepository.UpdateDeck(deck);
return(true);
}
public void CanRegisterUser()
{
var userRepository = new UserRepository(Session, Encryptor);
var cardRepository = new CardRepository(Session);
var deckRepository = new DeckRepository(Session);
var card = new Card("A", "B", "C", CardRarity.Special, "D", "E");
var deck = new Deck("F");
var user = new User("*****@*****.**", "Appie", userRepository);
deck.Cards.Add(card);
deck.Cards.Add(card);
user.Decks.Add(deck);
user.Cards.Add(card);
Session.BeginTransaction();
userRepository.CreateNewUser(user, "test123");
cardRepository.Save(card);
deckRepository.Save(deck);
Session.Transaction.Commit();
Session.Evict(card);
Session.Evict(deck);
Session.Evict(user);
Session.Clear();
var userFromRepository = userRepository.Get(user.Id);
Assert.AreEqual(user.DisplayName, userFromRepository.DisplayName);
Assert.AreEqual(userFromRepository.Decks[0].Cards.Count, deck.Cards.Count);
Assert.AreEqual(userFromRepository.Cards.Count, 1);
Assert.AreEqual(userRepository.AuthenticateUser(userFromRepository.Email, "test123"), AuthenticateMessages.AuthenticationSuccessfull);
Assert.AreEqual(userRepository.AuthenticateUser("*****@*****.**", "blaat"), AuthenticateMessages.UsernameDoesNotExist);
Assert.AreEqual(userRepository.AuthenticateUser(userFromRepository.Email, "tester"), AuthenticateMessages.WrongEmailOrPassword);
}
public static void Main()
{
var list = new List <Card>()
{
new Card()
{
SourceId = "Мельбурн",
DestinationId = "Кельн"
},
new Card()
{
SourceId = "Москва",
DestinationId = "Париж"
},
new Card()
{
SourceId = "Кельн",
DestinationId = "Москва"
}
};
var repository = new CardRepository();
foreach (var card in list)
{
repository.Add(card);
}
var cards = repository.GetAll().ToArray();
Debug.Assert(cards.Length == 3);
Debug.Assert(cards[0].SourceId == "Мельбурн");
Debug.Assert(cards[0].DestinationId == "Kельн");
Debug.Assert(cards[1].SourceId == "Kельн");
Debug.Assert(cards[1].DestinationId == "Москва");
Debug.Assert(cards[2].SourceId == "Москва");
Debug.Assert(cards[2].DestinationId == "Париж");
// The complexity of the sort algorithm would be measured as O(n + k) = O(n)
}
public void CanAddCardToMultipleUsers()
{
var userRepository = new UserRepository(Session, Encryptor);
var cardRepository = new CardRepository(Session);
var card = new Card("CardName", "CardType", "Expansion", CardRarity.Mythic, "Artist", "someUrl");
var user1 = new User("*****@*****.**", "Robin van der Knaap", userRepository);
user1.Cards.Add(card);
var user2 = new User("*****@*****.**", "Erwin Bonnet", userRepository);
user2.Cards.Add(card);
Session.BeginTransaction();
cardRepository.Save(card);
userRepository.CreateNewUser(user1, "test123");
userRepository.CreateNewUser(user2, "test123");
Session.Transaction.Commit();
Session.Evict(card);
Session.Evict(user1);
Session.Evict(user2);
Session.Clear();
var userFromDatabase1 = userRepository.Get(user1.Id);
var userFromDatabase2 = userRepository.Get(user2.Id);
Assert.AreEqual(1, userFromDatabase1.Cards.Count);
Assert.AreEqual(1, userFromDatabase2.Cards.Count);
Assert.AreEqual(card, userFromDatabase1.Cards.First());
Assert.AreEqual(card, userFromDatabase2.Cards.First());
}
public DeckSerializationSubsystem(
CardRepository cardRepository,
ForgeSetRepository forgeSetRepo)
{
MtgArenaFormatter = new MtgArenaFormatter(cardRepository);
MtgoFormatter = new MtgoDeckFormatter(cardRepository);
_formatters = new[]
{
new JsonDeckFormatter(),
new TcgCsvDeckFormatter(cardRepository),
new ForgeDeckFormatter(cardRepository, forgeSetRepo),
new MagarenaDeckFormatter(cardRepository),
new DeckedBuilderDeckFormatter(cardRepository),
new XMageDeckFormatter(cardRepository),
MtgArenaFormatter,
// must be after MtgArenaFormatter for correct format resolution
MtgoFormatter
};
_loadFormatters = _formatters.Where(_ => _.SupportsImport && _.SupportsFile).ToArray();
_saveFormatters = _formatters.Where(_ => _.SupportsExport && _.SupportsFile).ToArray();
ImportedFilePatterns = _loadFormatters
.Where(_ => _.SupportsImport)
.Select(f => f.FileNamePattern)
.Distinct()
.ToList();
_loadFilter = string.Join(@"|", Sequence.From($"Any {{type}}|{string.Join(@";", ImportedFilePatterns)}").Concat(
_loadFormatters.Select(f => $"{f.Description}|{f.FileNamePattern}")));
_saveFilter = string.Join(@"|",
_saveFormatters.Select(f => $"{f.Description}|{f.FileNamePattern}"));
AppDir.Save.CreateDirectory();
}
public UpdateForm(
Installer installer,
ImageDownloader imageDownloader,
ImageDownloadProgressReader imageDownloadProgressReader,
NewsService newsService,
PriceDownloader priceDownloader,
PriceRepository priceRepository,
ImageRepository imageRepository,
CardRepository cardRepository)
: this()
{
_installer = installer;
_imageDownloader = imageDownloader;
_imageDownloadProgressReader = imageDownloadProgressReader;
_newsService = newsService;
_priceDownloader = priceDownloader;
_priceRepository = priceRepository;
_imageRepository = imageRepository;
_cardRepository = cardRepository;
_buttonApp.Click += appClick;
_buttonImgLq.Click += imgLqClick;
_buttonImgMq.Click += imgMqClick;
_buttonImgArt.Click += imgArtClick;
_buttonsMtgjson.Click += mtgjsonClick;
_buttonPrices.Click += pricesClick;
_buttonEditConfig.Click += editConfigClick;
_buttonNotifications.Click += notificationsClick;
Closing += closing;
Load += load;
DoubleBuffered = true;
_imageDownloader.ProgressChanged += downloadImageProgressChanged;
_priceDownloader.SidAdded += downloadPricesProgressChanged;
_priceDownloader.PriceAdded += downloadPricesProgressChanged;
}
static void Main(string[] args)
{
var productRepo = new ProductRepository();
var cardRepo = new CardRepository(productRepo);
var scenarioService = new ScenarioService(productRepo, cardRepo);
Console.WriteLine("Scenario Builder");
foreach (var g in scenarioService.ScenarioGroups())
{
Console.WriteLine("Scenario Group: " + g.Name);
foreach (var s in g.Scenarios)
{
var slug = getScenarioSlug(s);
var fileName = slug + ".cs";
Console.WriteLine(string.Format(" {0} ({1})", s.Title, fileName));
var text = getScenarioText(s, slug);
System.IO.File.WriteAllText(fileName, text);
}
}
Console.WriteLine("DONE");
Console.ReadLine();
}
static void LoadCards(MTGToolboxContext context, string setCode)
{
CardRepository cardRepository = new CardRepository(context);
SetRepository setRepository = new SetRepository(context);
CardService cardService = new CardService();
Set set = setRepository.GetSetByCode(setCode);
int cardResultsPage = 1;
var cardResults = cardService.Where(x => x.Set, setCode).Where(x => x.Page, cardResultsPage).All();
do
{
foreach (var item in cardResults.Value)
{
Card card = new Card();
card.Name = item.Name;
card.ImageFile = item.ImageUrl?.ToString();
card.SetCards = new List <SetCards> {
new SetCards {
Set = set, Card = card, Rarity = item.Rarity, ImageFile = item.ImageUrl?.ToString()
}
};
cardRepository.AddCard(card);
}
cardResultsPage += 1;
cardResults = cardService.Where(x => x.Set, setCode).Where(x => x.Page, cardResultsPage).All();
} while (cardResults.Value.Count > 1);
cardRepository.Save();
}
public DeckSerializationSubsystem(
CardRepository cardRepository,
ForgeSetRepository forgeSetRepo)
{
_formatters = new IDeckFormatter[]
{
new JsonDeckFormatter(),
new ForgeDeckFormatter(cardRepository, forgeSetRepo),
new MagarenaDeckFormatter(cardRepository),
new DeckedBuilderDeckFormatter(cardRepository),
new XMageDeckFormatter(cardRepository),
new MtgoDeckFormatter(cardRepository)
};
string anyFormatFilter = $"Any {{type}}|{string.Join(@";", _formatters.Where(_ => _.SupportsImport).Select(f => f.FileNamePattern).Distinct())}";
_loadFilter = string.Join(@"|", Sequence.From(anyFormatFilter).Concat(
_formatters.Where(_ => _.SupportsImport).Select(f => $"{f.Description}|{f.FileNamePattern}")));
_saveFilter = string.Join(@"|",
_formatters.Where(_ => _.SupportsExport).Select(f => $"{f.Description}|{f.FileNamePattern}"));
Directory.CreateDirectory(AppDir.Save);
}
public static void DeleteCard(int idCard)
{
using (ICardRepository cardRepository = new CardRepository(true))
{
cardRepository.Delete<Card>(p => p.IdCard == idCard);
cardRepository.UnitOfWork.SaveChanges();
}
}
public bool CheckLoginInfo(string cardNumber, string pin)
{
CardRepository cardRepository = new CardRepository();
return(cardRepository.CheckCard(cardNumber, new CardGenerator().HashPin(pin)));
}
public static IList<SoftwareEncoder> ListAllSofwareEncodersAudio()
{
using (ICardRepository cardRepository = new CardRepository())
{
return cardRepository.GetQuery<SoftwareEncoder>(s => s.Type == 1).OrderBy(s => s.Priority).ToList();
}
}
public PrintingSubsystem(ImageRepository imageRepository, CardRepository cardRepository)
{
_imageRepository = imageRepository;
_cardRepository = cardRepository;
}
public int SampleHandSize(CardRepository repo) => countNonTokens(repo, SampleHand);
public int SideDeckSize(CardRepository repo) => countNonTokens(repo, SideDeck);
private static IEnumerable <(string Set, string Number, int Count)> addBasicLands(CardRepository repo, IEnumerable <(string Set, string Number, int Count)> collectionData)
public FormMain(
UndoConfig undoConfig,
CardRepository cardRepo,
ImageRepository imageRepo,
ImageCacheConfig imageCacheConfig,
ImageLoader imageLoader,
CollectionEditorModel collectionEditor,
CardSearcher cardSearcher,
CardDocumentAdapter cardAdapter,
DeckDocumentAdapter deckAdapter,
KeywordSearcher keywordSearcher,
ForgeSetRepository forgeSetRepo,
DeckListModel deckListModel,
DeckSearcher deckSearcher,
IconRecognizer iconRecognizer,
FormManager formManager)
: this()
{
DoubleBuffered = true;
KeyPreview = true;
_viewCards = new MtgLayoutView(_layoutViewCards);
_viewDeck = new MtgLayoutView(_layoutViewDeck);
_cardSearcher = cardSearcher;
_keywordSearcher = keywordSearcher;
_quickFilterControls = QuickFilterSetup.GetQuickFilterControls(this);
_cardRepo = cardRepo;
_imageLoader = imageLoader;
_collectionEditor = collectionEditor;
_serialization = new DeckSerializationSubsystem(_cardRepo, forgeSetRepo);
beginRestoreSettings();
_fields = new Fields();
QuickFilterSetup.SetQuickFilterProperties(this);
QuickFilterImages.SetImages(this);
_quickFilterFacade = new QuickFilterFacade(
KeywordDefinitions.Patterns,
KeywordDefinitions.Values.ToKeywordDisplayTexts(),
KeywordDefinitions.PropertyNames,
KeywordDefinitions.PropertyNamesDisplay,
keywordSearcher);
_buttons = new ButtonSubsystem();
_cardSearch = new CardSearchSubsystem(
this,
_searchEditor,
_panelIconSearch,
_listBoxSuggest,
cardSearcher,
cardAdapter,
_viewCards,
_viewDeck);
_panelSearchExamples.Setup(_cardSearch, _buttons, _buttonSearchExamplesDropDown);
_sort = new SortSubsystem(_viewCards, _cardRepo, _fields, _cardSearch);
endRestoreSettings();
_tooltipViewCards = new LayoutViewTooltip(this, _viewCards, _cardSearch);
_tooltipViewDeck = new LayoutViewTooltip(this, _viewDeck, _cardSearch);
var formZoomCard = new FormZoom(_cardRepo, imageRepo, _imageLoader);
_scroll = new ScrollSubsystem(_viewDeck, _viewCards);
_imagePreloading = new ImagePreloadingSubsystem(
_viewCards,
_viewDeck,
_scroll,
imageCacheConfig);
_deckEditor = new DeckEditorModel();
_dragging = new DraggingSubsystem(
_viewDeck,
_viewCards,
_deckEditor,
this,
_imageLoader,
formManager);
_deckEditorUi = new DeckEditorUi(
_viewCards,
_viewDeck,
_deckEditor,
_collectionEditor,
_dragging,
Cursor,
formZoomCard);
_viewDeck.SetDataSource(_deckEditor.DataSource);
_viewCards.SetDataSource(_searchResultCards);
_legality = new LegalitySubsystem(
_menuLegalityFormat,
_buttonLegalityAllowLegal,
_buttonLegalityAllowRestricted,
_buttonLegalityAllowBanned);
_drawing = new DrawingSubsystem(
_viewCards,
_viewDeck,
_dragging,
_cardSearch,
cardAdapter,
_deckEditor,
_quickFilterFacade,
_legality,
_imageLoader,
iconRecognizer);
_printing = new PrintingSubsystem(imageRepo, _cardRepo);
DeckZone = Zone.Main;
scale();
setRightPanelsWidth();
_keywordsIndexUpToDate = _keywordSearcher.IsUpToDate;
_luceneSearchIndexUpToDate = _cardSearcher.IsUpToDate;
_spellcheckerIndexUpToDate = _cardSearcher.Spellchecker.IsUpToDate;
_searchTextSelection = new RichTextBoxSelectionSubsystem(_searchEditor);
_history = new HistorySubsystem(undoConfig);
_evaluators = new Evaluators
{
{ 2, _legality.IsAllowedInFormat },
{ 3, evalFilterByCollection },
{ 4, evalFilterByDeck },
{ 0, _quickFilterFacade.Evaluate },
{ 1, evalFilterBySearchText }
};
_deckListControl.Init(
deckListModel,
iconRecognizer,
deckSearcher,
deckAdapter,
this);
_copyPaste = new CopyPasteSubsystem(
_cardRepo,
_serialization,
_collectionEditor,
_deckEditor,
_formRoot,
this,
_layoutViewDeck,
_tabHeadersDeck,
_layoutViewCards,
_deckListControl.DeckListView);
setupCheckButtonImages();
updateExcludeManaAbility();
updateExcludeManaCost();
updateShowProhibited();
updateShowSampleHandButtons();
updateDeckVisibility();
subscribeToEvents();
}
public static void DeleteGroupMap(int idMap)
{
using (ICardRepository cardRepository = new CardRepository(true))
{
cardRepository.Delete<CardGroupMap>(p => p.IdMapping == idMap);
cardRepository.UnitOfWork.SaveChanges();
}
}
public static SoftwareEncoder SaveSoftwareEncoder(SoftwareEncoder encoder)
{
using (ICardRepository cardRepository = new CardRepository())
{
cardRepository.AttachEntityIfChangeTrackingDisabled(cardRepository.ObjectContext.SoftwareEncoders, encoder);
cardRepository.ApplyChanges(cardRepository.ObjectContext.SoftwareEncoders, encoder);
cardRepository.UnitOfWork.SaveChanges();
encoder.AcceptChanges();
return encoder;
}
}
public static Satellite SaveSatellite(Satellite satellite)
{
using (ICardRepository cardRepository = new CardRepository())
{
cardRepository.AttachEntityIfChangeTrackingDisabled(cardRepository.ObjectContext.Satellites, satellite);
cardRepository.ApplyChanges(cardRepository.ObjectContext.Satellites, satellite);
cardRepository.UnitOfWork.SaveChanges();
satellite.AcceptChanges();
return satellite;
}
}
public static IList<Satellite> ListAllSatellites()
{
using (ICardRepository cardRepository = new CardRepository())
{
return cardRepository.GetAll<Satellite>().ToList();
}
}
public MtgArenaFormatter(CardRepository repo)
: base(repo)
{
}
public static Dictionary <string, int> ImportCollection(MtgArenaIntegration integration, CardRepository repo)
{
var collectionData = integration.ImportCollection();
var countById = new Dictionary <string, int>();
if (collectionData == null)
{
return(countById);
}
collectionData = addBasicLands(repo, collectionData);
foreach (var data in collectionData)
{
if (!repo.SetsByCode.TryGetValue(data.Set, out var set))
{
continue;
}
var card = set.Cards.FirstOrDefault(c => Str.Equals(c.Number, data.Number));
if (card == null)
{
continue;
}
countById.Add(card.Id, data.Count);
}
return(countById);
}
public static DisEqcMotor SaveDisEqcMotor(DisEqcMotor motor)
{
using (ICardRepository cardRepository = new CardRepository())
{
cardRepository.AttachEntityIfChangeTrackingDisabled(cardRepository.ObjectContext.DisEqcMotors, motor);
cardRepository.ApplyChanges(cardRepository.ObjectContext.DisEqcMotors, motor);
cardRepository.UnitOfWork.SaveChanges();
motor.AcceptChanges();
return motor;
}
}
public void SetZone(Zone?value, CardRepository repo)
{
CurrentZone = value;
LoadDeck(repo);
ZoneChanged?.Invoke();
}
public void ThrowErrorIfInitWithNoItems()
{
var repository = new CardRepository();
Assert.That(() => ((IEditableRepository<ICard>)repository).Init(), Throws.Exception.TypeOf<ApplicationException>());
}
public int MaybeDeckSize(CardRepository repo) => countNonTokens(repo, MaybeDeck);
public CardSearcher(CardRepository repository, CardDocumentAdapter adapter)
: base(new CardSpellchecker(repository, adapter), adapter)
{
_repo = repository;
IndexDirectoryParent = AppDir.Data.AddPath("index").AddPath("search");
}
public FormChart(CardRepository repository, UiModel ui, Fields fields)
: this()
{
_ui = ui;
_fields = fields;
_fieldsOrder = fields.ChartFields.OrderBy(_ => _fields.ByName[_].Alias)
.ToArray();
_repository = repository;
Load += load;
foreach (var button in _headerButtons)
{
button.Click += buttonClick;
}
SnapTo(Direction.North, System.Windows.Forms.Cursor.Position);
_tabByButton = Enumerable.Range(0, _buttons.Length)
.ToDictionary(i => _buttons[i], i => _tabs[i]);
foreach (var button in _buttons)
{
button.Click += buttonAddFieldClick;
}
_buttonApply.Click += buttonApplyClick;
var defaultIcons = new[]
{
_sortIconsOrder[0],
_sortIconsOrder[0],
_aggregateIconsOrder[0],
_sortIconsOrder[0]
};
for (int i = 0; i < _tabs.Length; i++)
{
_tabs[i].DefaultIcon = defaultIcons[i];
if (_tabs[i] != _tabSumm)
{
_tabs[i].Click += tabAxisClick;
}
else
{
_tabs[i].Click += tabSummClick;
}
_tabs[i].TabRemoving += tabRemoving;
}
_menuDataSource.Items.AddRange(Enum.GetNames(typeof(DataSource)).Cast <object>().ToArray());
_menuDataSource.SelectedIndex = 0;
_menuLabelDataElement.Items.AddRange(Enum.GetNames(typeof(DataElement)).Cast <object>().ToArray());
_menuDataSource.SelectedIndex = 0;
_menuChartType.Items.AddRange(
Enum.GetValues(typeof(SeriesChartType))
.Cast <SeriesChartType>()
.Where(isChartTypeSupported)
.Select(_ => _.ToString())
.Cast <object>().ToArray());
_menuChartType.SelectedIndex = 0;
_menuFields.Items.AddRange(_fieldsOrder.Select(_ => _fields.ByName[_].Alias).Cast <object>().ToArray());
foreach (var tab in _summTabs)
{
tab.TabAdded += tabSummAdded;
tab.TabRemoving += tabSummRemoving;
tab.TabReordered += tabSummReordered;
}
_menuPriceChartType.Items.AddRange(new object[]
{
SeriesChartType.Bar.ToString(),
SeriesChartType.Pyramid.ToString(),
SeriesChartType.Pie.ToString(),
SeriesChartType.Doughnut.ToString()
});
_menuPriceChartType.SelectedIndex = 0;
_menuPrice.Items.AddRange(new object[]
{
@"Low",
@"Mid",
@"High"
});
_menuPrice.SelectedIndex = 1;
_menuPrice.SelectedIndexChanged += priceMenuIndexChanged;
_menuPriceChartType.SelectedIndexChanged += priceMenuIndexChanged;
_menuChartType.SelectedIndexChanged += chartTypeChanged;
_buttonApplyFilter.CheckedChanged += applyFilterChanged;
}
public static IList<CardGroup> ListAllCardGroups()
{
using (ICardRepository cardRepository = new CardRepository())
{
var listAllCardGroups = cardRepository.GetAll<CardGroup>().ToList();
return listAllCardGroups;
}
}
public CardController()
{
_repo = new CardRepository();
}
public static Card GetCard(int idCard, CardIncludeRelationEnum includeRelations)
{
using (ICardRepository cardRepository = new CardRepository())
{
IQueryable<Card> query = cardRepository.GetQuery<Card>(c => c.IdCard == idCard);
query = cardRepository.IncludeAllRelations(query, includeRelations);
Card card = query.ToList().FirstOrDefault();
return card;
}
}
public static CardGroupMap SaveCardGroupMap(CardGroupMap map)
{
using (ICardRepository cardRepository = new CardRepository())
{
cardRepository.AttachEntityIfChangeTrackingDisabled(cardRepository.ObjectContext.CardGroupMaps, map);
cardRepository.ApplyChanges(cardRepository.ObjectContext.CardGroupMaps, map);
cardRepository.UnitOfWork.SaveChanges();
map.AcceptChanges();
return map;
}
}
public static Card SaveCard(Card card)
{
using (ICardRepository cardRepository = new CardRepository())
{
cardRepository.AttachEntityIfChangeTrackingDisabled(cardRepository.ObjectContext.Cards, card);
cardRepository.ApplyChanges(cardRepository.ObjectContext.Cards, card);
cardRepository.UnitOfWork.SaveChanges();
card.AcceptChanges();
return card;
}
}
public CardDocumentAdapter(CardRepository repo)
{
_repo = repo;
}
public static IList<Card> SaveCards(IEnumerable<Card> cards)
{
using (ICardRepository cardRepository = new CardRepository())
{
cardRepository.AttachEntityIfChangeTrackingDisabled(cardRepository.ObjectContext.Cards, cards);
cardRepository.ApplyChanges(cardRepository.ObjectContext.Cards, cards);
cardRepository.UnitOfWork.SaveChanges();
cardRepository.ObjectContext.AcceptAllChanges();
return cards.ToList();
}
}
public FormChart(CardRepository repository, Func <UiModel> uiSnapshotFactory, CardFields fields)
: this()
{
_checkBoxes = new[]
{
_buttonArgumentTotal,
_buttonSeriesTotal,
_buttonExplainTotal,
_buttonFilterBySearchResult
};
_fields = fields;
_fieldsOrder = fields.ChartFields.OrderBy(_ => _fields.ByName[_].Alias)
.ToArray();
_repository = repository;
_uiSnapshotFactory = uiSnapshotFactory;
Load += load;
foreach (var button in _headerButtons)
{
button.AutoCheck = false;
button.Pressed += buttonClick;
}
_tabByButton = Enumerable.Range(0, _buttons.Length)
.ToDictionary(i => _buttons[i], i => _tabs[i]);
foreach (var button in _buttons)
{
button.Pressed += buttonAddFieldClick;
}
_buttonApply.Pressed += buttonApplyClick;
for (int i = 0; i < _tabs.Length; i++)
{
if (_tabs[i] != _tabSumm)
{
_tabs[i].Click += tabAxisClick;
}
else
{
_tabs[i].Click += tabSummClick;
}
_tabs[i].TabRemoving += tabRemoving;
}
_menuDataSource.SetMenuValues(Enum.GetNames(typeof(DataSource)).Cast <string>());
_menuDataSource.SelectedIndex = 0;
_menuLabelDataElement.SetMenuValues(Enum.GetNames(typeof(DataElement)).Cast <string>());
_menuDataSource.SelectedIndex = 0;
_menuChartType.SetMenuValues(
Enum.GetValues(typeof(SeriesChartType))
.Cast <SeriesChartType>()
.Where(isChartTypeSupported)
.Select(_ => _.ToString()));
_menuChartType.SelectedIndex = 0;
_menuFields.SetMenuValues(_fieldsOrder.Select(_ => _fields.ByName[_].Alias));
foreach (var tab in _summTabs)
{
tab.TabAdded += tabSummAdded;
tab.TabRemoving += tabSummRemoving;
tab.TabReordered += tabSummReordered;
}
_menuPriceChartType.SetMenuValues(
SeriesChartType.Bar.ToString(),
SeriesChartType.Pyramid.ToString(),
SeriesChartType.Pie.ToString(),
SeriesChartType.Doughnut.ToString());
_menuPriceChartType.SelectedIndex = 0;
_menuPrice.SetMenuValues("Low", "Mid", "High");
_menuPrice.SelectedIndex = 1;
_menuPrice.SelectedIndexChanged += priceMenuIndexChanged;
_menuPriceChartType.SelectedIndexChanged += priceMenuIndexChanged;
_menuChartType.SelectedIndexChanged += chartTypeChanged;
_sortIconsOrder = new[]
{
LayoutControlBitmaps.SortNone,
LayoutControlBitmaps.SortAsc,
LayoutControlBitmaps.SortDesc
}.AsReadOnlyList();
_aggregateIconsOrder = new[]
{
ResourcesFilter.sum_hovered,
ResourcesFilter.count_hovered,
ResourcesFilter.count_distinct_hovered,
ResourcesFilter.min_hovered,
ResourcesFilter.avg_hovered,
ResourcesFilter.max_hovered
}.AsReadOnlyList();
var defaultIcons = new[]
{
_sortIconsOrder[0],
_sortIconsOrder[0],
_aggregateIconsOrder[0],
_sortIconsOrder[0]
};
for (int i = 0; i < _tabs.Length; i++)
{
_tabs[i].DefaultIcon = defaultIcons[i];
}
scale();
var filesSubsystem = new ChartFilesSubsystem(this, _buttonSave, _buttonLoad, _menuMruFiles);
if (components == null)
{
components = new Container();
}
components.Add(filesSubsystem);
_dropdownMruFiles.MenuControl = _menuMruFiles;
_dropdownMruFiles.MenuAlignment = HorizontalAlignment.Right;
_dropdownMruFiles.BeforeShow = filesSubsystem.UpdateMruFilesMenu;
}
public static Card GetCardByDevicePath(string devicePath)
{
using (ICardRepository cardRepository = new CardRepository())
{
var query = cardRepository.GetQuery<Card>(c => c.DevicePath == devicePath);
query = cardRepository.IncludeAllRelations(query);
Card card = query.ToList().FirstOrDefault();
return card;
}
}
