示例#1
0
        public static bool CancelEmployeeIdByEmployeeId(string employeeId)
        {
            if (employeeId.IsEmpty())
            {
                throw new ArgumentNullException("employeeId");
            }

            IBaseCard factory = BaseCardFactory.GetFactory();

            using (DbOperator dbOperator = ConnectionManager.CreateConnection())
            {
                try
                {
                    dbOperator.BeginTransaction();
                    bool result = factory.CancelEmployeeIdByEmployeeId(employeeId, dbOperator);
                    if (!result)
                    {
                        throw new MyException("取消卡绑定用户信息失败");
                    }
                    dbOperator.CommitTransaction();
                    return(result);
                }
                catch
                {
                    dbOperator.RollbackTransaction();
                    throw;
                }
            }
        }
示例#2
0
        public bool DeleteBySellerID(string sellerId)
        {
            List <ParkDerate> models = QueryBySellerID(sellerId);

            if (models.Count == 0)
            {
                return(true);
            }

            using (DbOperator dbOperator = ConnectionManager.CreateConnection())
            {
                try
                {
                    dbOperator.BeginTransaction();
                    bool result = CommonDelete("ParkDerate", "SellerID", sellerId, dbOperator);
                    if (!result)
                    {
                        throw new MyException("删除优免信息失败");
                    }

                    foreach (var item in models)
                    {
                        CommonDelete("ParkDerateIntervar", "DerateID", item.DerateID, dbOperator);
                    }
                    dbOperator.CommitTransaction();
                    return(result);
                }
                catch
                {
                    dbOperator.RollbackTransaction();
                    throw;
                }
            }
        }
示例#3
0
 /// <summary>
 /// 修改通道规则
 /// </summary>
 /// <param name="model"></param>
 /// <returns></returns>
 public static bool UpdateIOTime(List <ParkGateIOTime> list)
 {
     if (list == null || list.Count == 0)
     {
         throw new ArgumentNullException("list");
     }
     using (DbOperator dbOperator = ConnectionManager.CreateConnection())
     {
         try
         {
             dbOperator.BeginTransaction();
             foreach (var model in list)
             {
                 IParkGate factory = ParkGateFactory.GetFactory();
                 bool      result  = factory.UpdateIOTime(model, dbOperator);
                 if (!result)
                 {
                     throw new MyException("修改通道规则失败");
                 }
             }
             dbOperator.CommitTransaction();
         }
         catch
         {
             dbOperator.RollbackTransaction();
             throw;
         }
     }
     OperateLogServices.AddOperateLog <List <ParkGateIOTime> >(list, OperateType.Update);
     return(true);
 }
示例#4
0
        public static bool Add(List <SysScopeAuthorize> models)
        {
            if (models == null || models.Count == 0)
            {
                throw new ArgumentNullException("models");
            }

            ISysScopeAuthorize factory = SysScopeAuthorizeFactory.GetFactory();

            using (DbOperator dbOperator = ConnectionManager.CreateConnection())
            {
                try
                {
                    dbOperator.BeginTransaction();
                    bool result = factory.DeleteByScopeId(models.First().ASID, dbOperator);
                    result = factory.Add(models, dbOperator);
                    if (!result)
                    {
                        throw new MyException("保存失败");
                    }
                    dbOperator.CommitTransaction();
                    return(true);
                }
                catch
                {
                    dbOperator.RollbackTransaction();
                    throw;
                }
            }
        }
