public AgregarAsignacion(RepositoryManager<PPPObjectContext> repositoryManager, List<Persona> listaAsignados)
: base(repositoryManager)
{
InitializeComponent();
if (!DesignMode)
{
ListaAsignados = listaAsignados;
_asignadosBindingSource.DataSource = listaAsignados;
}
}
public static RepositoryManager<PPPObjectContext> GetManager()
{
try
{
var ctx = new PPPObjectContext();
var mgr = new RepositoryManager<PPPObjectContext>(ctx);
return mgr;
}
catch (Exception)
{
throw;
}
}
public QueryOrdersResponse Process(QueryOrdersRequest request)
{
var response = new QueryOrdersResponse()
{
ResultType = ResultTypes.Ok
};
var ordersService = new OrdersService();
var ordersRepo = RepositoryManager.GetRepository <IOrderRepository>();
if (!string.IsNullOrWhiteSpace(request.OrderNumber))
{
var dt = ordersRepo.QueryOrderReportSummaryByOrderNum(request.OrderNumber);
foreach (DataRow row in dt.Rows)
{
row["AGE"] = GetAge(row["AGE"]);
}
response.Result = dt;
response.OrderCount = response.Result.Rows.Count;
}
else if (!string.IsNullOrWhiteSpace(request.Barcode))
{
var orderBarcodeRepo = RepositoryManager.GetRepository <IOrderBarcodeRepository>();
var orderBarcodeInfo = orderBarcodeRepo.GetByBarcode(request.Barcode);
if (orderBarcodeInfo != null)
{
var dt = ordersRepo.QueryOrderReportSummaryByOrderNum(orderBarcodeInfo.Ordernum);
foreach (DataRow row in dt.Rows)
{
row["AGE"] = GetAge(row["AGE"]);
}
response.Result = dt;
response.OrderCount = response.Result.Rows.Count;
}
else
{
response.OrderCount = 0;
}
}
else
{
var htPara = new System.Collections.Hashtable();
htPara.Add("pageStart", request.PageStart);
htPara.Add("pageEnd", request.PageEnd);
htPara.Add("dictlabid", request.Dictlabid); // 分点
htPara.Add("dictcustomerid", request.Dictcustomerid); //体检单位
htPara.Add("status", request.OrderStatus);
htPara.Add("auditstatus", request.FinanceAuditStatus);
htPara.Add("reportstatus", request.ReportStatus);
htPara.Add("name", request.Keyword);
htPara.Add("section", request.Section);
htPara.Add("province", request.Province);
htPara.Add("batchnumber", request.BatchNumber);
if (!string.IsNullOrWhiteSpace(request.StartDate))
{
htPara.Add("StartDate", request.StartDate);
}
if (!string.IsNullOrWhiteSpace(request.EndDate))
{
htPara.Add("EndDate", request.EndDate);
}
if (!string.IsNullOrWhiteSpace(request.ScanStartDate))
{
htPara.Add("SDateBegin", request.ScanStartDate);
}
if (!string.IsNullOrWhiteSpace(request.ScanEndDate))
{
htPara.Add("SDateEnd", request.ScanEndDate);
}
if (!string.IsNullOrWhiteSpace(request.AuditStartDate))
{
htPara.Add("FDateBegin", request.AuditStartDate);
}
if (!string.IsNullOrWhiteSpace(request.AuditEndDate))
{
htPara.Add("FDateEnd", request.AuditEndDate);
}
response.OrderCount = ordersService.DataForFocusPrintPageTotal(htPara);
response.Result = ordersService.DataForFocusPrintPageLst(htPara);
}
return(response);
}
/// <summary>
/// Initializes a new instance of the <see cref="Program"/> class.
/// Constructor for the main entry program.
/// </summary>
/// <param name="args">The command line args.</param>
public Program(string[] args)
{
this.repositoryManager = new RepositoryManager();
this.repositoryManager.InitializeSqlLogging();
if (args.Contains("-reinit"))
{
Console.WriteLine("The database is getting reininitialized...");
this.repositoryManager.ReInitializeDatabase();
}
else if (!this.repositoryManager.IsDatabaseUpToDate())
{
Console.WriteLine("The database needs to be updated before the server can be started. Apply update? (y/n)");
var key = Console.ReadLine()?.ToLowerInvariant();
if (key == "y")
{
this.repositoryManager.ApplyAllPendingUpdates();
Console.WriteLine("The database has been successfully updated.");
}
else
{
Console.WriteLine("Cancelled the update process, can't start the server.");
return;
}
}
this.repositoryManager.RegisterRepositories();
Log.Info("Start initializing sub-components");
var loginServer = new LoginServer();
var chatServer = new ChatServerListener(55980);
this.servers.Add(chatServer);
var guildServer = new GuildServer(this.gameServers, this.repositoryManager);
var friendServer = new FriendServer(this.gameServers, chatServer, this.repositoryManager);
var connectServer = ConnectServerFactory.CreateConnectServer();
this.servers.Add(connectServer);
Log.Info("Start initializing game servers");
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
foreach (var gameServerDefinition in this.GetGameServers())
{
using (ThreadContext.Stacks["gameserver"].Push(gameServerDefinition.ServerID.ToString()))
{
var gameServer = new GameServer(gameServerDefinition, guildServer, loginServer, this.repositoryManager, friendServer);
foreach (var mainPacketHandler in gameServer.Context.PacketHandlers)
{
gameServer.AddListener(new DefaultTcpGameServerListener(gameServerDefinition.NetworkPort, gameServer.ServerInfo, gameServer.Context, connectServer, mainPacketHandler));
//// At the moment only one main packet handler should be used;
//// A TCP port can only be used for one TCP listener, so we have to introduce something to pair ports with main packets handlers.
break;
}
this.servers.Add(gameServer);
this.gameServers.Add(gameServer.Id, gameServer);
Log.InfoFormat("Game Server {0} - [{1}] initialized", gameServer.Id, gameServer.Description);
}
}
stopwatch.Stop();
Log.Info($"All game servers initialized, elapsed time: {stopwatch.Elapsed}");
Log.Info("Start initializing admin panel");
this.adminPanel = new AdminPanel(1234, this.servers, this.repositoryManager);
Log.Info("Admin panel initialized");
if (args.Contains("-autostart"))
{
chatServer.Start();
foreach (var gameServer in this.gameServers.Values)
{
gameServer.Start();
}
connectServer.Start();
}
}
/// <inheritdoc />
public async Task CompileProcess(Job job, IDatabaseContext databaseContext, Action <int> progressReporter, CancellationToken cancellationToken)
{
#pragma warning disable IDE0016 // Use 'throw' expression
if (job == null)
{
throw new ArgumentNullException(nameof(job));
}
#pragma warning restore IDE0016 // Use 'throw' expression
if (databaseContext == null)
{
throw new ArgumentNullException(nameof(databaseContext));
}
if (progressReporter == null)
{
throw new ArgumentNullException(nameof(progressReporter));
}
var ddSettingsTask = databaseContext.DreamDaemonSettings.Where(x => x.InstanceId == metadata.Id).Select(x => new DreamDaemonSettings
{
StartupTimeout = x.StartupTimeout,
}).FirstOrDefaultAsync(cancellationToken);
var compileJobsTask = databaseContext.CompileJobs
.Where(x => x.Job.Instance.Id == metadata.Id)
.OrderByDescending(x => x.Job.StoppedAt)
.Select(x => new Job
{
StoppedAt = x.Job.StoppedAt,
StartedAt = x.Job.StartedAt
})
.Take(10)
.ToListAsync(cancellationToken);
var dreamMakerSettings = await databaseContext.DreamMakerSettings.Where(x => x.InstanceId == metadata.Id).FirstAsync(cancellationToken).ConfigureAwait(false);
if (dreamMakerSettings == default)
{
throw new JobException("Missing DreamMakerSettings in DB!");
}
var ddSettings = await ddSettingsTask.ConfigureAwait(false);
if (ddSettings == default)
{
throw new JobException("Missing DreamDaemonSettings in DB!");
}
Task <RepositorySettings> repositorySettingsTask = null;
string repoOwner = null;
string repoName = null;
CompileJob compileJob;
RevisionInformation revInfo;
using (var repo = await RepositoryManager.LoadRepository(cancellationToken).ConfigureAwait(false))
{
if (repo == null)
{
throw new JobException("Missing Repository!");
}
if (repo.IsGitHubRepository)
{
repoOwner = repo.GitHubOwner;
repoName = repo.GitHubRepoName;
repositorySettingsTask = databaseContext.RepositorySettings.Where(x => x.InstanceId == metadata.Id).Select(x => new RepositorySettings
{
AccessToken = x.AccessToken,
ShowTestMergeCommitters = x.ShowTestMergeCommitters,
PushTestMergeCommits = x.PushTestMergeCommits
}).FirstOrDefaultAsync(cancellationToken);
}
var repoSha = repo.Head;
revInfo = await databaseContext.RevisionInformations.Where(x => x.CommitSha == repoSha && x.Instance.Id == metadata.Id).Include(x => x.ActiveTestMerges).ThenInclude(x => x.TestMerge).ThenInclude(x => x.MergedBy).FirstOrDefaultAsync().ConfigureAwait(false);
if (revInfo == default)
{
revInfo = new RevisionInformation
{
CommitSha = repoSha,
OriginCommitSha = repoSha,
Instance = new Models.Instance
{
Id = metadata.Id
}
};
logger.LogWarning(Repository.Repository.OriginTrackingErrorTemplate, repoSha);
databaseContext.Instances.Attach(revInfo.Instance);
}
TimeSpan?averageSpan = null;
var previousCompileJobs = await compileJobsTask.ConfigureAwait(false);
if (previousCompileJobs.Count != 0)
{
var totalSpan = TimeSpan.Zero;
foreach (var I in previousCompileJobs)
{
totalSpan += I.StoppedAt.Value - I.StartedAt.Value;
}
averageSpan = totalSpan / previousCompileJobs.Count;
}
compileJob = await dreamMaker.Compile(revInfo, dreamMakerSettings, ddSettings.StartupTimeout.Value, repo, progressReporter, averageSpan, cancellationToken).ConfigureAwait(false);
}
compileJob.Job = job;
databaseContext.CompileJobs.Add(compileJob); // will be saved by job context
job.PostComplete = ct => compileJobConsumer.LoadCompileJob(compileJob, ct);
if (repositorySettingsTask != null)
{
var repositorySettings = await repositorySettingsTask.ConfigureAwait(false);
if (repositorySettings == default)
{
throw new JobException("Missing repository settings!");
}
if (repositorySettings.AccessToken != null)
{
// potential for commenting on a test merge change
var outgoingCompileJob = LatestCompileJob();
if (outgoingCompileJob != null && outgoingCompileJob.RevisionInformation.CommitSha != compileJob.RevisionInformation.CommitSha && repositorySettings.PostTestMergeComment.Value)
{
var gitHubClient = gitHubClientFactory.CreateClient(repositorySettings.AccessToken);
async Task CommentOnPR(int prNumber, string comment)
{
try
{
await gitHubClient.Issue.Comment.Create(repoOwner, repoName, prNumber, comment).ConfigureAwait(false);
}
catch (ApiException e)
{
logger.LogWarning("Error posting GitHub comment! Exception: {0}", e);
}
}
var tasks = new List <Task>();
string FormatTestMerge(TestMerge testMerge, bool updated) => String.Format(CultureInfo.InvariantCulture, "#### Test Merge {4}{0}{0}##### Server Instance{0}{5}{1}{0}{0}##### Revision{0}Origin: {6}{0}Pull Request: {2}{0}Server: {7}{3}",
Environment.NewLine,
repositorySettings.ShowTestMergeCommitters.Value ? String.Format(CultureInfo.InvariantCulture, "{0}{0}##### Merged By{0}{1}", Environment.NewLine, testMerge.MergedBy.Name) : String.Empty,
testMerge.PullRequestRevision,
testMerge.Comment != null ? String.Format(CultureInfo.InvariantCulture, "{0}{0}##### Comment{0}{1}", Environment.NewLine, testMerge.Comment) : String.Empty,
updated ? "Updated" : "Deployed",
metadata.Name,
compileJob.RevisionInformation.OriginCommitSha,
compileJob.RevisionInformation.CommitSha);
// added prs
foreach (var I in compileJob
.RevisionInformation
.ActiveTestMerges
.Select(x => x.TestMerge)
.Where(x => !outgoingCompileJob
.RevisionInformation
.ActiveTestMerges
.Any(y => y.TestMerge.Number == x.Number)))
{
tasks.Add(CommentOnPR(I.Number.Value, FormatTestMerge(I, false)));
}
// removed prs
foreach (var I in outgoingCompileJob
.RevisionInformation
.ActiveTestMerges
.Select(x => x.TestMerge)
.Where(x => !compileJob
.RevisionInformation
.ActiveTestMerges
.Any(y => y.TestMerge.Number == x.Number)))
{
tasks.Add(CommentOnPR(I.Number.Value, "#### Test Merge Removed"));
}
// updated prs
foreach (var I in compileJob
.RevisionInformation
.ActiveTestMerges
.Select(x => x.TestMerge)
.Where(x => outgoingCompileJob
.RevisionInformation
.ActiveTestMerges
.Any(y => y.TestMerge.Number == x.Number)))
{
tasks.Add(CommentOnPR(I.Number.Value, FormatTestMerge(I, true)));
}
if (tasks.Any())
{
await Task.WhenAll(tasks).ConfigureAwait(false);
}
}
}
}
}
public SqlClientDbManager(RepositoryManager mgr, string name)
: base(mgr, name)
{
}
/// <summary>
///
/// </summary>
/// <returns></returns>
internal bool Delete()
{
var repository = RepositoryManager.GetRepository <ISignedUpInfoRepository>(ModuleEnvironment.ModuleName);
return(repository.Remove(this));
}
/// <summary>
/// This timer will crawl through the data and find any item with no hash
/// It will then then select records to activate the hash generation routine
/// </summary>
private static void _timerCheck_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
{
//If the system is turned off then do nothing
if (!ConfigHelper.EnabledDataManager)
{
return;
}
if (!IsActive)
{
return;
}
if (!EnableHouseKeeping)
{
return;
}
_timerCheck.Enabled = false;
try
{
const int BlockCount = 50;
const int WaitTime = 250;
var core = ((SystemCore)RepositoryManager.SystemCore);
while (_highPriority.Any())
{
//Try to get an ID from the high priority list
//if none found then grab an arbitrary one from the global list
Guid ID = Guid.Empty;
if (!_highPriority.TryTake(out ID))
{
return;
}
if (ID == Guid.Empty)
{
return;
}
//If there was an error it is in the skip list so never handle this ID again
if (!_skipList.Any(x => x == ID))
{
var sb = new StringBuilder();
var schema = RepositoryManager.GetSchema(ID);
if (schema != null)
{
DataQueryResults results = new DataQueryResults();
do
{
if (!IsActive)
{
return; //Stop when housekeeping comes on
}
var query = new DataQuery {
IncludeRecords = true, IncludeDimensions = false, ExcludeCount = true
};
query.FieldFilters.Add(new FieldFilter {
Name = SqlHelper.HashField, Comparer = ComparisonConstants.Equals, Value = 0
});
query.RecordsPerPage = BlockCount;
try
{
results = core.Manager.Query(ID, query, true);
Interlocked.Add(ref _counter, results.RecordList.Count);
}
catch
{
results = new DataQueryResults();
}
//Do not overload the system with background queries
if (results.ComputeTime > 2000)
{
System.Threading.Thread.Sleep(WaitTime * 2);
}
else if (core.GetCpu() > 60)
{
System.Threading.Thread.Sleep(WaitTime * 8);
}
else
{
System.Threading.Thread.Sleep(WaitTime);
}
} while (results.RecordList?.Count == BlockCount && results.ComputeTime < 5000);
}
}
}
if (InFullIndex)
{
SystemCore.PatchApply(FullIndexPatch, "DataManager:FullIndex");
}
}
catch (Exception ex)
{
LoggerCQ.LogError(ex);
}
finally
{
_timerCheck.Enabled = true;
}
}
protected override void OnInitialize()
{
RepositoryManager.Initialize();
}
public async Task ShouldAddAndCommitFiles()
{
await Initialize(TestRepoMasterCleanSynchronized);
var managerAutoResetEvent = new RepositoryManagerAutoResetEvent();
var repositoryManagerListener = Substitute.For <IRepositoryManagerListener>();
repositoryManagerListener.AttachListener(RepositoryManager, managerAutoResetEvent);
var expectedAfterChanges = new GitStatus {
Behind = 1,
LocalBranch = "master",
RemoteBranch = "origin/master",
Entries =
new List <GitStatusEntry> {
new GitStatusEntry("Assets\\TestDocument.txt",
TestRepoMasterCleanSynchronized.Combine("Assets", "TestDocument.txt"),
"Assets\\TestDocument.txt", GitFileStatus.Modified),
new GitStatusEntry("foobar.txt", TestRepoMasterCleanSynchronized.Combine("foobar.txt"),
"foobar.txt", GitFileStatus.Untracked)
}
};
var expectedAfterCommit = new GitStatus {
Ahead = 1,
Behind = 1,
LocalBranch = "master",
RemoteBranch = "origin/master",
Entries = new List <GitStatusEntry>()
};
var result = new GitStatus();
RepositoryManager.OnStatusUpdated += status => {
result = status;
};
Logger.Trace("Issuing Changes");
var foobarTxt = TestRepoMasterCleanSynchronized.Combine("foobar.txt");
foobarTxt.WriteAllText("foobar");
var testDocumentTxt = TestRepoMasterCleanSynchronized.Combine("Assets", "TestDocument.txt");
testDocumentTxt.WriteAllText("foobar");
await TaskManager.Wait();
managerAutoResetEvent.OnRepositoryChanged.WaitOne(TimeSpan.FromSeconds(200)).Should().BeTrue();
Logger.Trace("Continue test");
repositoryManagerListener.Received().OnRepositoryChanged(Args.GitStatus);
result.AssertEqual(expectedAfterChanges);
repositoryManagerListener.ReceivedWithAnyArgs().OnIsBusyChanged(Args.Bool);
repositoryManagerListener.DidNotReceive().OnActiveBranchChanged();
repositoryManagerListener.DidNotReceive().OnActiveRemoteChanged();
repositoryManagerListener.DidNotReceive().OnHeadChanged();
repositoryManagerListener.DidNotReceive().OnLocalBranchListChanged();
repositoryManagerListener.DidNotReceive().OnRemoteBranchListChanged();
repositoryManagerListener.DidNotReceive().OnRemoteOrTrackingChanged();
repositoryManagerListener.DidNotReceive().OnLocksUpdated(Args.EnumerableGitLock);
repositoryManagerListener.ClearReceivedCalls();
Logger.Trace("Issuing Command");
await RepositoryManager
.CommitFiles(new List <string>() { "Assets\\TestDocument.txt", "foobar.txt" }, "IntegrationTest Commit", string.Empty)
.StartAsAsync();
await TaskManager.Wait();
managerAutoResetEvent.OnActiveBranchChanged.WaitOne(TimeSpan.FromSeconds(5)).Should().BeTrue();
Logger.Trace("Continue test");
repositoryManagerListener.Received(1).OnActiveBranchChanged();
repositoryManagerListener.DidNotReceive().OnActiveRemoteChanged();
repositoryManagerListener.DidNotReceive().OnHeadChanged();
repositoryManagerListener.DidNotReceive().OnLocalBranchListChanged();
repositoryManagerListener.DidNotReceive().OnRemoteBranchListChanged();
repositoryManagerListener.DidNotReceive().OnRemoteOrTrackingChanged();
repositoryManagerListener.DidNotReceive().OnLocksUpdated(Args.EnumerableGitLock);
}
private void InitProjects()
{
//
RepositoryManager.RegisterFactory(new DefaultRepositoryFactory());
}
public static List<DatoAsignacionSemanal> CrearDesdeListaTareas(RepositoryManager<PPPObjectContext> repositoryManager, List<DatosProyecto> tareasProyecto, DateTime fechaInicio)
{
var data = repositoryManager.ObjectContext;
var lista = tareasProyecto
.Where(x => x.EsFilaDato)
.Where(x => x.EsFilaActiva)
.Select(x => new DatoAsignacionSemanal(x)
{
OrdenTipoActividad = data.TipoActividadSet.Where(y => y.IdTipoActividad == x.IdTipoActividad).First().OrdenTipoActividad,
OrdenActividad = x.OrdenActividad,
TipoActividadDescripcion = data.TipoActividadSet.Where(y => y.IdTipoActividad == x.IdTipoActividad).First().DescripcionTipoActividad,
FechaInicio = fechaInicio,
IdProyectoAsignacion = null,
PersonaAsignacionAlias = "(Sin asignar)",
})
.ToList();
return lista;
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public bool Delete()
{
var repository = RepositoryManager.GetRepository <IBossCommentRepository>(ModuleEnvironment.ModuleName);
return(repository.Remove(this));
}
public RepositoryCache()
{
_provider = new FileRepositoryProvider(CandleSettings.BaseDirectory, RepositoryManager.GetFolderPath(RepositoryCategory.Models));
HttpContext.Current.Trace.Write(_provider.Name);
}
public static void Start()
{
//initial database
RepositoryManager.Init();
}
public OfxManager()
{
repositoryManager = new RepositoryManager();
}
public HttpResponseMessage Put(int id, [FromBody] DeviceController deviceInfo)
{
return(ActionWarpper.Process(deviceInfo, OperationCodes.MDV, () =>
{
deviceInfo.DeviceID = id;
var deviceControllerParameterRepo = RepositoryManager.GetRepository <IDeviceControllerParameterRepository>();
var deviceDoorRepo = RepositoryManager.GetRepository <IDeviceDoorRepository>();
var deviceHeadReadingRepo = RepositoryManager.GetRepository <IDeviceHeadReadingRepository>();
var deviceRepo = RepositoryManager.GetRepository <IDeviceControllerRepository>();
var originalDeviceInfo = deviceRepo.GetByKey(id);
if (originalDeviceInfo == null)
{
return Request.CreateResponse(HttpStatusCode.BadRequest, string.Format("Device Id={0} does not exist.", id));
}
if (deviceRepo.Query(new Hashtable()
{
{ "Code", deviceInfo.Code }
}).Any(x => x.DeviceID != id))
{
return new HttpResponseMessage(HttpStatusCode.BadRequest)
{
Content = new StringContent(string.Format("系统中已经存在编号为{0}的设备", deviceInfo.Code)),
ReasonPhrase = ConstStrings.BusinessLogicError,
};
}
#region Doors
var addedDeviceDoors = new List <DeviceDoor>();
var deletedDeviceDoorIds = new List <int>();
if (deviceInfo.DeviceDoors != null && deviceInfo.DeviceDoors.Any())
{
var originalDeviceDoorIDs = originalDeviceInfo.DeviceDoors.Select(d => d.DeviceDoorID);
var currentDeviceDoorIDs = deviceInfo.DeviceDoors.Select(d => d.DeviceDoorID);
deletedDeviceDoorIds = originalDeviceDoorIDs.Except(currentDeviceDoorIDs).ToList();
addedDeviceDoors = deviceInfo.DeviceDoors.FindAll(d => d.DeviceDoorID == 0);
deletedDeviceDoorIds.ForEach(d => deviceDoorRepo.Delete(d));
addedDeviceDoors.ForEach(d => deviceDoorRepo.Insert(d));
deviceInfo.DeviceDoors.FindAll(d => d.DeviceDoorID != 0).ForEach(d => deviceDoorRepo.Update(d));
}
else
{
deletedDeviceDoorIds = originalDeviceInfo.DeviceDoors.Select(d => d.DeviceDoorID).ToList();
deletedDeviceDoorIds.ForEach(d => deviceDoorRepo.Delete(d));
}
#endregion
#region HeadReading
var addedDeviceHeadReadings = new List <DeviceHeadReading>();
var deletedDeviceHeadReadingIds = new List <int>();
if (deviceInfo.DeviceHeadReadings != null && deviceInfo.DeviceHeadReadings.Any())
{
var originalDeviceHeadReadingIDs = originalDeviceInfo.DeviceHeadReadings.Select(d => d.DeviceHeadReadingID);
var currentDeviceHeadReadingIDs = deviceInfo.DeviceHeadReadings.Select(d => d.DeviceHeadReadingID);
deletedDeviceHeadReadingIds = originalDeviceHeadReadingIDs.Except(currentDeviceHeadReadingIDs).ToList();
addedDeviceHeadReadings = deviceInfo.DeviceHeadReadings.FindAll(d => d.DeviceHeadReadingID == 0);
deletedDeviceHeadReadingIds.ForEach(d => deviceHeadReadingRepo.Delete(d));
addedDeviceHeadReadings.ForEach(d => deviceHeadReadingRepo.Insert(d));
deviceInfo.DeviceHeadReadings.FindAll(d => d.DeviceHeadReadingID != 0).ForEach(d => deviceHeadReadingRepo.Update(d));
}
else
{
deletedDeviceHeadReadingIds = originalDeviceInfo.DeviceHeadReadings.Select(d => d.DeviceHeadReadingID).ToList();
deletedDeviceHeadReadingIds.ForEach(d => deviceHeadReadingRepo.Delete(d));
}
#endregion
#region parameters
if (deviceInfo.DeviceControllerParameter != null)
{
deviceControllerParameterRepo.Update(deviceInfo.DeviceControllerParameter);
}
#endregion
deviceRepo.Update(deviceInfo);
return Request.CreateResponse(HttpStatusCode.OK);
}, this));
}
public ActionResult SubmitForm(ActivePageTireSizeConfigEntity entity, int?IsTireSize = null)
{
if (entity == null || entity?.FKActiveID == 0)
{
return(Content(JsonConvert.SerializeObject(new
{
state = "error",
message = "信息为空"
})));
}
RepositoryManager repository = new RepositoryManager();
try
{
var activityEntity = repository.GetEntity <ActivePageListEntity>(entity.FKActiveID);
if (activityEntity != null)
{
activityEntity.IsTireSize = IsTireSize;
repository.Update <ActivePageListEntity>(activityEntity);
}
if (entity.PKID == 0)
{
entity.CreateDateTime = DateTime.Now;
repository.Add <ActivePageTireSizeConfigEntity>(entity);
LoggerManager.InsertLog("ActivityPage", new FlashSaleProductOprLog()
{
OperateUser = User.Identity.Name,
CreateDateTime = DateTime.Now,
BeforeValue = JsonConvert.SerializeObject(""),
AfterValue = JsonConvert.SerializeObject(entity),
LogType = "ActivityPage",
LogId = entity.FKActiveID.ToString(),
Operation = "新增轮胎适配",
});
// LoggerManager.InsertOplog(new ConfigHistory() { AfterValue = JsonConvert.SerializeObject(entity), Author = User.Identity.Name, Operation = "新增轮胎适配:"+entity.FKActiveID, ObjectType = "AUCAct", ObjectID = entity.PKID.ToString() });
}
else
{
var before = repository.GetEntity <ActivePageTireSizeConfigEntity>(entity.PKID);
entity.UpdateDateTime = DateTime.Now;
repository.Update <ActivePageTireSizeConfigEntity>(entity);
LoggerManager.InsertLog("ActivityPage", new FlashSaleProductOprLog()
{
OperateUser = User.Identity.Name,
CreateDateTime = DateTime.Now,
BeforeValue = JsonConvert.SerializeObject(before),
AfterValue = JsonConvert.SerializeObject(entity),
LogType = "ActivityPage",
LogId = entity.FKActiveID.ToString(),
Operation = "修改轮胎适配",
});
//LoggerManager.InsertOplog(new ConfigHistory() { BeforeValue=JsonConvert.SerializeObject(before), AfterValue = JsonConvert.SerializeObject(entity), Author = User.Identity.Name, Operation = "修改轮胎适配:" + entity.FKActiveID, ObjectType = "AUCAct", ObjectID = entity.PKID.ToString() });
}
return(Content(JsonConvert.SerializeObject(new
{
state = "success",
message = "操作成功"
})));
}
catch (Exception em)
{
return(Content(JsonConvert.SerializeObject(new
{
state = "error",
message = JsonConvert.SerializeObject(em)
})));
}
}
public void ADOFactoryTest()
{
RepositoryManager repositoryManager = RepositoryManagerFactory.Create();
Assert.IsTrue(repositoryManager.GetAllCars().Carss.Count == 6);
}
public ManagerBase(BusinessContext businessContext, RepositoryManager repositoryManger)
{
this.repositoryManger = repositoryManger;
this.businessContext = businessContext;
}
public OracleDbManager(RepositoryManager mgr, string name)
: base(mgr, name)
{
RegisterFieldNameAlias("IComment", "Comment");
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public bool Save()
{
var repository = RepositoryManager.GetRepository <ISignedUpInfoRepository>(ModuleEnvironment.ModuleName);
return(repository.Save(this));
}
public void BikeSearch_SmokeTest()
{
//
RepositoryManager.RegisterFactory(new RepositoryFactoryMock());
//
}
private void BuildLabeledControl(PropertyInfo propertyInfo)
{
Grid grid = new Grid();
grid.Width = 270.0;
grid.Height = 23.0;
grid.Margin = new Thickness(0, 0, 15, 5);
ColumnDefinition columnDefinition = new ColumnDefinition();
columnDefinition.Width = new GridLength(120);
grid.ColumnDefinitions.Add(columnDefinition);
columnDefinition = new ColumnDefinition();
columnDefinition.Width = new GridLength(150);
grid.ColumnDefinitions.Add(columnDefinition);
ControlType controlType = DisplayUtil.GetControlType(propertyInfo);
Binding binding = this.CreateBinding(propertyInfo, controlType, this.DataContext);
TextBox textBox = null;
switch (controlType)
{
case ControlType.Button:
Button button = new Button();
button.SetBinding(Button.CommandProperty, binding);
button.Content = DisplayUtil.GetControlDescription(propertyInfo);
button.HorizontalAlignment = HorizontalAlignment.Right;
button.Margin = new Thickness(5, 0, 0, 0);
button.Padding = new Thickness(15, 3, 15, 3);
this.commandPanel.Children.Add(button);
break;
case ControlType.CheckBox:
CheckBox checkBox = new CheckBox();
checkBox.SetBinding(CheckBox.IsCheckedProperty, binding);
Grid.SetColumn(checkBox, 1);
grid.Children.Add(checkBox);
break;
// combo box
case ControlType.ComboBox:
ComboBox comboBox = new ComboBox();
if (propertyInfo.PropertyType.IsEnum)
{
comboBox.ItemsSource = Enum.GetValues(propertyInfo.PropertyType);
// populate?
}
else
{
comboBox.ItemsSource = RepositoryManager.GetLookupRepository(propertyInfo.PropertyType).LookupList;
}
comboBox.SetBinding(ComboBox.SelectedItemProperty, binding);
Grid.SetColumn(comboBox, 1);
grid.Children.Add(comboBox);
break;
case ControlType.DateBox:
break;
case ControlType.Label:
textBox = new TextBox();
textBox.IsEnabled = false;
textBox.SetBinding(TextBox.TextProperty, binding);
Grid.SetColumn(textBox, 1);
grid.Children.Add(textBox);
break;
case ControlType.None:
break;
case ControlType.TextBox:
textBox = new TextBox();
textBox.SetBinding(TextBox.TextProperty, binding);
Grid.SetColumn(textBox, 1);
grid.Children.Add(textBox);
break;
default:
break;
}
if (controlType != ControlType.Button)
{
Label label = new Label();
label.Content = DisplayUtil.GetControlDescription(propertyInfo);
label.Margin = new Thickness(0, -2, 0, 0);
Grid.SetColumn(label, 0);
grid.Children.Add(label);
RowDefinition rowDefinition = new RowDefinition();
rowDefinition.Height = GridLength.Auto;
this.propertyGrid.RowDefinitions.Add(rowDefinition);
Grid.SetRow(grid, this.propertyGrid.RowDefinitions.Count - 1);
this.propertyGrid.Children.Add(grid);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="GenericRepository{T}"/> class.
/// </summary>
/// <param name="repositoryManager">The repository manager.</param>
public GenericRepository(RepositoryManager repositoryManager)
: base(repositoryManager)
{
}
public PPPFormBase(RepositoryManager<PPPObjectContext> repositoryManager)
: this()
{
_repositoryManager = repositoryManager;
}
/// <summary>
/// 提交大翻盘的配置
/// </summary>
/// <param name="modeljson"></param>
/// <param name="wheeljson"></param>
/// <returns></returns>
public async Task <ActionResult> SubmitForm(string modeljson, string wheeljson)
{
modeljson = modeljson.Replace("\" \"", "null");
wheeljson = wheeljson.Replace("\" \"", "null");
try
{
BigBrandRewardListEntity entity = JsonConvert.DeserializeObject <BigBrandRewardListEntity>(modeljson);
IEnumerable <BigBrandWheelEntity> wheel = null;
if (!string.IsNullOrWhiteSpace(wheeljson))
{
wheel = JsonConvert.DeserializeObject <IEnumerable <BigBrandWheelEntity> >(wheeljson);
}
RepositoryManager manager = new RepositoryManager();
using (var db = manager.BeginTrans())
{
if (entity.PKID == 0)
{
entity.HashKeyValue = Tuhu.Provisioning.Common.SecurityHelper.Sha1Encrypt(Guid.NewGuid().ToString(), System.Text.Encoding.UTF8).Substring(0, 8);
entity.CreateDateTime = DateTime.Now;
entity.LastUpdateDateTime = DateTime.Now;
entity.UpdateUserName = User.Identity.Name;
entity.CreateUserName = User.Identity.Name;
manager.Add <BigBrandRewardListEntity>(entity);
LoggerManager.InsertOplog(new ConfigHistory()
{
AfterValue = JsonConvert.SerializeObject(entity), Author = User.Identity.Name, Operation = "新增大翻牌活动", ObjectType = "BigBrand"
});
}
else
{
entity.LastUpdateDateTime = DateTime.Now;
entity.UpdateUserName = User.Identity.Name;
manager.Update <BigBrandRewardListEntity>(entity);
LoggerManager.InsertOplog(new ConfigHistory()
{
AfterValue = JsonConvert.SerializeObject(entity), Author = User.Identity.Name, Operation = "更新大翻牌活动", ObjectType = "BigBrand"
});
}
Expression <Func <BigBrandWheelEntity, bool> > exp = _ => _.FKBigBrand == entity.PKID;
db.Delete <BigBrandWheelEntity>(exp);
if (wheel != null)
{
foreach (var item in wheel)
{
item.CreateDateTime = DateTime.Now;
item.CreateUserName = User.Identity.Name;
item.LastUpdateDateTime = DateTime.Now;
item.UpdateUserName = User.Identity.Name;
item.FKBigBrand = entity.PKID;
var array = item.FKPoolPKIDText.TrimEnd(',').Split(',');
if (array != null && array.Length > 0)
{
foreach (var s in array)
{
int poolPKID = 0;
if (int.TryParse(s, out poolPKID))
{
if (poolPKID != 0)
{
item.FKPoolPKID = poolPKID;
string json = JsonConvert.SerializeObject(item);
var tempModel = JsonConvert.DeserializeObject <BigBrandWheelEntity>(json);
db.Insert <BigBrandWheelEntity>(tempModel);
}
}
}
}
}
}
db.Commit();
LoggerManager.InsertOplog(new ConfigHistory()
{
AfterValue = JsonConvert.SerializeObject(wheel), Author = User.Identity.Name, Operation = "大翻牌明细", ObjectType = "BigBrand"
});
}
entity = manager.GetEntity <BigBrandRewardListEntity>(p => p.PKID == entity.PKID);
//读写分离 做延时
await Task.Delay(3000);
#region 更新大翻盘缓存
using (var client = new Tuhu.Service.Activity.BigBrandClient())
{
var result = client.UpdateBigBrand(entity.HashKeyValue);
result.ThrowIfException(true);
}
#endregion
#region 更新 活动页的 缓存
//筛选 出大翻盘相关的 活动页 配置
List <ActivePageContentEntity> activeEntityList = manager.GetEntityList <ActivePageContentEntity>(p => p.HashKey == entity.HashKeyValue && p.Type == 20).ToList();
foreach (var activeEntity in activeEntityList)
{
var activePageList = manager.GetEntity <ActivePageListEntity>(activeEntity.FKActiveID);
using (var client = new Tuhu.Service.Activity.ActivityClient())
{
var result1 = await client.RefreshActivePageListModelCacheAsync(new Service.Activity.Models.Requests.ActivtyPageRequest()
{
Channel = "wap",
HashKey = activePageList.HashKey,
});
result1.ThrowIfException(true);
var result2 = await client.RefreshActivePageListModelCacheAsync(new Service.Activity.Models.Requests.ActivtyPageRequest()
{
ActivityId = activePageList.PKGuid.Value,
Channel = "website",
HashKey = activePageList.HashKey,
});
result2.ThrowIfException(true);
}
var list = manager.GetEntityList <ActivePageContentEntity>(_ => _.FKActiveID == activeEntity.FKActiveID);
var lucy = list?.Where(_ => _.Type == 13)?.FirstOrDefault();
if (lucy != null)
{
using (var client = new Tuhu.Service.Activity.ActivityClient())
{
var result = await client.RefreshLuckWheelCacheAsync(lucy.ActivityID.ToString());
result.ThrowIfException(true);
}
}
}
#endregion
return(Content(JsonConvert.SerializeObject(new
{
state = "success",
message = "操作成功",
data = ""
})));
}
catch (Exception em)
{
throw em;
}
}
/// <summary>
/// Pull the repository and compile for every set of given <paramref name="minutes"/>
/// </summary>
/// <param name="minutes">How many minutes the operation should repeat. Does not include running time</param>
/// <param name="cancellationToken">The <see cref="CancellationToken"/> for the operation</param>
/// <returns>A <see cref="Task"/> representing the running operation</returns>
#pragma warning disable CA1502 // TODO: Decomplexify
async Task TimerLoop(uint minutes, CancellationToken cancellationToken)
{
while (true)
{
try
{
await Task.Delay(TimeSpan.FromMinutes(minutes > Int32.MaxValue ? Int32.MaxValue : (int)minutes), cancellationToken).ConfigureAwait(false);
logger.LogDebug("Beginning auto update...");
await eventConsumer.HandleEvent(EventType.InstanceAutoUpdateStart, new List <string>(), cancellationToken).ConfigureAwait(false);
try
{
Models.User user = null;
await databaseContextFactory.UseContext(async (db) => user = await db.Users.Where(x => x.CanonicalName == Api.Models.User.AdminName.ToUpperInvariant()).FirstAsync(cancellationToken).ConfigureAwait(false)).ConfigureAwait(false);
var repositoryUpdateJob = new Job
{
Instance = new Models.Instance
{
Id = metadata.Id
},
Description = "Scheduled repository update",
CancelRightsType = RightsType.Repository,
CancelRight = (ulong)RepositoryRights.CancelPendingChanges,
StartedBy = user
};
string deploySha = null;
await jobManager.RegisterOperation(repositoryUpdateJob, async (paramJob, databaseContext, progressReporter, jobCancellationToken) =>
{
var repositorySettingsTask = databaseContext.RepositorySettings.Where(x => x.InstanceId == metadata.Id).FirstAsync(jobCancellationToken);
// assume 5 steps with synchronize
const int ProgressSections = 7;
const int ProgressStep = 100 / ProgressSections;
const int NumSteps = 3;
var doneSteps = 0;
Action <int> NextProgressReporter()
{
var tmpDoneSteps = doneSteps;
++doneSteps;
return(progress => progressReporter((progress + (100 * tmpDoneSteps)) / NumSteps));
}
using (var repo = await RepositoryManager.LoadRepository(jobCancellationToken).ConfigureAwait(false))
{
if (repo == null)
{
logger.LogTrace("Aborting repo update, no repository!");
return;
}
var startSha = repo.Head;
if (!repo.Tracking)
{
logger.LogTrace("Aborting repo update, not tracking origin!");
deploySha = startSha;
return;
}
var repositorySettings = await repositorySettingsTask.ConfigureAwait(false);
// the main point of auto update is to pull the remote
await repo.FetchOrigin(repositorySettings.AccessUser, repositorySettings.AccessToken, NextProgressReporter(), jobCancellationToken).ConfigureAwait(false);
RevisionInformation currentRevInfo = null;
bool hasDbChanges = false;
Task <RevisionInformation> LoadRevInfo() => databaseContext.RevisionInformations
.Where(x => x.CommitSha == startSha && x.Instance.Id == metadata.Id)
.Include(x => x.ActiveTestMerges).ThenInclude(x => x.TestMerge)
.FirstOrDefaultAsync(cancellationToken);
async Task UpdateRevInfo(string currentHead, bool onOrigin)
{
if (currentRevInfo == null)
{
currentRevInfo = await LoadRevInfo().ConfigureAwait(false);
}
if (currentRevInfo == default)
{
logger.LogWarning(Repository.Repository.OriginTrackingErrorTemplate, currentHead);
onOrigin = true;
}
var attachedInstance = new Models.Instance
{
Id = metadata.Id
};
var oldRevInfo = currentRevInfo;
currentRevInfo = new RevisionInformation
{
CommitSha = currentHead,
OriginCommitSha = onOrigin ? currentHead : oldRevInfo.OriginCommitSha,
Instance = attachedInstance
};
if (!onOrigin)
{
currentRevInfo.ActiveTestMerges = new List <RevInfoTestMerge>(oldRevInfo.ActiveTestMerges);
}
databaseContext.Instances.Attach(attachedInstance);
databaseContext.RevisionInformations.Add(currentRevInfo);
hasDbChanges = true;
}
// take appropriate auto update actions
bool shouldSyncTracked;
if (repositorySettings.AutoUpdatesKeepTestMerges.Value)
{
logger.LogTrace("Preserving test merges...");
var currentRevInfoTask = LoadRevInfo();
var result = await repo.MergeOrigin(repositorySettings.CommitterName, repositorySettings.CommitterEmail, NextProgressReporter(), jobCancellationToken).ConfigureAwait(false);
if (!result.HasValue)
{
throw new JobException("Merge conflict while preserving test merges!");
}
currentRevInfo = await currentRevInfoTask.ConfigureAwait(false);
var lastRevInfoWasOriginCommit = currentRevInfo == default || currentRevInfo.CommitSha == currentRevInfo.OriginCommitSha;
var stillOnOrigin = result.Value && lastRevInfoWasOriginCommit;
var currentHead = repo.Head;
if (currentHead != startSha)
{
await UpdateRevInfo(currentHead, stillOnOrigin).ConfigureAwait(false);
shouldSyncTracked = stillOnOrigin;
}
else
{
shouldSyncTracked = false;
}
}
else
{
logger.LogTrace("Not preserving test merges...");
await repo.ResetToOrigin(NextProgressReporter(), jobCancellationToken).ConfigureAwait(false);
var currentHead = repo.Head;
currentRevInfo = await databaseContext.RevisionInformations
.Where(x => x.CommitSha == currentHead && x.Instance.Id == metadata.Id)
.FirstOrDefaultAsync(jobCancellationToken).ConfigureAwait(false);
if (currentHead != startSha && currentRevInfo != default)
{
await UpdateRevInfo(currentHead, true).ConfigureAwait(false);
}
shouldSyncTracked = true;
}
// synch if necessary
if (repositorySettings.AutoUpdatesSynchronize.Value && startSha != repo.Head)
{
var pushedOrigin = await repo.Sychronize(repositorySettings.AccessUser, repositorySettings.AccessToken, repositorySettings.CommitterName, repositorySettings.CommitterEmail, NextProgressReporter(), shouldSyncTracked, jobCancellationToken).ConfigureAwait(false);
var currentHead = repo.Head;
if (currentHead != currentRevInfo.CommitSha)
{
await UpdateRevInfo(currentHead, pushedOrigin).ConfigureAwait(false);
}
}
if (hasDbChanges)
{
try
{
await databaseContext.Save(cancellationToken).ConfigureAwait(false);
}
catch
{
await repo.ResetToSha(startSha, progressReporter, default).ConfigureAwait(false);
throw;
}
}
progressReporter(5 * ProgressStep);
deploySha = repo.Head;
}
}, cancellationToken).ConfigureAwait(false);
await jobManager.WaitForJobCompletion(repositoryUpdateJob, user, cancellationToken, default).ConfigureAwait(false);
if (deploySha == null)
{
logger.LogTrace("Aborting auto update, repository error!");
continue;
}
if (deploySha == LatestCompileJob()?.RevisionInformation.CommitSha)
{
logger.LogTrace("Aborting auto update, same revision as latest CompileJob");
continue;
}
// finally set up the job
var compileProcessJob = new Job
{
StartedBy = user,
Instance = repositoryUpdateJob.Instance,
Description = "Scheduled code deployment",
CancelRightsType = RightsType.DreamMaker,
CancelRight = (ulong)DreamMakerRights.CancelCompile
};
await jobManager.RegisterOperation(compileProcessJob, CompileProcess, cancellationToken).ConfigureAwait(false);
await jobManager.WaitForJobCompletion(compileProcessJob, user, cancellationToken, default).ConfigureAwait(false);
}
catch (OperationCanceledException)
{
logger.LogDebug("Cancelled auto update job!");
throw;
}
catch (Exception e)
{
logger.LogWarning("Error in auto update loop! Exception: {0}", e);
continue;
}
}
catch (OperationCanceledException)
{
break;
}
}
logger.LogTrace("Leaving auto update loop...");
}
public CategoryService(RepositoryManager repo)
{
_repositoryManager = repo;
}
public MyBatisRepository()
{
SessionToPersistanceAdapter session = RepositoryManager.GetConnection() as SessionToPersistanceAdapter;
_sqlMapper = session.GetUndelayingSession();
}
/// <inheritdoc />
#pragma warning disable CA1506 // TODO: Decomplexify
public async Task <IInstance> CreateInstance(IBridgeRegistrar bridgeRegistrar, Models.Instance metadata)
{
// Create the ioManager for the instance
var instanceIoManager = new ResolvingIOManager(ioManager, metadata.Path);
// various other ioManagers
var repoIoManager = new ResolvingIOManager(instanceIoManager, "Repository");
var byondIOManager = new ResolvingIOManager(instanceIoManager, "Byond");
var gameIoManager = new ResolvingIOManager(instanceIoManager, "Game");
var diagnosticsIOManager = new ResolvingIOManager(instanceIoManager, "Diagnostics");
var configurationIoManager = new ResolvingIOManager(instanceIoManager, "Configuration");
var configuration = new StaticFiles.Configuration(
configurationIoManager,
synchronousIOManager,
symlinkFactory,
processExecutor,
postWriteHandler,
platformIdentifier,
fileTransferService,
loggerFactory.CreateLogger <StaticFiles.Configuration>());
var eventConsumer = new EventConsumer(configuration);
var repoManager = new RepositoryManager(
repositoryFactory,
repositoryCommands,
repoIoManager,
eventConsumer,
gitRemoteFeaturesFactory,
loggerFactory.CreateLogger <Repository.Repository>(),
loggerFactory.CreateLogger <RepositoryManager>());
try
{
var byond = new ByondManager(byondIOManager, byondInstaller, eventConsumer, loggerFactory.CreateLogger <ByondManager>());
var commandFactory = new CommandFactory(assemblyInformationProvider, byond, repoManager, databaseContextFactory, metadata);
var chatManager = chatFactory.CreateChatManager(instanceIoManager, commandFactory, metadata.ChatSettings);
try
{
var sessionControllerFactory = new SessionControllerFactory(
processExecutor,
byond,
topicClientFactory,
cryptographySuite,
assemblyInformationProvider,
gameIoManager,
chatManager,
networkPromptReaper,
platformIdentifier,
bridgeRegistrar,
serverPortProvider,
loggerFactory,
loggerFactory.CreateLogger <SessionControllerFactory>(),
metadata.CloneMetadata());
var dmbFactory = new DmbFactory(
databaseContextFactory,
gameIoManager,
remoteDeploymentManagerFactory,
loggerFactory.CreateLogger <DmbFactory>(),
metadata.CloneMetadata());
try
{
var reattachInfoHandler = new SessionPersistor(
databaseContextFactory,
dmbFactory,
processExecutor,
loggerFactory.CreateLogger <SessionPersistor>(),
metadata.CloneMetadata());
var watchdog = watchdogFactory.CreateWatchdog(
chatManager,
dmbFactory,
reattachInfoHandler,
sessionControllerFactory,
gameIoManager,
diagnosticsIOManager,
eventConsumer,
remoteDeploymentManagerFactory,
metadata.CloneMetadata(),
metadata.DreamDaemonSettings);
eventConsumer.SetWatchdog(watchdog);
commandFactory.SetWatchdog(watchdog);
try
{
Instance instance = null;
var dreamMaker = new DreamMaker(
byond,
gameIoManager,
configuration,
sessionControllerFactory,
eventConsumer,
chatManager,
processExecutor,
dmbFactory,
repoManager,
remoteDeploymentManagerFactory,
loggerFactory.CreateLogger <DreamMaker>(),
metadata.CloneMetadata());
instance = new Instance(
metadata.CloneMetadata(),
repoManager,
byond,
dreamMaker,
watchdog,
chatManager,
configuration,
dmbFactory,
jobManager,
eventConsumer,
remoteDeploymentManagerFactory,
loggerFactory.CreateLogger <Instance>());
return(instance);
}
catch
{
await watchdog.DisposeAsync().ConfigureAwait(false);
throw;
}
}
catch
{
dmbFactory.Dispose();
throw;
}
}
catch
{
await chatManager.DisposeAsync().ConfigureAwait(false);
throw;
}
}
catch
{
repoManager.Dispose();
throw;
}
}
/// <summary>
/// Open repository manager
/// </summary>
/// <param name="param"></param>
private void OnOpenRepositoryManager(object param)
{
Window window = new RepositoryManager();
window.DataContext = new RepositoryManagerViewModel(Repository, this, _memoryRepositories) { View = window };
window.ShowDialog();
Logger.Log.InfoFormat("User {0} open repository manager", Settings.Default.Login);
}
/// <inheritdoc />
public async Task CompileProcess(Job job, IDatabaseContext databaseContext, Action <int> progressReporter, CancellationToken cancellationToken)
{
//DO NOT FOLLOW THE SUGGESTION FOR A THROW EXPRESSION HERE
if (job == null)
{
throw new ArgumentNullException(nameof(job));
}
if (databaseContext == null)
{
throw new ArgumentNullException(nameof(databaseContext));
}
if (progressReporter == null)
{
throw new ArgumentNullException(nameof(progressReporter));
}
var ddSettingsTask = databaseContext.DreamDaemonSettings.Where(x => x.InstanceId == metadata.Id).Select(x => new DreamDaemonSettings
{
StartupTimeout = x.StartupTimeout,
}).FirstOrDefaultAsync(cancellationToken);
var compileJobsTask = databaseContext.CompileJobs
.Where(x => x.Job.Instance.Id == metadata.Id)
.OrderByDescending(x => x.Job.StoppedAt)
//TODO: Replace with this select when the issues linked in https://github.com/tgstation/tgstation-server/issues/737 are fixed
//.Select(x => x.Job.StoppedAt.Value - x.Job.StartedAt.Value)
.Select(x => new Job
{
StoppedAt = x.Job.StoppedAt,
StartedAt = x.Job.StartedAt
})
.Take(10)
.ToListAsync(cancellationToken);
var dreamMakerSettings = await databaseContext.DreamMakerSettings.Where(x => x.InstanceId == metadata.Id).FirstAsync(cancellationToken).ConfigureAwait(false);
if (dreamMakerSettings == default)
{
throw new JobException("Missing DreamMakerSettings in DB!");
}
var ddSettings = await ddSettingsTask.ConfigureAwait(false);
if (ddSettings == default)
{
throw new JobException("Missing DreamDaemonSettings in DB!");
}
CompileJob compileJob;
RevisionInformation revInfo;
using (var repo = await RepositoryManager.LoadRepository(cancellationToken).ConfigureAwait(false))
{
if (repo == null)
{
throw new JobException("Missing Repository!");
}
var repoSha = repo.Head;
revInfo = await databaseContext.RevisionInformations.Where(x => x.CommitSha == repoSha && x.Instance.Id == metadata.Id).Include(x => x.ActiveTestMerges).ThenInclude(x => x.TestMerge).FirstOrDefaultAsync().ConfigureAwait(false);
if (revInfo == default)
{
revInfo = new RevisionInformation
{
CommitSha = repoSha,
OriginCommitSha = repoSha,
Instance = new Models.Instance
{
Id = metadata.Id
}
};
logger.LogWarning(Repository.Repository.OriginTrackingErrorTemplate, repoSha);
databaseContext.Instances.Attach(revInfo.Instance);
}
TimeSpan?averageSpan = null;
var previousCompileJobs = await compileJobsTask.ConfigureAwait(false);
if (previousCompileJobs.Count != 0)
{
var totalSpan = TimeSpan.Zero;
foreach (var I in previousCompileJobs)
{
totalSpan += I.StoppedAt.Value - I.StartedAt.Value;
}
averageSpan = totalSpan / previousCompileJobs.Count;
}
compileJob = await DreamMaker.Compile(revInfo, dreamMakerSettings, ddSettings.StartupTimeout.Value, repo, progressReporter, averageSpan, cancellationToken).ConfigureAwait(false);
}
compileJob.Job = job;
databaseContext.CompileJobs.Add(compileJob); //will be saved by job context
job.PostComplete = ct => CompileJobConsumer.LoadCompileJob(compileJob, ct);
}
private Game()
{
Repository= new RepositoryManager();
Commands = new CommandManager();
Users = new UserManager();
}
protected abstract void Populate(RepositoryManager repositories, BlockchainEntities entities);
protected override void Process(InitializationPipeline pipeline)
{
Debug.ArgumentNotNull(pipeline, nameof(pipeline));
if (!pipeline.IsStartUp)
{
return;
}
RepositoryManager.Register(RepositoryManager.LicenseFiles);
RepositoryManager.Register(RepositoryManager.Packages);
RepositoryManager.Register(RepositoryManager.Reports);
RepositoryManager.Register(RepositoryManager.SitecoreZip);
RepositoryManager.Register(RepositoryManager.StartPages);
RepositoryManager.Register(RepositoryManager.Folders);
var zipFiles = RepositoryManager.GetRepository(RepositoryManager.SitecoreZip);
if (!zipFiles.Entries.Any())
{
var location = Path.Combine(AppHost.User.UserFolder, @"Repositories\SitecoreZipFiles");
Directory.CreateDirectory(location);
var repository = new RepositoryEntry("Sitecore Zip Files", location);
zipFiles.Entries.Add(repository);
zipFiles.Save();
}
var licenseFiles = RepositoryManager.GetRepository(RepositoryManager.LicenseFiles);
if (!licenseFiles.Entries.Any())
{
var location = Path.Combine(AppHost.User.UserFolder, @"Repositories\LicenseFiles");
Directory.CreateDirectory(location);
var repository = new RepositoryEntry("License Files", location);
licenseFiles.Entries.Add(repository);
licenseFiles.Save();
}
var packages = RepositoryManager.GetRepository(RepositoryManager.Packages);
if (!packages.Entries.Any())
{
var location = Path.Combine(AppHost.User.UserFolder, @"Repositories\Packages");
Directory.CreateDirectory(location);
var repository = new RepositoryEntry("Local Packages", location);
packages.Entries.Add(repository);
packages.Save();
}
var startPages = RepositoryManager.GetRepository(RepositoryManager.StartPages);
if (!startPages.Entries.Any())
{
var location = Path.Combine(AppHost.User.UserFolder, @"Repositories\StartPages");
Directory.CreateDirectory(location);
var repository = new RepositoryEntry("Start Pages", location);
startPages.Entries.Add(repository);
startPages.Save();
}
var reports = RepositoryManager.GetRepository(RepositoryManager.Reports);
if (!reports.Entries.Any())
{
var location = Path.Combine(AppHost.User.UserFolder, @"Repositories\Reports");
Directory.CreateDirectory(location);
var repository = new RepositoryEntry("Reports", location);
reports.Entries.Add(repository);
reports.Save();
}
var folders = RepositoryManager.GetRepository(RepositoryManager.Folders);
if (!folders.Entries.Any())
{
var combine = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) ?? string.Empty, @"Repositories\Folders");
Directory.CreateDirectory(combine);
var repository = new RepositoryEntry("Default", @".\Repositories\Folders");
folders.Entries.Add(repository);
folders.Save();
}
}
public void AssertFileExistsInRepo(string s)
{
Chorus.sync.RepositoryManager r = new RepositoryManager(PathToBackupProjectDir, new ProjectFolderConfiguration(SourceProjectDir));
Assert.IsTrue(r.GetFileExistsInRepo(Path.Combine(PathToBackupProjectDir ,"test.lift")));
}