using System;
using Microsoft.EntityFrameworkCore.Migrations;

#nullable disable

namespace WebNote.Migrations
{
    /// <inheritdoc />
    public partial class AddSiteOwnerTable : Migration
    {
        /// <inheritdoc />
        protected override void Up(MigrationBuilder migrationBuilder)
        {
            migrationBuilder.CreateTable(
                name: "SiteOwners",
                columns: table => new
                {
                    Id = table.Column<int>(type: "int", nullable: false)
                        .Annotation("SqlServer:Identity", "1, 1"),
                    Name = table.Column<string>(type: "nvarchar(100)", maxLength: 100, nullable: false),
                    Title = table.Column<string>(type: "nvarchar(200)", maxLength: 200, nullable: true),
                    Bio = table.Column<string>(type: "nvarchar(500)", maxLength: 500, nullable: true),
                    Resume = table.Column<string>(type: "nvarchar(max)", nullable: true),
                    AvatarPath = table.Column<string>(type: "nvarchar(255)", maxLength: 255, nullable: true),
                    Email = table.Column<string>(type: "nvarchar(20)", maxLength: 20, nullable: true),
                    Mobile = table.Column<string>(type: "nvarchar(20)", maxLength: 20, nullable: true),
                    GitHub = table.Column<string>(type: "nvarchar(100)", maxLength: 100, nullable: true),
                    QQ = table.Column<string>(type: "nvarchar(20)", maxLength: 20, nullable: true),
                    CreatedAt = table.Column<DateTime>(type: "datetime2", nullable: false),
                    UpdatedAt = table.Column<DateTime>(type: "datetime2", nullable: true),
                    IsActive = table.Column<bool>(type: "bit", nullable: false)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_SiteOwners", x => x.Id);
                });
        }

        /// <inheritdoc />
        protected override void Down(MigrationBuilder migrationBuilder)
        {
            migrationBuilder.DropTable(
                name: "SiteOwners");
        }
    }
}

Add-Migration AddSiteOwnerTable

Update-Database

if (this.gpCustomer.SelectedValue.ToString() != string.Empty && this.gpSD.SelectedValue.ToString() != string.Empty && this.gpCustomer.SelectedValue.ToString() != "-1" && this.gpSD.SelectedValue.ToString() != "-1")
{
    if (((Enums.PageStatus)Session["Session_PageStatus"]) == SOI.Enums.PageStatus.Create || ((Enums.PageStatus)Session["Session_PageStatus"]) == SOI.Enums.PageStatus.Edit)
    {
        //if ((Enums.PageStatus)Session["Session_PageStatus"] == SOI.Enums.PageStatus.Create)

        Wicresoft.Session.Session session = new Wicresoft.Session.Session();
        string sql = @"select count(*) from SOI_DealerCustomer where  isvalid=1 and FK_CustomerInfo=" + gpCustomer.SelectedValue + "and FK_Dealer=" + gpSD.SelectedValue + " and customerkind='客户'" + ((Enums.PageStatus)Session["Session_PageStatus"] == SOI.Enums.PageStatus.Create ? "" : (" AND PKID!= " + this.PKID));
        int i = Convert.ToInt32(session.SqlHelper.ExecuteScalar(sql, CommandType.Text));
        if (i > 0)
        {
            valiateSDDName.ErrorMessage = "经销商与医院已做过关联";
            args.IsValid = false;
        }
    }
}

新疆生产建设兵团总医院
新疆生产建设兵团第一师医院
新疆生产建设兵团第六师医院101团分院
新疆生产建设兵团第十三师红星医院
新疆生产建设兵团第十师北屯医院
新疆生产建设兵团第四师六十二团医院
石河子大学医学院第一附属医院
第八师石河子市总医院(石河子市人民医院、石河子大学医学院第三附属医院)
新疆生产建设兵团第三师总医院四十五团分院

最近研究mysql，遇到这个问题

解决方法，用navicat加上用户，以及ip

