public async Task <Term> Update(Term term)
{
if (!await TermValidator.Update(term))
{
return(term);
}
using (UOW.Begin())
{
try
{
term = await GetSemesterId(term);
await UOW.TermRepository.Update(term);
await UOW.Commit();
return(term);
}
catch (Exception e)
{
await UOW.Rollback();
term.AddError(nameof(TermService), nameof(Create), CommonEnum.ErrorCode.SystemError);
return(term);
}
}
}
public bool TryParse(string mechanism, out Term term)
{
Match match = _mechanismRegex.Match(mechanism);
if (match.Success)
{
string qualifierToken = match.Groups["qualifier"].Value;
string mechanismToken = match.Groups["mechanism"].Value.ToLower();
string argumentToken = match.Groups["argument"].Value;
Qualifier qualifier = _qualifierParser.Parse(qualifierToken);
if (!_parserStrategies.TryGetValue(mechanismToken, out IMechanismParserStrategy strategy))
{
throw new ArgumentException($"No strategy found to process {mechanismToken}");
}
term = strategy.Parse(mechanism, qualifier, argumentToken);
if (qualifier == Qualifier.Unknown)
{
string message = string.Format(SpfParserResource.UnknownQualifierErrorMessage, qualifierToken);
string markdown = string.Format(SpfParserMarkdownResource.UnknownQualifierErrorMessage, qualifierToken);
term.AddError(new Error(Id, ErrorType.Error, message, markdown));
}
return(true);
}
term = null;
return(false);
}
private bool ValidateStringLength(Term term)
{
if (string.IsNullOrEmpty(term.SubjectName))
{
term.AddError(nameof(TermValidator), nameof(term), ERROR.StringEmpty);
return(false);
}
else if (term.SubjectName.Length > 100)
{
term.AddError(nameof(TermValidator), nameof(term), ERROR.StringLimited);
return(false);
}
if (string.IsNullOrEmpty(term.SemesterCode))
{
term.AddError(nameof(TermValidator), nameof(term.SemesterCode), ERROR.SemesterCodeEmpty);
return(false);
}
else if (term.SemesterCode != null && Regex.IsMatch(term.SemesterCode, @"^\d{4}_\d{4}_\d") == false)
{
term.AddError(nameof(TermValidator), nameof(term.SemesterCode), ERROR.SemesterCodeInValid);
return(false);
}
return(true);
}
/*private async Task<bool> ValidateExist(Term Term)
* {
* TermFilter filter = new TermFilter
* {
* Take = Int32.MaxValue,
* SubjectName = new StringFilter { Equal = Term.SubjectName },
* SemesterCode = new StringFilter { Equal = Term.SemesterCode }
* };
*
* int count = await UOW.TermRepository.Count(filter);
* if (count == 0)
* {
* Term.AddError(nameof(TermValidator), nameof(Term), ERROR.NotExisted);
* return false;
* }
* return true;
* }*/
private async Task <bool> ValidateId(Term Term)
{
TermFilter filter = new TermFilter
{
Id = new GuidFilter {
Equal = Term.Id
}
};
int count = await UOW.TermRepository.Count(filter);
if (count == 0)
{
Term.AddError(nameof(TermValidator), nameof(Term), ERROR.IdNotFound);
}
return(count == 1);
}
public async Task <SpfRecords> Process(string domain, Term term)
{
Redirect redirect = term as Redirect;
DnsResult <List <List <string> > > spfDnsRecords = await _dnsClient.GetSpfRecords(redirect.DomainSpec.Domain);
if (spfDnsRecords.IsErrored)
{
string message = string.Format(SpfExpansionResource.FailedSpfRecordQueryErrorMessage, redirect.DomainSpec.Domain, spfDnsRecords.Error);
string markdown = string.Format(SpfExpansionMarkdownResource.FailedSpfRecordQueryErrorMessage, redirect.DomainSpec.Domain, spfDnsRecords.Error);
term.AddError(new Error(Id, ErrorType.Error, message, markdown));
return(null);
}
redirect.Records = await _recordsParser.Parse(redirect.DomainSpec.Domain, spfDnsRecords.Value, spfDnsRecords.MessageSize);
return(redirect.Records);
}
private async Task <bool> ValidateNotExist(Term Term)
{
TermFilter filter = new TermFilter
{
SubjectName = new StringFilter {
Equal = Term.SubjectName
},
SemesterCode = new StringFilter {
Equal = Term.SemesterCode
}
};
int count = await UOW.TermRepository.Count(filter);
if (count > 0)
{
Term.AddError(nameof(TermValidator), nameof(Term), ERROR.TermExisted);
return(false);
}
return(true);
}
