public List<EHistoryDataStoreConfig> GetVehicleStoreTableConfigList(IList<Guid> vehicleCodes)
{
if (vehicleCodes.IsNullOrEmpty())
return null;
List<EHistoryDataStoreConfig> res = null;
string cmdText = string.Format("select RecordID, VehicleCode, StoreTable, ENABLE, CreateDate, remark from gps_historydatastoreconfig where VehicleCode in ('{0}')", vehicleCodes.JoinToString<Guid>("','"));
using (MySqlDataReader sdr = MySqlDB.GetDataReader(CommandType.Text, cmdText))
{
if (sdr != null)
{
res = new List<EHistoryDataStoreConfig>();
while (sdr.Read())
{
res.Add(new EHistoryDataStoreConfig
{
RecordID = sdr.GetGuid(0),
VehicleCode = sdr.GetGuid(1),
StoreTable = GetHisotryDataStoreTable(sdr.GetGuid(2)),
Enable = sdr.GetShort(3) == 1,
CreateDate = sdr.GetDateTimeExt(4),
Remark = sdr.GetStringExt(5)
});
}
sdr.Close();
}
}
return res;
}
/// <summary>
/// Serializes the list of active plugins to the permanent store.
/// </summary>
/// <returns>The ordered list of active plugins.</returns>
public void SavePluginLog(IList<Plugin> p_lstActivePlugins)
{
if (p_lstActivePlugins.IsNullOrEmpty())
{
LoadOrderManager.SetActivePlugins(GameMode.OrderedCriticalPluginNames);
return;
}
List<string> lstPlugins = new List<string>();
foreach (Plugin plgPlugin in p_lstActivePlugins)
lstPlugins.Add(plgPlugin.Filename);
lstPlugins.Sort();
List<string> lstActivePlugins = new List<string>();
foreach (string strPlugin in GameMode.OrderedCriticalPluginNames)
{
lstPlugins.RemoveAll(x => x.Equals(strPlugin, StringComparison.CurrentCultureIgnoreCase));
if (!lstActivePlugins.Contains(strPlugin, StringComparer.CurrentCultureIgnoreCase))
lstActivePlugins.Add(strPlugin);
}
foreach (Plugin plgPlugin in PluginOrderLog.OrderedPlugins)
{
if (lstPlugins.Contains(plgPlugin.Filename, StringComparer.CurrentCultureIgnoreCase))
if (!lstActivePlugins.Contains(plgPlugin.Filename, StringComparer.CurrentCultureIgnoreCase))
lstActivePlugins.Add(plgPlugin.Filename);
}
LoadOrderManager.SetActivePlugins(lstActivePlugins.ToArray());
}
public ConditionResolver(IList<Condition> conditions)
{
if (conditions.IsNullOrEmpty())
throw new ArgumentNullException(nameof(conditions));
_conditions = conditions;
}
/// <summary>
/// 统计停车次数，过滤停车时长小于指定值的次数
/// </summary>
/// <param name="ltVehicleCode"></param>
/// <param name="beginTime"></param>
/// <param name="endTime"></param>
/// <param name="second"></param>
/// <param name="tenantCode"></param>
/// <returns></returns>
public Dictionary<Guid, VCountStopCar> Count(IList<Guid> ltVehicleCode, DateTime beginTime, DateTime endTime, int second, string tenantCode)
{
if (ltVehicleCode.IsNullOrEmpty())
return new Dictionary<Guid, VCountStopCar>();
Dictionary<Guid, TimeSpan> totalTimes; //运行轨迹的总时长
IList<VStopCarReport> list = SearchStop(ltVehicleCode, beginTime, endTime, second, tenantCode, out totalTimes);
Dictionary<Guid, VCountStopCar> dic = new Dictionary<Guid, VCountStopCar>();
if (list != null && list.Count > 0)
{ //合并停车明细
VCountStopCar vCount;
foreach (var item in list)
{
if (dic.ContainsKey(item.VehicleCode))
{
vCount = dic[item.VehicleCode];
vCount.Count++;
vCount.CountTime += item.StopTimeSpan;
//vCount.TotalTime += item.TotalTimeSpan;
}
else
{
vCount = new VCountStopCar();
vCount.Count++;
vCount.CountTime = item.StopTimeSpan;
//vCount.TotalTime = item.TotalTimeSpan;
vCount.VehicleCode = item.VehicleCode;
vCount.LicenceNumber = item.LicenceNumber;
dic.Add(vCount.VehicleCode, vCount);
}
}
}
foreach (var item in totalTimes)
{
if (dic.ContainsKey(item.Key))
{
dic[item.Key].TotalTime = item.Value;
}
else
{
dic.Add(item.Key, new VCountStopCar
{
VehicleCode = item.Key,
Count = 0,
CountTime = new TimeSpan(0),
TotalTime = item.Value
});
}
}
return dic;
}
public Grid Build(IList<IPanelItem> items)
{
var grid = new Grid();
var i = 1;
while (!items.IsNullOrEmpty())
{
grid.Blocks.Add(GenerateBlock(items.Take(i)));
items = items.Skip(i).ToList();
if (items.IsNullOrEmpty())
break;
i = i == 1 ? 4 : 1;
grid.Blocks.Add(GenerateBlock(items.Take(i)));
items = items.Skip(i).ToList();
}
return grid;
}
public void Delete(IList<Guid> vehicleCodes, Guid areaCode)
{
if (vehicleCodes.IsNullOrEmpty())
return;
using (IRepository repository = SessionManager.CreateRepository(typeof(ETraceAlertSetting)))
{
Query query = new Query(typeof(ETraceAlertSetting));
Expression expression = null;
ExpressionUtility<Guid>.AddExpression("VehicleCode", vehicleCodes, PolynaryOperatorType.In, ref expression);
ExpressionUtility<Guid>.AddExpression("TracePoint.RecordID", areaCode, BinaryOperatorType.EqualTo, ref expression);
query.Expression = expression;
repository.DeleteBy(query);
}
}
private static IList<ParameterInstances> Expand(IList<ParameterInstances> instancesList, IList<ParameterDefinition> definitions)
{
if (definitions.IsNullOrEmpty())
return instancesList;
var nextDefinition = definitions.First();
var newInstancesList = new List<ParameterInstances>();
foreach (var instances in instancesList)
foreach (var value in nextDefinition.Values)
{
var items = new List<ParameterInstance>();
items.AddRange(instances.Items);
items.Add(new ParameterInstance(nextDefinition, value));
newInstancesList.Add(new ParameterInstances(items));
}
return Expand(newInstancesList, definitions.Skip(1).ToArray());
}
public IList<EBreakOilLastRecord> Search(IList<Guid> vehicleCodes)
{
if (vehicleCodes.IsNullOrEmpty())
{
return null;
}
using (IRepository repository = SessionManager.CreateRepository(typeof(EBreakOilLastRecord)))
{
Query query = new Query(typeof(EBreakOilLastRecord));
Expression expression = Expression.CreateExpression("VehicleCode", PolynaryOperatorType.In, vehicleCodes);
query.Expression = expression;
var list = repository.List<EBreakOilLastRecord>(query);
return list;
}
}
public IAsyncOperation<IList<SynchronizedType>> GetMultipleAsync(IList<string> typeIDs)
{
if (typeIDs.IsNullOrEmpty())
{
throw new ArgumentException("typeIDs");
}
return AsyncInfo.Run<IList<SynchronizedType>>(async cancelToken =>
{
List<SynchronizedType> sTypes = new List<SynchronizedType>();
foreach(string typeID in typeIDs)
{
SynchronizedType type = await this.Ensure(typeID, cancelToken);
sTypes.Add(type);
}
return sTypes;
});
}
static bool Target(IList<string> unparsed)
{
string url = command_url;
if (false == unparsed.IsNullOrEmpty())
{
url = unparsed[0];
}
IVcapClient vc = new VcapClient();
VcapClientResult rslt = vc.Target(url);
if (rslt.Success)
{
Console.WriteLine(String.Format(Resources.Vmc_TargetDisplay_Fmt, rslt.Message));
}
else
{
Console.WriteLine(String.Format(Resources.Vmc_TargetNoSuccessDisplay_Fmt, rslt.Message));
}
return rslt.Success;
}
public IAsyncOperation<IList<RecordItemChange>> GetChangesForItemsAsync(IList<string> itemIDs)
{
if (itemIDs.IsNullOrEmpty())
{
throw new ArgumentException("itemID");
}
return AsyncInfo.Run<IList<RecordItemChange>>(async cancelToken =>
{
using (await CrossThreadLockScope.Enter(m_lock))
{
List<RecordItemChange> changes = new List<RecordItemChange>();
foreach(string id in itemIDs)
{
RecordItemChange change = await this.GetChangeAsync(id);
if (change != null)
{
changes.Add(change);
}
}
return changes;
}
});
}
public async Task SaveLocalItems(IList<ReaderItem> items)
{
await WriteItemsToDisk(items, SourceProvider.Local);
if (!items.IsNullOrEmpty())
{
CacheCount.LocalCount = items.Count;
}
else
{
CacheCount.LocalCount = null;
}
WriteCountsToStorage().ConfigureAwait(false);
}
public IAsyncOperation<IList<SynchronizedView>> GetViewsAsync(IList<string> viewNames)
{
if (viewNames.IsNullOrEmpty())
{
throw new ArgumentException("viewNames");
}
return AsyncInfo.Run<IList<SynchronizedView>>(async cancelToken =>
{
LazyList<SynchronizedView> views = new LazyList<SynchronizedView>();
foreach(string viewName in viewNames)
{
SynchronizedView view = await this.GetViewAsync(viewName, cancelToken);
if (view != null)
{
views.Add(view);
}
}
return views.HasValue ? views.Value : null;
});
}
public TernarySearchTree(IList <IEnumerable <TS> > searchObjects, IObservable <TS> streamToMatchAgainstTree)
{
if (searchObjects.IsNullOrEmpty())
{
throw new ArgumentOutOfRangeException("Nothing to build tree from!");
}
if (streamToMatchAgainstTree == null)
{
throw new ArgumentOutOfRangeException("Nothing to match against!");
}
CreateTree(searchObjects);
Node currentNode = _root;
streamToMatchAgainstTree.Subscribe(ts =>
{
if (_root == null)
{
return;
}
MatchResult mr = currentNode.FindMatch(ts, out currentNode);
if (mr.DeadEnd)
{
currentNode = _root;
return;
}
if (mr.Hit)
{
_observers.OnNext(mr.Match);
}
});
}
public void SetOffer(long newCredit, IList <long> newItemEids)
{
State = TradeState.Offer;
_credit = newCredit;
_items.Clear();
var data = new Dictionary <string, object>
{
{ k.characterID, owner.Id },
{ k.credit, _credit },
};
if (!newItemEids.IsNullOrEmpty())
{
var myContainer = owner.GetPublicContainerWithItems();
foreach (var newItemEid in newItemEids)
{
var item = myContainer.GetItem(newItemEid);
if (item == null)
{
continue;
}
_items.Add(new TradeItem(item));
}
var items = _items.ToDictionary <TradeItem, string, object>(item => "i" + item.itemEid, item => item.ToDictionary());
data.Add(k.items, items);
}
Message.Builder.SetCommand(Commands.TradeOffer).WithData(data).ToCharacters(owner, trader).Send();
}
public static void RemoveAll <T>(this IList <T> source, Func <T, bool> condition)
{
if (source.IsNullOrEmpty())
{
return;
}
var removed = default(IList <T>);
foreach (var item in source)
{
if (condition(item))
{
if (removed.IsNull())
{
removed = new List <T>();
}
removed.Add(item);
}
}
if (!removed.IsNullOrEmpty())
{
foreach (var item in removed)
{
source.Remove(item);
}
}
}
public static void AssertListIsNotNullOrEmpty <T>(this IList <T> list, string name)
{
if (list.IsNullOrEmpty())
{
throw new ArgumentNullException(name, ErrorMessageResource.ArgumentNullError);
}
}
public static IList <GameObject> gameObjects <T>(this IList <T> objs) where T : MonoBehaviour
{
if (objs.IsNullOrEmpty())
{
return(null);
}
var result = default(List <GameObject>);
foreach (var item in objs)
{
if (item.IsNull())
{
continue;
}
var newObj = item.gameObject;
if (newObj.IsNull())
{
continue;
}
if (result.IsNull())
{
result = new List <GameObject>();
}
result.Add(newObj);
}
return(result);
}
/// <summary>
/// Helper function used to remove, and dispose of each IDisposable item, in a given list (using DisposeOfGivenObject).
/// <para/>Removes all items from the list even if not all of them are IDisposable.
/// </summary>
/// <typeparam name="ObjType">Any type of ref object. May be a type that is castable to IDisposable.</typeparam>
public static void TakeAndDisposeOfGivenObjects <ObjType>(this IList <ObjType> objList) where ObjType : class
{
while (!objList.IsNullOrEmpty())
{
objList.SafeTakeFirst().DisposeOfGivenObject();
}
}
/// <summary>
/// 修改套餐模板方案
/// </summary>
/// <param name="schemeName">方案名称</param>
/// <param name="cover">封面</param>
/// <param name="description">描述</param>
/// <param name="images">方案概况图片集</param>
/// <param name="schemeDescription">方案概况描述</param>
/// <param name="videoAudioLink">视频音频地址链接</param>
/// <param name="videoAudioFileName">视频音频文件名称</param>
/// <param name="videoAudioFileSize">视频音频文件大小</param>
/// <param name="videoAudioFileId">视频音频文件Id</param>
/// <param name="videoAudiogFileSuffix">视频音频文件扩展名</param>
/// <param name="schemeSpaces">方案空间集</param>
public void UpdateInfo(string schemeName, string cover, string description, IList <string> images, IList <string> schemeDescriptions, string videoAudioLink, string videoAudioFileSize, string videoAudioFileId, string videoAudiogFileSuffix, string videoAudioFileName, IEnumerable <DecorationPackSchemeSpace> schemeSpaces)
{
#region # 验证
schemeSpaces = schemeSpaces == null ? new DecorationPackSchemeSpace[0] : schemeSpaces.ToArray();
if (schemeSpaces.Count() != schemeSpaces.DistinctBy(x => x.PackSpaceId).Count())
{
throw new ArgumentOutOfRangeException("schemeSpaces", "套餐模板空间不可重复！");
}
#endregion
base.Name = schemeName;
this.Cover = cover;
this.Description = description;
this.ImagesStr = images.IsNullOrEmpty() ? null : images.ToJson();
this.SchemeDescriptionsStr = schemeDescriptions.IsNullOrEmpty() ? null : schemeDescriptions.ToJson();
this.VideoAudioLink = videoAudioLink;
this.VideoAudioFileId = videoAudioFileId;
this.VideoAudioFileName = videoAudioFileName;
this.VideoAudioFileSize = videoAudioFileSize;
this.VideoAudiogFileSuffix = videoAudiogFileSuffix;
//先清空
foreach (DecorationPackSchemeSpace schemeSpace in this.SchemeSpaces.ToArray())
{
this.SchemeSpaces.Remove(schemeSpace);
}
//再添加
this.SchemeSpaces.AddRange(schemeSpaces);
}
/// <summary>
/// Kraken Downloader Toolbox Project For LEAN Algorithmic Trading Engine.
/// By @matthewsedam
/// </summary>
public static void KrakenDownloader(IList <string> tickers, string resolution, DateTime startDate, DateTime endDate)
{
if (resolution.IsNullOrEmpty() || tickers.IsNullOrEmpty())
{
Console.WriteLine("KrakenDownloader ERROR: '--tickers=' or '--resolution=' parameter is missing");
Console.WriteLine("--tickers=eg XXBTZUSD,XETHZUSD");
Console.WriteLine("--resolution=Minute/Hour/Daily/Tick");
Environment.Exit(1);
}
try
{
var castResolution = (Resolution)Enum.Parse(typeof(Resolution), resolution);
// Load settings from config.json and create downloader
var dataDirectory = Config.Get("data-directory", "../../../Data");
var downloader = new KrakenDataDownloader();
foreach (var pair in tickers)
{
// Download data
var pairObject = Symbol.Create(pair, SecurityType.Crypto, Market.Kraken);
var data = downloader.Get(pairObject, castResolution, startDate, endDate);
// Write data
var writer = new LeanDataWriter(castResolution, pairObject, dataDirectory);
writer.Write(data);
}
}
catch (Exception err)
{
Log.Error(err);
}
}
/// <summary>
/// 创建套餐模板方案构造器
/// </summary>
/// <param name="schemeName">方案名称</param>
/// <param name="packId">套餐模板Id</param>
/// <param name="cover">封面</param>
/// <param name="description">描述</param>
/// <param name="images">方案概况图片集</param>
/// <param name="schemeDescriptions">方案概况描述集</param>
/// <param name="videoAudioLink">视频音频地址链接</param>
/// <param name="videoAudioFileName">视频音频文件名称</param>
/// <param name="videoAudioFileSize">视频音频文件大小</param>
/// <param name="videoAudioFileId">视频音频文件Id</param>
/// <param name="videoAudiogFileSuffix">视频音频文件扩展名</param>
/// <param name="isDefault">默认方案</param>
/// <param name="schemeSpaces">方案空间集</param>
public DecorationPackScheme(string schemeName, Guid packId, string cover, string description, IList <string> images, IList <string> schemeDescriptions, string videoAudioLink, string videoAudioFileSize, string videoAudioFileId, string videoAudiogFileSuffix, string videoAudioFileName, bool isDefault, IEnumerable <DecorationPackSchemeSpace> schemeSpaces)
: this()
{
#region # 验证
schemeSpaces = schemeSpaces == null ? new DecorationPackSchemeSpace[0] : schemeSpaces.ToArray();
if (schemeSpaces.Count() != schemeSpaces.DistinctBy(x => x.PackSpaceId).Count())
{
throw new ArgumentOutOfRangeException("schemeSpaces", "套餐模板空间不可重复！");
}
#endregion
base.Name = schemeName;
this.PackId = packId;
this.Cover = cover;
this.Description = description;
this.ImagesStr = images.IsNullOrEmpty() ? null : images.ToJson();
this.SchemeDescriptionsStr = schemeDescriptions.IsNullOrEmpty() ? null : schemeDescriptions.ToJson();
this.VideoAudioLink = videoAudioLink;
this.VideoAudioFileId = videoAudioFileId;
this.VideoAudioFileName = videoAudioFileName;
this.VideoAudioFileSize = videoAudioFileSize;
this.VideoAudiogFileSuffix = videoAudiogFileSuffix;
this.IsDefault = isDefault;
this.SchemeSpaces.AddRange(schemeSpaces);
}
/// <summary>
///
/// </summary>
/// <param name="views">Views to synchronize</param>
/// <returns>Subset of views acutually refreshed OR null if none</returns>
public IAsyncOperation <IList <ISynchronizedView> > SynchronizeAsync(IList <ISynchronizedView> views)
{
if (views == null)
{
throw new ArgumentNullException("views");
}
return(AsyncInfo.Run <IList <ISynchronizedView> >(async cancelToken => {
this.Reset();
try
{
IList <ISynchronizedView> synchronizableViews = await this.CollectSynchronizableViews(views);
if (!synchronizableViews.IsNullOrEmpty())
{
IList <ItemQueryResult> results = await this.ExecuteSyncQueries();
await this.UpdateViews(views, results);
}
return synchronizableViews;
}
finally
{
this.Reset();
}
}));
}
/// <summary>
/// Checks if an identifier in format of an uri is unique.
/// The base uri is a special kind of identifier and is therefore checked separately.
/// </summary>
/// <param name="pidUriResults">All found entries with the same identifier</param>
/// <param name="resource">Id of the entity to be checked</param>
/// <param name="resourceId">Resource id of the main entry (parent entry id)</param>
/// <returns></returns>
private bool CheckIdentifierIsDuplicate(IList <DuplicateResult> pidUriResults, Entity resource, string resourceId, out bool orphaned)
{
string resourceType = resource.Properties.GetValueOrNull(Graph.Metadata.Constants.RDF.Type, true);
orphaned = false;
if (pidUriResults.IsNullOrEmpty())
{
return(false);
}
else if (pidUriResults.IsAnyDraftAndPublishedNull())
{
orphaned = true;
return(true);
}
else if (string.IsNullOrWhiteSpace(resourceId))
{
return(true);
}
else if (pidUriResults.IsAnyDraftAndPublishedNotEqualToIdentifier(resourceId))
{
return(true);
}
else if (pidUriResults.IsAnyResultEqualToIdentifierAndHasDifferentType(resourceId, resourceType))
{
return(true);
}
return(false);
}
/// <summary>
/// Sends request to Google Drive API, downloads file and reads it.
/// </summary>
/// <param name="storageName">Storage name on Google Drive with Things names.</param>
/// <returns>Processed collection of Things names as strings.</returns>
public List <string> ReadThingNames(string storageName)
{
var result = new List <string>();
if (string.IsNullOrEmpty(storageName))
{
return(result);
}
// Get info from API, download file and read it.
IList <GoogleDriveData.File> files = ListFiles(new GoogleDriveFilesListOptionalParams
{
Q = $"name contains '{storageName}'"
}).Files;
if (!files.IsNullOrEmpty())
{
foreach (GoogleDriveData.File file in files)
{
if (storageName.IsEqualWithInvariantCulture(file.Name))
{
result = DownloadAndReadFile(storageName, file.Id);
break;
}
}
}
else
{
_logger.Info($"No files found. Tried to find \"{storageName}\".");
}
return(result);
}
private static void Start(IntPtr info)
{
NSJSFunctionCallbackInfo arguments = NSJSFunctionCallbackInfo.From(info);
HTTPApplication application = GetApplication(arguments.This);
if (application == null)
{
Throwable.ObjectDisposedException(arguments.VirtualMachine);
}
else
{
try
{
IList <string> prefixes = ArrayAuxiliary.ToStringList(arguments.Length > 0 ? arguments[0] : null);
do
{
if (prefixes.IsNullOrEmpty())
{
Throwable.ArgumentNullException(arguments.VirtualMachine);
break;
}
application.Start(prefixes);
arguments.SetReturnValue(true);
} while (false);
}
catch (Exception e)
{
Throwable.Exception(arguments.VirtualMachine, e);
}
}
}
protected IList <IDictionary <string, string> > GetTestInstanceRun(Response response)
{
IList <IDictionary <string, string> > ret = null;
try
{
if (!response.Data.IsNullOrWhiteSpace())
{
ret = Xml.ToEntities($"{response}");
}
if (ret.IsNullOrEmpty())
{
_logger.LogInfo($"Parse TestInstanceRuns from response XML got no result. Response: {response}");
}
}
catch (ThreadInterruptedException)
{
throw;
}
catch (Exception ex)
{
_logger.LogError($"Failed to parse TestInstanceRuns response XML. Exception: {ex.Message}, XML: {response}");
}
return(ret);
}
internal async Task CommitAsync(CancellationToken cancelToken)
{
bool hasPendingWork = true;
while (hasPendingWork)
{
if (!m_workerController.BeginWork())
{
return;
}
hasPendingWork = false;
this.NotifyStarting();
try
{
IList <string> changedItems = await m_changeTable.GetChangeQueueAsync();
if (!changedItems.IsNullOrEmpty())
{
await this.CommitChangesAsync(changedItems);
}
}
catch (Exception ex)
{
this.NotifyError(ex);
throw;
}
finally
{
this.NotifyFinished();
hasPendingWork = m_workerController.CompleteWork();
}
}
}
private void TestBulletPoints(IList <string> bulletPoints)
{
var jobAd = CreateJobAd(bulletPoints);
Search(Keywords);
var node = GetResult(jobAd.Id);
node = node.SelectSingleNode(".//ul[@class='bulletpoints']");
Assert.IsNotNull(node);
var nodes = node.SelectNodes("./li");
if (bulletPoints.IsNullOrEmpty())
{
Assert.IsTrue(nodes.IsNullOrEmpty());
}
else
{
Assert.AreEqual(bulletPoints.Count, nodes.Count);
for (var index = 0; index < nodes.Count; ++index)
{
Assert.AreEqual(bulletPoints[index], nodes[index].InnerText);
}
}
var model = ApiSearch(Keywords);
Assert.AreEqual(1, model.JobAds.Count);
Assert.IsTrue(bulletPoints.NullableSequenceEqual(model.JobAds[0].BulletPoints));
}
/// <summary>
/// Cryptoiq Downloader Toolbox Project For LEAN Algorithmic Trading Engine.
/// </summary>
public static void CryptoiqDownloader(IList <string> tickers, string exchange, DateTime startDate, DateTime endDate)
{
if (exchange.IsNullOrEmpty() || tickers.IsNullOrEmpty())
{
Console.WriteLine("CryptoiqDownloader ERROR: '--exchange=' or '--tickers=' parameter is missing");
Environment.Exit(1);
}
try
{
// Load settings from config.json
var dataDirectory = Config.Get("data-directory", "../../../Data");
//todo: will download any exchange but always save as gdax
// Create an instance of the downloader
const string market = Market.GDAX;
var downloader = new CryptoiqDownloader(exchange);
foreach (var ticker in tickers)
{
// Download the data
var symbolObject = Symbol.Create(ticker, SecurityType.Crypto, market);
var data = downloader.Get(symbolObject, Resolution.Tick, startDate, endDate);
// Save the data
var writer = new LeanDataWriter(Resolution.Tick, symbolObject, dataDirectory, TickType.Quote);
writer.Write(data);
}
}
catch (Exception err)
{
Log.Error(err);
}
}
public async Task <AccessTokenResponse> GenerateEncodedToken(User user, OAuth oAuth, IList <string> roles = null)
{
string id = user.Id;
string userName = user.UserName;
string provider = oAuth.Provider.ToString();
string picture = oAuth.PictureUrl;
string name = oAuth.GivenName;
var identity = GenerateClaimsIdentity(id, userName);
var claims = new[]
{
new Claim(JwtRegisteredClaimNames.Sub, userName),
new Claim("provider", provider),
new Claim("picture", picture),
new Claim("name", name),
new Claim("roles", roles.IsNullOrEmpty() ? "" : String.Join(",", roles)),
new Claim(JwtRegisteredClaimNames.Jti, await _jwtOptions.JtiGenerator()),
new Claim(JwtRegisteredClaimNames.Iat, ToUnixEpochDate(_jwtOptions.IssuedAt).ToString(), ClaimValueTypes.Integer64),
identity.FindFirst(Helpers.Constants.Strings.JwtClaimIdentifiers.Rol),
identity.FindFirst(Helpers.Constants.Strings.JwtClaimIdentifiers.Id)
};
// Create the JWT security token and encode it.
var jwt = new JwtSecurityToken(
_jwtOptions.Issuer,
_jwtOptions.Audience,
claims,
_jwtOptions.NotBefore,
_jwtOptions.Expiration,
_jwtOptions.SigningCredentials);
return(new AccessTokenResponse(_jwtTokenHandler.WriteToken(jwt), (int)_jwtOptions.ValidFor.TotalSeconds));
}
protected async Task GetTracksAsync(IList <string> artists, IList <string> genres, IList <AlbumViewModel> albumViewModels, TrackOrder trackOrder)
{
IList <Track> tracks = null;
if (albumViewModels != null && albumViewModels.Count > 0)
{
// First, check Albums. They topmost have priority.
tracks = await this.trackRepository.GetAlbumTracksAsync(albumViewModels.Select(x => x.AlbumKey).ToList());
}
else if (!artists.IsNullOrEmpty())
{
// Artists and Genres have the same priority
tracks = await this.trackRepository.GetArtistTracksAsync(artists.Select(x => x.Replace(ResourceUtils.GetString("Language_Unknown_Artist"), string.Empty)).ToList());
}
else if (!genres.IsNullOrEmpty())
{
// Artists and Genres have the same priority
tracks = await this.trackRepository.GetGenreTracksAsync(genres.Select(x => x.Replace(ResourceUtils.GetString("Language_Unknown_Genre"), string.Empty)).ToList());
}
else
{
tracks = await queuedTrackRepository.GetSavedQueuedTracksAsync();
if (tracks.Count == 0)
{
// Tracks have lowest priority
tracks = await this.trackRepository.GetTracksAsync();
}
}
await this.GetTracksCommonAsync(await this.container.ResolveTrackViewModelsAsync(tracks), trackOrder);
}
/// <summary>
/// Sends request to Google Drive API, downloads file and reads it.
/// </summary>
/// <param name="storageName">Storage name on Google Drive with Things names.</param>
/// <returns>Processed collection of Things names as strings.</returns>
public IReadOnlyList <string> ReadThingNames(string storageName)
{
if (string.IsNullOrEmpty(storageName))
{
return(new List <string>());
}
// Get info from API, download file and read it.
IList <GoogleDriveData.File> files = ListFiles(new GoogleDriveFilesListOptionalParams
{
Q = $"name contains '{storageName}'"
}).Files;
if (!files.IsNullOrEmpty())
{
foreach (GoogleDriveData.File file in files)
{
if (string.Equals(storageName, file.Name,
StringComparison.InvariantCultureIgnoreCase))
{
return(DownloadAndReadFile(storageName, file.Id));
}
}
}
else
{
_logger.Info($"No files found. Tried to find \"{storageName}\".");
}
return(new List <string>());
}
private bool AreAeTitlesValid(string source, IList <ClaraApplicationEntity> aeTitles, bool readAeTitlesFromCrd)
{
bool valid = true;
if (!readAeTitlesFromCrd && aeTitles.IsNullOrEmpty())
{
_logger.Log(LogLevel.Error, "No AE Titles defined in {0}.", source);
valid = false;
return(valid);
}
else if (readAeTitlesFromCrd)
{
aeTitles.Clear();
_logger.Log(LogLevel.Information, "Local AE Titles will be read from Kubernetes Custom Resource.");
}
foreach (var app in aeTitles)
{
valid &= IsClaraAeTitleValid(aeTitles, source, app);
if (!valid)
{
break;
}
}
return(valid);
}
public IDictionary <string, bool> CheckTableSourcesExist(params string[] tableSourcesNames)
{
DatabaseInfo dbInfo = DatabaseServices.ObjectFactory.CreateLocalDatabaseInfo() as DatabaseInfo;
if (dbInfo == null)
{
return(null);
}
HashSet <string> tableSourcesFound = new HashSet <string>();
IList <string> tableSourceNamesList = tableSourcesNames.ToList();
if (tableSourceNamesList.IsNullOrEmpty())
{
return(null);
}
using (IDbConnection conn = DatabaseServices.TransactionService.CreateConnection()) {
string tableCondition;
string paramPrefix = DatabaseServices.ExecutionService.ParameterPrefix;
if (tableSourceNamesList.Count == 1)
{
tableCondition = "=" + paramPrefix + "tablename";
}
else
{
tableCondition = " IN ('" + tableSourceNamesList.StrCat("','").ToUpper() + "')";
}
string sql = string.Format(@"(SELECT TABLE_NAME
FROM {0}.INFORMATION_SCHEMA.TABLES
WHERE TABLE_NAME {1})
UNION
(SELECT TABLE_NAME
FROM {0}.INFORMATION_SCHEMA.VIEWS
WHERE TABLE_NAME {1})", DMLIdentifiers.EscapeIdentifierInner(dbInfo.Catalog), tableCondition);
using (IDbCommand cmd = DatabaseServices.ExecutionService.CreateCommand(conn, sql)) {
if (tableSourceNamesList.Count == 1)
{
DatabaseServices.ExecutionService.CreateParameter(cmd,
paramPrefix + "tablename", DbType.String, tableSourceNamesList.First().ToUpper());
}
cmd.CommandTimeout = QueryTimeout;
using (IDataReader reader = DatabaseServices.ExecutionService.ExecuteReader(cmd)) {
while (reader.Read())
{
tableSourcesFound.Add(Convert.ToString(reader["TABLE_NAME"]).ToUpper());
}
}
}
}
IDictionary <string, bool> result = new Dictionary <string, bool>();
foreach (var tableSource in tableSourceNamesList)
{
result.Add(tableSource, tableSourcesFound.Contains(tableSource.ToUpper()));
}
return(result);
}
protected async Task GetTracksAsync(IList <string> artists, IList <string> genres, IList <AlbumViewModel> albumViewModels, TrackOrder trackOrder)
{
IList <Track> tracks = null;
if (albumViewModels != null && albumViewModels.Count > 0)
{
// First, check Albums. They topmost have priority.
tracks = await this.trackRepository.GetAlbumTracksAsync(albumViewModels.Select(x => x.AlbumKey).ToList());
}
else if (!artists.IsNullOrEmpty())
{
// Artists and Genres have the same priority
tracks = await this.trackRepository.GetArtistTracksAsync(artists);
}
else if (!genres.IsNullOrEmpty())
{
// Artists and Genres have the same priority
tracks = await this.trackRepository.GetGenreTracksAsync(genres);
}
else
{
// Tracks have lowest priority
tracks = await this.trackRepository.GetTracksAsync();
}
await this.GetTracksCommonAsync(await this.container.ResolveTrackViewModelsAsync(tracks), trackOrder);
}
/// <summary>
/// Checks if file with specified name exists on Google Drive and in this regard decides to
/// upload or update results which saved in local file.
/// </summary>
/// <param name="path">Local file path to upload.</param>
/// <param name="storageName">Local filename to save on Google Drive.</param>
/// <returns><c>true</c> if procedure was successful, <c>false</c> otherwise.</returns>
private bool ReadFileAndUploadOrUpdate(string path, string storageName)
{
if (string.IsNullOrEmpty(path) || string.IsNullOrEmpty(storageName))
{
return(false);
}
String storageNameWithoutExtension = Path.GetFileNameWithoutExtension(storageName);
IList <GoogleDriveData.File> files = ListFiles(new GoogleDriveFilesListOptionalParams
{
Q = $"name contains '{storageNameWithoutExtension}'"
}).Files;
bool result = false;
if (!files.IsNullOrEmpty())
{
foreach (GoogleDriveData.File file in files)
{
if (storageNameWithoutExtension == file.Name)
{
// Need full filename because we will read file and upload it.
result = UpdateFile(file.Id, path);
break;
}
}
}
else
{
result = UploadFile(path, storageName);
}
return(result);
}
public async Task <List <TeamAgentModel> > GetAgentsInTeams(IList <string> teamIds)
{
LoggingService.Trace("Querying TeamAgentsDatabase.GetAgentsInTeams");
if (teamIds.IsNullOrEmpty())
{
return(new List <TeamAgentModel>());
}
var databaseConnection = await GetDatabaseConnection <TeamAgentDatabaseModel>().ConfigureAwait(false);
var dbLock = databaseConnection.GetConnection().Lock();
try
{
var teamAgentDatabaseModels = databaseConnection.GetConnection().GetAllWithChildren <TeamAgentDatabaseModel>();
return(teamAgentDatabaseModels?
.Where(x => teamIds.Any(id => x.Teams.Any(t => t.TeamId.Equals(id))))
.Select(x => TeamAgentDatabaseModel.ToTeamAgentModel(x))
.ToList() ?? new List <TeamAgentModel>());
}
catch (Exception e)
{
LoggingService.Error(e, "Error Querying TeamAgentsDatabase.GetAgentsInTeams");
return(new List <TeamAgentModel>());
}
finally
{
dbLock.Dispose();
}
}
/// <summary>
/// Creates a series of instances of <see cref="IBindingBuilder" />.
/// </summary>
/// <param name="target">The specified binding target.</param>
/// <param name="bindingExpression">The specified binding expression.</param>
/// <param name="sources">The specified sources, if any.</param>
/// <returns>An instance of <see cref="IBindingBuilder" />.</returns>
public IList <IBindingBuilder> CreateBuildersFromString(object target, string bindingExpression, IList <object> sources = null)
{
Should.NotBeNull(target, "target");
Should.NotBeNullOrWhitespace(bindingExpression, "bindingExpression");
try
{
var parserResult = Parser.Parse(bindingExpression, sources.IsNullOrEmpty()
? DataContext.Empty
: new DataContext(1)
{
{ BindingBuilderConstants.RawSources, sources }
});
var result = new IBindingBuilder[parserResult.Count];
for (int index = 0; index < parserResult.Count; index++)
{
var builder = new BindingBuilder(parserResult[index]);
builder.Add(BindingBuilderConstants.Target, target);
builder.Add(BindingBuilderConstants.BuildDelegate, _buildDelegate);
result[index] = builder;
}
return(result);
}
catch (Exception exception)
{
exception = new InvalidOperationException(exception.Message, exception);
var builder = new BindingBuilder();
builder.Add(BindingBuilderConstants.Target, target);
builder.Add(ProviderConstant, this);
builder.Add(ExceptionConstant, exception);
builder.Add(BindingBuilderConstants.BuildDelegate, CreateInvalidaDataBindingDelegate);
return(new IBindingBuilder[] { builder });
}
}
private void PopulateListObject <T>(IList <T> list, GameObject gameObjectList)
{
while (gameObjectList.transform.childCount > 1)
{
DestroyImmediate(gameObjectList.transform.GetChild(1).gameObject);
}
GameObject element = gameObjectList.transform.GetChild(0).gameObject;
if (list.IsNullOrEmpty())
{
SetText("", element);
return;
}
SetText(list[0], element);
for (int i = 1; i < list.Count; i++)
{
GameObject instance = Instantiate(element);
instance.transform.SetParent(gameObjectList.transform);
instance.transform.localScale = Vector3.one;
SetText(list[i], instance);
}
}
protected void WriteArray(JsonWriter writer, IList list)
{
writer.WriteStartArray();
if (list.IsNullOrEmpty())
{
writer.WriteEndArray();
return;
}
for (int i = 0; i < list.Count; i++)
{
var value = list[i];
if (value is INamedList)
{
WriteNamedList(writer, value as INamedList);
}
else if (value is IList)
{
WriteArray(writer, value as IList);
}
else
{
writer.WriteValue(value);
}
}
writer.WriteEndArray();
}
public bool Save(object fieldValue, ConfigNode node, OperationContext context)
{
node.ThrowIfNullArgument(nameof(node));
fieldValue.EnsureArgumentType(listType, nameof(fieldValue));
IList list = (IList)fieldValue;
if (list.IsNullOrEmpty())
{
return(false);
}
foreach (object value in list)
{
if (value.IsNull())
{
continue;
}
string formattedValue = parser.Format(value);
if (formattedValue.IsNotNull())
{
node.AddValue(name, formattedValue);
}
}
return(true);
}
public LoggingInfo(IList list)
{
if (list.IsNullOrEmpty()) return;
Levels = list.Cast<string>().ToList();
}
/// <summary>
/// Adds the metric current metric read data.
/// </summary>
/// <param name="process">The process.</param>
/// <param name="metric">The metric.</param>
/// <param name="groupingFieldsList">The grouping fields list.</param>
/// <returns>System.String.</returns>
private static string AddMetricCurrentMetricReadData(IProcessDefinition process, IMetricDefinition metric, IList<string> groupingFieldsList)
{
string readDataFirstInfoObject = null;
var columnType = GetMetricOrderByFieldType(process, metric, groupingFieldsList);
Action getReadDataFirstInfoObject = () =>
{
if (columnType.HasValue && (columnType.Value == ColumnTypes.Approval || columnType.Value == ColumnTypes.Boolean))
{
readDataFirstInfoObject = "item.Value.First()";
return;
}
if (!groupingFieldsList.Any())
{
return;
}
if (metric.MetricFieldSystemName == metric.OrderByMetricField || (metric.SummaryType == SummaryTypes.Count && metric.OrderByMetricField == string.Empty))
{
readDataFirstInfoObject = "item.Key";
return;
}
if (!string.IsNullOrWhiteSpace(metric.OrderByMetricField))
{
readDataFirstInfoObject = "item.Source.First()";
return;
}
readDataFirstInfoObject = "item.ToList().First()";
};
getReadDataFirstInfoObject();
string metricinfoClass;
if (columnType.HasValue && (columnType.Value == ColumnTypes.Approval || columnType.Value == ColumnTypes.Boolean))
{
metricinfoClass = "Value.First()";
}
else
if (!string.IsNullOrWhiteSpace(metric.OrderByMetricField) && metric.MetricFieldSystemName != metric.OrderByMetricField)
{
metricinfoClass = "Source.First()";
}
else
{
metricinfoClass = "Key";
}
var groupByFieldValuesList = new List<string>();
foreach (var groupedField in groupingFieldsList)
{
var field = GetField(process, groupedField);
var groupFieldPath = groupedField;
if (!string.IsNullOrWhiteSpace(metric.OrderByMetricField) && metric.MetricFieldSystemName != metric.OrderByMetricField)
{
groupFieldPath = field.Key;
}
if (groupedField == field.Value.SystemName)
{
var variable = string.Format("var {0}_value = ", groupedField);
switch (field.Value.ColumnType)
{
case ColumnTypes.DateTime:
variable += string.Format(@"dtConverter.Convert({0}.{1}, null, ""{2}"", null);"
, readDataFirstInfoObject
, field.Key
, field.Value.DateTimeFormat);
break;
case ColumnTypes.Approval:
if (metric.OrderByMetricField == field.Value.SystemName)
{
variable += "item.Key;";
}
else
{
variable += string.Format(@"approvalConvertMethod.Invoke(approvalInstance, new object[] {{ item.{0}.{1}, null, null, null }});", metricinfoClass, groupFieldPath);
}
break;
case ColumnTypes.Boolean:
var result = field.Value.NameValuesList["IsSwitchToggle"];
if (Convert.ToBoolean(result))
{
if (metric.OrderByMetricField == field.Value.SystemName)
{
variable += "item.Key;";
}
else
{
var converterParameter = string.Format("{0}~{1}~{2}",
((string)field.Value.NameValuesList["UndefinedLabel"]).Replace("\"", null),
((string)field.Value.NameValuesList["FalseLabel"]).Replace("\"", null),
((string)field.Value.NameValuesList["TrueLabel"]).Replace("\"", null))
.ToLiteral();
variable += string.Format(@"boolConverter.Convert(item.{0}.{1}, null, {2}, CultureInfo.InvariantCulture);", metricinfoClass, groupFieldPath, converterParameter);
}
}
else
{
goto default;
}
break;
default:
variable += string.Format("item.{0}.{1};", metricinfoClass, groupFieldPath);
break;
}
variable += Environment.NewLine;
groupByFieldValuesList.Add(variable);
}
}
return string.Format(@"
var currentMetric = new {0}Metric_{1}();
{2}
currentMetric.ReadData(Convert.ToDecimal({3}) {4}{5});
Add(currentMetric);"
, process.Name
, metric.Guid.ToString().Replace("-", string.Empty)
, string.Join(string.Empty, groupByFieldValuesList)
, metric.MetricFieldSystemName == metric.OrderByMetricField || readDataFirstInfoObject == "item.Key" ? "item.Value" : "result"
, readDataFirstInfoObject != null ? ", " + readDataFirstInfoObject : null
, groupingFieldsList.IsNullOrEmpty() ? null : ", " + string.Join(",", groupingFieldsList.Select(f => string.Format("{0}_value", f))));
}
/// <summary>
/// Synchronize multiple types with a single roundtrip
/// </summary>
/// <param name="typeIDs">TypeIds to sync</param>
/// <param name="maxAgeInSeconds">View age</param>
/// <returns>A list of type ids actually synchronized</returns>
public IAsyncOperation<IList<string>> SynchronizeTypesAsync(IList<string> typeIDs, int maxAgeInSeconds)
{
if (typeIDs.IsNullOrEmpty())
{
throw new ArgumentException("typeIDs");
}
if (maxAgeInSeconds < 0)
{
throw new ArgumentException("maxAgeInSeconds");
}
return AsyncInfo.Run<IList<string>>(async cancelToken =>
{
IList<SynchronizedType> sTypes = await this.GetMultipleAsync(typeIDs);
SynchronizedViewSynchronizer synchronizer = new SynchronizedViewSynchronizer(m_recordStore.Record, maxAgeInSeconds);
synchronizer.MaxAgeInSeconds = maxAgeInSeconds;
IList<ISynchronizedView> synchronized = await synchronizer.SynchronizeAsync(sTypes.Cast<ISynchronizedView>().ToList());
if (synchronized.IsNullOrEmpty())
{
return null;
}
string[] syncedIDs = (from view in synchronized
select ((SynchronizedType) view).TypeID).ToArray();
return syncedIDs;
});
}
static bool Login(IList<string> unparsed)
{
bool failed = true;
ushort tries = 0;
while (failed && tries < 3)
{
string email = command_email;
if (false == unparsed.IsNullOrEmpty())
{
email = unparsed[0];
}
if (prompt_ok && email.IsNullOrWhiteSpace())
{
Console.Write(Resources.Vmc_EmailPrompt_Text);
email = Console.ReadLine();
}
string password = command_password;
if (prompt_ok && password.IsNullOrWhiteSpace())
{
Console.Write(Resources.Vmc_PasswordPrompt_Text);
password = readPassword();
}
Console.WriteLine();
if (email.IsNullOrWhiteSpace())
{
Console.Error.WriteLine(Resources.Vmc_NeedEmailPrompt_Text);
return false;
}
if (password.IsNullOrWhiteSpace())
{
Console.Error.WriteLine(Resources.Vmc_NeedPasswordPrompt_Text);
return false;
}
IVcapClient vc = new VcapClient();
try
{
VcapClientResult rslt = vc.Login(email, password);
if (rslt.Success)
{
Console.WriteLine(String.Format(Resources.Vmc_LoginSuccess_Fmt, vc.CurrentUri));
failed = false;
}
else
{
Console.Error.WriteLine(String.Format(Resources.Vmc_LoginFail_Fmt, vc.CurrentUri));
}
}
catch (Exception e)
{
Console.Error.WriteLine(String.Format(Resources.Vmc_LoginError_Fmt, vc.CurrentUri, e.Message));
}
++tries;
}
return false == failed;
}
internal ItemQuery CreateRefreshQueryForKeys(IList<ItemKey> keys, IList<string> typeVersions)
{
ItemQuery query = ItemQuery.QueryForKeys(keys);
query.View.SetSections(SectionsToFetch);
if (!typeVersions.IsNullOrEmpty())
{
query.View.TypeVersions.AddRange(typeVersions);
}
return query;
}
async Task UpdateViews(IList<ISynchronizedView> views, IList<ItemQueryResult> queryResults)
{
int iResult = 0;
for (int i = 0, count = views.Count; i < count; ++i)
{
ItemQuery query = m_syncQueries[i];
if (query != null)
{
ItemQueryResult queryResult = null;
if (!queryResults.IsNullOrEmpty())
{
queryResult = queryResults[iResult++];
}
await this.UpdateKeys(views[i], queryResult);
}
}
}
protected void WriteArray(JsonWriter writer, IList list)
{
writer.WriteStartArray();
if (list.IsNullOrEmpty())
{
writer.WriteEndArray();
return;
}
for (int i = 0; i < list.Count; i++)
{
var value = list[i];
if (value is INamedList)
WriteNamedList(writer, value as INamedList);
else if (value is IList)
WriteArray(writer, value as IList);
else
writer.WriteValue(value);
}
writer.WriteEndArray();
}
public IList<EGPSCurrentInfo> GetCurrentInfoList(IList<Guid> ltVehicleCode)
{
//Query query = new Query(typeof(EGPSCurrentInfo));
//query.Expression = Expression.CreateExpression("VehicleCode", PolynaryOperatorType.In, ltVehicleCode);
//using (IRepository repository = SessionManager.CreateRepository(typeof(EGPSCurrentInfo)))
//{
// return repository.List<EGPSCurrentInfo>(query);
//}
//优化
if (ltVehicleCode.IsNullOrEmpty())
return null;
List<EGPSCurrentInfo> list = null;
string sqlText = string.Format(@"SELECT ID,GPSCode,Longitude,Latitude,Speed,Direction,ReportTime,OilState,ACCState,Mileage,PowerState,
StarkMileage,AntennaState,OilBearing,DoorStatus,PhotoPath,VehicleCode,PlunderState,Detector1,Detector2,Detector3,Detector4,CoolerStatus
FROM gps_currentinfo WHERE VehicleCode in ('{0}')", ltVehicleCode.JoinToString<Guid>("','"));
using (MySqlDataReader sdr = MySqlDB.GetDataReader(CommandType.Text, sqlText))
{
if (sdr != null)
{
list = new List<EGPSCurrentInfo>();
while (sdr.Read())
{
list.Add(new EGPSCurrentInfo
{
ID = sdr.GetGuid(0),
GPSCode = sdr.GetString(1),
Longitude = sdr.GetDouble(2),
Latitude = sdr.GetDouble(3),
Speed = sdr.GetDouble(4),
Direction = sdr.GetDouble(5),
ReportTime = sdr.GetDateTime(6),
OilState = sdr.GetInt(7),
ACCState = sdr.GetInt(8),
Mileage = sdr.GetDouble(9),
PowerState = sdr.GetInt(10),
StarkMileage = sdr.GetDouble(11),
AntennaState = sdr.GetInt(12),
OilBearing = sdr.GetDoubleExt(13),
DoorStatus = sdr.GetInt(14),
PhotoPath = sdr.GetStringExt(15),
VehicleCode = sdr.GetGuidExt(16),
PlunderState = sdr.GetInt16(17),
Detector1 = sdr.GetFloatNull(18),
Detector2 = sdr.GetFloatNull(19),
Detector3 = sdr.GetFloatNull(20),
Detector4 = sdr.GetFloatNull(21),
CoolerStatus = sdr.GetInt(22)
});
}
sdr.Close();
}
}
return list;
}
public IAsyncAction PutViewsAsync(IList<SynchronizedView> views)
{
if (views.IsNullOrEmpty())
{
throw new ArgumentException("views");
}
return AsyncInfo.Run(async cancelToken =>
{
foreach(SynchronizedView view in views)
{
view.ValidateRequired("view");
await this.PutViewAsync(view, cancelToken);
}
});
}
public async Task<IResult> DeleteCustomFieldsAsync(IList<CustomField> customFields)
{
IResult result = null;
if (customFields.IsNullOrEmpty())
{
result = new ShopTimeResult()
{
Error = new Error() { Message = "customFields can't be null or empty."}
};
}
try
{
foreach (var customField in customFields)
{
customField.IsDeleted = true;
}
await _customFieldRepo.UpdateAsync(customFields)
.Error(err =>
{
result = new ShopTimeResult() { Error = err};
})
.Success(() =>
{
result = new ShopTimeResult();
});
}
catch (Exception ex)
{
result = new ShopTimeResult()
{
Error = new Error() { CodeNumber = 500, Message = ex.Message }
};
}
return result;
}
/// <summary>
/// The get kpi gadget data.
/// </summary>
/// <param name="processName">
/// The process name.
/// </param>
/// <param name="parameters">
/// The parameters.
/// </param>
/// <returns>
/// The <see cref="IList"/>.
/// </returns>
public IList<KpiItem> GetKpiGadgetData(string processName, IList<KpiParameters> parameters)
{
if (string.IsNullOrWhiteSpace(processName)) return null;
if (parameters.IsNullOrEmpty()) return null;
_selectedKPIList.Clear();
if (parameters != null)
{
foreach (var parameter in parameters)
{
var random = Guid.NewGuid();
var kpiinfo = this.DynamicTypeManager.GetGadgetAggregateInfo(processName, parameter.KpiGuid, random);
if (!IconList.Any())
{
var items = this.DynamicTypeManager.GetInfoList<IIcon>(Constants.IconProcessName, string.Empty, 0, int.MaxValue);
if (items != null)
IconList.AddRange(items);
}
var icon = IconList.FirstOrDefault(x => x.Id == kpiinfo.CurrentIconID);
var iconName = icon != null ? icon.name : kpiinfo.CurrentIconURL;
this._selectedKPIList.Add(new KpiItem(kpiinfo.Id, kpiinfo.Name, kpiinfo.Guid, kpiinfo.CurrentValue, iconName));
}
}
return _selectedKPIList;
}
private void PrepareGroups(IList<string> groupsNames)
{
var groupsDict = CreateProperties()
.GroupBy(x => x.GroupName)
.ToDictionary(x => x.Key);
Groups = new List<GroupProperties>();
if (groupsNames.IsNullOrEmpty())
{
foreach (var group in groupsDict)
{
Groups.Add(new GroupProperties
{
GroupName = group.Key,
Properties = group.Value.ToList()
});
}
}
else
{
foreach (var groupName in groupsNames)
{
var trimedGroupName = groupName.TrimEnd('*');
if (!groupsDict.ContainsKey(trimedGroupName)) continue;
var group = groupsDict[trimedGroupName];
Groups.Add(new GroupProperties
{
GroupName = @group.Key,
Properties = @group.ToList(),
IsCollapsed = groupName.EndsWith("*")
});
}
}
}
private Dictionary<EHisotryDataStoreTables, IList<Guid>> GroupByStoreTable(
IList<EHistoryDataStoreConfig> ltTableConfig)
{
if (ltTableConfig.IsNullOrEmpty())
{
return null;
}
Dictionary<EHisotryDataStoreTables, IList<Guid>> dic = new Dictionary<EHisotryDataStoreTables, IList<Guid>>();
IList<Guid> ltVehicleCode;
foreach (var item in ltTableConfig)
{
if (dic.ContainsKey(item.StoreTable))
{
ltVehicleCode = dic[item.StoreTable];
}
else
{
ltVehicleCode = new List<Guid>();
dic.Add(item.StoreTable, ltVehicleCode);
}
ltVehicleCode.Add(item.VehicleCode);
}
return dic;
}
private bool CheckCommandCondition(IList<EGPSCurrentInfo> ltCurrent, CommandResultViewModel vm,
EnumOilCommandType commandType)
{
if (ltCurrent.IsNullOrEmpty())
{
vm.Msg = "车辆已经离线，无法操作";
vm.CommandResult = EnumCommandResult.MisMatchCondition;
return false;
}
TimeSpan timeSpan = DateTime.Now.Subtract(ltCurrent[0].ReportTime);
if (timeSpan.TotalMinutes > Param_OffLineTime)
{
vm.Msg = "车辆已经离线，无法操作";
vm.CommandResult = EnumCommandResult.MisMatchCondition;
return false;
}
if (commandType == EnumOilCommandType.BreakOil)
{
if (ltCurrent[0].OilState != 1) //1 表示油电路正常
{
vm.Msg = "车辆油电路已经断开";
vm.CommandResult = EnumCommandResult.MisMatchCondition;
return false;
}
if (ltCurrent[0].Speed >= 30)
{
vm.Msg = "此操作在速度30公里/时才能操作";
vm.CommandResult = EnumCommandResult.MisMatchCondition;
return false;
}
}
else if (commandType == EnumOilCommandType.Support)
{
if (ltCurrent[0].OilState == 1) //1 表示油电路正常
{
vm.Msg = "车辆油电路已正常";
vm.CommandResult = EnumCommandResult.MisMatchCondition;
return false;
}
}
return true;
}
/// <summary>
/// 获取所有准确历史数据时只获取IsGPSOverFlow=0;
/// </summary>
private IList<EGPSHistoryInfo> GetGPSHistoryInfoList(EHisotryDataStoreTables table , IList<Guid> ltVehicleCode, DateTime beginTime, DateTime endTime)
{
if (table == null || ltVehicleCode.IsNullOrEmpty())
return null;
string codes = string.Join("','", ltVehicleCode.Select(s => s.ToString()).ToArray());
codes = " ('" + codes + "') ";
string sqlText = string.Format("select * from {0} where VehicleCode in {1} and reporttime between '{2}' and '{3}' and IsGPSOverFlow=0 order by ReportTime asc ",
table.TableName, codes, beginTime, endTime);
return List(table.SelectConnStr, sqlText);
}
/// <summary>
/// Receives messages from source queue and puts them into destination queues.
/// </summary>
/// <param name="sourceQueue"></param>
/// <param name="inboundMessages"></param>
private void RelayMessagesInternal(CloudQueue sourceQueue, IList<CloudQueueMessage> inboundMessages)
{
if (inboundMessages.IsNullOrEmpty())
return;
if (this.DestinationQueues.IsNullOrEmpty())
throw new Exception("Cannot relay queue messages because destination queue(s) are not specified.");
this.LogInformation("Received {0} messages from queue \"{1}\". Dispatching them to {2} destination queues.", inboundMessages.Count, sourceQueue.Name, this.DestinationQueues.Count);
//messages.ForEach(msg => this.LogInformation("Received message at {0}:\r\n\"{1}\"\r\n", DateTimeOffset.Now, msg.AsString));
var stopWatch = new Stopwatch();
stopWatch.Start();
inboundMessages = this.TransformInboundMessages(inboundMessages, stopWatch);
this.ForwardMessages(inboundMessages.Count, inboundMessages, stopWatch);
this.DeleteSourceMessages(sourceQueue, inboundMessages, stopWatch);
}
/// <summary>
/// Constructs a new course for this fleet from the <c>vectorCourse</c> provided.
/// </summary>
/// <param name="vectorCourse">The vector course.</param>
private void ConstructApCourse(IList<Vector3> vectorCourse) {
if (vectorCourse.IsNullOrEmpty()) {
D.Error("{0}'s vectorCourse contains no course to {1}.", DebugName, ApTarget.DebugName);
return;
}
ApCourse.Clear();
int destinationIndex = vectorCourse.Count - 1; // no point adding StationaryLocation for Destination as it gets immediately replaced
for (int i = 0; i < destinationIndex; i++) {
ApCourse.Add(new StationaryLocation(vectorCourse[i]));
}
ApCourse.Add(ApTarget); // places it at course[destinationIndex]
HandleApCourseChanged();
}
