Example #1
0
        private Task <IIndexResponse> CreateSystemEvent(EventRequestModel model, CancellationToken cancellationToken)
        {
            if (model.Tags == null)
            {
                model.Tags = new List <string>();
            }

            model.Tags.Add(model.Level.ToString());
            model.Tags.Add(model.Category);
            model.Tags.Add(model.TargetKey);

            // Remove duplicates
            var hashset = model.Tags.ToHashSet();

            var eventTimestamp = _timeStampFactory.GetTimestamp();
            var systemEvent    = new SystemEventElasticsearchDocument
            {
                Category  = model.Category,
                Level     = model.Level.ToString(),
                TargetKey = model.TargetKey,
                Message   = $"{model.Message} by {model.Sender}",
                Tags      = hashset.ToArray(),
                Sender    = model.Sender,
                Timestamp = eventTimestamp,
                Endtime   = eventTimestamp
            };

            return(_esClient.IndexAsync(systemEvent, cancellationToken: cancellationToken));
        }
Example #2
0
        public static Event CastEventRequestToEvent(EventRequestModel model)
        {
            var evnt = new Event();

            evnt.EventCreateTime     = DateTime.Now;
            evnt.EventType           = (int)EventTypes.GoReturn;
            evnt.EventCoductorName   = model.Name;
            evnt.EventCoductorFamily = model.Family;
            evnt.EventCoductorMobile = model.Mobile;
            evnt.EventName           = model.EventName;
            evnt.EventLink           = model.EventLink;
            var startTime = new DateTime(model.Edate.Year, model.Edate.Month, model.Edate.Day, model.TimeStart.Hour, model.TimeStart.Minute, 0);

            evnt.EventStartTime = startTime;
            var endTime = new DateTime(model.Edate.Year, model.Edate.Month, model.Edate.Day, model.TimeEnd.Hour, model.TimeEnd.Minute, 0);

            evnt.EventEndTime   = endTime;
            evnt.EventDeadLine  = endTime.AddHours(2);
            evnt.EventConfirmed = 0;//false
            evnt.EventDesc      = "";
            evnt.EventAddress   = "";
            evnt.EventLat       = decimal.Parse(model.Latitude);
            evnt.EventLng       = decimal.Parse(model.Longitude);
            evnt.IsConfirmed    = false;

            return(evnt);
        }
        public async static Task <EventRequestModel> genEventRequestModel(HttpMessage request,
                                                                          string ReqHeadersName,
                                                                          string RequestTimeName,
                                                                          string _ApiVersion, string clientIpAddress)
        {
            var h       = request.HttpRequestMessage;
            var reqBody = h.Content != null
                            ? await h.Content.ReadAsStringAsync()
                            : null;

            var reqHeaders     = HeadersUtils.deSerializeHeaders(h.Properties[ReqHeadersName]);
            var reqBodyWrapper = BodyUtil.Serialize(reqBody);


            EventRequestModel moesifRequest = new EventRequestModel()
            {
                Time = (DateTime)h.Properties[RequestTimeName],
                Uri  = h.RequestUri.OriginalString,
                /*	Uri = (String)request.HttpRequestMessage.Headers.GetValues("originalURL").FirstOrDefault(),*/
                Verb       = h.Method.ToString(),
                Headers    = reqHeaders,
                ApiVersion = _ApiVersion,
                /*IpAddress = null,*/
                /*IpAddress = (String)request.HttpRequestMessage.Headers.GetValues("clientIPAddress").FirstOrDefault(),*/
                IpAddress        = clientIpAddress,
                Body             = reqBodyWrapper.Item1,
                TransferEncoding = reqBodyWrapper.Item2
            };

            return(moesifRequest);
        }
        /**
         * From Http request and response, construct the moesif EventModel
         */
        public async Task <EventModel> BuildMoesifEvent(HttpMessage request, HttpMessage response)
        {
            _Logger.LogDebug("Building Moesif event");
            EventRequestModel moesifRequest = await genEventRequestModel(request,
                                                                         ReqHeadersName,
                                                                         RequestTimeName,
                                                                         _ApiVersion);

            EventResponseModel moesifResponse = await genEventResponseModel(response);

            Dictionary <string, object> metadata = genMetadata(request, MetadataName);
            string     skey        = safeGetHeaderFirstOrDefault(request, _SessionTokenKey);
            string     userId      = safeGetOrNull(request, UserIdName);
            string     companyId   = safeGetOrNull(request, CompanyIdName);
            EventModel moesifEvent = new EventModel()
            {
                Request      = moesifRequest,
                Response     = moesifResponse,
                SessionToken = skey,
                Tags         = null,
                UserId       = userId,
                CompanyId    = companyId,
                Metadata     = metadata,
                Direction    = "Incoming"
            };

            return(moesifEvent);
        }
        public async static Task <EventRequestModel> genEventRequestModel(HttpMessage request,
                                                                          string ReqHeadersName,
                                                                          string RequestTimeName,
                                                                          string _ApiVersion)
        {
            var h       = request.HttpRequestMessage;
            var reqBody = h.Content != null
                            ? await h.Content.ReadAsStringAsync()
                            : null;

            var reqHeaders     = HeadersUtils.deSerializeHeaders(h.Properties[ReqHeadersName]);
            var reqBodyWrapper = BodyUtil.Serialize(reqBody);
            EventRequestModel moesifRequest = new EventRequestModel()
            {
                Time             = (DateTime)h.Properties[RequestTimeName],
                Uri              = h.RequestUri.OriginalString,
                Verb             = h.Method.ToString(),
                Headers          = reqHeaders,
                ApiVersion       = _ApiVersion,
                IpAddress        = null,
                Body             = reqBodyWrapper.Item1,
                TransferEncoding = reqBodyWrapper.Item2
            };

            return(moesifRequest);
        }
Example #6
0
        public int Save(EventRequestModel model)
        {
            EventRequest _eventRequest = new EventRequest(model);

            if (model.Id != null && model.Id != 0)
            {
                _EventRequest.Update(_eventRequest);
            }
            else
            {
                RequestSubmitModel res = new RequestSubmitModel();
                res.RequestTypeId = 9;
                res.UserId        = model.UserId;
                res.ShortDesc     = model.Description;

                int id = new RequestSubmitBs().Save(res);
                _eventRequest.RequestSubmitId = id;
                _eventRequest.Poster          = model.Poster;
                _eventRequest.CreatedDate     = System.DateTime.Now;
                _eventRequest.RequestTypeId   = 9;
                _EventRequest.Insert(_eventRequest);
            }

            return(_eventRequest.Id);
        }
Example #7
0
        public ActionResult CreateEvent(EventRequestModel model)
        {
            long i = 0;

            if (model != null)
            {
                //if (File != null)
                //{
                //    model.Poster = new byte[File.ContentLength];
                //    File.InputStream.Read(model.Poster, 0, File.ContentLength);
                //}
                model.UserId = new UserRegistrationBs().UserRegistrationList().Where(x => x.UserName == User.Identity.Name).FirstOrDefault().Id;
                i            = _EventRequestBs.Save(model);
            }


            if (i > 0)
            {
                TempData["msg"] = "Save Successfully";
            }
            else
            {
                TempData["msg"] = "Error while saving data";
            }

            return(RedirectToAction("Index", "EventRequest", new { area = "User" }));
        }
