public bool IsLDMFlightDataValid(string[] splitMessageContent)
{
if (MessageValidation.IsLoadDistributionMessageTypeValid(splitMessageContent[0]))
{
var flightDataRegex = new Regex(FlightInfoConstants.IsLDMFlightInfoValid);
var match = flightDataRegex.Match(splitMessageContent[1]);
if (match.Success)
{
string fltNumber = match.Groups["flt"].Value;
string registration = match.Groups["reg"].Value;
string date = match.Groups["date"].Value;
if (this.IsFlightNumberAndRegistrationValid(fltNumber, registration))
{
return(true);
}
else
{
return(false);
}
}
}
else
{
return(false);
}
return(true);
}
private bool CanExecuteSendMessage(object obj)
{
var res = MessageValidation.ValidateMessage(_messageContent, _receiver, _isBroadcastChecked);
_messageType = res.Item2;
return(res.Item1);
}
protected virtual void Validate(string socketId, Message message)
{
var validator = new MessageValidation().Validate(message);
if (!validator.IsValid)
{
throw new Exception(validator.Errors.FirstOrDefault().ErrorMessage);
}
ValidateMessage(socketId, message);
}
public bool IsDepartureMovementFlightDataValid(string[] splitMessageContent)
{
string messageType = splitMessageContent[0];
if (MessageValidation.IsMovementMessageTypeValid(messageType))
{
var flightRegex = new Regex(FlightInfoConstants.IsFlightInfoValid);
var match = flightRegex.Match(splitMessageContent[1]);
if (match.Success)
{
string flightNumber = match.Groups["flt"].Value;
string registration = match.Groups["reg"].Value;
string date = match.Groups["date"].Value;
string station = match.Groups["origin"].Value;
if (MessageValidation.IsFlightInfoNotNullOrEmpty(flightNumber, registration, date, station))
{
if (this.IsFlightNumberAndRegistrationValid(flightNumber, registration))
{
if (this.IsDateAndStationValid(flightNumber, date, station))
{
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
else
{
return(false);
}
}
else
{
return(false);
}
}
else
{
return(false);
}
}
/// <summary>
/// Create Entry form instance
/// </summary>
/// <param name="EtityBLO"></param>
/// <param name="entity"></param>
/// <param name="critereRechercheFiltre"></param>
/// <param name="AutoGenerateField"></param>
public BaseEntryForm(
IGwinBaseBLO EtityBLO,
BaseEntity entity,
Dictionary <string, object> critereRechercheFiltre,
bool AutoGenerateField)
{
InitializeComponent();
errorProvider.RightToLeft = GwinApp.isRightToLeft;
if (System.ComponentModel.LicenseManager.UsageMode != System.ComponentModel.LicenseUsageMode.Designtime)
{
CheckPramIsNull.CheckParam_is_NotNull(EtityBLO, this, nameof(EtityBLO));
// Init Variables
this.EntityBLO = EtityBLO;
this.Entity = entity;
this.FilterValues = critereRechercheFiltre;
this.AutoGenerateField = AutoGenerateField;
this.ConfigEntity = ConfigEntity.CreateConfigEntity(this.EntityBLO.TypeEntity);
// Default values
this.ConteneurFormulaire = FlowLayoutContainer;
this.isStepInitializingValues = false;
this.MessageValidation = new MessageValidation(errorProvider);
this.Fields = new Dictionary <string, BaseField>();
this.GroupsBoxes = new Dictionary <string, GroupBox>();
// Create PLO Instance if PLO exist
if (this.EntityPLO == null && this.ConfigEntity.PresentationLogic != null)
{
this.EntityPLO = (IGwinPLO)Activator.CreateInstance(this.ConfigEntity.PresentationLogic.TypePLO);
}
// Create or Config Entity Instance
if (this.EntityBLO != null && this.Entity == null)
{
this.Entity = (BaseEntity)EtityBLO.CreateEntityInstance();
}
if ((this.Entity == null || this.Entity.Id == 0) && this.FilterValues != null)
{
this.InitialisationEntityParCritereRechercheFiltre();
}
// Create Field in Form
this.CreateFieldIfNotGenerated();
}
}
/// <summary>
/// Créer du formuliare
/// </summary>
/// <param name="service"></param>
public BaseEntryForm(
IBaseRepository service,
BaseEntity entity,
Dictionary <string, object> critereRechercheFiltre,
bool AutoGenerateField,
ConfigEntity configEntity)
{
InitializeComponent();
if (!DesignMode)
{
// Params
this.Service = service;
this.Entity = entity;
this.CritereRechercheFiltre = critereRechercheFiltre;
this.AutoGenerateField = AutoGenerateField;
this.ConfigEntity = configEntity;
// Les valeus par défaux
this.isStepInitializingValues = false;
this.MessageValidation = new MessageValidation(errorProvider);
// Préparation de l'objet Entity
if (this.Service != null && this.Entity == null)
{
this.Entity = (BaseEntity)service.CreateInstanceObjet();
}
if ((this.Entity == null || this.Entity.Id == 0) && this.CritereRechercheFiltre != null)
{
this.InitialisationEntityParCritereRechercheFiltre();
}
// Conteneurs du formulaire
this.ConteneurFormulaire = this.flowLayoutPanelForm;
// Génération du Formulaire
if (this.AutoGenerateField)
{
if (this.ConfigEntity == null)
{
this.ConfigEntity = new ConfigEntity(this.Service.TypeEntity);
}
}
}
}
public async Task ThatCommand(CommandContext ctx)
{
// Setup logging context
using (_logger.BeginScope($"ThatCommand@{ctx.Message.Id.ToString()}"))
{
try
{
_logger.LogDebug("Invoked by [{user}]", ctx.User);
// Prevent infinite loops
if (MessageValidation.IsDeepReply(ctx.Client.CurrentUser, ctx.Message))
{
_logger.LogDebug("Skipping message loop");
return;
}
// Get original message from reference
var text = ctx.Message.ReferencedMessage.Content;
// Skip if no text provided
if (string.IsNullOrWhiteSpace(text))
{
_logger.LogDebug("Skipping empty input");
return;
}
// Uwuify it
var uwuText = _textUwuifier.UwuifyText(text);
// Send reply
await new DiscordMessageBuilder()
.WithContent(uwuText)
.WithReply(ctx.Message.ReferencedMessage.Id)
.SendAsync(ctx.Channel);
}
catch (Exception ex)
{
_logger.LogError(ex, "Uncaught exception");
}
}
}
private void ProcessMessage() // called from read
{
try
{
MessageValidation.ValidateHeader(txtMessageHeader.Text); // Validate Header
Message m = ParseMessage(); // parsing messege = as this is in a try statement, should it fail, it will returh the exception and the message to this try's catch
if (m is null)
{
throw new Exception("No Message"); // if parsing message was unsuccessful go no further
}
m.ToJson(); // writing message to jsonfile
os.Add(m); // adding message to main list
UpdateGlobalMessageList(); // adding message to message list box
if (m is EmailMessage)
{
EmailMessage em = m as EmailMessage;
UpdateURLList(em); // if message is email message, cast as such and add it's qurantined links to URL list
}
if (m is SIREmail)
{
UpdateSIRList(); // if Message is an incident report, add the details to a SIR list
}
if (m is TweetMessage)
{
TweetMessage tm = m as TweetMessage;
MasterHashtags = tm.HashTagCount(MasterHashtags);
MasterMentions = tm.MentionsCount(MasterMentions);
Refresh(); // if message is tweet = add its hashtags/mentions to master list(if they exist increase count) refresh trending and mentions list
}
MessageBox.Show("Message Added");
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Message Not Added");
return;
}
}
public bool IsCPMFlightDataValid(string[] splitMessageContent)
{
bool flag = true;
if (MessageValidation.IsCPMMessageTypeValid(splitMessageContent[0]))
{
var flightRegex = new Regex(FlightInfoConstants.IsFlightInfoValid);
var match = flightRegex.Match(splitMessageContent[1]);
if (match.Success)
{
string flightNumber = match.Groups["flt"].Value;
string date = match.Groups["date"].Value;
string registration = match.Groups["reg"].Value;
string station = match.Groups["origin"].Value;
if (this.IsFlightNumberAndRegistrationValid(flightNumber, registration))
{
if (this.IsDateAndStationValid(flightNumber, date, station))
{
return(flag);
}
else
{
flag = false;
}
}
else
{
flag = false;
}
}
}
else
{
flag = false;
}
return(flag);
}
public void Setup()
{
validator = new MessageValidation();
}
public static async Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Function, "post", Route = "message")] HttpRequestMessage req, TraceWriter log)
{
log.Info("C# HTTP trigger function processed a request.");
// validate the required environment variables
var envVariables = Environment.GetEnvironmentVariables();
ValidationResult envVarValidationResult = new ConfigValidation().Validate(envVariables);
var envVarValidationResponse = new ValidationResponse("Validation failure", envVarValidationResult.Errors.ToDictionary(x => x.PropertyName, x => x.ErrorMessage));
// return a 400 with the validation errors
if (!envVarValidationResult.IsValid)
{
return(req.CreateResponse(HttpStatusCode.BadRequest, envVarValidationResponse));
}
// read variables from app settings
EventTopic = Environment.GetEnvironmentVariable("EventTopic", EnvironmentVariableTarget.Process);
EventTopicUrl = Environment.GetEnvironmentVariable("EventTopicUrl", EnvironmentVariableTarget.Process);
EventTopicSasKey = Environment.GetEnvironmentVariable("EventTopicSasKey", EnvironmentVariableTarget.Process);
// parse query parameters
log.Info("Parsing query parameters");
string name = req.GetQueryNameValuePairs()
.FirstOrDefault(q => string.Compare(q.Key, "name", true) == 0)
.Value;
string email = req.GetQueryNameValuePairs()
.FirstOrDefault(q => string.Compare(q.Key, "email", true) == 0)
.Value;
string message = req.GetQueryNameValuePairs()
.FirstOrDefault(q => string.Compare(q.Key, "message", true) == 0)
.Value;
// parse request body parameters
log.Info("Parsing request body parameters");
dynamic data = await req.Content.ReadAsAsync <object>();
name = name ?? data.name;
email = email ?? data.email;
message = message ?? data.message;
// construct message object
var messageRequest = new Message(name, email, message);
// validation
ValidationResult results = new MessageValidation().Validate(messageRequest);
// create a custom validation response using key value pairs
var validationResponse = new ValidationResponse("Validation failure", results.Errors.ToDictionary(x => x.PropertyName, x => x.ErrorMessage));
// return a 400 with the validation errors
if (!results.IsValid)
{
return(req.CreateResponse(HttpStatusCode.BadRequest, validationResponse));
}
// send event to event grid
var events = new List <Event <Message> >();
var eventMessage = new Event <Message>
{
Id = Guid.NewGuid().ToString(),
Topic = EventTopic,
Subject = "/azContactForm/",
EventType = "AzContactForm.NewMessage",
EventTime = DateTimeOffset.Now.ToString("o"),
Data = messageRequest
};
events.Add(eventMessage);
HttpClient httpClient = new HttpClient
{
BaseAddress = new Uri(EventTopicUrl)
};
var json = JsonConvert.SerializeObject(events);
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, "");
request.Headers.Add("aeg-sas-key", EventTopicSasKey);
request.Content = new StringContent(json,
Encoding.UTF8,
"application/json");
await httpClient.SendAsync(request)
.ContinueWith(responseTask =>
{
Console.WriteLine("Response: {0}", responseTask.Result);
log.Info("Sent Event to Event Grid");
});
// return a 200 response message
return(req.CreateResponse(HttpStatusCode.OK, "Your message has been sent. Thank you."));
}
