public static Domain.AirlineCompany.AirlineCompany Create(AirlineCompanyView view)
        {
            var d = new AirlineCompanyData();

            Copy.Members(view, d);

            return(new Domain.AirlineCompany.AirlineCompany(d));
        }
        private async Task <AirlineCompanyData> AirlineCompanyToData(AirlineCompany airline)
        {
            return(await Task.Run(async() =>
            {
                AirlineCompanyData data = new AirlineCompanyData();
                data.iD = airline.ID;
                data.USER_ID = airline.USER_ID;
                data.Adorning = airline.ADORNING;
                data.AirlineName = airline.AIRLINE_NAME;
                data.BaseCountryName = (await _dao.GetOneById <Country>(airline.COUNTRY_CODE)).COUNTRY_NAME;
                try
                {
                    data.Image = ImageRestorer.GetBitmapFrom64baseString(airline.IMAGE);
                }
                catch (Exception)
                {
                    data.Image = ImageRestorer.GetBitmapFrom64baseString(ImageRestorer.UnformatImage64BaseString(BASE_64_IMAGE_ABSENCE_IMAGE));
                }

                data = await UtilityClassUserTreatent(data, airline) as AirlineCompanyData;
                return data;
            }));
        }
        public async Task <IBasicData> ConversionSelector(IPoco selector, Type selectionType)
        {
            return(await Task.Run(async() =>
            {
                if (!correlation.ContainsKey(selectionType))
                {
                    if (selector is AirlineCompany)
                    {
                        correlation.Add(selectionType, async(selectorToFunc) => { return await AirlineCompanyToData(selectorToFunc as AirlineCompany); });
                    }
                    if (selector is Country)
                    {
                        correlation.Add(selectionType, async(selectorToFunc) => { return await CountryToData(selectorToFunc as Country); });
                    }
                    if (selector is Customer)
                    {
                        correlation.Add(selectionType, async(selectorToFunc) => { return await CustomerToData(selectorToFunc as Customer); });
                    }
                    if (selector is Administrator)
                    {
                        correlation.Add(selectionType, async(selectorToFunc) => { return await AdministratorToData(selectorToFunc as Administrator); });
                    }

                    if (selector is Utility_class_User)
                    {
                        switch ((selector as Utility_class_User).USER_KIND)
                        {
                        case "Administrator":
                            selectionType = typeof(Utility_class_UserAdministratorData);
                            if (!correlation.ContainsKey(selectionType))
                            {
                                correlation.Add(selectionType, async(selectorToFunc) => { return await Task.Run(async() =>
                                    {
                                        Utility_class_UserData baseData = await Utility_class_UserToData(selectorToFunc as Utility_class_User);
                                        Utility_class_UserAdministratorData adminData = FillBasicData(new Utility_class_UserAdministratorData(), baseData) as Utility_class_UserAdministratorData;
                                        if (baseData.administrator != null)
                                        {
                                            AdministratorData administratorData = await AdministratorToData(baseData.administrator);
                                            adminData.AdministratoriD = administratorData.iD;
                                            adminData.Name = administratorData.Name;
                                        }
                                        return adminData;
                                    }); });
                            }

                            break;

                        case "AirlineCompany":
                            selectionType = typeof(Utility_class_UserAirlineCompanyData);
                            if (!correlation.ContainsKey(selectionType))
                            {
                                correlation.Add(selectionType, async(selectorToFunc) => { return await Task.Run(async() =>
                                    {
                                        Utility_class_UserData baseData = await Utility_class_UserToData(selectorToFunc as Utility_class_User);
                                        Utility_class_UserAirlineCompanyData airlineData = FillBasicData(new Utility_class_UserAirlineCompanyData(), baseData) as Utility_class_UserAirlineCompanyData;
                                        if (baseData.airline != null)
                                        {
                                            AirlineCompanyData airlineCompanyData = await AirlineCompanyToData(baseData.airline);
                                            airlineData.AirlineCompanyiD = airlineCompanyData.iD;
                                            airlineData.Adorning = airlineCompanyData.Adorning;
                                            airlineData.Image = airlineCompanyData.Image;
                                            airlineData.AirlineName = airlineCompanyData.AirlineName;
                                            airlineData.BaseCountryName = airlineCompanyData.BaseCountryName;
                                        }
                                        return airlineData;
                                    }); });
                            }
                            break;

                        case "Customer":
                            selectionType = typeof(Utility_class_UserCustomerData);
                            if (!correlation.ContainsKey(selectionType))
                            {
                                correlation.Add(selectionType, async(selectorToFunc) => { return await Task.Run(async() =>
                                    {
                                        Utility_class_UserData baseData = await Utility_class_UserToData(selectorToFunc as Utility_class_User);
                                        Utility_class_UserCustomerData customerData = FillBasicData(new Utility_class_UserCustomerData(), baseData) as Utility_class_UserCustomerData;
                                        if (baseData.customer != null)
                                        {
                                            CustomerData currentCustomerData = await CustomerToData(baseData.customer);
                                            customerData.CustomeriD = currentCustomerData.iD;
                                            customerData.FirstName = currentCustomerData.FirstName;
                                            customerData.LastName = currentCustomerData.LastName;
                                            customerData.Address = currentCustomerData.Address;
                                            customerData.Phone_Num = currentCustomerData.Phone_Num;
                                            customerData.Credit_Card = currentCustomerData.Credit_Card;
                                            customerData.Image = currentCustomerData.Image;
                                        }
                                        return customerData;
                                    }); });
                            }
                            break;
                        }
                    }
                }

                var retVal = await correlation[selectionType](selector);
                return retVal;//await correlation[selectionType](selector);
            }));
        }