public static void CreateTable(this CrateConnection conn, Type t)
{
var tabledata = AttributeHelpers.GetTableData(t);
var tablecols = CrateFieldCacheProvider.Instance.Get(t);
var sb = new StringBuilder();
sb.Append("CREATE TABLE ").Append(tabledata.Name).Append(" ( ");
sb.Append(LoopObject(t));
var pk = tablecols.Where(tc => tc.Value.PrimaryKey).Select(tc => tc.Value.Name).ToArray();
if (pk.Any())
{
sb.Append("primary key (").Append(string.Join(" ,", pk)).Append(" )");
}
else
{
sb.Remove(sb.Length - 2, 2);
}
sb.Append(" ) ");
sb.Append(string.Format("clustered into {0} shards ", tabledata.NumberOfShards));
sb.Append(string.Format(" with (number_of_replicas = '{0}') ", EnumHelpers.Replication(tabledata.NumberOfReplicas)));
var sql = sb.ToString();
using (var cmd = new CrateCommand(sql, conn))
{
cmd.ExecuteNonQuery();
}
}
public void GetLong_ReturnsCorrectLong()
{
Assert.Equal(12345, AttributeHelpers.GetLong("12345"));
Assert.Null(AttributeHelpers.GetLong(""));
Assert.Null(AttributeHelpers.GetLong(null));
Assert.Null(AttributeHelpers.GetLong("SOME_RANDOM_STRING"));
}
public void SignIn(RestRequest _request)
{
string _coreengine_id, _organization_id, _access_key, _secret_key;
while (true)
{
TripleDESOAuth2TokenCryptor _token_cryptor = new TripleDESOAuth2TokenCryptor();
ICoreEngineSettings _core_settings = new CoreEngineSettings();
_coreengine_id = _core_settings.CoreEngineID;
_organization_id = _core_settings.OrganizationID;
_access_key = _core_settings.AccessKey;
_secret_key = _core_settings.SecretKey;
List <String> _auth_variables = new List <String>()
{
"CoreEngineID", "OrganizationID", "AccessKey", "SecretKey"
};
var authorName = AttributeHelpers.GetPropValue(_core_settings, "CoreEngineID");
if (_auth_variables.Any(x => AttributeHelpers.IsPropValueEmpty(_core_settings, x)))
{
_logger.Error(string.Format("Missing authentication attributes {0}", string.Join(", ", _auth_variables.Where(x => AttributeHelpers.IsPropValueEmpty(_core_settings, x)))));
Thread.Sleep(TimeSpan.FromSeconds(10));
}
else
{
break;
}
}
IRestResponse _auth_response = _oculi_api.Authorization.Signin();
OculiTokenFactory.StoreToken(OculiTokenFactory.SetToken(_auth_response));
}
private TypeSchemaKey CreateKey(Required valueRequired, JsonProperty memberProperty, JsonContract contract)
{
int? minLength = AttributeHelpers.GetMinLength(memberProperty);
int? maxLength = AttributeHelpers.GetMaxLength(memberProperty);
string title = GetTitle(contract.NonNullableUnderlyingType, memberProperty);
string description = GetDescription(contract.NonNullableUnderlyingType, memberProperty);
Required resolvedRequired;
switch (valueRequired)
{
case Required.Default:
case Required.AllowNull:
resolvedRequired = Required.AllowNull;
break;
case Required.Always:
case Required.DisallowNull:
resolvedRequired = Required.DisallowNull;
break;
default:
throw new ArgumentOutOfRangeException(nameof(valueRequired));
}
TypeSchemaKey key = new TypeSchemaKey(contract.UnderlyingType, resolvedRequired, minLength, maxLength, title, description);
return(key);
}
public static string GetMarkdown(Anime anime)
{
var kind = AttributeHelpers.GetDescriptionAttributeData(anime.Kind) ?? "?";
var markdownStringBuilder = new StringBuilder()
.AppendLine($"<a href=\"{Settings.ShikimoriUrl + anime.Url}\">{anime.Russian ?? anime.Name}</a>")
.AppendLine($"Тип: {kind}")
.Append($"Статус: {AttributeHelpers.GetDescriptionAttributeData(anime.Status)}");
switch (anime.Status)
{
case Status.Released:
markdownStringBuilder.Append($", {anime.Episodes.ToString()} эп.");
break;
case Status.Ongoing:
markdownStringBuilder.Append($", {anime.EpisodesAired.ToString()}/{anime.Episodes.ToString()}");
break;
}
return(markdownStringBuilder.ToString());
}
public override IRestRequest GetRequest()
{
var request = base.GetRequest();
request.AddQueryParameter("forum", AttributeHelpers.GetParamAttributeData(Forum));
return(request);
}
public void GetAuditTrailType_ReturnsCorrectAuditTrailType()
{
Assert.Equal(AuditTrailType.Electronic, AttributeHelpers.GetAuditTrailType("ELECTRONIC"));
Assert.Equal(AuditTrailType.Printed, AttributeHelpers.GetAuditTrailType("PRINTED"));
Assert.Null(AttributeHelpers.GetAuditTrailType(""));
Assert.Null(AttributeHelpers.GetAuditTrailType(null));
Assert.Null(AttributeHelpers.GetAuditTrailType("SOME_RANDOM_STRING"));
}
public void GetImageType_ReturnsCorrectImageType()
{
Assert.Equal(ImageType.Full, AttributeHelpers.GetImageType("FULL"));
Assert.Equal(ImageType.Snippet, AttributeHelpers.GetImageType("SNIPPET"));
Assert.Null(AttributeHelpers.GetImageType(""));
Assert.Null(AttributeHelpers.GetImageType(null));
Assert.Null(AttributeHelpers.GetImageType("SOME_RANDOM_STRING"));
}
public void GetBooleanFromYesNo_ReturnsCorrectBoolean()
{
Assert.True(AttributeHelpers.GetBooleanFromYesNo("YES"));
Assert.False(AttributeHelpers.GetBooleanFromYesNo("NO"));
Assert.Null(AttributeHelpers.GetBooleanFromYesNo(""));
Assert.Null(AttributeHelpers.GetBooleanFromYesNo(null));
Assert.Null(AttributeHelpers.GetBooleanFromYesNo("SOME_RANDOM_STRING"));
}
public void GetSide_ReturnsCorrectSide()
{
Assert.Equal(Side.Front, AttributeHelpers.GetSide("FRONT"));
Assert.Equal(Side.Back, AttributeHelpers.GetSide("BACK"));
Assert.Null(AttributeHelpers.GetSide(""));
Assert.Null(AttributeHelpers.GetSide(null));
Assert.Null(AttributeHelpers.GetSide("SOME_RANDOM_STRING"));
}
public void GetDateTime_ReturnsCorrectDateTime()
{
Assert.Equal(new DateTime(2019, 3, 22, 23, 24, 07), AttributeHelpers.GetDateTime("2019-03-22 23:24:07"));
Assert.Equal(new DateTime(2019, 3, 22), AttributeHelpers.GetDateTime("2019-03-22"));
Assert.Null(AttributeHelpers.GetDateTime(""));
Assert.Null(AttributeHelpers.GetDateTime(null));
Assert.Null(AttributeHelpers.GetDateTime("SOME_RANDOM_STRING"));
}
public void GetRescanStatus_ReturnsCorrectItemStatus()
{
Assert.Equal(RescanStatus.Rescan, AttributeHelpers.GetRescanStatus("RESCAN"));
Assert.Equal(RescanStatus.NotRescan, AttributeHelpers.GetRescanStatus("NOT_RESCAN"));
Assert.Null(AttributeHelpers.GetRescanStatus(""));
Assert.Null(AttributeHelpers.GetRescanStatus(null));
Assert.Null(AttributeHelpers.GetRescanStatus("SOME_RANDOM_STRING"));
}
public void GetOperatingMode_ReturnsCorrectOperatingMode()
{
Assert.Equal(OperatingMode.ManualScan, AttributeHelpers.GetOperatingMode("MANUAL_SCAN"));
Assert.Equal(OperatingMode.Modified, AttributeHelpers.GetOperatingMode("MODIFIED"));
Assert.Null(AttributeHelpers.GetOperatingMode(""));
Assert.Null(AttributeHelpers.GetOperatingMode(null));
Assert.Null(AttributeHelpers.GetOperatingMode("SOME_RANDOM_STRING"));
}
public void GetImageFormat_ReturnsCorrectImageFormat()
{
Assert.Equal(ImageFormat.JPEG, AttributeHelpers.GetImageFormat("JPEG"));
Assert.Equal(ImageFormat.TIFF, AttributeHelpers.GetImageFormat("TIFF"));
Assert.Equal(ImageFormat.RAW, AttributeHelpers.GetImageFormat("RAW"));
Assert.Null(AttributeHelpers.GetImageFormat(""));
Assert.Null(AttributeHelpers.GetImageFormat(null));
Assert.Null(AttributeHelpers.GetImageFormat("SOME_RANDOM_STRING"));
}
public void GetImageDepth_ReturnsCorrectImageDepth()
{
Assert.Equal(ImageDepth.Bitonal, AttributeHelpers.GetImageDepth("1"));
Assert.Equal(ImageDepth.Grayscale, AttributeHelpers.GetImageDepth("8"));
Assert.Equal(ImageDepth.Color, AttributeHelpers.GetImageDepth("24"));
Assert.Null(AttributeHelpers.GetImageDepth(""));
Assert.Null(AttributeHelpers.GetImageDepth(null));
Assert.Null(AttributeHelpers.GetImageDepth("SOME_RANDOM_STRING"));
}
public void GetItemStatus_ReturnsCorrectItemStatus()
{
Assert.Equal(ItemStatus.Valid, AttributeHelpers.GetItemStatus("VALID"));
Assert.Equal(ItemStatus.Void, AttributeHelpers.GetItemStatus("VOID"));
Assert.Equal(ItemStatus.VoidMarked, AttributeHelpers.GetItemStatus("VOID MARKED"));
Assert.Null(AttributeHelpers.GetItemStatus(""));
Assert.Null(AttributeHelpers.GetItemStatus(null));
Assert.Null(AttributeHelpers.GetItemStatus("SOME_RANDOM_STRING"));
}
public void GetDeskewStatus_ReturnsCorrectDeskewStatus()
{
Assert.Equal(DeskewStatus.Yes, AttributeHelpers.GetDeskewStatus("YES"));
Assert.Equal(DeskewStatus.No, AttributeHelpers.GetDeskewStatus("NO"));
Assert.Equal(DeskewStatus.Inactive, AttributeHelpers.GetDeskewStatus("INACTIVE"));
Assert.Null(AttributeHelpers.GetDeskewStatus(""));
Assert.Null(AttributeHelpers.GetDeskewStatus(null));
Assert.Null(AttributeHelpers.GetDeskewStatus("SOME_RANDOM_STRING"));
}
public void GetEnvelopeDetect_ReturnsCorrectEnvelopeDetect()
{
Assert.Equal(EnvelopeDetect.Yes, AttributeHelpers.GetEnvelopeDetect("YES"));
Assert.Equal(EnvelopeDetect.No, AttributeHelpers.GetEnvelopeDetect("NO"));
Assert.Equal(EnvelopeDetect.Inactive, AttributeHelpers.GetEnvelopeDetect("INACTIVE"));
Assert.Null(AttributeHelpers.GetEnvelopeDetect(""));
Assert.Null(AttributeHelpers.GetEnvelopeDetect(null));
Assert.Null(AttributeHelpers.GetEnvelopeDetect("SOME_RANDOM_STRING"));
}
public void GetBooleanFromTrueFalse_ReturnsCorrectBoolean()
{
Assert.True(AttributeHelpers.GetBooleanFromTrueFalse("TRUE"));
Assert.False(AttributeHelpers.GetBooleanFromTrueFalse("FALSE"));
Assert.Null(AttributeHelpers.GetBooleanFromTrueFalse(""));
Assert.Null(AttributeHelpers.GetBooleanFromTrueFalse(null));
Assert.Null(AttributeHelpers.GetBooleanFromTrueFalse(null));
Assert.Null(AttributeHelpers.GetBooleanFromTrueFalse("SOME_RANDOM_STRING"));
}
public void GetRtStatus_ReturnsCorrectRtStatus()
{
Assert.Equal(RtStatus.Good, AttributeHelpers.GetRtStatus("GOOD"));
Assert.Equal(RtStatus.Bad, AttributeHelpers.GetRtStatus("BAD"));
Assert.Equal(RtStatus.NotFound, AttributeHelpers.GetRtStatus("NOT_FOUND"));
Assert.Null(AttributeHelpers.GetRtStatus(""));
Assert.Null(AttributeHelpers.GetRtStatus(null));
Assert.Null(AttributeHelpers.GetRtStatus("SOME_RANDOM_STRING"));
}
private void AnalyzeSymbol(SymbolAnalysisContext symbolContext, IEnumerable <INamedTypeSymbol> exportAttributes)
{
var namedType = (INamedTypeSymbol)symbolContext.Symbol;
var namedTypeAttributes = AttributeHelpers.GetApplicableAttributes(namedType);
// Figure out which export attributes are being used here
var appliedExportAttributes = exportAttributes.Where(e => namedTypeAttributes.Any(ad => AttributeHelpers.DerivesFrom(ad.AttributeClass, e))).ToList();
// If we have no exports we're done
if (appliedExportAttributes.Count == 0)
{
return;
}
var badNamespaces = exportAttributes.Except(appliedExportAttributes).Select(s => s.ContainingNamespace).ToList();
// Now look at all attributes and see if any are metadata attributes
foreach (var namedTypeAttribute in namedTypeAttributes)
{
if (AttributeHelpers.GetApplicableAttributes(namedTypeAttribute.AttributeClass).Any(ad => badNamespaces.Contains(ad.AttributeClass.ContainingNamespace) &&
ad.AttributeClass.Name == "MetadataAttributeAttribute"))
{
ReportDiagnostic(symbolContext, namedType, namedTypeAttribute);
}
}
// Also look through all members and their attributes, and see if any are using from bad places
foreach (var member in namedType.GetMembers())
{
foreach (var attribute in member.GetAttributes())
{
if (badNamespaces.Contains(attribute.AttributeClass.ContainingNamespace))
{
ReportDiagnostic(symbolContext, namedType, attribute);
}
}
// if it's a constructor, we should also check parameters since they may have [ImportMany]
var methodSymbol = member as IMethodSymbol;
if (methodSymbol != null && methodSymbol.MethodKind == MethodKind.Constructor)
{
foreach (var parameter in methodSymbol.Parameters)
{
foreach (var attribute in parameter.GetAttributes())
{
if (badNamespaces.Contains(attribute.AttributeClass.ContainingNamespace))
{
ReportDiagnostic(symbolContext, namedType, attribute);
}
}
}
}
}
}
public override IRestRequest GetRequest()
{
var request = base.GetRequest();
if (Order.HasValue)
{
request.AddQueryParameter("order", AttributeHelpers.GetParamAttributeData(Order));
}
if (Status.HasValue)
{
request.AddQueryParameter("status", AttributeHelpers.GetParamAttributeData(Status));
}
if (!string.IsNullOrEmpty(Season))
{
request.AddQueryParameter("season", Season);
}
if (Score.HasValue)
{
request.AddQueryParameter("score", Score.Value.ToString());
}
if (Genre != null)
{
request.AddQueryParameter("genre", string.Join(",", Genre));
}
if (Studio != null)
{
request.AddQueryParameter("studio", string.Join(",", Studio));
}
if (Franchise != null)
{
request.AddQueryParameter("franchise", string.Join(",", Franchise));
}
if (Censored.HasValue)
{
request.AddQueryParameter("censored", Censored.Value.ToString().ToLower());
}
if (MyList.HasValue)
{
request.AddQueryParameter("mylist", AttributeHelpers.GetParamAttributeData(MyList));
}
if (Ids != null)
{
request.AddQueryParameter("ids", string.Join(",", Ids));
}
if (ExcludeIds != null)
{
request.AddQueryParameter("exclude_ids", string.Join(",", ExcludeIds));
}
if (!string.IsNullOrEmpty(Search))
{
request.AddQueryParameter("search", Search);
}
return(request);
}
public void GetCheckType_ReturnsCorrectCheckType()
{
Assert.Equal(CheckType.E13B, AttributeHelpers.GetCheckType("E13B"));
Assert.Equal(CheckType.US, AttributeHelpers.GetCheckType("US"));
Assert.Equal(CheckType.Canada, AttributeHelpers.GetCheckType("CANADA"));
Assert.Equal(CheckType.CMC7, AttributeHelpers.GetCheckType("CMC7"));
Assert.Equal(CheckType.Unknown, AttributeHelpers.GetCheckType("UNKNOWN"));
Assert.Null(AttributeHelpers.GetCheckType(""));
Assert.Null(AttributeHelpers.GetCheckType(null));
Assert.Null(AttributeHelpers.GetCheckType("SOME_RANDOM_STRING"));
}
public void GetImageResolution_ReturnsCorrectImageResolution()
{
Assert.Equal(ImageResolution.Low, AttributeHelpers.GetImageResolution("100"));
Assert.Equal(ImageResolution.MediumLow, AttributeHelpers.GetImageResolution("150"));
Assert.Equal(ImageResolution.Medium, AttributeHelpers.GetImageResolution("200"));
Assert.Equal(ImageResolution.MediumHigh, AttributeHelpers.GetImageResolution("240"));
Assert.Equal(ImageResolution.High, AttributeHelpers.GetImageResolution("300"));
Assert.Null(AttributeHelpers.GetImageResolution(""));
Assert.Null(AttributeHelpers.GetImageResolution(null));
Assert.Null(AttributeHelpers.GetImageResolution("SOME_RANDOM_STRING"));
}
public static int Delete <T>(this CrateConnection conn, Expression <Func <T, bool> > exp)
{
var table = AttributeHelpers.GetTableData(typeof(T));
var swhere = "DELETE FROM " + table.Name + " WHERE " + (new WhereTranslater()).Translate(exp);
using (var cmd = new CrateCommand(swhere, conn))
{
return(cmd.ExecuteNonQuery());
}
}
public Dictionary <string, CrateField> Get(Type t)
{
var ret = (Dictionary <string, CrateField>)Get(t.FullName);
if (ret == null)
{
ret = AttributeHelpers.GetTableFields(t);
Set(t.FullName, ret);
}
return(ret);
}
private string GetDescription(Type type, JsonProperty memberProperty)
{
JsonContainerAttribute containerAttribute = JsonTypeReflector.GetCachedAttribute <JsonContainerAttribute>(type);
if (!string.IsNullOrEmpty(containerAttribute?.Description))
{
return(containerAttribute.Description);
}
AttributeHelpers.GetDescription(type, memberProperty, out string description);
return(description);
}
public void GetScantimeFinalBlankAreaDecision_ReturnsCorrectScantimeFinalBlankAreaDecision()
{
Assert.Equal(ScantimeFinalBlankAreaDecision.Blank,
AttributeHelpers.GetScantimeFinalBlankAreaDecision("BLANK"));
Assert.Equal(ScantimeFinalBlankAreaDecision.NotBlank,
AttributeHelpers.GetScantimeFinalBlankAreaDecision("NOT_BLANK"));
Assert.Equal(ScantimeFinalBlankAreaDecision.Undetermined,
AttributeHelpers.GetScantimeFinalBlankAreaDecision("UNDETERMINED"));
Assert.Null(AttributeHelpers.GetScantimeFinalBlankAreaDecision(""));
Assert.Null(AttributeHelpers.GetScantimeFinalBlankAreaDecision(null));
Assert.Null(AttributeHelpers.GetScantimeFinalBlankAreaDecision("SOME_RANDOM_STRING"));
}
private string GetTitle(Type type, JsonProperty memberProperty)
{
JsonContainerAttribute containerAttribute = JsonTypeReflector.GetCachedAttribute <JsonContainerAttribute>(type);
if (!string.IsNullOrEmpty(containerAttribute?.Title))
{
return(containerAttribute.Title);
}
AttributeHelpers.GetDisplayName(type, memberProperty, out string displayName);
return(displayName);
}
public void GetMicrStatus_ReturnsCorrectMicrStatus()
{
Assert.Equal(MicrStatus.Good, AttributeHelpers.GetMicrStatus("GOOD"));
Assert.Equal(MicrStatus.Partial, AttributeHelpers.GetMicrStatus("PARTIAL"));
Assert.Equal(MicrStatus.Bad, AttributeHelpers.GetMicrStatus("BAD"));
Assert.Equal(MicrStatus.NoMicr, AttributeHelpers.GetMicrStatus("NO_MICR"));
Assert.Equal(MicrStatus.Inactive, AttributeHelpers.GetMicrStatus("INACTIVE"));
Assert.Equal(MicrStatus.Error, AttributeHelpers.GetMicrStatus("ERROR"));
Assert.Null(AttributeHelpers.GetMicrStatus(""));
Assert.Null(AttributeHelpers.GetMicrStatus(null));
Assert.Null(AttributeHelpers.GetMicrStatus("SOME_RANDOM_STRING"));
}