Example #8
0
        private async Task <(EventRequestModel, String)> FormatRequest(HttpRequest request, string transactionId)
        {
            // Request headers
            var reqHeaders = LoggerHelper.ToHeaders(request.Headers, debug);

            // RequestBody
            request.EnableBuffering(bufferThreshold: 1000000);
            string bodyAsText = null;

            string contentEncoding     = "";
            string contentLength       = "";
            int    parsedContentLength = 100000;

            reqHeaders.TryGetValue("Content-Encoding", out contentEncoding);
            reqHeaders.TryGetValue("Content-Length", out contentLength);
            int.TryParse(contentLength, out parsedContentLength);

            bodyAsText = await LoggerHelper.GetRequestContents(bodyAsText, request, contentEncoding, parsedContentLength, debug);

            // Add Transaction Id to the Request Header
            bool disableTransactionId = LoggerHelper.GetConfigBoolValues(moesifOptions, "DisableTransactionId", false);

            if (!disableTransactionId)
            {
                transactionId = LoggerHelper.GetOrCreateTransactionId(reqHeaders, "X-Moesif-Transaction-Id");
                reqHeaders    = LoggerHelper.AddTransactionId("X-Moesif-Transaction-Id", transactionId, reqHeaders);
            }

            // Serialize request body
            var bodyWrapper = LoggerHelper.Serialize(bodyAsText, request.ContentType, logBody, debug);

            // Client Ip Address
            string ip  = clientIpHelper.GetClientIp(reqHeaders, request);
            var    uri = new Uri(request.GetDisplayUrl()).ToString();

            string apiVersion     = null;
            var    apiVersion_out = new object();
            var    getApiVersion  = moesifOptions.TryGetValue("ApiVersion", out apiVersion_out);

            if (getApiVersion)
            {
                apiVersion = apiVersion_out.ToString();
            }

            var eventReq = new EventRequestModel()
            {
                Time             = DateTime.UtcNow,
                Uri              = uri,
                Verb             = request.Method,
                ApiVersion       = apiVersion,
                IpAddress        = ip,
                Headers          = reqHeaders,
                Body             = bodyWrapper.Item1,
                TransferEncoding = bodyWrapper.Item2
            };

            return(eventReq, transactionId);
        }
Example #9
0
        public EventRequestModel GetByRequestSubmitIdBoard(int id, int userid)
        {
            EventRequestModel varList = new EventRequestModel();
            var item = _EventRequest.GetAll().Where(x => x.RequestSubmitId == id).FirstOrDefault();

            item    = item ?? new EventRequest();
            varList = new EventRequestModel
            {
                Id              = item.Id,
                EventName       = item.EventName,
                Description     = item.Description,
                TotalSpeakers   = item.TotalSpeakers,
                Poster          = item.Poster,
                FromDate        = item.FromDate,
                ToDate          = item.ToDate,
                CreatedDate     = item.CreatedDate,
                Venu            = item.Venu,
                UserId          = item.UserId,
                UserName        = (item.User != null) ? item.User.Name : string.Empty,
                RequestTypeId   = item.RequestTypeId,
                RequestTypeName = (item.RequestType != null) ? item.RequestType.Name : string.Empty,
                RequestSubmitId = item.RequestSubmitId,
            };



            RequestCommentBs obj = new RequestCommentBs();
            var BoardComments    = obj.BoardCommentList(id).ToList();

            varList.BoardCommentList = BoardComments;

            var PannelComments = obj.PanelCommentList(id).ToList();

            varList.PanelCommentList = PannelComments;

            RequestApproveRejectBs obj1 = new RequestApproveRejectBs();

            varList.ApprovedList = obj1.ApproveRejectDisplay(id).ToList();
            varList.AlreadyExistsInMemberOpinion = varList.ApprovedList == null ? false : varList.ApprovedList.Where(m => m.UserTypeId == userid && m.RequestSubmitId == item.RequestSubmitId).Any();
            if (varList.AlreadyExistsInMemberOpinion)
            {
                varList.MemberOpinionId = varList.ApprovedList.Where(m => m.UserTypeId == userid && m.RequestSubmitId == item.RequestSubmitId).FirstOrDefault().Id;
                varList.IsAgreed        = varList.ApprovedList.Where(m => m.UserTypeId == userid && m.RequestSubmitId == item.RequestSubmitId).FirstOrDefault().IsApproved;
                varList.LikeStatus      = varList.ApprovedList.Where(m => m.UserTypeId == userid && m.RequestSubmitId == item.RequestSubmitId).FirstOrDefault().LikeStatus;
            }
            PanelInvolveBs panelobject = new PanelInvolveBs();

            varList.PannelMemberInvolved = panelobject.InvolveList(id).ToList();
            return(varList);
        }
Example #10
0
 public EventRequest(EventRequestModel item)
 {
     Id              = item.Id;
     EventName       = item.EventName;
     Description     = item.Description;
     TotalSpeakers   = item.TotalSpeakers;
     Venu            = item.Venu;
     FromDate        = item.FromDate;
     ToDate          = item.ToDate;
     CreatedDate     = item.CreatedDate;
     UserId          = item.UserId;
     EventType       = item.EventTypeId;
     RequestTypeId   = item.RequestTypeId;
     RequestSubmitId = item.RequestSubmitId;
 }
Example #11
0
        public async Task ProcessHttpMessage(HttpMessage message)
        {
            if (message.IsRequest)
            {
                message.HttpRequestMessage.Properties.Add(RequestTimeName, DateTime.UtcNow);
                return;
            }

            EventRequestModel moesifRequest = new EventRequestModel()
            {
                Time             = (DateTime)message.HttpRequestMessage.Properties[RequestTimeName],
                Uri              = message.HttpRequestMessage.RequestUri.OriginalString,
                Verb             = message.HttpRequestMessage.Method.ToString(),
                Headers          = ToHeaders(message.HttpRequestMessage.Headers),
                ApiVersion       = _ApiVersion,
                IpAddress        = null,
                Body             = System.Convert.ToBase64String(await message.HttpRequestMessage.Content.ReadAsByteArrayAsync()),
                TransferEncoding = "base64"
            };

            EventResponseModel moesifResponse = new EventResponseModel()
            {
                Time             = DateTime.UtcNow,
                Status           = (int)message.HttpResponseMessage.StatusCode,
                IpAddress        = Environment.MachineName,
                Headers          = ToHeaders(message.HttpResponseMessage.Headers),
                Body             = System.Convert.ToBase64String(await message.HttpResponseMessage.Content.ReadAsByteArrayAsync()),
                TransferEncoding = "base64"
            };

            Dictionary <string, string> metadata = new Dictionary <string, string>();

            metadata.Add("ApimMessageId", message.MessageId.ToString());

            EventModel moesifEvent = new EventModel()
            {
                Request      = moesifRequest,
                Response     = moesifResponse,
                SessionToken = message.HttpRequestMessage.Headers.GetValues(_SessionTokenKey).FirstOrDefault(),
                Tags         = null,
                UserId       = null,
                Metadata     = metadata
            };

            Dictionary <string, string> response = await _MoesifClient.Api.CreateEventAsync(moesifEvent);

            _Logger.LogDebug("Message forwarded to Moesif");
        }
        public async Task <EventResponse> EventPostAsync(EventRequestModel model)
        {
            var latency = PreInvoke(_clientName, _eventPostAsyncMethodName, model);

            try
            {
                var result = await _systemEventsClient.CreateAsync(model);

                PostInvokeSuccess(latency, _clientName, _eventPostAsyncMethodName, result);
                return(result);
            }
            catch (Exception ex)
            {
                PostInvokeFailure(_clientName, _eventPostAsyncMethodName, ex, model);
                throw;
            }
        }
