public ScheduleZoneDetailsViewModel(Schedule schedule, Organisation organisation)
{
Title = "Добавить новые зоны";
ScheduleZone = new List<ScheduleZone>();
Zones = new SortableObservableCollection<SelectationScheduleZoneViewModel>();
var organisationResult = OrganisationHelper.GetSingle(organisation.UID);
_doorUIDs = organisationResult != null ? organisationResult.DoorUIDs : new List<Guid>();
var gkDoors = GKManager.Doors.Where(x => _doorUIDs.Any(y => y == x.UID));
foreach (var door in gkDoors)
{
if (door.EnterZoneUID != Guid.Empty)
{
var enterZone = GKManager.SKDZones.FirstOrDefault(x => x.UID == door.EnterZoneUID);
if (enterZone != null && !Zones.Any(x => x.ZoneUID == enterZone.UID))
Zones.Add(new SelectationScheduleZoneViewModel(enterZone, schedule, door.UID));
}
if (door.ExitZoneUID != Guid.Empty)
{
var exitZone = GKManager.SKDZones.FirstOrDefault(x => x.UID == door.ExitZoneUID);
if (exitZone != null && !Zones.Any(x => x.ZoneUID == exitZone.UID))
Zones.Add(new SelectationScheduleZoneViewModel(exitZone, schedule, door.UID));
}
}
Zones = new ObservableCollection<SelectationScheduleZoneViewModel>(Zones.OrderBy(x => x.No)); //TODO:
SelectedZone = Zones.FirstOrDefault();
}
public static OrderCalculationResponse CalculateOrder(OrderCalculationRequest request, bool hasAutoOrder = false)
{
var result = new OrderCalculationResponse();
if (request.Items.Count() == 0) return result;
if (request.Address == null) request.Address = GlobalSettings.Company.Address;
if (request.ShipMethodID == 0) request.ShipMethodID = request.Configuration.DefaultShipMethodID;
var apirequest = new CalculateOrderRequest();
apirequest.WarehouseID = request.Configuration.WarehouseID;
apirequest.CurrencyCode = request.Configuration.CurrencyCode;
apirequest.PriceType = request.Configuration.PriceTypeID;
apirequest.ShipMethodID = request.ShipMethodID;
apirequest.ReturnShipMethods = request.ReturnShipMethods;
apirequest.City = request.Address.City;
apirequest.State = request.Address.State;
apirequest.Zip = request.Address.Zip;
apirequest.Country = request.Address.Country;
apirequest.Details = request.Items.Select(c => new OrderDetailRequest(c)).ToArray();
if(hasAutoOrder){
apirequest.OrderType = Common.Api.ExigoWebService.OrderType.AutoOrder;
}
var apiresponse = Exigo.WebService().CalculateOrder(apirequest);
result.Subtotal = apiresponse.SubTotal;
result.Shipping = apiresponse.ShippingTotal;
result.Tax = apiresponse.TaxTotal;
result.Discount = apiresponse.DiscountTotal;
result.Total = apiresponse.Total;
// Assemble the ship methods
var shipMethods = new List<ShipMethod>();
if (apiresponse.ShipMethods != null && apiresponse.ShipMethods.Length > 0)
{
foreach (var shipMethod in apiresponse.ShipMethods)
{
shipMethods.Add((ShipMethod)shipMethod);
}
// Ensure that at least one ship method is selected
var shipMethodID = (request.ShipMethodID != 0) ? request.ShipMethodID : request.Configuration.DefaultShipMethodID;
if (shipMethods.Any(c => c.ShipMethodID == (int)shipMethodID))
{
shipMethods.First(c => c.ShipMethodID == shipMethodID).Selected = true;
}
else
{
shipMethods.First().Selected = true;
}
}
result.ShipMethods = shipMethods.AsEnumerable();
return result;
}
/// <summary>
/// 根据SysMenuId，获取所有角色菜单操作数据
/// </summary>
/// <param name="id">外键的主键</param>
/// <returns></returns>
public IQueryable<SysOperation> GetByRefSysMenuIdAndSysRoleId(SysEntities db, string id, List<string> sysRoleIds)
{
//兼容oracle
return
( from o in db.SysOperation
from m in db.SysMenuSysRoleSysOperation.Where(c => sysRoleIds.Any(a => a == c.SysRoleId) && c.SysMenuId == id && c.SysOperationId != null).Select(s => s.SysOperationId)
where o.Id == m
select o).Distinct().OrderBy(o=>o.Sort).AsQueryable()
;
}
public static List<User> GetAllUsers()
{
try
{
using (var context = DatabaseContext.Initialize())
{
var result = new List<User>();
foreach (var item in context.Users.Select(x => new { UID = x.UID, Name = x.Name, Login = x.Login }))
{
result.Add(new User
{
UID = item.UID,
Name = item.Name,
Login = item.Login
});
}
if (!result.Any())
{
var userpermissions = new List<UserPermission>();
User user = new User() { Name = "Adm", Login = "******", PasswordHash = HashHelper.GetHashFromString("") };
userpermissions.Add(new UserPermission { User = user, PermissionType = PermissionType.ViewConsumer });
userpermissions.Add(new UserPermission { User = user, PermissionType = PermissionType.ViewDevice });
userpermissions.Add(new UserPermission { User = user, PermissionType = PermissionType.EditConsumer });
userpermissions.Add(new UserPermission { User = user, PermissionType = PermissionType.EditDevice });
userpermissions.Add(new UserPermission { User = user, PermissionType = PermissionType.EditUser });
userpermissions.Add(new UserPermission { User = user, PermissionType = PermissionType.ViewUser });
userpermissions.Add(new UserPermission { User = user, PermissionType = PermissionType.ViewJournal });
userpermissions.Add(new UserPermission { User = user, PermissionType = PermissionType.ViewPlot });
userpermissions.Add(new UserPermission { User = user, PermissionType = PermissionType.ViewReport });
userpermissions.Add(new UserPermission { User = user, PermissionType = PermissionType.ViewTariff });
userpermissions.Add(new UserPermission { User = user, PermissionType = PermissionType.EditTariff });
user.UserPermissions = userpermissions;
context.Users.Add(user);
context.SaveChanges();
result.Add(user);
}
return result;
}
}
catch (Exception e)
{
MessageBoxService.ShowException(e);
return null;
}
}
void OnGKObjectsStateChanged(object obj)
{
alarms = new List<Alarm>();
foreach (var device in XManager.Devices)
{
if (!device.IsRealDevice)
//|| device.DriverType == XDriverType.GK || device.DriverType == XDriverType.KAU || device.DriverType == XDriverType.RSR2_KAU)
continue;
foreach (var stateClass in device.State.StateClasses)
{
switch (stateClass)
{
case XStateClass.Ignore:
alarms.Add(new Alarm(XAlarmType.Ignore, device));
break;
case XStateClass.Failure:
alarms.Add(new Alarm(XAlarmType.Failure, device));
break;
case XStateClass.On:
case XStateClass.TurningOn:
if (device.Driver.IsControlDevice)
{
if (!alarms.Any(x => x.AlarmType == XAlarmType.Turning && x.Device.UID == device.UID))
{
alarms.Add(new Alarm(XAlarmType.Turning, device));
}
}
break;
case XStateClass.Fire1:
alarms.Add(new Alarm(XAlarmType.Turning, device));
break;
case XStateClass.Fire2:
if (device.DriverType != XDriverType.AM1_T)
{
alarms.Add(new Alarm(XAlarmType.Turning, device));
}
break;
}
}
if (device.State.StateClasses.Contains(XStateClass.AutoOff) && device.Driver.IsControlDevice)
{
alarms.Add(new Alarm(XAlarmType.AutoOff, device));
}
if (device.State.StateClasses.Contains(XStateClass.Service)) // || device.DeviceState.IsRealMissmatch)
{
alarms.Add(new Alarm(XAlarmType.Service, device));
}
}
foreach (var zone in XManager.Zones)
{
foreach (var stateClass in zone.State.StateClasses)
{
switch (stateClass)
{
case XStateClass.Fire2:
alarms.Add(new Alarm(XAlarmType.Fire2, zone));
break;
case XStateClass.Fire1:
alarms.Add(new Alarm(XAlarmType.Fire1, zone));
break;
case XStateClass.Attention:
alarms.Add(new Alarm(XAlarmType.Attention, zone));
break;
case XStateClass.Ignore:
alarms.Add(new Alarm(XAlarmType.Ignore, zone));
break;
}
}
//if (zone.ZoneState.IsRealMissmatch)
//{
// alarms.Add(new Alarm(XAlarmType.Service, zone));
//}
}
foreach (var direction in XManager.Directions)
{
foreach (var stateClass in direction.State.StateClasses)
{
switch (stateClass)
{
case XStateClass.On:
case XStateClass.TurningOn:
alarms.Add(new Alarm(XAlarmType.NPTOn, direction));
break;
case XStateClass.Ignore:
alarms.Add(new Alarm(XAlarmType.Ignore, direction));
break;
}
}
if (direction.State.StateClasses.Contains(XStateClass.AutoOff))
{
alarms.Add(new Alarm(XAlarmType.AutoOff, direction));
}
//if (direction.DirectionState.IsRealMissmatch)
//{
// alarms.Add(new Alarm(XAlarmType.Service, direction));
//}
}
alarms = (from Alarm alarm in alarms orderby alarm.AlarmType select alarm).ToList();
UpdateAlarms();
AlarmGroupsViewModel.Current.Update(alarms);
}
//TODO: lot of copy-pasta here. Refactor!
private string doRequest(string methodName, List<Tuple<string, string>> paramz = null)
{
ServicePointManager.ServerCertificateValidationCallback = delegate { return true; };
WebException exc = null;
var delay = 0;
for (int i = 1; i <= RETRY_COUNT; i++)
{
var serverTimeDiff = new TimeSpan(-2, 0, 0);
var totalSeconds = (long)Math.Round((DateTime.Now - new DateTime(1970, 1, 1) + serverTimeDiff).TotalSeconds); //TODO: using DateTime.Now is not ideal, should use server time
totalSeconds += _timeOffset;
var parameters = new List<Tuple<string, string>>
{
//Must be sorted by key
new Tuple<string, string>("access_key", _config.AccessKey),
new Tuple<string, string>("created", totalSeconds.ToString()),
new Tuple<string, string>("method", methodName),
new Tuple<string, string>("secret_key", _config.SecretKey)
};
if (null != paramz && paramz.Any())
{
parameters.AddRange(paramz);
parameters = parameters.OrderBy(tuple => tuple.Item1).ToList();
}
//Finally add MD5 hash sign. It's out of sorting.
var sign = getMD5Hash(buildQueryString(parameters));
parameters.Add(new Tuple<string, string>("sign", sign));
var postData = buildQueryString(parameters);
delay += RETRY_DELAY;
try
{
var text = sendPostRequest(TRADING_API_URL, postData);
_logger.LastResponse = text;
return text;
}
catch (WebException we)
{
var text = String.Format("(ATTEMPT {0}/{1}) Web request failed with exception={2}; status={3}", i, RETRY_COUNT, we.Message, we.Status);
_logger.Warning(text);
exc = we;
Thread.Sleep(delay);
}
}
throw new Exception(String.Format("Web request failed {0} times in a row with error '{1}'. Giving up.", RETRY_COUNT, exc.Message));
}
private List<ObjectProvider> GetObjectProviders()
{
if (this.InstallAdapter.MetadataTimestamp != this.InstallAdapter.RetrieveMetadataTimestamp())
{
List<ObjectProvider> MtoMAvailableProviders = new List<ObjectProvider>();
this.availableProviders = new List<ObjectProvider>();
RetrieveAllEntitiesRequest retrieveAll = new RetrieveAllEntitiesRequest();
RetrieveAllEntitiesResponse response = new RetrieveAllEntitiesResponse();
RetrieveEntityRequest entityRequest = new RetrieveEntityRequest();
this.PublishPreConfigurationMessage(string.Format(CultureInfo.CurrentCulture, Resources.StartRetrievingEntityMetadata));
response = this.InstallAdapter.OrganizationService.Execute(retrieveAll) as RetrieveAllEntitiesResponse;
foreach (EntityMetadata crmMetadata in response.EntityMetadata)
{
entityRequest.MetadataId = crmMetadata.MetadataId.Value;
entityRequest.EntityFilters = EntityFilters.Relationships;
RetrieveEntityResponse entityResponse = this.InstallAdapter.OrganizationService.Execute(entityRequest) as RetrieveEntityResponse;
if (entityResponse.EntityMetadata.DisplayName.LocalizedLabels.Count > 0 && !entityResponse.EntityMetadata.LogicalName.StartsWith("dynamics_deleted", StringComparison.OrdinalIgnoreCase) && entityResponse.EntityMetadata.IsCustomizable.Value)
{
this.availableProviders.Add(new DynamicObjectProvider() { Adapter = this.InstallAdapter, Id = crmMetadata.MetadataId.Value, DisplayName = entityResponse.EntityMetadata.DisplayName.LocalizedLabels[0].Label, Name = entityResponse.EntityMetadata.LogicalName });
}
List<ManyToManyRelationshipMetadata> entityMToMRelationships = (from meta in entityResponse.EntityMetadata.ManyToManyRelationships
where (meta.IsCustomRelationship.Value == true)
|| (meta.SecurityTypes == SecurityTypes.ParentChild && meta.IsCustomRelationship.Value == false)
select meta).ToList();
if (entityMToMRelationships.Count > 0)
{
foreach (ManyToManyRelationshipMetadata relation in entityMToMRelationships)
{
if (!MtoMAvailableProviders.Any(f => f.DisplayName == relation.SchemaName))
{
MtoMAvailableProviders.Add(new DynamicObjectProvider() { Adapter = this.InstallAdapter, Id = relation.MetadataId.Value, DisplayName = relation.SchemaName, Name = relation.SchemaName + ",Relationship" });
}
}
}
}
foreach (ObjectProvider relationObjectProvider in MtoMAvailableProviders)
{
this.availableProviders.Add(relationObjectProvider);
}
this.PublishPostConfigurationMessage(string.Format(CultureInfo.CurrentCulture, Resources.FinishedRetreivingEntityMetadata));
this.InstallAdapter.MetadataTimestamp = this.InstallAdapter.RetrieveMetadataTimestamp();
this.PublishPostConfigurationMessage(string.Format(CultureInfo.CurrentCulture, Resources.MetadataTimeStamp, this.InstallAdapter.MetadataTimestamp));
}
return this.availableProviders;
}
public Player Apply(TurnInfo info, IEnumerable<Player> queue)
{
var owner = queue.FirstOrDefault(p => p == info.Ball.Owner);
// We are not the owner.
if (owner == null) { return null; }
var ownerDistanceToGoal2 = (Field.EnemyGoal.Center - owner.Position).LengthSquared;
if(!info.Other.Players.Any(p => (p.Position - Field.EnemyGoal.Center).LengthSquared < ownerDistanceToGoal2))
{
if (ownerDistanceToGoal2 < 150 * 150)
{
owner.ActionShootGoal();
}
else
{
owner.ActionGo(Field.EnemyGoal.Center);
}
return owner;
}
var shotOnGoalTop = Field.EnemyGoal.Top - owner.Position;
var shotOnGoalCen = Field.EnemyGoal.Center - owner.Position;
var shotOnGoalBot = Field.EnemyGoal.Bottom - owner.Position;
var accuracy = Statistics.GetAccuracy(10, 0.75f);
var shotAngle = Theta.Create(shotOnGoalTop, shotOnGoalBot);
if (shotAngle > 2f * accuracy)
{
if (!info.Other.Players.Any(oppo => MightCatch(oppo.Position - owner.Position, shotOnGoalCen, 10, 0.75f)))
{
owner.ActionShootGoal();
return owner;
}
}
var passCandidates = info.Own.Players
.Where(p => p != owner && IsCandidate(owner, p, ownerDistanceToGoal2))
.OrderBy(p => (Field.EnemyGoal.Center - p.Position).LengthSquared)
.ToList();
if (!passCandidates.Any())
{
owner.ActionGo(Field.EnemyGoal.Center);
return owner;
}
var oppos = info.Other.Players.Where(p => p.Position.X > owner.Position.X).ToList();
foreach (var z in PassingZs)
{
foreach (var power in PassingPowers)
{
var safe = new List<Player>();
foreach (var candidate in passCandidates)
{
if (!info.Other.Players.Any(oppo => MightCatch(oppo.Position - owner.Position, candidate.Position - owner.Position, power, z)))
{
safe.Add(candidate);
}
}
if (safe.Any())
{
var target = safe.OrderBy(s => (s.Position - Field.EnemyGoal.Center).LengthSquared).FirstOrDefault();
owner.ActionShoot(target, PassingPower);
return owner;
}
}
}
// else run.
owner.ActionGo(Field.EnemyGoal.Center);
return owner;
}
private double suggestSellPrice(List<Order> asks)
{
if (null == asks || !asks.Any())
{
return _sellOrderPrice > 0.0 ? _sellOrderPrice : _minSellPrice;
}
const int DEC_PLACES = 14;
double increment = 2.0 * _minPriceUpdate;
//Find first ASK price higher than minPrice
foreach (Order ask in asks)
{
//Don't consider own order
if (ask.SequenceNumber == _sellOrderId) //TODO: this is a pure guess. In case orderbook bid/ask cannot be matched with my order, use old method (price and amount equality)
{
continue;
}
if (ask.Price >= _minSellPrice)
{
double sellPrice = Math.Round(ask.Price - increment, DEC_PLACES);
//The difference is too small. Leave previous price to avoid server call
if (-1 != _sellOrderId && Math.Abs(sellPrice - _sellOrderPrice) < _minPriceUpdate)
{
log(String.Format("DEBUG: SELL price {0:0.00000} too similar, using previous", sellPrice));
return _sellOrderPrice;
}
if (sellPrice > _maxSellPrice)
{
return _maxSellPrice;
}
return sellPrice;
}
}
//Order book filled with junk. Use order before last, so we see it in chart
double price = asks.Last().Price - increment;
if (-1 != _sellOrderId && Math.Abs(price - _sellOrderPrice) < _minPriceUpdate)
{
return _sellOrderPrice;
}
return Math.Round(price, DEC_PLACES);
}
/// <summary>
/// Adds the passenger.
/// </summary>
/// <param name="passengerPresenter">The passenger presenter.</param>
/// <returns>
/// The JSON Result
/// </returns>
public JsonResult AddPassenger(PassengerPresenter passengerPresenter)
{
if (passengerPresenter != null)
{
if (!string.IsNullOrEmpty(passengerPresenter.PersonIds) || (SessionData.Instance.SelectedPassengerIds != null && SessionData.Instance.SelectedPassengerIds.Count > 0))
{
var filteredPersonList = new List<Person>();
foreach (var persionId in SessionData.Instance.SelectedPassengerIds)
{
if (!SessionData.Instance.SelectedPersonIds.Contains(persionId))
{
SessionData.Instance.SelectedPersonIds.Add(persionId);
}
}
foreach (var personId in SessionData.Instance.SelectedPersonIds)
{
if (SessionData.Instance.PersonItemListResult != null)
{
foreach (var person in SessionData.Instance.PersonItemListResult)
{
if (person.PersonId == personId)
{
filteredPersonList.Add(person);
}
}
}
}
if (filteredPersonList.Count > 0)
{
if (SessionData.Instance.FilterPersonList != null)
{
foreach (var person in SessionData.Instance.FilterPersonList)
{
if (!filteredPersonList.Any(p => p.PersonId == person.PersonId))
{
filteredPersonList.Add(person);
}
}
}
}
SessionData.Instance.AssignFilterPersonResult(filteredPersonList);
}
}
return this.Json(true);
}
private double suggestPrice(List<FiatAsk> asks, double minPrice, double maxPrice, int currentOrderId, double currentOrderPrice, double minPriceUpdate)
{
if (null == asks || !asks.Any())
{
return currentOrderPrice > 0.0 ? currentOrderPrice : minPrice;
}
const int DEC_PLACES = 14;
double increment = 2.0 * minPriceUpdate;
//Find first ASK price higher than minPrice
foreach (FiatAsk ask in asks)
{
//Don't consider own order
if (_config.AccessKey == ask.Account && ask.Sequence == currentOrderId)
{
continue;
}
if (ask.Price >= minPrice)
{
double sellPrice = Math.Round(ask.Price - increment, DEC_PLACES);
//The difference is too small. Leave previous price to avoid server call
if (-1 != currentOrderId && Math.Abs(sellPrice - currentOrderPrice) < minPriceUpdate)
{
log(String.Format("DEBUG: price {0:0.00000} too similar, using previous", sellPrice));
return currentOrderPrice;
}
if (sellPrice > maxPrice)
{
return maxPrice;
}
return sellPrice;
}
}
//Order book filled with junk. Use order before last, so we see it in chart
double price = asks.Last().Price - increment;
if (-1 != currentOrderId && Math.Abs(price - currentOrderPrice) < minPriceUpdate)
{
return currentOrderPrice;
}
if (price < minPrice)
{
return minPrice;
}
return Math.Round(price, DEC_PLACES);
}
private string sendPostRequest(string method, List<Tuple<string, string>> paramz = null)
{
string path = BASE_URL + method;
WebException exc = null;
for (int i = 1; i <= RETRY_COUNT; i++)
{
long nonce = DateTime.UtcNow.Ticks;
nonce += _nonceOffset;
string paramDict = "{" + String.Format("\"request\":\"/v1/{0}\",\"nonce\":\"{1}\"", method, nonce);
if (null != paramz && paramz.Any())
{
foreach (var param in paramz)
paramDict += "," + param.Item1 + ":" + param.Item2;
}
paramDict += "}";
string payload = Convert.ToBase64String(Encoding.UTF8.GetBytes(paramDict));
var hmac = new HMACSHA384(Encoding.UTF8.GetBytes(_config.SecretKey));
byte[] hash = hmac.ComputeHash(Encoding.UTF8.GetBytes(payload));
string hexHash = BitConverter.ToString(hash).Replace("-", "").ToLower();
var headers = new NameValueCollection
{
{"X-BFX-APIKEY", _config.AccessKey},
{"X-BFX-PAYLOAD", payload},
{"X-BFX-SIGNATURE", hexHash}
};
var request = (HttpWebRequest)WebRequest.Create(path);
request.KeepAlive = true;
request.Method = "POST";
if (null != _webProxy)
request.Proxy = _webProxy;
request.Headers.Add(headers);
byte[] byteArray = Encoding.UTF8.GetBytes(paramDict);
request.ContentLength = byteArray.Length;
using (var writer = request.GetRequestStream())
{
writer.Write(byteArray, 0, byteArray.Length);
}
try
{
using (WebResponse response = request.GetResponse())
{
using (Stream stream = response.GetResponseStream())
{
using (var reader = new StreamReader(stream))
{
var text = reader.ReadToEnd();
_logger.LastResponse = text;
return text;
}
}
}
}
catch (WebException we)
{
//Business errors act as 400-ProtocolError, so must be sorted out
if (we.Response != null)
{
using (var errorResponse = (HttpWebResponse)we.Response)
{
using (var reader = new StreamReader(errorResponse.GetResponseStream()))
{
string json = reader.ReadToEnd();
var error = Helpers.DeserializeJSON<ErrorResponse>(json);
if (!String.IsNullOrEmpty(error.message))
return json;
}
}
}
//Else real HTTP problem
var text = String.Format("(ATTEMPT {0}/{1}) Web request failed with exception={2}; status={3}", i, RETRY_COUNT, we.Message, we.Status);
_logger.Warning(text);
exc = we;
Thread.Sleep(RETRY_DELAY);
}
}
throw new Exception(String.Format("Web request failed {0} times in a row with error '{1}'. Giving up.", RETRY_COUNT, exc.Message));
}
private double suggestSellPrice(List<MarketOrder> asks)
{
if (null == asks || !asks.Any())
{
return _sellOrderPrice > 0.0 ? _sellOrderPrice : _sellMinPrice;
}
const int DEC_PLACES = 14;
double increment = 2.0 * _minPriceUpdate;
//Find first ASK price higher than minPrice
foreach (MarketOrder ask in asks)
{
//Don't consider own order
if (ask.Amount.eq(_sellOrderAmount) && ask.Price.eq(_sellOrderPrice))
{
continue;
}
if (ask.Price >= _sellMinPrice)
{
double sellPrice = Math.Round(ask.Price - increment, DEC_PLACES);
//The difference is too small. Leave previous price to avoid server call
if (-1 != _sellOrderId && Math.Abs(sellPrice - _sellOrderPrice) < _minPriceUpdate)
{
log($"DEBUG: price {sellPrice:0.#####} too similar, using previous");
return _sellOrderPrice;
}
if (sellPrice > _sellMaxPrice)
{
return _sellMaxPrice;
}
return sellPrice;
}
}
//Order book filled with junk. Use order before last, so we see it in order book
double price = asks.Last().Price - increment;
if (-1 != _sellOrderId && Math.Abs(price - _sellOrderPrice) < _minPriceUpdate)
{
return _sellOrderPrice;
}
if (price < _sellMinPrice)
{
return _sellMinPrice;
}
return Math.Round(price, DEC_PLACES);
}
private double suggestBuyPrice(List<MarketOrder> bids)
{
if (null == bids || !bids.Any())
{
return _buyOrderPrice > 0.0 ? _buyOrderPrice : _buyMaxPrice;
}
const int DEC_PLACES = 14;
double increment = 2.0 * _minPriceUpdate;
//Find first BID price lower than maxPrice
foreach (MarketOrder bid in bids)
{
//Don't consider own order
if (bid.Amount.eq(_buyOrderAmount) && bid.Price.eq(_buyOrderPrice))
{
continue;
}
if (bid.Price <= _buyMaxPrice)
{
double buyPrice = Math.Round(bid.Price + increment, DEC_PLACES);
//The difference is too small. Leave previous buy price to avoid server call
if (-1 != _buyOrderId && Math.Abs(buyPrice - _buyOrderPrice) < _minPriceUpdate)
{
log($"DEBUG: price {buyPrice:0.#####} too similar, using previous");
return _buyOrderPrice;
}
if (buyPrice < _buyMinPrice)
{
return _buyMinPrice;
}
return buyPrice;
}
}
//Order book filled with junk. Use order before last, so we see it in order book
double price = bids.Last().Price + increment;
if (-1 != _buyOrderId && Math.Abs(price - _buyOrderPrice) < _minPriceUpdate)
{
return _buyOrderPrice;
}
if (price > _buyMaxPrice)
{
return _buyMaxPrice;
}
return Math.Round(price, DEC_PLACES);
}
/// <summary>
/// The cache assembly.
/// </summary>
/// <param name="activityAssemblyItems">
/// The activity assembly items.
/// </param>
public static void CacheAssembly(List<ActivityAssemblyItem> activityAssemblyItems, bool isFromServer = false)
{
if (activityAssemblyItems == null)
{
throw new ArgumentNullException("activityAssemblyItems");
}
if (activityAssemblyItems.Any(item => item == null))
{
throw new ArgumentNullException("activityAssemblyItems");
}
foreach (ActivityAssemblyItem assemblyItem in activityAssemblyItems)
{
// Skip cached item
if (assemblyItem.CachingStatus == CachingStatus.Latest)
{
continue;
}
// Check if a location is already in location catalog. If true, remove it first.
ActivityAssemblyItem cachedAssembly;
if (Utility.LoadCachedAssembly(ActivityAssemblyItems, assemblyItem.AssemblyName, out cachedAssembly))
{
ActivityAssemblyItems.Remove(cachedAssembly);
}
// Copy assemblies to local caching directory
string destFileName = Utility.CopyAssemblyToLocalCachingDirectory(assemblyItem.AssemblyName, assemblyItem.Location, false);
// break link to original location by resetting Location and AssemblyName.CodeBase
assemblyItem.Location = destFileName;
assemblyItem.AssemblyName.CodeBase = null;
assemblyItem.UpdateDateTime = DateTime.Now;
assemblyItem.CachingStatus = CachingStatus.Latest;
if (isFromServer)
{
var inspection = Utility.GetAssemblyInspectionService();
inspection.Inspect(destFileName);
assemblyItem.ActivityItems = inspection.SourceAssembly.ActivityItems;
assemblyItem.UserSelected = true;
assemblyItem.ActivityItems.ToList().ForEach(i =>
{
i.UserSelected = true;
i.Category = "Unassigned";
});
}
// Make ActivityItem read only. Note: ActivityItem's metadata can be edited only when imported.
foreach (var activityItem in assemblyItem.ActivityItems)
{
activityItem.IsReadOnly = true;
activityItem.CachingStatus = CachingStatus.Latest;
}
ActivityAssemblyItems.Add(assemblyItem);
}
}
private static bool SetGroupNumbersIfFilled(Dictionary<IndexPair, IEnumerable<sbyte>> dict, int count)
{
var isModified = false;
var manyValuesItems = dict.Where(item => item.Value.Count() > count).ToList();
var subItemsList = manyValuesItems.SelectMany(item => item.Value.OrderBy(x => x).GetAllSubItems(count));
var distinctSubItems = new List<List<sbyte>>();
foreach (var subItems in subItemsList)
{
var currentSubItems = subItems;
if (!distinctSubItems.Any(item => item.SequenceEqual(currentSubItems)))
distinctSubItems.Add(currentSubItems);
}
foreach (var groupItems in distinctSubItems)
{
if (groupItems.Any(item => dict.Count(x => x.Value.Contains(item)) != count))
continue;
var currentItems = groupItems;
var itemsContainsGroupItems = dict.Where(item => item.Value.Contains(currentItems)).ToList();
if (itemsContainsGroupItems.Count == count)
{
foreach (var item in itemsContainsGroupItems)
{
dict.Remove(item.Key);
dict.Add(item.Key, currentItems);
isModified = true;
}
}
}
return isModified;
}
/// <summary>
/// Gets a <c>Dictionary</c> that represents a <c>DynamicEntity</c>.
/// </summary>
/// <param name="entity">The CRM <c>Entity</c> to return as a <c>Dictioanry</c>.</param>
/// <param name="adapter">An instance of a <c>CRMAdapter</c> to use when getting dynamics_integrationkey data for a <c>Lookup</c> type.</param>
/// <param name="fieldDefinitions">The <C>List</C> of <see cref="FieldDefinition"/>s to use when populating the <C>Dictionary</C>.</param>
/// <returns>A <c>Dictionary</c> that has Keys that are the property names of the <c>DynamicEntity</c> supplied and
/// Values that are the values of those properties on the <c>DynamicEntity</c>.</returns>
internal static Dictionary<string, object> GetDictionary(Entity entity, DynamicCrmAdapter adapter, List<FieldDefinition> fieldDefinitions)
{
Dictionary<string, object> dictionary = new Dictionary<string, object>();
// This dictionary is for holding a complexType that might be the type for the current property on the entity
Dictionary<string, object> holdingDictionary;
foreach (KeyValuePair<string, object> property in entity.Attributes)
{
// CrmMoney needs the dictionary to be converted but it also starts with the same prefix as the property types that do not,so handle it separately
// else if the property is not one of the Built-in types and is also not of the StringProperty type, use the holding dictionary
Type propertyType = property.Value.GetType();
holdingDictionary = new Dictionary<string, object>();
if (propertyType == typeof(Money))
{
PopulateDictionary(entity, holdingDictionary, property);
}
else if (propertyType == typeof(OptionSetValue))
{
PopulateOptionSetValueDictionary(entity, holdingDictionary, property, adapter);
}
else if (propertyType == typeof(EntityReference))
{
FieldDefinition definition = fieldDefinitions.FirstOrDefault(x => x.Name == property.Key);
PopulateDictionary(entity, holdingDictionary, property, adapter, definition);
}
else if (propertyType == typeof(EntityCollection))
{
FieldDefinition definition = fieldDefinitions.FirstOrDefault(x => x.Name == property.Key);
PopulatePartyList(entity, holdingDictionary, property, adapter, definition);
}
// The property is of a ComplexType and the holding dictionary was populated
// else if the property is one of the Built-in CRM types just convert it
// else if the property was a string property, just use its value
if (holdingDictionary.Count > 0)
{
dictionary.Add(property.Key, holdingDictionary);
}
else
{
dictionary.Add(property.Key, property.Value);
}
}
if (fieldDefinitions.Any(x => x.Name == "overriddencreatedon"))
{
dictionary.Add("overriddencreatedon", null);
}
return dictionary;
}
public void Update()
{
var libraryDevice = FiresecManager.DeviceLibraryConfiguration.Devices.FirstOrDefault(x => x.DriverId == DriverId);
if (libraryDevice == null)
{
Logger.Error("DeviceControl.Update libraryDevice = null " + DriverId.ToString());
return;
}
var additionalLibraryStates = new List<LibraryState>();
foreach (var additionalStateCode in AdditionalStateCodes)
{
var additionalState = libraryDevice.States.FirstOrDefault(x => x.Code == additionalStateCode);
if (additionalState != null)
{
if (additionalState.StateType == StateType)
{
additionalLibraryStates.Add(additionalState);
}
}
}
var resultLibraryStates = new List<LibraryState>();
if (_xstateViewModelList.IsNotNullOrEmpty())
_stateViewModelList.ForEach(x => x.Dispose());
_stateViewModelList = new List<StateViewModel>();
var libraryState = libraryDevice.States.FirstOrDefault(x => x.Code == null && x.StateType == StateType);
if (libraryState == null)
{
if (!additionalLibraryStates.Any(x => x.StateType == StateType))
{
libraryState = libraryDevice.States.FirstOrDefault(x => x.Code == null && x.StateType == StateType.No);
if (libraryState == null)
{
Logger.Error("DeviceControl.Update libraryState = null " + DriverId.ToString());
return;
}
}
}
if (libraryState != null)
{
resultLibraryStates.Add(libraryState);
}
foreach (var additionalLibraryState in additionalLibraryStates)
{
resultLibraryStates.Add(additionalLibraryState);
}
var sortedResultLibraryStates = from LibraryState state in resultLibraryStates
orderby state.Layer
select state;
var canvases = new List<Canvas>();
foreach (var libraryStates in sortedResultLibraryStates)
{
_stateViewModelList.Add(new StateViewModel(libraryStates, canvases));
}
_canvas.Children.Clear();
foreach (var canvas in canvases)
_canvas.Children.Add(new Viewbox() { Child = canvas });
}
private double suggestBuyPrice(List<Order> bids)
{
if (null == bids || !bids.Any())
{
return _buyOrderPrice > 0.0 ? _buyOrderPrice : _maxBuyPrice;
}
const int DEC_PLACES = 14;
double increment = 2.0 * _minPriceUpdate;
//Find first BID price lower than max. price
foreach (Order bid in bids)
{
//Don't consider own order
if (bid.SequenceNumber == _sellOrderId) //TODO: this is a pure guess. In case orderbook bid/ask cannot be matched with my order, use old method (price and amount equality)
{
continue;
}
if (bid.Price <= _maxBuyPrice)
{
double buyPrice = Math.Round(bid.Price + increment, DEC_PLACES);
//The difference is too small. Leave previous price to avoid server call
if (-1 != _buyOrderId && Math.Abs(buyPrice - _buyOrderPrice) < _minPriceUpdate)
{
log(String.Format("DEBUG: BUY price {0:0.00000} too similar, using previous", buyPrice));
return _buyOrderPrice;
}
if (buyPrice > _maxBuyPrice)
{
return _maxBuyPrice;
}
return buyPrice;
}
}
//Order book filled with junk. Use order before last, so we see it in chart
double price = bids.Last().Price + increment;
if (-1 != _buyOrderId && Math.Abs(price - _buyOrderPrice) < _minPriceUpdate)
{
return _buyOrderPrice;
}
return Math.Round(price, DEC_PLACES);
}
public static Driver Convert(Firesec.Models.Metadata.config coreDriversConfig, drvType innerDriver)
{
var driver = new Driver()
{
UID = new Guid(innerDriver.id),
StringUID = innerDriver.id,
Name = innerDriver.name,
ShortName = innerDriver.shortName,
HasAddress = innerDriver.ar_no_addr != "1",
IsAutoCreate = innerDriver.acr_enabled == "1",
MinAutoCreateAddress = int.Parse(innerDriver.acr_from),
MaxAutoCreateAddress = int.Parse(innerDriver.acr_to),
HasAddressMask = innerDriver.addrMask != null,
IsAlternativeUSB = innerDriver.altIntf != null,
ChildAddressMask = innerDriver.childAddrMask,
IsZoneDevice = ((innerDriver.minZoneCardinality == "0") && (innerDriver.maxZoneCardinality == "0")) == false,
IsDeviceOnShleif = innerDriver.addrMask != null && (innerDriver.addrMask == "[8(1)-15(2)];[0(1)-7(255)]" || innerDriver.addrMask == "[0(1)-8(30)]")
};
var driverData = DriversHelper.DriverDataList.FirstOrDefault(x => x.DriverId == innerDriver.id && x.IgnoreLevel < 2);
if (driverData != null)
driver.DriverType = driverData.DriverType;
if (innerDriver.options != null)
{
driver.DisableAutoCreateChildren = innerDriver.options.Contains("DisableAutoCreateChildren");
driver.IsZoneLogicDevice = innerDriver.options.Contains("ExtendedZoneLogic");
driver.CanDisable = innerDriver.options.Contains("Ignorable");
driver.IsPlaceable = innerDriver.options.Contains("Placeable") && driver.DriverType != DriverType.Computer;
driver.IsOutDevice = innerDriver.options.Contains("OutDevice");
driver.IgnoreInZoneState = innerDriver.options.Contains("IgnoreInZoneState");
driver.IsNotValidateZoneAndChildren = innerDriver.options.Contains("NotValidateZoneAndChildren");
driver.IsSingleInParent = innerDriver.options.Contains("Single");
driver.IsSingleInZone = innerDriver.options.Contains("SingleInZone");
driver.CanMonitoringDisable = innerDriver.options.Contains("CannotDisable") == false;
driver.CanWriteDatabase = innerDriver.options.Contains("DeviceDatabaseWrite");
driver.CanReadDatabase = innerDriver.options.Contains("DeviceDatabaseRead");
driver.CanReadJournal = innerDriver.options.Contains("EventSource")
&& driver.DriverType != DriverType.MS_1
&& driver.DriverType != DriverType.MS_2
&& driver.DriverType != DriverType.IndicationBlock
&& driver.DriverType != DriverType.MS_3
&& driver.DriverType != DriverType.MS_4
&& driver.DriverType != DriverType.PDU
&& driver.DriverType != DriverType.PDU_PT
&& driver.DriverType != DriverType.UOO_TL;
driver.CanSynchonize = innerDriver.options.Contains("HasTimer");
driver.CanReboot = innerDriver.options.Contains("RemoteReload");
driver.CanGetDescription = innerDriver.options.Contains("DescriptionString");
driver.CanSetPassword = innerDriver.options.Contains("PasswordManagement");
driver.CanUpdateSoft = innerDriver.options.Contains("SoftUpdates");
driver.CanExecuteCustomAdminFunctions = innerDriver.options.Contains("CustomIOCTLFunctions");
}
if (driver.DriverType == DriverType.Exit)
driver.IsPlaceable = false;
var metadataClass = [email protected](x => x.clsid == innerDriver.clsid);
if (metadataClass != null)
{
driver.DeviceClassName = metadataClass.param.FirstOrDefault(x => x.name == "DeviceClassName").value;
}
driver.CanEditAddress = true;
if (innerDriver.ar_no_addr != null)
{
if (innerDriver.ar_no_addr == "1")
driver.CanEditAddress = false;
if (innerDriver.acr_enabled == "1")
driver.CanEditAddress = false;
}
driver.ShleifCount = 0;
if (innerDriver.childAddrMask != null)
{
switch (innerDriver.childAddrMask)
{
case "[8(1)-15(2)];[0(1)-7(255)]":
driver.ShleifCount = 2;
break;
case "[8(1)-15(4)];[0(1)-7(255)]":
driver.ShleifCount = 4;
break;
case "[8(1)-15(10)];[0(1)-7(255)]":
driver.ShleifCount = 10;
break;
}
}
if (driver.DriverType == DriverType.BUNS)
driver.ShleifCount = 2;
if (driver.DriverType == DriverType.USB_BUNS)
driver.ShleifCount = 2;
driver.HasShleif = driver.ShleifCount == 0 ? false : true;
if (innerDriver.name == "Насосная Станция")
driver.UseParentAddressSystem = false;
else
driver.UseParentAddressSystem = innerDriver.options != null && innerDriver.options.Contains("UseParentAddressSystem");
driver.IsChildAddressReservedRange = innerDriver.res_addr != null;
driver.ChildAddressReserveRangeCount = driver.IsChildAddressReservedRange ? int.Parse(innerDriver.res_addr) : 0;
if (innerDriver.addrMask == "[0(1)-8(8)]")
driver.IsRangeEnabled = true;
else
driver.IsRangeEnabled = innerDriver.ar_enabled == "1";
if (innerDriver.addrMask == "[0(1)-8(8)]")
driver.MinAddress = 1;
else
driver.MinAddress = int.Parse(innerDriver.ar_from);
if (innerDriver.addrMask == "[0(1)-8(8)]")
driver.MaxAddress = 8;
else
driver.MaxAddress = int.Parse(innerDriver.ar_to);
driver.IsBUtton = false;
switch (driver.DriverType)
{
case DriverType.StopButton:
case DriverType.StartButton:
case DriverType.AutomaticButton:
case DriverType.ShuzOffButton:
case DriverType.ShuzOnButton:
case DriverType.ShuzUnblockButton:
driver.IsBUtton = true;
break;
}
driver.Category = (DeviceCategoryType)int.Parse(innerDriver.cat);
driver.CategoryName = driver.Category.ToDescription();
driver.DeviceType = DeviceType.FireSecurity;
if (innerDriver.options != null)
{
if (innerDriver.options.Contains("FireOnly"))
driver.DeviceType = DeviceType.Fire;
if (innerDriver.options.Contains("SecOnly"))
driver.DeviceType = DeviceType.Sequrity;
if (innerDriver.options.Contains("TechOnly"))
driver.DeviceType = DeviceType.Technoligical;
}
driver.DeviceTypeName = driver.DeviceType.ToDescription();
var driverdata = DriversHelper.DriverDataList.FirstOrDefault(x => (x.DriverId == innerDriver.id));
if (driverdata != null)
{
driver.IsIgnore = driverdata.IgnoreLevel > 1;
driver.IsAssadIgnore = driverdata.IgnoreLevel > 0;
}
else
{
return null;
}
var allChildren = new List<drvType>();
foreach (var childDriver in coreDriversConfig.drv)
{
var childClass = [email protected](x => x.clsid == childDriver.clsid);
if (childClass != null && childClass.parent != null && childClass.parent.Any(x => x.clsid == innerDriver.clsid))
{
if (childDriver.lim_parent != null && childDriver.lim_parent != innerDriver.id)
continue;
allChildren.Add(childDriver);
}
}
try
{
driver.Children = new List<Guid>(
from drvType childInnerDriver in allChildren
where (DriversHelper.DriverDataList.FirstOrDefault(x => x.DriverId == childInnerDriver.id) != null &&
DriversHelper.DriverDataList.FirstOrDefault(x => x.DriverId == childInnerDriver.id).IgnoreLevel == 0)
select new Guid(childInnerDriver.id));
}
catch (Exception e)
{
Logger.Error(e);
}
driver.AvaliableChildren = new List<Guid>(
from drvType childInnerDriver in allChildren
where childInnerDriver.acr_enabled != "1"
select new Guid(childInnerDriver.id));
if (driver.DisableAutoCreateChildren)
{
driver.AutoCreateChildren = new List<Guid>();
}
else
{
driver.AutoCreateChildren = new List<Guid>(
from drvType childInnerDriver in allChildren
where childInnerDriver.acr_enabled == "1"
select new Guid(childInnerDriver.id));
}
driver.CanAddChildren = driver.AvaliableChildren.Count > 0;
if (innerDriver.child_id != null)
{
driver.AutoChild = new Guid(innerDriver.child_id);
driver.AutoChildCount = int.Parse(innerDriver.child_count);
}
driver.CanAutoDetect = allChildren.Any(x => (x.options != null) && (x.options.Contains("CanAutoDetectInstances")));
driver.Properties = new List<DriverProperty>();
if (innerDriver.propInfo != null && driver.DriverType != DriverType.PumpStation)
{
foreach (var internalProperty in innerDriver.propInfo)
{
if ((internalProperty.hidden == "1") && (driver.DriverType != DriverType.UOO_TL))
continue;
if (internalProperty.caption == "Заводской номер" || internalProperty.caption == "Версия микропрограммы")
continue;
if (internalProperty.name.StartsWith("Config$"))
continue;
if (internalProperty.name == "DeviceCountSecDev")
continue;
var driverProperty = new DriverProperty()
{
Name = internalProperty.name,
Caption = internalProperty.caption,
ToolTip = internalProperty.hint,
Default = internalProperty.@default,
Visible = internalProperty.hidden == "0" && internalProperty.showOnlyInState == "0",
IsHidden = internalProperty.hidden == "1",
BlockName = internalProperty.blockName
};
if (internalProperty.name.StartsWith("Control$"))
{
//driverProperty.Name = internalProperty.name.Replace("Control$", "");
driverProperty.IsControl = true;
}
driverProperty.Parameters = new List<DriverPropertyParameter>();
if (internalProperty.param != null)
{
foreach (var firesecParameter in internalProperty.param)
{
driverProperty.Parameters.Add(new DriverPropertyParameter()
{
Name = firesecParameter.name,
Value = firesecParameter.value
});
}
}
if (internalProperty.param != null)
{
driverProperty.DriverPropertyType = DriverPropertyTypeEnum.EnumType;
}
else
{
switch (internalProperty.type)
{
case "String":
driverProperty.DriverPropertyType = DriverPropertyTypeEnum.StringType;
break;
case "Int":
case "Double":
driverProperty.DriverPropertyType = DriverPropertyTypeEnum.IntType;
break;
case "Byte":
driverProperty.DriverPropertyType = DriverPropertyTypeEnum.ByteType;
break;
case "Bool":
driverProperty.DriverPropertyType = DriverPropertyTypeEnum.BoolType;
break;
case "Empty":
driverProperty.DriverPropertyType = DriverPropertyTypeEnum.Empty;
break;
default:
continue;
}
}
driver.Properties.Add(driverProperty);
}
}
driver.Parameters = new List<Parameter>();
if (innerDriver.paramInfo != null)
{
foreach (var innerParameter in innerDriver.paramInfo)
{
driver.Parameters.Add(new Parameter()
{
Name = innerParameter.name,
Caption = innerParameter.caption,
//Visible = innerParameter.hidden == "0" && innerParameter.showOnlyInState == "1"
Visible = innerParameter.showOnlyInState == "1"
});
}
}
driver.States = new List<DriverState>();
if (innerDriver.state != null)
{
var codes = new HashSet<string>();
foreach (var innerState in innerDriver.state)
{
if (codes.Add(innerState.code) == false)
{
innerState.code += "_" + Guid.NewGuid().ToString();
}
if (innerState.name == null)
continue;
if (innerState.code == null)
continue;
driver.States.Add(new DriverState()
{
Id = innerState.id,
Name = innerState.name,
AffectChildren = innerState.affectChildren == "1" ? true : false,
AffectParent = innerState.AffectedParent == "1" ? true : false,
StateType = (StateType)int.Parse(innerState.@class),
IsManualReset = innerState.manualReset == "1" ? true : false,
CanResetOnPanel = innerState.CanResetOnPanel == "1" ? true : false,
//IsAutomatic = innerState.type == "Auto" ? true : false,
IsAutomatic = (innerState.code.Contains("AutoOff") || innerState.code.Contains("Auto_Off") || innerState.code.Contains("Auto_off")),
Code = innerState.code
});
}
}
return driver;
}
private void AddWinnersToContestViewModel(ContestClosedViewModel model, List<User> users)
{
if (users.Any() && model != null)
{
foreach (var winner in users)
{
model.Winners.Add(winner.UserName);
}
}
}
void OnGKObjectsStateChanged(object obj)
{
alarms = new List<Alarm>();
foreach (var device in GKManager.Devices)
{
if (!device.IsRealDevice)
continue;
foreach (var stateClass in device.State.StateClasses)
{
switch (stateClass)
{
case XStateClass.Ignore:
alarms.Add(new Alarm(GKAlarmType.Ignore, device));
break;
case XStateClass.Failure:
alarms.Add(new Alarm(GKAlarmType.Failure, device));
break;
case XStateClass.On:
case XStateClass.TurningOn:
if (device.Driver.IsControlDevice)
{
if (!alarms.Any(x => x.AlarmType == GKAlarmType.Turning && x.GkBaseEntity.UID == device.UID))
{
alarms.Add(new Alarm(GKAlarmType.Turning, device));
}
}
break;
}
}
if (device.State.StateClasses.Contains(XStateClass.AutoOff) && device.Driver.IsControlDevice)
{
alarms.Add(new Alarm(GKAlarmType.AutoOff, device));
}
if (device.State.StateClasses.Contains(XStateClass.Service))
{
alarms.Add(new Alarm(GKAlarmType.Service, device));
}
}
foreach (var zone in GKManager.Zones)
{
foreach (var stateClass in zone.State.StateClasses)
{
switch (stateClass)
{
case XStateClass.Fire2:
alarms.Add(new Alarm(GKAlarmType.Fire2, zone));
break;
case XStateClass.Fire1:
alarms.Add(new Alarm(GKAlarmType.Fire1, zone));
break;
case XStateClass.Attention:
alarms.Add(new Alarm(GKAlarmType.Attention, zone));
break;
case XStateClass.Ignore:
alarms.Add(new Alarm(GKAlarmType.Ignore, zone));
break;
}
}
}
foreach (var guardZone in GKManager.GuardZones)
{
foreach (var stateClass in guardZone.State.StateClasses)
{
switch (stateClass)
{
case XStateClass.Fire1:
alarms.Add(new Alarm(GKAlarmType.GuardAlarm, guardZone));
break;
case XStateClass.Ignore:
alarms.Add(new Alarm(GKAlarmType.Ignore, guardZone));
break;
case XStateClass.Attention:
alarms.Add(new Alarm(GKAlarmType.Attention, guardZone));
break;
case XStateClass.AutoOff:
alarms.Add(new Alarm(GKAlarmType.AutoOff, guardZone));
break;
}
}
}
foreach (var door in GKManager.Doors)
{
foreach (var stateClass in door.State.StateClasses)
{
switch (stateClass)
{
case XStateClass.Fire2:
alarms.Add(new Alarm(GKAlarmType.Fire2, door));
break;
case XStateClass.Fire1:
alarms.Add(new Alarm(GKAlarmType.GuardAlarm, door));
break;
case XStateClass.Attention:
alarms.Add(new Alarm(GKAlarmType.Attention, door));
break;
case XStateClass.Ignore:
alarms.Add(new Alarm(GKAlarmType.Ignore, door));
break;
case XStateClass.AutoOff:
alarms.Add(new Alarm(GKAlarmType.AutoOff, door));
break;
}
}
}
foreach (var direction in GKManager.Directions)
{
foreach (var stateClass in direction.State.StateClasses)
{
switch (stateClass)
{
case XStateClass.On:
case XStateClass.TurningOn:
alarms.Add(new Alarm(GKAlarmType.NPTOn, direction));
break;
case XStateClass.Ignore:
alarms.Add(new Alarm(GKAlarmType.Ignore, direction));
break;
}
}
if (direction.State.StateClasses.Contains(XStateClass.AutoOff))
{
alarms.Add(new Alarm(GKAlarmType.AutoOff, direction));
}
if (!direction.State.StateClasses.Contains(XStateClass.Off) && !direction.State.StateClasses.Contains(XStateClass.On) &&
!direction.State.StateClasses.Contains(XStateClass.TurningOn) && !direction.State.StateClasses.Contains(XStateClass.TurningOff))
{
alarms.Add(new Alarm(GKAlarmType.StopStart, direction));
}
}
foreach (var pumpStation in GKManager.PumpStations)
{
foreach (var stateClass in pumpStation.State.StateClasses)
{
switch (stateClass)
{
case XStateClass.On:
case XStateClass.TurningOn:
alarms.Add(new Alarm(GKAlarmType.NPTOn, pumpStation));
break;
case XStateClass.Ignore:
alarms.Add(new Alarm(GKAlarmType.Ignore, pumpStation));
break;
}
}
if (pumpStation.State.StateClasses.Contains(XStateClass.AutoOff))
{
alarms.Add(new Alarm(GKAlarmType.AutoOff, pumpStation));
}
if (!pumpStation.State.StateClasses.Contains(XStateClass.Off) && !pumpStation.State.StateClasses.Contains(XStateClass.On) &&
!pumpStation.State.StateClasses.Contains(XStateClass.TurningOn) && !pumpStation.State.StateClasses.Contains(XStateClass.TurningOff))
{
alarms.Add(new Alarm(GKAlarmType.StopStart, pumpStation));
}
}
foreach (var mpt in GKManager.MPTs)
{
foreach (var stateClass in mpt.State.StateClasses)
{
switch (stateClass)
{
case XStateClass.On:
case XStateClass.TurningOn:
alarms.Add(new Alarm(GKAlarmType.NPTOn, mpt));
break;
case XStateClass.Ignore:
alarms.Add(new Alarm(GKAlarmType.Ignore, mpt));
break;
}
}
if (mpt.State.StateClasses.Contains(XStateClass.AutoOff))
{
alarms.Add(new Alarm(GKAlarmType.AutoOff, mpt));
}
if (!mpt.State.StateClasses.Contains(XStateClass.Off) && !mpt.State.StateClasses.Contains(XStateClass.On) &&
!mpt.State.StateClasses.Contains(XStateClass.TurningOn) && !mpt.State.StateClasses.Contains(XStateClass.TurningOff))
{
alarms.Add(new Alarm(GKAlarmType.StopStart, mpt));
}
}
foreach (var delay in GKManager.Delays)
{
foreach (var stateClass in delay.State.StateClasses)
{
switch (stateClass)
{
case XStateClass.On:
case XStateClass.TurningOn:
alarms.Add(new Alarm(GKAlarmType.Turning, delay));
break;
case XStateClass.Ignore:
alarms.Add(new Alarm(GKAlarmType.Ignore, delay));
break;
}
}
if (delay.State.StateClasses.Contains(XStateClass.AutoOff))
{
alarms.Add(new Alarm(GKAlarmType.AutoOff, delay));
}
}
alarms = (from Alarm alarm in alarms orderby alarm.AlarmType select alarm).ToList();
UpdateAlarms();
AlarmGroupsViewModel.Current.Update(alarms);
}
public static List<Rubezh2010.driverConfigDeviceStatesDeviceState> GetMetadataDeviceStates(Device device, bool isFireAndWarning)
{
//Test1();
var result = new List<Rubezh2010.driverConfigDeviceStatesDeviceState>();
var tableNo = MetadataHelper.GetDeviceTableNo(device);
if (tableNo != null)
{
foreach (var metadataDeviceState in MetadataHelper.Metadata.deviceStates)
{
if (metadataDeviceState.tableType == tableNo)
{
if (metadataDeviceState.ID == "MDU_Test")
continue;
result.Add(metadataDeviceState);
}
}
foreach (var metadataDeviceState in MetadataHelper.Metadata.deviceStates)
{
if (metadataDeviceState.tableType == null && metadataDeviceState.notForTableType != tableNo)
{
var bitNo = GetBitNo(metadataDeviceState);
var intBitNo = GetIntBitNo(metadataDeviceState);
var bits = GetBits(metadataDeviceState);
if (bitNo != -1)
{
if (!result.Any(x => GetBitNo(x) == bitNo))
{
if (!isFireAndWarning)
{
if (metadataDeviceState.ID == "Alarm" || metadataDeviceState.ID == "Warning")
{
switch (device.Driver.DriverType)
{
case DriverType.HandDetector:
case DriverType.RadioHandDetector:
if (metadataDeviceState.ID == "Warning")
continue;
break;
default:
if (metadataDeviceState.ID == "Alarm")
continue;
break;
}
}
}
result.Add(metadataDeviceState);
}
}
else
{
if (intBitNo != -1)
{
if (!result.Any(x => GetIntBitNo(x) == intBitNo))
{
result.Add(metadataDeviceState);
}
}
}
if (bitNo == -1 && intBitNo == -1 && bits == null)
{
result.Add(metadataDeviceState);
}
}
}
}
return result;
}
private int? ControlarImprimirEnvase(List<LINEA_VENTA> ImprimirLineasEnGrilla)
{
//controlo si existen envases
if (!ImprimirLineasEnGrilla.Any(x => x.ENV_ID != null))
return null;
List<LINEA_VENTA> listaEnvase = new List<LINEA_VENTA>();
decimal subTotal = 0;
decimal total = 0;
foreach (var item in ImprimirLineasEnGrilla)
{
if (item.ENV_ID != null)
{
listaEnvase.Add(item);
}
}
subTotal = listaEnvase.Sum(x => x.LIN_TOTAL);
total = subTotal;
var comprobante = cTIPO_COMPROBANTES.ObtenerPorDescripcion(Constantes.ValeEnvase);
int nroComprobante = (int)comprobante.TIC_ULTIMONUMERO;
comprobante.TIC_ULTIMONUMERO = nroComprobante + 1;
cTIPO_COMPROBANTES.Modificacion(comprobante);
var nroCompEnvase = comprobante.TIC_ULTIMONUMERO;
if (!ImpresoraOK)
{
MostrarMensajeInformativo(string.Format("Por falla de impresora se generó la devolución de envase Nro: {0}", nroCompEnvase));
return nroCompEnvase;
}
else
{
#region IMPRIME DOCUMENTO NO FISCAL
var noFiscal = new DocumentoNoFiscalTicket();
noFiscal.DescripcionCabecera1 = "---------------------------";
noFiscal.DescripcionCabecera2 = "-- Devolucion de Envases";
noFiscal.DescripcionCabecera3 = string.Format("-- Nro: {0}", TipoComprobante.TIC_ULTIMONUMERO);
noFiscal.DescripcionCabecera4 = "---------------------------";
noFiscal.items = new List<DocumentoNoFiscalTicketItem>();
foreach (LINEA_VENTA LineaEnGrilla in listaEnvase)
{
var item = new DocumentoNoFiscalTicketItem();
item.DescripcionItem = (LineaEnGrilla.LIN_DESCRESUMIDA.Length > 27) ? LineaEnGrilla.LIN_DESCRESUMIDA.Substring(0, 27) : LineaEnGrilla.LIN_DESCRESUMIDA.ToString();
item.Cantidad = LineaEnGrilla.LIN_CANTIDAD.ToString("0.000");
item.PrecioUnitario = LineaEnGrilla.LIN_PRECIOUNIDAD.ToString("0.000");
noFiscal.items.Add(item);
}
//DESCUENTO
noFiscal.DescuentoDescripcion = "";
noFiscal.DescuentoMonto = "";
//PAGO
noFiscal.PagoDescripcionExtra = "";
noFiscal.PagoDescripcion = "";
noFiscal.SubTotalMonto = subTotal.ToString("0.000");
noFiscal.TotalMonto = total.ToString("0.000");
//CIERRE
noFiscal.DescripcionPie1 = "Para retornar los envases";
noFiscal.DescripcionPie2 = "debe presentar el comprobante.";
noFiscal.DescripcionPie3 = "";
var retornoImpresion = frmImpresoraFiscal.DocumentoNoFiscalTicket(noFiscal);
if (retornoImpresion < 0)
return nroCompEnvase;
//MostrarMensajeInformativo("Se imprimió correctamente Nº: " + retornoImpresion);
#endregion
}
return nroCompEnvase;
}
public Task InstallPackage(CanonicalName canonicalName, bool? autoUpgrade, bool? force, bool? download, bool? pretend, CanonicalName replacingPackage)
{
var response = Event<GetResponseInterface>.RaiseFirst();
if (CancellationRequested) {
response.OperationCanceled("install-package");
return FinishedSynchronously;
}
double[] overallProgress = {0.0};
double[] eachTaskIsWorth = {0.0};
int[] lastProgress = {0};
Package currentPackageInstalling = null;
var numberOfPackagesToInstall = 0;
var numberOfPackagesToDownload = 0;
CurrentTask.Events += new IndividualProgress(percentage => {
overallProgress[0] += ((percentage - lastProgress[0])*eachTaskIsWorth[0])/100;
lastProgress[0] = percentage;
// ReSharper disable PossibleNullReferenceException ... this is what I really want. :[
// ReSharper disable AccessToModifiedClosure
response.InstallingPackageProgress(currentPackageInstalling.CanonicalName, percentage, (int)(overallProgress[0]*100));
// ReSharper restore AccessToModifiedClosure
// ReSharper restore PossibleNullReferenceException
});
var unwantedPackages = new List<Package>();
if( null != replacingPackage ) {
if( replacingPackage.DiffersOnlyByVersion(canonicalName)) {
unwantedPackages.AddRange(SearchForPackages(replacingPackage));
}
}
using (var manualResetEvent = new ManualResetEvent(true)) {
try {
lock (_manualResetEvents) {
_manualResetEvents.Add(manualResetEvent);
}
var packagesTriedToDownloadThisTask = new List<Package>();
if (canonicalName.IsPartial) {
response.Error("Invalid Canonical Name", "InstallPackage", "Canonical name '{0}' is not a complete canonical name".format(canonicalName));
}
var package = SearchForPackages(canonicalName).FirstOrDefault();
if (package == null) {
response.UnknownPackage(canonicalName);
return FinishedSynchronously;
}
if (package.IsBlocked) {
response.PackageBlocked(canonicalName);
return FinishedSynchronously;
}
var installedPackages = package.InstalledPackages.ToArray();
// is the user authorized to install this?
if (null != replacingPackage) {
if (replacingPackage.DiffersOnlyByVersion(canonicalName)) {
if (!Event<CheckForPermission>.RaiseFirst(PermissionPolicy.UpdatePackage)) {
return FinishedSynchronously;
}
}
} else {
if( package.LatestInstalledThatUpdatesToThis != null ) {
if (!Event<CheckForPermission>.RaiseFirst(PermissionPolicy.UpdatePackage)) {
return FinishedSynchronously;
}
} else {
if (!Event<CheckForPermission>.RaiseFirst(PermissionPolicy.InstallPackage)) {
return FinishedSynchronously;
}
}
}
// if this is an explicit update or upgrade,
// - check to see if there is a compatible package already installed that is marked do-not-update
// fail if so.
if (null != replacingPackage && unwantedPackages.Any( each => each.IsBlocked )) {
response.PackageBlocked(canonicalName);
return FinishedSynchronously;
}
// mark the package as the client requested.
package.PackageSessionData.DoNotSupercede = (false == autoUpgrade);
package.PackageSessionData.UpgradeAsNeeded = (true == autoUpgrade);
package.PackageSessionData.IsWanted = true;
// the resolve-acquire-install-loop
do {
// if the world changes, this will get set somewhere between here and the
// other end of the do-loop.
manualResetEvent.Reset();
if (CancellationRequested) {
response.OperationCanceled("install-package");
return FinishedSynchronously;
}
IEnumerable<Package> installGraph;
try {
UpdateDependencyFlags();
installGraph = GenerateInstallGraph(package).ToArray();
} catch (OperationCompletedBeforeResultException) {
// we encountered an unresolvable condition in the install graph.
// messages should have already been sent.
response.FailedPackageInstall(canonicalName, package.LocalLocations.FirstOrDefault(),
"One or more dependencies are unable to be resolved.");
return FinishedSynchronously;
}
// seems like a good time to check if we're supposed to bail...
if (CancellationRequested) {
response.OperationCanceled("install-package");
return FinishedSynchronously;
}
if (download == false && pretend == true) {
// we can just return a bunch of foundpackage messages, since we're not going to be
// actually installing anything, nor trying to download anything.
foreach (var p in installGraph) {
response.PackageInformation(p);
}
return FinishedSynchronously;
}
// we've got an install graph.
// let's see if we've got all the files
var missingFiles = (from p in installGraph where !p.HasLocalLocation select p).ToArray();
if (download == true) {
// we want to try downloading all the files that we're missing, regardless if we've tried before.
// unless we've already tried in this task once.
foreach (var p in missingFiles.Where(packagesTriedToDownloadThisTask.Contains)) {
packagesTriedToDownloadThisTask.Add(p);
p.PackageSessionData.CouldNotDownload = false;
}
}
if (numberOfPackagesToInstall != installGraph.Count() || numberOfPackagesToDownload != missingFiles.Count()) {
// recalculate the rest of the install progress based on the new install graph.
numberOfPackagesToInstall = installGraph.Count();
numberOfPackagesToDownload = missingFiles.Count();
eachTaskIsWorth[0] = (1.0 - overallProgress[0])/(numberOfPackagesToInstall + numberOfPackagesToDownload);
}
if (missingFiles.Any()) {
// we've got some packages to install that don't have files.
foreach (var p in missingFiles.Where(p => !p.PackageSessionData.HasRequestedDownload)) {
SessionData.Current.RequireRemoteFile(p.CanonicalName,
p.RemotePackageLocations, PackageManagerSettings.CoAppPackageCache, false,(rrfState) => {
Updated(); //shake loose anything that might be waiting for this.
return rrfState.LocalLocation;
});
p.PackageSessionData.HasRequestedDownload = true;
}
} else {
// check to see if this package requires trust.
bool ok = true;
foreach (var pkg in installGraph.Where(pkg => pkg.RequiresTrustedPublisher && !TrustedPublishers.ContainsIgnoreCase(pkg.PublicKeyToken))) {
response.FailedPackageInstall(pkg.CanonicalName, pkg.LocalLocations.FirstOrDefault(), "Package requires a trusted publisher key of '{0}'.".format(pkg.PublicKeyToken));
ok = false;
}
if( ok == false) {
return FinishedSynchronously;
}
if (pretend == true) {
// we can just return a bunch of found-package messages, since we're not going to be
// actually installing anything, and everything we needed is downloaded.
foreach (var p in installGraph) {
response.PackageInformation(p);
}
return FinishedSynchronously;
}
var failed = false;
// no missing files? Check
// complete install graph? Check
foreach (var p in installGraph) {
currentPackageInstalling = p;
// seems like a good time to check if we're supposed to bail...
if (CancellationRequested) {
response.OperationCanceled("install-package");
return FinishedSynchronously;
}
var validLocation = currentPackageInstalling.PackageSessionData.LocalValidatedLocation;
try {
if (!currentPackageInstalling.IsInstalled) {
if (string.IsNullOrEmpty(validLocation)) {
// can't find a valid location
response.FailedPackageInstall(currentPackageInstalling.CanonicalName, currentPackageInstalling.LocalLocations.FirstOrDefault(), "Can not find local valid package");
currentPackageInstalling.PackageSessionData.PackageFailedInstall = true;
} else {
lastProgress[0] = 0;
// GS01: We should put a softer lock here to keep the client aware that packages
// are being installed on other threads...
lock (typeof (MSIBase)) {
if (Engine.DoesTheServiceNeedARestart) {
// something has changed where we need restart the service before we can continue.
// and the one place we don't wanna be when we issue a shutdown in in Install :) ...
Engine.RestartService();
response.OperationCanceled("install-package");
return FinishedSynchronously;
}
// install progress is now handled by the delegate at the beginning of this function.
currentPackageInstalling.Install();
}
overallProgress[0] += ((100 - lastProgress[0])*eachTaskIsWorth[0])/100;
response.InstallingPackageProgress(currentPackageInstalling.CanonicalName, 100, (int)(overallProgress[0]*100));
response.InstalledPackage(currentPackageInstalling.CanonicalName);
Signals.InstalledPackage(currentPackageInstalling.CanonicalName);
}
}
} catch (Exception e) /* (PackageInstallFailedException pife) */ {
Logger.Error("FAILED INSTALL");
Logger.Error(e);
response.FailedPackageInstall(currentPackageInstalling.CanonicalName, validLocation, "Package failed to install.");
currentPackageInstalling.PackageSessionData.PackageFailedInstall = true;
if (!currentPackageInstalling.PackageSessionData.AllowedToSupercede) {
throw new OperationCompletedBeforeResultException(); // user specified packge as critical.
}
failed = true;
break;
}
}
if (!failed) {
if( unwantedPackages.Any()) {
foreach (Package eachPkg in unwantedPackages) {
eachPkg.IsWanted = false;
}
} else {
var olderpkgs = package.InstalledPackages.Where(each => each.IsWanted && package.IsNewerThan(each)).ToArray();
if( olderpkgs.Length > 0 ) {
//anthing older?
if( olderpkgs.Length > 1) {
// hmm. more than one.
// is there just a single thing we're updating?
olderpkgs = olderpkgs.Where(package.IsAnUpdateFor).ToArray();
}
// if we can get down to one, let's unwant that.
if (olderpkgs.Length == 1) {
((Package)olderpkgs[0]).IsWanted = false;
}
}
}
// W00T ... We did it!
// check for restart required...
if (Engine.DoesTheServiceNeedARestart) {
// something has changed where we need restart the service before we can continue.
// and the one place we don't wanna be when we issue a shutdown in in Install :) ...
response.Restarting();
Engine.RestartService();
return FinishedSynchronously;
}
return FinishedSynchronously;
}
// otherwise, let's run it thru again. maybe it'll come together.
}
//----------------------------------------------------------------------------
// wait until either the manualResetEvent is set, but check every second or so
// to see if the client has cancelled the operation.
while (!manualResetEvent.WaitOne(500)) {
if (CancellationRequested) {
response.OperationCanceled("install-package");
return FinishedSynchronously;
}
// we can also use this opportunity to update progress on any outstanding download tasks.
overallProgress[0] += missingFiles.Sum(missingFile => ((missingFile.PackageSessionData.DownloadProgressDelta*eachTaskIsWorth[0])/100));
}
} while (true);
} catch (OperationCompletedBeforeResultException) {
// can't continue with options given.
return FinishedSynchronously;
} finally {
// remove manualResetEvent from the mre list
lock (_manualResetEvents) {
_manualResetEvents.Remove(manualResetEvent);
}
}
}
}
static bool StreamsIsEquals(List<RviStream> oldRviStreams, List<RviStream> newRviStreams)
{
if (oldRviStreams.Count != newRviStreams.Count)
return false;
foreach (var rviStream in oldRviStreams)
{
if (!newRviStreams.Any(x => x.Number == rviStream.Number))
return false;
}
return true;
}
public Card CheckForAnounce(CardSuit trumpSuit, int cardsLeftInDeck, string state, ICollection<Card> playerCards)
{
if (state == GameStates.StartRoundState)
{
return null;
}
IList<Card> announcePairs = new List<Card>();
foreach (var card in playerCards)
{
if (card.Type == CardType.King || card.Type == CardType.Queen)
{
var otherTypeForAnnounce = card.Type == CardType.King ? CardType.Queen : CardType.King;
var otherCardForAnnounce = new Card(card.Suit, otherTypeForAnnounce);
if (this.cardHolder.AllCards[card.Suit][otherTypeForAnnounce] == CardStatus.InStalker)
{
announcePairs.Add(card);
announcePairs.Add(otherCardForAnnounce);
}
}
}
if (announcePairs.Count == 0)
{
return null;
}
// Check if it's forty.
if (announcePairs.Any(c => c.Suit == trumpSuit))
{
CardStatus cardStatusForTen = this.cardHolder.AllCards[trumpSuit][CardType.Ten];
CardStatus cardStatusForAce = this.cardHolder.AllCards[trumpSuit][CardType.Ace];
if ((cardStatusForTen == CardStatus.Passed || cardStatusForTen == CardStatus.InStalker) &&
(cardStatusForAce == CardStatus.Passed || cardStatusForAce == CardStatus.InStalker))
{
return new Card(trumpSuit, CardType.King);
}
return new Card(trumpSuit, CardType.Queen);
}
var cardToReturn = new Card(announcePairs[0].Suit, announcePairs[0].Type);
// They will be ordered in this way: [Q♦ K♦; K♠ Q♠; К♣ Q♣] by pairs: two diamonds, two clubs e.t.c. so incrementation will be i+=2.
for (int i = 0; i < announcePairs.Count; i += 2)
{
var currentSuit = announcePairs[i].Suit;
var cardStatusForTen = this.cardHolder.AllCards[currentSuit][CardType.Ten];
var cardStatusForAce = this.cardHolder.AllCards[currentSuit][CardType.Ace];
// Return bigger if 10 and A of current Suit is passed or is in us.
if ((cardStatusForTen == CardStatus.Passed || cardStatusForTen == CardStatus.InStalker) &&
(cardStatusForAce == CardStatus.Passed || cardStatusForAce == CardStatus.InStalker))
{
return new Card(currentSuit, CardType.King);
}
cardToReturn = new Card(currentSuit, CardType.Queen);
}
return cardToReturn;
}
/// <summary>
/// Gets the crew for port.
/// </summary>
/// <param name="positionId">The position identifier.</param>
/// <returns>
/// The JSON Result.
/// </returns>
public JsonResult GetCrewForPosition(string positionId)
{
var positionDetail = SessionData.Instance.PortManningDetails.Items.FirstOrDefault(positionItem => positionItem.IPMPositionId.Equals(positionId));
var crewDetails = new List<PortManningPosition>();
if (positionDetail != null)
{
foreach (var detail in positionDetail.PortManningPosition.Where(positionItem => !string.IsNullOrEmpty(positionItem.CrewmemberFirstName)))
{
if (!crewDetails.Any(item => item.SafetyRoleId == detail.SafetyRoleId))
{
var crewDepartment = SessionData.Instance.MasterData.CrewDepartments.FirstOrDefault(dept => dept.DepartmentId == detail.DepartmentId);
detail.DepartmentName = crewDepartment != null ? crewDepartment.Name : null;
detail.LastIPMDateString = detail.LastIPMDate.HasValue ? detail.LastIPMDate.Value.ToString(SessionData.Instance.DateFormat, CultureInfo.CurrentCulture) : "-";
crewDetails.Add(detail);
}
}
}
return this.Json(crewDetails, JsonRequestBehavior.AllowGet);
}
