using CloudServiceDAO;
using Grpc.Core;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static CloudServiceDAO.servicioDAOService;
using System.Threading;
using System.Numerics;

namespace server
{
    public class IDAOServices : servicioDAOServiceBase
    { 
        ServicesDAO requestQueue = new ServicesDAO();
        
        
        public override async Task<SetContractedServicesResponse> setContractedServicesService(SetContractedServicesRequest request, ServerCallContext context) 
        {
            requestQueue = new ServicesDAO();
            String result = requestQueue.setContractedServices(request.UserId, request.BackupScheduledId, request.PlanId,
                request.FirewallId, request.VdcVcdId);
            if (result == null || String.IsNullOrEmpty(result))
            {
                throw new RpcException(new Status(StatusCode.NotFound, "No results for contracted service"));

            }
            cloudServiceDAO resultmessage = new cloudServiceDAO
            {

                Response = result
            };
            return new SetContractedServicesResponse() { Response = resultmessage };


        }

        public override async Task<SetfirewallResponse> setfirewallServices(SetfirewallRequest request, ServerCallContext context)
        {
            requestQueue = new ServicesDAO();            
            var ipsRequest = request.Ips;            
            String result = requestQueue.setFirewall(ipsRequest, request.IsSegment);

            if (result == null || String.IsNullOrEmpty(result))
            {
                throw new RpcException(new Status(StatusCode.NotFound, "No results for firewall information"));

            }
            cloudServiceDAO resultmessage = new cloudServiceDAO
            {

                Response = result
            };
            return new SetfirewallResponse() { Response = resultmessage };


        }
        
        public override async Task<ProductsType> getProductType(GetProductTypeRequest request, ServerCallContext context)
        {
            requestQueue = new ServicesDAO();
            ProductsType listProducts = new ProductsType();          
            DataTable? result = requestQueue.getProductType();

            if (result == null )
                throw new RpcException(new Status(StatusCode.NotFound, "No results for type catalog"));
            else
            {
                if (result.Rows.Count > 0)
                {
                    foreach (DataRow row in result.Rows)
                    {
                        int id = 0;
                        bool isavaible=false;
                        productType productItem = new productType()
                        {
                            Id = (Int32.TryParse(row["id"].ToString(), out id) == true
                            ? id : 0),
                            ProductName = row["product_name"].ToString(),
                            ProductDsc = row["product_dsc"].ToString(),
                            IsAvaible = (Boolean.TryParse(row["is_available"].ToString(),out isavaible)==true
                            ? isavaible : false),
                            Steps = row["steps"].ToString()
                        };
                        listProducts.Products.Add(productItem);
                    }
                }
                else
                    throw new RpcException(new Status(StatusCode.NotFound, "No results for product types information"));
            }
            return new ProductsType(listProducts);            
        }
        
        public override async Task<PlansServices> getPlansService(GetPlansServiceRequest request, ServerCallContext context)
        {
            requestQueue = new ServicesDAO();
            PlansServices listPlans = new PlansServices();
            var IdServiceRequest = request.IdService;
            DataTable? result = requestQueue.getPlansService(IdServiceRequest);

            if (result == null)
                throw new RpcException(new Status(StatusCode.NotFound, "No results for type catalog"));
            else
            {
                if (result.Rows.Count > 0)
                {
                    try
                    {
                        foreach (DataRow row in result.Rows)
                        {
                            int id = 0, serviceid = 0;
                            bool active = false;
                            double priceFactor = 0;
                            Plan planItem = new Plan()
                            {
                                PlanId = (Int32.TryParse(row["PlanID"].ToString(), out id) == true
                                ? id : 0),
                                Name = row["name"].ToString(),
                                Description = row["description"].ToString(),
                                PriceFactor = (Double.TryParse(row["price_factor"].ToString(), out priceFactor) == true
                                ? priceFactor : 0),
                                Resources = row["resources"].ToString(),
                                Model = row["model"].ToString(),
                                ServiceId = (Int32.TryParse(row["service_id"].ToString(), out serviceid) == true
                                ? serviceid : 0),
                                Active = (Boolean.TryParse(row["active"].ToString(), out active) == true
                                ? active : false)
                            };
                            listPlans.Plan.Add(planItem);
                        }
                    }
                    catch (Exception ex)
                    {
                        throw new RpcException(new Status(StatusCode.Aborted, "Error to extract data information"));
                    }
                }
                else
                    throw new RpcException(new Status(StatusCode.NotFound, "No results for plans information"));
            }
            return new PlansServices(listPlans) ;
        }

