public static void InitiateHandoff(string botresponseJson)
{
BotResponse response = JsonConvert.DeserializeObject <BotResponse>(botresponseJson);
// Look for Handoff Initiate Activity. This indicates that conversation needs to be handed off to agent
Activity handoffInitiateActivity = response.Activities.ToList().FirstOrDefault(
item => string.Equals(item.Type, ActivityTypes.Event, System.StringComparison.Ordinal) &&
string.Equals(item.Name, HandoffInitiateActivityName, System.StringComparison.Ordinal));
if (handoffInitiateActivity != null)
{
// Read transcript from attachment
if (handoffInitiateActivity.Attachments?.Any() == true)
{
Attachment transcriptAttachment = handoffInitiateActivity.Attachments.FirstOrDefault(
a => string.Equals(a.Name.ToLowerInvariant(), TranscriptAttachmentName, System.StringComparison.Ordinal));
if (transcriptAttachment != null)
{
Transcript transcript = JsonConvert.DeserializeObject <Transcript>(
transcriptAttachment.Content.ToString());
}
}
// Read handoff context
HandoffContext context = JsonConvert.DeserializeObject <HandoffContext>(handoffInitiateActivity.Value.ToString());
// Connect to Agent Hub
// <YOUR CUSTOM ADAPTER CODE GOES HERE>
}
}
public void FinalizeAndAddAnnotationObject(Transcript transcript, TranscriptAnnotation ta, string[] consequences)
{
if (ta.AlternateAllele.IsStructuralVariant)
{
return;
}
if (ta.HasValidCdnaCodingStart)
{
_currTranscript.ProteinID = transcript.Translation.ProteinId.ToString();
}
_currTranscript.Consequence = consequences;
if (ta.HasValidCdsStart || ta.HasValidCdsEnd)
{
_currTranscript.ProteinPosition = GetProtRangeString(ta);
_currTranscript.UpStreamPeptides = GetFlankingPeptides(ta, transcript, 15, true);
_currTranscript.AminoAcids = GetAlleleString(ta.ReferenceAminoAcids, ta.AlternateAminoAcids);
if (!ta.HasFrameShift)
{
_currTranscript.DownStreamPeptides = GetFlankingPeptides(ta, transcript, 15, false);
}
}
_currPianoAllele.Transcripts.Add(_currTranscript);
}
internal AppState(App application)
{
Application = application;
Transcript = new Transcript();
_view = ControlViews.Transcript;
}
public void InitializeInterface(Transcript transcriptRecto, Transcript transcriptVerso, int side)
{
transcripts = new Transcript[2];
if (transcriptRecto != null)
{
transcripts[0] = transcriptRecto;
}
if (transcriptVerso != null)
{
transcripts[1] = transcriptVerso;
}
DisplayTranscriptSide(side);
for (int i = 0; i < 3; i++)
{
axisActive[i] = true;
}
if (transcriptZone.activeSelf)
{
ToggleTranscript();
}
}
// GET: Transcripts/Details/5
public ActionResult Play(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Transcript transcript = db.Transcripts.Find(id);
if (transcript == null)
{
return(HttpNotFound());
}
if (!transcript.Active)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
string fn = Path.GetFileNameWithoutExtension(transcript.PlayFile);
ViewBag.srtFile = fn + ".txt";
string inFile = Server.MapPath("~/temp") + "\\" + ViewBag.srtFile;
System.IO.File.WriteAllText(inFile, transcript.Text_Sort);
EventLoad.LogEvent(User.Identity.Name, transcript.Id, "Load_Play", null, null, null, null);
return(View(transcript));
}
// GET: Transcripts/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Transcript transcript = db.Transcripts.Find(id);
if (transcript == null)
{
return(HttpNotFound());
}
var projects = db.Projects.Where(s => s.CreateBy.Equals(User.Identity.Name))
.Select(s => new { s.ID, s.ProjectName })
.OrderBy(s => s.ProjectName)
.ToList();
// var formdata = new FileUpload();
ViewBag.projectList = new SelectList(projects, "ID", "ProjectName");
// ViewBag.projectList.SelectedValue = transcript.ProjectId;
return(View(transcript));
}
public void TestCreateHandoffInitiation()
{
var adapter = new TestAdapter(TestAdapter.CreateConversation(TestContext.TestName));
string fromID = "test";
var activity = new Activity
{
Type = ActivityTypes.Message,
Text = string.Empty,
Conversation = new ConversationAccount(),
Recipient = new ChannelAccount(),
From = new ChannelAccount(fromID),
ChannelId = "testchannel",
ServiceUrl = "http://myservice"
};
var context = new TurnContext(adapter, activity);
var transcript = new Transcript(new Activity[] { MessageFactory.Text("hello") });
Assert.IsNull(transcript.Activities[0].ChannelId);
Assert.IsNull(transcript.Activities[0].ServiceUrl);
Assert.IsNull(transcript.Activities[0].Conversation);
var handoffEvent = EventFactory.CreateHandoffInitiation(context, new { Skill = "any" }, transcript);
Assert.AreEqual(handoffEvent.Name, HandoffEventNames.InitiateHandoff);
var skill = (handoffEvent.Value as JObject)?.Value <string>("Skill");
Assert.AreEqual(skill, "any");
Assert.AreEqual(handoffEvent.From.Id, fromID);
}
/// <summary>
/// constructor
/// </summary>
public HgvsCodingNomenclature(TranscriptAnnotation ta, Transcript transcript, VariantFeature variant,
ICompressedSequence compressedSequence, bool isGenomicDuplicate)
{
_ta = ta;
_transcript = transcript;
_variant = variant;
_compressedSequence = compressedSequence;
_isGenomicDuplicate = isGenomicDuplicate;
_sb = new StringBuilder();
// get reference sequence strand
var transcriptOnReverseStrand = transcript.Gene.OnReverseStrand;
// this may be different to the input one for insertions/deletions
var altAllele = ta.AlternateAllele;
string variationFeatureSequence = altAllele.AlternateAllele;
// get the reverse complement of the vfs if needed
if (transcriptOnReverseStrand)
{
variationFeatureSequence = SequenceUtilities.GetReverseComplement(variationFeatureSequence);
}
// calculate the reference start and end
GetReferenceCoordinates(transcript, altAllele, out _hgvsStart, out _hgvsEnd);
// decide event type from HGVS nomenclature
_hgvsNotation = new HgvsNotation(ta.TranscriptReferenceAllele, variationFeatureSequence,
FormatUtilities.CombineIdAndVersion(transcript.Id, transcript.Version), _hgvsStart, _hgvsEnd,
_transcript.Translation != null);
}
private RespondToChallenge CommitToNonces(Transcript transcript, WasabiRandom random)
{
// With all the statements committed, generate a vector of random secret
// nonces for every equation in underlying proof system. In order to
// ensure that nonces are never reused (e.g. due to an insecure RNG) with
// different challenges which would leak the witness, these are generated
// as synthetic nonces that also depend on the witness data.
var secretNonceProvider = transcript.CreateSyntheticSecretNonceProvider(Knowledge.Witness, random);
// Actually generate all of the required nonces and save them in an array
// because if the enumerable is evaluated several times the results will
// be different.
// Note, ToArray() is needed to make sure that secretNonces is captured
// once and shared between the phases.
var equations = Knowledge.Statement.Equations;
var secretNonces = secretNonceProvider.Sequence.Take(equations.Count()).ToArray();
// The prover then commits to these, adding the corresponding public
// points to the transcript.
var publicNonces = new GroupElementVector(equations.Zip(secretNonces, (equation, pointSecretNonces) => pointSecretNonces * equation.Generators));
transcript.CommitPublicNonces(publicNonces);
return(() => Respond(transcript, publicNonces, secretNonces));
}
private static void WriteGeneralAttributes(TextWriter writer, Transcript transcript)
{
var geneId = transcript.TranscriptSource == TranscriptDataSource.Ensembl
? transcript.Gene.EnsemblId.ToString()
: transcript.Gene.EntrezGeneId.ToString();
if (!string.IsNullOrEmpty(geneId))
{
writer.Write($"gene_id \"{geneId}\"; ");
}
if (!string.IsNullOrEmpty(transcript.Gene.Symbol))
{
writer.Write($"gene_name \"{transcript.Gene.Symbol}\"; ");
}
if (!transcript.Id.IsEmpty)
{
writer.Write($"transcript_id \"{FormatUtilities.CombineIdAndVersion(transcript.Id, transcript.Version)}\"; ");
}
writer.Write($"transcript_type \"{BioTypeUtilities.GetBiotypeDescription(transcript.BioType)}\"; ");
if (transcript.IsCanonical)
{
writer.Write("tag \"canonical\"; ");
}
if (!string.IsNullOrEmpty(transcript.Translation?.ProteinId.ToString()))
{
writer.Write($"protein_id \"{FormatUtilities.CombineIdAndVersion(transcript.Translation.ProteinId, transcript.Translation.ProteinVersion)}\"; ");
}
}
public byte[] ChallengeBytes(Transcript ts, byte[] label)
{
var buf = new byte[64];
ts.ChallengeBytes(label, ref buf);
return(buf);
}
public void Update(Transcript entity)
{
var transcript = _context.Transcripts.Attach(entity);
transcript.State = EntityState.Modified;
_unitOfWork.Commit();
}
public void FinalizeAndAddAnnotationObject(Transcript transcript, TranscriptAnnotation ta, string[] consequences)
{
if (!ta.AlternateAllele.IsStructuralVariant)
{
_currTranscript.ComplementaryDnaPosition = GetCdnaRangeString(ta);
_currTranscript.HgvsCodingSequenceName = ta.HgvsCodingSequenceName;
if (ta.HasValidCdnaCodingStart)
{
_currTranscript.ProteinID = TranscriptUtilities.GetProteinId(transcript);
}
}
else
{
_currTranscript.ProteinID = ta.HasValidCdnaCodingStart ? TranscriptUtilities.GetProteinId(transcript) : null;
if (ta.GeneFusionAnnotations != null && ta.GeneFusionAnnotations.Count == 1)
{
var sb = new StringBuilder();
ta.GeneFusionAnnotations.First().SerializeJson(sb);
_currTranscript.GeneFusion = sb.ToString();
}
else if (ta.GeneFusionAnnotations != null && ta.GeneFusionAnnotations.Count > 1)
{
throw new Exception("has mutiple gene fusions");
}
}
_currTranscript.Consequence = consequences;
_currJsonVariant.AddTranscript(_currTranscript, transcript.TranscriptSource);
}
private static void CalculateCdsPositions(Transcript transcript, TranscriptAnnotation ta)
{
// sanity check: make sure we have a valid start position
ta.HasValidCdsStart = true;
ta.HasValidCdsEnd = true;
if (ta.BackupCdnaEnd < transcript.Translation.CodingRegion.CdnaStart ||
ta.BackupCdnaBegin > transcript.Translation.CodingRegion.CdnaEnd)
{
// if the variant is completely non overlapping with the transcript's coding start
ta.HasValidCdsStart = false;
ta.HasValidCdsEnd = false;
return;
}
// calculate the CDS position
int beginOffset = transcript.StartExonPhase - transcript.Translation.CodingRegion.CdnaStart + 1;
ta.CodingDnaSequenceBegin = ta.BackupCdnaBegin + beginOffset;
ta.CodingDnaSequenceEnd = ta.BackupCdnaEnd + beginOffset;
if (ta.CodingDnaSequenceBegin < 1 || ta.HasValidCdnaStart == false)
{
ta.HasValidCdsStart = false;
}
if (ta.CodingDnaSequenceEnd > transcript.Translation.CodingRegion.CdnaEnd + beginOffset ||
ta.HasValidCdnaEnd == false)
{
ta.HasValidCdsEnd = false;
}
}
public static List <Transcript> GetTranscript(String classCode, String courseCode, int timesStep)
{
String query = "Exec sp_GetTranscript '" + classCode + "', '" + courseCode + "', " + timesStep;
SqlDataReader reader = ExecSqlDataReader(query);
List <Transcript> listTranscript = new List <Transcript>();
while (reader.Read())
{
String sc = reader.GetString(0);
String fn = reader.GetString(1);
double m = 0.0;
try
{
m = reader.GetDouble(2);
}
catch (Exception)
{
}
Transcript transcript = new Transcript
{
StudentCode = sc,
FullName = fn,
Marks = (float)m
};
listTranscript.Add(transcript);
}
reader.Close(); // <- too easy to forget
reader.Dispose(); // <- too easy to forget
return(listTranscript);
}
/// <summary>
/// Every conversation turn will call this method. The method either echoes the message activity or uploads the history to the channel.
/// </summary>
/// <param name="turnContext">A <see cref="ITurnContext"/> containing all the data needed
/// for processing this conversation turn. </param>
/// <param name="cancellationToken">(Optional) A <see cref="CancellationToken"/> that can be used by other objects
/// or threads to receive notice of cancellation.</param>
/// <returns>A <see cref="Task"/> that represents the work queued to execute.</returns>
/// <seealso cref="BotStateSet"/>
/// <seealso cref="ConversationState"/>
/// <seealso cref="IMiddleware"/>
public async Task OnTurnAsync(ITurnContext turnContext, CancellationToken cancellationToken = default(CancellationToken))
{
if (turnContext == null)
{
throw new ArgumentNullException(nameof(turnContext));
}
var activity = turnContext.Activity;
if (activity.Type == ActivityTypes.Message)
{
if (activity.Text == "!history")
{
// Download the activities from the Transcript (blob store) and send them over to the channel when a request to upload history arrives.
// This could be an event or a special message acctivity as above.
var connectorClient = turnContext.TurnState.Get <ConnectorClient>(typeof(IConnectorClient).FullName);
// Get all the message type activities from the Transcript.
string continuationToken = null;
var count = 0;
do
{
var pagedTranscript = await _transcriptStore.GetTranscriptActivitiesAsync(activity.ChannelId, activity.Conversation.Id, continuationToken);
var activities = pagedTranscript.Items
.Where(a => a.Type == ActivityTypes.Message)
.Select(ia => (Activity)ia)
.ToList();
// DirectLine only allows the upload of at most 500 activities at a time. The limit of 1500 below is
// arbitrary and up to the Bot author to decide.
count += activities.Count();
if (activities.Count() > 500 || count > 1500)
{
throw new InvalidOperationException("Attempt to upload too many activities");
}
var transcript = new Transcript(activities);
await connectorClient.Conversations.SendConversationHistoryAsync(activity.Conversation.Id, transcript, cancellationToken : cancellationToken);
continuationToken = pagedTranscript.ContinuationToken;
}while (continuationToken != null);
await turnContext.SendActivityAsync("Transcript sent", cancellationToken : cancellationToken);
}
else
{
// Echo back to the user whatever they typed.
await turnContext.SendActivityAsync($"You sent '{activity.Text}'\n", cancellationToken : cancellationToken);
}
}
else if (activity.Type == ActivityTypes.ConversationUpdate)
{
if (activity.MembersAdded != null)
{
await SendWelcomeMessageAsync(turnContext, cancellationToken);
}
}
}
private void CheckSmallIntron(int intronIdx, Transcript transcript, HashSet <LofteeFilter.Filter> filters)
{
if (transcript.Introns[intronIdx].End - transcript.Introns[intronIdx].Start + 1 < 15)
{
filters.Add(LofteeFilter.Filter.small_intron);
}
}
private void CheckSingleExon(Transcript transcript, HashSet <LofteeFilter.Flag> flags)
{
if (transcript.CdnaMaps.Length == 1)
{
flags.Add(LofteeFilter.Flag.single_exon);
}
}
public BuildTranscriptHMM(string context, Transcript transcript, AcousticModel acousticModel, UnitManager unitManager)
{
this.acousticModel = acousticModel;
this.unitManager = unitManager;
this.wordGraph = this.buildWordGraph(transcript);
if (!BuildTranscriptHMM.assertionsDisabled && !this.wordGraph.validate())
{
object obj = "Word graph not validated";
throw new AssertionError(obj);
}
this.phonemeGraph = this.buildPhonemeGraph(this.wordGraph);
if (!BuildTranscriptHMM.assertionsDisabled && !this.phonemeGraph.validate())
{
object obj2 = "Phone graph not validated";
throw new AssertionError(obj2);
}
this.contextDependentPhoneGraph = this.buildContextDependentPhonemeGraph(this.phonemeGraph);
if (!BuildTranscriptHMM.assertionsDisabled && !this.contextDependentPhoneGraph.validate())
{
object obj3 = "Context dependent graph not validated";
throw new AssertionError(obj3);
}
this.hmmGraph = this.buildHMMGraph(this.contextDependentPhoneGraph);
if (!BuildTranscriptHMM.assertionsDisabled && !this.hmmGraph.validate())
{
object obj4 = "HMM graph not validated";
throw new AssertionError(obj4);
}
}
/// <summary>
/// One or more exons fully included (no partial overlap)
/// </summary>
private void exons()
{
Interval cdsMarker = null;
if (Transcript.IsProteinCoding())
{
cdsMarker = Transcript.CdsMarker();
}
foreach (Exon ex in Transcript.Exons)
{
if (Variant.Intersects(ex))
{
EffectImpact impact = EffectImpact.LOW;
// Is the variant affecting a coding part of the exon?
// If so, then this is a HIGH impact effect.
if (cdsMarker != null && Variant.Intersect(ex).Intersects(cdsMarker))
{
impact = EffectImpact.HIGH;
}
// Is the whole exon inverted or just part of it?
EffectType effType = Variant.Includes(ex) ? EffectType.EXON_INVERSION : EffectType.EXON_INVERSION_PARTIAL;
EffectNoCodon(ex, effType, impact);
}
}
}
private string GetFlankingPeptides(TranscriptAnnotation ta, Transcript transcript, int nBase, bool upStrem)
{
var begin = ta.ProteinBegin;
var end = ta.ProteinEnd;
if (!ta.HasValidCdsStart && !ta.HasValidCdsEnd)
{
return(null);
}
if (!ta.HasValidCdsStart && ta.HasValidCdsEnd)
{
begin = end;
}
if (!ta.HasValidCdsEnd && ta.HasValidCdsStart)
{
end = begin;
}
if (upStrem)
{
var peptideStart = Math.Max(1, begin - nBase);
return(transcript.Translation.PeptideSeq.Substring(peptideStart - 1, (begin - peptideStart)));
}
var peptideEnd = Math.Min(transcript.Translation.PeptideSeq.Length, end + nBase);
return(peptideEnd > end + 1 ? transcript.Translation.PeptideSeq.Substring(end, (peptideEnd - end)) : "");
}
public RegistrationResults CanRegisterForCourseSection(CourseSection section)
{
if (section.EnrolledStudents.Where(s => s.Id == this.Id).Any())
{
return(RegistrationResults.AlreadyEnrolled);
}
if (Transcript.Where(t => (int)t.GradeEarned <= (int)GradeTypes.C && t.CourseSection.CatalogCourse.Id == section.CatalogCourse.Id).Any())
{
return(RegistrationResults.AlreadyCompleted);
}
foreach (var pre in section.CatalogCourse.Prerequisites)
{
if (!Transcript.Where(t => (int)t.GradeEarned <= (int)GradeTypes.C &&
t.CourseSection.CatalogCourse.Id == pre.Id).Any())
{
return(RegistrationResults.PrerequisiteNotMet);
}
}
foreach (var en in EnrolledCourses)
{
if ((en.MeetingDays & section.MeetingDays) != DaysOfWeek.None)
{
if ((en.StartTime <= section.EndTime && section.StartTime <= en.EndTime) ||
(section.StartTime <= en.EndTime && en.StartTime <= section.EndTime))
{
return(RegistrationResults.TimeConflict);
}
}
}
return(RegistrationResults.Success);
}
private object[] GetData(int index, Transcript trans)
{
return(new object[]
{
index, trans.StudentCode, trans.FullName, trans.Marks, trans.MarksStr
});
}
/// <summary>
/// List conversations in the channelId.
/// </summary>
/// <param name="channelId">Channel Id.</param>
/// <param name="continuationToken">Continuatuation token to page through results.</param>
/// <returns>A <see cref="Task"/> A task that represents the work queued to execute.</returns>
public async Task <PagedResult <Transcript> > ListTranscriptsAsync(string channelId, string continuationToken = null)
{
if (string.IsNullOrEmpty(channelId))
{
throw new ArgumentNullException($"missing {nameof(channelId)}");
}
var dirName = GetDirName(channelId);
var dir = this.Container.Value.GetDirectoryReference(dirName);
int pageSize = 20;
BlobContinuationToken token = null;
List <Transcript> conversations = new List <Transcript>();
do
{
var segment = await dir.ListBlobsSegmentedAsync(false, BlobListingDetails.Metadata, null, token, null, null).ConfigureAwait(false);
foreach (var blob in segment.Results.Where(c => c is CloudBlobDirectory).Cast <CloudBlobDirectory>())
{
var conversation = new Transcript()
{
Id = blob.Prefix.Split('/').Where(s => s.Length > 0).Last(), ChannelId = channelId
};
if (continuationToken != null)
{
if (conversation.Id == continuationToken)
{
// we found continuation token
continuationToken = null;
}
// skip record
}
else
{
conversations.Add(conversation);
if (conversations.Count == pageSize)
{
break;
}
}
}
if (segment.ContinuationToken != null)
{
token = segment.ContinuationToken;
}
}while (token != null && conversations.Count < pageSize);
var pagedResult = new PagedResult <Transcript>();
pagedResult.Items = conversations.ToArray();
if (pagedResult.Items.Length == 20)
{
pagedResult.ContinuationToken = pagedResult.Items.Last().Id;
}
return(pagedResult);
}
public void Populate()
{
RequirementSelector.ClearOptions();
List <string> NeedToTake = new List <string> ();
genReq = new List <bool> ();
//start new lists
NeedToTake.Add("Select a requirement"); //default option
PlayerScript myPlayer = GameObject.FindGameObjectWithTag("Player").GetComponent <PlayerScript> ();
Transcript MyScript = myPlayer.myTrans;
List <Course> coursesTaken = MyScript.coursesTaken; //retrieve and save values from Transcript
List <Course> myCourses = MyScript.coursesRequired;
//Add courses/GenReqs if they are take-able
myCourses.ForEach(x => {
if (x.CanTake(coursesTaken))
{
NeedToTake.Add(x.courseName);
CourseLocations.Add("Course/" + x.name);
genReq.Add(false);
}
});
MyScript.genRequired.ForEach(x => {
bool aCourse = false;
int i = 0;
while (!aCourse && i < x.availCourse.Count)
{
aCourse = x.availCourse[i].CanTake(coursesTaken);
i++;
}
if (aCourse)
{
NeedToTake.Add(x.reqName);
CourseLocations.Add("GenReq/" + x.name);
genReq.Add(true);
}
});
MyScript.GenEdReqs.ForEach(x => {
bool aCourse = false;
int i = 0;
while (!aCourse && i < x.availCourse.Count)
{
aCourse = x.availCourse[i].CanTake(coursesTaken);
i++;
}
if (aCourse)
{
NeedToTake.Add(x.reqName);
CourseLocations.Add("GenReq/" + x.name);
genReq.Add(true);
}
});
RequirementSelector.AddOptions(NeedToTake); //add options to dropdown
RequirementSelector.interactable = true;
}
public static bool Verify(Transcript transcript, IEnumerable <Statement> statements, IEnumerable <Proof> proofs)
{
Guard.Same(nameof(proofs), proofs.Count(), statements.Count());
// Before anything else all components in a compound proof commit to the
// individual sub-statement that will be proven, ensuring that the
// challenges and therefore the responses depend on the statement as a
// whole.
foreach (var statement in statements)
{
transcript.CommitStatement(statement);
}
// After all the statements have been committed, the public nonces are
// added to the transcript. This is done separately from the statement
// commitments because the prover derives these based on the compound
// statements, and the verifier must add data to the transcript in the
// same order as the prover.
foreach (var proof in proofs)
{
transcript.CommitPublicNonces(proof.PublicNonces);
}
// After all the public nonces have been committed, a challenge can be
// generated based on transcript state. Since challenges are deterministic
// outputs of a hash function which depends on the prover commitments, the
// verifier obtains the same challenge and then accepts if the responses
// satisfy the verification equation.
var challenge = transcript.GenerateChallenge();
return(Enumerable.Zip(statements, proofs, (s, p) => s.CheckVerificationEquation(p.PublicNonces, challenge, p.Responses)).All(x => x));
}
private void AddTranscriptToVariant(VariantFeature variant, Transcript transcript)
{
foreach (var altAllele in variant.AlternateAlleles)
{
AnnotateAltAllele(variant, altAllele, transcript);
}
}
public async Task <ResourceResponse> SendTranscriptAsync(
string conversationId, IList <Activity> activities)
{
ResourceResponse resourceResponse = null;
if (activities.Count == 0)
{
return(resourceResponse);
}
try
{
Transcript transcript = new Transcript(activities);
resourceResponse = await _botClient.Conversations.SendConversationHistoryAsync(conversationId, transcript);
}
catch (UnauthorizedAccessException e)
{
_logger.LogError($"Failed to send message: {e.Message}");
return(null);
}
catch (Exception e)
{
_logger.LogError($"Failed to send message: {e.Message}");
return(null);
}
return(resourceResponse);
}
public async Task Delete(int studentId, int courseId)
{
Transcript transcript = await GetOne(studentId, courseId);
_context.Entry(transcript).State = EntityState.Deleted;
await _context.SaveChangesAsync();
}
public async Task <Transcript> Update(int id, Transcript transcript)
{
_context.Entry(transcript).State = EntityState.Modified;
await _context.SaveChangesAsync();
return(transcript);
}
public async Task <Transcript> Create(Transcript transcript)
{
_context.Entry(transcript).State = EntityState.Added;
await _context.SaveChangesAsync();
return(transcript);
}
private List<Section> attends; // of Sections
#endregion Fields
#region Constructors
//----------------
// Constructor(s).
//----------------
// Reuse the code of the parent's constructor using the base.
// keyword.
public Student(string name, string id,
string major, string degree)
: base(name, id)
{
Major = major;
Degree = degree;
Transcript = new Transcript(this);
// We create an empty List.
attends = new List<Section>();
}
private List<Section> attends; // of Sections
#endregion Fields
#region Constructors
//----------------
// Constructor(s).
//----------------
public Student(string studentFile, string name, string id, string major,
string degree)
: base(name, id)
{
// Assign auto-implemented property values
Major = major;
Degree = degree;
StudentFile = studentFile;
Transcript = new Transcript(this);
// Create an empty List.
attends = new List<Section>();
// Initialize the password to be the first three digits
// of the name of the student's data file.
this.Password = this.StudentFile.Substring(0,3); // added for GUI purposes
}
public TranscriptProvider()
{
Transcript = new Transcript();
}