示例#5
0
        public static bool AddOrUpdateIOTime(List <ParkGateIOTime> list)
        {
            if (list == null || list.Count == 0)
            {
                throw new ArgumentNullException("list");
            }

            IParkGate             factory      = ParkGateFactory.GetFactory();
            List <ParkGateIOTime> models       = factory.QueryGateIOTime(list.First().GateID);
            List <ParkGateIOTime> updateModels = new List <ParkGateIOTime>();
            List <ParkGateIOTime> addModels    = new List <ParkGateIOTime>();

            using (DbOperator dbOperator = ConnectionManager.CreateConnection())
            {
                try
                {
                    dbOperator.BeginTransaction();
                    foreach (var item in list)
                    {
                        ParkGateIOTime model = models.FirstOrDefault(p => p.RuleType == 0 && p.WeekIndex == item.WeekIndex);
                        if (model != null)
                        {
                            model.StartTime  = item.StartTime;
                            model.EndTime    = item.EndTime;
                            model.InOutState = item.InOutState;
                            bool result = factory.UpdateIOTime(model, dbOperator);
                            if (!result)
                            {
                                throw new MyException("修改星期规则失败");
                            }
                            updateModels.Add(model);
                        }
                        else
                        {
                            item.RecordID = GuidGenerator.GetGuid().ToString();
                            bool result = factory.AddIOTime(item, dbOperator);
                            if (!result)
                            {
                                throw new MyException("添加星期规则失败");
                            }
                            addModels.Add(item);
                        }
                    }
                    dbOperator.CommitTransaction();
                }
                catch {
                    dbOperator.RollbackTransaction();
                    throw;
                }
            }
            if (updateModels.Count > 0)
            {
                OperateLogServices.AddOperateLog <List <ParkGateIOTime> >(updateModels, OperateType.Update);
            }
            if (addModels.Count > 0)
            {
                OperateLogServices.AddOperateLog <List <ParkGateIOTime> >(addModels, OperateType.Add);
            }
            return(true);
        }
示例#6
0
        public static bool Add(List <SysRoleAuthorize> models)
        {
            if (models == null || models.Count == 0)
            {
                throw new ArgumentNullException("models");
            }

            ISysRoleAuthorize factory = SysRoleAuthorizeFactory.GetFactory();

            using (DbOperator dbOperator = ConnectionManager.CreateConnection())
            {
                try
                {
                    dbOperator.BeginTransaction();
                    bool result = factory.DeleteByRoleId(models.First().RoleID, dbOperator);
                    result = factory.Add(models, dbOperator);
                    if (!result)
                    {
                        throw new MyException("保存失败");
                    }
                    dbOperator.CommitTransaction();
                    OperateLogServices.AddOperateLog(OperateType.Delete, string.Format("RoleId:{0}", models.First().RoleID));
                    OperateLogServices.AddOperateLog(OperateType.Add, string.Format("RecordIds:{0}", string.Join(",", models.Select(p => p.RecordID))));
                    return(true);
                }
                catch
                {
                    dbOperator.RollbackTransaction();
                    throw;
                }
            }
        }
示例#7
0
        public static bool Recharge(string cardId, decimal balance)
        {
            if (cardId.IsEmpty())
            {
                throw new ArgumentNullException("cardId");
            }
            if (balance <= 0)
            {
                throw new ArgumentNullException("balance");
            }

            IBaseCard factory = BaseCardFactory.GetFactory();

            using (DbOperator dbOperator = ConnectionManager.CreateConnection())
            {
                try
                {
                    dbOperator.BeginTransaction();
                    bool result = factory.Recharge(cardId, balance, dbOperator);
                    if (!result)
                    {
                        throw new MyException("卡片充值失败");
                    }
                    dbOperator.CommitTransaction();
                    return(result);
                }
                catch
                {
                    dbOperator.RollbackTransaction();
                    throw;
                }
            }
        }
示例#8
0
        public static bool Add(List <ParkCarDerate> models)
        {
            if (models == null || models.Count == 0)
            {
                throw new ArgumentNullException("models");
            }

            IParkCarDerate factory = ParkCarDerateFactory.GetFactory();

            using (DbOperator dbOperator = ConnectionManager.CreateConnection())
            {
                try
                {
                    dbOperator.BeginTransaction();
                    foreach (var item in models)
                    {
                        bool result = factory.Add(item, dbOperator);
                        if (!result)
                        {
                            throw new MyException("保存失败");
                        }
                    }
                    dbOperator.CommitTransaction();
                    return(true);
                }
                catch {
                    dbOperator.RollbackTransaction();
                    throw;
                }
            }
        }
示例#9
0
 public bool Add(ParkFeeRule model)
 {
     using (DbOperator dbOperator = ConnectionManager.CreateConnection())
     {
         try
         {
             dbOperator.BeginTransaction();
             bool result = AddFeeRule(model, dbOperator);
             if (!result)
             {
                 throw new MyException("添加收费规则失败");
             }
             result = AddFeeRuleDetails(model.ParkFeeRuleDetails, dbOperator);
             if (!result)
             {
                 throw new MyException("添加收费规则明细失败");
             }
             dbOperator.CommitTransaction();
             return(true);
         }
         catch
         {
             dbOperator.RollbackTransaction();
             throw;
         }
     }
 }
