@יגעתי-ומצאתי לגבי המחיקה, הסיבה שלא יכולת למחוק הוא מפני שהעמודה מוגדרת כ-Display Value Field - הכוונה שהעמודה משתמשת עבור הצגת השורה (כאשר מקשרים שורה זו לטבלה אחרת השורה מוצגת על ידי התוכן של עמודה זו)
הפתרון הוא להחליף את ה-Display Value Field לעמודה אחרת (איזה עמודה שתבחר תעבור למיקום הראשון בטבלה - אחרי המספר)

@יגעתי-ומצאתי כתב במערכת לניהול תורמים יעבוד גם עם אתר?:

אבל משום מה אני לא מצליח למחוק חלק מהעמודות

גם אני, ניסיתי לבדוק, ובינתיים לא מצאתי פתרון. מקווה שזה לא באג אצלם.

אגב, לשנות את הtype של התאריך ושעה ג"כ לפורמט של תאריך ושעה ולא של טקסט, נכון?

כן

מה הרווח בזה?

יש פונקציות שעובדות על תאריך/שעה, למשל סינון לפי תאריך, לא מוקדם מ- או לא מאוחר מ-
זה לא יעבוד על שדה טקסט

הטייפ השולל: never

נחזור שוב ל-never לכמה רגעים
הטייפ never הוא סט בלי חברים, טייפ ששום ערך לא יכול להיות בו חבר.
נמצא שלא יקרה אף פעם שלערך אמיתי יהיה טייפ never
אם כן לְמָה זה טייפ שימושי?

שלילת מצב

אחד מהשימושים של טייפ זה הוא לסמן ל-TS שמצב מסויים אמור להיות בלתי אפשרי, ולקבל אישור מ-TS שזה באמת בלתי אפשרי
למשל: אם רוצים לוודא שב-switch עברנו על כל האפשרויות ולא פיספסנו אחד מהם בטעות אפשר לכתוב ככה:

type Color = 'red' | 'blue' | 'green'

function handleColor(color: Color) {
  switch (color) {
    case 'red':
      // ...
      break
    case 'blue':
      // ...
      break
    case 'green':
      // ...
      break
    default:
      throw new Error('Impossible!')
  }
}

פה אנחנו בודקים בזמן ריצה שלא הגענו לענף הבלתי אפשרי

אבל עם TS יש לנו אפשרות לבדוק בזמן קימפול שלא שכחנו לטפל בשום אפשרות
מוסיפים שורה זו:

type Color = 'red' | 'blue' | 'green'

function handleColor(color: Color) {
  switch (color) {
    case 'red':
      // ...
      break
    case 'blue':
      // ...
      break
    case 'green':
      // ...
      break
    default:
      const _test:never = color
      throw new Error('Impossible!')
  }
}

עיין שורה 15. אנחנו מצהירים ל-TS שבשלב הזה מיצינו את כל הערכים האפשריים ש-color יכול לקבל ופה הטייפ חייב להיות never, כלומר זה לא יקרה אף פעם
(להבין יותר איך זה עובד, כדאי להכיר את המושג narrowing, בקיצור נמרץ: מנוע TS עוקב אחרי משתנים תוך כדי זרימת הקוד וכאשר הוא רואה ביטויים מסויימים בקוד, הוא מבין אותם ומוציא מתוך ה-union של הטייפ של המשתנים את אותם הטייפים שהקוד שולל, ובהקשר שלנו, בכל ענף של ה-switch, מנוע TS יכיר בעובדה שהטייפ של color הוא רק הערך שאותו ענף מטפל, ובענף default הטייפ הוא האפשרויות שה-switch לא מיצה)
ברגע שנוסיף עוד אפשרות ל-union של Color נקבל מיד אזהרה שהמשתנה _test קיבל ערך שהטייפ שלו הוא לא never

שלילת ערך

אבל השימוש שמעניין אותנו יותר פה הוא השימוש השני,
כאשר יוצרים טייפ חדש באמצעות ביטוי עם תנאי, ורוצים שענף אחד של התנאי לא יחזיר שום טייפ, או יותר נכון: יחזיר טייפ ריק, במקום כזה בא never לידי שימוש
נדגים את זה על ידי ה-helper המובנה - Exclude
(helper הוא פונקציה שעוזר לבניית טייפ שמבוסס על טייפ קיים. נזכיר: פונקציה ב-TS == ‏generic)
הטייפ Exclude מגיע מובנה ב-TS ושימושו הוא כאשר רוצים ליצור מ-union קיים, טייפ שדומה למקור רק שחסר ממנו אחד או יותר ערכים.
למשל:

