text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>using System;
using FluentValidation;
namespace Equinox.Domain.Commands.Validations
{
public abstract class CustomerValidation<T> : AbstractValidator<T> where T : CustomerCommand
{
protected void ValidateName()
{
RuleFor(c => c.Name)
.NotEmpty().WithMe... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_suffix|> }
}
}<|fim_prefix|>namespace Equinox.Domain.Commands.Valid<|fim_middle|>ations
{
public class RegisterNewCustomerCommandValidation : CustomerValidation<RegisterNewCustomerCommand>
{
public RegisterNewCustomerCommandValidation()
{
ValidateName();
Va... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_suffix|>CustomerCommandValidation : CustomerValidation<RemoveCustomerCommand>
{
public RemoveCustomerCommandValidation()
{
ValidateId();
}
}
}<|fim_prefix|>namespace Equinox.Domain.Commands.Validatio<|fim_middle|>ns
{
public class Remove<|endoftext|> | fim | EduardoPires/EquinoxProject | csharp |
<|fim_prefix|>namespace Equinox.Domain.Commands.Vali<|fim_suffix|>tion : CustomerValidation<UpdateCustomerCommand>
{
public UpdateCustomerCommandValidation()
{
ValidateId();
ValidateName();
ValidateBirthDate();
ValidateEmail();
}
}
}<|fim_... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_prefix|>using NetDevPack.SimpleMediator.Core.Interfaces;
using System.Threading;
using System.Threading.Tasks;
namespace Equinox.Domain.Events
{
public class CustomerEventHandler :
INotificationHandler<CustomerRegisteredEvent>,
INotificationHandler<CustomerUpdate<|fim_suffix|> // Send s... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_suffix|>l { get; private set; }
public DateTime BirthDate { get; private set; }
}
}<|fim_prefix|>using System;
using NetDevPack.Messaging;
namespace Equinox.Domain.Events
{
public class CustomerRegisteredEvent : Event
{
<|fim_middle|> public CustomerRegisteredEvent(Guid id, string na... | fim | EduardoPires/EquinoxProject | csharp |
using System;
using NetDevPack.Messaging;
namespace Equinox.Domain.Events
{
public class CustomerRemovedEvent : Event
{
public CustomerRemovedEvent(Guid id)
{
Id = id;
AggregateId = id;
}
public Guid Id { get; set; }
}
}<|endoftext|> | fim | EduardoPires/EquinoxProject | csharp |
using System;
using NetDevPack.Messaging;
namespace Equinox.Domain.Events
{
public class CustomerUpdatedEvent : Event
{
public CustomerUpdatedEvent(Guid id, string name, string email, DateTime birthDate)
{
Id = id;
Name = name;
Email = email;
Bir... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_prefix|>using System;
<|fim_suffix|>tem.Threading.Tasks;
using Equinox.Domain.Models;
using NetDevPack.Data;
namespace Equinox.Domain.Interfaces
{
public interface ICustomerRepository : IRepository<Customer>
{
Task<Customer> GetById(Guid id);
Task<Customer> GetByEmail(string email);
... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_suffix|>; private set; }
public string Email { get; private set; }
public DateTime BirthDate { get; private set; }
}
}<|fim_prefix|>using System;
using NetDevPack.Domain;
namespace Equinox.Domain.Models
{
public class Customer : Entity, IAggregateRoot
{
<|fim_middle|> public... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_prefix|>using NetDevPack.Messaging<|fim_suffix|>re.Events
{
public interface IEventStore
{
void Save<T>(T theEvent) where T : Event;
}
}<|fim_middle|>;
namespace Equinox.Domain.Co<|endoftext|> | fim | EduardoPires/EquinoxProject | csharp |
<|fim_prefix|>using Syst<|fim_suffix|>
public class StoredEvent : Event
{
public StoredEvent(Event theEvent, string data, string user)
{
Id = Guid.NewGuid();
AggregateId = theEvent.AggregateId;
MessageType = theEvent.MessageType;
Data = data;
... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_suffix|> public async Task<ValidationResult> SendCommand<T>(T command) where T : Command
{
return await _mediator.Send(command);
}
}
}<|fim_prefix|>using System.Threading.Tasks;
using Equinox.Domain.Core.Events;
using FluentValidation.Results;
using NetDevPack.Mediator;
using Ne... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_prefix|>namespace Equinox.Infra.CrossCutting.Identity.API
{
public class AppJwtSettings
{
public string Secre<|fim_suffix|>ublic string Issuer { get; set; } = "Equinox.Api";
public string Audience { get; set; } = "Api";
}
}<|fim_middle|>tKey { get; set; }
public int Expiration... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_suffix|>Claims.Select(c => new UserClaim { Type = c.Type, Value = c.Value })
}
};
return user;
}
private static long ToUnixEpochDate(DateTime date)
=> (long)Math.Round((date.ToUniversalTime() - new DateTimeOffset(1970, 1, 1, 0, 0, 0, TimeSpan.Z... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_prefix|>using System.Linq;
using Microsoft.AspNetCore.Http;
namespace Equinox.Infra.CrossCutting.Identity.Authorization
{
public static class CustomAuthorizationValidation
{
public stat<|fim_suffix|>nticated &&
context.User.Claims.Any(c =>
c.Type == clai... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_suffix|>ation
{
public class CustomAuthorizeAttribute : TypeFilterAttribute
{
public CustomAuthorizeAttribute(string claimName, string claimValue) : base(typeof(RequerimentClaimFilter))
{
Arguments = new object[] { new Claim(claimName, claimValue) };
}
}
}<|fim_pref... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_suffix|>te readonly Claim _claim;
public RequerimentClaimFilter(Claim claim)
{
_claim = claim;
}
public void OnAuthorization(AuthorizationFilterContext context)
{
if (!context.HttpContext.User.Identity.IsAuthenticated)
{
... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_suffix|>ilder AddJwtSupport(this WebApplicationBuilder builder)
{
var appSettingsSection = builder.Configuration.GetSection("AppSettings");
builder.Services.Configure<AppJwtSettings>(appSettingsSection);
var appSettings = appSettingsSection.Get<AppJwtSettings>();
... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_suffix|>;
var configuration = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", optional: true)
.AddJsonFile($"appsettings.{environment}.json", optional: true)
.Build();
... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_prefix|>using System.Security.Claims;
using System;
using System.IdentityModel.Tokens.Jwt;
namespace Equinox.Infra.CrossCutting.Identity.Extensions
{
public static class ClaimsPrincipalExtensions
{
public static string GetUserId(this ClaimsPrincipal p<|fim_suffix|>irst(ClaimTypes.Email);
... | fim | EduardoPires/EquinoxProject | csharp |
// <auto-generated />
using System;
using Equinox.Infra.CrossCutting.Identity.Data;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Migrations;
using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
#nullable disable
namespace Equinox... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_suffix|>ype: "TEXT", nullable: false),
Name = table.Column<string>(type: "TEXT", nullable: false),
Value = table.Column<string>(type: "TEXT", nullable: true)
},
constraints: table =>
{
table.PrimaryKey("PK_... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_prefix|>// <auto-generated />
using System;
using Equinox.Infra.CrossCutting.Identity.Data;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
#nullable disable
namespace Equinox.Infra.CrossCutting.Identity.Migra... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_suffix|> public string Password { get; set; }
}
}
<|fim_prefix|>using System.ComponentModel.DataAnnotations;
namespace Equinox.Infra.CrossCutting.Identity.Models
{
public class LoginUser
{
[Required]
[EmailAddress]
public string Email { get; set; }
<|fim_middle|> ... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_suffix|>0, MinimumLength = 6)]
public string Password { get; set; }
[Compare("Password")]
public string ConfirmPassword { get; set; }
}
}
<|fim_prefix|>using System.ComponentModel.DataAnnotations;
namespace Equinox.Infra.CrossCutting.Identity.Models
{
public class RegisterUser
... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_prefix|>namespace Equinox.Infra.CrossCutting.Ide<|fim_suffix|> public string Value { get; set; }
public string Type { get; set; }
}
}
<|fim_middle|>ntity.Models
{
public class UserClaim
{
<|endoftext|> | fim | EduardoPires/EquinoxProject | csharp |
<|fim_suffix|>
<|fim_prefix|>namespace Equinox.Infra.CrossCutting.Identity.Models
{
public class UserResponse
{
public string AccessToken { get; set; }
public double ExpiresIn { get; set; }
public Use<|fim_middle|>rToken UserToken { get; set; }
public string RefreshToken { get; ... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_suffix|>erToken
{
public dynamic Id { get; set; }
public string Email { get; set; }
public IEnumerable<UserClaim> Claims { get; set; }
}
}
<|fim_prefix|><|fim_middle|>using System.Collections.Generic;
namespace Equinox.Infra.CrossCutting.Identity.Models
{
public class Us<|end... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_prefix|>using System;
using System.Collections.Generic;
using System.Security.Claims;
using Equinox.Infra.CrossCutting.Identity.Extensions;
using Microsoft.AspNetCore.Http;
namespace Equinox.Infra.CrossCutting.Identity.User
{
public class AspNetUser : IAspNetUser
{
private readonly IHttpContextA... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_prefix|>using System;
using System.Collections.Generic;
using System.Security.Claims;
using Microsoft.AspNetCore.Http;
namespace Equinox.Infra.CrossCutting.Identity.User
{
public interface IAspNetUser
{
string Name { get; }
Guid GetUserId();
string GetUserEmail();
bool Is... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_suffix|>rvice>();
// Domain - Events
builder.Services.AddScoped<INotificationHandler<CustomerRegisteredEvent>, CustomerEventHandler>();
builder.Services.AddScoped<INotificationHandler<CustomerUpdatedEvent>, CustomerEventHandler>();
builder.Services.AddScoped<INotif... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_suffix|>text
{
var domainEntities = ctx.ChangeTracker
.Entries<Entity>()
.Where(x => x.Entity.DomainEvents != null && x.Entity.DomainEvents.Any());
var domainEvents = domainEntities
.SelectMany(x => x.Entity.DomainEvents)
... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_prefix|>using Equinox.Domain.Core.Events;
using Equinox.Infra.Data.Mappings;
using Microsoft.EntityFrameworkCore;
namespace Equ<|fim_suffix|>ptions) : base(options) { }
public DbSet<StoredEvent> StoredEvent { get; set; }
protected override void OnModelCreating(ModelBuilder modelBuilder)
... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_prefix|>using Equinox.Domain.Core.Events;
using Equinox.Infra.CrossCutting.Identity.User;
using Equinox.Infra.Data.Repository.EventSourcing;
using NetDevPack.Messaging;
using Newtonsoft.Jso<|fim_suffix|>riteIndented = true };
var serializedData = JsonConvert.SerializeObject(theEvent);
v... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_prefix|>using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata.Builders;
using Equinox.Domain.Models;
namespace Equinox.Infra.Data.Mappings
{
public class CustomerMap : IEntityTypeConfiguration<Customer>
{
public void Configure(EntityTypeBuilder<Customer> builder)
... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_suffix|>tionDate");
builder.Property(c => c.MessageType)
.HasColumnName("Action")
.HasColumnType("varchar(100)");
}
}
}<|fim_prefix|>using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata.Builders;
using Equinox.Domain.Core.Events... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_suffix|> b.ToTable("Customers");
});
#pragma warning restore 612, 618
}
}
}
<|fim_prefix|>// <auto-generated />
using System;
using Equinox.Infra.Data.Context;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFra... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_prefix|>using System;
using Microsoft.EntityFrameworkCore.Migrations;
#nullable disable
namespace Equinox.Infra.Data.Migrations
{
/// <inheritdoc />
public partial class SQLite : Migration
{
/// <inheritdoc />
protected override void Up(MigrationBuilder migrationBuilder)
{
... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_suffix|>
b.Property<DateTime>("BirthDate")
.HasColumnType("TEXT");
b.Property<string>("Email")
.IsRequired()
.HasMaxLength(100)
.HasColumnType("varchar(100)");
... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_suffix|>DateTime>("Timestamp")
.HasColumnType("TEXT")
.HasColumnName("CreationDate");
b.Property<string>("User")
.HasColumnType("TEXT");
b.HasKey("Id");
b.ToTable("StoredEvent");
... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_prefix|>using System;
using Microsoft.EntityFrameworkCore.Migrations;
#nullable disable
namespace Equinox.Infra.Data.Migrations.EventStoreSql
{
/// <inheritdoc />
<|fim_suffix|> name: "StoredEvent",
columns: table => new
{
Id = table.Column<Guid>(t... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_suffix|>ionDate");
b.Property<string>("User")
.HasColumnType("TEXT");
b.HasKey("Id");
b.ToTable("StoredEvent");
});
#pragma warning restore 612, 618
}
}
}
<|fim_prefix|>// <auto-generated />
using S... | fim | EduardoPires/EquinoxProject | csharp |
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Equinox.Domain.Interfaces;
using Equinox.Domain.Models;
using Equinox.Infra.Data.Context;
using Microsoft.EntityFrameworkCore;
using NetDevPack.Data;
namespace Equinox.Infra.Data.Repository
{
public class CustomerRepository : ICus... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_prefix|>using System;
using System.Linq;
using System.Collections.Generic;
using System.Threading.Tasks;
using Equinox.Domain.Core.Events;
using Equinox.Infra.Data.Context;
using Microsoft.EntityFrameworkCore;
namespace Equinox.Infra.Data.Repository.EventSourcing
{
public class EventStoreSqlRepository : IEv... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_suffix|>oid Store(StoredEvent theEvent);
Task<IList<StoredEvent>> All(Guid aggregateId);
}
}<|fim_prefix|>using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Equinox.Domain.Core.Events;
namespace Equinox.Infra.Data.R<|fim_middle|>epository.EventSourcing
{
public i... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_suffix|>builder.Environment.EnvironmentName}.json", true, true)
.AddEnvironmentVariables();
builder.Services.AddControllers();
return builder;
}
}
}<|fim_prefix|>namespace Equinox.Services.Api.Configurations
{
public static class ApiConfig
{
... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_prefix|>using Equinox.Infra.Data.Context;
using Microsoft.EntityFrameworkCore;
namespace Equinox.Service<|fim_suffix|>ons =>
options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));
return builder;
}
}
}<|fim_middle|>s.Api.Configurations
{
... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_prefix|>using E<|fim_suffix|>l) throw new ArgumentNullException(nameof(builder));
NativeInjectorBootStrapper.RegisterServices(builder);
return builder;
}
}
}<|fim_middle|>quinox.Infra.CrossCutting.IoC;
namespace Equinox.Services.Api.Configurations
{
public static class ... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_suffix|> {
s.SwaggerDoc("v1", new OpenApiInfo
{
Version = "v1",
Title = "Equinox Project",
Description = "Equinox API Swagger surface",
Contact = new OpenApiContact { Name = "Eduardo Pires", Email ... | fim | EduardoPires/EquinoxProject | csharp |
using Equinox.Infra.CrossCutting.Identity.API;
using Equinox.Infra.CrossCutting.Identity.Models;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Options;
namespace Equinox.Services.Api.Controllers
{
[Route("account")]
[ApiController]
public class AccountCont... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_suffix|>{
foreach (var error in validationResult.Errors)
{
AddError(error.ErrorMessage);
}
return CustomResponse();
}
protected bool IsOperationValid()
{
return !_errors.Any();
}
protected void A... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_prefix|>using Equinox.Application.EventSourcedNormalizers;
using Equinox.Application.Interfaces;
using Equinox.Application.ViewModels;
using Equinox.Infra.CrossCutting.Identity.Authorization;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
namespace Equinox.Services.Api.Controllers
{
... | fim | EduardoPires/EquinoxProject | csharp |
using Equinox.Infra.CrossCutting.Identity.Configuration;
using Equinox.Services.Api.Configurations;
using Microsoft.AspNetCore.Identity;
var builder = WebApplication.CreateBuilder(args);
// Configure Services
builder.AddApiConfiguration() // Api Configurations
.AddDatabaseConfiguration() ... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_suffix|> }
}<|fim_prefix|>[ass<|fim_middle|>embly: HostingStartup(typeof(Equinox.UI.Web.Areas.Identity.IdentityHostingStartup))]
namespace Equinox.UI.Web.Areas.Identity
{
public class IdentityHostingStartup : IHostingStartup
{
public void Configure(IWebHostBuilder builder)
{
b... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_suffix|>ockedOut)
{
_logger.LogWarning("User account locked out.");
return RedirectToPage("./Lockout");
}
else
{
ModelState.AddModelError(string.Empty, "Invalid login attempt.");
... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_prefix|>using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authorization;
usin<|fim_suffix|>UI.Web.Areas.Identity.Pages.Account
{
[AllowAnonymous]
public class LogoutModel : PageModel
{
private readonly SignInManager<Ide... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_prefix|>using System.ComponentModel.DataAnnotations;
using System.Security.Claims;
using System.Text;
using Microsoft.AspNetCore.Authentication;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.RazorPages;
using Microsof... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_prefix|>using Equinox.Infra.Data.Context;
using Microsoft.EntityFrameworkCore;
namespace Equinox.UI.Web.Configurations
{
public static class DatabaseConfig
{
public static WebAp<|fim_suffix|>EquinoxContext>(options =>
options.UseSqlite(builder.Configuration.GetConnectionStrin... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_prefix|>using Equinox.Domain.Core.Events;
using Equinox.Domain.Events;
using Equinox.Domain.Models;
using Equinox.Infra.CrossCutting.Identity.Data;
using Equinox.Infra.Data.Context;
using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;
using NetDevPack.Messaging;
using Newtonsoft.Json;
names... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_suffix|>ctionConfiguration(this WebApplicationBuilder builder)
{
ArgumentNullException.ThrowIfNull(builder);
NativeInjectorBootStrapper.RegisterServices(builder);
}
}
}<|fim_prefix|>using Equinox.Infra.CrossCutti<|fim_middle|>ng.IoC;
namespace Equinox.UI.Web.Configur... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_prefix|>using Microsoft.AspNetCore.Mvc;
namespace Equinox.UI.Web.Configurations
{
public static class MvcConfig
{
public static WebApplicationBuilder AddMvcConfiguration(this WebApplicationBuilder builder)
{
if (builder == null) throw new ArgumentNullException(nameof(builder)... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_suffix|>(string.Empty, error.ErrorMessage);
}
return true;
}
protected void AddProcessError(string erro)
{
_errors.Add(erro);
}
public bool IsValidOperation()
{
return !_errors.Any();
}
}
}
<|fim_prefix|... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_prefix|>using Equinox.Application.Interfaces;
using Equinox.Application.ViewModels;
using Equinox.Infra.CrossCutting.Identity.Authorization;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
namespace Equinox.UI.Web.Controllers
{
[Authorize]
public class CustomerController(ICustom... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_suffix|> {
modelErro.Message = "You are not allowed to do this.";
modelErro.Title = "Access Denied";
modelErro.ErrorCode = id;
}
else
{
return StatusCode(500);
}
return View("Error", modelE... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_prefix|>using Microsoft.AspNetCore.Identity.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore;
namespace Equinox.UI.Web.Data
{
public class ApplicationDbContext :<|fim_suffix|>
{
}
}
}
<|fim_middle|> IdentityDbContext
{
public ApplicationDbContext(DbContextOptions<Appl... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_suffix|>gnKey("RoleId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", null)
.WithMany()
.HasForeignKey("UserId")
.O... | fim | EduardoPires/EquinoxProject | csharp |
using Microsoft.EntityFrameworkCore.Metadata;
using Microsoft.EntityFrameworkCore.Migrations;
namespace Equinox.UI.Web.Data.Migrations
{
public partial class CreateIdentitySchema : Migration
{
protected override void Up(MigrationBuilder migrationBuilder)
{
migrationBuilder.CreateTa... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_suffix|>operty<bool>("EmailConfirmed")
.HasColumnType("bit");
b.Property<bool>("LockoutEnabled")
.HasColumnType("bit");
b.Property<DateTimeOffset?>("LockoutEnd")
.HasColumnType("datetimeoffset");
... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_suffix|>g Message { get; set; }
}
}
<|fim_prefix|>namespace Equinox.UI.Web.Models
{
public class ErrorViewModel
{
public int ErrorCode { get; set; }
public str<|fim_middle|>ing Title { get; set; }
public strin<|endoftext|> | fim | EduardoPires/EquinoxProject | csharp |
using Equinox.UI.Web.Configurations;
using Equinox.Infra.CrossCutting.Identity.Configuration;
var builder = WebApplication.CreateBuilder(args);
// Adding Services
builder.AddMvcConfiguration() // Entire Equinox MVC Config
.AddDatabaseConfiguration() // Setting DBContexts
.... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_suffix|>");
}
}
}<|fim_prefix|>using Microsoft.AspNetCore.Mvc;
namespace Equinox.UI.Web.ViewComponents
{
public class SummaryViewComponen<|fim_middle|>t : ViewComponent
{
public IViewComponentResult Invoke()
{
return View("Default<|endoftext|> | fim | EduardoPires/EquinoxProject | csharp |
<|fim_suffix|>ive/jquery.validate.unobtrusive.js" />
<|fim_prefix|>/// <autosync enabled="true" />
/// <reference path="js/site.js" />
/// <reference path="lib/bootstrap/dist/js/boots<|fim_middle|>trap.js" />
/// <reference path="lib/jquery/dist/jquery.js" />
/// <reference path="lib/jquery-validation/dist/jquery.vali... | fim | EduardoPires/EquinoxProject | javascript |
<|fim_prefix|>// Please see do<|fim_suffix|> on configuring this project to bundle and minify static web assets.
// Write your JavaScript code.
<|fim_middle|>cumentation at https://docs.microsoft.com/aspnet/core/client-side/bundling-and-minification
// for details<|endoftext|> | fim | EduardoPires/EquinoxProject | javascript |
<|fim_suffix|>,
replace = replaceAttrValue ? $.parseJSON(replaceAttrValue) : null;
container.addClass("field-validation-valid").removeClass("field-validation-error");
error.removeData("unobtrusiveContainer");
if (replace) {
container.empty();
... | fim | EduardoPires/EquinoxProject | javascript |
<|fim_prefix|>// Unobtrusive validation support library for jQuery and jQuery Validate
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
// @version v3.2.11
!function(a){"function"==typeof define&&define... | fim | EduardoPires/EquinoxProject | javascript |
<|fim_prefix|>/**
* @fileoverview
* - Using the 'QRCode for Javascript library'
* - Fixed dataset of 'QRCode for Javascript library' for support full-spec.
* - this library has no dependencies.
*
* @author davidshimjs
* @see <a href="http://www.d-project.com/" target="_blank">http://www.d-project.com/</a>
* @s... | fim | EduardoPires/EquinoxProject | javascript |
<|fim_suffix|>MeetCustomRule(new ShouldUseDependencyInjectionRule())
.GetResult();
Assert.True(result.IsSuccessful, $"Failed in {result.FailingTypes?.Count} objects(s)");
}
}
<|fim_prefix|>using Equinox.Tests.Architecture.Support;
using NetArchTest.Rules;
using Xunit.Abstractions;
... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_prefix|>using Equinox.Domain.Core.Events;
using Equinox.Domain.Models;
using NetArchTest.Rules;
namespace Equinox.Tests.Architecture;
public class DomainTests
{
[Fact(DisplayName = "Domain Should Not Have Any Dependencies")]
[Trait("", "Domain")]
public void Domain_ShouldNotHave_ProjectDependencies... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_suffix|>led in {result.FailingTypes?.Count} objects(s)");
}
}
<|fim_prefix|>using Equinox.Tests.Architecture.Support;
using NetArchTest.Rules;
namespace Equinox.Tests.Architecture;
public class GeneralPatternTests
{
[Fact(DisplayName = "Base Classes Must Be Abstract")]
[Trait("", "General")]
... | fim | EduardoPires/EquinoxProject | csharp |
using Mono.Cecil;
using NetArchTest.Rules;
namespace Equinox.Tests.Architecture.Support;
public class ShouldUseDependencyInjectionRule : ICustomRule
{
public bool MeetsRule(TypeDefinition type)
{
if (!type.IsClass || !type.IsPublic)
{
return true; // Ignore non-public classes or n... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_prefix|>us<|fim_suffix|>ine(value ?? string.Empty);
}
public override Encoding Encoding => Encoding.UTF8;
}
<|fim_middle|>ing System.Text;
using Xunit.Abstractions;
namespace Equinox.Tests.Architecture.Support;
public class TestOutputHelperTextWriter(ITestOutputHelper output) : TextWriter
{
privat... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_prefix|>using Equinox.Application.Services;
using Equinox.Domain.Core.Events;
using Equinox.Domain.Models;
using Equinox.Infra.CrossCutting.Bus;
using Equinox.Infra.CrossCutting.Identity.User;
using Equinox.Infra.CrossCutting.IoC;
using Equinox.Infra.Data.Context;
using Equinox.Services.Api.Controllers;
using Eq... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_suffix|> var appWeb = Types.InAssembly(typeof(HomeController).Assembly)
.That().DoNotResideInNamespace("Equinox.UI.Web.Configurations");
// Act
var result = appWeb
.ShouldNot()
.HaveDependencyOnAny
... | fim | EduardoPires/EquinoxProject | csharp |
<|fim_prefix|>import eslint from '@eslint/js';
import tseslint from 'typescript-eslint';
import globals from 'globals';
export default tseslint.config(
{
ignores: [
'**/node_modules/**',
'**/dist/**',
'**/build/**',
'**/public/**',
'**/coverage/**',
'**/.understand-anything/**... | fim | Egonex-AI/Understand-Anything | javascript |
<|fim_suffix|>,
});
<|fim_prefix|>// @ts-check
import { defineConfig } from 'astro/config';
// https://astro.build/config
export default defineConfig({
site: 'https://understand-anyth<|fim_middle|>ing.com'<|endoftext|> | fim | Egonex-AI/Understand-Anything | javascript |
<|fim_suffix|>&& Math.random() < 0.5 ? null : layers,
tour: MESSY && Math.random() < 0.5 ? null : tour,
};
const outDir = resolve(process.cwd(), ".understand-anything");
mkdirSync(outDir, { recursive: true });
const outPath = resolve(outDir, "knowledge-graph.json");
writeFileSync(outPath, JSON.stringify(graph, null,... | fim | Egonex-AI/Understand-Anything | javascript |
<|fim_suffix|>projectRoot, { recursive: true, force: true });
});
it('merges 100 isolated singletons into a small number of misc batches', () => {
const result = runScript(projectRoot);
expect(result.status).toBe(0);
const batches = readBatches(projectRoot);
expect(batches.totalFiles).toBe(100);
... | fim | Egonex-AI/Understand-Anything | javascript |
<|fim_prefix|>import { describe, it, expect, afterEach } from 'vitest';
import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, rmSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join, dirname, resolve } from 'node:path';
import { spawnSync } from 'node:child_process';
import { fileURLToPath } fr... | fim | Egonex-AI/Understand-Anything | javascript |
<|fim_prefix|>#!/usr/bin/env python3
"""
test_merge_batch_graphs.py — Tests for the deterministic tested_by linker.
Run from the repo root:
python -m unittest tests.skill.understand.test_merge_batch_graphs -v
"""
from __future__ import annotations
import importlib.util
import sys
import unittest
from pathlib imp... | fim | Egonex-AI/Understand-Anything | python |
import { describe, it, expect, afterEach } from 'vitest';
import {
mkdtempSync,
mkdirSync,
writeFileSync,
readFileSync,
rmSync,
chmodSync,
existsSync,
} from 'node:fs';
import { tmpdir } from 'node:os';
import { join, dirname, resolve } from 'node:path';
import { spawnSync } from 'node:child_process';
imp... | fim | Egonex-AI/Understand-Anything | javascript |
<|fim_prefix|>import { describe, it, expect } from "vitest";
import { classifyUpdate } from "../change-classifier.js";
import type { ChangeAnalysis } from "../fingerprint.js";
function makeAnalysis(overrides: Partial<ChangeAnalysis> = {}): ChangeAnalysis {
return {
fileChanges: [],
newFiles: [],
deletedF... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|>lePath", () => {
const result = normalizeNodeId("validate", {
type: "step",
name: "Validate",
filePath: "src/validators/order.ts",
});
expect(result).toBe("step:src/validators/order.ts:validate");
});
});
<|fim_prefix|>import { describe, it, expect } from "vitest";
import {... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|>ders");
});
it("returns null when no domain graph exists", () => {
const loaded = loadDomainGraph(testRoot);
expect(loaded).toBeNull();
});
it("saves to domain-graph.json, not knowledge-graph.json", () => {
saveDomainGraph(testRoot, domainGraph);
const domainPath = join(testRoot,... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_prefix|>import { describe, it, expect } from "vitest";
import { validateGraph } from "../schema.js";
import type { KnowledgeGraph } from "../types.js";
const domainGraph: KnowledgeGraph = {
version: "1.0.0",
project: {
name: "test-project",
languages: ["typescript"],
frameworks: [],
descripti... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|>(results.every((r) => {
const node = nodes.find((n) => n.id === r.nodeId);
return node?.type === "function";
})).toBe(true);
});
it("returns empty for nodes without embeddings", () => {
const engine = new SemanticSearchEngine(nodes, {});
const results = engine.se... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_prefix|>import { describe, it, expect, vi, beforeEach } from "vitest";
import type { StructuralAnalysis } from "../types.js";
import {
contentHash,
extractFileFingerprint,
compareFingerprints,
analyzeChanges,
type FileFingerprint,
type FingerprintStore,
} from "../fingerprint.js";
// Mock fs and path... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|> "requirements.txt": "django==4.2\ndjango==4.2\n",
"pyproject.toml": '[project]\ndependencies = ["django>=4.0"]',
});
expect(detected).toHaveLength(1);
});
});
it("returns frameworks for all listed languages (cross-language)", () => {
const registry = FrameworkRegistry.cre... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_prefix|>import { describe, it, expect, beforeEach, afterEach } from "vitest";
import { createIgnoreFilter, DEFAULT_IGNORE_PATTERNS } from "../ignore-filter";
import { mkdirSync, writeFileSync, rmSync } from "node:fs";
import { join } from "node:path";
import { tmpdir } from "node:os";
describe("IgnoreFilter", ()... | fim | Egonex-AI/Understand-Anything | typescript |
<|fim_suffix|> });
it("suggests test and tests when they exist", () => {
mkdirSync(join(testDir, "test"), { recursive: true });
mkdirSync(join(testDir, "tests"), { recursive: true });
const content = generateStarterIgnoreFile(testDir);
expect(content).toContain("# test/");
expect(content).toCont... | fim | Egonex-AI/Understand-Anything | typescript |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.