Introduce basic label generation, qr generation, and engine logic

.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+    "vsicons.associations.folders": [
+        { "icon": "engine", "extensions": ["engine"], "format": "svg" }
+    ],
+}

service/src/main.rs → engine/src/main.rs

@@ -2,6 +2,7 @@ use tracing::info;
 
 mod router;
 mod state;
+mod permissions;
 
 #[tokio::main]
 async fn main() {

engine/src/permissions/default_rules.rs

@@ -0,0 +1,51 @@
+use crate::permissions::rule::{PermissionedEntity, Rule, RuleOutput};
+
+/**
+ * 
+ * Examples rules for permissions (impl Rule):
+ * - byOrg(ruleOutput, org)
+ * - byUser(ruleOutput, user)
+ * - byGroup(ruleOutput, group)
+ * 
+ */
+
+#[derive(Debug, Clone)]
+pub struct ByOrgRule {
+    pub rule_output: RuleOutput,
+    pub org: String,
+}
+
+impl Rule for ByOrgRule {
+    fn check(&self, entity: PermissionedEntity) -> RuleOutput {
+        match entity {
+            PermissionedEntity::Organization(org) => {
+                if org == self.org {
+                    self.rule_output
+                }
+                else {
+                    RuleOutput::PASSTHROUGH
+                }
+            },
+            _ => RuleOutput::PASSTHROUGH,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_by_org_rule() {
+        let rule = ByOrgRule {
+            rule_output: RuleOutput::READ,
+            org: "test".to_string(),
+        };
+
+        let entity = PermissionedEntity::Organization("test".to_string());
+        assert_eq!(rule.check(entity), RuleOutput::READ);
+
+        let entity = PermissionedEntity::Organization("other".to_string());
+        assert_eq!(rule.check(entity), RuleOutput::NONE);
+    }
+}

engine/src/permissions/mod.rs

@@ -0,0 +1,2 @@
+mod rule;
+mod default_rules;

engine/src/permissions/rule.rs

@@ -0,0 +1,18 @@
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum RuleOutput {
+    DISSALOW,
+    READ,
+    WRITE,
+    PASSTHROUGH,
+}
+
+#[derive(Debug, Clone)]
+pub enum PermissionedEntity {
+    Organization(String),
+    User(String),
+    Group(String),
+}
+
+pub trait Rule {
+    fn check(&self, entity: PermissionedEntity) -> RuleOutput;
+}