/// <summary>
/// Converts to number to the specified numbering type.
/// </summary>
/// <param name="number">The number.</param>
/// <param name="numberingType">Numbering Type required.</param>
/// <param name="suffix">Optional suffix. Default is ". ".</param>
/// <param name="prefix">Optional prefix. Default is "".</param>
/// <returns>String version of the number in the correct numbering type.</returns>
public static string ToNumberingType(
this int number,
NumberingType numberingType,
string suffix = ". ",
string prefix = "")
{
switch (numberingType)
{
case NumberingType.None:
return(string.Empty);
case NumberingType.Number:
return($"{prefix}{number}{suffix}");
case NumberingType.LetterLower:
return($"{prefix}{number.ToLetterLower()}{suffix}");
case NumberingType.LetterUpper:
return($"{prefix}{number.ToLetterLower().ToUpperInvariant()}{suffix}");
case NumberingType.RomanLower:
return($"{prefix}{number.ToRomanLower()}{suffix}");
case NumberingType.RomanUpper:
return($"{prefix}{number.ToRomanLower().ToUpperInvariant()}{suffix}");
default:
throw new ArgumentOutOfRangeException(nameof(numberingType), numberingType, null);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="AgendaItemDto"/> class.
/// </summary>
/// <param name="id">Agenda Item Id.</param>
/// <param name="meetingId">Meeting Id.</param>
/// <param name="parentId">Parent Agenda Item Id.</param>
/// <param name="elderSiblingId">Elder Sibling Agenda Item Id.</param>
/// <param name="text">Text.</param>
/// <param name="agendaItemType">Agenda Item Type.</param>
/// <param name="childNumberingType">Child Numbering Type.</param>
public AgendaItemDto(
Guid id,
Guid meetingId,
Guid?parentId,
Guid?elderSiblingId,
string text,
AgendaItemType agendaItemType,
NumberingType childNumberingType)
{
this.Id = id;
this.MeetingId = meetingId;
this.ParentId = parentId;
this.ElderSiblingId = elderSiblingId;
this.Text = text;
this.AgendaItemType = agendaItemType;
this.ChildNumberingType = childNumberingType;
}
protected override OpResult _Store(NumberingType _obj)
{
if (_obj == null)
{
return(OpResult.NotifyStoreAction(OpResult.ResultStatus.ObjectIsNull, _obj, "NumberingType object cannot be created as it is null"));
}
if (Exists(_obj))
{
ExecuteNonQuery(GetQuery_UpdateQuery(_obj));
return(OpResult.NotifyStoreAction(OpResult.ResultStatus.Updated, _obj));
}
ExecuteNonQuery(GetQuery_InsertQuery(_obj));
_obj.FromDb = true;
return(OpResult.NotifyStoreAction(OpResult.ResultStatus.Created, _obj));
}
public Dictionary <uint, string> ServerEnumToName = new Dictionary <uint, string>(); // m_EnumToName
public override void Unpack(BinaryReader reader)
{
Id = reader.ReadUInt32();
ClientIDNumberingType = (NumberingType)reader.ReadByte();
uint numClientEnumToIDs = reader.ReadCompressedUInt32();
for (var i = 0; i < numClientEnumToIDs; i++)
{
ClientEnumToID.Add(reader.ReadUInt32(), reader.ReadUInt32());
}
ClientNameNumberingType = (NumberingType)reader.ReadByte();
uint numClientEnumToNames = reader.ReadCompressedUInt32();
for (var i = 0; i < numClientEnumToNames; i++)
{
ClientEnumToName.Add(reader.ReadUInt32(), reader.ReadPString(1));
}
ServerIDNumberingType = (NumberingType)reader.ReadByte();
uint numServerEnumToIDs = reader.ReadCompressedUInt32();
for (var i = 0; i < numServerEnumToIDs; i++)
{
ServerEnumToID.Add(reader.ReadUInt32(), reader.ReadUInt32());
}
ServerNameNumberingType = (NumberingType)reader.ReadByte();
uint numServerEnumToNames = reader.ReadCompressedUInt32();
for (var i = 0; i < numServerEnumToNames; i++)
{
ServerEnumToName.Add(reader.ReadUInt32(), reader.ReadPString(1));
}
}
public static List <PageRange> MergeAdjacent(List <PageRange> pageRangesList)
{
int i = pageRangesList.Count;
if (pageRangesList.Count < 1)
{
return(pageRangesList);
}
List <PageRange> newList = new List <PageRange>();
PageNumber minPage = new PageNumber();
PageNumber maxPage = new PageNumber();
int minPageAsInteger = 0;
int maxPageAsInteger = 0;
PageRange first = pageRangesList.FirstOrDefault();
PageRange last = pageRangesList.Last();
NumberingType previousPageRangeNumberingType = new NumberingType();
bool PreviousPageRangeWasNumber = false;
foreach (PageRange pageRange in pageRangesList)
{
PageNumber currentStartPage = pageRange.StartPage;
PageNumber currentEndPage = pageRange.EndPage;
if (currentEndPage == null)
{
currentEndPage = currentStartPage;
}
if (string.IsNullOrEmpty(currentEndPage.OriginalString))
{
currentEndPage = currentStartPage;
}
int currentStartPageAsInteger = 0;
int currentEndPageAsInteger = 0;
bool startPageIsNumber = Int32.TryParse(currentStartPage.OriginalString.Replace(".", ""), out currentStartPageAsInteger);
bool endPageIsNumber = Int32.TryParse(currentEndPage.OriginalString.Replace(".", ""), out currentEndPageAsInteger);
bool IsDiscreteRange = false;
bool SameNumberingType = (previousPageRangeNumberingType == pageRange.NumberingType);
if (pageRangesList.Count == 1)
{
PageRange dummyPageRange = new PageRange();
dummyPageRange = dummyPageRange.Update(pageRange.NumberingType);
Double result;
if (Double.TryParse(pageRange.StartPage.ToString(), out result) == false)
{
newList.Add(dummyPageRange.Update(pageRange.OriginalString));
}
else
{
newList.Add(dummyPageRange.Update(string.Format("{0}-{1}", currentStartPage.OriginalString, currentEndPage.OriginalString)));
}
continue;
}
else if (pageRange == first)
{
minPage = currentStartPage;
maxPage = currentEndPage;
minPageAsInteger = currentStartPageAsInteger;
maxPageAsInteger = currentEndPageAsInteger;
}
else if (!PreviousPageRangeWasNumber || !SameNumberingType || !startPageIsNumber || !endPageIsNumber || pageRange.StartPage.Number == null)
{
IsDiscreteRange = true;
}
else if (currentStartPageAsInteger.CompareTo(minPageAsInteger) >= 0 && currentEndPageAsInteger.CompareTo(maxPageAsInteger) <= 0 && SameNumberingType)
{
// In this case, we don't have to do anything because the current page range is within the range defined by minPage & maxPage
}
else if (currentStartPageAsInteger.CompareTo(maxPageAsInteger + 1) < 1 && SameNumberingType)
{
maxPage = currentEndPage;
maxPageAsInteger = currentEndPageAsInteger;
}
else
{
IsDiscreteRange = true;
}
if (IsDiscreteRange && pageRange == last)
{
PageRange dummyPageRange = new PageRange();
dummyPageRange = dummyPageRange.Update(previousPageRangeNumberingType);
newList.Add(dummyPageRange.Update(string.Format("{0}-{1}", minPage.OriginalString, maxPage.OriginalString)));
minPage = currentStartPage;
maxPage = currentEndPage;
dummyPageRange = dummyPageRange.Update(pageRange.NumberingType);
newList.Add(dummyPageRange.Update(string.Format("{0}-{1}", minPage.OriginalString, maxPage.OriginalString)));
}
else if (IsDiscreteRange)
{
PageRange dummyPageRange = new PageRange();
dummyPageRange = dummyPageRange.Update(previousPageRangeNumberingType);
newList.Add(dummyPageRange.Update(string.Format("{0}-{1}", minPage.OriginalString, maxPage.OriginalString)));
minPage = currentStartPage;
maxPage = currentEndPage;
minPageAsInteger = currentStartPageAsInteger;
maxPageAsInteger = currentEndPageAsInteger;
}
else if ((newList.Count == 0 || !PreviousPageRangeWasNumber || !SameNumberingType) && pageRange == last)
{
PageRange dummyPageRange = new PageRange();
dummyPageRange = dummyPageRange.Update(pageRange.NumberingType);
newList.Add(dummyPageRange.Update(string.Format("{0}-{1}", minPage.OriginalString, maxPage.OriginalString)));
}
previousPageRangeNumberingType = pageRange.NumberingType;
PreviousPageRangeWasNumber = true;
}
return(newList);
} // end MergeAdjacent
public static void InitializeNumberings( )
{
#region NumberingTypes
NumberingTypes = new Dictionary <Guid, NumberingType>();
DataSet ds = BusinessObjectController.RunQuery(@"SELECT * FROM GENumberingTypes");
if (ds != null && ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
{
foreach (DataRow dr in ds.Tables[0].Rows)
{
if (dr["GENumberingTypeID"] == DBNull.Value)
{
continue;
}
NumberingType type = new NumberingType();
#region type
type.ID = ABCHelper.DataConverter.ConvertToGuid(dr["GENumberingTypeID"]);
if (type.ID == Guid.Empty)
{
continue;
}
if (dr["PatternType"] != DBNull.Value)
{
type.PatternType = dr["PatternType"].ToString();
}
type.IsByUser = false;
if (dr["IsByUser"] != DBNull.Value)
{
type.IsByUser = Convert.ToBoolean(dr["IsByUser"]);
}
type.IsByUserGroup = false;
if (dr["IsByUserGroup"] != DBNull.Value)
{
type.IsByUserGroup = Convert.ToBoolean(dr["IsByUserGroup"]);
}
type.IsByEmployee = false;
if (dr["IsByEmployee"] != DBNull.Value)
{
type.IsByEmployee = Convert.ToBoolean(dr["IsByEmployee"]);
}
type.IsByCompanyUnit = false;
if (dr["IsByCompanyUnit"] != DBNull.Value)
{
type.IsByCompanyUnit = Convert.ToBoolean(dr["IsByCompanyUnit"]);
}
type.IsYYMMCount = false;
if (dr["IsYYMMCount"] != DBNull.Value)
{
type.IsYYMMCount = Convert.ToBoolean(dr["IsYYMMCount"]);
}
type.IsYYMMDDCount = false;
if (dr["IsYYMMDDCount"] != DBNull.Value)
{
type.IsYYMMDDCount = Convert.ToBoolean(dr["IsYYMMDDCount"]);
}
type.IsMMDDCount = false;
if (dr["IsMMDDCount"] != DBNull.Value)
{
type.IsMMDDCount = Convert.ToBoolean(dr["IsMMDDCount"]);
}
type.CountingSpace = 2;
if (dr["CountingSpace"] != DBNull.Value)
{
type.CountingSpace = Convert.ToInt32(dr["CountingSpace"]);
}
type.IsByField = false;
if (dr["IsByField"] != DBNull.Value)
{
type.IsByField = Convert.ToBoolean(dr["IsByField"]);
}
if (dr["FieldName"] != DBNull.Value)
{
type.FieldName = dr["FieldName"].ToString();
}
#endregion
if (!NumberingTypes.ContainsKey(type.ID))
{
NumberingTypes.Add(type.ID, type);
}
}
}
#endregion
#region NumberingConfigs
NumberingConfigs = new List <Numbering>();
ds = BusinessObjectController.RunQuery(@"SELECT * FROM GENumberings");
if (ds != null && ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
{
foreach (DataRow dr in ds.Tables[0].Rows)
{
if (dr["GENumberingID"] == DBNull.Value)
{
continue;
}
Numbering number = new Numbering();
#region Number
number.ID = ABCHelper.DataConverter.ConvertToGuid(dr["GENumberingID"]);
if (number.ID == Guid.Empty)
{
continue;
}
if (dr["TableName"] != DBNull.Value)
{
number.TableName = dr["TableName"].ToString();
}
if (dr["ConditionString"] != DBNull.Value)
{
number.ConditionString = dr["ConditionString"].ToString();
}
if (dr["FieldCondition"] != DBNull.Value)
{
number.FieldCondition = dr["FieldCondition"].ToString();
}
if (dr["FieldValue"] != DBNull.Value)
{
number.FieldValue = dr["FieldValue"].ToString();
}
if (dr["SeperateChar"] != DBNull.Value)
{
number.SeperateChar = dr["SeperateChar"].ToString();
}
if (dr["Prefix"] != DBNull.Value)
{
number.Prefix = dr["Prefix"].ToString();
}
if (dr["Suffix"] != DBNull.Value)
{
number.Suffix = dr["Suffix"].ToString();
}
number.IsUsePattern = false;
if (dr["IsUsePattern"] != DBNull.Value)
{
number.IsUsePattern = Convert.ToBoolean(dr["IsUsePattern"]);
}
if (dr["NumberPattern"] != DBNull.Value)
{
number.NumberPattern = dr["NumberPattern"].ToString();
}
#endregion
#region number.MiddleConfigs
number.MiddleConfigs = new List <NumberingType>();
List <Object> lstTypeIDs = BusinessObjectController.GetListObjects(String.Format(@"SELECT FK_GENumberingTypeID FROM GENumberingMiddleItems WHERE FK_GENumberingID ='{0}' ORDER BY MiddleIndex", number.ID));
foreach (Object objID in lstTypeIDs)
{
Guid typeID = ABCHelper.DataConverter.ConvertToGuid(objID);
if (typeID == Guid.Empty)
{
continue;
}
if (NumberingTypes.ContainsKey(typeID))
{
number.MiddleConfigs.Add(NumberingTypes[typeID]);
}
}
#endregion
NumberingConfigs.Add(number);
}
}
#endregion
}
private DbUpdateStatement GetQuery_UpdateQuery(NumberingType _obj)
{
return(DbMgr.CreateUpdateClause("NumberingTypes", GetFields(_obj), "NumberingTypeID", _obj.NumberingTypeID));
}
private DbInsertStatement GetQuery_InsertQuery(NumberingType _obj)
{
Dictionary <string, DbFieldEntry> fields = GetFields(_obj);
return(DbMgr.CreateInsertClause("NumberingTypes", fields));
}