Example #13
0
        public ActionResult CreateEvent(int?id)
        {
            EventRequestModel model = new EventRequestModel();

            if (id != null)
            {
                var Varial = _EventRequestBs.GetById(Convert.ToInt32(id));

                return(View(Varial));
            }
            else
            {
                ViewBag.EventTypeName = new SelectList(_EventRequestBs.GetAllEventMasterList(), "Id", "Name");
            }

            return(View(model));
        }
Example #14
0
        public IHttpActionResult InsertEvent(EventRequestModel model)
        {
            try
            {
                if (!ModelState.IsValid)
                {
                    return(Json(_responseProvider.GenerateBadRequestResponse(ModelState)));
                }
                _routemanager.InsertEvent(model);

                ResponseModel responseModel = _responseProvider.GenerateOKResponse();
                return(Json(responseModel));
            }
            catch (Exception e)
            {
                _logmanager.Log(Tag, "InsertEvent", e.Message);
            }
            return(Json(_responseProvider.GenerateUnknownErrorResponse()));
        }
Example #15
0
        public async Task <IActionResult> Create([FromBody] EventRequestModel model)
        {
            var userId = User.GetUserId();

            if (!await _calendarService.CanEditAsync(model.CalendarId, userId))
            {
                return(this.BadRequestError("You don't have any permissions to create event in that calendar."));
            }

            var eventDomain = _mapper.Map <Event>(model);
            var id          = await _eventService.CreateEventAsync(eventDomain, userId);

            var calendar = await _calendarService.GetCalendarByIdAsync(model.CalendarId, nameof(Calendar.Owner));

            if (userId != calendar.Owner.Id)
            {
                await _notificationManager.EventInCalendarCreatedAsync(calendar.Owner.Id, User.Identity.Name, model.Name, calendar.Name);
            }

            return(Ok(new { Id = id }));
        }
Example #16
0
        public override BaseState Run()
        {
            var eventNames = BotConstants.sampleEventNames[new Random().Next(6)];

            var eventModel = new EventRequestModel
            {
                event_datetime = DateTime.Now,
                event_common   = this.eventCommon,
                event_dic      = new Dictionary <string, string>()
            };

            foreach (var eventName in eventNames)
            {
                eventModel.event_name = eventName;

                if (eventName == BotConstants.LOGIN_EVENT)
                {
                    eventModel.event_dic.Add("user_id", Guid.NewGuid().ToString());
                }

                if (eventName == BotConstants.LOGOUT_EVENT)
                {
                    eventModel.event_dic.Remove("user_id");
                }
            }

            var httpRequestModel = new HttpRequestModel
            {
                Url        = "",
                HttpMethod = HttpMethod.Post,
                Headers    = new Dictionary <string, string> {
                    { "content-type", "application/json" }
                },
                Body = JsonConvert.SerializeObject(eventModel)
            };

            NetworkUtil.HttpRequestAsync(httpRequestModel).Wait();

            return(this);
        }
Example #17
0
        public async Task <IActionResult> Update(int id, [FromBody] EventRequestModel model)
        {
            var userId = User.GetUserId();

            if (!await _eventService.CanEditAsync(id, userId))
            {
                return(this.BadRequestError("You don't have any permissions to edit that event."));
            }

            var eventDomain = await _eventService.GetEventByIdAsync(id, "Period", nameof(Event.Owner));

            eventDomain    = _mapper.Map(model, eventDomain);
            eventDomain.Id = id;
            await _eventService.UpdateEventAsync(eventDomain);

            if (userId != eventDomain.Owner.Id)
            {
                await _notificationManager.EventEditedAsync(eventDomain.Owner.Id, User.Identity.Name, eventDomain.Name, model.Name);
            }

            return(Ok());
        }
Example #18
0
        public async Task <ActionResult <EventResponse> > Create([FromBody] EventRequestModel model, CancellationToken cancellationToken)
        {
            if (!Validate(model, out string reason))
            {
                return(BadRequest($"Invalid request: {reason}"));
            }

            var response = await CreateSystemEvent(model, cancellationToken);

            if (!response.IsValid)
            {
                throw new ArgumentException("System event was not created");
            }

            if (_categorySubscriptionNotifier == null)
            {
                return(Ok(new EventResponse {
                    EventId = response.Id
                }));
            }

            // Notify about this event
            try
            {
                var document = await _esClient.GetAsync(response.Id, cancellationToken);

                await _categorySubscriptionNotifier.OnEventCreated(model.Category, document, cancellationToken);
            }
            catch (Exception exception)
            {
                // Ignore failure to send notification about system event
                _logger.LogError(exception, $"Error sending notifications for event with id {response.Id}");
            }

            return(Ok(new EventResponse {
                EventId = response.Id
            }));
        }
        private async Task <(EventRequestModel, String)> ToRequest(IOwinRequest request, string transactionId)
        {
            // Request headers
            var reqHeaders = LoggerHelper.ToHeaders(request.Headers, debug);

            // RequestBody
            string contentEncoding     = "";
            string contentLength       = "";
            int    parsedContentLength = 100000;

            string body = null;

            reqHeaders.TryGetValue("Content-Encoding", out contentEncoding);
            reqHeaders.TryGetValue("Content-Length", out contentLength);
            int.TryParse(contentLength, out parsedContentLength);
            try
            {
                body = await LoggerHelper.GetRequestContents(request, contentEncoding, parsedContentLength, disableStreamOverride);
            }
            catch
            {
                LoggerHelper.LogDebugMessage(debug, "Cannot read request body.");
            }

            var bodyWrapper = LoggerHelper.Serialize(body, request.ContentType);

            // Add Transaction Id to the Request Header
            bool disableTransactionId = LoggerHelper.GetConfigBoolValues(moesifOptions, "DisableTransactionId", false);

            if (!disableTransactionId)
            {
                transactionId = LoggerHelper.GetOrCreateTransactionId(reqHeaders, "X-Moesif-Transaction-Id");
                reqHeaders    = LoggerHelper.AddTransactionId("X-Moesif-Transaction-Id", transactionId, reqHeaders);
            }

            string ip  = clientIpHelper.GetClientIp(reqHeaders, request);
            var    uri = request.Uri.ToString();

            string apiVersion     = null;
            var    apiVersion_out = new object();
            var    getApiVersion  = moesifOptions.TryGetValue("ApiVersion", out apiVersion_out);

            if (getApiVersion)
            {
                apiVersion = apiVersion_out.ToString();
            }

            var eventReq = new EventRequestModel()
            {
                Time             = DateTime.UtcNow,
                Uri              = uri,
                Verb             = request.Method,
                ApiVersion       = apiVersion,
                IpAddress        = ip,
                Headers          = reqHeaders,
                Body             = bodyWrapper.Item1,
                TransferEncoding = bodyWrapper.Item2
            };

            return(eventReq, transactionId);
        }