        public override async Task<AllContractedServices> getServicesAllContracted(GetAllContractedServicesRequest request, ServerCallContext context)
        {
           requestQueue = new ServicesDAO();
           AllContractedServices listServices = new AllContractedServices();
           DataTable? result = requestQueue.getServicesAllContracted(request.IdUser, request.IdPlan,
               request.ContractedServicesId, request.VdcVcdId);
            if (result == null)
                throw new RpcException(new Status(StatusCode.NotFound, "No results for contracted services"));
            else
            {
                if (result.Rows.Count > 0)
                {
                    foreach (DataRow row in result.Rows)
                    {
                        int id = 0, sid=0, serviceStatusId = 0, planid = 0,
                            requestId = 0, srvstatusid = 0, supplyid = 0;
                        bool active = false;
                        double priceFactor = 0;
                        ContractedServices planItem = new ContractedServices()
                        {
                            ServicesID = (Int32.TryParse(row["ServicesID"].ToString(), out sid) == true
                            ? sid : 0),
                            ContractedServicesId = (Int32.TryParse(row["contracted_services_id"].ToString(), out id) == true
                            ? id : 0),
                            ServiceName = row["serviceName"].ToString(),
                            ServiceDescription = row["serviceDescription"].ToString(),
                            ServiceBasePrice = row["serviceBasePrice"].ToString(),
                            EventsIds = row["events_ids"].ToString(),
                            PlanID = (Int32.TryParse(row["PlanID"].ToString(), out planid) == true
                            ? planid : 0),
                            PlanName = row["planName"].ToString(),
                            PlanDescription = row["planDescription"].ToString(),
                            PriceFactor = (Double.TryParse(row["price_factor"].ToString(), out priceFactor) == true
                            ? priceFactor : 0),
                            Ips = row["IPs"].ToString(),
                            FirewallID = row["FirewallID"].ToString(),
                            IsSegment = row["is_segment"].ToString().Equals("1") ? true : false,
                            RequestQueueID = (Int32.TryParse(row["RequestQueueID"].ToString(), out requestId) == true
                            ? requestId : 0),
                            ResourceSpecs = row["resource_specs"].ToString(),
                            RequestDatetime= row["request_datetime"].ToString(),
                            SupplyDatetime= row["supply_datetime"].ToString(),
                            DownDatetime= row["down_datetime"].ToString(),
                            SupplyStatusId= (Int32.TryParse(row["supply_status_id"].ToString(), out supplyid) == true
                            ? supplyid : 0),
                            ServiceStatusId= (Int32.TryParse(row["service_status_id"].ToString(), out srvstatusid) == true
                            ? srvstatusid : 0),
                            ErrorLog= row["error_log"].ToString(),
                            Identificator= row["identificator"].ToString(),
                            NameApp= row["name_app"].ToString(),
                            Status= row["status"].ToString(),
                            Port= row["port"].ToString()  ,
                            VcdVcdId = row["vdc_vcd_id"].ToString()
                        };
                        listServices.ContractedService.Add(planItem);
                    }
                }
                else
                    throw new RpcException(new Status(StatusCode.NotFound, "No results for contracted services information"));
            }
            return new AllContractedServices(listServices);

        }

        public override async Task<GetIpServiceByIdResponse> getIpServiceById(GetIpServiceByIdRequest request, ServerCallContext context)
        {
           requestQueue = new ServicesDAO();

           var IdServiceRequest = request.IdFirewall;
           String result = requestQueue.getIpServiceById(IdServiceRequest);

           if (result == null || String.IsNullOrEmpty(result))
           {
               throw new RpcException(new Status(StatusCode.NotFound, "No results for type catalog"));

           }
           cloudServiceDAO resultmessage = new cloudServiceDAO()
           {

               Response = result
           };
           return new GetIpServiceByIdResponse() { Response = resultmessage };

        }

        public override async Task<GetServicesByProductTypeResponse> getServicesCatalog(GetServicesByProductTypeRequest request, ServerCallContext context)
        {
            requestQueue = new ServicesDAO();
            String result = requestQueue.getServicesCatalog(request.IdProductType);

            if (result == null || String.IsNullOrEmpty(result))
            {
                throw new RpcException(new Status(StatusCode.NotFound, "No results for type catalog"));

            }
            cloudServiceDAO resultmessage = new cloudServiceDAO()
            {

                Response = result
            };
            return new GetServicesByProductTypeResponse() { Response = resultmessage };

        }