示例#10
0
        public static bool Delete(string cardId)
        {
            if (cardId.IsEmpty())
            {
                throw new ArgumentNullException("cardId");
            }

            IBaseCard factory = BaseCardFactory.GetFactory();

            using (DbOperator dbOperator = ConnectionManager.CreateConnection())
            {
                try
                {
                    dbOperator.BeginTransaction();
                    bool result = factory.Delete(cardId, dbOperator);
                    if (!result)
                    {
                        throw new MyException("删除卡失败");
                    }
                    dbOperator.CommitTransaction();
                    return(result);
                }
                catch
                {
                    dbOperator.RollbackTransaction();
                    throw;
                }
            }
        }
示例#11
0
        public static bool Add(BaseCard model)
        {
            if (model == null)
            {
                throw new ArgumentNullException("model");
            }

            using (DbOperator dbOperator = ConnectionManager.CreateConnection())
            {
                try
                {
                    dbOperator.BeginTransaction();
                    IBaseCard factory = BaseCardFactory.GetFactory();
                    model.CardID = GuidGenerator.GetGuidString();
                    bool result = factory.Add(model, dbOperator);
                    if (!result)
                    {
                        throw new MyException("添加卡信息失败");
                    }
                    dbOperator.CommitTransaction();
                    return(result);
                }
                catch {
                    dbOperator.RollbackTransaction();
                    throw;
                }
            }
        }
示例#12
0
 public bool Delete(string feeRuleId)
 {
     using (DbOperator dbOperator = ConnectionManager.CreateConnection())
     {
         try
         {
             dbOperator.BeginTransaction();
             bool result = CommonDelete("ParkFeeRule", "FeeRuleID", feeRuleId, dbOperator);
             if (!result)
             {
                 throw new MyException("删除收费规则失败");
             }
             result = CommonDelete("ParkFeeRuleDetail", "RuleID", feeRuleId, dbOperator);
             if (!result)
             {
                 throw new MyException("删除收费规则明细失败");
             }
             dbOperator.CommitTransaction();
             return(true);
         }
         catch
         {
             dbOperator.RollbackTransaction();
             throw;
         }
     }
 }
示例#13
0
        public static WX_Info AddOrGetWXInfo(WX_Info model)
        {
            IWXAccount factory  = WXAccountFactory.GetFactory();
            WX_Info    oldModel = factory.QueryWXInfoByMobilePhone(model.MobilePhone, model.CompanyID);

            if (oldModel == null)
            {
                using (DbOperator dbOperator = ConnectionManager.CreateReadConnection())
                {
                    try
                    {
                        dbOperator.BeginTransaction();
                        bool result = factory.AddWXAccount(model, dbOperator);
                        if (!result)
                        {
                            throw new MyException("添加微信账号信息失败");
                        }
                        result = factory.AddWXInfo(model, dbOperator);
                        if (!result)
                        {
                            throw new MyException("添加微信信息失败");
                        }
                        dbOperator.CommitTransaction();
                    }
                    catch {
                        dbOperator.RollbackTransaction();
                        throw;
                    }
                }
            }
            return(factory.QueryWXInfoByMobilePhone(model.MobilePhone, model.CompanyID));
        }
示例#14
0
        public static bool Delete(string employeeId)
        {
            if (string.IsNullOrWhiteSpace(employeeId))
            {
                throw new ArgumentNullException("employeeId");
            }
            IBaseEmployee  factory      = BaseEmployeeFactory.GetFactory();
            IEmployeePlate platefactory = EmployeePlateFactory.GetFactory();

            using (DbOperator dbOperator = ConnectionManager.CreateConnection())
            {
                try
                {
                    dbOperator.BeginTransaction();
                    //删除车牌
                    bool result = platefactory.DeleteByEmployeeId(employeeId, dbOperator);
                    if (!result)
                    {
                        throw new MyException("删除车牌失败");
                    }
                    //删授权表
                    result = factory.Delete(employeeId, dbOperator);
                    if (!result)
                    {
                        throw new MyException("删除人员信息失败");
                    }
                    dbOperator.CommitTransaction();
                    return(result);
                }
                catch {
                    dbOperator.RollbackTransaction();
                    throw;
                }
            }
        }
