Example #1
0
        public PowerRequestDto MapToPowerRequestDto(PowerRequest powerrequest)
        {
            if (powerrequest != null)
            {
                var powerrequestDto = new PowerRequestDto
                {
                    Id                = powerrequest.Id,
                    Amount            = powerrequest.Amount,
                    Energyneeded      = powerrequest.Energyneeded,
                    IsConfirmed       = powerrequest.IsConfirmed,
                    Date              = powerrequest.Date,
                    RequestFrom       = powerrequest.RequestFrom,
                    Load              = powerrequest.Load,
                    SMID              = powerrequest.SMID,
                    ResponseFrom      = powerrequest.ResponseFrom,
                    TariffId          = powerrequest.TariffId,
                    TransactionStatus = powerrequest.TransactionStatus.GetDisplayName(),

                    CreateDate   = powerrequest.CreateDate,
                    ModifiedDate = powerrequest.ModifiedDate,
                    IsDeleted    = powerrequest.IsDeleted
                };

                return(powerrequestDto);
            }
            return(new PowerRequestDto());
        }
 private void SetPowerplantsInfos(PowerRequest powerRequest)
 {
     infos = new List <PowerplantInfo>();
     foreach (Powerplant p in powerRequest.powerplants)
     {
         infos.Add(new PowerplantInfo(p, powerRequest.fuels));
     }
 }
Example #3
0
        private void OnBusy(object sender, IdleScanAnalysis analysis)
        {
            string tokens = string.Join(", ", analysis.BusyTokens.Where(t => !(t.StartsWith("((") && t.EndsWith("))"))));
            string reason = $"Kein Standby-Modus wegen: {tokens}";

            if (Request?.Reason != reason)
            {
                Request?.Clear();
                Request = new PowerRequest(reason);
            }
        }
Example #4
0
        public ActionResult GetPowerPlants([FromBody] PowerRequest powerRequest)
        {
            try
            {
                var plants = _powerloadService.GetPowerPlants(powerRequest);

                return(Ok(plants.Result));
            }
            catch (Exception ex)
            {
                return(BadRequest(ex.Message));
            }
        }
        public Assingment[] Solve(PowerRequest powerRequest)
        {
            this.powerRequest = powerRequest;
            SetPowerplantsInfos(powerRequest);

            if (!PowerSurplus())
            {
                return(MaxAssingments());
            }
            else
            {
                return(AstarSearch(infos));
            }
        }
Example #6
0
        private PowerRequest GetRequest(int load, int windPercent)
        {
            var request     = new PowerRequest();
            var rng         = new Random();
            var powerPlants = new List <PowerPlant>();

            decimal[] efficiency = new[] { 0.53M, 0.37M };
            var       fuels      = new Dictionary <string, decimal>();

            request.Load = load;

            powerPlants.AddRange(Enumerable.Range(1, 2).Select(index => new PowerPlant
            {
                Efficiency = 1,
                Name       = "windPark" + rng.Next(0, 99),
                Pmax       = rng.Next(50, 150),
                Pmin       = 0,
                Type       = "windturbine"
            }));

            powerPlants.AddRange(Enumerable.Range(1, 2).Select(index => new PowerPlant
            {
                Efficiency = efficiency[rng.Next(efficiency.Length)],
                Name       = "gasfired" + rng.Next(0, 99),
                Pmax       = rng.Next(200, 400),
                Pmin       = rng.Next(40, 100),
                Type       = "gasfired"
            }));

            powerPlants.Add(new PowerPlant
            {
                Efficiency = 0.3M,
                Name       = "turbojet1",
                Pmax       = 17,
                Pmin       = 0,
                Type       = "turbojet"
            });
            request.Powerplants = powerPlants;

            fuels.Add("wind(%)", windPercent);
            fuels.Add("kerosine(euro/MWh)", 50.8M);
            fuels.Add("co2(euro/ton)", 20);
            fuels.Add("gas(euro / MWh)", 13.4M);

            request.Fuels = fuels;

            return(request);
        }
 public IActionResult Post([FromBody] PowerRequest powerRequest)
 {
     try
     {
         LogPowerRequest(powerRequest);
         Assingment[] assingments = powerRequestSolver.Solve(powerRequest);
         LogAssingments(assingments);
         BroadcastRequestAssingments(powerRequest, assingments);
         return(new JsonResult(assingments));
     }
     catch (Exception ex)
     {
         LogException(ex);
         return(new StatusCodeResult(Microsoft.AspNetCore.Http.StatusCodes.Status400BadRequest));
     }
 }
        public IActionResult Post([FromBody] PowerRequest request)
        {
            if (!this.ModelState.IsValid)
            {
                return(this.BadRequest());
            }

            var delayMilliseconds = (request.DelaySeconds ?? 5) * 1000;

            delayMilliseconds = delayMilliseconds > 0 ? delayMilliseconds : 0;

            Task.Run(() => {
                Thread.Sleep(delayMilliseconds);
                this.powerStateManager.SetState(request.State);
            });

            return(this.Ok());
        }