        /// <summary>
        /// Servicio para almacenar en tabla licenses a partir de un id_usuario
        /// </summary>
        /// <param name="request">Incluye los parametros Specs/form, name/orgname y contracted_services_id</param>
        /// <param name="context"></param>
        /// <returns></returns>
        /// <exception cref="RpcException"></exception>
        public override async Task<SetLicensesResponse> setLicensesService(SetLicensesRequest request, ServerCallContext context)
        {
            requestQueue = new ServicesDAO();

            var Specs = request.Specs;
            var name = request.Name; 
            int contractedServicesId = 0;
            Int32.TryParse(request.ContractedServicesId.ToString(), out contractedServicesId);
            String result = requestQueue.saveLicenses(Specs, contractedServicesId, name);

            if (result == null || String.IsNullOrEmpty(result))
            {
                throw new RpcException(new Status(StatusCode.NotFound, "No results for user/services contracted"));

            }
            cloudServiceDAO resultmessage = new cloudServiceDAO()
            {

                Response = result
            };
            return new SetLicensesResponse() { Response = resultmessage };

        }

        /// <summary>
        /// Servicio para almacenar usuarios en tabla user_vcd
        /// </summary>
        /// <param name="request"></param>
        /// <param name="context"></param>
        /// <returns></returns>
        /// <exception cref="RpcException"></exception>
        public override async Task<SetUserVCDResponse> setUserVCD(SetUserVCDRequest request, ServerCallContext context)
        {
            requestQueue = new ServicesDAO();
            String result = requestQueue.setUserVcd(request.Username, request.Email, request.Orgid);

            if (result == null || String.IsNullOrEmpty(result))
            {
                throw new RpcException(new Status(StatusCode.NotFound, "No results to save user interface"));

            }
            cloudServiceDAO resultmessage = new cloudServiceDAO()
            {

                Response = result
            };
            return new SetUserVCDResponse() { Response = resultmessage };

        }

       public override async Task<UsersVCD> getUserVCD(GetUserVCDRequest request, ServerCallContext context)
        {
            requestQueue = new ServicesDAO();
            var user = new userVCD() ;
            UsersVCD userslist = new UsersVCD();            
            DataTable? result = requestQueue.getUserfromUserName(request.UserName, request.PublicId, request.UserId,
               request.OrgId);
            if (result == null)
                throw new RpcException(new Status(StatusCode.NotFound, "No results for user information"));
            else{
                if (result.Rows.Count > 0)
                {                  
                    foreach (DataRow row in result.Rows)
                    {
                        int apublicID;
                        user = new userVCD()
                        {
                            UserVCDId = Convert.ToInt32(row["UserVcdID"].ToString()),
                            Username = row["username"].ToString(),
                            PublicId = 
                            (Int32.TryParse(row["public_id"].ToString(), out apublicID)==true
                            ? apublicID : 0 ),
                            OrgId = Convert.ToInt32(row["org_id"].ToString()),
                            Password = row["password"].ToString()
                        };
                        userslist.Users.Add(user);
                    }              
                }
                else 
                    throw new RpcException(new Status(StatusCode.NotFound, "No results for user information"));
            }     
            return new UsersVCD(userslist);
        }

        public override async Task<orgsVCD> getOrgVCD(GetOrgVCDRequest request, ServerCallContext context)
        {
            requestQueue = new ServicesDAO();
            orgsVCD listOrgs = new orgsVCD();
        
            DataTable? result = requestQueue.getOrgfromName(request.Name, request.OrgId);
            if (result == null)
                throw new RpcException(new Status(StatusCode.NotFound, "No results for organization information"));
            else
            {
                if (result.Rows.Count > 0)
                {
                    foreach (DataRow row in result.Rows)
                    {
                        orgVCD orgItem  = new orgVCD()
                        {
                            OrgVcdId = Convert.ToInt32(row["OrgVcdID"].ToString()),
                            Name = row["name"].ToString(),
                            Host = row["host"].ToString(),
                            ApiVersion = row["api_version"].ToString()
                        };
                        listOrgs.Orgs.Add(orgItem);
                    }
                }
                else
                    throw new RpcException(new Status(StatusCode.NotFound, "No results for organizations information"));
            }
            return new orgsVCD(listOrgs);

        }

