תחומים - פורום חרדי מקצועי

באופן כללי ישנן חברות משלוחים שיכולים לקבל אליהם לכתובת מקומית בארה"ב ולשלוח אליך במשלוח רגיל.
סביר מאוד שזה לא יעצר במכס (אחרת מסתבר שהנזק גדול על התועלת).
אין לי כרגע שמות

בדיקת הרשאות (authentication ו- authotization) אמורה להיעשות בשלב מוקדם יותר, של ה middleware.
כלומר ב route אתה מגדיר לו איזה middleware הוא יעבור.

אבל אתה אכן צריך לפעמים לגשת גם אח"כ ל user, כדי לדעת האם יש לו גישה לרשומה הספציפית שהוא מבקש (נניח שאתה מרשה לו לקבל רשימת ספרים, אבל רק של אגף ספציפי).ואת זה אני לא חושב שתמיד אפשר לבדוק ב middleware. כי זה מחוץ ל scope שלה הרבה פעמים.

אני אישית מעביר את כל ה req. ואתה יכול לבנות middleware שיסדר לך אובייקט user בתוך ה req כרצונך.

לגבי הטרנזקציות, לא הבנתי את המקרה.

לגבי שאלה ב:
אני לא מבין איך אתה ניגש למודל לא דרך ה controller. כלומר מה בדיוק מבנה השרת אצלך.
אבל כמובן שהכל צריך להיות דרך ה controller.
ואגב, לדעתי את רוב הלוגיקה של משיכה מה DB צריך לכתוב במודל עצמו.
נניח findBookByAuthorName, או createNewBook.

ה controllre אמור להיות רק החלק האחרון שהבקשה מגיעה אליו, והוא עושה את בדיקת הנתונים וטיוב הנתונים שלא יכולנו לעשות לפני זה. כמו כן לעשות פעולות שלא קשורות למודל. כמו, לשלוח מייל. או לשלוח הודעה ב webSocket.

אך זו רק דעתי.

נ.ב. אני מחכה לפוסט שלך על ה-Sequelize.

הפתרון הנכון הוא להשתמש ב timeOut.
בדיוק בשביל זה הוא נועד.