Example #9
0
        /// <summary>
        /// Method for selecting available plants considering fuel price and CO emissions cost
        /// </summary>
        /// <param name="powerRequest"></param>
        /// <returns></returns>
        public Task <List <RequestResult> > GetPowerPlants(PowerRequest powerRequest)
        {
            var results = new List <RequestResult>();

            try
            {
                // Grouping all the plants by type, sorting each group from higher to lower efficiency and from higher to lower maximum power.
                var groups = powerRequest.Powerplants.GroupBy(g => g.Type).ToDictionary(g => g.Key, g => g.OrderByDescending(a => a.Efficiency).ThenByDescending(a => a.Pmax).ToList());

                decimal load = powerRequest.Load;

                var plantsSortedByPrice = new List <PowerPlant>();

                var windPerc = default(decimal);
                if (powerRequest.Fuels.Keys.Any(a => a.Contains("wind")))
                {
                    windPerc = powerRequest.Fuels.First(a => a.Key.Contains("wind")).Value;
                }

                if (groups.Keys.Any(a => a.Contains("windturbine")))
                {
                    plantsSortedByPrice.AddRange(groups["windturbine"]);
                }

                if (groups.Keys.Any(a => a.Contains("gasfired")))
                {
                    plantsSortedByPrice.AddRange(groups["gasfired"]);
                }

                if (groups.Keys.Any(a => a.Contains("turbojet")))
                {
                    plantsSortedByPrice.AddRange(groups["turbojet"]);
                }

                for (int i = 0; i < plantsSortedByPrice.Count && load > 0; i++)
                {
                    var plant = plantsSortedByPrice[i];

                    //In order to get the exact amount of capacity and use every plant, the Pmin for the next plant will be considered.
                    var nextPlant = new PowerPlant();
                    if (i + 1 < plantsSortedByPrice.Count)
                    {
                        nextPlant = plantsSortedByPrice[i + 1];
                    }

                    var pmax = plant.Pmax;
                    var pmin = plant.Pmin;

                    if (plant.Type == "windturbine")
                    {
                        pmax = pmax * windPerc / 100;
                        pmin = pmin * windPerc / 100;
                    }

                    var power = default(decimal);

                    if (pmax < 1)
                    {
                        continue;
                    }

                    if (pmax < load)
                    {
                        if (nextPlant.Pmin > (load - pmax))
                        {
                            power = load - nextPlant.Pmin;
                        }
                        else
                        {
                            power = pmax;
                        }

                        load -= power;
                    }
                    else
                    {
                        power = load;
                        load  = default(decimal);
                    }

                    results.Add(new RequestResult {
                        p = power, name = plant.Name
                    });
                }
            }
            catch
            {
                throw;
            }

            return(Task.FromResult(results));
        }
Example #10
0
 public void DeletePowerRequest(PowerRequest person)
 {
     _context.PowerRequests.Remove(person);
     _context.SaveChanges();
 }
 private void LogPowerRequest(PowerRequest powerRequest)
 {
     logger.LogInformation(LoggingEvents.PowerRequestReceived, "New Power request: {powerRequest}",
                           JsonConvert.SerializeObject(powerRequest));
 }
 private void BroadcastRequestAssingments(PowerRequest powerRequest, Assingment[] assingments)
 {
     hub.Clients.All.SendAsync("transferRequestAssingments",
                               new RequestAssingments(powerRequest, assingments));
 }
