public void RebaseCurrentBranchOnOriginMaster()
{
AllRepositories.ForEach(r =>
{
var originMaster = r.repo.Branches[OriginMaster];
var head = r.repo.Head;
var tracked = head.TrackedBranch;
//var sig = new Signature();
//var result = r.Rebase.Start(head, tracked, null, new Identity(sig.Name, sig.Email), new RebaseOptions());
try
{
r.repo.Rebase.Start(r.repo.Head, originMaster, originMaster,
new Identity(Config.UserDisplayName, Config.Email), new RebaseOptions());
Add2CommandLog(true, r.repo, $"Rebased {head.FriendlyName} on origin/master successful");
}
catch (Exception e)
{
Add2CommandLog(false, r.repo, e.Message);
}
});
}
public string GenerateConfig(AllRepositories allRep)
{
var strb = new StringBuilder();
var pType = allRep.ProxyTypeRep.GetById(ProxyTypeId);
strb.AppendLine("\t" + "upstream " + Name.Replace(" ", "_") + " {");
if (pType.ProxyValue != "")
{
strb.AppendLine("\t\t" + pType.ProxyValue + ";");
}
for (int i = 0; i < ServerIds.Count; i++)
{
strb.AppendLine("\t" + allRep.ServerRep.GetById(ServerIds[i]).GenerateConfig(Port, MaxFails, FailTimeout));
}
if (FreeText != null && FreeText != "")
{
strb.AppendLine("\t" + FreeText);
}
strb.AppendLine("\t}");
return(strb.ToString());
}
public WebSMiddleware(RequestDelegate next, AllRepositories allRep)
{
_allRep = allRep;
_next = next;
_client = null;
_stream = null;
}
public string GenerateConfig(AllRepositories allRep, string upstreamId, string Protocol)
{
var strb = new StringBuilder();
var s = MatchType != null ? MatchType : "";
strb.AppendLine("\t\tlocation " + s + " " + URI + " {");
var up = allRep.UpstreamRep.GetById(upstreamId);
if (PassType != null && PassType != "" && up != null)
{
strb.AppendLine("\t\t\t" + PassType + " " + Protocol + up.Name.Replace(" ", "_") + ";");
}
if (FreeText != null && FreeText != "")
{
strb.AppendLine("\t\t\t" + FreeText);
}
strb.AppendLine("\t\t}");
return(strb.ToString());
}
public IRepository GetRepository(Type ModelType)
{
if (ModelType == null)
{
return(null);
}
var repo = AllRepositories.Find(o => o.ModelType == ModelType);
if (repo != null)
{
return(repo);
}
else
{
var all = AllRepositories;
foreach (var item in all)
{
if (item.ModelType == ModelType)
{
return(item);
}
}
return(this.GetRepository(ModelType.Name));
}
}
public string GenerateConfig(AllRepositories allRep)
{
var strb = new StringBuilder();
strb.AppendLine("\tserver {");
strb.AppendLine("\t\tlisten " + Listen + ";");
strb.AppendLine("\t\tserver_name " + Domain + ";\n");
if (SSL != null && SSL != "")
{
strb.Append(allRep.SSLRep.GetById(SSL).GenerateConfig());
}
if (FreeText != null)
{
strb.AppendLine("\t" + FreeText);
}
for (int i = 0; i < Applications.Count; i++)
{
strb.Append(allRep.ApplicationRep.GetById(Applications[i].ApplicationId).GenerateConfig(allRep, Applications[i].UpstreamToPass));
}
if (Whitelist != null)
{
strb.AppendLine(allRep.WhitelistRep.GetById(Whitelist).GenerateConfig());
}
strb.AppendLine("\t}");
return(strb.ToString());
}
static void Presentacion()
{
//Instancia al REpositorio que se encarga de llamar gestionar la persistencia
RepoDb = new AllRepositories();
DatosdParaPruebas();
MenuPrincipal();
ControlDeFlujoPrincipal();
}
static void Presentacion()
{
//Instancia al REpositorio que se encarga de llamar gestionar la persistencia
RepoDb = new AllRepositories();
//Por si volvemos a necesitar datos de pruebas en una Db Vacía
//DatosdParaPruebas();
MenuPrincipal();
ControlDeFlujoPrincipal();
}
public void TestInit()
{
tran = new TransactionScope();
DbContext context = new BlogEntities();
this.context = context;
AllRepositories allRepositories = new AllRepositories(context);
this.httpServer = new InMemoryHttpServer("http://localhost/", allRepositories);
}
public OrderProcessor()
{
_allRepositories = new AllRepositories();
_orderStatusCodesList = new Dictionary <string, int>();
foreach (var code in _allRepositories.OrderStatusCodesRepository.GetAll())
{
_orderStatusCodesList.Add(code.STATUS, code.ORDERSTATUSCODES_ID);
}
}
public string GenerateConfig(AllRepositories allRep, string UpstreamId)
{
var strb = new StringBuilder();
foreach (var l in Locations)
{
strb.AppendLine(l.GenerateConfig(allRep, UpstreamId, Protocol));
}
return(strb.ToString());
}
public MainWindow()
{
InitializeComponent();
//
//Instancia al REpositorio que se encarga de llamar y gestionar la persistencia
RepoDb = new AllRepositories();
//Activamos botones CRUDS según el contenido en persistencia
OpcionesIniciales();
}
public void RemoveMergedLocalBranches()
{
AllRepositories
.ForEach(r =>
{
var originMaster = r.repo.Branches[OriginMaster];
r.repo.Branches
.Where(b => !b.IsRemote)
.ToList()
.ForEach(b =>
{
try
{
if (r.repo.Head.FriendlyName == b.FriendlyName)
{
return;
}
var branchDivergence =
r.repo.ObjectDatabase.CalculateHistoryDivergence(b.Tip, originMaster.Tip);
var branchName = b.FriendlyName;
var tip = r.repo.Head.FriendlyName;
if (branchDivergence.AheadBy == 0 && branchDivergence.BehindBy >= 0)
{
r.repo.Branches.Remove(b);
Add2CommandLog(true, r.repo, $"Removed branch: [{b.FriendlyName}]");
}
}
catch (Exception ex)
{
Add2CommandLog(false, r.repo,
$"Couldn't remove branch: [{b.FriendlyName}] due to error - {ex.Message}");
}
});
});
// using (var repository = new Repository(path))
//{
// var remote = repository.Network.Remotes["origin"];
// var options = new PushOptions();
// var credentials = options.CredentialsProvider = GetUserCredentialsProvider();
// options.CredentialsProvider = credentials;
// string pushRefSpec = @"refs/heads/:{0}".FormatWith(branch);
// repository.Network.Push(remote, pushRefSpec);
// repository.Branches.Remove(repository.Branches[branch]);
//}
}
public void PushLocalHeadBranchesAheadOfMaster(bool forcePush) =>
AllRepositories.ForEach(r =>
{
var remote = r.repo.Network.Remotes["origin"];
var pushOptions = new PushOptions {
CredentialsProvider = Credentials,
};
var originMasterBranch = r.repo.Branches[OriginMaster];
var headTip = r.repo.Head.Tip;
var originMasterTipSha = originMasterBranch.Tip;
var repoName = r.repo.Info.Path;
var historyDivergence =
r.repo.ObjectDatabase.CalculateHistoryDivergence(r.repo.Head.Tip, originMasterBranch.Tip);
var headAheadOfMasterBy = historyDivergence.AheadBy;
if (headAheadOfMasterBy > 0)
{
r.repo.Branches.Update(r.repo.Head,
b => b.Remote = remote.Name,
b => b.UpstreamBranch = r.repo.Head.CanonicalName
);
try
{
if (forcePush)
{
var pushRefSpec = string.Format("+{0}:{0}", r.repo.Head.CanonicalName);
r.repo.Network.Push(remote, pushRefSpec, pushOptions);
Add2CommandLog(true, r.repo, "FORCE Push successful");
}
else
{
r.repo.Network.Push(r.repo.Head, pushOptions);
Add2CommandLog(true, r.repo, "Push successful");
}
}
catch (Exception e)
{
Add2CommandLog(false, r.repo, e.Message);
}
}
});
public InMemoryHttpServer(string baseUrl, AllRepositories allRepositories)
{
this.baseUrl = baseUrl;
var config = new HttpConfiguration();
this.AddHttpRoutes(config.Routes);
config.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
var resolver = new TestStudentsDependencyResolver();
resolver.Repository = allRepositories;
config.DependencyResolver = resolver;
var server = new HttpServer(config);
this.client = new HttpClient(server);
}
public string GenerateConfig(AllRepositories allRep)
{
var strb = new StringBuilder();
foreach (var up in allRep.UpstreamRep.GetAll())
{
strb.AppendLine(up.GenerateConfig(allRep));
}
//to order the virtual servers by their priority
List <VirtualServer> virtualServers = ((List <VirtualServer>)allRep.VirtualServerRep.GetAll()).OrderBy(vs => vs.Priority).ToList();
foreach (var vs in virtualServers)
{
strb.AppendLine(vs.GenerateConfig(allRep));
}
return(Text.Replace("{{config}}", strb.ToString()));
}
public ConfigController(AllRepositories allRep)
{
_allRep = allRep;
}
public UserController(AllRepositories<ChessEntities> data)
{
this.data = data;
}
public PostsController(AllRepositories data)
{
this.data = data;
}
public PostsController()
{
data = new AllRepositories(new ForumDbEntities());
}
public UserController(AllRepositories <ChessEntities> data)
{
this.data = data;
}
public UsersController(AllRepositories data)
{
this.data = data;
}
public DeploymentServersController(DeploymentServerDataAccess repository, AllRepositories allrep) : base(repository)
{
_allRep = allrep;
}
public PostsController()
{
data = new AllRepositories(new BlogEntities());
}
public string GenerateConfig(AllRepositories allRep)
{
return(allRep.GeneralConfigRep.GetAll().First().GenerateConfig(allRep));
}