示例#15
0
        public static bool Create(List <WX_Article> models)
        {
            if (models == null || models.Count == 0)
            {
                throw new ArgumentNullException("models");
            }

            IWXArticle factory = WXArticleFactory.GetFactory();

            using (DbOperator dbOperator = ConnectionManager.CreateConnection()) {
                try
                {
                    dbOperator.BeginTransaction();

                    factory.DeleteByGroupID(models.First().GroupID, dbOperator);
                    foreach (var item in models)
                    {
                        bool result = factory.Create(item, dbOperator);
                        if (!result)
                        {
                            throw new MyException("添加图文失败");
                        }
                        OperateLogServices.AddOperateLog <WX_Article>(item, OperateType.Add);
                    }

                    dbOperator.CommitTransaction();
                    return(true);
                }
                catch {
                    dbOperator.RollbackTransaction();
                    throw;
                }
            }
        }
示例#16
0
 public bool Add(VisitorInfo model)
 {
     using (DbOperator dbOperator = ConnectionManager.CreateConnection())
     {
         try
         {
             dbOperator.BeginTransaction();
             dbOperator.ClearParameters();
             bool result = AddVisitorInfo(model, dbOperator);
             if (!result)
             {
                 throw new MyException("保存访客信息失败");
             }
             if (model.ParkVisitors != null && model.ParkVisitors.Count > 0)
             {
                 foreach (var item in model.ParkVisitors)
                 {
                     dbOperator.ClearParameters();
                     result = AddVisitorCar(item, dbOperator);
                     if (!result)
                     {
                         throw new MyException("保存访客车辆信息失败");
                     }
                 }
             }
             dbOperator.CommitTransaction();
             return(result);
         }
         catch
         {
             dbOperator.RollbackTransaction();
             throw;
         }
     }
 }
示例#17
0
        public bool Update(ParkDerate model)
        {
            using (DbOperator dbOperator = ConnectionManager.CreateConnection())
            {
                try
                {
                    dbOperator.BeginTransaction();
                    bool result = Update(model, dbOperator);
                    if (!result)
                    {
                        throw new MyException("修改优免信息失败");
                    }

                    CommonDelete("ParkDerateIntervar", "DerateID", model.DerateID, dbOperator);

                    result = AddDerateIntervar(model.DerateIntervar, dbOperator);
                    if (!result)
                    {
                        throw new MyException("添加优免时段信息失败");
                    }

                    dbOperator.CommitTransaction();
                    return(result);
                }
                catch
                {
                    dbOperator.RollbackTransaction();
                    throw;
                }
            }
        }
示例#18
0
        public bool Add(ParkDerate model)
        {
            using (DbOperator dbOperator = ConnectionManager.CreateConnection())
            {
                try
                {
                    dbOperator.BeginTransaction();
                    bool result = Add(model, dbOperator);
                    if (!result)
                    {
                        throw new MyException("保存优免信息失败");
                    }

                    result = AddDerateIntervar(model.DerateIntervar, dbOperator);
                    if (!result)
                    {
                        throw new MyException("保存优免时段信息失败");
                    }

                    dbOperator.CommitTransaction();
                    return(result);
                }
                catch {
                    dbOperator.RollbackTransaction();
                    throw;
                }
            }
        }
示例#19
0
        private static bool SyncSellerRecharge(OnlineOrder order, OrderPayWay payWay)
        {
            using (DbOperator dbOperator = ConnectionManager.CreateConnection())
            {
                IParkSeller factory = ParkSellerFactory.GetFactory();
                ParkSeller  model   = factory.QueryBySellerId(order.InOutID);
                if (model == null)
                {
                    throw new MyException("商家不存在");
                }

                dbOperator.BeginTransaction();
                try
                {
                    ParkOrder pkOrder = ParkOrderServices.MarkSellerChargeOrder(model, order.Amount, model.SellerID, OrderSource.WeiXin, payWay, dbOperator);
                    if (order == null)
                    {
                        throw new MyException("创建充值订单失败");
                    }

                    bool result = factory.SellerRecharge(model.SellerID, order.Amount, dbOperator);
                    if (!result)
                    {
                        throw new MyException("商家充值失败");
                    }
                    dbOperator.CommitTransaction();
                    return(result);
                }
                catch (Exception ex) {
                    dbOperator.RollbackTransaction();
                    ExceptionsServices.AddExceptions(ex, "商家微信充值通知失败,订单编号:" + order.OrderID);
                    return(false);
                }
            }
        }