Example #13
0
 public void UpdatePowerRequest(PowerRequest person)
 {
     _context.PowerRequests.Update(person);
     _context.SaveChanges();
 }
Example #14
0
 private void OnIdle(object sender, IdleScanAnalysis analysis)
 {
     Request?.Clear();
     Request = null;
 }
 public ProductInfo PowerSearchRequest(PowerRequest PowerSearchRequest)
 {
     object[] results = this.Invoke("PowerSearchRequest", new object[] {
         PowerSearchRequest});
     return ((ProductInfo)(results[0]));
 }
 public System.IAsyncResult BeginPowerSearchRequest(PowerRequest PowerSearchRequest, System.AsyncCallback callback, object asyncState)
 {
     return this.BeginInvoke("PowerSearchRequest", new object[] {
         PowerSearchRequest}, callback, asyncState);
 }
 // for the initial node
 public Node(List <PowerplantInfo> unused, PowerRequest powerRequest)
 {
     _powerRequest = powerRequest;
     ResetGrapth();
     this.unused.AddRange(unused);
 }
Example #18
0
        public object FunctionHandler(object input, ILambdaContext context)
        {
            // Get request object
            Request request     = JsonConvert.DeserializeObject <Request>(input.ToString());
            string  requestType = request.Directive.Header.Name;

            LambdaLogger.Log("Request type: " + requestType + Environment.NewLine);

            if (requestType == "Discover")
            {
                // Create response object
                Response response = new Response
                {
                    Event = new Event()
                };

                response.Event.Header = new Header();

                LambdaLogger.Log("DISCOVER: " + input.ToString());
                response.Event.Payload = new Payload
                {
                    Endpoints = new List <Endpoint>()
                };
                LambdaLogger.Log("Discovering devices" + Environment.NewLine);
                // Set header properties
                response.Event.Header.Namespace      = "Alexa.Discovery";
                response.Event.Header.Name           = "Discover.Response";
                response.Event.Header.PayloadVersion = "3";
                response.Event.Header.MessageId      = request.Directive.Header.MessageId;

                // Create endpoint
                Endpoint ep1 = new Endpoint
                {
                    EndpointId        = "endpoint-001",
                    ManufacturerName  = "Ryan Malencia",
                    FriendlyName      = "Apple Jacks",
                    Description       = "This is a switch!",
                    DisplayCategories = new List <string>()
                    {
                        "SMARTPLUG"
                    }
                };
                ep1.Capabilities = new List <Capability>();

                // Create capabilities
                Capability cap1 = new Capability
                {
                    Type      = "AlexaInterface",
                    Interface = "Alexa",
                    Version   = "3"
                };
                Capability cap2 = new Capability
                {
                    Type      = "AlexaInterface",
                    Interface = "Alexa.PowerController",
                    Version   = "3"
                };

                // Create properties
                Properties p1 = new Properties();
                Supported  s1 = new Supported
                {
                    Name = "powerState"
                };
                p1.Supported = new List <Supported>();
                p1.Supported.Add(s1);
                //p1.ProactivelyReported = true;
                //p1.Retrievable = true;
                cap2.Properties = p1;

                // Set capabilities
                ep1.Capabilities.Add(cap1);
                ep1.Capabilities.Add(cap2);

                // Add endpoint to response
                response.Event.Payload.Endpoints.Add(ep1);

                return(response);
            }
            else if (requestType == "TurnOff")
            {
                PowerRequest  powerRequest  = JsonConvert.DeserializeObject <PowerRequest>(input.ToString());
                PowerResponse powerResponse = new PowerResponse
                {
                    Context = new Context
                    {
                        Properties = new List <Property>()
                    }
                };
                Property p1 = new Property
                {
                    Namespace    = "Alexa.PowerController",
                    Name         = "powerState",
                    Value        = "OFF",
                    TimeOfSample = DateTime.Now,
                    UncertaintyInMilliseconds = 200
                };
                Property p2 = new Property
                {
                    Namespace    = "Alexa.EndpointHealth",
                    Name         = "connectivity",
                    Value        = "OK",
                    TimeOfSample = DateTime.Now,
                    UncertaintyInMilliseconds = 200
                };
                powerResponse.Context.Properties.Add(p1);
                powerResponse.Context.Properties.Add(p2);

                powerResponse.Event = new SmartPLugHandlerLambda.Response.Event
                {
                    Header = new SmartPLugHandlerLambda.Response.Header
                    {
                        Namespace        = "Alexa",
                        Name             = "Response",
                        PayloadVersion   = "3",
                        MessageId        = powerRequest.Directive.Header.MessageId,
                        CorrelationToken = powerRequest.Directive.Header.CorrelationToken
                    },

                    Endpoint = new SmartPLugHandlerLambda.Response.Endpoint
                    {
                        Scope = new SmartPLugHandlerLambda.Response.Scope
                        {
                            Type  = powerRequest.Directive.Endpoint.Scope.Type,
                            Token = powerRequest.Directive.Endpoint.Scope.Token
                        },
                        EndpointId = powerRequest.Directive.Endpoint.EndpointId,
                    },

                    Payload = new SmartPLugHandlerLambda.Response.Payload()
                };


                LambdaLogger.Log("OFF: " + input.ToString());
                const string queueUrl = "https://sqs.us-east-1.amazonaws.com/320502343338/SmartPlugQueue";
                var          config   = new AmazonSQSConfig
                {
                    ServiceURL = "http://sqs.us-east-1.amazonaws.com"
                };
                var client      = new AmazonSQSClient(config);
                var sendMessage = client.SendMessageAsync(queueUrl, "OFF", new System.Threading.CancellationToken());
                while (!sendMessage.IsCompleted)
                {
                }
                return(powerResponse);
            }
            else if (requestType == "TurnOn")
            {
                PowerRequest  powerRequest  = JsonConvert.DeserializeObject <PowerRequest>(input.ToString());
                PowerResponse powerResponse = new PowerResponse
                {
                    Context = new Context
                    {
                        Properties = new List <Property>()
                    }
                };
                Property p1 = new Property
                {
                    Namespace    = "Alexa.PowerController",
                    Name         = "powerState",
                    Value        = "ON",
                    TimeOfSample = DateTime.Now,
                    UncertaintyInMilliseconds = 200
                };
                Property p2 = new Property
                {
                    Namespace    = "Alexa.EndpointHealth",
                    Name         = "connectivity",
                    Value        = "OK",
                    TimeOfSample = DateTime.Now,
                    UncertaintyInMilliseconds = 200
                };
                powerResponse.Context.Properties.Add(p1);
                powerResponse.Context.Properties.Add(p2);

                powerResponse.Event = new SmartPLugHandlerLambda.Response.Event
                {
                    Header = new SmartPLugHandlerLambda.Response.Header
                    {
                        Namespace        = "Alexa",
                        Name             = "Response",
                        PayloadVersion   = "3",
                        MessageId        = powerRequest.Directive.Header.MessageId,
                        CorrelationToken = powerRequest.Directive.Header.CorrelationToken
                    },

                    Endpoint = new SmartPLugHandlerLambda.Response.Endpoint
                    {
                        Scope = new SmartPLugHandlerLambda.Response.Scope
                        {
                            Type  = powerRequest.Directive.Endpoint.Scope.Type,
                            Token = powerRequest.Directive.Endpoint.Scope.Token
                        },
                        EndpointId = powerRequest.Directive.Endpoint.EndpointId,
                    },

                    Payload = new SmartPLugHandlerLambda.Response.Payload()
                };

                LambdaLogger.Log("ON: " + input.ToString());
                const string queueUrl = "https://sqs.us-east-1.amazonaws.com/320502343338/SmartPlugQueue";
                var          config   = new AmazonSQSConfig
                {
                    ServiceURL = "http://sqs.us-east-1.amazonaws.com"
                };
                var client      = new AmazonSQSClient(config);
                var sendMessage = client.SendMessageAsync(queueUrl, "ON", new System.Threading.CancellationToken());
                while (!sendMessage.IsCompleted)
                {
                }
                return(powerResponse);
            }
            return(new Response());
        }
Example #19
0
 protected override void OnShutdown()
 {
     Request?.Clear();
     Request = null;
 }
Example #20
0
 public void SavePowerRequest(PowerRequest person)
 {
     _context.PowerRequests.Add(person);
     _context.SaveChanges();
 }