type Weekday = 'sunday' | 'monday' | 'tuesday' | 'wednesday' | 'thursday' | 'friday' | 'saturday'
type Workday = Exclude<Weekday, 'friday' | 'saturday'>

כפי שאפשר לראות: ה"פונקציה" Exclude מקבלת כפרמטר ראשון את הטייפ המקורי ובפרמטר השני union של טייפים (או טייפ יחיד) לחסר מהטייפ המקורי.

איך הוא עובד?
הנה קוד המקור

type Exclude<T, U> = T extends U ? never : T

להבין את זה צריך להקדים עוד דבר אחד: ביטוי של תנאי שמריצים על union עובד על כל אבר של ה-union בנפרד
בתיעוד של TS קוראים לזה: Distributive Conditional Types
כלומר זה עובד כמו הקוד פסואודו הבא:

function Conditional(source: Union, condition: Type => Bool, resultIfTrue: Type => Type, resultIfFalse: Type => Type) {
  const runConditional = (type: Type) => {
    if (condition(type)) {
      return resultIfTrue(type)
    } else {
      return resultIfFalse(type)
    }
  }
  return source.split('|').map(runConditional).join('|')
}

function Exclude(source: Union, exclusions: Union) {
  return Conditional(source, t => t.extends(exclusions), t => t, t => never)
}

Exclude(Weekday, 'friday' | 'saturday') // 'sunday' | 'monday' | 'tuesday' | 'wednesday' | 'thursday' | never | never

מקווה שהפסאודו קוד מובן
רק מזכיר שוב כמה נקודות שכבר הזכרנו:

• בדיקת extends בודק עם הצד שמאלי כולו כלול בתוך הסט שהצד הימני מייצג
• פעולת union עם never - כמוהו כמו אי-פעולה. הוספת סט ריק לסט המקורי לא מוסיף שום דבר, לכן בתוצאה של Exclude אפשר להשמיט את ה-never בלי שום השלכה

הערה בענין מילת extends

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

"פוקנציית" Omit

עכשיו נוכל להסביר את הטייפ Omit שבו סיימנו את הפוסט הראשון, וזה אמור להיות מובן בקלות כעת

הפונקציה מקבלת בפרמטר הראשונה אובייקט, ובשנייה, union של מפתחות שאתה רוצה להשמיט ממנו
דוגמה לשימוש (מתוך התיעוד הרשמי):

type Todo = {
  title: string
  description: string
  completed: boolean
  createdAt: number
}
 
type TodoPreview = Omit<Todo, "description">;

שיניתי קצת מהמקור בתיעוד של TS ממילת המפתח interface למילת type רק לשם העקביות כי לא הצגנו interface במאמר זה - יש הבדל קטן בין השניים אבל זה נושא לשיחה אחרת ולא חשוב כעת
פה אני רוצה להתמקד על האינטואיציות המרכזיות ולא על פרטים קטנים

והנה קוד המקור של Omit

type Omit<T, K extends keyof any> = { [P in Exclude<keyof T, K>]: T[P]; }

ננתח את זה לחלקים:

הפרמטרים

Omit<T, K extends keyof any>

הפונקציה מקבלת שני פרמטרים, הראשון ברור. זה יכול להיות כל טייפ שהוא. השני מוגבל לקבל רק טייפ שמקיים בעצמו התנאי extends keyof any
מה זה keyof any? זו דרך קצרה להגיד כל טייפ שחוקי להשתמש בו כמפתח של אובייקט כלשהו, שזה כהיום: string | number | symbol. אז הפרמטר השני הוא טייפ שמורכב רק מדברים שמותרים במפתח אובייקט

ה-body של הפונקציה

{ [P in Exclude<keyof T, K>]: T[P]; }

יש פה שימוש בכמה דברים שהסברנו כבר למעלה, נתחיל מהפנים לחוץ:

• keyof T = מחזיר union של כל המפתחות של שדות בטייפ T
• Exclude<keyof T, K>‎ = מוציא מתוך זה את השמות של השדות שאתה רוצה להשמיט בטייפ הסופי
• מיפוי [P in Exclude<keyof T, K>] מריץ לולאה על כל חבר מבודד מתוך ה-union שהתקבל מהשלב הקודם כאשר הטייפ המבודד מיוצג על ידי המשתנה P
• { [P in Exclude<keyof T, K>]: T[P]; } = מייצג טייפ שבו עבור כל P בלולאה, יש שדה בשם P וערך מהטייפ T[P] = כלומר הטייפ המקורי של שדה זו בטייפ המקורי

פסואודו קוד

והנה פסאודו קוד לקינוח:

function Omit(t: Type, u: UnionOfKeys) {
  const res = {}
  for (key of Omit(Keyof(t), u).split('|')) {
    res[key] = t[key]
  }
  return res
}

פשוט ביותר!

הנושא המקורי (אחרי כל ההקדמות הארוכות)

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

ולשם הקדמה אביא את הטריגר שהביא אותי להבנה זו:
מישהו שאל: איך אפשר ליצור טייפ שבו מותרים רק שדה x ו-y ולא שום שדה נוסף

נציין פה שיש טעות נפוצה אצל מתחילים ב-TS, שאם טייפ לא כולל שדה מסויים, אז ערך שיש בו שדה זו לא יכול להיות חבר בטייפ. זה לא נכון.
ב-TS, העובדה שטייפ לא כולל שדה מסויים, עדיין לא שולל שהשדה יכול להיות קיים.
למשל:

type HasFoo = { foo: string }

גם אובייקט שיש לו שדה bar יכול להיות חבר בקובצת HasFoo

const hasBar = { bar: 1, foo: 'foo' } 
const test:HasFoo = hasBar // no error

Object literal may only specify known properties
אם הייתי כותב בקיצור בקטע הנ"ל:

const test:HasFoo = { bar: 1, foo: 'foo' }

הייתי מקבל שגיאה זו: Object literal may only specify known properties, and 'bar' does not exist in type 'HasFoo'.(2353)
אל תתנו לשגיאה זו להטעות אותך! העובדה ש-HasFoo לא מצהיר על שדה bar לא מונע מחברי הסט לשאת שדות נוספות!
ההתרעה של TS הוא מסיבה אחרת: מכיון שהמשתנה היחיד שקיבל את הערך של { bar: 1, foo: 'foo' } יש לו טייפ שלא כולל את השדה bar, יוצא שבפועל אין דרך להשתמש בשדה bar. כי הגישה דרך משתנה test אסור כי השדה לא כלול בטייפ שלו. רוב הסיכויים הם שקוד כזה הוא שגיאה של המתכנת, לכן TS מתריע.
לעומת זאת, בדוגמה שהבאתי, ששמרתי את הערך בתוך משתנה אחר לפני ההשמה ל-test, אין על מה להתריע מכיון ששדה bar נשאר נגיש דרך משתנה hasBar

נחזור לשאלה: איך אפשר לשלול שדות לא מוצהרות מטייפ

ספוילר: התשובה היא שאי אפשר. וזה מתועד בתשובות ב-stack overflow ו-issues בגיטהאב

אבל אני כעקשן ניסתי בכל זאת לפתור את זה על ידי הטייפ הבא:

type T = {
    x: string
    y: number
}

type Exact<T> = {
    [K in keyof any]?: K extends keyof T ? T[K] : never
}

מקווה שכעת קל לכם להבין את הקוד

בתרגום לאנגלית, זה אומר ככה:
בטייפ Exact<T>‎: קח את הטייפ של כל מפתח חוקי אפשרי (keyof any), עבור כל חבר מתוך מרכיביו בלולאה ותבדוק אם הוא מתוך המפתחות של T, אם כן, הערך של המפתח בתוך התוצאה צריך להיות כמו ב-T (המקור); אחרת הטייפ צריך להיות never - דבר שכמובן לא יכול להיות
לכאורה יצא לנו טייפ שאוסר מפתחות מיותרות

התשובה היא מה שכתבתי בכותרת: "טייפ X לא זהה ל-union של כל הערכים האפשריים שהטייפ כולל"