        public override async Task<SetOrgVCDResponse> setOrgVCD(SetOrgVCDRequest request, ServerCallContext context)
        {
            requestQueue = new ServicesDAO();
            String result = requestQueue.setOrgVcd(request.Name, request.Host, request.ApiVersion);

            if (result == null || String.IsNullOrEmpty(result))
            {
                throw new RpcException(new Status(StatusCode.NotFound, "No results to save organization information"));

            }
            cloudServiceDAO resultmessage = new cloudServiceDAO()
            {

                Response = result
            };
            return new SetOrgVCDResponse() { Response = resultmessage };

        }

        public override async Task<AllLicenses> GetLicenses (GetLicensesRequest request, ServerCallContext context)
        {
            requestQueue = new ServicesDAO();
            AllLicenses allLicenses = new AllLicenses();
            DataTable? result = requestQueue.getLicenses(request.Idlicenses, request.PublicId,
                request.OrgId, request.IdService, request.ContractedServicesId);
            if (result == null)
                throw new RpcException(new Status(StatusCode.NotFound, "No results for licenses information"));
            else
            {
                if (result.Rows.Count > 0)
                {
                    foreach (DataRow row in result.Rows)
                    {
                        Int32 public_id = 0;
                        Licenses item = new Licenses()
                        {                           
                            Idlicenses = Convert.ToInt32(row["idlicenses"].ToString()),
                            NameLicenses = row["name_licenses"].ToString(),
                            Specs = row["specs"].ToString(),
                            ContractedServicesId = Convert.ToInt32(row["contracted_services_id"].ToString()),
                            UserId = Convert.ToInt32(row["user_id"].ToString()),
                            PlanId = Convert.ToInt32(row["plan_id"].ToString()),
                            PublicId = Int32.TryParse(row["public_id"].ToString(),out public_id)== true ? public_id : 0,
                            OrgId = Convert.ToInt32(row["org_id"].ToString()),
                            NamePlan = row["name_plan"].ToString(),
                            ServiceId = Convert.ToInt32(row["service_id"].ToString()),
                            NameService = row["name_service"].ToString(),
                            ProductTypeId = Convert.ToInt32(row["product_type_id"].ToString()),
                            ProductName = row["product_name"].ToString()
                        };
                        allLicenses.Licenses.Add(item);
                    }
                }
                else
                    throw new RpcException(new Status(StatusCode.NotFound, "No results for licenses information"));
            }
            return new AllLicenses(allLicenses);
        }
        
        public override async Task<GetGenericInformationResponse> getGenericInformation (GetGenericInformationRequest request, ServerCallContext context)
        {
            requestQueue = new ServicesDAO();
            String result = requestQueue.getDataTablefromClause(request.TabName, request.WcolNameFilter, request.WParam);

            if (result == null || String.IsNullOrEmpty(result))
            {
                throw new RpcException(new Status(StatusCode.NotFound, "No results information"));

            }
            cloudServiceDAO resultmessage = new cloudServiceDAO()
            {

                Response = result
            };
            return new GetGenericInformationResponse() { Response = resultmessage };
        }

        public override async Task<SetUpdateLicensesResponse> setUpdateLicenses(SetUpdateLicensesRequest request, ServerCallContext context)
        {
            requestQueue = new ServicesDAO();
            String result = requestQueue.updateLicenses(request.Idlicenses, request.Name, request.Specs, request.IdContractedServices);

            if (result == null || String.IsNullOrEmpty(result))
            {
                throw new RpcException(new Status(StatusCode.NotFound, "No results to update licenses information"));

            }
            cloudServiceDAO resultmessage = new cloudServiceDAO()
            {

                Response = result
            };
            return new SetUpdateLicensesResponse() { Response = resultmessage };

        }

