public async Task <ReturnedSaveFuncInfo> SaveAsync(BuildingRelatedOptionsBussines item, SqlTransaction tr)
        {
            var res = new ReturnedSaveFuncInfo();

            try
            {
                var cmd = new SqlCommand("sp_BuildingRelatedOptopn_Save", tr.Connection, tr)
                {
                    CommandType = CommandType.StoredProcedure
                };
                cmd.Parameters.AddWithValue("@guid", item.Guid);
                cmd.Parameters.AddWithValue("@buOptionGuid", item.BuildingOptionGuid);
                cmd.Parameters.AddWithValue("@modif", item.Modified);
                cmd.Parameters.AddWithValue("@buGuid", item.BuildinGuid);
                cmd.Parameters.AddWithValue("@serverSt", (short)item.ServerStatus);
                cmd.Parameters.AddWithValue("@serverDate", item.ServerDeliveryDate);

                await cmd.ExecuteNonQueryAsync();
            }
            catch (Exception ex)
            {
                WebErrorLog.ErrorInstence.StartErrorLog(ex);
                res.AddReturnedValue(ex);
            }

            return(res);
        }
        public async Task <BuildingRelatedOptionsBussines> GetAsync(string _connectionString, Guid guid)
        {
            var list = new BuildingRelatedOptionsBussines();

            try
            {
                using (var cn = new SqlConnection(_connectionString))
                {
                    var cmd = new SqlCommand("sp_BuildingRelatedOption_Get", cn)
                    {
                        CommandType = CommandType.StoredProcedure
                    };
                    cmd.Parameters.AddWithValue("@guid", guid);
                    await cn.OpenAsync();

                    var dr = await cmd.ExecuteReaderAsync();

                    if (dr.Read())
                    {
                        list = LoadData(dr);
                    }
                    cn.Close();
                }
            }
            catch (Exception exception)
            {
                WebErrorLog.ErrorInstence.StartErrorLog(exception);
            }

            return(list);
        }
        public static async Task <ReturnedSaveFuncInfo> SaveAsync(BuildingRelatedOptionsBussines cls)
        {
            var res = new ReturnedSaveFuncInfo();

            try
            {
                var obj = new WebBuildingRelatedOptions()
                {
                    Guid               = cls.Guid,
                    HardSerial         = cls.HardSerial,
                    BuildingOptionGuid = cls.BuildingOptionGuid,
                    BuildinGuid        = cls.BuildinGuid,
                    Modified           = cls.Modified,
                    ServerStatus       = cls.ServerStatus,
                    ServerDeliveryDate = cls.ServerDeliveryDate
                };
                await obj.SaveAsync();
            }
            catch (Exception ex)
            {
                WebErrorLog.ErrorInstence.StartErrorLog(ex);
                res.AddReturnedValue(ex);
            }

            return(res);
        }
        private BuildingRelatedOptionsBussines LoadData(SqlDataReader dr)
        {
            var res = new BuildingRelatedOptionsBussines();

            try
            {
                res.Guid               = (Guid)dr["Guid"];
                res.Modified           = (DateTime)dr["Modified"];
                res.BuildinGuid        = (Guid)dr["BuildinGuid"];
                res.BuildingOptionGuid = (Guid)dr["BuildingOptionGuid"];
                res.ServerDeliveryDate = (DateTime)dr["ServerDeliveryDate"];
                res.ServerStatus       = (ServerStatus)dr["ServerStatus"];
            }
            catch (Exception ex)
            {
                WebErrorLog.ErrorInstence.StartErrorLog(ex);
            }

            return(res);
        }
