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

נתחיל...

שלב א:

ראשית בקובץ ה- Excel של רשימת הנמענים, הוסיפו לטבלת הנתונים ארבעה עמודות בשמות כדלהלן (חשוב שהשמות יהיו מדויקים ללא רווחים מיותרים - לתשומת ליבכם):

• DocFolderPath

• DocFileName

• PdfFolderPath

• PdfFileName

שלב ב:
צרו שתי תיקיות נפרדות, אחד לקבצי הפלט בפורמט docx, ואחד לקבצי הקלט בפורמט pdf, העתיקו את נתיב התיקייה של קבצי ה- docx והדביקו אותם עבור כל רשומה בשדה שיצרתם בשם DocFolderPath, לאחמ"כ חזרו על הפעולה והפעם העתיקו את נתיב התיקייה של קובצי ה- PDF והדביקו בשדה PdfFolderPath.
בשדה DocFileName כתבו את השם של הקובץ עבור הרשומה - ניתן להשתמש בנוסחאות, כמו"כ בשדה PdfFileName כתבו את שם הקובץ כנ"ל.

שלב ג:
פתחו את קובץ ה- word והשלימו את פעולת המיזוג כרגיל, עצבו את המסמך כרצונכם.

שלב ד:
פתחו את לשונית מפתחים בקובץ ה- word פתחו את עורך הקוד הוסיפו מודל חדש מצו"ב צילום מסך:

הדביקו את הקוד הבא:

Sub MailMergeToPdfBasic()                                                        ' Mark the start of the Subroutine (i.e. Macro) and name it "MailMergeToPdf"
' Macro created by Imnoss Ltd
' Please share freely while retaining attribution
' Last Updated 2021-05-03
    Dim masterDoc As Document, singleDoc As Document, lastRecordNum As Long   ' Create variables ("Post-it Notes") for later use
    Set masterDoc = ActiveDocument                                               ' Identify the ActiveDocument (foremost doc when Macro run) as "masterDoc"

    masterDoc.MailMerge.DataSource.ActiveRecord = wdLastRecord                   ' jump to the last active record (active = ticked in edit recipients)
    lastRecordNum = masterDoc.MailMerge.DataSource.ActiveRecord                  ' retrieve the record number of the last active record so we know when to stop

    masterDoc.MailMerge.DataSource.ActiveRecord = wdFirstRecord                  ' jump to the first active record (active = ticked in edit recipients)
    Do While lastRecordNum > 0                                                   ' create a loop, lastRecordNum is used to end the loop by setting to zero (see below)
        masterDoc.MailMerge.Destination = wdSendToNewDocument                    ' Identify that we are creating a word docx (and no e.g. an email)
        masterDoc.MailMerge.DataSource.FirstRecord = masterDoc.MailMerge.DataSource.ActiveRecord              ' Limit the selection to just one document by setting the start ...
        masterDoc.MailMerge.DataSource.LastRecord = masterDoc.MailMerge.DataSource.ActiveRecord               ' ... and end points to the active record
        masterDoc.MailMerge.Execute False                                        ' run the MailMerge based on the above settings (i.e. for one record)
        Set singleDoc = ActiveDocument                                           ' Identify the ActiveDocument (foremost doc after running the MailMerge) as "singleDoc"
        singleDoc.SaveAs2 _
            FileName:=masterDoc.MailMerge.DataSource.DataFields("DocFolderPath").Value & Application.PathSeparator & _
                masterDoc.MailMerge.DataSource.DataFields("DocFileName").Value & ".docx", _
            FileFormat:=wdFormatXMLDocument                                      ' Save "singleDoc" as a word docx with the details provided in the DocFolderPath and DocFileName fields in the MailMerge data
        singleDoc.ExportAsFixedFormat _
            OutputFileName:=masterDoc.MailMerge.DataSource.DataFields("PdfFolderPath").Value & Application.PathSeparator & _
                masterDoc.MailMerge.DataSource.DataFields("PdfFileName").Value & ".pdf", _
            ExportFormat:=wdExportFormatPDF                                      ' Export "singleDoc" as a PDF with the details provided in the PdfFolderPath and PdfFileName fields in the MailMerge data
        singleDoc.Close False                                                    ' Close "singleDoc", the variable "singleDoc" can now be used for the next record when created
        If masterDoc.MailMerge.DataSource.ActiveRecord >= lastRecordNum Then     ' test if we have just created a document for the last record
            lastRecordNum = 0                                                    ' if so we set lastRecordNum to zero to indicate that the loop should end
        Else
            masterDoc.MailMerge.DataSource.ActiveRecord = wdNextRecord           ' otherwise go to the next active record
        End If

    Loop                                                                         ' loop back to the Do start
