public async Task <List <ListItemViewModel> > GetItemsForTypeAsync(ListTypeEnum type)
{
var dbResult = await _context.ListItems
.Include(x => x.ListType)
.Include(x => x.Permissions)
.Where(x => x.ListType.Id == type)
.ToListAsync();
var result = dbResult.Select(x => _mapper.Map <ListItemViewModel>(x)).ToList();
return(result);
}
/// <summary>
/// Initialize <see cref="List"/> instance from XML Documentation Comments element.
/// Extracts the <c>type</c> attribute
/// </summary>
/// <param name="element">XML element of XML Documentation Comments</param>
public List(XElement element) : base(element)
{
switch (element?.Attribute("type")?.Value)
{
case "number":
ListType = ListTypeEnum.Number;
break;
case "table":
ListType = ListTypeEnum.Table;
break;
default:
ListType = ListTypeEnum.Bullet;
break;
}
}
public ListType GetListType(SqlConnection _cn = null)
{
SqlConnection cn = _cn == null ? this._cn : _cn;
try
{
ListTypeDB = StaticClass.GetListType(iid, cn, null);
}
catch { ListTypeDB = ListTypeEnum.Unknown; }
switch (ListTypeDB)
{
case ListTypeEnum.LeadFlash:
return(ListType.FLASH);
case ListTypeEnum.LeadSimple:
return(ListType.LEAD);
case ListTypeEnum.SpeedFinal:
return(ListType.SPEED);
case ListTypeEnum.SpeedQualy:
return(ListType.SPEED);
case ListTypeEnum.SpeedQualy2:
if (cn != null && ((SettingsForm.GetSpeedRules(cn) & SpeedRules.BestResultFromTwoQfRounds) == SpeedRules.BestResultFromTwoQfRounds))
{
return(ListType.SPEED_2);
}
else
{
return(ListType.SPEED);
}
case ListTypeEnum.BoulderSuper:
return(ListType.LEAD);
case ListTypeEnum.BoulderSimple:
return(ListType.BOULDER);
default:
return(ListType.UNKNOWN);
}
}
public async Task <List <ListItemViewModel> > GetListItemsAsync(ListTypeEnum typeId)
{
return(await _listItemsService.GetItemsForTypeAsync(typeId));
}
/// <summary>
/// Process a paragraph
/// </summary>
/// <param name="paragraphNode"></param>
/// <param name="prevNode"></param>
/// <param name="nextNode"></param>
private void ProcessParagraph(XmlNode paragraphNode, XmlNode prevNode, XmlNode nextNode, bool inTable, bool drawNewLine)
{
// list settings of the current paragraph
int? currentNumId = GetInt(paragraphNode, "./w:pPr/w:numPr/w:numId/@w:val");
int? currentLevel = GetInt(paragraphNode, "./w:pPr/w:numPr/w:ilvl/@w:val");
bool isList = currentNumId.HasValue && currentLevel.HasValue;
ListTypeEnum currentType = _numberingFn.GetNumberingStyle(currentNumId, currentLevel);
int? prevNumId = null;
int? prevLevel = null;
ListTypeEnum prevType = ListTypeEnum.None;
int? nextNumId = null;
int? nextLevel = null;
ListTypeEnum nextType = ListTypeEnum.None;
// process list data if we are in a list
if (isList)
{
// list settings of the previous paragraph
prevNumId = GetInt(prevNode, "./w:pPr/w:numPr/w:numId/@w:val");
prevLevel = GetInt(prevNode, "./w:pPr/w:numPr/w:ilvl/@w:val");
prevType = _numberingFn.GetNumberingStyle(prevNumId, prevLevel);
// list settings of the next paragraph
nextNumId = GetInt(nextNode, "./w:pPr/w:numPr/w:numId/@w:val");
nextLevel = GetInt(nextNode, "./w:pPr/w:numPr/w:ilvl/@w:val");
nextType = _numberingFn.GetNumberingStyle(nextNumId, nextLevel);
}
// if it is a list
if (isList)
{
ListControl listBegin = _numberingFn.ProcessBeforeListItem(currentNumId.Value, currentLevel.Value, currentType, prevNumId, prevLevel, nextNumId, nextLevel);
// some numbered
if (listBegin.ListType == ListTypeEnum.Numbered)
{
switch (listBegin.NumberedCounterType)
{
// simple numbered begins
case NumberedCounterTypeEnum.None:
_tex.AddStartTag(TagEnum.Enumerate);
_tex.AddNL();
break;
// a new numbered begins
case NumberedCounterTypeEnum.NewCounter:
if (Config.Instance.LaTeXTags.AllowContinuousLists.Value)
{
_tex.AddTextNL(@"\newcounter{numberedCnt" + listBegin.Numbering + "}");
}
_tex.AddStartTag(TagEnum.Enumerate);
_tex.AddNL();
break;
// a numbered loaded
case NumberedCounterTypeEnum.LoadCounter:
_tex.AddStartTag(TagEnum.Enumerate);
_tex.AddNL();
if (Config.Instance.LaTeXTags.AllowContinuousLists.Value)
{
_tex.AddTextNL(@"\setcounter{enumi}{\thenumberedCnt" + listBegin.Numbering + "}");
}
break;
}
}
else if (listBegin.ListType == ListTypeEnum.Bulleted)
{
// bulleted list begins
_tex.AddStartTag(TagEnum.Itemize);
_tex.AddNL();
}
//list item
_tex.AddText(@"\item ");
}
// this will process the real content of the paragraph
ProcessParagraphContent(paragraphNode, prevNode, nextNode, drawNewLine & true, inTable | false, isList);
// in case of list
if (isList)
{
List <ListControl> listEnd = _numberingFn.ProcessAfterListItem(currentNumId.Value, currentLevel.Value, currentType, prevNumId, prevLevel, nextNumId, nextLevel);
// rollback the ended lists
foreach (var token in listEnd)
{
// if a numbered list found
if (token.ListType == ListTypeEnum.Numbered)
{
// save counter of next use
if (token.NumberedCounterType == NumberedCounterTypeEnum.SaveCounter)
{
if (Config.Instance.LaTeXTags.AllowContinuousLists.Value)
{
_tex.AddTextNL("\\setcounter{numberedCnt" + token.Numbering + "}{\\theenumi}");
}
}
_tex.AddEndTag(TagEnum.Enumerate);
_tex.AddNL();
}
else if (token.ListType == ListTypeEnum.Bulleted)
{
// bulleted ended
_tex.AddEndTag(TagEnum.Itemize);
_tex.AddNL();
}
}
}
}
private void btnNxtRound_Click(object sender, EventArgs e)
{
//NewStartList nl;
if (cbRound.SelectedIndex < 0)
{
MessageBox.Show("����� �� ������");
return;
}
int nextID;
//bool b = false;
SqlCommand cmd = new SqlCommand("SELECT l.iid FROM lists l(NOLOCK), lists l1(NOLOCK) WHERE " +
"(l.style=l1.style) AND (l.group_id=l1.group_id) AND (l1.iid=" + listID.ToString() +
") AND (l.round = '" + cbRound.SelectedItem.ToString() + "')", cn);
try { nextID = Convert.ToInt32(cmd.ExecuteScalar()); }
catch { nextID = 0; }
if (nextID > 0)
{
DialogResult dgr = MessageBox.Show("����� �������� ��� ����������.\n�������� ���?",
"�������� ����������", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
if (dgr == DialogResult.No)
{
return;
}
//b = true;
}
else
{
nextID = (int)StaticClass.GetNextIID("lists", cn, "iid", null);
}
DataTable dtTmp = StaticClass.FillResFlash(listID, cn, false, out routeNumber, true, out timeLists, out lists);
Random rnd = new Random();
cmd.CommandText = "SELECT rankingLead, lateAppl FROM Participants P(NOLOCK) WHERE iid = @iid";
cmd.Parameters.Add("@iid", SqlDbType.Int);
List <Starter> data = new List <Starter>();
foreach (DataRow rdd in dtTmp.Rows)
{
if (rdd["��."].ToString() == "Q")
{
Starter st = new Starter();
st.iid = Convert.ToInt32(rdd["�"]);
st.prevPos = Convert.ToInt32(rdd["pos"]);
st.prevStart = 1;
st.random = rnd.NextDouble();
st.ranking = int.MaxValue;
st.lateAppl = false;
cmd.Parameters[0].Value = st.iid;
try
{
SqlDataReader rdss = cmd.ExecuteReader();
while (rdss.Read())
{
try { st.lateAppl = (bool)rdss["lateAppl"]; }
catch { }
try { st.ranking = (int)rdss["rankingLead"]; }
catch { }
break;
}
rdss.Close();
}
catch { }
data.Add(st);
}
else
{
break;
}
}
//cmd.CommandText = "SELECT LQ.iid " +
// " FROM lists LQ(NOLOCK) " +
// " JOIN lists LF(NOLOCK) ON LQ.style = LF.style " +
// " AND LQ.group_id = LF.group_id " +
// " AND LQ.round = '������������ 1'" +
// " WHERE LF.iid = " + listID.ToString();
try
{
cmd.CommandText = "SELECT P.iid, P.lateAppl, P.rankingLead " +
" FROM Participants P(NOLOCK) " +
" JOIN routeResults R(NOLOCK) ON R.climber_id = P.iid " +
" JOIN lists L(NOLOCK) ON L.iid = R.list_id " +
" WHERE L.iid_parent = " + listID.ToString() +
" AND R.preQf = 1 ";
SqlDataReader rdr = cmd.ExecuteReader();
while (rdr.Read())
{
Starter s = new Starter();
s.iid = Convert.ToInt32(rdr["iid"]);
bool exists = false;
foreach (Starter st in data)
{
if (st.iid == s.iid)
{
exists = true;
break;
}
}
if (!exists)
{
s.lateAppl = Convert.ToBoolean(rdr["lateAppl"]);
s.prevPos = 0;
s.prevStart = 0;
s.random = rnd.NextDouble();
try { s.ranking = Convert.ToInt32(rdr["rankingLead"]); }
catch { s.ranking = int.MaxValue; }
data.Add(s);
}
}
rdr.Close();
}
catch { }
//foreach(StartListMember stm in stNum)
//{
// StartListMember stmQ;
// stmQ.iid = stm.iid;
// stmQ.prevPos = stm.prevPos;
// cmd.CommandText = "SELECT rankingLead FROM Participants WHERE iid = " + stm.iid.ToString();
// try { stmQ.ranking = Convert.ToInt32(cmd.ExecuteScalar()); }
// catch { stmQ.ranking = 9999; }
// stmQ.rndDouble = stm.rndDouble;
// starters.Add(stmQ);
//}
cmd.Parameters.Clear();
cmd.Parameters.Add("@i", SqlDbType.Int);
cmd.Parameters[0].Value = listID;
cmd.CommandText = "SELECT g.name, g.iid FROM lists l INNER JOIN Groups g ON l.group_id=g.iid WHERE l.iid=@i";
SqlDataReader rd = cmd.ExecuteReader();
int group_id = 0;
string group_name = "";
while (rd.Read())
{
group_id = Convert.ToInt32(rd[1]);
group_name = rd[0].ToString();
break;
}
rd.Close();
//int nextID = (int)StaticMethods.GetNextIID("lists", cn);
ListTypeEnum newListType = ListTypeEnum.LeadSimple;
List <int> childLists = new List <int>();
try
{
//cmd.Transaction = cn.BeginTransaction();
cmd.Transaction = cn.BeginTransaction();
cmd.CommandText = "INSERT INTO lists(iid,group_id,style,round,online) VALUES (@i,@g,@s,@r,@o)";
cmd.Parameters[0].Value = nextID;
cmd.Parameters.Add("@g", SqlDbType.Int);
cmd.Parameters[1].Value = group_id;
cmd.Parameters.Add("@s", SqlDbType.VarChar);
cmd.Parameters[2].Value = "���������";
cmd.Parameters.Add("@r", SqlDbType.VarChar);
cmd.Parameters[3].Value = cbRound.SelectedItem.ToString();
cmd.Parameters.Add("@o", SqlDbType.Bit);
cmd.Parameters[4].Value = StaticClass.IsListOnline(listID, cn, cmd.Transaction);
cmd.ExecuteNonQuery();
cmd.CommandText = "UPDATE lists SET next_round=@i WHERE iid=@g";
cmd.Parameters[1].Value = listID;
cmd.ExecuteNonQuery();
cmd.CommandText = "UPDATE lists SET prev_round=@g WHERE iid=@i";
cmd.ExecuteNonQuery();
//nl = new NewStartList(false, group_name, "���������", cbRound.SelectedItem.ToString());
//nl.ShowDialog();
Sorting sorting = new Sorting(data, StartListMode.NotFirstRound, true);
sorting.ShowDialog();
if (sorting.Cancel)
//if (nl.type == StartListType.Cancel)
{
//cmd.Transaction.Rollback();
try { cmd.Transaction.Rollback(); }
catch
{
cmd.CommandText = "DELETE FROM lists WHERE iid = " + nextID.ToString();
try { cmd.ExecuteNonQuery(); }
catch { }
}
return;
}
cmd.Parameters.Clear();
cmd.CommandText = "UPDATE lists SET listType = @ltp WHERE iid = " + nextID.ToString();
cmd.Parameters.Add("@ltp", SqlDbType.VarChar, 255);
newListType = sorting.RoundFlash ? ListTypeEnum.LeadFlash : ListTypeEnum.LeadSimple;
cmd.Parameters[0].Value = newListType.ToString();
cmd.ExecuteNonQuery();
if (newListType == ListTypeEnum.LeadFlash)
{
cmd.CommandText = "UPDATE lists SET routeNumber = " + sorting.SettedRouteNumber.ToString() +
" WHERE iid = " + nextID.ToString();
cmd.ExecuteNonQuery();
for (int i = 1; i <= sorting.SettedRouteNumber; i++)
{
cmd.Parameters.Clear();
int curId = (int)StaticClass.GetNextIID("lists", cn, "iid", cmd.Transaction);
cmd.CommandText = "INSERT INTO lists(iid,group_id,style,round,online,listType,iid_parent) VALUES (@i,@g,@s,@r,@o,@lt,@ip)";
cmd.Parameters.Add("@i", SqlDbType.Int);
cmd.Parameters[0].Value = curId;
childLists.Add(curId);
cmd.Parameters.Add("@g", SqlDbType.Int);
cmd.Parameters[1].Value = group_id;
cmd.Parameters.Add("@s", SqlDbType.VarChar);
cmd.Parameters[2].Value = "���������";
cmd.Parameters.Add("@r", SqlDbType.VarChar);
cmd.Parameters[3].Value = cbRound.SelectedItem.ToString() + " ������ " + i.ToString();
cmd.Parameters.Add("@o", SqlDbType.Bit);
cmd.Parameters[4].Value = StaticClass.IsListOnline(listID, cn, cmd.Transaction);
cmd.Parameters.Add("@lt", SqlDbType.VarChar, 255);
cmd.Parameters[5].Value = ListTypeEnum.LeadSimple.ToString();
cmd.Parameters.Add("@ip", SqlDbType.Int);
cmd.Parameters[6].Value = nextID;
cmd.ExecuteNonQuery();
}
}
//bool b;
/*
* do
* {
* switch (nl.type)
* {
* case StartListType.General:
* starters.Sort(new RandomListComparer());
* b = false;
* break;
* case StartListType.Reverse:
* starters.Sort(new NextRoundComparer());
* b = false;
* break;
* case StartListType.Cancel:
* cmd.Transaction.Rollback();
* return;
* default:
* MessageBox.Show("��� ���������� ����������������. �������� ������ ���.");
* nl.ShowDialog();
* b = true;
* break;
* }
* } while (b);*/
//sorting.Starters
if (newListType == ListTypeEnum.LeadSimple)
{
childLists.Clear();
childLists.Add(nextID);
}
for (int i = 0; i < sorting.Count && i < childLists.Count; i++)
{
InsertToList(childLists[i], sorting[i], cn, cmd.Transaction);
}
cmd.Transaction.Commit();
MessageBox.Show("�������� ������. iid = " + nextID.ToString());
}
catch (SqlException ex)
{
MessageBox.Show(ex.Message);
try { cmd.Transaction.Rollback(); }
catch { }
return;
}
}
private void AddToResponseQueue(ListTypeEnum type, string[] response)
{
_responsesQueue.Enqueue(new KeyValuePair <ListTypeEnum, string[]>(type, response));
_responsesQueueSemaphore.Release();
}
private void IoListProcess(IList <string> listResponse, ListTypeEnum listType)
{
var ports = new List <IRouterPort>();
var crosspoints = new List <CrosspointInfo>();
foreach (var line in listResponse)
{
var lineParams = line.Split(' ');
try
{
switch (listType)
{
case ListTypeEnum.Input:
case ListTypeEnum.Output:
{
var split = line.Split(new [] { ' ' }, 2, StringSplitOptions.RemoveEmptyEntries);
if (split.Length < 1 || !short.TryParse(split[0], out var numer))
{
throw new ArgumentException("Too few parameters");
}
ports.Add(new RouterPort(numer, split.ElementAtOrDefault(1) ?? string.Empty));
break;
}
case ListTypeEnum.CrosspointChange:
case ListTypeEnum.CrosspointStatus:
{
crosspoints.Add(new CrosspointInfo(short.Parse(lineParams[1]), short.Parse(lineParams[0])));
break;
}
}
}
catch (Exception ex)
{
Logger.Error($"Failed to generate port from response. [Line: {line} message: {ex.Message}]");
Debug.WriteLine($"Failed to generate port from response. [\n{line}\n{ex.Message}]");
}
}
switch (listType)
{
case ListTypeEnum.Input:
{
OnInputPortsListReceived?.Invoke(this, new EventArgs <IEnumerable <IRouterPort> >(ports));
_inputPortsListRequested = false;
break;
}
case ListTypeEnum.Output:
{
OnOutputPortsListReceived?.Invoke(this, new EventArgs <IEnumerable <IRouterPort> >(ports));
_outputPortsListRequested = false;
break;
}
case ListTypeEnum.CrosspointStatus:
{
OnInputPortChangeReceived?.Invoke(this, new EventArgs <IEnumerable <CrosspointInfo> >(crosspoints));
_currentInputPortRequested = false;
break;
}
case ListTypeEnum.CrosspointChange:
{
OnInputPortChangeReceived?.Invoke(this, new EventArgs <IEnumerable <CrosspointInfo> >(crosspoints));
break;
}
}
}
public ListControl ProcessBeforeListItem(int currentNumId, int currentLevel, ListTypeEnum currentType,
int?previousNumId, int?previousLevel,
int?nextNumId, int?nextLevel)
{
// this is the first list element
if (!previousNumId.HasValue || !previousLevel.HasValue)
{
ListInfo listInfo = new ListInfo(currentNumId, currentLevel, currentType);
_listStyle.Add(listInfo);
string suffix = string.Empty;
if (currentType == ListTypeEnum.Numbered && currentLevel == 0)
{
if (_visitedFirstLevelNumberings.ContainsKey(listInfo.HashCode))
{
return(new ListControl(ListTypeEnum.Numbered, NumberedCounterTypeEnum.LoadCounter, UniqueString(listInfo.NumId)));
}
else
{
_visitedFirstLevelNumberings.Add(listInfo.HashCode, string.Empty);
return(new ListControl(ListTypeEnum.Numbered, NumberedCounterTypeEnum.NewCounter, UniqueString(listInfo.NumId)));
}
}
return(new ListControl(currentType, NumberedCounterTypeEnum.None, null));
}
else //this is not the first list element
{
int listTopNumId = _listStyle[_listStyle.Count - 1].NumId;
int listTopLevel = _listStyle[_listStyle.Count - 1].Level;
// the same list continues
if (listTopNumId == currentNumId)
{
// the same list continues with the same level
if (listTopLevel == currentLevel)
{
//nothing to do
}
else // the same list continues but with different level
{
// a new level started
if (currentLevel > listTopLevel)
{
_listStyle.Add(new ListInfo(currentNumId, currentLevel, currentType));
return(new ListControl(currentType, NumberedCounterTypeEnum.None, null));
}
else // the previous level ended
{
//nothing to do
}
}
}
else // there was an other list before this
{
int indexOfPrevious = FindListElement(previousNumId.Value, previousLevel.Value);
//a new list started because the previous cannot find in the list
if (indexOfPrevious != -1)
{
_listStyle.Add(new ListInfo(currentNumId, currentLevel, currentType));
return(new ListControl(currentType, NumberedCounterTypeEnum.None, null));
}
else // a previously broken list found
{
// nothing to do
}
}
}
return(new ListControl(ListTypeEnum.None, NumberedCounterTypeEnum.None, null));
}
public ListControl(ListTypeEnum listType, NumberedCounterTypeEnum numberedCounterType, string numbering)
{
this.ListType = listType;
this.NumberedCounterType = numberedCounterType;
this.Numbering = numbering;
}
public ListInfo(int numId, int level, ListTypeEnum style)
{
this.NumId = numId;
this.Level = level;
this.Style = style;
}
public List <ListControl> ProcessAfterListItem(int currentNumId, int currentLevel, ListTypeEnum currentType,
int?previousNumId, int?previousLevel,
int?nextNumId, int?nextLevel)
{
//if this is the last list element
if (!nextNumId.HasValue || !nextLevel.HasValue)
{
ListControl suffix = new ListControl(ListTypeEnum.None, NumberedCounterTypeEnum.None, null);
if (_listStyle.Count > 0)
{
ListInfo listInfo = _listStyle[0];
if (listInfo.Style == ListTypeEnum.Numbered && listInfo.Level == 0)
{
if (_visitedFirstLevelNumberings.ContainsKey(listInfo.HashCode))
{
suffix.NumberedCounterType = NumberedCounterTypeEnum.SaveCounter;
suffix.Numbering = UniqueString(listInfo.NumId);
}
}
}
List <ListControl> ends = GetReverseListTilIndex(0);
if (ends.Count > 0)
{
var first = ends[0];
first.NumberedCounterType = suffix.NumberedCounterType;
first.Numbering = suffix.Numbering;
ends.RemoveAt(0);
ends.Insert(0, first);
}
_listStyle.Clear();
return(ends);
}
else //a list
{
// the same list continues
if (currentNumId == nextNumId.Value && currentLevel == nextLevel.Value)
{
//nothing to do
}
else // other list encountered
{
int indexOfNext = FindListElement(nextNumId.Value, nextLevel.Value);
//if the next list element cannot find, then a unknown new list will start
if (indexOfNext == -1)
{
//nothing to do
}
else // else end of list
{
//remove listStyles and sign ends
List <ListControl> ends = GetReverseListTilIndex(indexOfNext + 1);
_listStyle.RemoveRange(indexOfNext + 1, _listStyle.Count - indexOfNext - 1);
return(ends);
}
}
}
return(new List <ListControl>());
}