Example #20
0
        private async Task LogEventAsync(EventRequestModel event_request, EventResponseModel event_response, string userId, string companyId, string sessionToken, Dictionary <string, object> metadata)
        {
            var eventModel = new EventModel()
            {
                Request      = event_request,
                Response     = event_response,
                UserId       = userId,
                CompanyId    = companyId,
                SessionToken = sessionToken,
                Metadata     = metadata,
                Direction    = "Incoming"
            };

            // Get Mask Event
            var maskEvent_out = new object();
            var getMaskEvent  = moesifOptions.TryGetValue("MaskEventModel", out maskEvent_out);

            // Check to see if we need to send event to Moesif
            Func <EventModel, EventModel> MaskEvent = null;

            if (getMaskEvent)
            {
                MaskEvent = (Func <EventModel, EventModel>)(maskEvent_out);
            }

            // Mask event
            if (MaskEvent != null)
            {
                try
                {
                    eventModel = MaskEvent(eventModel);
                }
                catch
                {
                    LoggerHelper.LogDebugMessage(debug, "Can not execute MASK_EVENT_MODEL function. Please check moesif settings.");
                }
            }

            // Send Events
            try
            {
                // Get Sampling percentage
                samplingPercentage = appConfig.getSamplingPercentage(config, userId, companyId);

                Random random           = new Random();
                double randomPercentage = random.NextDouble() * 100;
                if (samplingPercentage >= randomPercentage)
                {
                    eventModel.Weight = appConfig.calculateWeight(samplingPercentage);

                    if (isBatchingEnabled)
                    {
                        LoggerHelper.LogDebugMessage(debug, "Add Event to the batch");

                        if (MoesifQueue.Count < queueSize)
                        {
                            // Add event to the batch
                            MoesifQueue.Enqueue(eventModel);

                            if (DateTime.Compare(lastWorkerRun, DateTime.MinValue) != 0)
                            {
                                if (lastWorkerRun.AddMinutes(1) < DateTime.UtcNow)
                                {
                                    LoggerHelper.LogDebugMessage(debug, "Scheduling worker thread. lastWorkerRun=" + lastWorkerRun.ToString());
                                    ScheduleWorker();
                                }
                            }
                        }
                        else
                        {
                            LoggerHelper.LogDebugMessage(debug, "Queue is full, skip adding events ");
                        }
                    }
                    else
                    {
                        await client.Api.CreateEventAsync(eventModel);

                        LoggerHelper.LogDebugMessage(debug, "Event sent successfully to Moesif");
                    }
                }
                else
                {
                    LoggerHelper.LogDebugMessage(debug, "Skipped Event due to sampling percentage: " + samplingPercentage.ToString() + " and random percentage: " + randomPercentage.ToString());
                }
            }
            catch (APIException inst)
            {
                if (401 <= inst.ResponseCode && inst.ResponseCode <= 403)
                {
                    Console.WriteLine("Unauthorized access sending event to Moesif. Please check your Appplication Id.");
                }
                if (debug)
                {
                    Console.WriteLine("Error sending event to Moesif, with status code:");
                    Console.WriteLine(inst.ResponseCode);
                }
            }
        }
        private async Task <EventRequestModel> FormatRequest(IOwinRequest request)
        {
            var body = request.Body;

            string requestBody = await new StreamReader(request.Body).ReadToEndAsync();

            // Read request Body
            byte[] requestData = Encoding.UTF8.GetBytes(requestBody);
            request.Body = new MemoryStream(requestData);

            var reqHeaders = new Dictionary <string, string>();

            try
            {
                reqHeaders = request.Headers.ToDictionary(k => k.Key, k => k.Value.First(), StringComparer.OrdinalIgnoreCase);
            }
            catch (Exception inst)
            {
                if (debug)
                {
                    Console.WriteLine("error encountered while copying request header");
                    Console.WriteLine(inst);
                }
            }

            // Add Transaction Id to the Request Header
            var transation_id_out    = new Object();
            var captureTransactionId = moesifOptions.TryGetValue("DisableTransactionId", out transation_id_out);

            bool GetCaptureTransactionId = false;

            if (captureTransactionId)
            {
                GetCaptureTransactionId = (bool)(transation_id_out);
            }

            if (!GetCaptureTransactionId)
            {
                if (reqHeaders.ContainsKey("X-Moesif-Transaction-Id"))
                {
                    string reqTransId = reqHeaders["X-Moesif-Transaction-Id"];
                    if (!string.IsNullOrEmpty(reqTransId))
                    {
                        transactionId = reqTransId;
                        if (string.IsNullOrEmpty(transactionId))
                        {
                            transactionId = Guid.NewGuid().ToString();
                        }
                    }
                    else
                    {
                        transactionId = Guid.NewGuid().ToString();
                    }
                }
                else
                {
                    transactionId = Guid.NewGuid().ToString();
                }
                // Add Transaction Id to the Request Header
                reqHeaders["X-Moesif-Transaction-Id"] = transactionId;
            }

            var reqBody = new object();

            reqBody = null;
            string requestTransferEncoding;

            requestTransferEncoding = null;
            if (logBody)
            {
                try
                {
                    reqBody = ApiHelper.JsonDeserialize <object>(requestBody);
                }
                catch (Exception inst)
                {
                    if (debug)
                    {
                        Console.WriteLine("About to parse Request body as Base64 encoding");
                    }
                    // Get Request Body
                    reqBody = Base64Encode(requestBody);
                    requestTransferEncoding = "base64";
                }
            }

            string ip = null;

            try
            {
                List <string> proxyHeaders = new List <string> {
                    "X-Client-Ip", "X-Forwarded-For", "Cf-Connecting-Ip", "True-Client-Ip",
                    "X-Real-Ip", "X-Cluster-Client-Ip", "X-Forwarded", "Forwarded-For", "Forwarded"
                };

                if (!proxyHeaders.Intersect(reqHeaders.Keys.ToList(), StringComparer.OrdinalIgnoreCase).Any())
                {
                    ip = request.RemoteIpAddress.ToString();
                }
                else
                {
                    ClientIp helpers = new ClientIp();
                    ip = helpers.GetClientIp(reqHeaders, request);
                }
            }
            catch (Exception inst)
            {
                Console.WriteLine("error encountered while trying to get the client IP address");
                Console.WriteLine(inst);
            }

            var uri = request.Uri.ToString();

            string apiVersion     = null;
            var    apiVersion_out = new object();
            var    getApiVersion  = moesifOptions.TryGetValue("ApiVersion", out apiVersion_out);

            if (getApiVersion)
            {
                apiVersion = apiVersion_out.ToString();
            }

            var eventReq = new EventRequestModel()
            {
                Time             = DateTime.UtcNow,
                Uri              = uri,
                Verb             = request.Method,
                ApiVersion       = apiVersion,
                IpAddress        = ip,
                Headers          = reqHeaders,
                Body             = reqBody,
                TransferEncoding = requestTransferEncoding
            };

            return(eventReq);
        }
        private async Task Middleware(EventRequestModel event_request, EventResponseModel event_response)
        {
            var eventModel = new EventModel()
            {
                Request      = event_request,
                Response     = event_response,
                UserId       = userId,
                CompanyId    = companyId,
                SessionToken = sessionToken,
                Metadata     = metadata,
                Direction    = "Incoming"
            };

            // Get Mask Event
            var maskEvent_out = new object();
            var getMaskEvent  = moesifOptions.TryGetValue("MaskEventModel", out maskEvent_out);

            // Check to see if we need to send event to Moesif
            Func <EventModel, EventModel> MaskEvent = null;

            if (getMaskEvent)
            {
                MaskEvent = (Func <EventModel, EventModel>)(maskEvent_out);
            }

            // Mask event
            if (MaskEvent != null)
            {
                try
                {
                    eventModel = MaskEvent(eventModel);
                }
                catch
                {
                    Console.WriteLine("Can not execute MASK_EVENT_MODEL function. Please check moesif settings.");
                }
            }

            // Send Events
            try
            {
                // Get Sampling percentage
                samplingPercentage = appConfig.getSamplingPercentage(config, userId, companyId);

                Random random           = new Random();
                double randomPercentage = random.NextDouble() * 100;
                if (samplingPercentage >= randomPercentage)
                {
                    eventModel.Weight = appConfig.calculateWeight(samplingPercentage);

                    if (isBatchingEnabled)
                    {
                        if (debug)
                        {
                            Console.WriteLine("Add Event to the batch");
                        }
                        // Add event to queue
                        MoesifQueue.Enqueue(eventModel);
                    }
                    else
                    {
                        var createEventResponse = await client.Api.CreateEventAsync(eventModel);

                        var eventResponseConfigETag = createEventResponse["X-Moesif-Config-ETag"];

                        if (!(string.IsNullOrEmpty(eventResponseConfigETag)) &&
                            !(string.IsNullOrEmpty(configETag)) &&
                            configETag != eventResponseConfigETag &&
                            DateTime.UtcNow > lastUpdatedTime.AddMinutes(5))
                        {
                            try
                            {
                                // Get Application config
                                config = await appConfig.getConfig(client, debug);

                                if (!string.IsNullOrEmpty(config.ToString()))
                                {
                                    (configETag, samplingPercentage, lastUpdatedTime) = appConfig.parseConfiguration(config, debug);
                                }
                            }
                            catch (Exception ex)
                            {
                                if (debug)
                                {
                                    Console.WriteLine("Error while updating the application configuration");
                                }
                            }
                        }
                        if (debug)
                        {
                            Console.WriteLine("Event sent successfully to Moesif");
                        }
                    }
                }
                else
                {
                    if (debug)
                    {
                        Console.WriteLine("Skipped Event due to sampling percentage: " + samplingPercentage.ToString() + " and random percentage: " + randomPercentage.ToString());
                    }
                }
            }
            catch (APIException inst)
            {
                if (401 <= inst.ResponseCode && inst.ResponseCode <= 403)
                {
                    Console.WriteLine("Unauthorized access sending event to Moesif. Please check your Appplication Id.");
                }
                if (debug)
                {
                    Console.WriteLine("Error sending event to Moesif, with status code:");
                    Console.WriteLine(inst.ResponseCode);
                }
            }
        }
