public static void ProcessSurvey(List <SurveyCollector> recs, SurveyFilter filter) { var collGraph = CreateInstance <SurveyCollectorMaint>(); var action = filter.Action; if (string.IsNullOrEmpty(action)) { throw new PXException(Messages.SurveyActionNotRecognised); } SurveyProcess surveyProcessGraph = PXGraph.CreateInstance <SurveyProcess>(); surveyProcessGraph.Filter.Insert(filter); var collCache = collGraph.Collector.Cache; var errorOccurred = false; var docCount = 0; foreach (var rec in recs) { var row = (SurveyCollector)collCache.CreateCopy(rec); collGraph.Collector.Current = row; try { PXProcessing <SurveyCollector> .SetCurrentItem(rec); switch (action) { case SurveyAction.SendNew: collGraph.DoSendNewNotification(row); break; case SurveyAction.RemindOnly: collGraph.DoSendReminder(row, filter.DurationTimeSpan); break; case SurveyAction.ExpireOnly: row.Status = CollectorStatus.Expired; row.Message = null; collGraph.Collector.Update(row); break; } if (++docCount % 10 == 0) { surveyProcessGraph.Actions.PressSave(); } PXProcessing <SurveyCollector> .SetInfo(recs.IndexOf(rec), string.Format("The survey collector {0} has been updated", rec.CollectorID)); PXProcessing <SurveyCollector> .SetProcessed(); } catch (Exception ex) { row.Status = CollectorStatus.Error; row.Message = ex.Message; surveyProcessGraph.Documents.Update(row); surveyProcessGraph.Actions.PressSave(); PXTrace.WriteError(ex); string errorMessage = ex.Message + ": "; if (ex is PXOuterException pex && pex.InnerMessages != null) { foreach (string message in pex.InnerMessages) { errorMessage += message + ", "; } }
private static void ProcessMassMailEmails(CRMassMail massMail, IEnumerable <Recipient> recipients) { var processor = PXGraph.CreateInstance <CRMassMailMaint>(); processor.EnsureCachePersistence(typeof(Note)); foreach (Recipient recipient in recipients) { var cache = processor.Caches[recipient.Entity.GetType()]; cache.SetStatus(recipient.Entity, PXEntryStatus.Notchanged); IEnumerable <CRSMEmail> messages; try { messages = recipient.GetSender(massMail).Send(); } catch (Exception e) { PXTrace.WriteError(new PXException(Messages.FailedToSendMassEmail, e)); continue; } processor.AddSendedMessages(massMail, messages); } processor.MassMails.Current = massMail; processor.MassMails.Current.Status = CRMassMailStatusesAttribute.Send; processor.MassMails.Current.SentDateTime = DateTime.Now; processor.MassMails.UpdateCurrent(); processor.Actions.PressSave(); }
#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously async Task <IHttpActionResult> IWebhookHandler.ProcessRequestAsync(HttpRequestMessage request, CancellationToken cancellationToken) { using (var scope = GetUserScope()) { string collectorToken = "NO_TOKEN"; try { var _queryParameters = HttpUtility.ParseQueryString(request.RequestUri.Query); collectorToken = _queryParameters.Get(TOKEN_PARAM); if (string.IsNullOrEmpty(collectorToken)) { throw new Exception($"The {TOKEN_PARAM} Parameter was not specified in the Query String"); } var pageNbrStr = _queryParameters.Get(PAGE_PARAM); var pageNbr = SurveyUtils.GetPageNumber(pageNbrStr); if (pageNbrStr != null && request.Method == HttpMethod.Post) { SurveyUtils.SubmitSurvey(collectorToken, request, pageNbr); pageNbr = SurveyUtils.GetNextOrPrevPageNbr(request, pageNbr); } var(content, newToken) = GetSurveyPage(collectorToken, pageNbr); if (newToken != null && newToken != collectorToken) { return(new RedirectResult(request.RequestUri, newToken, "Was anonymous")); } else { return(new HtmlActionResult(content, HttpStatusCode.OK)); } } catch (Exception ex) { PXTrace.WriteError(ex); var content = GetBadRequestPage(collectorToken, $"{ex.Message}:\n{ex.StackTrace}"); return(new HtmlActionResult(content, HttpStatusCode.BadRequest)); } } }
public static void Process(IList <KCStore> stores) { logger.SetRequestId(GetRequestId()); for (int i = 0; i < stores.Count; i++) { var tokenSource = new CancellationTokenSource(); try { ProcessStore(stores[i], tokenSource.Token); PXProcessing <KCStore> .SetInfo(i, KCMessages.BulkUploadSuccess(stores[i].SiteMasterCD)); } catch (Exception exception) { string log = KCMessages.ProcessException(stores[i].SiteMasterCD, exception.Message, exception.StackTrace); PXTrace.WriteError(exception); logger.ClearLoggingIds(); logger.Error(log); PXProcessing <KCStore> .SetError(i, new Exception(log)); } finally { tokenSource.Cancel(true); tokenSource.Dispose(); } } }
protected virtual void CheckMasterOrganizationCalendarDiscrepancy() { int messageCount = 0; bool isError = false; foreach (Organization organization in PXSelect <Organization> .Select(this)) { foreach (MasterFinPeriod problemPeriod in PXSelectJoin < MasterFinPeriod, LeftJoin <OrganizationFinPeriod, On <MasterFinPeriod.finPeriodID, Equal <OrganizationFinPeriod.masterFinPeriodID>, And <OrganizationFinPeriod.organizationID, Equal <Required <OrganizationFinPeriod.organizationID> > > > >, Where <OrganizationFinPeriod.finPeriodID, IsNull> > .Select(this, organization.OrganizationID)) { isError = true; if (messageCount <= MAX_FINPERIOD_DISCREPANCY_MESSAGE_COUNT) { PXTrace.WriteError(GL.Messages.DiscrepancyPeriod, organization.OrganizationCD, problemPeriod.FinPeriodID); messageCount++; } else { break; } } } if (isError) { throw new PXSetPropertyException(GL.Messages.DiscrepancyPeriodError); } }
public static void TraceAndThrowException(string message, params object[] args) { var exception = new PXException(message, args); PXTrace.WriteError(exception); throw exception; }
/// <summary> /// Creates the Acumatica Employee as a Smartsheet User /// </summary> /// <param name="bAccountID">Employee ID</param> /// <param name="smartsheetClient">Smartsheet SDK Client</param> /// <returns></returns> public User CreateSmartsheetUser(int?bAccountID, SmartsheetClient smartsheetClient) { BAccount bAccountRecord = PXSelect <BAccount, Where <BAccount.bAccountID, Equal <Required <BAccount.bAccountID> > > > .Select(Base, bAccountID); PX.Objects.CR.Contact contactRecord = PXSelect <PX.Objects.CR.Contact, Where <PX.Objects.CR.Contact.contactID, Equal <Required <PX.Objects.CR.Contact.contactID> > > > .Select(Base, bAccountRecord.DefContactID); if (contactRecord == null) { throw new PXException(string.Format(SmartsheetConstants.Messages.ERROR_CONTACT, bAccountRecord.AcctName)); } try { User ssUserNew = new User(); ssUserNew.Email = contactRecord.EMail; ssUserNew.FirstName = contactRecord.FirstName; ssUserNew.LastName = contactRecord.LastName; ssUserNew.Admin = false; ssUserNew.LicensedSheetCreator = false; User updatedUser = smartsheetClient.UserResources.AddUser(ssUserNew, false, false); return(updatedUser); } catch (Exception e) { PXTrace.WriteError(e.Message); return(null); } }
protected virtual List <PILocks> LoadExistingLocks() { var dummyGraph = new PXGraph(); var statusItemsQuery = new PXSelectReadonly <INPIStatusItem, Where <INPIStatusItem.siteID, Equal <Required <INPIStatusItem.siteID> > >, OrderBy <Asc <INPIStatusItem.pIID> > >(dummyGraph); // the sorting required for ToPiIdDictionary method Dictionary <string, List <INPIStatusItem> > itemLocksByPiId; using (new PXFieldScope(statusItemsQuery.View, typeof(INPIStatusItem.recordID), typeof(INPIStatusItem.inventoryID), typeof(INPIStatusItem.pIID), typeof(INPIStatusItem.excluded), typeof(INPIStatusItem.active))) { itemLocksByPiId = ToPiIdDictionary( statusItemsQuery .Select(_siteId) .RowCast <INPIStatusItem>()); } var statusLocQuery = new PXSelectReadonly <INPIStatusLoc, Where <INPIStatusLoc.siteID, Equal <Required <INPIStatusLoc.siteID> > >, OrderBy <Asc <INPIStatusLoc.pIID> > >(dummyGraph); // the sorting required for ToPiIdDictionary method Dictionary <string, List <INPIStatusLoc> > locationLocksByPiId; using (new PXFieldScope(statusLocQuery.View, typeof(INPIStatusLoc.recordID), typeof(INPIStatusLoc.locationID), typeof(INPIStatusLoc.pIID), typeof(INPIStatusLoc.excluded), typeof(INPIStatusLoc.active))) { locationLocksByPiId = ToPiIdDictionary( statusLocQuery .Select(_siteId) .RowCast <INPIStatusLoc>()); } if (itemLocksByPiId.Count != locationLocksByPiId.Count) { PXTrace.WriteError(Messages.PIDBInconsistency); } var existingLocks = new List <PILocks>(); foreach (var itemLocksKvp in itemLocksByPiId) { var piId = itemLocksKvp.Key; var locationLocks = locationLocksByPiId[piId]; existingLocks.Add(new PILocks(piId, itemLocksKvp.Value, locationLocks)); } return(existingLocks); }
public virtual IEnumerable importForecast(PXAdapter adapter) { PXLongOperation.StartOperation(this, delegate() { //Create needed graphs var graph = PXGraph.CreateInstance <AFResultMaint>(); AFSetup setup = graph.Setup.Current ?? graph.Setup.Select(); //----------------------------------------------------------------------------- //Change for Setup daya string bucketName = setup.AFBucketName; string s3DirectoryName = setup.AFOutDirectoryName; string accessKey = setup.AFAccessKey; string secretKey = setup.AFSecretKey; //----------------------------------------------------------------------------- PXTrace.WriteInformation($"AFAccessKey: {accessKey} AFSecretKey: {secretKey} AFBucketName: {bucketName} AFDirectoryName: {s3DirectoryName}"); //if (data?.Count == 0) return; try { AFAmazonTools myUploader = new AFAmazonTools(); var result = myUploader.DownloadFromS3(accessKey, secretKey, bucketName, s3DirectoryName); foreach (var line in result) { try { var item = new AFResult(); item.ResultID = line[0]; item.ResultTstamp = DateTime.Parse(line[1], null, System.Globalization.DateTimeStyles.RoundtripKind); item.ResultP10 = Convert.ToDecimal(line[2]); item.ResultE50 = Convert.ToDecimal(line[3]); item.ResultP90 = Convert.ToDecimal(line[4]); graph.AFResultView.Update(item); } catch (Exception e) { PXTrace.WriteError($"Error parsing data ({String.Join(",", line)}): {e.Message}"); } } graph.Save.Press(); } catch (Exception e) { throw new PXException(e.Message, e); } }); return(adapter.Get()); }
public static void GetVATObligationsProc(VATMaint graph, DateTime from, DateTime to, string status = null) { obligationsRequest req = new obligationsRequest() { from = from, to = to, status = status }; obligationResponse obligationResponse = null; try { obligationResponse = graph.VATProvider.Obligations(req); } catch (Exceptions.VATAPIInvalidToken eToken) { PXTrace.WriteError(eToken); graph.signInHMRC.SetEnabled(true); throw new PXException(Messages.PleaseAuthorize); } catch (Exceptions.VATAPIException eApi) { PXTrace.WriteError(eApi); if (eApi.Data.Contains("json")) { PXTrace.WriteError(eApi.Data["json"].ToString()); } if (eApi.Code != error.MATCHING_RESOURCE_NOT_FOUND) { throw eApi; } } catch (Exception e) { PXTrace.WriteError(e); throw e; } graph.Obligations.Cache.Clear(); if (obligationResponse != null) { foreach (var o in obligationResponse.obligations) { graph.Obligations.Insert(new Obligation() { Start = o.start, End = o.end, Due = o.due, Status = o.status, PeriodKey = o.periodKey, Received = o.received }); } } return; }
protected virtual void CheckOrganizationCalendarFieldsDiscrepancy() { int messageCount = 0; bool isError = false; if (EtalonOrganization != null) { foreach (Organization organization in PXSelect < Organization, Where <Organization.organizationID, NotEqual <Required <Organization.organizationID> > > > .Select(this, EtalonOrganization.OrganizationID)) { foreach (OrganizationFinPeriod problemPeriod in PXSelectJoin < OrganizationFinPeriod, LeftJoin <OrganizationFinPeriodStatus, On <OrganizationFinPeriodStatus.organizationID, Equal <Required <OrganizationFinPeriodStatus.organizationID> >, And <OrganizationFinPeriod.finPeriodID, Equal <OrganizationFinPeriodStatus.finPeriodID>, And <OrganizationFinPeriod.dateLocked, Equal <OrganizationFinPeriodStatus.dateLocked>, And <OrganizationFinPeriod.status, Equal <OrganizationFinPeriodStatus.status>, And <OrganizationFinPeriod.aPClosed, Equal <OrganizationFinPeriodStatus.aPClosed>, And <OrganizationFinPeriod.aRClosed, Equal <OrganizationFinPeriodStatus.aRClosed>, And <OrganizationFinPeriod.iNClosed, Equal <OrganizationFinPeriodStatus.iNClosed>, And <OrganizationFinPeriod.cAClosed, Equal <OrganizationFinPeriodStatus.cAClosed>, And <OrganizationFinPeriod.fAClosed, Equal <OrganizationFinPeriodStatus.fAClosed> > > > > > > > > > >, Where <OrganizationFinPeriodStatus.finPeriodID, IsNull, And <OrganizationFinPeriod.organizationID, Equal <Required <OrganizationFinPeriod.organizationID> > > > > .Select(this, organization.OrganizationID, EtalonOrganization.OrganizationID)) { isError = true; if (messageCount <= MAX_FINPERIOD_DISCREPANCY_MESSAGE_COUNT) { string problemFields = GetProblemFields(organization, problemPeriod); PXTrace.WriteError(GL.Messages.DiscrepancyField, EtalonOrganization.OrganizationCD, organization.OrganizationCD, problemFields, problemPeriod.FinPeriodID); messageCount++; } else { break; } } } if (isError) { throw new PXSetPropertyException(GL.Messages.DiscrepancyFieldError); } } }
public override void Initialize() { try { var fullName = Base.GetType().Namespace + '.' + Base.GetType().Name; //if (Base.GetType().Name == "CustomerMaint") { PowerTabAssignment.Current = PowerTabAssignment.Select(fullName); if (PowerTabAssignment.Current != null) { var paramMap = PowerTabMapping.Select(); if (paramMap != null) { var ptParams = new Dictionary <string, string>(); foreach (GIMappingLine param in paramMap) { //var cleanName = param.FieldName.Split('.').Last(); ptParams.Add(param.ParamName, param.FieldName); } //PowerTabSource.Current = new PTSource(); //PowerTabSource.Current.PowerTabUrl = BuildSource("GI", PowerTabAssignment.Current.DesignID, ptParams); // ptParams.Add("CustomerAccountID", "AcctCD"); //BuildSource("DB", "DB000031", ptParams); Base.RowSelected.AddHandler(Base.PrimaryView, (cache, args) => { if (PowerTabSource?.Current == null) { PowerTabSource.Current = new PTSource(); } PowerTabAssignment.Current = PowerTabAssignment.Select(fullName); var giName = ((GIDesign)PXSelectorAttribute.SelectAll <GIMapping.designID>(PowerTabAssignment.Cache, PowerTabAssignment.Current).Find(map => ((GIDesign)map).DesignID == PowerTabAssignment.Current.DesignID))?.Name; PowerTabSource.Current.PowerTabUrl = BuildSource("GI", giName, ptParams); }); } } } catch (Exception ex) { PXTrace.WriteError(ex); } }
public virtual void Persist(Action persist) { if (!ExtractionIsActive) { persist(); return; } Action revertCallback = null; FormatExceptionBehaviour?eh = null; ImageExtractor.Base64FormatException ex = null; try { ExtractEmbeddedImages(out revertCallback); ProcessWhenNoExceptionThrown(); } catch (ImageExtractor.Base64FormatException b64e) { PXTrace.WriteError(b64e); if (revertCallback != null) { revertCallback(); revertCallback = null; } eh = ProcessBase64FormatException(b64e); if (eh == FormatExceptionBehaviour.Throw) { throw new PXSetPropertyException(b64e, PXErrorLevel.Error, Messages.CannotDecodeBase64ContentExplicit); } ex = b64e; } try { persist(); } catch { revertCallback?.Invoke(); throw; } if (ex != null && eh == FormatExceptionBehaviour.ThrowWarningAfterPersist) { throw new PXSetPropertyException(ex, PXErrorLevel.Warning, Messages.CannotDecodeBase64Content); } }
public static void HandleAggregateException(AggregateException aggregateException, HttpStatusCode codeToHandle, Action <Exception> action) { aggregateException.Handle((e) => { PXTrace.WriteError(e); var boxException = e as BoxException; if (boxException != null && boxException.StatusCode == codeToHandle) { action(e); return(true); } return(false); }); }
private IEnumerable <KeyValuePair <string, Guid> > CreateAttachments(ICollection <string> allowedExtensions) { var images = new List <KeyValuePair <string, Guid> >(); foreach (Entity c in _email.Message.Attachments) { var newFileId = Guid.NewGuid(); var name = c.ContentDisposition?.Param_FileName ?? c.ContentType?.Param_Name; if (name == null) { continue; } name = name.Trim(); if (string.IsNullOrEmpty(name)) { name = "untitled"; } string ext; try { ext = Path.GetExtension(name); } catch (ArgumentException ae) { PXTrace.WriteError(new Exception("Cannot parse extension of the attachment name. Name contains invalid symbols.", ae)); ext = null; } if (!string.IsNullOrEmpty(ext)) { ext = ext.Substring(1).ToLower(); } if (allowedExtensions != null && !allowedExtensions.Contains(ext)) { continue; } var content = ((BodySinglepartBase)c.Body).Data; CreateFile(_activityMessage.NoteID.Value, newFileId, name, content); if (!string.IsNullOrEmpty(c.ContentID)) { images.Add(new KeyValuePair <string, Guid>(c.ContentID, newFileId)); } } return(images); }
private protected override FormatExceptionBehaviour ProcessBase64FormatException(ImageExtractor.Base64FormatException e) { var cache = Base.Caches <TDocument>(); var entity = cache.Current; if (entity == null) { // shouldn't ever happen return(base.ProcessBase64FormatException(e)); } var value = cache.GetValue <TExceptionField>(entity) as string; if (!value.IsNullOrEmpty()) { try { var doc = new HtmlDocument(); doc.LoadHtml(value); if (doc.DocumentNode .Descendants(ExceptionHtmlConsts.Tag) .Where(el => el.Attributes[ExceptionHtmlConsts.PXExceptionDataTag]?.Value == ExceptionHtmlConsts.Base64FormatExceptionDataTagValue) .Any()) { // do nothing - exception already exists return(FormatExceptionBehaviour.DontThrow); } value += "<br><br>" + string.Format(ExceptionHtmlConsts.HtmlExceptionTag, PXMessages.LocalizeNoPrefix(Messages.CannotDecodeBase64ContentExplicit)); } catch (Exception ex) { PXTrace.WriteError(ex); } } else { value = string.Format(ExceptionHtmlConsts.HtmlExceptionTag, PXMessages.LocalizeNoPrefix(Messages.CannotDecodeBase64ContentExplicit)); } cache.SetValue <TExceptionField>(entity, value); return(FormatExceptionBehaviour.DontThrow); }
public virtual IEnumerable UploadFile(PXAdapter adapter) { this.Save.Press(); if (this.NewFacePanel.AskExt() == WebDialogResult.OK) { var person = this.Persons.Current; if (person != null) { const string PanelSessionKey = "FaceFile"; var info = PXContext.SessionTyped <PXSessionStatePXData>().FileInfo[PanelSessionKey] as PX.SM.FileInfo; try { var faceId = Api.AddPersonFace(person, info.BinData); info.UID = faceId; try { info.UID = faceId; SaveFile(info); } catch (Exception ex) { PXTrace.WriteError(ex); Api.DeletePersonFace(person, faceId); } } finally { System.Web.HttpContext.Current.Session.Remove(PanelSessionKey); } PXLongOperation.StartOperation(this, () => { Api.Train(person.GroupName); }); } } return(adapter.Get()); }
private protected override void ProcessWhenNoExceptionThrown() { var cache = Base.Caches <TDocument>(); var entity = cache.Current; if (entity == null && cache.GetValue <TExceptionField>(entity) == null) { return; } var value = cache.GetValue <TExceptionField>(entity) as string; if (!value.IsNullOrEmpty()) { try { var doc = new HtmlDocument(); doc.LoadHtml(value); var nodes = doc.DocumentNode .Descendants(ExceptionHtmlConsts.Tag) .Where(el => el.Attributes[ExceptionHtmlConsts.PXExceptionDataTag]?.Value == ExceptionHtmlConsts.Base64FormatExceptionDataTagValue) .ToList(); foreach (var node in nodes) { // remove empty lines if (node.PreviousSibling?.Name == "br") { doc.DocumentNode.RemoveChild(node.PreviousSibling); if (node.PreviousSibling?.PreviousSibling?.Name == "br") { doc.DocumentNode.RemoveChild(node.PreviousSibling.PreviousSibling); } } if (node.NextSibling?.Name == "br") { doc.DocumentNode.RemoveChild(node.NextSibling); } doc.DocumentNode.RemoveChild(node); } cache.SetValue <TExceptionField>(entity, doc.DocumentNode.OuterHtml); } catch (Exception ex) { PXTrace.WriteError(ex); } } }
private bool CreateMessage() { if (_message != null) { _activityMessage = PXSelect <CRSMEmail, Where <CRSMEmail.noteID, Equal <Required <SMEmail.refNoteID> > > > .Select(_graph, _message.RefNoteID); return(true); } try { if (_email.Message.From == null || _email.Message.From.Count() == 0) { return(false); } using (PXTransactionScope ts = new PXTransactionScope()) { // Only two functions in scope so as not to create activity without email, // but also to prevent repetition of processing messages with bad attachments CreateActivity(); CreateEmail(); ts.Complete(); } if (_message == null) { return(false); } _activityMessage = PXSelect <CRSMEmail, Where <CRSMEmail.noteID, Equal <Required <SMEmail.refNoteID> > > > .Select(_graph, _message.RefNoteID); AppendAttachments(); PersistAM(); return(true); } catch (Exception ex) { PXTrace.WriteError(ex); PersistException(ex); return(false); } }
protected static void LogMessages(BaseResult result) { foreach (AvaMessage msg in result.Messages) { switch (result.ResultCode) { case SeverityLevel.Exception: case SeverityLevel.Error: PXTrace.WriteError(msg.Summary + ": " + msg.Details); break; case SeverityLevel.Warning: PXTrace.WriteWarning(msg.Summary + ": " + msg.Details); break; } } }
public void SendAndForget(NotificationResultWrapper result, CancellationToken cancellationToken, Action <string> onSendingFailed, Action continuation) { try { this.Send(result, cancellationToken); } catch (Exception e) { string queueName = _msmq?.QueueName ?? Address; PXTrace.WriteError($"Sending to MSMQ {queueName} failed: {e.Message}"); onSendingFailed($"Send to target {this.Name} failed: ({e.Message})"); } finally { continuation(); } }
private void AddReversedTaxTransactionsToReversedTaxAdjustment(TaxAdjustment originalTaxAdj, TaxAdjustment reversedTaxAdj) { if (reversedTaxAdj == null) { PXTrace.WriteError("The creation reversed Tax Adjustment for the Tax Adjustment with the ID {0} failed", originalTaxAdj.RefNbr); throw new PXException("The creation reversed Tax Adjustment for the Tax Adjustment with the ID {0} failed", originalTaxAdj.RefNbr); } var originalTransactions = PXSelect <TaxTran, Where <TaxTran.tranType, Equal <Required <TaxAdjustment.docType> >, And <TaxTran.refNbr, Equal <Required <TaxAdjustment.refNbr> > > > > .Select(this, originalTaxAdj.DocType, originalTaxAdj.RefNbr); foreach (TaxTran originalTaxTran in originalTransactions) { TaxTran reversingTran = PXCache <TaxTran> .CreateCopy(originalTaxTran); reversingTran.TranType = originalTaxTran.TranType; reversingTran.RefNbr = reversedTaxAdj.RefNbr; reversingTran.RecordID = null; reversingTran.Released = null; reversingTran.CuryInfoID = null; reversingTran.ExpenseAmt = -originalTaxTran.ExpenseAmt; reversingTran.CuryExpenseAmt = -originalTaxTran.CuryExpenseAmt; reversingTran.OrigTaxableAmt = -originalTaxTran.OrigTaxableAmt; reversingTran.CuryOrigTaxableAmt = -originalTaxTran.CuryOrigTaxableAmt; reversingTran.TaxAmt = -originalTaxTran.TaxAmt; reversingTran.CuryTaxAmt = -originalTaxTran.CuryTaxAmt; reversingTran.TaxableAmt = -originalTaxTran.TaxableAmt; reversingTran.CuryTaxableAmt = -originalTaxTran.CuryTaxableAmt; reversingTran.ReportTaxAmt = -originalTaxTran.ReportTaxAmt; reversingTran.ReportTaxableAmt = -originalTaxTran.ReportTaxableAmt; Transactions.Insert(reversingTran); } Transactions.View.RequestRefresh(); }
protected void Page_InitComplete(object sender, EventArgs e) { this.InitializeModules(); if (!this.Page.IsCallback) { this.FillBrachesList(); } this.InitAuditMenu(); if (!this.Page.IsCallback || ControlHelper.IsReloadPage(tlbPath)) { var favBtn = (PXToolBarButton)tlbPath.Items["favorites"]; PXSiteMapNode currentNode = System.Web.SiteMap.CurrentNode as PXSiteMapNode; try { if (currentNode == null || String.IsNullOrEmpty(currentNode.ScreenID)) { favBtn.Visible = false; } else { tlbPath.CallbackUpdatable = favBtn.DynamicText = true; var entryScreenId = GetEntryNodeId(PXSiteMap.CurrentNode.ScreenID); if (!entryScreenId.HasValue) { favBtn.Visible = false; } else { favBtn.Pushed = this.IsInFavorites(entryScreenId.Value); favBtn.Tooltip = favBtn.Pushed ? InfoMessages.RemoveFromFavorites : InfoMessages.AddToFavorites; } } } catch (Exception ex) { PXTrace.WriteError(ex); } } // Force the customization controls creation !!! this.EnsureChildControls(); }
public void Commit() { if (_inconsistencyHandlingMode == InconsistencyHandlingMode.None || !_errors.Any()) { return; } foreach (InconsistencyError error in _errors) { foreach (RecordContextInfo contextInfo in error.ContextData) { PXTrace.WriteInformation(contextInfo.Cache.GetFullDescription(contextInfo.Record)); } PXTrace.WriteInformation($"{error.ErrorCode} {error.IntegrityException.Message}"); } if (_inconsistencyHandlingMode == InconsistencyHandlingMode.Prevent) { DataIntegrityException firstError = _errors.First().IntegrityException; throw new DataIntegrityException( firstError.InconsistencyCode, Messages.DataIntegrityErrorDuringProcessingFormat, firstError.Message); } if (_inconsistencyHandlingMode == InconsistencyHandlingMode.Log) { DateTime now = DateTime.UtcNow; foreach (InconsistencyError error in _errors) { string context = error.ContextData.Any() ? string.Join("\r\n", error.ContextData.Select(contextInfo => contextInfo.Cache.ToXml(contextInfo.Record))) : string.Empty; var errorMsg = $"Error message: {error.IntegrityException.Message}; Date: {DateTime.Now}; Screen: {_graph.Accessinfo.ScreenID}; Context: {context}; InconsistencyCode: {error.IntegrityException.InconsistencyCode}"; PXTrace.WriteError(errorMsg); } } }
public virtual IEnumerable ReverseAdjustment(PXAdapter adapter) { TaxAdjustment taxAdjToReverse = Document.Current; if (taxAdjToReverse?.Released != true || !AskUserApprovalIfReversingDocumentAlreadyExists(taxAdjToReverse)) { return(adapter.Get()); } Save.Press(); try { IsReversingInProgress = true; Clear(PXClearOption.PreserveTimeStamp); var reverseAdjustmentWithCuryInfo = CreateReversingTaxAdjustmentWithCuryInfo(taxAdjToReverse); TaxAdjustment reverseAdjustment = Document.Insert(reverseAdjustmentWithCuryInfo.Item1); UpdateCurrencyInfoForReversedTaxAdjustment(reverseAdjustmentWithCuryInfo.Item2); AddReversedTaxTransactionsToReversedTaxAdjustment(taxAdjToReverse, reverseAdjustment); Document.Cache.RaiseExceptionHandling <TaxAdjustment.finPeriodID>(Document.Current, Document.Current.FinPeriodID, null); PXTrace.WriteVerbose("Reverse Tax Adjustment for Tax Adjustment \"{0}\" was created", taxAdjToReverse.RefNbr); return(new List <TaxAdjustment> { Document.Current }); } catch (PXException e) { PXTrace.WriteError(e); Clear(PXClearOption.PreserveTimeStamp); Document.Current = taxAdjToReverse; throw; } finally { IsReversingInProgress = false; } }
private Tuple <TaxAdjustment, CurrencyInfo> CreateReversingTaxAdjustmentWithCuryInfo(TaxAdjustment taxAdjToReverse) { CurrencyInfo originalCuryInfo = PXSelect <CurrencyInfo, Where <CurrencyInfo.curyInfoID, Equal <Required <CurrencyInfo.curyInfoID> > > > .SelectSingleBound(this, currents : null, pars : taxAdjToReverse.CuryInfoID); if (originalCuryInfo == null) { PXTrace.WriteError("The {0} object with the ID {1} is not found", nameof(CurrencyInfo), taxAdjToReverse.CuryInfoID); throw new PXException("The {0} object with the ID {1} is not found. The reverse tax adjustment can't be created.", nameof(CurrencyInfo), taxAdjToReverse.CuryInfoID); } CurrencyInfo reversedAdjCuryInfo = PXCache <CurrencyInfo> .CreateCopy(originalCuryInfo); reversedAdjCuryInfo.CuryInfoID = null; reversedAdjCuryInfo.IsReadOnly = false; reversedAdjCuryInfo = currencyinfo.Insert(reversedAdjCuryInfo); TaxAdjustment reverseAdjustment = PXCache <TaxAdjustment> .CreateCopy(taxAdjToReverse); reverseAdjustment.CuryInfoID = reversedAdjCuryInfo.CuryInfoID; reverseAdjustment.RefNbr = null; reverseAdjustment.OrigRefNbr = taxAdjToReverse.RefNbr; reverseAdjustment.Released = false; reverseAdjustment.Hold = true; reverseAdjustment.BatchNbr = null; reverseAdjustment.NoteID = null; reverseAdjustment.OrigDocAmt = -reverseAdjustment.OrigDocAmt; reverseAdjustment.CuryOrigDocAmt = -reverseAdjustment.CuryOrigDocAmt; //Adjustment doc balance is calculated via PXFormula attribute on TaxTan, therefore it's cleared here reverseAdjustment.CuryDocBal = null; reverseAdjustment.DocBal = null; return(Tuple.Create(reverseAdjustment, reversedAdjCuryInfo)); }
public void Emit(LogEvent logEvent) { switch (logEvent.Level) { case LogEventLevel.Information: case LogEventLevel.Debug: PXTrace.WriteInformation(logEvent.ToTraceMessage(_formatProvider)); break; case LogEventLevel.Error: case LogEventLevel.Fatal: PXTrace.WriteError(logEvent.ToTraceMessage(_formatProvider)); break; case LogEventLevel.Warning: PXTrace.WriteWarning(logEvent.ToTraceMessage(_formatProvider)); break; default: throw new ArgumentOutOfRangeException(); } }
public static async Task SendPushNotificationAsync(VXUserPushNotification pushNotification, PushMessage pushMessage) { var subject = @"mailto:[email protected]"; const string publicKey = @"BAHU3QNr2PvPSufR9hKYgV7daemnktvh6AYqBqta9brwWK6S064nzJQCadUT4LD3fyJMs5FiKh9uW_v_t4aU4eI"; const string privateKey = @"hoIs3IDTJvGbPUgK2qhwFuREX5deqKhBVNAN0a70_dg"; var subscription = new PushSubscription(pushNotification.Endpoint, pushNotification.ReceiverKey, pushNotification.AuthKey); var vapidDetails = new VapidDetails(subject, publicKey, privateKey); var webPushClient = new WebPushClient(); try { await webPushClient.SendNotificationAsync(subscription, JsonConvert.SerializeObject(pushMessage), vapidDetails); } catch (AggregateException ae) { ae.Handle((ex) => { if (ex is WebPushException) { var xpe = (WebPushException)ex; switch (xpe.StatusCode) { case System.Net.HttpStatusCode.Gone: //TODO: Delete endpoint from VXUserPushNotification return(true); default: PXTrace.WriteError(ex); return(false); } } PXTrace.WriteError(ex); return(false); }); } }
public bool PrepareImportRow(string viewName, IDictionary keys, IDictionary values) { if (string.Compare(viewName, PIDetail.View.Name, true) == 0) { PXCache barCodeCache = AddByBarCode.Cache; INBarCodeItem item = (INBarCodeItem)(AddByBarCode.Current ?? barCodeCache.CreateInstance()); try { barCodeCache.SetValueExt <INBarCodeItem.inventoryID>(item, GetImportedValue <INPIDetail.inventoryID>(values, true)); if (PXAccess.FeatureInstalled <FeaturesSet.subItem>()) { barCodeCache.SetValueExt <INBarCodeItem.subItemID>(item, GetImportedValue <INPIDetail.subItemID>(values, true)); } if (PXAccess.FeatureInstalled <FeaturesSet.warehouseLocation>()) { barCodeCache.SetValueExt <INBarCodeItem.locationID>(item, GetImportedValue <INPIDetail.locationID>(values, true)); } if (PXAccess.FeatureInstalled <FeaturesSet.lotSerialTracking>()) { barCodeCache.SetValueExt <INBarCodeItem.lotSerialNbr>(item, GetImportedValue <INPIDetail.lotSerialNbr>(values, false)); } barCodeCache.SetValueExt <INBarCodeItem.qty>(item, GetImportedValue <INPIDetail.physicalQty>(values, true)); barCodeCache.SetValueExt <INBarCodeItem.autoAddLine>(item, false); barCodeCache.Update(item); UpdatePhysicalQty(); } catch (Exception e) { PXTrace.WriteError(IN.Messages.RowError, excelRowNumber, e.Message); importHasError = true; } finally { excelRowNumber++; } } return(false); }
public virtual void SetFlagsFromStatus(PMTask task, string status) { if (string.IsNullOrEmpty(status)) { throw new ArgumentNullException(); } switch (status) { case ProjectTaskStatus.Planned: task.IsActive = false; task.IsCompleted = false; task.IsCancelled = false; break; case ProjectTaskStatus.Active: task.IsActive = true; task.IsCompleted = false; task.IsCancelled = false; break; case ProjectTaskStatus.Canceled: task.IsActive = false; task.IsCompleted = false; task.IsCancelled = true; break; case ProjectTaskStatus.Completed: task.IsActive = true; task.IsCompleted = true; task.IsCancelled = false; break; default: PXTrace.WriteError("Unknown status: " + status); break; } }