private void createResponse(ActionResult result, BpmTask bpmTask)
        {
            try
            {
                try
                {
                    OkResult x = (OkResult)result;
                    if (bpmTask.type != "userTask")
                    {
                        createSuccessResponse(new object[] {}, bpmTask);
                    }
                }
                catch (Exception)
                {
                    OkObjectResult x = (OkObjectResult)result;
                    if (bpmTask.type != "userTask")
                    {
                        createSuccessResponse(new object[] { x.Value }, bpmTask);
                    }
                }
            }
            catch (Exception ex)
            {
                BadRequestObjectResult x = (BadRequestObjectResult)result;

                createFailedResponse(x.Value, bpmTask);
            }
        }
        public void QueueExection(BpmTask workItem)
        {
            if (workItem == null)
            {
                throw new ArgumentNullException(nameof(workItem));
            }

            _workItems.Enqueue(workItem);
            _signal.Release();
        }
        public async Task Execute(BpmTask bpmTask)
        {
            _logger.LogInformation("executing " + bpmTask.TaskName);

            using (var scope = Services.CreateScope())
            {
                var _sysServices = scope.ServiceProvider.GetRequiredService <SystemServices>();

                await _sysServices.findServiceAsync(bpmTask, scope);
            }
        }
        private void createFailedResponse(object message, BpmTask bpmTask)
        {
            ServiceResponse bpmResponse = new ServiceResponse
            {
                Organization = bpmTask.databaseName,
                status       = "Failed",
                IsBpm        = bpmTask.IsBpm,
                InvokerId    = bpmTask.InvokerId,
                Type         = bpmTask.type,
                parameters   = message,
            };

            _responseQueue.QueueExection(bpmResponse);
        }
        private void createSuccessResponse(object[] param, BpmTask bpmTask)
        {
            ServiceResponse Response = new ServiceResponse
            {
                Organization = bpmTask.databaseName,
                InvokerId    = bpmTask.InvokerId,
                status       = "success",
                Type         = bpmTask.type,
                IsBpm        = bpmTask.IsBpm,
                parameters   = param
            };

            _responseQueue.QueueExection(Response);
        }
        public ActionResult RunTask(BpmTask bpmTask)
        {
            var bpmWorker = new BpmWorker
            {
                instanceID   = bpmTask.instanceID,
                workflowName = bpmTask.workflowName,
                taskID       = bpmTask.taskID
            };

            _accountDbContext.BpmWorkers.Add(bpmWorker);
            _accountDbContext.SaveChanges();
            bpmTask.InvokerId = bpmWorker.Id;

            bpmTask.databaseName = ((ClaimsIdentity)HttpContext.User.Identity).FindFirst("organization").Value;
            bpmTask.IsBpm        = true;
            _exectionQueue.QueueExection(bpmTask);
            return(Ok());
        }
        protected async override Task ExecuteAsync(CancellationToken stoppingToken)
        {
            _logger.LogInformation("Task Execution Engine Hosted Service is starting.");


            while (!stoppingToken.IsCancellationRequested)
            {
                BpmTask bpmTask = await _taskExectionQueue.DequeueAsync(stoppingToken);

                if (bpmTask != null)
                {
                    tasks.Add(Execute(bpmTask));
                }
                //Thread.Sleep(1000);
            }

            await Task.WhenAll(tasks);

            _logger.LogInformation("Task Execution Engine Hosted Service is stopping.");
        }
        public async Task <ActionResult <string> > AddOrderPayment([FromBody] Order order)
        {
            string       OrganizationName = (string)RouteData.Values["OrganizationName"];
            Organization orgExist         = await _organizationRepository.OraganizationExist(OrganizationName);

            if (orgExist != null)
            {
                _orderRepository.setConnectionString(OrganizationName);

                byte[] error  = new byte[500];
                int    status = await _orderRepository.AddOrderPayment(order, error);

                string z = Encoding.ASCII.GetString(error);
                if (status != 0)
                {
                    return(BadRequest(z.Remove(z.IndexOf('\0'))));
                }
                else
                {
                    BpmTask task = new BpmTask()
                    {
                        IsBpm        = false,
                        type         = "external",
                        TaskName     = "InvokeOrder",
                        databaseName = OrganizationName,
                        TaskParam    = new object[] { order }
                    };
                    _executionEngine.QueueExection(task);
                    return(Ok("successfuly added"));
                }
            }
            else
            {
                return(NotFound("This organization does not exist"));
            }
        }
        public async Task findServiceAsync(BpmTask bpmTask, IServiceScope serviceScope)
        {
            var services = _actionDescriptorCollectionProvider
                           .ActionDescriptors
                           .Items
                           .OfType <ControllerActionDescriptor>()
                           .Where(a => a.ActionName == bpmTask.TaskName);

            if (services.Count() > 0)
            {
                foreach (var item in services)
                {
                    try
                    {
                        var                  id           = new ClaimsIdentity();
                        string               httpMethode  = item.ActionConstraints.OfType <HttpMethodActionConstraint>().SingleOrDefault().HttpMethods.FirstOrDefault();
                        MethodInfo           methodInfo   = item.ControllerTypeInfo.GetMethod(bpmTask.TaskName);
                        List <ParameterInfo> parameters   = methodInfo.GetParameters().ToList();
                        List <object>        methodeParam = new List <object>();
                        if (parameters.Count == bpmTask.TaskParam.Length)
                        {
                            for (int i = 0; i < parameters.Count; ++i)
                            {
                                var     taskParameterobj = bpmTask.TaskParam[i];
                                string  json             = JsonConvert.SerializeObject(taskParameterobj);
                                JObject jsonOb           = JObject.Parse(json);
                                var     jsonObProperties = jsonOb.Properties();
                                Type    methodParamtype  = parameters[i].ParameterType;
                                bool    isClass          = checkedClassType(methodParamtype);

                                try
                                {
                                    if (isClass)
                                    {
                                        methodeParam.Add(JsonConvert.DeserializeObject(json, methodParamtype));
                                    }
                                    else if (jsonObProperties.Count() == 1)
                                    {
                                        methodeParam.Add(Convert.ChangeType(jsonObProperties.FirstOrDefault().Value, parameters[i].ParameterType));
                                    }
                                }
                                catch (Exception)
                                {
                                    createFailedResponse("Cannont convert paramenter" + json + "to the task paramerter " + i, bpmTask);
                                    return;
                                }
                            }
                            var controller  = (ControllerBase)serviceScope.ServiceProvider.GetService(item.ControllerTypeInfo);
                            var httpContext = new DefaultHttpContext();
                            httpContext.Request.Headers["organization"] = bpmTask.databaseName;

                            var controllerContext = new ControllerContext()
                            {
                                HttpContext = httpContext,
                            };
                            controller.ControllerContext = controllerContext;
                            var contProperties = controller.GetType().GetProperties().ToList();
                            foreach (var property in contProperties)
                            {
                                try
                                {
                                    var proType = property.GetValue(controller).GetType();
                                    if (proType != null)
                                    {
                                        Console.WriteLine(property.Name);
                                        MethodInfo _methodInfo = proType.GetMethod("setConnectionString");
                                        if (_methodInfo != null)
                                        {
                                            var result = _methodInfo.Invoke(property.GetValue(controller), new object[] { bpmTask.databaseName });
                                        }
                                    }
                                }
                                catch (Exception ex)
                                {
                                    continue;
                                }
                            }
                            if (bpmTask.type == "userTask")
                            {
                                var IsBpmEngine = methodeParam[0].GetType().GetProperty("IsBpmEngine");
                                IsBpmEngine.SetValue(methodeParam[0], bpmTask.IsBpm);
                                var InvokerId = methodeParam[0].GetType().GetProperty("InvokerId");
                                InvokerId.SetValue(methodeParam[0], bpmTask.InvokerId);
                            }
                            _logger.LogInformation("Invoking " + bpmTask.TaskName);
                            var resutlt = await(dynamic) methodInfo.Invoke(controller, methodeParam.ToArray());

                            var prop = resutlt.GetType().GetProperty("Result");
                            if (prop != null)
                            {
                                var action = prop.GetValue(resutlt);
                                createResponse((ActionResult)action, bpmTask);
                            }
                            else
                            {
                                createResponse((ActionResult)(resutlt), bpmTask);
                            }
                        }
                        else
                        {
                            createFailedResponse("Parameter Don't match service Parameter", bpmTask);
                        }
                    }
                    catch (Exception ex)
                    {
                        createFailedResponse("Problem has occurred while Trying to execute this Task", bpmTask);
                        throw;
                    }
                }
            }
            else
            {
                createFailedResponse("This Task Does not exist", bpmTask);
            }
        }