示例#20
0
        public static bool Update(BaseCard model)
        {
            if (model == null)
            {
                throw new ArgumentNullException("model");
            }

            IBaseCard factory = BaseCardFactory.GetFactory();

            using (DbOperator dbOperator = ConnectionManager.CreateConnection())
            {
                try
                {
                    dbOperator.BeginTransaction();
                    bool result = factory.Update(model, dbOperator);
                    if (!result)
                    {
                        throw new MyException("修改卡信息失败");
                    }
                    dbOperator.CommitTransaction();
                    return(result);
                }
                catch
                {
                    dbOperator.RollbackTransaction();
                    throw;
                }
            }
        }
示例#21
0
        /// <summary>
        /// 月租车恢复使用
        /// </summary>
        /// <param name="cardGrantId"></param>
        /// <returns></returns>
        public static bool CarRestoreUse(string grantId)
        {
            IParkGrant factory = ParkGrantFactory.GetFactory();
            ParkGrant  grant   = factory.QueryByGrantId(grantId);

            if (grant == null)
            {
                throw new MyException("获取授权信息失败");
            }
            if (grant.State == ParkGrantState.Normal)
            {
                return(true);
            }

            ParkCarType carType = ParkCarTypeServices.QueryParkCarTypeByRecordId(grant.CarTypeID);

            if (carType == null)
            {
                throw new MyException("获取车型类型失败");
            }

            IParkCardSuspendPlan planFactory = ParkCardSuspendPlanFactory.GetFactory();

            using (DbOperator dbOperator = ConnectionManager.CreateConnection())
            {
                try
                {
                    dbOperator.BeginTransaction();
                    ParkCardSuspendPlan plan       = planFactory.QueryByGrantId(grantId);
                    DateTime            newEndDate = ComputeParkGrantNewEndDate(grant, plan);
                    grant.BeginDate = grant.BeginDate == null ? DateTime.Now.Date : grant.BeginDate;
                    bool result = factory.RestoreUse(grantId, grant.BeginDate, newEndDate, dbOperator);
                    if (!result)
                    {
                        throw new MyException("恢复暂停失败");
                    }

                    result = planFactory.Delete(grantId, dbOperator);
                    if (!result)
                    {
                        throw new MyException("取消暂停计划失败");
                    }
                    dbOperator.CommitTransaction();

                    ParkGrant dbGrant = factory.QueryByGrantId(grantId);
                    if (dbGrant != null)
                    {
                        OperateLogServices.AddOperateLog <ParkGrant>(dbGrant, OperateType.Update);
                    }
                    OperateLogServices.AddOperateLog(OperateType.Update, string.Format("CarRestore.GrantID:{0}", grantId));
                    return(result);
                }
                catch (Exception ex)
                {
                    dbOperator.RollbackTransaction();
                    throw ex;
                }
            }
        }
示例#22
0
        public static bool Add(BaseParkinfo model)
        {
            if (model == null)
            {
                throw new ArgumentNullException("model");
            }
            if (string.IsNullOrWhiteSpace(model.PKNo))
            {
                throw new MyException("车场编号不能为空");
            }

            IParking     factory = ParkingFactory.GetFactory();
            BaseParkinfo park    = factory.QueryParkingByParkingNo(model.PKNo);

            if (park != null)
            {
                throw new MyException("车场编号不能重复");
            }

            model.PKID = GuidGenerator.GetGuidString();

            using (DbOperator dbOperator = ConnectionManager.CreateConnection())
            {
                try
                {
                    dbOperator.BeginTransaction();
                    bool result = factory.Add(model, dbOperator);
                    if (!result)
                    {
                        throw new MyException("添加车场信息失败");
                    }

                    result = ParkCarModelServices.AddDefault(model.PKID, dbOperator);
                    if (!result)
                    {
                        throw new MyException("添加车型失败");
                    }

                    result = ParkCarTypeServices.AddDefault(model.PKID, dbOperator);
                    if (!result)
                    {
                        throw new MyException("添加车类型失败");
                    }
                    dbOperator.CommitTransaction();
                    if (result)
                    {
                        OperateLogServices.AddOperateLog <BaseParkinfo>(model, OperateType.Add);
                    }
                    return(true);
                }
                catch
                {
                    dbOperator.RollbackTransaction();
                    throw;
                }
            }
        }
