public void ShowAlert(AlertType type, string message) { HtmlGenericControl h4AlertHeading = (HtmlGenericControl)(this.Master).FindControl("h4AlertHeading"); Label lblErrorMessage = (Label)(this.Master).FindControl("lblErrorMessage"); Panel pnlAlert = (Panel)(this.Master).FindControl("pnlAlert"); h4AlertHeading.Visible = false; lblErrorMessage.Text = message; switch (type) { case AlertType.Error: pnlAlert.CssClass = BootstrapStyleConstant.AlertError; break; case AlertType.Information: pnlAlert.CssClass = BootstrapStyleConstant.AlertInfo; break; case AlertType.Success: pnlAlert.CssClass = BootstrapStyleConstant.AlertSuccess; break; default: pnlAlert.CssClass = BootstrapStyleConstant.AlertWarning; break; } pnlAlert.Visible = true; }
public static SetAlert Set(string message, string strongMessage, AlertType typeOfAlert) { SetAlert alert = new SetAlert(); alert.Message = message; alert.StrongMessage = strongMessage; switch (typeOfAlert) { case AlertType.Success: alert.TypeOfAlert = "alert-success"; break; case AlertType.Danger: alert.TypeOfAlert = "alert-danger"; break; case AlertType.Info: alert.TypeOfAlert = "alert-info"; break; case AlertType.Warning: alert.TypeOfAlert = "alert-warning"; break; } return alert; }
/// <summary> /// Creates a list of AlertModels with a single item. /// </summary> /// <param name="type">The alert type.</param> /// <param name="message">The message.</param> /// <returns>A single item list of an AlertModel.</returns> public static List<AlertModel> CreateSingle(AlertType type, string message) { Guard.NotNull(() => type); Guard.NotNullOrEmpty(() => message); return new List<AlertModel> { new AlertModel(type, message) }; }
private SettingManager() { this.alertType = AlertType.LatestOnly; this.alertAfterDate = DateTime.MinValue; this.svnUserName = ""; this.svnPassword = ""; this.listOfTrackingTarget = new List<TrackingTargetEntity>(); }
public void Add(String message, AlertType alerttype) { if (frm != null) { frm.AddAlert(message, alerttype, scriptname); } }
public static MvcHtmlString GetAlerts(this HtmlHelper helper, AlertType alertType, AlertLocation alertLocation) { var alertData = helper.ViewContext.TempData.InitializeAlertData(); List<string> messages = alertData[alertLocation][alertType]; if (messages.Count > 0) { var outerBuilder = new TagBuilder("div"); outerBuilder.AddCssClass("container-fluid"); foreach (var message in messages) { var builder = new TagBuilder("div"); builder.AddCssClass("alert"); builder.AddCssClass("in"); builder.AddCssClass("fade"); builder.AddCssClass(alertType.GetDescription()); builder.SetInnerText(message); var closeButton = new TagBuilder("a"); closeButton.AddCssClass("close"); closeButton.MergeAttribute("data-dismiss", "alert"); closeButton.MergeAttribute("href", "#"); closeButton.InnerHtml += "×"; builder.InnerHtml += closeButton.ToString(TagRenderMode.Normal); outerBuilder.InnerHtml += builder.ToString(TagRenderMode.Normal); } return outerBuilder.ToString(TagRenderMode.Normal).ToMvcHtmlString(); } return string.Empty.ToMvcHtmlString(); }
public AlertMsg(AlertType alertType, string title, string body) : base(typeof(AlertViewModel)) { AlertType = alertType; Title = title; Body = body; }
public Alert(AlertType type, AlertDirection direction, int? trigger, string queue) { Type = type; Direction = direction; Trigger = trigger; Queue = queue; }
public void OnSaved(WpfConfiguration configurationControl) { ACPowerMonitorConfig config = configurationControl as ACPowerMonitorConfig; lock (Lock) { AlertWhen = config.AlertWhen; } }
/// <summary> /// Initializes a new instance of the <see cref="AlertModel" /> class. /// </summary> /// <param name="type">The type of the alert.</param> /// <param name="message">The message.</param> public AlertModel(AlertType type, string message) { Guard.NotNull(() => type); Guard.NotNullOrEmpty(() => message); this.Type = type; this.Message = message; }
public void ShowAlert(AlertType type, string header, string message) { ShowAlert(type, message); HtmlGenericControl h4AlertHeading = (HtmlGenericControl)(this.Master).FindControl("h4AlertHeading"); h4AlertHeading.InnerText = header; h4AlertHeading.Visible = true; }
private static void AddMessage(TempDataDictionary tempData, AlertType type, string message, AlertLocation location) { var alertData = tempData.InitializeAlertData(); alertData[location][type].Add(message); tempData["AlertData"] = alertData; }
/// <summary> /// Adds an alert of the specified type with the specified message /// </summary> /// <param name="controller"> /// The <see cref="Controller"/> to use to add the alert /// </param> /// <param name="type"> /// The <see cref="AlertType"/> for the alert /// </param> /// <param name="message"> /// The message for the alert /// </param> public static void AddAlert( this Controller controller, AlertType type, string message) { List<AlertMessage> alerts = controller.TempData[ALERT_MESSAGE_KEY] as List<AlertMessage> ?? new List<AlertMessage>(); alerts.Add(new AlertMessage() { Type = type, Message = message}); controller.TempData["AlertMessages"] = alerts; }
/// <summary> /// Create an alert box of the specified type /// </summary> /// <param name="html">The current HtmlHelper instance</param> /// <param name="message">The message to show</param> /// <param name="alertType">The type of alert to show.</param> public static MvcHtmlString Alert(this HtmlHelper html, string message, AlertType alertType) { var div = new TagBuilder("div"); div.AddCssClass("alert-box"); div.AddCssClass(alertType.GetStringValue()); div.InnerHtml = message; div.InnerHtml += "<a href=\"#\" class=\"close\">×</a>"; return new MvcHtmlString(div.ToString(TagRenderMode.Normal)); }
public MessageBoxForm (IWin32Window owner, string text, string caption, MessageBoxButtons buttons, MessageBoxIcon icon, bool displayHelpButton) { show_help = displayHelpButton; switch (icon) { case MessageBoxIcon.None: { icon_image = null; alert_type = AlertType.Default; break; } case MessageBoxIcon.Error: { // Same as MessageBoxIcon.Hand and MessageBoxIcon.Stop icon_image = SystemIcons.Error; alert_type = AlertType.Error; break; } case MessageBoxIcon.Question: { icon_image = SystemIcons.Question; alert_type = AlertType.Question; break; } case MessageBoxIcon.Asterisk: { // Same as MessageBoxIcon.Information icon_image = SystemIcons.Information; alert_type = AlertType.Information; break; } case MessageBoxIcon.Warning: { // Same as MessageBoxIcon.Exclamation: icon_image = SystemIcons.Warning; alert_type = AlertType.Warning; break; } } msgbox_text = text; msgbox_buttons = buttons; msgbox_default = MessageBoxDefaultButton.Button1; if (owner != null) { Owner = Control.FromHandle(owner.Handle).FindForm(); } else { if (Application.MWFThread.Current.Context != null) { Owner = Application.MWFThread.Current.Context.MainForm; } } this.Text = caption; this.ControlBox = true; this.MinimizeBox = false; this.MaximizeBox = false; this.ShowInTaskbar = (Owner == null); this.FormBorderStyle = FormBorderStyle.FixedDialog; }
private void CreateMemberSearchAlert(MemberSearch search, AlertType alertType) { var alert = new MemberSearchAlert { MemberSearchId = search.Id, AlertType = alertType }; alert.Prepare(); alert.Validate(); _repository.CreateMemberSearchAlert(alert); }
internal Alert(int id, int code, string message) : base(message) { RequestId = OrderId = id; // id refers to either a requestId or an orderId. Code = code; if (string.IsNullOrWhiteSpace(message)) { throw new ArgumentException(nameof(message)); } AlertType = GetAlertTypeFromCode(code, id); }
public static void Show(string message, AlertType type, bool off_soud = true) { if (off_soud == true) { System.IO.Stream str = CCMS.Properties.Resources.notification; System.Media.SoundPlayer snd = new System.Media.SoundPlayer(str); snd.Play(); } new CCMS.view.alert(message, type).Show(); }
protected void AddAlert(AlertType type, TitleType titleType, string title, string content) { AddAlert(new Alert { Type = type, TitleType = titleType, Title = title, Content = content }); }
/// <summary> /// Dto for deleting from IContentJobScheduler /// </summary> /// <param name="contentId"></param> /// <param name="contentType"></param> public ContentJobDto(long contentId, AlertType contentType) { if (contentId <= 0 || contentType == AlertType.Undefined) { throw new ArgumentException(); } ContentId = contentId; ContentType = contentType; }
public static void AddAlert(this TempDataDictionary tempData, AlertType alertType, string message) { var alerts = tempData.GetAllAlerts(); alerts.Add(new Alert() { AllertType = alertType, Message = message }); }
//initialize the object of this form and show it public static void ShowDialog(string message, AlertType type, bool autoclose) { if (alt != null) { alt.Dispose(); } alt = new AlertBox(message, type, autoclose); alt.AutoClose = autoclose; alt.ShowDialog(); }
/// <summary> /// Initializes a new instance of the <see cref="HighlightModel" /> class. /// </summary> /// <param name="style">The row style.</param> /// <param name="partition">The items partition.</param> /// <param name="row">The items row key.</param> public HighlightModel(AlertType style, string partition, string row) { Guard.NotNull(() => style); Guard.NotNullOrEmpty(() => row); Guard.NotNullOrEmpty(() => partition); this.Style = style; this.Partition = partition; this.Row = row; }
public static void ShowAlert( this HtmlGenericControl control , string msg , AlertType alertType ) { control.Visible = true; control.Attributes.Add("class", $"alert alert-{GetAlert(alertType)}"); control.InnerHtml = msg; }
public Message(AlertType alertType, string line, string objectType, string objName, string message, string userName, DateTime eventTime) { AlertType = alertType; Line = line; ObjectType = objectType; ObjName = objName; MessageString = message; UserName = userName; EventTime = eventTime; }
private void SendEmail() { Email.BreachEnd = EndEventTime; Email.BreachStart = StartEventTime; Email.Percentage = NotificationSettings.PercentageLimit; Email.TimeThresholdSec = NotificationSettings.ThresholdTime; Email.BreachType = AlertType.ToString(); Sendy.SendEmail(Email); }
/// <summary> /// Save settings. /// </summary> /// <param name="storage">Settings storage.</param> public void Save(SettingsStorage storage) { storage.SetValue(nameof(Rules), Rules.Select(r => r.Save()).ToArray()); storage.SetValue(nameof(AlertType), AlertType.To <string>()); storage.SetValue(nameof(Caption), Caption); storage.SetValue(nameof(Message), Message); storage.SetValue(nameof(IsEnabled), IsEnabled); storage.SetValue(nameof(Id), Id); storage.SetValue(nameof(MessageType), MessageType.GetTypeName(false)); }
/// <summary> /// Create a new alert. /// </summary> /// <param name="type">The type.</param> /// <param name="emailTo">The email to.</param> /// <param name="frequency">The frequency.</param> /// <param name="percentage">The percentage.</param> /// <param name="cancellationToken">Cancellation token</param> /// <returns> /// The <see cref="Alert" />. /// </returns> public Task <Alert> CreateAsync(AlertType type, Parameter <string> emailTo = default(Parameter <string>), Parameter <Frequency?> frequency = default(Parameter <Frequency?>), Parameter <int?> percentage = default(Parameter <int?>), CancellationToken cancellationToken = default(CancellationToken)) { var data = CreateJObject(type, emailTo, frequency, percentage); return(_client .PostAsync(_endpoint) .WithJsonBody(data) .WithCancellationToken(cancellationToken) .AsSendGridObject <Alert>()); }
public Alert(AlertType type, params BodyElement[] content) : base(content) { this.Class("alert"); this.Class("alert-" + type.AsKebab()); this.Attr("role", "alert"); // add alert-link class to all links content.Where(x => x is Anchor).ToList() .ForEach(x => ((Anchor)x).Class("alert-link")); }
public static Alert Create(string message, AlertType type) { return(new Alert { Id = Guid.NewGuid(), Date = DateTime.Now, Message = message, Type = type }); }
public void ClearAlert(AlertType type) { if (runtimeCacheRepository.ConfigurationAlertExists(type)) { foreach (ConfigurationAlert alert in runtimeCacheRepository.GetConfigurationAlerts(type)) { runtimeCacheRepository.DeleteConfigurationAlert(alert); } } }
///<summary>Returns a list of AlertItems for the given cinicNum.</summary> public static List <AlertItem> RefreshForType(AlertType alertType) { if (RemotingClient.RemotingRole == RemotingRole.ClientWeb) { return(Meth.GetObject <List <AlertItem> >(MethodBase.GetCurrentMethod(), alertType)); } string command = "SELECT * FROM alertitem WHERE Type = " + POut.Int((int)alertType) + " "; return(Crud.AlertItemCrud.SelectMany(command)); }
public void Play(AlertType at) { if (at == AlertType.None) { return; } m_player.Source = m_mpAlertMedia[at]; m_player.Play(); }
protected void showAccountBannedPrompt(AlertType category = AlertType.Unknown, DateTime?expirationDate = null) { PromptDefinition promptDefinition = Service.Get <PromptManager>().GetPromptDefinition("ModerationCriticalPrompt"); PromptLoaderCMD promptLoaderCMD = new PromptLoaderCMD(this, promptDefinition, delegate(PromptLoaderCMD loader) { onAccountBannedPromptLoaded(loader, category, expirationDate); }); promptLoaderCMD.Execute(); }
protected ResumeSearchAlertsTask(IExecuteMemberSearchCommand executeMemberSearchCommand, IMemberSearchesQuery memberSearchesQuery, IMemberSearchAlertsCommand memberSearchAlertsCommand, IMemberSearchAlertsQuery memberSearchAlertsQuery, IEmployersQuery employersQuery, AlertType alertType) : base(EventSource) { _executeMemberSearchCommand = executeMemberSearchCommand; _memberSearchesQuery = memberSearchesQuery; _memberSearchAlertsCommand = memberSearchAlertsCommand; _memberSearchAlertsQuery = memberSearchAlertsQuery; _employersQuery = employersQuery; _alertType = alertType; }
public Alarm(string name, AlertType alertType, bool playSound, bool focusClient, bool pauseBot, bool disconnect) { this._name = name; this._alertType = alertType; this._playSound = playSound; this._focusClient = focusClient; this._pauseBot = pauseBot; this._disconnect = disconnect; this._buttonVisibility = Visibility.Hidden; }
public async Task <IActionResult> CreateProduct(ProductModel model, IFormFile file) { ViewBag.ürünler = "active"; if (ModelState.IsValid) { var entity = new Product() { name = model.Name, price = (double)model.Price, description = model.Description, url = model.CreateUrl(), isApproved = model.IsApproved }; if (file != null) { var extension = Path.GetExtension(file.FileName); string randomname = string.Format($"{Guid.NewGuid()}{extension}"); entity.imageUrl = randomname; var path = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot\\img\\products", randomname); using (var stream = new FileStream(path, FileMode.Create)) { await file.CopyToAsync(stream); } } try { _productService.Create(entity); var msg = new AlertType() { Message = $"{entity.name} isimli ürün başarıyla eklendi", Alert = "success" }; TempData["message"] = JsonConvert.SerializeObject(msg); return(RedirectToAction("ProductList")); } catch (System.Exception) { var msg = new AlertType() { Message = $"{entity.name} isimli ürün eklenirken bir hata oluştu!", Alert = "warning" }; TempData["message"] = JsonConvert.SerializeObject(msg); return(View(model)); } } var msg1 = new AlertType() { Message = "Oluşturmaya çalıştığınız ürün kriterlere uymuyor!", Alert = "warning" }; TempData["message"] = JsonConvert.SerializeObject(msg1); return(View(model)); }
/// <summary> /// 计时器提醒 /// </summary> /// <param name="type"></param> private void ExamClock_TimeAlert(AlertType type) { switch (type) { case AlertType.ExamOver: //考试结束通知 { SubmitPaper(true); //考试时间到强制交卷 } break; } }
private static void AddMessageToTempData(ControllerBase controller, AlertType type, string title, string message, string tempData) { var alertMessage = new AlertMessage { Title = title, Message = message, CssClass = type.CssClass }; controller.TempData[tempData] = alertMessage.AsJson(); }
internal static DialogResult Alert(string title, string message, AlertType alertType, AlertButtons alertButtons) { using (var alertForm = AlertFormFactory.CreateAlertForm(title, message, alertType, alertButtons)) { alertForm.ShowDialog(); return(alertForm.DialogResult); } }
public IEnumerable <SelectListItem> GetAlertTypeSelectList(AlertType alertType) { foreach (AlertType item in typeof(AlertType).GetEnumValues()) { yield return new SelectListItem() { Text = item.GetDisplayName(), Value = item.ToString(), Selected = item == alertType } } ; }
/// <summary> /// 添加提醒 /// </summary> public void AddAlert(AlertType type, DateTime datetime) { TimeSpan timespan = currentTime - datetime; if (timespan.Seconds < 0) { return; } AlertList.Add(type, datetime); }
/// <summary> /// Tries to get the alert of the indicated type /// </summary> /// <returns>true if found</returns> public bool TryGet(AlertType alertType, out AlertPrototype alert) { if (_typeToIndex.TryGetValue(alertType, out var idx)) { alert = _orderedAlerts[idx]; return(true); } alert = null; return(false); }
/// <summary> /// Tries to get the compact encoded representation of the alert with /// the indicated id /// </summary> /// <returns>true if successful</returns> public bool TryEncode(AlertType alertType, out byte encoded) { if (_typeToIndex.TryGetValue(alertType, out var idx)) { encoded = idx; return(true); } encoded = 0; return(false); }
public static void Add(string logText, AlertType alertType, string specialMark = "") { if (string.IsNullOrEmpty(specialMark) == false) { logText = string.Format($"{specialMark} => {logText}"); } string logLineText = string.Format($"{alertType} \t {DateTime.Now} \t {logText}"); WriteToTxtFile(logLineText); }
/// <summary> /// Create a new alert. /// </summary> /// <param name="type">The type.</param> /// <param name="emailTo">The email to.</param> /// <param name="frequency">The frequency.</param> /// <param name="percentage">The percentage.</param> /// <param name="onBehalfOf">The user to impersonate.</param> /// <param name="cancellationToken">Cancellation token.</param> /// <returns> /// The <see cref="Alert" />. /// </returns> public Task <Alert> CreateAsync(AlertType type, Parameter <string> emailTo = default, Parameter <Frequency?> frequency = default, Parameter <int?> percentage = default, string onBehalfOf = null, CancellationToken cancellationToken = default) { var data = ConvertToJson(type, emailTo, frequency, percentage); return(_client .PostAsync(_endpoint) .OnBehalfOf(onBehalfOf) .WithJsonBody(data) .WithCancellationToken(cancellationToken) .AsObject <Alert>()); }
public WithNotificationResult(System.Web.Mvc.ActionResult result, String message, Position position, AlertType alertType, int timeOut, bool animation, bool modal) { this._result = result; this._message = message; this._position = position; this._animation = animation; this._modal = modal; this._alertType = alertType; this._timeout = timeOut; }
private static void AddMessageToTempData(ControllerBase controller, AlertType type, string title, string message) { var alertMessage = new AlertMessage { Title = title, Message = message, CssClass = type.CssClass }; controller.TempData["alert"] = alertMessage.AsJson(); }
public static MvcHtmlString Alert(this HtmlHelper html, string shortTitle, string message, AlertType alertType) { var div = new TagBuilder("div"); var alertTypeCSS = string.Format("alert-{0}", alertType.ToString().ToLower()); div.AddCssClass("alert"); div.AddCssClass(alertTypeCSS); var a = new TagBuilder("a"); a.AddCssClass("close"); a.Attributes.Add("data-dismiss", "alert"); a.InnerHtml = "×"; div.InnerHtml = string.Format("{0}<strong>{1} </strong>{2}", a.ToString(), shortTitle, message); return new MvcHtmlString(div.ToString()); }
public static void SetAlert( this NancyContext context, string message, AlertType? type = null) { var hash = MD5(message); context.Request.Session[String.Concat("alert-", hash)] = new Alert { Message = message, Type = type ?? AlertType.NotSpecified }; context.Items["alert-hash"] = hash; }
public static ICollection<Alert> GetAlerts(this TempDataDictionary tempData, AlertType? type = null) { if (!tempData.ContainsKey(AlertsKey)) { tempData[AlertsKey] = new List<Alert>(); } var alerts = (ICollection<Alert>)tempData[AlertsKey]; if (type.HasValue) { alerts = alerts.Where(a => a.Type == type.Value).ToList(); } return alerts; }
private static string convertTypeToString(AlertType a) { switch (a) { case AlertType.Danger: return "danger"; case AlertType.Warning: return "warning"; case AlertType.Info: return "info"; case AlertType.Success: return "success"; } return ""; }
public MessageBoxForm (IWin32Window owner, string text, string caption, MessageBoxButtons buttons, MessageBoxIcon icon, bool displayHelpButton) { show_help = displayHelpButton; Icon = icon; switch (icon) { case MessageBoxIcon.None: { icon_image = null; alert_type = AlertType.Default; break; } case MessageBoxIcon.Error: { // Same as MessageBoxIcon.Hand and MessageBoxIcon.Stop icon_image = SystemIcons.Error; alert_type = AlertType.Error; break; } case MessageBoxIcon.Question: { icon_image = SystemIcons.Question; alert_type = AlertType.Question; break; } case MessageBoxIcon.Asterisk: { // Same as MessageBoxIcon.Information icon_image = SystemIcons.Information; alert_type = AlertType.Information; break; } case MessageBoxIcon.Warning: { // Same as MessageBoxIcon.Exclamation: icon_image = SystemIcons.Warning; alert_type = AlertType.Warning; break; } } msgbox_text = text; msgbox_buttons = buttons; msgbox_default = MessageBoxDefaultButton.Button1; this.Text = caption; }
public AlertMessage(string header, string body, AlertType type, bool enableClose = true) : this(header, body, enableClose) { switch (type) { case AlertType.Block: CssClass = "alert-block"; break; case AlertType.Info: CssClass = "alert-info"; break; case AlertType.Success: CssClass = "alert-success"; break; case AlertType.Error: CssClass = "alert-error"; break; } }
public RCAlert(string message, AlertType type) { this.Message = message; this.Type = type; switch (this.Type) { case AlertType.Warning: this.HTMLClass = ""; break; case AlertType.Error: this.HTMLClass = "alert-danger"; break; case AlertType.Success: this.HTMLClass = "alert-success"; break; case AlertType.Info: this.HTMLClass = "alert-info"; break; } }
public PMAMailController(string message, AlertType alertType, string user) { this.alertType = alertType; _emailSubscribers = new List<string>(); switch (alertType) { case AlertType.EVENT_ALERT: _alertType = "Event"; _emailSubscribers = configManager.SystemAnalyzerInfo.ListAlertMailSubscription; break; case AlertType.GENERAL_ALERT: _alertType = "General"; _emailSubscribers = configManager.SystemAnalyzerInfo.ListAlertMailSubscription; break; case AlertType.USER_ALERT : _alertType = "PMA User Login"; _emailSubscribers.AddRange(configManager.PMAServerManagerInfo.EmailActionServicesSubsubscribers); _emailSubscribers.AddRange(configManager.PMAServerManagerInfo.EmailSqlRemoteActivitySubscribers); break; case AlertType.SQL_ALERT : _alertType = "SQL Remote Action"; _emailSubscribers.AddRange(configManager.PMAServerManagerInfo.EmailSqlRemoteActivitySubscribers); break; case AlertType.SERVICE_ALERT : _alertType = "Remote Service Action"; _emailSubscribers.AddRange(configManager.PMAServerManagerInfo.EmailActionServicesSubsubscribers); break; case AlertType.ACTION_ALERT: _alertType = "Remote Command Action"; _emailSubscribers.AddRange(configManager.PMAServerManagerInfo.EmailActionServicesSubsubscribers); break; } if (user == null || user == string.Empty) { user = "******"; } _user = user; _message = message; }
public static MvcHtmlString Alert(this HtmlHelper helper, AlertType type, string text, string header, ButtonTag? closeButton, bool block) { var builder = new TagBuilder("div"); if (block) builder.AddCssClass("alert-block"); builder.AddCssClass(type.ToCssClass()); builder.AddCssClass("alert"); if (closeButton.HasValue) { builder.InnerHtml += DismissButton(helper, closeButton.Value); } if (!string.IsNullOrEmpty(header)) { var headerTag = new TagBuilder("h4"); headerTag.SetInnerText(header); builder.InnerHtml = headerTag.ToString(); } builder.InnerHtml += text; return new MvcHtmlString(builder.ToString()); }
public RCAlert(string message, AlertType type, string urlHelp, string urlName) { this.Message = message; this.Type = type; this.UrlHelp = urlHelp; this.UrlName = urlName; switch (this.Type) { case AlertType.Warning: this.HTMLClass = ""; break; case AlertType.Error: this.HTMLClass = "alert-error"; break; case AlertType.Success: this.HTMLClass = "alert-success"; break; case AlertType.Info: this.HTMLClass = "alert-info"; break; } }
internal static Boolean IsAlertFiredByHandINT(IntPtr instance, AlertType alertEvent, Int32 handID, out AlertData alertData) { alertData = new AlertData(); return PXCMHandData_IsAlertFiredByHand(instance, alertEvent, handID, alertData); }
private static extern Boolean PXCMHandData_IsAlertFiredByHand(IntPtr instance, AlertType alertEvent, Int32 handID, [Out] AlertData alertData);