        public override async Task<AllRequestQueue> getRequestQueueService(GetRequestQueueRequest request, ServerCallContext context)
        {
            requestQueue = new ServicesDAO();
            AllRequestQueue allrequest = new AllRequestQueue();
            DataTable? result = requestQueue.getRequestQueue(request.UserId, request.ServicesId, request.ContractedServicesId
                ,request.ServiceStatusId, request.SupplyDatetimeStart, request.SupplyDatetimeEnd, request.RequestDatetimeStart
                ,request.RequestDatetimeEnd, request.RequestQueueId);
            if (result == null)
                throw new RpcException(new Status(StatusCode.NotFound, "No results for request queue information"));
            else
            {
                if (result.Rows.Count > 0)
                {
                    foreach (DataRow row in result.Rows)
                    {
                        Int32 public_id = 0;
                        Requestqueue item = new Requestqueue()
                        {
                            RequestQueueID = Convert.ToInt32(row["RequestQueueID"].ToString()),
                            ContractedServicesId = Convert.ToInt32(row["contracted_services_id"].ToString()),
                            ResourceSpecs = row["resource_specs"].ToString(),
                            RequestDatetime = row["request_datetime"].ToString(),
                            SupplyDatetime = row["supply_datetime"].ToString(),
                            DownDatetime = row["down_datetime"].ToString(),
                            SupplyStatusId = Int32.TryParse(row["supply_status_id"].ToString(), out public_id) == true ? public_id : 0,
                            ServiceStatusId = Int32.TryParse(row["service_status_id"].ToString(), out public_id) == true ? public_id : 0,
                            ErrorLog = row["error_log"].ToString(),
                            Identificator = row["identificator"].ToString(),
                            NameApp = row["name_app"].ToString(),
                            Status = row["status"].ToString(),
                            Port = Int32.TryParse(row["port"].ToString(), out public_id) == true ? public_id : 0,
                            UserId = Convert.ToInt32(row["user_id"].ToString()),
                            PlanId = Convert.ToInt32(row["plan_id"].ToString()),
                            ServiceId = Convert.ToInt32(row["service_id"].ToString()),
                            ServicesName = row["name"].ToString(),
                            ServicesProductTypeId = Convert.ToInt32(row["product_type_id"].ToString())


                        };
                        allrequest.Requestqueue.Add(item);
                    }
                }
                else
                    throw new RpcException(new Status(StatusCode.NotFound, "No results for request queue information"));
            }
            return new AllRequestQueue(allrequest);
        }

        public override async Task<allfieldsvdc> getfieldsvdc(getfieldsvdcRequest request, ServerCallContext context)
        {
            requestQueue = new ServicesDAO();
            allfieldsvdc allrequest = new allfieldsvdc();
            DataTable? result = requestQueue.getfieldsvdc(request.VdcId, request.OrgId, request.UrnId);
            if (result == null)
                throw new RpcException(new Status(StatusCode.NotFound, "No results for vdc information"));
            else
            {
                if (result.Rows.Count > 0)
                {
                    foreach (DataRow row in result.Rows)
                    {
                        Int32 public_id = 0;
                        fieldvdc item = new fieldvdc()
                        {
                            Id= Convert.ToInt32(row["id"].ToString()),
                            Name = row["name"].ToString(),
                            UrnId = row["urn_id"].ToString(),
                            SubscriptionId = row["subscription_id"].ToString(),
                            OrgId = Convert.ToInt32(row["org_id"].ToString())
                        };
                        allrequest.Fieldvdc.Add(item);
                    }
                }
                else
                    throw new RpcException(new Status(StatusCode.NotFound, "No results for request queue information"));
            }
            return new allfieldsvdc(allrequest);
        }

        public override async Task<setfieldsvdcResponse> setfieldsvdc(setfieldsvdcRequest request, ServerCallContext context)
        {
            requestQueue = new ServicesDAO();
            allfieldsvdc allrequest = new allfieldsvdc();
            String result = requestQueue.setfieldsvdc(request.VdcId , request.Name, request.UrnId, request.SubscriptionId, request.OrgId, request.Active);

            if (result == null || String.IsNullOrEmpty(result))
            {
                throw new RpcException(new Status(StatusCode.NotFound, "No results to update vdc information"));

            }
            cloudServiceDAO resultmessage = new cloudServiceDAO()
            {

                Response = result
            };
            return new setfieldsvdcResponse() { Response = resultmessage };
           
        }

        public override async Task<insertfieldsvdcResponse> insertfieldsvdc(insertfieldsvdcRequest request, ServerCallContext context)
        {
            requestQueue = new ServicesDAO();
            allfieldsvdc allrequest = new allfieldsvdc();
            String result = requestQueue.insertfieldsvdc(request.Name, request.UrnId, request.SubscriptionId, request.OrgId);
            if (result == null || String.IsNullOrEmpty(result))
            {
                throw new RpcException(new Status(StatusCode.NotFound, "No results to update licenses information"));

            }
            cloudServiceDAO resultmessage = new cloudServiceDAO()
            {

                Response = result
            };
            return new insertfieldsvdcResponse() { Response = resultmessage };
        }

