{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*",
  "ConnectionStrings": {
    "ConnectionString_1": "Server=ServeurLocal;Database=BaseLocale;Trusted_Connection=True;MultipleActiveResultSets=true;TrustServerCertificate=True",
    "ConnectionString_2": "Server=ServeurDistant;Database=BaserDistante;Trusted_Connection=True;MultipleActiveResultSets=true;TrustServerCertificate=True"
  }
}

 
public partial class Context1 : DbContext
{
    public Context1 (DbContextOptions<Context1> options)
        : base(options)
    {
    }
 
    public virtual DbSet<model1> models1{ get; set; }
    ....

 
public partial class Context2 : DbContext
{
    public Context2  (DbContextOptions<Context2> options)
        : base(options)
    {
    }
 
    public virtual DbSet<model2> models2{ get; set; }
    ....

 
var ConnectionString1= builder.Configuration.GetConnectionString("ConnectionString_1") ?? throw new InvalidOperationException("La connexion au serveru n'a pas été établie.");
builder.Services.AddDbContext<Context1>(options =>
    options.UseSqlServer(ConnectionString_1));
 
var ConnectionString2= builder.Configuration.GetConnectionString("ConnectionString_2") ?? throw new InvalidOperationException("La connexion au serveru de trading n'a pas été établie.");
builder.Services.AddDbContext<Context2>(options =>
    options.UseSqlServer(ConnectionString_2));

  public async Task<ActionResult> Index()
  {
       var liste= await _context2.model2.FromSqlRaw("EXEC procedure").ToListAsync();
 
      return View();
  }

public async Task<ActionResult> Edit(int? id)
{
    if (id == null)
    {
        return NotFound();
    }
 
    var SearchOperation = await _context.Operations.FromSqlRaw("EXEC dbo.affiche_operations").ToListAsync();
    var listOperations = SearchOperation.FirstOrDefault(x => x.numero_operation == id);
 
    if (listOperations == null)
    {
        return NotFound();
    }
 
    var listeNatureOperation = await _context.NatureOperations.ToListAsync();
    ViewBag.lib_nature= new SelectList(listeNatureOperation, "CodeNature", "LibNature", selectedValue: listOperations.lib_nature);
 
    var listEmetteur = await _context.Emetteurs.ToListAsync();
    ViewBag.Emetteur = new SelectList(listEmetteur, "CodeEmetteur", "raison_sociale", selectedValue: listOperations.CodeEmetteur);
 
      return View(listOperations);
}

<form asp-action="Edit">
    <div asp-validation-summary="ModelOnly" class="text-danger"></div>
    <input type="hidden" asp-for="numero_operation" />
    <div class="form-group">
        <label asp-for="CodeEmetteur" class="control-label"></label>
        <select asp-for="CodeEmetteur" asp-items="@ViewBag.Emetteur" class="form-control">
            <option value="">-- Selectionner émetteur --</option>
        </select>
        <span asp-validation-for="CodeEmetteur" class="text-danger"></span>
    </div>
    <div class="form-group">
        <label asp-for="lib_nature" class="control-label"></label>
        <select asp-for="lib_nature" asp-items="@ViewBag.lib_nature" class="form-control">
            <option value="">-- Selectionner le type --</option>
        </select>
        <span asp-validation-for="lib_nature" class="text-danger"></span>
    </div>
</form>

public partial class Operation
{
    [Display(Name = "Code émetteur")]
    [Required]
    public int CodeEmetteur { get; set; }
 
    [Display(Name = "Numéro opération")]
    public int NumeroOperation { get; set; }
 
    [Display(Name = "Code nature opération")]
    [Required]
    public int CodeNature { get; set; }
 
    [Display(Name = "Observation")]
    public string Observations { get; set; }
 
    [Display(Name = "Date d'enregistrement")]
    public DateTime? DateEnregistrement { get; set; }
 
    [Display(Name = "Date de diffusion")]
    public DateTime? DateDebutDiffusion { get; set; }
 