Example #23
0
        private EventModel CreateEvent()
        {
            // Parameters for the API call
            var reqHeaders = new Dictionary <string, string>();

            reqHeaders.Add("Host", "api.acmeinc.com");
            reqHeaders.Add("Accept", "*/*");
            reqHeaders.Add("Connection", "Keep-Alive");
            reqHeaders.Add("Content-Type", "application/json");
            reqHeaders.Add("Accept-Encoding", "gzip");

            var reqBody = ApiHelper.JsonDeserialize <object>(@" {
                    ""items"": [
                        {
                            ""type"": 1,
                            ""id"": ""fwfrf""
                        },
                        {
                            ""type"": 2,
                            ""id"": ""d43d3f""
                        }
                    ]
                }");

            var rspHeaders = new Dictionary <string, string>();

            rspHeaders.Add("Vary", "Accept-Encoding");
            rspHeaders.Add("Pragma", "no-cache");
            rspHeaders.Add("Expires", "-1");
            rspHeaders.Add("Content-Type", "application/json; charset=utf-8");
            rspHeaders.Add("Cache-Control", "no-cache");

            var rspBody = ApiHelper.JsonDeserialize <object>(@" {
                    ""Error"": ""InvalidArgumentException"",
                    ""Message"": ""Missing field field_a""
                }");

            var eventReq = new EventRequestModel()
            {
                Time       = DateTime.UtcNow.AddSeconds(-1),
                Uri        = "https://api.acmeinc.com/items/reviews/",
                Verb       = "PATCH",
                ApiVersion = "1.1.0",
                IpAddress  = "61.48.220.123",
                Headers    = reqHeaders,
                Body       = reqBody
            };

            var eventRsp = new EventResponseModel()
            {
                Time    = DateTime.UtcNow,
                Status  = 200,
                Headers = rspHeaders,
                Body    = rspBody
            };

            Dictionary <string, string> metadata = new Dictionary <string, string>
            {
                { "email", "*****@*****.**" },
                { "name", "abcdef" },
                { "image", "123" }
            };

            var eventModel = new EventModel()
            {
                Request      = eventReq,
                Response     = eventRsp,
                UserId       = "123456",
                CompanyId    = "67890",
                SessionToken = "XXXXXXXXX",
                Metadata     = metadata
            };

            return(eventModel);
        }
        /**
         * From Http request and response, construct the moesif EventModel
         */
        public async Task <EventModel> BuildMoesifEvent(HttpMessage request, HttpMessage response)
        {
            _Logger.LogDebug("Building Moesif event");

            string clientIpAddress  = "";
            string subscriptionId   = "";
            string subscriptionName = "";
            string correlationid    = "";

            Dictionary <string, string> reqheaders = HeadersUtils.deSerializeHeaders(request.HttpRequestMessage.Properties[ReqHeadersName]);

            foreach (var h in reqheaders)
            {
                string n = h.Key.Trim();
                string v = h.Value.Trim();
                if (n.Equals("clientIPAddress"))
                {
                    clientIpAddress = v;
                }
                if (n.Equals("subscription_id"))
                {
                    subscriptionId = v;
                }
                if (n.Equals("subscription_name"))
                {
                    subscriptionName = v;
                }
                if (n.Equals("correlationid"))
                {
                    correlationid = v;
                }
            }


            EventRequestModel moesifRequest = await genEventRequestModel(request,
                                                                         ReqHeadersName,
                                                                         RequestTimeName,
                                                                         _ApiVersion, clientIpAddress);

            EventResponseModel moesifResponse = await genEventResponseModel(response, clientIpAddress);

            Dictionary <string, object> metadata = genMetadata(request, MetadataName);

            metadata.Add("ApimSubscriptionId", subscriptionId);
            metadata.Add("ApimSubscriptionName", subscriptionName);
            metadata.Add("ApimCorrelationId", correlationid);

            string skey      = safeGetHeaderFirstOrDefault(request, _SessionTokenKey);
            string userId    = safeGetOrNull(request, UserIdName);
            string companyId = safeGetOrNull(request, CompanyIdName);


            EventModel moesifEvent = new EventModel()
            {
                Request      = moesifRequest,
                Response     = moesifResponse,
                SessionToken = skey,
                Tags         = null,
                UserId       = userId,
                CompanyId    = companyId,
                Metadata     = metadata,
                Direction    = "Incoming"
            };

            return(moesifEvent);
        }