button_custom_submit: function (t) {
    var body = t.RequestButton;
    switch (body.name) {
        case "btn_custom_use"://启用/禁用
            var dt = mzServer.selectRow();
            if (dt.ResponseMessage.Success) {
                if (dt.Stats.length < 1) {
                    $scope.view.submit.Fn.loading(t.RequestButton.name, false);
                    mzServer.Msg.error("请选择一条数据");

                    return;
                }
                debugger;
                $scope.view.submit.Fn.loading(t.RequestButton.name, false);
                var state = dt.Stats[0].a_TemplateStatus; var tip = "";
                if (state == 1) {
                    state = 0; tip = "禁用";
                } else {
                    state = 1; tip = "启用";
                }
                mzServer.confirm('确定' + tip + '吗？').result.then(function (isconfirm) {
                    debugger;
                    if (isconfirm) {
                        var data = {};
                        var Info = {};
                        Info.a_ID = dt.Stats[0].a_ID;
                        Info.a_Status = state;
                        data.ConfigType = "view";
                        data.OpType = "query";
                        data.ConfigName = "TBFreightTemplate";
                        data.RequestBody = JSON.stringify(Info);
                        data.SpecialParameter = "ForbidOrUse";
                        data.url = "gridview/LoadData";
                        mzServer.postData(data).then(
                            function (response) {
                                console.log(response);
                                if (response.data.ResponseMessage.Success) {
                                    mzServer.Msg.success(tip+"成功！");
                                    angular.element("table[for='TBFreightTemplate']").bootstrapTable('refresh');
                                } else {
                                    mzServer.Msg.error(response.data.ResponseMessage.ErrorMessage);
                                }
                            }, function (error) {
                                mzServer.Msg.error(error);
                            });

                    }
                });
            }
            else {
                $scope.view.submit.Fn.loading(t.RequestButton.name, false);
                mzServer.Msg.error(dt.ResponseMessage.ErrorMessage);
            }
            break;

        default:
            mzServer.Msg.error("无效的事件");
            break;
    }

},

• 当一个类不知道它所必须创建的对象的类时
• 当一个类希望由它的子类来指定所创建的对象时
• 当将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化时

  using System;
  
  // 定义产品接口
  public interface IProduct
  {
      void Operation();
  }
  
  // 具体产品A
  public class ConcreteProductA : IProduct
  {
      public void Operation()
      {
          Console.WriteLine("ConcreteProductA Operation");
      }
  }
  
  // 具体产品B
  public class ConcreteProductB : IProduct
  {
      public void Operation()
      {
          Console.WriteLine("ConcreteProductB Operation");
      }
  }
  
  // 简单工厂类
  public class SimpleFactory
  {
      public static IProduct CreateProduct(string type)
      {
          switch (type.ToLower())
          {
              case "a":
                  return new ConcreteProductA();
              case "b":
                  return new ConcreteProductB();
              default:
                  throw new ArgumentException("Invalid product type", nameof(type));
          }
      }
  }
  
  // 客户端代码
  class Program
  {
      static void Main()
      {
          // 使用简单工厂创建产品A
          IProduct productA = SimpleFactory.CreateProduct("A");
          productA.Operation();
  
          // 使用简单工厂创建产品B
          IProduct productB = SimpleFactory.CreateProduct("B");
          productB.Operation();
  
          try
          {
              // 尝试创建无效产品类型
              IProduct invalidProduct = SimpleFactory.CreateProduct("C");
              invalidProduct.Operation();
          }
          catch (ArgumentException ex)
          {
              Console.WriteLine($"Error: {ex.Message}");
          }
      }
  }    

工厂模式的优点

• 解耦对象的创建和使用：客户端不需要知道具体产品类的类名，只需要知道对应的参数即可。
• 可扩展性好：在增加新的产品类时，只需要修改工厂类或者扩展工厂子类，符合开闭原则。
• 便于代码维护：创建对象的逻辑集中在一个工厂类中，便于维护和修改。

工厂模式的缺点

• 工厂类职责过重：简单工厂模式中，工厂类集中了所有产品的创建逻辑，一旦不能正常工作，整个系统都会受到影响。
• 增加系统复杂度：如果产品种类过多，会导致工厂类变得庞大，增加系统的复杂度。
• 违反开闭原则：在简单工厂模式中，每当增加新的产品时，都需要修改工厂类，这违反了开闭原则。

1. 高层模块不应依赖低层模块，二者都应依赖抽象。
2. 抽象不应依赖细节，细节应依赖抽象。
   示例：

   # 反例：高层模块依赖低层模块
   class LightBulb:
       def turn_on(self):
           print("灯泡亮了")
   
   class Switch:
       def __init__(self):
           self.bulb = LightBulb()  # 直接依赖具体实现
   
   # 正例：依赖抽象
   from abc import ABC, abstractmethod
   
   class Switchable(ABC):
       @abstractmethod
       def turn_on(self):
           pass
   
   class LightBulb(Switchable):
       def turn_on(self):
           print("灯泡亮了")
   
   class Fan(Switchable):
       def turn_on(self):
           print("风扇转了")
   
   class Switch:
       def __init__(self, device: Switchable):
           self.device = device  # 依赖抽象而非具体实现

客户端不应该被迫依赖它不需要的接口。应该把庞大的接口拆分成更小、更具体的接口。

# 反例：一个大而全的接口
class Worker:
    def work(self):
        pass
    def eat(self):
        pass

class Robot(Worker):
    def work(self):
        pass
    def eat(self):
        raise NotImplementedError("机器人不需要吃饭")  # 被迫实现不需要的方法

# 正例：拆分接口
class Workable:
    def work(self):
        pass

class Eatable:
    def eat(self):
        pass

class HumanWorker(Workable, Eatable):
    pass

class RobotWorker(Workable):
    pass