כלומר, הלולאה של K in keyof any שמפרק את keyof any למרכיביו, ומעביר כל מרכיב בודד בלולאה, לא מפרק את הטייפ string לכל מחרוזת אפשרית. בהקשר זה string הוא אטומי. כמו"כ number.

היה אפשר לחשוב אחרת, כי סה"כ הטייפ string הוא סה"כ סט שמחובר מכל המחרוזות האפשריים ביקום. אבל לצערנו TS לא מסתכל על זה ככה. אלא מתייחסים ל-string כאטום. ולכן בלולאה K in keyof any יש התייחסות רק ל-string ו-number ו-symbol ולא לערכים הפרטיים שמרכיבים אותם. כמובן, אם ככה, ההמצאה שלי לא תעבוד כי התנאי K extends keyof T אף פעם לא יתקיים

השלכה נוספת

עוד דבר שאנשים מבקשים מפעם לפעם (עיין דברי ימי שאלות SO ואישיו-אים של GH) הוא טייפ שמייצג כל מחרוזת אפשרית חוץ ממחרוזות ידועות לשמצה. למשל

type NotWeekday = Exclude<string, Weekday>

אנשים מצפים שדבר כזה יעבוד. אבל זה לא עובד. ולפי הנ"ל זה מובן
נזכיר את קוד המקור של Exclude

type Exclude<T, U> = T extends U ? never : T

הטייפ מתבסס על העובדה שלפני בדיקת התנאי יש פירוק של T למרכיביו ובדיקת התנאי רץ על כל מרכיב בנפרד (Distributive Conditional Types)
אבל לצערנו, הטייפ string הוא אטומי. הוא לא מתפרק לכל המחרוזות שמרכיבים אותו. לכן התנאי T extends U אף פעם לא מתקיים

---

תם ולא נשלם

@pcinfogmach כתב בDebugging על ViewModel ב-WPF:

הבעיות מתחילות כאשר אני משתמש במבנה MVVM ויש בעיה במודל או ב-ViewModel

ניסיתי גם ככה, ולא הצלחתי לשכפל את הבעיה שלך...
הוספתי ל-vscode תוסף template studio ויצרתי פרוייקט עם מבנה MVVM וכל שאר ה-goodies שהם מציעים

הוספתי ל-viewmodel אקראי איזה חריגה בטיפול של אירוע, ו... הכל עובד מצויין, הדיבגר נעצר בדיוק על החריגה

מה שונה אצלך?

יצויין שכל ההגדרות אצלי הם בררות מחדל

@יגעתי-ומצאתי כתב במערכת לניהול תורמים יעבוד גם עם אתר?:

ומה צריך להוסיף \ לשנות בטבלאות

תמחק מכל טבלה את העמודה ID כי העמודה הכי שמאלית עם הכותרת "#" הוא ה-ID

איך מקשרים ביניהם

למשל בטבלה "רשימת מתרימים" תלחץ על החץ למטה בכותרת העמודה "שיעור ID" ושנה את ה-type ל-link, בתיבה שנפתח תבחר Relation Type = One to One ובבחירת טבלאות תבחר "רשימת שיעורים"
כנ"ל לגבי כל עמודה שהוא קישור לטבלה אחרת

מובן?

@יגעתי-ומצאתי כתב במערכת לניהול תורמים יעבוד גם עם אתר?:

יש לזה איזשהו מדריך בעברית אולי?

מן הסתם לא

@יגעתי-ומצאתי כתב במערכת לניהול תורמים יעבוד גם עם אתר?:

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

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

אגב, אני לא מפתח WPF אבל יצרתי פרוייקט דמו כדי לבדוק את הנושא
הוספתי לפרוייקט שלי UserControl ובתוך הconstructor זרקתי שגיאה
אצלי הדיבאגר עוצר בתוך הקוד שלי בשורה שאני זורק את השגיאה (ב-catch ולא בזריקה הראשונה בתוך ה-try)
אני לא יודע מה שונה אצלך, אם זה שינוי של הגדרות, או קלאס שונה של exception

שים לב בתמונה גם לכותרת הודעת השגיאה (User-Unhandled) וגם להגדרות וקישור להגדרות נוספות

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

@pcinfogmach יש כמה מצבי exception שיכולים לקרות תוך כדי דיבוג