Example #25
0
        private async Task Middleware(EventRequestModel event_request, EventResponseModel event_response)
        {
            var eventModel = new EventModel()
            {
                Request      = event_request,
                Response     = event_response,
                UserId       = userId,
                SessionToken = sessionToken,
                Metadata     = metadata
            };

            string applicationId     = null;
            var    applicationId_out = new object();
            var    getApplicationId  = moesifOptions.TryGetValue("ApplicationId", out applicationId_out);

            if (getApplicationId)
            {
                applicationId = applicationId_out.ToString();
            }

            if (applicationId_out == null || applicationId == null)
            {
                Console.WriteLine("Please provide the application Id to send events to Moesif");
            }
            else
            {
                // Get Mask Event
                var maskEvent_out = new object();
                var getMaskEvent  = moesifOptions.TryGetValue("MaskEventModel", out maskEvent_out);

                // Check to see if we need to send event to Moesif
                Func <EventModel, EventModel> MaskEvent = null;

                if (getMaskEvent)
                {
                    MaskEvent = (Func <EventModel, EventModel>)(maskEvent_out);
                }

                // Mask event
                if (MaskEvent != null)
                {
                    try
                    {
                        eventModel = MaskEvent(eventModel);
                    }
                    catch
                    {
                        Console.WriteLine("Can not execute MASK_EVENT_MODEL function. Please check moesif settings.");
                    }
                }

                // Send Events
                try
                {
                    double samplingPercentage = Convert.ToDouble(confDict["sample_rate"]);

                    Random random           = new Random();
                    double randomPercentage = random.NextDouble() * 100;
                    if (samplingPercentage >= randomPercentage)
                    {
                        var createEventResponse = await client.Api.CreateEventAsync(eventModel);

                        var eventResponseConfigETag = createEventResponse["X-Moesif-Config-ETag"];
                        cachedConfigETag = confDict["ETag"].ToString();

                        if (!(string.IsNullOrEmpty(eventResponseConfigETag)) &&
                            cachedConfigETag != eventResponseConfigETag &&
                            DateTime.UtcNow > ((DateTime)confDict["last_updated_time"]).AddMinutes(5))
                        {
                            confDict = await GetConfig(client, confDict, eventResponseConfigETag);
                        }
                        if (debug)
                        {
                            Console.WriteLine("Event sent successfully to Moesif");
                        }
                    }
                    else
                    {
                        if (debug)
                        {
                            Console.WriteLine("Skipped Event due to sampling percentage: " + samplingPercentage.ToString() + " and random percentage: " + randomPercentage.ToString());
                        }
                    }
                }
                catch (APIException inst)
                {
                    if (401 <= inst.ResponseCode && inst.ResponseCode <= 403)
                    {
                        Console.WriteLine("Unauthorized access sending event to Moesif. Please check your Appplication Id.");
                    }
                    if (debug)
                    {
                        Console.WriteLine("Error sending event to Moesif, with status code:");
                        Console.WriteLine(inst.ResponseCode);
                    }
                }
            }
        }
Example #26
0
 public EventRequestController()
 {
     _EventRequestBs    = new EventRequestBs();
     _EventRequestModel = new EventRequestModel();
 }
