public EntityDecisionController()
{
Get("/api/v1/entity/decisions/active/get", _ => {
var rules = new List <IValidatorRule>()
{
new ShouldHaveParameters(new[] { "entity_guid", "entity_type" }),
new EntityShouldExist("entity_guid", "entity_type"),
new ShouldBeCorrectEnumValue("entity_type", typeof(EntityType)),
};
var errors = ValidationProcessor.Process(Request, rules, true);
if (errors.Count > 0)
{
return(HttpResponse.Errors(errors));
}
var entityType = (EntityType)GetRequestEnum("entity_type", typeof(EntityType));
var entityId = EntityUtils.GetEntityId(GetRequestStr("entity_guid"), entityType);
var decisions = EntityDecisionRepository.GetActive(entityId, entityType);
return(HttpResponse.Item("decisions", new DecisionTransformer().Many(decisions)));
});
}
public CardWorkCrudController()
{
Post("/api/v1/card/work/submit", _ => {
var errors = ValidationProcessor.Process(Request, new IValidatorRule[] {
new ShouldHaveParameters(new[] { "card_guid", "work_type_guid", "proof" }),
new ExistsInTable("card_guid", "cards", "guid"),
new ExistsInTable("work_type_guid", "project_work_types", "guid"),
});
if (errors.Count > 0)
{
return(HttpResponse.Errors(errors));
}
var me = UserRepository.Find(CurrentRequest.UserId);
var card = CardRepository.FindByGuid(GetRequestStr("card_guid"));
var workType = ProjectWorkTypeRepository.FindBy(
"guid", GetRequestStr("work_type_guid")
);
var work = CardWorkRepository.CreateAndGet(
me, card, workType, GetRequestStr("proof")
);
return(HttpResponse.Item("work_item", new CardWorkTransformer().Transform(work)));
});
}
public BoardColumnController()
{
Get("/api/v1/board_column/get", _ => {
var errors = ValidationProcessor.Process(Request, new IValidatorRule[] {
new ShouldHaveParameter("board_column_guid"),
new ExistsInTable("board_column_guid", "board_columns", "guid")
});
if (errors.Count > 0)
{
return(HttpResponse.Errors(errors));
}
return(HttpResponse.Item("board_column", new BoardColumnTransformer().Transform(
BoardColumnRepository.FindByGuid((string)Request.Query["board_column_guid"])
)));
});
Get("/api/v1/board/columns/get", _ => {
var errors = ValidationProcessor.Process(Request, new IValidatorRule[] {
new ShouldHaveParameter("board_guid"),
new ExistsInTable("board_guid", "boards", "guid")
});
if (errors.Count > 0)
{
return(HttpResponse.Errors(errors));
}
var board = BoardRepository.FindByGuid(GetRequestStr("board_guid"));
return(HttpResponse.Item("board_columns", new BoardColumnTransformer().Many(board.Columns())));
});
}
public UploadExposureKey(IMediator mediator, ValidationProcessor validation, IConfiguration configuration, IClientInfo clientInfo)
{
this.mediator = mediator;
this.validation = validation;
this.configuration = configuration;
this.clientInfo = clientInfo;
}
public EntityPermissionsController()
{
Get("/api/v1/entity/permissions/get", _ => {
var errors = ValidationProcessor.Process(Request, new IValidatorRule[] {
new ShouldHaveParameters(new[] { "entity_guid", "entity_type" }),
new ShouldBeCorrectEnumValue("entity_type", typeof(EntityType)),
new EntityShouldExist(),
}, true);
if (errors.Count > 0)
{
return(HttpResponse.Errors(errors));
}
var me = UserRepository.Find(CurrentRequest.UserId);
var entityType = (EntityType)GetRequestEnum("entity_type", typeof(EntityType));
var entityId = EntityUtils.GetEntityId(GetRequestStr("entity_guid"), entityType);
if (!PermissionUtils.HasEntityPermission(me, entityId, entityType))
{
return(HttpResponse.Item("permissions", new JArray()
{
}));
}
return(HttpResponse.Item("permissions", new JArray()
{
"read", "write"
}));
});
}
static void Main(string[] args)
{
const string filePath = @"U:\TestData\DSS.csv";
var fileReader = new FileReader();
char[] separator = { ',' };
var fieldNames = fileReader.GetHeaderFieldNamesFromFile(0, filePath, separator);
//var userRecords = fileReader.ReadFile(filePath, 1, fieldNames, separator);
var stream = File.OpenText(filePath);
var ignoreLines = 1;
var userRecords = fileReader.ReadStream(stream, ignoreLines, fieldNames, separator);
//These will come from database
var validatorDefs = new List <ValidatorDef>
{
new ValidatorDef("BarcodeId", "IsRequired"),
new ValidatorDef("AnimalID", "IsRequired"),
new ValidatorDef("DamRegistrationNumber", "number"),
new ValidatorDef("SexofAnimal", "Gender", "", "m,F,Male,Female,sire,dam,heifer,steer"),
};
var validationProcessor = new ValidationProcessor(validatorDefs);
if (!validationProcessor.RunValidatorsForAllObjects(fileReader.InputType, userRecords))
{
Console.WriteLine(validationProcessor.ErrorMessages.ToString());
EndProgram();
return;
}
var fileMapper = new FileMapper();
//These will come from database
IList <MapDefinition> mapDefs = new List <MapDefinition>();
mapDefs.Add(new MapDefinition()
{
InputName = "BarcodeId", OutputName = "BarcodeId"
});
mapDefs.Add(new MapDefinition()
{
InputName = "AnimalID", OutputName = "AnimalId"
});
mapDefs.Add(new MapDefinition()
{
InputName = "SexofAnimal", OutputName = "GenderOfAnimal"
});
mapDefs.Add(new MapDefinition()
{
InputName = "DamRegistrationNumber", OutputName = "DamRegistrationNumber"
});
var output = fileMapper.MapFields <OutPutRow>(userRecords, mapDefs, fileReader.InputType);
EndProgram();
}
private static ITypedReport <T> Validate <T>(List <T> rawData)
{
var factory = new XmlPipelineFactory();
var provider = new XmlValidatorDataProvider <string, T>(rawData);
var validator = new ValidationProcessor <string, XmlValidationContext>(factory);
return(validator.ValidateFeedXml(provider));
}
public void Validate_ValidatorListIsEmpty_ThrowProperlyValidatorIsNotRegisteredException()
{
var validators = new List <IValidator>();
var validationProcessor = new ValidationProcessor(validators);
Assert.That(() => validationProcessor.Validate(new object()),
Throws.InstanceOf <ProperlyValidatorIsNotRegisteredException>()
.And.Message.EqualTo(string.Format("Properly validator is not registered for type {0}", typeof(object).Name)));
}
public RepoController()
{
Get("/api/v1/repository/get", _ => {
var errors = ValidationProcessor.Process(Request, new IValidatorRule[] {
new ExistsInTable("repo_guid", "repositories", "guid"),
});
if (errors.Count > 0)
{
return(HttpResponse.Errors(errors));
}
return(HttpResponse.Item("repository", new RepoTransformer().Transform(
RepoRepository.FindByGuid((string)Request.Query["repo_guid"])
)));
});
Get("/api/v1/repository/meta/get", _ => {
var errors = ValidationProcessor.Process(Request, new IValidatorRule[] {
new ExistsInTable("repo_guid", "repositories", "guid"),
});
if (errors.Count > 0)
{
return(HttpResponse.Errors(errors));
}
var sponsorLinks = new JObject();
var repo = RepoRepository.FindByGuid((string)Request.Query["repo_guid"]);
if (repo.service_type == RepoServiceType.GitHub)
{
try {
var splitUrl = repo.repo_url.Split("/");
var response = new HttpClient().GetAsync(
$"https://raw.githubusercontent.com/{splitUrl[3]}/{splitUrl[4]}/master/.github/FUNDING.yml"
).Result.Content.ReadAsStringAsync().Result;
var yamlObject = (Dictionary <object, object>) new DeserializerBuilder().Build()
.Deserialize(new StringReader(response));
sponsorLinks["github"] = yamlObject["github"]?.ToString();
sponsorLinks["patreon"] = yamlObject["patreon"]?.ToString();
sponsorLinks["open_collective"] = yamlObject["open_collective"]?.ToString();
}
catch (Exception e) {
SentrySdk.CaptureException(e);
}
}
return(HttpResponse.Data(new JObject()
{
["repository"] = new RepoTransformer().Transform(repo)
["meta"] = new JObject()
{
["sponsor_links"] = sponsorLinks
}
}));
});
}
public ProjectTeamMemberCrudController()
{
Post("/api/v1/project_team_member/create", _ => {
var me = UserRepository.Find(CurrentRequest.UserId);
var project = ProjectRepository.FindByGuid(GetRequestStr("project_guid"));
var errors = ValidationProcessor.Process(Request, new IValidatorRule[] {
new ShouldHaveParameters(new[] { "project_guid", "user_guid" }),
new ExistsInTable("project_guid", "projects", "guid"),
new ExistsInTable("user_guid", "users", "guid"),
new HasPermission(me, project.id, EntityType.Project),
}, true);
if (errors.Count > 0)
{
return(HttpResponse.Errors(errors));
}
var user = UserRepository.FindByGuid(GetRequestStr("user_guid"));
var projectTeamMember = ProjectTeamMemberRepository.CreateAndGet(project, user);
return(HttpResponse.Item(
"project_team_member",
new ProjectTeamMemberTransformer().Transform(projectTeamMember), HttpStatusCode.Created
));
});
Delete("/api/v1/project_team_member/delete", _ => {
var me = UserRepository.Find(CurrentRequest.UserId);
var project = ProjectRepository.FindByGuid(GetRequestStr("project_guid"));
var errors = ValidationProcessor.Process(Request, new IValidatorRule[] {
new ExistsInTable("project_guid", "projects", "guid"),
new ExistsInTable("user_guid", "users", "guid"),
new HasPermission(me, project.id, EntityType.Project)
}, true);
if (errors.Count > 0)
{
return(HttpResponse.Errors(errors));
}
var projectTeamMember = ProjectTeamMemberRepository.FindByProjectAndUser(
GetRequestStr("project_guid"),
GetRequestStr("user_guid")
);
projectTeamMember.Delete();
return(HttpResponse.Item(
"project_team_member", new ProjectTeamMemberTransformer().Transform(projectTeamMember)
));
});
}
public void Validate_ValidatorIsNotRegistered_ThrowProperlyValidatorIsNotRegisteredException()
{
var instance = new object();
var validators = new List <IValidator> {
new StringValidator()
};
var validationProcessor = new ValidationProcessor(validators);
Assert.That(() => validationProcessor.Validate(instance),
Throws.InstanceOf <ProperlyValidatorIsNotRegisteredException>()
.And.Message.EqualTo(string.Format("Properly validator is not registered for type {0}", instance.GetType().Name)));
}
public void Validate_ValidatorIsRegisteredAndInstanceIsValid_ReturValidValidationStatus()
{
var instance = new object();
var validators = new List <IValidator> {
new StringValidator(), new ObjectValidator(new ValidationResult())
};
var validationProcessor = new ValidationProcessor(validators);
var validationStatus = validationProcessor.Validate(instance);
Assert.IsTrue(validationStatus.IsValid);
}
public ProjectCrudController()
{
Post("/api/v1/project/post/new", _ => {
var me = UserRepository.Find(CurrentRequest.UserId);
var project = ProjectRepository.FindByGuid(GetRequestStr("project_guid"));
if (project == null)
{
return(HttpResponse.Error(HttpStatusCode.NotFound, "Project not found"));
}
var errors = ValidationProcessor.Process(Request, new IValidatorRule[] {
new ShouldHaveParameters(new[] { "project_guid", "title", "content" }),
new ExistsInTable("project_guid", "projects", "guid"),
new HasPermission(me, project.id, EntityType.Project),
}, true);
if (errors.Count > 0)
{
return(HttpResponse.Errors(errors));
}
var post = ProjectPost.Create(
project, GetRequestStr("title"), GetRequestStr("content")
);
return(HttpResponse.Item(
"post", new ProjectPostTransformer().Transform(post), HttpStatusCode.Created
));
});
Delete("/api/v1/project/post/delete", _ => {
var post = ProjectPost.FindBy("guid", GetRequestStr("post_guid"));
if (post == null)
{
return(HttpResponse.Error(HttpStatusCode.NotFound, "Post not found"));
}
var me = UserRepository.Find(CurrentRequest.UserId);
var errors = ValidationProcessor.Process(Request, new IValidatorRule[] {
new ShouldHaveParameters(new[] { "post_guid" }),
new HasPermission(me, post.project_id, EntityType.Project),
}, true);
if (errors.Count > 0)
{
return(HttpResponse.Errors(errors));
}
post.Delete();
return(HttpResponse.Item("post", new ProjectPostTransformer().Transform(post)));
});
}
public GitlabAuthController()
{
var clientId = AppConfig.GetConfiguration("auth:external:gitlab:client_id");
var redirectUri = AppConfig.GetConfiguration("auth:external:gitlab:redirect_url");
Get("/api/v1/auth/gitlab/login_link/get", _ => {
var loginLink =
$"https://gitlab.com/oauth/authorize?client_id={clientId}&redirect_uri={redirectUri}" +
$"&response_type=token&scope={Scopes}";
return(HttpResponse.Data(new JObject()
{
["login_link"] = loginLink
}));
});
Get("/api/v1/auth/gitlab/get_auth_token", av => {
var errors = ValidationProcessor.Process(Request, new IValidatorRule[] {
new ShouldHaveParameters(new[] { "access_token" }),
});
if (errors.Count > 0)
{
return(HttpResponse.Errors(errors));
}
var accessToken = GetRequestStr("access_token");
var client = new GitLabClient(accessToken);
client.SetAuthorizedUser();
if (client.User == null)
{
return(HttpResponse.Error(HttpStatusCode.Unauthorized,
"We're unable to get your access token, please try again"));
}
var user = UserRepository.FindByEmail(client.User.Email) ??
UserRepository.FindOrCreateByEmailAndLogin(
client.User.Email,
client.User.Login,
null,
UserRepository.FindByGuid(GetRequestStr("referral_key"))
);
ServiceAccessTokenRepository.FindOrUpdateAccessToken(user, accessToken, ServiceType.GitLab);
return(HttpResponse.Data(new JObject()
{
["token"] = Jwt.FromUserId(user.id)
}));
});
}
public void Validate_ValidatorIsRegistered_NotProperlyValidatorValidateMustNotHasHappend()
{
var instance = new object();
var validators = new List <IValidator> {
new StringValidator(), new ObjectValidator(new ValidationResult())
};
var validationProcessor = new ValidationProcessor(validators);
validationProcessor.Validate(instance);
Assert.IsFalse((new StringValidator()).ValidateHasHappend);
}
public void Process_ItemNotExists_404()
{
var request = new Request("GET", "/");
request.Query["item_guid"] = Guid.NewGuid().ToString();
var errors = ValidationProcessor.Process(request, new IValidatorRule[] {
new ExistsInTable("item_guid", "items", "guid"),
});
Assert.True(errors.Count == 1);
Assert.True(errors.First().StatusCode == HttpStatusCode.NotFound);
}
private IReadOnlyCollection <HttpError> ValidateRequest(IValidatorRule[] validatorRules = null)
{
if (validatorRules == null)
{
validatorRules = new IValidatorRule[] {
new ExistsInTable("item_guid", "items", "guid"),
};
}
var errors = ValidationProcessor.Process(Request, validatorRules);
return(errors);
}
public void Process_ItemExists_Ok()
{
var item = ItemFaker.Create();
var request = new Request("GET", "/");
request.Query["item_guid"] = item.guid;
var errors = ValidationProcessor.Process(request, new IValidatorRule[] {
new ExistsInTable("item_guid", "items", "guid"),
});
Assert.Zero(errors.Count);
}
public WithdrawalsCrudController()
{
Post("/api/v1/me/withdrawal/new", _ => {
var errors = ValidationProcessor.Process(Request, new IValidatorRule[] {
new ShouldHaveParameters(new[] { "amount", "currency_type", "address" }),
new MinLength("address", 4),
new ShouldBeCorrectEnumValue("currency_type", typeof(CurrencyType)),
}, true);
if (errors.Count > 0)
{
return(HttpResponse.Errors(errors));
}
var me = UserRepository.Find(CurrentRequest.UserId);
var currencyType = (CurrencyType)GetRequestEnum("currency_type", typeof(CurrencyType));
decimal amount = System.Convert.ToDecimal(GetRequestStr("amount"));
if (amount < 0.01M)
{
return(HttpResponse.Error(HttpStatusCode.Forbidden, "Amount cannot be less than 0.01"));
}
var userBalance = UserBalanceRepository.Find(me, currencyType);
if (userBalance == null || amount > userBalance.balance)
{
return(HttpResponse.Error(HttpStatusCode.Forbidden, "You cannot withdraw more that you currently have"));
}
var address = GetRequestStr("address");
var withdrawalRequest = WithdrawalRequestRepository.Create(me, currencyType, amount, address);
return(HttpResponse.Item(
"withdraw_request", new WithdrawalRequestTransformer().Transform(withdrawalRequest),
HttpStatusCode.Created
));
});
Get("/api/v1/me/withdrawals/get", _ => {
var me = UserRepository.Find(CurrentRequest.UserId);
var withdrawalRequests = WithdrawalRequestRepository.Get(me);
return(HttpResponse.Item(
"withdraw_requests", new WithdrawalRequestTransformer().Many(withdrawalRequests)
));
});
}
public void Validate_ValidatorIsRegisteredAndInstanceIsNotValid_ReturnInvalidValidationStatus()
{
var instance = new object();
var objectValidator = new ObjectValidator(new ValidationResult(new List <ValidationFailure> {
new ValidationFailure("prop", "error")
}));
var validators = new List <IValidator> {
new StringValidator(), objectValidator
};
var validationProcessor = new ValidationProcessor(validators);
var validationStatus = validationProcessor.Validate(instance);
Assert.IsFalse(validationStatus.IsValid);
}
public UserProjectsController()
{
Get("/api/v1/user/projects/get", _ => {
var errors = ValidationProcessor.Process(Request, new IValidatorRule[] {
new ExistsInTable("user_guid", "users", "guid")
});
if (errors.Count > 0)
{
return(HttpResponse.Errors(errors));
}
var user = UserRepository.FindByGuid(GetRequestStr("user_guid"));
return(HttpResponse.Item("projects", new ProjectTransformer().Many(user.Projects())));
});
}
public UserController()
{
Get("/api/v1/user/get", _ => {
var errors = ValidationProcessor.Process(Request, new IValidatorRule[] {
new ShouldHaveParameters(new[] { "user_guid" }),
new ExistsInTable("user_guid", "users", "guid")
});
if (errors.Count > 0)
{
return(HttpResponse.Errors(errors));
}
var user = UserRepository.FindByGuid(GetRequestStr("user_guid"));
return(HttpResponse.Item("me", new UserTransformer().Transform(user)));
});
}
public ProjectImageController()
{
Get("/api/v1/project/images/get", _ => {
var errors = ValidationProcessor.Process(Request, new IValidatorRule[] {
new ExistsInTable("project_guid", "projects", "guid"),
});
if (errors.Count > 0)
{
return(HttpResponse.Errors(errors));
}
var project = ProjectRepository.FindByGuid(GetRequestStr("project_guid"));
return(HttpResponse.Item("images", new ImageTransformer().Many(project.Images())));
});
}
public MailingListController()
{
Post("/api/v1/mailing_list/subscribe", _ => {
var errors = ValidationProcessor.Process(Request, new IValidatorRule[] {
new ShouldHaveParameters(new[] { "email" }),
new ShouldBeValidEmail(),
}, true);
if (errors.Count > 0)
{
return(HttpResponse.Errors(errors));
}
var email = GetRequestStr("email");
var existingSubscriber = MailingListSubscriber.FindBy("email", email);
if (existingSubscriber == null)
{
MailingListSubscriber.Create(email);
}
return(HttpResponse.Data(new JObject()
{
["status"] = "subscribed"
}));
});
Delete("/api/v1/mailing_list/unsubscribe", _ => {
var errors = ValidationProcessor.Process(Request, new IValidatorRule[] {
new ShouldHaveParameters(new[] { "unsubscribe_key" })
});
if (errors.Count > 0)
{
return(HttpResponse.Errors(errors));
}
var subscriber = MailingListSubscriber.FindBy(
"unsubscribe_key", GetRequestStr("unsubscribe_key")
);
subscriber?.Delete();
return(HttpResponse.Data(new JObject()
{
["status"] = "unsubscribed"
}));
});
}
public void HeaderValidation_HappyPath()
{
var valProc = new ValidationProcessor(new List <ValidatorDef>());
var expectedHeaders = new List <string>()
{
"h1", "h2", "h3", "h4"
};
var actualHeaders = new List <string>()
{
"h1", "h2", "h3", "h4"
};
var result = valProc.HeaderValidation(expectedHeaders, actualHeaders);
Assert.IsTrue(result);
}
public CardRelationsController()
{
Get("/api/v1/card/project/get", _ => {
var errors = ValidationProcessor.Process(Request, new IValidatorRule[] {
new ShouldHaveParameter("card_guid"),
new ExistsInTable("card_guid", "cards", "guid")
});
if (errors.Count > 0)
{
return(HttpResponse.Errors(errors));
}
var card = CardRepository.FindByGuid(GetRequestStr("card_guid"));
return(HttpResponse.Item("project", new ProjectTransformer().Transform(card.Project())));
});
}
public void HeaderValidation_MissingColumns()
{
var valProc = new ValidationProcessor(new List <ValidatorDef>());
var expectedHeaders = new List <string>()
{
"h1", "h2", "h3", "h4"
};
var actualHeaders = new List <string>()
{
"h1", "h2", "h3"
};
var result = valProc.HeaderValidation(expectedHeaders, actualHeaders);
Assert.IsFalse(result, valProc.ErrorMessages.ToString());
Console.WriteLine(valProc.ErrorMessages.ToString());
}
public ProjectWorkTypeController()
{
Get("/api/v1/project/work_types/get", _ => {
var errors = ValidationProcessor.Process(Request, new IValidatorRule[] {
new ShouldHaveParameters(new[] { "project_guid" }),
new ExistsInTable("project_guid", "projects", "guid")
});
if (errors.Count > 0)
{
return(HttpResponse.Errors(errors));
}
var project = ProjectRepository.FindByGuid(GetRequestStr("project_guid"));
return(HttpResponse.Item(
"work_types", new ProjectWorkTypeTransformer().Many(project.WorkTypes())
));
});
}
public CardWorkController()
{
Get("/api/v1/card/work/get", _ => {
var errors = ValidationProcessor.Process(Request, new IValidatorRule[] {
new ShouldHaveParameters(new[] { "card_guid" }),
new ExistsInTable("card_guid", "cards", "guid")
});
if (errors.Count > 0)
{
return(HttpResponse.Errors(errors));
}
var card = CardRepository.FindByGuid(GetRequestStr("card_guid"));
return(HttpResponse.Item(
"work_items", new CardWorkTransformer().Many(card.SubmittedWork())
));
});
}
public FacebookAuthController()
{
Get("/api/v1/auth/facebook/my_token/get", _ => {
var errors = ValidationProcessor.Process(Request, new IValidatorRule[] {
new ShouldHaveParameters(new[] { "facebook_token" }),
});
if (errors.Count > 0)
{
return(HttpResponse.Errors(errors));
}
var facebookToken = GetRequestStr("facebook_token");
var response = new HttpClient().GetAsync(
ApiUrl + $"me?access_token={facebookToken}&fields=name,email"
).Result;
if (!response.IsSuccessStatusCode)
{
return(HttpResponse.Error(HttpStatusCode.BadRequest, "Invalid facebook token"));
}
var json = JObject.Parse(response.Content.ReadAsStringAsync().Result);
var email = json.Value <string>("email");
var login = email.Split("@")[0];
var user = UserRepository.FindByEmail(email) ??
UserRepository.FindOrCreateByEmailAndLogin(
email, login, null,
UserRepository.FindByGuid(GetRequestStr("referral_key"))
);
var accessToken =
ServiceAccessTokenRepository.FindOrUpdateAccessToken(user, facebookToken, ServiceType.Facebook);
accessToken.UpdateCol("origin_user_id", json.Value <string>("id"));
return(HttpResponse.Data(new JObject()
{
["token"] = Jwt.FromUserId(user.id)
}));
});
}