示例#23
0
 public int Save(Guid companyId, IEnumerable <Customer> customers)
 {
     if (!customers.Any())
     {
         return(0);
     }
     using (var dbOperator = new DbOperator(Provider, ConnectionString)) {
         dbOperator.BeginTransaction();
         try {
             foreach (var item in customers)
             {
                 string sql = "IF NOT EXISTS(SELECT NULL FROM dbo.T_Customer WHERE Company=@Company AND Name=@Name AND CredentialsType=@CredentialsType) " +
                              "INSERT INTO dbo.T_Customer (Id,Name,Sex,PassengerType,CredentialsType,Credentials,Mobile,Remark,Company,[Time]) " +
                              "VALUES(@Id,@Name,@Sex,@PassengerType,@CredentialsType,@Credentials,@Mobile,@Remark,@Company,@Time)";
                 dbOperator.ClearParameters();
                 dbOperator.AddParameter("Company", companyId);
                 dbOperator.AddParameter("Id", item.Id);
                 dbOperator.AddParameter("Name", item.Name);
                 if (item.Sex.HasValue)
                 {
                     dbOperator.AddParameter("Sex", (byte)item.Sex);
                 }
                 else
                 {
                     dbOperator.AddParameter("Sex", DBNull.Value);
                 }
                 dbOperator.AddParameter("CredentialsType", (byte)item.CredentialsType);
                 dbOperator.AddParameter("Credentials", item.Credentials);
                 if (string.IsNullOrWhiteSpace(item.Mobile))
                 {
                     dbOperator.AddParameter("Mobile", DBNull.Value);
                 }
                 else
                 {
                     dbOperator.AddParameter("Mobile", item.Mobile);
                 }
                 if (string.IsNullOrWhiteSpace(item.Remark))
                 {
                     dbOperator.AddParameter("Remark", DBNull.Value);
                 }
                 else
                 {
                     dbOperator.AddParameter("Remark", item.Remark);
                 }
                 dbOperator.AddParameter("PassengerType", (byte)item.PassengerType);
                 dbOperator.AddParameter("Time", DateTime.Now);
                 dbOperator.ExecuteNonQuery(sql);
             }
             dbOperator.CommitTransaction();
             return(customers.Count());
         } catch {
             dbOperator.RollbackTransaction();
             throw;
         }
     }
 }
示例#24
0
        public static bool SellerCharge(string sellerId, decimal balance, string operatorId)
        {
            if (sellerId.IsEmpty())
            {
                throw new ArgumentNullException("sellerId");
            }
            if (operatorId.IsEmpty())
            {
                throw new ArgumentNullException("operatorId");
            }
            if (balance <= 0)
            {
                throw new ArgumentNullException("balance");
            }

            IParkSeller factory = ParkSellerFactory.GetFactory();
            ParkSeller  model   = factory.QueryBySellerId(sellerId);

            if (model == null)
            {
                throw new MyException("商家不存在");
            }

            using (DbOperator dbOperator = ConnectionManager.CreateConnection())
            {
                try
                {
                    dbOperator.BeginTransaction();
                    ParkOrder order = ParkOrderServices.MarkSellerChargeOrder(model, balance, operatorId, OrderSource.ManageOffice, OrderPayWay.Cash, dbOperator);
                    if (order == null)
                    {
                        throw new MyException("创建充值订单失败");
                    }

                    bool result = factory.SellerRecharge(sellerId, balance, dbOperator);
                    if (!result)
                    {
                        throw new MyException("取消暂停计划失败");
                    }
                    dbOperator.CommitTransaction();

                    ParkSeller newSeller = factory.QueryBySellerId(sellerId);
                    if (newSeller != null)
                    {
                        OperateLogServices.AddOperateLog(OperateType.Update, string.Format("sellerId:{0},充值:{1},余额为:{2}", sellerId, balance, newSeller.Balance));
                    }
                    return(result);
                }
                catch (Exception ex)
                {
                    dbOperator.RollbackTransaction();
                    throw ex;
                }
            }
        }
