public void can_generate_exception_on_creating_session_query_when_specified_query_value_does_not_match_property_type()
{
try
{
// account number is a string and an integer is used on input:
session.CreateQueryFor <Account>()
.Select(SelectionOptions.AllFrom <Account>())
.CreateCriteria(Restrictions.EqualTo <Account>(a => a.AccountNumber, 123456))
.SingleOrDefault();
Assert.False(true, "The exception for mismatch query to property type was not thrown.");
}
catch (Exception exception)
{
System.Diagnostics.Debug.WriteLine(exception.ToString());
Assert.Equal(typeof(InvalidCastException), exception.GetBaseException().GetType());
}
//Assert.Throws<InvalidCastException>(() =>
// {
// // account number is a string and an integer is used on input:
// session.CreateQueryFor<Account>()
// .Select(SelectionOptions.AllFrom<Account>())
// .CreateCriteria(Restrictions.EqualTo<Account>(a => a.AccountNumber, 123456))
// .SingleOrDefault();
// }
//);
}
public void can_create_session_query_using_and_comparator_with_component()
{
session.CreateQueryFor <Employee>()
.Select(SelectionOptions.AllFrom <Employee>())
.CreateCriteria(Restrictions.GreaterThanOrEqualTo <Employee>(a => a.EmployeeNumber, "12234"))
.SingleOrDefault();
}
public async Task <IActionResult> Index(SelectionOptions status = SelectionOptions.All
, SelectionOptions batch = SelectionOptions.All
, int page = 1
, int perPage = Constants.ItemsPerPage)
{
int items = await _repository.GetSuppliersCountAsync(status, batch);
if (perPage < 2)
{
perPage = Constants.ItemsPerPage;
}
int pages = ((items + perPage - 1) / perPage);
if (page < 1)
{
page = 1;
}
if (page > pages)
{
page = pages;
}
SupplierIndexViewModel model = new SupplierIndexViewModel()
{
Suppliers = await _repository.GetSuppliersAsync(status, batch, page, perPage),
Page = page,
Pages = pages,
perPage = perPage,
Status = status,
Batch = batch
};
ViewBag.Title = _stringLocalizer["Suppliers"].ToString();
return(View(model));
}
public void can_create_session_query_using_and_comparator()
{
session.CreateQueryFor <Account>()
.Select(SelectionOptions.AllFrom <Account>())
.CreateCriteria(Restrictions.EqualTo <Account>(a => a.AccountNumber, "12234"))
.SingleOrDefault();
}
public async Task <IActionResult> Index(SelectionOptions inStock = SelectionOptions.Active
, SelectionOptions isFeed = SelectionOptions.All
, int page = 1
, int perPage = Constants.ItemsPerPage)
{
int items = await _repository.GetInventoryItemsCountAsync(inStock, isFeed);
if (perPage < 2)
{
perPage = Constants.ItemsPerPage;
}
int pages = (items - 1 / perPage);
if (page < 1)
{
page = 1;
}
if (page > pages)
{
page = pages;
}
InventoryItemsIndexViewModel model = new InventoryItemsIndexViewModel()
{
Page = page,
Pages = pages,
PerPage = perPage,
InStock = inStock,
IsFeed = isFeed,
InventoryItems = await _repository.GetInventoryItemsAsync(inStock, isFeed, page, perPage)
};
ViewBag.Title = _stringLocalizer["Inventory Items"].ToString();
return(View(model));
}
/// <summary>
/// Initializes a new instance of the <see cref="SharedModelOptions"/> class.
/// </summary>
/// <param name="variables">The shared variables dictionary.</param>
/// <param name="prefix">The variable key prefix.</param>
public SharedModelOptions(VariableDictionary variables, string prefix) : base(variables, prefix)
{
Namespace = "{Project.Namespace}.Domain.Models";
Directory = @"{Project.Directory}\Domain\Models";
Include = new SelectionOptions();
Exclude = new SelectionOptions();
}
private void RefreshSelection()
{
SelectionOptions.Clear();
SelectionOptions.Add("--All Cons Together--");
foreach (var con in ComicCons.Select(c => c.EventName).Distinct())
{
SelectionOptions.Add(con.ToString());
}
}
public static string[] GetOptions(SelectionOptions optionSet)
{
switch (optionSet)
{
case SelectionOptions.EffectClass:
return(ECs.Select(ec => ec.Name).ToArray());
default: return(null);
}
}
public void can_find_entity_by_query()
{
using (var session = factory.OpenSession())
{
var department = session.CreateQueryFor <Department>()
.Select(SelectionOptions.AllFrom <Department>())
.CreateCriteria(Restrictions.Like <Department>(d => d.Description, "#2"))
.SingleOrDefault();
Assert.NotNull(department);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="BaseModelOptions"/> class.
/// </summary>
protected BaseModelOptions(VariableDictionary variables, string prefix)
: base(variables, prefix)
{
// null so shared option is used
Namespace = null;
Directory = null;
Generate = false;
Include = new SelectionOptions();
Exclude = new SelectionOptions();
}
public void can_find_entity_set_by_query()
{
using (var session = factory.OpenSession())
{
var department = session.CreateQueryFor <Department>()
.Select(SelectionOptions.AllFrom <Department>())
.CreateCriteria(Restrictions.EqualTo <Department>(d => d.Id, 1))
.SingleOrDefault();
System.Diagnostics.Debug.WriteLine(department.Instructors.Count);
Assert.True(department.Instructors.Count > 0);
}
}
public void can_use_aggregate_function_and_project_into_entity()
{
using (var session = factory.OpenSession())
{
var countOfNameView = session.CreateQueryFor <Department>()
.Select(SelectionOptions.CountOnFieldFrom <Department>(d => d.Name, "name_count"))
//.JoinOn<Instructor>(i=>i.Department.Id, d=>d.Id)
.CreateCriteria(Restrictions.Like <Department>(d => d.Name, "arts"))
.SingleOrDefault <CountOfNameView>();
Assert.NotNull(countOfNameView);
Assert.Equal(1, countOfNameView.Count);
}
}
public void can_create_session_query_for_select_all_over_object()
{
session.CreateQueryFor <Account>()
.Select(SelectionOptions.FieldFrom <AccountTransaction>(t => t.Description),
SelectionOptions.AvgOnFieldFrom <Account>(a => a.AccountNumber, "avg_accounts"))
.LeftJoinOn <AccountTransaction>(t => t.Account.Id, a => a.Id)
.CreateCriteria(Restrictions.CreateDisjunctionOn(
Restrictions.EqualTo <Account>(a => a.Id, 1),
Restrictions.GreaterThan <Account>(a => a.AccountNumber, "12344")),
Restrictions.Like <Account>(a => a.Description, "completed"))
.AddOrder(OrderOptions.Asc <Account>(a => a.Id))
.GroupBy(GroupByOptions.AliasField <Account>("avg_accounts"),
GroupByOptions.FieldFrom <AccountTransaction>(t => t.Description))
.SingleOrDefault();
}
// Select all / unselect all; Inverse selection / select files/folders by extension
public IEnumerable SelectEntries(IList selectedItems, IEnumerable <T> allItems, SelectionOptions selectionOptions)
{
switch (selectionOptions)
{
case SelectionOptions.SelectAll:
InsertSelectItems(allItems, selectedItems);
break;
case SelectionOptions.UnSelectAll:
selectedItems.Clear();
break;
case SelectionOptions.Inverse:
var temp = allItems.Except(selectedItems.Cast <T>()).ToArray();
selectedItems.Clear();
InsertSelectItems(temp, selectedItems);
break;
case SelectionOptions.SelectByExtension:
break;
case SelectionOptions.SaveInternal:
break;
case SelectionOptions.RestoreInternal:
break;
case SelectionOptions.SaveToFile:
// Ничего не выделено
if (selectedItems == null)
{
MessageBox.Show(
"Ничего не выделено",
"Ultimate Commander - Подсистема выделения",
MessageBoxButton.OK,
MessageBoxImage.Information
);
break;
}
var saveFileDialog = new SaveFileDialog
{
Filter = "Текстовые документы (*.txt)|*.txt|Все файлы (*,*)|*.*",
FilterIndex = 0,
AddExtension = true
};
if (saveFileDialog.ShowDialog() == true)
{
var itemsText = new StringBuilder();
foreach (var item in selectedItems.Cast <T>())
{
itemsText.AppendLine(item.ToString());
}
File.WriteAllText(saveFileDialog.FileName, itemsText.ToString());
}
break;
case SelectionOptions.RestoreFromFile:
var openFileDialog = new OpenFileDialog
{
InitialDirectory = Environment.CurrentDirectory,
CheckPathExists = true,
DereferenceLinks = true,
Filter = "Текстовые документы (*.txt)|*.txt|Все файлы (*,*)|*.*",
FilterIndex = 0,
FileName = "*.txt"
};
if (openFileDialog.ShowDialog() == true)
{
// Check for vaild info in file
// Restore selection
}
break;
default:
if (selectionOptions != SelectionOptions.DoNothing)
{
throw new ArgumentOutOfRangeException("selectionOptions", selectionOptions,
Resources.SelectionControl_CopyPathsToClipBoard_OptionException);
}
break;
}
return(selectedItems);
}
public override void FromXML(XmlNode vNode)
{
base.FromXML(vNode);
SelectionOptions.Clear();
XmlNodeList oNodes = vNode.ChildNodes;
foreach (XmlNode oNode in oNodes)
{
ItemSelectorOption option = null;
try
{
switch (oNode.LocalName)
{
case "Text":
string labelText = oNode.Attributes.GetNamedItem("text").Value;
option = new ItemSelectorLabel {
Label = labelText
};
break;
case "Image":
string imageLocation = Path.Combine(OverlaySettings.Instance.Location.Directory.FullName,
oNode.Attributes.GetNamedItem("image").Value);
option = new ItemSelectorImage {
Location = imageLocation
};
break;
case "Color":
string colorValue = oNode.Attributes.GetNamedItem("color").Value;
if (ColorConverter.ConvertFromString(colorValue) == null)
{
throw new InvalidXMLValueException("OverlayItemSelector:Option", "color", InvalidXMLValueException.Reason.InvalidValue);
}
option = new ItemSelectorColor {
Fill = new SolidColorBrush((Color)ColorConverter.ConvertFromString(colorValue))
};
break;
}
} catch (Exception) {
throw new InvalidXMLValueException("OverlayItemSelector:Option", oNode.LocalName, InvalidXMLValueException.Reason.NotSpecified);
}
if (option == null)
{
throw new InvalidXMLValueException("OverlayItemSelector:Option", oNode.LocalName, InvalidXMLValueException.Reason.InvalidValue);
}
foreach (XmlAttribute xAttrib in oNode.Attributes)
{
switch (xAttrib.LocalName)
{
case "value":
option.Value = xAttrib.Value;
break;
case "alt":
option.Alt = xAttrib.Value;
break;
}
}
option.PropertyChanged += new PropertyChangedEventHandler(ItemSelectorOption_PropertyChanged);
SelectionOptions.Add(option);
}
RaisePropertyChanged("Columns");
foreach (XmlAttribute vNodeAttrib in vNode.Attributes)
{
try
{
switch (vNodeAttrib.LocalName)
{
case "default":
DefaultValue = vNodeAttrib.Value;
break;
case "value":
Value = vNodeAttrib.Value;
break;
case "columns":
Columns = int.Parse(vNodeAttrib.Value);
break;
case "itemHeight":
ItemHeight = double.Parse(vNodeAttrib.Value);
break;
case "itemWidth":
ItemWidth = double.Parse(vNodeAttrib.Value);
break;
}
} catch (FormatException) {
throw new InvalidXMLValueException("OverlayItemSelector", vNodeAttrib.Value, InvalidXMLValueException.Reason.FormatIncorrect);
} catch (ArgumentNullException) {
throw new InvalidXMLValueException("OverlayItemSelector", vNodeAttrib.Value, InvalidXMLValueException.Reason.NotSpecified);
} catch (OverflowException) {
throw new InvalidXMLValueException("OverlayItemSelector", vNodeAttrib.Value, InvalidXMLValueException.Reason.Overflow);
}
}
if (DefaultValue == null && SelectionOptions.Count > 0)
{
DefaultValue = SelectionOptions.First().Value;
}
}
public async Task <IEnumerable <Supplier> > GetSuppliersAsync(SelectionOptions status, SelectionOptions batch, int page = 0, int perPage = 0)
{
if (page < 1 || perPage < 1)
{
switch (status, batch)
{
public Options(SelectionOptions option)
{
Option = option;
}
private void Button7Click(object sender, RoutedEventArgs e)
{
_vibrate.Start(TimeSpan.FromMilliseconds(10));
if (_assignment[1].Selected)
{
_assignment[1] = new SelectionOptions() { MatrixView = GetEmptyMatrix(true), Selected = true, HasValue = false };
textBlock6.Text = _assignment[1].MatrixView.MatrixName;
EnableMatrixB();
}
else
{
_assignment[0].Selected = false;
_assignment[1] = new SelectionOptions() { MatrixView = GetEmptyMatrix(true), Selected = true, HasValue = false };
textBlock6.Text = _assignment[1].MatrixView.MatrixName;
EnableMatrixB();
}
}