Beispiel #5
0
        private static async Task StartSendToServerAsync()
        {
            try
            {
                var list = await TempBussines.GetAllAsync();

                while (true)
                {
                    if (list == null || list.Count <= 0)
                    {
                        await Task.Delay(2000);

                        continue;
                    }
                    foreach (var item in list)
                    {
                        switch (item.Type)
                        {
                        case EnTemp.States:
                            var states = await StatesBussines.GetAsync(item.ObjectGuid);

                            if (states != null)
                            {
                                await WebStates.SaveAsync(states);
                            }
                            break;

                        case EnTemp.Cities:
                            var city = await CitiesBussines.GetAsync(item.ObjectGuid);

                            if (city != null)
                            {
                                await WebCity.SaveAsync(city);
                            }
                            break;

                        case EnTemp.Region:
                            var region = await RegionsBussines.GetAsync(item.ObjectGuid);

                            if (region != null)
                            {
                                await WebRegion.SaveAsync(region);
                            }
                            break;

                        case EnTemp.Users:
                            var user = await UserBussines.GetAsync(item.ObjectGuid);

                            if (user != null)
                            {
                                await WebUser.SaveAsync(user);
                            }
                            break;

                        case EnTemp.PeopleGroups:
                            var pg = await PeopleGroupBussines.GetAsync(item.ObjectGuid);

                            if (pg != null)
                            {
                                await WebPeopleGroup.SaveAsync(pg);
                            }
                            break;

                        case EnTemp.Peoples:
                            var p = await PeoplesBussines.GetAsync(item.ObjectGuid);

                            if (p != null)
                            {
                                await WebPeople.SaveAsync(p);
                            }
                            break;

                        case EnTemp.BuildingAccountType:
                            var acc = await BuildingAccountTypeBussines.GetAsync(item.ObjectGuid);

                            if (acc != null)
                            {
                                await WebBuildingAccountType.SaveAsync(acc);
                            }
                            break;

                        case EnTemp.BuildingCondition:
                            var co = await BuildingConditionBussines.GetAsync(item.ObjectGuid);

                            if (co != null)
                            {
                                await WebBuildingCondition.SaveAsync(co);
                            }
                            break;

                        case EnTemp.BuildingType:
                            var type = await BuildingTypeBussines.GetAsync(item.ObjectGuid);

                            if (type != null)
                            {
                                await WebBuildingType.SaveAsync(type);
                            }
                            break;

                        case EnTemp.BuildingView:
                            var view = await BuildingViewBussines.GetAsync(item.ObjectGuid);

                            if (view != null)
                            {
                                await WebBuildingView.SaveAsync(view);
                            }
                            break;

                        case EnTemp.DocumentType:
                            var doc = await DocumentTypeBussines.GetAsync(item.ObjectGuid);

                            if (doc != null)
                            {
                                await WebDocumentType.SaveAsync(doc);
                            }
                            break;

                        case EnTemp.FloorCover:
                            var fc = await FloorCoverBussines.GetAsync(item.ObjectGuid);

                            if (fc != null)
                            {
                                await WebFloorCover.SaveAsync(fc);
                            }
                            break;

                        case EnTemp.KitchenService:
                            var ks = await KitchenServiceBussines.GetAsync(item.ObjectGuid);

                            if (ks != null)
                            {
                                await WebKitchenService.SaveAsync(ks);
                            }
                            break;

                        case EnTemp.RentalAuthority:
                            var ra = await RentalAuthorityBussines.GetAsync(item.ObjectGuid);

                            if (ra != null)
                            {
                                await WebRental.SaveAsync(ra);
                            }
                            break;

                        case EnTemp.BuildingOptions:
                            var o = await BuildingOptionsBussines.GetAsync(item.ObjectGuid);

                            if (o != null)
                            {
                                await WebBuildingOptions.SaveAsync(o);
                            }
                            break;

                        case EnTemp.Building:
                            var bu = await BuildingBussines.GetAsync(item.ObjectGuid);

                            if (bu != null)
                            {
                                await WebBuilding.SaveAsync(bu, Application.StartupPath);
                            }
                            break;

                        case EnTemp.Contract:
                            var con = await ContractBussines.GetAsync(item.ObjectGuid);

                            if (con != null)
                            {
                                await WebContract.SaveAsync(con);
                            }
                            break;

                        case EnTemp.Requests:
                            var req = await BuildingRequestBussines.GetAsync(item.ObjectGuid);

                            if (req != null)
                            {
                                await WebBuildingRequest.SaveAsync(req);
                            }
                            break;

                        case EnTemp.Reception:
                            var rec = await ReceptionBussines.GetAsync(item.ObjectGuid);

                            if (rec != null)
                            {
                                await WebReception.SaveAsync(rec);
                            }
                            break;

                        case EnTemp.Pardakht:
                            var pa = await PardakhtBussines.GetAsync(item.ObjectGuid);

                            if (pa != null)
                            {
                                await WebPardakht.SaveAsync(pa);
                            }
                            break;

                        case EnTemp.BuildingRelatedOptions:
                            var re = await BuildingRelatedOptionsBussines.GetAsync(item.ObjectGuid);

                            if (re != null)
                            {
                                await WebBuildingRelatedOptions.SaveAsync(re);
                            }
                            break;

                        case EnTemp.RequestRegions:
                            var rr = await BuildingRequestRegionBussines.GetAsync(item.ObjectGuid);

                            if (rr != null)
                            {
                                await WebBuildingRequestRegion.SaveAsync(rr);
                            }
                            break;

                        case EnTemp.PhoneBook:
                            var ph = await PhoneBookBussines.GetAsync(item.ObjectGuid);

                            if (ph != null)
                            {
                                await WebPhoneBook.SaveAsync(ph);
                            }
                            break;

                        case EnTemp.Advisor:
                            var ad = await AdvisorBussines.GetAsync(item.ObjectGuid);

                            if (ad != null)
                            {
                                await WebAdvisor.SaveAsync(ad);
                            }
                            break;

                        case EnTemp.Bank:
                            var ba = await BankBussines.GetAsync(item.ObjectGuid);

                            if (ba != null)
                            {
                                await WebBank.SaveAsync(ba);
                            }
                            break;

                        case EnTemp.Kol:
                            var kol = await KolBussines.GetAsync(item.ObjectGuid);

                            if (kol != null)
                            {
                                await WebKol.SaveAsync(kol);
                            }
                            break;

                        case EnTemp.Moein:
                            var moein = await MoeinBussines.GetAsync(item.ObjectGuid);

                            if (moein != null)
                            {
                                await WebMoein.SaveAsync(moein);
                            }
                            break;

                        case EnTemp.Tafsil:
                            var tafsil = await TafsilBussines.GetAsync(item.ObjectGuid);

                            if (tafsil != null)
                            {
                                await WebTafsil.SaveAsync(tafsil);
                            }
                            break;

                        case EnTemp.Sanad:
                            var sa = await SanadBussines.GetAsync(item.ObjectGuid);

                            if (sa != null)
                            {
                                await WebSanad.SaveAsync(sa);
                            }
                            break;

                        case EnTemp.SanadDetail:
                            var saD = await SanadDetailBussines.GetAsync(item.ObjectGuid);

                            if (saD != null)
                            {
                                await WebSanadDetail.SaveAsync(saD);
                            }
                            break;
                        }

                        await item.RemoveAsync();
                    }

                    await Task.Delay(2000);

                    list = await TempBussines.GetAllAsync();
                }
            }
            catch (Exception ex)
            {
                WebErrorLog.ErrorInstence.StartErrorLog(ex);
            }
        }
        private BuildingBussines LoadData(SqlDataReader dr)
        {
            var res = new BuildingBussines();

            try
            {
                res.Guid         = (Guid)dr["Guid"];
                res.OwnerGuid    = (Guid)dr["OwnerGuid"];
                res.SellPrice    = (decimal)dr["SellPrice"];
                res.Modified     = (DateTime)dr["Modified"];
                res.Status       = (bool)dr["Status"];
                res.Code         = dr["Code"].ToString();
                res.VamPrice     = (decimal)dr["VamPrice"];
                res.QestPrice    = (decimal)dr["QestPrice"];
                res.Dang         = (int)dr["Dang"];
                res.DocumentType = (Guid)dr["DocumentType"];
                var tr = dr["Tarakom"].ToString().ParseToShort();
                res.Tarakom     = (EnTarakom?)tr;
                res.RahnPrice1  = (decimal)dr["RahnPrice1"];
                res.RahnPrice2  = (decimal)dr["RahnPrice2"];
                res.EjarePrice1 = (decimal)dr["EjarePrice1"];
                res.EjarePrice2 = (decimal)dr["EjarePrice2"];
                if (dr["RentalAutorityGuid"] != DBNull.Value)
                {
                    res.RentalAutorityGuid = (Guid?)dr["RentalAutorityGuid"];
                }
                res.IsShortTime    = (bool)dr["IsShortTime"];
                res.IsOwnerHere    = (bool)dr["IsOwnerHere"];
                res.PishTotalPrice = (decimal)dr["PishTotalPrice"];
                res.PishPrice      = (decimal)dr["PishPrice"];
                if (dr["DeliveryDate"] != DBNull.Value)
                {
                    res.DeliveryDate = (DateTime?)dr["DeliveryDate"];
                }
                res.PishDesc              = dr["PishDesc"].ToString();
                res.MoavezeDesc           = dr["MoavezeDesc"].ToString();
                res.MosharekatDesc        = dr["MosharekatDesc"].ToString();
                res.UserGuid              = (Guid)dr["UserGuid"];
                res.Masahat               = (int)dr["Masahat"];
                res.ZirBana               = (int)dr["ZirBana"];
                res.CityGuid              = (Guid)dr["CityGuid"];
                res.RegionGuid            = (Guid)dr["RegionGuid"];
                res.Address               = dr["Address"].ToString();
                res.BuildingConditionGuid = (Guid)dr["BuildingConditionGuid"];
                res.Side                    = (EnBuildingSide)dr["Side"];
                res.BuildingTypeGuid        = (Guid)dr["BuildingTypeGuid"];
                res.ShortDesc               = dr["ShortDesc"].ToString();
                res.BuildingAccountTypeGuid = (Guid)dr["BuildingAccountTypeGuid"];
                res.MetrazhTejari           = (float)dr["MetrazhTejari"];
                res.BuildingViewGuid        = (Guid)dr["BuildingViewGuid"];
                res.FloorCoverGuid          = (Guid)dr["FloorCoverGuid"];
                res.KitchenServiceGuid      = (Guid)dr["KitchenServiceGuid"];
                res.Water                   = (EnKhadamati)dr["Water"];
                res.Barq                    = (EnKhadamati)dr["Barq"];
                res.Gas                     = (EnKhadamati)dr["Gas"];
                res.Tell                    = (EnKhadamati)dr["Tell"];
                res.TedadTabaqe             = (int)dr["TedadTabaqe"];
                res.TabaqeNo                = (int)dr["TabaqeNo"];
                res.VahedPerTabaqe          = (int)dr["VahedPerTabaqe"];
                res.MetrazhKouche           = (float)dr["MetrazhKouche"];
                res.ErtefaSaqf              = (float)dr["ErtefaSaqf"];
                res.Hashie                  = (float)dr["Hashie"];
                res.SaleSakht               = dr["SaleSakht"].ToString();
                res.DateParvane             = dr["DateParvane"].ToString();
                res.ParvaneSerial           = dr["ParvaneSerial"].ToString();
                res.BonBast                 = (bool)dr["BonBast"];
                res.MamarJoda               = (bool)dr["MamarJoda"];
                res.RoomCount               = (int)dr["RoomCount"];
                res.CreateDate              = (DateTime)dr["CreateDate"];
                res.Image                   = dr["Image"].ToString();
                res.Priority                = (EnBuildingPriority)dr["Priority"];
                res.IsArchive               = (bool)dr["IsArchive"];
                res.GalleryList             = AsyncContext.Run(() => BuildingGalleryBussines.GetAllAsync(res.Guid));
                res.OptionList              = BuildingRelatedOptionsBussines.GetAll(res.Guid);
                res.ServerDeliveryDate      = (DateTime)dr["ServerDeliveryDate"];
                res.ServerStatus            = (ServerStatus)dr["ServerStatus"];
                res.OwnerName               = dr["OwnerName"].ToString();
                res.BuildingTypeName        = dr["BuildingTypeName"].ToString();
                res.UserName                = dr["UserName"].ToString();
                res.RegionName              = dr["RegionName"].ToString();
                res.RentalAuthorityName     = dr["RentalAuthorityName"].ToString();
                res.DocumentTypeName        = dr["DocumentTypeName"].ToString();
                res.BuildingConditionName   = dr["BuildingConditionName"].ToString();
                res.BuildingViewName        = dr["BuildingViewName"].ToString();
                res.FloorCoverName          = dr["FloorCoverName"].ToString();
                res.KitchenServiceName      = dr["KitchenServiceName"].ToString();
                res.BuildingAccountTypeName = dr["BuildingAccountTypeName"].ToString();
                res.IsModified              = true;
            }
            catch (Exception ex)
            {
                WebErrorLog.ErrorInstence.StartErrorLog(ex);
            }

            return(res);
        }