        public override async Task<allStatusCatalog> getStatusCatalog(GetStatusCatalogRequest request, ServerCallContext context)
        {
            requestQueue = new ServicesDAO();
            allStatusCatalog allrequest = new allStatusCatalog();
            DataTable? result = requestQueue.getStatusCatalog(request.StatusCatalogId, request.IdType);
            if (result == null)
                throw new RpcException(new Status(StatusCode.NotFound, "No results for vdc information"));
            else
            {
                if (result.Rows.Count > 0)
                {
                    foreach (DataRow row in result.Rows)
                    {
                        Int32 public_id = 0;
                        statusCatalog item = new statusCatalog()
                        {
                            StatusCatalogID = Convert.ToInt32(row["StatusCatalogID"].ToString()),
                            Status = row["status"].ToString(),
                            StatusDesc = row["status_dsc"].ToString(),
                            IdType = Convert.ToInt32(row["id_type"].ToString())
                        };
                        allrequest.StatusCatalog.Add(item);
                    }
                }
                else
                    throw new RpcException(new Status(StatusCode.NotFound, "No results for request queue information"));
            }
            return new allStatusCatalog(allrequest);
        }

        public override async Task<SetUpdateRequestQueueResponse> setUpdateRequestQueue(SetUpdateRequestQueueRequest request, ServerCallContext context)
        {
            requestQueue = new ServicesDAO();
            String result = requestQueue.setRequestQueue(request.ContractedServicesId, request.RequestQueueId,
                request.ResourceSpecs, request.RequestDatetime, request.SupplyDatetime, request.DownDatetime,
                request.SupplyStatusId, request.ServiceStatusId, request.ErrorLog, request.Identificator, request.NameApp,
                request.Status, request.Port);
            if (result == null || String.IsNullOrEmpty(result))
            {
                throw new RpcException(new Status(StatusCode.NotFound, "No results for update request_queue"));

            }
            cloudServiceDAO resultmessage = new cloudServiceDAO
            {

                Response = result
            };
            return new SetUpdateRequestQueueResponse() { Response = resultmessage };


        }

        public override async Task<allConsumptionHistory> getConsumptionHistory(GetConsumptionHistoryRequest request, ServerCallContext context)
        {
            requestQueue = new ServicesDAO();
            allConsumptionHistory allrequest = new allConsumptionHistory();
            DataTable? result = requestQueue.getConsumptionHistory(request.ConsumptionHistoryId,
                request.RequestServicesId, request.StartDate, request.EndDate);
            if (result == null)
                throw new RpcException(new Status(StatusCode.NotFound, "No results for ConsumptionHistory information"));
            else
            {
                if (result.Rows.Count > 0)
                {
                    foreach (DataRow row in result.Rows)
                    {
                        Int32 public_id = 0;
                        consumptionHistory item = new consumptionHistory()
                        {
                            ConsumptionHistoryID = Convert.ToInt32(row["ConsumptionHistoryID"].ToString()),
                            StartDate = row["start_date"].ToString(),
                            EndDate  = row["end_date"].ToString(),
                            RequestsQueueId = Convert.ToInt32(row["requests_queue_id"].ToString()),
                            PodIdentificator= row["pod_identificator"].ToString()
                        };
                        allrequest.ConsumptionHistory.Add(item);
                    }
                }
                else
                    throw new RpcException(new Status(StatusCode.NotFound, "No results for consumption history information"));
            }
            return new allConsumptionHistory(allrequest);
        }

        public override async Task<SetInsertConsumptionHistoryIdentificatorResponse> setInsertConsumptionHistoryIdentificator 
            (SetInsertConsumptionHistoryIdentificatorRequest request, ServerCallContext context)
        {
            requestQueue = new ServicesDAO();
            String result = requestQueue.setInsertConsumptionHistoryIdentificator(
                request.StartDate, request.EndDate, request.Identificator, request.PodIdentificator);
            if (result == null || String.IsNullOrEmpty(result))
            {
                throw new RpcException(new Status(StatusCode.NotFound, "No results for update ConsumptionHistory"));

            }
            cloudServiceDAO resultmessage = new cloudServiceDAO
            {

                Response = result
            };
            return new SetInsertConsumptionHistoryIdentificatorResponse() { Response = resultmessage };


        }

    }

}