public virtual IEnumerable DisableWizards(PXAdapter adapter)
{
WZSetup setup = this.Setup.Select();
setup.WizardsStatus = false;
this.Setup.Update(setup);
this.Actions.PressSave();
SiteMapMaint siteMapGraph = PXGraph.CreateInstance <SiteMapMaint>();
SiteMap wizardsSiteMapNode = PXSelect <SiteMap, Where <SiteMap.screenID, Equal <Required <SiteMap.screenID> > > > .Select(this, "WZ000000");
SiteMap hiddenSiteMapNode = PXSelect <SiteMap, Where <SiteMap.screenID, Equal <Required <SiteMap.screenID> > > > .Select(this, "HD000000");
siteMapGraph.SiteMap.Select();
siteMapGraph.SiteMap.Current = wizardsSiteMapNode;
siteMapGraph.Children.Select();
siteMapGraph.Cut.Press();
siteMapGraph.SiteMap.Current = hiddenSiteMapNode;
siteMapGraph.Children.Select();
siteMapGraph.Paste.Press();
siteMapGraph.Save.Press();
//Deactivate all scenarios
PXSiteMap.Provider.Clear();
WZTaskEntry wzGraph = PXGraph.CreateInstance <WZTaskEntry>();
foreach (WZScenario activeScenario in PXSelect <WZScenario, Where <WZScenario.status, Equal <Required <WZScenario.status> > > > .Select(this, WizardScenarioStatusesAttribute._ACTIVE))
{
wzGraph.Scenario.Current = activeScenario;
wzGraph.completeScenarioWithoutRefresh.Press();
}
return(adapter.Get());
}
public virtual IEnumerable MarkAsCompleted(PXAdapter adapter)
{
WZTaskEntry graph = PXGraph.CreateInstance <WZTaskEntry>();
WZTask selectedTask = Tasks.Current;
if (selectedTask != null && selectedTask.Status != WizardTaskStatusesAttribute._PENDING &&
selectedTask.Status != WizardTaskStatusesAttribute._DISABLED)
{
if (graph.CanTaskBeCompleted(selectedTask))
{
selectedTask.Status = WizardTaskStatusesAttribute._COMPLETED;
graph.TaskInfo.Update(selectedTask);
graph.Save.Press();
if (graph.ScenarioTasksCompleted(selectedTask.ScenarioID))
{
PXSiteMap.Provider.Clear();
PXSiteMapNode node = PXSiteMap.Provider.FindSiteMapNodeByScreenID("WZ201505");
throw new PXRedirectToUrlException(node.Url + "?ScenarioID=" + selectedTask.ScenarioID, PXBaseRedirectException.WindowMode.Same, "Refresh SiteMap");
}
}
else
{
throw new PXException(Messages.CannotBeCompletedWileOpenTasks);
}
}
Tasks.Cache.ClearQueryCache();
Scenario.Cache.ClearQueryCache();
Scenario.Cache.Clear();
Scenario.View.RequestRefresh();
return(adapter.Get());
}
public virtual IEnumerable EnableWizards(PXAdapter adapter)
{
WZSetup setup = this.Setup.Select();
setup.WizardsStatus = true;
this.Setup.Update(setup);
this.Actions.PressSave();
SiteMapMaint siteMapGraph = PXGraph.CreateInstance <SiteMapMaint>();
SiteMap wizardsSiteMapNode = PXSelect <SiteMap, Where <SiteMap.screenID, Equal <Required <SiteMap.screenID> > > > .Select(this, "WZ000000");
SiteMap organizationSiteMapNode = PXSelect <SiteMap, Where <SiteMap.screenID, Equal <Required <SiteMap.screenID> > > > .Select(this, "OG000000");
siteMapGraph.SiteMap.Select();
siteMapGraph.SiteMap.Current = wizardsSiteMapNode;
siteMapGraph.Children.Select();
siteMapGraph.Cut.Press();
siteMapGraph.SiteMap.Current = organizationSiteMapNode;
siteMapGraph.Children.Select();
siteMapGraph.Paste.Press();
siteMapGraph.Save.Press();
//Activate main scenario
PXSiteMap.Provider.Clear();
WZTaskEntry wzGraph = PXGraph.CreateInstance <WZTaskEntry>();
foreach (WZScenario activeScenario in PXSelect <WZScenario, Where <WZScenario.nodeID, Equal <Required <WZScenario.nodeID> > > > .Select(this, Guid.Empty))
{
wzGraph.Scenario.Current = activeScenario;
wzGraph.activateScenarioWithoutRefresh.Press();
}
return(adapter.Get());
}
public virtual IEnumerable StartTask(PXAdapter adapter)
{
WZTaskEntry graph = PXGraph.CreateInstance <WZTaskEntry>();
WZTask selectedTask = Tasks.Current;
if (selectedTask != null && selectedTask.Status == WizardTaskStatusesAttribute._ACTIVE)
{
viewTask.Press();
return(adapter.Get());
}
if (selectedTask != null && selectedTask.Status == WizardTaskStatusesAttribute._OPEN)
{
selectedTask.Status = WizardTaskStatusesAttribute._ACTIVE;
graph.TaskInfo.Update(selectedTask);
graph.Save.Press();
viewTask.Press();
}
Tasks.Cache.ClearQueryCache();
Scenario.Cache.ClearQueryCache();
Scenario.Cache.Clear();
Scenario.View.RequestRefresh();
return(adapter.Get());
}
public virtual void GenerateProc(Schedule s, short Times, DateTime runDate)
{
IEnumerable <ScheduleDet> sd = new Scheduler(this).MakeSchedule(s, Times, runDate);
WZTaskEntry graph = PXGraph.CreateInstance <WZTaskEntry>();
using (PXTransactionScope ts = new PXTransactionScope())
{
foreach (ScheduleDet d in sd)
{
foreach (WZScenario scenario in PXSelect <WZScenario, Where <WZScenario.scheduleID, Equal <Required <Schedule.scheduleID> >, And <WZScenario.scheduled, Equal <True> > > > .
Select(this, s.ScheduleID))
{
scenario.ExecutionDate = d.ScheduledDate;
graph.Scenario.Current = scenario;
if (scenario.Status != WizardScenarioStatusesAttribute._SUSPEND)
{
graph.activateScenarioWithoutRefresh.Press();
}
}
s.LastRunDate = d.ScheduledDate;
Running_Schedule.Cache.Update(s);
}
Running_Schedule.Cache.Persist(PXDBOperation.Update);
ts.Complete(this);
}
}
public virtual IEnumerable ViewScenarioDetails(PXAdapter adapter)
{
WZTaskEntry graph = PXGraph.CreateInstance <WZTaskEntry>();
WZScenario row = Scenarios.Current;
if (row != null)
{
graph.Scenario.Current = row;
throw new PXRedirectRequiredException(graph, "Scenario Tasks");
}
return(adapter.Get());
}
public virtual IEnumerable CompleteScenario(PXAdapter adapter)
{
WZTaskEntry graph = PXGraph.CreateInstance <WZTaskEntry>();
WZScenario row = Scenarios.Current;
if (row != null)
{
graph.Scenario.Current = row;
graph.completeScenario.Press();
}
return(adapter.Get());
}
public virtual IEnumerable CompleteScenario(PXAdapter adapter)
{
WZTaskEntry graph = PXGraph.CreateInstance <WZTaskEntry>();
WZScenario scenario = Scenario.Current;
if (scenario != null && scenario.Status == WizardScenarioStatusesAttribute._ACTIVE)
{
graph.Scenario.Current = scenario;
graph.completeScenarioWithoutRefresh.Press();
PXSiteMapNode node = PXSiteMap.Provider.FindSiteMapNode(typeof(WizardNotActiveScenario));
throw new PXRedirectToUrlException(@"~\Main.aspx?ScreenId=" + node.ScreenID + "&ScenarioID=" + scenario.ScenarioID + "$target=_top", PXBaseRedirectException.WindowMode.Same, node.Title);
}
return(adapter.Get());
}
public virtual IEnumerable CompleteScenario(PXAdapter adapter)
{
WZTaskEntry graph = PXGraph.CreateInstance <WZTaskEntry>();
WZScenario scenario = Scenario.Current;
if (scenario != null && scenario.Status == WizardScenarioStatusesAttribute._ACTIVE)
{
graph.Scenario.Current = scenario;
graph.completeScenarioWithoutRefresh.Press();
PXSiteMapNode node = PXSiteMap.Provider.FindSiteMapNode(typeof(WizardNotActiveScenario));
throw new PXRedirectByScreenIDException(node.ScreenID, PXBaseRedirectException.WindowMode.Same, PXRedirectByScreenIDException.FramesetBehavior.Refresh, new { ScenarioID = scenario.ScenarioID });
}
return(adapter.Get());
}
public virtual IEnumerable StartTask(PXAdapter adapter)
{
WZTask task = Tasks.Current;
WZTaskEntry taskGraph = PXGraph.CreateInstance <WZTaskEntry>();
if (task != null && task.Status == WizardTaskStatusesAttribute._OPEN)
{
task.Status = WizardTaskStatusesAttribute._ACTIVE;
taskGraph.TaskInfo.Update(task);
taskGraph.Save.Press();
Tasks.Cache.Clear();
Tasks.Cache.ClearQueryCache();
}
return(adapter.Get());
}
public virtual IEnumerable Skip(PXAdapter adapter)
{
WZTaskEntry graph = PXGraph.CreateInstance <WZTaskEntry>();
WZTask selectedTask = Tasks.Current;
if (selectedTask != null && selectedTask.IsOptional == true)
{
selectedTask.Status = WizardTaskStatusesAttribute._SKIPPED;
graph.TaskInfo.Update(selectedTask);
graph.Save.Press();
}
Tasks.Cache.ClearQueryCache();
Scenario.Cache.ClearQueryCache();
Scenario.Cache.Clear();
Scenario.View.RequestRefresh();
return(adapter.Get());
}
public virtual IEnumerable Reopen(PXAdapter adapter)
{
WZTaskEntry graph = PXGraph.CreateInstance <WZTaskEntry>();
WZTask selectedTask = Tasks.Current;
if (selectedTask != null && (selectedTask.Status == WizardTaskStatusesAttribute._COMPLETED ||
selectedTask.Status == WizardTaskStatusesAttribute._SKIPPED))
{
selectedTask.Status = WizardTaskStatusesAttribute._OPEN;
graph.TaskInfo.Update(selectedTask);
graph.Save.Press();
}
Tasks.Cache.ClearQueryCacheObsolete();
Scenario.Cache.ClearQueryCacheObsolete();
Scenario.Cache.Clear();
Scenario.View.RequestRefresh();
return(adapter.Get());
}
public virtual IEnumerable EnableWizards(PXAdapter adapter)
{
WZSetup setup = this.Setup.Select();
setup.WizardsStatus = true;
this.Setup.Update(setup);
this.Actions.PressSave();
//Activate main scenario
PXSiteMap.Provider.Clear();
WZTaskEntry wzGraph = PXGraph.CreateInstance <WZTaskEntry>();
foreach (WZScenario activeScenario in PXSelect <WZScenario, Where <WZScenario.nodeID, Equal <Required <WZScenario.nodeID> > > > .Select(this, Guid.Empty))
{
wzGraph.Scenario.Current = activeScenario;
wzGraph.activateScenarioWithoutRefresh.Press();
}
return(adapter.Get());
}
public virtual IEnumerable SkipSubtask(PXAdapter adapter)
{
WZTask task = SubTasks.Current;
WZTaskEntry taskGraph = PXGraph.CreateInstance <WZTaskEntry>();
if (task != null && (task.Status == WizardTaskStatusesAttribute._OPEN ||
task.Status == WizardTaskStatusesAttribute._PENDING ||
task.Status == WizardTaskStatusesAttribute._ACTIVE) &&
task.IsOptional == true)
{
task.Status = WizardTaskStatusesAttribute._SKIPPED;
taskGraph.TaskInfo.Update(task);
taskGraph.Actions.PressSave();
Tasks.Cache.Clear();
Tasks.Cache.ClearQueryCache();
}
return(adapter.Get());
}
public virtual IEnumerable Assign(PXAdapter adapter)
{
if (CurrentTask.AskExt(true) == WebDialogResult.OK)
{
if (CurrentTask.Current.AssignedTo != null)
{
WZTaskEntry taskGraph = PXGraph.CreateInstance <WZTaskEntry>();
WZTask task = Tasks.Current as WZTask;
if (task != null)
{
task.AssignedTo = CurrentTask.Current.AssignedTo;
taskGraph.TaskInfo.Update(task);
taskGraph.Actions.PressSave();
}
}
Tasks.Cache.ClearQueryCache();
}
return(adapter.Get());
}
public virtual IEnumerable Assign(PXAdapter adapter)
{
if (CurrentTask.AskExtRequired())
{
if (CurrentTask.Current.AssignedTo != null)
{
WZTaskEntry taskGraph = PXGraph.CreateInstance <WZTaskEntry>();
WZTask task = PXSelect <WZTask, Where <WZTask.taskID, Equal <Required <WZTask.taskID> > > > .Select(this,
CurrentTask.Current.TaskID);
if (task != null)
{
WZTask taskCopy = (WZTask)taskGraph.TaskInfo.Cache.CreateCopy(task);
taskCopy.AssignedTo = CurrentTask.Current.AssignedTo;
taskGraph.TaskInfo.Update(taskCopy);
taskGraph.TaskInfo.Current = task;
taskGraph.Scenario.Current = Scenario.Current;
if (CurrentTask.Current.OverrideAssignee == true)
{
foreach (WZTask subTask in taskGraph.Childs.Select())
{
WZTask subTaskCopy = (WZTask)taskGraph.TaskInfo.Cache.CreateCopy(subTask);
subTaskCopy.AssignedTo = CurrentTask.Current.AssignedTo;
taskGraph.TaskInfo.Update(subTaskCopy);
}
}
taskGraph.Save.Press();
this.CurrentTask.Cache.IsDirty = false;
}
}
Tasks.Cache.ClearQueryCache();
CurrentTask.Cache.SetDefaultExt <WZTaskAssign.overrideAssignee>(CurrentTask.Current);
CurrentTask.Cache.ClearQueryCache();
CurrentTask.View.RequestRefresh();
}
return(adapter.Get());
}
public virtual IEnumerable MarkAsComplete(PXAdapter adapter)
{
WZTaskEntry graph = PXGraph.CreateInstance <WZTaskEntry>();
WZTask selectedTask = Tasks.Current;
if (selectedTask != null && selectedTask.Status != WizardTaskStatusesAttribute._PENDING &&
selectedTask.Status != WizardTaskStatusesAttribute._DISABLED)
{
if (graph.CanTaskBeCompleted(selectedTask))
{
selectedTask.Status = WizardTaskStatusesAttribute._COMPLETED;
graph.TaskInfo.Update(selectedTask);
graph.Save.Press();
}
else
{
throw new PXException(Messages.CannotBeCompletedWileOpenTasks);
}
}
Tasks.Cache.ClearQueryCache();
return(adapter.Get());
}
protected void btnActivate_Click(object sender, EventArgs e)
{
string ScenarioID = Request.Params["ScenarioID"];
if (!String.IsNullOrEmpty(ScenarioID))
{
WZTaskEntry graph = PXGraph.CreateInstance <WZTaskEntry>();
Guid id = Guid.Parse(ScenarioID);
WZScenario scenario = PXSelect <WZScenario, Where <WZScenario.scenarioID, Equal <Required <WZScenario.scenarioID> > > > .Select(graph, id);
if (scenario != null && !String.IsNullOrEmpty(scenario.Name))
{
graph.Scenario.Current = scenario;
graph.prepareTasksForActivation.Press();
graph.activateScenarioWithoutRefresh.Press();
PXSiteMap.Provider.Clear();
string url = ResolveUrl("~/Main.aspx");
if (id == Guid.Empty)
{
Controls.Add(new LiteralControl(@"<script type='text/javascript'>try { window.top.location.href='" + url + "'; } catch (ex) {}</script>\n"));
}
else
{
PXSiteMapNode node = PXSiteMap.Provider.FindSiteMapNodeFromKey(id);
if (node != null)
{
url = ResolveUrl("~/Pages/WZ/WZ201500.aspx");
Redirector.Redirect(this.Context, url + "?ScenarioID=" + id);
}
else
{
Controls.Add(new LiteralControl(@"<script type='text/javascript'>try { window.top.location.href='" + url + "'; } catch (ex) {}</script>\n"));
}
}
}
}
}
public IEnumerable requestValidation(PXAdapter adapter)
{
foreach (FeaturesSet feature in adapter.Get())
{
if (feature.Status == 3)
{
bool? customerDiscountsOld = PXAccess.FeatureInstalled <FeaturesSet.customerDiscounts>();
bool? branchOld = PXAccess.FeatureInstalled <FeaturesSet.branch>();
PXCache cache = new PXCache <FeaturesSet>(this);
FeaturesSet update = PXCache <FeaturesSet> .CreateCopy(feature);
update.Status = 0;
update = this.Features.Update(update);
this.Features.Delete(feature);
if (update.Status != 1)
{
this.Features.Delete(new FeaturesSet()
{
Status = 1
});
}
this.Persist();
PXAccess.Version++;
var tasks = PXSelect <WZTask> .Select(this);
WZTaskEntry taskGraph = CreateInstance <WZTaskEntry>();
foreach (WZTask task in tasks)
{
bool disableTask = false;
bool enableTask = false;
foreach (
WZTaskFeature taskFeature in
PXSelectReadonly <WZTaskFeature, Where <WZTaskFeature.taskID, Equal <Required <WZTask.taskID> > > > .Select(
this, task.TaskID))
{
bool featureInstalled = (bool?)cache.GetValue(update, taskFeature.Feature) == true;
if (!featureInstalled)
{
disableTask = true;
enableTask = false;
break;
}
enableTask = true;
}
if (disableTask)
{
task.Status = WizardTaskStatusesAttribute._DISABLED;
taskGraph.TaskInfo.Update(task);
taskGraph.Save.Press();
}
if (enableTask && task.Status == WizardTaskStatusesAttribute._DISABLED)
{
bool needToBeOpen = false;
WZScenario scenario = PXSelect <WZScenario, Where <WZScenario.scenarioID, Equal <Required <WZTask.scenarioID> > > > .Select(this, task.ScenarioID);
if (scenario != null && scenario.Status == WizardScenarioStatusesAttribute._ACTIVE)
{
WZTask parentTask =
PXSelect <WZTask, Where <WZTask.taskID, Equal <Required <WZTask.parentTaskID> > > > .Select(
this, task.ParentTaskID);
if (parentTask != null && (parentTask.Status == WizardTaskStatusesAttribute._OPEN ||
parentTask.Status == WizardTaskStatusesAttribute._ACTIVE))
{
needToBeOpen = true;
}
foreach (
PXResult <WZTaskPredecessorRelation, WZTask> predecessorResult in
PXSelectJoin <WZTaskPredecessorRelation,
InnerJoin
<WZTask,
On <WZTask.taskID, Equal <WZTaskPredecessorRelation.predecessorID> > >,
Where <WZTaskPredecessorRelation.taskID, Equal <Required <WZTask.taskID> > > > .
Select(this, task.TaskID))
{
WZTask predecessorTask = (WZTask)predecessorResult;
if (predecessorTask != null)
{
if (predecessorTask.Status == WizardTaskStatusesAttribute._COMPLETED)
{
needToBeOpen = true;
}
else
{
needToBeOpen = false;
break;
}
}
}
}
task.Status = needToBeOpen ? WizardTaskStatusesAttribute._OPEN : WizardTaskStatusesAttribute._PENDING;
taskGraph.TaskInfo.Update(task);
taskGraph.Save.Press();
}
}
if (customerDiscountsOld == true && update.CustomerDiscounts != true)
{
PXUpdate <Set <ARSetup.applyLineDiscountsIfCustomerPriceDefined, True>, ARSetup> .Update(this);
PXUpdate <Set <ARSetup.applyLineDiscountsIfCustomerClassPriceDefined, True>, ARSetup> .Update(this);
PXUpdate <Set <SOOrderType.recalculateDiscOnPartialShipment, False, Set <SOOrderType.postLineDiscSeparately, False> >, SOOrderType> .Update(this);
}
if (branchOld != update.Branch)
{
PXUpdate <Set <ListEntryPoint.isActive, Required <ListEntryPoint.isActive> >, ListEntryPoint,
Where <ListEntryPoint.entryScreenID, Equal <Required <ListEntryPoint.entryScreenID> > > >
.Update(this, update.Branch == true, "CS101500");
}
yield return(update);
}
else
{
yield return(feature);
}
}
bool needRefresh = !(ActivationBehaviour.Current != null && ActivationBehaviour.Current.Refresh == false);
PXDatabase.ResetSlots();
PXPageCacheUtils.InvalidateCachedPages();
this.Clear();
if (needRefresh)
{
throw new PXRefreshException();
}
}