א) חריגה שנזרקה מתוך קוד שלך והולכת להיות מטופל בתוך קוד שאתה כתבת, כלומר, זה בתוך בלוק של try/catch שאתה כתבת
ב) חריכה שנזרקה מתוך קוד שלך והולכת להיות מטופל, אבל לא על ידי קוד שלך (מי שקרא לפונקציה של הוסיף מסביב לקריאה try/catch)
ג) חריגה שנזרקה מתוך קוד ספרייה - לא קוד שלך, והולכת להיות מטופלת על ידי קוד הספרייה
ד) חריגה שנזרקה מתוך קוד ספרייה - לא קוד שלך, והולכת להיות מטופלת על ידי קוד שלך - אין בלוק try/catch של הספרייה אבל אתה עטפת את הקריאה עם try/catch
ה) חריגה שלא מטופלת כלל

הכללים מתי VS עוצר את הדיבאגר בעת זריקת חריגה תלויה בכמה הגדרות
רמה ה) תמיד גורם לדביאגר לעצור
השאר תלויים בהגדרות

במקרה שלך מדובר החריגה שנזקרה מתוך הקוד שלך וטופלה על ידי ספריית XamlLoader של הפריימוורק (כמו שאתה רואה בתמונה, כאשר נטענת קובץ xaml זה קורה בתוך בלוק של try/catch)

כנראה שההרכב של ההגדרות שלך גורמות שחריגה זו לא תעצור את הדיבאגר עד שהיא לא תגיע למצב ה) - חריגה לא מטופלת - ולכן העצירה קרתה רק בתוך קוד של הפריימוורק

אחרי הקדמה זו תקרא את תיעוד ההגדרות
https://learn.microsoft.com/en-us/visualstudio/debugger/managing-exceptions-with-the-debugger?view=vs-2022
ותבדוק אם אתה מצליח להבין למה זה קרה
שים לב שאפשר להגדיר כל תת-טייפ של exception עם הגדרה שונה, ויש גם הגדרות כלליות כמו מה ש @Mordechai-0 הביא - Just My Code

בינתיים לא התעמקתי בתיעוד בצורה מספקת להבין בדיוק הכללים

@yossiz כתב בלהורדה | תוכנה לשינוי סיומות קבצים ללא הדיאלוג:

איכשהו הוא הצליח לממש את זה בפי עשר שורות...

לכאורה השיטה שלו יותר חסכונית

רק שים לב שזה יעבוד רק אם שפת המערכת מוגדר כעברית

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

אגב, האם בדקת מה המחיר שגובה קריאת ה-API של FindWindowExW עשר פעמים בשנייה? האם זה שולי לגמרי?

@רמי-פרי
(קודם כל, תכתוב את השאלה בגוף הפוסט ולא בכותרת, הכותרת מיועד לתמצת את התוכן של גוף הפוסט. עיין חוקי הפורום)

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

אנא האיר עינינו

אבל אם ארצה לענות ברוח השאלה בגדר "עם חסיד תתחסד"
אז התשובה היא:

C:\Users\User\AppData\Local\Google\Chrome\User Data\Default\IndexedDB\https_mail.google.com_0.indexeddb.leveldb

כמובן תשובה זו מבוססת על הרבה הנחות סמויות ולא מתחיל להיות שימושי

@צבי-ש כתב בבעיה בגישה לדומיין מקומי במכונה וירטואלית על MacBook M2:

אולי כי זה רץ איטי במחשב שלי ונתקע כל הזמן העדפתי לוותר

לך יש M2 ולי יש רק M1... כנראה יש לך ציפיות יותר גבוהות ממני...
הופתעתי באמת איך שזה רץ בסדר למרות שזה קוד מכונה של אינטל על מעבד ARM

עוד לא מצאתי איך הדפדפן אמור להצליח לגשת לאתר עם הכתובת http://pizzaluigi
אני חושש שאולי זה יעבוד רק עם תתקין את המכונה עם ה-exe שלהם

@יגעתי-ומצאתי יש תחליף חינמי ל-airtable בשם nocodb

אגב, בסוף הדרך הכי טובה שמצאתי להריץ את המכונה על מק הוא ככה:

sudo qemu-system-x86_64 \
  -hda "ubuntuvm-disk001.qcow2" \
  -m 2048 \
  -smp 4 \
  -netdev vmnet-bridged,id=net0,ifname=en0 \
  -device virtio-net,netdev=net0 \
  -usb -device usb-tablet \
  -cpu max \
  -rtc base=utc

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

@צבי-ש יש לי חדשות טובות בשבילך

אתה יכול להיפטר מהמכונה השמנה
באמת לא מובן מה חשבו. למה צריך פיירפוקס, ליברהאופיס, וכו' כדי להריץ אתר

היה קל מאוד להגיע לדסקטופ
צריך פשוט לתפוס אותו לפני שהוא ננעל
זה מוגדר לנעול אחרי שניה אחת של חוסר פעילות
אבל אפשר לפתוח טרמינל
אחרי שהיה לי טרמינל דיפדפתי בהיסטוריה (כן, יש שם הרבה דברים משעשעים ) וראיתי את הפקודה של gsettings שמגדיר את ה-idle timeout לנעילה, ופשוט הרצתי במקום זה gsettings reset ... כדי לחזור לברירת המחדל

gettings reset org.gnome.desktop.session idle-delay
gettings reset org.gnome.desktop.screensaver lock-delay

משם היה קל מאוד להגיע לסיסמת המשתמש (cecadmin2020) - זה היה גלוי בהיסטוריה של שורת הפקודה - אפשר ככה לקבל sudo (אבל אין שום צורך...)
בדקתי את היסטורית הדפדפן והגעתי לריפו זה
https://github.com/DaniRubin/pizzaCyber
שם יש כל מה שצריך להריץ את האתר...

אאל"ט תוכל להריץ לוקלית על מק בלי להסתבך עם מכונה וירטואלית ענקית

אולי כדאי לא לקרוא את קוד המקור של האתר כדי שזה לא יהרוס לך את הכיף של מציאת החולשות

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

אולי תוכל לעשות חסד לקהילה ולהמיר את זה לתמונת דוקר ששוקל 5% מתמונת ה-vbox

@צבי-ש כתב בבעיה בגישה לדומיין מקומי במכונה וירטואלית על MacBook M2:

תוכל להרחיב קצת בהסבר מה בעצם שינת?

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

@צבי-ש כתב בבעיה בגישה לדומיין מקומי במכונה וירטואלית על MacBook M2:

וכן אם אני רוצה בכל זאת להשתמש בדומיין http://pizzaluigi/ , אני אצטרך לעשות את זה ברמת הdns אצלי במחשב

אפשר להוסיף לקובץ ההוסטס שpizzaluigi נמצא ב-127.0.0.1

אני לא יודע באיזה מנגנון השתמשו במכונה המקורית כדי לפרסם את שם המכונה שלהם (אולי משהו כמו WINS, אני לא לגמרי מבין בזה)

הבנתי מהתיעוד שאם תרצה גישה מלאה לכל הפורטים, תצטרך תצורת TUN אבל נראה שזה מצריך קצת עבודה להקים

@צבי-ש
זה עבד לי:

qemu-system-x86_64 \
  -hda "ubuntuvm-disk001.qcow2" \
  -m 2048 \
  -smp 4 \
  -device e1000,netdev=net0 \
  -netdev user,id=net0,hostfwd=tcp::8080-:80 \
  -vga std \
  -usb -device usb-tablet \
  -cpu max \
  -rtc base=utc

ואז אפשר להיכנס ב-localhost:8080

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

@יגעתי-ומצאתי חפש בפורום, יש כמה נושאים פה על הנושא
אבל זה רלוונטי אחרי שכבר השקעת במסד של אקסס
אם עוד לא השקעת באקסס, לענ"ד אל תבנה מראש עם אקסס אם אתה רוצה לחבר אליו אתר. אקסס לא מיועד לזה.

הDB שלי הוא גוגל שיטס

המילים צורמים קצת... שיטס לא מיועד לזה. יש מוצרים אחרים יותר מתאימים

מה שלא כ"כ מאפשר לי להתנהל עם תורמים ומתרימים ועוד ועוד כל מיני

לא הבנתי בדיוק הכוונה, אבל בכל מקרה אני לא חושב שאקסס יהיה הכיוון הנכון לפתור את זה במקרה שלך

תלך יותר לכיוון של DB קלאסי, או כלים כמו airtable