Example #27
0
        private bool Validate(EventRequestModel model, out string reason)
        {
            if (model == null)
            {
                reason = $"{nameof(model)} can not be null";
                return(false);
            }

            if (string.IsNullOrWhiteSpace(model.Category))
            {
                reason = $"{nameof(model.Category)} can not be null or whitespace";
                return(false);
            }

            if (string.IsNullOrWhiteSpace(model.TargetKey))
            {
                reason = $"{nameof(model.TargetKey)} can not be null or whitespace";
                return(false);
            }

            if (string.IsNullOrWhiteSpace(model.Message))
            {
                reason = $"{nameof(model.Message)} can not be null or whitespace";
                return(false);
            }

            if (string.IsNullOrWhiteSpace(model.Sender))
            {
                reason = $"{nameof(model.Sender)} can not be null or whitespace";
                return(false);
            }

            model.Category  = model.Category.Trim();
            model.TargetKey = model.TargetKey.Trim();
            model.Sender    = model.Sender.Trim();

            if (_advanceConfiguration?.Categories == null)
            {
                reason = null;
                return(true);
            }

            var allAllowed = _advanceConfiguration.Categories.Any(c => c.Name == "*");

            // If Advance Configuration is enabled then only specified categories
            // from the configuration can be used
            var category = _advanceConfiguration.Categories.FirstOrDefault(
                c => c.Name == model.Category);

            if (!allAllowed && category == null)
            {
                reason = $"The provided category `{model.Category}` is not allowed. Check" +
                         "/category/all for a list of allowed categories or contact your system administrator.";
                return(false);
            }

            if (category?.Level != null && category.Level.Value != model.Level)
            {
                reason = $"Only events of level `{category.Level.Value}` are allowed for category `{model.Category}`. Check" +
                         "/category/all for a list of allowed categories or contact your system administrator.";
                return(false);
            }

            reason = null;
            return(true);
        }
        public async Task <ActionResult> SlackInteractiveAction([FromForm] InteractivePayload request, CancellationToken cancellationToken)
        {
            var payload = JsonConvert.DeserializeObject <Payload>(request.payload);
            var values  = payload.view.state.values;

            string category = null;

            try
            {
                if (_configuration.ShowPredefinedCategory)
                {
                    category = values.event_category_select.category.selected_option.value.Trim();
                }
            }
            catch
            {
                if (!_configuration.ShowCustomCategory)
                {
                    return(Ok(new {
                        response_action = "errors",
                        errors = new {
                            event_category_select = "Select a category for your event",
                        }
                    }));
                }
            }

            try
            {
                if (string.IsNullOrWhiteSpace(category) && _configuration.ShowCustomCategory)
                {
                    category = values.event_custom_category.custom_category.value.Trim();
                }
            }
            catch
            {
                return(Ok(new {
                    response_action = "errors",
                    errors = new {
                        event_custom_category = "Enter a category for your event",
                    }
                }));
            }

            if (string.IsNullOrWhiteSpace(category))
            {
                return(Ok(new {
                    response_action = "errors",
                    errors = new {
                        event_category_select = "Select a category for your event",
                        event_custom_category = "Enter a category for your event",
                    }
                }));
            }

            var tags = new List <string>();

            if (!string.IsNullOrWhiteSpace(values.event_tags.tags.value))
            {
                tags = values.event_tags.tags.value
                       .Split(",")
                       .Select(e => e.Trim())
                       .Where(e => !string.IsNullOrWhiteSpace(e))
                       .ToList();
            }

            if (string.IsNullOrWhiteSpace(values?.event_target?.target?.value))
            {
                return(Ok(new {
                    response_action = "errors",
                    errors = new {
                        event_target = "Enter a target for your event"
                    }
                }));
            }

            if (string.IsNullOrWhiteSpace(values?.event_message?.message?.value))
            {
                return(Ok(new {
                    response_action = "errors",
                    errors = new {
                        event_message = "Enter a message for your event"
                    }
                }));
            }

            var model = new EventRequestModel
            {
                Category  = category,
                TargetKey = values.event_target.target.value,
                Level     = GetLevel(values.event_level.level.selected_option.value),
                Message   = values.event_message.message.value,
                Sender    = payload.user.username,
                Tags      = new ObservableCollection <string>(tags)
            };

            await _systemEventClient.EventPostAsync(model);

            return(Ok(new {
                response_action = "clear"
            }));
        }
        public async Task <HttpResponseMessage> SendEvent(HttpRequestMessage request, DateTime reqTime, HttpResponseMessage response, DateTime respTime)
        {
            if (debug)
            {
                Console.WriteLine("Calling the API to send the event to Moesif");
            }

            // Request Body Encoding
            var reqBody = new object();

            reqBody = null;
            string requestTransferEncoding;

            requestTransferEncoding = null;
            if (logBodyOutgoing && request.Content != null)
            {
                try
                {
                    if (debug)
                    {
                        Console.WriteLine("About to parse Request body as json");
                    }
                    // Get Request Body
                    string requestBody = await request.Content.ReadAsStringAsync();

                    reqBody = ApiHelper.JsonDeserialize <object>(requestBody);
                    requestTransferEncoding = "json";
                }
                catch (Exception e)
                {
                    if (debug)
                    {
                        Console.WriteLine("About to parse Request body as Base64 encoding");
                    }
                    // Get Request Body
                    string requestBody = await request.Content.ReadAsStringAsync();

                    reqBody = Base64Encode(requestBody);
                    requestTransferEncoding = "base64";
                }
            }

            // Prepare Moesif EventRequest Model
            Dictionary <string, string> reqHeaders = request.Headers.ToDictionary(a => a.Key, a => string.Join(";", a.Value));

            var eventReq = new EventRequestModel()
            {
                Time             = reqTime,
                Uri              = request.RequestUri.AbsoluteUri,
                Verb             = request.Method.ToString(),
                ApiVersion       = null,
                IpAddress        = null,
                Headers          = reqHeaders,
                Body             = reqBody,
                TransferEncoding = requestTransferEncoding
            };

            // Response Body Encoding
            var rspBody = new object();

            rspBody = null;
            string responseTransferEncoding;

            responseTransferEncoding = null;
            if (logBodyOutgoing && response.Content != null)
            {
                try
                {
                    if (debug)
                    {
                        Console.WriteLine("About to parse Response body as json");
                    }
                    // Get Response body
                    string responseBody = await response.Content.ReadAsStringAsync();

                    rspBody = ApiHelper.JsonDeserialize <object>(responseBody);
                    responseTransferEncoding = "json";
                }
                catch (Exception e)
                {
                    if (debug)
                    {
                        Console.WriteLine("About to parse Response body as Base64 encoding");
                    }
                    // Get Response body
                    string responseBody = await response.Content.ReadAsStringAsync();

                    rspBody = Base64Encode(responseBody);
                    responseTransferEncoding = "base64";
                }
            }

            // Response header
            Dictionary <string, string> respHeaders = response.Headers.ToDictionary(a => a.Key, a => string.Join(";", a.Value));

            // Prepare Moesif EventResponse Model
            var eventRsp = new EventResponseModel()
            {
                Time             = respTime,
                Status           = (int)response.StatusCode,
                Headers          = respHeaders,
                Body             = rspBody,
                TransferEncoding = responseTransferEncoding
            };

            // Get Outgoing Metadata
            var metadata_out = new object();
            var getMetadata  = moesifConfigOptions.TryGetValue("GetMetadataOutgoing", out metadata_out);

            Func <HttpRequestMessage, HttpResponseMessage, Dictionary <string, object> > GetMetadata = null;

            if (getMetadata)
            {
                GetMetadata = (Func <HttpRequestMessage, HttpResponseMessage, Dictionary <string, object> >)(metadata_out);
            }

            // Metadata
            metadataOutgoing = null;
            if (GetMetadata != null)
            {
                try
                {
                    metadataOutgoing = GetMetadata(request, response);
                }
                catch
                {
                    Console.WriteLine("Can not execute GetMetadataOutgoing function. Please check moesif settings.");
                }
            }

            // Get Outgoing SessionToken
            var token_out       = new object();
            var getSessionToken = moesifConfigOptions.TryGetValue("GetSessionTokenOutgoing", out token_out);

            Func <HttpRequestMessage, HttpResponseMessage, string> GetSessionToken = null;

            if (getSessionToken)
            {
                GetSessionToken = (Func <HttpRequestMessage, HttpResponseMessage, string>)(token_out);
            }

            // Session Token
            sessionTokenOutgoing = null;
            if (GetSessionToken != null)
            {
                try
                {
                    sessionTokenOutgoing = GetSessionToken(request, response);
                }
                catch {
                    Console.WriteLine("Can not execute GetSessionTokenOutgoing function. Please check moesif settings.");
                }
            }

            // Get UserId outgoing
            var user_out  = new object();
            var getUserId = moesifConfigOptions.TryGetValue("IdentifyUserOutgoing", out user_out);

            Func <HttpRequestMessage, HttpResponseMessage, string> IdentifyUser = null;

            if (getUserId)
            {
                IdentifyUser = (Func <HttpRequestMessage, HttpResponseMessage, string>)(user_out);
            }

            // UserId
            userIdOutgoing = null;
            if (IdentifyUser != null)
            {
                try
                {
                    userIdOutgoing = IdentifyUser(request, response);
                }
                catch {
                    Console.WriteLine("Can not execute IdentifyUserOutgoing function. Please check moesif settings.");
                }
            }

            // Get CompanyId outgoing
            var company_out  = new object();
            var getCompanyId = moesifConfigOptions.TryGetValue("IdentifyCompanyOutgoing", out company_out);

            Func <HttpRequestMessage, HttpResponseMessage, string> IdentifyCompany = null;

            if (getCompanyId)
            {
                IdentifyCompany = (Func <HttpRequestMessage, HttpResponseMessage, string>)(company_out);
            }

            // CompanyId
            companyIdOutgoing = null;
            if (IdentifyCompany != null)
            {
                try
                {
                    companyIdOutgoing = IdentifyCompany(request, response);
                }
                catch
                {
                    Console.WriteLine("Can not execute IdentifyCompanyOutgoing function. Please check moesif settings.");
                }
            }

            // Prepare Moesif Event Model
            var eventModel = new EventModel()
            {
                Request      = eventReq,
                Response     = eventRsp,
                UserId       = userIdOutgoing,
                CompanyId    = companyIdOutgoing,
                SessionToken = sessionTokenOutgoing,
                Metadata     = metadataOutgoing,
                Direction    = "Outgoing"
            };

            // Mask Outgoing Event Model
            var maskEvent_out = new object();
            var getMaskEvent  = moesifConfigOptions.TryGetValue("MaskEventModelOutgoing", out maskEvent_out);

            // Check to see if we need to send event to Moesif
            Func <EventModel, EventModel> MaskEventOutgoing = null;

            if (getMaskEvent)
            {
                MaskEventOutgoing = (Func <EventModel, EventModel>)(maskEvent_out);
            }

            // Mask event
            if (MaskEventOutgoing != null)
            {
                try
                {
                    eventModel = MaskEventOutgoing(eventModel);
                }
                catch
                {
                    Console.WriteLine("Can not execute MaskEventModelOutgoing function. Please check moesif settings.");
                }
            }

            // Send Event
            try
            {
                // Get Sampling percentage
                samplingPercentage = appConfig.getSamplingPercentage(config, eventModel.UserId, eventModel.CompanyId);

                Random random           = new Random();
                double randomPercentage = random.NextDouble() * 100;
                if (samplingPercentage >= randomPercentage)
                {
                    eventModel.Weight = appConfig.calculateWeight(samplingPercentage);

                    var createEventResponse = await client.Api.CreateEventAsync(eventModel);

                    var eventResponseConfigETag = createEventResponse["X-Moesif-Config-ETag"];

                    if (!(string.IsNullOrEmpty(eventResponseConfigETag)) &&
                        !(string.IsNullOrEmpty(configETag)) &&
                        configETag != eventResponseConfigETag &&
                        DateTime.UtcNow > lastUpdatedTime.AddMinutes(5))
                    {
                        try
                        {
                            // Get Application config
                            config = await appConfig.getConfig(client, debug);

                            if (!string.IsNullOrEmpty(config.ToString()))
                            {
                                (configETag, samplingPercentage, lastUpdatedTime) = appConfig.parseConfiguration(config, debug);
                            }
                        }
                        catch (Exception ex)
                        {
                            if (debug)
                            {
                                Console.WriteLine("Error while updating the application configuration");
                            }
                        }
                    }
                    if (debug)
                    {
                        Console.WriteLine("Event sent successfully to Moesif");
                    }
                }
                else
                {
                    if (debug)
                    {
                        Console.WriteLine("Skipped Event due to sampling percentage: " + samplingPercentage.ToString() + " and random percentage: " + randomPercentage.ToString());
                    }
                }
            }
            catch (APIException inst)
            {
                if (401 <= inst.ResponseCode && inst.ResponseCode <= 403)
                {
                    Console.WriteLine("Unauthorized access sending event to Moesif. Please check your Appplication Id.");
                }
                if (debug)
                {
                    Console.WriteLine("Error sending event to Moesif, with status code:");
                    Console.WriteLine(inst.ResponseCode);
                }
            }

            // Return Response back to the client
            return(response);
        }
