/// <summary>
/// Saves updates to the phone number.
/// </summary>
/// <param name="client">REST client.</param>
/// <returns></returns>
public void Save(IVcRestClient client = null)
{
Number number = null;
UpdateNumber updateNumber = new UpdateNumber(this.Id)
{
Name = this.Name,
StatusTextUrl = this.StatusTextUrl,
IncomingTextUrl = this.IncomingTextUrl,
IncomingTextMethod = this.IncomingTextMethod,
IncomingTextFallbackUrl = this.IncomingTextFallbackUrl,
IncomingTextFallbackMethod = this.IncomingTextFallbackMethod,
VoiceForwardingNumber = this.VoiceForwardingNumber
};
if (this.PhoneNumberType == PhoneNumberTypeEnum.Local)
{
number = UpdateLocal(this.AccountId, updateNumber, client);
}
else
{
number = Update(this.AccountId, updateNumber, client);
}
ResourceConfiguration.GetMapper().Map(number, this);
}
//create new ResourceConfiguration (and save to DB) or if already exist get one
public ResourceConfiguration GetResourceConfig(string domain)
{
if (Db.Database.Connection.State == System.Data.ConnectionState.Closed)
{
Db.Database.Connection.Open();
}
var configs = (from n in Db.ResourceConfiguration where n.ResourceDomain == domain select n).ToList();
if (configs.Count > 1)
{
throw new Exception("DB contains duplicated ResourceConfiguration.");
}
if (configs.Count == 0)
{
ResourceConfiguration newConfig = new ResourceConfiguration
{
ResourceDomain = domain,
ResourceDataFormat = ResourceDataFormat.Html //by default
};
Db.ResourceConfiguration.Add(newConfig);
Db.SaveChanges();
Db.Database.Connection.Close();
return(GetResourceConfig(domain));
}
Db.Database.Connection.Close();
return(configs[0]);
}
public bool AddResourceProcessingStatus(string targetUrl, ResourceConfiguration config)
{
if (Db.Database.Connection.State == System.Data.ConnectionState.Closed)
{
Db.Database.Connection.Open();
}
if ((from n in Db.ResourceProcessingStatus where n.TargetUrl == targetUrl select n).Any())
{
Console.WriteLine($"[AddResourceProcessingStatus] link({targetUrl}) already exist in DB");
return(false);
}
ResourceProcessingStatus newStatus = new ResourceProcessingStatus
{
ResourceConfiguration = config,
ResourceConfigurationId = config.ResourceConfigurationId,
Status = ProcessingStatus.Start,
ProcessedMatches = 0,
TargetUrl = targetUrl
};
Db.ResourceProcessingStatus.Add(newStatus);
Db.SaveChanges();
Db.Database.Connection.Close();
return(true);
}
/// <summary>
/// The repopulate resource configuration.
/// </summary>
/// <param name="ranttConfiguration">
/// The gantt configuration.
/// </param>
/// <param name="currentResourceConfigurationSource">
/// The current resource configuration source.
/// </param>
public void RepopulateResourceConfiguration(
RanttConfiguration ranttConfiguration,
Dictionary <string, ResourceConfiguration> currentResourceConfigurationSource)
{
// Group allOperations by resource
var operationsGroupedByResource =
Operations
.GroupBy(x => x.Resource)
.ToDictionary(
x => x.Key,
x => x.OrderBy(y => y.StartTime).ToList());
foreach (var resourceName in operationsGroupedByResource.Keys)
{
if (!operationsGroupedByResource.ContainsKey(resourceName))
{
continue;
}
if (!currentResourceConfigurationSource.ContainsKey(resourceName))
{
ResourceConfiguration resourceConfiguration = new ResourceConfiguration(resourceName, currentResourceConfigurationSource.Count + 1, true);
currentResourceConfigurationSource.Add(
resourceName,
resourceConfiguration);
if (currentResourceConfigurationSource == ranttConfiguration.ResourceConfigurations)
{
resourceConfiguration.PropertyChanged += (sender, args) => ranttConfiguration.RaiseConfigurationChangeEvent(sender, args.PropertyName);
}
}
}
}
private void DrawPath(ResourceConfiguration data, List <Vector3> path)
{
for (var i = 0; i < path.Count - 2; i++)
{
//Debug.DrawLine(path[i], path[i+1], data.Material.Color, 6000, false);
DrawCapsule(path[i], path[i + 1], data.VeinRadius, data.Material);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ResourceConfigurationChangeEventArgs" /> class.
/// </summary>
/// <param name="resourceConfiguration">The resource configuration model.</param>
/// <param name="propertyName">Name of the property.</param>
public ResourceConfigurationChangeEventArgs(ResourceConfiguration resourceConfiguration, string propertyName)
: base(propertyName)
{
// If resource configuration is not provided it means every resource has been changed.
// Argument.IsNotNull("resourceConfiguration", resourceConfiguration);
Model = resourceConfiguration;
}
public PresentationWindow(IPresentationController presentationController, ResourceConfiguration resourceConfiguration, StateConfiguration stateConfiguration)
{
PresentationController = presentationController;
ResourceConfiguration = resourceConfiguration;
StateConfiguration = stateConfiguration;
InitializeSettings();
InitializeComponent();
InitializeContexts();
}
private void InitializeResourceManager(Context context)
{
try
{
ResourceConfiguration configuration = new ResourceConfiguration();
configuration.Load("Monitor.xml");
DeviceManager deviceManager = new DeviceManager();
foreach (string key in configuration.Resources.Keys)
{
foreach (ResourceConfig resourceConfig in configuration.Resources[key])
{
Resource resource = new Resource();
resource.DeviceClass = key;
resource.StateCode = resourceConfig.StateCode;
resource.StateDesc = resourceConfig.StateDesc;
System.Drawing.Image image = null;
try
{
if (resourceConfig.ImageFile != null && resourceConfig.ImageFile.Trim().Length != 0)
{
image = System.Drawing.Bitmap.FromFile(resourceConfig.ImageFile);
}
}
catch (Exception e)
{
Logger.Error("ContextInitialize出错。原因：" + e.Message);
}
resource.Image = image;
deviceManager.AddResource(resource);
}
}
foreach (string key in configuration.Devices.Keys)
{
foreach (DeviceConfig deviceConfig in configuration.Devices[key])
{
Device device = new Device();
device.DeviceClass = key;
device.DeviceNo = deviceConfig.DeviceNo;
device.X = deviceConfig.X;
device.Y = deviceConfig.Y;
device.Width = deviceConfig.Width;
device.Height = deviceConfig.Height;
deviceManager.AddDevice(device);
}
}
context.DeviceManager = deviceManager;
configuration.Release();
}
catch (Exception e)
{
Logger.Error("ContextInitialize出错。原因：" + e.Message);
}
}
/// <summary>
/// Initializes the VcRestClient.
/// </summary>
/// <param name="accountId">Account ID.</param>
/// <param name="apiKey">API key.</param>
/// <param name="apiSecret">API secret.</param>
/// <param name="apiBaseUrl">API base URL.</param>
public static void Init(int accountId, string apiKey, string apiSecret, string apiBaseUrl = "https://api.vivialconnect.net/api/v1.0/")
{
_accountId = accountId;
_apiKey = apiKey;
_apiSecret = apiSecret;
_apiBaseUrl = apiBaseUrl;
_restClient = null;
ResourceConfiguration.Configure();
}
/// <summary>
/// Saves updates to the account.
/// </summary>
/// <param name="client">REST client.</param>
/// <returns></returns>
public void Save(IVcRestClient client = null)
{
UpdateAccount updateAccount = new UpdateAccount {
Id = this.Id, CompanyName = this.CompanyName
};
Account account = Update(updateAccount, client);
ResourceConfiguration.GetMapper().Map(account, this);
}
private void SpawnVein(ResourceConfiguration data, MapData map, Vector3 start, int veinsLeft)
{
veinsLeft--;
var path = GetPath(data, map, start);
DrawPath(data, path);
if (veinsLeft > 0)
{
SpawnVein(data, map, path[Random.Range(0, 4) % path.Count], veinsLeft / 2);
SpawnVein(data, map, path[Random.Range(0, 4) % path.Count], veinsLeft - (veinsLeft / 2));
}
}
public void ResourceConfiguration_Constructor_ShouldSetParameters()
{
var mapping = new ResourceMapping <ResourceA>(
new Dictionary <string, PropertyInfo>(),
new Dictionary <string, RelationInfo>(),
new IdPropertyInfo("IdName", null));
var info = new ResourceConfiguration <ResourceA>("SomeTypeName", mapping);
Assert.That(info.ResourceType, Is.EqualTo(typeof(ResourceA)));
Assert.That(info.TypeName, Is.EqualTo("SomeTypeName"));
Assert.That(info.Mapping, Is.EqualTo(mapping));
}
private void InitializePlayingVideo()
{
if (ResourceConfiguration.IsVideosPathValid())
{
var videos = ResourceConfiguration.GetVideos();
if (videos != null && videos.Count > 0)
{
var selectedVideo = GetSelectedVideo();
MediaSource = new Uri(selectedVideo);
PropertyChanged(this, new PropertyChangedEventArgs("MediaSource"));
sbPresentation.Begin();
}
}
}
public void SpawnResources(ResourceConfiguration data, MapData map)
{
var amount = Random.Range(data.MinAmount, data.MaxAmount + 1);
var width = map.Chunks.GetLength(0) * Chunk.ChunkSize;
var height = map.Chunks.GetLength(0) * Chunk.ChunkSize;
var start = Vector3.zero;
do
{
start = new Vector3(Random.Range(0, width), Random.Range(0, height), Random.Range(0, width));
} while (!IsStone(start, map));
SpawnVein(data, map, start, amount);
}
/// <summary>
/// Saves the connector.
/// </summary>
/// <param name="client">REST client.</param>
/// <returns></returns>
public void Save(IVcRestClient client = null)
{
Connector connector = null;
if (this.IsNew)
{
connector = Create(VcClient.AccountId, this.Active, this.Name, this.Callbacks, this.Numbers, client);
}
else
{
connector = Update(this.AccountId, (int)this.Id, this.Active, this.Name, this.Callbacks, this.Numbers, (bool)this.MoreNumbers, client);
}
ResourceConfiguration.GetMapper().Map(connector, this);
}
private List <Vector3> GetPath(ResourceConfiguration data, MapData map, Vector3 start)
{
var list = new List <Vector3>();
list.Add(start);
var length = 0f;
do
{
var end = new Vector3(start.x + Random.Range(-data.MinVeinLength, data.MinVeinLength),
start.y + Random.Range(-data.MinVeinLength / 3, data.MinVeinLength / 3),
start.z + Random.Range(-data.MinVeinLength, data.MinVeinLength));
if (IsStone(end, map) && (start - end).magnitude > data.MinVeinLength / 2f)
{
list.Add(end);
length += (list[list.Count - 1] - list[list.Count - 2]).magnitude;
}
} while (length < data.MinVeinLength);
return(list);
}
private void ShuffleVideoOptions()
{
if (!ResourceConfiguration.IsVideosPathValid())
{
CurrentVideoSelection = new List <string>();
}
else
{
var random = new Random();
var videos = new List <string>(ResourceConfiguration.GetVideos());
var shuffle = new List <string>();
while (videos.Count > 0)
{
var videoIndex = random.Next(videos.Count);
var video = videos[videoIndex];
shuffle.Add(video);
videos.RemoveAt(videoIndex);
}
CurrentVideoSelection = shuffle;
}
}
private void InitializeThis()
{
PresentationController = new PresentationController();
SongController = new SongController();
ResourceConfiguration = ResourceConfiguration.CreateInstance();
PresentationController.Subscribe(this);
PresentationController.SetKeyEvents(this);
ProgressControl = new MainProgressControl();
sbiProgress.DataContext = ProgressControl;
StateConfiguration = StateConfiguration.CreateInstance();
tbPesquisar.Text = StateConfiguration.Keywords ?? "";
gPreferences.DataContext = this;
if (PropertyChanged != null)
{
PropertyChanged(this, new PropertyChangedEventArgs("ResourceConfiguration"));
}
}
/// <summary>
/// Redacts the text message.
/// </summary>
/// <param name="client">REST client.</param>
/// <returns></returns>
public void Redact(IVcRestClient client = null)
{
Message message = Update(this.AccountId, (int)this.Id, client);
ResourceConfiguration.GetMapper().Map(message, this);
}
public List <Song> GetSongs(ResourceConfiguration resourceConfiguration)
{
var result = new List <Song>();
foreach (var lyric in resourceConfiguration.GetLyrics())
{
string[] lyricLines = File.ReadAllLines(lyric, Encoding.UTF8);
Song song = new Song();
List <SongItem> items = new List <SongItem>();
char? lastUsedKey = null;
string lastVerseTip = null;
char pKey = 'A';
List <char> userDefinedKeys = new List <char>();
for (int i = 0; i < lyricLines.Length; i++)
{
var lyricLine = lyricLines[i];
if (i == 0)
{
song.Name = lyricLine;
}
else if (i == 1)
{
song.Album = lyricLine;
}
else
{
if (!string.IsNullOrEmpty(lyricLine))
{
if (lyricLine.Trim().StartsWith("[") && lyricLine.Trim().EndsWith("]"))
{
string command = lyricLine.Substring(1, lyricLine.Length - 2);
string[] keyVerseTip = command.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
if (keyVerseTip.Length > 0)
{
lastUsedKey = keyVerseTip[0][0];
userDefinedKeys.Add(lastUsedKey.Value);
}
if (keyVerseTip.Length > 1)
{
lastVerseTip = keyVerseTip[1];
}
if (keyVerseTip.Length == 0)
{
song.HasErrors = true;
}
}
else
{
SongItem item = new SongItem();
item.Line = i;
if (lastUsedKey == null)
{
var usedKey = pKey++;
while (userDefinedKeys.Contains((usedKey)))
{
if (pKey >= 'Z')
{
pKey = 'A';
continue;
}
pKey++;
}
lastUsedKey = item.Key = usedKey;
}
else
{
item.Key = lastUsedKey.Value;
}
item.VerseTip = lastVerseTip ?? "";
item.Verse = lyricLine;
items.Add(item);
}
}
else
{
lastUsedKey = null;
lastVerseTip = null;
}
}
}
song.Items = items;
Console.WriteLine(string.Format("IsValid: {0}, {1}", song.IsValid(), song.ToString()));
if (song.IsValid())
{
result.Add(song);
}
}
return(result);
}
/// <summary>
/// Loads raw configuration data.
/// </summary>
/// <param name="configuration">
/// The configuration object in context of which operation is executed.
/// </param>
/// <param name="rawConfigurationData">
/// The raw configuration data.
/// </param>
public static void LoadRawConfiguration(this RanttConfiguration configuration, RawConfigurationData rawConfigurationData)
{
configuration.IsInitializing = true;
configuration.AvailableWorkspaces.Clear();
configuration.ResourceConfigurations.Clear();
configuration.AttributeConfigurations.Clear();
configuration.CalendarStateConfigurations.Clear();
foreach (RawResourceConfiguration rawResource in rawConfigurationData.ResourceConfigurations)
{
ResourceConfiguration resourceConfiguration = new ResourceConfiguration(rawResource.Name, rawResource.Position, rawResource.IsVisible);
configuration.ResourceConfigurations.Add(resourceConfiguration.Name, resourceConfiguration);
resourceConfiguration.PropertyChanged += (sender, args) => configuration.RaiseConfigurationChangeEvent(sender, args.PropertyName);
}
foreach (RawBaseAttributeConfiguration rawBaseAttributeConfiguration in rawConfigurationData.BaseAttributeConfigurations)
{
AttributeConfiguration attributeConfiguration = rawBaseAttributeConfiguration.GetAttributeConfiguration();
configuration.AttributeConfigurations.Add(attributeConfiguration.Name, attributeConfiguration);
if (rawConfigurationData.ExtendedAttributeConfigurations.ContainsKey(attributeConfiguration.Name))
{
foreach (RawAttributeExtendedConfiguration extendedConfiguration in rawConfigurationData.ExtendedAttributeConfigurations[attributeConfiguration.Name])
{
attributeConfiguration.InitializeAttributeValue(extendedConfiguration.Value);
attributeConfiguration.SetAttributeValueColor(extendedConfiguration.Value, CustomColorConverter.StringToColor(extendedConfiguration.Color));
attributeConfiguration.SetAttributeValueVisibility(extendedConfiguration.Value, extendedConfiguration.Visibility);
}
}
attributeConfiguration.PropertyChanged += (sender, args) => configuration.RaiseConfigurationChangeEvent(sender, args.PropertyName);
}
foreach (RawCalendarStateConfiguration rawCalendarStateConfiguration in rawConfigurationData.CalendarStateConfigurations)
{
CalendarStateConfiguration calendarStateConfiguration = new CalendarStateConfiguration(rawCalendarStateConfiguration.Name, CustomColorConverter.StringToColor(rawCalendarStateConfiguration.Color))
{
IsVisible = rawCalendarStateConfiguration.IsVisible
};
calendarStateConfiguration.PropertyChanged += (sender, args) => configuration.RaiseConfigurationChangeEvent(sender, args.PropertyName);
}
RawWorkspaceConfiguration rawWorkspace = rawConfigurationData.CurrentWorkspace;
configuration.CurrentWorkspace = rawWorkspace == null ? null :
new WorkspaceConfiguration
{
Name = rawWorkspace.Name,
GroupByAttributeName = rawWorkspace.GroupByAttributeName,
HighlightPast = rawWorkspace.HighlightPast,
AreTooltipsEnabled = rawWorkspace.AreTooltipsEnabled,
IsDataRowEnabled = rawWorkspace.IsDataRowEnabled,
IsPlotRowEnabled = rawWorkspace.IsPlotRowEnabled,
OperationColorAttribute = rawWorkspace.OperationColorAttribute,
PlotType = rawWorkspace.PlotType,
PlotInterval = rawWorkspace.PlotInterval,
RelativeStartTime = rawWorkspace.RelativeStartTime,
SelectedAttributes = rawWorkspace.SelectedAttributes,
ShowCurrentTime = rawWorkspace.ShowCurrentTime,
ShowHorizontalGridLines = rawWorkspace.ShowHorizontalGridLines,
ShowVerticalGridLines = rawWorkspace.ShowVerticalGridLines,
UseRelativeTime = rawWorkspace.UseRelativeTime,
RelativeDuration = rawWorkspace.RelativeDuration,
ShowCountData = rawWorkspace.ShowCountData,
ShowDurationData = rawWorkspace.ShowDurationData
};
foreach (string availableWorkspace in rawConfigurationData.AvailableWorkspaces)
{
if ((configuration.CurrentWorkspace != null) &&
(configuration.CurrentWorkspace.Name == availableWorkspace))
{
configuration.AvailableWorkspaces.Add(availableWorkspace, configuration.CurrentWorkspace);
}
else
{
configuration.AvailableWorkspaces.Add(availableWorkspace, null);
}
}
configuration.IsInitializing = false;
}
partial void OnResourceConfigurationChanging(ResourceConfiguration value);
