public void IncrementGroupOrderType(int position, int startPosition)
{
GroupTypeOrder previousGto = null;
int i = position + 1;
while (i <= startPosition)
{
GroupTypeOrder currentGto = GroupTypeOrderCollection[i];
if (i > 0)
{
previousGto = GroupTypeOrderCollection[i - 1];
if (currentGto.GroupTypeID.Equals(previousGto.GroupTypeID))
{
currentGto.GroupOrder = previousGto.GroupOrder;
}
else
{
GroupTypeOrderCollection[i].GroupOrder++;
}
}
else
{
GroupTypeOrderCollection[i].GroupOrder++;
}
i++;
}
_wvm._changedFlag = true;
}
void HandleToolboxGroupDrop(ToolboxGroup tbg)
{
GroupTypeOrder targetGroupTypeOrder = MyGroupTypeOrder;
GroupType draggedGroupType = tbg.Group;
GTViewModel.InsertGroup(targetGroupTypeOrder, draggedGroupType);
}
public void DropToolboxGroupOnGroup()
{
glvm.PopulateGTList();
List <ToolboxGroup> tbgList = glvm.DesignItemsView.Cast <ToolboxGroup>().ToList();
ToolboxGroup tbg = tbgList.Find(x => x.Group.GroupTypeID.Equals("16"));
ObservableCollection <GroupTypeOrder> gtoList = wvm.PageList[14].GroupTypeOrders; // page 15
ObservableCollection <GroupTypeOrder> unmodifiedgtoList = DeepCopyGroupTypeOrderList(gtoList);
GroupTypeOrder targetGroupTypeOrder = gtoList[2];
gtvm.Group = targetGroupTypeOrder.Group;
gtvm.GroupTypeOrderCollection = gtoList;
gtvm.AdjustGroupOrder();
gtvm.InsertGroup(targetGroupTypeOrder, tbg.Group);
int targetIndex = gtoList.IndexOf(targetGroupTypeOrder);
Assert.AreEqual(targetIndex, 3);
int i = targetIndex + 1;
while (i < unmodifiedgtoList.Count)
{
Assert.AreEqual(unmodifiedgtoList[i].Group, gtoList[i - 1].Group);
Assert.AreEqual(unmodifiedgtoList[i].GroupOrder + 1, gtoList[i - 1].GroupOrder);
i++;
}
}
/// <summary>
/// Adjust the order of the groups. Takes duplications of a group into account
/// </summary>
public void AdjustGroupOrder()
{
GroupTypeOrder previousGto = null;
int i = 0;
int skipped = 0;
while (i < GroupTypeOrderCollection.Count)
{
GroupTypeOrder currentGto = GroupTypeOrderCollection[i];
if (i > 0)
{
previousGto = GroupTypeOrderCollection[i - 1];
if (currentGto.GroupTypeID.Equals(previousGto.GroupTypeID))
{
currentGto.GroupOrder = previousGto.GroupOrder;
skipped++;
}
else
{
GroupTypeOrderCollection[i].GroupOrder = i + 1 - skipped;
}
}
else
{
GroupTypeOrderCollection[i].GroupOrder = i + 1;
}
i++;
}
_wvm._changedFlag = true;
}
public void DecrementGroupOrderType(int targetPosition, int draggedPosition)
{
GroupTypeOrder previousGto = null;
int i = GroupTypeOrderCollection.Count - 1;
int counter = GroupTypeOrderCollection.Count - FindNoOfDuplicates() + 1;
while (i >= 0)
{
GroupTypeOrder currentGto = GroupTypeOrderCollection[i];
if (i < GroupTypeOrderCollection.Count - 1)
{
previousGto = GroupTypeOrderCollection[i + 1];
if (currentGto.GroupTypeID.Equals(previousGto.GroupTypeID))
{
currentGto.GroupOrder = previousGto.GroupOrder;
}
else
{
counter--;
GroupTypeOrderCollection[i].GroupOrder = counter;
}
}
else
{
counter--;
GroupTypeOrderCollection[i].GroupOrder = counter;
}
i--;
}
_wvm._changedFlag = true;
}
public GroupTypeOrder GetGroupType(Grid grid)
{
Border b = (Border)grid.GetCellChild(0, 0);
GroupTypeOrder gto = (GroupTypeOrder)b.DataContext;
return(gto);
}
/// <summary>
/// Removes departments which do no exist in the list of departments for a group
/// </summary>
/// <param name="gto"></param>
/// <param name="departmentList"></param>
public void CleanUpRemovedDepartments(GroupTypeOrder gto, List <string> departmentList)
{
int j = 0;
while (j < GroupTypeOrderCollection.Count)
{
GroupTypeOrder gtoItem = GroupTypeOrderCollection[j];
if (gtoItem.GroupTypeID.Equals(gto.GroupTypeID))
{
//bool remove = true;
//int i = 0;
//while (i < departmentList.Count && remove)
//{
// if (gtoItem.DepartmentID.Equals(departmentList[i]))
// {
// remove = false;
// }
// i++;
//}
//if (remove)
//{
// GroupTypeOrderCollection.Remove(gtoItem);
//}
if (!departmentList.Any(x => x.Equals(gtoItem.DepartmentID)))
{
GroupTypeOrderCollection.Remove(gtoItem);
j--;
}
}
j++;
}
}
private void InsertGroupItem(GroupTypeOrder groupTypeOrder, int row, int column)
{
Border bCell = GetCellItem(row, column);
bCell.DataContext = groupTypeOrder;
Grid gridGroupCell = (Grid)bCell.Child;
TextBlock tb = (TextBlock)gridGroupCell.Children[1];
WorkspaceViewModel wvm = WorkspaceViewModel.Instance;
List <GroupTypeOrder> gtoList = wvm.PageList.First(x => x.PageTypeID.Equals(wvm.SelectedPage)).GroupTypeOrders.Where(x => x.GroupTypeID.Equals(MyGroupTypeOrder.GroupTypeID)).ToList();
List <string> departmentList = new List <string>();
foreach (GroupTypeOrder gto in gtoList)
{
departmentList.Add(gto.DepartmentID);
}
departmentList.Sort();
MultiBinding multiBinding = new MultiBinding();
multiBinding.StringFormat = "{0} ({1})";
multiBinding.Bindings.Add(new Binding("Group.GroupHeader"));
multiBinding.Bindings.Add(new Binding()
{
Source = string.Join(",", departmentList.ToArray())
});
tb.SetBinding(TextBlock.TextProperty, multiBinding);
}
private static void OnGroupTableChangedCallBack(
DependencyObject sender, DependencyPropertyChangedEventArgs e)
{
GroupTableUserControl groupTableUserControl = sender as GroupTableUserControl;
GroupTypeOrder groupTypeOrder = (GroupTypeOrder)e.NewValue;
groupTableUserControl.MyGroupTypeOrder = groupTypeOrder;
}
public void RemoveGroup(GroupTypeOrder gto)
{
List <GroupTypeOrder> gtoList = FindDuplicatesOfGroups(gto);
foreach (GroupTypeOrder groupTypeOrder in gtoList)
{
GroupTypeOrderCollection.Remove(groupTypeOrder);
}
//RefreshGroupOrder();
AdjustGroupOrder();
}
public void EditGroupDepartment()
{
string pageTypeID = "16";
PageType page = _wvm.PageList.FirstOrDefault(x => x.PageTypeID.Equals(pageTypeID));
ObservableCollection <GroupTypeOrder> groups = page.GroupTypeOrders;
GroupTypeOrder renameGroup = groups[0];
List <string> departments = new List <string>();
string department1 = "2";
string department2 = "3";
departments.Add(department1);
departments.Add(department2);
string engTransText = "Rename group";
string danTransText = "Omdøb gruppe";
_groupTableVm.GroupTypeOrderCollection = groups;
_groupTableVm.EditGroup(renameGroup, engTransText, danTransText, departments);
//Export to excel with the group in it
_exExcel.CreateNewExcel(_exportPath);
//Import the new excel file
_impExcel.ImportExcelConfiguration(_exportPath);
#region ktUIGroupOrder tests
List <ktUIGroupOrder> groupOrders =
_impExcel._workSheetktUIGroupOrder.ktUIGroupOrderList.Where(x => x.PageTypeID.Equals(pageTypeID) && x.GroupTypeID.Equals(renameGroup.GroupTypeID))
.ToList();
Assert.AreEqual(groupOrders.Count, 2);
Assert.IsTrue(groupOrders.Exists(x => x.DepartmentID.Equals(department1)));
Assert.IsTrue(groupOrders.Exists(x => x.DepartmentID.Equals(department2)));
foreach (ktUIGroupOrder go in groupOrders)
{
if (go.DepartmentID.Equals(department1))
{
Assert.AreEqual(go.PageTypeID, pageTypeID);
Assert.AreEqual(go.GroupTypeID, renameGroup.GroupTypeID);
}
if (go.DepartmentID.Equals(department2))
{
Assert.AreEqual(go.PageTypeID, pageTypeID);
Assert.AreEqual(go.GroupTypeID, renameGroup.GroupTypeID);
}
}
#endregion
}
/// <summary>
/// Inserts a group at the end of a list. Used when dropping a new group from toolbox on a page
/// </summary>
/// <param name="gt"></param>
/// <param name="pageTypeID"></param>
public void InsertGroupLast(GroupType gt, string pageTypeID)
{
GroupTypeOrder gtoCompare = GroupTypeOrderCollection.Last();
GroupTypeOrder gto = new GroupTypeOrder();
gto.DepartmentID = "-1";
gto.PageTypeID = pageTypeID;
gto.Group = gt;
gto.GroupTypeID = gt.GroupTypeID;
gto.GroupOrder = gtoCompare.GroupOrder + 1;
GroupTypeOrderCollection.Add(gto);
}
/// <summary>
/// Edits group in terms of translation text and departments
/// </summary>
/// <param name="gto">the group to be edit</param>
/// <param name="engTransText">english text</param>
/// <param name="danTransText">danish text</param>
/// <param name="departmentList">departments to be shown at</param>
public void EditGroup(GroupTypeOrder gto, string engTransText, string danTransText, List <string> departmentList)
{
//PageType page = (from a in PageList where a.PageTypeID.Equals(pageTypeID) select a).FirstOrDefault();
//GroupTypeOrder group = (from b in page.GroupTypeOrders where b.GroupTypeID.Equals(groupTypeID) select b).FirstOrDefault();
gto.Group.DanishTranslationText = danTransText;
gto.Group.EnglishTranslationText = engTransText;
RefreshLanguage(gto);
//if(departmentList.Contains("-1") && departmentList.Count == 1)
//{
// GroupTypeOrder gtoRemoved = GroupTypeOrderCollection.First(x => x.DepartmentID.Equals("-1");
//}
//if(GroupTypeOrderCollection.Any<
foreach (string departmentID in departmentList)
{
int i = 0;
bool departmentIDExist = false;
while (i < GroupTypeOrderCollection.Count && !departmentIDExist)
{
if (departmentID.Equals(GroupTypeOrderCollection[i].DepartmentID) && GroupTypeOrderCollection[i].GroupTypeID.Equals(gto.GroupTypeID))
{
departmentIDExist = true;
}
i++;
}
if (!departmentIDExist)
{
GroupTypeOrder clonedGto = new GroupTypeOrder();
clonedGto.DepartmentID = departmentID;
clonedGto.Group = gto.Group;
clonedGto.GroupOrder = gto.GroupOrder;
clonedGto.GroupTypeID = gto.GroupTypeID;
clonedGto.PageTypeID = gto.PageTypeID;
GroupTypeOrderCollection.Add(clonedGto);
}
//if (!GroupTypeOrderCollection.Any(x => x.DepartmentID.Equals(departmentID)) && GroupTypeOrderCollection.Any(x => x.GroupTypeID.Equals(gto.GroupTypeID)))
//{
// GroupTypeOrder clonedGto = new GroupTypeOrder();
// clonedGto.DepartmentID = departmentID;
// clonedGto.Group = gto.Group;
// clonedGto.GroupOrder = gto.GroupOrder;
// clonedGto.GroupTypeID = gto.GroupTypeID;
// clonedGto.PageTypeID = gto.PageTypeID;
// GroupTypeOrderCollection.Add(clonedGto);
//}
}
CleanUpRemovedDepartments(gto, departmentList);
GroupTypeOrderCollection.Sort(gtoItem => gtoItem.GroupOrder);
}
void HandleGroupTableDrop(object sender, DragEventArgs e)
{
Grid targetGroupTable = e.Data.GetData("System.Windows.Controls.Grid") as Grid;
GroupTableUserControl gtUC = (GroupTableUserControl)targetGroupTable.Parent;
GroupTypeOrder targetGroupTypeOrder = MyGroupTypeOrder;
GroupTypeOrder draggedGroupTypeOrder = gtUC.MyGroupTypeOrder;
if (!targetGroupTypeOrder.GroupTypeID.Equals(draggedGroupTypeOrder.GroupTypeID))
{
GTViewModel.HandleGroupTableDrop(targetGroupTypeOrder, draggedGroupTypeOrder);
}
}
/// <summary>
/// Finds duplications of a group. Duplications are caused by having multiple departments
/// </summary>
/// <param name="draggedGto"></param>
/// <returns></returns>
public List <GroupTypeOrder> FindDuplicatesOfGroups(GroupTypeOrder draggedGto)
{
List <GroupTypeOrder> gtoList = new List <GroupTypeOrder>();
foreach (GroupTypeOrder gto in GroupTypeOrderCollection)
{
if (gto.GroupTypeID.Equals(draggedGto.GroupTypeID))
{
gtoList.Add(gto);
}
}
return(gtoList);
}
/// <summary>
/// Finds the index of the last occurrence of a group. Used for group with multiple departments
/// </summary>
/// <param name="gto"></param>
/// <returns></returns>
public int FindLastOccurrence(GroupTypeOrder gto)
{
int i = GroupTypeOrderCollection.IndexOf(GroupTypeOrderCollection.First(x => x.GroupTypeID.Equals(gto.GroupTypeID)));
while (i < GroupTypeOrderCollection.Count)
{
if (!GroupTypeOrderCollection[i].GroupTypeID.Equals(gto.GroupTypeID))
{
break;
}
i++;
}
return(i);
}
public void InsertGroup(GroupTypeOrder targetGroupTypeOrder, GroupType groupType)
{
int targetPosition = GroupTypeOrderCollection.IndexOf(targetGroupTypeOrder);
GroupTypeOrder gto = new GroupTypeOrder();
gto.DepartmentID = "-1";
gto.GroupOrder = targetGroupTypeOrder.GroupOrder - 1;
gto.PageTypeID = targetGroupTypeOrder.PageTypeID;
gto.GroupTypeID = groupType.GroupTypeID;
gto.Group = groupType;
GroupTypeOrderCollection.Insert(targetPosition, gto);
}
/// <summary>
/// Creates a copy of GroupTypeOrderList. GroupTypeOrder are deep copied and GroupType are referenced
/// </summary>
/// <param name="gtoList"></param>
/// <returns></returns>
public ObservableCollection <GroupTypeOrder> DeepCopyGroupTypeOrderList(ObservableCollection <GroupTypeOrder> gtoList)
{
ObservableCollection <GroupTypeOrder> deepCopyGroupTypeOrders = new ObservableCollection <GroupTypeOrder>();
foreach (GroupTypeOrder gto in gtoList)
{
GroupTypeOrder clonedgto = new GroupTypeOrder();
clonedgto.DepartmentID = gto.DepartmentID;
clonedgto.Group = gto.Group;
clonedgto.GroupOrder = gto.GroupOrder;
clonedgto.GroupTypeID = gto.GroupTypeID;
clonedgto.PageTypeID = gto.PageTypeID;
deepCopyGroupTypeOrders.Add(clonedgto);
}
return(deepCopyGroupTypeOrders);
}
void HandleItemTypeDrop(object sender, DragEventArgs e)
{
Border target = GetBorderByDropEvent(e);
ItemTypeOrder targetItemType = (ItemTypeOrder)target.DataContext;
Border target2 = e.Data.GetData("System.Windows.Controls.Border") as Border;
ItemTypeOrder draggedItemType = (ItemTypeOrder)target2.DataContext;
Grid groupTable = (Grid)target2.Parent;
GroupTypeOrder gto = GetGroupType(groupTable);
GroupType gt = gto.Group;
GTViewModel.HandleDropAndDropBetweenItems(gt, targetItemType, draggedItemType);
gt.ItemOrder.Sort(i => i.ItemOrder);
RefreshGroupTable();
}
private void btnRemoveGroup_Click(object sender, RoutedEventArgs e)
{
if (MessageBox.Show("Are you sure?", "Confirmation", MessageBoxButton.YesNo, MessageBoxImage.Warning) == MessageBoxResult.Yes)
{
Button btn = sender as Button;
btn.Visibility = Visibility.Hidden;
StackPanel sp = (StackPanel)btn.Parent;
Grid gridCell = (Grid)sp.Parent;
Border border = (Border)gridCell.Parent;
GroupTypeOrder gto = (GroupTypeOrder)border.DataContext;
GTViewModel.RemoveGroup(gto);
RefreshGroupTable();
DisableAllowDropByNewLineItem();
}
}
public void HandleGroupTableDrop(GroupTypeOrder targetGroupTypeOrder, GroupTypeOrder draggedGroupTypeOrder)
{
List <GroupTypeOrder> draggedMultipleGTOList = FindDuplicatesOfGroups(draggedGroupTypeOrder); // For a particular group, there is an instance for each department
//int draggedPosition = FindLastOccurrence(draggedGroupTypeOrder);
//List<GroupTypeOrder> targetMultipleGTOList = FindDuplicatesOfGroups(targetGroupTypeOrder);
int targetPosition = GroupTypeOrderCollection.IndexOf(targetGroupTypeOrder);
double targetGroupOrder = targetGroupTypeOrder.GroupOrder;
foreach (GroupTypeOrder gto in draggedMultipleGTOList)
{
GroupTypeOrderCollection.Remove(gto); // prepare for moving the group(s)
}
if (draggedGroupTypeOrder.GroupOrder > targetGroupTypeOrder.GroupOrder)
{
foreach (GroupTypeOrder gto in draggedMultipleGTOList)
{
GroupTypeOrderCollection.Insert(targetPosition, gto);
}
}
else
{
if (GroupTypeOrderCollection.Max(x => x.GroupOrder) != targetGroupOrder)
{
foreach (GroupTypeOrder gto in draggedMultipleGTOList)
{
targetPosition = FindLastOccurrence(targetGroupTypeOrder); // make sure that the group(s) are inserted at the end of a sequence of duplicated gropus
GroupTypeOrderCollection.Insert(targetPosition, gto);
}
}
else
{
foreach (GroupTypeOrder gto in draggedMultipleGTOList)
{
GroupTypeOrderCollection.Add(gto);
}
}
}
AdjustGroupOrder();
GroupTypeOrderCollection.Sort(gto => gto.GroupOrder);
_wvm._changedFlag = true;
}
void CheckItemTypeDrop(object sender, DragEventArgs e)
{
Border borderCell = GetBorderByDropEvent(e);
int row = Grid.GetRow(borderCell);
Border draggedBorderCell = (Border)e.Data.GetData("System.Windows.Controls.Border");
Grid draggedGridCell = (Grid)draggedBorderCell.Child;
TextBlock draggedTextBlock = (TextBlock)draggedGridCell.Children[1];
int draggedItemRow = Grid.GetRow(draggedBorderCell);
Grid draggedGroupTable = (Grid)draggedBorderCell.Parent;
GroupTypeOrder draggedGto = GetGroupType(draggedGroupTable);
GroupTypeOrder gto = GetGroupType(GroupTable);
GroupType draggedGt = draggedGto.Group;
GroupType gt = gto.Group;
ItemTypeOrder ito = (ItemTypeOrder)draggedTextBlock.DataContext;
ItemType it = ito.Item;
if (borderCell.DataContext is ItemTypeOrder)
{
//if (!draggedGt.GroupTypeID.Equals(gt.GroupTypeID))
//{
// e.Effects = DragDropEffects.None;
//}
//else
//{
bool containsRow = CheckForNewLineItem(row);
if (it.DesignID.Equals("198") && containsRow && draggedItemRow != row)
{
e.Effects = DragDropEffects.None;
}
else
{
e.Effects = DragDropEffects.Move;
}
//}
}
if (borderCell.DataContext is GroupTypeOrder)
{
e.Effects = DragDropEffects.None;
}
}
private void btnRemoveItem_Click(object sender, RoutedEventArgs e)
{
Button btn = sender as Button;
btn.Visibility = Visibility.Hidden;
Grid gridCell = (Grid)btn.Parent;
Border border = (Border)gridCell.Parent;
Grid gridGroupTable = (Grid)border.Parent;
GroupTypeOrder gto = (GroupTypeOrder)gridGroupTable.DataContext;
GroupType gt = gto.Group;
ItemTypeOrder itToBeDeleted = (ItemTypeOrder)border.DataContext;
//gt.ItemOrder.Remove(itToBeDeleted);
GTViewModel.RemoveItemTypeOrder(gt, itToBeDeleted);
GTViewModel.AdjustItemOrder(gt);
RefreshGroupTable();
DisableAllowDropByNewLineItem();
PreviousGroupTypeOrder = null;
}
public void DropBetweenGroupsOnPageTestOne()
{
ObservableCollection <GroupTypeOrder> gtoList = wvm.PageList[14].GroupTypeOrders; // page 15
GroupTypeOrder targetGroupTypeOrder = wvm.PageList[14].GroupTypeOrders[0]; //drop target = first group
GroupTypeOrder draggedGroupTypeOrder = wvm.PageList[14].GroupTypeOrders[3]; //dragged group = last group
gtvm.GroupTypeOrderCollection = gtoList;
gtvm.AdjustGroupOrder();
ObservableCollection <GroupTypeOrder> unmodifiedgtoList = DeepCopyGroupTypeOrderList(gtoList);
gtvm.HandleGroupTableDrop(targetGroupTypeOrder, draggedGroupTypeOrder);
Assert.AreEqual(gtoList[0], draggedGroupTypeOrder);
int i = gtoList.IndexOf(targetGroupTypeOrder);
while (i < unmodifiedgtoList.Count)
{
Assert.AreEqual(unmodifiedgtoList[i - 1].Group, gtoList[i].Group);
Assert.AreEqual(unmodifiedgtoList[i].GroupOrder, i + 1);
Assert.AreEqual(gtoList[i].GroupOrder, i + 1);
i++;
}
}
public void AddItemsToExistingGroup()
{
//Get items and add them to a group
string groupTypeID1 = "0";
double itemOrder1 = 35.00;
string designID1 = "12";
string includedType1 = "1";
ItemTypeOrder tempItemOrder1 =
(from a in _wvm.ItemTypeOrderList.Where(x => x.Item.DesignID.Equals(designID1))
select a).FirstOrDefault();
ItemType item1 = tempItemOrder1.Item;
string groupTypeID2 = "0";
double itemOrder2 = 36.00;
string designID2 = "5";
string includedType2 = "1";
ItemTypeOrder tempItemOrder2 =
(from a in _wvm.ItemTypeOrderList.Where(x => x.Item.DesignID.Equals(designID2))
select a).FirstOrDefault();
ItemType item2 = tempItemOrder2.Item;
ItemTypeOrder itemTypeOrder1 = new ItemTypeOrder(item1, groupTypeID1,
itemOrder1, designID1, includedType1);
ItemTypeOrder itemTypeOrder2 = new ItemTypeOrder(item2, groupTypeID2,
itemOrder2, designID2, includedType2);
//Add the new ItemTypeOrder items to page 15, group 0
PageType testPage = _wvm.PageList.FirstOrDefault(x => x.PageTypeID.Equals("15"));
GroupTypeOrder testGto = testPage.GroupTypeOrders.FirstOrDefault(x => x.GroupTypeID.Equals("0"));
testGto.Group.ItemOrder.Add(itemTypeOrder1);
testGto.Group.ItemOrder.Add(itemTypeOrder2);
//Export excel with the added items in it
_exExcel.CreateNewExcel(_exportPath);
//Import the new excel file
_impExcel.ImportExcelConfiguration(_exportPath);
#region ktUIOrder tests
//Get the new group in ktUIOrder
List <ktUIOrder> orders1 =
_impExcel._workSheetktUIOrder.ktUIOrderList.Where(
x => x.GroupTypeID.Equals(itemTypeOrder1.GroupTypeID)).ToList();
foreach (var order in orders1)
{
if (order.DesignID.Equals(designID1))
{
Assert.AreEqual(order.GroupOrder, itemOrder1);
Assert.AreEqual(order.IncludedTypeID, includedType1);
}
if (order.DesignID.Equals(designID2))
{
Assert.AreEqual(order.GroupOrder, itemOrder2);
Assert.AreEqual(order.IncludedTypeID, includedType2);
}
}
#endregion
}
public void RefreshLanguage(GroupTypeOrder gto)
{
string languageID = gto.Group.LanguageID;
gto.Group.LanguageID = languageID;
}
public void PopulateGroupTable(GroupTypeOrder gto)
{
if (PreviousGroupTypeOrder == null || PreviousGroupTypeOrder.GroupTypeID != gto.GroupTypeID)
{
PreviousGroupTypeOrder = gto;
GroupType gt = gto.Group;
CreateColumns(GroupTable, 4);
int counterRow = 0;
int counterColumn = 0;
AddNewGroupRow();
InsertGroupItem(gto, 0, 0);
if (!_specialGroups.Any(x => x.Equals(gt.GroupTypeID)))
{
int skipped = 0;
for (int j = 0; j < gt.ItemOrder.Count - skipped; j++)
{
if (gt.ItemOrder[j + skipped].DesignID.Equals("198"))
{
if (j % 4 == 0)
{
AddNewEmptyItemRow();
counterRow++;
gt.ItemOrder[j + skipped].Item.Header = "<NewLineItem>";
//gt.ItemOrder[j + skipped].ItemOrder = j + skipped;
InsertItem(gt.ItemOrder[j + skipped], counterRow, j % 4);
j--;
skipped++;
continue;
}
gt.ItemOrder[j + skipped].Item.Header = "<NewLineItem>";
//gt.ItemOrder[j + skipped].ItemOrder = j + skipped;
InsertItem(gt.ItemOrder[j + skipped], counterRow, j % 4);
skipped = skipped + j;
j = 0;
}
else if (j % 4 == 0)
{
AddNewEmptyItemRow();
counterRow++;
}
if (gt.ItemOrder[j + skipped].DesignID.Equals("198"))
{
j--;
skipped++;
continue;
}
if (gt.ItemOrder[j + skipped].DesignID.Equals("197"))
{
gt.ItemOrder[j + skipped].Item.Header = "<EmptyField>";
InsertItem(gt.ItemOrder[j + skipped], counterRow, j % 4);
//gt.ItemOrder[j + skipped].ItemOrder = j + skipped;
}
else
{
if (counterColumn >= 4)
{
counterColumn = 0;
}
InsertItem(gt.ItemOrder[j + skipped], counterRow, j % 4);
//gt.ItemOrder[j + skipped].ItemOrder = j + skipped;
}
counterColumn++;
}
AddNewEmptyItemRow();
}
}
}
public void AdjustGroupOrder(GroupTypeOrder draggedGroupTypeOrder, GroupTypeOrder targetGroupTypeOrder)
{
//GTCViewModel.AdjustGroupOrder(draggedGroupTypeOrder, targetGroupTypeOrder);
}
///// <summary>
///// Creates a new group on a the page
///// </summary>
///// <param name="pageTypeId">The id for the selected page</param>
///// <param name="languageId">The selected language of the application</param>
///// <param name="groupOrder">The group order number on the selected page</param>
///// <param name="englishTranslationText">The english group name</param>
///// <param name="danishTranslationText">The danish group name</param>
//public void CreateGroup(string pageTypeId, string languageId, double groupOrder, string englishTranslationText, string danishTranslationText)
//{
// GroupTypeOrder gtOrder = new GroupTypeOrder();
// GroupType groupType = new GroupType();
// //Create new GroupTypeOrder
// gtOrder.DepartmentID = "-1";
// gtOrder.PageTypeID = pageTypeId;
// int highestId = 0;
// foreach (PageType page in PageList)
// {
// int index = 0;
// while (index < page.GroupTypeOrders.Count)
// {
// if (Convert.ToInt32(page.GroupTypeOrders[index].GroupTypeID) > highestId)
// {
// highestId = Convert.ToInt32(page.GroupTypeOrders[index].GroupTypeID);
// }
// index++;
// }
// }
// gtOrder.GroupTypeID = (highestId + 1).ToString();
// gtOrder.GroupOrder = groupOrder;
// //Create new GroupType
// groupType.GroupTypeID = (highestId + 1).ToString();
// groupType.DanishTranslationText = danishTranslationText;
// groupType.EnglishTranslationText = englishTranslationText;
// groupType.LanguageID = languageId;
// string hej = englishTranslationText.Replace(" ", string.Empty);
// int i = 1;
// foreach (PageType page in PageList)
// {
// while ((from a in page.GroupTypeOrders where a.Group.ResourceType.Equals(hej + i) select a).Any())
// {
// i++;
// }
// }
// hej = hej + i;
// groupType.ResourceType = hej;
// groupType.ResourceID = (_groupCounter + 1).ToString();
// _groupCounter++;
// groupType.ResourceTypeID = "1";
// //Reference GroupTypeOrder with GroupType
// gtOrder.Group = groupType;
// int hello = 0;
// while (hello < PageList.Count)
// {
// if (PageList[hello].PageTypeID.Equals(pageTypeId))
// {
// PageList[hello].GroupTypeOrders.Add(gtOrder);
// }
// hello++;
// }
//}
/// <summary>
/// Creates a new group on a the page
/// </summary>
/// <param name="pageTypeId">The id for the selected page</param>
/// <param name="englishTranslationText">The english group name</param>
/// <param name="danishTranslationText">The danish group name</param>
/// <param name="departmentList">The selected departments the group is in</param>
public void CreateGroup(string pageTypeId, string englishTranslationText, string danishTranslationText, List <string> departmentList)
{
GroupType groupType = new GroupType();
//Create new GroupTypeOrder
int highestId = 0;
foreach (PageType page in PageList)
{
int highestIdOnPage = Convert.ToInt32(page.GroupTypeOrders.Max(x => x.GroupTypeID));
if (highestIdOnPage > highestId)
{
highestId = highestIdOnPage;
}
//int index = 0;
//while (index < page.GroupTypeOrders.Count)
//{
// if (Convert.ToInt32(page.GroupTypeOrders[index].GroupTypeID) > highestId)
// {
// highestId = Convert.ToInt32(page.GroupTypeOrders[index].GroupTypeID);
// }
// index++;
//}
}
ObservableCollection <GroupTypeOrder> groupTypeOrderCollection = PageList.First(x => x.PageTypeID.Equals(pageTypeId)).GroupTypeOrders;
GroupTypeOrder gtoCompare = groupTypeOrderCollection.Last();
//Create new GroupType
groupType.GroupTypeID = (highestId + 1).ToString();
groupType.DanishTranslationText = danishTranslationText;
groupType.EnglishTranslationText = englishTranslationText;
groupType.LanguageID = gtoCompare.Group.LanguageID;
string hej = englishTranslationText.Replace(" ", string.Empty);
int i = 1;
foreach (PageType page in PageList)
{
while ((from a in page.GroupTypeOrders where a.Group.ResourceType.Equals(hej + i) select a).Any())
{
i++;
}
}
hej = hej + i;
groupType.ResourceType = hej;
groupType.ResourceID = (_groupCounter + 1).ToString();
_groupCounter++;
groupType.ResourceTypeID = "1";
//Reference GroupTypeOrder with GroupType
ToolboxGroupsViewModel glvm = ToolboxGroupsViewModel.Instance;
ToolboxGroup tbg = new ToolboxGroup();
tbg.Group = groupType;
glvm.GTList.Add(tbg);
//int hello = 0;
//while (hello < PageList.Count)
//{
// if (PageList[hello].PageTypeID.Equals(pageTypeId))
// {
// PageList[hello].GroupTypeOrders.Add(gtOrder);
// }
// hello++;
//}
foreach (string departmentID in departmentList)
{
GroupTypeOrder clonedGto = new GroupTypeOrder();
clonedGto.DepartmentID = departmentID;
clonedGto.Group = groupType;
//clonedGto.GroupOrder = gtoCompare.GroupOrder + 1;
clonedGto.GroupOrder = groupTypeOrderCollection.Max(x => x.GroupOrder) + 1;
clonedGto.GroupTypeID = (highestId + 1).ToString();
clonedGto.PageTypeID = pageTypeId;
groupTypeOrderCollection.Add(clonedGto);
}
}
public void CreateGroupWithItems()
{
//Get items and add them to a group
int highestId = 0;
foreach (PageType page in _wvm.PageList)
{
int index = 0;
while (index < page.GroupTypeOrders.Count)
{
if (Convert.ToInt32(page.GroupTypeOrders[index].GroupTypeID) > highestId)
{
highestId = Convert.ToInt32(page.GroupTypeOrders[index].GroupTypeID);
}
index++;
}
}
string groupTypeID = (highestId + 1).ToString();
double itemOrder1 = 0.00;
string designID1 = "12";
string includedType1 = "1";
ItemTypeOrder tempItemOrder1 =
(from a in _wvm.ItemTypeOrderList.Where(x => x.Item.DesignID.Equals(designID1))
select a).FirstOrDefault();
ItemType item1 = tempItemOrder1.Item;
double itemOrder2 = 1.00;
string designID2 = "5";
string includedType2 = "1";
ItemTypeOrder tempItemOrder2 =
(from a in _wvm.ItemTypeOrderList.Where(x => x.Item.DesignID.Equals(designID2))
select a).FirstOrDefault();
ItemType item2 = tempItemOrder2.Item;
ItemTypeOrder itemTypeOrder1 = new ItemTypeOrder(item1, groupTypeID,
itemOrder1, designID1, includedType1);
ItemTypeOrder itemTypeOrder2 = new ItemTypeOrder(item2, groupTypeID,
itemOrder2, designID2, includedType2);
//Create a new group
string pageTypeID = "15";
string engTransText = "New group";
string danTransText = "Ny gruppe";
List <string> departmentList1 = new List <string>();
departmentList1.Add("-1");
_wvm.CreateGroup(pageTypeID, engTransText, danTransText, departmentList1);
//Add the new ItemTypeOrder items to page 15
PageType testPage = _wvm.PageList.FirstOrDefault(x => x.PageTypeID.Equals(pageTypeID));
GroupTypeOrder testGto = testPage.GroupTypeOrders.FirstOrDefault(x => x.GroupTypeID.Equals(groupTypeID));
testGto.Group.ItemOrder.Add(itemTypeOrder1);
testGto.Group.ItemOrder.Add(itemTypeOrder2);
//Export excel with the new group in it
_exExcel.CreateNewExcel(_exportPath);
//Import the new excel file
_impExcel.ImportExcelConfiguration(_exportPath);
#region ktUIOrder tests
//Get the new group in ktUIOrder
List <ktUIOrder> orders =
_impExcel._workSheetktUIOrder.ktUIOrderList.Where(x => x.GroupTypeID.Equals(groupTypeID)).ToList();
Assert.AreEqual(orders.Count(), 2);
Assert.IsTrue(orders.Exists(x => x.DesignID.Equals(designID1)));
Assert.IsTrue(orders.Exists(x => x.DesignID.Equals(designID2)));
Assert.IsTrue(orders.Exists(x => x.GroupOrder.Equals(itemOrder1)));
Assert.IsTrue(orders.Exists(x => x.GroupOrder.Equals(itemOrder2)));
foreach (ktUIOrder order in orders)
{
Assert.AreEqual(order.GroupTypeID, groupTypeID);
}
#endregion
}