Example #30
0
        private async Task <EventRequestModel> FormatRequest(HttpRequest request)
        {
            var body = request.Body;

            request.EnableRewind();

            var buffer = new byte[Convert.ToInt32(request.ContentLength)];

            await request.Body.ReadAsync(buffer, 0, buffer.Length);

            var bodyAsText = Encoding.UTF8.GetString(buffer);

            request.Body = body;

            var reqHeaders = new Dictionary <string, string>();

            try
            {
                reqHeaders = request.Headers.ToDictionary(k => k.Key, k => k.Value.ToString(), StringComparer.OrdinalIgnoreCase);
            }
            catch (Exception inst)
            {
                if (debug)
                {
                    Console.WriteLine("error encountered while copying request header");
                    Console.WriteLine(inst);
                }
            }

            // Add Transaction Id to the Request Header
            var transation_id_out    = new Object();
            var captureTransactionId = moesifOptions.TryGetValue("DisableTransactionId", out transation_id_out);

            bool GetCaptureTransactionId = false;

            if (captureTransactionId)
            {
                GetCaptureTransactionId = (bool)(transation_id_out);
            }

            if (!GetCaptureTransactionId)
            {
                if (reqHeaders.ContainsKey("X-Moesif-Transaction-Id"))
                {
                    string reqTransId = reqHeaders["X-Moesif-Transaction-Id"];
                    if (!string.IsNullOrEmpty(reqTransId))
                    {
                        transactionId = reqTransId;
                        if (string.IsNullOrEmpty(transactionId))
                        {
                            transactionId = Guid.NewGuid().ToString();
                        }
                    }
                    else
                    {
                        transactionId = Guid.NewGuid().ToString();
                    }
                }
                else
                {
                    transactionId = Guid.NewGuid().ToString();
                }
                // Add Transaction Id to the Request Header
                reqHeaders["X-Moesif-Transaction-Id"] = transactionId;
            }

            var reqBody = new object();

            reqBody = null;
            try
            {
                reqBody = ApiHelper.JsonDeserialize <object>(bodyAsText);
            }
            catch (Exception inst)
            {
                Console.WriteLine("error encountered while trying to serialize request body");
                Console.WriteLine(inst);
            }

            string ip = null;

            try
            {
                List <string> proxyHeaders = new List <string> {
                    "X-Client-Ip", "X-Forwarded-For", "Cf-Connecting-Ip", "True-Client-Ip",
                    "X-Real-Ip", "X-Cluster-Client-Ip", "X-Forwarded", "Forwarded-For", "Forwarded"
                };

                if (!proxyHeaders.Intersect(reqHeaders.Keys.ToList(), StringComparer.OrdinalIgnoreCase).Any())
                {
                    ip = request.HttpContext.Connection.RemoteIpAddress.ToString();
                }
                else
                {
                    ClientIp helpers = new ClientIp();
                    ip = helpers.GetClientIp(reqHeaders, request);
                }
            }
            catch (Exception inst)
            {
                Console.WriteLine("error encountered while trying to get the client IP address");
                Console.WriteLine(inst);
            }

            var uri = new Uri(request.GetDisplayUrl()).ToString();

            string apiVersion     = null;
            var    apiVersion_out = new object();
            var    getApiVersion  = moesifOptions.TryGetValue("ApiVersion", out apiVersion_out);

            if (getApiVersion)
            {
                apiVersion = apiVersion_out.ToString();
            }

            var eventReq = new EventRequestModel()
            {
                Time       = DateTime.UtcNow,
                Uri        = uri,
                Verb       = request.Method,
                ApiVersion = apiVersion,
                IpAddress  = ip,
                Headers    = reqHeaders,
                Body       = reqBody
            };

            return(eventReq);
        }