示例#25
0
        public static bool Delete(string recordId)
        {
            if (string.IsNullOrWhiteSpace(recordId))
            {
                throw new ArgumentNullException("recordId");
            }

            ISysUser factory = SysUserFactory.GetFactory();

            SysUser model = factory.QuerySysUserByRecordId(recordId);

            if (model == null)
            {
                throw new MyException("待删除的用户不存在");
            }

            if (model.IsDefaultUser == YesOrNo.Yes)
            {
                throw new MyException("该用户为系统默认用户不能删除");
            }

            ISysUserRolesMapping roleFactory  = SysUserRolesMappingFactory.GetFactory();
            ISysUserScopeMapping scopeFactory = SysUserScopeMappingFactory.GetFactory();

            using (DbOperator dbOperator = ConnectionManager.CreateConnection())
            {
                try
                {
                    dbOperator.BeginTransaction();
                    bool result = factory.Delete(recordId, dbOperator);
                    if (!result)
                    {
                        throw new MyException("添加用户信息失败");
                    }

                    roleFactory.DeleteByUserId(recordId, dbOperator);
                    scopeFactory.DeleteByUserID(recordId, dbOperator);

                    dbOperator.CommitTransaction();
                    if (result)
                    {
                        OperateLogServices.AddOperateLog(OperateType.Delete, string.Format("RecordId:{0}", recordId));
                    }
                    return(true);
                }
                catch
                {
                    dbOperator.RollbackTransaction();
                    throw;
                }
            }
        }
示例#26
0
        public static bool Update(ParkDevice model)
        {
            if (model == null)
            {
                throw new ArgumentNullException("model");
            }

            IParkDevice          factory          = ParkDeviceFactory.GetFactory();
            IParkDeviceDetection factoryDetection = ParkDeviceDetectionFactory.GetFactory();
            bool result = false;

            using (DbOperator dbOperator = ConnectionManager.CreateConnection())
            {
                try
                {
                    dbOperator.BeginTransaction();

                    result = factory.Update(model, dbOperator);
                    if (!result)
                    {
                        throw new MyException("修改设备失败");
                    }

                    if (model.DeviceType == DeviceType.NZ_CONTROL)
                    {
                        ParkDeviceParam deviceParam = factory.QueryParkDeviceParamByDID(model.DeviceID);
                        if (deviceParam == null)
                        {
                            AddDefaultParkDeviceParam(model.GateID, model.DeviceID, model.DeviceNo, dbOperator);
                        }
                        else
                        {
                            factory.UpdateParam(model.DeviceID, model.DeviceNo, dbOperator);
                        }
                    }

                    dbOperator.CommitTransaction();
                }
                catch
                {
                    dbOperator.RollbackTransaction();
                    throw;
                }
            }
            if (result)
            {
                OperateLogServices.AddOperateLog <ParkDevice>(model, OperateType.Update);
            }
            return(result);
        }
示例#27
0
        public static bool DAAdd(List <DAAddMonth> listmonth)
        {
            if (listmonth.Count == 0)
            {
                throw new ArgumentNullException("employee");
            }
            using (DbOperator dbOperator = ConnectionManager.CreateConnection())
            {
                dbOperator.BeginTransaction();
                try
                {
                    foreach (var obj in listmonth)
                    {
                        bool result = BaseEmployeeServices.AddOrUpdateBaseEmployee(obj.employye, dbOperator);
                        if (!result)
                        {
                            throw new MyException("保存人员信息失败");
                        }

                        result = BaseCardServices.AddOrUpdateCard(obj.card, dbOperator);
                        if (!result)
                        {
                            throw new MyException("保存卡信息失败");
                        }

                        result = EmployeePlateServices.AddOrUpdateEmployeePlate(obj.plate, dbOperator);
                        if (!result)
                        {
                            throw new MyException("保存车牌信息失败");
                        }

                        obj.grant.PlateID = obj.plate.PlateID;
                        obj.grant.CardID  = obj.card.CardID;
                        result            = AddOrderUpdateParkGrant(obj.grant, dbOperator);
                        if (!result)
                        {
                            throw new MyException("保存授权失败");
                        }
                        dbOperator.CommitTransaction();
                    }

                    return(true);
                }
                catch
                {
                    dbOperator.RollbackTransaction();
                    throw;
                }
            }
        }
