public void speak(bool val, Speaker speaker=Speaker.Host, string words=null, float time=-1)
{
if (val && !isSpeaking ()) {
startSpeak(speaker, words, time);
}
_speak = val;
}
public async Task<SetTeamOrAdjudicatorResult> PostSpeaker(Speaker speaker)
{
var ident = HttpContext.Current.User.Identity as ClaimsIdentity;
String userId = ident.GetUserId();
var user = await userManager.FindByIdAsync(userId);
var team = tournamentRegistrationsManager.GetTeam(speaker.teamId);
if (team == null)
{
return SetTeamOrAdjudicatorResult.TeamNotFound;
}
// Check if user has permissions
if (!userManager.HasOrganizationRole(userId, team.OrganizationId, OrganizationRole.Delegate))
{
// User does not have permissions
return SetTeamOrAdjudicatorResult.NotAuthorized;
}
// Add speaker to team
var result = await tournamentRegistrationsManager.AddSpeakerAsync(speaker.teamId, speaker.userId, user);
return result;
}
public Session(Slot slot, Room room, Speaker speaker, string title)
{
Slot = slot;
Room = room;
Speaker = speaker;
Title = title;
}
public void Speak(Speaker speaker, string words, float time)
{
Debug.Log ("Starting to speak");
timeLeft = time;
this.transform.position = startPos;
text.setText (words);
//set speakers image
foreach (Transform child in this.faces.transform) {
child.gameObject.SetActive(false);
switch (speaker) {
case Speaker.Bobby:
if(child.name == "Bobby") {
child.gameObject.SetActive(true);
}
break;
case Speaker.Gary:
if(child.name == "Gary") {
child.gameObject.SetActive(true);
}
break;
case Speaker.Robert:
if(child.name == "Robert") {
child.gameObject.SetActive(true);
}
break;
case Speaker.Host:
if(child.name == "Host") {
child.gameObject.SetActive(true);
}
break;
}
}
}
private void setSpeaker(Speaker speaker) {
speakers[(int)speaker].SetActive(true);
speakers[(((int)speaker) + 1) % 3].SetActive(false);
speakers[(((int)speaker) + 2) % 3].SetActive(false);
textMesh.color = speakerColors[(int)speaker];
}
/// <summary>
/// Returns true if Self Filters agree with responce
/// </summary>
private bool ReadyToSpeak(Speaker argSpeaker)
{
if (argSpeaker != null)
if (_NPCFilters.Any(x => x == null || x.Accepted(argSpeaker.Tags)))
return true;
return _NPCFilters.Count == 0;
}
public async Task<string> GetSpeakerImagePath (Conference conference, Speaker speaker)
{
string documentsPath = Environment.GetFolderPath (Environment.SpecialFolder.Personal);
string localFilename = conference.Slug + "-" + speaker.Slug + ".png";
string localPath = Path.Combine (documentsPath, localFilename);
byte[] bytes = null;
if (!File.Exists (localPath)) {
using (var httpClient = new HttpClient (new NativeMessageHandler ())) {
try {
bytes = await httpClient.GetByteArrayAsync (speaker.ImageUrl);
} catch (OperationCanceledException opEx) {
Insights.Report (opEx);
return null;
} catch (Exception e) {
Insights.Report (e);
return null;
}
//Save the image using writeAsync
FileStream fs = new FileStream (localPath, FileMode.OpenOrCreate);
await fs.WriteAsync (bytes, 0, bytes.Length);
}
}
return localPath;
}
/// <summary>
/// Returns true if Listener Filters agree with responce
/// </summary>
private bool ReadyToListen(Speaker argListener)
{
if (argListener != null)
if (_PlayerFilters.Any(x => x == null || x.Accepted(argListener.Tags)))
return true;
return _PlayerFilters.Count == 0;
}
public SpeakerContainer(SpeakerCollection speakers, Speaker s)
{
_speaker = s;
this.SpeakerColletion = speakers;
_OriginalAttributes = s.Attributes.Select(a => new SpeakerAttribute(a)).ToList(); ;
}
// return true if we should continue
internal override bool SpeechIsCommand(string text, Speaker speaker)
{
// deal with commands if present
switch (text)
{
case "target only":
SetTargetOnly(speaker);
return true;
case "confirm source":
SetSourceToo(speaker);
return true;
case "formal":
SetFormal(speaker);
return true;
case "polite":
SetPolite(speaker);
return true;
case "intimate":
SetIntimate(speaker);
return true;
case "close the program":
Application.Exit();
return true;
}
return false;
}
public IEnumerable<Speaker> GetSpeakerSessions()
{
List<Speaker> speakers = new List<Speaker>();
//var obj = ServiceStack.Text.CsvSerializer.DeserializeFromStream(typeof(object), File.Open(_filePath, FileMode.OpenOrCreate));
var dataTable = CsvToDataTable(_filePath);
//var dataTable = CSVParser.ParseCSV(_filePath);// CSVReader.ReadCSVFile(_filePath, true);
//var dataTable = new DataTable();
foreach (DataRow row in dataTable.Rows)
{
var speaker = new Speaker
{
Name = row["Speaker Name"].ToString(),
HomeTown = row["City, State"].ToString(),
Email = row["Email Address"].ToString(),
Website = row["Website or Blog URL"].ToString(),
HeadshotUrl = row["URL for a 90x117 pixel JPG headshot image of you"].ToString(),
Bio = row["Speaker Bio"].ToString(),
NotesToOrganizer = row["Other notes about yourself or your submission"].ToString(),
};
var session1 = new Session
{
Level = row["Session 1 - Level"].ToString(),
Title = row["Session 1 - Title"].ToString(),
Description = row["Session 1 - Description"].ToString(),
};
var session2 = new Session
{
Level = row["Session 2 - Level"].ToString(),
Title = row["Session 2 - Title"].ToString(),
Description = row["Session 2 - Description"].ToString(),
};
var session3 = new Session
{
Level = row["Session 3 - Level"].ToString(),
Title = row["Session 3 - Title"].ToString(),
Description = row["Session 3 - Description"].ToString(),
};
if (!string.IsNullOrWhiteSpace(session1.Title))
speaker.AddSession(session1);
if (!string.IsNullOrWhiteSpace(session2.Title))
speaker.AddSession(session2);
if (!string.IsNullOrWhiteSpace(session3.Title))
speaker.AddSession(session3);
speakers.Add(speaker);
}
return speakers;
}
public override bool Remove(Speaker item)
{
if (item.DBType == DBType.File || item.DBID == null)
return false;
_slist.Remove(item.DBID);
return base.Remove(item);
}
public void ButtonPress()
{
List<string> workingStrings = new List<string>(strings);
if(lastString != -1) workingStrings.RemoveAt(lastString);
Speaker newSpeaker = (lastSpeaker == Speaker.LEFT) ? Speaker.RIGHT : Speaker.LEFT;
lastSpeaker = newSpeaker;
lastString = Random.Range(0, workingStrings.Count);
dialogue.NewLine(workingStrings[lastString], newSpeaker);
}
public void InsertOrUpdate(Speaker speaker)
{
if (speaker.Id == default(int)) {
// New entity
context.Speakers.Add(speaker);
} else {
// Existing entity
context.Entry(speaker).State = EntityState.Modified;
}
}
public override void Execute(Speaker[] speakers)
{
foreach (Speaker speaker in speakers)
foreach (Tag tag in _Tags)
speaker.Tags.RemoveAll(x => x.Key == tag.Key);
foreach (Speaker speaker in speakers)
foreach (Tag tag in _Tags)
speaker.Tags.Add(tag);
}
public ActionResult Create(Speaker speaker)
{
try {
var result = repo.Add(speaker);
return RedirectToAction("Index");
} catch {
return View(speaker);
}
}
internal override void CbxTarget_SelectedIndexChanged(string text, Speaker speaker)
{
if (speaker != null)
{
speaker.cbxRelations.Items.Clear();
speaker.cbxRelations.Text = "Ignore";
speaker.cbxRelations.Visible = false;
speaker.lblSpkRelations.Visible = false;
}
}
/// <summary>
/// Handler of making call and receiving call
/// </summary>
/// <param name="registerName">The SIP ID what will registered into your PBX</param>
/// <param name="domainHost">The address of your PBX</param>
public CallHandlerSample(string registerName, string domainHost)
{
microphone = Microphone.GetDefaultDevice();
speaker = Speaker.GetDefaultDevice();
connector = new MediaConnector();
mediaSender = new PhoneCallAudioSender();
mediaReceiver = new PhoneCallAudioReceiver();
InitializeSoftPhone(registerName, domainHost);
}
internal override void CbxTarget_SelectedIndexChanged(string text, Speaker speaker)
{
if (speaker != null)
{
speaker.cbxRelations.Items.Clear();
speaker.cbxRelations.Items.AddRange(_relations);
speaker.cbxRelations.Text = "Informal-Polite";
speaker.cbxRelations.Visible = true;
speaker.lblSpkRelations.Visible = true;
}
}
/// <summary>
/// Returns an Image UI element.
/// </summary>
/// <param name="speaker">See Speaker enum.</param>
/// <returns>An Image UI element: the left one, the right one, or null.</returns>
Image getSpeaker(Speaker speaker)
{
switch (speaker)
{
case Speaker.LEFT:
return speakerLeft;
case Speaker.RIGHT:
return speakerRight;
default:
return null;
}
}
public void Should_map_session_fields()
{
var speaker = new Speaker("Joe", "Schmoe");
var session = new Session("Foo", new string('a', 5000), speaker);
SaveEntities(session);
var loaded = SessionSource.CreateSession().Load<Session>(session.Id);
loaded.Title.ShouldEqual(session.Title);
loaded.Abstract.ShouldEqual(session.Abstract);
}
public bool CanOpen(Speaker argSpeaker)
{
if(_Filter == null) return true;
if(argSpeaker == null) return true;
bool canDo = _Filter.Accepted(argSpeaker.Tags);
if (!canDo)
{
HighlightGUI.Color = Color.red;
if (HighlightGUI.Target == null)
HighlightGUI.Target = this;
}
return (canDo);
}
public void Should_cascade_to_speaker()
{
var speaker = new Speaker("Joe", "Schmoe");
var session = new Session("Foo", "Bar", speaker);
SaveEntities(session);
var loaded = SessionSource.CreateSession().Load<Session>(session.Id);
loaded.Speaker.ShouldEqual(speaker);
loaded.Speaker.GetSessions().Count().ShouldEqual(1);
}
public RunStatus speak(Speaker speaker, string words, float time)
{
if(!this.Body.isSpeaking())
this.Body.speak (true, speaker, words, time);
if (this.Body.finishedSpeaking ()) {
this.Body.speak (false);
Debug.Log ("Just finished speaking!");
return RunStatus.Success;
}
return RunStatus.Running;
// TODO: Timeout? - AS
}
public PageProcessor(int pageIndex,
TargetRecord jobInfo,
PageLoader pageLoader,
FileDb db,
MaxiPageMgr maxiPageMgr,
Speaker speaker)
{
this.speaker = speaker;
this.maxiPageMgr = maxiPageMgr;
this.db = db;
this.pageLoader = pageLoader;
this.pageIndex = pageIndex;
this.jobInfo = jobInfo;
}
public void SayHelloWorld()
{
INameSource nameSource = MockRepository.Mock<INameSource>();
nameSource.Expect(x => x.CreateName(null, null))
.IgnoreArguments()
.DoInstead(new NameSourceDelegate(Formal));
string expected = "Hi, my name is Ayende Rahien";
string actual = new Speaker("Ayende", "Rahien", nameSource)
.Introduce();
Assert.Equal(expected, actual);
}
/// <summary>
/// Displays a new line of dialogue, and changes the speaker's image.
/// </summary>
/// <param name="str">Dialogue</param>
/// <param name="speaker">Which speaker to display.</param>
/// <param name="sprite">What image to display for chosen speaker.</param>
public void NewLine(string str, Speaker speaker, Sprite sprite)
{
ResetDialogue();
dialogue.text = str;
Image img = getSpeaker(speaker);
if (img != null)
{
img.enabled = true;
img.sprite = sprite;
} else
{
Debug.LogWarning("Invalid Speaker variable for NewLine, can't change image.");
}
}
public void Should_map_all_speaker_fields()
{
var speaker = new Speaker("Joe", "Schmoe")
{
Bio = "I come from France"
};
SaveEntities(speaker);
var loaded = SessionSource.CreateSession().Load<Speaker>(speaker.Id);
loaded.FirstName.ShouldEqual(speaker.FirstName);
loaded.LastName.ShouldEqual(speaker.LastName);
loaded.Bio.ShouldEqual(speaker.Bio);
}
public Dialogue(StreamReader dialogueData, SpriteFont sf, ContentManager cm)
{
Content = cm;
textFont = sf;
textbox = Content.Load<Texture2D>(@"sprites\textbox");
bool readingSpeakers = true;
string line;
while ((line = dialogueData.ReadLine()) != null)
{
if (readingSpeakers && line == "DIALOGUE_BEGIN")
{
readingSpeakers = false;
line = dialogueData.ReadLine();
}
if (readingSpeakers)
{
char[] spaceDelim = new char[] { ' ' };
string[] lineParts = line.Split(spaceDelim);
if(lineParts[0] == "SPEAKER")
{
Speaker aSpeaker = new Speaker();
if (lineParts[1] == "LEFT")
aSpeaker.left = true;
else
aSpeaker.left = false;
aSpeaker.sprite = Content.Load<Texture2D>(@"sprites\" + lineParts[2]);
speakers.Add(aSpeaker);
}
}
else
{
double dummy;
Double.TryParse(line.Substring(0,1), out dummy);
int speakerID = (int)dummy;
script.Enqueue(speakerID);
speakers[speakerID].lines.Enqueue(line.Substring(1, line.Length - 1));
}
}
}
public async void Init_SomeSessionsHaveEnded_LoadsNextUnfinishedSlots()
{
var speaker = new Speaker {Id = 1};
var pastSession = new Session { StartTime = DateTime.UtcNow.AddHours(-1), EndTime = DateTime.UtcNow.AddHours(-1), Id = 42, SpeakerId = speaker.Id};
var inProgressSession = new Session { StartTime = DateTime.UtcNow.AddMinutes(-10), EndTime = DateTime.UtcNow.AddHours(1), Id = 24 };
var data = new CampData
{
Sessions = new List<Session> {inProgressSession, pastSession},
Speakers = new List<Speaker> {speaker}
};
DataClient.GetDataBody = () => Task.FromResult(data);
var viewModel = new OverviewViewModel(Messenger, CodeCampService);
await viewModel.Init();
Assert.AreEqual(1, viewModel.TimeSlots.Count);
Assert.AreEqual(inProgressSession, viewModel.TimeSlots.First().Sessions.Single());
}
/// <summary>
/// Adds a speaker and returns its id
/// </summary>
/// <param name="speaker"></param>
public int AddSpeaker(Speaker speaker)
{
return(-1);
}
/// <summary>
/// Deletes a speaker
/// </summary>
/// <param name="speaker">The speaker to delete</param>
public void DeleteSpeaker(Speaker speaker)
{
// nothing
}
public async Task <Speaker> SaveSpeaker(Speaker speaker)
{
return(await _speakerRepository.SaveSpeaker(speaker));
}
/// <summary> /// The action to perform on the tag enter /// </summary> /// <param name="speaker">The speaker instance</param> /// <param name="text">The text of the tag</param> public abstract void StartAction(Speaker speaker, string text);
public void LoadPrevoiusScene()
{
Speaker.Silence();
SceneManager.LoadScene(RTVoice.Util.Helper.isWebGLPlatform ? PreviousSceneWebGL : PreviousScene);
}
public void Silence()
{
Speaker.Silence();
}
public static void Initialize(MeetingContext context)
{
context.Database.EnsureCreated();
// Look for any students.
if (context.Speakers.Any())
{
return; // DB has been seeded
}
var speakers = new Speaker[]
{
new Speaker {
FirstName = "Carson", LastName = "Alexander"
},
new Speaker {
FirstName = "Meredith", LastName = "Alonso"
},
new Speaker {
FirstName = "Arturo", LastName = "Anand"
},
new Speaker {
FirstName = "Gytis", LastName = "Barzdukas"
},
new Speaker {
FirstName = "Yan", LastName = "Li"
},
new Speaker {
FirstName = "Peggy", LastName = "Justice"
},
new Speaker {
FirstName = "Laura", LastName = "Norman"
},
new Speaker {
FirstName = "Nino", LastName = "Olivetto"
}
};
foreach (Speaker s in speakers)
{
context.Speakers.Add(s);
}
context.SaveChanges();
var topics = new Topic[]
{
new Topic {
TopicID = 1050, Subject = "Prayer"
},
new Topic {
TopicID = 4022, Subject = "Scripture Study"
},
new Topic {
TopicID = 4041, Subject = "Gratitude"
},
new Topic {
TopicID = 1045, Subject = "Faith"
},
new Topic {
TopicID = 3141, Subject = "Family"
},
new Topic {
TopicID = 2021, Subject = "Dangers of Vaping"
},
new Topic {
TopicID = 2042, Subject = "Articles of Faith"
}
};
foreach (Topic t in topics)
{
context.Topics.Add(t);
}
context.SaveChanges();
var assignments = new Assignment[]
{
new Assignment {
SpeakerID = 1, TopicID = 1050, SpeechDate = DateTime.Parse("2005-09-01")
},
new Assignment {
SpeakerID = 1, TopicID = 4022, SpeechDate = DateTime.Parse("2002-09-01")
},
new Assignment {
SpeakerID = 1, TopicID = 4041, SpeechDate = DateTime.Parse("2003-09-01")
},
new Assignment {
SpeakerID = 2, TopicID = 1045, SpeechDate = DateTime.Parse("2002-09-01")
},
new Assignment {
SpeakerID = 2, TopicID = 3141, SpeechDate = DateTime.Parse("2002-09-01")
},
new Assignment {
SpeakerID = 2, TopicID = 2021, SpeechDate = DateTime.Parse("2001-09-01")
},
new Assignment {
SpeakerID = 3, TopicID = 1050, SpeechDate = DateTime.Parse("2001-09-01")
},
new Assignment {
SpeakerID = 4, TopicID = 1050, SpeechDate = DateTime.Parse("2001-09-01")
},
new Assignment {
SpeakerID = 4, TopicID = 4022, SpeechDate = DateTime.Parse("2001-09-01")
},
new Assignment {
SpeakerID = 5, TopicID = 4041, SpeechDate = DateTime.Parse("2001-09-01")
},
new Assignment {
SpeakerID = 6, TopicID = 1045, SpeechDate = DateTime.Parse("2001-09-01")
},
new Assignment {
SpeakerID = 7, TopicID = 3141, SpeechDate = DateTime.Parse("2001-09-01")
},
};
foreach (Assignment a in assignments)
{
context.Assignments.Add(a);
}
context.SaveChanges();
}
/// <summary>
/// Updates a speaker
/// </summary>
/// <param name="speaker">The speaker to udpate</param>
public void UpdateSpeaker(Speaker speaker)
{
// nothing
}
public static async Task <Xamarin.Forms.Color> CalculateBackgroundColorAsync(Speaker speaker)
{
try
{
var localFolder = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
var cachedFilePath = Path.Combine(localFolder, $"{speaker.Id}.png");
// Cache the file now so that any future requests for the same speaker doesn't need to redownload it
if (!File.Exists(cachedFilePath))
{
using (Stream stream = await new HttpClient().GetStreamAsync(speaker.ImageUrl))
using (var fileStream = File.OpenWrite(cachedFilePath))
{
await stream.CopyToAsync(fileStream);
}
}
//
using (var fileStream = File.OpenRead(cachedFilePath))
using (MemoryStream memStream = new MemoryStream())
{
// load stream into SKBitmap
await fileStream.CopyToAsync(memStream);
memStream.Seek(0, SeekOrigin.Begin);
var bitmap = SKBitmap.Decode(memStream);
// create a dictionary to keep track of the color that is used the most
var colors = new Dictionary <SKColor, int>();
for (int x = 0; x < bitmap.Width; x++)
{
for (int y = 0; y < bitmap.Height; y++)
{
// get the pixel
SKColor color = bitmap.GetPixel(x, y);
if (colors.ContainsKey(color))
{
// Found the same color again, bump it
colors[color]++;
}
else
{
// new color found, give it its own entry
colors.Add(color, 1);
}
}
}
// Use LINQ to find the most prevenlent color
SKColor mostCommonColor = colors.Aggregate((left, right) => left.Value > right.Value ? left : right).Key;
// Convert it for use in Xamarin.Forms
return(mostCommonColor.ToFormsColor());
};
}
catch (Exception ex)
{
Crashes.TrackError(ex, new Dictionary <string, string>
{
{ "Location", "Helpers" },
{ "Method", "CalculateBackgroundColorAsync" },
{ "Speaker", speaker.Name }
});
return(Xamarin.Forms.Color.FromHex("#AA000000"));
}
}
protected internal void SetAuthor(Speaker author)
{
Author = author ?? throw new ArgumentNullException(nameof(author));
}
public void SpeakerC()
{ //default voice
uidSpeakerC = Speaker.SpeakNative(textC, Speaker.VoiceForCulture("en", 2), RateSpeakerC);
}
public override async Task LoadDataAsync(string conferenceName, Stream fileStream, ApplicationDbContext db)
{
var reader = new JsonTextReader(new StreamReader(fileStream));
var conference = new Conference {
Name = conferenceName
};
var speakerNames = new Dictionary <string, Speaker>();
var tracks = new Dictionary <string, Track>();
JArray doc = await JArray.LoadAsync(reader);
foreach (JObject item in doc)
{
var theseSpeakers = new List <Speaker>();
foreach (var thisSpeakerName in item["speakerNames"])
{
if (!speakerNames.ContainsKey(thisSpeakerName.Value <string>()))
{
var thisSpeaker = new Speaker {
Name = thisSpeakerName.Value <string>()
};
db.Speakers.Add(thisSpeaker);
speakerNames.Add(thisSpeakerName.Value <string>(), thisSpeaker);
Console.WriteLine(thisSpeakerName.Value <string>());
}
theseSpeakers.Add(speakerNames[thisSpeakerName.Value <string>()]);
}
var theseTracks = new List <Track>();
foreach (var thisTrackName in item["trackNames"])
{
if (!tracks.ContainsKey(thisTrackName.Value <string>()))
{
var thisTrack = new Track {
Name = thisTrackName.Value <string>(), Conference = conference
};
db.Tracks.Add(thisTrack);
tracks.Add(thisTrackName.Value <string>(), thisTrack);
}
theseTracks.Add(tracks[thisTrackName.Value <string>()]);
}
var session = new Session
{
Conference = conference,
Title = item["title"].Value <string>(),
StartTime = item["startTime"].Value <DateTime>(),
EndTime = item["endTime"].Value <DateTime>(),
Track = theseTracks[0],
Abstract = item["abstract"].Value <string>()
};
session.SessionSpeakers = new List <SessionSpeaker>();
foreach (var sp in theseSpeakers)
{
session.SessionSpeakers.Add(new SessionSpeaker
{
Session = session,
Speaker = sp
});
}
db.Sessions.Add(session);
}
}
private void Button_Click(object sender, RoutedEventArgs e)
{
Button b = (Button)sender;
string _btnContent = b.Content.ToString();
Thread t = new Thread(new ThreadStart(() => {
App.Current.Dispatcher.Invoke(new Action(() => {
b.Background = Brushes.Lime;
b.IsEnabled = false;
}));
GlobalData.camera.Close();
bool ret = false;
string message = "";
//CONNECT TO CAMERA
switch (GlobalData.initSetting.station)
{
case "PCBA-LAYER2":
case "PCBA-LAYER3": {
//open IP camera uart port
ret = GlobalData.camera.Open(out message);
break;
}
case "SAU-DONG-VO": {
//Connect to IP camera
ret = GlobalData.camera.Connection(ref message);
ret = GlobalData.camera.LoginToCamera(ref message);
break;
}
}
//MANUAL CHECK
switch (_btnContent)
{
//MAC ADDRESS
case "ĐỌC MAC TỪ IP CAMERA": {
GlobalData.manualData.mac_manuallog = "";
GlobalData.testingDataDUT.CAMERALOG = "";
if (!ret)
{
GlobalData.manualData.mac_manuallog += "Không thể kết nối tới IP Camera.\r\n";
GlobalData.manualData.mac_manuallog += "Kết thúc.\r\n";
MessageBox.Show("Finished.", "Check MAC", MessageBoxButton.OK, MessageBoxImage.Error);
break;
}
GlobalData.manualData.mac_manuallog += "Connect to IP Camera success.\r\n";
GlobalData.manualData.mac_manuallog += "Địa chỉ MAC trên tem......................\r\n";
App.Current.Dispatcher.Invoke(new Action(() => {
GlobalData.manualData.mac_manuallog += txtMACout.Text + "\r\n";
txtMACin.Clear();
MACResult.Content = "--";
}));
GlobalData.manualData.mac_manuallog += "Gửi lệnh đọc địa chỉ MAC..................\r\n";
GlobalData.camera.WriteLine("ifconfig");
Thread.Sleep(1000);
string data = GlobalData.initSetting.station == "SAU-DONG-VO" ? GlobalData.camera.Read0() : GlobalData.testingDataDUT.CAMERALOG;
GlobalData.manualData.mac_manuallog += string.Format("{0}\r\n", data);
string _macincamera = "";
if (!data.Contains("eth0") || !data.Contains("lo"))
{
GlobalData.manualData.mac_manuallog += "Dữ liệu đọc về sai định dạng.\r\n";
GlobalData.manualData.mac_manuallog += "Kết thúc.\r\n";
MessageBox.Show("Finished.", "Check MAC", MessageBoxButton.OK, MessageBoxImage.Error);
break;
}
else
{
data = data.Split(new string[] { "eth0" }, StringSplitOptions.None)[1];
data = data.Split(new string[] { "lo" }, StringSplitOptions.None)[0];
data = data.Split(new string[] { "Link encap:Ethernet HWaddr" }, StringSplitOptions.None)[1];
data = data.Trim();
_macincamera = data.Substring(0, 17).Trim();
App.Current.Dispatcher.Invoke(new Action(() => {
txtMACin.Text = _macincamera.Replace(":", "");
}));
GlobalData.manualData.mac_manuallog += string.Format("\r\n\r\nĐỊA CHỈ MAC ĐỌC VỀ TỪ IP CAMERA: {0}\r\n", _macincamera);
GlobalData.manualData.mac_manuallog += "So sánh địa chỉ MAC.......................\r\n";
App.Current.Dispatcher.Invoke(new Action(() => {
ret = txtMACin.Text == txtMACout.Text;
MACResult.Content = ret == true ? "PASS" : "FAIL";
}));
GlobalData.manualData.mac_manuallog += string.Format("{0}\r\n", ret == true ? "PASS" : "FAIL");
GlobalData.manualData.mac_manuallog += "Kết thúc.\r\n";
MessageBox.Show("Finished.", "Check MAC", MessageBoxButton.OK, MessageBoxImage.Information);
}
break;
}
//CHECK WIFI
case "KIỂM TRA KẾT NỐI WIFI": {
GlobalData.manualData.wifi_manuallog = "";
ret = false;
try {
App.Current.Dispatcher.Invoke(new Action(() => {
WIFIResult.Content = "--";
}));
GlobalData.manualData.wifi_manuallog += "\r\nKIỂM TRA KẾT NỐI WIFI CỦA IP CAMERA >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\r\n";
GlobalData.manualData.wifi_manuallog += string.Format("Phần mềm gửi lệnh: ifconfig eth0 down \r\n");
GlobalData.testingDataDUT.CAMERALOG = "";
GlobalData.camera.WriteLine("ifconfig eth0 down");
GlobalData.manualData.wifi_manuallog += "Delay 1000 ms \r\n";
Thread.Sleep(1000);
GlobalData.manualData.wifi_manuallog += "CAMERA Feedback:\r\n" + GlobalData.testingDataDUT.CAMERALOG + "\r\n";
GlobalData.manualData.wifi_manuallog += string.Format("Phần mềm gửi lệnh: nm_cfg client IPCAM-Test-1 \r\n");
GlobalData.testingDataDUT.CAMERALOG = "";
App.Current.Dispatcher.Invoke(new Action(() => {
GlobalData.camera.WriteLine(string.Format("nm_cfg client {0}", txtSSID.Text));
}));
GlobalData.manualData.wifi_manuallog += "Delay 1000 ms \r\n";
Thread.Sleep(1000);
GlobalData.manualData.wifi_manuallog += "CAMERA Feedback:\r\n" + GlobalData.testingDataDUT.CAMERALOG + "\r\n";
int count = 0;
REP:
GlobalData.manualData.wifi_manuallog += string.Format("Kiểm tra kết nối LẦN {0}\r\n", count);
count++;
GlobalData.manualData.wifi_manuallog += string.Format("Phần mềm gửi lệnh: nm_cfg status \r\n");
GlobalData.camera.WriteLine("nm_cfg status");
GlobalData.testingDataDUT.CAMERALOG = "";
GlobalData.manualData.wifi_manuallog += "Delay 500 ms \r\n";
Thread.Sleep(500);
GlobalData.manualData.wifi_manuallog += "CAMERA Feedback:\r\n" + GlobalData.testingDataDUT.CAMERALOG + "\r\n";
ret = GlobalData.testingDataDUT.UARTLOG.Contains("status = connect");
if (!ret)
{
if (count < 20)
{
Thread.Sleep(500);
goto REP;
}
}
GlobalData.manualData.wifi_manuallog += string.Format("KẾT QUẢ KIỂM TRA WIFI: {0}\r\n", ret == true ? "PASS" : "FAIL");
App.Current.Dispatcher.Invoke(new Action(() => {
WIFIResult.Content = ret == true ? Parameters.testStatus.PASS.ToString() : Parameters.testStatus.FAIL.ToString();
}));
MessageBox.Show("Finished.", "Check WIFI", MessageBoxButton.OK, ret == true ? MessageBoxImage.Information : MessageBoxImage.Error);
}
catch (Exception ex) {
App.Current.Dispatcher.Invoke(new Action(() => {
WIFIResult.Content = Parameters.testStatus.FAIL.ToString();
}));
GlobalData.manualData.wifi_manuallog += ex.ToString() + "\r\n";
GlobalData.manualData.wifi_manuallog += string.Format("KẾT QUẢ KIỂM TRA WIFI: FAIL\r\n");
MessageBox.Show("Finished.", "Check WIFI", MessageBoxButton.OK, MessageBoxImage.Error);
}
break;
}
//CHECK SD CARD
case "KIỂM TRA SD CARD": {
GlobalData.manualData.sdcard_manuallog = "";
ret = false;
GlobalData.testingDataDUT.CAMERALOG = "";
try {
App.Current.Dispatcher.Invoke(new Action(() => {
SDCardResult.Content = "--";
}));
GlobalData.manualData.sdcard_manuallog += "\r\nKIỂM TRA THẺ NHỚ SD CARD CỦA IP CAMERA >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\r\n";
int count = 0;
REP:
count++;
GlobalData.manualData.sdcard_manuallog += string.Format("Phần mềm gửi lệnh: mount LẦN {0}\r\n", count);
string data = "";
GlobalData.camera.WriteLine("mount");
GlobalData.manualData.sdcard_manuallog += "Delay 1000 ms \r\n";
Thread.Sleep(1000);
data = GlobalData.initSetting.station == "SAU-DONG-VO" ? GlobalData.camera.Read0() : GlobalData.testingDataDUT.CAMERALOG;
GlobalData.manualData.sdcard_manuallog += "CAMERA Feedback:\r\n" + data + "\r\n";
ret = data.Contains("/dev/mmcblk0p1 on /media/sdcard type vfat (rw,relatime,fmask=0000,dmask=0000");
if (!ret)
{
if (count < 5)
{
Thread.Sleep(1000);
goto REP;
}
}
App.Current.Dispatcher.Invoke(new Action(() => {
SDCardResult.Content = ret == true ? Parameters.testStatus.PASS.ToString() : Parameters.testStatus.FAIL.ToString();
}));
GlobalData.manualData.sdcard_manuallog += string.Format("KẾT QUẢ KIỂM TRA THẺ NHỚ SD card: {0}\r\n", ret == true ? "PASS" : "FAIL");
MessageBox.Show("Finished.", "Check SDCard", MessageBoxButton.OK, ret == true ? MessageBoxImage.Information : MessageBoxImage.Error);
}
catch (Exception ex) {
GlobalData.manualData.sdcard_manuallog += ex.ToString() + "\r\n";
GlobalData.manualData.sdcard_manuallog += string.Format("KẾT QUẢ KIỂM TRA THẺ NHỚ SD card: FAIL\r\n");
App.Current.Dispatcher.Invoke(new Action(() => {
SDCardResult.Content = Parameters.testStatus.FAIL.ToString();
}));
MessageBox.Show("Finished.", "Check SDCard", MessageBoxButton.OK, MessageBoxImage.Error);
}
break;
}
//CHECK LAN
case "KIỂM TRA CỔNG LAN": {
GlobalData.manualData.lan_manuallog = "";
ret = false;
GlobalData.testingDataDUT.CAMERALOG = "";
try {
App.Current.Dispatcher.Invoke(new Action(() => {
LANResult.Content = "--";
}));
GlobalData.manualData.lan_manuallog += "\r\nKIỂM TRA CỔNG LAN CỦA IP CAMERA >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\r\n";
GlobalData.manualData.lan_manuallog += "Phần mềm gửi lệnh: ifconfig eth0 up\r\n";
GlobalData.testingDataDUT.CAMERALOG = "";
GlobalData.camera.WriteLine("ifconfig eth0 up");
GlobalData.manualData.lan_manuallog += "Delay 500 ms\r\n";
Thread.Sleep(500);
GlobalData.manualData.lan_manuallog += "CAMERA Feedback:\r\n" + GlobalData.testingDataDUT.CAMERALOG + "\r\n";
GlobalData.testingDataDUT.CAMERALOG = "";
GlobalData.manualData.lan_manuallog += "Phần mềm gửi lệnh: ping -c 4 192.168.1.100\r\n";
GlobalData.camera.WriteLine("ping -c 4 192.168.1.100");
GlobalData.manualData.lan_manuallog += "Delay 5000 ms\r\n";
Thread.Sleep(5000);
GlobalData.manualData.lan_manuallog += "CAMERA Feedback:\r\n" + GlobalData.testingDataDUT.CAMERALOG + "\r\n";
ret = GlobalData.testingDataDUT.CAMERALOG.Contains("64 bytes from 192.168.1.100:");
App.Current.Dispatcher.Invoke(new Action(() => {
LANResult.Content = ret == true ? Parameters.testStatus.PASS.ToString() : Parameters.testStatus.FAIL.ToString();
}));
GlobalData.manualData.lan_manuallog += string.Format("KẾT QUẢ KIỂM TRA CỔNG LAN: {0}\r\n", ret == true ? "PASS" : "FAIL");
MessageBox.Show("Finished.", "Check LAN", MessageBoxButton.OK, ret == true ? MessageBoxImage.Information : MessageBoxImage.Error);
}
catch (Exception ex) {
GlobalData.manualData.lan_manuallog += ex.ToString() + "\r\n";
GlobalData.manualData.lan_manuallog += string.Format("KẾT QUẢ KIỂM TRA CỔNG LAN: FAIL\r\n");
App.Current.Dispatcher.Invoke(new Action(() => {
LANResult.Content = Parameters.testStatus.FAIL.ToString();
}));
MessageBox.Show("Finished.", "Check LAN", MessageBoxButton.OK, MessageBoxImage.Error);
}
break;
}
//CHECK SPEAKER, MIC
case "THU ÂM VÀO CAMERA": {
GlobalData.manualData.audio_manuallog = "";
GlobalData.camera.WriteLine("\n");
GlobalData.manualData.audio_manuallog += "Phần mềm gửi lệnh: killall lark\r\n";
GlobalData.camera.WriteLine("killall lark");
Thread.Sleep(500);
GlobalData.manualData.audio_manuallog += "Gửi lệnh yêu cầu IP Camera thu âm:\r\n";
GlobalData.manualData.audio_manuallog += "arecord -D hw:0,1 /tmp/audio_record.wav & \r\n";
GlobalData.camera.WriteLine("arecord -D hw:0,1 /tmp/audio_record.wav &");
Thread.Sleep(500);
GlobalData.camera.WriteLine("\n");
GlobalData.manualData.audio_manuallog += "Máy tính phát âm thanh ra loa:\r\n";
Speaker speaker = new Speaker();
speaker.PlaySound(ref message);
Thread.Sleep(3000);
GlobalData.manualData.audio_manuallog += "delay 3000 ms\r\n";
GlobalData.manualData.audio_manuallog += "Phần mềm gửi lệnh dừng thu âm: killall arecord \r\n";
GlobalData.camera.WriteLine("killall arecord");
MessageBox.Show("Finished.", "Record Sound", MessageBoxButton.OK, MessageBoxImage.Information);
break;
}
case "PHÁT ÂM CỦA CAMERA": {
GlobalData.manualData.audio_manuallog = "";
GlobalData.manualData.audio_manuallog += "Gửi lệnh phát âm thanh ra loa IP Camera:\r\n";
GlobalData.manualData.audio_manuallog += "aplay - D hw: 0,1 / tmp / audio_record.wav\r\n";
GlobalData.camera.WriteLine("aplay -D hw:0,1 /tmp/audio_record.wav");
GlobalData.manualData.audio_manuallog += "delay 5000ms\r\n";
System.Threading.Thread.Sleep(4000);
MessageBox.Show("Finished.", "Play Sound", MessageBoxButton.OK, MessageBoxImage.Information);
break;
}
//CHECK IMAGE SENSOR
case "LIVE STREAM CAMERA": {
Process.Start("LiveCam\\LiveCamera.exe");
break;
}
//CHECK RGB LED
case "BẬT LED XANH": {
GlobalData.manualData.rgbled_manuallog = "";
GlobalData.manualData.rgbled_manuallog += "killall vnptledindicator\r\n";
GlobalData.camera.WriteLine("killall vnptledindicator");
GlobalData.manualData.rgbled_manuallog += "Delay 100ms\r\n";
Thread.Sleep(100);
GlobalData.manualData.rgbled_manuallog += "echo 1> /sys/devices/platform/pwm_platform/settings/pwm/request\r\n";
GlobalData.camera.WriteLine("echo 1> /sys/devices/platform/pwm_platform/settings/pwm/request");
GlobalData.manualData.rgbled_manuallog += "Delay 100ms\r\n";
Thread.Sleep(100);
GlobalData.manualData.rgbled_manuallog += "echo 1000000 > /sys/devices/platform/pwm_platform/settings/pwm1/duty_ns\r\n";
GlobalData.camera.WriteLine("echo 1000000 > /sys/devices/platform/pwm_platform/settings/pwm1/duty_ns");
GlobalData.manualData.rgbled_manuallog += "Delay 10ms\r\n";
Thread.Sleep(10);
GlobalData.manualData.rgbled_manuallog += "echo 1 > /sys/devices/platform/pwm_platform/settings/pwm1/enable\r\n";
GlobalData.camera.WriteLine("echo 1 > /sys/devices/platform/pwm_platform/settings/pwm1/enable");
GlobalData.manualData.rgbled_manuallog += "Delay 10ms\r\n";
Thread.Sleep(10);
GlobalData.manualData.rgbled_manuallog += "echo 0 > /sys/devices/platform/pwm_platform/settings/pwm2/duty_ns\r\n";
GlobalData.camera.WriteLine("echo 0 > /sys/devices/platform/pwm_platform/settings/pwm2/duty_ns");
GlobalData.manualData.rgbled_manuallog += "Delay 10ms\r\n";
Thread.Sleep(10);
GlobalData.manualData.rgbled_manuallog += "echo 1 > /sys/devices/platform/pwm_platform/settings/pwm2/enable\r\n";
GlobalData.camera.WriteLine("echo 1 > /sys/devices/platform/pwm_platform/settings/pwm2/enable");
GlobalData.manualData.rgbled_manuallog += "Delay 10ms\r\n";
Thread.Sleep(10);
MessageBox.Show("Finished.", "Turn on Green LED", MessageBoxButton.OK, MessageBoxImage.Information);
break;
}
case "BẬT LED ĐỎ": {
GlobalData.manualData.rgbled_manuallog = "";
GlobalData.manualData.rgbled_manuallog += "killall vnptledindicator\r\n";
GlobalData.camera.WriteLine("killall vnptledindicator");
GlobalData.manualData.rgbled_manuallog += "Delay 100ms\r\n";
Thread.Sleep(100);
GlobalData.manualData.rgbled_manuallog += "echo 1> /sys/devices/platform/pwm_platform/settings/pwm/request\r\n";
GlobalData.camera.WriteLine("echo 1> /sys/devices/platform/pwm_platform/settings/pwm/request");
GlobalData.manualData.rgbled_manuallog += "Delay 100ms\r\n";
Thread.Sleep(100);
GlobalData.manualData.rgbled_manuallog += "echo 1000000 > /sys/devices/platform/pwm_platform/settings/pwm2/duty_ns\r\n";
GlobalData.camera.WriteLine("echo 1000000 > /sys/devices/platform/pwm_platform/settings/pwm2/duty_ns");
GlobalData.manualData.rgbled_manuallog += "Delay 10ms\r\n";
Thread.Sleep(10);
GlobalData.manualData.rgbled_manuallog += "echo 1 > /sys/devices/platform/pwm_platform/settings/pwm2/enable\r\n";
GlobalData.camera.WriteLine("echo 1 > /sys/devices/platform/pwm_platform/settings/pwm2/enable");
GlobalData.manualData.rgbled_manuallog += "Delay 10ms\r\n";
Thread.Sleep(10);
GlobalData.manualData.rgbled_manuallog += "echo 0 > /sys/devices/platform/pwm_platform/settings/pwm1/duty_ns\r\n";
GlobalData.camera.WriteLine("echo 0 > /sys/devices/platform/pwm_platform/settings/pwm1/duty_ns");
GlobalData.manualData.rgbled_manuallog += "Delay 10ms\r\n";
Thread.Sleep(10);
GlobalData.manualData.rgbled_manuallog += "echo 1 > /sys/devices/platform/pwm_platform/settings/pwm1/enable\r\n";
GlobalData.camera.WriteLine("echo 1 > /sys/devices/platform/pwm_platform/settings/pwm1/enable");
GlobalData.manualData.rgbled_manuallog += "Delay 10ms\r\n";
Thread.Sleep(10);
MessageBox.Show("Finished.", "Turn on RED LED", MessageBoxButton.OK, MessageBoxImage.Information);
break;
}
//CHECK LIGHT SENSOR
case "KIỂM TRA MỨC SÁNG": {
GlobalData.manualData.lightsensor_manuallog = "";
App.Current.Dispatcher.Invoke(new Action(() => {
LightSensorResult.Content = "--";
txtADC.Clear();
}));
MessageBox.Show("VUI LÒNG KHÔNG CHE CẢM BIẾN ÁNH SÁNG.", "Check Light Sensor", MessageBoxButton.OK, MessageBoxImage.Warning);
GlobalData.manualData.lightsensor_manuallog += "Kiểm tra mức sáng:\r\n";
int count = 0;
REP:
count++;
GlobalData.testingDataDUT.CAMERALOG = "";
GlobalData.manualData.lightsensor_manuallog += "cat /sys/devices/platform/rts_saradc.0/in0_input";
GlobalData.camera.WriteLine("cat /sys/devices/platform/rts_saradc.0/in0_input");
Thread.Sleep(500);
GlobalData.manualData.lightsensor_manuallog += "delay 500ms";
string data = GlobalData.initSetting.station == "SAU-DONG-VO" ? GlobalData.camera.Read0() : GlobalData.testingDataDUT.CAMERALOG;
GlobalData.manualData.lightsensor_manuallog += string.Format("{0}\r\n", data);
data = data.Replace("\r", "").Replace("\n", "").Trim();
data = data.Replace("cat /sys/devices/platform/rts_saradc.0/in0_input", "");
data = data.Replace("~ #", "");
App.Current.Dispatcher.Invoke(new Action(() => {
txtADC.Text = data;
}));
ret = int.Parse(data) > int.Parse(GlobalData.initSetting.adcvalue);
if (!ret)
{
if (count < 10)
{
Thread.Sleep(1000);
goto REP;
}
}
App.Current.Dispatcher.Invoke(new Action(() => {
LightSensorResult.Content = ret == true ? Parameters.testStatus.PASS.ToString() : Parameters.testStatus.FAIL.ToString();
}));
GlobalData.manualData.lightsensor_manuallog += string.Format("KẾT QUẢ KIỂM TRA MỨC SÁNG LIGHT SENSOR: {0}\r\n", ret == true ? "PASS" : "FAIL");
MessageBox.Show("Finished.", "Check Light Sensor", MessageBoxButton.OK, ret == true ? MessageBoxImage.Information : MessageBoxImage.Error);
break;
}
case "KIỂM TRA MỨC TỐI": {
GlobalData.manualData.lightsensor_manuallog = "";
App.Current.Dispatcher.Invoke(new Action(() => {
LightSensorResult.Content = "--";
txtADC.Clear();
}));
MessageBox.Show("VUI LÒNG CHE CẢM BIẾN ÁNH SÁNG.", "Check Light Sensor", MessageBoxButton.OK, MessageBoxImage.Warning);
GlobalData.manualData.lightsensor_manuallog += "Kiểm tra mức tối:\r\n";
int count = 0;
REP:
count++;
GlobalData.testingDataDUT.CAMERALOG = "";
GlobalData.manualData.lightsensor_manuallog += "cat /sys/devices/platform/rts_saradc.0/in0_input";
GlobalData.camera.WriteLine("cat /sys/devices/platform/rts_saradc.0/in0_input");
Thread.Sleep(500);
GlobalData.manualData.lightsensor_manuallog += "delay 500ms";
string data = GlobalData.initSetting.station == "SAU-DONG-VO" ? GlobalData.camera.Read0() : GlobalData.testingDataDUT.CAMERALOG;
GlobalData.manualData.lightsensor_manuallog += string.Format("{0}\r\n", data);
data = data.Replace("\r", "").Replace("\n", "").Trim();
data = data.Replace("cat /sys/devices/platform/rts_saradc.0/in0_input", "");
data = data.Replace("~ #", "");
App.Current.Dispatcher.Invoke(new Action(() => {
txtADC.Text = data;
}));
ret = int.Parse(data) < int.Parse(GlobalData.initSetting.adcvalue);
if (!ret)
{
if (count < 10)
{
Thread.Sleep(1000);
goto REP;
}
}
App.Current.Dispatcher.Invoke(new Action(() => {
LightSensorResult.Content = ret == true ? Parameters.testStatus.PASS.ToString() : Parameters.testStatus.FAIL.ToString();
}));
GlobalData.manualData.lightsensor_manuallog += string.Format("KẾT QUẢ KIỂM TRA MỨC TỐI LIGHT SENSOR: {0}\r\n", ret == true ? "PASS" : "FAIL");
MessageBox.Show("Finished.", "Check Light Sensor", MessageBoxButton.OK, ret == true ? MessageBoxImage.Information : MessageBoxImage.Error);
break;
}
//CHECK BUTTON
case "KIỂM TRA NÚT NHẤN IP CAMERA": {
GlobalData.manualData.button_manuallog = "";
App.Current.Dispatcher.Invoke(new Action(() => {
ButtonResult.Content = "--";
}));
GlobalData.manualData.button_manuallog += "\r\nKIỂM TRA NÚT BẤM CỦA IP CAMERA >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\r\n";
GlobalData.manualData.button_manuallog += string.Format("Đang chờ người dùng thực hiện nhấn nút bấm... \r\n");
GlobalData.testingDataDUT.CAMERALOG = "";
int count = 0;
REP:
count++;
GlobalData.manualData.button_manuallog += string.Format("Thời gian chờ {0} s ... \r\n", count);
GlobalData.manualData.button_manuallog += "CAMERA Feedback:\r\n" + GlobalData.testingDataDUT.CAMERALOG + "\r\n";
ret = GlobalData.testingDataDUT.UARTLOG.Contains("time_process = 0") || GlobalData.testingDataDUT.UARTLOG.Contains("time_process = 1");
if (!ret)
{
if (count <= 30)
{
Thread.Sleep(1000);
goto REP;
}
}
GlobalData.manualData.button_manuallog += string.Format("KẾT QUẢ KIỂM TRA NÚT BẤM: {0}\r\n", ret == true ? "PASS" : "FAIL");
App.Current.Dispatcher.Invoke(new Action(() => {
ButtonResult.Content = ret == true ? Parameters.testStatus.PASS.ToString() : Parameters.testStatus.FAIL.ToString();
}));
MessageBox.Show("Finished.", "Check Button", MessageBoxButton.OK, ret == true ? MessageBoxImage.Information : MessageBoxImage.Error);
break;
}
//UPLOAD FW
case "UPLOAD FIRMWARE": {
GlobalData.manualData.fw_manuallog = "";
App.Current.Dispatcher.Invoke(new Action(() => {
UploadFWResult.Content = "--";
}));
int count = 0, _max = 200;
REP:
//Access to uboot (timeout = 20s)
GlobalData.manualData.fw_manuallog += "Đang chờ thiết bị khởi động...\r\n";
count++;
ret = GlobalData.testingDataDUT.CAMERALOG.Contains("Hit any key to stop autoboot:");
if (!ret)
{
if (count < _max)
{
Thread.Sleep(100);
goto REP;
}
GlobalData.manualData.fw_manuallog += "Không đăng nhập được vào uboot\r\n";
break;
}
GlobalData.testingDataDUT.CAMERALOG = "";
GlobalData.manualData.fw_manuallog += "\r\nĐANG NẠP FIRMWARE CHO IP CAMERA >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\r\n";
int _count = 0, _timeout = 90;
string _cmdPath = string.Format("{0}UPLOAD\\cmd.txt", System.AppDomain.CurrentDomain.BaseDirectory);
string _wpsPath = string.Format("{0}UPLOAD\\wps.txt", System.AppDomain.CurrentDomain.BaseDirectory);
string _runPath = string.Format("{0}UPLOAD\\RunPowerShell.exe", System.AppDomain.CurrentDomain.BaseDirectory);
//Set IP Camera ve che do Upload FW
GlobalData.testingDataDUT.CAMERALOG = "";
GlobalData.manualData.fw_manuallog += "Phần mềm gửi lệnh: setipaddr 192.168.1.253 \r\n";
GlobalData.camera.WriteLine("setipaddr 192.168.1.253");
GlobalData.manualData.fw_manuallog += "Delay 500 ms\r\n";
Thread.Sleep(500);
GlobalData.manualData.fw_manuallog += "CAMERA Feedback:\r\n" + GlobalData.testingDataDUT.CAMERALOG + "\r\n";
GlobalData.testingDataDUT.CAMERALOG = "";
GlobalData.manualData.fw_manuallog += "Phần mềm gửi lệnh: saveenv\r\n";
GlobalData.camera.WriteLine("saveenv");
GlobalData.manualData.fw_manuallog += "Delay 500 ms\r\n";
Thread.Sleep(500);
GlobalData.manualData.fw_manuallog += "CAMERA Feedback:\r\n" + GlobalData.testingDataDUT.CAMERALOG + "\r\n";
GlobalData.manualData.fw_manuallog += "Phần mềm gửi lệnh: update all\r\n";
GlobalData.camera.WriteLine("update all");
GlobalData.manualData.fw_manuallog += "Delay 1000 ms\r\n";
Thread.Sleep(1000);
GlobalData.manualData.fw_manuallog += "Đang chờ client gửi FIRMWARE lên thiết bị......\r\n";
//Upload file linux.bin
//********************************************//
//1. Set đường dẫn file FW
File.WriteAllText(_cmdPath, string.Format("tftp -i 192.168.1.253 put {0}", GlobalData.initSetting.linuxpath));
Thread.Sleep(100);
Process.Start(_runPath);
GlobalData.testingDataDUT.CAMERALOG = "";
REP1:
_count++;
ret = GlobalData.testingDataDUT.CAMERALOG.Contains("update all done");
if (!ret)
{
GlobalData.manualData.fw_manuallog += string.Format("Chờ {0}s\r\n", _count);
if (_count < _timeout)
{
Thread.Sleep(1000);
goto REP1;
}
}
GlobalData.manualData.fw_manuallog += "CAMERA Feedback: \r\n" + GlobalData.testingDataDUT.CAMERALOG + "\r\n";
GlobalData.manualData.fw_manuallog += string.Format("KẾT QUẢ UPLOAD FILE linux.bin: {0}\r\n", ret == true ? "PASS" : "FAIL");
//Upload file mcu.bin
//********************************************//
GlobalData.manualData.fw_manuallog += "Phần mềm gửi lệnh: update fw\r\n";
GlobalData.camera.WriteLine("update fw");
GlobalData.manualData.fw_manuallog += "Delay 1000 ms\r\n";
Thread.Sleep(1000);
GlobalData.manualData.fw_manuallog += "Đang chờ client gửi FIRMWARE lên thiết bị......\r\n";
File.WriteAllText(_cmdPath, string.Format("tftp -i 192.168.1.253 put {0}", GlobalData.initSetting.mcupath));
Thread.Sleep(100);
Process.Start(_runPath);
GlobalData.testingDataDUT.CAMERALOG = "";
_count = 0;
REP2:
_count++;
ret = GlobalData.testingDataDUT.CAMERALOG.Contains("update fw done");
if (!ret)
{
if (_count < _timeout)
{
GlobalData.manualData.fw_manuallog += string.Format("Chờ {0}s\r\n", _count);
Thread.Sleep(1000);
goto REP2;
}
}
GlobalData.manualData.fw_manuallog += "CAMERA Feedback: \r\n" + GlobalData.testingDataDUT.CAMERALOG + "\r\n";
GlobalData.manualData.fw_manuallog += string.Format("KẾT QUẢ UPLOAD FILE mcu.bin: {0}\r\n", ret == true ? "PASS" : "FAIL");
//Upload file ldc.bin
//********************************************//
GlobalData.manualData.fw_manuallog += "Phần mềm gửi lệnh: update ldc\r\n";
GlobalData.camera.WriteLine("update ldc");
GlobalData.manualData.fw_manuallog += "Delay 1000 ms\r\n";
Thread.Sleep(1000);
GlobalData.manualData.fw_manuallog += "Đang chờ client gửi FIRMWARE lên thiết bị......\r\n";
File.WriteAllText(_cmdPath, string.Format("tftp -i 192.168.1.253 put {0}", GlobalData.initSetting.ldcpath));
Thread.Sleep(100);
Process.Start(_runPath);
GlobalData.testingDataDUT.CAMERALOG = "";
_count = 0;
REP3:
_count++;
ret = GlobalData.testingDataDUT.CAMERALOG.Contains("update ldc done");
if (!ret)
{
if (_count < _timeout)
{
GlobalData.manualData.fw_manuallog += string.Format("Chờ {0}s\r\n", _count);
Thread.Sleep(1000);
goto REP3;
}
}
GlobalData.manualData.fw_manuallog += "CAMERA Feedback: \r\n" + GlobalData.testingDataDUT.CAMERALOG + "\r\n";
GlobalData.manualData.fw_manuallog += string.Format("KẾT QUẢ UPLOAD FILE ldc.bin: {0}\r\n", ret == true ? "PASS" : "FAIL");
GlobalData.manualData.fw_manuallog += string.Format("KẾT QUẢ UPLOAD FIRMWARE: {0}\r\n", ret == true ? "PASS" : "FAIL");
App.Current.Dispatcher.Invoke(new Action(() => {
UploadFWResult.Content = ret == true ? Parameters.testStatus.PASS.ToString() : Parameters.testStatus.FAIL.ToString();
}));
MessageBox.Show("Finished.", "Upload Firmware", MessageBoxButton.OK, ret == true ? MessageBoxImage.Information : MessageBoxImage.Error);
break;
}
}
GlobalData.camera.Close();
App.Current.Dispatcher.Invoke(new Action(() => {
b.Background = (SolidColorBrush) new BrushConverter().ConvertFrom("#FF039BE5");
b.IsEnabled = true;
}));
}));
t.IsBackground = true;
t.Start();
}
protected override void ExecuteCore(CarSignalInfo signalInfo)
{
if (!IsLoudSpeakerCheck && signalInfo.Sensor.Loudspeaker)
{
IsLoudSpeakerCheck = true;
}
//过滤10m
//准备距离0 处理
if (!isOverPrepareDistance && Settings.OvertakePrepareDistance > 0)
{
//超车10米后才评判
if (signalInfo.Distance - StartDistance < Settings.OvertakePrepareDistance)
{
return;
}
if (signalInfo.BearingAngle.IsValidAngle())
{
isOverPrepareDistance = true;
StartAngle = signalInfo.BearingAngle;
}
return;
}
//检测是否超速
//检测打错灯，一进入就打右转
//if (OvertakeStepState == OvertakeStep.None && !IsCheckedOvertakeLeftLight)
//{
// //超车，左转向灯,或者右灯判错
// if (signalInfo.Sensor.RightIndicatorLight)
// {
// IsCheckedOvertakeLeftLight = true;
// CheckRule(true, DeductionRuleCodes.RC30205, DeductionRuleCodes.SRC3020504);
// }
//}
//TODO：以前有部分客户反馈是会2扣分得。原因不明。不知道是不是信号不稳定影响得。有时间可以打开在多次测试 2018.04.22 鲍君
if (IsCheckOverSpeed == false && ((Settings.OvertakeSpeedLimit > 0 && signalInfo.SpeedInKmh > Settings.OvertakeSpeedLimit) ||
(Settings.OvertakeLowestSpeed > 0 && signalInfo.SpeedInKmh < Settings.OvertakeLowestSpeed)))
{
IsCheckOverSpeed = true;
CheckRule(true, DeductionRuleCodes.RC30116);
}
//达到一次速度
if (Settings.OvertakeSpeedOnce > 10)
{
if (signalInfo.SpeedInKmh > Settings.OvertakeSpeedOnce)
{
_reachSpeedSet.Enqueue(signalInfo.SpeedInKmh);
}
if (_reachSpeedSet.Count > 30)
{
_reachSpeedSet.Dequeue();
}
}
//检测是否低于规定速度
//Logger.InfoFormat("OverTakeTest {0}", OvertakeStepState.ToString());
//检测开始超车转向角度
//如果角度大于0
if (Settings.OvertakeChangeLanesAngle > 0)
{
if (OvertakeStepState == OvertakeStep.None)
{
if (signalInfo.BearingAngle.IsValidAngle() &&
!GeoHelper.IsBetweenDiffAngle(signalInfo.BearingAngle, StartAngle, Settings.OvertakeChangeLanesAngle))
{
//设置开始变道时的距离(由于评判转向灯太快，所以延后大概1秒)
if (!StartChangingLanesDistance.HasValue)
{
StartChangingLanesDistance = signalInfo.Distance;
}
//变道摆正10米后才开始评判
//if (signalInfo.Distance - StartChangingLanesDistance.Value < 10)
//{
// return;
//}
//设置开始变道时的距离
OvertakeStepState = OvertakeStep.StartChangeLanesToLeft;
//动方向就要评判那个额喇叭
if (!IsLoudSpeakerCheck)
{
if (Settings.OvertakeLoudSpeakerNightCheck && Context.ExamTimeMode == ExamTimeMode.Night)
{
BreakRule(DeductionRuleCodes.RC30212);
}
if (Settings.OvertakeLoudSpeakerDayCheck && Context.ExamTimeMode == ExamTimeMode.Day)
{
BreakRule(DeductionRuleCodes.RC30212);
}
}
if (Settings.OvertakeLightCheck && !IsCheckedOvertakeLeftLight)
{
IsCheckedOvertakeLeftLight = true;
//超车，左转向灯,或者右灯判错
if (!CarSignalSet.Query(StartTime).Any(d => d.Sensor.LeftIndicatorLight))
{
CheckRule(true, DeductionRuleCodes.RC30205, DeductionRuleCodes.SRC3020504);
}
else
{
if (!AdvancedSignal.CheckOperationAheadSeconds(x => x.Sensor.LeftIndicatorLight, StartTime, Settings.TurnLightAheadOfTime))
{
BreakRule(DeductionRuleCodes.RC30206, DeductionRuleCodes.SRC3020604);
}
}
}
//判断一下是否有点客户不需要返回原车道
}
}
else if (OvertakeStepState == OvertakeStep.StartChangeLanesToLeft)
{
//当开始变道后向前行驶15米则认为变道成功
if (signalInfo.Distance - StartChangingLanesDistance >= OvertakeChangingLanesSuccessOrBackToOriginalLanceDistance &&
signalInfo.BearingAngle.IsValidAngle())
{
//路径
//
OvertakeStepState = OvertakeStep.EndChangeLanesToLeft;
StartChangeLanesAngle = signalInfo.BearingAngle;
//如果设置了不需要返回原车道
if (!Settings.OvertakeBackToOriginalLane)
{
OvertakeStepState = OvertakeStep.EndChangeLanesToRight;
}
else
{
Speaker.PlayAudioAsync(Settings.OvertakeBackToOriginalLaneVocie);
}
}
}
else if (OvertakeStepState == OvertakeStep.EndChangeLanesToLeft)
{
if (signalInfo.BearingAngle.IsValidAngle() && !GeoHelper.IsBetweenDiffAngle(signalInfo.BearingAngle, StartChangeLanesAngle, Settings.OvertakeChangeLanesAngle))
{
OvertakeStepState = OvertakeStep.EndChangeLanesToRight;
if (Settings.OvertakeLightCheck && !IsCheckedOvertakeRightLight)
{
IsCheckedOvertakeRightLight = true;
if (!CarSignalSet.Query(StartTime).Any(d => d.Sensor.RightIndicatorLight))
{
BreakRule("302071");
}
else
{
if (!AdvancedSignal.CheckOperationAheadSeconds(x => x.Sensor.RightIndicatorLight, StartTime, Settings.TurnLightAheadOfTime))
{
BreakRule("302081");
}
}
}
}
}
else if (OvertakeStepState == OvertakeStep.EndChangeLanesToRight)
{
//结束考试项目
//StopCore();
IsSuccess = true;
return;
}
}
else
{
//表示客户其实只关心打灯问题
//简单的处理 如果打右转灯之前没有打过左转灯则扣分
if (signalInfo.Sensor.RightIndicatorLight && !IsCheckedOvertakeLeftLight)
{
//如果没有打左转灯就扣分
if (!AdvancedSignal.CheckOperationAheadSeconds(x => x.Sensor.LeftIndicatorLight, StartTime, Settings.TurnLightAheadOfTime))
{
//CheckRule(true, DeductionRuleCodes.RC30205, DeductionRuleCodes.SRC3020504);
//只有泸州版本才这样
//todo:之所以不分出来 是觉得其实全国所有的版本都可以这样做
BreakRule(DeductionRuleCodes.RC30205, DeductionRuleCodes.SRC3020506);
IsCheckedOvertakeLeftLight = true;
}
}
IsSuccess = true;
}
base.ExecuteCore(signalInfo);
}
public async Task <IActionResult> Create([Bind("ID,MeetingDate,Conductor,OpeningHymn,Invocation,SacramentHymn,ClosingHymn,Benediction,Notes")] Meeting meeting, Speaker speaker)
{
if (ModelState.IsValid)
{
_context.Add(meeting);
speaker.Name = Request.Form["Name"];
_context.AddRange(speaker);
SpeakingAssignment topic = new SpeakingAssignment();
topic.Topic = Request.Form["Topic"];
topic.MeetingID = meeting.ID;
topic.SpeakerID = speaker.ID;
_context.AddRange(topic);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(meeting));
}
/// <summary>
/// 特殊要求：灯光完成后5秒才能报起步（泸州）
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
protected override async Task StartExamAsync(ExamContext context)
{
if (!context.IsExaming)
{
return;
}
//启用绕车一周 to 在车上进行验证探头
if (Settings.PrepareDrivingEnable)
{
var prepareTask = StartExamItemAutoAsync(context, ExamItemCodes.PrepareDriving);
await prepareTask;
await Task.Run(() =>
{
while (context.IsExaming && prepareTask.Result.State != ExamItemState.Finished)
{
Thread.Sleep(100);
}
});
}
await StartExamItemAutoAsync(context, ExamItemCodes.CommonExamItem);
if (!context.IsExaming)
{
Logger.Debug("考试结束:context.IsExaming");
return;
}
//上车准备完成之后就启动灯光模拟
//吉首白天夜间都要灯光模拟
if (context.ExamTimeMode == ExamTimeMode.Day && Settings.SimulationsLightOnDay ||
context.ExamTimeMode == ExamTimeMode.Night && Settings.SimulationsLightOnNight)
{
Speaker.CancelAllAsync(false);
while (SignalSet.Current == null)
{
Thread.Sleep(100);
}
if (SignalSet.Current != null && !SignalSet.Current.Sensor.Engine)
{
if (Settings.CommonExambeforeSimionLightStartEngine)
{
Speaker.PlayAudioAsync(Settings.CommonExambeforeSimionLightStartEngineVoice);
}
}
while (!(SignalSet.Current != null && SignalSet.Current.Sensor.Engine) && Settings.CommonExambeforeSimionLightStartEngine)
{
//如果启动要扣分
Thread.Sleep(100);
}
//打火黑屏延时启动灯光模拟
if (Settings.CommonExambeforeSimionLightStartEngine && Settings.CommonStartEngineDeleyTime > 0)
{
await Task.Run(() =>
{
int delaytime = Settings.CommonStartEngineDeleyTime * 1000;
Thread.Sleep(delaytime);
});
}
//等待关闭发动机
var lightTask = StartExamItemAutoAsync(context, ExamItemCodes.Light);
await lightTask;
await Task.Run(() =>
{
while (context.IsExaming && lightTask.Result.State != ExamItemState.Finished)
{
Thread.Sleep(100);
}
});
}
if (!context.IsExaming)
{
Logger.Debug("考试结束:context.IsExaming");
return;
}
//TODO:可以考虑做成配置 决定综合评判启动的位置
await Task.Run(() => {
//等待5秒才能启动起步
Thread.Sleep(3000);
});
await StartExamItemAutoAsync(context, ExamItemCodes.Start);
}
Boolean CanSpeakerSelectedCommand(Speaker speaker)
{
return(speaker != null);
}
public Speaker UpdateSpeaker(Speaker speaker)
{
return(context.Update(speaker).Entity);
}
public void StartTTS()
{
Speaker.SpeakNative(SpeechText, Speaker.VoiceForCulture("en", 1));
}
public override async Task LoadDataAsync(string conferenceName, Stream fileStream, ApplicationDbContext db)
{
//var blah = new RootObject().rooms[0].sessions[0].speakers[0].name;
var addedSpeakers = new Dictionary <string, Speaker>();
var addedTracks = new Dictionary <string, Track>();
var addedTags = new Dictionary <string, Tag>();
var array = await JToken.LoadAsync(new JsonTextReader(new StreamReader(fileStream)));
var conference = new Conference {
Name = conferenceName
};
var root = array.ToObject <List <RootObject> >();
foreach (var date in root)
{
foreach (var room in date.rooms)
{
if (!addedTracks.ContainsKey(room.name))
{
var thisTrack = new Track {
Name = room.name, Conference = conference
};
db.Tracks.Add(thisTrack);
addedTracks.Add(thisTrack.Name, thisTrack);
}
foreach (var thisSession in room.sessions)
{
foreach (var speaker in thisSession.speakers)
{
if (!addedSpeakers.ContainsKey(speaker.name))
{
var thisSpeaker = new Speaker {
Name = speaker.name
};
db.Speakers.Add(thisSpeaker);
addedSpeakers.Add(thisSpeaker.Name, thisSpeaker);
}
}
foreach (var category in thisSession.categories)
{
if (!addedTags.ContainsKey(category.name))
{
var thisTag = new Tag {
Name = category.name
};
db.Tags.Add(thisTag);
addedTags.Add(thisTag.Name, thisTag);
}
}
var session = new Session
{
Conference = conference,
Title = thisSession.title,
StartTime = thisSession.startsAt,
EndTime = thisSession.endsAt,
Track = addedTracks[room.name],
Abstract = thisSession.description
};
session.SessionSpeakers = new List <SessionSpeaker>();
foreach (var sp in thisSession.speakers)
{
session.SessionSpeakers.Add(new SessionSpeaker
{
Session = session,
Speaker = addedSpeakers[sp.name]
});
}
db.Sessions.Add(session);
}
}
}
}
/// <summary>Speaks a text with an optional index.</summary>
/// <param name="index">Index of the text (default: -1 (random), optional).</param>
/// <returns>UID of the speaker.</returns>
public string SpeakText(int index = -1)
{
string[] texts = new string[TextFiles.Length];
string file_path = Application.persistentDataPath + "/ocrtext.txt";
string result = null;
for (int ii = 0; ii < TextFiles.Length; ii++)
{
if (TextFiles[ii] != null)
{
texts[ii] = TextFiles[ii].text;
}
else
{
texts[ii] = string.Empty;
}
}
StreamReader sr = System.IO.File.OpenText(file_path);
texts[0] = sr.ReadToEnd();
Debug.Log("text[0]=" + texts[0]);
Model.Voice voice = Speaker.VoiceForName(RTVoiceName);
if (voice == null)
{
voice = Speaker.VoiceForCulture(Culture);
}
if (texts.Length > 0)
{
if (index < 0)
{
if (Util.Helper.isEditorMode)
{
#if UNITY_EDITOR
Speaker.SpeakNativeInEditor(texts[rnd.Next(texts.Length)], voice, Rate, Pitch, Volume);
#endif
}
else
{
if (Mode == Model.Enum.SpeakMode.Speak)
{
result = Speaker.Speak(texts[rnd.Next(texts.Length)], Source, voice, true, Rate, Pitch, Volume);
}
else
{
result = Speaker.SpeakNative(texts[rnd.Next(texts.Length)], voice, Rate, Pitch, Volume);
}
}
}
else
{
if (index < texts.Length)
{
if (Util.Helper.isEditorMode)
{
#if UNITY_EDITOR
Speaker.SpeakNativeInEditor(texts[index], voice, Rate, Pitch, Volume);
#endif
}
else
{
if (Mode == Model.Enum.SpeakMode.Speak)
{
result = Speaker.Speak(texts[index], Source, voice, true, Rate, Pitch, Volume);
}
else
{
result = Speaker.SpeakNative(texts[index], voice, Rate, Pitch, Volume);
}
}
}
else
{
Debug.LogWarning("Text file index is out of bounds: " + index + " - maximal index is: " + (texts.Length - 1));
}
}
}
else
{
Debug.LogError("No text files added - speak cancelled!");
}
return(result);
}
public async Task <ActionResult> Import(int id, ConferenceImportModel conferenceImportModel)
{
using (var oldSwetugg = new SqlConnection(conferenceImportModel.ConnectionString))
{
var oldSponsors = oldSwetugg.Query("SELECT * FROM Sponsors");
foreach (var oldSponsor in oldSponsors)
{
var sponsor = new Sponsor()
{
ConferenceId = id,
Name = oldSponsor.Name,
Description = oldSponsor.Description,
Web = oldSponsor.Web,
Twitter = oldSponsor.Twitter,
Priority = oldSponsor.Priority,
Published = oldSponsor.Published,
Slug = ((string)oldSponsor.Name).Slugify()
};
_dbContext.Sponsors.Add(sponsor);
}
await _dbContext.SaveChangesAsync();
var oldSpeakers = oldSwetugg.Query("SELECT * FROM Speakers");
foreach (var oldSpeaker in oldSpeakers)
{
var speaker = new Speaker()
{
ConferenceId = id,
Name = oldSpeaker.Name,
Company = oldSpeaker.Company,
Bio = oldSpeaker.Bio,
GitHub = oldSpeaker.GitHub,
Twitter = oldSpeaker.Twitter,
Priority = oldSpeaker.Priority,
Published = oldSpeaker.Published,
Slug = ((string)oldSpeaker.Name).Slugify()
};
_dbContext.Speakers.Add(speaker);
}
await _dbContext.SaveChangesAsync();
var oldSessions = oldSwetugg.Query(
"SELECT s.Id, s.Name, s.Description, s.EmbeddedVideoLink, s.Priority, s.Deleted, ssp.SpeakerId, sp.Name AS SpeakerName " +
"FROM Sessions AS s LEFT OUTER JOIN SessionSpeakers AS ssp " +
"ON s.Id = ssp.SessionId " +
"JOIN Speakers AS sp ON ssp.SpeakerId = sp.Id " +
"ORDER BY s.Id");
int lastId = 0;
Session session = null;
foreach (var oldSession in oldSessions)
{
if (lastId != oldSession.Id)
{
lastId = oldSession.Id;
session = new Session()
{
ConferenceId = id,
Name = oldSession.Name,
Description = oldSession.Description,
VideoUrl = oldSession.EmbeddedVideoLink,
VideoPublished = !string.IsNullOrEmpty(oldSession.EmbeddedVideoLink),
Priority = oldSession.Priority,
Published = !(oldSession.Deleted),
Speakers = new List <SessionSpeaker>(),
Slug = ((string)oldSession.Name).Slugify()
};
_dbContext.Sessions.Add(session);
}
if (oldSession.SpeakerId != null && session != null)
{
var speakerSlug = ((string)oldSession.SpeakerName).Slugify();
var speaker = await _dbContext.Speakers.SingleOrDefaultAsync(s => s.Slug == speakerSlug);
if (speaker != null)
{
session.Speakers.Add(new SessionSpeaker()
{
Session = session, Speaker = speaker
});
}
}
}
await _dbContext.SaveChangesAsync();
var oldRooms = oldSwetugg.Query("SELECT * FROM Rooms");
foreach (var oldRoom in oldRooms)
{
var room = new Room()
{
ConferenceId = id,
Name = oldRoom.Name,
Description = oldRoom.Description,
Priority = oldRoom.Priority,
Slug = ((string)oldRoom.Name).Slugify()
};
_dbContext.Rooms.Add(room);
}
await _dbContext.SaveChangesAsync();
var oldSlots = oldSwetugg.Query("SELECT * FROM Slots");
foreach (var oldSlot in oldSlots)
{
var slot = new Slot()
{
ConferenceId = id,
Start = oldSlot.Start,
End = oldSlot.End,
Title = oldSlot.Description
};
_dbContext.Slots.Add(slot);
}
await _dbContext.SaveChangesAsync();
var allRooms = await _dbContext.Rooms.Where(r => r.ConferenceId == id).ToListAsync();
var allSessions = await _dbContext.Sessions.Where(r => r.ConferenceId == id).ToListAsync();
foreach (var slot in await _dbContext.Slots.Where(s => s.ConferenceId == id).ToListAsync())
{
foreach (var room in allRooms)
{
var oldRoomSlot = oldSwetugg.Query("SELECT rs.SessionId, se.Id, se.Name " +
"FROM RoomSlots rs " +
"JOIN Slots s ON rs.SlotId = s.Id " +
"JOIN Rooms r ON rs.RoomId = r.Id " +
"JOIN Sessions se ON se.Id = rs.SessionId " +
"WHERE s.Start = @SlotStart " +
"AND r.Name = @RoomName",
new { SlotStart = slot.Start, RoomName = room.Name }).SingleOrDefault();
if (oldRoomSlot != null)
{
var sessionSlug = ((string)oldRoomSlot.Name).Slugify();
session = allSessions.SingleOrDefault(s => s.Slug == sessionSlug);
if (slot.RoomSlots == null)
{
slot.RoomSlots = new List <RoomSlot>();
}
slot.RoomSlots.Add(new RoomSlot()
{
Room = room,
Slot = slot,
AssignedSession = session
});
}
}
}
await _dbContext.SaveChangesAsync();
}
return(RedirectToAction("Conference", new { id }));
}
public Speaker Add(Speaker newSpeaker)
{
return(context.Add(newSpeaker).Entity);
}
public void OnDisable()
{
Speaker.Silence();
OnStopPlayback -= silence;
}
/// <summary> /// The action to perform on the tag exit /// </summary> /// <param name="speaker">The speaker instance</param> /// <param name="text">The text of the tag</param> public abstract void EndAction(Speaker speaker, string text);
private void showTestDrive()
{
if (Util.Helper.isEditorMode)
{
if (Speaker.Voices.Count > 0 && EditorHelper.isRTVoiceInScene)
{
scrollPosTD = EditorGUILayout.BeginScrollView(scrollPosTD, false, false);
{
GUILayout.Label("Test-Drive", EditorStyles.boldLabel);
if (Speaker.isMaryMode)
{
EditorGUILayout.HelpBox("Test-Drive is not supported for MaryTTS.", MessageType.Info);
}
else
{
text = EditorGUILayout.TextField("Text: ", text);
voiceIndex = EditorGUILayout.Popup("Voice", voiceIndex, Speaker.Voices.CTToString().ToArray());
rate = EditorGUILayout.Slider("Rate", rate, 0f, 3f);
if (Util.Helper.isWindowsPlatform)
{
pitch = EditorGUILayout.Slider("Pitch", pitch, 0f, 2f);
volume = EditorGUILayout.Slider("Volume", volume, 0f, 1f);
}
}
}
EditorGUILayout.EndScrollView();
EditorHelper.SeparatorUI();
GUILayout.BeginHorizontal();
{
if (GUILayout.Button(new GUIContent(" Speak", EditorHelper.Icon_Speak, "Speaks the text with the selected voice and settings.")))
{
Speaker.SpeakNativeInEditor(text, Speaker.Voices[voiceIndex], rate, pitch, volume);
silenced = false;
}
GUI.enabled = Speaker.isSpeaking;
if (GUILayout.Button(new GUIContent(" Silence", EditorHelper.Icon_Silence, "Silence all active speakers.")))
{
silence();
}
GUI.enabled = true;
}
GUILayout.EndHorizontal();
GUILayout.Space(6);
}
else
{
EditorHelper.NoVoicesUI();
}
}
else
{
EditorGUILayout.HelpBox("Disabled in Play-mode!", MessageType.Info);
}
}
public void SpeakerA()
{
uidSpeakerA = Speaker.SpeakNative(textA, Speaker.VoiceForCulture("en"), RateSpeakerA);
}
public void LoadNextScene()
{
Speaker.Silence();
SceneManager.LoadScene(RTVoice.Util.Helper.isWebGLPlatform ? NextSceneWebGL : NextScene);
}
public int SaveSpeaker(Speaker speaker)
{
// Simulate saving a speaker and returning the ID since this is a simiple fake repository.
return(1);
}
public void SpeakerB()
{
uidSpeakerB = Speaker.SpeakNative(textB, Speaker.VoiceForCulture("en", 1), RateSpeakerB);
}
