// Funkcja odpowiedzialna za utworzenie zamówienia i wysłanie maila. Zapisuje wszystkie dane na temat zamówienia, produktów i adresu do bazy a następnie wysyła maila z zamówieniem.
public void CreateOrder(OrderObject orderObject, AddressObject addressObject, List <OrderProductObject> products)
{
string date = orderObject.OrderDate;
string sql = string.Format("insert into Orders (Email, Price, ProductCount, OrderDate, Attention) values ('{0}', '{1}', {2}, '{3}', '{4}')",
orderObject.Email, orderObject.Price, orderObject.ProductCount, date, orderObject.AttentionToOrder);
long orderFk = _connectDB.InsertOrderToDatabase(sql);
orderObject.ID = (int)orderFk;
sql = string.Format("insert into Address (Street, HouseNumber, FlatNumber, City, PhoneNumber, OrderFK) values ('{0}', '{1}', '{2}', '{3}', {4}, {5})",
addressObject.Street, addressObject.HouseNumber, addressObject.FlatNumber, addressObject.City, addressObject.PhoneNumber, orderFk);
_connectDB.ExecuteSql(sql);
foreach (OrderProductObject product in products)
{
sql = string.Format("insert into Product (Name, OrderFK) values ('{0}', {1})", product.Name, orderFk);
_connectDB.ExecuteSql(sql);
}
string subject = string.Format(Resources.OrderNumber_Message, orderFk);
string body = OrderLogic.CreateOrderDetails(orderObject, addressObject, products);
SendMail(subject, body, orderObject.Email);
}
// Zdarzenie wysyłania zamówienia. Występuje formatka do wprowadzania adresu. Utworzenie zamówienia w bazie danych plus wysłanie maila.
private void uiBtnSendOrder_Click(object sender, EventArgs e)
{
string message;
if (!_orderLogic.Validate(out message, uiTxtEmail.Text, uiClbShopingCard.Items.Count))
{
MessageBox.Show(message, Resources.Attention, MessageBoxButtons.OK, MessageBoxIcon.Warning);
return;
}
AddressObject addressObject = _orderLogic.CreateAddress();
if (addressObject == null)
{
MessageBox.Show(Resources.NotSetEmailAddress, Resources.Attention, MessageBoxButtons.OK,
MessageBoxIcon.Warning);
return;
}
List <OrderProductObject> orderProductObjects = new List <OrderProductObject>();
foreach (object obj in uiClbShopingCard.Items)
{
orderProductObjects.Add(new OrderProductObject(obj.ToString()));
}
OrderObject orderObject = CreateOrderObject();
_orderLogic.CreateOrder(orderObject, addressObject, orderProductObjects);
Close();
}
public override object ConvertFromString(string text, IReaderRow row, MemberMapData memberMapData)
{
var emptyObj = new AddressObject();
// if you are reading back the CSV then additional code should be needed here
return(emptyObj);
}
private List <ObjectNode> GetHousesGUIDVariants(AddressObject house, List <ObjectNode> objects)
{
var houseGuids = new List <ObjectNode>();
foreach (var obj in objects)
{
if (obj == null)
{
continue;
}
string housing = StringHelper.GetLettersOrNumbersAfterSlash(house.Name, out int firstIndexHousing, out int lengthHousing);
string nameWithoutHousing = house.Name;
if (!string.IsNullOrEmpty(housing))
{
nameWithoutHousing = house.Name.Remove(firstIndexHousing, lengthHousing).Replace("/", "");
}
if (house.Type?.AbbreviatedName == "дом с корпусом" && housing.Length > 0)
{
var qWithLitter = (from h in DataContext.House
where h.HOUSENUM == nameWithoutHousing && h.AOGUID == obj.Guid && h.BUILDNUM == housing && h.STRUCNUM == null
select new ObjectNode(h.HOUSEGUID, nameWithoutHousing + ", корпус " + housing, TableType.House, obj.Guid, obj)).ToList().Distinct();
houseGuids.AddRange(qWithLitter);
if (houseGuids.Count == 0)
{
var qWithLitter2 = (from h in DataContext.House
where h.HOUSENUM == nameWithoutHousing && h.AOGUID == obj.Guid && h.BUILDNUM == housing
select new ObjectNode(h.HOUSEGUID, nameWithoutHousing + ", корпус " + housing, TableType.House, obj.Guid, obj)).ToList().Distinct();
houseGuids.AddRange(qWithLitter2);
}
}
if (houseGuids.Count == 0)
{
var qWithLitter = (from h in DataContext.House
where h.HOUSENUM == house.Name && h.AOGUID == obj.Guid && h.STRUCNUM == null && h.BUILDNUM == null
select new ObjectNode(h.HOUSEGUID, house.Name, TableType.House, obj.Guid, obj)).ToList().Distinct();
houseGuids.AddRange(qWithLitter);
}
if (houseGuids.Count == 0 && housing.Length > 0)
{
var qWithNumericHousing = (from h in DataContext.House
where h.HOUSENUM == nameWithoutHousing && h.AOGUID == obj.Guid && (h.BUILDNUM == housing || h.STRUCNUM == housing)
select new ObjectNode(h.HOUSEGUID, house.Name, TableType.House, obj.Guid, obj)).ToList().Distinct();
houseGuids.AddRange(qWithNumericHousing);
}
if (houseGuids.Count == 0)
{
var q = (from h in DataContext.House
where h.HOUSENUM == house.Name && h.AOGUID == obj.Guid
select new ObjectNode(h.HOUSEGUID, house.Name, TableType.House, obj.Guid, obj)).ToList().Distinct();
houseGuids.AddRange(q);
}
}
return(houseGuids);
}
public EmployeeDetails(EmployeeWithState emp, Department depart) : base(emp)
{
BirthDate = emp.BirthDate;
HireDate = emp.HireDate;
Address = emp.Address;
RegNat = emp.RegNat;
Department = new CurrentOn(depart);
}
public Address()
{
Region = new AddressObject();
District = new AddressObject();
City = new AddressObject();
Street = new AddressObject();
Building = new AddressObject();
}
public EventListItem(Event events, Employee emp)
{
Id = events.Id;
Name = events.Name;
Address = new AddressObject(events);
StartDate = events.StartDate;
EndDate = events.EndDate;
FullDay = events.FullDay;
Creator = new CurrentOn(emp);
}
private AddressObject CreateAddressObject()
{
AddressObject address = new AddressObject();
address.Street = uiTxtStreet.Text;
address.HouseNumber = uiTxtHouseNumber.Text;
address.FlatNumber = uiTxtFlatNumber.Text;
address.City = uiTxtCity.Text;
address.PhoneNumber = int.Parse(uiNudPhoneNumber.Value.ToString());
return(address);
}
private void uiBtnAccept_Click(object sender, EventArgs e)
{
if (!Validate())
{
return;
}
AddressObj = CreateAddressObject();
this.DialogResult = DialogResult.OK;
Close();
}
/**
* Set address text into address bar game object
*/
public void SetAddressBarText(AddressObject buildingAddress)
{
if (buildingAddress == null)
{
UiUtils.SetText(AddressText, LanguageUtils.Get(StringIds.IdMainSceneUnknownAddress));
return;
}
var addressBarText = buildingAddress.Street + " " + buildingAddress.StreetNumber;
UiUtils.SetText(AddressText, addressBarText);
}
// Funkcja do tworzenia adresu odpala formularz do wypełnienia danych adresowych
public AddressObject CreateAddress()
{
AddressObject addressObject = null;
using (AddressForm addressForm = new AddressForm())
{
if (addressForm.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
addressObject = addressForm.AddressObj;
}
}
return(addressObject);
}
private List <ObjectNode> GetRoomsGUIDVariants(AddressObject room, List <ObjectNode> houses)
{
var roomsGuids = new List <ObjectNode>();
foreach (var house in houses)
{
var q = (from r in DataContext.Room
where r.FLATNUMBER == room.Name && r.HOUSEGUID == house.Guid
select new ObjectNode(r.ROOMGUID, room.Name, TableType.Room, house.Guid, house)).ToList().Distinct();
roomsGuids.AddRange(q);
}
return(roomsGuids);
}
public AddressObject GetAddress(long orderId)
{
AddressObject address = null;
string sql = string.Format("select * from Address where OrderFK = {0}", orderId);
try
{
OpenConnection();
SQLiteCommand command = new SQLiteCommand(sql, SqliteConnection);
SQLiteDataReader reader = command.ExecuteReader();
int id;
string street;
string houseNumber;
string flatNumber;
string city;
int phoneNumber;
while (reader.Read())
{
id = int.Parse(reader["ID"].ToString());
street = reader["Street"].ToString();
houseNumber = reader["HouseNumber"].ToString();
flatNumber = reader["FlatNumber"].ToString();
city = reader["City"].ToString();
phoneNumber = int.Parse(reader["PhoneNumber"].ToString());
address = new AddressObject();
address.ID = id;
address.Street = street;
address.HouseNumber = houseNumber;
address.FlatNumber = flatNumber;
address.City = city;
address.PhoneNumber = phoneNumber;
}
}
catch (SQLiteException sqlEx)
{
MessageBox.Show(sqlEx.Message);
}
finally
{
CloseConnection();
}
return(address);
}
/**
* Pokud ukáže myš na objekt, změní objekt barvu
*/
private void OnMouseEnter()
{
var buildingAddress = new AddressObject();
foreach (var building in BuildingRender.Get().Buildings)
{
if (building.Name.Equals(gameObject.name))
{
buildingAddress = building.Address;
}
}
MenuController.Get().SetAddressBarText(buildingAddress);
MenuController.Get().ChangeAddressBarVisibility(true);
BuildingRender.Get().ChangeBuildingSurfaceColor(gameObject, ColorUtils.OnMouse);
}
/// <summary>
/// Получение из XML
/// </summary>
/// <param name="a"></param>
/// <returns></returns>
public static AddressObject Get(XmlAddressObject a)
{
var r = new AddressObject()
{
ActStatus = a.ActStatus,
AoGuid = a.AoGuid,
AoId = a.AoId,
AoLevel = a.AoLevel,
AreaCode = a.AreaCode,
AutoCode = a.AutoCode,
CentStatus = a.CentStatus,
CityCode = a.CityCode,
Code = a.Code.ToNullLong(),
CtarCode = a.CtarCode,
CurrStatus = a.CurrStatus.GetCurStatus(),
DivType = a.DivType,
EndDate = a.EndDate,
ExtrCode = a.ExtrCode,
FormalName = a.FormalName,
IFNSFL = a.IFNSFL.ToNullInt(),
IFNSUL = a.IFNSUL.ToNullInt(),
LiveStatus = a.LiveStatus,
NORMDOC = a.NORMDOC.ToNullGuid(),
NextId = a.NextId.ToNullGuid(),
OKATO = a.OKATO.ToNullLong(),
OKTMO = a.OKTMO.ToNullLong(),
OffName = a.OffName,
OperStatus = a.OperStatus,
ParentGuid = a.ParentGuid.ToNullGuid(),
PlaceCode = a.PlaceCode,
PlainCode = a.PlainCode.ToNullLong(),
PlanCode = a.PlanCode,
PostalCode = a.PostalCode.ToNullInt(),
PrevId = a.PrevId.ToNullGuid(),
RegionCode = a.RegionCode,
SHORTNAME = a.SHORTNAME,
SextCode = a.SextCode,
StartDate = a.StartDate,
StreetCode = a.StreetCode,
TERRIFNSFL = a.TERRIFNSFL.ToNullInt(),
TERRIFNSUL = a.TERRIFNSUL.ToNullInt(),
UpdateDate = a.UpdateDate
};
return(r);
}
/// <summary>
/// Получение адресного объекта
/// </summary>
/// <param name="a"></param>
/// <returns></returns>
public static DbAddressObject Get(this AddressObject a)
{
return(new DbAddressObject
{
AoGuid = a.AoGuid,
ActStatus = a.ActStatus,
AoId = a.AoId,
AoLevel = a.AoLevel,
AreaCode = a.AreaCode,
AutoCode = a.AutoCode,
CentStatus = a.CentStatus,
CityCode = a.CityCode,
Code = a.Code,
CtarCode = a.CtarCode,
UpdateDate = a.UpdateDate,
CurrStatus = a.CurrStatus,
IFNSUL = a.IFNSUL,
FormalName = a.FormalName,
PlanCode = a.PlanCode,
StreetCode = a.StreetCode,
OffName = a.OffName,
RegionCode = a.RegionCode,
StartDate = a.StartDate,
PlaceCode = a.PlaceCode,
EndDate = a.EndDate,
LiveStatus = a.LiveStatus,
SextCode = a.SextCode,
ExtrCode = a.ExtrCode,
OperStatus = a.OperStatus,
DivType = a.DivType,
NORMDOC = a.NORMDOC,
PostalCode = a.PostalCode,
ParentGuid = a.ParentGuid,
NextId = a.NextId,
PrevId = a.PrevId,
PlainCode = a.PlainCode,
OKTMO = a.OKTMO,
OKATO = a.OKATO,
IFNSFL = a.IFNSFL,
TERRIFNSFL = a.TERRIFNSFL,
SHORTNAMEID = a.SHORTNAMEID,
TERRIFNSUL = a.TERRIFNSUL
});
}
/// <summary>
/// Populates the view ViewModel by handling the Load Event.
/// </summary>
/// <returns>
/// <br/>
/// </returns>
public override void HandleViewDataLoadEvent()
{
BaseCL.RoutineEntry("AddressDetailViewModel");
HLinkAdressModel HLinkObject = CommonRoutines.GetHLinkParameter <HLinkAdressModel>((BaseParamsHLink));
AddressObject = HLinkObject.DeRef;
if (AddressObject.Valid)
{
BaseModelBase = AddressObject;
// Get media image
MediaCard = AddressObject.ModelItemGlyph.ImageHLinkMediaModel;
// Get the Name Details
BaseDetail.Add(new CardListLineCollection("Address Detail")
{
new CardListLine("Street:", AddressObject.GStreet),
new CardListLine("City:", AddressObject.GCity),
new CardListLine("Locality:", AddressObject.GLocality),
new CardListLine("County:", AddressObject.GCounty),
new CardListLine("State:", AddressObject.GState),
new CardListLine("Country:", AddressObject.GCountry),
new CardListLine("Date:", AddressObject.GDate.ShortDate),
new CardListLine("Postal:", AddressObject.GPostal),
new CardListLine("Phone:", AddressObject.GPhone),
});
// Add date card
BaseDetail.Add(AddressObject.GDate.AsHLink("Address Date"));
// Add Map card
BaseDetail.Add(AddressObject.ToMapModel().HLink);
// Add Standard details
BaseDetail.Add(DV.AddressDV.GetModelInfoFormatted(AddressObject));
}
return;
}
public AddressObjectViewModel Map(AddressObject source)
{
if (source == null)
{
return(null);
}
return(new AddressObjectViewModel
{
Id = source.Id,
Guid = source.GUID,
ParentGuid = source.ParentGUID,
Level = source.Level != null ? (AddressObjectLevel)Enum.ToObject(typeof(AddressObjectLevel), source.Level) : AddressObjectLevel.Undefined,
Status = source.ActualStatus,
PostalCode = source.PostalCode,
UpdateDate = source.UpdateDate?.ToLocalTime(),
FormalName = source.FormalName,
ShortName = source.ShortName,
RegionCode = source.RegionCode
});
}
/**
* Parse building addresses from 'node' XML tags
*/
private List <AddressObject> ParseAddresses(XmlNodeList nodeTags)
{
var addressObjects = new List <AddressObject>();
foreach (XmlNode nodeTag in nodeTags)
{
if (nodeTag.ChildNodes.Count == 0)
{
continue;
}
var address = new AddressObject();
for (var i = 0; i < nodeTag.ChildNodes.Count; i++)
{
//node tag
var tag = nodeTag.ChildNodes[i];
//key value in node tag
var tagKeyValue = tag.Attributes["k"].Value;
if (tagKeyValue.Equals("addr:street"))
{
address.Street = tag.Attributes["v"].Value;
continue;
}
if (tagKeyValue.Equals("addr:streetnumber"))
{
address.StreetNumber = tag.Attributes["v"].Value;
}
}
if (!address.Equals(new AddressObject()))
{
var lat = float.Parse(nodeTag.Attributes["lat"].Value);
var lon = float.Parse(nodeTag.Attributes["lon"].Value);
address.Position = new LatLngObject(lat, lon);
addressObjects.Add(address);
}
}
return(addressObjects);
}
// Funkcja przygotowuje treść szczegółów zamówienia wykorzystywana przy budowaniu treści maila i szczegółów zamówienia w historii zamówień
public static string CreateOrderDetails(OrderObject order, AddressObject address, List <OrderProductObject> products)
{
StringBuilder orderDatails = new StringBuilder();
orderDatails.AppendLine(string.Format(Resources.OrderNumber2_Message, order.ID, Environment.NewLine));
foreach (OrderProductObject product in products)
{
orderDatails.AppendLine(string.Format("{0}", product.Name));
}
CultureInfo info = new CultureInfo(Resources.CultureInfo_Message);
orderDatails.AppendLine(string.Format(Resources.OrderCost_Message, order.Price.ToString("C", info), Environment.NewLine));
if (string.IsNullOrWhiteSpace(order.AttentionToOrder))
{
orderDatails.AppendLine(string.Format(Resources.OrderAttentionEmpty_Message, Environment.NewLine));
}
else
{
orderDatails.AppendLine(string.Format(Resources.OrderAttention_Message, order.AttentionToOrder, Environment.NewLine));
}
orderDatails.AppendLine(Resources.OrderSend_Message);
if (string.IsNullOrWhiteSpace(address.FlatNumber))
{
orderDatails.AppendLine(string.Format("{0} {1}", address.Street, address.HouseNumber));
}
else
{
orderDatails.AppendLine(string.Format(Resources.OrderStreetDetail_Message, address.Street, address.HouseNumber, address.FlatNumber));
}
orderDatails.AppendLine(string.Format("{0}", address.City));
orderDatails.AppendLine(string.Format(Resources.PhoneNumber_Message, address.PhoneNumber));
return(orderDatails.ToString());
}
public void Edit(AddressObject addressObject)
{
if (addressObject.Id.Equals(Guid.Empty))
{
throw new Exception("Id is empty.");
}
var ao = _context.AddressObjects.Find(addressObject.Id);
if (ao == null)
{
throw new Exception("Can not fand address object with specified id.");
}
ao.Id = addressObject.Id;
ao.ActualStatus = addressObject.ActualStatus;
ao.Level = addressObject.Level;
ao.FormalName = addressObject.FormalName;
ao.ShortName = addressObject.ShortName;
ao.PostalCode = addressObject.PostalCode;
ao.RegionCode = addressObject.RegionCode;
ao.UpdateDate = addressObject.UpdateDate;
_context.SaveChanges();
}
/**
*
*/
private void AssignBuildingAddresses(BuildingObject building, List <AddressObject> addressObjects)
{
var buildingList = new List <BuildingObject> {
building
};
var middleBuildingPoint = TerrainRender.GetMiddlePoint(buildingList);
AddressObject finalAddress = null;
var finalDiffLat = float.MaxValue;
var finalDiffLon = float.MaxValue;
foreach (var address in addressObjects)
{
var diffLat = Math.Abs(middleBuildingPoint.Latitude - address.Position.Latitude);
var diffLon = Math.Abs(middleBuildingPoint.Longitude - address.Position.Longitude);
if (diffLat < finalDiffLat && diffLon < finalDiffLon)
{
finalAddress = address;
finalDiffLon = diffLon;
finalDiffLat = diffLat;
}
}
building.AddressObject = finalAddress;
}
protected bool Equals(AddressObject other)
{
return(string.Equals(Street, other.Street) && string.Equals(StreetNumber, other.StreetNumber) && Equals(Position, other.Position));
}
public static async Task <AddressObject> UpdateAddress(AddressObject entity)
{
return(await LG.Data.Core.Clients.Details.Address.Run(entity));
}
/// <summary>
/// Обработчик добавления адреса.
/// </summary>
/// <param name="s">Отправитель</param>
/// <param name="address">Обработанный адрес</param>
protected virtual void OnAddressParsed(object s, AddressObject address)
{
AddressParsed?.Invoke(s, new AddressProcessorEventArgs(address, _count));
}
public void Create(AddressObject addressObject)
{
addressObject.Id = Guid.NewGuid();
_context.AddressObjects.Add(addressObject);
_context.SaveChanges();
}
private IEnumerable <AddressObject> ReadAddressObjects(string filePath, int number)
{
using (var reader = XmlReader.Create(filePath))
{
var i = 0;
while (i < number && reader.Read())
{
var nodeType = reader.NodeType;
if (nodeType != XmlNodeType.Element)
{
continue;
}
if (reader.LocalName == AddressObjectFields.ObjectNodeName)
{
var objectXml = reader.ReadOuterXml();
var objectDoc = new XmlDocument();
objectDoc.LoadXml(objectXml);
var objectNode = objectDoc.SelectSingleNode(AddressObjectFields.ObjectNodeName);
var aoidAttr = objectNode.Attributes[AddressObjectFields.AoId];
if (string.IsNullOrEmpty(aoidAttr.Value) || !Guid.TryParse(aoidAttr.Value, out var aoid))
{
continue;
}
;
var addressObject = new AddressObject
{
Id = aoid,
FormalName = objectNode.Attributes[AddressObjectFields.FormalName]?.Value,
AreaCode = objectNode.Attributes[AddressObjectFields.AreaCode]?.Value,
AutoCode = objectNode.Attributes[AddressObjectFields.AutoCode]?.Value,
CityCode = objectNode.Attributes[AddressObjectFields.CityCode]?.Value,
Code = objectNode.Attributes[AddressObjectFields.Code]?.Value,
CtarCode = objectNode.Attributes[AddressObjectFields.CtarCode]?.Value,
IFNSFL = objectNode.Attributes[AddressObjectFields.IFNSFL]?.Value,
IFNSUL = objectNode.Attributes[AddressObjectFields.IFNSUL]?.Value,
OfficialName = objectNode.Attributes[AddressObjectFields.OfficialName]?.Value,
OKATO = objectNode.Attributes[AddressObjectFields.OKATO]?.Value,
OKTMO = objectNode.Attributes[AddressObjectFields.OKTMO]?.Value,
PlaceCode = objectNode.Attributes[AddressObjectFields.PlaceCode]?.Value,
PlainCode = objectNode.Attributes[AddressObjectFields.PlainCode]?.Value,
PlanCode = objectNode.Attributes[AddressObjectFields.PlanCode]?.Value,
PostalCode = objectNode.Attributes[AddressObjectFields.PostalCode]?.Value,
ShortName = objectNode.Attributes[AddressObjectFields.ShortName]?.Value,
RegionCode = objectNode.Attributes[AddressObjectFields.RegionCode]?.Value,
StreetCode = objectNode.Attributes[AddressObjectFields.StreetCode]?.Value,
TERRIFNSFL = objectNode.Attributes[AddressObjectFields.TERRIFNSFL]?.Value,
TERRIFNSUL = objectNode.Attributes[AddressObjectFields.TERRIFNSUL]?.Value
};
var aoguidString = objectNode.Attributes[AddressObjectFields.AoGuid]?.Value;
if (!string.IsNullOrEmpty(aoguidString))
{
if (Guid.TryParse(aoguidString, out var aoguid))
{
addressObject.GUID = aoguid;
}
}
var parentString = objectNode.Attributes[AddressObjectFields.ParentGUID]?.Value;
if (!string.IsNullOrEmpty(parentString))
{
if (Guid.TryParse(parentString, out var val))
{
addressObject.ParentGUID = val;
}
}
var levelString = objectNode.Attributes[AddressObjectFields.Level]?.Value;
if (!string.IsNullOrEmpty(levelString))
{
if (int.TryParse(levelString, out var val))
{
addressObject.Level = val;
}
}
var actString = objectNode.Attributes[AddressObjectFields.ActualStatus]?.Value;
if (!string.IsNullOrEmpty(actString))
{
if (int.TryParse(actString, out var val))
{
addressObject.ActualStatus = val;
}
}
var centString = objectNode.Attributes[AddressObjectFields.CentStatus]?.Value;
if (!string.IsNullOrEmpty(centString))
{
if (int.TryParse(centString, out var val))
{
addressObject.CentStatus = val;
}
}
var currString = objectNode.Attributes[AddressObjectFields.CurrStatus]?.Value;
if (!string.IsNullOrEmpty(currString))
{
if (int.TryParse(currString, out var val))
{
addressObject.CurrStatus = val;
}
}
var liveString = objectNode.Attributes[AddressObjectFields.LiveStatus]?.Value;
if (!string.IsNullOrEmpty(liveString))
{
if (int.TryParse(liveString, out var val))
{
addressObject.LiveStatus = val;
}
}
var operString = objectNode.Attributes[AddressObjectFields.OperStatus]?.Value;
if (!string.IsNullOrEmpty(operString))
{
if (int.TryParse(operString, out var val))
{
addressObject.OperStatus = val;
}
}
var endString = objectNode.Attributes[AddressObjectFields.EndDate]?.Value;
if (!string.IsNullOrEmpty(endString))
{
if (DateTime.TryParse(endString, out var val))
{
addressObject.EndDate = val;
}
}
var startString = objectNode.Attributes[AddressObjectFields.StartDate]?.Value;
if (!string.IsNullOrEmpty(startString))
{
if (DateTime.TryParse(startString, out var val))
{
addressObject.StartDate = val;
}
}
var updateString = objectNode.Attributes[AddressObjectFields.UpdateDate]?.Value;
if (!string.IsNullOrEmpty(updateString))
{
if (DateTime.TryParse(updateString, out var val))
{
addressObject.UpdateDate = val;
}
}
i++;
yield return(addressObject);
}
}
}
}
/// <summary>
/// Аргументы обработки Адреса
/// </summary>
/// <param name="address">Обработанный адрес</param>
/// <param name="count">Количество обработанных адресов</param>
public AddressProcessorEventArgs(AddressObject address, long count)
{
Address = address;
Count = count;
}
public static bool SafeIsEmpty(this AddressObject addressObject)
{
return(addressObject == null || addressObject.IsEmpty());
}
public IActionResult Post([FromBody] AddressObject addressObject)
{
_addressObjectService.Create(addressObject);
return(Created(addressObject));
}
private List <ObjectNode> IterateAddressObject(AddressObject variantObj, List <ObjectNode> prevNodes, bool retrying = false)
{
var result = new List <ObjectNode>();
if (prevNodes != null)
{
foreach (var prevNode in prevNodes)
{
var query = (from obj in DataContext.Object
where obj.FORMALNAME == variantObj.Name && obj.PARENTGUID == prevNode.Guid && obj.ACTSTATUS == 1 && obj.AOLEVEL >= prevNode.AOLevel
select new ObjectNode(obj.AOGUID, variantObj.Name, TableType.Object, prevNode.Guid, prevNode, obj.SHORTNAME, obj.AOLEVEL)).ToList();
result.AddRange(query);
if (query.Count == 0 && !retrying)
{
var allQ = (from obj in DataContext.Object
where obj.PARENTGUID == prevNode.Guid && obj.ACTSTATUS == 1
select new ObjectNode(obj.AOGUID, obj.FORMALNAME, TableType.Object, prevNode.Guid, prevNode, obj.SHORTNAME, obj.AOLEVEL)).ToList();
if (allQ.Count > 0 && allQ.Count < 500)
{
var missed = IterateAddressObject(variantObj, allQ, true);
result.AddRange(missed);
}
}
}
//TODO
if (result.Count == 0 && !retrying && false)
{
var concrete = IterateAddressObject(variantObj, null, true);
result.AddRange(concrete);
foreach (var prevNode in prevNodes)
{
if (prevNode.AOLevel < 4)
{
result.Add(prevNode);
}
}
}
}
else if (prevNodes == null)
{
var firstQuery = (from obj in DataContext.Object
where obj.FORMALNAME == variantObj.Name && obj.ACTSTATUS == 1
select new ObjectNode(obj.AOGUID, variantObj.Name, TableType.Object, obj.PARENTGUID, null, obj.SHORTNAME, obj.AOLEVEL)).ToList();
result = firstQuery;
}
if (variantObj.Type != null)
{
var types = dictionary.GetAOTypes(variantObj.Type.AbbreviatedName);
for (int i = 0; i < result.Count; i++)
{
bool finded = false;
foreach (var type in types)
{
if (result[i].AOLevel == type.Level)
{
finded = true;
break;
}
}
if (!finded)
{
if (result.Count > 1)
{
result.RemoveAt(i);
i--;
}
}
}
}
else if (result.Count > 50)
{
//берём самое минимальное
int minAO = int.MaxValue;
foreach (var r in result)
{
if (r.AOLevel < minAO)
{
minAO = r.AOLevel;
}
}
var sorted = new List <ObjectNode>();
for (int i = 0; i < result.Count; i++)
{
if (result[i].AOLevel == minAO)
{
sorted.Add(result[i]);
}
}
result = sorted;
}
return(result);
}