    [Display(Name = "Date de fin de diffusion")]
    public DateTime? DateFinDiffusion { get; set; }
 
    [Display(Name = "Document joint")]
    public string Document { get; set; }
 
    [NotMapped]
    public IEnumerable<SelectListItem> NatureOperation { get; set; }
 
    [NotMapped]
    public IEnumerable<SelectListItem> Emetteur { get; set; }
}

public class PaginationViewModel<T> : List<T>
{
    public int TotalItems { get; set; }
    public int PageActive { get; set; }
    public int NbreParPage { get; set; }
    public int TotalPage { get; set; }
    public int DebutPage { get; set; }
    public int FinPage { get; set; }
 
    public PaginationViewModel(List<T> items, int count, int pageIndex, int pageSize)
    {
        TotalItems = count;
        PageActive = pageIndex;
        NbreParPage = pageSize;
        TotalPage = (int)Math.Ceiling(count / (double)NbreParPage);
        DebutPage = pageIndex - 5;
        FinPage = pageIndex + 4;
 
        if (DebutPage <= 0)
        {
            FinPage = FinPage - (DebutPage - 1);
            DebutPage = 1;
        }
        if (FinPage > TotalPage)
        {
            FinPage = TotalPage;
            if (FinPage > 10)
            {
                DebutPage = FinPage - 9;
            }
        }
        this.AddRange(items);
    }
 
    public bool PrecDesactive => PageActive > 1;
    public bool SuivDesactive => PageActive < TotalPage;
 
    public static PaginationViewModel<T> Create(List<T> source, int pageIndex, int pageSize) 
    {
        var count = source.Count;
        var items = source.Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
        return new PaginationViewModel<T>(items, count, pageIndex, pageSize);
    }
}

public ActionResult Index(int NumPage)
{
    int NbreParPage = 10;
    //On réinitialise le numéro de page à 1 si le numéro est égal ou inférieru à 1
    if (NumPage < 1)
        NumPage = 1;
 
    var operations = _context.Operations
        .Include(o => o.NatureOperation)
        .Include(o => o.Emetteur)
        .ToList();
 
    return View(PaginationViewModel<Operation>.Create(operations, NumPage, NbreParPage));
}

 
@model BOCNEW_2025.Models.PaginationViewModel<BOCNEW_2025.Models.Operation>
@foreach (var item in Model) {
<tr>
    <td class="col-1" style="width:5%; text-align:right;">
            @Html.DisplayFor(modeltem => item.CodeEmetteur)
    </td>
    <td class="col-1" style="width:5%; text-align:right;">
            @Html.DisplayFor(modelItem => item.Emetteur)
    </td>
     <td class="col-3" style="width:3%; text-align:right;">
            @Html.DisplayFor(modelItem => item.CodeNature)
    </td>
        <td class="col-4" style="width:15%">
            @Html.DisplayFor(modelItem => item.DateDebutDiffusion)
    </td>
        <td style="width:15%">
            @Html.DisplayFor(modelItem => item.DateFinDiffusion)
    </td>
        <td style="width:30%">
            @Html.DisplayFor(modelItem => item.Observations)
        </td>
        <td style="width:15%">
        <button type="button" class="btn btn-primary"><a asp-action="Edit" asp-route-id="@item.NatureOperation" class="text-white">Modifier</a></button>
        <button type="button" class="btn btn-danger"><a asp-action="Delete" asp-route-id="@item.NatureOperation" class="text-white">Supprimer</a></button>
    </td>
</tr>
}

public class DetailVenteModel
{
    [Required]
    [Display(Name = "Symbole")]
    public string? Symbole{ get; set; }
 
    [Display(Name = "Prix Vente")]
    public float PrixDeVente{ get; set; }
 
    [Display(Name = "Prix d'achat")]
    public int PrixAchat{ get; set; }
}
}

