Example #1
0
    protected void Page_Load(object sender, EventArgs e)
    {
        string ScenarioID         = Request.Params["ScenarioID"];
        WizardScenarioMaint graph = PXGraph.CreateInstance <WizardScenarioMaint>();

        if (!String.IsNullOrEmpty(ScenarioID))
        {
            Guid id;
            Guid.TryParse(ScenarioID, out id);
            WZScenario scenario = PXSelect <WZScenario, Where <WZScenario.scenarioID, Equal <Required <WZScenario.scenarioID> > > > .Select(graph, id);

            if (scenario != null && !String.IsNullOrEmpty(scenario.Name))
            {
                ((PXLabel)this.frmBottom.FindControl("lblErrCode")).Text = scenario.Name;
                if (scenario.ExecutionDate != null)
                {
                    ((PXLabel)this.frmBottom.FindControl("lastExecTimeVal")).Text = string.Format("{0}. ",
                                                                                                  scenario.ExecutionDate);

                    if (scenario.OwnerID == null)
                    {
                        ((PXLabel)this.frmBottom.FindControl("lastExecByPre")).Visible = false;
                        ((PXLabel)this.frmBottom.FindControl("lastExecByVal")).Visible = false;
                    }
                }
                else
                {
                    ((PXLabel)this.frmBottom.FindControl("lastExecTimePre")).Visible = false;
                    ((PXLabel)this.frmBottom.FindControl("lastExecTimeVal")).Visible = false;
                    ((PXLabel)this.frmBottom.FindControl("lastExecByPre")).Visible   = false;
                    ((PXLabel)this.frmBottom.FindControl("lastExecByVal")).Visible   = false;
                }
            }
        }
    }
Example #2
0
    protected void Page_PreInit(object sender, EventArgs e)
    {
        WizardArticleMaint graph = PXGraph.CreateInstance <WizardArticleMaint>();

        if (!String.IsNullOrEmpty(this.Request.QueryString["TaskID"]))
        {
            Guid   id   = Guid.Parse(this.Request.QueryString["TaskID"]);
            WZTask task = PXSelect <WZTask, Where <WZTask.taskID, Equal <Required <WZTask.taskID> > > > .Select(graph, id);

            if (task != null && !String.IsNullOrEmpty(task.Name))
            {
                WZScenario scenario = PXSelect <WZScenario, Where <WZScenario.scenarioID, Equal <Required <WZScenario.scenarioID> > > > .Select(graph, task.ScenarioID);

                if (scenario != null)
                {
                    this.Master.ScreenTitle = scenario.Name + " - ";
                }
                this.Master.ScreenTitle += task.Name;
                if ((bool)task.IsOptional)
                {
                    this.Master.ScreenTitle += " (Optional)";
                }
            }
        }
    }
Example #3
0
    protected void Page_Init(object sender, EventArgs e)
    {
        WizardScenarioMaint graph = PXGraph.CreateInstance <WizardScenarioMaint>();

        if (!String.IsNullOrEmpty(this.Request.QueryString["ScenarioID"]))
        {
            Guid       id       = Guid.Parse(this.Request.QueryString["ScenarioID"]);
            WZScenario scenario = PXSelect <WZScenario, Where <WZScenario.scenarioID, Equal <Required <WZScenario.scenarioID> > > > .Select(graph, id);

            if (scenario != null && !String.IsNullOrEmpty(scenario.Name))
            {
                this.Master.ScreenTitle = scenario.Name;
            }
        }
    }
Example #4
0
    protected void btnHistory_Click(object sender, EventArgs e)
    {
        string ScenarioID = Request.Params["ScenarioID"];

        if (!String.IsNullOrEmpty(ScenarioID))
        {
            WizardScenarioMaint graph = PXGraph.CreateInstance <WizardScenarioMaint>();
            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))
            {
                PXSiteMapNode node = PXSiteMap.Provider.FindSiteMapNodeFromKey(id);
                if (node != null)
                {
                    string url = ResolveUrl(@"~\Main.aspx?ScreenId=WZ201501&ScenarioID=" + scenario.ScenarioID);
                    Controls.Add(new LiteralControl(@"<script  type='text/javascript'>try { window.top.location.href='" + url + "'; } catch (ex) {}</script>\n"));
                }
            }
        }
    }
Example #5
0
    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"));
                    }
                }
            }
        }
    }
Example #6
0
        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();
            }
        }