End Sub                                                                          ' Mark the end of the Subroutine

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

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

מקור

הקדמה ל-SQL ולמדריך

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

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

טיפת תחביר

התחביר של שאילתת SQL נראה כך:
SELECT <עמודות...>
FROM <טבלאות...>
WHERE <תנאים>
GROUP BY <ביטוי>
HAVING <תנאים>
ORDER BY <ביטוי>
OFFSET <מספר>
LIMIT <מספר>
(נראה לי שבשני החלקים הנ"ל יש שינויים בין המנועים)
; (לסיום המשפט)

כמה נקודות (בלתי אפשרי להקיף פה את הכל, אני רק כותב כמה נקודות):

• השפה הינה case insensitive, (לא מבדילה בין אותיות גדולות לקטנות). אפשר לכתוב SeLecT גם כן.
• שמות הטבלאות והעמודות הם בברירת מחדל case insensitive. תבדקו את התיעוד של המנוע שלכם לגבי יצירת עמודות שהם case sensitive ואיזכורם. ב-postgres אם שם העמודה הינה case sensitive צריך להזכיר את שם העמודה והטבלה בתוך גרשיים (לא ככה: "Table.Column" וגם לא ככה: 'Table.Column' או ככה: 'Table'.'Column' אלא ככה: ‎"Table"."Column"‎ - כן כן, מגעיל... בשנות השמונים או השבעים לא ידעו לעשות תחבירים אלגנטיים כנראה...).
• לא כל החלקים חיוביים. בעיקרון אפשר להשמיט את הכל חוץ מה-SELECT. כל השאר הם אופצינאליים לפחות בחלק מהמקרים. חלק מהם הם חיוביים במקרים מסויימים. (עזרתי מאוד, לא? הכללים הם הגיוניים ולא קשים לניחוש אחרי שאתה מכיר את המבנה של השאילתה שנרחיב עליו בקטע הבא).

השאילתה הלוגית

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

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

סדר הפעולות היא כזאת:

• FROM - בחירת טבלה גולמית (כולל חיבורים עם טבלאות אחרות).
• WHERE - סינון השורות
• GROUP BY - קיפול של כמה שורות לתוך שורה אחת
• HAVING - שוב סינון על השורות המקופלות
• SELECT - בחירת עמודות מתוך התוצאה של השלבים הקודמים (כולל יצירת עמודות חדשות שמחושבות מהתוצאה של השלבים הקודמים)
• DISTINCT - מחיקת כפלויות
• UNION - חיבור תשובות משאילתה אחרת
• ORDER BY - מיון השורות
• OFFSET דילוג לשורה מסויימת
• LIMIT - מחיקת השורות מה-limit והלאה.

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

עכשיו נפרט קצת על כל שלב.

FROM - בחירת טבלה גולמית

כמה נקודות:

• שלב זה אופציונאלית. אם משמיטים את השלב הכוונה היא שאנחנו רוצים שהמנוע יחזיר טבלה חדשה יש מאין. צריך להשמיט גם את כל השלבים עד שלב ה-SELECT כי כולם הם פעולות על הטבלה הגולמית - שלא קיימת במקרה זו.
  אפשר להשתמש ב-SELECT ערטילאית כמו סוג של echo או console.log כדי לקבל את הערך של ביטוי. לדוגמה SELECT 20+4;‎ מחזיר טבלה של 1×1 עם הערך 24. או SELECT sqlite_version();‎ ב-sqlite מחזיר טבלה של 1×1 עם הערך של הגירסה של המנוע.
• ה-FROM מקבלת כל ביטוי שמחזיר טבלה.
  ביטויים שמחזירים טבלאות:
  • שם של טבלה, לדוגמה FROM "SomeTable"‎
  • פונקציה שמחזירה טבלה, לדוגמה FROM generate_series(1,100)‎ (הפונקציה generate_series ב-postgres מחזירה טבלה - [תיעוד])
  • שאילתה שמחזירה טבלה, דוגמה: FROM (SELECT * FROM "SomeTable")
  • ביטוי שמחזירה טבלה משולב עם עוד ביטוי שמחזירה טבלה באמצעות JOIN

JOIN - חיבור כמה טבלאות ביחד

אפשר לחבר כמה טבלאות ביחד על ידי פעולת JOIN.
התחביר של JOIN:

• <טבלה> (ביטוי שמחזיר טבלה, כנ"ל)
• JOIN (עם פירוט של סוג ה-JOIN)
• <טבלה> (ביטוי שמחזיר טבלה, כנ"ל)
• ON <תנאי> (או USING <עמודה>)

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

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

WHERE - סינון שורות

התחביר של WHERE:

• WHERE <תנאי>

זהו!
מהו התנאי? זה ביטוי שמחזיר ערך בוליאני (TRUE או FALSE).
המנוע מעביר את כל השורות דרך התנאי ומוחקת את השורות שלהם הביטוי מחזירה FALSE. כאשר בתוך הביטוי אפשר להזכיר את הערכים של השורה שמועברת דרכה.
דוגמאות:

• WHERE 1 - תמיד מחזיר TRUE
• WHERE "SomeColumn" = 25‎‎
• WHERE some_condition() AND another_condition OR something_else()‎

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

אפשר להשמיט לגמרי את ה-WHERE ואז לא מתבצעת סינון

GROUP BY - קיפול כמה שורות לתוך שורה אחת

התחביר:
GROUP BY <ביטוי שמחזיר עמודה>
הפעולה: פעולה זו מקפלת כמה שורות לתוך שורה אחת, מעתה ולהלן לא תוכל לקבל את הערך של שורה ספציפית מתוך השורות המקופלות אלא ערך של פונקציה שמסכמת את כל הפריטים ביחד. לדוגמה סך כולל על ידי פונקציית SUM או ממוצע על ידי פונקציית AVG. או הכי גדול או הכי קטן על ידי פונקציות MIN ו-MAX.

HAVING - שוב סינון

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

SELECT - בחירת או יצירת עמודות לטבלה הסופית

סוף סוף קיבלנו את הדאטה הגולמית שאותה אנחנו רוצים להציג, אחרי כל המניפלציות. בשלב זה אתה מגדירים את העמודות שאנחנו רוצים להציג מתוך הדאטה.
אפשר לבחור עמודות קיימות, או אפשר לייצר עמודות חדשות.
לדוגמה: SELECT "SomeColumn", "AnotherColumn", "SomeColumn" * 50 / 2 - בחרנו שתי עמודות קיימות, ויצרנו עמודה שלישית שמחושבת מתוך העמודה הראשונה.

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

DISTINCT - מחיקת כפילויות

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

UNION - חיבור לתשובות של שאילתה אחרת

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

ORDER BY - מיון

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

LIMIT ו-OFFSET

אחרי שיש לנו את כל הדאטה ממויין אפשר להגביל את התשובה לחלק קטן מכלל השורות על ידי LIMIT ו-OFFSET.

קרדיטים:

• https://jvns.ca/blog/2019/10/03/sql-queries-don-t-start-with-select/
• https://blog.jooq.org/2016/12/09/a-beginners-guide-to-the-true-order-of-sql-operations/

מקוה שלמדתם משהו.

הדרך הטובה ביותר להבין איך מתרחשים אירועים - היא ליצור אותם בעצמך

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

{
    "click": [
        function name (params) {
            ...params
        }
    ],
    "myEvent": [
        function name (params) {
                ...params
            },
        function name (params) {
                ...params
            }
    ]
}

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

class EventEmitter {
    _events = {};

    on (eventId, callback) {
        this._events[eventId] = this._events[eventId] || [];
        this._events[eventId].push(callback);
    }
}

נבדוק שזה עובד, ניצור מופע של המחלקה, ונרשם להאזנה לאירוע:

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

עכשיו נוסיף למחלקה מתודה בשם emit שדרכה יתאפשר להכריז על התרחשות האירוע, היא תקבל גם 2 פרמטרים, שם האירוע והמידע שישלח יחד עם האירוע.

emit (eventId, args) {
       if (!this._events[eventId]) return;
       for (let callback of this._events[eventId]) {
           callback(args)
       }
   }

ובכן, זה עובד. כל מי שיש לו גישה ל events יוכל להרשם ולפלוט אירועים.

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

class Car extends EventEmitter {}

כעת ניצור שני סוגי רכבים, ונראה שאפשר ליצור מטפל לכל אירוע מכל רכב בנפרד:

אם מופיע השגיאה הבאה Starting inspector on 127.0.0.1:9229 failed: address already in use,
צריך לקבוע פורט, כך: node --inspect-brk=1234 app.js.

לפתוח בכרום את הכתובת: about:inspect.
אם קבעתם פורט, צריך להכניס אותו לרשימה, כך:
ללחוץ על Open dedicated DevTools for Node, ואח"כ להכניס את הכתובת כך:

ללחוץ על הסמל של המופע:

זהו.