public ActionResult _RelatedReports(string SPName, string CurrentReportId)
{
ViewModels.CheckboxList relRepList = new CheckboxList();
if (!(SPName == null || SPName == "")) // if no SP selected then don't return checkboxlist( if is rdl change is no then this method won't be called)
{
if (DB_MSBDW.ReportSPs.Any(s => s.SPName == SPName))
{
int SPId = DB_MSBDW.ReportSPs.FirstOrDefault(sp => sp.SPName == SPName).ID;
var relatedReportsId = DB_MSBDW.Report_ReportSP.Where(re => re.ReportSPId == SPId).Select(re => re.SSRSReportId).Distinct().ToList();
int rId = Convert.ToInt32(CurrentReportId);
relatedReportsId.Remove(rId);
var relatedReports = DB_MSBDW.SSRSReport1.Where(r => relatedReportsId.Contains(r.id)).OrderBy(r => r.rpt_name).ToList();
foreach (var r in relatedReports)
{
ViewModels.CheckboxItem temp = new CheckboxItem();
temp.Id = r.id;
temp.Name = r.rpt_name;
temp.IsSelected = false;
relRepList.checkboxList.Add(temp);
}
}
relRepList.info = "All Related reports will reflect this change. Select additional reports that had their RDLs altered";
}
return(PartialView(relRepList));
}
public static AskCheckboxes Parse(Parser parser)
{
var cb = new AskCheckboxes();
cb.Label = parser.GetString("CheckBoxes");
cb.Min = parser.GetInt(Parser.RegKeywords.Minimum);
cb.Max = parser.GetInt(Parser.RegKeywords.Maximum);
cb.Cols = parser.GetInt(Parser.RegKeywords.Columns) ?? 1;
cb.list = new List <CheckboxItem>();
if (parser.curr.indent == 0)
{
return(cb);
}
var startindent = parser.curr.indent;
while (parser.curr.indent == startindent)
{
var m = CheckboxItem.Parse(parser, startindent);
cb.list.Add(m);
}
var q = (from i in cb.list
where i.SmallGroup != "nocheckbox"
where i.SmallGroup != "comment"
group i by i.SmallGroup into g
where g.Count() > 1
select g.Key).ToList();
if (q.Any())
{
throw parser.GetException("Duplicate SmallGroup in Checkboxes: {0}".Fmt(string.Join(",", q)));
}
return(cb);
}
public override void onDispose()
{
base.onDispose();
checkbox.Dispose();
checkbox = null;
}
public ConfigurationDataHDBitsApi() : base()
{
Codecs = new CheckboxItem(new Dictionary <string, string>()
{
{ "1", "H.264" },
{ "5", "HEVC" },
{ "2", "MPEG-2" },
{ "3", "VC-1" },
{ "6", "VP9" },
{ "4", "XviD" }
})
{
Name = "Codec", Values = new string[] { "1", "5", "2", "3", "6", "4" }
};
Mediums = new CheckboxItem(new Dictionary <string, string>()
{
{ "1", "Blu-ray/HD DVD" },
{ "4", "Capture" },
{ "3", "Encode" },
{ "5", "Remux" },
{ "6", "WEB-DL" }
})
{
Name = "Medium", Values = new string[] { "1", "4", "3", "5", "6" }
};
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
private void BuildItem()
{
switch (Type)
{
case HoverboardItemType.Selector:
vItem = new SelectorItem();
break;
case HoverboardItemType.Sticky:
vItem = new StickyItem();
break;
case HoverboardItemType.Checkbox:
var checkItem = new CheckboxItem();
checkItem.Value = CheckboxValue;
vItem = checkItem;
break;
case HoverboardItemType.Radio:
var radItem = new RadioItem();
radItem.Value = RadioValue;
radItem.GroupId = RadioGroupId;
vItem = radItem;
break;
case HoverboardItemType.Slider:
var sliderItem = new SliderItem();
sliderItem.Ticks = SliderTicks;
sliderItem.Snaps = SliderSnaps;
sliderItem.RangeMin = SliderRangeMin;
sliderItem.RangeMax = SliderRangeMax;
sliderItem.Value = Mathf.InverseLerp(SliderRangeMin, SliderRangeMax, SliderValue);
sliderItem.AllowJump = SliderAllowJump;
sliderItem.FillStartingPoint = SliderFillStartingPoint;
vItem = sliderItem;
break;
case HoverboardItemType.Text:
vItem = new TextItem();
break;
default:
throw new Exception("Unhandled item type: " + Type);
}
if (!string.IsNullOrEmpty(Id))
{
vItem.Id = Id;
}
vItem.DisplayContainer = gameObject;
vItem.Label = (string.IsNullOrEmpty(Label) ? gameObject.name : Label);
vItem.Width = Width;
vItem.Height = Height;
vItem.IsVisible = IsVisible;
vItem.IsEnabled = IsEnabled;
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
private void BuildItem()
{
switch ( Type ) {
case HoverboardItemType.Selector:
vItem = new SelectorItem();
break;
case HoverboardItemType.Sticky:
vItem = new StickyItem();
break;
case HoverboardItemType.Checkbox:
var checkItem = new CheckboxItem();
checkItem.Value = CheckboxValue;
vItem = checkItem;
break;
case HoverboardItemType.Radio:
var radItem = new RadioItem();
radItem.InitDefaultGroupId(gameObject.transform);
radItem.Value = RadioValue;
radItem.GroupId = RadioGroupId;
vItem = radItem;
break;
case HoverboardItemType.Slider:
var sliderItem = new SliderItem();
sliderItem.Ticks = SliderTicks;
sliderItem.Snaps = SliderSnaps;
sliderItem.RangeMin = SliderRangeMin;
sliderItem.RangeMax = SliderRangeMax;
sliderItem.Value = Mathf.InverseLerp(SliderRangeMin, SliderRangeMax, SliderValue);
sliderItem.AllowJump = SliderAllowJump;
sliderItem.FillStartingPoint = SliderFillStartingPoint;
vItem = sliderItem;
break;
case HoverboardItemType.Text:
vItem = new TextItem();
break;
default:
throw new Exception("Unhandled item type: "+Type);
}
if ( !string.IsNullOrEmpty(Id) ) {
vItem.Id = Id;
}
vItem.DisplayContainer = gameObject;
vItem.Label = (string.IsNullOrEmpty(Label) ? gameObject.name : Label);
vItem.Width = Width;
vItem.Height = Height;
vItem.IsVisible = IsVisible;
vItem.IsEnabled = IsEnabled;
}
} // end of ModularCheckboxList AddText()
/// <summary>
/// Adds a new Checkbox item.
/// </summary>
/// <param name="text">Text label for checkbox</param>
/// <param name="check">Initial state of checkbox.</param>
/// <param name="obj">User defined object ref.</param>
public void AddItem(string text, bool check, object obj)
{
CheckboxItem item = new CheckboxItem(text, check, this, obj);
itemList.Add(item);
if (itemList.Count == 1)
{
item.Selected = true;
}
dirty = true;
} // end of ModularCheckboxList AddText()
internal static CheckboxItem ReadXml(XElement ele)
{
var i = new CheckboxItem
{
Description = ele.Element("Description")?.Value,
Fee = ele.Attribute("Fee")?.Value.ToDecimal(),
Limit = ele.Attribute("Limit")?.Value.ToInt2(),
MeetingTime = ele.Attribute("Time")?.Value.ToDate()
};
i.SmallGroup = (ele.Element("SmallGroup")?.Value ?? i.Description)?.TrimEnd();
return(i);
}
public new static AskCheckboxes ReadXml(XElement ele)
{
var cb = new AskCheckboxes
{
Minimum = ele.Attribute("Minimum")?.Value.ToInt2(),
Maximum = ele.Attribute("Maximum")?.Value.ToInt2(),
Columns = ele.Attribute("Columns")?.Value.ToInt2(),
Label = ele.Element("Label")?.Value,
};
foreach (var ee in ele.Elements("CheckboxItem"))
{
cb.list.Add(CheckboxItem.ReadXml(ee));
}
return(cb);
}
} // end of ModularCheckboxList AddText()
/// <summary>
/// Inserts a new item at the given index.
/// </summary>
/// <param name="text">Text label for checkbox</param>
/// <param name="check">Initial state of checkbox.</param>
/// <param name="index">Index for new item</param>
public void InsertText(string text, bool check, int index)
{
CheckboxItem item = new CheckboxItem(text, check, this);
// Move everything below the new entry down one space.
itemList.Add(itemList[itemList.Count - 1]);
for (int i = itemList.Count - 1; i > index; i--)
{
itemList[i] = itemList[i - 1];
}
itemList[index] = item;
InitDeviceResources(BokuGame.bokuGame.GraphicsDevice);
dirty = true;
} // end of InsertText()
public JSONBoolRow(JObject dict, string key)
{
this.dict = dict;
this.key = key;
setColor(CrhcConstants.COLOR_BLUE_MEDIUM);
setPadding(true, false, false);
// Break up key into separate words.
TextItem textItem = new TextItem(splitCamelCase(key));
addItem(textItem, .8f);
checkbox = new CheckboxItem(dict.Value <bool>(key));
addItem(checkbox, .2f);
setTouchable(true);
}
public static CheckboxItem Parse(Parser parser, int startindent)
{
var i = new CheckboxItem();
if (parser.curr.kw != Parser.RegKeywords.None)
{
throw parser.GetException("unexpected line in CheckBoxes");
}
i.Description = parser.GetLine();
i.SmallGroup = i.Description;
if (parser.curr.indent <= startindent)
{
return(i);
}
var ind = parser.curr.indent;
while (parser.curr.indent == ind)
{
switch (parser.curr.kw)
{
case Parser.RegKeywords.SmallGroup:
i.SmallGroup = parser.GetString(i.Description);
break;
case Parser.RegKeywords.Fee:
i.Fee = parser.GetDecimal();
break;
case Parser.RegKeywords.Limit:
i.Limit = parser.GetNullInt();
break;
case Parser.RegKeywords.Time:
i.MeetingTime = parser.GetDateTime();
break;
default:
throw parser.GetException("unexpected line in CheckboxItem");
}
}
return(i);
}
public new static AskCheckboxes ReadXml(XElement ele)
{
var cb = new AskCheckboxes
{
TargetExtraValue = ele.Attribute("TargetExtraValue").ToBool(),
Minimum = ele.Attribute("Minimum").ToInt2(),
Maximum = ele.Attribute("Maximum").ToInt2(),
Columns = ele.Attribute("Columns").ToInt2(),
Label = ele.Element("Label")?.Value,
};
foreach (var ee in ele.Elements("CheckboxItem"))
{
if (ee.Element("Description")?.Value != null)
{
cb.list.Add(CheckboxItem.ReadXml(ee));
}
}
return(cb);
}
public IActionResult Index()
{
List <CheckboxItem> items = new List <CheckboxItem>();
foreach (var item in _carsRepository.GetAllCars())
{
CheckboxItem ent = new CheckboxItem
{
Id = item.Id,
Name = item.RegistrationNumber,
Entity = "car",
Selected = false
};
items.Add(ent);
}
ReportsIndexViewModel model = new ReportsIndexViewModel
{
CheckboxItems = items
};
return(View(model));
}
internal static CheckboxItem ReadXml(XElement ele)
{
var i = new CheckboxItem
{
Description = ele.Element("Description")?.Value,
Fee = ele.Attribute("Fee")?.Value.ToDecimal(),
Limit = ele.Attribute("Limit")?.Value.ToInt2(),
MeetingTime = ele.Attribute("Time")?.Value.ToDate()
};
i.SmallGroup = ele.Element("SmallGroup")?.Value ?? i.Description;
return i;
}
public static CheckboxItem Parse(Parser parser, int startindent)
{
var i = new CheckboxItem();
if (parser.curr.kw != Parser.RegKeywords.None)
throw parser.GetException("unexpected line in CheckBoxes");
i.Description = parser.GetLine();
i.SmallGroup = i.Description;
if (parser.curr.indent <= startindent)
return i;
var ind = parser.curr.indent;
while (parser.curr.indent == ind)
{
switch (parser.curr.kw)
{
case Parser.RegKeywords.SmallGroup:
i.SmallGroup = parser.GetString(i.Description);
break;
case Parser.RegKeywords.Fee:
i.Fee = parser.GetDecimal();
break;
case Parser.RegKeywords.Limit:
i.Limit = parser.GetNullInt();
break;
case Parser.RegKeywords.Time:
i.MeetingTime = parser.GetDateTime();
break;
default:
throw parser.GetException("unexpected line in CheckboxItem");
}
}
return i;
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
private void BuildItem()
{
switch ( Type ) {
case HovercastItemType.Checkbox:
var checkItem = new CheckboxItem();
checkItem.Value = CheckboxValue;
vItem = checkItem;
break;
case HovercastItemType.Parent:
vItem = new ParentItem();
(vItem as ParentItem).InitChildGroup(GetChildItems);
break;
case HovercastItemType.Radio:
var radItem = new RadioItem();
radItem.InitDefaultGroupId(gameObject.transform);
radItem.Value = RadioValue;
vItem = radItem;
break;
case HovercastItemType.Selector:
vItem = new SelectorItem();
break;
case HovercastItemType.Slider:
var sliderItem = new SliderItem();
sliderItem.Ticks = SliderTicks;
sliderItem.Snaps = SliderSnaps;
sliderItem.RangeMin = SliderRangeMin;
sliderItem.RangeMax = SliderRangeMax;
sliderItem.Value = Mathf.InverseLerp(SliderRangeMin, SliderRangeMax, SliderValue);
sliderItem.AllowJump = SliderAllowJump;
sliderItem.FillStartingPoint = SliderFillStartingPoint;
vItem = sliderItem;
break;
case HovercastItemType.Sticky:
vItem = new StickyItem();
break;
case HovercastItemType.Text:
vItem = new TextItem();
break;
default:
throw new Exception("Unhandled item type: "+Type);
}
if ( !string.IsNullOrEmpty(Id) ) {
vItem.Id = Id;
}
vItem.DisplayContainer = gameObject;
vItem.Label = (string.IsNullOrEmpty(Label) ? gameObject.name : Label);
vItem.Height = RelativeSize;
vItem.IsVisible = IsVisible;
vItem.IsEnabled = IsEnabled;
ISelectorItem selItem = (vItem as ISelectorItem);
if ( selItem != null ) {
selItem.NavigateBackUponSelect = NavigateBackUponSelect;
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
private void BuildItem()
{
switch (Type)
{
case SelectableItemType.Checkbox:
var checkItem = new CheckboxItem();
checkItem.Value = CheckboxValue;
vItem = checkItem;
break;
case SelectableItemType.Parent:
vItem = new ParentItem(GetChildItems);
break;
case SelectableItemType.Radio:
var radItem = new RadioItem();
radItem.Value = RadioValue;
vItem = radItem;
break;
case SelectableItemType.Selector:
vItem = new SelectorItem();
break;
case SelectableItemType.Slider:
var sliderItem = new SliderItem();
sliderItem.Ticks = SliderTicks;
sliderItem.Snaps = SliderSnaps;
sliderItem.RangeMin = SliderRangeMin;
sliderItem.RangeMax = SliderRangeMax;
sliderItem.Value = Mathf.InverseLerp(SliderRangeMin, SliderRangeMax, SliderValue);
sliderItem.AllowJump = SliderAllowJump;
vItem = sliderItem;
break;
case SelectableItemType.Sticky:
vItem = new StickyItem();
break;
default:
throw new Exception("Unhandled item type: " + Type);
}
if (!string.IsNullOrEmpty(Id))
{
vItem.Id = Id;
}
vItem.DisplayContainer = gameObject;
vItem.Label = (string.IsNullOrEmpty(Label) ? gameObject.name : Label);
vItem.Height = RelativeSize;
vItem.IsVisible = IsVisible;
vItem.IsEnabled = IsEnabled;
ISelectableItem selItem = (vItem as ISelectableItem);
if (selItem != null && !(vItem is IParentItem))
{
selItem.NavigateBackUponSelect = NavigateBackUponSelect;
}
}
