public void Persists()
{
service.AddBook("QA123", "The Trial", "Kafka, Franz", "1927");
service = new MasterClassificationService();
AssertBook(service.Retrieve("QA123"), "QA123", "The Trial", "Kafka, Franz", "1927");
}
public static ClassificationService getClassificationService(String endPointAddress)
{
ClassificationService classificationService = new ClassificationService();
classificationService.Url = endPointAddress + CLASSIFICATION_SERVICE_ADDRESS;
addSecurityHeader(classificationService);
return(classificationService);
}
public void Classification_Controller_Put_Test()
{
foreach (LanguageEnum LanguageRequest in AllowableLanguages)
{
foreach (int ContactID in new List <int>()
{
AdminContactID
}) //, TestEmailValidatedContactID, TestEmailNotValidatedContactID })
{
ClassificationController classificationController = new ClassificationController(DatabaseTypeEnum.SqlServerTestDB);
Assert.IsNotNull(classificationController);
Assert.AreEqual(DatabaseTypeEnum.SqlServerTestDB, classificationController.DatabaseType);
Classification classificationLast = new Classification();
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
Query query = new Query();
query.Language = LanguageRequest;
ClassificationService classificationService = new ClassificationService(query, db, ContactID);
classificationLast = (from c in db.Classifications select c).FirstOrDefault();
}
// ok with Classification info
IHttpActionResult jsonRet = classificationController.GetClassificationWithID(classificationLast.ClassificationID);
Assert.IsNotNull(jsonRet);
OkNegotiatedContentResult <Classification> Ret = jsonRet as OkNegotiatedContentResult <Classification>;
Classification classificationRet = Ret.Content;
Assert.AreEqual(classificationLast.ClassificationID, classificationRet.ClassificationID);
BadRequestErrorMessageResult badRequest = jsonRet as BadRequestErrorMessageResult;
Assert.IsNull(badRequest);
// Put to return success
IHttpActionResult jsonRet2 = classificationController.Put(classificationRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet2);
OkNegotiatedContentResult <Classification> classificationRet2 = jsonRet2 as OkNegotiatedContentResult <Classification>;
Assert.IsNotNull(classificationRet2);
BadRequestErrorMessageResult badRequest2 = jsonRet2 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest2);
// Put to return CSSPError because ClassificationID of 0 does not exist
classificationRet.ClassificationID = 0;
IHttpActionResult jsonRet3 = classificationController.Put(classificationRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet3);
OkNegotiatedContentResult <Classification> classificationRet3 = jsonRet3 as OkNegotiatedContentResult <Classification>;
Assert.IsNull(classificationRet3);
BadRequestErrorMessageResult badRequest3 = jsonRet3 as BadRequestErrorMessageResult;
Assert.IsNotNull(badRequest3);
}
}
}
public IHttpActionResult GetClassificationList([FromUri] string lang = "en", [FromUri] int skip = 0, [FromUri] int take = 200,
[FromUri] string asc = "", [FromUri] string desc = "", [FromUri] string where = "", [FromUri] string extra = "")
{
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
ClassificationService classificationService = new ClassificationService(new Query()
{
Lang = lang
}, db, ContactID);
private SimplifiedClassificationInfo(string name)
{
Name = name;
var info = ClassificationService.GetDefaultOption(name);
IsDisabled = info.IsDisabled;
IsDisabledInXml = info.IsDisabledInXml;
IsDisabledInEditor = info.IsDisabledInEditor;
IsDisabledInQuickInfo = info.IsDisabledInQuickInfo;
}
static void Main(string[] args)
{
string json = File.ReadAllText("importSettings.json");
var settings = JsonConvert.DeserializeObject <ImportSettings>(json);
decimal total = 0;
foreach (var file in settings.Files)
{
System.Console.WriteLine($"File {file}");
System.Console.WriteLine("--------------------------------------------");
using (var stream = File.OpenRead(file))
{
IImportService importService = new ImportService();
var result = importService.Import(stream, "csv", "ANZ");
IClassificationService classificationService = new ClassificationService();
classificationService.Classify(result.Transactions, settings.Categories, settings.Tags);
decimal subtotal = 0;
foreach (var t in result.Transactions.Where(t => t.Category != null || t.Tags.Any()))
{
System.Console.WriteLine($"{t.Date.ToString("dd/MM/yyyy")}\t${t.Amount.ToString()}\t{t.Description}");
System.Console.WriteLine($"\tCategory: { t.Category?.Name ?? "No category" }");
if (t.Tags.Any())
{
System.Console.WriteLine($"\tTags: {t.Tags?.Select(x => x.Name).Aggregate((a, b) => $"{a}, {b}") ?? "No tags"}");
}
else
{
System.Console.WriteLine("\tTags: No tags");
}
subtotal += t.Amount;
}
total += subtotal;
System.Console.WriteLine("-------------------");
System.Console.WriteLine("Total: ${0}", subtotal);
System.Console.WriteLine();
}
}
System.Console.WriteLine("Full total: ${0}", total);
if (System.Diagnostics.Debugger.IsAttached)
{
System.Console.WriteLine("Press any key to continue...");
System.Console.ReadLine();
}
}
public void Classification_CRUD_Test()
{
foreach (CultureInfo culture in AllowableCulture)
{
ChangeCulture(culture);
using (CSSPDBContext dbTestDB = new CSSPDBContext(DatabaseTypeEnum.SqlServerTestDB))
{
ClassificationService classificationService = new ClassificationService(new Query()
{
Lang = culture.TwoLetterISOLanguageName
}, dbTestDB, ContactID);
int count = 0;
if (count == 1)
{
// just so we don't get a warning during compile [The variable 'count' is assigned but its value is never used]
}
Classification classification = GetFilledRandomClassification("");
// -------------------------------
// -------------------------------
// CRUD testing
// -------------------------------
// -------------------------------
count = classificationService.GetClassificationList().Count();
Assert.AreEqual(count, (from c in dbTestDB.Classifications select c).Count());
classificationService.Add(classification);
if (classification.HasErrors)
{
Assert.AreEqual("", classification.ValidationResults.FirstOrDefault().ErrorMessage);
}
Assert.AreEqual(true, classificationService.GetClassificationList().Where(c => c == classification).Any());
classificationService.Update(classification);
if (classification.HasErrors)
{
Assert.AreEqual("", classification.ValidationResults.FirstOrDefault().ErrorMessage);
}
Assert.AreEqual(count + 1, classificationService.GetClassificationList().Count());
classificationService.Delete(classification);
if (classification.HasErrors)
{
Assert.AreEqual("", classification.ValidationResults.FirstOrDefault().ErrorMessage);
}
Assert.AreEqual(count, classificationService.GetClassificationList().Count());
}
}
}
public MigrationController(
DataProcessingService dataProcessingService,
BuyersService buyersService,
SuppliersService suppliersService,
ClassificationService classificationService,
CuentasClarasContext db)
{
this.dataProcessingService = dataProcessingService;
this.db = db;
this.buyersService = buyersService;
this.suppliersService = suppliersService;
this.classificationService = classificationService;
}
public IHttpActionResult GetClassificationWithID([FromUri] int ClassificationID, [FromUri] string lang = "en", [FromUri] string extra = "")
{
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
ClassificationService classificationService = new ClassificationService(new Query()
{
Language = (lang == "fr" ? LanguageEnum.fr : LanguageEnum.en)
}, db, ContactID);
classificationService.Query = classificationService.FillQuery(typeof(Classification), lang, 0, 1, "", "", extra);
if (classificationService.Query.Extra == "A")
{
ClassificationExtraA classificationExtraA = new ClassificationExtraA();
classificationExtraA = classificationService.GetClassificationExtraAWithClassificationID(ClassificationID);
if (classificationExtraA == null)
{
return(NotFound());
}
return(Ok(classificationExtraA));
}
else if (classificationService.Query.Extra == "B")
{
ClassificationExtraB classificationExtraB = new ClassificationExtraB();
classificationExtraB = classificationService.GetClassificationExtraBWithClassificationID(ClassificationID);
if (classificationExtraB == null)
{
return(NotFound());
}
return(Ok(classificationExtraB));
}
else
{
Classification classification = new Classification();
classification = classificationService.GetClassificationWithClassificationID(ClassificationID);
if (classification == null)
{
return(NotFound());
}
return(Ok(classification));
}
}
}
public async Task <ActionResult <ImageClassificationResponseDTO> > Classify(ImageClassificationRequestDTO request)
{
var service = new GoogleService();
var classificationService = new ClassificationService();
ImageRecognitionRequestDTO dto = new ImageRecognitionRequestDTO(new Image(request.Base64));
dto.Features.Add(new Feature("LABEL_DETECTION"));
dto.Features.Add(new Feature("IMAGE_PROPERTIES"));
var requestDto = new GoogleVisionRequest();
requestDto.Requests.Add(dto);
var visionDto = await service.GetGoogleVisionResponseAsync(requestDto);
return(classificationService.ConvertToClassificationDto(visionDto));
}
public async Task ClassifyImageCharacters()
{
FormFile file;
using (var stream = File.OpenRead(@"E:\AOIS\AOIS3.Prep\AOIS3.Prep\Cyrillic\25_3.bmp"))
{
stream.Position = 0;
file = new FormFile(stream, 0, stream.Length, null, Path.GetFileName(stream.Name))
{
Headers = new HeaderDictionary(),
ContentType = "image/bmp"
};
}
ClassificationService service = new ClassificationService();
string result = await service.ClassifyImageCharacters(file);
Assert.Equal("х", result);
}
public void Classification_Controller_GetClassificationWithID_Test()
{
foreach (LanguageEnum LanguageRequest in AllowableLanguages)
{
foreach (int ContactID in new List <int>()
{
AdminContactID
}) //, TestEmailValidatedContactID, TestEmailNotValidatedContactID })
{
ClassificationController classificationController = new ClassificationController(DatabaseTypeEnum.SqlServerTestDB);
Assert.IsNotNull(classificationController);
Assert.AreEqual(DatabaseTypeEnum.SqlServerTestDB, classificationController.DatabaseType);
Classification classificationFirst = new Classification();
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
ClassificationService classificationService = new ClassificationService(new Query(), db, ContactID);
classificationFirst = (from c in db.Classifications select c).FirstOrDefault();
}
// ok with Classification info
IHttpActionResult jsonRet = classificationController.GetClassificationWithID(classificationFirst.ClassificationID);
Assert.IsNotNull(jsonRet);
OkNegotiatedContentResult <Classification> Ret = jsonRet as OkNegotiatedContentResult <Classification>;
Classification classificationRet = Ret.Content;
Assert.AreEqual(classificationFirst.ClassificationID, classificationRet.ClassificationID);
BadRequestErrorMessageResult badRequest = jsonRet as BadRequestErrorMessageResult;
Assert.IsNull(badRequest);
// Not Found
IHttpActionResult jsonRet2 = classificationController.GetClassificationWithID(0);
Assert.IsNotNull(jsonRet2);
OkNegotiatedContentResult <Classification> classificationRet2 = jsonRet2 as OkNegotiatedContentResult <Classification>;
Assert.IsNull(classificationRet2);
NotFoundResult notFoundRequest = jsonRet2 as NotFoundResult;
Assert.IsNotNull(notFoundRequest);
}
}
}
public IHttpActionResult Delete([FromBody] Classification classification, [FromUri] string lang = "en")
{
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
ClassificationService classificationService = new ClassificationService(new Query()
{
Language = (lang == "fr" ? LanguageEnum.fr : LanguageEnum.en)
}, db, ContactID);
if (!classificationService.Delete(classification))
{
return(BadRequest(String.Join("|||", classification.ValidationResults)));
}
else
{
classification.ValidationResults = null;
return(Ok(classification));
}
}
}
/// <summary>
/// Creates the default classification from <paramref name="formatting"/>
/// which doesn't set the default values for properties that can be reset
/// </summary>
public static ClassificationSettings ToDefaultSettings(
this TextFormattingRunProperties formatting, string classificationName)
{
var defaultOption = ClassificationService.GetDefaultOption(classificationName);
return(new ClassificationSettings
{
Name = classificationName,
FontFamily = formatting.GetFontFamily(),
IsBold = formatting.Bold,
FontStyle = formatting.GetFontStyleName(),
IsOverline = formatting.TextDecorations.Contains(TextDecorations.OverLine[0]),
IsUnderline = formatting.TextDecorations.Contains(TextDecorations.Underline[0]),
IsStrikethrough = formatting.TextDecorations.Contains(TextDecorations.Strikethrough[0]),
IsBaseline = formatting.TextDecorations.Contains(TextDecorations.Baseline[0]),
IsDisabled = defaultOption.IsDisabled,
IsDisabledInXml = defaultOption.IsDisabledInXml,
IsDisabledInEditor = defaultOption.IsDisabledInEditor,
IsDisabledInQuickInfo = defaultOption.IsDisabledInQuickInfo,
});
}
public void GetClassificationList_Test()
{
foreach (CultureInfo culture in AllowableCulture)
{
ChangeCulture(culture);
using (CSSPDBContext dbTestDB = new CSSPDBContext(DatabaseTypeEnum.SqlServerTestDB))
{
ClassificationService classificationService = new ClassificationService(new Query()
{
Lang = culture.TwoLetterISOLanguageName
}, dbTestDB, ContactID);
Classification classification = (from c in dbTestDB.Classifications select c).FirstOrDefault();
Assert.IsNotNull(classification);
List <Classification> classificationDirectQueryList = new List <Classification>();
classificationDirectQueryList = (from c in dbTestDB.Classifications select c).Take(200).ToList();
foreach (string extra in new List <string>()
{
null, "A", "B", "C", "D", "E"
})
{
classificationService.Query.Extra = extra;
if (string.IsNullOrWhiteSpace(extra))
{
List <Classification> classificationList = new List <Classification>();
classificationList = classificationService.GetClassificationList().ToList();
CheckClassificationFields(classificationList);
}
else
{
//Assert.AreEqual(true, false);
}
}
}
}
}
public void GetClassificationList_2Where_Test()
{
foreach (CultureInfo culture in AllowableCulture)
{
ChangeCulture(culture);
using (CSSPDBContext dbTestDB = new CSSPDBContext(DatabaseTypeEnum.SqlServerTestDB))
{
foreach (string extra in new List <string>()
{
null, "A", "B", "C", "D", "E"
})
{
ClassificationService classificationService = new ClassificationService(new Query()
{
Lang = culture.TwoLetterISOLanguageName
}, dbTestDB, ContactID);
classificationService.Query = classificationService.FillQuery(typeof(Classification), culture.TwoLetterISOLanguageName, 0, 10000, "", "", "ClassificationID,GT,2|ClassificationID,LT,5", extra);
List <Classification> classificationDirectQueryList = new List <Classification>();
classificationDirectQueryList = (from c in dbTestDB.Classifications select c).Where(c => c.ClassificationID > 2 && c.ClassificationID < 5).ToList();
if (string.IsNullOrWhiteSpace(extra))
{
List <Classification> classificationList = new List <Classification>();
classificationList = classificationService.GetClassificationList().ToList();
CheckClassificationFields(classificationList);
Assert.AreEqual(classificationDirectQueryList[0].ClassificationID, classificationList[0].ClassificationID);
}
else
{
//Assert.AreEqual(true, false);
}
}
}
}
}
public void Test()
{
var transactions = new List <Transaction>();
transactions.Add(new Transaction(new DateTime(2017, 4, 7), 7777.77m, "PAY/SALARY FROM SUPERIOR SOFTWAR FORTNIGHTLY SALARY"));
transactions.Add(new Transaction(new DateTime(2017, 4, 5), -1000m, "ANZ M-BANKING PAYMENT TRANSFER 1234 TO LAND LORD"));
transactions.Add(new Transaction(new DateTime(2017, 4, 1), -10m, "MISC thing"));
List <TagDefinition> tagDefs = new List <TagDefinition>();
tagDefs.Add(new TagDefinition("ssw", "SSW", new[] { "FROM SUPERIOR SOFTWAR" }, new string[0]));
tagDefs.Add(new TagDefinition("salary", "Salary", new[] { "SALARY" }, new string[0]));
tagDefs.Add(new TagDefinition("rent", "Rent", new[] { "LAND LORD" }, new string[0]));
tagDefs.Add(new TagDefinition("land-lord", "Land lord", new[] { "LAND LORD" }, new string[0]));
List <CategoryDefinition> categoryDefs = new List <CategoryDefinition>();
categoryDefs.Add(new CategoryDefinition("salary", "Salary", new[] { "FROM SUPERIOR SOFTWAR" }, new string[0]));
categoryDefs.Add(new CategoryDefinition("home", "Home and Utillities", new[] { "LAND LORD" }, new string[0]));
var undefined = new Category("xyz", "XYZ");
IClassificationService service = new ClassificationService();
service.Classify(transactions, categoryDefs, tagDefs, undefined);
Assert.IsTrue(transactions[0].Tags.Any(t => t.Id == "ssw"));
Assert.IsTrue(transactions[0].Tags.Any(t => t.Id == "salary"));
Assert.IsTrue(transactions[1].Tags.Any(t => t.Id == "rent"));
Assert.IsNotNull(transactions[0].Category);
Assert.IsNotNull(transactions[1].Category);
Assert.IsNotNull(transactions[2].Category);
Assert.AreEqual("salary", transactions[0].Category.Id);
Assert.AreEqual("home", transactions[1].Category.Id);
Assert.AreEqual("xyz", transactions[2].Category.Id);
}
private static RoslynTextBufferClassifier GetClassifier(
ProgrammingLanguage language, IReadOnlyList <SimplifiedClassificationInfo> infos)
{
var dictionary = infos?.ToDictionary(x => x.Name);
var classificationTypes = new Dictionary <string, ClassificationInfo>(32);
var names = language == ProgrammingLanguage.VisualBasic ? VisualBasicNames.All : CSharpNames.All;
foreach (var name in names)
{
var option = dictionary is null || !dictionary.TryGetValue(name, out var simplifiedInfo)
? ClassificationService.GetDefaultOption(name)
: simplifiedInfo;
classificationTypes.Add(name, new ClassificationInfo(new ClassificationType(name), option));
}
if (language == ProgrammingLanguage.VisualBasic)
{
VisualBasicClassifierService.Reset();
return(new VisualBasicTextBufferClassifier(classificationTypes));
}
CSharpClassifierService.Reset();
return(new CSharpTextBufferClassifier(classificationTypes));
}
public LocateController()
{
_hubService = new HubService();
_classificationService = new ClassificationService();
}
public void Initialize()
{
service = new MasterClassificationService();
service.DeleteAllBooks();
}
public IHttpActionResult GetClassificationList([FromUri] string lang = "en", [FromUri] int skip = 0, [FromUri] int take = 200,
[FromUri] string asc = "", [FromUri] string desc = "", [FromUri] string where = "", [FromUri] string extra = "")
{
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
ClassificationService classificationService = new ClassificationService(new Query()
{
Lang = lang
}, db, ContactID);
if (extra == "A") // QueryString contains [extra=A]
{
classificationService.Query = classificationService.FillQuery(typeof(ClassificationExtraA), lang, skip, take, asc, desc, where, extra);
if (classificationService.Query.HasErrors)
{
return(Ok(new List <ClassificationExtraA>()
{
new ClassificationExtraA()
{
HasErrors = classificationService.Query.HasErrors,
ValidationResults = classificationService.Query.ValidationResults,
},
}.ToList()));
}
else
{
return(Ok(classificationService.GetClassificationExtraAList().ToList()));
}
}
else if (extra == "B") // QueryString contains [extra=B]
{
classificationService.Query = classificationService.FillQuery(typeof(ClassificationExtraB), lang, skip, take, asc, desc, where, extra);
if (classificationService.Query.HasErrors)
{
return(Ok(new List <ClassificationExtraB>()
{
new ClassificationExtraB()
{
HasErrors = classificationService.Query.HasErrors,
ValidationResults = classificationService.Query.ValidationResults,
},
}.ToList()));
}
else
{
return(Ok(classificationService.GetClassificationExtraBList().ToList()));
}
}
else // QueryString has no parameter [extra] or extra is empty
{
classificationService.Query = classificationService.FillQuery(typeof(Classification), lang, skip, take, asc, desc, where, extra);
if (classificationService.Query.HasErrors)
{
return(Ok(new List <Classification>()
{
new Classification()
{
HasErrors = classificationService.Query.HasErrors,
ValidationResults = classificationService.Query.ValidationResults,
},
}.ToList()));
}
else
{
return(Ok(classificationService.GetClassificationList().ToList()));
}
}
}
}
public void Classification_Controller_Post_Test()
{
foreach (LanguageEnum LanguageRequest in AllowableLanguages)
{
foreach (int ContactID in new List <int>()
{
AdminContactID
}) //, TestEmailValidatedContactID, TestEmailNotValidatedContactID })
{
ClassificationController classificationController = new ClassificationController(DatabaseTypeEnum.SqlServerTestDB);
Assert.IsNotNull(classificationController);
Assert.AreEqual(DatabaseTypeEnum.SqlServerTestDB, classificationController.DatabaseType);
Classification classificationLast = new Classification();
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
Query query = new Query();
query.Language = LanguageRequest;
query.Asc = "";
query.Desc = "";
ClassificationService classificationService = new ClassificationService(query, db, ContactID);
classificationLast = (from c in db.Classifications select c).FirstOrDefault();
}
// ok with Classification info
IHttpActionResult jsonRet = classificationController.GetClassificationWithID(classificationLast.ClassificationID);
Assert.IsNotNull(jsonRet);
OkNegotiatedContentResult <Classification> Ret = jsonRet as OkNegotiatedContentResult <Classification>;
Classification classificationRet = Ret.Content;
Assert.AreEqual(classificationLast.ClassificationID, classificationRet.ClassificationID);
BadRequestErrorMessageResult badRequest = jsonRet as BadRequestErrorMessageResult;
Assert.IsNull(badRequest);
// Post to return CSSPError because ClassificationID exist
IHttpActionResult jsonRet2 = classificationController.Post(classificationRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet2);
OkNegotiatedContentResult <Classification> classificationRet2 = jsonRet2 as OkNegotiatedContentResult <Classification>;
Assert.IsNull(classificationRet2);
BadRequestErrorMessageResult badRequest2 = jsonRet2 as BadRequestErrorMessageResult;
Assert.IsNotNull(badRequest2);
// Post to return newly added Classification
classificationRet.ClassificationID = 0;
classificationController.Request = new System.Net.Http.HttpRequestMessage();
classificationController.Request.RequestUri = new System.Uri("http://localhost:5000/api/classification");
IHttpActionResult jsonRet3 = classificationController.Post(classificationRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet3);
CreatedNegotiatedContentResult <Classification> classificationRet3 = jsonRet3 as CreatedNegotiatedContentResult <Classification>;
Assert.IsNotNull(classificationRet3);
BadRequestErrorMessageResult badRequest3 = jsonRet3 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest3);
IHttpActionResult jsonRet4 = classificationController.Delete(classificationRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet4);
OkNegotiatedContentResult <Classification> classificationRet4 = jsonRet4 as OkNegotiatedContentResult <Classification>;
Assert.IsNotNull(classificationRet4);
BadRequestErrorMessageResult badRequest4 = jsonRet4 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest4);
}
}
}
public IndexModel(ILogger <IndexModel> logger, ClassificationService classificationService)
{
_logger = logger;
_classificationService = classificationService;
}
public void Classification_Controller_GetClassificationList_Test()
{
foreach (LanguageEnum LanguageRequest in AllowableLanguages)
{
foreach (int ContactID in new List <int>()
{
AdminContactID
}) //, TestEmailValidatedContactID, TestEmailNotValidatedContactID })
{
ClassificationController classificationController = new ClassificationController(DatabaseTypeEnum.SqlServerTestDB);
Assert.IsNotNull(classificationController);
Assert.AreEqual(DatabaseTypeEnum.SqlServerTestDB, classificationController.DatabaseType);
Classification classificationFirst = new Classification();
int count = -1;
Query query = new Query();
using (CSSPDBContext db = new CSSPDBContext(DatabaseTypeEnum.SqlServerTestDB))
{
ClassificationService classificationService = new ClassificationService(query, db, ContactID);
classificationFirst = (from c in db.Classifications select c).FirstOrDefault();
count = (from c in db.Classifications select c).Count();
count = (query.Take > count ? count : query.Take);
}
// ok with Classification info
IHttpActionResult jsonRet = classificationController.GetClassificationList();
Assert.IsNotNull(jsonRet);
OkNegotiatedContentResult <List <Classification> > ret = jsonRet as OkNegotiatedContentResult <List <Classification> >;
Assert.AreEqual(classificationFirst.ClassificationID, ret.Content[0].ClassificationID);
Assert.AreEqual((count > query.Take ? query.Take : count), ret.Content.Count);
List <Classification> classificationList = new List <Classification>();
count = -1;
query = new Query();
using (CSSPDBContext db = new CSSPDBContext(DatabaseTypeEnum.SqlServerTestDB))
{
ClassificationService classificationService = new ClassificationService(query, db, ContactID);
classificationList = (from c in db.Classifications select c).OrderBy(c => c.ClassificationID).Skip(0).Take(2).ToList();
count = (from c in db.Classifications select c).Count();
}
if (count > 0)
{
query.Skip = 0;
query.Take = 5;
count = (query.Take > count ? query.Take : count);
// ok with Classification info
jsonRet = classificationController.GetClassificationList(query.Language.ToString(), query.Skip, query.Take);
Assert.IsNotNull(jsonRet);
ret = jsonRet as OkNegotiatedContentResult <List <Classification> >;
Assert.AreEqual(classificationList[0].ClassificationID, ret.Content[0].ClassificationID);
Assert.AreEqual((count > query.Take ? query.Take : count), ret.Content.Count);
if (count > 1)
{
query.Skip = 1;
query.Take = 5;
count = (query.Take > count ? query.Take : count);
// ok with Classification info
IHttpActionResult jsonRet2 = classificationController.GetClassificationList(query.Language.ToString(), query.Skip, query.Take);
Assert.IsNotNull(jsonRet2);
OkNegotiatedContentResult <List <Classification> > ret2 = jsonRet2 as OkNegotiatedContentResult <List <Classification> >;
Assert.AreEqual(classificationList[1].ClassificationID, ret2.Content[0].ClassificationID);
Assert.AreEqual((count > query.Take ? query.Take : count), ret2.Content.Count);
}
}
}
}
}
public void Classification_Properties_Test()
{
foreach (CultureInfo culture in AllowableCulture)
{
ChangeCulture(culture);
using (CSSPDBContext dbTestDB = new CSSPDBContext(DatabaseTypeEnum.SqlServerTestDB))
{
ClassificationService classificationService = new ClassificationService(new Query()
{
Lang = culture.TwoLetterISOLanguageName
}, dbTestDB, ContactID);
int count = 0;
if (count == 1)
{
// just so we don't get a warning during compile [The variable 'count' is assigned but its value is never used]
}
count = classificationService.GetClassificationList().Count();
Classification classification = GetFilledRandomClassification("");
// -------------------------------
// -------------------------------
// Properties testing
// -------------------------------
// -------------------------------
// -----------------------------------
// [Key]
// Is NOT Nullable
// classification.ClassificationID (Int32)
// -----------------------------------
classification = null;
classification = GetFilledRandomClassification("");
classification.ClassificationID = 0;
classificationService.Update(classification);
Assert.AreEqual(string.Format(CSSPServicesRes._IsRequired, "ClassificationID"), classification.ValidationResults.FirstOrDefault().ErrorMessage);
classification = null;
classification = GetFilledRandomClassification("");
classification.ClassificationID = 10000000;
classificationService.Update(classification);
Assert.AreEqual(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "Classification", "ClassificationID", classification.ClassificationID.ToString()), classification.ValidationResults.FirstOrDefault().ErrorMessage);
// -----------------------------------
// Is NOT Nullable
// [CSSPExist(ExistTypeName = "TVItem", ExistPlurial = "s", ExistFieldID = "TVItemID", AllowableTVtypeList = Classification)]
// classification.ClassificationTVItemID (Int32)
// -----------------------------------
classification = null;
classification = GetFilledRandomClassification("");
classification.ClassificationTVItemID = 0;
classificationService.Add(classification);
Assert.AreEqual(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "ClassificationTVItemID", classification.ClassificationTVItemID.ToString()), classification.ValidationResults.FirstOrDefault().ErrorMessage);
classification = null;
classification = GetFilledRandomClassification("");
classification.ClassificationTVItemID = 1;
classificationService.Add(classification);
Assert.AreEqual(string.Format(CSSPServicesRes._IsNotOfType_, "ClassificationTVItemID", "Classification"), classification.ValidationResults.FirstOrDefault().ErrorMessage);
// -----------------------------------
// Is NOT Nullable
// [CSSPEnumType]
// classification.ClassificationType (ClassificationTypeEnum)
// -----------------------------------
classification = null;
classification = GetFilledRandomClassification("");
classification.ClassificationType = (ClassificationTypeEnum)1000000;
classificationService.Add(classification);
Assert.AreEqual(string.Format(CSSPServicesRes._IsRequired, "ClassificationType"), classification.ValidationResults.FirstOrDefault().ErrorMessage);
// -----------------------------------
// Is NOT Nullable
// [Range(0, 10000)]
// classification.Ordinal (Int32)
// -----------------------------------
classification = null;
classification = GetFilledRandomClassification("");
classification.Ordinal = -1;
Assert.AreEqual(false, classificationService.Add(classification));
Assert.AreEqual(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Ordinal", "0", "10000"), classification.ValidationResults.FirstOrDefault().ErrorMessage);
Assert.AreEqual(count, classificationService.GetClassificationList().Count());
classification = null;
classification = GetFilledRandomClassification("");
classification.Ordinal = 10001;
Assert.AreEqual(false, classificationService.Add(classification));
Assert.AreEqual(string.Format(CSSPServicesRes._ValueShouldBeBetween_And_, "Ordinal", "0", "10000"), classification.ValidationResults.FirstOrDefault().ErrorMessage);
Assert.AreEqual(count, classificationService.GetClassificationList().Count());
// -----------------------------------
// Is NOT Nullable
// [CSSPAfter(Year = 1980)]
// classification.LastUpdateDate_UTC (DateTime)
// -----------------------------------
classification = null;
classification = GetFilledRandomClassification("");
classification.LastUpdateDate_UTC = new DateTime();
classificationService.Add(classification);
Assert.AreEqual(string.Format(CSSPServicesRes._IsRequired, "LastUpdateDate_UTC"), classification.ValidationResults.FirstOrDefault().ErrorMessage);
classification = null;
classification = GetFilledRandomClassification("");
classification.LastUpdateDate_UTC = new DateTime(1979, 1, 1);
classificationService.Add(classification);
Assert.AreEqual(string.Format(CSSPServicesRes._YearShouldBeBiggerThan_, "LastUpdateDate_UTC", "1980"), classification.ValidationResults.FirstOrDefault().ErrorMessage);
// -----------------------------------
// Is NOT Nullable
// [CSSPExist(ExistTypeName = "TVItem", ExistPlurial = "s", ExistFieldID = "TVItemID", AllowableTVtypeList = Contact)]
// classification.LastUpdateContactTVItemID (Int32)
// -----------------------------------
classification = null;
classification = GetFilledRandomClassification("");
classification.LastUpdateContactTVItemID = 0;
classificationService.Add(classification);
Assert.AreEqual(string.Format(CSSPServicesRes.CouldNotFind_With_Equal_, "TVItem", "LastUpdateContactTVItemID", classification.LastUpdateContactTVItemID.ToString()), classification.ValidationResults.FirstOrDefault().ErrorMessage);
classification = null;
classification = GetFilledRandomClassification("");
classification.LastUpdateContactTVItemID = 1;
classificationService.Add(classification);
Assert.AreEqual(string.Format(CSSPServicesRes._IsNotOfType_, "LastUpdateContactTVItemID", "Contact"), classification.ValidationResults.FirstOrDefault().ErrorMessage);
// -----------------------------------
// Is NOT Nullable
// [NotMapped]
// classification.HasErrors (Boolean)
// -----------------------------------
// No testing requied
// -----------------------------------
// Is NOT Nullable
// [NotMapped]
// classification.ValidationResults (IEnumerable`1)
// -----------------------------------
// No testing requied
}
}
}
// Token: 0x06000050 RID: 80 RVA: 0x0000346A File Offset: 0x0000166A
internal DLPClassificationProducer(ClassificationService classificationService, FASTClassificationStore ruleStore)
{
this.classificationService = classificationService;
this.ruleStore = ruleStore;
}