示例#28
0
        /// <summary>
        /// 再次同步支付结果
        /// </summary>
        /// <param name="orderId"></param>
        /// <param name="payTime"></param>
        /// <returns></returns>
        public static void AgainSyncPayResult(decimal orderId, DateTime payTime)
        {
            lock (order_lock)
            {
                IOnlineOrder factory = OnlineOrderFactory.GetFactory();

                OnlineOrder order = factory.QueryByOrderId(orderId);
                if (order.Status == OnlineOrderStatus.SyncPayResultFail)
                {
                    using (DbOperator dbOperator = ConnectionManager.CreateConnection())
                    {
                        try
                        {
                            dbOperator.BeginTransaction();
                            bool result = factory.SyncPayResultSuccess(orderId, dbOperator);
                            if (!result)
                            {
                                throw new MyException("更改同步成功状态失败");
                            }

                            string payDetailId     = string.Empty;
                            bool   noticePayResult = SyncNoticePayResult(orderId, payTime, order, out payDetailId);
                            if (!noticePayResult)
                            {
                                throw new MyException("同步支付结果失败");
                            }

                            dbOperator.CommitTransaction();


                            UpdateSyncResultTimes(order.OrderID, payDetailId);
                            SendSyncResultMessage(order);
                        }
                        catch (MyException ex)
                        {
                            dbOperator.RollbackTransaction();
                            factory.SyncPayResultFail(order.OrderID, ex.Message);
                        }
                        catch (Exception ex)
                        {
                            dbOperator.RollbackTransaction();
                            factory.SyncPayResultFail(orderId, "同步支付结果异常");

                            string message = string.Format("【{0}】再次同步支付结果,订单编号:{1},描述:{2}", order.PaymentChannel.GetDescription(), order.OrderTime, ex.Message);
                            ExceptionsServices.AddExceptionToDbAndTxt("OnlineOrderServices", message, ex, LogFrom.WeiXin);
                        }
                    }
                }
            }
        }
示例#29
0
        public static bool CancelParkGrant(string grantId)
        {
            if (grantId.IsEmpty())
            {
                throw new ArgumentNullException("grantId");
            }

            IParkGrant     factory      = ParkGrantFactory.GetFactory();
            IBaseCard      cardFactory  = BaseCardFactory.GetFactory();
            IEmployeePlate plateFactory = EmployeePlateFactory.GetFactory();

            using (DbOperator dbOperator = ConnectionManager.CreateConnection())
            {
                try
                {
                    ParkGrant grant = factory.QueryByGrantId(grantId);

                    dbOperator.BeginTransaction();
                    bool result = plateFactory.Delete(grant.PlateID, dbOperator);
                    if (!result)
                    {
                        throw new MyException("删除车牌失败");
                    }

                    result = cardFactory.Delete(grant.CardID, dbOperator);
                    if (!result)
                    {
                        throw new MyException("删除卡失败");
                    }

                    result = factory.Delete(grantId, dbOperator);
                    if (!result)
                    {
                        throw new MyException("删除授权失败");
                    }
                    dbOperator.CommitTransaction();
                    if (result)
                    {
                        OperateLogServices.AddOperateLog(OperateType.Delete, string.Format("grantId:{0}", grantId));
                    }
                    return(result);
                }
                catch
                {
                    dbOperator.RollbackTransaction();
                    throw;
                }
            }
        }
示例#30
0
        private static bool NoticePaymentResult(OnlineOrder order)
        {
            if (order.Status != OnlineOrderStatus.PaySuccess)
            {
                TxtLogServices.WriteTxtLogEx("OnlineOrderServices", "【通知支付结果】订单不是已支付状态,订单编号:{0},支付账号:{1}", order.OrderID, order.PayAccount);
                return(false);
            }

            bool         noticePayResult = false;
            IOnlineOrder factory         = OnlineOrderFactory.GetFactory();

            using (DbOperator dbOperator = ConnectionManager.CreateConnection())
            {
                try
                {
                    dbOperator.BeginTransaction();
                    bool result = factory.SyncPayResultSuccess(order.OrderID, dbOperator);
                    if (!result)
                    {
                        throw new MyException("更改同步成功状态失败");
                    }

                    string payDetailId = string.Empty;
                    noticePayResult = SyncNoticePayResult(order.OrderID, order.RealPayTime, order, out payDetailId);
                    if (!noticePayResult)
                    {
                        throw new MyException("同步支付结果失败");
                    }
                    dbOperator.CommitTransaction();

                    factory.UpdateSyncResultTimes(order.OrderID, payDetailId);
                    SendSyncResultMessage(order);
                    return(true);
                }
                catch (MyException ex)
                {
                    dbOperator.RollbackTransaction();
                    factory.SyncPayResultFail(order.OrderID, ex.Message);
                    return(false);
                }
                catch (Exception ex)
                {
                    dbOperator.RollbackTransaction();
                    factory.SyncPayResultFail(order.OrderID, "同步支付结果异常");
                    TxtLogServices.WriteTxtLogEx("OnlineOrderServices", "【{0}】支付账号{3},订单编号:{1},描述:{2}", order.PaymentChannel.GetDescription(), order.OrderID, ex.Message, order.PayAccount);
                    return(false);
                }
            }
        }