אגב, מי בודק אם הכפתור נלחץ ואיך? האם זו פונקציה מובנית? (כי בעולם של מיקרו קונטרולרים כמו אדרואינו, זה לא דבר כ"כ פשוט. ברספברי אני לא מכיר).

אני בדיוק נדרש כעת לנושא זה.

לדעתי, כפי שכתבו כאן למעלה, ב API חיצוני, זה מאוד מתאים.

אבל בשביל סשן של דף וובי רגיל, זה פחות מתאים.

ההבדלים:

1. קשה (יותר) לבטל JWT, זה מצריך רשימה שחורה. וזה מוריד את כל הקאצ' של הטוקן.

2. ב JWT יש פחות התאמה לשמירת נתונים על הסשן הספציפי. (נניח רוצים לשמור רשימת קניות או כל state אחר.

אני משתמש ב JWT בשביל דברים שמצריכים סשן ארוך טווח. נראה לי לזה זה יותר מתאים.

איך כדאי לעשות כונן רשת משותף בלינוקס?
אני בעצם רוצה שתהיה תיקיה אחת משותפת בכמה שרתים.
ככשרת אחד הוא הראשי, וכל שרת ניגש לתיקיה הזו כresouce מקומי.

אין עושים ב NodeBB שיפתח קישורים בחלון חדש?
עם target _blank

לא הבנתי מה הבעיה?
לקרוא אנגלית קצת אתה יודע?
12V power זה ה+ של המתח
GND זה המינוס של המתח

LOCK com זה ה"מינוס" של המנעול.
Lock NC זה הפלוס של המנעול, פעיל במצב של סגירה
LOCK NO זה כמו הקודם אבל פעיל במצב פתיחה (או שזה הפוך. פשוט תנסה).

Button ו GND זה הכפתור עקיפה (צריך פשוט לקצר את שני החוטים בשביל לעקוף את הנעילה.

BELL+ ו BELL- זה החשמל לפעמון.

לא משנה לי הפלטפורמה.
אבל שיהיה מאוחסן אצלי בשרת.

מדובר על אתר תדמיתי סטטי. ללא בק אנד.

אשמח לקבל הצעות מחיר במייל avam.eps@gmail.com

הנייד שלי קיבל עדכון ווינדוס (10) אוטומטי.
ולא היה לי אינטרנט. (מתחבר לוייפי אבל אין אינטרנט בכל התוכנות).
הפתרון- להפעיל מחדש את המחשב.

מישהו נתקל בכזה דבר?

בסוף, הפתרון כנראה הוא ברמת הקליינט (ווב).
לקחתי מהשרת רשימה של items ושל group בנפרד. (כולל הקשרים הקרובים אליהם)
ואת הקשרים עשיתי עם לולאה פשוטה בצד לקוח.
זה פשוט משחזר את המבנה כמו שהתקבל בשרת.

וכנראה זה פתרון אמיתי ונכון.

ואוו. מעניין.
חדש לי.
ככה זה גם ב C#?

אני מנסה לעשות שירות משותף באנגולר לצורך העברת מידע בין ראוטרים שונים.

אני יודע שיש כל מיני דרכים להעביר את המידע, אבל אני מנסה להבין למה הקוד הבא לא עובד כראוי:

יש לי service בשם DataService שמכיל אובייקט בשם product

import { Injectable } from '@angular/core';
import { Product } from './product';
@Injectable({
  providedIn: 'root'
})
export class DataService {
  constructor() {
    this.product = {
      name: "Keyboard", id: 1
    }
  }
  public product: Product;
}

אני ניגש אליו מתוך appComponent

import { DataService } from './data.service';
@Component({
  selector: 'app-root',
  templateUrl: './app.component.html',
  styleUrls: ['./app.component.css']
})
export class AppComponent {
  product;
  dataService: DataService;
  constructor(dataService: DataService) {
    this.dataService = dataService;
    this.product = this.dataService.product;
    this.dataService.product = {
      name: "Computer", id: 1
    }
  }
}

ואני מציג אותו ע"י ה app.component.html

{{product | json}}

ציפיתי שאחרי שאשנה את המופע של ה dataService.product ל "Computer" בשורה 14, גם ה this.product ישתנה.
כי הרי חיברנו אותם בשורה 11?
למעשה זה לא קורה.
מה ההסבר לזה?

מבחינת SQL זה שאילתה אחת. (כי עשיתי include ו - thenInclude)
אחרת, ה SELECT לא יביא כלום

התכוונתי רקורסיה על המידע שEF הביא.
במקום לעשות כל דור בנפרד.
אביא דוגמה בל"נ בהמשך

אוקי.
בעצם זו עבודה ידנית לפלטר את מה שבדיוק רוצים.
חשבתי ש EF יפתור לי את זה.

אני שמח שלא טעיתי בזה ש EF לא אמור להתמודד עם סוג מבנה מידע כזה.

בכל אופן, אני יכול לעשות שם אולי רקורסיה? בשביל להביא את כל המידע הרלוונטי.

צריך לשים לב, במה שהראתי כאן, ITEM מחובר לקבוצה אחת בלבד כבן, אך יכול להיות מחובר למספר קבוצות בתור אב.

אלו שני קשרים נפרדים.
(לא עשיתי ש ITEM יוכל להתחבר לשני קבוצות, כי ITEM בעצמו הוא מימוש לאובייקט שלישי שלא הבאתי כאן, לדעתי אין בו עניין)

public class Item
    {
        public string Name { get; set; }

        public int? Id { get; set; }
        public int? Price { get; set; }

        public int? GroupId { get; set; }
        public Group Group { get; set; }

        public ICollection<Group> Groups { get; set; }
        public ICollection<Group2Item> Groups2Item { get; set; }
    }

 public class Group
    {
        [Key]
        public int? Id { get; set; }

        public string Name { get; set; }

        public List<Item> Items { get; set; }//parent
        public List<Group2Item> Group2Items{ get; set; }//parent
        
        public List<Item> ItemsChildren { get; set; }//children
}


    public class Group2Item
    {   [Key]
        public int Id { get; set; }

        public int ItemId { get; set; }
        public Item Item { get; set; }

        public int GroupId { get; set; }
        public Group Group{ get; set; }
    }


  protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
  modelBuilder.Entity<Item>()
            .HasOne<Group>(i => i.Group)
            .WithMany(o => o.ItemsChildren)
            .HasForeignKey(i=> i.GroupId);



            modelBuilder.Entity<Group>()
        .HasMany(g => g.Items)
        .WithMany(g=> g.Groups)

        .UsingEntity<Group2Item>(
            j => j
                .HasOne(pt => pt.Item)
                .WithMany(t => t.Groups2Item)
                .HasForeignKey(pt => pt.ItemId),
            j => j
                .HasOne(pt => pt.Group)
                .WithMany(p => p.Group2Items)
                .HasForeignKey(pt => pt.GroupId),
            j =>
            {  
                   j.HasKey(t => new { t.GroupId, t.ItemId });
            });
}

אני פיתחתי בתחום הזה.
אתה רוצה משהו מסחרי לתפוצה נרחבת? או משהו קטן?

יש מוצר אב.
למוצר אב יש קבוצת תוספים (מוצרים)
שמכילה עוד מוצרים.

דוגמה:
אב: מחשב DELL

קבוצת מוצרים מתאימים שמכילה: מסך, עכבר, מקלדת, מדפסת.

הקבוצה הזאת יכולה להיות מקושרת לעוד מוצרי אב. כגון מחשב LENOVO

גם למוצרים הבנים אפשר להוסיף עוד קבוצה שיש לה עוד מוצרים.

כגון:
למדפסת תהיה קבוצת תוספים שמכילה: דיו, דפים, טונר.
והקבוצה הזאת יכולה להתאים לעוד מוצרים. כגון מדפסת HP, מדפסת CANON וכו'.

לסיכום: יש כאן 2 אובייקטים בסה"כ
מוצר. מכיל שם, מחיר ורשימת קבוצות מקושרת
קבוצה: מכילה שם קבוצה ורשימת מוצרים בנים

 public class Item
 {
        public string Name { get; set; }
        public int Price{ get; set; }
}

 public class Group
{
        public string Name { get; set; }
}

אני רוצה לגשת למוצר ספציפי ולקבל את כל הקבוצות שלו ואת כל הבנים שלהם. ואם יש להם עוד קבוצות, לקבל את הקבוצות ואת הבנים שלהם.
(לא צריך עד אין סוף. מספיק לי 3 דורות).

כמו כן לגשת לרשימת כל המוצרים ולקבל את הנתונים כנ"ל.

זה לא מגביל את הקליינט בשליחת בקשה כמובן. רק התשובה תתמהמה מעט.