 public class ListVente
 {
    public int Id { get; set; }
    List<EquitiesDetailModel> ListOfEquities { get; set; }
}

 
 [HttpPost]
 public ActionResult InsertVente(IEnumerable<DetailVenteModel> ListeDetailVenteModels)
 {
 
     foreach (var item in equitiesDetailViewModels) {
 
         DetailVenteModel vente = new DetailVenteModel();
 
         vente.Symbole = item.Symbole;
         vente.PrixDeVente= item.PrixDeVente;
         vente.PrixAchat= item.PrixDeVente;
 
 
         _context.Add(item);
         await _context.SaveChangesAsync();
     }
 
     return Json(new { success = true });
 }

 
<script type="text/javascript">
    $(document).ready(function () {
       $("input[type=button]").click(function () {
 
            var ListeDetailVenteModels = new Array();
 
            $("#listeTransactions").find("tr:gt(0)").each(function () {
 
                var symbole = $(this).find("td:eq(0)").text();
                var prixDeVente= $(this).find("td:eq(1)").text();
                var prixAchat= $(this).find("td:eq(2)").text();
 
 
                var DetailVenteModel = {};
 
                DetailVenteModel.symbol = symbole ;
                DetailVenteModel.BestBidPrice = prixDeVente;
                DetailVenteModel.BestBidVolume = prixAchat;
 
 
                ListeDetailVenteModels .push(DetailVenteModel);
            });
 
            $.ajax({
                async: true,
                type: 'POST',
                dataType: "JSON",
                contentType: 'application/json; charset=utf-8',
                url: '@Url.Action("InsertVente", "Vente")',
                data: JSON.stringify(ListeDetailVenteModels ),
                success: function (data) {
                     //console.log();
                    alert('Données enregistrées avec succès !');
                },
                error: function (xhr, status, error) {
                    console.log('Erreur lors de l\'enregistrement des données : ' + error);
                }
            });
        });
 
    });
</script>
 
 <div><input type="button" id="envoyer" value="Enregistrer dans la base de données" class="btn btn-primary"></div><br />
<div>
   <table class="table table-bordered" id="listeTransactions">
        <thead>
            <tr class="table-success">
                <th>Symbole</th>
                <th>Meilleure vente</th>
                <th>Meilleur prix achat</th>
            </tr>
        </thead>
        <tbody>
             @foreach (DataRow row in Model.Rows)
            {
                <tr>
                    <td id="symbol">@row["Symbole"]</td>
                    <td id="BestBidPrice">@row["PrixDeVente"]</td>
                    <td id="BestBidVolume">@row["PrixAchat"]</td>
 
                </tr>
            }
        </tbody>
 
    </table>
</div>

public interface IRepository<TEntity> where TEntity : class
{
Task<TEntity?> GetByIdAsync(Guid id);
Task<IEnumerable<TEntity>> GetAllAsync();
Task AddAsync(TEntity entity);
void Update(TEntity entity);
void Remove(TEntity entity);
Task<int> SaveChangesAsync();
}

public abstract class BaseDbContext : DbContext
{
public BaseDbContext(DbContextOptions options) : base(options) { }
}

public class ContentDbContext : BaseDbContext
{
public ContentDbContext(DbContextOptions<ContentDbContext> options) : base(options) { }
public DbSet<ContentItem> ContentItems => Set<ContentItem>();
}

public class DesignTimeContentDbContextFactory : IDesignTimeDbContextFactory<ContentDbContext>
{
public ContentDbContext CreateDbContext(string[] args)
{
var options = new DbContextOptionsBuilder<ContentDbContext>()
.UseSqlServer("DataSource=:memory:")
.Options;
return new ContentDbContext(options);
}
}

public interface ISeeder
{
Task SeedAsync(CancellationToken cancellationToken = default);
string Name { get; }
}

public class RealDataSeeder : ISeeder
{
public async Task SeedAsync(CancellationToken cancellationToken = default)
{
// logique seeding réelle
}
}

public class DummyDataSeeder : ISeeder
{
public async Task SeedAsync(CancellationToken cancellationToken = default)
{
// logique seeding fictive
}
}