//Delete Multiple Templates
public static void DeleteMultipleTemplates()
{
log4net.Config.XmlConfigurator.Configure();
ILog logger = LogManager.GetLogger(typeof(MyProjectsPage));
try
{
FirstCheckBox.Click();
SecondCheckBox.Click();
DeleteSelected.Click();
Wait.WaitVisible(DeleteAlertPopup, 10);
if (DeleteAlertPopup.IsElementDisplayed())
{
Console.Write("Message from the Delete alert popup is " + DeleteAlertPopupMsg.GetText());
DeleteAlertPopupYes.Click();
}
else
{
Console.Write("Delete alert pop-up is not comming ");
}
Console.WriteLine("Confirmation message is " + ConfirmationMsgPopup.GetText());
Wait.WaitTime(10);
}
catch (Exception e)
{
logger.Error("Delete Multiple Template failed due to : " + e);
//**Closing browser
Driver.Quit();
throw e;
}
}
public static void DismissPopupMultipleTemplate()
{
log4net.Config.XmlConfigurator.Configure();
ILog logger = LogManager.GetLogger(typeof(MyProjectsPage));
test = Base.extent.CreateTest("DismissPopup");
try
{
FirstCheckBox.Click();
FirstCheckBox.Click();
SecondCheckBox.Click();
DeleteSelected.Click();
Wait.WaitVisible(DeleteAlertPopup, 10);
Console.Write("Message from the Delete alert popup is " + DeleteAlertPopupMsg.GetText());
DeleteAlertPopupNo.Click();
Assert.IsTrue(ProjectsHeader.IsElementDisplayed());
}
catch (Exception e)
{
logger.Error("Click on Cancel button failed due to : " + e);
//**Closing browser
Driver.Quit();
throw e;
}
}
public static void VerifyProjectsPage()
{
log4net.Config.XmlConfigurator.Configure();
ILog logger = LogManager.GetLogger(typeof(MyProjectsPage));
try
{
//Check the visiblity of My Project Header
Wait.WaitVisible(ProjectsHeader, 60);
bool status_of_myprojectheader = ProjectsHeader.IsElementDisplayed();
Console.WriteLine("Status of logo is " + status_of_myprojectheader);
//Check the status of SelectAll
Wait.WaitVisible(SelectAll, 60);
bool status_of_selecteall = ProjectsHeader.IsElementEnabled();
Console.WriteLine("Status of SelectAll is " + status_of_selecteall);
//Check the status of SelectNone
Wait.WaitVisible(SelectNone, 60);
bool status_of_selectnone = ProjectsHeader.IsElementEnabled();
Console.WriteLine("Status of SelectNone is " + status_of_selectnone);
//Check the status of DeleteSelected
Wait.WaitVisible(DeleteSelected, 60);
bool status_of_deleteselected = DeleteSelected.IsElementEnabled();
Console.WriteLine("Status of DeleteSelected is " + status_of_deleteselected);
}
catch (Exception e)
{
logger.Error("Verify home page failed due to : " + e);
//**Closing browser
Driver.Quit();
throw e;
}
}
protected override void RenderContent(UnityEngine.Object undoRecordObject)
{
AppendToSelection.RenderEditorGUI(undoRecordObject);
MultiDeselect.RenderEditorGUI(undoRecordObject);
DeleteSelected.RenderEditorGUI(undoRecordObject);
FocusCameraOnSelection.RenderEditorGUI(undoRecordObject);
DuplicateSelection.RenderEditorGUI(undoRecordObject);
}
private void NotifyCanExecuteChanged()
{
PlaySelected.NotifyCanExecuteChanged();
SelectAll.NotifyCanExecuteChanged();
StopSelected.NotifyCanExecuteChanged();
DeleteSelected.NotifyCanExecuteChanged();
ClearSelection.NotifyCanExecuteChanged();
RemoveFinished.NotifyCanExecuteChanged();
}
//Click on DeleteSelected without Clicking on Checkbox
public static void ClickDeleteSelectWithoutCheck()
{
log4net.Config.XmlConfigurator.Configure();
ILog logger = LogManager.GetLogger(typeof(MyProjectsPage));
test = Base.extent.CreateTest("DismissPopupSingleTemplate");
try
{
DeleteSelected.Click();
Wait.WaitVisible(WithoutSelectDeleteAlert, 20);
string msg = WithoutSelectDeleteAlert.GetText();
Console.WriteLine("Message after click on DeleteSelected without selcting check box is " + msg);
}
catch (Exception e)
{
logger.Error("Click Delete Select Without Check failed due to : " + e);
//**Closing browser
Driver.Quit();
throw e;
}
}
private void UpdateCommands()
{
RaisePropertyChanged(nameof(EditSelected));
_editSelected?.RaiseCanExecuteChanged();
RaisePropertyChanged(nameof(SendSelectedImageToClipboard));
RaisePropertyChanged(nameof(SendSelectedScaledImageToClipboard));
RaisePropertyChanged(nameof(SendSelectedTextToClipboard));
_sendSelectedToClipboard?.RaiseCanExecuteChanged();
CloneSelected.RaiseCanExecuteChanged();
RaisePropertyChanged(nameof(CloneSelectedToolTip));
CopySelected.RaiseCanExecuteChanged();
RaisePropertyChanged(nameof(CopySelectedToolTip));
MoveSelected.RaiseCanExecuteChanged();
RaisePropertyChanged(nameof(MoveSelectedToolTip));
ExportSelected.RaiseCanExecuteChanged();
RaisePropertyChanged(nameof(ExportSelectedToolTip));
DeleteSelected.RaiseCanExecuteChanged();
RaisePropertyChanged(nameof(DeleteSelectedToolTip));
ResetStylesSelected.RaiseCanExecuteChanged();
RaisePropertyChanged(nameof(ResetStylesSelectedToolTip));
}
private void UpdateCommands()
{
RaisePropertyChanged("EditSelected");
_editSelected?.RaiseCanExecuteChanged();
RaisePropertyChanged("SendSelectedImageToClipboard");
RaisePropertyChanged("SendSelectedScaledImageToClipboard");
RaisePropertyChanged("SendSelectedTextToClipboard");
_sendSelectedToClipboard?.RaiseCanExecuteChanged();
CloneSelected.RaiseCanExecuteChanged();
RaisePropertyChanged("CloneSelectedToolTip");
CopySelected.RaiseCanExecuteChanged();
RaisePropertyChanged("CopySelectedToolTip");
MoveSelected.RaiseCanExecuteChanged();
RaisePropertyChanged("MoveSelectedToolTip");
ExportSelected.RaiseCanExecuteChanged();
RaisePropertyChanged("ExportSelectedToolTip");
DeleteSelected.RaiseCanExecuteChanged();
RaisePropertyChanged("DeleteSelectedToolTip");
ResetStylesSelected.RaiseCanExecuteChanged();
RaisePropertyChanged("ResetStylesSelectedToolTip");
}
//Delete All Templates
public static void DeleteAllTemplates()
{
log4net.Config.XmlConfigurator.Configure();
ILog logger = LogManager.GetLogger(typeof(MyProjectsPage));
try
{
SelectAllCheckBox.Click();
DeleteSelected.Click();
bool status_of_deletealertpopup = DeleteAlertPopup.IsElementDisplayed();
Assert.IsTrue(status_of_deletealertpopup);
Wait.WaitVisible(ConfirmationMsgPopup, 10);
Console.WriteLine("Confirmation message is " + ConfirmationMsgPopup.GetText());
}
catch (Exception e)
{
logger.Error("Delete All Template failed due to : " + e);
//**Closing browser
Driver.Quit();
throw e;
}
}
private static void ShowDeleteSelectedWindow()
{
DeleteSelected window = EditorWindow.GetWindow <DeleteSelected>();
window.ShowUtility();
}
public void NotifySelectionChanged()
{
DeleteSelected.RaiseCanExecuteChanged();
}
public SmartScriptEditorViewModel(IHistoryManager history,
IDatabaseProvider database,
IEventAggregator eventAggregator,
ISmartDataManager smartDataManager,
ISmartFactory smartFactory,
IItemFromListProvider itemFromListProvider,
ISmartTypeListProvider smartTypeListProvider,
IStatusBar statusbar,
ISolutionItemNameRegistry itemNameRegistry)
{
this.history = history;
this.database = database;
this.smartDataManager = smartDataManager;
this.smartFactory = smartFactory;
this.itemFromListProvider = itemFromListProvider;
this.smartTypeListProvider = smartTypeListProvider;
this.statusbar = statusbar;
this.itemNameRegistry = itemNameRegistry;
EditEvent = new DelegateCommand(EditEventCommand);
DeselectActions = new DelegateCommand(() =>
{
foreach (var e in Events)
{
if (!e.IsSelected)
{
foreach (var a in e.Actions)
{
a.IsSelected = false;
}
}
}
});
DeselectAll = new DelegateCommand(() =>
{
foreach (var e in Events)
{
foreach (var a in e.Actions)
{
a.IsSelected = false;
}
e.IsSelected = false;
}
});
DeselectAllEvents = new DelegateCommand(() =>
{
foreach (var e in Events)
{
e.IsSelected = false;
}
});
OnDropItems = new DelegateCommand <int?>(destIndex =>
{
using (script.BulkEdit("Reorder events"))
{
var selected = new List <SmartEvent>();
int d = destIndex.Value;
for (int i = Events.Count - 1; i >= 0; --i)
{
if (Events[i].IsSelected)
{
if (i <= destIndex)
{
d--;
}
selected.Add(Events[i]);
script.Events.RemoveAt(i);
}
}
if (d == -1)
{
d = 0;
}
selected.Reverse();
foreach (var s in selected)
{
script.Events.Insert(d++, s);
}
}
});
OnDropActions = new DelegateCommand <DropActionsArgs>(data =>
{
using (script.BulkEdit("Reorder actions"))
{
var selected = new List <SmartAction>();
var d = data.ActionIndex;
for (var eventIndex = 0; eventIndex < Events.Count; eventIndex++)
{
var e = Events[eventIndex];
for (int i = e.Actions.Count - 1; i >= 0; --i)
{
if (e.Actions[i].IsSelected)
{
if (eventIndex == data.EventIndex && i < data.ActionIndex)
{
d--;
}
selected.Add(e.Actions[i]);
e.Actions.RemoveAt(i);
}
}
}
selected.Reverse();
foreach (var s in selected)
{
Events[data.EventIndex].Actions.Insert(d++, s);
}
}
});
EditAction = new DelegateCommand <SmartAction>(action => EditActionCommand(action));
AddEvent = new DelegateCommand(AddEventCommand);
AddAction = new DelegateCommand <NewActionViewModel>(AddActionCommand);
SaveCommand = new AsyncAutoCommand(SaveAllToDb, null, e =>
{
statusbar.PublishNotification(new PlainNotification(NotificationType.Error, "Error while saving script to the database: " + e.Message));
});
DeleteAction = new DelegateCommand <SmartAction>(DeleteActionCommand);
DeleteSelected = new DelegateCommand(() =>
{
if (anyEventSelected)
{
using (script.BulkEdit("Delete events"))
{
int?nextSelect = firstSelectedIndex;
if (multipleEventsSelected)
{
nextSelect = null;
}
for (int i = Events.Count - 1; i >= 0; --i)
{
if (Events[i].IsSelected)
{
Events.RemoveAt(i);
}
}
if (nextSelect.HasValue)
{
if (nextSelect.Value < Events.Count)
{
Events[nextSelect.Value].IsSelected = true;
}
else if (nextSelect.Value - 1 >= 0 && nextSelect.Value - 1 < Events.Count)
{
Events[nextSelect.Value - 1].IsSelected = true;
}
}
}
}
else if (anyActionSelected)
{
using (script.BulkEdit("Delete actions"))
{
(int eventIndex, int actionIndex)? nextSelect = firstSelectedActionIndex;
if (multipleActionsSelected)
{
nextSelect = null;
}
for (int i = 0; i < Events.Count; ++i)
{
var e = Events[i];
for (int j = e.Actions.Count - 1; j >= 0; --j)
{
if (e.Actions[j].IsSelected)
{
e.Actions.RemoveAt(j);
}
}
}
if (nextSelect.HasValue && nextSelect.Value.actionIndex < Events[nextSelect.Value.eventIndex].Actions.Count)
{
Events[nextSelect.Value.eventIndex].Actions[nextSelect.Value.actionIndex].IsSelected = true;
}
}
}
});
UndoCommand = new DelegateCommand(history.Undo, () => history.CanUndo);
RedoCommand = new DelegateCommand(history.Redo, () => history.CanRedo);
EditSelected = new DelegateCommand(() =>
{
if (anyEventSelected)
{
if (!multipleEventsSelected)
{
EditEventCommand();
}
}
else if (anyActionSelected && !multipleActionsSelected)
{
EditActionCommand(Events[firstSelectedActionIndex.eventIndex]
.Actions[firstSelectedActionIndex.actionIndex]);
}
});
CopyCommand = new DelegateCommand(() =>
{
var selectedEvents = Events.Where(e => e.IsSelected).ToList();
if (selectedEvents.Count > 0)
{
var lines = string.Join("\n",
selectedEvents.SelectMany((e, index) => e.ToSmartScriptLines(script.EntryOrGuid, script.SourceType, index)).Select(s => s.ToSqlString()));
Clipboard.SetText(lines);
}
else
{
var selectedActions = Events.SelectMany(e => e.Actions).Where(e => e.IsSelected).ToList();
if (selectedActions.Count > 0)
{
var fakeEvent = new SmartEvent(-1)
{
ReadableHint = ""
};
foreach (var a in selectedActions)
{
fakeEvent.AddAction(a.Copy());
}
var lines = string.Join("\n", fakeEvent.ToSmartScriptLines(script.EntryOrGuid, script.SourceType, 0).Select(s => s.ToSqlString()));
Clipboard.SetText(lines);
}
}
});
CutCommand = new DelegateCommand(() =>
{
CopyCommand.Execute();
DeleteSelected.Execute();
});
PasteCommand = new DelegateCommand(() =>
{
var lines = (Clipboard.GetText() ?? "").Split('\n').Select(line =>
{
if (line.TryToISmartScriptLine(out var s))
{
return(s);
}
return(null);
}).Where(l => l != null).ToList();
if (lines.Count > 0)
{
if (lines[0].EventType == -1) // actions
{
int?eventIndex = null;
int?actionIndex = null;
using (script.BulkEdit("Paste actions"))
{
for (int i = 0; i < Events.Count - 1; ++i)
{
if (Events[i].IsSelected)
{
eventIndex = i;
}
for (int j = Events[i].Actions.Count - 1; j >= 0; j--)
{
if (Events[i].Actions[j].IsSelected)
{
eventIndex = i;
if (!actionIndex.HasValue)
{
actionIndex = j;
}
else
{
actionIndex--;
}
//Events[i].Actions.RemoveAt(j);
}
}
}
if (!eventIndex.HasValue)
{
eventIndex = Events.Count - 1;
}
if (eventIndex < 0)
{
return;
}
if (!actionIndex.HasValue)
{
actionIndex = Events[eventIndex.Value].Actions.Count - 1;
}
if (actionIndex < 0)
{
actionIndex = 0;
}
DeselectAll.Execute();
foreach (var smartAction in lines.Select(line => script.SafeActionFactory(line)))
{
Events[eventIndex.Value].Actions.Insert(actionIndex.Value, smartAction);
smartAction.IsSelected = true;
actionIndex++;
}
}
}
else
{
int?index = null;
using (script.BulkEdit("Paste events"))
{
for (int i = Events.Count - 1; i >= 0; --i)
{
if (Events[i].IsSelected)
{
if (!index.HasValue)
{
index = i;
}
else
{
index--;
}
//Events.RemoveAt(i);
}
}
if (!index.HasValue)
{
index = Events.Count;
}
script.InsertFromClipboard(index.Value, lines);
}
}
}
});
Action <bool, int> selectionUpDown = (addToSelection, diff) =>
{
if (anyEventSelected)
{
var selectedEventIndex = Math.Clamp(firstSelectedIndex + diff, 0, Events.Count - 1);
if (!addToSelection)
{
DeselectAll.Execute();
}
Events[selectedEventIndex].IsSelected = true;
}
else if (anyActionSelected)
{
var nextActionIndex = firstSelectedActionIndex.actionIndex + diff;
var nextEventIndex = firstSelectedActionIndex.eventIndex;
while (nextActionIndex == -1 || nextActionIndex >= Events[nextEventIndex].Actions.Count)
{
nextEventIndex += diff;
if (nextEventIndex >= 0 && nextEventIndex < Events.Count)
{
nextActionIndex = diff > 0 ? (Events[nextEventIndex].Actions.Count > 0 ? 0 : -1) : Events[nextEventIndex].Actions.Count - 1;
}
else
{
break;
}
}
if (nextActionIndex != -1 && nextEventIndex >= 0 && nextEventIndex < Events.Count)
{
DeselectAll.Execute();
Events[nextEventIndex].Actions[nextActionIndex].IsSelected = true;
}
}
else
{
if (Events.Count > 0)
{
Events[diff > 0 ? 0 : Events.Count - 1].IsSelected = true;
}
}
};
SelectionUp = new DelegateCommand <bool?>(addToSelection => selectionUpDown(addToSelection ?? false, -1));
SelectionDown = new DelegateCommand <bool?>(addToSelection => selectionUpDown(addToSelection ?? false, 1));
SelectionLeft = new DelegateCommand(() =>
{
if (!anyEventSelected && anyActionSelected)
{
var actionEventIndex = firstSelectedActionIndex;
DeselectAll.Execute();
Events[actionEventIndex.eventIndex].IsSelected = true;
}
else if (!anyEventSelected && !anyActionSelected)
{
selectionUpDown(false, -1);
}
});
SelectionRight = new DelegateCommand(() =>
{
if (!anyEventSelected)
{
selectionUpDown(false, -1);
}
if (anyEventSelected)
{
var eventIndex = firstSelectedIndex;
if (Events[eventIndex].Actions.Count > 0)
{
DeselectAll.Execute();
Events[eventIndex].Actions[0].IsSelected = true;
}
}
});
SelectAll = new DelegateCommand(() =>
{
foreach (var e in Events)
{
e.IsSelected = true;
}
});
this.history.PropertyChanged += (sender, args) =>
{
UndoCommand.RaiseCanExecuteChanged();
RedoCommand.RaiseCanExecuteChanged();
};
token = eventAggregator.GetEvent <EventRequestGenerateSql>().Subscribe((args) =>
{
if (args.Item is SmartScriptSolutionItem)
{
var itemm = args.Item as SmartScriptSolutionItem;
if (itemm.Entry == _item.Entry && itemm.SmartType == _item.SmartType)
{
args.Sql = new SmartScriptExporter(script, smartFactory).GetSql();
}
}
});
}
// <summary>
// Relay clicks on butons
// </summary>
private void DeleteSelectedClicked(object sender, EventArgs e)
{
DeleteSelected?.Invoke(this, EventArgs.Empty);
}