public async Task <ActionResult <ServiceResponse <bool> > > PostOpenings(Openings openings)
{
var response = new ServiceResponse <bool>();
try
{
if (openings == null)
{
response.Success = false;
response.Message = "Invalid Response , Please check";
return(Ok(response));
}
openings.createdBy = LoggedInUser;
openings.createdDate = DateTime.UtcNow;
_context.Openings.Add(openings);
await _context.SaveChangesAsync();
response.Success = true;
response.Message = "Job Opening added successfully";
response.Data = true;
}
catch (Exception ex)
{
response.Success = false;
response.Message = await CustomLog.Log(ex, _context);
}
return(Ok(response));
}
private void LoadTruckOpeningVMs(IEnumerable <TruckOpening> TruckOpenings)
{
if (TruckOpenings == null)
{
return;
}
_TruckOpenings = TruckOpenings;
Openings.Clear();
foreach (var o in TruckOpenings)
{
Openings.Add(new TruckOpeningVM()
{
Id = o.Id,
ClosingTime = o.ClosingTime,
OpeningTime = o.OpeningTime,
Latitude = o.Latitude,
Longitude = o.Longitude,
Rating = o.Rating,
FoodType = o.FoodType,
ImageUrl = TruckService.UrlRoot + o.ImageUrl,
Title = o.Title,
TruckId = o.TruckId,
});
}
}
/// <summary>
/// Processes IfcElement attributes.
/// </summary>
/// <param name="ifcElement">The IfcElement handle.</param>
protected override void Process(IFCAnyHandle ifcElement)
{
base.Process(ifcElement);
m_Tag = IFCAnyHandleUtil.GetStringAttribute(ifcElement, "Tag");
ICollection <IFCAnyHandle> hasOpenings = IFCAnyHandleUtil.GetAggregateInstanceAttribute <List <IFCAnyHandle> >(ifcElement, "HasOpenings");
if (hasOpenings != null)
{
foreach (IFCAnyHandle hasOpening in hasOpenings)
{
IFCAnyHandle relatedOpeningElement = IFCAnyHandleUtil.GetInstanceAttribute(hasOpening, "RelatedOpeningElement");
if (IFCAnyHandleUtil.IsNullOrHasNoValue(relatedOpeningElement))
{
continue;
}
IFCFeatureElementSubtraction opening = IFCFeatureElementSubtraction.ProcessIFCFeatureElementSubtraction(relatedOpeningElement);
if (opening != null)
{
opening.VoidsElement = this;
Openings.Add(opening);
}
}
}
}
public void MapPrimaryandSecondarySkills(OpeningViewModel openingViewModel, Openings opening)
{
var primarySkillList = opening.OpeningSkills.Where(x => x.SkillType == OpeningSkillType.Primary && (x.IsActive && !x.IsDeleted)).Select(x => x.Skill).ToList();
var secondarySkillList = opening.OpeningSkills.Where(x => x.SkillType == OpeningSkillType.Secondary && (x.IsActive && !x.IsDeleted)).Select(x => x.Skill).ToList();
openingViewModel.PrimarySkillTypes = new List <SkillViewModel>();
openingViewModel.SecondarySkillTypes = new List <SkillViewModel>();
openingViewModel.PrimarySkills = string.Join(",", primarySkillList.Select(x => x.Name).ToList());
openingViewModel.SecondarySkills = string.Join(",", secondarySkillList.Select(x => x.Name).ToList());
if (primarySkillList.Any())
{
foreach (var skill in primarySkillList)
{
var skillViewModel = new SkillViewModel();
skillViewModel.MapFromModel(skill);
skillViewModel.OpeningSkillType = OpeningSkillType.Primary;
openingViewModel.PrimarySkillTypes.Add(skillViewModel);
}
}
if (secondarySkillList.Any())
{
foreach (var skill in secondarySkillList)
{
var skillViewModel = new SkillViewModel();
skillViewModel.MapFromModel(skill);
skillViewModel.OpeningSkillType = OpeningSkillType.Secondary;
openingViewModel.SecondarySkillTypes.Add(skillViewModel);
}
}
}
/// <summary>
/// Detects and sets directions up,down,left,right as either open or closed.
/// </summary>
private void DetermineSurroundings(Maze maze, int yCount, int xCount)
{
Up = maze.horizontalWalls[yCount + 1, xCount] == 1 ? Opening.CLOSED : Opening.OPEN;
Down = maze.horizontalWalls[yCount, xCount] == 1 ? Opening.CLOSED : Opening.OPEN;
Left = maze.verticalsWalls[xCount, yCount] == 1 ? Opening.CLOSED : Opening.OPEN;
Right = maze.verticalsWalls[xCount + 1, yCount] == 1 ? Opening.CLOSED : Opening.OPEN;
/* very significant; this is the order in which directions are checked */
if (Right == Opening.OPEN)
{
Openings.Push(Direction.RIGHT);
}
if (Left == Opening.OPEN)
{
Openings.Push(Direction.LEFT);
}
if (Up == Opening.OPEN)
{
Openings.Push(Direction.UP);
}
if (Down == Opening.OPEN)
{
Openings.Push(Direction.DOWN);
}
}
private bool tileInOpenings(Point3d pt)
{
// Проверка попадаетли точка вставки блока плитки в один из проемов
Point3d ptMax = new Point3d(pt.X + 288, pt.Y + 88, 0);
return((Openings.Any(b => b.IsPointInBounds(pt, 4))) || (Openings.Any(b => b.IsPointInBounds(ptMax, 4))));
}
internal void AddMasterBar(MasterBar masterBar)
{
if (Openings.Count == 0)
{
Openings.Add(masterBar);
}
MasterBars.Add(masterBar);
masterBar.RepeatGroup = this;
if (masterBar.IsRepeatEnd)
{
Closings.Add(masterBar);
IsClosed = true;
if (!IsOpened)
{
MasterBars[0].IsRepeatStart = true;
IsOpened = true;
}
}
// a new item after the header was closed? -> repeat alternative reopens the group
else if (IsClosed)
{
IsClosed = false;
Openings.Add(masterBar);
}
}
public IResult InsertOrUpdateOpening(EntityAndApprovalViewModel entityAndApprovalViewModel)
{
var result = new Result
{
Operation = Operation.Create,
Status = Status.Success
};
try
{
var openingViewModel = entityAndApprovalViewModel.openingViewModel;
if (openingViewModel.OpeningId != Guid.Empty)
{
result.Body = UpdateOpening(entityAndApprovalViewModel);
}
else
{
var openingModel = new Openings();
openingModel.MapFromViewModel(openingViewModel, (ClaimsIdentity)_principal.Identity);
var openingSkillList = new List <OpeningSkills>();
var openingSkills = openingViewModel.PrimarySkillTypes.Union(openingViewModel.SecondarySkillTypes).ToList();
foreach (var item in openingSkills)
{
var openingSkill = new OpeningSkills
{
SkillId = item.SkillId,
SkillType = item.OpeningSkillType
};
openingSkill.MapAuditColumns((ClaimsIdentity)_principal.Identity);
openingSkillList.Add(openingSkill);
}
_openingRepository.CreateOpening(openingModel, openingSkillList);
entityAndApprovalViewModel.openingViewModel.OpeningId = openingModel.OpeningId;
var approvalTransactionViewModel = _approvalManagerService.AddApprovalTransaction(entityAndApprovalViewModel);
// var users = _approvalRepository.GetUserForOpeningApproval(approvalTransactionViewModel);
//users.ForEach(user =>
//{
// MailDetailModel mailDetail = new MailDetailModel();
// mailDetail.EmailId = user.Email;
// mailDetail.Subject = "Opening Approval";
// mailDetail.Template = TemplateType.Appoval;
// mailDetail.MessageBody = approvalTransactionViewModel;
// GenericHelper.Send(mailDetail, _configuration);
//});
result.Body = approvalTransactionViewModel;
}
}
catch (Exception e)
{
result.Message = e.Message;
result.Status = Status.Fail;
}
return(result);
}
/// <summary>
/// The Profile of the Wall computed from its Perimeter and the Openings.
/// </summary>
/// <returns></returns>
public Profile GetProfile()
{
#pragma warning disable 612, 618
if (Perimeter == null && Profile != null) // this might be a legacy style WallByProfile, we should check for Profile directly
{
return(Profile);
}
#pragma warning restore 612, 618
return(new Profile(Perimeter, Openings.Select(o => o.Perimeter).ToList()));
}
/// <summary>
/// Processes IfcElement attributes.
/// </summary>
/// <param name="ifcElement">The IfcElement handle.</param>
protected override void Process(IFCAnyHandle ifcElement)
{
base.Process(ifcElement);
m_Tag = IFCAnyHandleUtil.GetStringAttribute(ifcElement, "Tag");
ICollection <IFCAnyHandle> hasOpenings = IFCAnyHandleUtil.GetAggregateInstanceAttribute <List <IFCAnyHandle> >(ifcElement, "HasOpenings");
if (hasOpenings != null)
{
foreach (IFCAnyHandle hasOpening in hasOpenings)
{
IFCAnyHandle relatedOpeningElement = IFCAnyHandleUtil.GetInstanceAttribute(hasOpening, "RelatedOpeningElement");
if (IFCAnyHandleUtil.IsNullOrHasNoValue(relatedOpeningElement))
{
continue;
}
IFCFeatureElementSubtraction opening = IFCFeatureElementSubtraction.ProcessIFCFeatureElementSubtraction(relatedOpeningElement);
if (opening != null)
{
opening.VoidsElement = this;
Openings.Add(opening);
}
}
}
// "HasPorts" is new to IFC2x2.
// For IFC4, "HasPorts" has moved to IfcDistributionElement. We'll keep the check here, but we will only check it
// if we are exporting before IFC4 or if we have an IfcDistributionElement handle.
bool checkPorts = (IFCImportFile.TheFile.SchemaVersion > IFCSchemaVersion.IFC2x2) &&
(IFCImportFile.TheFile.SchemaVersion < IFCSchemaVersion.IFC4 || IFCAnyHandleUtil.IsSubTypeOf(ifcElement, IFCEntityType.IfcDistributionElement));
if (checkPorts)
{
ICollection <IFCAnyHandle> hasPorts = IFCAnyHandleUtil.GetAggregateInstanceAttribute <List <IFCAnyHandle> >(ifcElement, "HasPorts");
if (hasPorts != null)
{
foreach (IFCAnyHandle hasPort in hasPorts)
{
IFCAnyHandle relatingPort = IFCAnyHandleUtil.GetInstanceAttribute(hasPort, "RelatingPort");
if (IFCAnyHandleUtil.IsNullOrHasNoValue(relatingPort))
{
continue;
}
IFCPort port = IFCPort.ProcessIFCPort(relatingPort);
if (port != null)
{
Ports.Add(port);
}
}
}
}
}
/// <summary>
/// Adds a Room to the Openings list.
/// </summary>
/// <param name="room">Room to add.</param>
/// <returns>
/// True if one or more Rooms were added.
/// </returns>
public bool AddOpening(Room room)
{
Openings.Add(new Room(room)
{
Elevation = Elevation
});
FitServices();
FitCorridors();
FitRooms();
return(true);
}
public ApprovalTransactionViewModel UpdateOpening(EntityAndApprovalViewModel entityAndApprovalViewModel)
{
var openingViewModel = entityAndApprovalViewModel.openingViewModel;
var openingModel = new Openings();
openingModel.MapFromViewModel(openingViewModel, (ClaimsIdentity)_principal.Identity);
var openingDetail = _openingRepository.GetByID(openingViewModel.OpeningId);
var skillViewModelList = openingViewModel.PrimarySkillTypes.Union(openingViewModel.SecondarySkillTypes).ToList();
var skillModelList = openingDetail.OpeningSkills.Where(x => (x.IsActive && !x.IsDeleted)).Select(x => x.Skill).ToList();
var existingSkills = skillViewModelList.Select(x => x.SkillId).Intersect(skillModelList.Select(x => x.SkillId)).ToList();
var addingSkills = skillViewModelList.Select(x => x.SkillId).Except(existingSkills).ToList();
var removingSkills = skillModelList.Select(x => x.SkillId).Except(existingSkills).ToList();
if (existingSkills.Any())
{
var openingSkills = openingDetail.OpeningSkills.Where(x => existingSkills.Contains(x.SkillId)).ToList();
openingSkills.ForEach(x => x.MapAuditColumns((ClaimsIdentity)_principal.Identity));
}
if (removingSkills.Any())
{
var openingSkills = openingDetail.OpeningSkills.Where(x => removingSkills.Contains(x.SkillId)).ToList();
openingSkills.ForEach(x => x.MapDeleteColumns((ClaimsIdentity)_principal.Identity));
}
var openingSkillList = new List <OpeningSkills>();
if (addingSkills.Any())
{
var addingSkillList = skillViewModelList.Where(x => addingSkills.Contains(x.SkillId)).ToList();
foreach (var item in addingSkillList)
{
var openingSkill = new OpeningSkills()
{
OpeningId = openingDetail.OpeningId,
SkillId = item.SkillId,
SkillType = item.OpeningSkillType
};
openingSkill.MapAuditColumns((ClaimsIdentity)_principal.Identity);
openingSkillList.Add(openingSkill);
}
}
if (openingSkillList.Any())
{
_openingRepository.UpdateOpeningSkills(openingSkillList);
}
_openingRepository.Update(openingModel);
entityAndApprovalViewModel.approvalTransactionViewModel.NextEventOrderNumber += 1;
_approvalManagerService.ManageApprovalTransaction(entityAndApprovalViewModel);
_openingRepository.SaveChanges();
return(entityAndApprovalViewModel.approvalTransactionViewModel);
}
public Openings Put(Openings model)
{
try
{
return(_repository.Update(model));
}
catch (Exception ex)
{
throw;
}
}
private void LoadOpenings()
{
Openings.Clear();
var openings = OpeningsService.GetAllOpeningsAsViewDtos();
foreach (var v in openings)
{
if (v.Opening.IsOpen)
{
Openings.Add(v);
}
}
}
/// <summary>
/// adds opening in opening list, create new Id for new opening
/// </summary>
/// <param name="opening">new opening</param>
public void AddOpening(IPolyLine2D opening)
{
var lastId = 0;
if (Openings.Count > 0)
{
var opLast = Openings.MaxByOrDefault(o => o.Id);
lastId = opLast != null ? opLast.Id : 0;
}
opening.Id = lastId + 1;
Openings.Add(opening);
}
public Openings Post(Openings model)
{
try
{
model.Id = Guid.NewGuid();
var data = _repository.Insert(model);
return(data);
}
catch (Exception ex)
{
throw;
}
}
public ActionResult AddJob([Bind(Include = "jobId,designation,salary,experience,qualification,location,vacancy")] Openings open)
{
string empid = Session["UserId"].ToString();
var org = db.Employerss.Where(o => o.employerId.Equals(empid)).FirstOrDefault();
var check = db.Openings.Find(open.jobId);
if (check == null)
{
open.employerID = empid;
open.company = org.Organisation;
db.Openings.Add(open);
db.SaveChanges();
return(RedirectToAction("AddJob"));
}
return(RedirectToAction("AddJob"));
}
private void DoSort(string param)
{
if (isFilter)
{
switch (param)
{
case "All":
FilteredOpenings = Openings;
break;
default:
FilteredOpenings = Openings.Where(o => o.Title.ToLower().Contains(param.ToLower())).ToList();
break;
}
return;
}
switch (param)
{
case "Source":
FilteredOpenings = FilteredOpenings.OrderBy(o => o.Source).ToList();
break;
case "Song Artist":
FilteredOpenings = FilteredOpenings
.Where(o => o.Song != null)
.OrderBy(o => o.Song.Artist)
.Concat(FilteredOpenings
.Where(x => x.Song == null)
.OrderBy(x => x.Source))
.ToList();
break;
case "Song Title":
FilteredOpenings = FilteredOpenings
.Where(o => o.Song != null)
.OrderBy(o => o.Song.Title)
.Concat(FilteredOpenings
.Where(x => x.Song == null)
.OrderBy(x => x.Source))
.ToList();
break;
}
}
public IEnumerable <Step> GetSteps()
{
return(Openings.TwelveHatch()
.Concat(new Step[]
{
Make.Drone,
Make.Drone,
Make.Drone,
Make.Hatchery(HatcheryType.MainMacro),
Make.Extractor,
Make.Zergling // scout
})
//.Concat(While(() => UsedSupply < 15, () => Make.Drone))
.Concat(Repeat(() => Make.Drone, 4))
.Concat(Make.Overlord.Yield())
.Concat(Repeat(() => Make.Drone, 2))
//.Concat(While(() => Game.Self.Gas < 100, () => Make.Drone))
.Concat(Make.Lair.Yield())
.Concat(Repeat(() => Make.Drone, 3))
//.Concat(While(() => Game.Self.Gas < 100 || CompletionPercentage(UnitType.Zerg_Lair) < 10, () => Make.Drone))
.Concat(Make.ZerglingSpeed.Yield())
.Concat(Make.Extractor.Yield())
.Concat(Repeat(() => Make.Drone, 4))
.Concat(Make.Overlord.Yield())
.Concat(Repeat(() => Make.Drone, 4))
.Concat(Make.Spire.Yield())
.Concat(Repeat(() => Make.Zergling, 6))
.Concat(Repeat(() => Make.Overlord, 3))
.Concat(Repeat(() => Make.Mutalisk, 9))
.Concat(Do.SendDroneToThird.Yield())
.Concat(Make.HydraliskDen.Yield())
.Concat(Make.QueensNest.Yield())
.Concat(Repeat(() => Make.Drone, 4))
.Concat(Make.Hatchery(HatcheryType.ThirdExp).Yield())
.Concat(Make.LurkerAspect.Yield())
.Concat(Make.Hive.Yield())
.Concat(Make.DefilerMound.Yield())
.Concat(Make.UltraliskCavern.Yield())
.Concat(Make.NydusCanal.Yield())
.Concat(Make.NydusExit.Yield())
.Concat(While(() => true, () => Make.Zergling)));
//.Concat(While(() => !HaveBuilding(UnitType.Zerg_Lair) && CompletionPercentage(UnitType.Zerg_Lair) < 90, () => Make.Drone));
}
public async Task <ActionResult> Create(Openings model)
{
try
{
ModelState.Remove("Id");
ModelState.Remove("CreatedDate");
ModelState.Remove("Experience");
if (ModelState.IsValid)
{
var month = Convert.ToDecimal(Request["Month"]);
if (month < 10)
{
month = Convert.ToDecimal("0" + month);
}
else
{
month = Convert.ToDecimal(Request["Month"]);
}
var exp = Request["Year"] + "." + month;
model.Experience = Convert.ToDecimal(exp);
model.Skills = string.Join(",", Request["Skill"]);
if (model.Id == Guid.Empty)
{
model.CreatedDate = DateTime.Now.Date;
//model.Skills = string.Join(",", Request["Skill"]);
var data = await APIHelpers.PostAsync <Openings>("api/Openings/Post", model);
TempData["sucess"] = OpeningResources.create;
}
else
{
var data = await APIHelpers.PutAsync <Openings>("api/Openings/Put", model);
TempData["sucess"] = OpeningResources.update;
}
}
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
return(View());
}
}
private void Search(string query)
{
if (string.IsNullOrEmpty(query))
{
FilteredOpenings = Openings;
}
else
{
query = query.ToLower();
FilteredOpenings = Openings
.Where(o =>
o.Source.ToLower().Contains(query) ||
(o.Song != null &&
(o.Song.Artist.ToLower().Contains(query) ||
o.Song.Title.ToLower().Contains(query)))
)
.ToList();
}
}
private async Task LoadOpeningsAsync()
{
// CancellationToken token = new CancellationToken();
// token.ThrowIfCancellationRequested();
//
// CancellationTokenSource.CreateLinkedTokenSource()
Openings.Clear();
var openings = await Task.Run(() => _Repository.Opening.GetRange(c => c.CompanyId == Model.CompanyId));
foreach (var opening in openings)
{
var qual = await Task.Run(() => _repository.Qualification.Get(c => c.QualificationId == opening.QualificationId));
opening.Qualification = qual;
Openings.Add(new OpeningModel(opening, _repository));
Task.Delay(10);
}
}
//CONSTRUCTOR
#region Constructor
public Game(Size boardSize, Player playerO, Player playerX, Mark starts, Openings opening, int compODeffQ, int compXDeffQ, int moveDuration)
{
BoardState = new BoardState(boardSize, moveDuration);
PlayerTypes = new Dictionary <Mark, Player>();
PlayerTypes.Add(Mark.O, playerO);
PlayerTypes.Add(Mark.X, playerX);
Size = boardSize;
Opening = opening;
CompODeffQ = compODeffQ;
CompXDeffQ = compXDeffQ;
MoveDuration = moveDuration;
PlayerOnTurn = starts;
if (starts == Mark.None)
{
Random rng = new Random();
PlayerOnTurn = rng.Next(2) == 0 ? Mark.O : Mark.X;
}
NextMove(true);
}
public override string ToString()
{
string result = Position.ToString();
if (!Openings.Contains(true))
{
result += " (no openings)";
}
else
{
result += " (" + string.Join(", ", OpeningDirections.Select(x => x.ToString()).ToArray()) + ")";
}
if (Purpose != RoomPurpose.Normal)
{
result += " (" + Purpose + ")";
}
return(result);
}
/// <summary>
/// Creates and adds an Opening to the Story by deriving the Perimeter from the supplied Room.
/// </summary>
/// <param name="room">Room representing the Opening.</param>
/// <returns></returns>
public bool AddOpening(Room opening)
{
if (opening.Perimeter == null || !Perimeter.Covers(opening.Perimeter))
{
return(false);
}
var toRooms = new List <Room>()
{
opening
};
Exclusions = FitRooms(Exclusions, toRooms);
toRooms.AddRange(Exclusions);
Services = FitRooms(Services, toRooms);
toRooms.AddRange(Services);
Corridors = FitRooms(Corridors, toRooms);
toRooms.AddRange(Corridors);
Rooms = FitRooms(Rooms, toRooms);
Openings.Add(opening);
return(true);
}
private IList <OpeningStrategy> OpeningsWithSameMoves(IList <SingleMove> previousMoves)
{
var list = new List <OpeningStrategy>();
// Include defensive openings
foreach (var opening in Openings.Concat(DefensiveOpenings))
{
if (opening.Moves.Count <= previousMoves.Count)
{
continue;
}
if (!ListMembersEqual(previousMoves, opening.Moves))
{
continue;
}
// All matched
list.Add(opening);
}
return(list);
}
public async Task <ServiceResponse <bool> > PutOpenings(int id, Openings openings)
{
var response = new ServiceResponse <bool>();
if (id != openings.id)
{
response.Success = false;
response.Message = "Invalid job id , Please check";
}
try
{
openings.modifiedBy = LoggedInUser;
openings.modifiedDate = DateTime.UtcNow;
var job = _context.Openings.Find(id);
_context.Entry(job).CurrentValues.SetValues(openings);
await _context.SaveChangesAsync();
response.Success = true;
response.Message = "Job Opening updated successfully";
response.Data = true;
}
catch (DbUpdateConcurrencyException ex)
{
response.Success = false;
if (!OpeningsExists(id))
{
response.Message = "Invalid job id , Please check";
}
else
{
response.Message = await CustomLog.Log(ex, _context);
}
}
return(response);
}
private void addWindows(BlockTableRecord btrPanel, Transaction t)
{
// все окна и балеоны в панели
var windows = Panel.windows?.window?.Select(w => new { posi = w.posi, width = w.width, height = w.height });
var balconys = Panel.balconys?.balcony?.Select(b => new { posi = b.posi, width = b.width, height = b.height });
var apertures = balconys == null? windows: windows?.Union(balconys) ?? balconys;
if (apertures != null)
{
foreach (var item in apertures)
{
// контур окон
Polyline plWindow = new Polyline();
plWindow.LayerId = Service.Env.IdLayerContourPanel;
Point2d ptMinWindow = new Point2d(item.posi.X, item.posi.Y);
plWindow.AddVertexAt(0, ptMinWindow, 0, 0, 0);
plWindow.AddVertexAt(0, new Point2d(ptMinWindow.X, ptMinWindow.Y + item.height), 0, 0, 0);
Point2d ptMaxWindow = new Point2d(ptMinWindow.X + item.width, ptMinWindow.Y + item.height);
plWindow.AddVertexAt(0, ptMaxWindow, 0, 0, 0);
plWindow.AddVertexAt(0, new Point2d(ptMinWindow.X + item.width, ptMinWindow.Y), 0, 0, 0);
plWindow.Closed = true;
btrPanel.AppendEntity(plWindow);
t.AddNewlyCreatedDBObject(plWindow, true);
// добавление точек для верхнего образмеривания.
PtsForTopDim.Add(ptMinWindow.X);
PtsForTopDim.Add(ptMaxWindow.X);
Openings.Add(new Extents3d(ptMinWindow.Convert3d(), ptMaxWindow.Convert3d()));
// Вставка окон
if (WindowsBaseCenters.Count > 0)
{
var xCenter = item.posi.X + item.width * 0.5;
var winMarkMin = WindowsBaseCenters.Where(w => Math.Abs(w.Key.X - xCenter) < 600);
if (winMarkMin.Count() > 0)
{
var winMark = winMarkMin.MinBy(g => (g.Key.X - xCenter));
if (string.IsNullOrWhiteSpace(winMark.Value))
{
continue;
}
// Точка вставки блока окна
Point3d ptWin = new Point3d(item.posi.X, item.posi.Y, 0);
// Вставка блока окна
if (!Service.Env.IdBtrWindow.IsNull)
{
BlockReference blRefWin = new BlockReference(ptWin, Service.Env.IdBtrWindow);
blRefWin.LayerId = Service.Env.IdLayerWindow;
btrPanel.AppendEntity(blRefWin);
t.AddNewlyCreatedDBObject(blRefWin, true);
var resSetDyn = BlockWindow.SetDynBlWinMark(blRefWin, winMark.Value);
if (!resSetDyn)
{
// Добавление текста марки окна
DBText dbTextWin = new DBText();
dbTextWin.Position = ptWin;
dbTextWin.LayerId = Service.Env.IdLayerWindow;
dbTextWin.TextString = winMark.Value;
dbTextWin.Height = 180;
btrPanel.AppendEntity(dbTextWin);
t.AddNewlyCreatedDBObject(dbTextWin, true);
}
}
#if Test
// Test
else
{
// Добавление текста марки окна
DBText dbTextWin = new DBText();
dbTextWin.Position = ptWin;
dbTextWin.LayerId = Service.Env.IdLayerWindow;
dbTextWin.TextString = winMark.Value;
dbTextWin.Height = 180;
btrPanel.AppendEntity(dbTextWin);
t.AddNewlyCreatedDBObject(dbTextWin, true);
}
#endif
}
}
// Сортировка окон слева-направо
Openings.Sort((w1, w2) => w1.MinPoint.X.CompareTo(w2.MinPoint.X));
}
}
}
public void RescaleOpenings()
{
Openings.ForEach(op => op.Points = op.RawPoints.Select(p => new MWPoint2D(p.X * PlaneScaling, p.Y * PlaneScaling)).ToList());
}
public void CreateOpening(Openings opening)
{
this.opening |= opening;
}
